diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000000..3e9dc9f270
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,13 @@
+---
+BasedOnStyle: Google
+IndentWidth: 4
+Language: Cpp
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+PointerAlignment: Left
+ColumnLimit: 80
+AccessModifierOffset: 0
+KeepEmptyLinesAtTheStartOfBlocks: true
\ No newline at end of file
diff --git a/.github/check_format.sh b/.github/check_format.sh
new file mode 100755
index 0000000000..b5c5e20e6f
--- /dev/null
+++ b/.github/check_format.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+#
+# check that all code complies w/ the clang-format specification
+#
+# if all is well, returns w/o errors and does not print anything.
+# otherwise, return an error and print offending changes
+
+set -e # abort on error
+
+INCLUDE_DIRS=("apps core display plugins tests")
+
+if [ $# -ne 1 ]; then
+    echo "wrong number of arguments"
+    echo ""
+    echo "usage: check_format <DIR>"
+    exit 1
+fi
+
+_binary=${CLANG_FORMAT_BINARY:-clang-format}
+
+$_binary --version
+
+cd $1
+$_binary -i -style=file $(find ${INCLUDE_DIRS} \( -iname '*.cpp' -or -iname '*.hpp' -or -iname '*.ipp' -or -iname '*.inl' -or -iname '*.cu' -or -iname '*.cuh' -or -iname '*.hip' -or -iname '*.sycl' \))
+
+if ! [ -z $CI ] || ! [ -z $GITHUB_ACTIONS ]; then
+  mkdir changed
+  for f in $(git diff --name-only -- ${INCLUDE_DIRS[@]/#/:/}); do
+    cp --parents $f changed
+  done
+fi
+    
+echo "clang-format done"
+    
+set +e
+git diff --exit-code --stat -- ${INCLUDE_DIRS[@]/#/:/}
+result=$?
+
+if [ "$result" -eq "128" ]; then
+    echo "Format was successfully applied"
+    echo "Could not create summary of affected files"
+    echo "Are you in a submodule?"
+
+fi
+
+exit $result
diff --git a/.github/workflows/builds.yml b/.github/workflows/builds.yml
index 054eedde84..c9941a0890 100644
--- a/.github/workflows/builds.yml
+++ b/.github/workflows/builds.yml
@@ -6,7 +6,7 @@ on:
     branches:
       - main
       - 'release/**'
-
+      
 jobs:
   ubuntu:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
new file mode 100644
index 0000000000..6dc7de92ca
--- /dev/null
+++ b/.github/workflows/checks.yml
@@ -0,0 +1,21 @@
+name: Checks
+
+on:
+  push:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  format:
+    runs-on: ubuntu-latest
+    container: ghcr.io/acts-project/format10:v11
+    steps:
+      - uses: actions/checkout@v2
+      - name: Check
+        run: .github/check_format.sh .
+      - uses: actions/upload-artifact@v1
+        if: failure()
+        with:
+          name: changed
+          path: changed
diff --git a/apps/common/include/apps/common/display_bin_association.inl b/apps/common/include/apps/common/display_bin_association.inl
index dd97ffc78d..60824862e1 100644
--- a/apps/common/include/apps/common/display_bin_association.inl
+++ b/apps/common/include/apps/common/display_bin_association.inl
@@ -1,42 +1,41 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
+#include <matplot/matplot.h>
+
+#include <climits>
+#include <fstream>
+#include <iostream>
+
 #include "core/detector.hpp"
 #include "core/transform_store.hpp"
-#include "io/csv_io.hpp"
 #include "grids/associator.hpp"
+#include "io/csv_io.hpp"
+#include "style/styles.hpp"
 #include "utils/enumerate.hpp"
 #include "utils/generators.hpp"
 #include "view/draw.hpp"
 #include "view/views.hpp"
-#include "style/styles.hpp"
-
-#include <fstream>
-#include <iostream>
-#include <climits>
-#include <matplot/matplot.h>
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     using point2 = __plugin::point2;
     using namespace detray;
     using namespace matplot;
 
-    if (argc > 1)
-    {
+    if (argc > 1) {
         std::string first_arg = argv[1];
-        if (first_arg == "-h" or first_arg == "--help")
-        {
-            std::cout << "[detray] Usage: 'display_bin_association detector_name <surface_file> <grid_file> <volume_file>'" << std::endl;
+        if (first_arg == "-h" or first_arg == "--help") {
+            std::cout
+                << "[detray] Usage: 'display_bin_association detector_name "
+                   "<surface_file> <grid_file> <volume_file>'"
+                << std::endl;
             return 1;
-        }
-        else if (argc > 7)
-        {
+        } else if (argc > 7) {
 
             // Create a sub plot
             auto ax = matplot::subplot({0.1, 0.1, 0.65, 0.8});
@@ -47,8 +46,9 @@ int main(int argc, char **argv)
             std::string volumes_file = argv[3];
             std::string grids_file = argv[4];
             std::string grid_entries_file = argv[5];
-            
-            auto d = detector_from_csv<>(name, surfaces_file, volumes_file, grids_file, grid_entries_file);
+
+            auto d = detector_from_csv<>(name, surfaces_file, volumes_file,
+                                         grids_file, grid_entries_file);
             std::cout << "[detray] Detector read successfully." << std::endl;
 
             global_xy_view xy_view;
@@ -89,7 +89,8 @@ int main(int argc, char **argv)
             // Grid drawing sections styles and addons
             // - styles and addons are on faint grid, cell, assoc
             std::vector<style> gstyles = {grid_style, cell_style, assoc_style};
-            std::vector<std::array<scalar, 4>> gadds = {grid_adds, cell_adds, assoc_adds};
+            std::vector<std::array<scalar, 4>> gadds = {grid_adds, cell_adds,
+                                                        assoc_adds};
 
             decltype(d)::transform_store::context s_context;
 
@@ -97,16 +98,16 @@ int main(int argc, char **argv)
             auto surfaces_finders = d.surfaces_finders();
             const auto &lvolume = d.indexed_volume(lvol);
             const auto &bounds = lvolume.bounds();
-            bool is_cylinder = std::abs(bounds[1] - bounds[0]) < std::abs(bounds[3] - bounds[2]);
-            const auto &sf_range = lvolume. template range<>();
+            bool is_cylinder = std::abs(bounds[1] - bounds[0]) <
+                               std::abs(bounds[3] - bounds[2]);
+            const auto &sf_range = lvolume.template range<>();
 
             dindex finder_entry = lvolume.surfaces_finder_entry();
             const auto &surfaces = d.surfaces();
             const auto &surface_transforms = d.transforms(sf_range, s_context);
             const auto &surface_masks = d.masks();
 
-            if (not is_cylinder)
-            {
+            if (not is_cylinder) {
 
                 const auto &disk_grid = surfaces_finders[finder_entry];
                 auto r_borders = disk_grid.axis_p0().borders(bin_0);
@@ -118,16 +119,15 @@ int main(int argc, char **argv)
                 scalar phi_max = phi_borders[1];
 
                 const auto &bin_entry = disk_grid.bin(bin_0, bin_1);
-                std::cout << "Disk grid - bin (" << bin_0 << ", " << bin_1 << ") = ";
-                for (auto b_e : bin_entry)
-                {
+                std::cout << "Disk grid - bin (" << bin_0 << ", " << bin_1
+                          << ") = ";
+                for (auto b_e : bin_entry) {
                     std::cout << b_e << ", ";
                 }
                 std::cout << std::endl;
 
                 // Loop over the surfaces within a volume
-                for (dindex sfi = sf_range[0]; sfi < sf_range[1]; sfi++)
-                {
+                for (dindex sfi = sf_range[0]; sfi < sf_range[1]; sfi++) {
                     const auto &s = surfaces[sfi];
                     dvector<point3> vertices = {};
                     const auto &mask_link = s.mask();
@@ -139,25 +139,30 @@ int main(int argc, char **argv)
                     const auto &mask_context = std::get<0>(mask_link);
                     const auto &mask_range = std::get<1>(mask_link);
 
-                    auto vertices_per_masks = unroll_masks_for_vertices(surface_masks, mask_range, mask_context,
-                                                                        std::make_integer_sequence<dindex, std::tuple_size_v<decltype(d)::surface_mask_container>>{});
-
-                    for (auto &vertices : vertices_per_masks)
-                    {
-                        if (not vertices.empty())
-                        {
-                            style draw_style = (std::find(bin_entry.begin(), bin_entry.end(), static_cast<dindex>(sfi - sf_range[0])) != bin_entry.end())
-                                                   ? selected_surface_style
-                                                   : surface_style;
-
-                            draw_vertices(vertices, transform, draw_style, xy_view);
+                    auto vertices_per_masks = unroll_masks_for_vertices(
+                        surface_masks, mask_range, mask_context,
+                        std::make_integer_sequence<
+                            dindex, std::tuple_size_v<decltype(
+                                        d)::surface_mask_container>>{});
+
+                    for (auto &vertices : vertices_per_masks) {
+                        if (not vertices.empty()) {
+                            style draw_style =
+                                (std::find(
+                                     bin_entry.begin(), bin_entry.end(),
+                                     static_cast<dindex>(sfi - sf_range[0])) !=
+                                 bin_entry.end())
+                                    ? selected_surface_style
+                                    : surface_style;
+
+                            draw_vertices(vertices, transform, draw_style,
+                                          xy_view);
                         }
                     }
                 }
 
                 // Grid drawing section
-                for (auto [i, st] : enumerate(gstyles))
-                {
+                for (auto [i, st] : enumerate(gstyles)) {
 
                     // Arc parameters
                     scalar arc_r_min = r_min - gadds[i][0];
@@ -177,20 +182,14 @@ int main(int argc, char **argv)
                     scalar cos_phi_max = std::cos(rad_phi_max);
                     scalar sin_phi_max = std::sin(rad_phi_max);
 
-                    draw_line(rad_r_min * cos_phi_max,
-                              rad_r_min * sin_phi_max,
-                              rad_r_max * cos_phi_max,
-                              rad_r_max * sin_phi_max,
+                    draw_line(rad_r_min * cos_phi_max, rad_r_min * sin_phi_max,
+                              rad_r_max * cos_phi_max, rad_r_max * sin_phi_max,
                               st);
-                    draw_line(rad_r_min * cos_phi_min,
-                              rad_r_min * sin_phi_min,
-                              rad_r_max * cos_phi_min,
-                              rad_r_max * sin_phi_min,
+                    draw_line(rad_r_min * cos_phi_min, rad_r_min * sin_phi_min,
+                              rad_r_max * cos_phi_min, rad_r_max * sin_phi_min,
                               st);
                 }
-            }
-            else
-            {
+            } else {
                 const auto &cylinder_grid = surfaces_finders[finder_entry + 2];
                 auto z_borders = cylinder_grid.axis_p0().borders(bin_0);
                 auto phi_borders = cylinder_grid.axis_p1().borders(bin_1);
@@ -201,16 +200,15 @@ int main(int argc, char **argv)
                 scalar phi_max = phi_borders[1];
 
                 const auto &bin_entry = cylinder_grid.bin(bin_0, bin_1);
-                std::cout << "Cylinder grid - bin (" << bin_0 << ", " << bin_1 << ") = ";
-                for (auto b_e : bin_entry)
-                {
+                std::cout << "Cylinder grid - bin (" << bin_0 << ", " << bin_1
+                          << ") = ";
+                for (auto b_e : bin_entry) {
                     std::cout << b_e << ", ";
                 }
                 std::cout << std::endl;
 
                 // Loop over the surfaces within a volume
-                for (dindex sfi = sf_range[0]; sfi < sf_range[1]; sfi++)
-                {
+                for (dindex sfi = sf_range[0]; sfi < sf_range[1]; sfi++) {
                     const auto &s = surfaces[sfi];
                     dvector<point3> vertices = {};
                     const auto &mask_link = s.mask();
@@ -222,34 +220,42 @@ int main(int argc, char **argv)
                     const auto &mask_context = std::get<0>(mask_link);
                     const auto &mask_range = std::get<1>(mask_link);
 
-                    auto vertices_per_masks = unroll_masks_for_vertices(surface_masks, mask_range, mask_context,
-                                                                        std::make_integer_sequence<dindex, std::tuple_size_v<decltype(d)::surface_mask_container>>{});
+                    auto vertices_per_masks = unroll_masks_for_vertices(
+                        surface_masks, mask_range, mask_context,
+                        std::make_integer_sequence<
+                            dindex, std::tuple_size_v<decltype(
+                                        d)::surface_mask_container>>{});
 
-                    for (auto &vertices : vertices_per_masks)
-                    {
+                    for (auto &vertices : vertices_per_masks) {
 
-                        if (not vertices.empty())
-                        {
+                        if (not vertices.empty()) {
 
                             // Check the association (with potential splits)
-                            style draw_style = (std::find(bin_entry.begin(), bin_entry.end(), static_cast<dindex>(sfi - sf_range[0])) != bin_entry.end())
-                                                   ? selected_surface_style
-                                                   : surface_style;
-
-                            draw_vertices(vertices, transform, draw_style, zphi_view, true);
+                            style draw_style =
+                                (std::find(
+                                     bin_entry.begin(), bin_entry.end(),
+                                     static_cast<dindex>(sfi - sf_range[0])) !=
+                                 bin_entry.end())
+                                    ? selected_surface_style
+                                    : surface_style;
+
+                            draw_vertices(vertices, transform, draw_style,
+                                          zphi_view, true);
                         }
                     }
                 }
 
                 // Grid drawing section
-                for (auto [i, st] : enumerate(gstyles))
-                {
-                    if (i > 0)
-                    {
-                        point2 p0 = {z_min - gadds[i][0], phi_min - gadds[i][1]};
-                        point2 p1 = {z_min - gadds[i][0], phi_max + gadds[i][1]};
-                        point2 p2 = {z_max + gadds[i][0], phi_max + gadds[i][1]};
-                        point2 p3 = {z_max + gadds[i][0], phi_min - gadds[i][1]};
+                for (auto [i, st] : enumerate(gstyles)) {
+                    if (i > 0) {
+                        point2 p0 = {z_min - gadds[i][0],
+                                     phi_min - gadds[i][1]};
+                        point2 p1 = {z_min - gadds[i][0],
+                                     phi_max + gadds[i][1]};
+                        point2 p2 = {z_max + gadds[i][0],
+                                     phi_max + gadds[i][1]};
+                        point2 p3 = {z_max + gadds[i][0],
+                                     phi_min - gadds[i][1]};
 
                         draw_polygon({p0, p1, p2, p3}, st);
                     }
@@ -263,13 +269,10 @@ int main(int argc, char **argv)
             vol_lay_name += "_";
             vol_lay_name += std::to_string(bin_1);
             vol_lay_name += ".png";
-            if (is_cylinder)
-            {
+            if (is_cylinder) {
                 ax->xlabel("z [mm]");
                 ax->ylabel("phi [rad]");
-            }
-            else
-            {
+            } else {
                 ax->xlabel("x [mm]");
                 ax->ylabel("y [mm]");
                 matplot::axis(equal);
@@ -284,6 +287,7 @@ int main(int argc, char **argv)
         }
     }
 
-    std::cout << "[detray] Not enough arguments given, run with -h for help. " << std::endl;
+    std::cout << "[detray] Not enough arguments given, run with -h for help. "
+              << std::endl;
     return 0;
 }
\ No newline at end of file
diff --git a/apps/common/include/apps/common/display_layers.inl b/apps/common/include/apps/common/display_layers.inl
index e5f1329b3d..e1d0c3050e 100644
--- a/apps/common/include/apps/common/display_layers.inl
+++ b/apps/common/include/apps/common/display_layers.inl
@@ -1,40 +1,38 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
+#include <matplot/matplot.h>
+
+#include <climits>
+#include <fstream>
+#include <iostream>
+
 #include "core/detector.hpp"
 #include "core/transform_store.hpp"
 #include "io/csv_io.hpp"
+#include "style/styles.hpp"
 #include "utils/enumerate.hpp"
 #include "utils/generators.hpp"
 #include "view/draw.hpp"
 #include "view/views.hpp"
-#include "style/styles.hpp"
 
-#include <fstream>
-#include <iostream>
-#include <climits>
-#include <matplot/matplot.h>
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     using namespace detray;
     using namespace matplot;
 
-    if (argc > 1)
-    {
+    if (argc > 1) {
         std::string first_arg = argv[1];
-        if (first_arg == "-h" or first_arg == "--help")
-        {
-            std::cout << "[detray] Usage: 'display_layers detector_name <surface_file> <grid_file> <volume_file>'" << std::endl;
+        if (first_arg == "-h" or first_arg == "--help") {
+            std::cout << "[detray] Usage: 'display_layers detector_name "
+                         "<surface_file> <grid_file> <volume_file>'"
+                      << std::endl;
             return 1;
-        }
-        else if (argc > 5)
-        {
+        } else if (argc > 5) {
 
             int layer = argc > 6 ? atoi(argv[6]) : -1;
             bool mouse_over_mode = argc > 7 ? true : false;
@@ -48,8 +46,9 @@ int main(int argc, char **argv)
             std::string volumes_file = argv[3];
             std::string grids_file = argv[4];
             std::string grid_entries_file = argv[5];
-            
-            auto d = detector_from_csv<>(name, surfaces_file, volumes_file, grids_file, grid_entries_file);
+
+            auto d = detector_from_csv<>(name, surfaces_file, volumes_file,
+                                         grids_file, grid_entries_file);
 
             std::cout << d.to_string() << std::endl;
 
@@ -69,31 +68,29 @@ int main(int argc, char **argv)
             auto surfaces_finders = d.surfaces_finders();
 
             // Loop over the volumes
-            for (const auto [iv, v] : enumerate(d.volumes()))
-            {
+            for (const auto [iv, v] : enumerate(d.volumes())) {
 
-                if (layer > 0 and layer != iv)
-                {
+                if (layer > 0 and layer != iv) {
                     continue;
                 }
 
                 // Switch 'quiet' mode on during drawing
                 const auto &bounds = v.bounds();
-                bool is_cylinder = std::abs(bounds[1] - bounds[0]) < std::abs(bounds[3] - bounds[2]);
-                const auto &sf_range = v. template range<>();
+                bool is_cylinder = std::abs(bounds[1] - bounds[0]) <
+                                   std::abs(bounds[3] - bounds[2]);
+                const auto &sf_range = v.template range<>();
 
                 const auto &surfaces = d.surfaces<>();
-                const auto &volume_transforms = d.transforms(sf_range, s_context);
+                const auto &volume_transforms =
+                    d.transforms(sf_range, s_context);
                 const auto &volume_masks = d.masks();
 
-                if (v.empty())
-                {
+                if (v.empty()) {
                     continue;
                 }
 
                 // Loop over the surfaces within a volume
-                for (dindex sfi = sf_range[0]; sfi < sf_range[1]; sfi++)
-                {
+                for (dindex sfi = sf_range[0]; sfi < sf_range[1]; sfi++) {
                     const auto &s = surfaces[sfi];
                     dvector<point3> vertices = {};
                     const auto &mask_link = s.mask();
@@ -105,20 +102,20 @@ int main(int argc, char **argv)
                     const auto &mask_context = std::get<0>(mask_link);
                     const auto &mask_range = std::get<1>(mask_link);
 
-                    auto vertices_per_masks = unroll_masks_for_vertices(volume_masks, mask_range, mask_context,
-                                                                        std::make_integer_sequence<dindex, std::tuple_size_v<decltype(d)::surface_mask_container>>{});
-
-                    for (auto &vertices : vertices_per_masks)
-                    {
-                        if (not vertices.empty())
-                        {
-                            if (not is_cylinder)
-                            {
-                                draw_vertices(vertices, transform, surface_style, xy_view);
-                            }
-                            else
-                            {
-                                draw_vertices(vertices, transform, surface_style, zphi_view, true);
+                    auto vertices_per_masks = unroll_masks_for_vertices(
+                        volume_masks, mask_range, mask_context,
+                        std::make_integer_sequence<
+                            dindex, std::tuple_size_v<decltype(
+                                        d)::surface_mask_container>>{});
+
+                    for (auto &vertices : vertices_per_masks) {
+                        if (not vertices.empty()) {
+                            if (not is_cylinder) {
+                                draw_vertices(vertices, transform,
+                                              surface_style, xy_view);
+                            } else {
+                                draw_vertices(vertices, transform,
+                                              surface_style, zphi_view, true);
                             }
                         }
                     }
@@ -127,29 +124,25 @@ int main(int argc, char **argv)
                 // Draw the surface finder grid
                 dindex surfaces_finder_entry = v.surfaces_finder_entry();
 
-                if (surfaces_finder_entry != dindex_invalid)
-                {
+                if (surfaces_finder_entry != dindex_invalid) {
 
-                    if (not is_cylinder)
-                    {
-                        const auto &r_phi_grid = surfaces_finders[surfaces_finder_entry];
+                    if (not is_cylinder) {
+                        const auto &r_phi_grid =
+                            surfaces_finders[surfaces_finder_entry];
                         draw_r_phi_grid(r_phi_grid, grid_style);
-                    }
-                    else
-                    {
-                        const auto &z_phi_grid = surfaces_finders[surfaces_finder_entry + 2];
+                    } else {
+                        const auto &z_phi_grid =
+                            surfaces_finders[surfaces_finder_entry + 2];
                         draw_z_phi_grid(z_phi_grid, grid_style);
                     }
                 }
 
                 // Special functionality for single layers
                 //
-                if (layer > 0)
-                {
+                if (layer > 0) {
 
                     // run option: mouse over parsing
-                    if (mouse_over_mode)
-                    {
+                    if (mouse_over_mode) {
                         ax->run_command("set mouse; set print \"mouse.gpio\"");
                         ax->run_command("print MOUSE_X, MOUSE_Y, MOUSE_BUTTON");
 
@@ -158,13 +151,12 @@ int main(int argc, char **argv)
                         gpio_file.open("mouse.gpio", std::ios::in);
                         std::streamoff p = 0;
 
-                        while (true)
-                        {
-                            ax->run_command("print MOUSE_X, MOUSE_Y, MOUSE_BUTTON");
+                        while (true) {
+                            ax->run_command(
+                                "print MOUSE_X, MOUSE_Y, MOUSE_BUTTON");
 
-                            gpio_file.seekg(p); //*1
-                            while (getline(gpio_file, gpio_line))
-                            {
+                            gpio_file.seekg(p);  //*1
+                            while (getline(gpio_file, gpio_line)) {
                                 std::cout << gpio_line << std::endl;
 
                                 if (gpio_file.tellg() == -1)
@@ -179,13 +171,10 @@ int main(int argc, char **argv)
                 std::string vol_lay_name = "lay_";
                 vol_lay_name += std::to_string(iv);
                 vol_lay_name += ".png";
-                if (is_cylinder)
-                {
+                if (is_cylinder) {
                     ax->xlabel("z [mm]");
                     ax->ylabel("phi [rad]");
-                }
-                else
-                {
+                } else {
                     ax->xlabel("x [mm]");
                     ax->ylabel("y [mm]");
                     matplot::axis(equal);
@@ -198,6 +187,7 @@ int main(int argc, char **argv)
         }
     }
 
-    std::cout << "[detray] Not enough arguments given, run with -h for help. " << std::endl;
+    std::cout << "[detray] Not enough arguments given, run with -h for help. "
+              << std::endl;
     return 0;
 }
\ No newline at end of file
diff --git a/apps/common/include/apps/common/display_volumes_rz.inl b/apps/common/include/apps/common/display_volumes_rz.inl
index 8820ce0364..ee8d988c97 100644
--- a/apps/common/include/apps/common/display_volumes_rz.inl
+++ b/apps/common/include/apps/common/display_volumes_rz.inl
@@ -1,67 +1,63 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
+#include <matplot/matplot.h>
+
+#include <climits>
+#include <iostream>
+
 #include "core/detector.hpp"
 #include "core/transform_store.hpp"
 #include "io/csv_io.hpp"
 
-#include <iostream>
-#include <climits>
-#include <matplot/matplot.h>
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     using namespace detray;
     using namespace matplot;
 
-    if (argc > 1)
-    {
+    if (argc > 1) {
         std::string first_arg = argv[1];
-        if (first_arg == "-h" or first_arg == "--help")
-        {
-            std::cout << "[detray] Usage: 'display_volumes_rz detector_name <surface_file> <grid_file> <volume_file>'" << std::endl;
+        if (first_arg == "-h" or first_arg == "--help") {
+            std::cout << "[detray] Usage: 'display_volumes_rz detector_name "
+                         "<surface_file> <grid_file> <volume_file>'"
+                      << std::endl;
             return 1;
-        }
-        else if (argc > 5)
-        {
+        } else if (argc > 5) {
             std::string name = first_arg;
             std::string surfaces_file = argv[2];
             std::string volumes_file = argv[3];
             std::string grids_file = argv[4];
             std::string grid_entries_file = argv[5];
-            
-            auto d = detector_from_csv<>(name, surfaces_file, volumes_file, grids_file, grid_entries_file);
+
+            auto d = detector_from_csv<>(name, surfaces_file, volumes_file,
+                                         grids_file, grid_entries_file);
 
             std::cout << "[detray] Detector read successfully." << std::endl;
             std::cout << d.to_string() << std::endl;
-            // std::cout << "         Volumes : " << d.volumes().size() << std::endl;
-            // Parse the volumes for r/z max dimensions - pre-loop
+            // std::cout << "         Volumes : " << d.volumes().size() <<
+            // std::endl; Parse the volumes for r/z max dimensions - pre-loop
             const scalar scalar_limit = std::numeric_limits<scalar>::max();
-            darray<scalar, 4> rz_det = {scalar_limit, 0., scalar_limit, -scalar_limit};
+            darray<scalar, 4> rz_det = {scalar_limit, 0., scalar_limit,
+                                        -scalar_limit};
             dmap<scalar, std::vector<dindex>> r_min_attachments;
             dmap<scalar, std::vector<dindex>> r_max_attachments;
             dmap<scalar, std::vector<dindex>> z_min_attachments;
             dmap<scalar, std::vector<dindex>> z_max_attachments;
 
-            auto attach = [](dmap<scalar, std::vector<dindex>> &attachments, scalar value, dindex volume_index) -> void
-            {
-                if (attachments.find(value) == attachments.end())
-                {
+            auto attach = [](dmap<scalar, std::vector<dindex>> &attachments,
+                             scalar value, dindex volume_index) -> void {
+                if (attachments.find(value) == attachments.end()) {
                     attachments[value] = {volume_index};
-                }
-                else
-                {
+                } else {
                     attachments[value].push_back(volume_index);
                 }
             };
 
-            for (const auto &v : d.volumes())
-            {
+            for (const auto &v : d.volumes()) {
                 const auto &v_bounds = v.bounds();
                 rz_det[0] = std::min(rz_det[0], v_bounds[0]);
                 rz_det[1] = std::max(rz_det[1], v_bounds[1]);
@@ -74,19 +70,22 @@ int main(int argc, char **argv)
             }
 
             // Helper method to sort and rmove duplicates
-            auto sort_and_remove_duplicates = [](std::vector<dindex> &att) -> void
-            {
+            auto sort_and_remove_duplicates =
+                [](std::vector<dindex> &att) -> void {
                 std::sort(att.begin(), att.end());
                 att.erase(std::unique(att.begin(), att.end()), att.end());
             };
 
-            std::cout << "[detray] Detector grid bins r_min " << r_min_attachments.size() << std::endl;
-            std::cout << "                            r_max " << r_max_attachments.size() << std::endl;
-            std::cout << "                            z_min " << z_min_attachments.size() << std::endl;
-            std::cout << "                            z_max " << z_max_attachments.size() << std::endl;
+            std::cout << "[detray] Detector grid bins r_min "
+                      << r_min_attachments.size() << std::endl;
+            std::cout << "                            r_max "
+                      << r_max_attachments.size() << std::endl;
+            std::cout << "                            z_min "
+                      << z_min_attachments.size() << std::endl;
+            std::cout << "                            z_max "
+                      << z_max_attachments.size() << std::endl;
 
-            if (argc > 6)
-            {
+            if (argc > 6) {
 
                 auto ax = matplot::subplot({0.1, 0.1, 0.8, 0.8});
                 ax->parent()->quiet_mode(true);
@@ -94,45 +93,40 @@ int main(int argc, char **argv)
                 int base_draw_option = std::atoi(argv[6]);
 
                 // Draw first the detailed views
-                if (argc > 7)
-                {
+                if (argc > 7) {
                     // drawing: base draw option
                     int detail_draw_option = std::atoi(argv[7]);
 
-                    if (detail_draw_option == 1)
-                    {
-                        std::cout << "[detray] Drawing grid lines." << std::endl;
+                    if (detail_draw_option == 1) {
+                        std::cout << "[detray] Drawing grid lines."
+                                  << std::endl;
 
                         // Drawing the lines for the grid search
-                        for (auto [key, value] : r_min_attachments)
-                        {
+                        for (auto [key, value] : r_min_attachments) {
                             sort_and_remove_duplicates(value);
                             auto l = line(rz_det[2], key, rz_det[3], key);
                             l->color("red");
                         }
-                        for (auto [key, value] : r_max_attachments)
-                        {
+                        for (auto [key, value] : r_max_attachments) {
                             sort_and_remove_duplicates(value);
                             auto l = line(rz_det[2], key, rz_det[3], key);
                             l->color("red");
                         }
-                        for (auto [key, value] : z_min_attachments)
-                        {
+                        for (auto [key, value] : z_min_attachments) {
                             sort_and_remove_duplicates(value);
                             auto l = line(key, rz_det[0], key, rz_det[1]);
                             l->color("red");
                         }
-                        for (auto [key, value] : z_max_attachments)
-                        {
+                        for (auto [key, value] : z_max_attachments) {
                             sort_and_remove_duplicates(value);
                             auto l = line(key, rz_det[0], key, rz_det[1]);
                             l->color("red");
                         }
                     }
 
-                    if (detail_draw_option == 2 and base_draw_option == 0)
-                    {
-                        std::cout << "[detray] Drawing volume heat map." << std::endl;
+                    if (detail_draw_option == 2 and base_draw_option == 0) {
+                        std::cout << "[detray] Drawing volume heat map."
+                                  << std::endl;
 
                         // Get the grid
                         auto volume_grid = d.volume_search_grid();
@@ -143,15 +137,12 @@ int main(int argc, char **argv)
 
                         heat_data.reserve(r_axis.bins());
 
-                        for (dindex ir = 0; ir < r_axis.bins(); ++ir)
-                        {
+                        for (dindex ir = 0; ir < r_axis.bins(); ++ir) {
                             dvector<dindex> heat_values;
                             heat_values.reserve(z_axis.bins());
-                            for (dindex iz = 0; iz < z_axis.bins(); ++iz)
-                            {
+                            for (dindex iz = 0; iz < z_axis.bins(); ++iz) {
                                 dindex vidx = volume_grid.bin(ir, iz);
-                                if (vidx % 2)
-                                {
+                                if (vidx % 2) {
                                     vidx += 100;
                                 }
                                 heat_values.push_back(vidx);
@@ -167,53 +158,57 @@ int main(int argc, char **argv)
                     const auto &z_axis = volume_grid.axis_p1();
 
                     // Volume grid lines
-                    if (detail_draw_option == 3)
-                    {
-                        std::cout << "[detray] Drawing volume grid." << std::endl;
+                    if (detail_draw_option == 3) {
+                        std::cout << "[detray] Drawing volume grid."
+                                  << std::endl;
 
-                        for (dindex ir = 0; ir < r_axis.bins(); ++ir)
-                        {
+                        for (dindex ir = 0; ir < r_axis.bins(); ++ir) {
                             darray<scalar, 2> r_borders = r_axis.borders(ir);
-                            for (dindex iz = 0; iz < z_axis.bins(); ++iz)
-                            {
-                                darray<scalar, 2> z_borders = z_axis.borders(iz);
+                            for (dindex iz = 0; iz < z_axis.bins(); ++iz) {
+                                darray<scalar, 2> z_borders =
+                                    z_axis.borders(iz);
                                 dindex volume = volume_grid.bin(ir, iz);
 
-                                auto v_dis = rectangle(z_borders[0], r_borders[0], z_borders[1] - z_borders[0], r_borders[1] - r_borders[0], 0);
+                                auto v_dis =
+                                    rectangle(z_borders[0], r_borders[0],
+                                              z_borders[1] - z_borders[0],
+                                              r_borders[1] - r_borders[0], 0);
                                 v_dis->color({0.9, 0.5, 0.5, 0.5});
                             }
                         }
                     }
 
                     // Volume grid colored
-                    if (detail_draw_option == 4)
-                    {
-                        std::cout << "[detray] Drawing grid colored" << std::endl;
-                        rectangle(rz_det[2], rz_det[0], rz_det[3] - rz_det[2], rz_det[1] - rz_det[0], 0);
+                    if (detail_draw_option == 4) {
+                        std::cout << "[detray] Drawing grid colored"
+                                  << std::endl;
+                        rectangle(rz_det[2], rz_det[0], rz_det[3] - rz_det[2],
+                                  rz_det[1] - rz_det[0], 0);
 
                         std::map<dindex, darray<float, 3>> volume_colors;
 
                         /// Helper method for randomized color
-                        auto random_color = []() -> darray<float, 3>
-                        {
+                        auto random_color = []() -> darray<float, 3> {
                             int r = std::rand() % 10;
                             int g = std::rand() % 10;
                             int b = std::rand() % 10;
                             return {r * 0.1f, g * 0.1f, b * 0.1f};
                         };
 
-                        for (dindex ir = 0; ir < r_axis.bins(); ++ir)
-                        {
-                            for (dindex iz = 0; iz < z_axis.bins(); ++iz)
-                            {
+                        for (dindex ir = 0; ir < r_axis.bins(); ++ir) {
+                            for (dindex iz = 0; iz < z_axis.bins(); ++iz) {
                                 dindex volume_index = volume_grid.bin(ir, iz);
-                                if (volume_colors.find(volume_index) == volume_colors.end())
-                                {
-                                    volume_colors[volume_index] = random_color();
+                                if (volume_colors.find(volume_index) ==
+                                    volume_colors.end()) {
+                                    volume_colors[volume_index] =
+                                        random_color();
                                 }
                                 auto r_borders = r_axis.borders(ir);
                                 auto z_borders = z_axis.borders(iz);
-                                auto rz = rectangle(z_borders[0], r_borders[0], z_borders[1] - z_borders[0], r_borders[1] - r_borders[0]);
+                                auto rz =
+                                    rectangle(z_borders[0], r_borders[0],
+                                              z_borders[1] - z_borders[0],
+                                              r_borders[1] - r_borders[0]);
                                 auto color = volume_colors[volume_index];
                                 rz->fill(true);
                                 rz->color(color);
@@ -222,22 +217,24 @@ int main(int argc, char **argv)
                     }
 
                     // Volume grid blocks
-                    if (detail_draw_option == 5)
-                    {
+                    if (detail_draw_option == 5) {
 
-                        std::cout << "[detray] Drawing expanded volume grid around kernels" << std::endl;
-                        rectangle(rz_det[2], rz_det[0], rz_det[3] - rz_det[2], rz_det[1] - rz_det[0], 0);
+                        std::cout << "[detray] Drawing expanded volume grid "
+                                     "around kernels"
+                                  << std::endl;
+                        rectangle(rz_det[2], rz_det[0], rz_det[3] - rz_det[2],
+                                  rz_det[1] - rz_det[0], 0);
 
                         using bin2 = darray<dindex, 2>;
                         using bin_area = darray<bin2, 2>;
 
-                        /** Helper method for expanding the area 
-                         * 
+                        /** Helper method for expanding the area
+                         *
                          * @param be The bin area to be expanded
-                         * @param bin The bin in question  
+                         * @param bin The bin in question
                          */
-                        auto expand = [&](bin_area &be, const bin2 &bin) -> void
-                        {
+                        auto expand = [&](bin_area &be,
+                                          const bin2 &bin) -> void {
                             auto &b = be[0];
                             auto &e = be[1];
                             b[0] = std::min(b[0], bin[0]);
@@ -251,57 +248,63 @@ int main(int argc, char **argv)
                         bin_area start_bin = {max_bin, min_bin};
 
                         dmap<dindex, bin_area> volume_extends;
-                        for (dindex ir = 0; ir < r_axis.bins(); ++ir)
-                        {
-                            for (dindex iz = 0; iz < z_axis.bins(); ++iz)
-                            {
+                        for (dindex ir = 0; ir < r_axis.bins(); ++ir) {
+                            for (dindex iz = 0; iz < z_axis.bins(); ++iz) {
                                 dindex volume_index = volume_grid.bin(ir, iz);
-                                auto vol_itr = volume_extends.find(volume_index);
-                                if (vol_itr == volume_extends.end())
-                                {
+                                auto vol_itr =
+                                    volume_extends.find(volume_index);
+                                if (vol_itr == volume_extends.end()) {
                                     volume_extends[volume_index] = start_bin;
                                 }
                                 expand(volume_extends[volume_index], {ir, iz});
                             }
                         }
 
-                        std::cout << "[detray] Found " << volume_extends.size() << " individual volume extends." << std::endl;
-                        for (const auto &[vidx, be] : volume_extends)
-                        {
+                        std::cout << "[detray] Found " << volume_extends.size()
+                                  << " individual volume extends." << std::endl;
+                        for (const auto &[vidx, be] : volume_extends) {
                             const auto &b = be[0];
                             const auto &e = be[1];
                             scalar vol_rmin = r_axis.borders(b[0])[0];
                             scalar vol_zmin = z_axis.borders(b[1])[0];
                             scalar vol_rmax = r_axis.borders(e[0])[1];
                             scalar vol_zmax = z_axis.borders(e[1])[1];
-                            std::cout << "     Volume " << vidx << " with rmin/rmax = " << vol_rmin << ", " << vol_rmax << std::endl;
-                            std::cout << "            " << vidx << " with zmin/zmax = " << vol_zmin << ", " << vol_zmax << std::endl;
-                            std::cout << "            " << vidx << " from  = (" << b[0] << ", " << b[1] << ")" << std::endl;
-                            std::cout << "            " << vidx << " to    = (" << e[0] << ", " << e[1] << ")" << std::endl;
-                            auto vis_vol = rectangle(vol_zmin, vol_rmin, vol_zmax - vol_zmin, vol_rmax - vol_rmin, 0);
+                            std::cout << "     Volume " << vidx
+                                      << " with rmin/rmax = " << vol_rmin
+                                      << ", " << vol_rmax << std::endl;
+                            std::cout << "            " << vidx
+                                      << " with zmin/zmax = " << vol_zmin
+                                      << ", " << vol_zmax << std::endl;
+                            std::cout << "            " << vidx << " from  = ("
+                                      << b[0] << ", " << b[1] << ")"
+                                      << std::endl;
+                            std::cout << "            " << vidx << " to    = ("
+                                      << e[0] << ", " << e[1] << ")"
+                                      << std::endl;
+                            auto vis_vol = rectangle(vol_zmin, vol_rmin,
+                                                     vol_zmax - vol_zmin,
+                                                     vol_rmax - vol_rmin, 0);
                         }
                     }
                 }
 
                 // Drawing: base draw option on top
-                if (base_draw_option == 1)
-                {
+                if (base_draw_option == 1) {
 
                     std::cout << "[detray] Drawing volumes." << std::endl;
-                    rectangle(rz_det[2], rz_det[0], rz_det[3] - rz_det[2], rz_det[1] - rz_det[0], 0);
+                    rectangle(rz_det[2], rz_det[0], rz_det[3] - rz_det[2],
+                              rz_det[1] - rz_det[0], 0);
 
                     // Drawing loop for all volumes
-                    for (const auto &v : d.volumes())
-                    {
+                    for (const auto &v : d.volumes()) {
                         const auto &v_bounds = v.bounds();
-                        auto v_dis = rectangle(v_bounds[2], v_bounds[0], v_bounds[3] - v_bounds[2], v_bounds[1] - v_bounds[0], 0);
+                        auto v_dis = rectangle(v_bounds[2], v_bounds[0],
+                                               v_bounds[3] - v_bounds[2],
+                                               v_bounds[1] - v_bounds[0], 0);
                         v_dis->fill(true);
-                        if (not v.empty())
-                        {
+                        if (not v.empty()) {
                             v_dis->color({0.8, 0, 0, 1});
-                        }
-                        else
-                        {
+                        } else {
                             v_dis->color({0.9, 0.5, 0.5, 0.5});
                         }
                     }
@@ -315,6 +318,7 @@ int main(int argc, char **argv)
         }
     }
 
-    std::cout << "[detray] Not enough arguments given, run with -h for help. " << std::endl;
+    std::cout << "[detray] Not enough arguments given, run with -h for help. "
+              << std::endl;
     return 0;
 }
\ No newline at end of file
diff --git a/apps/src/eigen/eigen_display_bin_association.cpp b/apps/src/eigen/eigen_display_bin_association.cpp
index 96aa8307ea..8ff52d05cc 100644
--- a/apps/src/eigen/eigen_display_bin_association.cpp
+++ b/apps/src/eigen/eigen_display_bin_association.cpp
@@ -1,9 +1,9 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "plugins/algebra/eigen_definitions.hpp"
 #include "apps/common/display_bin_association.inl"
+#include "plugins/algebra/eigen_definitions.hpp"
diff --git a/apps/src/eigen/eigen_display_layers.cpp b/apps/src/eigen/eigen_display_layers.cpp
index f76ba8ba1e..410c6d3648 100644
--- a/apps/src/eigen/eigen_display_layers.cpp
+++ b/apps/src/eigen/eigen_display_layers.cpp
@@ -1,9 +1,9 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "plugins/algebra/eigen_definitions.hpp"
 #include "apps/common/display_layers.inl"
+#include "plugins/algebra/eigen_definitions.hpp"
diff --git a/apps/src/eigen/eigen_display_volumes_rz.cpp b/apps/src/eigen/eigen_display_volumes_rz.cpp
index 90586e38c1..633b589ff0 100644
--- a/apps/src/eigen/eigen_display_volumes_rz.cpp
+++ b/apps/src/eigen/eigen_display_volumes_rz.cpp
@@ -1,9 +1,9 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "plugins/algebra/eigen_definitions.hpp"
 #include "apps/common/display_volumes_rz.inl"
+#include "plugins/algebra/eigen_definitions.hpp"
diff --git a/core/include/core/detector.hpp b/core/include/core/detector.hpp
index 0b2b9786e4..4aec72852f 100644
--- a/core/include/core/detector.hpp
+++ b/core/include/core/detector.hpp
@@ -1,624 +1,656 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
+#include <sstream>
+#include <string>
+
 #include "core/intersection.hpp"
 #include "core/surface_base.hpp"
 #include "core/transform_store.hpp"
 #include "grids/axis.hpp"
 #include "grids/grid2.hpp"
-#include "grids/serializer2.hpp"
 #include "grids/populator.hpp"
+#include "grids/serializer2.hpp"
 #include "masks/masks.hpp"
-#include "utils/indexing.hpp"
-#include "utils/enumerate.hpp"
-#include "tools/planar_intersector.hpp"
-#include "tools/cylinder_intersector.hpp"
 #include "tools/concentric_cylinder_intersector.hpp"
+#include "tools/cylinder_intersector.hpp"
 #include "tools/local_object_finder.hpp"
+#include "tools/planar_intersector.hpp"
+#include "utils/enumerate.hpp"
+#include "utils/indexing.hpp"
 
-#include <string>
-#include <sstream>
+namespace detray {
+
+// Algebra, point2 is not strongly typed
+using point3 = __plugin::point3;
+using vector3 = __plugin::vector3;
+using point2 = __plugin::point2;
+
+/** Indexed detector definition.
+ *
+ * This class is a heavy templated detector definition class, that connects
+ * surfaces, layers and volumes via an indexed system.
+ *
+ * @tparam array_type the type of the internal array, must have STL semantics
+ * @tparam tuple_type the type of the internal tuple, must have STL semantics
+ * @tparam vector_type the type of the internal array, must have STL semantics
+ * @tparam alignable_store the type of the transform store
+ * @tparam surface_source_link the type of the link to an external surface
+ * source
+ * @tparam bounds_source_link the type of the link to an external bounds source
+ * @tparam surfaces_populator_type the type of populator used to fill the
+ * surfaces grids
+ * @tparam surfaces_serializer_type the type of the memory serializer for the
+ * surfaces grids
+ *
+ */
+template <template <typename, unsigned int> class array_type = darray,
+          template <typename...> class tuple_type = dtuple,
+          template <typename> class vector_type = dvector,
+          typename alignable_store = static_transform_store<vector_type>,
+          typename surface_source_link = dindex,
+          typename bounds_source_link = dindex,
+          typename surfaces_populator_type =
+              attach_populator<false, dindex, vector_type>,
+          typename surfaces_serializer_type = serializer2>
+class detector {
 
-namespace detray
-{
+    public:
+    /** Encodes the position in a collection container for the respective
+        mask type (not for portals for the moment). */
+    enum mask_container_index : unsigned int {
+        e_mask_types = 5,
+        e_rectangle2 = 0,
+        e_trapezoid2 = 1,
+        e_annulus2 = 2,
+        e_cylinder3 = 3,
+        e_ring2 = 4,
+        e_single3 = std::numeric_limits<unsigned int>::max(),
+        e_unknown = std::numeric_limits<unsigned int>::max(),
+    };
 
-    // Algebra, point2 is not strongly typed
-    using point3 = __plugin::point3;
-    using vector3 = __plugin::vector3;
-    using point2 = __plugin::point2;
+    enum use_primitive : bool {
+        e_surface = true,
+        e_portal = false,
+    };
 
-    /** Indexed detector definition.
-     * 
-     * This class is a heavy templated detector definition class, that connects
-     * surfaces, layers and volumes via an indexed system.
+    /// The detector type
+    using detector_type =
+        detector<array_type, tuple_type, vector_type, alignable_store,
+                 surface_source_link, bounds_source_link,
+                 surfaces_populator_type, surfaces_serializer_type>;
+
+    /// Forward the alignable container and context
+    using transform_store = alignable_store;
+    using context = typename alignable_store::context;
+
+    /// Volume grid definition
+    using volume_grid =
+        grid2<replace_populator<dindex, std::numeric_limits<dindex>::max(),
+                                vector_type>,
+              axis::irregular<array_type, vector_type>,
+              axis::irregular<array_type, vector_type>, serializer2>;
+
+    /// Portals components:
+    /// - links:  next volume, next (local) object finder
+    using portal_links = array_type<dindex, 2>;
+    /// - masks, with mask identifiers 0, 1
+    using portal_cylinder = cylinder3<false, cylinder_intersector,
+                                      __plugin::cylindrical2, portal_links, 0>;
+    using portal_disc =
+        ring2<planar_intersector, __plugin::cartesian2, portal_links, 1>;
+    // - mask index: type, { first/last }
+    using portal_mask_index = tuple_type<dindex, array_type<dindex, 2>>;
+    using portal_mask_container =
+        tuple_type<vector_type<portal_cylinder>, vector_type<portal_disc>>;
+
+    /** The Portal definition:
+     *  <transform_link, mask_index, volume_link, source_link >
+     *
+     * transform_link: index into the transform container
+     * mask_index: typed index into the mask container
+     * volume_link: index of the volume this portal belongs to
+     * source_link: some link to an eventual exernal representation
      *
-     * @tparam array_type the type of the internal array, must have STL semantics
-     * @tparam tuple_type the type of the internal tuple, must have STL semantics
-     * @tparam vector_type the type of the internal array, must have STL semantics
-     * @tparam alignable_store the type of the transform store
-     * @tparam surface_source_link the type of the link to an external surface source
-     * @tparam bounds_source_link the type of the link to an external bounds source
-     * @tparam surfaces_populator_type the type of populator used to fill the surfaces grids
-     * @tparam surfaces_serializer_type the type of the memory serializer for the surfaces grids
-     * 
      */
-    template <template <typename, unsigned int> class array_type = darray,
-              template <typename...> class tuple_type = dtuple,
-              template <typename> class vector_type = dvector,
-              typename alignable_store = static_transform_store<vector_type>,
-              typename surface_source_link = dindex,
-              typename bounds_source_link = dindex,
-              typename surfaces_populator_type = attach_populator<false, dindex, vector_type>,
-              typename surfaces_serializer_type = serializer2>
-    class detector
-    {
-
-    public:
-
-        /** Encodes the position in a collection container for the respective
-            mask type (not for portals for the moment). */
-        enum mask_container_index : unsigned int {
-            e_mask_types = 5,
-            e_rectangle2 = 0,
-            e_trapezoid2 = 1,
-            e_annulus2 = 2,
-            e_cylinder3 = 3,
-            e_ring2 = 4,
-            e_single3 = std::numeric_limits<unsigned int>::max(),
-            e_unknown = std::numeric_limits<unsigned int>::max(),
-        };
+    using portal =
+        surface_base<dindex, portal_mask_index, dindex, surface_source_link>;
+    using portal_container = vector_type<portal>;
+
+    /// Surface components:
+    /// - surface links
+    using surface_links = array_type<dindex, 1>;
+    /// - masks, with mask identifiers 0,1,2
+    using surface_rectangle =
+        rectangle2<planar_intersector, __plugin::cartesian2, surface_links, 0>;
+    using surface_trapezoid =
+        trapezoid2<planar_intersector, __plugin::cartesian2, surface_links, 1>;
+    using surface_annulus =
+        annulus2<planar_intersector, __plugin::cartesian2, surface_links, 2>;
+    using surface_cylinder =
+        cylinder3<false, cylinder_intersector, __plugin::cylindrical2,
+                  surface_links, 3>;
+    /// - mask index: type, entry
+    using surface_mask_index = array_type<dindex, 2>;
+    using surface_mask_container =
+        tuple_type<vector_type<surface_rectangle>,
+                   vector_type<surface_trapezoid>, vector_type<surface_annulus>,
+                   vector_type<surface_cylinder>>;
+
+    using surface_link = surface_source_link;
+    /** The Surface definition:
+     *  <transform_link, mask_link, volume_link, source_link >
+     */
+    using surface =
+        surface_base<dindex, surface_mask_index, dindex, surface_link>;
+    using surface_container = vector_type<surface>;
+
+    using surfaces_regular_axis = axis::regular<array_type>;
+    using surfaces_circular_axis = axis::circular<array_type>;
+    using surfaces_regular_circular_grid =
+        grid2<surfaces_populator_type, surfaces_regular_axis,
+              surfaces_circular_axis, surfaces_serializer_type, array_type,
+              tuple_type, vector_type>;
+
+    using surfaces_finder = surfaces_regular_circular_grid;
+
+    /** Temporary container structures that are used to fill the detector.
+     * The respective objects are sorted by mask type, so that they can be
+     * unrolled and filled in lockstep with the masks
+     */
+    using surface_filling_container = array_type<vector_type<surface>, 5>;
+    using portal_filling_container = array_type<vector_type<portal>, 5>;
+    using transform_container = array_type<transform_store, 5>;
 
-        enum use_primitive : bool {
-            e_surface = true,
-            e_portal = false,
-        };
+    /** Nested volume struct that holds the local information of the
+     * volume and its portals.
+     */
+    class volume {
+        friend class detector<array_type, tuple_type, vector_type,
+                              alignable_store, surface_source_link,
+                              bounds_source_link, surfaces_populator_type,
+                              surfaces_serializer_type>;
 
+        public:
+        /** Deleted constructor */
+        volume() = delete;
 
-        /// The detector type
-        using detector_type = detector<array_type, tuple_type, vector_type, alignable_store, surface_source_link, bounds_source_link, surfaces_populator_type, surfaces_serializer_type>;
-
-        /// Forward the alignable container and context
-        using transform_store = alignable_store;
-        using context = typename alignable_store::context;
-
-        /// Volume grid definition
-        using volume_grid = grid2<replace_populator<dindex, std::numeric_limits<dindex>::max(), vector_type>,
-                                  axis::irregular<array_type, vector_type>,
-                                  axis::irregular<array_type, vector_type>,
-                                  serializer2>;
-
-        /// Portals components:
-        /// - links:  next volume, next (local) object finder
-        using portal_links = array_type<dindex, 2>;
-        /// - masks, with mask identifiers 0, 1
-        using portal_cylinder = cylinder3<false, cylinder_intersector, __plugin::cylindrical2, portal_links, 0>;
-        using portal_disc = ring2<planar_intersector, __plugin::cartesian2, portal_links, 1>;
-        // - mask index: type, { first/last }
-        using portal_mask_index = tuple_type<dindex, array_type<dindex, 2>>;
-        using portal_mask_container = tuple_type<vector_type<portal_cylinder>, vector_type<portal_disc>>;
-
-        /** The Portal definition:
-         *  <transform_link, mask_index, volume_link, source_link >
-         * 
-         * transform_link: index into the transform container
-         * mask_index: typed index into the mask container
-         * volume_link: index of the volume this portal belongs to
-         * source_link: some link to an eventual exernal representation
-         * 
-         */
-        using portal = surface_base<dindex, portal_mask_index, dindex, surface_source_link>;
-        using portal_container = vector_type<portal>;
-
-        /// Surface components:
-        /// - surface links
-        using surface_links = array_type<dindex, 1>;
-        /// - masks, with mask identifiers 0,1,2
-        using surface_rectangle = rectangle2<planar_intersector, __plugin::cartesian2, surface_links, 0>;
-        using surface_trapezoid = trapezoid2<planar_intersector, __plugin::cartesian2, surface_links, 1>;
-        using surface_annulus = annulus2<planar_intersector, __plugin::cartesian2, surface_links, 2>;
-        using surface_cylinder = cylinder3<false, cylinder_intersector, __plugin::cylindrical2, surface_links, 3>;
-        /// - mask index: type, entry
-        using surface_mask_index = array_type<dindex, 2>;
-        using surface_mask_container = tuple_type<vector_type<surface_rectangle>,
-                                                  vector_type<surface_trapezoid>,
-                                                  vector_type<surface_annulus>,
-                                                  vector_type<surface_cylinder>>;
-
-        using surface_link = surface_source_link;
-        /** The Surface definition:
-         *  <transform_link, mask_link, volume_link, source_link >
+        /** Allowed constructors
+         * @param name of the volume
+         * @param d detector the volume belongs to
+         *
+         * @note will be contructed boundless
          */
-        using surface = surface_base<dindex, surface_mask_index, dindex, surface_link>;
-        using surface_container = vector_type<surface>;
-
-        using surfaces_regular_axis = axis::regular<array_type>;
-        using surfaces_circular_axis = axis::circular<array_type>;
-        using surfaces_regular_circular_grid = grid2<surfaces_populator_type,
-                                                     surfaces_regular_axis,
-                                                     surfaces_circular_axis,
-                                                     surfaces_serializer_type,
-                                                     array_type,
-                                                     tuple_type,
-                                                     vector_type>;
-
-        using surfaces_finder = surfaces_regular_circular_grid;
-
-        /** Temporary container structures that are used to fill the detector. 
-         * The respective objects are sorted by mask type, so that they can be 
-         * unrolled and filled in lockstep with the masks
+        volume(const std::string &name) : _name(name) {}
+
+        /** Contructor with name and bounds
+         * @param name of the volume
+         * @param bounds of the volume
+         * @param d detector the volume belongs to
          */
-        using surface_filling_container = array_type<vector_type<surface>, 5>;
-        using portal_filling_container = array_type<vector_type<portal>, 5>;
-        using transform_container = array_type<transform_store, 5>;
+        volume(const std::string &name, const array_type<scalar, 6> &bounds)
+            : _name(name), _bounds(bounds) {}
 
-        /** Nested volume struct that holds the local information of the
-         * volume and its portals.
+        /** Copy ctor makes sure constituents keep valid volume pointer
+         *
+         * @param other Volume to be copied
          */
-        class volume
-        {
-            friend class detector<array_type,
-                                  tuple_type,
-                                  vector_type,
-                                  alignable_store,
-                                  surface_source_link,
-                                  bounds_source_link,
-                                  surfaces_populator_type,
-                                  surfaces_serializer_type>;
+        volume(const volume &other) = default;
 
-        public:
+        /** @return the bounds - const access */
+        const array_type<scalar, 6> &bounds() const { return _bounds; }
 
-            /** Deleted constructor */
-            volume() = delete;
-
-            /** Allowed constructors
-             * @param name of the volume
-             * @param d detector the volume belongs to
-             * 
-             * @note will be contructed boundless
-             */
-            volume(const std::string &name) : _name(name){}
-
-            /** Contructor with name and bounds 
-             * @param name of the volume
-             * @param bounds of the volume
-             * @param d detector the volume belongs to
-             */
-            volume(const std::string &name, const array_type<scalar, 6> &bounds) : _name(name), _bounds(bounds) {}
-
-            /** Copy ctor makes sure constituents keep valid volume pointer
-             *
-             * @param other Volume to be copied
-             */
-            volume(const volume &other) = default;
-
-            /** @return the bounds - const access */
-            const array_type<scalar, 6> &bounds() const { return _bounds; }
-
-            /** @return the name */
-            const std::string &name() const { return _name; }
-
-            /** @return the index */
-            dindex index() const { return _index; }
-
-            /** @return the entry into the local surface finders */
-            dindex surfaces_finder_entry() const { return _surfaces_finder_entry; }
-
-            /** @return if the volume is empty or not */
-            bool empty() const
-            {
-                return is_empty_range(_surface_range);
-            }
+        /** @return the name */
+        const std::string &name() const { return _name; }
 
-            /** @return the number of surfaces in the volume */
-            template<bool use_surfaces = e_surface>
-            dindex n_objects()
-            {
-                if constexpr (use_surfaces) { return n_in_range(_surface_range); }
-                else { return n_in_range(_portal_range); }
-            }
+        /** @return the index */
+        dindex index() const { return _index; }
 
-            /** @return the number of surfaces in the volume */
-            template<bool use_surfaces = e_surface>
-            const dindex n_objects() const
-            {
-                if constexpr (use_surfaces) { return n_in_range(_surface_range); }
-                else { return n_in_range(_portal_range); }
-            }
+        /** @return the entry into the local surface finders */
+        dindex surfaces_finder_entry() const { return _surfaces_finder_entry; }
 
-            /** Set the index into the detector surface container
-             *
-             * @param range Surface index range
-             */
-            template<bool surface_range = e_surface>
-            void set_range(dindex_range range)
-            {
-                if constexpr (surface_range) { update_range(_surface_range, std::move(range)); }
-                else { update_range(_portal_range, std::move(range)); }
-            }
+        /** @return if the volume is empty or not */
+        bool empty() const { return is_empty_range(_surface_range); }
 
-            /** @return range of surfaces- const access */
-            template<bool surface_range = e_surface>
-            const auto &range() const {
-                
-                if constexpr (surface_range) { return _surface_range; }
-                else { return _portal_range;}
+        /** @return the number of surfaces in the volume */
+        template <bool use_surfaces = e_surface>
+        dindex n_objects() {
+            if constexpr (use_surfaces) {
+                return n_in_range(_surface_range);
+            } else {
+                return n_in_range(_portal_range);
             }
+        }
 
-            /** @return range of portals - const access */
-            //const auto &portal_range() const { return _portal_range; }
-
-            /** @return range of surface transforms - const access */
-            template<bool surface_range = e_surface>
-            const auto &trf_range() const
-            {
-                if constexpr (surface_range) { return _surface_trf_range; }
-                else { return _portal_trf_range;}
+        /** @return the number of surfaces in the volume */
+        template <bool use_surfaces = e_surface>
+        const dindex n_objects() const {
+            if constexpr (use_surfaces) {
+                return n_in_range(_surface_range);
+            } else {
+                return n_in_range(_portal_range);
             }
+        }
 
-            /** Set the index into the detector transform store for portals
-             *
-             * @param range Portal transform index range
-             */
-            template<bool surface_range = e_surface>
-            void set_trf_range(dindex_range range)
-            {
-                if constexpr (surface_range) { update_range(_surface_trf_range, std::move(range)); }
-                else { update_range(_portal_trf_range, std::move(range)); }
+        /** Set the index into the detector surface container
+         *
+         * @param range Surface index range
+         */
+        template <bool surface_range = e_surface>
+        void set_range(dindex_range range) {
+            if constexpr (surface_range) {
+                update_range(_surface_range, std::move(range));
+            } else {
+                update_range(_portal_range, std::move(range));
             }
+        }
 
-        private:
-            /** Volume section: name */
-            std::string _name = "unknown";
-
-            /** Volume index */
-            dindex _index = dindex_invalid;
-
-            /** Transform ranges in the detector transform store.*/
-            dindex_range _surface_trf_range = {dindex_invalid, dindex_invalid};
-            dindex_range _portal_trf_range  = {dindex_invalid, dindex_invalid};
-
-            /** Index ranges in the detector surface/portal containers.*/
-            dindex_range _surface_range = {dindex_invalid, dindex_invalid};
-            dindex_range _portal_range  = {dindex_invalid, dindex_invalid};
-
-            /** Index into the surface finder container */
-            dindex _surfaces_finder_entry = dindex_invalid;
-
-            /** Bounds section, default for r, z, phi */
-            array_type<scalar, 6> _bounds = {0.,
-                                             std::numeric_limits<scalar>::max(),
-                                             -std::numeric_limits<scalar>::max(),
-                                             std::numeric_limits<scalar>::max(),
-                                             -M_PI, M_PI};
-
-            /**
-             * @param range Any index range
-             *
-             * @return the number of indexed objects
-             */
-            inline dindex n_in_range(const dindex_range &range) { return range[1] - range[0]; }
-
-            /**
-             * @param range Any index range
-             *
-             * @return the number of indexed objects
-             */
-            inline const dindex n_in_range(const dindex_range &range) const { return range[1] - range[0]; }
-
-            /** Test whether a range is empty
-             *
-             * @param range Any index range
-             *
-             * @return boolean whether the range is empty
-             */
-            inline bool is_empty_range(const dindex_range &range) { return n_in_range(range) == 0; }
-
-            /** Test whether a range is empty - const
-             *
-             * @param range Any index range
-             *
-             * @return boolean whether the range is empty
-             */
-            inline const bool is_empty_range(const dindex_range &range) const { return n_in_range(range) == 0; }
-
-
-            /** Set or update a range
-             *
-             * @param range One of the volume member ranges
-             * @param other new index range
-             *
-             * @return boolean whether the range is empty
-             */
-            inline void update_range(dindex_range &range, dindex_range &&other)
-            {
-                // Range not set yet
-                if (range[0] == dindex_invalid) {
-                    range = other;
-                }
-                else {
-                    range[1] += other[1] - other[0];
-                }
+        /** @return range of surfaces- const access */
+        template <bool surface_range = e_surface>
+        const auto &range() const {
+
+            if constexpr (surface_range) {
+                return _surface_range;
+            } else {
+                return _portal_range;
             }
-        };
+        }
 
-        /** Allowed costructor
-         * @param name the detector
-         */
-        detector(const std::string &name) : _name(name) {}
+        /** @return range of portals - const access */
+        // const auto &portal_range() const { return _portal_range; }
 
-        /** Copy constructor makes sure the volumes belong to new detector.
-         *
-         * @param other Detector to be copied
-         */
-        detector(const detector &other) = default;
-        detector() = delete;
-        ~detector() = default;
+        /** @return range of surface transforms - const access */
+        template <bool surface_range = e_surface>
+        const auto &trf_range() const {
+            if constexpr (surface_range) {
+                return _surface_trf_range;
+            } else {
+                return _portal_trf_range;
+            }
+        }
 
-        /** Add a new volume and retrieve a reference to it
-         *
-         * @param name of the volume
-         * @param bounds of the volume, they are expected to be already attaching
-         * @param surfaces_finder_entry of the volume, where to entry the surface finder 
+        /** Set the index into the detector transform store for portals
          *
-         * @return non-const reference of the new volume
+         * @param range Portal transform index range
          */
-        volume &new_volume(const std::string &name, const array_type<scalar, 6> &bounds, dindex surfaces_finder_entry = dindex_invalid)
-        {
-            _volumes.emplace_back(name, bounds);
-            dindex cvolume_idx = _volumes.size() - 1;
-            volume &cvolume = _volumes[cvolume_idx];
-            cvolume._index = cvolume_idx;
-            cvolume._surfaces_finder_entry = surfaces_finder_entry;
-            return cvolume;
+        template <bool surface_range = e_surface>
+        void set_trf_range(dindex_range range) {
+            if constexpr (surface_range) {
+                update_range(_surface_trf_range, std::move(range));
+            } else {
+                update_range(_portal_trf_range, std::move(range));
+            }
         }
 
-        /** @return the name of the detector */
-        const std::string &name() const { return _name; }
+        private:
+        /** Volume section: name */
+        std::string _name = "unknown";
 
-        /** @return the contained volumes of the detector - const access */
-        const vector_type<volume> &volumes() const { return _volumes; }
+        /** Volume index */
+        dindex _index = dindex_invalid;
 
-        /** @return the volume by @param volume_index - const access */
-        const volume &indexed_volume(dindex volume_index) const { return _volumes[volume_index]; }
+        /** Transform ranges in the detector transform store.*/
+        dindex_range _surface_trf_range = {dindex_invalid, dindex_invalid};
+        dindex_range _portal_trf_range = {dindex_invalid, dindex_invalid};
 
-        /** @return the volume by @param position - const access */
-        const volume &indexed_volume(const point3 &p) const
-        {
-            point2 p2 = {getter::perp(p), p[2]};
-            dindex volume_index = _volume_grid.bin(p2);
-            return _volumes[volume_index];
-        }
+        /** Index ranges in the detector surface/portal containers.*/
+        dindex_range _surface_range = {dindex_invalid, dindex_invalid};
+        dindex_range _portal_range = {dindex_invalid, dindex_invalid};
 
-        /** @return the volume by @param volume_index - non-const access */
-        volume &indexed_volume(dindex volume_index) { return _volumes[volume_index]; }
+        /** Index into the surface finder container */
+        dindex _surfaces_finder_entry = dindex_invalid;
 
-        /** Add a new full set of alignable transforms for surfaces of a volume
-         *
-         * @param volume The volume we add the transforms to
-         * @param surfaces The surfaces in the volume
-         * @param trfs The surface transforms (same number as surfaces)
-         * @param ctx The context of the call
+        /** Bounds section, default for r, z, phi */
+        array_type<scalar, 6> _bounds = {0.,
+                                         std::numeric_limits<scalar>::max(),
+                                         -std::numeric_limits<scalar>::max(),
+                                         std::numeric_limits<scalar>::max(),
+                                         -M_PI,
+                                         M_PI};
+
+        /**
+         * @param range Any index range
          *
-         * @note can throw an exception if input data is inconsistent
+         * @return the number of indexed objects
          */
-        template <bool add_surfaces = e_surface,
-                  typename object_container,
-                  typename mask_container>
-        void add_objects(
-            volume &volume,
-            object_container &surfaces,
-            mask_container &masks,
-            transform_container &trfs,
-            const typename alignable_store::context ctx = {}) noexcept(false)
-        {
-            unroll_container_filling<0, object_container, mask_container, add_surfaces>(surfaces, masks, volume, trfs, ctx);
-        }
-        
-        /** @return all surfaces/portals in the detector */
-        template<bool get_surface = true>
-        const auto& surfaces() const
-        {
-            if constexpr (get_surface) { return _surfaces; }
-            else { return _portals; }
+        inline dindex n_in_range(const dindex_range &range) {
+            return range[1] - range[0];
         }
 
-        /** Get @return all surface/portal masks in the detector */
-        template<bool surface_masks = e_surface>
-        const auto& masks() const
-        {
-            if constexpr (surface_masks) { return _surface_masks; }
-            else { return _portal_masks; }
-        }
-
-        /** Unrolls the data containers according to mask type and fills the detector.
-          *
-          * @tparam current_idx the current mask context to be processed
-          * @tparam object_container surfaces/portals for which the links are updated
-          * @tparam mask_container surface/portal masks, sorted by type
-          * @tparam add_surfaces check whether we deal with surfaces or portals
-          *
-          */
-        template <size_t current_idx = 0,
-                  typename object_container,
-                  typename mask_container,
-                  bool add_surfaces = e_surface>
-        void unroll_container_filling(object_container &objects,
-                                      mask_container &masks,
-                                      volume &volume,
-                                      transform_container &trfs,
-                                      const typename alignable_store::context ctx = {})
-        {
-            // Get the surfaces/portals for a mask type
-            auto &typed_objects = objects[current_idx];
-            // Get the corresponding transforms
-            const auto &surface_transforms = trfs[current_idx];
-            // and the corresponding masks
-            auto &object_masks = std::get<current_idx>(masks);
-
-            // Fill object masks into the correct detector container
-            auto add_detector_masks = [&](auto &detector_container) -> dindex
-            {
-                auto &detector_masks = std::get<current_idx>(detector_container);
-                const dindex mask_offset = detector_masks.size();
-                detector_masks.reserve(mask_offset + object_masks.size());
-                detector_masks.insert(detector_masks.end(), object_masks.begin(), object_masks.end());
-
-                return mask_offset;
-            };
-
-            // Fill objects (surfaces or portals) into the detector container
-            auto add_detector_objects = [&](auto &detector_container)
-            {
-                detector_container.reserve(detector_container.size() + typed_objects.size());
-                detector_container.insert(detector_container.end(), typed_objects.begin(), typed_objects.end());
-            };
-
-
-            if (surface_transforms.size(ctx) != 0 and not typed_objects.empty())
-            {
-                // Current offsets into detectors containers
-                const auto trsf_offset = transform_index(ctx);
-                _transforms.append(ctx, std::move(std::get<current_idx>(trfs)));
-
-                // Fill surface or portal container?
-                if constexpr (add_surfaces)
-                {
-                    // Surface transforms for this volume
-                    volume.template set_trf_range<e_surface>(dindex_range{trsf_offset, transform_index(ctx)});
-
-                    const auto sf_mask_offset = add_detector_masks(_surface_masks);
-
-                    // Update the surfaces mask link
-                    for (auto &sf : typed_objects)
-                    {
-                        std::get<1>(sf.mask()) += sf_mask_offset;
-                    }
-
-                    // Now put the surfaces into the detector
-                    add_detector_objects(_surfaces);
-                    volume.template set_range<e_surface>({_surfaces.size() - typed_objects.size(), _surfaces.size()});
-                }
-                else
-                {
-                    // Portal transforms for this volume
-                    volume.template set_trf_range<e_portal>(dindex_range{trsf_offset, transform_index(ctx)});
-
-                    // Fill the correct mask type
-                    const auto pt_mask_offset = add_detector_masks(_portal_masks);
-
-                    // Update the portals mask links
-                    for (auto &obj : typed_objects)
-                    {
-                        auto& portal_mask_index = std::get<1>(obj.mask());
-                        portal_mask_index[0] += pt_mask_offset;
-                        portal_mask_index[1] += pt_mask_offset;
-                    }
-
-                    // Now put the portals into the detector
-                    add_detector_objects(_portals);
-                    volume.template set_range<e_portal>({_portals.size() - typed_objects.size(), _portals.size()});
-                }
-            }
-            // Next mask type
-            if constexpr (current_idx < std::tuple_size_v<mask_container> - 1)
-            {
-                return unroll_container_filling<current_idx + 1, object_container, mask_container, add_surfaces>(objects, masks, volume, trfs, ctx);
-            }
+        /**
+         * @param range Any index range
+         *
+         * @return the number of indexed objects
+         */
+        inline const dindex n_in_range(const dindex_range &range) const {
+            return range[1] - range[0];
         }
 
-        /** Get the current transform index
+        /** Test whether a range is empty
          *
-         * @param ctx The context of the call
+         * @param range Any index range
          *
-         * @return Index to add new transforms at 
+         * @return boolean whether the range is empty
          */
-        const unsigned int transform_index(const context &ctx) const
-        {
-            return _transforms.size(ctx);
+        inline bool is_empty_range(const dindex_range &range) {
+            return n_in_range(range) == 0;
         }
 
-        /** Get all transform in an index range from the detector
+        /** Test whether a range is empty - const
          *
-         * @param range The range of surfaces/portals in the transform store
-         * @param ctx The context of the call
+         * @param range Any index range
          *
-         * @return ranged iterator to the object transforms 
+         * @return boolean whether the range is empty
          */
-        const auto transforms(const dindex_range range, const context &ctx = {}) const
-        {
-            return _transforms.range(std::move(range), ctx);
+        inline const bool is_empty_range(const dindex_range &range) const {
+            return n_in_range(range) == 0;
         }
 
-        /** Add the volume grid - move semantics 
-         * 
-         * @param v_grid the volume grid to be added
+        /** Set or update a range
+         *
+         * @param range One of the volume member ranges
+         * @param other new index range
+         *
+         * @return boolean whether the range is empty
          */
-        void add_volume_grid(volume_grid &&v_grid)
-        {
-            _volume_grid = std::move(v_grid);
+        inline void update_range(dindex_range &range, dindex_range &&other) {
+            // Range not set yet
+            if (range[0] == dindex_invalid) {
+                range = other;
+            } else {
+                range[1] += other[1] - other[0];
+            }
         }
+    };
 
-        /** @return the volume grid - const access */
-        const volume_grid &volume_search_grid() const { return _volume_grid; }
+    /** Allowed costructor
+     * @param name the detector
+     */
+    detector(const std::string &name) : _name(name) {}
 
-        /** Add local surface finders linked to from the portals - move semantics
-         * 
-         * This connects portals and surface grids
-         */
-        void add_surfaces_finders(vector_type<surfaces_finder> &&surfaces_finders)
-        {
-            _surfaces_finders = std::move(surfaces_finders);
+    /** Copy constructor makes sure the volumes belong to new detector.
+     *
+     * @param other Detector to be copied
+     */
+    detector(const detector &other) = default;
+    detector() = delete;
+    ~detector() = default;
+
+    /** Add a new volume and retrieve a reference to it
+     *
+     * @param name of the volume
+     * @param bounds of the volume, they are expected to be already attaching
+     * @param surfaces_finder_entry of the volume, where to entry the surface
+     * finder
+     *
+     * @return non-const reference of the new volume
+     */
+    volume &new_volume(const std::string &name,
+                       const array_type<scalar, 6> &bounds,
+                       dindex surfaces_finder_entry = dindex_invalid) {
+        _volumes.emplace_back(name, bounds);
+        dindex cvolume_idx = _volumes.size() - 1;
+        volume &cvolume = _volumes[cvolume_idx];
+        cvolume._index = cvolume_idx;
+        cvolume._surfaces_finder_entry = surfaces_finder_entry;
+        return cvolume;
+    }
+
+    /** @return the name of the detector */
+    const std::string &name() const { return _name; }
+
+    /** @return the contained volumes of the detector - const access */
+    const vector_type<volume> &volumes() const { return _volumes; }
+
+    /** @return the volume by @param volume_index - const access */
+    const volume &indexed_volume(dindex volume_index) const {
+        return _volumes[volume_index];
+    }
+
+    /** @return the volume by @param position - const access */
+    const volume &indexed_volume(const point3 &p) const {
+        point2 p2 = {getter::perp(p), p[2]};
+        dindex volume_index = _volume_grid.bin(p2);
+        return _volumes[volume_index];
+    }
+
+    /** @return the volume by @param volume_index - non-const access */
+    volume &indexed_volume(dindex volume_index) {
+        return _volumes[volume_index];
+    }
+
+    /** Add a new full set of alignable transforms for surfaces of a volume
+     *
+     * @param volume The volume we add the transforms to
+     * @param surfaces The surfaces in the volume
+     * @param trfs The surface transforms (same number as surfaces)
+     * @param ctx The context of the call
+     *
+     * @note can throw an exception if input data is inconsistent
+     */
+    template <bool add_surfaces = e_surface, typename object_container,
+              typename mask_container>
+    void add_objects(
+        volume &volume, object_container &surfaces, mask_container &masks,
+        transform_container &trfs,
+        const typename alignable_store::context ctx = {}) noexcept(false) {
+        unroll_container_filling<0, object_container, mask_container,
+                                 add_surfaces>(surfaces, masks, volume, trfs,
+                                               ctx);
+    }
+
+    /** @return all surfaces/portals in the detector */
+    template <bool get_surface = true>
+    const auto &surfaces() const {
+        if constexpr (get_surface) {
+            return _surfaces;
+        } else {
+            return _portals;
+        }
+    }
+
+    /** Get @return all surface/portal masks in the detector */
+    template <bool surface_masks = e_surface>
+    const auto &masks() const {
+        if constexpr (surface_masks) {
+            return _surface_masks;
+        } else {
+            return _portal_masks;
         }
+    }
 
-        /** @return the surface finders - const access */
-        const vector_type<surfaces_finder> &surfaces_finders() const { return _surfaces_finders; }
-
-        /** Output to string */
-        const std::string to_string() const
-        {
-            std::stringstream ss;
-            ss << "[>] Detector '" << _name << "' has " << _volumes.size() << " volumes." << std::endl;
-            ss << "    contains  " << _surfaces_finders.size() << " local surface finders." << std::endl;
-            for (const auto &[i, v] : enumerate(_volumes))
-            {
-                ss << "[>>] Volume at index " << i << " - name: '" << v.name() << "'" << std::endl;
-                ss << "     contains    " << v.template n_objects<e_surface>() << " detector surfaces" << std::endl;
-                ss << "                 " << v.template n_objects<e_portal>() << " detector portals" << std::endl;
-                if (v._surfaces_finder_entry != dindex_invalid)
-                {
-                    ss << "     finders idx " << v._surfaces_finder_entry << std::endl;
+    /** Unrolls the data containers according to mask type and fills the
+     * detector.
+     *
+     * @tparam current_idx the current mask context to be processed
+     * @tparam object_container surfaces/portals for which the links are updated
+     * @tparam mask_container surface/portal masks, sorted by type
+     * @tparam add_surfaces check whether we deal with surfaces or portals
+     *
+     */
+    template <size_t current_idx = 0, typename object_container,
+              typename mask_container, bool add_surfaces = e_surface>
+    void unroll_container_filling(
+        object_container &objects, mask_container &masks, volume &volume,
+        transform_container &trfs,
+        const typename alignable_store::context ctx = {}) {
+        // Get the surfaces/portals for a mask type
+        auto &typed_objects = objects[current_idx];
+        // Get the corresponding transforms
+        const auto &surface_transforms = trfs[current_idx];
+        // and the corresponding masks
+        auto &object_masks = std::get<current_idx>(masks);
+
+        // Fill object masks into the correct detector container
+        auto add_detector_masks = [&](auto &detector_container) -> dindex {
+            auto &detector_masks = std::get<current_idx>(detector_container);
+            const dindex mask_offset = detector_masks.size();
+            detector_masks.reserve(mask_offset + object_masks.size());
+            detector_masks.insert(detector_masks.end(), object_masks.begin(),
+                                  object_masks.end());
+
+            return mask_offset;
+        };
+
+        // Fill objects (surfaces or portals) into the detector container
+        auto add_detector_objects = [&](auto &detector_container) {
+            detector_container.reserve(detector_container.size() +
+                                       typed_objects.size());
+            detector_container.insert(detector_container.end(),
+                                      typed_objects.begin(),
+                                      typed_objects.end());
+        };
+
+        if (surface_transforms.size(ctx) != 0 and not typed_objects.empty()) {
+            // Current offsets into detectors containers
+            const auto trsf_offset = transform_index(ctx);
+            _transforms.append(ctx, std::move(std::get<current_idx>(trfs)));
+
+            // Fill surface or portal container?
+            if constexpr (add_surfaces) {
+                // Surface transforms for this volume
+                volume.template set_trf_range<e_surface>(
+                    dindex_range{trsf_offset, transform_index(ctx)});
+
+                const auto sf_mask_offset = add_detector_masks(_surface_masks);
+
+                // Update the surfaces mask link
+                for (auto &sf : typed_objects) {
+                    std::get<1>(sf.mask()) += sf_mask_offset;
+                }
+
+                // Now put the surfaces into the detector
+                add_detector_objects(_surfaces);
+                volume.template set_range<e_surface>(
+                    {_surfaces.size() - typed_objects.size(),
+                     _surfaces.size()});
+            } else {
+                // Portal transforms for this volume
+                volume.template set_trf_range<e_portal>(
+                    dindex_range{trsf_offset, transform_index(ctx)});
+
+                // Fill the correct mask type
+                const auto pt_mask_offset = add_detector_masks(_portal_masks);
+
+                // Update the portals mask links
+                for (auto &obj : typed_objects) {
+                    auto &portal_mask_index = std::get<1>(obj.mask());
+                    portal_mask_index[0] += pt_mask_offset;
+                    portal_mask_index[1] += pt_mask_offset;
                 }
-                ss << "     bounds r = (" << v._bounds[0] << ", " << v._bounds[1] << ")" << std::endl;
-                ss << "            z = (" << v._bounds[2] << ", " << v._bounds[3] << ")" << std::endl;
+
+                // Now put the portals into the detector
+                add_detector_objects(_portals);
+                volume.template set_range<e_portal>(
+                    {_portals.size() - typed_objects.size(), _portals.size()});
             }
-            return ss.str();
-        };
+        }
+        // Next mask type
+        if constexpr (current_idx < std::tuple_size_v<mask_container> - 1) {
+            return unroll_container_filling<current_idx + 1, object_container,
+                                            mask_container, add_surfaces>(
+                objects, masks, volume, trfs, ctx);
+        }
+    }
+
+    /** Get the current transform index
+     *
+     * @param ctx The context of the call
+     *
+     * @return Index to add new transforms at
+     */
+    const unsigned int transform_index(const context &ctx) const {
+        return _transforms.size(ctx);
+    }
+
+    /** Get all transform in an index range from the detector
+     *
+     * @param range The range of surfaces/portals in the transform store
+     * @param ctx The context of the call
+     *
+     * @return ranged iterator to the object transforms
+     */
+    const auto transforms(const dindex_range range,
+                          const context &ctx = {}) const {
+        return _transforms.range(std::move(range), ctx);
+    }
+
+    /** Add the volume grid - move semantics
+     *
+     * @param v_grid the volume grid to be added
+     */
+    void add_volume_grid(volume_grid &&v_grid) {
+        _volume_grid = std::move(v_grid);
+    }
+
+    /** @return the volume grid - const access */
+    const volume_grid &volume_search_grid() const { return _volume_grid; }
+
+    /** Add local surface finders linked to from the portals - move semantics
+     *
+     * This connects portals and surface grids
+     */
+    void add_surfaces_finders(vector_type<surfaces_finder> &&surfaces_finders) {
+        _surfaces_finders = std::move(surfaces_finders);
+    }
+
+    /** @return the surface finders - const access */
+    const vector_type<surfaces_finder> &surfaces_finders() const {
+        return _surfaces_finders;
+    }
+
+    /** Output to string */
+    const std::string to_string() const {
+        std::stringstream ss;
+        ss << "[>] Detector '" << _name << "' has " << _volumes.size()
+           << " volumes." << std::endl;
+        ss << "    contains  " << _surfaces_finders.size()
+           << " local surface finders." << std::endl;
+        for (const auto &[i, v] : enumerate(_volumes)) {
+            ss << "[>>] Volume at index " << i << " - name: '" << v.name()
+               << "'" << std::endl;
+            ss << "     contains    " << v.template n_objects<e_surface>()
+               << " detector surfaces" << std::endl;
+            ss << "                 " << v.template n_objects<e_portal>()
+               << " detector portals" << std::endl;
+            if (v._surfaces_finder_entry != dindex_invalid) {
+                ss << "     finders idx " << v._surfaces_finder_entry
+                   << std::endl;
+            }
+            ss << "     bounds r = (" << v._bounds[0] << ", " << v._bounds[1]
+               << ")" << std::endl;
+            ss << "            z = (" << v._bounds[2] << ", " << v._bounds[3]
+               << ")" << std::endl;
+        }
+        return ss.str();
+    };
 
     private:
-        std::string _name = "unknown_detector";
+    std::string _name = "unknown_detector";
 
-        /** Contains the geometrical relations*/
-        vector_type<volume> _volumes = {};
+    /** Contains the geometrical relations*/
+    vector_type<volume> _volumes = {};
 
-        /** Keeps all of the transform data in contiguous memory*/
-        transform_store _transforms = {};
+    /** Keeps all of the transform data in contiguous memory*/
+    transform_store _transforms = {};
 
-        /** All surfaces and portals in the detector in contigous memory */
-        surface_container _surfaces = {};
-        portal_container _portals = {};
+    /** All surfaces and portals in the detector in contigous memory */
+    surface_container _surfaces = {};
+    portal_container _portals = {};
 
-        /** Surface and portal masks of the detector in contigous memory */
-        surface_mask_container _surface_masks = {};
-        portal_mask_container _portal_masks = {};
+    /** Surface and portal masks of the detector in contigous memory */
+    surface_mask_container _surface_masks = {};
+    portal_mask_container _portal_masks = {};
 
-        vector_type<surfaces_finder> _surfaces_finders;
+    vector_type<surfaces_finder> _surfaces_finders;
 
-        volume_grid _volume_grid = volume_grid(std::move(axis::irregular{{}}), std::move(axis::irregular{{}}));
-    };
+    volume_grid _volume_grid = volume_grid(std::move(axis::irregular{{}}),
+                                           std::move(axis::irregular{{}}));
+};
 
-}
+}  // namespace detray
diff --git a/core/include/core/intersection.hpp b/core/include/core/intersection.hpp
index 4be16e2cdc..3830470dbf 100644
--- a/core/include/core/intersection.hpp
+++ b/core/include/core/intersection.hpp
@@ -1,79 +1,67 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include "utils/indexing.hpp"
-
 #include <climits>
-#include <tuple>
 #include <optional>
+#include <tuple>
+
+#include "utils/indexing.hpp"
 
-namespace detray
-{
+namespace detray {
 
-    using point3 = __plugin::point3;
-    using vector3 = __plugin::vector3;
-    using point2 = __plugin::point2;    
+using point3 = __plugin::point3;
+using vector3 = __plugin::vector3;
+using point2 = __plugin::point2;
 
-    /** Intersection direction with respect to the
-     * normal of the surface
-     */
-    enum intersection_direction : int
-    {
-        e_undefined = -1, //!< the undefined direction at intersection
-        e_opposite = 0,   //!< opposite the surface normal at the intersection
-        e_along = 1       //!< along the surface normal at the intersection
-    };
+/** Intersection direction with respect to the
+ * normal of the surface
+ */
+enum intersection_direction : int {
+    e_undefined = -1,  //!< the undefined direction at intersection
+    e_opposite = 0,    //!< opposite the surface normal at the intersection
+    e_along = 1        //!< along the surface normal at the intersection
+};
 
-    /** Intersection status: outside, missed, insidem, hit ( w/o maks status) */
-    enum intersection_status : int
-    {
-        e_outside = -1, //!< surface hit but outside
-        e_missed = 0,   //!< surface missed
-        e_hit = 1,      //!< surface hit but status not checked
-        e_inside = 2    //!< surface hit and inside confirmed
-    };
+/** Intersection status: outside, missed, insidem, hit ( w/o maks status) */
+enum intersection_status : int {
+    e_outside = -1,  //!< surface hit but outside
+    e_missed = 0,    //!< surface missed
+    e_hit = 1,       //!< surface hit but status not checked
+    e_inside = 2     //!< surface hit and inside confirmed
+};
 
-    /** This templated class holds the intersection information
-     * 
-     * @tparam point3 is the type of global intsersection vector
-     * @tparam point2 is the type of the local intersection vector
-     * 
-     **/
-    struct intersection
-    {
+/** This templated class holds the intersection information
+ *
+ * @tparam point3 is the type of global intsersection vector
+ * @tparam point2 is the type of the local intersection vector
+ *
+ **/
+struct intersection {
 
-        scalar path = std::numeric_limits<scalar>::infinity();
-        point3 p3 = point3{std::numeric_limits<scalar>::infinity(),
-                           std::numeric_limits<scalar>::infinity(),
-                           std::numeric_limits<scalar>::infinity()};
+    scalar path = std::numeric_limits<scalar>::infinity();
+    point3 p3 = point3{std::numeric_limits<scalar>::infinity(),
+                       std::numeric_limits<scalar>::infinity(),
+                       std::numeric_limits<scalar>::infinity()};
 
-        point2 p2 = {std::numeric_limits<scalar>::infinity(),
-                     std::numeric_limits<scalar>::infinity()};
-        intersection_status status = e_missed;
-        intersection_direction direction = e_undefined;
-        dindex index = dindex_invalid;
-        dindex link = dindex_invalid;
+    point2 p2 = {std::numeric_limits<scalar>::infinity(),
+                 std::numeric_limits<scalar>::infinity()};
+    intersection_status status = e_missed;
+    intersection_direction direction = e_undefined;
+    dindex index = dindex_invalid;
+    dindex link = dindex_invalid;
 
-        /** @param rhs is the right hand side intersection for comparison 
-         **/
-        bool operator<(
-            const intersection& rhs) const
-        {
-            return (path < rhs.path);
-        }
+    /** @param rhs is the right hand side intersection for comparison
+     **/
+    bool operator<(const intersection &rhs) const { return (path < rhs.path); }
 
-        /** @param rhs is the left hand side intersection for comparison 
-         **/
-        bool operator>(
-            const intersection& rhs) const
-        {
-            return (path > rhs.path);
-        }
-    };
+    /** @param rhs is the left hand side intersection for comparison
+     **/
+    bool operator>(const intersection &rhs) const { return (path > rhs.path); }
+};
 
-} // namespace detray
\ No newline at end of file
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/core/surface_base.hpp b/core/include/core/surface_base.hpp
index 736e3b1c7d..03406f8687 100644
--- a/core/include/core/surface_base.hpp
+++ b/core/include/core/surface_base.hpp
@@ -1,108 +1,92 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include "utils/indexing.hpp"
 #include <memory>
 
-namespace detray
-{
-    /** Templated surface base class for detector surfaces and portals
-     * 
-     * @tparam transform_link the type of the transform/transform link for global 3D to local 3D frame
-     * @tparam mask_link the type of the mask/mask link representation
-     * @tparam volume_link the typ eof the volume/volume link representation
-     * @tparam source_link the type of the source/source link representation 
-     */
-    template <typename transform_link, typename mask_link = dindex, typename volume_link = dindex, typename source_link = bool>
-    class surface_base
-    {
-    public:
+#include "utils/indexing.hpp"
 
-        /** Constructor with full arguments - move semantics
-         * 
-         * @param trf the transform for positioning and 3D local frame 
-         * @param msk the mask/mask link for this surface 
-         * @param vol the volume link for this surface
-         * @param src the source object/source link this surface is representing
-         * 
-         **/
-        surface_base(transform_link &&trf, mask_link &&mask, volume_link &&vol, source_link &&src)
-            : _trf(std::move(trf)), _mask(std::move(mask)), _vol(std::move(vol)), _src(std::move(src))
-        {
-        }
+namespace detray {
+/** Templated surface base class for detector surfaces and portals
+ *
+ * @tparam transform_link the type of the transform/transform link for global 3D
+ * to local 3D frame
+ * @tparam mask_link the type of the mask/mask link representation
+ * @tparam volume_link the typ eof the volume/volume link representation
+ * @tparam source_link the type of the source/source link representation
+ */
+template <typename transform_link, typename mask_link = dindex,
+          typename volume_link = dindex, typename source_link = bool>
+class surface_base {
+    public:
+    /** Constructor with full arguments - move semantics
+     *
+     * @param trf the transform for positioning and 3D local frame
+     * @param msk the mask/mask link for this surface
+     * @param vol the volume link for this surface
+     * @param src the source object/source link this surface is representing
+     *
+     **/
+    surface_base(transform_link &&trf, mask_link &&mask, volume_link &&vol,
+                 source_link &&src)
+        : _trf(std::move(trf)),
+          _mask(std::move(mask)),
+          _vol(std::move(vol)),
+          _src(std::move(src)) {}
 
-        /** Constructor with full arguments - copy semantics
-         * 
-         * @param trf the transform for positioning and 3D local frame 
-         * @param msk the mask/mask link for this surface 
-         * @param vol the volume link for this surface
-         * @param src the source object/source link this surface is representing
-         * 
-         **/
-        surface_base(const transform_link &trf, const mask_link &mask, const volume_link &vol, const source_link &src)
-            : _trf(trf), _mask(mask), _vol(vol), _src(src)
-        {
-        }
+    /** Constructor with full arguments - copy semantics
+     *
+     * @param trf the transform for positioning and 3D local frame
+     * @param msk the mask/mask link for this surface
+     * @param vol the volume link for this surface
+     * @param src the source object/source link this surface is representing
+     *
+     **/
+    surface_base(const transform_link &trf, const mask_link &mask,
+                 const volume_link &vol, const source_link &src)
+        : _trf(trf), _mask(mask), _vol(vol), _src(src) {}
 
-        ~surface_base() = default;
-        surface_base(const surface_base &lhs) = default;
-        surface_base() = delete;
+    ~surface_base() = default;
+    surface_base(const surface_base &lhs) = default;
+    surface_base() = delete;
 
-        /** Equality operator 
-         * 
-         * @param rhs is the right hand side to be compared to 
-        */
-        bool operator==(const surface_base<transform_link, mask_link, source_link> &rhs) const
-        {
-            return (_trf == rhs.__trf and _mask == rhs._mask and _vol == rhs._vol and _src == rhs._src);
-        }
+    /** Equality operator
+     *
+     * @param rhs is the right hand side to be compared to
+     */
+    bool operator==(
+        const surface_base<transform_link, mask_link, source_link> &rhs) const {
+        return (_trf == rhs.__trf and _mask == rhs._mask and
+                _vol == rhs._vol and _src == rhs._src);
+    }
 
-        /** Return the transform type */
-        const transform_link &transform() const
-        {
-            return _trf;
-        }
+    /** Return the transform type */
+    const transform_link &transform() const { return _trf; }
 
-        /** Access to the mask  */
-        mask_link &mask()
-        {
-            return _mask;
-        }
+    /** Access to the mask  */
+    mask_link &mask() { return _mask; }
 
-        /** Return the mask */
-        const mask_link &mask() const
-        {
-            return _mask;
-        }
+    /** Return the mask */
+    const mask_link &mask() const { return _mask; }
 
-        /** Access to the volume */
-        volume_link &volume()
-        {
-            return _vol;
-        }
+    /** Access to the volume */
+    volume_link &volume() { return _vol; }
 
-        /** Return the mask */
-        const volume_link &volume() const
-        {
-            return _vol;
-        }
+    /** Return the mask */
+    const volume_link &volume() const { return _vol; }
 
-        /** Return the source/source link type */
-        const source_link &source() const
-        {
-            return _src;
-        }
+    /** Return the source/source link type */
+    const source_link &source() const { return _src; }
 
     private:
-        transform_link _trf;
-        mask_link _mask;
-        volume_link _vol;
-        source_link _src;
-    };
+    transform_link _trf;
+    mask_link _mask;
+    volume_link _vol;
+    source_link _src;
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/core/track.hpp b/core/include/core/track.hpp
index 7339e3ebaf..c23b9043f4 100644
--- a/core/include/core/track.hpp
+++ b/core/include/core/track.hpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
@@ -10,23 +10,21 @@
 #include <optional>
 #include <tuple>
 
-namespace detray
-{
+namespace detray {
 
-    /** Track struct for navigation through the detector */
-    template <typename context_type = bool>
-    struct track
-    {
-        using point3 = __plugin::point3;
-        using vector3 = __plugin::vector3;
+/** Track struct for navigation through the detector */
+template <typename context_type = bool>
+struct track {
+    using point3 = __plugin::point3;
+    using vector3 = __plugin::vector3;
 
-        point3 pos = {0., 0., 0.};
-        vector3 dir = {0., 0., 0.};
-        vector3 bfield = {0., 0., 0.};
-        scalar momentum = std::numeric_limits<scalar>::infinity();
-        context_type ctx;
+    point3 pos = {0., 0., 0.};
+    vector3 dir = {0., 0., 0.};
+    vector3 bfield = {0., 0., 0.};
+    scalar momentum = std::numeric_limits<scalar>::infinity();
+    context_type ctx;
 
-        scalar overstep_tolerance = 0.;
-    };
+    scalar overstep_tolerance = 0.;
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/core/transform_store.hpp b/core/include/core/transform_store.hpp
index ccc4a0e6e9..1b8c3db371 100644
--- a/core/include/core/transform_store.hpp
+++ b/core/include/core/transform_store.hpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
@@ -9,194 +9,186 @@
 #include "utils/enumerate.hpp"
 #include "utils/indexing.hpp"
 
-namespace detray
-{
+namespace detray {
 
-    using transform3 = __plugin::transform3;
+using transform3 = __plugin::transform3;
 
-    /** A static inplementation of an alignable transform store */
-    template < template <typename> class vector_type = dvector>
-    class static_transform_store
-    {
+/** A static inplementation of an alignable transform store */
+template <template <typename> class vector_type = dvector>
+class static_transform_store {
     public:
+    /** Elementwise access. Needs []operator for storage type for now */
+    inline decltype(auto) operator[](const dindex i) { return _data[i]; }
+    inline decltype(auto) operator[](const dindex i) const { return _data[i]; }
 
-        /** Elementwise access. Needs []operator for storage type for now */
-        inline decltype(auto) operator[](const dindex i) { return _data[i]; }
-        inline decltype(auto) operator[](const dindex i) const { return _data[i]; }
+    /** Empty context type struct */
+    struct context {};
 
-        /** Empty context type struct */
-        struct context
-        {
-        };
+    /** Helper struct to pass range and context */
+    template <typename range_iterator>
+    struct contextual_range {
+        using context = static_transform_store::context;
+        /*context ctx;*/
 
-        /** Helper struct to pass range and context */
-        template<typename range_iterator>
-        struct contextual_range {
-            using context = static_transform_store::context;
-            /*context ctx;*/
+        const range_iterator r;
 
-            const range_iterator r;
+        inline auto begin() { return r.begin(); }
+        inline auto end() { return r.end(); }
 
-            inline auto begin() { return r.begin(); }
-            inline auto end() { return r.end(); }
-
-            inline decltype(auto) operator[](const dindex i) { return *(r.begin() + i); }
-            inline decltype(auto) operator[](const dindex i) const { return *(r.begin() + i); }
-        };
-
-        using storage = vector_type<transform3>;
-
-        /** Forward iterator : Contextual STL like API
-         *
-         * @param ctx The context of the call (ignored)
-         */
-        auto begin(const context & /*ctx*/) const ->decltype(auto)
-        {
-            return _data.begin();
-        }
-
-        /** Forward iterator : Contextual STL like API
-         *
-         * @param ctx The context of the call (ignored)
-         */
-        auto end(const context & /*ctx*/) const ->decltype(auto)
-        {
-            return _data.end();
-        }
-
-        /** Access to a predefined range of elements
-         *
-         * @param start start index of rage
-         * @param end end index of rage
-         * @param ctx The context of the call (ignored)
-         *
-         * @return range restricted iterator
-         */
-        const inline auto range(const size_t begin, const size_t end, const context & ctx) const
-        {
-            return contextual_range<decltype(range_iter(_data, dindex_range{begin, end}))>{range_iter(_data, dindex_range{begin, end})};
+        inline decltype(auto) operator[](const dindex i) {
+            return *(r.begin() + i);
         }
-
-        /** Access to a predefined range of elements
-         *
-         * @param range index range in data store
-         * @param ctx The context of the call (ignored)
-         *
-         * @return range restricted iterator
-         */
-        const inline auto range(const dindex_range&& range, const context & ctx) const
-        {
-            return contextual_range<decltype(range_iter(_data, std::move(range)))>{range_iter(_data, std::move(range))};
-        }
-
-        /** Reserve memory : Contextual STL like API
-         *
-         * @param ctx The context of the call (ignored)
-         * @param tidx The size of the reserved container memory
-         */
-        void reserve(const context & /*ctx*/, size_t n_size)
-        {
-            _data.reserve(n_size);
-        }
-
-        /** Emplace back : Contextual STL like API
-         *
-         * @param ctx The context of the call (ignored)
-         * @param args Constructor arguments
-         */
-        template <class... Args>  
-        void emplace_back(const context & /*ctx*/, Args&&... args)
-        {
-            _data.emplace_back(std::forward<Args>(args)...);
-        }
-
-        /** Push back : Contextual STL like API, copy semantics
-         *
-         * @param ctx The context of the call (ignored)
-         * @param tcf The transform to be filled
-         */
-        void push_back(const context & /*ctx*/, const transform3 &tf)
-        {
-            _data.push_back(tf);
-        }
-
-        /** Push back : Contextual STL like API, move semantics
-         *
-         * @param ctx The context of the call (ignored)
-         * @param tcf The transform to be filled
-         */
-        void push_back(const context & /*ctx*/, const transform3 &&tf)
-        {
-            _data.push_back(std::move(tf));
-        }
-
-        /** Size : Contextual STL like API
-         * @param ctx The context of the call (ignored)
-         */ 
-        const size_t size(const context & /*ctx*/) const
-        {
-            return _data.size();
-        }
-
-        /** Empty : Contextual STL like API
-         * @param ctx The context of the call (ignored)
-         */
-        bool empty(const context & /*ctx*/)
-        {
-            return _data.empty();
-        }
-
-        /** Append a transform store to an existing one
-         *
-         * @param ctx The context of the call (ignored)
-         * @param other The transform store, move semantics
-         *
-         * @note in general can throw an exception
-         */
-        void append(const context & ctx, static_transform_store<vector_type> &&other) noexcept(false)
-        {
-            _data.reserve(_data.size() + other.size(ctx));
-            _data.insert(_data.end(), std::make_move_iterator(other.begin(ctx)), std::make_move_iterator(other.end(ctx)));
-        }
-
-        /** Add a new bunch of transforms for a new context - move semantics
-         *
-         * @param ctx The context of the call (ignored)
-         * @param trfs The transform container, move semantics
-         *
-         * @note in general can throw an exception
-         */
-        void add_contextual_transforms(const context & /*ctx*/, storage &&trfs) noexcept(false)
-        {
-            _data = std::move(trfs);
-        }
-
-        /** Append a bunch of transforms to existing context - move semantics
-         *
-         * @param ctx The context of the call (ignored)
-         * @param trfs The transform container, move semantics
-         *
-         * @note in general can throw an exception
-         */
-        void append_contextual_transforms(const context & /*ctx*/, storage &&trfs) noexcept(false)
-        {
-            _data.reserve(_data.size() + trfs.size());
-            _data.insert(_data.end(), std::make_move_iterator(trfs.begin()), std::make_move_iterator(trfs.end()));
+        inline decltype(auto) operator[](const dindex i) const {
+            return *(r.begin() + i);
         }
+    };
 
-        /** Get the contextual transform
-         *
-         * @param ctx The context of the call (ignored)
-         * @param tidx The transform index
-         */
-        const transform3 &contextual_transform(const context & /*ctx*/, dindex tidx) const
-        {
-            return _data[tidx];
-        }
+    using storage = vector_type<transform3>;
+
+    /** Forward iterator : Contextual STL like API
+     *
+     * @param ctx The context of the call (ignored)
+     */
+    auto begin(const context & /*ctx*/) const -> decltype(auto) {
+        return _data.begin();
+    }
+
+    /** Forward iterator : Contextual STL like API
+     *
+     * @param ctx The context of the call (ignored)
+     */
+    auto end(const context & /*ctx*/) const -> decltype(auto) {
+        return _data.end();
+    }
+
+    /** Access to a predefined range of elements
+     *
+     * @param start start index of rage
+     * @param end end index of rage
+     * @param ctx The context of the call (ignored)
+     *
+     * @return range restricted iterator
+     */
+    const inline auto range(const size_t begin, const size_t end,
+                            const context &ctx) const {
+        return contextual_range<decltype(
+            range_iter(_data, dindex_range{begin, end}))>{
+            range_iter(_data, dindex_range{begin, end})};
+    }
+
+    /** Access to a predefined range of elements
+     *
+     * @param range index range in data store
+     * @param ctx The context of the call (ignored)
+     *
+     * @return range restricted iterator
+     */
+    const inline auto range(const dindex_range &&range,
+                            const context &ctx) const {
+        return contextual_range<decltype(range_iter(_data, std::move(range)))>{
+            range_iter(_data, std::move(range))};
+    }
+
+    /** Reserve memory : Contextual STL like API
+     *
+     * @param ctx The context of the call (ignored)
+     * @param tidx The size of the reserved container memory
+     */
+    void reserve(const context & /*ctx*/, size_t n_size) {
+        _data.reserve(n_size);
+    }
+
+    /** Emplace back : Contextual STL like API
+     *
+     * @param ctx The context of the call (ignored)
+     * @param args Constructor arguments
+     */
+    template <class... Args>
+    void emplace_back(const context & /*ctx*/, Args &&... args) {
+        _data.emplace_back(std::forward<Args>(args)...);
+    }
+
+    /** Push back : Contextual STL like API, copy semantics
+     *
+     * @param ctx The context of the call (ignored)
+     * @param tcf The transform to be filled
+     */
+    void push_back(const context & /*ctx*/, const transform3 &tf) {
+        _data.push_back(tf);
+    }
+
+    /** Push back : Contextual STL like API, move semantics
+     *
+     * @param ctx The context of the call (ignored)
+     * @param tcf The transform to be filled
+     */
+    void push_back(const context & /*ctx*/, const transform3 &&tf) {
+        _data.push_back(std::move(tf));
+    }
+
+    /** Size : Contextual STL like API
+     * @param ctx The context of the call (ignored)
+     */
+    const size_t size(const context & /*ctx*/) const { return _data.size(); }
+
+    /** Empty : Contextual STL like API
+     * @param ctx The context of the call (ignored)
+     */
+    bool empty(const context & /*ctx*/) { return _data.empty(); }
+
+    /** Append a transform store to an existing one
+     *
+     * @param ctx The context of the call (ignored)
+     * @param other The transform store, move semantics
+     *
+     * @note in general can throw an exception
+     */
+    void append(const context &ctx,
+                static_transform_store<vector_type> &&other) noexcept(false) {
+        _data.reserve(_data.size() + other.size(ctx));
+        _data.insert(_data.end(), std::make_move_iterator(other.begin(ctx)),
+                     std::make_move_iterator(other.end(ctx)));
+    }
+
+    /** Add a new bunch of transforms for a new context - move semantics
+     *
+     * @param ctx The context of the call (ignored)
+     * @param trfs The transform container, move semantics
+     *
+     * @note in general can throw an exception
+     */
+    void add_contextual_transforms(const context & /*ctx*/,
+                                   storage &&trfs) noexcept(false) {
+        _data = std::move(trfs);
+    }
+
+    /** Append a bunch of transforms to existing context - move semantics
+     *
+     * @param ctx The context of the call (ignored)
+     * @param trfs The transform container, move semantics
+     *
+     * @note in general can throw an exception
+     */
+    void append_contextual_transforms(const context & /*ctx*/,
+                                      storage &&trfs) noexcept(false) {
+        _data.reserve(_data.size() + trfs.size());
+        _data.insert(_data.end(), std::make_move_iterator(trfs.begin()),
+                     std::make_move_iterator(trfs.end()));
+    }
+
+    /** Get the contextual transform
+     *
+     * @param ctx The context of the call (ignored)
+     * @param tidx The transform index
+     */
+    const transform3 &contextual_transform(const context & /*ctx*/,
+                                           dindex tidx) const {
+        return _data[tidx];
+    }
 
     private:
-        /** Common to surfaces & portals: transform store */
-        vector_type<transform3> _data;
-    };
+    /** Common to surfaces & portals: transform store */
+    vector_type<transform3> _data;
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/core/volume_connector.hpp b/core/include/core/volume_connector.hpp
index b681620f66..e06148a57a 100644
--- a/core/include/core/volume_connector.hpp
+++ b/core/include/core/volume_connector.hpp
@@ -1,294 +1,330 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-namespace detray
-{
-    /// Connector method for cylindrical volumes without phi separation
-    ///
-    /// @tparam detector_type is the type of the detector for the volume access
-    ///
-    /// @param d [in,out] the detector to which the portal surfaces are added
-    /// @param volume_grid [in] the indexed volume grid
-    ///
-    template <typename detector_type,
-              template <typename, unsigned int> class array_type = darray,
-              template <typename...> class tuple_type = dtuple,
-              template <typename> class vector_type = dvector>
-    void connect_cylindrical_volumes(detector_type &d, const typename detector_type::volume_grid &volume_grid)
-    {
-        typename detector_type::context default_context = {};
+namespace detray {
+/// Connector method for cylindrical volumes without phi separation
+///
+/// @tparam detector_type is the type of the detector for the volume access
+///
+/// @param d [in,out] the detector to which the portal surfaces are added
+/// @param volume_grid [in] the indexed volume grid
+///
+template <typename detector_type,
+          template <typename, unsigned int> class array_type = darray,
+          template <typename...> class tuple_type = dtuple,
+          template <typename> class vector_type = dvector>
+void connect_cylindrical_volumes(
+    detector_type &d, const typename detector_type::volume_grid &volume_grid) {
+    typename detector_type::context default_context = {};
 
-        // The grid is populated, now create portal surfaces
-        // Start from left bottom corner (0,0)
-        vector_type<array_type<dindex, 2>> seeds = {{0, 0}};
-        dmap<dindex, dindex> seed_map;
+    // The grid is populated, now create portal surfaces
+    // Start from left bottom corner (0,0)
+    vector_type<array_type<dindex, 2>> seeds = {{0, 0}};
+    dmap<dindex, dindex> seed_map;
 
-        // The axes are used quite a bit
-        const auto &axis_r = volume_grid.axis_p0();
-        const auto &axis_z = volume_grid.axis_p1();
+    // The axes are used quite a bit
+    const auto &axis_r = volume_grid.axis_p0();
+    const auto &axis_z = volume_grid.axis_p1();
 
-        /*** Helper function to add a new seed
-         * It checks for validity of the seed
-         * 
-         * @param seed the (potential new seed)
-         * @param volume_index the volume index for this seed
-         *        to avoid duplicate entries
-         * 
-         * @note seeds are only set in bottom left corners of blocks
-         **/
-        auto add_new_seed = [&](const array_type<dindex, 2> &seed, dindex volume_index) -> void
-        {
-            if (volume_index == dindex_invalid)
-            {
-                return;
-            }
+    /*** Helper function to add a new seed
+     * It checks for validity of the seed
+     *
+     * @param seed the (potential new seed)
+     * @param volume_index the volume index for this seed
+     *        to avoid duplicate entries
+     *
+     * @note seeds are only set in bottom left corners of blocks
+     **/
+    auto add_new_seed = [&](const array_type<dindex, 2> &seed,
+                            dindex volume_index) -> void {
+        if (volume_index == dindex_invalid) {
+            return;
+        }
 
-            if (seed_map.find(volume_index) != seed_map.end())
-            {
-                ++seed_map[volume_index];
-                return;
-            }
-            seed_map[volume_index] = 1;
+        if (seed_map.find(volume_index) != seed_map.end()) {
+            ++seed_map[volume_index];
+            return;
+        }
+        seed_map[volume_index] = 1;
 
-            if (seed[0] < axis_r.bins() and
-                seed[1] < axis_z.bins())
-            {
-                seeds.push_back(seed);
-            }
-        };
+        if (seed[0] < axis_r.bins() and seed[1] < axis_z.bins()) {
+            seeds.push_back(seed);
+        }
+    };
 
-        // Growing loop over the seeds, process to the end
-        for (dindex iseed = 0; iseed < seeds.size(); ++iseed)
-        {
-            // The running seed & the refence seed
-            auto seed = seeds[iseed];
-            const auto &ref = volume_grid.bin(seed[0], seed[1]);
+    // Growing loop over the seeds, process to the end
+    for (dindex iseed = 0; iseed < seeds.size(); ++iseed) {
+        // The running seed & the refence seed
+        auto seed = seeds[iseed];
+        const auto &ref = volume_grid.bin(seed[0], seed[1]);
 
-            // Build and add the portal surfaces
-            auto &volume = d.indexed_volume(ref);
+        // Build and add the portal surfaces
+        auto &volume = d.indexed_volume(ref);
 
-            // Collect portals per seed
-            vector_type<tuple_type<array_type<scalar, 2>, dindex>> left_portals_info;
-            vector_type<tuple_type<array_type<scalar, 2>, dindex>> upper_portals_info;
-            vector_type<tuple_type<array_type<scalar, 2>, dindex>> right_portals_info;
-            vector_type<tuple_type<array_type<scalar, 2>, dindex>> lower_portals_info;
+        // Collect portals per seed
+        vector_type<tuple_type<array_type<scalar, 2>, dindex>>
+            left_portals_info;
+        vector_type<tuple_type<array_type<scalar, 2>, dindex>>
+            upper_portals_info;
+        vector_type<tuple_type<array_type<scalar, 2>, dindex>>
+            right_portals_info;
+        vector_type<tuple_type<array_type<scalar, 2>, dindex>>
+            lower_portals_info;
 
-            /// Helper method for walking up along the bins
-            ///
-            /// @param start_bin is the start bin of the walk
-            /// @param portals_info is the container to collect for portals
-            /// @param peek is the peek direction in z
-            /// @param add_seed is a boolean whether new seeds should be added
-            ///
-            /// @return the end position of the the walk (inside position)
-            auto walk_up = [&](array_type<dindex, 2> start_bin,
-                               vector_type<tuple_type<array_type<scalar, 2>, dindex>> &portals_info,
-                               int peek,
-                               bool add_seed = false) -> array_type<dindex, 2>
-            {
-                auto running_bin = start_bin;
-                array_type<dindex, 2> last_added = {dindex_invalid, dindex_invalid};
-                // Test entry
-                auto test = volume_grid.bin(running_bin[0], running_bin[1]);
-                // Low/high
-                auto low = axis_r.borders(running_bin[0]);
-                auto high = axis_r.borders(running_bin[0]);
-                //  1 - Left walk up
-                // First peek to the to the left for portal desitnations
-                dindex last_portal_dest = (running_bin[1] > 0 and running_bin[1] < axis_r.bins()) ? volume_grid.bin(running_bin[0], running_bin[1] + peek) : dindex_invalid;
-                while ((ref == test) and ++running_bin[0] < axis_r.bins())
-                {
-                    high = axis_r.borders(running_bin[0]);
-                    test = (seed[0] + 1 < axis_r.bins()) ? volume_grid.bin(running_bin[0], running_bin[1]) : dindex_invalid;
-                    // Peek outside and see if the portal destination has changed
-                    dindex portal_dest = (running_bin[1] > 0 and running_bin[1] < axis_r.bins()) ? volume_grid.bin(running_bin[0], running_bin[1] + peek) : dindex_invalid;
-                    if (portal_dest != last_portal_dest)
-                    {
-                        // Record the boundary
-                        portals_info.push_back({{low[0], high[0]}, last_portal_dest});
-                        last_added = {running_bin[0] - 1, running_bin[1]};
-                        // low is the new high
-                        low = high;
-                        last_portal_dest = portal_dest;
-                    }
-                    high = axis_r.borders(running_bin[0]);
+        /// Helper method for walking up along the bins
+        ///
+        /// @param start_bin is the start bin of the walk
+        /// @param portals_info is the container to collect for portals
+        /// @param peek is the peek direction in z
+        /// @param add_seed is a boolean whether new seeds should be added
+        ///
+        /// @return the end position of the the walk (inside position)
+        auto walk_up =
+            [&](array_type<dindex, 2> start_bin,
+                vector_type<tuple_type<array_type<scalar, 2>, dindex>>
+                    &portals_info,
+                int peek, bool add_seed = false) -> array_type<dindex, 2> {
+            auto running_bin = start_bin;
+            array_type<dindex, 2> last_added = {dindex_invalid, dindex_invalid};
+            // Test entry
+            auto test = volume_grid.bin(running_bin[0], running_bin[1]);
+            // Low/high
+            auto low = axis_r.borders(running_bin[0]);
+            auto high = axis_r.borders(running_bin[0]);
+            //  1 - Left walk up
+            // First peek to the to the left for portal desitnations
+            dindex last_portal_dest =
+                (running_bin[1] > 0 and running_bin[1] < axis_r.bins())
+                    ? volume_grid.bin(running_bin[0], running_bin[1] + peek)
+                    : dindex_invalid;
+            while ((ref == test) and ++running_bin[0] < axis_r.bins()) {
+                high = axis_r.borders(running_bin[0]);
+                test = (seed[0] + 1 < axis_r.bins())
+                           ? volume_grid.bin(running_bin[0], running_bin[1])
+                           : dindex_invalid;
+                // Peek outside and see if the portal destination has changed
+                dindex portal_dest =
+                    (running_bin[1] > 0 and running_bin[1] < axis_r.bins())
+                        ? volume_grid.bin(running_bin[0], running_bin[1] + peek)
+                        : dindex_invalid;
+                if (portal_dest != last_portal_dest) {
+                    // Record the boundary
+                    portals_info.push_back(
+                        {{low[0], high[0]}, last_portal_dest});
+                    last_added = {running_bin[0] - 1, running_bin[1]};
+                    // low is the new high
+                    low = high;
+                    last_portal_dest = portal_dest;
                 }
+                high = axis_r.borders(running_bin[0]);
+            }
 
-                // First Potential new seed
-                if (add_seed)
-                {
-                    add_new_seed(running_bin, test);
-                }
-                // By this we undo the overstepping in the loop (either by grid boundary or ref/test fail)
-                high = axis_r.borders(--running_bin[0]);
-                if (last_added != running_bin)
-                {
-                    portals_info.push_back({{low[0], high[1]}, last_portal_dest});
-                }
+            // First Potential new seed
+            if (add_seed) {
+                add_new_seed(running_bin, test);
+            }
+            // By this we undo the overstepping in the loop (either by grid
+            // boundary or ref/test fail)
+            high = axis_r.borders(--running_bin[0]);
+            if (last_added != running_bin) {
+                portals_info.push_back({{low[0], high[1]}, last_portal_dest});
+            }
 
-                // The new position after walking is returned
-                return running_bin;
-            };
+            // The new position after walking is returned
+            return running_bin;
+        };
 
-            /// Helper method for walking up along the bins
-            ///
-            /// @param start_bin is the start bin of the walk
-            /// @param portals_info is the container to collect for portals
-            /// @param peek is the peek direction in z
-            /// @param add_seed is a boolean whether new seeds should be added
-            /// @param walk_only is a boolean whether to actually add boundaries or not
-            ///
-            /// @return the end position of the the walk (inside position)
-            auto walk_right = [&](const array_type<dindex, 2> &start_bin,
-                                  vector_type<tuple_type<array_type<scalar, 2>, dindex>> &portals_info,
-                                  int peek,
-                                  bool add_seed = false,
-                                  bool walk_only = false) -> array_type<dindex, 2>
-            {
-                auto running_bin = start_bin;
-                array_type<dindex, 2> last_added = {dindex_invalid, dindex_invalid};
+        /// Helper method for walking up along the bins
+        ///
+        /// @param start_bin is the start bin of the walk
+        /// @param portals_info is the container to collect for portals
+        /// @param peek is the peek direction in z
+        /// @param add_seed is a boolean whether new seeds should be added
+        /// @param walk_only is a boolean whether to actually add boundaries or
+        /// not
+        ///
+        /// @return the end position of the the walk (inside position)
+        auto walk_right =
+            [&](const array_type<dindex, 2> &start_bin,
+                vector_type<tuple_type<array_type<scalar, 2>, dindex>>
+                    &portals_info,
+                int peek, bool add_seed = false,
+                bool walk_only = false) -> array_type<dindex, 2> {
+            auto running_bin = start_bin;
+            array_type<dindex, 2> last_added = {dindex_invalid, dindex_invalid};
 
-                // Test, low and high at seed position
-                auto test = volume_grid.bin(running_bin[0], running_bin[1]);
-                // Low/high
-                auto low = axis_z.borders(running_bin[1]);
-                auto high = axis_z.borders(running_bin[1]);
+            // Test, low and high at seed position
+            auto test = volume_grid.bin(running_bin[0], running_bin[1]);
+            // Low/high
+            auto low = axis_z.borders(running_bin[1]);
+            auto high = axis_z.borders(running_bin[1]);
 
-                dindex last_portal_dest = (running_bin[0] < axis_r.bins()) ? volume_grid.bin(running_bin[0] + peek, running_bin[1]) : dindex_invalid;
+            dindex last_portal_dest =
+                (running_bin[0] < axis_r.bins())
+                    ? volume_grid.bin(running_bin[0] + peek, running_bin[1])
+                    : dindex_invalid;
 
-                // Seed setting loop as well
-                while (ref == test and (++running_bin[1]) < axis_z.bins())
-                {
-                    high = axis_z.borders(running_bin[1]);
-                    test = volume_grid.bin(running_bin[0], running_bin[1]);
-                    // Peek outside and see if the portal destination has changed
-                    dindex portal_dest = (running_bin[0] < axis_r.bins()) ? volume_grid.bin(running_bin[0] + peek, running_bin[1]) : dindex_invalid;
-                    if (portal_dest != last_portal_dest)
-                    {
-                        // Record the boundary
-                        if (not walk_only)
-                        {
-                            portals_info.push_back({{low[0], high[0]}, last_portal_dest});
-                            last_added = {running_bin[0], running_bin[1] - 1};
-                        }
-                        // low is the new high
-                        low = high;
-                        last_portal_dest = portal_dest;
-                        // That's a new seed right here, except for last one
-                        if (running_bin[1] < axis_z.bins() and add_seed)
-                        {
-                            add_new_seed({running_bin[0] + peek, running_bin[1]}, portal_dest);
-                        }
+            // Seed setting loop as well
+            while (ref == test and (++running_bin[1]) < axis_z.bins()) {
+                high = axis_z.borders(running_bin[1]);
+                test = volume_grid.bin(running_bin[0], running_bin[1]);
+                // Peek outside and see if the portal destination has changed
+                dindex portal_dest =
+                    (running_bin[0] < axis_r.bins())
+                        ? volume_grid.bin(running_bin[0] + peek, running_bin[1])
+                        : dindex_invalid;
+                if (portal_dest != last_portal_dest) {
+                    // Record the boundary
+                    if (not walk_only) {
+                        portals_info.push_back(
+                            {{low[0], high[0]}, last_portal_dest});
+                        last_added = {running_bin[0], running_bin[1] - 1};
+                    }
+                    // low is the new high
+                    low = high;
+                    last_portal_dest = portal_dest;
+                    // That's a new seed right here, except for last one
+                    if (running_bin[1] < axis_z.bins() and add_seed) {
+                        add_new_seed({running_bin[0] + peek, running_bin[1]},
+                                     portal_dest);
                     }
-                    high = axis_z.borders(running_bin[1]);
-                }
-                // By this we undo the overstepping (see above)
-                high = axis_z.borders(--running_bin[1]);
-                if (not walk_only and last_added != running_bin)
-                {
-                    portals_info.push_back({{low[0], high[1]}, last_portal_dest});
                 }
-                // The new bin position after walk
-                return running_bin;
-            };
+                high = axis_z.borders(running_bin[1]);
+            }
+            // By this we undo the overstepping (see above)
+            high = axis_z.borders(--running_bin[1]);
+            if (not walk_only and last_added != running_bin) {
+                portals_info.push_back({{low[0], high[1]}, last_portal_dest});
+            }
+            // The new bin position after walk
+            return running_bin;
+        };
+
+        // Walk up from the (initial) seed position
+        auto up_left = walk_up(seed, left_portals_info, true, -1);
+        // Walk to the right from the resulting upper position
+        walk_right(up_left, upper_portals_info, true, 1);
+        // Walk right from the (initial) seed position
+        auto bottom_right =
+            walk_right(seed, lower_portals_info, false, -1, seed[0] == 0);
+        // Walk up from the bottom right corner
+        walk_up(bottom_right, right_portals_info, false, 1);
 
-            // Walk up from the (initial) seed position
-            auto up_left = walk_up(seed, left_portals_info, true, -1);
-            // Walk to the right from the resulting upper position
-            walk_right(up_left, upper_portals_info, true, 1);
-            // Walk right from the (initial) seed position
-            auto bottom_right = walk_right(seed, lower_portals_info, false, -1, seed[0] == 0);
-            // Walk up from the bottom right corner
-            walk_up(bottom_right, right_portals_info, false, 1);
+        typename detector_type::portal_filling_container portals = {};
+        typename detector_type::portal_mask_container portal_masks;
+        typename detector_type::transform_container portal_transforms;
 
-            typename detector_type::portal_filling_container portals = {};
-            typename detector_type::portal_mask_container portal_masks;
-            typename detector_type::transform_container portal_transforms;
+        // The bounds can be used for the mask and transform information
+        const auto &volume_bounds = volume.bounds();
 
-            // The bounds can be used for the mask and transform information
-            const auto &volume_bounds = volume.bounds();
+        /** Helper lambda to build disc portals
+         *
+         * @param portals_info The volume_index
+         * @param bound_index The access for the boundary parameter
+         *
+         **/
+        auto add_disc_portals =
+            [&](vector_type<tuple_type<array_type<scalar, 2>, dindex>>
+                    &portals_info,
+                dindex bound_index) -> void {
+            // Fill in the left side portals
+            if (not portals_info.empty()) {
+                // The portal transfrom is given from the left
+                __plugin::vector3 _translation{0., 0.,
+                                               volume_bounds[bound_index]};
 
-            /** Helper lambda to build disc portals
-             * 
-             * @param portals_info The volume_index 
-             * @param bound_index The access for the boundary parameter
-             * 
-             **/
-            auto add_disc_portals = [&](vector_type<tuple_type<array_type<scalar, 2>, dindex>> &portals_info, dindex bound_index) -> void
-            {
-                // Fill in the left side portals
-                if (not portals_info.empty())
-                {
-                    // The portal transfrom is given from the left
-                    __plugin::vector3 _translation{0., 0., volume_bounds[bound_index]};
+                // Get the mask context group and fill it
+                auto &disc_portal_transforms =
+                    std::get<detector_type::portal_disc::mask_context>(
+                        portal_transforms);
+                auto &disc_portals =
+                    std::get<detector_type::portal_disc::mask_context>(portals);
+                auto &mask_group =
+                    std::get<detector_type::portal_disc::mask_context>(
+                        portal_masks);
 
-                    // Get the mask context group and fill it
-                    auto &disc_portal_transforms = std::get<detector_type::portal_disc::mask_context>(portal_transforms);
-                    auto &disc_portals = std::get<detector_type::portal_disc::mask_context>(portals);
-                    auto &mask_group   = std::get<detector_type::portal_disc::mask_context>(portal_masks);
-                    
-                    typename detector_type::portal_mask_index mask_index = {detector_type::portal_disc::mask_context, {mask_group.size(), mask_group.size()}};
-                    // Create a stub mask for every unique index
-                    for (auto &info_ : portals_info)
-                    {
-                        typename detector_type::portal_disc _portal_disc = {std::get<0>(info_), {std::get<1>(info_), dindex_invalid}};
-                        std::get<1>(mask_index)[1] = mask_group.size();
-                        mask_group.push_back(_portal_disc);
-                    }
-                    // Create the portal
-                    typename detector_type::portal _portal{disc_portal_transforms.size(default_context), mask_index, volume.index(), dindex_invalid};
-                    // Save the data
-                    disc_portals.push_back(std::move(_portal));
-                    disc_portal_transforms.emplace_back(default_context, _translation);
+                typename detector_type::portal_mask_index mask_index = {
+                    detector_type::portal_disc::mask_context,
+                    {mask_group.size(), mask_group.size()}};
+                // Create a stub mask for every unique index
+                for (auto &info_ : portals_info) {
+                    typename detector_type::portal_disc _portal_disc = {
+                        std::get<0>(info_),
+                        {std::get<1>(info_), dindex_invalid}};
+                    std::get<1>(mask_index)[1] = mask_group.size();
+                    mask_group.push_back(_portal_disc);
                 }
-            };
+                // Create the portal
+                typename detector_type::portal _portal{
+                    disc_portal_transforms.size(default_context), mask_index,
+                    volume.index(), dindex_invalid};
+                // Save the data
+                disc_portals.push_back(std::move(_portal));
+                disc_portal_transforms.emplace_back(default_context,
+                                                    _translation);
+            }
+        };
 
-            /** Helper lambda for cylindrical portals
-             * 
-             * @param portals_info 
-             * @param bound_index
-             **/
-            auto add_cylinder_portal = [&](vector_type<tuple_type<array_type<scalar, 2>, dindex>> &portals_info, dindex bound_index) -> void
-            {
-                // Fill in the upper side portals
-                if (not portals_info.empty())
-                {
-                    // Get the mask context group and fill it
-                    auto &cylinder_portal_transforms = std::get<detector_type::portal_cylinder::mask_context>(portal_transforms);
-                    auto &cylinder_portals = std::get<detector_type::portal_cylinder::mask_context>(portals);
-                    auto &mask_group   = std::get<detector_type::portal_cylinder::mask_context>(portal_masks);
+        /** Helper lambda for cylindrical portals
+         *
+         * @param portals_info
+         * @param bound_index
+         **/
+        auto add_cylinder_portal =
+            [&](vector_type<tuple_type<array_type<scalar, 2>, dindex>>
+                    &portals_info,
+                dindex bound_index) -> void {
+            // Fill in the upper side portals
+            if (not portals_info.empty()) {
+                // Get the mask context group and fill it
+                auto &cylinder_portal_transforms =
+                    std::get<detector_type::portal_cylinder::mask_context>(
+                        portal_transforms);
+                auto &cylinder_portals =
+                    std::get<detector_type::portal_cylinder::mask_context>(
+                        portals);
+                auto &mask_group =
+                    std::get<detector_type::portal_cylinder::mask_context>(
+                        portal_masks);
 
-                    typename detector_type::portal_mask_index mask_index = {detector_type::portal_cylinder::mask_context, {mask_group.size(), mask_group.size()}};
-                    for (auto &info_ : portals_info)
-                    {
-                        const auto cylinder_range = std::get<0>(info_);
-                        array_type<scalar, 3> cylinder_bounds = {volume_bounds[bound_index], cylinder_range[0], cylinder_range[1]};
-                        typename detector_type::portal_cylinder _portal_cylinder = {cylinder_bounds, {std::get<1>(info_), dindex_invalid}};
-                        std::get<1>(mask_index)[1] = mask_group.size();
-                        mask_group.push_back(_portal_cylinder);
-                    }
-                    // Create the portal
-                    typename detector_type::portal _portal{cylinder_portal_transforms.size(default_context), mask_index, volume.index(), dindex_invalid};
-                    cylinder_portals.push_back(std::move(_portal));
-                    // This will be concentric targetted at nominal center
-                    cylinder_portal_transforms.emplace_back(default_context);
+                typename detector_type::portal_mask_index mask_index = {
+                    detector_type::portal_cylinder::mask_context,
+                    {mask_group.size(), mask_group.size()}};
+                for (auto &info_ : portals_info) {
+                    const auto cylinder_range = std::get<0>(info_);
+                    array_type<scalar, 3> cylinder_bounds = {
+                        volume_bounds[bound_index], cylinder_range[0],
+                        cylinder_range[1]};
+                    typename detector_type::portal_cylinder _portal_cylinder = {
+                        cylinder_bounds, {std::get<1>(info_), dindex_invalid}};
+                    std::get<1>(mask_index)[1] = mask_group.size();
+                    mask_group.push_back(_portal_cylinder);
                 }
-            };
+                // Create the portal
+                typename detector_type::portal _portal{
+                    cylinder_portal_transforms.size(default_context),
+                    mask_index, volume.index(), dindex_invalid};
+                cylinder_portals.push_back(std::move(_portal));
+                // This will be concentric targetted at nominal center
+                cylinder_portal_transforms.emplace_back(default_context);
+            }
+        };
 
-            // Add portals to the volume
-            add_disc_portals(left_portals_info, 2);
-            add_cylinder_portal(upper_portals_info, 1);
-            add_disc_portals(right_portals_info, 3);
-            add_cylinder_portal(lower_portals_info, 0);
+        // Add portals to the volume
+        add_disc_portals(left_portals_info, 2);
+        add_cylinder_portal(upper_portals_info, 1);
+        add_disc_portals(right_portals_info, 3);
+        add_cylinder_portal(lower_portals_info, 0);
 
-            // Add portals to detector
-            d.template add_objects<detector_type::e_portal>(volume, portals, portal_masks, portal_transforms, default_context);
-        }
+        // Add portals to detector
+        d.template add_objects<detector_type::e_portal>(
+            volume, portals, portal_masks, portal_transforms, default_context);
     }
 }
+}  // namespace detray
diff --git a/core/include/grids/associator.hpp b/core/include/grids/associator.hpp
index 07fe9f8620..7a332e12f2 100644
--- a/core/include/grids/associator.hpp
+++ b/core/include/grids/associator.hpp
@@ -1,151 +1,147 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-#include <vector>
 #include <climits>
+#include <vector>
 
-namespace detray
-{
-
-    using point2 = __plugin::point2;
-
-    /** Struct that assigns the center of gravity to a rectangular bin */
-    struct center_of_gravity_rectangle
-    {
-        /** Call operator to the struct, allows to chain several chain operators together
-         * 
-         * @param bin_contour The contour description of the bin -> target
-         * @param surface_contour The contour description of the surface -> test
-         * 
-         * @note the bin_contour is asummed to be a rectangle
-         * 
-         * @return whether this should be associated
-         */
-        bool operator()(const std::vector<point2> &bin_contour, const std::vector<point2> &surface_contour)
-        {
-            // Check if centre of gravity is inside bin
-            point2 cgs = {0., 0.};
-            for (const auto &svtx : surface_contour)
-            {
-                cgs = cgs + svtx;
-            }
-            cgs = 1. / surface_contour.size() * cgs;
-            scalar min_l0 = std::numeric_limits<scalar>::max();
-            scalar max_l0 = -std::numeric_limits<scalar>::max();
-            scalar min_l1 = std::numeric_limits<scalar>::max();
-            scalar max_l1 = -std::numeric_limits<scalar>::max();
-            for (const auto &b : bin_contour)
-            {
-                min_l0 = std::min(b[0], min_l0);
-                max_l0 = std::max(b[0], max_l0);
-                min_l1 = std::min(b[1], min_l1);
-                max_l1 = std::max(b[1], max_l1);
-            }
+namespace detray {
+
+using point2 = __plugin::point2;
+
+/** Struct that assigns the center of gravity to a rectangular bin */
+struct center_of_gravity_rectangle {
+    /** Call operator to the struct, allows to chain several chain operators
+     * together
+     *
+     * @param bin_contour The contour description of the bin -> target
+     * @param surface_contour The contour description of the surface -> test
+     *
+     * @note the bin_contour is asummed to be a rectangle
+     *
+     * @return whether this should be associated
+     */
+    bool operator()(const std::vector<point2> &bin_contour,
+                    const std::vector<point2> &surface_contour) {
+        // Check if centre of gravity is inside bin
+        point2 cgs = {0., 0.};
+        for (const auto &svtx : surface_contour) {
+            cgs = cgs + svtx;
+        }
+        cgs = 1. / surface_contour.size() * cgs;
+        scalar min_l0 = std::numeric_limits<scalar>::max();
+        scalar max_l0 = -std::numeric_limits<scalar>::max();
+        scalar min_l1 = std::numeric_limits<scalar>::max();
+        scalar max_l1 = -std::numeric_limits<scalar>::max();
+        for (const auto &b : bin_contour) {
+            min_l0 = std::min(b[0], min_l0);
+            max_l0 = std::max(b[0], max_l0);
+            min_l1 = std::min(b[1], min_l1);
+            max_l1 = std::max(b[1], max_l1);
+        }
 
-            if (cgs[0] >= min_l0 and cgs[0] < max_l0 and cgs[1] >= min_l1 and cgs[1] < max_l1)
-            {
-                return true;
-            }
+        if (cgs[0] >= min_l0 and cgs[0] < max_l0 and cgs[1] >= min_l1 and
+            cgs[1] < max_l1) {
+            return true;
+        }
 
-            return false;
+        return false;
+    }
+};
+
+/** Check if center of mass is inside a generic polygon bin */
+struct center_of_gravity_generic {
+    /** Call operator to the struct, allows to chain several chain operators
+     * together
+     *
+     * @param bin_contour The contour description of the bin -> target
+     * @param surface_contour The contour description of the surface -> test
+     *
+     * @return whether this should be associated
+     */
+    bool operator()(const std::vector<point2> &bin_contour,
+                    const std::vector<point2> &surface_contour) {
+        // Check if centre of gravity is inside bin
+        point2 cgs = {0., 0.};
+        for (const auto &svtx : surface_contour) {
+            cgs = cgs + svtx;
         }
-    };
-
-    /** Check if center of mass is inside a generic polygon bin */
-    struct center_of_gravity_generic
-    {
-        /** Call operator to the struct, allows to chain several chain operators together
-        * 
-        * @param bin_contour The contour description of the bin -> target
-        * @param surface_contour The contour description of the surface -> test
-        * 
-        * @return whether this should be associated
-         */
-        bool operator()(const std::vector<point2> &bin_contour, const std::vector<point2> &surface_contour)
-        {
-            // Check if centre of gravity is inside bin
-            point2 cgs = {0., 0.};
-            for (const auto &svtx : surface_contour)
-            {
-                cgs = cgs + svtx;
-            }
-            cgs = 1. / surface_contour.size() * cgs;
-
-            size_t i, j = 0;
-            size_t num_points = bin_contour.size();
-
-            bool inside = false;
-            for (i = 0, j = num_points - 1; i < num_points; j = i++)
-            {
-                const auto &pi = bin_contour[i];
-                const auto &pj = bin_contour[j];
-                if ((((pi[1] <= cgs[1]) and (cgs[1] < pj[1])) or
-                     ((pj[1] <= cgs[1]) and (cgs[1] < pi[1]))) and
-                    (cgs[0] < (pj[0] - pi[0]) * (cgs[1] - pi[1]) / (pj[1] - pi[1]) + pi[0]))
-                    inside = !inside;
-            }
-            return inside;
+        cgs = 1. / surface_contour.size() * cgs;
+
+        size_t i, j = 0;
+        size_t num_points = bin_contour.size();
+
+        bool inside = false;
+        for (i = 0, j = num_points - 1; i < num_points; j = i++) {
+            const auto &pi = bin_contour[i];
+            const auto &pj = bin_contour[j];
+            if ((((pi[1] <= cgs[1]) and (cgs[1] < pj[1])) or
+                 ((pj[1] <= cgs[1]) and (cgs[1] < pi[1]))) and
+                (cgs[0] <
+                 (pj[0] - pi[0]) * (cgs[1] - pi[1]) / (pj[1] - pi[1]) + pi[0]))
+                inside = !inside;
         }
-    };
-
-     /** Check if the egdes of the bin and surface contour overlap */
-    struct edges_intersect_generic
-    {
-
-        /** Call operator to the struct, allows to chain several chain operators together
-       * 
-       * @param bin_contour The contour description of the bin -> target
-       * @param surface_contour The contour description of the surface -> test
-       * 
-       * @return whether this should be associated
-       */
-        bool operator()(const std::vector<point2> &bin_contour, const std::vector<point2> &surface_contour)
-        {
-
-            auto intersect = [](const point2 &pi, const point2 &pj, const point2 &pk, const point2 &pl) -> bool
-            {
-                scalar d = (pj[0] - pi[0]) * (pl[1] - pk[1]) - (pj[1] - pi[1]) * (pl[0] - pk[0]);
-
-                if (d != 0.)
-                {
-                    double r = ((pi[1] - pk[1]) * (pl[0] - pk[0]) - (pi[0] - pk[0]) * (pl[1] - pk[1])) / d;
-                    double s = ((pi[1] - pk[1]) * (pj[0] - pi[0]) - (pi[0] - pk[0]) * (pj[1] - pi[1])) / d;
-                    if (r >= 0. and r <= 1. and s >= 0. and s <= 1.)
-                    {
-                        return true;
-                    }
-                }
-                return false;
-            };
-
-            // Loop over bin_contour
-            for (size_t j = 1; j <= bin_contour.size(); ++j)
-            {
-                size_t i = j - 1;
-                size_t jc = (j == bin_contour.size()) ? 0 : j;
-                const auto &pi = bin_contour[i];
-                const auto &pj = bin_contour[jc];
-                // Loop over surface_contour
-                for (size_t k = 1; k <= surface_contour.size(); ++k)
-                {
-                    size_t l = k - 1;
-                    size_t kc = (k == surface_contour.size()) ? 0 : k;
-                    const auto &pl = surface_contour[l];
-                    const auto &pk = surface_contour[kc];
-                    if (intersect(pi, pj, pk, pl))
-                    {
-                        return true;
-                    }
+        return inside;
+    }
+};
+
+/** Check if the egdes of the bin and surface contour overlap */
+struct edges_intersect_generic {
+
+    /** Call operator to the struct, allows to chain several chain operators
+     * together
+     *
+     * @param bin_contour The contour description of the bin -> target
+     * @param surface_contour The contour description of the surface -> test
+     *
+     * @return whether this should be associated
+     */
+    bool operator()(const std::vector<point2> &bin_contour,
+                    const std::vector<point2> &surface_contour) {
+
+        auto intersect = [](const point2 &pi, const point2 &pj,
+                            const point2 &pk, const point2 &pl) -> bool {
+            scalar d = (pj[0] - pi[0]) * (pl[1] - pk[1]) -
+                       (pj[1] - pi[1]) * (pl[0] - pk[0]);
+
+            if (d != 0.) {
+                double r = ((pi[1] - pk[1]) * (pl[0] - pk[0]) -
+                            (pi[0] - pk[0]) * (pl[1] - pk[1])) /
+                           d;
+                double s = ((pi[1] - pk[1]) * (pj[0] - pi[0]) -
+                            (pi[0] - pk[0]) * (pj[1] - pi[1])) /
+                           d;
+                if (r >= 0. and r <= 1. and s >= 0. and s <= 1.) {
+                    return true;
                 }
             }
             return false;
+        };
+
+        // Loop over bin_contour
+        for (size_t j = 1; j <= bin_contour.size(); ++j) {
+            size_t i = j - 1;
+            size_t jc = (j == bin_contour.size()) ? 0 : j;
+            const auto &pi = bin_contour[i];
+            const auto &pj = bin_contour[jc];
+            // Loop over surface_contour
+            for (size_t k = 1; k <= surface_contour.size(); ++k) {
+                size_t l = k - 1;
+                size_t kc = (k == surface_contour.size()) ? 0 : k;
+                const auto &pl = surface_contour[l];
+                const auto &pk = surface_contour[kc];
+                if (intersect(pi, pj, pk, pl)) {
+                    return true;
+                }
+            }
         }
-    };
+        return false;
+    }
+};
 
-} // namespace detray
\ No newline at end of file
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/grids/axis.hpp b/core/include/grids/axis.hpp
index 55abb5c562..aca85c138b 100644
--- a/core/include/grids/axis.hpp
+++ b/core/include/grids/axis.hpp
@@ -1,450 +1,434 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-#include "utils/indexing.hpp"
-
 #include <algorithm>
 
-namespace detray
-{
-
-    namespace axis
-    {
-        /** A regular closed axis.
-         * 
-         * The axis is closed, i.e. each underflow bin is mapped to 0
-         * and henceforth each overflow bin is mapped to bins-1
-         */
-        template <template <typename, unsigned int> class array_type = darray,
-                  template <typename> class vector_type = dvector>
-        struct regular
-        {
-            dindex n_bins;
-            scalar min;
-            scalar max;
-
-            static constexpr unsigned int axis_identifier = 0;
-
-            /** Return the number of bins */
-            dindex bins() const { return n_bins; }
-
-            /** Access function to a single bin from a value v
-             * 
-             * @param v is the value for the bin search
-             * 
-             * As the axis is closed it @returns a dindex type
-             **/
-            dindex bin(scalar v) const
-            {
-                int ibin = static_cast<int>((v - min) / (max - min) * n_bins);
-                return (ibin >= 0 and ibin < n_bins) ? static_cast<dindex>(ibin)
-                       : ibin < 0                    ? 0
-                                                     : static_cast<dindex>(n_bins - 1);
-            }
-
-            /** Access function to a range with binned neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (in #bins)
-             * 
-             * As the axis is closed it @returns a dindex_range
-             **/
-            dindex_range range(scalar v, const array_type<dindex, 2> &nhood = {0u, 0u}) const
-            {
-
-                int ibin = static_cast<int>((v - min) / (max - min) * n_bins);
-                int ibinmin = ibin - static_cast<int>(nhood[0]);
-                int ibinmax = ibin + static_cast<int>(nhood[1]);
-                dindex min_bin = (ibinmin >= 0) ? static_cast<dindex>(ibinmin) : 0;
-                dindex max_bin = (ibinmax < static_cast<int>(n_bins)) ? static_cast<dindex>(ibinmax) : static_cast<dindex>(n_bins - 1);
-                return {min_bin, max_bin};
-            }
-
-            /** Access function to a range with scalar neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (scalar)
-             * 
-             * As the axis is closed it @returns a dindex_range
-             **/
-            dindex_range range(scalar v, const array_type<scalar, 2> &nhood) const
-            {
-                int nbin = static_cast<int>((v - nhood[0] - min) / (max - min) * n_bins);
-                int pbin = static_cast<int>((v + nhood[1] - min) / (max - min) * n_bins);
-                dindex min_bin = (nbin >= 0) ? static_cast<dindex>(nbin) : 0;
-                dindex max_bin = (pbin < static_cast<int>(n_bins)) ? static_cast<dindex>(pbin) : static_cast<dindex>(n_bins - 1);
-                return {min_bin, max_bin};
-            }
-
-            /** Access function to a zone with binned neighborhood
-             * 
-             * 
-             * @tparam neighbor_t is the neighborhood size
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (in #bins)
-             * 
-             * As the axis is closed it @returns a dindex_sequence
-             **/
-            template <typename neighbor_t>
-            dindex_sequence zone_t(scalar v, const array_type<neighbor_t, 2> &nhood) const
-            {
-                dindex_range nh_range = range(v, nhood);
-                dindex_sequence sequence(static_cast<dindex_sequence::size_type>(nh_range[1] - nh_range[0] + 1), nh_range[0]);
-                dindex m = 0;
-                std::for_each(sequence.begin(), sequence.end(), [&](auto &n)
-                              { n += m++; });
-                return sequence;
-            }
-
-            /** Access function to a zone with binned neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (#bins) 
-             * 
-             * As the axis is closed it @returns a dindex_sequence
-             **/
-            dindex_sequence zone(scalar v, const array_type<dindex, 2> &nhood) const
-            {
-                return zone_t<dindex>(v, nhood);
-            }
-
-            /** Access function to a zone with scalar neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (scalar) 
-             * 
-             * As the axis is closed it @returns a dindex_sequence
-             **/
-            dindex_sequence zone(scalar v, const array_type<scalar, 2> &nhood) const
-            {
-                return zone_t<scalar>(v, nhood);
-            }
-
-            /** @return the bin boundaries for a given @param ibin */
-            array_type<scalar, 2> borders(dindex ibin) const
-            {
-                scalar step = (max - min) / n_bins;
-                return {min + ibin * step, min + (ibin + 1) * step};
-            }
-
-            /** @return the values of the borders */
-            vector_type<scalar> all_borders() const
-            {
-                vector_type<scalar> borders;
-                borders.reserve(n_bins + 1);
-                scalar step = (max - min) / n_bins;
-                for (dindex ib = 0; ib < n_bins + 1; ++ib)
-                {
-                    borders.push_back(min + ib * step);
-                }
-                return borders;
-            }
-
-            /** @return the axis span [min, max) */
-            array_type<scalar, 2> span() const { return {min, max}; }
-        };
-
-        /** A regular circular axis.
-         * 
-         * The axis is circular, i.e. the underflow bins map into the circular sequence
-         */
-        template <template <typename, unsigned int> class array_type = darray,
-                  template <typename> class vector_type = dvector>
-        struct circular
-        {
-
-            dindex n_bins;
-            scalar min;
-            scalar max;
-
-            static constexpr unsigned int axis_identifier = 1;
-
-            /** Return the number of bins */
-            dindex bins() const { return n_bins; }
-
-            /** Access function to a single bin from a value v
-             * 
-             * @param v is the value for the bin search
-             * 
-             * As the axis is closed it @returns a dindex type
-             **/
-            dindex bin(scalar v) const
-            {
-                dindex ibin = static_cast<dindex>((v - min) / (max - min) * n_bins);
-                return (ibin >= 0 and ibin < n_bins) ? static_cast<dindex>(ibin)
-                       : ibin < 0                    ? static_cast<dindex>(n_bins + ibin)
-                                                     : static_cast<dindex>(ibin - n_bins);
-            }
-
-            /** Access function to a range with binned neighborhood
-             *               
-             * @param v is the value for the bin search
-             * @param nhood is the  neighborhood range (in #bins) 
-             * 
-             * As the axis is circular it @returns a dindex_range
-             **/
-            dindex_range range(scalar v, const array_type<dindex, 2> nhood = {0u, 0u}) const
-            {
-                dindex gbin = bin(v);
-                dindex min_bin = remap(gbin, -static_cast<int>(nhood[0]));
-                dindex max_bin = remap(gbin, static_cast<int>(nhood[1]));
-                return {min_bin, max_bin};
-            }
-
-            /** Access function to a range with scalar neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (scalar) 
-             * 
-             * As the axis is circular it @returns a dindex_range
-             **/
-            dindex_range range(scalar v, const array_type<scalar, 2> &nhood) const
-            {
-                dindex nbin = bin(v - nhood[0]);
-                dindex pbin = bin(v + nhood[1]);
-                return {nbin, pbin};
-            }
-
-            /** Access function to a zone with binned/scalar neighborhood
-             * 
-             * @tparam neighbor_t is the neighborhood size
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (in #bins/scalar) 
-             * 
-             * As the axis is closed it @returns a dindex_sequence
-             **/
-            template <typename neighbor_t>
-            dindex_sequence zone_t(scalar v, const array_type<neighbor_t, 2> &nhood) const
-            {
-                dindex_range nh_range = range(v, nhood);
-                if (nh_range[0] < nh_range[1])
-                {
-                    dindex_sequence sequence(static_cast<dindex_sequence::size_type>(nh_range[1] - nh_range[0] + 1), nh_range[0]);
-                    dindex m = 0;
-                    std::for_each(sequence.begin(), sequence.end(), [&](auto &n)
-                                  { n += m++; });
-                    return sequence;
-                }
-                dindex vl = static_cast<dindex>(n_bins - nh_range[0] + nh_range[1] + 1);
-                dindex mi = 0;
-                dindex mo = 0;
-                dindex_sequence sequence(static_cast<dindex_sequence::size_type>(vl), nh_range[0]);
-                std::for_each(sequence.begin(), sequence.end(), [&](auto &n)
-                              {
-                                  n += mi++;
-                                  if (n > n_bins - 1)
-                                  {
-                                      n = mo++;
-                                  }
-                              });
-                return sequence;
-            }
-
-            /** Access function to a zone with binned neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (#bins) 
-             * 
-             * As the axis is closed it @returns a dindex_sequence
-             **/
-            dindex_sequence zone(scalar v, const array_type<dindex, 2> &nhood) const
-            {
-                return zone_t<dindex>(v, nhood);
-            }
-
-            /** Access function to a zone with scalar neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (scalar) 
-             * 
-             * As the axis is closed it @returns a dindex_sequence
-             **/
-            dindex_sequence zone(scalar v, const array_type<scalar, 2> &nhood) const
-            {
-                return zone_t<scalar>(v, nhood);
-            }
-
-            /** Helper function to remap onto a circular range 
-             * 
-             * @param ibin is the optional binning value
-             * @param shood is the sided neighbour hood
-             * 
-             * @return an index, remapped bin 
-             **/
-            dindex remap(dindex ibin, int shood) const
-            {
-                int opt_bin = static_cast<int>(ibin) + shood;
-                if (opt_bin >= 0 and opt_bin < n_bins)
-                {
-                    return static_cast<dindex>(opt_bin);
-                }
-                if (opt_bin < 0)
-                {
-                    return static_cast<dindex>(n_bins + opt_bin);
-                }
-                return static_cast<dindex>(opt_bin - n_bins);
-            }
-
-            /** @return the bin boundaries for a given @param ibin */
-            array_type<scalar, 2> borders(dindex ibin) const
-            {
-                scalar step = (max - min) / n_bins;
-                return {min + ibin * step, min + (ibin + 1) * step};
-            }
-
-            /** @return the values of the borders */
-            vector_type<scalar> all_borders() const
-            {
-                vector_type<scalar> borders;
-                borders.reserve(n_bins + 1);
-                scalar step = (max - min) / n_bins;
-                for (dindex ib = 0; ib < n_bins + 1; ++ib)
-                {
-                    borders.push_back(min + ib * step);
-                }
-                return borders;
-            }
-
-            /** @return the range  */
-            array_type<scalar, 2> span() const { return {min, max}; }
-        };
-
-        /** An iregular circular axis.
-         * 
-         * The axis is closed, i.e. the underflow is mapped into the first,
-         * the overflow is mapped into the last.
-         */
-        template <template <typename, unsigned int> class array_type = darray,
-                  template <typename> class vector_type = dvector>
-        struct irregular
-        {
-
-            vector_type<scalar> boundaries;
-
-            static constexpr unsigned int axis_identifier = 2;
-
-            /** Return the number of bins */
-            dindex bins() const { return static_cast<dindex>(boundaries.size() - 1); }
-
-            /** Access function to a single bin from a value v
-             * 
-             * @param v is the value for the bin search
-             * 
-             * As the axis is closed it @returns a dindex type
-             **/
-            dindex bin(scalar v) const
-            {
-                dindex ibin = std::lower_bound(boundaries.begin(), boundaries.end(), v) - boundaries.begin();
-                return ((ibin > 0 and ibin < boundaries.size()) ? --ibin : (ibin == 0) ? ibin
-                                                                                       : boundaries.size() - 2);
-            }
-
-            /** Access function to a range with binned neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (#bins) 
-             * 
-             * As the axis is closed it @returns a dindex_range
-             **/
-            dindex_range range(scalar v, const array_type<dindex, 2> &nhood = {0u, 0u}) const
-            {
-
-                dindex ibin = bin(v);
-                int bins = boundaries.size() - 1;
-                int ibinmin = ibin - static_cast<int>(nhood[0]);
-                int ibinmax = ibin + static_cast<int>(nhood[1]);
-                dindex min_bin = (ibinmin >= 0) ? static_cast<dindex>(ibinmin) : 0;
-                dindex max_bin = (ibinmax < static_cast<int>(bins)) ? static_cast<dindex>(ibinmax) : static_cast<dindex>(bins - 1);
-                return {min_bin, max_bin};
-            }
-
-            /** Access function to a range with scalar neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (scalar) 
-             * 
-             * As the axis is closed it @returns a dindex_range
-             **/
-            dindex_range range(scalar v, const array_type<scalar, 2> &nhood) const
-            {
-                dindex nbin = bin(v - nhood[0]);
-                dindex pbin = bin(v + nhood[1]);
-                return {nbin, pbin};
-            }
-
-            /** Access function to a zone with binned/scalar neighborhood
-             * 
-             * @tparam neighbor_t is the neighborhood type
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (binned/scalar)
-             * 
-             * As the axis is closed it @returns a dindex_sequence
-             **/
-            template <typename neighbor_t>
-            dindex_sequence zone_t(scalar v, const array_type<neighbor_t, 2> nhood) const
-            {
-                dindex_range nh_range = range(v, nhood);
-                dindex_sequence sequence(static_cast<dindex_sequence::size_type>(nh_range[1] - nh_range[0] + 1), nh_range[0]);
-                dindex m = 0;
-                std::for_each(sequence.begin(), sequence.end(), [&](auto &n)
-                              { n += m++; });
-                return sequence;
-            }
-
-            /** Access function to a zone with binned neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (#bins) 
-             * 
-             * As the axis is closed it @returns a dindex_sequence
-             **/
-            dindex_sequence zone(scalar v, const array_type<dindex, 2> &nhood = {0, 0}) const
-            {
-                return zone_t<dindex>(v, nhood);
-            }
-
-            /** Access function to a zone with scalar neighborhood
-             * 
-             * @param v is the value for the bin search
-             * @param nhood is the neighborhood range (scalar) 
-             * 
-             * As the axis is closed it @returns a dindex_sequence
-             **/
-            dindex_sequence zone(scalar v, const array_type<scalar, 2> &nhood) const
-            {
-                return zone_t<scalar>(v, nhood);
-            }
-
-            /** @return the bin boundaries for a given @param ibin */
-            array_type<scalar, 2> borders(dindex ibin) const
-            {
-                return {boundaries[ibin], boundaries[ibin + 1]};
-            }
-
+#include "utils/indexing.hpp"
 
-            /** @return the values of the borders of all bins */
-            vector_type<scalar> all_borders() const
-            {
-                return boundaries;
-            }
+namespace detray {
 
-            /** @return the range  */
-            array_type<scalar, 2>
-            span() const
-            {
-                return {boundaries[0], boundaries[boundaries.size() - 1]};
+namespace axis {
+/** A regular closed axis.
+ *
+ * The axis is closed, i.e. each underflow bin is mapped to 0
+ * and henceforth each overflow bin is mapped to bins-1
+ */
+template <template <typename, unsigned int> class array_type = darray,
+          template <typename> class vector_type = dvector>
+struct regular {
+    dindex n_bins;
+    scalar min;
+    scalar max;
+
+    static constexpr unsigned int axis_identifier = 0;
+
+    /** Return the number of bins */
+    dindex bins() const { return n_bins; }
+
+    /** Access function to a single bin from a value v
+     *
+     * @param v is the value for the bin search
+     *
+     * As the axis is closed it @returns a dindex type
+     **/
+    dindex bin(scalar v) const {
+        int ibin = static_cast<int>((v - min) / (max - min) * n_bins);
+        return (ibin >= 0 and ibin < n_bins)
+                   ? static_cast<dindex>(ibin)
+                   : ibin < 0 ? 0 : static_cast<dindex>(n_bins - 1);
+    }
+
+    /** Access function to a range with binned neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (in #bins)
+     *
+     * As the axis is closed it @returns a dindex_range
+     **/
+    dindex_range range(scalar v,
+                       const array_type<dindex, 2> &nhood = {0u, 0u}) const {
+
+        int ibin = static_cast<int>((v - min) / (max - min) * n_bins);
+        int ibinmin = ibin - static_cast<int>(nhood[0]);
+        int ibinmax = ibin + static_cast<int>(nhood[1]);
+        dindex min_bin = (ibinmin >= 0) ? static_cast<dindex>(ibinmin) : 0;
+        dindex max_bin = (ibinmax < static_cast<int>(n_bins))
+                             ? static_cast<dindex>(ibinmax)
+                             : static_cast<dindex>(n_bins - 1);
+        return {min_bin, max_bin};
+    }
+
+    /** Access function to a range with scalar neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (scalar)
+     *
+     * As the axis is closed it @returns a dindex_range
+     **/
+    dindex_range range(scalar v, const array_type<scalar, 2> &nhood) const {
+        int nbin =
+            static_cast<int>((v - nhood[0] - min) / (max - min) * n_bins);
+        int pbin =
+            static_cast<int>((v + nhood[1] - min) / (max - min) * n_bins);
+        dindex min_bin = (nbin >= 0) ? static_cast<dindex>(nbin) : 0;
+        dindex max_bin = (pbin < static_cast<int>(n_bins))
+                             ? static_cast<dindex>(pbin)
+                             : static_cast<dindex>(n_bins - 1);
+        return {min_bin, max_bin};
+    }
+
+    /** Access function to a zone with binned neighborhood
+     *
+     *
+     * @tparam neighbor_t is the neighborhood size
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (in #bins)
+     *
+     * As the axis is closed it @returns a dindex_sequence
+     **/
+    template <typename neighbor_t>
+    dindex_sequence zone_t(scalar v,
+                           const array_type<neighbor_t, 2> &nhood) const {
+        dindex_range nh_range = range(v, nhood);
+        dindex_sequence sequence(static_cast<dindex_sequence::size_type>(
+                                     nh_range[1] - nh_range[0] + 1),
+                                 nh_range[0]);
+        dindex m = 0;
+        std::for_each(sequence.begin(), sequence.end(),
+                      [&](auto &n) { n += m++; });
+        return sequence;
+    }
+
+    /** Access function to a zone with binned neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (#bins)
+     *
+     * As the axis is closed it @returns a dindex_sequence
+     **/
+    dindex_sequence zone(scalar v, const array_type<dindex, 2> &nhood) const {
+        return zone_t<dindex>(v, nhood);
+    }
+
+    /** Access function to a zone with scalar neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (scalar)
+     *
+     * As the axis is closed it @returns a dindex_sequence
+     **/
+    dindex_sequence zone(scalar v, const array_type<scalar, 2> &nhood) const {
+        return zone_t<scalar>(v, nhood);
+    }
+
+    /** @return the bin boundaries for a given @param ibin */
+    array_type<scalar, 2> borders(dindex ibin) const {
+        scalar step = (max - min) / n_bins;
+        return {min + ibin * step, min + (ibin + 1) * step};
+    }
+
+    /** @return the values of the borders */
+    vector_type<scalar> all_borders() const {
+        vector_type<scalar> borders;
+        borders.reserve(n_bins + 1);
+        scalar step = (max - min) / n_bins;
+        for (dindex ib = 0; ib < n_bins + 1; ++ib) {
+            borders.push_back(min + ib * step);
+        }
+        return borders;
+    }
+
+    /** @return the axis span [min, max) */
+    array_type<scalar, 2> span() const { return {min, max}; }
+};
+
+/** A regular circular axis.
+ *
+ * The axis is circular, i.e. the underflow bins map into the circular sequence
+ */
+template <template <typename, unsigned int> class array_type = darray,
+          template <typename> class vector_type = dvector>
+struct circular {
+
+    dindex n_bins;
+    scalar min;
+    scalar max;
+
+    static constexpr unsigned int axis_identifier = 1;
+
+    /** Return the number of bins */
+    dindex bins() const { return n_bins; }
+
+    /** Access function to a single bin from a value v
+     *
+     * @param v is the value for the bin search
+     *
+     * As the axis is closed it @returns a dindex type
+     **/
+    dindex bin(scalar v) const {
+        dindex ibin = static_cast<dindex>((v - min) / (max - min) * n_bins);
+        return (ibin >= 0 and ibin < n_bins)
+                   ? static_cast<dindex>(ibin)
+                   : ibin < 0 ? static_cast<dindex>(n_bins + ibin)
+                              : static_cast<dindex>(ibin - n_bins);
+    }
+
+    /** Access function to a range with binned neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the  neighborhood range (in #bins)
+     *
+     * As the axis is circular it @returns a dindex_range
+     **/
+    dindex_range range(scalar v,
+                       const array_type<dindex, 2> nhood = {0u, 0u}) const {
+        dindex gbin = bin(v);
+        dindex min_bin = remap(gbin, -static_cast<int>(nhood[0]));
+        dindex max_bin = remap(gbin, static_cast<int>(nhood[1]));
+        return {min_bin, max_bin};
+    }
+
+    /** Access function to a range with scalar neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (scalar)
+     *
+     * As the axis is circular it @returns a dindex_range
+     **/
+    dindex_range range(scalar v, const array_type<scalar, 2> &nhood) const {
+        dindex nbin = bin(v - nhood[0]);
+        dindex pbin = bin(v + nhood[1]);
+        return {nbin, pbin};
+    }
+
+    /** Access function to a zone with binned/scalar neighborhood
+     *
+     * @tparam neighbor_t is the neighborhood size
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (in #bins/scalar)
+     *
+     * As the axis is closed it @returns a dindex_sequence
+     **/
+    template <typename neighbor_t>
+    dindex_sequence zone_t(scalar v,
+                           const array_type<neighbor_t, 2> &nhood) const {
+        dindex_range nh_range = range(v, nhood);
+        if (nh_range[0] < nh_range[1]) {
+            dindex_sequence sequence(static_cast<dindex_sequence::size_type>(
+                                         nh_range[1] - nh_range[0] + 1),
+                                     nh_range[0]);
+            dindex m = 0;
+            std::for_each(sequence.begin(), sequence.end(),
+                          [&](auto &n) { n += m++; });
+            return sequence;
+        }
+        dindex vl = static_cast<dindex>(n_bins - nh_range[0] + nh_range[1] + 1);
+        dindex mi = 0;
+        dindex mo = 0;
+        dindex_sequence sequence(static_cast<dindex_sequence::size_type>(vl),
+                                 nh_range[0]);
+        std::for_each(sequence.begin(), sequence.end(), [&](auto &n) {
+            n += mi++;
+            if (n > n_bins - 1) {
+                n = mo++;
             }
-        };
-
-    } // namespace axis
-
-} // namespace detray
\ No newline at end of file
+        });
+        return sequence;
+    }
+
+    /** Access function to a zone with binned neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (#bins)
+     *
+     * As the axis is closed it @returns a dindex_sequence
+     **/
+    dindex_sequence zone(scalar v, const array_type<dindex, 2> &nhood) const {
+        return zone_t<dindex>(v, nhood);
+    }
+
+    /** Access function to a zone with scalar neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (scalar)
+     *
+     * As the axis is closed it @returns a dindex_sequence
+     **/
+    dindex_sequence zone(scalar v, const array_type<scalar, 2> &nhood) const {
+        return zone_t<scalar>(v, nhood);
+    }
+
+    /** Helper function to remap onto a circular range
+     *
+     * @param ibin is the optional binning value
+     * @param shood is the sided neighbour hood
+     *
+     * @return an index, remapped bin
+     **/
+    dindex remap(dindex ibin, int shood) const {
+        int opt_bin = static_cast<int>(ibin) + shood;
+        if (opt_bin >= 0 and opt_bin < n_bins) {
+            return static_cast<dindex>(opt_bin);
+        }
+        if (opt_bin < 0) {
+            return static_cast<dindex>(n_bins + opt_bin);
+        }
+        return static_cast<dindex>(opt_bin - n_bins);
+    }
+
+    /** @return the bin boundaries for a given @param ibin */
+    array_type<scalar, 2> borders(dindex ibin) const {
+        scalar step = (max - min) / n_bins;
+        return {min + ibin * step, min + (ibin + 1) * step};
+    }
+
+    /** @return the values of the borders */
+    vector_type<scalar> all_borders() const {
+        vector_type<scalar> borders;
+        borders.reserve(n_bins + 1);
+        scalar step = (max - min) / n_bins;
+        for (dindex ib = 0; ib < n_bins + 1; ++ib) {
+            borders.push_back(min + ib * step);
+        }
+        return borders;
+    }
+
+    /** @return the range  */
+    array_type<scalar, 2> span() const { return {min, max}; }
+};
+
+/** An iregular circular axis.
+ *
+ * The axis is closed, i.e. the underflow is mapped into the first,
+ * the overflow is mapped into the last.
+ */
+template <template <typename, unsigned int> class array_type = darray,
+          template <typename> class vector_type = dvector>
+struct irregular {
+
+    vector_type<scalar> boundaries;
+
+    static constexpr unsigned int axis_identifier = 2;
+
+    /** Return the number of bins */
+    dindex bins() const { return static_cast<dindex>(boundaries.size() - 1); }
+
+    /** Access function to a single bin from a value v
+     *
+     * @param v is the value for the bin search
+     *
+     * As the axis is closed it @returns a dindex type
+     **/
+    dindex bin(scalar v) const {
+        dindex ibin =
+            std::lower_bound(boundaries.begin(), boundaries.end(), v) -
+            boundaries.begin();
+        return ((ibin > 0 and ibin < boundaries.size())
+                    ? --ibin
+                    : (ibin == 0) ? ibin : boundaries.size() - 2);
+    }
+
+    /** Access function to a range with binned neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (#bins)
+     *
+     * As the axis is closed it @returns a dindex_range
+     **/
+    dindex_range range(scalar v,
+                       const array_type<dindex, 2> &nhood = {0u, 0u}) const {
+
+        dindex ibin = bin(v);
+        int bins = boundaries.size() - 1;
+        int ibinmin = ibin - static_cast<int>(nhood[0]);
+        int ibinmax = ibin + static_cast<int>(nhood[1]);
+        dindex min_bin = (ibinmin >= 0) ? static_cast<dindex>(ibinmin) : 0;
+        dindex max_bin = (ibinmax < static_cast<int>(bins))
+                             ? static_cast<dindex>(ibinmax)
+                             : static_cast<dindex>(bins - 1);
+        return {min_bin, max_bin};
+    }
+
+    /** Access function to a range with scalar neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (scalar)
+     *
+     * As the axis is closed it @returns a dindex_range
+     **/
+    dindex_range range(scalar v, const array_type<scalar, 2> &nhood) const {
+        dindex nbin = bin(v - nhood[0]);
+        dindex pbin = bin(v + nhood[1]);
+        return {nbin, pbin};
+    }
+
+    /** Access function to a zone with binned/scalar neighborhood
+     *
+     * @tparam neighbor_t is the neighborhood type
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (binned/scalar)
+     *
+     * As the axis is closed it @returns a dindex_sequence
+     **/
+    template <typename neighbor_t>
+    dindex_sequence zone_t(scalar v,
+                           const array_type<neighbor_t, 2> nhood) const {
+        dindex_range nh_range = range(v, nhood);
+        dindex_sequence sequence(static_cast<dindex_sequence::size_type>(
+                                     nh_range[1] - nh_range[0] + 1),
+                                 nh_range[0]);
+        dindex m = 0;
+        std::for_each(sequence.begin(), sequence.end(),
+                      [&](auto &n) { n += m++; });
+        return sequence;
+    }
+
+    /** Access function to a zone with binned neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (#bins)
+     *
+     * As the axis is closed it @returns a dindex_sequence
+     **/
+    dindex_sequence zone(scalar v,
+                         const array_type<dindex, 2> &nhood = {0, 0}) const {
+        return zone_t<dindex>(v, nhood);
+    }
+
+    /** Access function to a zone with scalar neighborhood
+     *
+     * @param v is the value for the bin search
+     * @param nhood is the neighborhood range (scalar)
+     *
+     * As the axis is closed it @returns a dindex_sequence
+     **/
+    dindex_sequence zone(scalar v, const array_type<scalar, 2> &nhood) const {
+        return zone_t<scalar>(v, nhood);
+    }
+
+    /** @return the bin boundaries for a given @param ibin */
+    array_type<scalar, 2> borders(dindex ibin) const {
+        return {boundaries[ibin], boundaries[ibin + 1]};
+    }
+
+    /** @return the values of the borders of all bins */
+    vector_type<scalar> all_borders() const { return boundaries; }
+
+    /** @return the range  */
+    array_type<scalar, 2> span() const {
+        return {boundaries[0], boundaries[boundaries.size() - 1]};
+    }
+};
+
+}  // namespace axis
+
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/grids/grid2.hpp b/core/include/grids/grid2.hpp
index f489b4e2fa..3c9434b092 100644
--- a/core/include/grids/grid2.hpp
+++ b/core/include/grids/grid2.hpp
@@ -1,243 +1,255 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-namespace detray
-{
-
-    /** A two-dimensional grid for object storage
-     * 
-     * @tparam populator_type  is a prescription what to do when a bin gets pupulated, it broadcasts
-     *         also the value type
-     * @tparam tparam axis_p0_type the type of the first axis
-     * @tparam tparam axis_p1_type the type of the second axis
-     * @tparam serialzier_type  type of the serializer to the storage represenations
-     * 
-     **/
-    template <typename populator_type,
-              typename axis_p0_type,
-              typename axis_p1_type,
-              typename serializer_type,
-              template <typename, unsigned int> class array_type = darray,
-              template <typename ...> class tuple_type = dtuple,
-              template <typename> class vector_type = dvector>
-    class grid2
-    {
+namespace detray {
+
+/** A two-dimensional grid for object storage
+ *
+ * @tparam populator_type  is a prescription what to do when a bin gets
+ *pupulated, it broadcasts also the value type
+ * @tparam tparam axis_p0_type the type of the first axis
+ * @tparam tparam axis_p1_type the type of the second axis
+ * @tparam serialzier_type  type of the serializer to the storage represenations
+ *
+ **/
+template <typename populator_type, typename axis_p0_type, typename axis_p1_type,
+          typename serializer_type,
+          template <typename, unsigned int> class array_type = darray,
+          template <typename...> class tuple_type = dtuple,
+          template <typename> class vector_type = dvector>
+class grid2 {
 
     public:
-        using serialized_storage = vector_type<typename populator_type::store_value>;
-        using point2 = __plugin::point2;
-
-        template <typename neighbor_t>
-        using neighborhood = array_type<array_type<neighbor_t, 2>, 2>;
-
-        static constexpr array_type<dindex, 2> hermit1 = {0u, 0u};
-        static constexpr neighborhood<dindex> hermit2 = {hermit1, hermit1};
-
-        /** Constructor from axes - copy semantics
-         * 
-         * @param axis_p0 is the axis in the first coordinate
-         * @param axis_p1 is the axis in the second coordinate
-         * 
-         **/
-        grid2(const axis_p0_type &axis_p0, const axis_p1_type &axis_p1) : _axis_p0(axis_p0), _axis_p1(axis_p1)
-        {
-            _data_serialized = serialized_storage(_axis_p0.bins() * _axis_p1.bins(), _populator.init());
-        }
-
-        /** Constructor from axes - move semantics
-         * 
-         * @param axis_p0 is the axis in the first coordinate
-         * @param axis_p1 is the axis in the second coordinate
-         * 
-         **/
-        grid2(axis_p0_type &&axis_p0, axis_p1_type &&axis_p1) : _axis_p0(std::move(axis_p0)), _axis_p1(std::move(axis_p1))
-        {
-            _data_serialized = serialized_storage(_axis_p0.bins() * _axis_p1.bins(), _populator.init());
-        }
+    using serialized_storage =
+        vector_type<typename populator_type::store_value>;
+    using point2 = __plugin::point2;
 
-        /** Allow for grid shift, when using a centralized store and indices
-        * 
-        * @param offset is the applied offset shift
-        * 
-        **/
-        void shift(const typename populator_type::bare_value &offset)
-        {
-            std::for_each(_data_serialized.begin(), _data_serialized.end(), [&](auto &ds)
-                          { _populator.shift(ds, offset); });
-        }
-
-        /** Fill/populate operation
-         * 
-         * @tparam point2_type the 2D local point type
-         * 
-         * @param p2 the point in p2 local frame
-         * @param fvalue is a single fill value to be filled
-         * 
-         **/
-        template <typename point2_type>
-        void populate(const point2_type &p2, typename populator_type::bare_value &&fvalue)
-        {
-            auto sbin = _serializer.template serialize<axis_p0_type, axis_p1_type>(_axis_p0, _axis_p1, _axis_p0.bin(p2[0]), _axis_p1.bin(p2[1]));
-            _populator(_data_serialized[sbin], std::move(fvalue));
-        }
+    template <typename neighbor_t>
+    using neighborhood = array_type<array_type<neighbor_t, 2>, 2>;
 
-        /** Fill/populate operation - with bin entry
-         * 
-         * @param bin The two-dimensional bin2 
-         * @param fvalue is a single fill value to be filled
-         * 
-         **/
-        void populate(dindex bin0, dindex bin1, typename populator_type::bare_value &&fvalue)
-        {
-            auto sbin = _serializer.template serialize<axis_p0_type, axis_p1_type>(_axis_p0, _axis_p1, bin0, bin1);
-            _populator(_data_serialized[sbin], std::move(fvalue));
-        }
+    static constexpr array_type<dindex, 2> hermit1 = {0u, 0u};
+    static constexpr neighborhood<dindex> hermit2 = {hermit1, hermit1};
 
-        /** Return the value of a single bin - with direct bin acess
-         * 
-         * @param bin0 the index of bin 0
-         * @param bin1 the index of bin 1
-         * 
-         * @return the const reference to the value in this bin 
-         **/
-        const auto &bin(dindex bin0, dindex bin1) const
-        {
-            return _data_serialized[_serializer.template serialize<axis_p0_type, axis_p1_type>(_axis_p0, _axis_p1, bin0, bin1)];
-        }
-
-        /** Return the value of a single bin 
-         * 
-         * @param p2 is point in the local frame
-         * 
-         * @return the const reference to the value in this bin 
-         **/
-        const auto &bin(const point2 &p2) const
-        {
-            return _data_serialized[_serializer.template serialize<axis_p0_type, axis_p1_type>(_axis_p0, _axis_p1, _axis_p0.bin(p2[0]), _axis_p1.bin(p2[1]))];
-        }
-
-        /** Return the value of a single bin - non-const access
-         * 
-         * @param p2 is point in the local frame
-         * 
-         * @return the const reference to the value in this bin 
-         **/
-        auto &bin(const point2 &p2)
-        {
-            return _data_serialized[_serializer.template serialize<axis_p0_type, axis_p1_type>(_axis_p0, _axis_p1, _axis_p0.bin(p2[0]), _axis_p1.bin(p2[1]))];
-        }
-
-        /** Return a zone around a single bin, either with binned or scalar neighborhood
-         * 
-         * The zone is done with a neighborhood around the bin which is defined by p2
-         * 
-         * @param p2 is point in the local frame
-         * @param nhood is the binned/scalar neighborhood
-         * @param sort is a directive whether to sort or not
-         * 
-         * @return the sequence of values
-         **/
-        template <typename neighbor_t>
-        vector_type<typename populator_type::bare_value> zone_t(const point2 &p2, const neighborhood<neighbor_t> &nhood, bool sort) const
-        {
-            auto zone0 = _axis_p0.zone(p2[0], nhood[0]);
-            auto zone1 = _axis_p1.zone(p2[1], nhood[1]);
-
-            vector_type<typename populator_type::bare_value> zone;
-
-            // Specialization for bare value equal to store value
-            if constexpr (std::is_same_v<typename populator_type::bare_value, typename populator_type::store_value>)
-            {
-                unsigned int iz = 0;
-                zone = vector_type<typename populator_type::bare_value>(zone0.size() * zone1.size(), {});
-                for (const auto z1 : zone1)
-                {
-                    for (const auto z0 : zone0)
-                    {
-                        auto sbin = _serializer.template serialize<axis_p0_type, axis_p1_type>(_axis_p0, _axis_p1, z0, z1);
-                        zone[iz++] = _data_serialized[sbin];
-                    }
+    /** Constructor from axes - copy semantics
+     *
+     * @param axis_p0 is the axis in the first coordinate
+     * @param axis_p1 is the axis in the second coordinate
+     *
+     **/
+    grid2(const axis_p0_type &axis_p0, const axis_p1_type &axis_p1)
+        : _axis_p0(axis_p0), _axis_p1(axis_p1) {
+        _data_serialized = serialized_storage(_axis_p0.bins() * _axis_p1.bins(),
+                                              _populator.init());
+    }
+
+    /** Constructor from axes - move semantics
+     *
+     * @param axis_p0 is the axis in the first coordinate
+     * @param axis_p1 is the axis in the second coordinate
+     *
+     **/
+    grid2(axis_p0_type &&axis_p0, axis_p1_type &&axis_p1)
+        : _axis_p0(std::move(axis_p0)), _axis_p1(std::move(axis_p1)) {
+        _data_serialized = serialized_storage(_axis_p0.bins() * _axis_p1.bins(),
+                                              _populator.init());
+    }
+
+    /** Allow for grid shift, when using a centralized store and indices
+     *
+     * @param offset is the applied offset shift
+     *
+     **/
+    void shift(const typename populator_type::bare_value &offset) {
+        std::for_each(_data_serialized.begin(), _data_serialized.end(),
+                      [&](auto &ds) { _populator.shift(ds, offset); });
+    }
+
+    /** Fill/populate operation
+     *
+     * @tparam point2_type the 2D local point type
+     *
+     * @param p2 the point in p2 local frame
+     * @param fvalue is a single fill value to be filled
+     *
+     **/
+    template <typename point2_type>
+    void populate(const point2_type &p2,
+                  typename populator_type::bare_value &&fvalue) {
+        auto sbin = _serializer.template serialize<axis_p0_type, axis_p1_type>(
+            _axis_p0, _axis_p1, _axis_p0.bin(p2[0]), _axis_p1.bin(p2[1]));
+        _populator(_data_serialized[sbin], std::move(fvalue));
+    }
+
+    /** Fill/populate operation - with bin entry
+     *
+     * @param bin The two-dimensional bin2
+     * @param fvalue is a single fill value to be filled
+     *
+     **/
+    void populate(dindex bin0, dindex bin1,
+                  typename populator_type::bare_value &&fvalue) {
+        auto sbin = _serializer.template serialize<axis_p0_type, axis_p1_type>(
+            _axis_p0, _axis_p1, bin0, bin1);
+        _populator(_data_serialized[sbin], std::move(fvalue));
+    }
+
+    /** Return the value of a single bin - with direct bin acess
+     *
+     * @param bin0 the index of bin 0
+     * @param bin1 the index of bin 1
+     *
+     * @return the const reference to the value in this bin
+     **/
+    const auto &bin(dindex bin0, dindex bin1) const {
+        return _data_serialized[_serializer.template serialize<
+            axis_p0_type, axis_p1_type>(_axis_p0, _axis_p1, bin0, bin1)];
+    }
+
+    /** Return the value of a single bin
+     *
+     * @param p2 is point in the local frame
+     *
+     * @return the const reference to the value in this bin
+     **/
+    const auto &bin(const point2 &p2) const {
+        return _data_serialized[_serializer.template serialize<axis_p0_type,
+                                                               axis_p1_type>(
+            _axis_p0, _axis_p1, _axis_p0.bin(p2[0]), _axis_p1.bin(p2[1]))];
+    }
+
+    /** Return the value of a single bin - non-const access
+     *
+     * @param p2 is point in the local frame
+     *
+     * @return the const reference to the value in this bin
+     **/
+    auto &bin(const point2 &p2) {
+        return _data_serialized[_serializer.template serialize<axis_p0_type,
+                                                               axis_p1_type>(
+            _axis_p0, _axis_p1, _axis_p0.bin(p2[0]), _axis_p1.bin(p2[1]))];
+    }
+
+    /** Return a zone around a single bin, either with binned or scalar
+     *neighborhood
+     *
+     * The zone is done with a neighborhood around the bin which is defined by
+     *p2
+     *
+     * @param p2 is point in the local frame
+     * @param nhood is the binned/scalar neighborhood
+     * @param sort is a directive whether to sort or not
+     *
+     * @return the sequence of values
+     **/
+    template <typename neighbor_t>
+    vector_type<typename populator_type::bare_value> zone_t(
+        const point2 &p2, const neighborhood<neighbor_t> &nhood,
+        bool sort) const {
+        auto zone0 = _axis_p0.zone(p2[0], nhood[0]);
+        auto zone1 = _axis_p1.zone(p2[1], nhood[1]);
+
+        vector_type<typename populator_type::bare_value> zone;
+
+        // Specialization for bare value equal to store value
+        if constexpr (std::is_same_v<typename populator_type::bare_value,
+                                     typename populator_type::store_value>) {
+            unsigned int iz = 0;
+            zone = vector_type<typename populator_type::bare_value>(
+                zone0.size() * zone1.size(), {});
+            for (const auto z1 : zone1) {
+                for (const auto z0 : zone0) {
+                    auto sbin =
+                        _serializer
+                            .template serialize<axis_p0_type, axis_p1_type>(
+                                _axis_p0, _axis_p1, z0, z1);
+                    zone[iz++] = _data_serialized[sbin];
                 }
             }
-            else
-            {
-                zone.reserve(10);
-                for (const auto z1 : zone1)
-                {
-                    for (const auto z0 : zone0)
-                    {
-                        auto sbin = _serializer.template serialize<axis_p0_type, axis_p1_type>(_axis_p0, _axis_p1, z0, z1);
-                        auto bin_data = _data_serialized[sbin];
-                        auto bin_content = _populator.sequence(bin_data);
-                        zone.insert(zone.end(), bin_content.begin(), bin_content.end());
-                    }
+        } else {
+            zone.reserve(10);
+            for (const auto z1 : zone1) {
+                for (const auto z0 : zone0) {
+                    auto sbin =
+                        _serializer
+                            .template serialize<axis_p0_type, axis_p1_type>(
+                                _axis_p0, _axis_p1, z0, z1);
+                    auto bin_data = _data_serialized[sbin];
+                    auto bin_content = _populator.sequence(bin_data);
+                    zone.insert(zone.end(), bin_content.begin(),
+                                bin_content.end());
                 }
             }
-
-            if (sort)
-            {
-                std::sort(zone.begin(), zone.end());
-            }
-            return zone;
         }
 
-        /** Return a zone around a single bin, either with binned neighborhood
-         * 
-         * The zone is done with a neighborhood around the bin which is defined by p2
-         * 
-         * @param p2 is point in the local frame
-         * @param nhood is the binned neighborhood
-         * @param sort is a directive whether to sort or not
-         * 
-         * @return the sequence of values
-         **/
-        vector_type<typename populator_type::bare_value> zone(const point2 &p2, const neighborhood<dindex> &nhood = hermit2, bool sort = false) const
-        {
-            return zone_t<dindex>(p2, nhood, sort);
-        }
-
-        /** Return a zone around a single bin, either with scalar neighborhood
-         * 
-         * The zone is done with a neighborhood around the bin which is defined by p2
-         * 
-         * @param p2 is point in the local frame
-         * @param nhood is the binned neighborhood
-         * @param sort is a directive whether to sort or not
-         * 
-         * @return the sequence of values
-         **/
-        vector_type<typename populator_type::bare_value> zone(const point2 &p2, const neighborhood<scalar> &nhood, bool sort = false) const
-        {
-            return zone_t<scalar>(p2, nhood, sort);
+        if (sort) {
+            std::sort(zone.begin(), zone.end());
         }
+        return zone;
+    }
+
+    /** Return a zone around a single bin, either with binned neighborhood
+     *
+     * The zone is done with a neighborhood around the bin which is defined by
+     *p2
+     *
+     * @param p2 is point in the local frame
+     * @param nhood is the binned neighborhood
+     * @param sort is a directive whether to sort or not
+     *
+     * @return the sequence of values
+     **/
+    vector_type<typename populator_type::bare_value> zone(
+        const point2 &p2, const neighborhood<dindex> &nhood = hermit2,
+        bool sort = false) const {
+        return zone_t<dindex>(p2, nhood, sort);
+    }
+
+    /** Return a zone around a single bin, either with scalar neighborhood
+     *
+     * The zone is done with a neighborhood around the bin which is defined by
+     *p2
+     *
+     * @param p2 is point in the local frame
+     * @param nhood is the binned neighborhood
+     * @param sort is a directive whether to sort or not
+     *
+     * @return the sequence of values
+     **/
+    vector_type<typename populator_type::bare_value> zone(
+        const point2 &p2, const neighborhood<scalar> &nhood,
+        bool sort = false) const {
+        return zone_t<scalar>(p2, nhood, sort);
+    }
 
-        /** Const access to axis p0  */
-        const axis_p0_type &axis_p0() const { return _axis_p0; }
+    /** Const access to axis p0  */
+    const axis_p0_type &axis_p0() const { return _axis_p0; }
 
-        /** Const access to axis p1 */
-        const axis_p1_type &axis_p1() const { return _axis_p1; }
+    /** Const access to axis p1 */
+    const axis_p1_type &axis_p1() const { return _axis_p1; }
 
-        /* Copy of axes in a tuple */
-        tuple_type<axis_p0_type, axis_p1_type> axes() const { return std::tie(_axis_p0, _axis_p1); }
+    /* Copy of axes in a tuple */
+    tuple_type<axis_p0_type, axis_p1_type> axes() const {
+        return std::tie(_axis_p0, _axis_p1);
+    }
 
-        /** Const acess to the serializer */
-        const serializer_type &serializer() const { return _serializer; }
+    /** Const acess to the serializer */
+    const serializer_type &serializer() const { return _serializer; }
 
-        /** Const acess to the polulator */
-        const populator_type &populator() const { return _populator; }
+    /** Const acess to the polulator */
+    const populator_type &populator() const { return _populator; }
 
     private:
-        serialized_storage _data_serialized;
-        axis_p0_type _axis_p0;
-        axis_p1_type _axis_p1;
-        serializer_type _serializer;
-        populator_type _populator;
-    };
-
-} // namespace detray
\ No newline at end of file
+    serialized_storage _data_serialized;
+    axis_p0_type _axis_p0;
+    axis_p1_type _axis_p1;
+    serializer_type _serializer;
+    populator_type _populator;
+};
+
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/grids/populator.hpp b/core/include/grids/populator.hpp
index 1cfc26622e..749cfb46e1 100644
--- a/core/include/grids/populator.hpp
+++ b/core/include/grids/populator.hpp
@@ -1,230 +1,201 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-#include "utils/indexing.hpp"
-
 #include <algorithm>
 #include <limits>
 
-namespace detray
-{
-    /** A replace populator that swaps whatever current value in the 
-     * bin with the new one.
-     * 
-     * @tparam value_type the type of a single stored object
-     * 
-     * @note bare_value and store_value are identicial in this case
-     **/
-    template <typename value_type = dindex, 
-              value_type kInvalid = std::numeric_limits<dindex>::max(),
-              template <typename> class vector_type = dvector>
-    struct replace_populator
-    {
-
-        using bare_value = value_type;
-        using store_value = value_type;
-
-        static constexpr value_type invalid_value = kInvalid;
-
-        /** Swap the stored value with a new bare value
-         * 
-         * @param stored the stored value for the population
-         * @param bvalue the new value to be added
-         **/
-        void operator()(store_value &stored, bare_value &&bvalue) const
-        {
-            stored = std::move(bvalue);
-        }
-
-        /** Create a sequence of bare values, independent of the store_value.
-         * 
-         * @param stored the stored value
-         * 
-         * @return a sequence of bare values
-         */
-        vector_type<bare_value> sequence(store_value &stored) const
-        {
-            if (stored != kInvalid)
-            {
-                return {stored};
-            }
-            return {};
-        }
-
-        /** Shift operation for unified memory block
-         * 
-         * @param stored the stored value
-         * @param offset is the shift offset
-         * 
-         **/
-        void shift(store_value &stored, const bare_value &offset) const
-        {
-            stored += offset;
-        }
+#include "utils/indexing.hpp"
 
-        /** Return an initialized bin value
-         */
-        store_value init() const
-        {
-            return kInvalid;
-        }
-    };
-
-    /** A complete populator that adds values to the internal
-     * store array until it is completed, ignored afterwards.
-     * 
-     * @tparam kDIM the dimension of the underlying stored array
-     * @tparam kSORT a sorting flag 
-     * @tparam value_type the type of a single stored object
-     * @tparam kInvalid the chosen invalid type
-     * 
-     * @note bare_value and store_value are different in this case
+namespace detray {
+/** A replace populator that swaps whatever current value in the
+ * bin with the new one.
+ *
+ * @tparam value_type the type of a single stored object
+ *
+ * @note bare_value and store_value are identicial in this case
+ **/
+template <typename value_type = dindex,
+          value_type kInvalid = std::numeric_limits<dindex>::max(),
+          template <typename> class vector_type = dvector>
+struct replace_populator {
+
+    using bare_value = value_type;
+    using store_value = value_type;
+
+    static constexpr value_type invalid_value = kInvalid;
+
+    /** Swap the stored value with a new bare value
+     *
+     * @param stored the stored value for the population
+     * @param bvalue the new value to be added
      **/
-    template <unsigned int kDIM, 
-              bool kSORT = false, 
-              typename value_type = dindex, 
-              value_type kInvalid = std::numeric_limits<dindex>::max(),
-              template <typename, unsigned int> class array_type = darray,
-              template <typename> class vector_type = dvector>
-    struct complete_populator
-    {
-
-        static constexpr value_type invalid_value = kInvalid;
-
-        using bare_value = value_type;
-        using store_value = array_type<bare_value, kDIM>;
-
-        /** Complete the stored value with a new bare value
-         * 
-         * @param stored the stored value for the population
-         * @param bvalue the new value to be added
-         **/
-        void operator()(store_value &stored, bare_value &&bvalue) const
-        {
-
-            for (auto &val : stored)
-            {
-                if (val == kInvalid)
-                {
-                    val = bvalue;
-                    break;
-                }
-            }
-            if (kSORT)
-            {
-                std::sort(stored.begin(), stored.end());
-            }
+    void operator()(store_value &stored, bare_value &&bvalue) const {
+        stored = std::move(bvalue);
+    }
+
+    /** Create a sequence of bare values, independent of the store_value.
+     *
+     * @param stored the stored value
+     *
+     * @return a sequence of bare values
+     */
+    vector_type<bare_value> sequence(store_value &stored) const {
+        if (stored != kInvalid) {
+            return {stored};
         }
+        return {};
+    }
+
+    /** Shift operation for unified memory block
+     *
+     * @param stored the stored value
+     * @param offset is the shift offset
+     *
+     **/
+    void shift(store_value &stored, const bare_value &offset) const {
+        stored += offset;
+    }
+
+    /** Return an initialized bin value
+     */
+    store_value init() const { return kInvalid; }
+};
+
+/** A complete populator that adds values to the internal
+ * store array until it is completed, ignored afterwards.
+ *
+ * @tparam kDIM the dimension of the underlying stored array
+ * @tparam kSORT a sorting flag
+ * @tparam value_type the type of a single stored object
+ * @tparam kInvalid the chosen invalid type
+ *
+ * @note bare_value and store_value are different in this case
+ **/
+template <unsigned int kDIM, bool kSORT = false, typename value_type = dindex,
+          value_type kInvalid = std::numeric_limits<dindex>::max(),
+          template <typename, unsigned int> class array_type = darray,
+          template <typename> class vector_type = dvector>
+struct complete_populator {
+
+    static constexpr value_type invalid_value = kInvalid;
+
+    using bare_value = value_type;
+    using store_value = array_type<bare_value, kDIM>;
+
+    /** Complete the stored value with a new bare value
+     *
+     * @param stored the stored value for the population
+     * @param bvalue the new value to be added
+     **/
+    void operator()(store_value &stored, bare_value &&bvalue) const {
 
-        /** Create a sequence of bare values, independent of the store_value.
-         * 
-         * @param stored the stored value
-         * 
-         * @return a sequence of bare values, @note it will ignore invalid entries
-         */
-        vector_type<bare_value> sequence(store_value &stored) const
-        {
-            vector_type<bare_value> s;
-            s.reserve(kDIM);
-            for (const auto &val : stored)
-            {
-                if (val != kInvalid)
-                {
-                    s.push_back(val);
-                }
+        for (auto &val : stored) {
+            if (val == kInvalid) {
+                val = bvalue;
+                break;
             }
-            return s;
         }
-
-        /** Shift operation for unified memory block
-         * 
-         * @param stored the stored value
-         * @param offset is the shift offset
-         * 
-         **/
-        void shift(store_value &stored, const bare_value &offset) const
-        {
-            std::for_each(stored.begin(), stored.end(), [&](auto &d) { d += offset; });
+        if (kSORT) {
+            std::sort(stored.begin(), stored.end());
         }
-
-        /** Return an initialized bin value
-         **/
-        store_value init() const
-        {
-
-            store_value init_bin;
-            for (auto &val : init_bin)
-            {
-                val = kInvalid;
+    }
+
+    /** Create a sequence of bare values, independent of the store_value.
+     *
+     * @param stored the stored value
+     *
+     * @return a sequence of bare values, @note it will ignore invalid entries
+     */
+    vector_type<bare_value> sequence(store_value &stored) const {
+        vector_type<bare_value> s;
+        s.reserve(kDIM);
+        for (const auto &val : stored) {
+            if (val != kInvalid) {
+                s.push_back(val);
             }
-            return init_bin;
         }
-    };
-
-    /** An attach populator that adds the new value to the 
-     * 
-     * @tparam kSORT the sorting directive
-     * @tparam value_type the type of a single stored object
-     * 
-     * @note bare_value and store_value are identicial in this case
+        return s;
+    }
+
+    /** Shift operation for unified memory block
+     *
+     * @param stored the stored value
+     * @param offset is the shift offset
+     *
      **/
-    template <bool kSORT = false, 
-              typename value_type = dindex,
-              template <typename> class vector_type = dvector>
-    struct attach_populator
-    {
-
-        using bare_value = value_type;
-        using store_value = vector_type<bare_value>;
-
-        /** Add a new value to the stored value
-         * 
-         * @param stored the stored value for the population
-         * @param bvalue the new value to be added
-         **/
-        void operator()(store_value &stored, bare_value &&bvalue) const
-        {
-            stored.push_back(bvalue);
-            if (kSORT)
-            {
-                std::sort(stored.begin(), stored.end());
-            }
-        }
+    void shift(store_value &stored, const bare_value &offset) const {
+        std::for_each(stored.begin(), stored.end(),
+                      [&](auto &d) { d += offset; });
+    }
 
-        /** Create a sequence of bare values, independent of the store_value.
-         * 
-         * @param stored the stored value
-         * 
-         * @return a sequence of bare values
-         */
-        vector_type<bare_value> sequence(store_value &stored) const
-        {
-            return stored;
-        }
+    /** Return an initialized bin value
+     **/
+    store_value init() const {
 
-        /** Shift operation for unified memory block
-         * 
-         * @param stored the stored value
-         * @param offset is the shift offset
-         * 
-         **/
-        void shift(store_value &stored, const bare_value &offset) const
-        {
-            std::for_each(stored.begin(), stored.end(), [&](auto &d) { d += offset; });
+        store_value init_bin;
+        for (auto &val : init_bin) {
+            val = kInvalid;
         }
-
-        /** Return an initialized bin value
-         **/
-        store_value init() const
-        {
-            return {};
+        return init_bin;
+    }
+};
+
+/** An attach populator that adds the new value to the
+ *
+ * @tparam kSORT the sorting directive
+ * @tparam value_type the type of a single stored object
+ *
+ * @note bare_value and store_value are identicial in this case
+ **/
+template <bool kSORT = false, typename value_type = dindex,
+          template <typename> class vector_type = dvector>
+struct attach_populator {
+
+    using bare_value = value_type;
+    using store_value = vector_type<bare_value>;
+
+    /** Add a new value to the stored value
+     *
+     * @param stored the stored value for the population
+     * @param bvalue the new value to be added
+     **/
+    void operator()(store_value &stored, bare_value &&bvalue) const {
+        stored.push_back(bvalue);
+        if (kSORT) {
+            std::sort(stored.begin(), stored.end());
         }
-    };
+    }
+
+    /** Create a sequence of bare values, independent of the store_value.
+     *
+     * @param stored the stored value
+     *
+     * @return a sequence of bare values
+     */
+    vector_type<bare_value> sequence(store_value &stored) const {
+        return stored;
+    }
+
+    /** Shift operation for unified memory block
+     *
+     * @param stored the stored value
+     * @param offset is the shift offset
+     *
+     **/
+    void shift(store_value &stored, const bare_value &offset) const {
+        std::for_each(stored.begin(), stored.end(),
+                      [&](auto &d) { d += offset; });
+    }
+
+    /** Return an initialized bin value
+     **/
+    store_value init() const { return {}; }
+};
 
-} // namespace detray
\ No newline at end of file
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/grids/serializer2.hpp b/core/include/grids/serializer2.hpp
index 9b128d67e7..c5f8a62363 100644
--- a/core/include/grids/serializer2.hpp
+++ b/core/include/grids/serializer2.hpp
@@ -1,67 +1,65 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-#include "utils/indexing.hpp"
-
 #include <algorithm>
 
-namespace detray
-{
-    /** Struct that helps taking a two-dimensional binning into
-     * a serial binning for data storage.
-     * 
-     * Serializers allow to create a memory local environment if
-     * advantegeous. 
-     * 
-     **/
-    struct serializer2
-    {
-        /** Create a serial bin from two individual bins 
-         * 
-         * @tparam faxis_type is the type of the first axis
-         * @tparam saxis_type is the type of the second axis
-         * 
-         * @param faxis the first axis
-         * @param saxis the second axis, unused here
-         * @param fbin first bin
-         * @param sbin second bin
-         * 
-         * @return a dindex for the memory storage
-         */
-        template <typename faxis_type, typename saxis_type>
-        dindex serialize(const faxis_type& faxis, const saxis_type& /*saxis*/,
-                                   dindex fbin, dindex sbin) const
-        {
+#include "utils/indexing.hpp"
+
+namespace detray {
+/** Struct that helps taking a two-dimensional binning into
+ * a serial binning for data storage.
+ *
+ * Serializers allow to create a memory local environment if
+ * advantegeous.
+ *
+ **/
+struct serializer2 {
+    /** Create a serial bin from two individual bins
+     *
+     * @tparam faxis_type is the type of the first axis
+     * @tparam saxis_type is the type of the second axis
+     *
+     * @param faxis the first axis
+     * @param saxis the second axis, unused here
+     * @param fbin first bin
+     * @param sbin second bin
+     *
+     * @return a dindex for the memory storage
+     */
+    template <typename faxis_type, typename saxis_type>
+    dindex serialize(const faxis_type &faxis, const saxis_type & /*saxis*/,
+                     dindex fbin, dindex sbin) const {
 
-            dindex offset = sbin * faxis.bins();
-            return offset + fbin;
-        }
+        dindex offset = sbin * faxis.bins();
+        return offset + fbin;
+    }
 
-        /** Create a bin tuple from a serialized bin
-         * 
-         * @tparam faxis_type is the type of the first axis
-         * @tparam saxis_type is the type of the second axis
-         * 
-         * @param faxis the first axis
-         * @param saxis the second axis, unused here
-         * @param serialbin the serial bin 
-         * 
-         * @return a 2-dim array of dindex 
-         */
-        template <typename faxis_type, typename saxis_type,
-                  template <typename, unsigned int> class array_type = darray>
-        array_type<dindex, 2> deserialize(const faxis_type& faxis, const saxis_type& /*saxis*/, dindex serialbin) const
-        {
-            dindex sbin = static_cast<dindex>(serialbin/faxis.bins());
-            dindex fbin = serialbin - sbin * faxis.bins();
-            return { fbin, sbin };
-        }
-    };
+    /** Create a bin tuple from a serialized bin
+     *
+     * @tparam faxis_type is the type of the first axis
+     * @tparam saxis_type is the type of the second axis
+     *
+     * @param faxis the first axis
+     * @param saxis the second axis, unused here
+     * @param serialbin the serial bin
+     *
+     * @return a 2-dim array of dindex
+     */
+    template <typename faxis_type, typename saxis_type,
+              template <typename, unsigned int> class array_type = darray>
+    array_type<dindex, 2> deserialize(const faxis_type &faxis,
+                                      const saxis_type & /*saxis*/,
+                                      dindex serialbin) const {
+        dindex sbin = static_cast<dindex>(serialbin / faxis.bins());
+        dindex fbin = serialbin - sbin * faxis.bins();
+        return {fbin, sbin};
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/masks/annulus2.hpp b/core/include/masks/annulus2.hpp
index cef6d09ead..e7034cd871 100644
--- a/core/include/masks/annulus2.hpp
+++ b/core/include/masks/annulus2.hpp
@@ -1,210 +1,206 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include "masks/mask_identifier.hpp"
-#include "core/intersection.hpp"
-#include "tools/planar_intersector.hpp"
-
-#include <cmath>
 #include <climits>
-#include <string>
+#include <cmath>
 #include <sstream>
+#include <string>
 
-namespace detray
-{
-    /** This is a 2-dimensional mask for the annulus geometry that is
-     *  e.g. used for the itk strip endcaps.
-     * 
-     * @tparam intersector_type is a struct used for intersecting this cylinder
-     * @tparam local_type is the default local type for this mask
-     * @tparam links_type is an object where the mask can link to 
-     * @tparam kMaskContext is a unique mask identifier in a certain context
+#include "core/intersection.hpp"
+#include "masks/mask_identifier.hpp"
+#include "tools/planar_intersector.hpp"
+
+namespace detray {
+/** This is a 2-dimensional mask for the annulus geometry that is
+ *  e.g. used for the itk strip endcaps.
+ *
+ * @tparam intersector_type is a struct used for intersecting this cylinder
+ * @tparam local_type is the default local type for this mask
+ * @tparam links_type is an object where the mask can link to
+ * @tparam kMaskContext is a unique mask identifier in a certain context
+ *
+ * It is defined by the two radii _values[0] and  _values[1] in the polar
+ * coordinate system of and endcap strip module, as well as the two phi
+ * boundaries, _values[2] and _values[3], that are only easily definable in
+ * the local strips system (relative to the average Phi along the
+ * strips r coordinate). Using a conversion between the two coordinate
+ * systems, these boundaries can be checked with a tolerance in r (t[0] and
+ * t[1]), as well as phi (t[3] and t[3]).
+ * Due to the local polar coordinate system of the strips needing a
+ * different origin from the discs polar one, three additional conversion
+ * parameters are included (_values[4], values[5], _values[6]).
+ * Here, the first two are the origin shift in xy, while _values[6] is the
+ * average Phi angle mentioned above.
+ *
+ * @note  While the mask_context can change depending on the typed container
+ * structure the mask_identifier is a const expression that determines the
+ * mask type once for all.
+ *
+ **/
+template <typename intersector_type = planar_intersector,
+          typename local_type = __plugin::polar2, typename links_type = bool,
+          unsigned int kMaskContext = e_annulus2,
+          template <typename, unsigned int> class array_type = darray>
+struct annulus2 {
+    using mask_tolerance = array_type<scalar, 2>;
+
+    using mask_values = array_type<scalar, 7>;
+
+    using mask_links_type = links_type;
+
+    mask_values _values = {0.,
+                           std::numeric_limits<scalar>::infinity(),
+                           -std::numeric_limits<scalar>::infinity(),
+                           std::numeric_limits<scalar>::infinity(),
+                           0.,
+                           0.,
+                           0.};
+
+    links_type _links;
+
+    static constexpr unsigned int mask_context = kMaskContext;
+
+    static constexpr unsigned int mask_identifier = e_annulus2;
+
+    static constexpr mask_tolerance within_epsilon = {
+        std::numeric_limits<scalar>::epsilon(),
+        std::numeric_limits<scalar>::epsilon()};
+
+    /** Assignment operator from an array, convenience function
      *
-     * It is defined by the two radii _values[0] and  _values[1] in the polar
-     * coordinate system of and endcap strip module, as well as the two phi 
-     * boundaries, _values[2] and _values[3], that are only easily definable in 
-     * the local strips system (relative to the average Phi along the 
-     * strips r coordinate). Using a conversion between the two coordinate 
-     * systems, these boundaries can be checked with a tolerance in r (t[0] and 
-     * t[1]), as well as phi (t[3] and t[3]). 
-     * Due to the local polar coordinate system of the strips needing a 
-     * different origin from the discs polar one, three additional conversion
-     * parameters are included (_values[4], values[5], _values[6]).
-     * Here, the first two are the origin shift in xy, while _values[6] is the 
-     * average Phi angle mentioned above.
-     * 
-     * @note  While the mask_context can change depending on the typed container
-     * structure the mask_identifier is a const expression that determines the
-     * mask type once for all.
-     * 
+     * @param rhs is the right hand side object
      **/
-    template <typename intersector_type = planar_intersector,
-              typename local_type = __plugin::polar2,
-              typename links_type = bool,
-              unsigned int kMaskContext = e_annulus2,
-              template <typename, unsigned int> class array_type = darray>
-    struct annulus2
-    {
-        using mask_tolerance = array_type<scalar, 2>;
-
-        using mask_values = array_type<scalar, 7>;
-
-        using mask_links_type = links_type;
-
-        mask_values _values = {0., std::numeric_limits<scalar>::infinity(),
-                               -std::numeric_limits<scalar>::infinity(),
-                               std::numeric_limits<scalar>::infinity(),
-                               0., 0., 0.};
-
-        links_type _links;
-
-        static constexpr unsigned int mask_context = kMaskContext;
-
-        static constexpr unsigned int mask_identifier = e_annulus2;
-
-        static constexpr mask_tolerance within_epsilon = {std::numeric_limits<scalar>::epsilon(),
-                                                          std::numeric_limits<scalar>::epsilon()};
-
-        /** Assignment operator from an array, convenience function
-         * 
-         * @param rhs is the right hand side object
-         **/
-        annulus2<intersector_type, local_type, links_type, kMaskContext> &
-        operator=(const array_type<scalar, 7> &rhs)
-        {
-            _values = rhs;
-            return (*this);
-        }
-
-        /** Mask operation 
-         * 
-         * @tparam inside_local_type is the local type for checking, needs to be
-         * specificed 
-         * 
-         * @param p the point to be checked in local polar coord
-         * @param t is the tolerance in (r, phi)
-         * 
-         * @return an intersection status e_inside / e_outside
-         **/
-        template <typename inside_local_type>
-        intersection_status is_inside(const point2 &p,
-                                      const mask_tolerance &t = within_epsilon) const
-        {
-            // The two quantities to check: r^2 in module system, phi in strips system
-
-            // In cartesian coordinates go to modules system by shifting origin
-            if constexpr (std::is_same_v<inside_local_type, __plugin::cartesian2>)
-            {
-                // Calculate radial coordinate in module system:
-                scalar x_mod = p[0] - _values[4];
-                scalar y_mod = p[1] - _values[5];
-                scalar r_mod2 = x_mod * x_mod + y_mod * y_mod;
-
-                // apply tolerances
-                scalar minR_tol = _values[0] - t[0];
-                scalar maxR_tol = _values[1] + t[0];
-
-                if (r_mod2 < minR_tol * minR_tol or r_mod2 > maxR_tol * maxR_tol)
-                    return e_outside;
-
-                scalar phi_strp = getter::phi(p) - _values[6];
-                // Check phi boundaries, which are well def. in local frame
-                return (phi_strp >= _values[2] - t[1] and phi_strp <= _values[3] + t[1]) ? e_inside : e_outside;
-            }
-            // polar strip coordinates given
-            else
-            {
-                // For a point p in local polar coordinates, rotate by avr phi
-                scalar phi_strp = p[1] - _values[6];
-
-                // Check phi boundaries, which are well def. in local frame
-                if (phi_strp < _values[2] - t[1] || phi_strp > _values[3] + t[1])
-                    return e_outside;
-
-                // Now go to module frame to check r boundaries. Use the origin shift
-                // in polar coordinates for that
-                point2 shift_xy = {-1 * _values[4], -1 * _values[5]};
-                scalar shift_r = getter::perp(shift_xy);
-                scalar shift_phi = getter::phi(shift_xy);
-
-                scalar r_mod2 = shift_r * shift_r + p[0] * p[0] +
-                                2 * shift_r * p[0] * std::cos(phi_strp - shift_phi);
-
-                // Apply tolerances
-                scalar minR_tol = _values[0] - t[0];
-                scalar maxR_tol = _values[1] + t[0];
-
-                return (r_mod2 >= minR_tol * minR_tol and r_mod2 <= maxR_tol * maxR_tol) ? e_inside : e_outside;
-            }
-        }
-
-        /** Equality operator from an array, convenience function
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         **/
-        bool operator==(const array_type<scalar, 7> &rhs)
-        {
-            return (_values == rhs);
-        }
+    annulus2<intersector_type, local_type, links_type, kMaskContext> &operator=(
+        const array_type<scalar, 7> &rhs) {
+        _values = rhs;
+        return (*this);
+    }
 
-        /** Equality operator 
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         **/
-        bool operator==(const annulus2<> &rhs)
-        {
-            return operator==(rhs._values);
-        }
-
-        /** Access operator - non-const
-         * @return the reference to the member variable
-         */
-        scalar &operator[](unsigned int value_index)
-        {
-            return _values[value_index];
+    /** Mask operation
+     *
+     * @tparam inside_local_type is the local type for checking, needs to be
+     * specificed
+     *
+     * @param p the point to be checked in local polar coord
+     * @param t is the tolerance in (r, phi)
+     *
+     * @return an intersection status e_inside / e_outside
+     **/
+    template <typename inside_local_type>
+    intersection_status is_inside(
+        const point2 &p, const mask_tolerance &t = within_epsilon) const {
+        // The two quantities to check: r^2 in module system, phi in strips
+        // system
+
+        // In cartesian coordinates go to modules system by shifting origin
+        if constexpr (std::is_same_v<inside_local_type, __plugin::cartesian2>) {
+            // Calculate radial coordinate in module system:
+            scalar x_mod = p[0] - _values[4];
+            scalar y_mod = p[1] - _values[5];
+            scalar r_mod2 = x_mod * x_mod + y_mod * y_mod;
+
+            // apply tolerances
+            scalar minR_tol = _values[0] - t[0];
+            scalar maxR_tol = _values[1] + t[0];
+
+            if (r_mod2 < minR_tol * minR_tol or r_mod2 > maxR_tol * maxR_tol)
+                return e_outside;
+
+            scalar phi_strp = getter::phi(p) - _values[6];
+            // Check phi boundaries, which are well def. in local frame
+            return (phi_strp >= _values[2] - t[1] and
+                    phi_strp <= _values[3] + t[1])
+                       ? e_inside
+                       : e_outside;
         }
-
-        /** Access operator - non-const
-         * @return a copy of the member variable
-         */
-        scalar operator[](unsigned int value_index) const
-        {
-            return _values[value_index];
+        // polar strip coordinates given
+        else {
+            // For a point p in local polar coordinates, rotate by avr phi
+            scalar phi_strp = p[1] - _values[6];
+
+            // Check phi boundaries, which are well def. in local frame
+            if (phi_strp < _values[2] - t[1] || phi_strp > _values[3] + t[1])
+                return e_outside;
+
+            // Now go to module frame to check r boundaries. Use the origin
+            // shift in polar coordinates for that
+            point2 shift_xy = {-1 * _values[4], -1 * _values[5]};
+            scalar shift_r = getter::perp(shift_xy);
+            scalar shift_phi = getter::phi(shift_xy);
+
+            scalar r_mod2 = shift_r * shift_r + p[0] * p[0] +
+                            2 * shift_r * p[0] * std::cos(phi_strp - shift_phi);
+
+            // Apply tolerances
+            scalar minR_tol = _values[0] - t[0];
+            scalar maxR_tol = _values[1] + t[0];
+
+            return (r_mod2 >= minR_tol * minR_tol and
+                    r_mod2 <= maxR_tol * maxR_tol)
+                       ? e_inside
+                       : e_outside;
         }
+    }
 
-        /** Return an associated intersector type */
-        intersector_type intersector() const { return intersector_type{}; };
-
-        /** Return the values */
-        const mask_values &values() const { return _values; }
-
-        /** Return the local frame type */
-        local_type local() const { return local_type{}; }
-
-        /** Return the volume link - const reference */
-        const links_type &links() const { return _links; }
-
-        /** Return the volume link - non-const access */
-        links_type &links() { return _links; }
+    /** Equality operator from an array, convenience function
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     **/
+    bool operator==(const array_type<scalar, 7> &rhs) {
+        return (_values == rhs);
+    }
 
-        /** Transform to a string for output debugging */
-        std::string to_string() const
-        {
-            std::stringstream ss;
-            ss << "annulus2," << kMaskContext;
-            for (const auto &v : _values)
-            {
-                ss << "," << v;
-            }
-            return ss.str();
+    /** Equality operator
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     **/
+    bool operator==(const annulus2<> &rhs) { return operator==(rhs._values); }
+
+    /** Access operator - non-const
+     * @return the reference to the member variable
+     */
+    scalar &operator[](unsigned int value_index) {
+        return _values[value_index];
+    }
+
+    /** Access operator - non-const
+     * @return a copy of the member variable
+     */
+    scalar operator[](unsigned int value_index) const {
+        return _values[value_index];
+    }
+
+    /** Return an associated intersector type */
+    intersector_type intersector() const { return intersector_type{}; };
+
+    /** Return the values */
+    const mask_values &values() const { return _values; }
+
+    /** Return the local frame type */
+    local_type local() const { return local_type{}; }
+
+    /** Return the volume link - const reference */
+    const links_type &links() const { return _links; }
+
+    /** Return the volume link - non-const access */
+    links_type &links() { return _links; }
+
+    /** Transform to a string for output debugging */
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << "annulus2," << kMaskContext;
+        for (const auto &v : _values) {
+            ss << "," << v;
         }
-    };
+        return ss.str();
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/masks/cylinder3.hpp b/core/include/masks/cylinder3.hpp
index 770f09cde3..e97514499d 100644
--- a/core/include/masks/cylinder3.hpp
+++ b/core/include/masks/cylinder3.hpp
@@ -1,167 +1,158 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include "masks/mask_identifier.hpp"
-#include "core/intersection.hpp"
-#include "tools/cylinder_intersector.hpp"
-
-#include <cmath>
 #include <climits>
+#include <cmath>
 #include <optional>
-#include <string>
 #include <sstream>
+#include <string>
 
-namespace detray
-{
-    /** This is a simple mask for a full cylinder
-     * 
-     * @tparam kRadialCheck is a boolean to steer wheter the radius compatibility needs to be checked
-     * @tparam intersector_type is a struct used for intersecting this cylinder
-     * @tparam links_type is an object where the mask can link to 
-     * @tparam kMaskContext is a unique mask identifier in a certain context
-     * 
-     * It is defined by r and the half length.
-     * 
-     * @note  While the mask_context can change depending on the typed container
-     * structure the mask_identifier is a const expression that determines the
-     * mask type once for all.
-     * 
-     **/
-    template <bool kRadialCheck = true,
-              typename intersector_type = detray::cylinder_intersector,
-              typename local_type = __plugin::cylindrical2,
-              typename links_type = bool,
-              unsigned int kMaskContext = e_cylinder3,
-              template <typename, unsigned int> class array_type = darray>
-    struct cylinder3
-    {
-
-        using mask_tolerance = array_type<scalar, 2>;
-
-        // This masks checks on: radius, -z, +z
-        using mask_values = array_type<scalar, 3>;
-
-        using mask_links_type = links_type;
-
-        mask_values _values =
-            {std::numeric_limits<scalar>::infinity(),
-             -std::numeric_limits<scalar>::infinity(),
-             std::numeric_limits<scalar>::infinity()};
-
-        links_type _links;
-
-        static constexpr unsigned int mask_context = kMaskContext;
-
-        static constexpr unsigned int mask_identifier = e_cylinder3;
-
-        static constexpr mask_tolerance within_epsilon = {std::numeric_limits<scalar>::epsilon(),
-                                                          std::numeric_limits<scalar>::epsilon()};
-
-        /** Assignment operator from an array, convenience function
-         * 
-         * @param rhs is the right hand side object
-         **/
-        cylinder3<kRadialCheck, intersector_type, local_type, links_type, kMaskContext> &
-        operator=(const array_type<scalar, 3> &rhs)
-        {
-            _values = rhs;
-            return (*this);
-        }
+#include "core/intersection.hpp"
+#include "masks/mask_identifier.hpp"
+#include "tools/cylinder_intersector.hpp"
 
-        /** Mask operation 
-         * 
-         * @tparam inside_local_type::point3 is the deduced type of the point to be checked w.r.t. to
-         * the mask bounds, it's assumed to be within the cylinder 3D frame
-         * 
-         * @param p the point to be checked
-         * @param t is the tolerance tuple in (radius, z)
-         * 
-         * @return an intersection status e_inside / e_outside
-         **/
-        template <typename inside_local_type>
-        intersection_status is_inside(const point3 &p,
-                                      const mask_tolerance &t = within_epsilon) const
-        {
-            if (kRadialCheck)
-            {
-                scalar r = getter::perp(p);
-                if (std::abs(r - _values[0]) >= t[0] + 5 * std::numeric_limits<scalar>::epsilon())
-                {
-                    return e_missed;
-                }
+namespace detray {
+/** This is a simple mask for a full cylinder
+ *
+ * @tparam kRadialCheck is a boolean to steer wheter the radius compatibility
+ *needs to be checked
+ * @tparam intersector_type is a struct used for intersecting this cylinder
+ * @tparam links_type is an object where the mask can link to
+ * @tparam kMaskContext is a unique mask identifier in a certain context
+ *
+ * It is defined by r and the half length.
+ *
+ * @note  While the mask_context can change depending on the typed container
+ * structure the mask_identifier is a const expression that determines the
+ * mask type once for all.
+ *
+ **/
+template <bool kRadialCheck = true,
+          typename intersector_type = detray::cylinder_intersector,
+          typename local_type = __plugin::cylindrical2,
+          typename links_type = bool, unsigned int kMaskContext = e_cylinder3,
+          template <typename, unsigned int> class array_type = darray>
+struct cylinder3 {
+
+    using mask_tolerance = array_type<scalar, 2>;
+
+    // This masks checks on: radius, -z, +z
+    using mask_values = array_type<scalar, 3>;
+
+    using mask_links_type = links_type;
+
+    mask_values _values = {std::numeric_limits<scalar>::infinity(),
+                           -std::numeric_limits<scalar>::infinity(),
+                           std::numeric_limits<scalar>::infinity()};
+
+    links_type _links;
+
+    static constexpr unsigned int mask_context = kMaskContext;
+
+    static constexpr unsigned int mask_identifier = e_cylinder3;
+
+    static constexpr mask_tolerance within_epsilon = {
+        std::numeric_limits<scalar>::epsilon(),
+        std::numeric_limits<scalar>::epsilon()};
+
+    /** Assignment operator from an array, convenience function
+     *
+     * @param rhs is the right hand side object
+     **/
+    cylinder3<kRadialCheck, intersector_type, local_type, links_type,
+              kMaskContext>
+        &operator=(const array_type<scalar, 3> &rhs) {
+        _values = rhs;
+        return (*this);
+    }
+
+    /** Mask operation
+     *
+     * @tparam inside_local_type::point3 is the deduced type of the point to be
+     *checked w.r.t. to the mask bounds, it's assumed to be within the cylinder
+     *3D frame
+     *
+     * @param p the point to be checked
+     * @param t is the tolerance tuple in (radius, z)
+     *
+     * @return an intersection status e_inside / e_outside
+     **/
+    template <typename inside_local_type>
+    intersection_status is_inside(
+        const point3 &p, const mask_tolerance &t = within_epsilon) const {
+        if (kRadialCheck) {
+            scalar r = getter::perp(p);
+            if (std::abs(r - _values[0]) >=
+                t[0] + 5 * std::numeric_limits<scalar>::epsilon()) {
+                return e_missed;
             }
-            return (_values[1] - t[1] <= p[2] and p[2] <= _values[2] + t[1]) ? e_inside : e_outside;
-        }
-
-        /** Equality operator from an array, convenience function
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         * checks identity within epsilon and @return s a boolean*
-         **/
-        bool operator==(const array_type<scalar, 3> &rhs)
-        {
-            return (_values == rhs);
-        }
-
-        /** Equality operator 
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         * checks identity within epsilon and @return s a boolean*
-         **/
-        bool operator==(const cylinder3<> &rhs)
-        {
-            return operator==(rhs._values);
-        }
-
-        /** Access operator - non-const
-         * @return the reference to the member variable
-         */
-        scalar &operator[](unsigned int value_index)
-        {
-            return _values[value_index];
-        }
-
-        /** Access operator - non-const
-         * @return a copy of the member variable
-         */
-        scalar operator[](unsigned int value_index) const
-        {
-            return _values[value_index];
         }
-
-        /** Return an associated intersector type */
-        intersector_type intersector() const { return intersector_type{}; };
-
-        /** Return the values */
-        const mask_values &values() const { return _values; }
-
-        /** Return the local frame type */
-        local_type local() const { return local_type{}; }
-
-        /** Return the volume link - const reference */
-        const links_type &links() const { return _links; }
-
-        /** Return the volume link - non-const access */
-        links_type &links() { return _links; }
-
-        /** Transform to a string for output debugging */
-        std::string to_string() const
-        {
-            std::stringstream ss;
-            ss << "cylinder3," << kMaskContext;
-            for (const auto &v : _values)
-            {
-                ss << "," << v;
-            }
-            return ss.str();
+        return (_values[1] - t[1] <= p[2] and p[2] <= _values[2] + t[1])
+                   ? e_inside
+                   : e_outside;
+    }
+
+    /** Equality operator from an array, convenience function
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     * checks identity within epsilon and @return s a boolean*
+     **/
+    bool operator==(const array_type<scalar, 3> &rhs) {
+        return (_values == rhs);
+    }
+
+    /** Equality operator
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     * checks identity within epsilon and @return s a boolean*
+     **/
+    bool operator==(const cylinder3<> &rhs) { return operator==(rhs._values); }
+
+    /** Access operator - non-const
+     * @return the reference to the member variable
+     */
+    scalar &operator[](unsigned int value_index) {
+        return _values[value_index];
+    }
+
+    /** Access operator - non-const
+     * @return a copy of the member variable
+     */
+    scalar operator[](unsigned int value_index) const {
+        return _values[value_index];
+    }
+
+    /** Return an associated intersector type */
+    intersector_type intersector() const { return intersector_type{}; };
+
+    /** Return the values */
+    const mask_values &values() const { return _values; }
+
+    /** Return the local frame type */
+    local_type local() const { return local_type{}; }
+
+    /** Return the volume link - const reference */
+    const links_type &links() const { return _links; }
+
+    /** Return the volume link - non-const access */
+    links_type &links() { return _links; }
+
+    /** Transform to a string for output debugging */
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << "cylinder3," << kMaskContext;
+        for (const auto &v : _values) {
+            ss << "," << v;
         }
-    };
+        return ss.str();
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/masks/mask_identifier.hpp b/core/include/masks/mask_identifier.hpp
index bb947e8679..f2dfc4200f 100644
--- a/core/include/masks/mask_identifier.hpp
+++ b/core/include/masks/mask_identifier.hpp
@@ -1,22 +1,22 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
 namespace detray {
 
-	/** Enumerate different mask types for convenience
-	**/
-	enum mask_context : unsigned int {
-		e_rectangle2 = 0,
-		e_trapezoid2 = 1,
-		e_ring2 = 2,
-		e_cylinder3 = 3,
-		e_single3 = 4,
-		e_annulus2 = 5,
-	};
+/** Enumerate different mask types for convenience
+ **/
+enum mask_context : unsigned int {
+    e_rectangle2 = 0,
+    e_trapezoid2 = 1,
+    e_ring2 = 2,
+    e_cylinder3 = 3,
+    e_single3 = 4,
+    e_annulus2 = 5,
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/masks/masks.hpp b/core/include/masks/masks.hpp
index e0cf6ad73d..f9fbfea86d 100644
--- a/core/include/masks/masks.hpp
+++ b/core/include/masks/masks.hpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/core/include/masks/rectangle2.hpp b/core/include/masks/rectangle2.hpp
index f250562d54..c98e89d650 100644
--- a/core/include/masks/rectangle2.hpp
+++ b/core/include/masks/rectangle2.hpp
@@ -1,155 +1,145 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include "masks/mask_identifier.hpp"
-#include "core/intersection.hpp"
-#include "tools/planar_intersector.hpp"
-
-#include <cmath>
 #include <climits>
-#include <string>
+#include <cmath>
 #include <sstream>
+#include <string>
 
-namespace detray
-{
-
-    /** This is a simple 2-dimensional mask for a regular rectangle
-     * 
-     * @tparam intersector_type is a struct used for intersecting this cylinder
-     * @tparam local_type is the default local frame definition type
-     * @tparam links_type is an object where the mask can link to 
-     * @tparam kMaskContext is a unique mask identifier in a certain context
-     * 
-     * It is defined by half length in local0 coordinates _values[0] and _values[1], 
-     * and can be checked with a tolerance in t[0] and t[1].
-     * 
-     * @note  While the mask_context can change depending on the typed container
-     * structure the mask_identifier is a const expression that determines the
-     * mask type once for all.
-     *  
-     **/
-    template <typename intersector_type = planar_intersector,
-              typename local_type = __plugin::cartesian2,
-              typename links_type = bool,
-              unsigned int kMaskContext = e_rectangle2,
-              template <typename, unsigned int> class array_type = darray>
-    struct rectangle2
-    {
-        using mask_tolerance = array_type<scalar, 2>;
-
-        using mask_values = array_type<scalar, 2>;
-
-        using mask_links_type = links_type;
-
-        mask_values _values =
-            {std::numeric_limits<scalar>::infinity(),
-             std::numeric_limits<scalar>::infinity()};
-
-        links_type _links;
-
-        static constexpr unsigned int mask_context = kMaskContext;
-
-        static constexpr unsigned int mask_indentifier = e_rectangle2;
-
-        static constexpr mask_tolerance within_epsilon = {std::numeric_limits<scalar>::epsilon(),
-                                                          std::numeric_limits<scalar>::epsilon()};
-
-        /** Assignment operator from an array, convenience function
-         * 
-         * @param rhs is the right hand side object
-         **/
-        rectangle2<intersector_type, local_type, links_type, kMaskContext> &
-        operator=(const array_type<scalar, 2> &rhs)
-        {
-            _values = rhs;
-            return (*this);
-        }
-
-        /** Mask operation 
-         * 
-         * @tparam inside_local_type is the local type for inside checking
-         * 
-         * @param p the point to be checked
-         * @param t is the tolerance tuple in (l0, l1)
-         * 
-         * @return an intersection status e_inside / e_outside
-         **/
-        template <typename inside_local_type>
-        intersection_status is_inside(const point2 &p,
-                                      const mask_tolerance &t = within_epsilon) const
-        {
-            return (std::abs(p[0]) <= _values[0] + t[0] and std::abs(p[1]) <= _values[1] + t[1]) ? e_inside : e_outside;
-        }
-
-        /** Equality operator from an array, convenience function
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         * checks identity within epsilon and @return s a boolean*
-         **/
-        bool operator==(const array_type<scalar, 2> &rhs)
-        {
-            return (_values == rhs);
-        }
-
-        /** Equality operator 
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         * checks identity within epsilon and @return s a boolean*
-         **/
-        bool operator==(const rectangle2<> &rhs)
-        {
-            return operator==(rhs._values);
-        }
-
-        /** Access operator - non-const
-         * @return the reference to the member variable
-         */
-        scalar &operator[](unsigned int value_index)
-        {
-            return _values[value_index];
-        }
-
-        /** Access operator - non-const
-         * @return a copy of the member variable
-         */
-        scalar operator[](unsigned int value_index) const
-        {
-            return _values[value_index];
-        }
-
-        /** Return the values */
-        const mask_values &values() const { return _values; }
-
-        /** Return an associated intersector type */
-        intersector_type intersector() const { return intersector_type{}; };
-
-        /** Return the local frame type */
-        local_type local() const { return local_type{}; }
-
-        /** Return the volume link - const reference */
-        const links_type &links() const { return _links; }
-
-        /** Return the volume link - non-const access */
-        links_type &links() { return _links; }
+#include "core/intersection.hpp"
+#include "masks/mask_identifier.hpp"
+#include "tools/planar_intersector.hpp"
 
-        /** Transform to a string for output debugging */
-        std::string to_string() const
-        {
-            std::stringstream ss;
-            ss << "rectangle2," << kMaskContext;
-            for (const auto &v : _values)
-            {
-                ss << "," << v;
-            }
-            return ss.str();
+namespace detray {
+
+/** This is a simple 2-dimensional mask for a regular rectangle
+ *
+ * @tparam intersector_type is a struct used for intersecting this cylinder
+ * @tparam local_type is the default local frame definition type
+ * @tparam links_type is an object where the mask can link to
+ * @tparam kMaskContext is a unique mask identifier in a certain context
+ *
+ * It is defined by half length in local0 coordinates _values[0] and _values[1],
+ * and can be checked with a tolerance in t[0] and t[1].
+ *
+ * @note  While the mask_context can change depending on the typed container
+ * structure the mask_identifier is a const expression that determines the
+ * mask type once for all.
+ *
+ **/
+template <typename intersector_type = planar_intersector,
+          typename local_type = __plugin::cartesian2,
+          typename links_type = bool, unsigned int kMaskContext = e_rectangle2,
+          template <typename, unsigned int> class array_type = darray>
+struct rectangle2 {
+    using mask_tolerance = array_type<scalar, 2>;
+
+    using mask_values = array_type<scalar, 2>;
+
+    using mask_links_type = links_type;
+
+    mask_values _values = {std::numeric_limits<scalar>::infinity(),
+                           std::numeric_limits<scalar>::infinity()};
+
+    links_type _links;
+
+    static constexpr unsigned int mask_context = kMaskContext;
+
+    static constexpr unsigned int mask_indentifier = e_rectangle2;
+
+    static constexpr mask_tolerance within_epsilon = {
+        std::numeric_limits<scalar>::epsilon(),
+        std::numeric_limits<scalar>::epsilon()};
+
+    /** Assignment operator from an array, convenience function
+     *
+     * @param rhs is the right hand side object
+     **/
+    rectangle2<intersector_type, local_type, links_type, kMaskContext>
+        &operator=(const array_type<scalar, 2> &rhs) {
+        _values = rhs;
+        return (*this);
+    }
+
+    /** Mask operation
+     *
+     * @tparam inside_local_type is the local type for inside checking
+     *
+     * @param p the point to be checked
+     * @param t is the tolerance tuple in (l0, l1)
+     *
+     * @return an intersection status e_inside / e_outside
+     **/
+    template <typename inside_local_type>
+    intersection_status is_inside(
+        const point2 &p, const mask_tolerance &t = within_epsilon) const {
+        return (std::abs(p[0]) <= _values[0] + t[0] and
+                std::abs(p[1]) <= _values[1] + t[1])
+                   ? e_inside
+                   : e_outside;
+    }
+
+    /** Equality operator from an array, convenience function
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     * checks identity within epsilon and @return s a boolean*
+     **/
+    bool operator==(const array_type<scalar, 2> &rhs) {
+        return (_values == rhs);
+    }
+
+    /** Equality operator
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     * checks identity within epsilon and @return s a boolean*
+     **/
+    bool operator==(const rectangle2<> &rhs) { return operator==(rhs._values); }
+
+    /** Access operator - non-const
+     * @return the reference to the member variable
+     */
+    scalar &operator[](unsigned int value_index) {
+        return _values[value_index];
+    }
+
+    /** Access operator - non-const
+     * @return a copy of the member variable
+     */
+    scalar operator[](unsigned int value_index) const {
+        return _values[value_index];
+    }
+
+    /** Return the values */
+    const mask_values &values() const { return _values; }
+
+    /** Return an associated intersector type */
+    intersector_type intersector() const { return intersector_type{}; };
+
+    /** Return the local frame type */
+    local_type local() const { return local_type{}; }
+
+    /** Return the volume link - const reference */
+    const links_type &links() const { return _links; }
+
+    /** Return the volume link - non-const access */
+    links_type &links() { return _links; }
+
+    /** Transform to a string for output debugging */
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << "rectangle2," << kMaskContext;
+        for (const auto &v : _values) {
+            ss << "," << v;
         }
-    };
+        return ss.str();
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/masks/ring2.hpp b/core/include/masks/ring2.hpp
index dc2b7be133..e6ba314e8b 100644
--- a/core/include/masks/ring2.hpp
+++ b/core/include/masks/ring2.hpp
@@ -1,157 +1,146 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include "masks/mask_identifier.hpp"
-#include "core/intersection.hpp"
-#include "tools/planar_intersector.hpp"
-
-#include <cmath>
 #include <climits>
-#include <string>
+#include <cmath>
 #include <sstream>
+#include <string>
 
-namespace detray
-{
-    /** This is a simple 2-dimensional mask for a closed ring
-     * 
-     * @tparam intersector_type is a struct used for intersecting this cylinder
-     * @tparam local_type is the default local frame type
-     * @tparam links_type is an object where the mask can link to 
-     * @tparam kMaskContext is a unique mask identifier in a certain context
-     *  
-     * It is defined by the two radii _values[0] and  _values[1], 
-     * and can be checked with a tolerance in t[0] and t[1].
-     * 
-     * @note  While the mask_context can change depending on the typed container
-     * structure the mask_identifier is a const expression that determines the
-     * mask type once for all.
-     * 
-     **/
-    template <typename intersector_type = planar_intersector,
-              typename local_type = __plugin::cartesian2,
-              typename links_type = bool,
-              unsigned int kMaskContext = e_ring2,
-              template <typename, unsigned int> class array_type = darray>
-    struct ring2
-    {
-        using mask_tolerance = scalar;
-
-        using mask_values = array_type<scalar, 2>;
-
-        using mask_links_type = links_type;
-
-        mask_values _values = {0., std::numeric_limits<scalar>::infinity()};
-
-        links_type _links;
-
-        static constexpr unsigned int mask_context = kMaskContext;
-
-        static constexpr unsigned int mask_identifier = e_ring2;
-
-        static constexpr mask_tolerance within_epsilon = std::numeric_limits<scalar>::epsilon();
-
-        /** Assignment operator from an array, convenience function
-         * 
-         * @param rhs is the right hand side object
-         **/
-        ring2<intersector_type, local_type, links_type, kMaskContext> &
-        operator=(const array_type<scalar, 2> &rhs)
-        {
-            _values = rhs;
-            return (*this);
-        }
-
-        /** Mask operation 
-         * 
-         * @tparam inside_local_type is the local type for inside checking
-         * 
-         * @param p the point to be checked
-         * @param t is the tolerance in r
-         * 
-         * @return an intersection status e_inside / e_outside
-         **/
-        template <typename inside_local_type>
-        intersection_status is_inside(const point2 &p,
-                                      const mask_tolerance &t = within_epsilon) const
-        {
-            if constexpr (std::is_same_v<inside_local_type, __plugin::cartesian2>)
-            {
-                scalar r = getter::perp(p);
-                return (r + t >= _values[0] and r <= _values[1] + t) ? e_inside : e_outside;
-            }
-
-            return (p[0] + t >= _values[0] and p[0] <= _values[1] + t) ? e_inside : e_outside;
-        }
-
-        /** Equality operator from an array, convenience function
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         * checks identity within epsilon and @return s a boolean*
-         **/
-        bool operator==(const array_type<scalar, 2> &rhs)
-        {
-            return (_values == rhs);
-        }
-
-        /** Equality operator 
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         * checks identity within epsilon and @return s a boolean*
-         **/
-        bool operator==(const ring2<> &rhs)
-        {
-            return operator==(rhs._values);
-        }
-
-        /** Access operator - non-const
-         * @return the reference to the member variable
-         */
-        scalar &operator[](unsigned int value_index)
-        {
-            return _values[value_index];
-        }
+#include "core/intersection.hpp"
+#include "masks/mask_identifier.hpp"
+#include "tools/planar_intersector.hpp"
 
-        /** Access operator - non-const
-         * @return a copy of the member variable
-         */
-        scalar operator[](unsigned int value_index) const
-        {
-            return _values[value_index];
+namespace detray {
+/** This is a simple 2-dimensional mask for a closed ring
+ *
+ * @tparam intersector_type is a struct used for intersecting this cylinder
+ * @tparam local_type is the default local frame type
+ * @tparam links_type is an object where the mask can link to
+ * @tparam kMaskContext is a unique mask identifier in a certain context
+ *
+ * It is defined by the two radii _values[0] and  _values[1],
+ * and can be checked with a tolerance in t[0] and t[1].
+ *
+ * @note  While the mask_context can change depending on the typed container
+ * structure the mask_identifier is a const expression that determines the
+ * mask type once for all.
+ *
+ **/
+template <typename intersector_type = planar_intersector,
+          typename local_type = __plugin::cartesian2,
+          typename links_type = bool, unsigned int kMaskContext = e_ring2,
+          template <typename, unsigned int> class array_type = darray>
+struct ring2 {
+    using mask_tolerance = scalar;
+
+    using mask_values = array_type<scalar, 2>;
+
+    using mask_links_type = links_type;
+
+    mask_values _values = {0., std::numeric_limits<scalar>::infinity()};
+
+    links_type _links;
+
+    static constexpr unsigned int mask_context = kMaskContext;
+
+    static constexpr unsigned int mask_identifier = e_ring2;
+
+    static constexpr mask_tolerance within_epsilon =
+        std::numeric_limits<scalar>::epsilon();
+
+    /** Assignment operator from an array, convenience function
+     *
+     * @param rhs is the right hand side object
+     **/
+    ring2<intersector_type, local_type, links_type, kMaskContext> &operator=(
+        const array_type<scalar, 2> &rhs) {
+        _values = rhs;
+        return (*this);
+    }
+
+    /** Mask operation
+     *
+     * @tparam inside_local_type is the local type for inside checking
+     *
+     * @param p the point to be checked
+     * @param t is the tolerance in r
+     *
+     * @return an intersection status e_inside / e_outside
+     **/
+    template <typename inside_local_type>
+    intersection_status is_inside(
+        const point2 &p, const mask_tolerance &t = within_epsilon) const {
+        if constexpr (std::is_same_v<inside_local_type, __plugin::cartesian2>) {
+            scalar r = getter::perp(p);
+            return (r + t >= _values[0] and r <= _values[1] + t) ? e_inside
+                                                                 : e_outside;
         }
 
-        /** Return an associated intersector type */
-        intersector_type intersector() const { return intersector_type{}; };
-
-        /** Return the values */
-        const mask_values &values() const { return _values; }
-
-        /** Return the local frame type */
-        local_type local() const { return local_type{}; }
+        return (p[0] + t >= _values[0] and p[0] <= _values[1] + t) ? e_inside
+                                                                   : e_outside;
+    }
 
-        /** Return the volume link - const reference */
-        const links_type &links() const { return _links; }
-
-        /** Return the volume link - non-const access */
-        links_type &links() { return _links; }
-
-        /** Transform to a string for output debugging */
-        std::string to_string() const
-        {
-            std::stringstream ss;
-            ss << "ring2," << kMaskContext;
-            for (const auto &v : _values)
-            {
-                ss << "," << v;
-            }
-            return ss.str();
+    /** Equality operator from an array, convenience function
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     * checks identity within epsilon and @return s a boolean*
+     **/
+    bool operator==(const array_type<scalar, 2> &rhs) {
+        return (_values == rhs);
+    }
+
+    /** Equality operator
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     * checks identity within epsilon and @return s a boolean*
+     **/
+    bool operator==(const ring2<> &rhs) { return operator==(rhs._values); }
+
+    /** Access operator - non-const
+     * @return the reference to the member variable
+     */
+    scalar &operator[](unsigned int value_index) {
+        return _values[value_index];
+    }
+
+    /** Access operator - non-const
+     * @return a copy of the member variable
+     */
+    scalar operator[](unsigned int value_index) const {
+        return _values[value_index];
+    }
+
+    /** Return an associated intersector type */
+    intersector_type intersector() const { return intersector_type{}; };
+
+    /** Return the values */
+    const mask_values &values() const { return _values; }
+
+    /** Return the local frame type */
+    local_type local() const { return local_type{}; }
+
+    /** Return the volume link - const reference */
+    const links_type &links() const { return _links; }
+
+    /** Return the volume link - non-const access */
+    links_type &links() { return _links; }
+
+    /** Transform to a string for output debugging */
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << "ring2," << kMaskContext;
+        for (const auto &v : _values) {
+            ss << "," << v;
         }
-    };
+        return ss.str();
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/masks/single3.hpp b/core/include/masks/single3.hpp
index 869cafcde5..ef89ba5b3e 100644
--- a/core/include/masks/single3.hpp
+++ b/core/include/masks/single3.hpp
@@ -1,151 +1,143 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include "masks/mask_identifier.hpp"
-#include "core/intersection.hpp"
-#include "tools/planar_intersector.hpp"
-
-#include <cmath>
 #include <climits>
-#include <string>
+#include <cmath>
 #include <sstream>
+#include <string>
 
-namespace detray
-{
-    /** This is a simple mask for single parameter bound mask
-     * 
-     * @tparam kCheckIndex is the index of the position on which the mask is applied
-     * @tparam intersector_type is a struct used for intersecting this cylinder
-     * @tparam local_type is the default local frame definition type
-     * @tparam links_type is an object where the mask can link to 
-     * @tparam kMaskContext is a unique mask identifier in a certain context
-     * 
-     * @note  While the mask_context can change depending on the typed container
-     * structure the mask_identifier is a const expression that determines the
-     * mask type once for all.
-     * 
-     **/
-    template <unsigned int kCheckIndex,
-              typename intersector_type = planar_intersector,
-              typename local_type = __plugin::cartesian2,
-              typename links_type = bool,
-              unsigned int kMaskContext = e_single3,
-              template <typename, unsigned int> class array_type = darray>
-    struct single3
-    {
-
-        using mask_tolerance = scalar;
-
-        /// This mask has min, max to check on
-        using mask_values = array_type<scalar, 2>;
-
-        using mask_links_type = links_type;
-
-        mask_values _values =
-            {std::numeric_limits<scalar>::infinity()};
-
-        links_type _links;
-
-        static constexpr unsigned int mask_context = kMaskContext;
-
-        static constexpr unsigned int mask_identifier = e_single3;
-
-        static constexpr mask_tolerance within_epsilon = std::numeric_limits<scalar>::epsilon();
-
-        /** Assignment operator from an array, convenience function
-         * 
-         * @param rhs is the right hand side object
-         **/
-        single3<kCheckIndex, intersector_type, local_type, links_type, kMaskContext> &
-        operator=(const array_type<scalar, 2> &rhs)
-        {
-            _values = rhs;
-            return (*this);
-        }
-
-        /** Mask operation 
-         * 
-         * @tparam inside_local_type is the global type for checking (ignored)
-         * 
-         * @param p the point to be checked
-         * @param t is the tolerance of the single parameter
-         * 
-         * @return an intersection status e_inside / e_outside
-         **/
-        template <typename inside_local_type>
-        intersection_status is_inside(const point3 &p,
-                                      const mask_tolerance &t = within_epsilon) const
-        {
-            return (_values[0] - t <= p[kCheckIndex] and p[kCheckIndex] <= _values[1] + t) ? e_inside : e_outside;
-        }
+#include "core/intersection.hpp"
+#include "masks/mask_identifier.hpp"
+#include "tools/planar_intersector.hpp"
 
-        /** Equality operator from an array, convenience function
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         **/
-        bool operator==(const array_type<scalar, 2> &rhs)
-        {
-            return (_values == rhs);
-        }
+namespace detray {
+/** This is a simple mask for single parameter bound mask
+ *
+ * @tparam kCheckIndex is the index of the position on which the mask is applied
+ * @tparam intersector_type is a struct used for intersecting this cylinder
+ * @tparam local_type is the default local frame definition type
+ * @tparam links_type is an object where the mask can link to
+ * @tparam kMaskContext is a unique mask identifier in a certain context
+ *
+ * @note  While the mask_context can change depending on the typed container
+ * structure the mask_identifier is a const expression that determines the
+ * mask type once for all.
+ *
+ **/
+template <unsigned int kCheckIndex,
+          typename intersector_type = planar_intersector,
+          typename local_type = __plugin::cartesian2,
+          typename links_type = bool, unsigned int kMaskContext = e_single3,
+          template <typename, unsigned int> class array_type = darray>
+struct single3 {
 
-        /** Equality operator 
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         **/
-        bool operator==(const single3<kCheckIndex> &rhs)
-        {
-            return operator==(rhs._values);
-        }
+    using mask_tolerance = scalar;
 
-        /** Access operator - non-const
-         * @return the reference to the member variable
-         */
-        scalar &operator[](unsigned int value_index)
-        {
-            return _values[value_index];
-        }
+    /// This mask has min, max to check on
+    using mask_values = array_type<scalar, 2>;
 
-        /** Access operator - non-const
-         * @return a copy of the member variable
-         */
-        scalar operator[](unsigned int value_index) const
-        {
-            return _values[value_index];
-        }
+    using mask_links_type = links_type;
 
-        /** Return an associated intersector type */
-        intersector_type intersector() const { return intersector_type{}; };
+    mask_values _values = {std::numeric_limits<scalar>::infinity()};
 
-        /** Return the values */
-        const mask_values &values() const { return _values; }
+    links_type _links;
 
-        /** Return the local frame type */
-        local_type local() const { return local_type{}; }
+    static constexpr unsigned int mask_context = kMaskContext;
 
-        /** Return the volume link - const reference */
-        const links_type &links() const { return _links; }
+    static constexpr unsigned int mask_identifier = e_single3;
 
-        /** Return the volume link - non-const access */
-        links_type &links() { return _links; }
+    static constexpr mask_tolerance within_epsilon =
+        std::numeric_limits<scalar>::epsilon();
 
-        /** Transform to a string for output debugging */
-        std::string to_string() const
-        {
-            std::stringstream ss;
-            ss << "single3," << kMaskContext;
-            for (const auto &v : _values)
-            {
-                ss << "," << v;
-            }
-            return ss.str();
+    /** Assignment operator from an array, convenience function
+     *
+     * @param rhs is the right hand side object
+     **/
+    single3<kCheckIndex, intersector_type, local_type, links_type, kMaskContext>
+        &operator=(const array_type<scalar, 2> &rhs) {
+        _values = rhs;
+        return (*this);
+    }
+
+    /** Mask operation
+     *
+     * @tparam inside_local_type is the global type for checking (ignored)
+     *
+     * @param p the point to be checked
+     * @param t is the tolerance of the single parameter
+     *
+     * @return an intersection status e_inside / e_outside
+     **/
+    template <typename inside_local_type>
+    intersection_status is_inside(
+        const point3 &p, const mask_tolerance &t = within_epsilon) const {
+        return (_values[0] - t <= p[kCheckIndex] and
+                p[kCheckIndex] <= _values[1] + t)
+                   ? e_inside
+                   : e_outside;
+    }
+
+    /** Equality operator from an array, convenience function
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     **/
+    bool operator==(const array_type<scalar, 2> &rhs) {
+        return (_values == rhs);
+    }
+
+    /** Equality operator
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     **/
+    bool operator==(const single3<kCheckIndex> &rhs) {
+        return operator==(rhs._values);
+    }
+
+    /** Access operator - non-const
+     * @return the reference to the member variable
+     */
+    scalar &operator[](unsigned int value_index) {
+        return _values[value_index];
+    }
+
+    /** Access operator - non-const
+     * @return a copy of the member variable
+     */
+    scalar operator[](unsigned int value_index) const {
+        return _values[value_index];
+    }
+
+    /** Return an associated intersector type */
+    intersector_type intersector() const { return intersector_type{}; };
+
+    /** Return the values */
+    const mask_values &values() const { return _values; }
+
+    /** Return the local frame type */
+    local_type local() const { return local_type{}; }
+
+    /** Return the volume link - const reference */
+    const links_type &links() const { return _links; }
+
+    /** Return the volume link - non-const access */
+    links_type &links() { return _links; }
+
+    /** Transform to a string for output debugging */
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << "single3," << kMaskContext;
+        for (const auto &v : _values) {
+            ss << "," << v;
         }
-    };
+        return ss.str();
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/masks/trapezoid2.hpp b/core/include/masks/trapezoid2.hpp
index 09a8c25fa5..26acebfa2e 100644
--- a/core/include/masks/trapezoid2.hpp
+++ b/core/include/masks/trapezoid2.hpp
@@ -1,156 +1,148 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include "masks/mask_identifier.hpp"
-#include "core/intersection.hpp"
-#include "tools/planar_intersector.hpp"
-
-#include <cmath>
 #include <climits>
+#include <cmath>
 #include <sstream>
 #include <string>
 
-namespace detray
-{
-    /** This is a simple 2-dimensional mask for a regular trapezoid
-     * 
-     * @tparam intersector_type is a struct used for intersecting this cylinder
-     * @tparam local_type is the default local frame definition type
-     * @tparam links_type is an object where the mask can link to 
-     * @tparam kMaskContext is a unique mask identifier in a certain context
-     *  
-     * It is defined by half lengths in local0 coordinate _values[0] and _values[1] at
-     * -/+ half length in the local1 coordinate _values[2]
-     * 
-     * @note  While the mask_context can change depending on the typed container
-     * structure the mask_identifier is a const expression that determines the
-     * mask type once for all.
-     *  
-     **/
-    template <typename intersector_type = planar_intersector,
-              typename local_type = __plugin::cartesian2,
-              typename links_type = bool,
-              unsigned int kMaskContext = e_trapezoid2,
-              template <typename, unsigned int> class array_type = darray>
-    struct trapezoid2
-    {
-        using mask_tolerance = array_type<scalar, 2>;
-
-        using mask_values = array_type<scalar, 3>;
-
-        using mask_links_type = links_type;
-
-        mask_values _values =
-            {std::numeric_limits<scalar>::infinity(),
-             std::numeric_limits<scalar>::infinity(),
-             std::numeric_limits<scalar>::infinity()};
-
-        links_type _links;
-
-        static constexpr unsigned int mask_context = kMaskContext;
-
-        static constexpr unsigned int mask_identifier = e_trapezoid2;
-
-        static constexpr mask_tolerance within_epsilon = {std::numeric_limits<scalar>::epsilon(),
-                                                          std::numeric_limits<scalar>::epsilon()};
-
-        /** Assignment operator from an array, convenience function
-         * 
-         * @param rhs is the right hand side object
-         **/
-        trapezoid2<intersector_type, local_type, links_type, kMaskContext> &
-        operator=(const array_type<scalar, 3> &rhs)
-        {
-            _values = rhs;
-            return (*this);
-        }
-
-        /** Mask operation 
-         * 
-         * @tparam inside_local_type is the type of the local frame (ignored here)
-         * 
-         * @param p the point to be checked
-         * @param t us the tolerance tuple (l0,l1)
-         * 
-         * @return an intersection status e_inside / e_outside
-         **/
-        template <typename inside_local_type>
-        intersection_status is_inside(const point2 &p,
-                                      const mask_tolerance &t = within_epsilon) const
-        {
-            scalar rel_y = (_values[2] + p[1]) / (2 * _values[2]);
-            return (std::abs(p[0]) <= _values[0] + rel_y * (_values[1] - _values[0]) + t[0] and std::abs(p[1]) <= _values[2] + t[1]) ? e_inside : e_outside;
-        }
-
-        /** Equality operator from an array, convenience function
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         * checks identity within epsilon and @return s a boolean*
-         **/
-        bool operator==(const array_type<scalar, 3> &rhs)
-        {
-            return (_values == rhs);
-        }
-
-        /** Equality operator 
-         * 
-         * @param rhs is the rectangle to be compared with
-         * 
-         * checks identity within epsilon and @return s a boolean*
-         **/
-        bool operator==(const trapezoid2<> &rhs)
-        {
-            return operator==(rhs._values);
-        }
-
-        /** Access operator - non-const
-         * @return the reference to the member variable
-         */
-        scalar &operator[](unsigned int value_index)
-        {
-            return _values[value_index];
-        }
-
-        /** Access operator - non-const
-         * @return a copy of the member variable
-         */
-        scalar operator[](unsigned int value_index) const
-        {
-            return _values[value_index];
-        }
-
-        /** Return an associated intersector type */
-        intersector_type intersector() const { return intersector_type{}; };
-
-        /** Return the values */
-        const mask_values &values() const { return _values; }
-
-        /** Return the local frame type */
-        local_type local() const { return local_type{}; }
-
-        /** Return the volume link - const reference */
-        const links_type &links() const { return _links; }
-
-        /** Return the volume link - non-const access */
-        links_type &links() { return _links; }
+#include "core/intersection.hpp"
+#include "masks/mask_identifier.hpp"
+#include "tools/planar_intersector.hpp"
 
-        /** Transform to a string for output debugging */
-        std::string to_string() const
-        {
-            std::stringstream ss;
-            ss << "trapezoid2," << kMaskContext;
-            for (const auto &v : _values)
-            {
-                ss << "," << v;
-            }
-            return ss.str();
+namespace detray {
+/** This is a simple 2-dimensional mask for a regular trapezoid
+ *
+ * @tparam intersector_type is a struct used for intersecting this cylinder
+ * @tparam local_type is the default local frame definition type
+ * @tparam links_type is an object where the mask can link to
+ * @tparam kMaskContext is a unique mask identifier in a certain context
+ *
+ * It is defined by half lengths in local0 coordinate _values[0] and _values[1]
+ *at
+ * -/+ half length in the local1 coordinate _values[2]
+ *
+ * @note  While the mask_context can change depending on the typed container
+ * structure the mask_identifier is a const expression that determines the
+ * mask type once for all.
+ *
+ **/
+template <typename intersector_type = planar_intersector,
+          typename local_type = __plugin::cartesian2,
+          typename links_type = bool, unsigned int kMaskContext = e_trapezoid2,
+          template <typename, unsigned int> class array_type = darray>
+struct trapezoid2 {
+    using mask_tolerance = array_type<scalar, 2>;
+
+    using mask_values = array_type<scalar, 3>;
+
+    using mask_links_type = links_type;
+
+    mask_values _values = {std::numeric_limits<scalar>::infinity(),
+                           std::numeric_limits<scalar>::infinity(),
+                           std::numeric_limits<scalar>::infinity()};
+
+    links_type _links;
+
+    static constexpr unsigned int mask_context = kMaskContext;
+
+    static constexpr unsigned int mask_identifier = e_trapezoid2;
+
+    static constexpr mask_tolerance within_epsilon = {
+        std::numeric_limits<scalar>::epsilon(),
+        std::numeric_limits<scalar>::epsilon()};
+
+    /** Assignment operator from an array, convenience function
+     *
+     * @param rhs is the right hand side object
+     **/
+    trapezoid2<intersector_type, local_type, links_type, kMaskContext>
+        &operator=(const array_type<scalar, 3> &rhs) {
+        _values = rhs;
+        return (*this);
+    }
+
+    /** Mask operation
+     *
+     * @tparam inside_local_type is the type of the local frame (ignored here)
+     *
+     * @param p the point to be checked
+     * @param t us the tolerance tuple (l0,l1)
+     *
+     * @return an intersection status e_inside / e_outside
+     **/
+    template <typename inside_local_type>
+    intersection_status is_inside(
+        const point2 &p, const mask_tolerance &t = within_epsilon) const {
+        scalar rel_y = (_values[2] + p[1]) / (2 * _values[2]);
+        return (std::abs(p[0]) <=
+                    _values[0] + rel_y * (_values[1] - _values[0]) + t[0] and
+                std::abs(p[1]) <= _values[2] + t[1])
+                   ? e_inside
+                   : e_outside;
+    }
+
+    /** Equality operator from an array, convenience function
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     * checks identity within epsilon and @return s a boolean*
+     **/
+    bool operator==(const array_type<scalar, 3> &rhs) {
+        return (_values == rhs);
+    }
+
+    /** Equality operator
+     *
+     * @param rhs is the rectangle to be compared with
+     *
+     * checks identity within epsilon and @return s a boolean*
+     **/
+    bool operator==(const trapezoid2<> &rhs) { return operator==(rhs._values); }
+
+    /** Access operator - non-const
+     * @return the reference to the member variable
+     */
+    scalar &operator[](unsigned int value_index) {
+        return _values[value_index];
+    }
+
+    /** Access operator - non-const
+     * @return a copy of the member variable
+     */
+    scalar operator[](unsigned int value_index) const {
+        return _values[value_index];
+    }
+
+    /** Return an associated intersector type */
+    intersector_type intersector() const { return intersector_type{}; };
+
+    /** Return the values */
+    const mask_values &values() const { return _values; }
+
+    /** Return the local frame type */
+    local_type local() const { return local_type{}; }
+
+    /** Return the volume link - const reference */
+    const links_type &links() const { return _links; }
+
+    /** Return the volume link - non-const access */
+    links_type &links() { return _links; }
+
+    /** Transform to a string for output debugging */
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << "trapezoid2," << kMaskContext;
+        for (const auto &v : _values) {
+            ss << "," << v;
         }
-    };
+        return ss.str();
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/masks/unmasked.hpp b/core/include/masks/unmasked.hpp
index ce1192cc3f..2f5d22f0ef 100644
--- a/core/include/masks/unmasked.hpp
+++ b/core/include/masks/unmasked.hpp
@@ -1,77 +1,70 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include "core/intersection.hpp"
-
 #include <optional>
 #include <string>
 
-namespace detray
-{
-    struct unmasked
-    {
+#include "core/intersection.hpp"
 
-        using mask_tolerance = bool;
+namespace detray {
+struct unmasked {
 
-        static constexpr mask_tolerance within_epsilon = true;
+    using mask_tolerance = bool;
 
-        /** Mask operation 
-         * 
-         * @tparam point_type is the type of the point to be checked w.r.t. to
-         * the mask bounds
-         *
-         * the parameters are ignored
-         * 
-         * @return a bool that is ture if inside
-         **/
-        template <typename local_type>
-        intersection_status is_inside(const point2 & /*ignored*/,
-                                      const mask_tolerance& t = within_epsilon) const
-        {
-            return t ? e_hit : e_missed;
-        }
+    static constexpr mask_tolerance within_epsilon = true;
 
-        /** Mask operation 
-         * 
-         * @tparam point_type is the type of the point to be checked w.r.t. to
-         * the mask bounds
-         *
-         * the parameters are ignored
-         * 
-         * @return a bool that is ture if inside
-         **/
-        template <typename local_type>
-        bool is_inside(const point2 & /*ignored*/, scalar /*ignored*/) const
-        {
-            return true;
-        }
+    /** Mask operation
+     *
+     * @tparam point_type is the type of the point to be checked w.r.t. to
+     * the mask bounds
+     *
+     * the parameters are ignored
+     *
+     * @return a bool that is ture if inside
+     **/
+    template <typename local_type>
+    intersection_status is_inside(
+        const point2 & /*ignored*/,
+        const mask_tolerance &t = within_epsilon) const {
+        return t ? e_hit : e_missed;
+    }
 
-        /** Mask operation 
-         * 
-         * @tparam point_type is the type of the point to be checked w.r.t. to
-         * the mask bounds
-         *
-         * the parameters are ignored
-         * 
-         * @return a bool that is ture if inside
-         **/
-        template <typename local_type>
-        bool is_inside(const point2 & /*ignored*/, scalar /*ignored*/, scalar /*ignored*/) const
-        {
-            return true;
-        }
+    /** Mask operation
+     *
+     * @tparam point_type is the type of the point to be checked w.r.t. to
+     * the mask bounds
+     *
+     * the parameters are ignored
+     *
+     * @return a bool that is ture if inside
+     **/
+    template <typename local_type>
+    bool is_inside(const point2 & /*ignored*/, scalar /*ignored*/) const {
+        return true;
+    }
 
-        /** Transform to a string for output debugging */
-        std::string to_string() const
-        {
-            return "unmasked";
-        }
+    /** Mask operation
+     *
+     * @tparam point_type is the type of the point to be checked w.r.t. to
+     * the mask bounds
+     *
+     * the parameters are ignored
+     *
+     * @return a bool that is ture if inside
+     **/
+    template <typename local_type>
+    bool is_inside(const point2 & /*ignored*/, scalar /*ignored*/,
+                   scalar /*ignored*/) const {
+        return true;
+    }
 
-    };
+    /** Transform to a string for output debugging */
+    std::string to_string() const { return "unmasked"; }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/tools/bin_association.hpp b/core/include/tools/bin_association.hpp
index ca3e625ae7..2c89392725 100644
--- a/core/include/tools/bin_association.hpp
+++ b/core/include/tools/bin_association.hpp
@@ -1,256 +1,258 @@
 
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
+#include <array>
+#include <tuple>
+#include <vector>
+
 #include "grids/associator.hpp"
 #include "utils/enumerate.hpp"
 #include "utils/generators.hpp"
 
-#include <array>
-#include <vector>
-#include <tuple>
-
-namespace detray
-{
-    using point2 = __plugin::point2;
-    using point3 = __plugin::point3;
-
-    /** Run the bin association of surfaces (via their contour)
-     *  - to a given grid.
-     * 
-     * @param context is the context to win which the association is done
-     * @param detector is the detector to which the grid belongs
-     * @param volume is the volume to which the surfaces belong
-     * @param grid is the grid that will be filled 
-     * @param tolerance is the bin_tolerance in the two local coordinates
-     * @param absolute_tolerance is an indicator if the tolerance is to be
-     *        taken absolute or relative
-     */
-    template <typename context_type,
-              typename detector_type,
-              typename volume_type,
-              typename grid_type>
-    static inline void bin_association(const context_type &context,
-                                       const detector_type &detector,
-                                       const volume_type &volume,
-                                       grid_type &grid,
-                                       const std::array<scalar, 2> &bin_tolerance,
-                                       bool absolute_tolerance = true)
-    {
-
-        // Get surfaces, transforms and masks
-        const auto &surfaces = detector.surfaces();
-        const auto &surface_transforms = detector.transforms(volume.template range<detector_type::e_surface>(), context);
-        const auto &surface_masks = detector.masks();
-
-        const auto &bounds = volume.bounds();
-        bool is_cylinder = std::abs(bounds[1] - bounds[0]) < std::abs(bounds[3] - bounds[2]);
-
-        auto sfm_copy = surface_masks;
-
-        const auto &axis_0 = grid.axis_p0();
-        const auto &axis_1 = grid.axis_p1();
-
-        // Disk type bin association
-        if (not is_cylinder)
-        {
-            // Run with two different associators: center of gravity and edge intersection
-            center_of_gravity_generic cgs_assoc;
-            edges_intersect_generic edges_assoc;
-
-            // Loop over all bins and associate the surfaces
-            for (unsigned int bin_0 = 0; bin_0 < axis_0.bins(); ++bin_0)
-            {
-                for (unsigned int bin_1 = 0; bin_1 < axis_1.bins(); ++bin_1)
+namespace detray {
+using point2 = __plugin::point2;
+using point3 = __plugin::point3;
+
+/** Run the bin association of surfaces (via their contour)
+ *  - to a given grid.
+ *
+ * @param context is the context to win which the association is done
+ * @param detector is the detector to which the grid belongs
+ * @param volume is the volume to which the surfaces belong
+ * @param grid is the grid that will be filled
+ * @param tolerance is the bin_tolerance in the two local coordinates
+ * @param absolute_tolerance is an indicator if the tolerance is to be
+ *        taken absolute or relative
+ */
+template <typename context_type, typename detector_type, typename volume_type,
+          typename grid_type>
+static inline void bin_association(const context_type &context,
+                                   const detector_type &detector,
+                                   const volume_type &volume, grid_type &grid,
+                                   const std::array<scalar, 2> &bin_tolerance,
+                                   bool absolute_tolerance = true) {
+
+    // Get surfaces, transforms and masks
+    const auto &surfaces = detector.surfaces();
+    const auto &surface_transforms = detector.transforms(
+        volume.template range<detector_type::e_surface>(), context);
+    const auto &surface_masks = detector.masks();
+
+    const auto &bounds = volume.bounds();
+    bool is_cylinder =
+        std::abs(bounds[1] - bounds[0]) < std::abs(bounds[3] - bounds[2]);
+
+    auto sfm_copy = surface_masks;
+
+    const auto &axis_0 = grid.axis_p0();
+    const auto &axis_1 = grid.axis_p1();
+
+    // Disk type bin association
+    if (not is_cylinder) {
+        // Run with two different associators: center of gravity and edge
+        // intersection
+        center_of_gravity_generic cgs_assoc;
+        edges_intersect_generic edges_assoc;
+
+        // Loop over all bins and associate the surfaces
+        for (unsigned int bin_0 = 0; bin_0 < axis_0.bins(); ++bin_0) {
+            for (unsigned int bin_1 = 0; bin_1 < axis_1.bins(); ++bin_1) {
+
+                auto r_borders = axis_0.borders(bin_0);
+                auto phi_borders = axis_1.borders(bin_1);
+
+                scalar r_add =
+                    absolute_tolerance
+                        ? bin_tolerance[0]
+                        : bin_tolerance[0] * (r_borders[1] - r_borders[0]);
+                scalar phi_add =
+                    absolute_tolerance
+                        ? bin_tolerance[1]
+                        : bin_tolerance[1] * (phi_borders[1] - phi_borders[0]);
+
+                // Create a contour for the bin
+                std::vector<point2> bin_contour = r_phi_polygon(
+                    r_borders[0] - r_add, r_borders[1] + r_add,
+                    phi_borders[0] - phi_add, phi_borders[1] + phi_add);
+
+                // Run through the surfaces and associate them by contour
+                const auto &sf_range = volume.template range<true>();
+                for (auto is = sf_range[0]; is < sf_range[1]; is++)
+                // for (auto [is, s] : enumerate(surfaces.objects()))
                 {
-
-                    auto r_borders = axis_0.borders(bin_0);
-                    auto phi_borders = axis_1.borders(bin_1);
-
-                    scalar r_add = absolute_tolerance ? bin_tolerance[0] : bin_tolerance[0] * (r_borders[1] - r_borders[0]);
-                    scalar phi_add = absolute_tolerance ? bin_tolerance[1] : bin_tolerance[1] * (phi_borders[1] - phi_borders[0]);
-
-                    // Create a contour for the bin
-                    std::vector<point2> bin_contour = r_phi_polygon(r_borders[0] - r_add,
-                                                                    r_borders[1] + r_add,
-                                                                    phi_borders[0] - phi_add,
-                                                                    phi_borders[1] + phi_add);
-
-                    // Run through the surfaces and associate them by contour
-                    const auto& sf_range = volume.template range<true>();
-                    for (auto is = sf_range[0]; is < sf_range[1]; is++)
-                    //for (auto [is, s] : enumerate(surfaces.objects()))
-                    {
-                        const auto& s = surfaces[is];
-                        dvector<point3> vertices = {};
-                        const auto &mask_link = s.mask();
-
-                        // Unroll the mask container and generate vertices
-                        const auto &transform = surface_transforms[s.transform()];
-
-                        const auto &mask_context = std::get<0>(mask_link);
-                        const auto &mask_range = std::get<1>(mask_link);
-
-                        auto vertices_per_masks = unroll_masks_for_vertices(surface_masks, mask_range, mask_context,
-                                                                            std::make_integer_sequence<dindex, std::tuple_size_v<decltype(sfm_copy)>>{});
-
-                        // Usually one mask per surface, but design allows - a single association  is sufficient though
-                        for (auto &vertices : vertices_per_masks)
-                        {
-                            if (not vertices.empty())
-                            {
-                                // Create a surface contour
-                                std::vector<point2> surface_contour;
-                                surface_contour.reserve(vertices.size());
-                                for (const auto &v : vertices)
-                                {
-                                    auto vg = transform.point_to_global(v);
-                                    surface_contour.push_back({vg[0], vg[1]});
-                                }
-                                // The association has worked
-                                if (cgs_assoc(bin_contour, surface_contour) or edges_assoc(bin_contour, surface_contour))
-                                {
-                                    dindex bin_index = is;
-                                    grid.populate(bin_0, bin_1, std::move(bin_index));
-                                    break;
-                                }
+                    const auto &s = surfaces[is];
+                    dvector<point3> vertices = {};
+                    const auto &mask_link = s.mask();
+
+                    // Unroll the mask container and generate vertices
+                    const auto &transform = surface_transforms[s.transform()];
+
+                    const auto &mask_context = std::get<0>(mask_link);
+                    const auto &mask_range = std::get<1>(mask_link);
+
+                    auto vertices_per_masks = unroll_masks_for_vertices(
+                        surface_masks, mask_range, mask_context,
+                        std::make_integer_sequence<
+                            dindex, std::tuple_size_v<decltype(sfm_copy)>>{});
+
+                    // Usually one mask per surface, but design allows - a
+                    // single association  is sufficient though
+                    for (auto &vertices : vertices_per_masks) {
+                        if (not vertices.empty()) {
+                            // Create a surface contour
+                            std::vector<point2> surface_contour;
+                            surface_contour.reserve(vertices.size());
+                            for (const auto &v : vertices) {
+                                auto vg = transform.point_to_global(v);
+                                surface_contour.push_back({vg[0], vg[1]});
+                            }
+                            // The association has worked
+                            if (cgs_assoc(bin_contour, surface_contour) or
+                                edges_assoc(bin_contour, surface_contour)) {
+                                dindex bin_index = is;
+                                grid.populate(bin_0, bin_1,
+                                              std::move(bin_index));
+                                break;
                             }
                         }
                     }
                 }
             }
         }
-        else
-        {
-
-            center_of_gravity_rectangle cgs_assoc;
-            edges_intersect_generic edges_assoc;
-
-            // Loop over all bins and associate the surfaces
-            for (unsigned int bin_0 = 0; bin_0 < axis_0.bins(); ++bin_0)
-            {
-                for (unsigned int bin_1 = 0; bin_1 < axis_1.bins(); ++bin_1)
+    } else {
+
+        center_of_gravity_rectangle cgs_assoc;
+        edges_intersect_generic edges_assoc;
+
+        // Loop over all bins and associate the surfaces
+        for (unsigned int bin_0 = 0; bin_0 < axis_0.bins(); ++bin_0) {
+            for (unsigned int bin_1 = 0; bin_1 < axis_1.bins(); ++bin_1) {
+
+                auto z_borders = axis_0.borders(bin_0);
+                auto phi_borders = axis_1.borders(bin_1);
+
+                scalar z_add =
+                    absolute_tolerance
+                        ? bin_tolerance[0]
+                        : bin_tolerance[0] * (z_borders[1] - z_borders[0]);
+                scalar phi_add =
+                    absolute_tolerance
+                        ? bin_tolerance[1]
+                        : bin_tolerance[1] * (phi_borders[1] - phi_borders[0]);
+
+                scalar z_min = z_borders[0];
+                scalar z_max = z_borders[1];
+                scalar phi_min = phi_borders[0];
+                scalar phi_max = phi_borders[1];
+
+                point2 p0_bin = {z_min - z_add, phi_min - phi_add};
+                point2 p1_bin = {z_min - z_add, phi_max + phi_add};
+                point2 p2_bin = {z_max + z_add, phi_max + phi_add};
+                point2 p3_bin = {z_max + z_add, phi_min - phi_add};
+
+                std::vector<point2> bin_contour = {p0_bin, p1_bin, p2_bin,
+                                                   p3_bin};
+
+                // Loop over the surfaces within a volume
+                const auto &sf_range = volume.template range<true>();
+                for (auto is = sf_range[0]; is < sf_range[1]; is++)
+                // for (auto [is, s] : enumerate(surfaces.objects()))
                 {
-
-                    auto z_borders = axis_0.borders(bin_0);
-                    auto phi_borders = axis_1.borders(bin_1);
-
-                    scalar z_add = absolute_tolerance ? bin_tolerance[0] : bin_tolerance[0] * (z_borders[1] - z_borders[0]);
-                    scalar phi_add = absolute_tolerance ? bin_tolerance[1] : bin_tolerance[1] * (phi_borders[1] - phi_borders[0]);
-
-                    scalar z_min = z_borders[0];
-                    scalar z_max = z_borders[1];
-                    scalar phi_min = phi_borders[0];
-                    scalar phi_max = phi_borders[1];
-
-                    point2 p0_bin = {z_min - z_add, phi_min - phi_add};
-                    point2 p1_bin = {z_min - z_add, phi_max + phi_add};
-                    point2 p2_bin = {z_max + z_add, phi_max + phi_add};
-                    point2 p3_bin = {z_max + z_add, phi_min - phi_add};
-
-                    std::vector<point2> bin_contour = {p0_bin, p1_bin, p2_bin, p3_bin};
-
-                    // Loop over the surfaces within a volume
-                    const auto& sf_range = volume.template range<true>();
-                    for (auto is = sf_range[0]; is < sf_range[1]; is++)
-                    //for (auto [is, s] : enumerate(surfaces.objects()))
-                    {
-                        const auto& s = surfaces[is];
-                        dvector<point3> vertices = {};
-                        const auto &mask_link = s.mask();
-
-                        // Unroll the mask container and generate vertices
-                        const auto &transform = surface_transforms[s.transform()];
-
-                        const auto &mask_context = std::get<0>(mask_link);
-                        const auto &mask_range = std::get<1>(mask_link);
-
-                        auto vertices_per_masks = unroll_masks_for_vertices(surface_masks, mask_range, mask_context,
-                                                                            std::make_integer_sequence<dindex, std::tuple_size_v<decltype(sfm_copy)>>{});
-
-                        for (auto &vertices : vertices_per_masks)
-                        {
-
-                            if (not vertices.empty())
-                            {
-                                // Create a surface contour
-                                std::vector<point2> surface_contour;
-                                surface_contour.reserve(vertices.size());
-                                scalar phi_min = std::numeric_limits<scalar>::max();
-                                scalar phi_max = -std::numeric_limits<scalar>::max();
-                                // We poentially need the split vertices
-                                std::vector<point2> s_c_neg;
-                                std::vector<point2> s_c_pos;
-                                scalar z_min_neg = std::numeric_limits<scalar>::max();
-                                scalar z_max_neg = -std::numeric_limits<scalar>::max();
-                                scalar z_min_pos = std::numeric_limits<scalar>::max();
-                                scalar z_max_pos = -std::numeric_limits<scalar>::max();
-
-                                for (const auto &v : vertices)
-                                {
-                                    const point3 vg = transform.point_to_global(v);
-                                    scalar phi = std::atan2(vg[1], vg[0]);
-                                    phi_min = std::min(phi, phi_min);
-                                    phi_max = std::max(phi, phi_max);
-                                    surface_contour.push_back({vg[2], phi});
-                                    if (phi < 0.)
-                                    {
-                                        s_c_neg.push_back({vg[2], phi});
-                                        z_min_neg = std::min(vg[2], z_min_neg);
-                                        z_max_neg = std::max(vg[2], z_max_neg);
-                                    }
-                                    else
-                                    {
-                                        s_c_pos.push_back({vg[2], phi});
-                                        z_min_pos = std::min(vg[2], z_min_pos);
-                                        z_max_pos = std::max(vg[2], z_max_pos);
-                                    }
-                                }
-                                // Check for phi wrapping
-                                std::vector<std::vector<point2>> surface_contours;
-                                if (phi_max - phi_min > M_PI and phi_max * phi_min < 0.)
-                                {
-                                    s_c_neg.push_back({z_max_neg, -M_PI});
-                                    s_c_neg.push_back({z_min_neg, -M_PI});
-                                    s_c_pos.push_back({z_max_pos, M_PI});
-                                    s_c_pos.push_back({z_min_pos, M_PI});
-                                    surface_contours = {s_c_neg, s_c_pos};
-                                }
-                                else
-                                {
-                                    surface_contours = {surface_contour};
-                                }
-
-                                // Check the association (with potential splits)
-                                bool associated = false;
-                                for (const auto &s_c : surface_contours)
-                                {
-                                    if (cgs_assoc(bin_contour, s_c) or edges_assoc(bin_contour, s_c))
-                                    {
-                                        associated = true;
-                                        break;
-                                    }
+                    const auto &s = surfaces[is];
+                    dvector<point3> vertices = {};
+                    const auto &mask_link = s.mask();
+
+                    // Unroll the mask container and generate vertices
+                    const auto &transform = surface_transforms[s.transform()];
+
+                    const auto &mask_context = std::get<0>(mask_link);
+                    const auto &mask_range = std::get<1>(mask_link);
+
+                    auto vertices_per_masks = unroll_masks_for_vertices(
+                        surface_masks, mask_range, mask_context,
+                        std::make_integer_sequence<
+                            dindex, std::tuple_size_v<decltype(sfm_copy)>>{});
+
+                    for (auto &vertices : vertices_per_masks) {
+
+                        if (not vertices.empty()) {
+                            // Create a surface contour
+                            std::vector<point2> surface_contour;
+                            surface_contour.reserve(vertices.size());
+                            scalar phi_min = std::numeric_limits<scalar>::max();
+                            scalar phi_max =
+                                -std::numeric_limits<scalar>::max();
+                            // We poentially need the split vertices
+                            std::vector<point2> s_c_neg;
+                            std::vector<point2> s_c_pos;
+                            scalar z_min_neg =
+                                std::numeric_limits<scalar>::max();
+                            scalar z_max_neg =
+                                -std::numeric_limits<scalar>::max();
+                            scalar z_min_pos =
+                                std::numeric_limits<scalar>::max();
+                            scalar z_max_pos =
+                                -std::numeric_limits<scalar>::max();
+
+                            for (const auto &v : vertices) {
+                                const point3 vg = transform.point_to_global(v);
+                                scalar phi = std::atan2(vg[1], vg[0]);
+                                phi_min = std::min(phi, phi_min);
+                                phi_max = std::max(phi, phi_max);
+                                surface_contour.push_back({vg[2], phi});
+                                if (phi < 0.) {
+                                    s_c_neg.push_back({vg[2], phi});
+                                    z_min_neg = std::min(vg[2], z_min_neg);
+                                    z_max_neg = std::max(vg[2], z_max_neg);
+                                } else {
+                                    s_c_pos.push_back({vg[2], phi});
+                                    z_min_pos = std::min(vg[2], z_min_pos);
+                                    z_max_pos = std::max(vg[2], z_max_pos);
                                 }
+                            }
+                            // Check for phi wrapping
+                            std::vector<std::vector<point2>> surface_contours;
+                            if (phi_max - phi_min > M_PI and
+                                phi_max * phi_min < 0.) {
+                                s_c_neg.push_back({z_max_neg, -M_PI});
+                                s_c_neg.push_back({z_min_neg, -M_PI});
+                                s_c_pos.push_back({z_max_pos, M_PI});
+                                s_c_pos.push_back({z_min_pos, M_PI});
+                                surface_contours = {s_c_neg, s_c_pos};
+                            } else {
+                                surface_contours = {surface_contour};
+                            }
 
-                                // Register if associated
-                                if (associated)
-                                {
-                                    dindex bin_index = is;
-                                    grid.populate(bin_0, bin_1, std::move(bin_index));
+                            // Check the association (with potential splits)
+                            bool associated = false;
+                            for (const auto &s_c : surface_contours) {
+                                if (cgs_assoc(bin_contour, s_c) or
+                                    edges_assoc(bin_contour, s_c)) {
+                                    associated = true;
                                     break;
                                 }
                             }
+
+                            // Register if associated
+                            if (associated) {
+                                dindex bin_index = is;
+                                grid.populate(bin_0, bin_1,
+                                              std::move(bin_index));
+                                break;
+                            }
                         }
                     }
                 }
             }
         }
     }
+}
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/tools/concentric_cylinder_intersector.hpp b/core/include/tools/concentric_cylinder_intersector.hpp
index 8b042f2d6d..800ee18af3 100644
--- a/core/include/tools/concentric_cylinder_intersector.hpp
+++ b/core/include/tools/concentric_cylinder_intersector.hpp
@@ -1,143 +1,139 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include <cmath>
 #include <climits>
+#include <cmath>
 #include <optional>
 
 #include "core/intersection.hpp"
 #include "core/track.hpp"
+#include "masks/unmasked.hpp"
 #include "utils/quadratic_equation.hpp"
 #include "utils/unbound.hpp"
-#include "masks/unmasked.hpp"
 
-namespace detray
-{
-    /** This is an intersector struct for a concetric cylinder surface
-     */
-    template<template <typename, unsigned int> class array_type = darray>
-    struct concentric_cylinder_intersector
-    {
-
-        using transform3 = __plugin::transform3;
-        using point3 = __plugin::point3;
-        using vector3 = __plugin::vector3;
-        using point2 = __plugin::point2;
-        using cylindrical2 = __plugin::cylindrical2;
-
-        /** Intersection method for cylindrical surfaces
-         * 
-         * @tparam track_type The type of the track caryying also the context object
-         * @tparam local_type The local frame type to be intersected
-         * @tparam mask_type The mask type applied to the local frame
-         * 
-         * Contextual part:
-         * @param trf the transform of the surface surface to be intersected @note is ignored 
-         * @param track the track information
-         * @param local to the local local frame 
-         * 
-         * Non-contextual part:
-         * @param mask the local mask 
-         * @param tolerance is the mask specific tolerance
-         * 
-         * @return the intersection with optional parameters
-         **/
-        template <typename track_type, typename local_type, typename mask_type>
-        intersection
-        intersect(const transform3 &trf,
-                  const track_type &track,
-                  const local_type &local,
-                  const mask_type &mask,
-                  const typename mask_type::mask_tolerance &tolerance = mask_type::within_epsilon) const
-        {
-            return intersect(trf, track.pos, track.dir, local, mask, tolerance, track.overstep_tolerance);
-        }
-
-        /** Intersection method for cylindrical surfaces
-         * 
-         * @tparam local_type The local frame type to be intersected
-         * @tparam mask_type The mask type applied to the local frame
-         * 
-         * Contextual part:
-         * @param trf the transform of the surface to be intersected
-         * @param ro the origin of the ray
-         * @param rd the direction of the ray
-         * @param local to the local local frame 
-         * 
-         * Non-contextual part:
-         * @param mask the local mask 
-         * @param tolerance is the mask specific tolerance
-         * @param overstep_tolerance  is the stepping specific tolerance
-         * 
-         * @return the intersection with optional parameters
-         **/
-        template <typename local_type, typename mask_type>
-        intersection
-        intersect(const transform3 & /*trf*/,
-                  const point3 &ro,
-                  const vector3 &rd,
-                  const local_type &local,
-                  const mask_type &mask,
-                  const typename mask_type::mask_tolerance &tolerance = mask_type::within_epsilon,
-                  scalar overstep_tolerance = 0.) const
-        {
-
-            scalar r = mask[0];
-
-            // Two points on the line, thes are in the cylinder frame
-            const auto &l0 = ro;
-            const auto l1 = point3(ro + rd);
-
-            // swap coorinates x/y for numerical stability
-            bool swap_x_y = std::abs(rd[0]) < 1e-3;
-
-            unsigned int _x = swap_x_y ? 1 : 0;
-            unsigned int _y = swap_x_y ? 0 : 1;
-            scalar k = (l0[_y] - l1[_y]) / (l0[_x] - l1[_x]);
-            scalar d = l1[_y] - k * l1[_x];
-
-            quadratic_equation<scalar> qe = {(1 + k * k), 2 * k * d, d * d - r * r};
-            auto qe_solution = qe();
-
-            if (std::get<0>(qe_solution) > overstep_tolerance)
-            {
-                array_type<point3, 2> candidates;
-                auto u01 = std::get<1>(qe_solution);
-                array_type<scalar, 2> t01 = {0., 0.};
-
-                candidates[0][_x] = u01[0];
-                candidates[0][_y] = k * u01[0] + d;
-                t01[0] = (candidates[0][_x] - ro[_x]) / rd[_x];
-                candidates[0][2] = ro[2] + t01[0] * rd[2];
-
-                candidates[1][_x] = u01[1];
-                candidates[1][_y] = k * u01[1] + d;
-                t01[1] = (candidates[1][_x] - ro[_x]) / rd[_x];
-                candidates[1][2] = ro[2] + t01[1] * rd[2];
-
-                // Chose the index, take the smaller positive one
-                int cindex = (t01[0] < t01[1] and t01[0] > overstep_tolerance) ? 0
-                                                                               : (t01[0] < overstep_tolerance and t01[1] > overstep_tolerance ? 1 : 0);
-                if (t01[0] > overstep_tolerance or t01[1] > overstep_tolerance)
-                {
-                    intersection is;
-                    is.p3 = candidates[cindex];
-                    is.path = t01[cindex];
-
-                    is.p2 = point2{r * getter::phi(is.p3), is.p3[2]};
-                    is.status = mask.template is_inside<cylindrical2>(is.p3);
-                    scalar rdir = getter::perp(is.p3 + 0.1 * rd);
-                    is.direction = rdir > r ? e_along : e_opposite;
-                    return is;
-                }
+namespace detray {
+/** This is an intersector struct for a concetric cylinder surface
+ */
+template <template <typename, unsigned int> class array_type = darray>
+struct concentric_cylinder_intersector {
+
+    using transform3 = __plugin::transform3;
+    using point3 = __plugin::point3;
+    using vector3 = __plugin::vector3;
+    using point2 = __plugin::point2;
+    using cylindrical2 = __plugin::cylindrical2;
+
+    /** Intersection method for cylindrical surfaces
+     *
+     * @tparam track_type The type of the track caryying also the context object
+     * @tparam local_type The local frame type to be intersected
+     * @tparam mask_type The mask type applied to the local frame
+     *
+     * Contextual part:
+     * @param trf the transform of the surface surface to be intersected @note
+     *is ignored
+     * @param track the track information
+     * @param local to the local local frame
+     *
+     * Non-contextual part:
+     * @param mask the local mask
+     * @param tolerance is the mask specific tolerance
+     *
+     * @return the intersection with optional parameters
+     **/
+    template <typename track_type, typename local_type, typename mask_type>
+    intersection intersect(const transform3 &trf, const track_type &track,
+                           const local_type &local, const mask_type &mask,
+                           const typename mask_type::mask_tolerance &tolerance =
+                               mask_type::within_epsilon) const {
+        return intersect(trf, track.pos, track.dir, local, mask, tolerance,
+                         track.overstep_tolerance);
+    }
+
+    /** Intersection method for cylindrical surfaces
+     *
+     * @tparam local_type The local frame type to be intersected
+     * @tparam mask_type The mask type applied to the local frame
+     *
+     * Contextual part:
+     * @param trf the transform of the surface to be intersected
+     * @param ro the origin of the ray
+     * @param rd the direction of the ray
+     * @param local to the local local frame
+     *
+     * Non-contextual part:
+     * @param mask the local mask
+     * @param tolerance is the mask specific tolerance
+     * @param overstep_tolerance  is the stepping specific tolerance
+     *
+     * @return the intersection with optional parameters
+     **/
+    template <typename local_type, typename mask_type>
+    intersection intersect(const transform3 & /*trf*/, const point3 &ro,
+                           const vector3 &rd, const local_type &local,
+                           const mask_type &mask,
+                           const typename mask_type::mask_tolerance &tolerance =
+                               mask_type::within_epsilon,
+                           scalar overstep_tolerance = 0.) const {
+
+        scalar r = mask[0];
+
+        // Two points on the line, thes are in the cylinder frame
+        const auto &l0 = ro;
+        const auto l1 = point3(ro + rd);
+
+        // swap coorinates x/y for numerical stability
+        bool swap_x_y = std::abs(rd[0]) < 1e-3;
+
+        unsigned int _x = swap_x_y ? 1 : 0;
+        unsigned int _y = swap_x_y ? 0 : 1;
+        scalar k = (l0[_y] - l1[_y]) / (l0[_x] - l1[_x]);
+        scalar d = l1[_y] - k * l1[_x];
+
+        quadratic_equation<scalar> qe = {(1 + k * k), 2 * k * d, d * d - r * r};
+        auto qe_solution = qe();
+
+        if (std::get<0>(qe_solution) > overstep_tolerance) {
+            array_type<point3, 2> candidates;
+            auto u01 = std::get<1>(qe_solution);
+            array_type<scalar, 2> t01 = {0., 0.};
+
+            candidates[0][_x] = u01[0];
+            candidates[0][_y] = k * u01[0] + d;
+            t01[0] = (candidates[0][_x] - ro[_x]) / rd[_x];
+            candidates[0][2] = ro[2] + t01[0] * rd[2];
+
+            candidates[1][_x] = u01[1];
+            candidates[1][_y] = k * u01[1] + d;
+            t01[1] = (candidates[1][_x] - ro[_x]) / rd[_x];
+            candidates[1][2] = ro[2] + t01[1] * rd[2];
+
+            // Chose the index, take the smaller positive one
+            int cindex = (t01[0] < t01[1] and t01[0] > overstep_tolerance)
+                             ? 0
+                             : (t01[0] < overstep_tolerance and
+                                        t01[1] > overstep_tolerance
+                                    ? 1
+                                    : 0);
+            if (t01[0] > overstep_tolerance or t01[1] > overstep_tolerance) {
+                intersection is;
+                is.p3 = candidates[cindex];
+                is.path = t01[cindex];
+
+                is.p2 = point2{r * getter::phi(is.p3), is.p3[2]};
+                is.status = mask.template is_inside<cylindrical2>(is.p3);
+                scalar rdir = getter::perp(is.p3 + 0.1 * rd);
+                is.direction = rdir > r ? e_along : e_opposite;
+                return is;
             }
-            return intersection{};
         }
-    };
+        return intersection{};
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/tools/cylinder_intersector.hpp b/core/include/tools/cylinder_intersector.hpp
index 5c048f6938..a27aec9740 100644
--- a/core/include/tools/cylinder_intersector.hpp
+++ b/core/include/tools/cylinder_intersector.hpp
@@ -1,124 +1,116 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
-#include <cmath>
 #include <climits>
+#include <cmath>
 #include <optional>
 
 #include "core/intersection.hpp"
 #include "core/track.hpp"
+#include "masks/unmasked.hpp"
 #include "utils/quadratic_equation.hpp"
 #include "utils/unbound.hpp"
-#include "masks/unmasked.hpp"
 
-namespace detray
-{
+namespace detray {
 
-    /** This is an intersector struct for generic cylinder surface
-     */
-    struct cylinder_intersector
-    {
+/** This is an intersector struct for generic cylinder surface
+ */
+struct cylinder_intersector {
 
-        using transform3 = __plugin::transform3;
-        using point3 = __plugin::point3;
-        using vector3 = __plugin::vector3;
-        using point2 = __plugin::point2;
-        using cylindrical2 = __plugin::cylindrical2;
+    using transform3 = __plugin::transform3;
+    using point3 = __plugin::point3;
+    using vector3 = __plugin::vector3;
+    using point2 = __plugin::point2;
+    using cylindrical2 = __plugin::cylindrical2;
 
-        /** Intersection method for cylindrical surfaces
-         * 
-         * @tparam track_type The type of the track carrying the context object
-         * @tparam local_type The local frame type to be intersected
-         * @tparam mask_type The mask type applied to the local frame
-         * 
-         * Contextual part:
-         * @param trf the transform of the surface to be intersected
-         * @param track the track information
-         * @param local to the local local frame 
-         * 
-         * Non-contextual part:
-         * @param mask the local mask 
-         * @param tolerance is the mask specific tolerance
-         * 
-         * @return the intersection with optional parameters
-         **/
-        template <typename track_type, typename local_type, typename mask_type>
-        intersection
-        intersect(const transform3 &trf,
-                  const track_type &track,
-                  const local_type &local,
-                  const mask_type &mask,
-                  const typename mask_type::mask_tolerance &tolerance = mask_type::within_epsilon) const
-        {
-            return intersect(trf, track.pos, track.dir, local, mask, tolerance, track.overstep_tolerance);
-        }
+    /** Intersection method for cylindrical surfaces
+     *
+     * @tparam track_type The type of the track carrying the context object
+     * @tparam local_type The local frame type to be intersected
+     * @tparam mask_type The mask type applied to the local frame
+     *
+     * Contextual part:
+     * @param trf the transform of the surface to be intersected
+     * @param track the track information
+     * @param local to the local local frame
+     *
+     * Non-contextual part:
+     * @param mask the local mask
+     * @param tolerance is the mask specific tolerance
+     *
+     * @return the intersection with optional parameters
+     **/
+    template <typename track_type, typename local_type, typename mask_type>
+    intersection intersect(const transform3 &trf, const track_type &track,
+                           const local_type &local, const mask_type &mask,
+                           const typename mask_type::mask_tolerance &tolerance =
+                               mask_type::within_epsilon) const {
+        return intersect(trf, track.pos, track.dir, local, mask, tolerance,
+                         track.overstep_tolerance);
+    }
 
-        /** Intersection method for cylindrical surfaces
-         * 
-         * @tparam local_type The local frame type to be intersected
-         * @tparam mask_type The mask type applied to the local frame
-         * 
-         * Contextual part:
-         * @param trf the transform of the surface to be intersected
-         * @param ro the origin of the ray
-         * @param rd the direction of the ray
-         * @param local to the local local frame 
-         * 
-         * Non-contextual part:
-         * @param mask the local mask 
-         * @param tolerance is the mask specific tolerance
-         * @param overstep_tolerance  is the stepping specific tolerance
-         * 
-         * @return the intersection with optional parameters
-         **/
-        template <typename local_type, typename mask_type>
-        intersection
-        intersect(const transform3 &trf,
-                  const point3 &ro,
-                  const vector3 &rd,
-                  const local_type &local,
-                  const mask_type &mask,
-                  const typename mask_type::mask_tolerance &tolerance = mask_type::within_epsilon,
-                  scalar overstep_tolerance = 0.) const
-        {
-            scalar r = mask[0];
-            const auto &m = trf.matrix();
-            auto sz = getter::vector<3>(m, 0, 2);
-            auto sc = getter::vector<3>(m, 0, 3);
+    /** Intersection method for cylindrical surfaces
+     *
+     * @tparam local_type The local frame type to be intersected
+     * @tparam mask_type The mask type applied to the local frame
+     *
+     * Contextual part:
+     * @param trf the transform of the surface to be intersected
+     * @param ro the origin of the ray
+     * @param rd the direction of the ray
+     * @param local to the local local frame
+     *
+     * Non-contextual part:
+     * @param mask the local mask
+     * @param tolerance is the mask specific tolerance
+     * @param overstep_tolerance  is the stepping specific tolerance
+     *
+     * @return the intersection with optional parameters
+     **/
+    template <typename local_type, typename mask_type>
+    intersection intersect(const transform3 &trf, const point3 &ro,
+                           const vector3 &rd, const local_type &local,
+                           const mask_type &mask,
+                           const typename mask_type::mask_tolerance &tolerance =
+                               mask_type::within_epsilon,
+                           scalar overstep_tolerance = 0.) const {
+        scalar r = mask[0];
+        const auto &m = trf.matrix();
+        auto sz = getter::vector<3>(m, 0, 2);
+        auto sc = getter::vector<3>(m, 0, 3);
 
-            vector3 pc_cross_sz = vector::cross(ro - sc, sz);
-            vector3 rd_cross_sz = vector::cross(rd, sz);
-            scalar a = vector::dot(rd_cross_sz, rd_cross_sz);
-            scalar b = 2. * vector::dot(rd_cross_sz, pc_cross_sz);
-            scalar c = vector::dot(pc_cross_sz, pc_cross_sz) - (r * r);
+        vector3 pc_cross_sz = vector::cross(ro - sc, sz);
+        vector3 rd_cross_sz = vector::cross(rd, sz);
+        scalar a = vector::dot(rd_cross_sz, rd_cross_sz);
+        scalar b = 2. * vector::dot(rd_cross_sz, pc_cross_sz);
+        scalar c = vector::dot(pc_cross_sz, pc_cross_sz) - (r * r);
 
-            quadratic_equation<scalar> qe = {a, b, c};
-            auto qe_solution = qe();
+        quadratic_equation<scalar> qe = {a, b, c};
+        auto qe_solution = qe();
 
-            if (std::get<0>(qe_solution) > 0)
-            {
-                auto t01 = std::get<1>(qe_solution);
-                scalar t = (t01[0] > overstep_tolerance) ? t01[0] : t01[1];
-                if (t > overstep_tolerance)
-                {
-                    intersection is;
-                    is.path = t;
-                    is.p3 = ro + is.path * rd;
-                    is.p2 = local(trf, is.p3);
-                    auto local3 = trf.point_to_local(is.p3);
-                    is.status = mask.template is_inside<cylindrical2>(local3, tolerance);
-                    scalar rdr = getter::perp(local3 + 0.1 * rd);
-                    is.direction = rdr > r ? e_along : e_opposite;
-                    return is;
-                }
+        if (std::get<0>(qe_solution) > 0) {
+            auto t01 = std::get<1>(qe_solution);
+            scalar t = (t01[0] > overstep_tolerance) ? t01[0] : t01[1];
+            if (t > overstep_tolerance) {
+                intersection is;
+                is.path = t;
+                is.p3 = ro + is.path * rd;
+                is.p2 = local(trf, is.p3);
+                auto local3 = trf.point_to_local(is.p3);
+                is.status =
+                    mask.template is_inside<cylindrical2>(local3, tolerance);
+                scalar rdr = getter::perp(local3 + 0.1 * rd);
+                is.direction = rdr > r ? e_along : e_opposite;
+                return is;
             }
-            return intersection{};
         }
-    };
+        return intersection{};
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/tools/intersection_kernel.hpp b/core/include/tools/intersection_kernel.hpp
index a409671945..d4f2f899a6 100644
--- a/core/include/tools/intersection_kernel.hpp
+++ b/core/include/tools/intersection_kernel.hpp
@@ -1,208 +1,184 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-#include "core/track.hpp"
+#include <tuple>
+#include <utility>
+
 #include "core/intersection.hpp"
-#include "utils/indexing.hpp"
+#include "core/track.hpp"
 #include "utils/enumerate.hpp"
+#include "utils/indexing.hpp"
 
-#include <utility>
-#include <tuple>
-
-namespace detray
-{
+namespace detray {
 
-    /// Transform definition
-    using transform3 = __plugin::transform3;
+/// Transform definition
+using transform3 = __plugin::transform3;
 
-    /** Specialized method to update an intersection when the mask group is resolved
-     * 
-     * @tparam track_type is the type of the track information including context 
-     * @tparam mask_group is the type of the split out mask group from all masks
-     * @tparam mask_range is the type of the according mask range object
-     * 
-     * @param track is the track information 
-     * @param trf is the surface transform for the intersection
-     * @param masks is the associated (and split out) mask group
-     * @param range is the range list of masks to be processed
-     * 
-     * @note since all masks are on the same surface, only maximally one mask solution at a time
-     * is possbile. Once this solution is found, it is returned
-     * 
-     * @return the surface intersection 
-     **/
-    template <typename track_type,
-              typename mask_group,
-              typename mask_range>
-    auto intersect_by_group(const track_type &track,
-                            const transform3 &trf,
-                            const mask_group &masks,
-                            const mask_range &range)
-    {
-        for (auto i : sequence(range))
-        {
-            const auto &mask = masks[i];
-            auto local = mask.local();
-            auto sfi = mask.intersector().intersect(trf, track, local, mask);
-            if (sfi.status == e_inside)
-            {
-                auto valid_link = mask.links();
-                return std::make_tuple(sfi, valid_link);
-            }
+/** Specialized method to update an intersection when the mask group is resolved
+ *
+ * @tparam track_type is the type of the track information including context
+ * @tparam mask_group is the type of the split out mask group from all masks
+ * @tparam mask_range is the type of the according mask range object
+ *
+ * @param track is the track information
+ * @param trf is the surface transform for the intersection
+ * @param masks is the associated (and split out) mask group
+ * @param range is the range list of masks to be processed
+ *
+ * @note since all masks are on the same surface, only maximally one mask
+ *solution at a time is possbile. Once this solution is found, it is returned
+ *
+ * @return the surface intersection
+ **/
+template <typename track_type, typename mask_group, typename mask_range>
+auto intersect_by_group(const track_type &track, const transform3 &trf,
+                        const mask_group &masks, const mask_range &range) {
+    for (auto i : sequence(range)) {
+        const auto &mask = masks[i];
+        auto local = mask.local();
+        auto sfi = mask.intersector().intersect(trf, track, local, mask);
+        if (sfi.status == e_inside) {
+            auto valid_link = mask.links();
+            return std::make_tuple(sfi, valid_link);
         }
-        typename mask_group::value_type::mask_links_type invalid_link;
-        intersection invalid_intersection;
-        return std::make_tuple(invalid_intersection, invalid_link);
     }
+    typename mask_group::value_type::mask_links_type invalid_link;
+    intersection invalid_intersection;
+    return std::make_tuple(invalid_intersection, invalid_link);
+}
 
-    /** Variadic unrolled intersection - last entry 
-     * 
-     * @tparam intersection_type The type of intersection (to be updated)
-     * @tparam links_type The links type (to be updated)
-     * @tparam track_type is The type of the surface container
-     * @tparam mask_container is the type of the type of the mask container
-     * @tparam mask_range is the mask range type 
-     * @tparam last_mask_context is the last mask group context 
-     * 
-     * @param intersection [in, out] the intersection to be updated
-     * @param link [in, out] the links to be updated
-     * @param tack_type the track information containing the context
-     * @param ctf the contextual transform (context resolved)
-     * @param masks the masks container 
-     * @param range the range within the mask group to be checked
-     * @param mask_context the last mask group context 
-     *
-     * @return a bool for break condition (ignored here as last)
-     */
-    template <typename intersection_type,
-              typename links_type,
-              typename track_type,
-              typename mask_container,
-              typename mask_range,
-              dindex last_mask_context>
-    bool last_intersect(intersection_type &intersection,
-                        links_type &links,
-                        const track_type &track,
-                        const transform3 &ctf,
-                        const mask_container &masks,
-                        const mask_range &range,
-                        dindex mask_context)
-    {
-        if (mask_context == last_mask_context)
-        {
-            auto isg = intersect_by_group(track, ctf, std::get<last_mask_context>(masks), range);
-            intersection = std::get<0>(isg);
-            links = std::get<1>(isg);
-            return true;
-        }
-        return false;
+/** Variadic unrolled intersection - last entry
+ *
+ * @tparam intersection_type The type of intersection (to be updated)
+ * @tparam links_type The links type (to be updated)
+ * @tparam track_type is The type of the surface container
+ * @tparam mask_container is the type of the type of the mask container
+ * @tparam mask_range is the mask range type
+ * @tparam last_mask_context is the last mask group context
+ *
+ * @param intersection [in, out] the intersection to be updated
+ * @param link [in, out] the links to be updated
+ * @param tack_type the track information containing the context
+ * @param ctf the contextual transform (context resolved)
+ * @param masks the masks container
+ * @param range the range within the mask group to be checked
+ * @param mask_context the last mask group context
+ *
+ * @return a bool for break condition (ignored here as last)
+ */
+template <typename intersection_type, typename links_type, typename track_type,
+          typename mask_container, typename mask_range,
+          dindex last_mask_context>
+bool last_intersect(intersection_type &intersection, links_type &links,
+                    const track_type &track, const transform3 &ctf,
+                    const mask_container &masks, const mask_range &range,
+                    dindex mask_context) {
+    if (mask_context == last_mask_context) {
+        auto isg = intersect_by_group(
+            track, ctf, std::get<last_mask_context>(masks), range);
+        intersection = std::get<0>(isg);
+        links = std::get<1>(isg);
+        return true;
     }
+    return false;
+}
 
-    /** Variadic unrolled intersection - any integer sequence
-     * 
-     * @tparam intersection_type The type of intersection (to be updated)
-     * @tparam links_type The links type (to be updated)
-     * @tparam track_type is The type of the surface container
-     * @tparam mask_container is the type of the type of the mask container
-     * @tparam mask_range is the mask range type 
-     * @tparam first_mask_context is the first mask group context 
-     * 
-     * @param intersection [in, out] the intersection to be updated
-     * @param link [in, out] the links to be updated
-     * @param tack_type the track information containing the context
-     * @param ctf the contextual transform (context resolved)
-     * @param masks the masks container 
-     * @param range the range within the mask group to be checked
-     * @param mask_context the last mask group context 
-     * @param available_contices the mask contices to be checked
-     *
-     * @return a bool for break condition 
-     */
-    template <typename intersection_type,
-              typename links_type,
-              typename track_type,
-              typename mask_container,
-              typename mask_range,
-              dindex first_mask_context,
-              dindex... remaining_mask_context>
-    bool unroll_intersect(intersection_type &intersection,
-                          links_type &links,
-                          const track_type &track,
-                          const transform3 &ctf,
-                          const mask_container &masks,
-                          const mask_range &range,
-                          dindex mask_context,
-                          std::integer_sequence<dindex, first_mask_context, remaining_mask_context...> available_contices)
-    {
-        // Pick the first one for interseciton
-        if (mask_context == first_mask_context)
-        {
-            auto isg = intersect_by_group(track, ctf, std::get<first_mask_context>(masks), range);
-            intersection = std::get<0>(isg);
-            links = std::get<1>(isg);
+/** Variadic unrolled intersection - any integer sequence
+ *
+ * @tparam intersection_type The type of intersection (to be updated)
+ * @tparam links_type The links type (to be updated)
+ * @tparam track_type is The type of the surface container
+ * @tparam mask_container is the type of the type of the mask container
+ * @tparam mask_range is the mask range type
+ * @tparam first_mask_context is the first mask group context
+ *
+ * @param intersection [in, out] the intersection to be updated
+ * @param link [in, out] the links to be updated
+ * @param tack_type the track information containing the context
+ * @param ctf the contextual transform (context resolved)
+ * @param masks the masks container
+ * @param range the range within the mask group to be checked
+ * @param mask_context the last mask group context
+ * @param available_contices the mask contices to be checked
+ *
+ * @return a bool for break condition
+ */
+template <typename intersection_type, typename links_type, typename track_type,
+          typename mask_container, typename mask_range,
+          dindex first_mask_context, dindex... remaining_mask_context>
+bool unroll_intersect(
+    intersection_type &intersection, links_type &links, const track_type &track,
+    const transform3 &ctf, const mask_container &masks, const mask_range &range,
+    dindex mask_context,
+    std::integer_sequence<dindex, first_mask_context, remaining_mask_context...>
+        available_contices) {
+    // Pick the first one for interseciton
+    if (mask_context == first_mask_context) {
+        auto isg = intersect_by_group(
+            track, ctf, std::get<first_mask_context>(masks), range);
+        intersection = std::get<0>(isg);
+        links = std::get<1>(isg);
+        return true;
+    }
+    // The reduced integer sequence
+    std::integer_sequence<dindex, remaining_mask_context...> remaining;
+    // Unroll as long as you have at least 2 entries
+    if constexpr (remaining.size() > 1) {
+        if (unroll_intersect(intersection, links, track, ctf, masks, range,
+                             mask_context, remaining)) {
             return true;
         }
-        // The reduced integer sequence
-        std::integer_sequence<dindex, remaining_mask_context...> remaining;
-        // Unroll as long as you have at least 2 entries
-        if constexpr (remaining.size() > 1)
-        {
-            if (unroll_intersect(intersection, links, track, ctf, masks, range, mask_context, remaining))
-            {
-                return true;
-            }
-        }
-        // Last chance - intersect the last index if possible
-        return last_intersect<intersection_type,
-                              links_type,
-                              track_type,
-                              mask_container,
-                              mask_range,
-                              std::tuple_size_v<mask_container> - 1>(intersection, links, track, ctf, masks, range, mask_context);
     }
+    // Last chance - intersect the last index if possible
+    return last_intersect<intersection_type, links_type, track_type,
+                          mask_container, mask_range,
+                          std::tuple_size_v<mask_container> - 1>(
+        intersection, links, track, ctf, masks, range, mask_context);
+}
 
-    /** Actual kernel method that updates the updates the intersections
-     * 
-     * @tparam surface_type is The type of the surface container
-     * @tparam transform_container is the type of the transform container
-     * @tparam mask_container is the type of the type of the mask container
-     *
-     * @param track the track information including the contexts
-     * @param surface the surface type to be intersected
-     * @param contextual_transform the transform container
-     * @param mask_container the tuple mask container to for the intersection
-     * 
-     * @return an intersection and the link to the result
-    **/
-    template <typename surface_type,
-              typename transform_container,
-              typename mask_container>
-    const auto
-    intersect(const track<typename transform_container::context> &track,
-              const surface_type &surface,
-              const transform_container &contextual_transforms,
-              const mask_container &masks)
-    {
-        const auto &ctf = contextual_transforms[surface.transform()];
-        auto mask_link = surface.mask();
-        const auto &mask_context = std::get<0>(mask_link);
-        const auto &mask_range = std::get<1>(mask_link);
+/** Actual kernel method that updates the updates the intersections
+ *
+ * @tparam surface_type is The type of the surface container
+ * @tparam transform_container is the type of the transform container
+ * @tparam mask_container is the type of the type of the mask container
+ *
+ * @param track the track information including the contexts
+ * @param surface the surface type to be intersected
+ * @param contextual_transform the transform container
+ * @param mask_container the tuple mask container to for the intersection
+ *
+ * @return an intersection and the link to the result
+ **/
+template <typename surface_type, typename transform_container,
+          typename mask_container>
+const auto intersect(const track<typename transform_container::context> &track,
+                     const surface_type &surface,
+                     const transform_container &contextual_transforms,
+                     const mask_container &masks) {
+    const auto &ctf = contextual_transforms[surface.transform()];
+    auto mask_link = surface.mask();
+    const auto &mask_context = std::get<0>(mask_link);
+    const auto &mask_range = std::get<1>(mask_link);
 
-        // Create a return intersection and run the variadic unrolling
-        const auto &reference_group = std::get<0>(masks);
-        typename std::decay_t<decltype(reference_group)>::value_type::mask_links_type result_links;
-        intersection result_intersection;
+    // Create a return intersection and run the variadic unrolling
+    const auto &reference_group = std::get<0>(masks);
+    typename std::decay_t<decltype(
+        reference_group)>::value_type::mask_links_type result_links;
+    intersection result_intersection;
 
-        // Unroll the intersection depending on the mask container size
-        unroll_intersect(result_intersection, result_links, track, ctf, masks, mask_range, mask_context,
-                         std::make_integer_sequence<dindex, std::tuple_size_v<mask_container>>{});
-        // Return the (eventually update) intersection and links
-        return std::make_tuple(result_intersection, result_links);
-    }
+    // Unroll the intersection depending on the mask container size
+    unroll_intersect(
+        result_intersection, result_links, track, ctf, masks, mask_range,
+        mask_context,
+        std::make_integer_sequence<dindex,
+                                   std::tuple_size_v<mask_container>>{});
+    // Return the (eventually update) intersection and links
+    return std::make_tuple(result_intersection, result_links);
 }
+}  // namespace detray
diff --git a/core/include/tools/line_stepper.hpp b/core/include/tools/line_stepper.hpp
index 7b7187b639..b18473ef1e 100644
--- a/core/include/tools/line_stepper.hpp
+++ b/core/include/tools/line_stepper.hpp
@@ -1,67 +1,61 @@
 
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-namespace detray
-{
+namespace detray {
 
-    /** Line stepper implementation */
-    template <typename track_type,
-              template <typename ...> class tuple_type = dtuple>
-    struct line_stepper {
+/** Line stepper implementation */
+template <typename track_type, template <typename...> class tuple_type = dtuple>
+struct line_stepper {
 
-        /** State struct holding the track 
-         * 
-         * It has to cast into a const track via the call
-         * operat.
-         */
-        struct state {
-           
-            track_type& _track;
+    /** State struct holding the track
+     *
+     * It has to cast into a const track via the call
+     * operat.
+     */
+    struct state {
 
-            scalar _s = 0.; //!< Next step 
-            scalar _pl = std::numeric_limits<scalar>::max(); //!< Remaining path limit
+        track_type &_track;
 
-            state() = delete;
-            state(track_type& t) : _track(t) {}
+        scalar _s = 0.;  //!< Next step
+        scalar _pl =
+            std::numeric_limits<scalar>::max();  //!< Remaining path limit
 
+        state() = delete;
+        state(track_type &t) : _track(t) {}
 
-            /** @return the step and heartbeat given a step length s */
-            tuple_type<scalar, bool> step(scalar s) {
-                _pl = (s > _pl) ? s - _pl : _pl - s;
-                const bool heartbeat = (_pl > 0.);
-                return std::tie(std::min(s,_pl), heartbeat);
-            }
-
-            /** Set the path limit to a scalar @param l */
-            void set_limit(scalar pl) {
-                _pl = pl;
-            }
-
-            /** Call operator casts it itno a const track referenc on @return */
-            const track_type& operator()() const { return _track; }
-
-        };
-
-        /** Take a step, regulared by a constrained step
-         * 
-         * @param s The state object that chaches
-         * @param es The external step, e.g. from navigation 
-         * 
-         * @return returning the heartbeat, indicating if the stepping is alive
-         */
-        bool step(state& s, scalar es) const {
-            const auto [ sl, heartbeat ] = s.step(es);
-            s._track.pos = s._track.pos + s._track.dir * sl;
-            return heartbeat;
+        /** @return the step and heartbeat given a step length s */
+        tuple_type<scalar, bool> step(scalar s) {
+            _pl = (s > _pl) ? s - _pl : _pl - s;
+            const bool heartbeat = (_pl > 0.);
+            return std::tie(std::min(s, _pl), heartbeat);
         }
 
+        /** Set the path limit to a scalar @param l */
+        void set_limit(scalar pl) { _pl = pl; }
+
+        /** Call operator casts it itno a const track referenc on @return */
+        const track_type &operator()() const { return _track; }
     };
 
-}
+    /** Take a step, regulared by a constrained step
+     *
+     * @param s The state object that chaches
+     * @param es The external step, e.g. from navigation
+     *
+     * @return returning the heartbeat, indicating if the stepping is alive
+     */
+    bool step(state &s, scalar es) const {
+        const auto [sl, heartbeat] = s.step(es);
+        s._track.pos = s._track.pos + s._track.dir * sl;
+        return heartbeat;
+    }
+};
+
+}  // namespace detray
diff --git a/core/include/tools/local_object_finder.hpp b/core/include/tools/local_object_finder.hpp
index d696bb992e..93a13c3f5d 100644
--- a/core/include/tools/local_object_finder.hpp
+++ b/core/include/tools/local_object_finder.hpp
@@ -1,99 +1,92 @@
 
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-namespace detray
-{
-    /** A zone finder based on a grid 
-     * 
-     * @tparam grid_type is the type of the underlying grid object 
-     */
-    template <typename grid_type>
-    struct local_zone_finder
-    {
-        grid_type _grid;
-        bool _sort = true;
-
-        using point2 = __plugin::point2;
-
-        /** Constructor from grid 
-         * 
-         * @param grid is the prepared object/index grid, it will be moved into the 
-         * the local finder object
-         **/
-        local_zone_finder(grid_type &&grid)
-            : _grid(std::move(grid)) {}
-
-        /** Call operator for the object search with binned neighborhood
-         * 
-         * @param p2 the local 2d point for the grid
-         * @param nhood the local binned neighborhood
-         * 
-         * This method will create a vector and fill it
-         * 
-         * @note return a binned zone around a bin
-         **/
-        auto operator()(const point2 &p2, const typename grid_type::template neighborhood<dindex>& nhood = grid_type::hermit2) const
-        {
-            return _grid.zone(p2, nhood, _sort);
-        }
-
-        /** Call operator for the object search with scalar neighborhood
-         * 
-         * @param p2 the local 2d point for the grid
-         * @param nhood the local scalar neighborhood
-         * 
-         * This method will create a vector and fill it
-         * 
-         * @note return a binned zone around a bin
-         **/
-        auto operator()(const point2 &p2, const typename grid_type::template neighborhood<scalar>& nhood ) const
-        {
-            return _grid.zone(p2, nhood, _sort);
-        }
-
-        /** Const access to the grid */
-        const grid_type& grid() const { return _grid; }
-
-        /** Non-const access to the grid */
-        grid_type& grid() { return _grid; }
-
-    };
-
-    /** A zone finder for a single object */
-    template <typename value_type, 
-              typename vector_type = dvector<value_type>, 
-              template <typename, unsigned int> class array_type = darray>
-    struct local_single_finder
-    {
-
-        using point2 = __plugin::point2;
-
-        vector_type _value = {};
-
-        /** Constructor from a single value */
-        local_single_finder(value_type &&value)
-        {
-            _value = {std::move(value)};
-        }
-
-        /** Call operator for the object search
-         * 
-         * @tparam point2_type the type of the point for the finding request
-         * @param p2 the local 2d point for the grid
-         * @note return always the same bin 
-         **/
-        vector_type operator()(const point2 &p2, const array_type<unsigned int, 2> &nhood = {0, 0}) const
-        {
-            return _value;
-        }
-
-    };
-
-} // namespace detray
\ No newline at end of file
+namespace detray {
+/** A zone finder based on a grid
+ *
+ * @tparam grid_type is the type of the underlying grid object
+ */
+template <typename grid_type>
+struct local_zone_finder {
+    grid_type _grid;
+    bool _sort = true;
+
+    using point2 = __plugin::point2;
+
+    /** Constructor from grid
+     *
+     * @param grid is the prepared object/index grid, it will be moved into the
+     * the local finder object
+     **/
+    local_zone_finder(grid_type &&grid) : _grid(std::move(grid)) {}
+
+    /** Call operator for the object search with binned neighborhood
+     *
+     * @param p2 the local 2d point for the grid
+     * @param nhood the local binned neighborhood
+     *
+     * This method will create a vector and fill it
+     *
+     * @note return a binned zone around a bin
+     **/
+    auto operator()(const point2 &p2,
+                    const typename grid_type::template neighborhood<dindex>
+                        &nhood = grid_type::hermit2) const {
+        return _grid.zone(p2, nhood, _sort);
+    }
+
+    /** Call operator for the object search with scalar neighborhood
+     *
+     * @param p2 the local 2d point for the grid
+     * @param nhood the local scalar neighborhood
+     *
+     * This method will create a vector and fill it
+     *
+     * @note return a binned zone around a bin
+     **/
+    auto operator()(
+        const point2 &p2,
+        const typename grid_type::template neighborhood<scalar> &nhood) const {
+        return _grid.zone(p2, nhood, _sort);
+    }
+
+    /** Const access to the grid */
+    const grid_type &grid() const { return _grid; }
+
+    /** Non-const access to the grid */
+    grid_type &grid() { return _grid; }
+};
+
+/** A zone finder for a single object */
+template <typename value_type, typename vector_type = dvector<value_type>,
+          template <typename, unsigned int> class array_type = darray>
+struct local_single_finder {
+
+    using point2 = __plugin::point2;
+
+    vector_type _value = {};
+
+    /** Constructor from a single value */
+    local_single_finder(value_type &&value) { _value = {std::move(value)}; }
+
+    /** Call operator for the object search
+     *
+     * @tparam point2_type the type of the point for the finding request
+     * @param p2 the local 2d point for the grid
+     * @note return always the same bin
+     **/
+    vector_type operator()(const point2 &p2,
+                           const array_type<unsigned int, 2> &nhood = {
+                               0, 0}) const {
+        return _value;
+    }
+};
+
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/tools/navigator.hpp b/core/include/tools/navigator.hpp
index f718dc20bd..9d983b6c09 100644
--- a/core/include/tools/navigator.hpp
+++ b/core/include/tools/navigator.hpp
@@ -1,502 +1,503 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
+#include <algorithm>
+
 #include "core/intersection.hpp"
 #include "core/track.hpp"
-#include "utils/indexing.hpp"
-#include "utils/enumerate.hpp"
 #include "tools/intersection_kernel.hpp"
+#include "utils/enumerate.hpp"
+#include "utils/indexing.hpp"
 
-#include <algorithm>
+namespace detray {
 
-namespace detray
-{
+/** A void inpector that does nothing.
+ *
+ * Inspectors can be plugged in to understand the
+ * the current navigation state information.
+ *
+ */
+struct void_inspector {
+    template <typename state_type>
+    void operator()(const state_type & /*ignored*/) {}
+};
+
+/** The navigator struct.
+ *
+ * It follows the Acts::Navigator sturcture of sequence of
+ * - status()
+ * - target()
+ * calls.
+ *
+ * @tparam detector_tupe is the type of the detector
+ * @tparam inspector_type is a validation inspector
+ */
+template <typename detector_type, typename inspector_type = void_inspector>
+struct navigator {
+
+    using surface = typename detector_type::surface;
+    using surface_link = typename detector_type::surface_link;
+
+    using portal = typename detector_type::portal;
+    using portal_links = typename detector_type::portal_links;
+
+    using context = typename detector_type::context;
+
+    /** Navigation status flag */
+    enum navigation_status : int {
+        e_on_target = -3,
+        e_abort = -2,
+        e_unknown = -1,
+        e_towards_surface = 0,
+        e_on_surface = 1,
+        e_towards_portal = 2,
+        e_on_portal = 3,
+    };
 
-    /** A void inpector that does nothing.
-     * 
-     * Inspectors can be plugged in to understand the
-     * the current navigation state information.
-     * 
-     */
-    struct void_inspector
-    {
-        template <typename state_type>
-        void operator()(const state_type & /*ignored*/) {}
+    /** Navigation trust level */
+    enum navigation_trust_level : int {
+        e_no_trust = 0,    // re-evalute the candidates all over
+        e_fair_trust = 1,  // re-evaluate the distance & order of the
+                           // (preselected) candidates
+        e_high_trust = 3,  // re-evaluate the distance to the next candidate
+        e_full_trust = 4   // trust fully: distance & next candidate
     };
 
-    /** The navigator struct. 
-     * 
-     * It follows the Acts::Navigator sturcture of sequence of
-     * - status()
-     * - target()
-     * calls.
-     * 
-     * @tparam detector_tupe is the type of the detector
-     * @tparam inspector_type is a validation inspector 
-     */
-    template <typename detector_type, typename inspector_type = void_inspector>
-    struct navigator
-    {
-
-        using surface = typename detector_type::surface;
-        using surface_link = typename detector_type::surface_link;
-
-        using portal = typename detector_type::portal;
-        using portal_links = typename detector_type::portal_links;
-
-        using context = typename detector_type::context;
-
-        /** Navigation status flag */
-        enum navigation_status : int
-        {
-            e_on_target = -3,
-            e_abort = -2,
-            e_unknown = -1,
-            e_towards_surface = 0,
-            e_on_surface = 1,
-            e_towards_portal = 2,
-            e_on_portal = 3,
-        };
-
-        /** Navigation trust level */
-        enum navigation_trust_level : int
-        {
-            e_no_trust = 0,   // re-evalute the candidates all over
-            e_fair_trust = 1, // re-evaluate the distance & order of the (preselected) candidates
-            e_high_trust = 3, // re-evaluate the distance to the next candidate
-            e_full_trust = 4  // trust fully: distance & next candidate
-        };
-
-        /** A nested navigation kernel struct which can be used for surfaces, portals,
-         *  volumes a like.
-         *  
-         * @tparam object_type the type of the relevant object
-         * @tparam candidate_type the type of the candidates in the list
-         * @tparam links_type the type of the links the candidate is holding
-         * 
-         **/
-        template <typename object_type,
-                  typename candidate_type,
-                  typename links_type,
-                  template <typename> class vector_type = dvector>
-        struct navigation_kernel
-        {
-            const object_type *on = nullptr;
-            vector_type<candidate_type> candidates = {};
-            typename vector_type<candidate_type>::iterator next = candidates.end();
-            links_type links;
-
-            /** Indicate that the kernel is empty */
-            bool empty() const { return candidates.empty(); }
-
-            /** Forward the kernel size */
-            size_t size() const { return candidates.size(); }
-
-            /** Clear the kernel */
-            void clear()
-            {
-                candidates.clear();
-                next = candidates.end();
-                links = links_type{};
-                on = nullptr;
-            }
-        };
+    /** A nested navigation kernel struct which can be used for surfaces,
+     *portals, volumes a like.
+     *
+     * @tparam object_type the type of the relevant object
+     * @tparam candidate_type the type of the candidates in the list
+     * @tparam links_type the type of the links the candidate is holding
+     *
+     **/
+    template <typename object_type, typename candidate_type,
+              typename links_type,
+              template <typename> class vector_type = dvector>
+    struct navigation_kernel {
+        const object_type *on = nullptr;
+        vector_type<candidate_type> candidates = {};
+        typename vector_type<candidate_type>::iterator next = candidates.end();
+        links_type links;
+
+        /** Indicate that the kernel is empty */
+        bool empty() const { return candidates.empty(); }
+
+        /** Forward the kernel size */
+        size_t size() const { return candidates.size(); }
+
+        /** Clear the kernel */
+        void clear() {
+            candidates.clear();
+            next = candidates.end();
+            links = links_type{};
+            on = nullptr;
+        }
+    };
 
-        /** A navigation state object used to cache the information of the
-         * current navigation stream.
-         * 
-         * It requires to have a scalar represenation to be used for a stepper
-         **/
-        struct state
-        {
-            /** Kernel for the surfaces */
-            navigation_kernel<surface, intersection, surface_link> surface_kernel;
-            /** Kernel for the portals */
-            navigation_kernel<portal, intersection, portal_links> portal_kernel;
-
-            /** Volume navigation: index */
-            dindex volume_index = dindex_invalid;
-
-            /**  Distance to next - will be casted into a scalar with call operator  */
-            scalar distance_to_next = std::numeric_limits<scalar>::infinity();
-            /** The on surface tolerance - permille */
-            scalar on_surface_tolerance = 1e-3;
-
-            /** The inspector type of this navigation engine */
-            inspector_type inspector;
-
-            /**  The navigation status */
-            navigation_status status = e_unknown;
-
-            /** If a surface / portal is reached */
-            dindex current_index = dindex_invalid;
-
-            /** The navigation trust level */
-            navigation_trust_level trust_level = e_no_trust;
-
-            /** Scalar representation of the navigation state,
-             * @returns distance to next
-             **/
-            scalar operator()() const
-            {
-                return distance_to_next;
-            }
-        };
+    /** A navigation state object used to cache the information of the
+     * current navigation stream.
+     *
+     * It requires to have a scalar represenation to be used for a stepper
+     **/
+    struct state {
+        /** Kernel for the surfaces */
+        navigation_kernel<surface, intersection, surface_link> surface_kernel;
+        /** Kernel for the portals */
+        navigation_kernel<portal, intersection, portal_links> portal_kernel;
+
+        /** Volume navigation: index */
+        dindex volume_index = dindex_invalid;
+
+        /**  Distance to next - will be casted into a scalar with call operator
+         */
+        scalar distance_to_next = std::numeric_limits<scalar>::infinity();
+        /** The on surface tolerance - permille */
+        scalar on_surface_tolerance = 1e-3;
 
-        __plugin::cartesian2 cart2;
-        __plugin::polar2 pol2;
-        __plugin::cylindrical2 cyl2;
+        /** The inspector type of this navigation engine */
+        inspector_type inspector;
 
-        /// The detector in which we are moving
-        detector_type detector;
+        /**  The navigation status */
+        navigation_status status = e_unknown;
 
-        /** Constructor with move constructor
-         * 
-         * @param d the detector for this navigator
-         */
-        navigator(detector_type &&d) : detector(std::move(d)) {}
-
-        /** Navigation status() call which established the current navigation information.
-         * 
-         * @param navigation [in, out] is the navigation cache object
-         * @param track [in] is the track infromation
-         * 
-         * @return a heartbeat to indicate if the navigation is still alive
+        /** If a surface / portal is reached */
+        dindex current_index = dindex_invalid;
+
+        /** The navigation trust level */
+        navigation_trust_level trust_level = e_no_trust;
+
+        /** Scalar representation of the navigation state,
+         * @returns distance to next
          **/
-        bool status(state &navigation, const track<context> &track) const
-        {
-
-            bool heartbeat = true;
-
-            // Retrieve the volume & set index
-            // Retrieve the volume, either from valid index or through global search
-            const auto &volume = (navigation.volume_index != dindex_invalid) ? detector.indexed_volume(navigation.volume_index)
-                                                                             : detector.indexed_volume(track.pos);
-            navigation.volume_index = volume.index();
-            // Retrieve the kernels
-            auto &surface_kernel = navigation.surface_kernel;
-            auto &portal_kernel = navigation.portal_kernel;
-
-            // The navigation is not yet initialized, or you lost trust in it
-            if (navigation.volume_index == dindex_invalid or navigation.trust_level == e_no_trust)
-            {
-                // First try to get the surface candidates
-                initialize_kernel(navigation, surface_kernel, track, volume.template range<detector_type::e_surface>(), volume.template trf_range<detector_type::e_surface>());
-                // If no surfaces are to processed, initialize the portals
-                if (surface_kernel.empty())
-                {
-                    initialize_kernel(navigation, portal_kernel, track, volume.template range<detector_type::e_portal>(), volume.template trf_range<detector_type::e_portal>());
-                    heartbeat = check_volume_switch(navigation);
-                }
-                // Before returning, run through the inspector
-                navigation.inspector(navigation);
-                return heartbeat;
-            }
+        scalar operator()() const { return distance_to_next; }
+    };
 
-            // Update the surface kernel
-            if (not is_exhausted(surface_kernel) and update_kernel(navigation, surface_kernel, track, volume.template range<detector_type::e_surface>(), volume.template trf_range<detector_type::e_surface>()))
-            {
-                navigation.inspector(navigation);
-                return heartbeat;
-            }
+    __plugin::cartesian2 cart2;
+    __plugin::polar2 pol2;
+    __plugin::cylindrical2 cyl2;
 
-            // Update the portal kernel
-            update_kernel(navigation, portal_kernel, track, volume.template range<detector_type::e_portal>(), volume.template trf_range<detector_type::e_portal>());
-            heartbeat = check_volume_switch(navigation);
+    /// The detector in which we are moving
+    detector_type detector;
+
+    /** Constructor with move constructor
+     *
+     * @param d the detector for this navigator
+     */
+    navigator(detector_type &&d) : detector(std::move(d)) {}
+
+    /** Navigation status() call which established the current navigation
+     *information.
+     *
+     * @param navigation [in, out] is the navigation cache object
+     * @param track [in] is the track infromation
+     *
+     * @return a heartbeat to indicate if the navigation is still alive
+     **/
+    bool status(state &navigation, const track<context> &track) const {
+
+        bool heartbeat = true;
+
+        // Retrieve the volume & set index
+        // Retrieve the volume, either from valid index or through global search
+        const auto &volume =
+            (navigation.volume_index != dindex_invalid)
+                ? detector.indexed_volume(navigation.volume_index)
+                : detector.indexed_volume(track.pos);
+        navigation.volume_index = volume.index();
+        // Retrieve the kernels
+        auto &surface_kernel = navigation.surface_kernel;
+        auto &portal_kernel = navigation.portal_kernel;
+
+        // The navigation is not yet initialized, or you lost trust in it
+        if (navigation.volume_index == dindex_invalid or
+            navigation.trust_level == e_no_trust) {
+            // First try to get the surface candidates
+            initialize_kernel(
+                navigation, surface_kernel, track,
+                volume.template range<detector_type::e_surface>(),
+                volume.template trf_range<detector_type::e_surface>());
+            // If no surfaces are to processed, initialize the portals
+            if (surface_kernel.empty()) {
+                initialize_kernel(
+                    navigation, portal_kernel, track,
+                    volume.template range<detector_type::e_portal>(),
+                    volume.template trf_range<detector_type::e_portal>());
+                heartbeat = check_volume_switch(navigation);
+            }
+            // Before returning, run through the inspector
             navigation.inspector(navigation);
             return heartbeat;
         }
 
-        /** Target function of the navigator, finds the next candidates 
-         *   and set the distance to next
-         * 
-         * @param navigation is the navigation cache
-         * @param track is the current track information
-         * 
-         * @return a heartbeat to indicate if the navigation is still alive
-         **/
-        bool target(state &navigation, const track<context> &track) const
-        {
-            bool heartbeat = true;
-
-            // Full trust level from target() call
-            if (navigation.trust_level == e_full_trust)
-            {
-                return heartbeat;
-            }
-
-            // Retrieve the volume, either from valid index or through global search
-            const auto &volume = (navigation.volume_index != dindex_invalid) ? detector.indexed_volume(navigation.volume_index)
-                                                                             : detector.indexed_volume(track.pos);
-            navigation.volume_index = volume.index();
-            // Retrieve the kernels
-            auto &surface_kernel = navigation.surface_kernel;
-            auto &portal_kernel = navigation.portal_kernel;
-            // High targetting level
-            if (navigation.trust_level == e_high_trust)
-            {
-                // Surfaces are/were present
-                if (not surface_kernel.empty())
-                {
-                    if (is_exhausted(surface_kernel))
-                    {
-                        // Clear the surface kernel
-                        surface_kernel.clear();
-                        navigation.trust_level = e_no_trust;
-                        update_kernel(navigation, portal_kernel, track, volume.template range<detector_type::e_portal>(), volume.template trf_range<detector_type::e_portal>());
-                        navigation.inspector(navigation);
-                        return heartbeat;
-                    }
-                    else if (update_kernel(navigation, surface_kernel, track, volume.template range<detector_type::e_surface>(), volume.template trf_range<detector_type::e_surface>()))
-                    {
-                        navigation.inspector(navigation);
-                        return heartbeat;
-                    }
-                }
-                // Portals are present
-                update_kernel(navigation, portal_kernel, track, volume.template range<detector_type::e_portal>(), volume.template trf_range<detector_type::e_portal>());
-            }
-            else if (navigation.trust_level == e_no_trust)
-            {
-                // First try to get the surface candidates
-                initialize_kernel(navigation, surface_kernel, track, volume.template range<detector_type::e_surface>(), volume.template trf_range<detector_type::e_surface>());
-                // If no surfaces are to processed, initialize the portals
-                if (surface_kernel.empty())
-                {
-                    initialize_kernel(navigation, portal_kernel, track, volume.template range<detector_type::e_portal>(), volume.template trf_range<detector_type::e_portal>(), navigation.status == e_on_portal);
-                    heartbeat = check_volume_switch(navigation);
-                }
-            }
+        // Update the surface kernel
+        if (not is_exhausted(surface_kernel) and
+            update_kernel(
+                navigation, surface_kernel, track,
+                volume.template range<detector_type::e_surface>(),
+                volume.template trf_range<detector_type::e_surface>())) {
             navigation.inspector(navigation);
             return heartbeat;
         }
 
-        /** Helper method to intersect all objects of a surface/portal store
-         * 
-         * @tparam kernel_t the type of the kernel: surfaces/portals
-         * @tparam range the type of range in the detector data containers
-         * 
-         * @param navigation is the navigation cache object
-         * @param kernel [in,out] the kernel to be checked/initialized 
-         * @param track the track information
-         * @param obj_range the surface/portal index range in the detector cont
-         * @param trf_range the transform index range in the detector cont
-         * @param on_object ignores on surface solution
-         * 
-         */
-        template <typename kernel_t, typename range_t>
-        void initialize_kernel(state &navigation,
-                               kernel_t &kernel,
-                               const track<context> &track,
-                               const range_t &obj_range,
-                               const range_t &trf_range,
-                               bool on_object = false) const
-        {
-
-            // Get the type of the kernel via a const expression at compile time
-            constexpr bool kSurfaceType = (std::is_same_v<kernel_t, navigation_kernel<surface, intersection, surface_link>>);
-
-            // Get the number of candidates & run them throuth the kernel
-            size_t n_objects = obj_range[1] - obj_range[0];
-            // Return if you have no objects
-            if (n_objects == 0)
-            {
-                return;
-            }
-            kernel.candidates.reserve(n_objects);
-            const auto &transforms = detector.transforms(trf_range, track.ctx);
-            const auto &surfaces = detector.template surfaces<kSurfaceType>();
-            const auto &masks = detector.template masks<kSurfaceType>();
-            // Loop over all indexed surfaces, intersect and fill
-            // @todo - will come from the local object finder
-            for (auto si : sequence(obj_range))
-            {
-                const auto &object = surfaces[si];
-                auto [sfi, link] = intersect(track, object, transforms, masks);
-                sfi.index = si;
-                sfi.link = link[0];
-                // Ignore negative solutions - except overstep limit
-                if (sfi.path < track.overstep_tolerance)
-                {
-                    continue;
-                }
-                // Accept if inside, but not if the same object is excluded
-                if (sfi.status == e_inside and (not on_object or std::abs(sfi.path) > navigation.on_surface_tolerance))
-                {
-                    navigation.status = kSurfaceType ? e_towards_surface : e_towards_portal;
-                    kernel.candidates.push_back(sfi);
+        // Update the portal kernel
+        update_kernel(navigation, portal_kernel, track,
+                      volume.template range<detector_type::e_portal>(),
+                      volume.template trf_range<detector_type::e_portal>());
+        heartbeat = check_volume_switch(navigation);
+        navigation.inspector(navigation);
+        return heartbeat;
+    }
+
+    /** Target function of the navigator, finds the next candidates
+     *   and set the distance to next
+     *
+     * @param navigation is the navigation cache
+     * @param track is the current track information
+     *
+     * @return a heartbeat to indicate if the navigation is still alive
+     **/
+    bool target(state &navigation, const track<context> &track) const {
+        bool heartbeat = true;
+
+        // Full trust level from target() call
+        if (navigation.trust_level == e_full_trust) {
+            return heartbeat;
+        }
+
+        // Retrieve the volume, either from valid index or through global search
+        const auto &volume =
+            (navigation.volume_index != dindex_invalid)
+                ? detector.indexed_volume(navigation.volume_index)
+                : detector.indexed_volume(track.pos);
+        navigation.volume_index = volume.index();
+        // Retrieve the kernels
+        auto &surface_kernel = navigation.surface_kernel;
+        auto &portal_kernel = navigation.portal_kernel;
+        // High targetting level
+        if (navigation.trust_level == e_high_trust) {
+            // Surfaces are/were present
+            if (not surface_kernel.empty()) {
+                if (is_exhausted(surface_kernel)) {
+                    // Clear the surface kernel
+                    surface_kernel.clear();
+                    navigation.trust_level = e_no_trust;
+                    update_kernel(
+                        navigation, portal_kernel, track,
+                        volume.template range<detector_type::e_portal>(),
+                        volume.template trf_range<detector_type::e_portal>());
+                    navigation.inspector(navigation);
+                    return heartbeat;
+                } else if (update_kernel(
+                               navigation, surface_kernel, track,
+                               volume
+                                   .template range<detector_type::e_surface>(),
+                               volume.template trf_range<
+                                   detector_type::e_surface>())) {
+                    navigation.inspector(navigation);
+                    return heartbeat;
                 }
             }
-            sort_and_set(navigation, kernel);
+            // Portals are present
+            update_kernel(navigation, portal_kernel, track,
+                          volume.template range<detector_type::e_portal>(),
+                          volume.template trf_range<detector_type::e_portal>());
+        } else if (navigation.trust_level == e_no_trust) {
+            // First try to get the surface candidates
+            initialize_kernel(
+                navigation, surface_kernel, track,
+                volume.template range<detector_type::e_surface>(),
+                volume.template trf_range<detector_type::e_surface>());
+            // If no surfaces are to processed, initialize the portals
+            if (surface_kernel.empty()) {
+                initialize_kernel(
+                    navigation, portal_kernel, track,
+                    volume.template range<detector_type::e_portal>(),
+                    volume.template trf_range<detector_type::e_portal>(),
+                    navigation.status == e_on_portal);
+                heartbeat = check_volume_switch(navigation);
+            }
         }
-
-        /** Helper method to the update the next candidate intersection 
-         * 
-         * @tparam kernel_t the type of the kernel: surfaces/portals
-         * @tparam range the type of range in the detector data containers
-         * 
-         * @param navigation [in, out] the navigation state
-         * @param kernel [in,out] the kernel to be checked/initialized 
-         * @param track the track information
-         * @param obj_range the surface/portal index range in the detector cont
-         * @param trf_range the transform index range in the detector cont
-         * 
-         * @return A boolean condition 
-         */
-        template <typename kernel_t, typename range_t>
-        bool update_kernel(state &navigation,
-                           kernel_t &kernel,
+        navigation.inspector(navigation);
+        return heartbeat;
+    }
+
+    /** Helper method to intersect all objects of a surface/portal store
+     *
+     * @tparam kernel_t the type of the kernel: surfaces/portals
+     * @tparam range the type of range in the detector data containers
+     *
+     * @param navigation is the navigation cache object
+     * @param kernel [in,out] the kernel to be checked/initialized
+     * @param track the track information
+     * @param obj_range the surface/portal index range in the detector cont
+     * @param trf_range the transform index range in the detector cont
+     * @param on_object ignores on surface solution
+     *
+     */
+    template <typename kernel_t, typename range_t>
+    void initialize_kernel(state &navigation, kernel_t &kernel,
                            const track<context> &track,
-                           const range_t &obj_range,
-                           const range_t &trf_range) const
-        {
-            // If the kernel is empty - intitalize it
-            if (kernel.empty())
-            {
-                initialize_kernel(navigation, kernel, track, obj_range, trf_range);
-                return true;
+                           const range_t &obj_range, const range_t &trf_range,
+                           bool on_object = false) const {
+
+        // Get the type of the kernel via a const expression at compile time
+        constexpr bool kSurfaceType =
+            (std::is_same_v<kernel_t, navigation_kernel<surface, intersection,
+                                                        surface_link>>);
+
+        // Get the number of candidates & run them throuth the kernel
+        size_t n_objects = obj_range[1] - obj_range[0];
+        // Return if you have no objects
+        if (n_objects == 0) {
+            return;
+        }
+        kernel.candidates.reserve(n_objects);
+        const auto &transforms = detector.transforms(trf_range, track.ctx);
+        const auto &surfaces = detector.template surfaces<kSurfaceType>();
+        const auto &masks = detector.template masks<kSurfaceType>();
+        // Loop over all indexed surfaces, intersect and fill
+        // @todo - will come from the local object finder
+        for (auto si : sequence(obj_range)) {
+            const auto &object = surfaces[si];
+            auto [sfi, link] = intersect(track, object, transforms, masks);
+            sfi.index = si;
+            sfi.link = link[0];
+            // Ignore negative solutions - except overstep limit
+            if (sfi.path < track.overstep_tolerance) {
+                continue;
             }
+            // Accept if inside, but not if the same object is excluded
+            if (sfi.status == e_inside and
+                (not on_object or
+                 std::abs(sfi.path) > navigation.on_surface_tolerance)) {
+                navigation.status =
+                    kSurfaceType ? e_towards_surface : e_towards_portal;
+                kernel.candidates.push_back(sfi);
+            }
+        }
+        sort_and_set(navigation, kernel);
+    }
+
+    /** Helper method to the update the next candidate intersection
+     *
+     * @tparam kernel_t the type of the kernel: surfaces/portals
+     * @tparam range the type of range in the detector data containers
+     *
+     * @param navigation [in, out] the navigation state
+     * @param kernel [in,out] the kernel to be checked/initialized
+     * @param track the track information
+     * @param obj_range the surface/portal index range in the detector cont
+     * @param trf_range the transform index range in the detector cont
+     *
+     * @return A boolean condition
+     */
+    template <typename kernel_t, typename range_t>
+    bool update_kernel(state &navigation, kernel_t &kernel,
+                       const track<context> &track, const range_t &obj_range,
+                       const range_t &trf_range) const {
+        // If the kernel is empty - intitalize it
+        if (kernel.empty()) {
+            initialize_kernel(navigation, kernel, track, obj_range, trf_range);
+            return true;
+        }
 
-            // Get the type of the kernel via a const expression at compile time
-            constexpr bool kSurfaceType = (std::is_same_v<kernel_t, navigation_kernel<surface, intersection, surface_link>>);
-
-            const auto &transforms = detector.transforms(trf_range, track.ctx);
-            const auto &surfaces = detector.template surfaces<kSurfaceType>();
-            const auto &masks = detector.template masks<kSurfaceType>();
-
-            // Update current candidate, or step further
-            // - do this only when you trust level is high
-            if (navigation.trust_level >= e_high_trust and kernel.next != kernel.candidates.end())
-            {
-                // Only update the last intersection
-                dindex si = kernel.next->index;
-                const auto &s = surfaces[si];
-                auto [sfi, link] = intersect(track, s, transforms, masks);
-                sfi.index = si;
-                sfi.link = link[0];
-                if (sfi.status == e_inside)
-                {
-                    // Update the intersection with a new one
-                    (*kernel.next) = sfi;
-                    navigation.distance_to_next = sfi.path;
-                    if (std::abs(sfi.path) < navigation.on_surface_tolerance)
-                    {
-                        navigation.status = kSurfaceType ? e_on_surface : e_on_portal;
-                        navigation.current_index = si;
-                        if (navigation.status != e_on_portal)
-                        {
-                            ++kernel.next;
-                            // Trust level is high
-                            navigation.trust_level = e_high_trust;
-                        }
-                    }
-                    else
-                    {
-                        navigation.status = kSurfaceType ? e_towards_surface : e_towards_portal;
-                        // Trust fully again
-                        navigation.trust_level = e_full_trust;
+        // Get the type of the kernel via a const expression at compile time
+        constexpr bool kSurfaceType =
+            (std::is_same_v<kernel_t, navigation_kernel<surface, intersection,
+                                                        surface_link>>);
+
+        const auto &transforms = detector.transforms(trf_range, track.ctx);
+        const auto &surfaces = detector.template surfaces<kSurfaceType>();
+        const auto &masks = detector.template masks<kSurfaceType>();
+
+        // Update current candidate, or step further
+        // - do this only when you trust level is high
+        if (navigation.trust_level >= e_high_trust and
+            kernel.next != kernel.candidates.end()) {
+            // Only update the last intersection
+            dindex si = kernel.next->index;
+            const auto &s = surfaces[si];
+            auto [sfi, link] = intersect(track, s, transforms, masks);
+            sfi.index = si;
+            sfi.link = link[0];
+            if (sfi.status == e_inside) {
+                // Update the intersection with a new one
+                (*kernel.next) = sfi;
+                navigation.distance_to_next = sfi.path;
+                if (std::abs(sfi.path) < navigation.on_surface_tolerance) {
+                    navigation.status =
+                        kSurfaceType ? e_on_surface : e_on_portal;
+                    navigation.current_index = si;
+                    if (navigation.status != e_on_portal) {
+                        ++kernel.next;
+                        // Trust level is high
+                        navigation.trust_level = e_high_trust;
                     }
-                    return true;
-                }
-                // If not successful: increase and switch to next
-                ++kernel.next;
-                if (update_kernel(navigation, kernel, track, obj_range, trf_range))
-                {
-                    return true;
+                } else {
+                    navigation.status =
+                        kSurfaceType ? e_towards_surface : e_towards_portal;
+                    // Trust fully again
+                    navigation.trust_level = e_full_trust;
                 }
+                return true;
             }
-            // Loop over all candidates and intersect again all candidates
-            // - do this when your trust level is low
-            else if (navigation.trust_level == e_fair_trust)
-            {
-                for (auto &c : kernel.candidates)
-                {
-                    dindex si = c.index;
-                    const auto &s = surfaces[si];
-                    auto [sfi, link] = intersect(track, s, transforms, masks);
-                    c = sfi;
-                    c.index = si;
-                    c.link = link[0];
-                }
-                sort_and_set(navigation, kernel);
-                if (navigation.trust_level == e_high_trust)
-                {
-                    return true;
-                }
+            // If not successful: increase and switch to next
+            ++kernel.next;
+            if (update_kernel(navigation, kernel, track, obj_range,
+                              trf_range)) {
+                return true;
             }
-            // This kernel is exhausted
-            kernel.next = kernel.candidates.end();
-            navigation.trust_level = e_no_trust;
-            return false;
         }
-
-        /** Helper method to sort within the kernel 
-         *
-         * @param navigation is the state for setting the distance to next
-         * @param kernel is the kernel which should be updated
-         */
-        template <typename kernel_t>
-        void sort_and_set(state &navigation, kernel_t &kernel) const
-        {
-            // Get the type of the kernel via a const expression at compile time
-            constexpr bool kSurfaceType = (std::is_same_v<kernel_t, navigation_kernel<surface, intersection, surface_link>>);
-
-            // Sort and set distance to next & navigation status
-            if (not kernel.candidates.empty())
-            {
-                navigation.trust_level = e_full_trust;
-                std::sort(kernel.candidates.begin(), kernel.candidates.end());
-                kernel.next = kernel.candidates.begin();
-                navigation.distance_to_next = kernel.next->path;
-                if (navigation.distance_to_next < navigation.on_surface_tolerance)
-                {
-                    navigation.status = kSurfaceType ? e_on_surface : e_on_portal;
-                    navigation.current_index = kernel.next->index;
-                }
-                navigation.current_index = dindex_invalid;
-                navigation.status = kSurfaceType ? e_towards_surface : e_towards_portal;
+        // Loop over all candidates and intersect again all candidates
+        // - do this when your trust level is low
+        else if (navigation.trust_level == e_fair_trust) {
+            for (auto &c : kernel.candidates) {
+                dindex si = c.index;
+                const auto &s = surfaces[si];
+                auto [sfi, link] = intersect(track, s, transforms, masks);
+                c = sfi;
+                c.index = si;
+                c.link = link[0];
+            }
+            sort_and_set(navigation, kernel);
+            if (navigation.trust_level == e_high_trust) {
+                return true;
             }
         }
-
-        /** Helper method to check and perform a volume switch
-         *
-         * @param navigation is the navigation state 
-         * 
-         * @return a flag if the volume navigation is still heartbeat
-         */
-        bool check_volume_switch(state &navigation) const
-        {
-            // On a portal: switch volume index and (re-)initialize
-            if (navigation.status == e_on_portal)
-            {
-                // Set volume index to the next volume provided by the portal, avoid setting to same
-                navigation.volume_index =
-                    (navigation.portal_kernel.next->link != navigation.volume_index) ? navigation.portal_kernel.next->link : dindex_invalid;
-                navigation.surface_kernel.clear();
-                navigation.portal_kernel.clear();
-                navigation.trust_level = e_no_trust;
+        // This kernel is exhausted
+        kernel.next = kernel.candidates.end();
+        navigation.trust_level = e_no_trust;
+        return false;
+    }
+
+    /** Helper method to sort within the kernel
+     *
+     * @param navigation is the state for setting the distance to next
+     * @param kernel is the kernel which should be updated
+     */
+    template <typename kernel_t>
+    void sort_and_set(state &navigation, kernel_t &kernel) const {
+        // Get the type of the kernel via a const expression at compile time
+        constexpr bool kSurfaceType =
+            (std::is_same_v<kernel_t, navigation_kernel<surface, intersection,
+                                                        surface_link>>);
+
+        // Sort and set distance to next & navigation status
+        if (not kernel.candidates.empty()) {
+            navigation.trust_level = e_full_trust;
+            std::sort(kernel.candidates.begin(), kernel.candidates.end());
+            kernel.next = kernel.candidates.begin();
+            navigation.distance_to_next = kernel.next->path;
+            if (navigation.distance_to_next < navigation.on_surface_tolerance) {
+                navigation.status = kSurfaceType ? e_on_surface : e_on_portal;
+                navigation.current_index = kernel.next->index;
             }
-            return (navigation.volume_index != dindex_invalid);
+            navigation.current_index = dindex_invalid;
+            navigation.status =
+                kSurfaceType ? e_towards_surface : e_towards_portal;
         }
+    }
 
-        /** Helper method to check if a kernel is exhaused 
-         * 
-         * @tparam kernel_t the type of the kernel
-         * @param kernel the kernel to be checked
-         * 
-         * @return true if the kernel is exhaused 
-         */
-        template <typename kernel_t>
-        bool is_exhausted(const kernel_t &kernel) const
-        {
-            return (kernel.next == kernel.candidates.end());
+    /** Helper method to check and perform a volume switch
+     *
+     * @param navigation is the navigation state
+     *
+     * @return a flag if the volume navigation is still heartbeat
+     */
+    bool check_volume_switch(state &navigation) const {
+        // On a portal: switch volume index and (re-)initialize
+        if (navigation.status == e_on_portal) {
+            // Set volume index to the next volume provided by the portal, avoid
+            // setting to same
+            navigation.volume_index =
+                (navigation.portal_kernel.next->link != navigation.volume_index)
+                    ? navigation.portal_kernel.next->link
+                    : dindex_invalid;
+            navigation.surface_kernel.clear();
+            navigation.portal_kernel.clear();
+            navigation.trust_level = e_no_trust;
         }
-    };
+        return (navigation.volume_index != dindex_invalid);
+    }
+
+    /** Helper method to check if a kernel is exhaused
+     *
+     * @tparam kernel_t the type of the kernel
+     * @param kernel the kernel to be checked
+     *
+     * @return true if the kernel is exhaused
+     */
+    template <typename kernel_t>
+    bool is_exhausted(const kernel_t &kernel) const {
+        return (kernel.next == kernel.candidates.end());
+    }
+};
 
-} // namespace detray
\ No newline at end of file
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/tools/planar_intersector.hpp b/core/include/tools/planar_intersector.hpp
index 09557e0219..be2740ca36 100644
--- a/core/include/tools/planar_intersector.hpp
+++ b/core/include/tools/planar_intersector.hpp
@@ -1,109 +1,103 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
+#include <climits>
+#include <cmath>
+#include <optional>
+
 #include "core/intersection.hpp"
 #include "core/surface_base.hpp"
 #include "core/track.hpp"
 #include "masks/unmasked.hpp"
 #include "utils/unbound.hpp"
 
-#include <cmath>
-#include <climits>
-#include <optional>
-
-namespace detray
-{
+namespace detray {
 
-    /** This is an intersector struct for planar surface
-     */
-    struct planar_intersector
-    {
+/** This is an intersector struct for planar surface
+ */
+struct planar_intersector {
 
-        using transform3 = __plugin::transform3;
-        using point3 = __plugin::point3;
-        using vector3 = __plugin::vector3;
-        using point2 = __plugin::point2;
+    using transform3 = __plugin::transform3;
+    using point3 = __plugin::point3;
+    using vector3 = __plugin::vector3;
+    using point2 = __plugin::point2;
 
-        /** Intersection method for planar surfaces
-         * 
-         * @tparam track_type The type of the track (which carries the context object)
-         * @tparam local_type The local frame type to be intersected
-         * @tparam mask_type The mask type applied to the local frame
-         * 
-         * Contextual part:
-         * @param trf the surface to be intersected
-         * @param track the track information
-         * @param local to the local frame 
-         * 
-         * Non-contextual part:
-         * @param mask the local mask 
-         * @param tolerance is the mask specific tolerance
-         * 
-         * @return the intersection with optional parameters
-         **/
-        template <typename track_type, typename local_type, typename mask_type>
-        intersection
-        intersect(const transform3 &trf,
-                  const track_type &track,
-                  const local_type &local,
-                  const mask_type &mask,
-                  const typename mask_type::mask_tolerance &tolerance = mask_type::within_epsilon) const
-        {
-            return intersect(trf, track.pos, track.dir, local, mask, tolerance, track.overstep_tolerance);
-        }
+    /** Intersection method for planar surfaces
+     *
+     * @tparam track_type The type of the track (which carries the context
+     *object)
+     * @tparam local_type The local frame type to be intersected
+     * @tparam mask_type The mask type applied to the local frame
+     *
+     * Contextual part:
+     * @param trf the surface to be intersected
+     * @param track the track information
+     * @param local to the local frame
+     *
+     * Non-contextual part:
+     * @param mask the local mask
+     * @param tolerance is the mask specific tolerance
+     *
+     * @return the intersection with optional parameters
+     **/
+    template <typename track_type, typename local_type, typename mask_type>
+    intersection intersect(const transform3 &trf, const track_type &track,
+                           const local_type &local, const mask_type &mask,
+                           const typename mask_type::mask_tolerance &tolerance =
+                               mask_type::within_epsilon) const {
+        return intersect(trf, track.pos, track.dir, local, mask, tolerance,
+                         track.overstep_tolerance);
+    }
 
-        /** Intersection method for planar surfaces
-         * 
-         * @tparam local_type The local frame type to be intersected
-         * @tparam mask_type The mask type applied to the local frame
-         * 
-         * Contextual part:
-         * @param trf the transform of the surface to be intersected
-         * @param ro the origin of the ray
-         * @param rd the direction of the ray
-         * @param local transform to the local local frame 
-         * 
-         * Non-contextual part:
-         * @param mask the local mask 
-         * @param tolerance is the mask specific tolerance
-         * 
-         * @return the intersection with optional parameters
-         **/
-        template <typename local_type = unbound, typename mask_type = unmasked>
-        intersection
-        intersect(const transform3 &trf,
-                  const point3 &ro,
-                  const vector3 &rd,
-                  const local_type &local = local_type(),
-                  const mask_type &mask = mask_type(),
-                  const typename mask_type::mask_tolerance &tolerance = mask_type::within_epsilon,
-                  scalar overstep_tolerance = 0.) const
-        {
+    /** Intersection method for planar surfaces
+     *
+     * @tparam local_type The local frame type to be intersected
+     * @tparam mask_type The mask type applied to the local frame
+     *
+     * Contextual part:
+     * @param trf the transform of the surface to be intersected
+     * @param ro the origin of the ray
+     * @param rd the direction of the ray
+     * @param local transform to the local local frame
+     *
+     * Non-contextual part:
+     * @param mask the local mask
+     * @param tolerance is the mask specific tolerance
+     *
+     * @return the intersection with optional parameters
+     **/
+    template <typename local_type = unbound, typename mask_type = unmasked>
+    intersection intersect(const transform3 &trf, const point3 &ro,
+                           const vector3 &rd,
+                           const local_type &local = local_type(),
+                           const mask_type &mask = mask_type(),
+                           const typename mask_type::mask_tolerance &tolerance =
+                               mask_type::within_epsilon,
+                           scalar overstep_tolerance = 0.) const {
 
-            // Retrieve the surface normal & translation (context resolved)
-            const auto &sm = trf.matrix();
-            auto sn = getter::vector<3>(sm, 0, 2);
-            auto st = getter::vector<3>(sm, 0, 3);
+        // Retrieve the surface normal & translation (context resolved)
+        const auto &sm = trf.matrix();
+        auto sn = getter::vector<3>(sm, 0, 2);
+        auto st = getter::vector<3>(sm, 0, 3);
 
-            // Intersection code
-            scalar denom = vector::dot(rd, sn);
-            if (denom != 0.0)
-            {
-                intersection is;
-                is.path = vector::dot(sn, (st - ro)) / (denom);
-                is.p3 = ro + is.path * rd;
-                is.p2 = local(trf, is.p3);
-                is.status = mask.template is_inside<local_type>(is.p2, tolerance);
-                is.direction = is.path > overstep_tolerance ? e_along : e_opposite;
-                return is;
-            }
-            return intersection{};
+        // Intersection code
+        scalar denom = vector::dot(rd, sn);
+        if (denom != 0.0) {
+            intersection is;
+            is.path = vector::dot(sn, (st - ro)) / (denom);
+            is.p3 = ro + is.path * rd;
+            is.p2 = local(trf, is.p3);
+            is.status = mask.template is_inside<local_type>(is.p2, tolerance);
+            is.direction = is.path > overstep_tolerance ? e_along : e_opposite;
+            return is;
         }
-    };
+        return intersection{};
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/tools/propagator.hpp b/core/include/tools/propagator.hpp
index 1e8b29da74..b1c9f16bc1 100644
--- a/core/include/tools/propagator.hpp
+++ b/core/include/tools/propagator.hpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
@@ -9,73 +9,70 @@
 
 #include <iostream>
 
-namespace detray
-{
+namespace detray {
 
-    /** A sterily track inspector instance */
-    struct void_track_inspector {
+/** A sterily track inspector instance */
+struct void_track_inspector {
 
-        /** Void operator */
-        template <typename track_t>
-        void
-        operator()(const track_t& /*ignored*/) {
-            return;
-        }
-    };
+    /** Void operator */
+    template <typename track_t>
+    void operator()(const track_t & /*ignored*/) {
+        return;
+    }
+};
 
-    /** Tempalted propagator class, using a 
-     * 
-     * @tparam stepper_t for the transport
-     * @tparam navigator_t for the navigation
-     *
-     **/
-    template <typename stepper_t, typename navigator_t>
-    struct propagator {
+/** Tempalted propagator class, using a
+ *
+ * @tparam stepper_t for the transport
+ * @tparam navigator_t for the navigation
+ *
+ **/
+template <typename stepper_t, typename navigator_t>
+struct propagator {
+
+    stepper_t _stepper;
+    navigator_t _navigator;
 
-        stepper_t _stepper;
-        navigator_t _navigator;
+    /** Can not be default constructed */
+    propagator() = delete;
+    /** Only valid constructor with a
+     * @param s stepper
+     * @param n navigator
+     * by move semantics
+     **/
+    propagator(stepper_t &&s, navigator_t &&n)
+        : _stepper(std::move(s)), _navigator(std::move(n)) {}
 
-        /** Can not be default constructed */
-        propagator() = delete;
-        /** Only valid constructor with a 
-         * @param s stepper
-         * @param n navigator
-         * by move semantics
-         **/
-        propagator(stepper_t&& s, navigator_t&& n) :
-            _stepper(std::move(s)), _navigator(std::move(n)) {}
-        
-        /** Propagate method 
-         * 
-         * @tparam track_t is the type of the track
-         * 
-         * @param t_in the track at input 
-         * 
-         * @return a track at output
-         */
-        template <typename track_t, typename track_inspector_t>
-        track_t propagate(const track_t& t_in, track_inspector_t& t_inspector) const {
+    /** Propagate method
+     *
+     * @tparam track_t is the type of the track
+     *
+     * @param t_in the track at input
+     *
+     * @return a track at output
+     */
+    template <typename track_t, typename track_inspector_t>
+    track_t propagate(const track_t &t_in,
+                      track_inspector_t &t_inspector) const {
 
-            track_t t_out(t_in);
-            typename stepper_t::state s_state(t_out);
-            typename navigator_t::state n_state;
+        track_t t_out(t_in);
+        typename stepper_t::state s_state(t_out);
+        typename navigator_t::state n_state;
 
-            bool heartbeat = _navigator.status(n_state, s_state());
+        bool heartbeat = _navigator.status(n_state, s_state());
+        t_inspector(t_out);
+        // Run while there is a heartbeat
+        while (heartbeat) {
+            // (Re-)target
+            heartbeat &= _navigator.target(n_state, s_state());
+            // Take the step
+            heartbeat &= _stepper.step(s_state, n_state());
             t_inspector(t_out);
-            // Run while there is a heartbeat
-            while (heartbeat) {
-                // (Re-)target 
-                heartbeat &= _navigator.target(n_state, s_state());
-                // Take the step 
-                heartbeat &= _stepper.step(s_state, n_state());
-                t_inspector(t_out);
-                // And check the status
-                heartbeat &= _navigator.status(n_state, s_state());
-            }
-            return t_out;
-        };
-
+            // And check the status
+            heartbeat &= _navigator.status(n_state, s_state());
+        }
+        return t_out;
     };
+};
 
-}
-
+}  // namespace detray
diff --git a/core/include/utils/c_step.hpp b/core/include/utils/c_step.hpp
index 7f82176750..263c11bad6 100644
--- a/core/include/utils/c_step.hpp
+++ b/core/include/utils/c_step.hpp
@@ -1,8 +1,8 @@
 
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
@@ -10,23 +10,30 @@
 
 #include <limits>
 
-namespace detray
-{
-
-    /** Constrained step struct, it is used to regulate the stepping
-     * 
-     */
-    template <size_t kDIM, template <typename, unsigned int> class array_type = darray>
-    struct c_step {
-
-        /** Possible step constraints */
-        enum type : int { e_accuracy = 0, e_navigation = 1, e_user = 2, e_limit = 3 };
-
-        array_type<scalar, kDIM> _values = { std::numeric_limits<scalar>::max(), 0., std::numeric_limits<scalar>::max(), std::numeric_limits<scalar>::max() };
-
-        const scalar operator()() const { return std::min_element(_values.begin(), _values.end()); }
+namespace detray {
 
+/** Constrained step struct, it is used to regulate the stepping
+ *
+ */
+template <size_t kDIM,
+          template <typename, unsigned int> class array_type = darray>
+struct c_step {
+
+    /** Possible step constraints */
+    enum type : int {
+        e_accuracy = 0,
+        e_navigation = 1,
+        e_user = 2,
+        e_limit = 3
     };
 
-}
+    array_type<scalar, kDIM> _values = {std::numeric_limits<scalar>::max(), 0.,
+                                        std::numeric_limits<scalar>::max(),
+                                        std::numeric_limits<scalar>::max()};
+
+    const scalar operator()() const {
+        return std::min_element(_values.begin(), _values.end());
+    }
+};
 
+}  // namespace detray
diff --git a/core/include/utils/containers.hpp b/core/include/utils/containers.hpp
index 6f96b2c710..a3fc1b2e9d 100644
--- a/core/include/utils/containers.hpp
+++ b/core/include/utils/containers.hpp
@@ -1,30 +1,28 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
 #include <array>
-#include <vector>
 #include <map>
 #include <tuple>
+#include <vector>
 
-namespace detray
-{
-    template <typename value_type, unsigned int kDIM>
-    using darray = std::array<value_type, kDIM>;
-
-    template <typename value_type>
-    using dvector = std::vector<value_type>;
+namespace detray {
+template <typename value_type, unsigned int kDIM>
+using darray = std::array<value_type, kDIM>;
 
-    template <typename key_type, typename value_type>
-    using dmap = std::map<key_type, value_type>;
+template <typename value_type>
+using dvector = std::vector<value_type>;
 
-    template< class... types>
-    using dtuple = std::tuple<types ...>;
+template <typename key_type, typename value_type>
+using dmap = std::map<key_type, value_type>;
 
+template <class... types>
+using dtuple = std::tuple<types...>;
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/utils/enumerate.hpp b/core/include/utils/enumerate.hpp
index e3df076fe7..4e81ce6b23 100644
--- a/core/include/utils/enumerate.hpp
+++ b/core/include/utils/enumerate.hpp
@@ -1,165 +1,160 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
+#include <tuple>
+#include <type_traits>
+
 #include "utils/indexing.hpp"
 
-#include <type_traits>
-#include <tuple>
+namespace detray {
 
-namespace detray
-{
-
-    /** Helper utility to allow indexed enumeration with structured binding
-     * 
-     * Usage:
-     * 
-     * for (auto [ i, value ] = enumerate(container) ) { ... };
-     * 
-     * with 'container' any stl-like container
-     */
-    template <typename container_type,
-              typename container_type_iter = decltype(std::begin(std::declval<container_type>())),
-              typename = decltype(std::end(std::declval<container_type>()))>
-    constexpr auto enumerate(container_type &&iterable)
-    {
-        struct iterator
-        {
-            size_t i;
-            container_type_iter iter;
-
-            bool operator!=(const iterator &rhs) const { return iter != rhs.iter; }
-
-            /** Increase index and iterator at once */
-            void operator++()
-            {
-                ++i;
-                ++iter;
-            }
-
-            /** Tie them together for returning */
-            auto operator*() const { return std::tie(i, *iter); }
-        };
-        struct iterable_wrapper
-        {
-            container_type iterable;
-            auto begin() { return iterator{0, std::begin(iterable)}; }
-            auto end() { return iterator{0, std::end(iterable)}; }
-        };
-        return iterable_wrapper{std::forward<container_type>(iterable)};
-    }
-
-    /** Helper method to (fake a) run over a single entry
-     * 
-     * Usage:
-     * for (auto i : sequence(j)) {}
-     * 
-     * with j an unsinged dindex type
-     * 
-     * @note sequence(2) will produce {2}
-     * 
-     **/
-    constexpr auto sequence(dindex iterable)
-    {
-
-        struct iterator
-        {
-            size_t i;
-
-            bool operator!=(const iterator &rhs) const { return i != rhs.i; }
-
-            /** Increase index and iterator at once */
-            void operator++()
-            {
-                ++i;
-            }
-
-            /** Tie them together for returning */
-            auto operator*() const { return i; }
-        };
-        struct iterable_wrapper
-        {
-            dindex iterable;
-            auto begin() { return iterator{iterable}; }
-            auto end() { return iterator{iterable + 1}; }
-        };
-        return iterable_wrapper{std::forward<dindex>(iterable)};
-    }
-
-    /** Helper method to run over a range 
-     * 
-     * Usage:
-     * for (auto i : sequence(r)) {}
-     * 
-     * with r a range that can be accessed with r[0] and r[1]
-     * 
-     * @note sequence({2,4}) will produce { 2, 3, 4 }
-     * 
-     **/
-    template <typename array_type,
-              typename = std::enable_if_t<std::conditional_t<std::is_array_v<array_type>, std::extent<array_type>, std::tuple_size<array_type>>::value == 2U>>
-    constexpr auto sequence(array_type iterable)
-    {
-
-        struct iterator
-        {
-            size_t i;
-            size_t end;
-
-            bool operator!=(const iterator &rhs) const { return i != rhs.end; }
-
-            /** Increase index and iterator at once */
-            void operator++()
-            {
-                ++i;
-            }
-
-            /** Tie them together for returning */
-            auto operator*() const { return i; }
-        };
-        struct iterable_wrapper
-        {
-            array_type _iterable;
-            auto begin() { return iterator{_iterable[0], _iterable[1]}; }
-            auto end() { return iterator{_iterable[1] + 1, _iterable[1] + 1}; }
-        };
-        return iterable_wrapper{std::forward<array_type>(iterable)};
-    }
-
-    /** Helper method to run over a range 
-     * 
-     * Usage:
-     * for (auto value : range(container, r)) {}
-     * 
-     * with r a range that can be accessed with r[0] and r[1]
-     *
-     * @note Convenience type: no range checks!
-     **/
-    template <typename container_type,
-              typename container_type_iter = decltype(std::begin(std::declval<container_type>())),
-              typename = decltype(std::end(std::declval<container_type>())),
-              typename array_type,
-              typename = std::enable_if_t<std::conditional_t<std::is_array_v<array_type>, std::extent<array_type>, std::tuple_size<array_type>>::value == 2U>>
-    constexpr auto range_iter(const container_type &iterable, const array_type &&range)
-    {
-        struct iterable_wrapper
-        {
-            iterable_wrapper() = delete;
-            iterable_wrapper(const container_type &i, const array_type &&r) : _iterable(i), _range(r) {}
-
-            const container_type &_iterable = {};
-            const array_type _range = {dindex_invalid, dindex_invalid};
-
-            inline decltype(auto) begin() const {return std::begin(_iterable) + _range[0]; }
-
-            inline decltype(auto) end() const { return std::begin(_iterable) + _range[1]; }
-        };
-
-        return iterable_wrapper(iterable, std::move(range));
-    }
-
-} // namespace detray
+/** Helper utility to allow indexed enumeration with structured binding
+ *
+ * Usage:
+ *
+ * for (auto [ i, value ] = enumerate(container) ) { ... };
+ *
+ * with 'container' any stl-like container
+ */
+template <typename container_type,
+          typename container_type_iter =
+              decltype(std::begin(std::declval<container_type>())),
+          typename = decltype(std::end(std::declval<container_type>()))>
+constexpr auto enumerate(container_type &&iterable) {
+    struct iterator {
+        size_t i;
+        container_type_iter iter;
+
+        bool operator!=(const iterator &rhs) const { return iter != rhs.iter; }
+
+        /** Increase index and iterator at once */
+        void operator++() {
+            ++i;
+            ++iter;
+        }
+
+        /** Tie them together for returning */
+        auto operator*() const { return std::tie(i, *iter); }
+    };
+    struct iterable_wrapper {
+        container_type iterable;
+        auto begin() { return iterator{0, std::begin(iterable)}; }
+        auto end() { return iterator{0, std::end(iterable)}; }
+    };
+    return iterable_wrapper{std::forward<container_type>(iterable)};
+}
+
+/** Helper method to (fake a) run over a single entry
+ *
+ * Usage:
+ * for (auto i : sequence(j)) {}
+ *
+ * with j an unsinged dindex type
+ *
+ * @note sequence(2) will produce {2}
+ *
+ **/
+constexpr auto sequence(dindex iterable) {
+
+    struct iterator {
+        size_t i;
+
+        bool operator!=(const iterator &rhs) const { return i != rhs.i; }
+
+        /** Increase index and iterator at once */
+        void operator++() { ++i; }
+
+        /** Tie them together for returning */
+        auto operator*() const { return i; }
+    };
+    struct iterable_wrapper {
+        dindex iterable;
+        auto begin() { return iterator{iterable}; }
+        auto end() { return iterator{iterable + 1}; }
+    };
+    return iterable_wrapper{std::forward<dindex>(iterable)};
+}
+
+/** Helper method to run over a range
+ *
+ * Usage:
+ * for (auto i : sequence(r)) {}
+ *
+ * with r a range that can be accessed with r[0] and r[1]
+ *
+ * @note sequence({2,4}) will produce { 2, 3, 4 }
+ *
+ **/
+template <
+    typename array_type,
+    typename = std::enable_if_t<
+        std::conditional_t<std::is_array_v<array_type>, std::extent<array_type>,
+                           std::tuple_size<array_type>>::value == 2U>>
+constexpr auto sequence(array_type iterable) {
+
+    struct iterator {
+        size_t i;
+        size_t end;
+
+        bool operator!=(const iterator &rhs) const { return i != rhs.end; }
+
+        /** Increase index and iterator at once */
+        void operator++() { ++i; }
+
+        /** Tie them together for returning */
+        auto operator*() const { return i; }
+    };
+    struct iterable_wrapper {
+        array_type _iterable;
+        auto begin() { return iterator{_iterable[0], _iterable[1]}; }
+        auto end() { return iterator{_iterable[1] + 1, _iterable[1] + 1}; }
+    };
+    return iterable_wrapper{std::forward<array_type>(iterable)};
+}
+
+/** Helper method to run over a range
+ *
+ * Usage:
+ * for (auto value : range(container, r)) {}
+ *
+ * with r a range that can be accessed with r[0] and r[1]
+ *
+ * @note Convenience type: no range checks!
+ **/
+template <
+    typename container_type,
+    typename container_type_iter =
+        decltype(std::begin(std::declval<container_type>())),
+    typename = decltype(std::end(std::declval<container_type>())),
+    typename array_type,
+    typename = std::enable_if_t<
+        std::conditional_t<std::is_array_v<array_type>, std::extent<array_type>,
+                           std::tuple_size<array_type>>::value == 2U>>
+constexpr auto range_iter(const container_type &iterable,
+                          const array_type &&range) {
+    struct iterable_wrapper {
+        iterable_wrapper() = delete;
+        iterable_wrapper(const container_type &i, const array_type &&r)
+            : _iterable(i), _range(r) {}
+
+        const container_type &_iterable = {};
+        const array_type _range = {dindex_invalid, dindex_invalid};
+
+        inline decltype(auto) begin() const {
+            return std::begin(_iterable) + _range[0];
+        }
+
+        inline decltype(auto) end() const {
+            return std::begin(_iterable) + _range[1];
+        }
+    };
+
+    return iterable_wrapper(iterable, std::move(range));
+}
+
+}  // namespace detray
diff --git a/core/include/utils/generators.hpp b/core/include/utils/generators.hpp
index 257aa1611f..386a26b11e 100644
--- a/core/include/utils/generators.hpp
+++ b/core/include/utils/generators.hpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
@@ -9,334 +9,322 @@
 
 #include "masks/masks.hpp"
 
-namespace detray
-{
+namespace detray {
 
-    using transform3 = __plugin::transform3;
-    using point2 = __plugin::point2;
+using transform3 = __plugin::transform3;
+using point2 = __plugin::point2;
 
-    /** Generate phi values
-     *
-     * @param start_phi is the start for the arc generation
-     * @param end_phi is the end of the arc generation
-     * @param lseg is the number of segments used to gnerate the arc
-     * 
-     * @return a vector of phi values for the arc
-     */
-    static inline dvector<scalar>
-    phi_values(scalar start_phi, scalar end_phi, unsigned int lseg)
-    {
-        dvector<scalar> values;
-        values.reserve(lseg + 1);
-        scalar step_phi = (end_phi - start_phi) / lseg;
-        for (unsigned int istep = 0; istep <= lseg; ++istep)
-        {
-            values.push_back(start_phi + istep * step_phi);
-        }
-        return values;
+/** Generate phi values
+ *
+ * @param start_phi is the start for the arc generation
+ * @param end_phi is the end of the arc generation
+ * @param lseg is the number of segments used to gnerate the arc
+ *
+ * @return a vector of phi values for the arc
+ */
+static inline dvector<scalar> phi_values(scalar start_phi, scalar end_phi,
+                                         unsigned int lseg) {
+    dvector<scalar> values;
+    values.reserve(lseg + 1);
+    scalar step_phi = (end_phi - start_phi) / lseg;
+    for (unsigned int istep = 0; istep <= lseg; ++istep) {
+        values.push_back(start_phi + istep * step_phi);
     }
-    /** Generate vertices, specialized for masks: annulus2
-     *
-     * @note template types are simply forwarded to mask
-     * 
-     * @param sf is the surface that generates vertices
-     * @param ls is the number of line segments if
-     *
-     * @return a generated list of vertices
-     */
-    template <typename intersector_type,
-              typename local_type,
-              typename links_type,
-              unsigned int kMaskContext>
-    dvector<point3> vertices(const annulus2<intersector_type, local_type, links_type, kMaskContext> &annulus_mask, unsigned int lseg)
-    {
-
-        const auto &m_values = annulus_mask.values();
+    return values;
+}
+/** Generate vertices, specialized for masks: annulus2
+ *
+ * @note template types are simply forwarded to mask
+ *
+ * @param sf is the surface that generates vertices
+ * @param ls is the number of line segments if
+ *
+ * @return a generated list of vertices
+ */
+template <typename intersector_type, typename local_type, typename links_type,
+          unsigned int kMaskContext>
+dvector<point3> vertices(const annulus2<intersector_type, local_type,
+                                        links_type, kMaskContext> &annulus_mask,
+                         unsigned int lseg) {
 
-        scalar min_r = m_values[0];
-        scalar max_r = m_values[1];
-        scalar min_phi_rel = m_values[2];
-        scalar max_phi_rel = m_values[3];
-        scalar avg_phi = m_values[4];
-        scalar origin_x = m_values[5];
-        scalar origin_y = m_values[6];
+    const auto &m_values = annulus_mask.values();
 
-        point2 origin_m = {origin_x, origin_y};
+    scalar min_r = m_values[0];
+    scalar max_r = m_values[1];
+    scalar min_phi_rel = m_values[2];
+    scalar max_phi_rel = m_values[3];
+    scalar avg_phi = m_values[4];
+    scalar origin_x = m_values[5];
+    scalar origin_y = m_values[6];
 
-        /// Helper method: find inner outer radius at edges in STRIP PC
-        auto circIx = [](scalar O_x, scalar O_y, scalar r, scalar phi) -> point2
-        {
-            //                      _____________________________________________
-            //                     /      2  2                    2    2  2    2
-            //     O_x + O_y*m - \/  - O_x *m  + 2*O_x*O_y*m - O_y  + m *r  + r
-            // x = --------------------------------------------------------------
-            //                                  2
-            //                                 m  + 1
-            //
-            // y = m*x
-            //
-            scalar m = std::tan(phi);
-            point2 dir = {std::cos(phi), std::sin(phi)};
-            scalar x1 = (O_x + O_y * m -
-                         std::sqrt(-std::pow(O_x, 2) * std::pow(m, 2) +
-                                   2 * O_x * O_y * m - std::pow(O_y, 2) +
-                                   std::pow(m, 2) * std::pow(r, 2) + std::pow(r, 2))) /
-                        (std::pow(m, 2) + 1);
-            scalar x2 = (O_x + O_y * m +
-                         std::sqrt(-std::pow(O_x, 2) * std::pow(m, 2) +
-                                   2 * O_x * O_y * m - std::pow(O_y, 2) +
-                                   std::pow(m, 2) * std::pow(r, 2) + std::pow(r, 2))) /
-                        (std::pow(m, 2) + 1);
+    point2 origin_m = {origin_x, origin_y};
 
-            point2 v1 = {x1, m * x1};
-            if (vector::dot(v1, dir) > 0)
-                return v1;
-            return {x2, m * x2};
-        };
+    /// Helper method: find inner outer radius at edges in STRIP PC
+    auto circIx = [](scalar O_x, scalar O_y, scalar r, scalar phi) -> point2 {
+        //                      _____________________________________________
+        //                     /      2  2                    2    2  2    2
+        //     O_x + O_y*m - \/  - O_x *m  + 2*O_x*O_y*m - O_y  + m *r  + r
+        // x = --------------------------------------------------------------
+        //                                  2
+        //                                 m  + 1
+        //
+        // y = m*x
+        //
+        scalar m = std::tan(phi);
+        point2 dir = {std::cos(phi), std::sin(phi)};
+        scalar x1 =
+            (O_x + O_y * m -
+             std::sqrt(-std::pow(O_x, 2) * std::pow(m, 2) + 2 * O_x * O_y * m -
+                       std::pow(O_y, 2) + std::pow(m, 2) * std::pow(r, 2) +
+                       std::pow(r, 2))) /
+            (std::pow(m, 2) + 1);
+        scalar x2 =
+            (O_x + O_y * m +
+             std::sqrt(-std::pow(O_x, 2) * std::pow(m, 2) + 2 * O_x * O_y * m -
+                       std::pow(O_y, 2) + std::pow(m, 2) * std::pow(r, 2) +
+                       std::pow(r, 2))) /
+            (std::pow(m, 2) + 1);
 
-        // calculate corners in STRIP XY, keep them we need them for minDistance()
-        point2 ul_xy = circIx(origin_x, origin_y, max_r, max_phi_rel);
-        point2 ll_xy = circIx(origin_x, origin_y, min_r, max_phi_rel);
-        point2 ur_xy = circIx(origin_x, origin_y, max_r, min_phi_rel);
-        point2 lr_xy = circIx(origin_x, origin_y, min_r, min_phi_rel);
+        point2 v1 = {x1, m * x1};
+        if (vector::dot(v1, dir) > 0)
+            return v1;
+        return {x2, m * x2};
+    };
 
-        auto inner_phi = phi_values(getter::phi(ll_xy - origin_m), getter::phi(lr_xy - origin_m), lseg);
-        auto outer_phi = phi_values(getter::phi(ur_xy - origin_m), getter::phi(ul_xy - origin_m), lseg);
+    // calculate corners in STRIP XY, keep them we need them for minDistance()
+    point2 ul_xy = circIx(origin_x, origin_y, max_r, max_phi_rel);
+    point2 ll_xy = circIx(origin_x, origin_y, min_r, max_phi_rel);
+    point2 ur_xy = circIx(origin_x, origin_y, max_r, min_phi_rel);
+    point2 lr_xy = circIx(origin_x, origin_y, min_r, min_phi_rel);
 
-        dvector<point3> annulus_vertices;
-        annulus_vertices.reserve(inner_phi.size() + outer_phi.size());
-        for (auto iphi : inner_phi)
-        {
-            annulus_vertices.push_back(point3{min_r * std::cos(iphi) + origin_x, min_r * std::sin(iphi) + origin_y, 0.});
-        }
+    auto inner_phi = phi_values(getter::phi(ll_xy - origin_m),
+                                getter::phi(lr_xy - origin_m), lseg);
+    auto outer_phi = phi_values(getter::phi(ur_xy - origin_m),
+                                getter::phi(ul_xy - origin_m), lseg);
 
-        for (auto ophi : outer_phi)
-        {
-            annulus_vertices.push_back(point3{max_r * std::cos(ophi) + origin_x, max_r * std::sin(ophi) + origin_y, 0.});
-        }
+    dvector<point3> annulus_vertices;
+    annulus_vertices.reserve(inner_phi.size() + outer_phi.size());
+    for (auto iphi : inner_phi) {
+        annulus_vertices.push_back(point3{min_r * std::cos(iphi) + origin_x,
+                                          min_r * std::sin(iphi) + origin_y,
+                                          0.});
+    }
 
-        return annulus_vertices;
+    for (auto ophi : outer_phi) {
+        annulus_vertices.push_back(point3{max_r * std::cos(ophi) + origin_x,
+                                          max_r * std::sin(ophi) + origin_y,
+                                          0.});
     }
 
-    /** Generate vertices, spacialized for masks: cylinder3
-     *
-     * @note template types are simply forwarded to mask
-     * 
-     * @param sf is the surface that generates vertices
-     * @param ls is the number of line segments if
-     *
-     * @return a generated list of vertices
-     */
-    template <bool kRadialCheck,
-              typename intersector_type,
-              typename local_type,
-              typename links_type,
-              unsigned int kMaskContext>
-    dvector<point3> vertices(const cylinder3<kRadialCheck, intersector_type, local_type, links_type, kMaskContext> &annulus_mask, unsigned int lseg)
-    {
+    return annulus_vertices;
+}
 
-        return {};
-    }
+/** Generate vertices, spacialized for masks: cylinder3
+ *
+ * @note template types are simply forwarded to mask
+ *
+ * @param sf is the surface that generates vertices
+ * @param ls is the number of line segments if
+ *
+ * @return a generated list of vertices
+ */
+template <bool kRadialCheck, typename intersector_type, typename local_type,
+          typename links_type, unsigned int kMaskContext>
+dvector<point3> vertices(
+    const cylinder3<kRadialCheck, intersector_type, local_type, links_type,
+                    kMaskContext> &annulus_mask,
+    unsigned int lseg) {
 
-    /** Generate vertices, specialized for masks: rectangle2
-     *
-     * @note template types are simply forwarded to mask
-     *
-     * @param sf is the surface that generates vertices
-     * @param ls is the number of line segments (ignored for rectangles)
-     *
-     * @return a generated list of vertices
-     */
-    template <typename intersector_type,
-              typename local_type,
-              typename links_type,
-              unsigned int kMaskContext>
-    dvector<point3> vertices(const rectangle2<intersector_type, local_type, links_type, kMaskContext> &rectangle_mask, unsigned int /*ignored*/)
-    {
-        const auto &m_values = rectangle_mask.values();
-        // left hand lower corner
-        point3 lh_lc = {-m_values[0], -m_values[1], 0.};
-        // right hand lower corner
-        point3 rh_lc = {m_values[0], -m_values[1], 0.};
-        // right hand upper corner
-        point3 rh_uc = {m_values[0], m_values[1], 0.};
-        // left hand upper corner
-        point3 lh_uc = {-m_values[0], m_values[1], 0.};
-        return {lh_lc, rh_lc, rh_uc, lh_uc};
-        // Return the confining vertices
-    }
+    return {};
+}
 
-    /** Generate vertices, specialized for masks: ring2
-     *
-     * @note template types are simply forwarded to mask
-     *
-     * @param sf is the surface that generates vertices
-     * @param ls is the number of line segments if
-     *
-     * @return a generated list of vertices
-     */
-    template <typename intersector_type,
-              typename local_type,
-              typename links_type,
-              unsigned int kMaskContext>
-    dvector<point3> vertices(const ring2<intersector_type, local_type, links_type, kMaskContext> &ring_mask, unsigned int lseg)
-    {
-        return {};
-    }
+/** Generate vertices, specialized for masks: rectangle2
+ *
+ * @note template types are simply forwarded to mask
+ *
+ * @param sf is the surface that generates vertices
+ * @param ls is the number of line segments (ignored for rectangles)
+ *
+ * @return a generated list of vertices
+ */
+template <typename intersector_type, typename local_type, typename links_type,
+          unsigned int kMaskContext>
+dvector<point3> vertices(
+    const rectangle2<intersector_type, local_type, links_type, kMaskContext>
+        &rectangle_mask,
+    unsigned int /*ignored*/) {
+    const auto &m_values = rectangle_mask.values();
+    // left hand lower corner
+    point3 lh_lc = {-m_values[0], -m_values[1], 0.};
+    // right hand lower corner
+    point3 rh_lc = {m_values[0], -m_values[1], 0.};
+    // right hand upper corner
+    point3 rh_uc = {m_values[0], m_values[1], 0.};
+    // left hand upper corner
+    point3 lh_uc = {-m_values[0], m_values[1], 0.};
+    return {lh_lc, rh_lc, rh_uc, lh_uc};
+    // Return the confining vertices
+}
 
-    /** Generate vertices, specialized for masks: trapezoid2
-     *
-     * @note template types are simply forwarded to mask
-     *
-     * @param sf is the surface that generates vertices
-     * @param ls is the number of line segments if, ignored
-     * 
-     * @return a generated list of vertices
-     */
-    template <typename intersector_type,
-              typename local_type,
-              typename links_type,
-              unsigned int kMaskContext>
-    dvector<point3> vertices(const trapezoid2<intersector_type, local_type, links_type, kMaskContext> &trapezoid_mask, unsigned int /* ignored */)
-    {
+/** Generate vertices, specialized for masks: ring2
+ *
+ * @note template types are simply forwarded to mask
+ *
+ * @param sf is the surface that generates vertices
+ * @param ls is the number of line segments if
+ *
+ * @return a generated list of vertices
+ */
+template <typename intersector_type, typename local_type, typename links_type,
+          unsigned int kMaskContext>
+dvector<point3> vertices(const ring2<intersector_type, local_type, links_type,
+                                     kMaskContext> &ring_mask,
+                         unsigned int lseg) {
+    return {};
+}
 
-        const auto &m_values = trapezoid_mask.values();
-        // left hand lower corner
-        point3 lh_lc = {-m_values[0], -m_values[2], 0.};
-        // right hand lower corner
-        point3 rh_lc = {m_values[0], -m_values[2], 0.};
-        // right hand upper corner
-        point3 rh_uc = {m_values[1], m_values[2], 0.};
-        // left hand upper corner
-        point3 lh_uc = {-m_values[1], m_values[2], 0.};
-        // Return the confining vertices
-        return {lh_lc, rh_lc, rh_uc, lh_uc};
-    }
+/** Generate vertices, specialized for masks: trapezoid2
+ *
+ * @note template types are simply forwarded to mask
+ *
+ * @param sf is the surface that generates vertices
+ * @param ls is the number of line segments if, ignored
+ *
+ * @return a generated list of vertices
+ */
+template <typename intersector_type, typename local_type, typename links_type,
+          unsigned int kMaskContext>
+dvector<point3> vertices(
+    const trapezoid2<intersector_type, local_type, links_type, kMaskContext>
+        &trapezoid_mask,
+    unsigned int /* ignored */) {
 
-    /** Specialized method to generate vertices per maks group
-    * 
-    * @tparam mask_group is the type of the split out mask group from all masks
-    * @tparam mask_range is the type of the according mask range object
-    * 
-    * @param masks is the associated (and split out) mask group
-    * @param range is the range list of masks to be processed
-    * 
-    * @return a jagged vector of points of the mask vertices (one per maks)
-     **/
-    template <typename mask_group,
-              typename mask_range>
-    auto vertices_for_mask_group(const mask_group &masks,
-                                 const mask_range &range,
-                                 dindex n_segments = 1)
-    {
-        dvector<dvector<point3>> mask_vertices = {};
-        for (auto i : sequence(range))
-        {
-            const auto &mask = masks[i];
-            mask_vertices.push_back(vertices(mask, n_segments));
-        }
-        return mask_vertices;
+    const auto &m_values = trapezoid_mask.values();
+    // left hand lower corner
+    point3 lh_lc = {-m_values[0], -m_values[2], 0.};
+    // right hand lower corner
+    point3 rh_lc = {m_values[0], -m_values[2], 0.};
+    // right hand upper corner
+    point3 rh_uc = {m_values[1], m_values[2], 0.};
+    // left hand upper corner
+    point3 lh_uc = {-m_values[1], m_values[2], 0.};
+    // Return the confining vertices
+    return {lh_lc, rh_lc, rh_uc, lh_uc};
+}
+
+/** Specialized method to generate vertices per maks group
+ *
+ * @tparam mask_group is the type of the split out mask group from all masks
+ * @tparam mask_range is the type of the according mask range object
+ *
+ * @param masks is the associated (and split out) mask group
+ * @param range is the range list of masks to be processed
+ *
+ * @return a jagged vector of points of the mask vertices (one per maks)
+ **/
+template <typename mask_group, typename mask_range>
+auto vertices_for_mask_group(const mask_group &masks, const mask_range &range,
+                             dindex n_segments = 1) {
+    dvector<dvector<point3>> mask_vertices = {};
+    for (auto i : sequence(range)) {
+        const auto &mask = masks[i];
+        mask_vertices.push_back(vertices(mask, n_segments));
     }
+    return mask_vertices;
+}
 
-    /** Variadic unrolled intersection - last entry 
-     * 
-     * @tparam mask_container is the type of the type of the mask container
-     * @tparam mask_range is the mask range type 
-     * @tparam last_mask_context is the last mask group context 
-     * 
-     * @param masks the masks container 
-     * @param range the range within the mask group to be checked
-     * @param mask_context the last mask group context 
-     *
-     * @return a jagged vector of points of the mask vertices (one per maks)
-     **/
-    template <typename mask_container,
-              typename mask_range,
-              dindex last_mask_context>
-    auto vertices_for_last_mask_group(
-        const mask_container &masks,
-        const mask_range &range,
-        dindex mask_context)
-    {
-        dvector<dvector<point3>> mask_vertices = {};
-        if (mask_context == last_mask_context)
-        {
-            mask_vertices = vertices_for_mask_group(std::get<last_mask_context>(masks), range);
-        }
-        return mask_vertices;
+/** Variadic unrolled intersection - last entry
+ *
+ * @tparam mask_container is the type of the type of the mask container
+ * @tparam mask_range is the mask range type
+ * @tparam last_mask_context is the last mask group context
+ *
+ * @param masks the masks container
+ * @param range the range within the mask group to be checked
+ * @param mask_context the last mask group context
+ *
+ * @return a jagged vector of points of the mask vertices (one per maks)
+ **/
+template <typename mask_container, typename mask_range,
+          dindex last_mask_context>
+auto vertices_for_last_mask_group(const mask_container &masks,
+                                  const mask_range &range,
+                                  dindex mask_context) {
+    dvector<dvector<point3>> mask_vertices = {};
+    if (mask_context == last_mask_context) {
+        mask_vertices =
+            vertices_for_mask_group(std::get<last_mask_context>(masks), range);
     }
+    return mask_vertices;
+}
 
-    /** Variadic unrolled intersection - any integer sequence
-     * 
-     * @tparam mask_container is the type of the type of the mask container
-     * @tparam mask_range is the mask range type 
-     * @tparam first_mask_context is the first mask group context 
-     * 
-     * @param masks the masks container 
-     * @param range the range within the mask group to be checked
-     * @param mask_context the last mask group context 
-     * @param available_contices the mask contices to be checked
-     *
-     * @return a jagged vector of points of the mask vertices (one per maks)
-    **/
-    template <typename mask_container,
-              typename mask_range,
-              dindex first_mask_context,
-              dindex... remaining_mask_context>
-    auto unroll_masks_for_vertices(
-        const mask_container &masks,
-        const mask_range &range,
-        dindex mask_context,
-        std::integer_sequence<dindex, first_mask_context, remaining_mask_context...> available_contices)
-    {
-        // Pick the first one for interseciton
-        if (mask_context == first_mask_context)
-        {
-            return vertices_for_mask_group(std::get<first_mask_context>(masks), range);
-        }
-        // The reduced integer sequence
-        std::integer_sequence<dindex, remaining_mask_context...> remaining;
-        // Unroll as long as you have at least 2 entries
-        if constexpr (remaining.size() > 1)
-        {
-            auto mask_vertices = unroll_masks_for_vertices(masks, range, mask_context, remaining);
-            if (not mask_vertices.empty())
-            {
-                return mask_vertices;
-            }
+/** Variadic unrolled intersection - any integer sequence
+ *
+ * @tparam mask_container is the type of the type of the mask container
+ * @tparam mask_range is the mask range type
+ * @tparam first_mask_context is the first mask group context
+ *
+ * @param masks the masks container
+ * @param range the range within the mask group to be checked
+ * @param mask_context the last mask group context
+ * @param available_contices the mask contices to be checked
+ *
+ * @return a jagged vector of points of the mask vertices (one per maks)
+ **/
+template <typename mask_container, typename mask_range,
+          dindex first_mask_context, dindex... remaining_mask_context>
+auto unroll_masks_for_vertices(
+    const mask_container &masks, const mask_range &range, dindex mask_context,
+    std::integer_sequence<dindex, first_mask_context, remaining_mask_context...>
+        available_contices) {
+    // Pick the first one for interseciton
+    if (mask_context == first_mask_context) {
+        return vertices_for_mask_group(std::get<first_mask_context>(masks),
+                                       range);
+    }
+    // The reduced integer sequence
+    std::integer_sequence<dindex, remaining_mask_context...> remaining;
+    // Unroll as long as you have at least 2 entries
+    if constexpr (remaining.size() > 1) {
+        auto mask_vertices =
+            unroll_masks_for_vertices(masks, range, mask_context, remaining);
+        if (not mask_vertices.empty()) {
+            return mask_vertices;
         }
-        // Last chance - intersect the last index if possible
-        return vertices_for_last_mask_group<mask_container, mask_range, std::tuple_size_v<mask_container> - 1>(masks, range, mask_context);
     }
+    // Last chance - intersect the last index if possible
+    return vertices_for_last_mask_group<mask_container, mask_range,
+                                        std::tuple_size_v<mask_container> - 1>(
+        masks, range, mask_context);
+}
 
-    /** Create a r-phi polygon from principle parameters
- * 
+/** Create a r-phi polygon from principle parameters
+ *
  * @param rmin minum r parameter
  * @param rmax maximum r parameter
  * @param phimin minimum phi parameter
  * @param phimax maximum phi parameters
- * 
+ *
  * @return a polygon representation of the bin
  **/
-    std::vector<point2>
-    r_phi_polygon(scalar rmin, scalar rmax, scalar phimin, scalar phimax, unsigned int nsegments = 1)
-    {
+std::vector<point2> r_phi_polygon(scalar rmin, scalar rmax, scalar phimin,
+                                  scalar phimax, unsigned int nsegments = 1) {
 
-        std::vector<point2> r_phi_poly;
-        r_phi_poly.reserve(2 * nsegments + 2);
+    std::vector<point2> r_phi_poly;
+    r_phi_poly.reserve(2 * nsegments + 2);
 
-        scalar cos_min_phi = std::cos(phimin);
-        scalar sin_min_phi = std::sin(phimin);
-        scalar cos_max_phi = std::cos(phimax);
-        scalar sin_max_phi = std::sin(phimax);
+    scalar cos_min_phi = std::cos(phimin);
+    scalar sin_min_phi = std::sin(phimin);
+    scalar cos_max_phi = std::cos(phimax);
+    scalar sin_max_phi = std::sin(phimax);
 
-        // @TODO add phi generators
-        r_phi_poly.push_back({rmin * cos_min_phi, rmin * sin_min_phi});
-        r_phi_poly.push_back({rmin * cos_max_phi, rmin * sin_max_phi});
-        r_phi_poly.push_back({rmax * cos_max_phi, rmax * sin_max_phi});
-        r_phi_poly.push_back({rmax * cos_min_phi, rmax * sin_min_phi});
+    // @TODO add phi generators
+    r_phi_poly.push_back({rmin * cos_min_phi, rmin * sin_min_phi});
+    r_phi_poly.push_back({rmin * cos_max_phi, rmin * sin_max_phi});
+    r_phi_poly.push_back({rmax * cos_max_phi, rmax * sin_max_phi});
+    r_phi_poly.push_back({rmax * cos_min_phi, rmax * sin_min_phi});
 
-        return r_phi_poly;
-    };
+    return r_phi_poly;
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/utils/indexing.hpp b/core/include/utils/indexing.hpp
index 2d32ab2e63..8e1f76bb35 100644
--- a/core/include/utils/indexing.hpp
+++ b/core/include/utils/indexing.hpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
@@ -9,11 +9,10 @@
 
 #include <limits>
 
-namespace detray
-{    
-    using dindex = unsigned long;
-    auto dindex_invalid = std::numeric_limits<dindex>::max();
-    using dindex_range = darray<dindex, 2>;
-    using dindex_sequence = dvector<dindex>;
+namespace detray {
+using dindex = unsigned long;
+auto dindex_invalid = std::numeric_limits<dindex>::max();
+using dindex_range = darray<dindex, 2>;
+using dindex_sequence = dvector<dindex>;
 
-} // namespace detray
\ No newline at end of file
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/utils/quadratic_equation.hpp b/core/include/utils/quadratic_equation.hpp
index f171f54eb1..70b6163c91 100644
--- a/core/include/utils/quadratic_equation.hpp
+++ b/core/include/utils/quadratic_equation.hpp
@@ -1,49 +1,47 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 #pragma once
 
+#include <algorithm>
 #include <cmath>
 #include <tuple>
-#include <algorithm>
 
-namespace detray
-{
+namespace detray {
 
-    /** Struct to solve a quadratic equation of type p[0] * x^2 + p[1] * x + p[2] = 0 
-     */
-    template <typename scalar_type,
-              template <typename, unsigned int> class array_type = darray,
-              template <typename ...> class tuple_type = dtuple>
-    struct quadratic_equation
-    {
-        array_type<scalar_type, 3> _params = {0., 0., 0.};
+/** Struct to solve a quadratic equation of type p[0] * x^2 + p[1] * x + p[2] =
+ * 0
+ */
+template <typename scalar_type,
+          template <typename, unsigned int> class array_type = darray,
+          template <typename...> class tuple_type = dtuple>
+struct quadratic_equation {
+    array_type<scalar_type, 3> _params = {0., 0., 0.};
 
-        /** Solve the quadratic equation 
-         **/
-        tuple_type<int, array_type<scalar_type, 2>>
-        operator()() const
-        {
-            scalar_type discriminant = _params[1] * _params[1] - 4 * _params[0] * _params[2];
-            if (discriminant < 0.)
-            {
-                return {0, {std::numeric_limits<scalar_type>::infinity(), std::numeric_limits<scalar_type>::infinity()}};
-            }
-            else
-            {
-                int solutions = (discriminant == 0.) ? 1 : 2;
-                double q = -0.5 * (_params[1] + (_params[1] > 0 ? std::sqrt(discriminant)
-                                                                : -std::sqrt(discriminant)));
-                scalar_type first = q / _params[0];
-                scalar_type second = _params[2] / q;
-                array_type<scalar_type, 2> poles = {first, second};
-                std::sort(poles.begin(), poles.end());
-                return {solutions, poles};
-            }
+    /** Solve the quadratic equation
+     **/
+    tuple_type<int, array_type<scalar_type, 2>> operator()() const {
+        scalar_type discriminant =
+            _params[1] * _params[1] - 4 * _params[0] * _params[2];
+        if (discriminant < 0.) {
+            return {0,
+                    {std::numeric_limits<scalar_type>::infinity(),
+                     std::numeric_limits<scalar_type>::infinity()}};
+        } else {
+            int solutions = (discriminant == 0.) ? 1 : 2;
+            double q = -0.5 * (_params[1] + (_params[1] > 0
+                                                 ? std::sqrt(discriminant)
+                                                 : -std::sqrt(discriminant)));
+            scalar_type first = q / _params[0];
+            scalar_type second = _params[2] / q;
+            array_type<scalar_type, 2> poles = {first, second};
+            std::sort(poles.begin(), poles.end());
+            return {solutions, poles};
         }
-    };
+    }
+};
 
-} // namespace detray
+}  // namespace detray
diff --git a/core/include/utils/unbound.hpp b/core/include/utils/unbound.hpp
index c7d4052813..ed1acfce5b 100644
--- a/core/include/utils/unbound.hpp
+++ b/core/include/utils/unbound.hpp
@@ -1,39 +1,37 @@
 
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-namespace detray
-{
+namespace detray {
 
-    /** A representation that is not bound to a local frame */
-    struct unbound
-    {
-        using transform3 = __plugin::transform3;
-        using point3 = __plugin::point3;
-        using point2 = __plugin::point2;
+/** A representation that is not bound to a local frame */
+struct unbound {
+    using transform3 = __plugin::transform3;
+    using point3 = __plugin::point3;
+    using point2 = __plugin::point2;
 
-        /** This method transform from a point from the global 3D cartesian frame to the local 2D cartesian frame,
-         * including the contextual transform into the local 3D frame
-         **/
-        const point2 operator()(const transform3 & /*ignored*/,
-                                               const point3 & /*ignored*/) const
-        {
-            return {std::numeric_limits<scalar>::infinity(),
-                    std::numeric_limits<scalar>::infinity()};
-        }
+    /** This method transform from a point from the global 3D cartesian frame to
+     *the local 2D cartesian frame, including the contextual transform into the
+     *local 3D frame
+     **/
+    const point2 operator()(const transform3& /*ignored*/,
+                            const point3& /*ignored*/) const {
+        return {std::numeric_limits<scalar>::infinity(),
+                std::numeric_limits<scalar>::infinity()};
+    }
 
-        /** This method transform from a point from the global 3D cartesian frame to the local 2D cartesian frame
-             */
-        const point2 operator()(const point3 & /*ignored*/) const
-        {
-            return {std::numeric_limits<scalar>::infinity(),
-                    std::numeric_limits<scalar>::infinity()};
-        }
-    };
-} // namespace detray
\ No newline at end of file
+    /** This method transform from a point from the global 3D cartesian frame to
+     * the local 2D cartesian frame
+     */
+    const point2 operator()(const point3& /*ignored*/) const {
+        return {std::numeric_limits<scalar>::infinity(),
+                std::numeric_limits<scalar>::infinity()};
+    }
+};
+}  // namespace detray
\ No newline at end of file
diff --git a/core/include/utils/utils_enumerate.cpp b/core/include/utils/utils_enumerate.cpp
index 95e55e1562..9bfa65d989 100644
--- a/core/include/utils/utils_enumerate.cpp
+++ b/core/include/utils/utils_enumerate.cpp
@@ -1,39 +1,35 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "utils/enumerate.hpp"
-#include "tests/common/test_defs.hpp"
-
 #include <gtest/gtest.h>
 
+#include "tests/common/test_defs.hpp"
+#include "utils/enumerate.hpp"
 
 using namespace detray;
 
 // This tests the convenience enumeration function
-TEST(utils, enumerate_function)
-{
+TEST(utils, enumerate_function) {
 
     struct uint_holder {
         unsigned int ui = 0;
     };
 
-    dvector<uint_holder> seq = { {0}, {1}, {2}, {3}, {4}, {5}};
+    dvector<uint_holder> seq = {{0}, {1}, {2}, {3}, {4}, {5}};
 
-    using container_type_iter = decltype(std::begin(std::declval<dvector<uint_holder>>()));
+    using container_type_iter =
+        decltype(std::begin(std::declval<dvector<uint_holder>>()));
 
-    for (auto [i, v] : enumerate(seq)){
+    for (auto [i, v] : enumerate(seq)) {
         ASSERT_EQ(i, v.ui);
     }
-
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/display/include/style/styles.hpp b/display/include/style/styles.hpp
index 2db9263f4a..52be4a5239 100644
--- a/display/include/style/styles.hpp
+++ b/display/include/style/styles.hpp
@@ -1,25 +1,23 @@
 
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-namespace detray
-{
+namespace detray {
 
-    using color = darray<float, 4>;
+using color = darray<float, 4>;
 
-    /** Style class for drawing with matplot++ */
-    struct style
-    {
-        color fill_color = {0., 1., 0., 0.};
-        scalar line_width = 0.;
-        std::string line_style = "-";
-        unsigned int segments = 72;
-    };
+/** Style class for drawing with matplot++ */
+struct style {
+    color fill_color = {0., 1., 0., 0.};
+    scalar line_width = 0.;
+    std::string line_style = "-";
+    unsigned int segments = 72;
+};
 
-}
\ No newline at end of file
+}  // namespace detray
\ No newline at end of file
diff --git a/display/include/view/draw.hpp b/display/include/view/draw.hpp
index 72ab824bfa..c90a0e4916 100644
--- a/display/include/view/draw.hpp
+++ b/display/include/view/draw.hpp
@@ -1,254 +1,240 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
-#include "view/views.hpp"
-#include "utils/generators.hpp"
+#include <matplot/matplot.h>
+
 #include "style/styles.hpp"
 #include "utils/enumerate.hpp"
+#include "utils/generators.hpp"
+#include "view/views.hpp"
 
-#include <matplot/matplot.h>
+namespace detray {
 
-namespace detray
-{
-
-    /** Static draw function for arcs 
-     * 
-     * @param x0 the x value of the first point
-     * @param y0 the y value of the first point
-     * @param x1 the x value of the second point
-     * @param y1 the y value of the second point
-     * @param st is the style class for the grid
-     * 
-     */
-    static inline void draw_line(scalar x0, scalar y0, scalar x1, scalar y1, const style &st)
-    {
-        auto line = matplot::line(x0, y0, x1, y1);
+/** Static draw function for arcs
+ *
+ * @param x0 the x value of the first point
+ * @param y0 the y value of the first point
+ * @param x1 the x value of the second point
+ * @param y1 the y value of the second point
+ * @param st is the style class for the grid
+ *
+ */
+static inline void draw_line(scalar x0, scalar y0, scalar x1, scalar y1,
+                             const style &st) {
+    auto line = matplot::line(x0, y0, x1, y1);
+    line->color(st.fill_color);
+    line->line_width(st.line_width);
+    line->line_style(st.line_style.c_str());
+}
+
+/** Static draw function for arcs
+ *
+ * @param c_x the x value of the center
+ * @param c_y the y value of the center
+ * @param R the Radius of the arc
+ * @param phi_min the min phi value
+ * @param phi_max the max phi valu
+ * @param st is the style class for the grid
+ *
+ */
+static inline void draw_arc(scalar c_x, scalar c_y, scalar R, scalar phi_min,
+                            scalar phi_max, const style &st) {
+    matplot::hold(matplot::on);
+    std::vector<scalar> theta = matplot::linspace(phi_min, phi_max);
+    std::vector<scalar> x = matplot::transform(
+        theta, [=](auto theta) { return R * std::cos(theta) + c_x; });
+    std::vector<scalar> y = matplot::transform(
+        theta, [=](auto theta) { return R * std::sin(theta) + c_y; });
+    auto arc = matplot::plot(x, y);
+    arc->color(st.fill_color);
+    arc->line_width(st.line_width);
+    arc->line_style(st.line_style.c_str());
+}
+
+/** Static draw function for a polygon
+ *
+ * @param polygon the polygon points
+ * @param st is the style class for the grid
+ *
+ */
+static inline void draw_polygon(const std::vector<point2> &polygon,
+                                const style &st) {
+    for (size_t j = 1; j <= polygon.size(); ++j) {
+        size_t i = j - 1;
+        size_t jc = (j == polygon.size()) ? 0 : j;
+        auto line = matplot::line(polygon[i][0], polygon[i][1], polygon[jc][0],
+                                  polygon[jc][1]);
         line->color(st.fill_color);
         line->line_width(st.line_width);
         line->line_style(st.line_style.c_str());
     }
-
-    /** Static draw function for arcs 
-     * 
-     * @param c_x the x value of the center
-     * @param c_y the y value of the center
-     * @param R the Radius of the arc
-     * @param phi_min the min phi value
-     * @param phi_max the max phi valu 
-     * @param st is the style class for the grid
-     * 
-     */
-    static inline void draw_arc(scalar c_x, scalar c_y, scalar R, scalar phi_min, scalar phi_max, const style &st)
-    {
-        matplot::hold(matplot::on);
-        std::vector<scalar> theta = matplot::linspace(phi_min, phi_max);
-        std::vector<scalar> x =
-            matplot::transform(theta, [=](auto theta)
-                               { return R * std::cos(theta) + c_x; });
-        std::vector<scalar> y =
-            matplot::transform(theta, [=](auto theta)
-                               { return R * std::sin(theta) + c_y; });
-        auto arc = matplot::plot(x, y);
-        arc->color(st.fill_color);
-        arc->line_width(st.line_width);
-        arc->line_style(st.line_style.c_str());
-    }
-
-    /** Static draw function for a polygon
-     * 
-     * @param polygon the polygon points
-     * @param st is the style class for the grid
-     * 
-     */
-    static inline void draw_polygon(const std::vector<point2> &polygon, const style &st)
-    {
-        for (size_t j = 1; j <= polygon.size(); ++j)
-        {
-            size_t i = j - 1;
-            size_t jc = (j == polygon.size()) ? 0 : j;
-            auto line = matplot::line(polygon[i][0], polygon[i][1], polygon[jc][0], polygon[jc][1]);
-            line->color(st.fill_color);
-            line->line_width(st.line_width);
-            line->line_style(st.line_style.c_str());
+}
+
+/** Static draw function for vertices
+ *
+ * @param vertices the vertices generated from the mask
+ * @param tf is the transform where the surface is placed
+ * @param st is the style class for the grid
+ * @param view is the view type for the display
+ * @param phi_wrappping check for phi_wrappping in a z-phi view
+ *                      (limited to 4 vertices)
+ *
+ */
+template <typename vertex_container_type, typename view_t = single_view>
+static inline void draw_vertices(const vertex_container_type &vertices,
+                                 const transform3 &tf, const style &st,
+                                 const view_t &view = view_t(),
+                                 bool phi_wrapping = false) {
+
+    // Create a view of the vertices
+    auto [x, y] = view(vertices, tf);
+
+    if (phi_wrapping and vertices.size() == 4) {
+
+        // @note this assumes ordering of the x,y as given by the mask
+        if (std::abs(y[0] - y[1]) > M_PI) {
+
+            std::vector<scalar> x_up = {x[0], 0.5 * (x[0] + x[1]),
+                                        0.5 * (x[1] + x[2]),
+                                        0.5 * (x[2] + x[3]), x[3]};
+            std::vector<scalar> y_up = {y[0], M_PI, 2 * M_PI - y[0], M_PI,
+                                        y[3]};
+            auto filled_area_up = matplot::fill(x_up, y_up, "w");
+            filled_area_up->color(st.fill_color);
+            filled_area_up->line_width(st.line_width);
+
+            std::vector<scalar> x_down = {x[1], 0.5 * (x[0] + x[1]),
+                                          0.5 * (x[1] + x[2]),
+                                          0.5 * (x[2] + x[3]), x[2]};
+            std::vector<scalar> y_down = {y[1], -2 * M_PI - y[1], -M_PI,
+                                          -2 * M_PI - y[2], y[2]};
+            auto filled_area_down = matplot::fill(x_down, y_down, "w");
+            filled_area_down->color(st.fill_color);
+            filled_area_down->line_width(st.line_width);
+            return;
         }
     }
 
-    /** Static draw function for vertices 
-     * 
-     * @param vertices the vertices generated from the mask
-     * @param tf is the transform where the surface is placed
-     * @param st is the style class for the grid
-     * @param view is the view type for the display
-     * @param phi_wrappping check for phi_wrappping in a z-phi view 
-     *                      (limited to 4 vertices)
-     * 
-     */
-    template <typename vertex_container_type, typename view_t = single_view>
-    static inline void draw_vertices(const vertex_container_type &vertices,
-                                     const transform3 &tf,
-                                     const style &st,
-                                     const view_t &view = view_t(),
-                                     bool phi_wrapping = false)
-    {
-
-        // Create a view of the vertices
-        auto [x, y] = view(vertices, tf);
-
-        if (phi_wrapping and vertices.size() == 4){
-
-            // @note this assumes ordering of the x,y as given by the mask
-            if (std::abs(y[0] - y[1]) > M_PI  ){
-                
-                std::vector<scalar> x_up = { x[0], 0.5 * (x[0] + x[1]), 0.5 * (x[1] + x[2]), 0.5 * (x[2] + x[3]), x[3] }; 
-                std::vector<scalar> y_up = { y[0], M_PI, 2 * M_PI - y[0], M_PI, y[3] };
-                auto filled_area_up = matplot::fill(x_up, y_up, "w");
-                filled_area_up->color(st.fill_color);
-                filled_area_up->line_width(st.line_width);
-
-                std::vector<scalar> x_down = { x[1], 0.5 * (x[0] + x[1]), 0.5 * (x[1] + x[2]), 0.5 * (x[2] + x[3]), x[2] }; 
-                std::vector<scalar> y_down = { y[1], -2 * M_PI - y[1], -M_PI, -2 * M_PI - y[2], y[2] };
-                auto filled_area_down = matplot::fill(x_down, y_down, "w");
-                filled_area_down->color(st.fill_color);
-                filled_area_down->line_width(st.line_width);
-                return;
-            }
-
-        } 
-
-        auto filled_area = matplot::fill(x, y, "w");
-
-        filled_area->color(st.fill_color);
-        filled_area->line_width(st.line_width);
-    }
-
-    /** Static draw function for masks 
-     *   
-     * @param mask is the mask of the surface to be drawn
-     * @param tf is the transform where the surface is placed
-     * @param st is the style class for the grid
-     * @param view is the view type for the display
-     */
-    template <typename mask_type, typename view_t = single_view>
-    static inline void draw_mask(const mask_type &mask,
-                                 const transform3 &tf,
-                                 const style &st,
-                                 const view_t &view = view_t())
-    {
-        auto contour = vertices(mask, st.segments);
-        // Create a view of the vertices
-        auto [x, y] = view(contour, tf);
-        auto filled_area = matplot::fill(x, y, "w");
-
-        filled_area->color(st.fill_color);
-        filled_area->line_width(st.line_width);
-    }
+    auto filled_area = matplot::fill(x, y, "w");
 
-    /** Static draw function for masks 
-     *   
-     * @param grid is the grid of the surface to be drawn
-     * @param st is the style class for the grid
-     * @param view is the view type for the display
-     */
-    template <typename grid_type>
-    static inline void draw_r_phi_grid(const grid_type &grid,
-                                       const style &st)
-    {
-        const auto &r_axis = grid.axis_p0();
-        auto r_borders = r_axis.all_borders();
-        for (auto r : r_borders)
-        {
-            auto r_line = matplot::rectangle(-r, -r, 2 * r, 2 * r, 1.);
-            r_line->color(st.fill_color);
-            r_line->line_width(st.line_width);
-        }
+    filled_area->color(st.fill_color);
+    filled_area->line_width(st.line_width);
+}
 
-        const auto &phi_axis = grid.axis_p1();
-        auto phi_borders = phi_axis.all_borders();
-        for (auto [i, phi] : enumerate(phi_borders))
-        {
-            scalar cos_phi = std::cos(phi);
-            scalar sin_phi = std::sin(phi);
-            scalar x0 = r_borders[0] * cos_phi;
-            scalar y0 = r_borders[0] * sin_phi;
-            scalar x1 = r_borders[r_borders.size() - 1] * cos_phi;
-            scalar y1 = r_borders[r_borders.size() - 1] * sin_phi;
-            if (i < static_cast<size_t>(phi_borders.size() - 1))
-            {
-                auto phi_line = matplot::line(x0, y0, x1, y1);
-                phi_line->color(st.fill_color);
-                phi_line->line_width(st.line_width);
-            }
-        }
+/** Static draw function for masks
+ *
+ * @param mask is the mask of the surface to be drawn
+ * @param tf is the transform where the surface is placed
+ * @param st is the style class for the grid
+ * @param view is the view type for the display
+ */
+template <typename mask_type, typename view_t = single_view>
+static inline void draw_mask(const mask_type &mask, const transform3 &tf,
+                             const style &st, const view_t &view = view_t()) {
+    auto contour = vertices(mask, st.segments);
+    // Create a view of the vertices
+    auto [x, y] = view(contour, tf);
+    auto filled_area = matplot::fill(x, y, "w");
+
+    filled_area->color(st.fill_color);
+    filled_area->line_width(st.line_width);
+}
+
+/** Static draw function for masks
+ *
+ * @param grid is the grid of the surface to be drawn
+ * @param st is the style class for the grid
+ * @param view is the view type for the display
+ */
+template <typename grid_type>
+static inline void draw_r_phi_grid(const grid_type &grid, const style &st) {
+    const auto &r_axis = grid.axis_p0();
+    auto r_borders = r_axis.all_borders();
+    for (auto r : r_borders) {
+        auto r_line = matplot::rectangle(-r, -r, 2 * r, 2 * r, 1.);
+        r_line->color(st.fill_color);
+        r_line->line_width(st.line_width);
     }
 
-    /** Static draw function for masks 
-     *   
-     * @param grid is the grid of the surface to be drawn
-     * @param st is the style class for the grid
-     * @param view is the view type for the display
-     */
-    template <typename grid_type>
-    static inline void draw_z_phi_grid(const grid_type &grid,
-                                       const style &st)
-    {
-        const auto &z_axis = grid.axis_p0();
-        auto z_borders = z_axis.all_borders();
-        for (auto z : z_borders)
-        {
-
-            scalar z0 = z;
-            scalar phi0 = -M_PI;
-            scalar z1 = z;
-            scalar phi1 = M_PI;
-            auto z_line = matplot::line(z0, phi0, z1, phi1);
-            z_line->color(st.fill_color);
-            z_line->line_width(st.line_width);
-        }
-
-        const auto &phi_axis = grid.axis_p1();
-        auto phi_borders = phi_axis.all_borders();
-        for (auto [i, phi] : enumerate(phi_borders))
-        {
-            scalar z0 = z_borders[0];
-            scalar z1 = z_borders[z_borders.size() - 1];
-            auto phi_line = matplot::line(z0, phi, z1, phi);
+    const auto &phi_axis = grid.axis_p1();
+    auto phi_borders = phi_axis.all_borders();
+    for (auto [i, phi] : enumerate(phi_borders)) {
+        scalar cos_phi = std::cos(phi);
+        scalar sin_phi = std::sin(phi);
+        scalar x0 = r_borders[0] * cos_phi;
+        scalar y0 = r_borders[0] * sin_phi;
+        scalar x1 = r_borders[r_borders.size() - 1] * cos_phi;
+        scalar y1 = r_borders[r_borders.size() - 1] * sin_phi;
+        if (i < static_cast<size_t>(phi_borders.size() - 1)) {
+            auto phi_line = matplot::line(x0, y0, x1, y1);
             phi_line->color(st.fill_color);
             phi_line->line_width(st.line_width);
         }
     }
+}
 
-    /** Set up a new display with dimensions and potentially wuite
-     *
-     * @param onscreen The boolean to make it quite or not
-     * @param dimensions The dimensions of the supbplot
-     * 
-     * @return an axis object
-     */
-    auto display(bool onscreen = true, std::array<float, 4> dimensions = {0.1, 0.1, 0.8, 0.8})
-    {
-        auto ax = matplot::subplot(dimensions);
-        ax->parent()->quiet_mode(not onscreen);
-        return ax;
+/** Static draw function for masks
+ *
+ * @param grid is the grid of the surface to be drawn
+ * @param st is the style class for the grid
+ * @param view is the view type for the display
+ */
+template <typename grid_type>
+static inline void draw_z_phi_grid(const grid_type &grid, const style &st) {
+    const auto &z_axis = grid.axis_p0();
+    auto z_borders = z_axis.all_borders();
+    for (auto z : z_borders) {
+
+        scalar z0 = z;
+        scalar phi0 = -M_PI;
+        scalar z1 = z;
+        scalar phi1 = M_PI;
+        auto z_line = matplot::line(z0, phi0, z1, phi1);
+        z_line->color(st.fill_color);
+        z_line->line_width(st.line_width);
     }
 
-    /** Save the current picture
-     *
-     * @param filename the name of the file (obviously)
-     * @param clearpad an indication if to clear the pad
-     */
-    void save(const std::string &filename, bool clearpad = true)
-    {
-        matplot::save(filename);
-        if (clearpad)
-        {
-            matplot::cla();
-        }
+    const auto &phi_axis = grid.axis_p1();
+    auto phi_borders = phi_axis.all_borders();
+    for (auto [i, phi] : enumerate(phi_borders)) {
+        scalar z0 = z_borders[0];
+        scalar z1 = z_borders[z_borders.size() - 1];
+        auto phi_line = matplot::line(z0, phi, z1, phi);
+        phi_line->color(st.fill_color);
+        phi_line->line_width(st.line_width);
+    }
+}
+
+/** Set up a new display with dimensions and potentially wuite
+ *
+ * @param onscreen The boolean to make it quite or not
+ * @param dimensions The dimensions of the supbplot
+ *
+ * @return an axis object
+ */
+auto display(bool onscreen = true,
+             std::array<float, 4> dimensions = {0.1, 0.1, 0.8, 0.8}) {
+    auto ax = matplot::subplot(dimensions);
+    ax->parent()->quiet_mode(not onscreen);
+    return ax;
+}
+
+/** Save the current picture
+ *
+ * @param filename the name of the file (obviously)
+ * @param clearpad an indication if to clear the pad
+ */
+void save(const std::string &filename, bool clearpad = true) {
+    matplot::save(filename);
+    if (clearpad) {
+        matplot::cla();
     }
+}
 
-} // namespace detray
\ No newline at end of file
+}  // namespace detray
\ No newline at end of file
diff --git a/display/include/view/views.hpp b/display/include/view/views.hpp
index 398206c2f1..0ee8ec33b1 100644
--- a/display/include/view/views.hpp
+++ b/display/include/view/views.hpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
@@ -9,155 +9,139 @@
 
 #include <cmath>
 
-namespace detray
-{
-    using point3 = __plugin::point3;
-    using transform3 = __plugin::transform3;
-
-    using contour = darray<dvector<scalar>, 2>;
-
-    /// Single view per module/surface
-    struct single_view
-    {
-
-        /** A single view operator, no transform is done
-         *
-         * @param vertices the vertices of the surface
-         * @param tf the (ignored) surface transform
-         *
-         * @return a 2D contour array
-         */
-        contour
-        operator()(const dvector<point3> &vertices, const transform3 & /*tf*/) const
-        {
-
-            dvector<scalar> x;
-            x.reserve(vertices.size());
-            dvector<scalar> y;
-            y.reserve(vertices.size());
-
-            for (const auto &v : vertices)
-            {
-                x.push_back(v[0]);
-                y.push_back(v[1]);
-            }
-            return {x, y};
+namespace detray {
+using point3 = __plugin::point3;
+using transform3 = __plugin::transform3;
+
+using contour = darray<dvector<scalar>, 2>;
+
+/// Single view per module/surface
+struct single_view {
+
+    /** A single view operator, no transform is done
+     *
+     * @param vertices the vertices of the surface
+     * @param tf the (ignored) surface transform
+     *
+     * @return a 2D contour array
+     */
+    contour operator()(const dvector<point3> &vertices,
+                       const transform3 & /*tf*/) const {
+
+        dvector<scalar> x;
+        x.reserve(vertices.size());
+        dvector<scalar> y;
+        y.reserve(vertices.size());
+
+        for (const auto &v : vertices) {
+            x.push_back(v[0]);
+            y.push_back(v[1]);
         }
-    };
-
-    /// x-y projection view
-    struct global_xy_view
-    {
-        /** A global xy view operator, no transform is done
-         *
-         * @param vertices the vertices of the surface
-         * @param tf the surface transform 
-         *
-         * @return a 2D contour array
-         */
-        contour
-        operator()(const dvector<point3> &vertices, const transform3 &tf) const
-        {
-            dvector<scalar> x;
-            x.reserve(vertices.size());
-            dvector<scalar> y;
-            y.reserve(vertices.size());
-
-            for (const auto &v : vertices)
-            {
-                auto vg = tf.point_to_global(v);
-                x.push_back(vg[0]);
-                y.push_back(vg[1]);
-            }
-            return {x, y};
+        return {x, y};
+    }
+};
+
+/// x-y projection view
+struct global_xy_view {
+    /** A global xy view operator, no transform is done
+     *
+     * @param vertices the vertices of the surface
+     * @param tf the surface transform
+     *
+     * @return a 2D contour array
+     */
+    contour operator()(const dvector<point3> &vertices,
+                       const transform3 &tf) const {
+        dvector<scalar> x;
+        x.reserve(vertices.size());
+        dvector<scalar> y;
+        y.reserve(vertices.size());
+
+        for (const auto &v : vertices) {
+            auto vg = tf.point_to_global(v);
+            x.push_back(vg[0]);
+            y.push_back(vg[1]);
         }
-    };
-
-    /// r-z projection view
-    struct global_rz_view
-    {
-        /** A global rz view operator, no transform is done
-         *
-         * @param vertices the vertices of the surface
-         * @param tf the surface transform 
-         *
-         * @return a 2D contour array
-         */
-        contour
-        operator()(const dvector<point3> &vertices, const transform3 &tf) const
-        {
-            dvector<scalar> r;
-            r.reserve(vertices.size());
-            dvector<scalar> z;
-            z.reserve(vertices.size());
-
-            for (const auto &v : vertices)
-            {
-                auto vg = tf.point_to_global(v);
-                r.push_back(getter::perp(vg));
-                z.push_back(vg[2]);
-            }
-            return {z, r};
+        return {x, y};
+    }
+};
+
+/// r-z projection view
+struct global_rz_view {
+    /** A global rz view operator, no transform is done
+     *
+     * @param vertices the vertices of the surface
+     * @param tf the surface transform
+     *
+     * @return a 2D contour array
+     */
+    contour operator()(const dvector<point3> &vertices,
+                       const transform3 &tf) const {
+        dvector<scalar> r;
+        r.reserve(vertices.size());
+        dvector<scalar> z;
+        z.reserve(vertices.size());
+
+        for (const auto &v : vertices) {
+            auto vg = tf.point_to_global(v);
+            r.push_back(getter::perp(vg));
+            z.push_back(vg[2]);
         }
-    };
-
-    // z-phi projection view
-    struct global_z_phi_view
-    {
-
-        /// A view for a z-phi projection
-        ///
-        /// @param vertices the vertices of the surface
-        /// @param tf the surface transform
-        ///
-        /// @return a 2D contour array
-        contour
-        operator()(const dvector<point3> &vertices, const transform3 &tf) const
-        {
-            dvector<scalar> z;
-            z.reserve(vertices.size());
-            dvector<scalar> phi;
-            phi.reserve(vertices.size());
-
-            for (const auto &v : vertices)
-            {
-                auto vg = tf.point_to_global(v);
-                z.push_back(vg[2]);
-                phi.push_back(getter::phi(vg));
-            }
-            return {z, phi};
+        return {z, r};
+    }
+};
+
+// z-phi projection view
+struct global_z_phi_view {
+
+    /// A view for a z-phi projection
+    ///
+    /// @param vertices the vertices of the surface
+    /// @param tf the surface transform
+    ///
+    /// @return a 2D contour array
+    contour operator()(const dvector<point3> &vertices,
+                       const transform3 &tf) const {
+        dvector<scalar> z;
+        z.reserve(vertices.size());
+        dvector<scalar> phi;
+        phi.reserve(vertices.size());
+
+        for (const auto &v : vertices) {
+            auto vg = tf.point_to_global(v);
+            z.push_back(vg[2]);
+            phi.push_back(getter::phi(vg));
         }
-    };
-
-    // rphi-z projection view
-    struct rphi_z_view
-    {
-
-        scalar fixed_r = std::numeric_limits<scalar>::quiet_NaN();
-
-        /// A view for a rphi-z projection
-        ///
-        /// @param vertices the vertices of the surface
-        /// @param tf the surface transform
-        ///
-        /// @return a 2D contour array
-        contour
-        operator()(const dvector<point3> &vertices, const transform3 &tf) const
-        {
-            dvector<scalar> x;
-            x.reserve(vertices.size());
-            dvector<scalar> y;
-            y.reserve(vertices.size());
-
-            for (const auto &v : vertices)
-            {
-                auto vg = tf.point_to_global(v);
-                scalar r = std::isnan(fixed_r) ? getter::perp(vg) : fixed_r;
-                x.push_back(r * getter::phi(vg));
-                y.push_back(vg[2]);
-            }
-            return {x, y};
+        return {z, phi};
+    }
+};
+
+// rphi-z projection view
+struct rphi_z_view {
+
+    scalar fixed_r = std::numeric_limits<scalar>::quiet_NaN();
+
+    /// A view for a rphi-z projection
+    ///
+    /// @param vertices the vertices of the surface
+    /// @param tf the surface transform
+    ///
+    /// @return a 2D contour array
+    contour operator()(const dvector<point3> &vertices,
+                       const transform3 &tf) const {
+        dvector<scalar> x;
+        x.reserve(vertices.size());
+        dvector<scalar> y;
+        y.reserve(vertices.size());
+
+        for (const auto &v : vertices) {
+            auto vg = tf.point_to_global(v);
+            scalar r = std::isnan(fixed_r) ? getter::perp(vg) : fixed_r;
+            x.push_back(r * getter::phi(vg));
+            y.push_back(vg[2]);
         }
-    };
+        return {x, y};
+    }
+};
 
-}
\ No newline at end of file
+}  // namespace detray
\ No newline at end of file
diff --git a/plugins/algebra/include/detray/array/include/plugins/algebra/array_definitions.hpp b/plugins/algebra/include/detray/array/include/plugins/algebra/array_definitions.hpp
index fcbc751fd3..631477d6a2 100644
--- a/plugins/algebra/include/detray/array/include/plugins/algebra/array_definitions.hpp
+++ b/plugins/algebra/include/detray/array/include/plugins/algebra/array_definitions.hpp
@@ -5,25 +5,25 @@
 
 namespace detray {
 
-    using scalar = algebra::scalar;
+using scalar = algebra::scalar;
 
-    template <typename value_type, unsigned int kDIM>
-    using darray = std::array<value_type, kDIM>;
+template <typename value_type, unsigned int kDIM>
+using darray = std::array<value_type, kDIM>;
 
-    template <typename value_type>
-    using dvector = algebra::vector_s<value_type>;
-    
-    template <typename key_type, typename value_type>
-    using dmap = algebra::map_s<key_type, value_type>;
+template <typename value_type>
+using dvector = algebra::vector_s<value_type>;
 
-    template< class... types>
-    using dtuple = algebra::tuple_s<types ...>;
+template <typename key_type, typename value_type>
+using dmap = algebra::map_s<key_type, value_type>;
 
-    using algebra::operator*;
-    using algebra::operator+;
-    using algebra::operator-;
+template <class... types>
+using dtuple = algebra::tuple_s<types...>;
 
-    namespace getter = algebra::getter;
-    namespace vector = algebra::vector;
+using algebra::operator*;
+using algebra::operator+;
+using algebra::operator-;
 
-} //namespace detray
+namespace getter = algebra::getter;
+namespace vector = algebra::vector;
+
+}  // namespace detray
diff --git a/plugins/algebra/include/detray/eigen/include/plugins/algebra/eigen_definitions.hpp b/plugins/algebra/include/detray/eigen/include/plugins/algebra/eigen_definitions.hpp
index ebcd21c0f8..2509cc570f 100644
--- a/plugins/algebra/include/detray/eigen/include/plugins/algebra/eigen_definitions.hpp
+++ b/plugins/algebra/include/detray/eigen/include/plugins/algebra/eigen_definitions.hpp
@@ -5,21 +5,21 @@
 
 namespace detray {
 
-    using scalar = algebra::scalar;
+using scalar = algebra::scalar;
 
-    template <typename value_type, unsigned int kDIM>
-    using darray = std::array<value_type, kDIM>;
+template <typename value_type, unsigned int kDIM>
+using darray = std::array<value_type, kDIM>;
 
-    template <typename value_type>
-    using dvector = algebra::vector_s<value_type>;
-    
-    template <typename key_type, typename value_type>
-    using dmap = algebra::map_s<key_type, value_type>;
+template <typename value_type>
+using dvector = algebra::vector_s<value_type>;
 
-    template< class... types>
-    using dtuple = algebra::tuple_s<types ...>;
+template <typename key_type, typename value_type>
+using dmap = algebra::map_s<key_type, value_type>;
 
-    namespace getter = algebra::getter;
-    namespace vector = algebra::vector;
+template <class... types>
+using dtuple = algebra::tuple_s<types...>;
 
-} //namespace detray
+namespace getter = algebra::getter;
+namespace vector = algebra::vector;
+
+}  // namespace detray
diff --git a/plugins/algebra/include/detray/smatrix/include/plugins/algebra/smatrix_definitions.hpp b/plugins/algebra/include/detray/smatrix/include/plugins/algebra/smatrix_definitions.hpp
index 0d34658abe..3bf4d1a99f 100644
--- a/plugins/algebra/include/detray/smatrix/include/plugins/algebra/smatrix_definitions.hpp
+++ b/plugins/algebra/include/detray/smatrix/include/plugins/algebra/smatrix_definitions.hpp
@@ -5,21 +5,21 @@
 
 namespace detray {
 
-    using scalar = algebra::scalar;
+using scalar = algebra::scalar;
 
-    template <typename value_type, unsigned int kDIM>
-    using darray = algebra::array_s<value_type, kDIM>;
+template <typename value_type, unsigned int kDIM>
+using darray = algebra::array_s<value_type, kDIM>;
 
-    template <typename value_type>
-    using dvector = algebra::vector_s<value_type>;
+template <typename value_type>
+using dvector = algebra::vector_s<value_type>;
 
-    template <typename key_type, typename value_type>
-    using dmap = algebra::map_s<key_type, value_type>;
+template <typename key_type, typename value_type>
+using dmap = algebra::map_s<key_type, value_type>;
 
-    template< class... types>
-    using dtuple = algebra::tuple_s<types ...>;
+template <class... types>
+using dtuple = algebra::tuple_s<types...>;
 
-    namespace getter = algebra::getter;
-    namespace vector = algebra::vector;
+namespace getter = algebra::getter;
+namespace vector = algebra::vector;
 
-} //namespace detray
+}  // namespace detray
diff --git a/plugins/algebra/include/detray/vc/include/plugins/algebra/vc_array_definitions.hpp b/plugins/algebra/include/detray/vc/include/plugins/algebra/vc_array_definitions.hpp
index 34e586b88c..afdf111d75 100644
--- a/plugins/algebra/include/detray/vc/include/plugins/algebra/vc_array_definitions.hpp
+++ b/plugins/algebra/include/detray/vc/include/plugins/algebra/vc_array_definitions.hpp
@@ -4,26 +4,26 @@
 
 namespace detray {
 
-    using scalar = algebra::scalar;
+using scalar = algebra::scalar;
 
-    template <typename value_type, unsigned int kDIM>
-    using darray = algebra::array_s<value_type, kDIM>;
+template <typename value_type, unsigned int kDIM>
+using darray = algebra::array_s<value_type, kDIM>;
 
-    template <typename value_type>
-    using dvector = algebra::vector_v<value_type>;
+template <typename value_type>
+using dvector = algebra::vector_v<value_type>;
 
-    template <typename key_type, typename value_type>
-    using dmap = algebra::map_s<key_type, value_type>;
+template <typename key_type, typename value_type>
+using dmap = algebra::map_s<key_type, value_type>;
 
-    template< class... types>
-    using dtuple = algebra::tuple_s<types ...>;
+template <class... types>
+using dtuple = algebra::tuple_s<types...>;
 
-    using algebra::operator*;
-    using algebra::operator/;
-    using algebra::operator+;
-    using algebra::operator-;
+using algebra::operator*;
+using algebra::operator/;
+using algebra::operator+;
+using algebra::operator-;
 
-    namespace getter = algebra::getter;
-    namespace vector = algebra::vector;
+namespace getter = algebra::getter;
+namespace vector = algebra::vector;
 
-} //namespace detray
+}  // namespace detray
diff --git a/tests/benchmarks/array/array_find_volume.cpp b/tests/benchmarks/array/array_find_volume.cpp
index 71f3992bea..c5b23166aa 100644
--- a/tests/benchmarks/array/array_find_volume.cpp
+++ b/tests/benchmarks/array/array_find_volume.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/array/array_intersect_all.cpp b/tests/benchmarks/array/array_intersect_all.cpp
index dd6ddb5adf..77e24e1e0d 100644
--- a/tests/benchmarks/array/array_intersect_all.cpp
+++ b/tests/benchmarks/array/array_intersect_all.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/array/array_intersect_surfaces.cpp b/tests/benchmarks/array/array_intersect_surfaces.cpp
index 554afafd7f..c2f5e08b6e 100644
--- a/tests/benchmarks/array/array_intersect_surfaces.cpp
+++ b/tests/benchmarks/array/array_intersect_surfaces.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/array/array_masks.cpp b/tests/benchmarks/array/array_masks.cpp
index 9bdd8cb089..b7fe7ccf98 100644
--- a/tests/benchmarks/array/array_masks.cpp
+++ b/tests/benchmarks/array/array_masks.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/core/benchmark_grids.cpp b/tests/benchmarks/core/benchmark_grids.cpp
index 407f73bd34..2b1c8a485c 100644
--- a/tests/benchmarks/core/benchmark_grids.cpp
+++ b/tests/benchmarks/core/benchmark_grids.cpp
@@ -1,131 +1,122 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+// detray test
 #include "tests/common/test_defs.hpp"
+
+// detray core
+#include <benchmark/benchmark.h>
+
 #include "grids/axis.hpp"
 #include "grids/grid2.hpp"
-#include "grids/serializer2.hpp"
 #include "grids/populator.hpp"
+#include "grids/serializer2.hpp"
 #include "utils/indexing.hpp"
 
-#include <benchmark/benchmark.h>
-
 using namespace detray;
 using namespace __plugin;
 
-namespace
-{
+namespace {
 
-    darray<dindex, 2> zone22 = { 2u, 2u };
+darray<dindex, 2> zone22 = {2u, 2u};
 
-    // This runs a reference test with random numbers only
-    static void BM_RERERENCE_GRID(benchmark::State &state)
-    {
-        for (auto _ : state)
-        {
-            for (unsigned int itest = 0; itest < 1000000; ++itest)
-            {
-                test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5), static_cast<scalar>((rand() % 120) * 0.5)};
-            }
+// This runs a reference test with random numbers only
+static void BM_RERERENCE_GRID(benchmark::State &state) {
+    for (auto _ : state) {
+        for (unsigned int itest = 0; itest < 1000000; ++itest) {
+            test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5),
+                              static_cast<scalar>((rand() % 120) * 0.5)};
         }
     }
-
-    replace_populator<> replacer;
-    serializer2 serializer;
-
-    // TrackML detector has 25 x 60 cells int he detector grid
-    axis::regular<> xaxisr = axis::regular<>{25, 0., 25.};
-    axis::regular<> yaxisr = axis::regular<>{60, 0., 60.};
-    using grid2r = grid2<decltype(replacer), decltype(xaxisr), decltype(yaxisr), decltype(serializer)>;
-    grid2r g2r(std::move(xaxisr), std::move(yaxisr));
-
-    // This runs a reference test with a regular grid structure
-    static void BM_REGULAR_GRID_BIN(benchmark::State &state)
-    {
-        for (auto _ : state)
-        {
-            for (unsigned int itest = 0; itest < 1000000; ++itest)
-            {
-                test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5), static_cast<scalar>((rand() % 120) * 0.5)};
-                g2r.bin(p);
-            }
+}
+
+replace_populator<> replacer;
+serializer2 serializer;
+
+// TrackML detector has 25 x 60 cells int he detector grid
+axis::regular<> xaxisr = axis::regular<>{25, 0., 25.};
+axis::regular<> yaxisr = axis::regular<>{60, 0., 60.};
+using grid2r = grid2<decltype(replacer), decltype(xaxisr), decltype(yaxisr),
+                     decltype(serializer)>;
+grid2r g2r(std::move(xaxisr), std::move(yaxisr));
+
+// This runs a reference test with a regular grid structure
+static void BM_REGULAR_GRID_BIN(benchmark::State &state) {
+    for (auto _ : state) {
+        for (unsigned int itest = 0; itest < 1000000; ++itest) {
+            test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5),
+                              static_cast<scalar>((rand() % 120) * 0.5)};
+            g2r.bin(p);
         }
     }
-
-    static void BM_REGULAR_GRID_ZONE(benchmark::State &state)
-    {
-        for (auto _ : state)
-        {
-            for (unsigned int itest = 0; itest < 1000000; ++itest)
-            {
-                test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5), static_cast<scalar>((rand() % 120) * 0.5)};
-                g2r.zone(p, {zone22, zone22});
-            }
+}
+
+static void BM_REGULAR_GRID_ZONE(benchmark::State &state) {
+    for (auto _ : state) {
+        for (unsigned int itest = 0; itest < 1000000; ++itest) {
+            test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5),
+                              static_cast<scalar>((rand() % 120) * 0.5)};
+            g2r.zone(p, {zone22, zone22});
         }
     }
-
-    auto construct_irregular_grid()
-    {
-        // Fill a 25 x 60 grid with an "irregular" axis
-        dvector<scalar> xboundaries = {};
-        xboundaries.reserve(25);
-        dvector<scalar> yboundaries = {};
-        yboundaries.reserve(60);
-
-        for (unsigned int i = 0; i < 61; ++i)
-        {
-            if (i < 26)
-            {
-                xboundaries.push_back(i);
-            }
-            yboundaries.push_back(i);
+}
+
+auto construct_irregular_grid() {
+    // Fill a 25 x 60 grid with an "irregular" axis
+    dvector<scalar> xboundaries = {};
+    xboundaries.reserve(25);
+    dvector<scalar> yboundaries = {};
+    yboundaries.reserve(60);
+
+    for (unsigned int i = 0; i < 61; ++i) {
+        if (i < 26) {
+            xboundaries.push_back(i);
         }
+        yboundaries.push_back(i);
+    }
 
-        axis::irregular<> xaxisir{xboundaries};
-        axis::irregular<> yaxisir{yboundaries};
+    axis::irregular<> xaxisir{xboundaries};
+    axis::irregular<> yaxisir{yboundaries};
 
-        using grid2ir = grid2<decltype(replacer), decltype(xaxisir), decltype(yaxisir), decltype(serializer)>;
+    using grid2ir = grid2<decltype(replacer), decltype(xaxisir),
+                          decltype(yaxisir), decltype(serializer)>;
 
-        return grid2ir(std::move(xaxisir), std::move(yaxisir));
-    }
+    return grid2ir(std::move(xaxisir), std::move(yaxisir));
+}
+
+auto g2irr = construct_irregular_grid();
 
-    auto g2irr = construct_irregular_grid();
-
-    // This runs a reference test with a irregular grid structure
-    static void BM_IRREGULAR_GRID_BIN(benchmark::State &state)
-    {
-        for (auto _ : state)
-        {
-            for (unsigned int itest = 0; itest < 1000000; ++itest)
-            {
-                test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5), static_cast<scalar>((rand() % 120) * 0.5)};
-                g2irr.bin(p);
-            }
+// This runs a reference test with a irregular grid structure
+static void BM_IRREGULAR_GRID_BIN(benchmark::State &state) {
+    for (auto _ : state) {
+        for (unsigned int itest = 0; itest < 1000000; ++itest) {
+            test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5),
+                              static_cast<scalar>((rand() % 120) * 0.5)};
+            g2irr.bin(p);
         }
     }
-
-    static void BM_IRREGULAR_GRID_ZONE(benchmark::State &state)
-    {
-        for (auto _ : state)
-        {
-            for (unsigned int itest = 0; itest < 1000000; ++itest)
-            {
-                test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5), static_cast<scalar>((rand() % 120) * 0.5)};
-                g2irr.zone(p, {zone22, zone22});
-            }
+}
+
+static void BM_IRREGULAR_GRID_ZONE(benchmark::State &state) {
+    for (auto _ : state) {
+        for (unsigned int itest = 0; itest < 1000000; ++itest) {
+            test::point2 p = {static_cast<scalar>((rand() % 50) * 0.5),
+                              static_cast<scalar>((rand() % 120) * 0.5)};
+            g2irr.zone(p, {zone22, zone22});
         }
     }
+}
 
-    BENCHMARK(BM_RERERENCE_GRID);
-    BENCHMARK(BM_REGULAR_GRID_BIN);
-    BENCHMARK(BM_REGULAR_GRID_ZONE);
-    BENCHMARK(BM_IRREGULAR_GRID_BIN);
-    BENCHMARK(BM_IRREGULAR_GRID_ZONE);
+BENCHMARK(BM_RERERENCE_GRID);
+BENCHMARK(BM_REGULAR_GRID_BIN);
+BENCHMARK(BM_REGULAR_GRID_ZONE);
+BENCHMARK(BM_IRREGULAR_GRID_BIN);
+BENCHMARK(BM_IRREGULAR_GRID_ZONE);
 
-} // namespace
+}  // namespace
 
-BENCHMARK_MAIN();
\ No newline at end of file
+BENCHMARK_MAIN();
diff --git a/tests/benchmarks/eigen/eigen_find_volume.cpp b/tests/benchmarks/eigen/eigen_find_volume.cpp
index 79749a76e5..3ad0b8bb02 100644
--- a/tests/benchmarks/eigen/eigen_find_volume.cpp
+++ b/tests/benchmarks/eigen/eigen_find_volume.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/eigen/eigen_intersect_all.cpp b/tests/benchmarks/eigen/eigen_intersect_all.cpp
index 84789abc30..d35ef2fcb2 100644
--- a/tests/benchmarks/eigen/eigen_intersect_all.cpp
+++ b/tests/benchmarks/eigen/eigen_intersect_all.cpp
@@ -1,10 +1,9 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #include "plugins/algebra/eigen_definitions.hpp"
 #include "tests/common/benchmark_intersect_all.inl"
-
diff --git a/tests/benchmarks/eigen/eigen_intersect_surfaces.cpp b/tests/benchmarks/eigen/eigen_intersect_surfaces.cpp
index 1dd8164fb8..b8ccd4611f 100644
--- a/tests/benchmarks/eigen/eigen_intersect_surfaces.cpp
+++ b/tests/benchmarks/eigen/eigen_intersect_surfaces.cpp
@@ -1,10 +1,9 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #include "plugins/algebra/eigen_definitions.hpp"
 #include "tests/common/benchmark_intersect_surfaces.inl"
-
diff --git a/tests/benchmarks/eigen/eigen_masks.cpp b/tests/benchmarks/eigen/eigen_masks.cpp
index 16a2d43df9..fafd2cf7da 100644
--- a/tests/benchmarks/eigen/eigen_masks.cpp
+++ b/tests/benchmarks/eigen/eigen_masks.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/smatrix/smatrix_find_volume.cpp b/tests/benchmarks/smatrix/smatrix_find_volume.cpp
index 65ef0d032d..20bafb9475 100644
--- a/tests/benchmarks/smatrix/smatrix_find_volume.cpp
+++ b/tests/benchmarks/smatrix/smatrix_find_volume.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/smatrix/smatrix_intersect_all.cpp b/tests/benchmarks/smatrix/smatrix_intersect_all.cpp
index 2d9fee93d0..3e1fd7532a 100644
--- a/tests/benchmarks/smatrix/smatrix_intersect_all.cpp
+++ b/tests/benchmarks/smatrix/smatrix_intersect_all.cpp
@@ -1,10 +1,9 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #include "plugins/algebra/smatrix_definitions.hpp"
 #include "tests/common/benchmark_intersect_all.inl"
-
diff --git a/tests/benchmarks/smatrix/smatrix_intersect_surfaces.cpp b/tests/benchmarks/smatrix/smatrix_intersect_surfaces.cpp
index 913f85add6..96cfb0e5d7 100644
--- a/tests/benchmarks/smatrix/smatrix_intersect_surfaces.cpp
+++ b/tests/benchmarks/smatrix/smatrix_intersect_surfaces.cpp
@@ -1,10 +1,9 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #include "plugins/algebra/smatrix_definitions.hpp"
 #include "tests/common/benchmark_intersect_surfaces.inl"
-
diff --git a/tests/benchmarks/smatrix/smatrix_masks.cpp b/tests/benchmarks/smatrix/smatrix_masks.cpp
index e853644b07..278a0e9b4e 100644
--- a/tests/benchmarks/smatrix/smatrix_masks.cpp
+++ b/tests/benchmarks/smatrix/smatrix_masks.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/vc/vc_array_find_volume.cpp b/tests/benchmarks/vc/vc_array_find_volume.cpp
index 0ae7df2dbd..18ecc8be20 100644
--- a/tests/benchmarks/vc/vc_array_find_volume.cpp
+++ b/tests/benchmarks/vc/vc_array_find_volume.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/vc/vc_array_intersect_all.cpp b/tests/benchmarks/vc/vc_array_intersect_all.cpp
index bc680172b1..626759b023 100644
--- a/tests/benchmarks/vc/vc_array_intersect_all.cpp
+++ b/tests/benchmarks/vc/vc_array_intersect_all.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/vc/vc_array_intersect_surfaces.cpp b/tests/benchmarks/vc/vc_array_intersect_surfaces.cpp
index f8adbea2f2..0582ba277c 100644
--- a/tests/benchmarks/vc/vc_array_intersect_surfaces.cpp
+++ b/tests/benchmarks/vc/vc_array_intersect_surfaces.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/benchmarks/vc/vc_array_masks.cpp b/tests/benchmarks/vc/vc_array_masks.cpp
index 3e0a9309ec..1d8741c543 100644
--- a/tests/benchmarks/vc/vc_array_masks.cpp
+++ b/tests/benchmarks/vc/vc_array_masks.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/common/include/tests/common/benchmark_find_volume.inl b/tests/common/include/tests/common/benchmark_find_volume.inl
index 2ce38e5c52..4af4c5bc7d 100644
--- a/tests/common/include/tests/common/benchmark_find_volume.inl
+++ b/tests/common/include/tests/common/benchmark_find_volume.inl
@@ -1,18 +1,18 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "core/detector.hpp"
-#include "core/transform_store.hpp"
-#include "io/csv_io.hpp"
-
 #include <benchmark/benchmark.h>
 
-#include <string>
 #include <iostream>
+#include <string>
+
+#include "core/detector.hpp"
+#include "core/transform_store.hpp"
+#include "io/csv_io.hpp"
 
 using namespace detray;
 
@@ -23,12 +23,11 @@ unsigned int gbench_repetitions = 0;
 #endif
 
 /** Read the detector from file */
-auto read_detector()
-{
+auto read_detector() {
     auto env_d_d = std::getenv("DETRAY_TEST_DATA_DIR");
-    if (env_d_d == nullptr)
-    {
-        throw std::ios_base::failure("Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
+    if (env_d_d == nullptr) {
+        throw std::ios_base::failure(
+            "Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
     }
     auto data_directory = std::string(env_d_d);
 
@@ -37,70 +36,62 @@ auto read_detector()
     std::string volumes = data_directory + "odd-layer-volumes.csv";
     std::string grids = data_directory + "odd-surface-grids.csv";
     std::string grid_entries = "";
-    return detray::detector_from_csv<>(name, surfaces, volumes, grids, grid_entries);
+    return detray::detector_from_csv<>(name, surfaces, volumes, grids,
+                                       grid_entries);
 };
 
 auto d = read_detector();
 const unsigned int itest = 10000;
 
-namespace __plugin
-{
-    // This test a reference run to deduce the random number
-    static void BM_FIND_VOLUMES(benchmark::State &state)
-    {
-        auto volume_grid = d.volume_search_grid();
-
-        const auto &axis0 = volume_grid.axis_p0();
-        const auto &axis1 = volume_grid.axis_p1();
-
-        auto range0 = axis0.span();
-        auto range1 = axis1.span();
-
-        scalar step0 = (range0[1] - range0[0]) / itest;
-        scalar step1 = (range0[1] - range0[0]) / itest;
-
-        size_t successful = 0;
-        size_t unsuccessful = 0;
-
-        for (auto _ : state)
-        {
-            for (unsigned int i1 = 0; i1 < itest; ++i1)
-            {
-                for (unsigned int i0 = 0; i0 < itest; ++i0)
-                {
-                    vector3 rz {i0 * step0, 0., i1 * step1};
-                    auto &v = d.indexed_volume(rz);
-
-                    benchmark::DoNotOptimize(successful);
-                    benchmark::DoNotOptimize(unsuccessful);
-                    if (v.index() == dindex_invalid)
-                    {
-                        ++unsuccessful;
-                    }
-                    else
-                    {
-                        ++successful;
-                    }
-                    benchmark::ClobberMemory();
+namespace __plugin {
+// This test a reference run to deduce the random number
+static void BM_FIND_VOLUMES(benchmark::State &state) {
+    auto volume_grid = d.volume_search_grid();
+
+    const auto &axis0 = volume_grid.axis_p0();
+    const auto &axis1 = volume_grid.axis_p1();
+
+    auto range0 = axis0.span();
+    auto range1 = axis1.span();
+
+    scalar step0 = (range0[1] - range0[0]) / itest;
+    scalar step1 = (range0[1] - range0[0]) / itest;
+
+    size_t successful = 0;
+    size_t unsuccessful = 0;
+
+    for (auto _ : state) {
+        for (unsigned int i1 = 0; i1 < itest; ++i1) {
+            for (unsigned int i0 = 0; i0 < itest; ++i0) {
+                vector3 rz{i0 * step0, 0., i1 * step1};
+                auto &v = d.indexed_volume(rz);
+
+                benchmark::DoNotOptimize(successful);
+                benchmark::DoNotOptimize(unsuccessful);
+                if (v.index() == dindex_invalid) {
+                    ++unsuccessful;
+                } else {
+                    ++successful;
                 }
+                benchmark::ClobberMemory();
             }
         }
-
-
-        #ifndef DETRAY_BENCHMARKS_MULTITHREAD
-        std::cout << "Successful   : " << successful << std::endl;
-        std::cout << "Unsuccessful : " << unsuccessful << std::endl;
-        #endif
     }
 
-    BENCHMARK(BM_FIND_VOLUMES)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+#ifndef DETRAY_BENCHMARKS_MULTITHREAD
+    std::cout << "Successful   : " << successful << std::endl;
+    std::cout << "Unsuccessful : " << unsuccessful << std::endl;
+#endif
+}
+
+BENCHMARK(BM_FIND_VOLUMES)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
 
-} // namespace __plugin
+}  // namespace __plugin
 
 BENCHMARK_MAIN();
diff --git a/tests/common/include/tests/common/benchmark_intersect_all.inl b/tests/common/include/tests/common/benchmark_intersect_all.inl
index 62202411ed..454aaae1d7 100644
--- a/tests/common/include/tests/common/benchmark_intersect_all.inl
+++ b/tests/common/include/tests/common/benchmark_intersect_all.inl
@@ -1,20 +1,20 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+#include <benchmark/benchmark.h>
+
+#include <fstream>
+#include <iostream>
+
 #include "core/detector.hpp"
 #include "core/transform_store.hpp"
 #include "io/csv_io.hpp"
 #include "tools/intersection_kernel.hpp"
 
-#include <iostream>
-#include <fstream>
-
-#include <benchmark/benchmark.h>
-
 using namespace detray;
 
 using transform3 = __plugin::transform3;
@@ -36,12 +36,11 @@ unsigned int phi_steps = 100;
 bool stream_file = false;
 
 /** Read the detector from file */
-auto read_detector()
-{
+auto read_detector() {
     auto env_d_d = std::getenv("DETRAY_TEST_DATA_DIR");
-    if (env_d_d == nullptr)
-    {
-        throw std::ios_base::failure("Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
+    if (env_d_d == nullptr) {
+        throw std::ios_base::failure(
+            "Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
     }
     auto data_directory = std::string(env_d_d);
 
@@ -50,7 +49,8 @@ auto read_detector()
     std::string volumes = data_directory + "odd-layer-volumes.csv";
     std::string grids = data_directory + "odd-surface-grids.csv";
     std::string grid_entries = "";
-    return detray::detector_from_csv<>(name, surfaces, volumes, grids, grid_entries);
+    return detray::detector_from_csv<>(name, surfaces, volumes, grids,
+                                       grid_entries);
 };
 
 auto d = read_detector();
@@ -59,96 +59,96 @@ const auto &surfaces = d.surfaces();
 constexpr bool get_surface_masks = true;
 const auto &masks = d.template masks<get_surface_masks>();
 
-namespace __plugin
-{
-    // This test runs intersection with all surfaces of the TrackML detector
-    static void BM_INTERSECT_ALL(benchmark::State &state)
-    {
+namespace __plugin {
+// This test runs intersection with all surfaces of the TrackML detector
+static void BM_INTERSECT_ALL(benchmark::State &state) {
 
-        /*std::ofstream hit_out;
-        if (stream_file)
-        {
-            hit_out.open("tml_hits.csv");
-        }*/
-        unsigned int hits = 0;
-        unsigned int missed = 0;
-
-        point3 ori = {0., 0., 0.};
-
-        using detray_context = decltype(d)::transform_store::context;
-        detray_context default_context;
-
-        for (auto _ : state)
-        {
-            track<static_transform_store<>::context> track;
-            track.pos = point3{0., 0., 0.};
-
-            // Loops of theta values
-            for (unsigned int itheta = 0; itheta < theta_steps; ++itheta)
-            {
-                scalar theta = 0.1 + itheta * (M_PI - 0.1) / theta_steps;
-                scalar sin_theta = std::sin(theta);
-                scalar cos_theta = std::cos(theta);
-
-                // Loops of phi values
-                for (unsigned int iphi = 0; iphi < phi_steps; ++iphi)
-                {
-                    // The direction
-                    scalar phi = -M_PI + iphi * (2 * M_PI) / phi_steps;
-                    scalar sin_phi = std::sin(phi);
-                    scalar cos_phi = std::cos(phi);
-                    track.dir = {cos_phi * sin_theta, sin_phi * sin_theta, cos_theta};
-
-                    // Loop over volumes
-                    for (const auto &v : d.volumes())
-                    {
-                        // Loop over surfaces
-                        for (size_t si = v.template range<get_surface_masks>()[0]; si < v.template range<get_surface_masks>()[1]; si++)
-                        {
-                            auto sfi_surface = intersect(track, surfaces[si], d.transforms(v.template trf_range<get_surface_masks>(), default_context), masks);
-
-                            const auto &sfi = std::get<0>(sfi_surface);
-                            
-                            benchmark::DoNotOptimize(hits);
-                            benchmark::DoNotOptimize(missed);
-                            if (sfi.status == intersection_status::e_inside)
-                            {
-                                /* state.PauseTiming();
-                                if (stream_file)
-                                {
-                                    hit_out << sfi.p3[0] << "," << sfi.p3[1] << "," << sfi.p3[2] << "\n";
-                                }
-                                state.ResumeTiming();*/
-                                ++hits;
-                            }
-                            else
+    /*std::ofstream hit_out;
+    if (stream_file)
+    {
+        hit_out.open("tml_hits.csv");
+    }*/
+    unsigned int hits = 0;
+    unsigned int missed = 0;
+
+    point3 ori = {0., 0., 0.};
+
+    using detray_context = decltype(d)::transform_store::context;
+    detray_context default_context;
+
+    for (auto _ : state) {
+        track<static_transform_store<>::context> track;
+        track.pos = point3{0., 0., 0.};
+
+        // Loops of theta values
+        for (unsigned int itheta = 0; itheta < theta_steps; ++itheta) {
+            scalar theta = 0.1 + itheta * (M_PI - 0.1) / theta_steps;
+            scalar sin_theta = std::sin(theta);
+            scalar cos_theta = std::cos(theta);
+
+            // Loops of phi values
+            for (unsigned int iphi = 0; iphi < phi_steps; ++iphi) {
+                // The direction
+                scalar phi = -M_PI + iphi * (2 * M_PI) / phi_steps;
+                scalar sin_phi = std::sin(phi);
+                scalar cos_phi = std::cos(phi);
+                track.dir = {cos_phi * sin_theta, sin_phi * sin_theta,
+                             cos_theta};
+
+                // Loop over volumes
+                for (const auto &v : d.volumes()) {
+                    // Loop over surfaces
+                    for (size_t si = v.template range<get_surface_masks>()[0];
+                         si < v.template range<get_surface_masks>()[1]; si++) {
+                        auto sfi_surface = intersect(
+                            track, surfaces[si],
+                            d.transforms(
+                                v.template trf_range<get_surface_masks>(),
+                                default_context),
+                            masks);
+
+                        const auto &sfi = std::get<0>(sfi_surface);
+
+                        benchmark::DoNotOptimize(hits);
+                        benchmark::DoNotOptimize(missed);
+                        if (sfi.status == intersection_status::e_inside) {
+                            /* state.PauseTiming();
+                            if (stream_file)
                             {
-                                ++missed;
+                                hit_out << sfi.p3[0] << "," << sfi.p3[1] << ","
+                            << sfi.p3[2]
+                            << "\n";
                             }
-                            benchmark::ClobberMemory();
+                            state.ResumeTiming();*/
+                            ++hits;
+                        } else {
+                            ++missed;
                         }
+                        benchmark::ClobberMemory();
                     }
                 }
             }
         }
-
-        #ifndef DETRAY_BENCHMARKS_MULTITHREAD
-        std::cout << "[detray] hits / missed / total = " << hits << " / " << missed << " / " << hits + missed << std::endl;
-        #endif
-        /**if (stream_file)
-        {
-            hit_out.close();
-        }*/
     }
 
-    BENCHMARK(BM_INTERSECT_ALL)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+#ifndef DETRAY_BENCHMARKS_MULTITHREAD
+    std::cout << "[detray] hits / missed / total = " << hits << " / " << missed
+              << " / " << hits + missed << std::endl;
+#endif
+    /**if (stream_file)
+    {
+        hit_out.close();
+    }*/
+}
+
+BENCHMARK(BM_INTERSECT_ALL)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
 
-} // namespace __plugin
+}  // namespace __plugin
 
 BENCHMARK_MAIN();
diff --git a/tests/common/include/tests/common/benchmark_intersect_surfaces.inl b/tests/common/include/tests/common/benchmark_intersect_surfaces.inl
index 5407eee160..c889882163 100644
--- a/tests/common/include/tests/common/benchmark_intersect_surfaces.inl
+++ b/tests/common/include/tests/common/benchmark_intersect_surfaces.inl
@@ -1,20 +1,20 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+#include <benchmark/benchmark.h>
+
+#include <fstream>
+
 #include "masks/masks.hpp"
 #include "tests/common/test_surfaces.hpp"
 #include "tools/concentric_cylinder_intersector.hpp"
 #include "tools/cylinder_intersector.hpp"
 #include "tools/planar_intersector.hpp"
 
-#include <fstream>
-
-#include <benchmark/benchmark.h>
-
 using namespace detray;
 
 using transform3 = __plugin::transform3;
@@ -35,204 +35,184 @@ unsigned int phi_steps = 1000;
 
 dvector<scalar> dists = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10.};
 
-auto planes = planes_along_direction(dists, vector::normalize(vector3{1., 1., 1.}));
-
-namespace __plugin
-{
-    // This test runs intersection with all surfaces of the TrackML detector
-    static void BM_INTERSECT_PLANES(benchmark::State &state)
-    {
-
-        unsigned int sfhit = 0;
-        unsigned int sfmiss = 0;
-
-        rectangle2<> rect = {10., 20.};
-        point3 ori = {0., 0., 0.};
-
-        for (auto _ : state)
-        {
-            benchmark::DoNotOptimize(sfhit);
-            benchmark::DoNotOptimize(sfmiss);
-            // Loops of theta values
-            for (unsigned int itheta = 0; itheta < theta_steps; ++itheta)
-            {
-                scalar theta = 0.85 + itheta * 0.2 / theta_steps;
-                scalar sin_theta = std::sin(theta);
-                scalar cos_theta = std::cos(theta);
-
-                // Loops of phi values
-                for (unsigned int iphi = 0; iphi < phi_steps; ++iphi)
-                {
-                    scalar phi = 0.7 + iphi * 0.2 / phi_steps;
-                    scalar sin_phi = std::sin(phi);
-                    scalar cos_phi = std::cos(phi);
-
-                    vector3 dir{cos_phi * sin_theta, sin_phi * sin_theta, cos_theta};
-
-                    for (auto plane : planes)
-                    {
-                        auto pi = rect.intersector();
-                        auto is = pi.intersect(plane.transform(), ori, dir, cart2, rect);
-                        
-                        benchmark::DoNotOptimize(sfhit);
-                        benchmark::DoNotOptimize(sfmiss);
-                        if (is.status == e_inside)
-                        {
-                            ++sfhit;
-                        }
-                        else
-                        {
-                            ++sfmiss;
-                        }
-                        benchmark::ClobberMemory();
+auto planes =
+    planes_along_direction(dists, vector::normalize(vector3{1., 1., 1.}));
+
+namespace __plugin {
+// This test runs intersection with all surfaces of the TrackML detector
+static void BM_INTERSECT_PLANES(benchmark::State &state) {
+
+    unsigned int sfhit = 0;
+    unsigned int sfmiss = 0;
+
+    rectangle2<> rect = {10., 20.};
+    point3 ori = {0., 0., 0.};
+
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(sfhit);
+        benchmark::DoNotOptimize(sfmiss);
+        // Loops of theta values
+        for (unsigned int itheta = 0; itheta < theta_steps; ++itheta) {
+            scalar theta = 0.85 + itheta * 0.2 / theta_steps;
+            scalar sin_theta = std::sin(theta);
+            scalar cos_theta = std::cos(theta);
+
+            // Loops of phi values
+            for (unsigned int iphi = 0; iphi < phi_steps; ++iphi) {
+                scalar phi = 0.7 + iphi * 0.2 / phi_steps;
+                scalar sin_phi = std::sin(phi);
+                scalar cos_phi = std::cos(phi);
+
+                vector3 dir{cos_phi * sin_theta, sin_phi * sin_theta,
+                            cos_theta};
+
+                for (auto plane : planes) {
+                    auto pi = rect.intersector();
+                    auto is =
+                        pi.intersect(plane.transform(), ori, dir, cart2, rect);
+
+                    benchmark::DoNotOptimize(sfhit);
+                    benchmark::DoNotOptimize(sfmiss);
+                    if (is.status == e_inside) {
+                        ++sfhit;
+                    } else {
+                        ++sfmiss;
                     }
+                    benchmark::ClobberMemory();
                 }
             }
         }
     }
+}
 
-    BENCHMARK(BM_INTERSECT_PLANES)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+BENCHMARK(BM_INTERSECT_PLANES)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
 
-    // This test runs intersection with all surfaces of the TrackML detector
-    static void BM_INTERSECT_CYLINDERS(benchmark::State &state)
-    {
+// This test runs intersection with all surfaces of the TrackML detector
+static void BM_INTERSECT_CYLINDERS(benchmark::State &state) {
 
-        unsigned int sfhit = 0;
-        unsigned int sfmiss = 0;
+    unsigned int sfhit = 0;
+    unsigned int sfmiss = 0;
 
-        using cylinder_mask = cylinder3<false, cylinder_intersector>;
-        dvector<cylinder_mask> cylinders;
-        for (auto r : dists)
-        {
-            cylinders.push_back(cylinder_mask{r, -10., 10.});
-        }
+    using cylinder_mask = cylinder3<false, cylinder_intersector>;
+    dvector<cylinder_mask> cylinders;
+    for (auto r : dists) {
+        cylinders.push_back(cylinder_mask{r, -10., 10.});
+    }
+
+    surface_base<transform3> plain(std::move(transform3()), 0, 0, false);
 
-        surface_base<transform3> plain(std::move(transform3()), 0, 0, false);
-
-        point3 ori = {0., 0., 0.};
-
-        for (auto _ : state)
-        {
-            benchmark::DoNotOptimize(sfhit);
-            benchmark::DoNotOptimize(sfmiss);
-
-            // Loops of theta values
-            for (unsigned int itheta = 0; itheta < theta_steps; ++itheta)
-            {
-                scalar theta = 0.85 + itheta * 0.2 / theta_steps;
-                scalar sin_theta = std::sin(theta);
-                scalar cos_theta = std::cos(theta);
-
-                // Loops of phi values
-                for (unsigned int iphi = 0; iphi < phi_steps; ++iphi)
-                {
-                    scalar phi = 0.7 + iphi * 0.2 / phi_steps;
-                    scalar sin_phi = std::sin(phi);
-                    scalar cos_phi = std::cos(phi);
-
-                    vector3 dir{cos_phi * sin_theta, sin_phi * sin_theta, cos_theta};
-
-                    for (auto cylinder : cylinders)
-                    {
-                        auto ci = cylinder.intersector();
-                        auto is = ci.intersect(plain.transform(), ori, dir, cyl2, cylinder);
-                        
-                        benchmark::DoNotOptimize(sfhit);
-                        benchmark::DoNotOptimize(sfmiss);
-                        if (is.status == e_inside)
-                        {
-                            ++sfhit;
-                        }
-                        else
-                        {
-                            ++sfmiss;
-                        }
-                        benchmark::ClobberMemory();
+    point3 ori = {0., 0., 0.};
+
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(sfhit);
+        benchmark::DoNotOptimize(sfmiss);
+
+        // Loops of theta values
+        for (unsigned int itheta = 0; itheta < theta_steps; ++itheta) {
+            scalar theta = 0.85 + itheta * 0.2 / theta_steps;
+            scalar sin_theta = std::sin(theta);
+            scalar cos_theta = std::cos(theta);
+
+            // Loops of phi values
+            for (unsigned int iphi = 0; iphi < phi_steps; ++iphi) {
+                scalar phi = 0.7 + iphi * 0.2 / phi_steps;
+                scalar sin_phi = std::sin(phi);
+                scalar cos_phi = std::cos(phi);
+
+                vector3 dir{cos_phi * sin_theta, sin_phi * sin_theta,
+                            cos_theta};
+
+                for (auto cylinder : cylinders) {
+                    auto ci = cylinder.intersector();
+                    auto is = ci.intersect(plain.transform(), ori, dir, cyl2,
+                                           cylinder);
+
+                    benchmark::DoNotOptimize(sfhit);
+                    benchmark::DoNotOptimize(sfmiss);
+                    if (is.status == e_inside) {
+                        ++sfhit;
+                    } else {
+                        ++sfmiss;
                     }
+                    benchmark::ClobberMemory();
                 }
             }
         }
     }
+}
 
-    BENCHMARK(BM_INTERSECT_CYLINDERS)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+BENCHMARK(BM_INTERSECT_CYLINDERS)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
 
-    // This test runs intersection with all surfaces of the TrackML detector
-    static void BM_INTERSECT_CONCETRIC_CYLINDERS(benchmark::State &state)
-    {
-        unsigned int sfhit = 0;
-        unsigned int sfmiss = 0;
-
-        using cylinder_mask = cylinder3<false, concentric_cylinder_intersector<>>;
-        dvector<cylinder_mask> cylinders;
-        for (auto r : dists)
-        {
-            cylinders.push_back(cylinder_mask{r, -10., 10.});
-        }
+// This test runs intersection with all surfaces of the TrackML detector
+static void BM_INTERSECT_CONCETRIC_CYLINDERS(benchmark::State &state) {
+    unsigned int sfhit = 0;
+    unsigned int sfmiss = 0;
 
-        surface_base<transform3> plain(std::move(transform3()), 0, 0, false);
-
-        point3 ori = {0., 0., 0.};
-
-        for (auto _ : state)
-        {
-            // Loops of theta values
-            for (unsigned int itheta = 0; itheta < theta_steps; ++itheta)
-            {
-                scalar theta = 0.85 + itheta * 0.2 / theta_steps;
-                scalar sin_theta = std::sin(theta);
-                scalar cos_theta = std::cos(theta);
-
-                // Loops of phi values
-                for (unsigned int iphi = 0; iphi < phi_steps; ++iphi)
-                {
-                    scalar phi = 0.7 + iphi * 0.2 / phi_steps;
-                    scalar sin_phi = std::sin(phi);
-                    scalar cos_phi = std::cos(phi);
-
-                    vector3 dir{cos_phi * sin_theta, sin_phi * sin_theta, cos_theta};
-
-                    for (auto cylinder : cylinders)
-                    {
-                        auto cci = cylinder.intersector();
-                        auto is = cci.intersect(plain.transform(), ori, dir, cyl2, cylinder);
-
-                        benchmark::DoNotOptimize(sfhit);
-                        benchmark::DoNotOptimize(sfmiss);
-                        if (is.status == e_inside)
-                        {
-                            ++sfhit;
-                        }
-                        else
-                        {
-                            ++sfmiss;
-                        }
-                        benchmark::ClobberMemory();
+    using cylinder_mask = cylinder3<false, concentric_cylinder_intersector<>>;
+    dvector<cylinder_mask> cylinders;
+    for (auto r : dists) {
+        cylinders.push_back(cylinder_mask{r, -10., 10.});
+    }
+
+    surface_base<transform3> plain(std::move(transform3()), 0, 0, false);
+
+    point3 ori = {0., 0., 0.};
+
+    for (auto _ : state) {
+        // Loops of theta values
+        for (unsigned int itheta = 0; itheta < theta_steps; ++itheta) {
+            scalar theta = 0.85 + itheta * 0.2 / theta_steps;
+            scalar sin_theta = std::sin(theta);
+            scalar cos_theta = std::cos(theta);
+
+            // Loops of phi values
+            for (unsigned int iphi = 0; iphi < phi_steps; ++iphi) {
+                scalar phi = 0.7 + iphi * 0.2 / phi_steps;
+                scalar sin_phi = std::sin(phi);
+                scalar cos_phi = std::cos(phi);
+
+                vector3 dir{cos_phi * sin_theta, sin_phi * sin_theta,
+                            cos_theta};
+
+                for (auto cylinder : cylinders) {
+                    auto cci = cylinder.intersector();
+                    auto is = cci.intersect(plain.transform(), ori, dir, cyl2,
+                                            cylinder);
+
+                    benchmark::DoNotOptimize(sfhit);
+                    benchmark::DoNotOptimize(sfmiss);
+                    if (is.status == e_inside) {
+                        ++sfhit;
+                    } else {
+                        ++sfmiss;
                     }
+                    benchmark::ClobberMemory();
                 }
             }
         }
     }
+}
 
-    BENCHMARK(BM_INTERSECT_CONCETRIC_CYLINDERS)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+BENCHMARK(BM_INTERSECT_CONCETRIC_CYLINDERS)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
 
-} // namespace __plugin
+}  // namespace __plugin
 
 BENCHMARK_MAIN();
diff --git a/tests/common/include/tests/common/benchmark_masks.inl b/tests/common/include/tests/common/benchmark_masks.inl
index a900de87f2..6dd7ae8ab2 100644
--- a/tests/common/include/tests/common/benchmark_masks.inl
+++ b/tests/common/include/tests/common/benchmark_masks.inl
@@ -1,21 +1,21 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/annulus2.hpp"
-#include "masks/cylinder3.hpp"
-#include "masks/rectangle2.hpp"
-#include "masks/trapezoid2.hpp"
-#include "masks/ring2.hpp"
+#include <benchmark/benchmark.h>
 
 #include <cmath>
 #include <fstream>
 #include <iostream>
 
-#include <benchmark/benchmark.h>
+#include "masks/annulus2.hpp"
+#include "masks/cylinder3.hpp"
+#include "masks/rectangle2.hpp"
+#include "masks/ring2.hpp"
+#include "masks/trapezoid2.hpp"
 
 using namespace detray;
 using namespace __plugin;
@@ -35,342 +35,301 @@ unsigned int steps_y2 = steps_x2;
 
 bool screen_output = false;
 
-namespace
-{
-    
-    // This test runs a rectangle2 maks test operation
-    static void BM_RECTANGLE2_MASK(benchmark::State &state)
-    {
-        using local_type = __plugin::cartesian2;
-        using point2 = __plugin::point2;
-
-        rectangle2<> r = {3, 4};
-
-        scalar world = 10.;
-        scalar area = 4 * r[0] * r[1];
-        scalar rest = world * world - area;
-
-        scalar sx = world / steps_x2;
-        scalar sy = world / steps_y2;
-        unsigned long inside = 0;
-        unsigned long outside = 0;
-
-        for (auto _ : state)
-        {
-            for (unsigned int ix = 0; ix < steps_x2; ++ix)
-            {
-                scalar x = -0.5 * world + ix * sx;
-                for (unsigned int iy = 0; iy < steps_y2; ++iy)
-                {
-                    scalar y = -0.5 * world + iy * sy;
+namespace {
 
-                    benchmark::DoNotOptimize(inside);
-                    benchmark::DoNotOptimize(outside);
-                    if (r.is_inside<local_type>(point2{x, y}) == e_inside)
-                    {
-                        ++inside;
-                    }
-                    else
-                    {
-                        ++outside;
-                    }
-                    benchmark::ClobberMemory();
-                }
-            }
-        }
-
-        if (screen_output)
-        {
-            std::cout << "Rectangle : Inside/outside ... " << inside << " / " << outside << " = "
-                      << static_cast<scalar>(inside) / static_cast<scalar>(outside)
-                      << " (theoretical = " << area / rest << ") " << std::endl;
-        }
-    }
-
-    // This test runs intersection a trapezoid2 mask operation
-    static void BM_TRAPEZOID2_MASK(benchmark::State &state)
-    {
-        using local_type = __plugin::cartesian2;
-        using point2 = __plugin::point2;
+// This test runs a rectangle2 maks test operation
+static void BM_RECTANGLE2_MASK(benchmark::State &state) {
+    using local_type = __plugin::cartesian2;
+    using point2 = __plugin::point2;
 
-        trapezoid2<> t = {2, 3, 4};
+    rectangle2<> r = {3, 4};
 
-        scalar world = 10.;
-        scalar area = 2 * (t[0] + t[1]) * t[2];
-        scalar rest = world * world - area;
+    scalar world = 10.;
+    scalar area = 4 * r[0] * r[1];
+    scalar rest = world * world - area;
 
-        scalar sx = world / steps_x2;
-        scalar sy = world / steps_y2;
-        unsigned long inside = 0;
-        unsigned long outside = 0;
+    scalar sx = world / steps_x2;
+    scalar sy = world / steps_y2;
+    unsigned long inside = 0;
+    unsigned long outside = 0;
 
-        for (auto _ : state)
-        {
-            for (unsigned int ix = 0; ix < steps_x2; ++ix)
-            {
-                scalar x = -0.5 * world + ix * sx;
-                for (unsigned int iy = 0; iy < steps_y2; ++iy)
-                {
-                    scalar y = -0.5 * world + iy * sy;
+    for (auto _ : state) {
+        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+            scalar x = -0.5 * world + ix * sx;
+            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+                scalar y = -0.5 * world + iy * sy;
 
-                    benchmark::DoNotOptimize(inside);
-                    benchmark::DoNotOptimize(outside);
-                    if (t.is_inside<local_type>(point2{x, y}) == e_inside)
-                    {
-                        ++inside;
-                    }
-                    else
-                    {
-                        ++outside;
-                    }
-                    benchmark::ClobberMemory();
+                benchmark::DoNotOptimize(inside);
+                benchmark::DoNotOptimize(outside);
+                if (r.is_inside<local_type>(point2{x, y}) == e_inside) {
+                    ++inside;
+                } else {
+                    ++outside;
                 }
+                benchmark::ClobberMemory();
             }
         }
-
-        if (screen_output)
-        {
-            std::cout << "Trapezoid : Inside/outside ..." << inside << " / " << outside << " = "
-                      << static_cast<scalar>(inside) / static_cast<scalar>(outside)
-                      << " (theoretical = " << area / rest << ") " << std::endl;
-        }
     }
 
-    // This test runs a ring2 mask operation
-    static void BM_RING2_MASK(benchmark::State &state)
-    {
-        using local_type = __plugin::cartesian2;
-        using point2 = __plugin::point2;
-
-        ring2<> r = {0., 5.};
-
-        scalar world = 10.;
-        scalar area = r[1] * r[1] * M_PI;
-        scalar rest = world * world - area;
-
-        scalar sx = world / steps_x2;
-        scalar sy = world / steps_y2;
-        unsigned long inside = 0;
-        unsigned long outside = 0;
-
-        for (auto _ : state)
-        {
-            for (unsigned int ix = 0; ix < steps_x2; ++ix)
-            {
-                scalar x = -0.5 * world + ix * sx;
-                for (unsigned int iy = 0; iy < steps_y2; ++iy)
-                {
-                    scalar y = -0.5 * world + iy * sy;
-
-                    benchmark::DoNotOptimize(inside);
-                    benchmark::DoNotOptimize(outside);
-                    if (r.is_inside<local_type>(point2{x, y}) == e_inside)
-                    {
-                        ++inside;
-                    }
-                    else
-                    {
-                        ++outside;
-                    }
-                    benchmark::ClobberMemory();
+    if (screen_output) {
+        std::cout << "Rectangle : Inside/outside ... " << inside << " / "
+                  << outside << " = "
+                  << static_cast<scalar>(inside) / static_cast<scalar>(outside)
+                  << " (theoretical = " << area / rest << ") " << std::endl;
+    }
+}
+
+// This test runs intersection a trapezoid2 mask operation
+static void BM_TRAPEZOID2_MASK(benchmark::State &state) {
+    using local_type = __plugin::cartesian2;
+    using point2 = __plugin::point2;
+
+    trapezoid2<> t = {2, 3, 4};
+
+    scalar world = 10.;
+    scalar area = 2 * (t[0] + t[1]) * t[2];
+    scalar rest = world * world - area;
+
+    scalar sx = world / steps_x2;
+    scalar sy = world / steps_y2;
+    unsigned long inside = 0;
+    unsigned long outside = 0;
+
+    for (auto _ : state) {
+        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+            scalar x = -0.5 * world + ix * sx;
+            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+                scalar y = -0.5 * world + iy * sy;
+
+                benchmark::DoNotOptimize(inside);
+                benchmark::DoNotOptimize(outside);
+                if (t.is_inside<local_type>(point2{x, y}) == e_inside) {
+                    ++inside;
+                } else {
+                    ++outside;
                 }
+                benchmark::ClobberMemory();
             }
         }
-        if (screen_output)
-        {
-            std::cout << "Disc : Inside/outside ..." << inside << " / " << outside << " = "
-                      << static_cast<scalar>(inside) / static_cast<scalar>(outside)
-                      << " (theoretical = " << area / rest << ") " << std::endl;
-        }
     }
 
-    // This test runs mask oeration on a disc2
-    static void BM_DISC2_MASK(benchmark::State &state)
-    {
-        using local_type = __plugin::cartesian2;
-        using point2 = __plugin::point2;
-
-        ring2<> r = {2., 5.};
-
-        scalar world = 10.;
-        scalar area = (r[1] * r[1] - r[0] * r[0]) * M_PI;
-        scalar rest = world * world - area;
-
-        scalar sx = world / steps_x2;
-        scalar sy = world / steps_y2;
-        unsigned long inside = 0;
-        unsigned long outside = 0;
-
-        for (auto _ : state)
-        {
-            for (unsigned int ix = 0; ix < steps_x2; ++ix)
-            {
-                scalar x = -0.5 * world + ix * sx;
-                for (unsigned int iy = 0; iy < steps_y2; ++iy)
-                {
-                    scalar y = -0.5 * world + iy * sy;
-
-                    benchmark::DoNotOptimize(inside);
-                    benchmark::DoNotOptimize(outside);
-                    if (r.is_inside<local_type>(point2{x, y}) == e_inside)
-                    {
-                        ++inside;
-                    }
-                    else
-                    {
-                        ++outside;
-                    }
-                    benchmark::ClobberMemory();
+    if (screen_output) {
+        std::cout << "Trapezoid : Inside/outside ..." << inside << " / "
+                  << outside << " = "
+                  << static_cast<scalar>(inside) / static_cast<scalar>(outside)
+                  << " (theoretical = " << area / rest << ") " << std::endl;
+    }
+}
+
+// This test runs a ring2 mask operation
+static void BM_RING2_MASK(benchmark::State &state) {
+    using local_type = __plugin::cartesian2;
+    using point2 = __plugin::point2;
+
+    ring2<> r = {0., 5.};
+
+    scalar world = 10.;
+    scalar area = r[1] * r[1] * M_PI;
+    scalar rest = world * world - area;
+
+    scalar sx = world / steps_x2;
+    scalar sy = world / steps_y2;
+    unsigned long inside = 0;
+    unsigned long outside = 0;
+
+    for (auto _ : state) {
+        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+            scalar x = -0.5 * world + ix * sx;
+            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+                scalar y = -0.5 * world + iy * sy;
+
+                benchmark::DoNotOptimize(inside);
+                benchmark::DoNotOptimize(outside);
+                if (r.is_inside<local_type>(point2{x, y}) == e_inside) {
+                    ++inside;
+                } else {
+                    ++outside;
                 }
+                benchmark::ClobberMemory();
             }
         }
-        if (screen_output)
-        {
-            std::cout << "Ring : Inside/outside ..." << inside << " / " << outside << " = "
-                      << static_cast<scalar>(inside) / static_cast<scalar>(outside)
-                      << " (theoretical = " << area / rest << ") " << std::endl;
-        }
     }
-
-    // This test runs masking operations on a cylinder3 mask
-    static void BM_CYLINDER3_MASK(benchmark::State &state)
-    {
-        using local_type = __plugin::transform3;
-        using point3 = __plugin::point3;
-
-        cylinder3<> c = {3., 5.};
-
-        scalar world = 10.;
-
-        scalar sx = world / steps_x3;
-        scalar sy = world / steps_y3;
-        scalar sz = world / steps_z3;
-
-        unsigned long inside = 0;
-        unsigned long outside = 0;
-
-        for (auto _ : state)
-        {
-            for (unsigned int ix = 0; ix < steps_x3; ++ix)
-            {
-                scalar x = -0.5 * world + ix * sx;
-                for (unsigned int iy = 0; iy < steps_y3; ++iy)
-                {
-                    scalar y = -0.5 * world + iy * sy;
-                    for (unsigned int iz = 0; iz < steps_z3; ++iz)
-                    {
-                        scalar z = -0.5 * world + iz * sz;
-
-                        benchmark::DoNotOptimize(inside);
-                        benchmark::DoNotOptimize(outside);
-                        if (c.is_inside<local_type>(point3{x, y, z}, {0.1, 0.}) == e_inside)
-                        {
-                            ++inside;
-                        }
-                        else
-                        {
-                            ++outside;
-                        }
-                        benchmark::ClobberMemory();
-                    }
+    if (screen_output) {
+        std::cout << "Disc : Inside/outside ..." << inside << " / " << outside
+                  << " = "
+                  << static_cast<scalar>(inside) / static_cast<scalar>(outside)
+                  << " (theoretical = " << area / rest << ") " << std::endl;
+    }
+}
+
+// This test runs mask oeration on a disc2
+static void BM_DISC2_MASK(benchmark::State &state) {
+    using local_type = __plugin::cartesian2;
+    using point2 = __plugin::point2;
+
+    ring2<> r = {2., 5.};
+
+    scalar world = 10.;
+    scalar area = (r[1] * r[1] - r[0] * r[0]) * M_PI;
+    scalar rest = world * world - area;
+
+    scalar sx = world / steps_x2;
+    scalar sy = world / steps_y2;
+    unsigned long inside = 0;
+    unsigned long outside = 0;
+
+    for (auto _ : state) {
+        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+            scalar x = -0.5 * world + ix * sx;
+            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+                scalar y = -0.5 * world + iy * sy;
+
+                benchmark::DoNotOptimize(inside);
+                benchmark::DoNotOptimize(outside);
+                if (r.is_inside<local_type>(point2{x, y}) == e_inside) {
+                    ++inside;
+                } else {
+                    ++outside;
                 }
+                benchmark::ClobberMemory();
             }
         }
-        if (screen_output)
-        {
-            std::cout << "Ring : Inside/outside ..." << inside << " / " << outside << " = "
-                      << static_cast<scalar>(inside) / static_cast<scalar>(outside) << std::endl;
-        }
     }
+    if (screen_output) {
+        std::cout << "Ring : Inside/outside ..." << inside << " / " << outside
+                  << " = "
+                  << static_cast<scalar>(inside) / static_cast<scalar>(outside)
+                  << " (theoretical = " << area / rest << ") " << std::endl;
+    }
+}
+
+// This test runs masking operations on a cylinder3 mask
+static void BM_CYLINDER3_MASK(benchmark::State &state) {
+    using local_type = __plugin::transform3;
+    using point3 = __plugin::point3;
 
-    // This test runs a annulus mask operation
-    static void BM_ANNULUS_MASK(benchmark::State &state)
-    {
-        using local_type = __plugin::cartesian2;
-        using point2 = __plugin::point2;
+    cylinder3<> c = {3., 5.};
 
-        annulus2<> ann = {2.5, 5., -0.64299, 4.13173, 1., 0.5};
+    scalar world = 10.;
 
-        scalar world = 10.;
+    scalar sx = world / steps_x3;
+    scalar sy = world / steps_y3;
+    scalar sz = world / steps_z3;
 
-        scalar sx = world / steps_x2;
-        scalar sy = world / steps_y2;
-        unsigned long inside = 0;
-        unsigned long outside = 0;
+    unsigned long inside = 0;
+    unsigned long outside = 0;
 
-        for (auto _ : state)
-        {
-            for (unsigned int ix = 0; ix < steps_x2; ++ix)
-            {
-                scalar x = -0.5 * world + ix * sx;
-                for (unsigned int iy = 0; iy < steps_y2; ++iy)
-                {
-                    scalar y = -0.5 * world + iy * sy;
+    for (auto _ : state) {
+        for (unsigned int ix = 0; ix < steps_x3; ++ix) {
+            scalar x = -0.5 * world + ix * sx;
+            for (unsigned int iy = 0; iy < steps_y3; ++iy) {
+                scalar y = -0.5 * world + iy * sy;
+                for (unsigned int iz = 0; iz < steps_z3; ++iz) {
+                    scalar z = -0.5 * world + iz * sz;
 
                     benchmark::DoNotOptimize(inside);
                     benchmark::DoNotOptimize(outside);
-                    if (ann.is_inside<local_type>(point2{x, y}) == e_inside)
-                    {
+                    if (c.is_inside<local_type>(point3{x, y, z}, {0.1, 0.}) ==
+                        e_inside) {
                         ++inside;
-                    }
-                    else
-                    {
+                    } else {
                         ++outside;
                     }
                     benchmark::ClobberMemory();
                 }
             }
         }
-        if (screen_output)
-        {
-            std::cout << "Annulus : Inside/outside ..." << inside << " / " << outside << " = "
-                      << static_cast<scalar>(inside) / static_cast<scalar>(outside) << std::endl;
+    }
+    if (screen_output) {
+        std::cout << "Ring : Inside/outside ..." << inside << " / " << outside
+                  << " = "
+                  << static_cast<scalar>(inside) / static_cast<scalar>(outside)
+                  << std::endl;
+    }
+}
+
+// This test runs a annulus mask operation
+static void BM_ANNULUS_MASK(benchmark::State &state) {
+    using local_type = __plugin::cartesian2;
+    using point2 = __plugin::point2;
+
+    annulus2<> ann = {2.5, 5., -0.64299, 4.13173, 1., 0.5};
+
+    scalar world = 10.;
+
+    scalar sx = world / steps_x2;
+    scalar sy = world / steps_y2;
+    unsigned long inside = 0;
+    unsigned long outside = 0;
+
+    for (auto _ : state) {
+        for (unsigned int ix = 0; ix < steps_x2; ++ix) {
+            scalar x = -0.5 * world + ix * sx;
+            for (unsigned int iy = 0; iy < steps_y2; ++iy) {
+                scalar y = -0.5 * world + iy * sy;
+
+                benchmark::DoNotOptimize(inside);
+                benchmark::DoNotOptimize(outside);
+                if (ann.is_inside<local_type>(point2{x, y}) == e_inside) {
+                    ++inside;
+                } else {
+                    ++outside;
+                }
+                benchmark::ClobberMemory();
+            }
         }
     }
+    if (screen_output) {
+        std::cout << "Annulus : Inside/outside ..." << inside << " / "
+                  << outside << " = "
+                  << static_cast<scalar>(inside) / static_cast<scalar>(outside)
+                  << std::endl;
+    }
+}
 
-    BENCHMARK(BM_RECTANGLE2_MASK)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+BENCHMARK(BM_RECTANGLE2_MASK)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-    BENCHMARK(BM_TRAPEZOID2_MASK)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+BENCHMARK(BM_TRAPEZOID2_MASK)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-    BENCHMARK(BM_DISC2_MASK)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+BENCHMARK(BM_DISC2_MASK)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-    BENCHMARK(BM_RING2_MASK)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+BENCHMARK(BM_RING2_MASK)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-    BENCHMARK(BM_CYLINDER3_MASK)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+BENCHMARK(BM_CYLINDER3_MASK)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
-    BENCHMARK(BM_ANNULUS_MASK)
-    #ifdef DETRAY_BENCHMARKS_MULTITHREAD
+BENCHMARK(BM_ANNULUS_MASK)
+#ifdef DETRAY_BENCHMARKS_MULTITHREAD
     ->ThreadPerCpu()
-    #endif
+#endif
     ->Unit(benchmark::kMillisecond)
     ->Repetitions(gbench_repetitions)
     ->DisplayAggregatesOnly(true);
 
-} // namespace
+}  // namespace
 
 BENCHMARK_MAIN();
diff --git a/tests/common/include/tests/common/core_detector.inl b/tests/common/include/tests/common/core_detector.inl
index 3c29cf0c55..21163642ea 100644
--- a/tests/common/include/tests/common/core_detector.inl
+++ b/tests/common/include/tests/common/core_detector.inl
@@ -1,25 +1,24 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+#include <gtest/gtest.h>
+
 #include "core/detector.hpp"
 #include "core/transform_store.hpp"
 
-#include <gtest/gtest.h>
-
 /// @note __plugin has to be defined with a preprocessor command
 
 // This tests the construction of a detector class
-TEST(ALGEBRA_PLUGIN, detector)
-{
+TEST(ALGEBRA_PLUGIN, detector) {
     using namespace detray;
     using namespace __plugin;
 
     using detector = detector<>;
-    
+
     static_transform_store<>::context ctx0;
 
     detector::transform_container trfs;
@@ -49,8 +48,7 @@ TEST(ALGEBRA_PLUGIN, detector)
     d.template add_objects<detector::e_surface>(v, surfaces, masks, trfs, ctx0);
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/core_transform_store.inl b/tests/common/include/tests/common/core_transform_store.inl
index 4cbaca32e4..7ae5514724 100644
--- a/tests/common/include/tests/common/core_transform_store.inl
+++ b/tests/common/include/tests/common/core_transform_store.inl
@@ -1,23 +1,22 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "core/transform_store.hpp"
-
 #include <gtest/gtest.h>
 
+#include "core/transform_store.hpp"
+
 /// @note __plugin has to be defined with a preprocessor command
 
 // This tests the construction of a static transform store
-TEST(ALGEBRA_PLUGIN, static_transform_store)
-{
+TEST(ALGEBRA_PLUGIN, static_transform_store) {
     using namespace detray;
     using namespace __plugin;
 
-    static_transform_store<> static_store;   
+    static_transform_store<> static_store;
     static_transform_store<>::context ctx0;
     static_transform_store<>::context ctx1;
 
@@ -25,35 +24,31 @@ TEST(ALGEBRA_PLUGIN, static_transform_store)
 
     ASSERT_EQ(static_store.size(ctx0), 0u);
 
-    point3 t0{0.,0.,0.};
+    point3 t0{0., 0., 0.};
     transform3 tf0{t0};
     static_store.push_back(ctx0, tf0);
     ASSERT_EQ(static_store.size(ctx0), 1u);
 
-    point3 t1{1.,0.,0.};
+    point3 t1{1., 0., 0.};
     transform3 tf1{t1};
     static_store.push_back(ctx1, tf1);
     ASSERT_EQ(static_store.size(ctx1), 2u);
 
-    point3 t2{2.,0.,0.};
+    point3 t2{2., 0., 0.};
     transform3 tf2{t2};
     static_store.push_back(ctx0, std::move(tf2));
     ASSERT_EQ(static_store.size(ctx0), 3u);
 
-    point3 t3{2.,0.,0.};
+    point3 t3{2., 0., 0.};
     static_store.emplace_back(ctx0, std::move(t3));
     ASSERT_EQ(static_store.size(ctx0), 4u);
 
     static_store.emplace_back(ctx0);
     ASSERT_EQ(static_store.size(ctx0), 5u);
-
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
 }
-
diff --git a/tests/common/include/tests/common/display_masks.inl b/tests/common/include/tests/common/display_masks.inl
index 29acbc7888..71f50a55af 100644
--- a/tests/common/include/tests/common/display_masks.inl
+++ b/tests/common/include/tests/common/display_masks.inl
@@ -1,19 +1,19 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/masks.hpp"
-#include "style/styles.hpp"
-#include "view/views.hpp"
-#include "view/draw.hpp"
+#include <gtest/gtest.h>
 
-#include <cmath>
 #include <climits>
+#include <cmath>
 
-#include <gtest/gtest.h>
+#include "masks/masks.hpp"
+#include "style/styles.hpp"
+#include "view/draw.hpp"
+#include "view/views.hpp"
 
 /// @note __plugin has to be defined with a preprocessor command
 using namespace detray;
@@ -22,8 +22,7 @@ using transform3 = __plugin::transform3;
 using vector3 = __plugin::vector3;
 using point3 = __plugin::point3;
 
-TEST(display, annulus2)
-{
+TEST(display, annulus2) {
     detray::global_xy_view gxy;
 
     // First rectangle
@@ -36,8 +35,7 @@ TEST(display, annulus2)
     save("annulus.png");
 }
 
-TEST(display, rectangle2)
-{
+TEST(display, rectangle2) {
     detray::global_xy_view gxy;
 
     // First rectangle
@@ -50,8 +48,7 @@ TEST(display, rectangle2)
     save("rectangle.png");
 }
 
-TEST(display, trapezoid2)
-{
+TEST(display, trapezoid2) {
     detray::global_xy_view gxy;
 
     // First rectangle
@@ -64,8 +61,7 @@ TEST(display, trapezoid2)
     save("trapezoid.png");
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/io_read_detector.inl b/tests/common/include/tests/common/io_read_detector.inl
index 6e49f85749..168af9f002 100644
--- a/tests/common/include/tests/common/io_read_detector.inl
+++ b/tests/common/include/tests/common/io_read_detector.inl
@@ -1,43 +1,45 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+#include <gtest/gtest.h>
+
+#include <iostream>
+
 #include "core/detector.hpp"
 #include "core/transform_store.hpp"
 #include "io/csv_io.hpp"
 
-#include <iostream>
-#include <gtest/gtest.h>
-
 /// @note __plugin has to be defined with a preprocessor command
 
 // This tests the construction of a detector class
-TEST(ALGEBRA_PLUGIN, read_detector)
-{
+TEST(ALGEBRA_PLUGIN, read_detector) {
     using namespace detray;
 
     auto env_d_d = std::getenv("DETRAY_TEST_DATA_DIR");
-    if (env_d_d == nullptr)
-    {
-        throw std::ios_base::failure("Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
+    if (env_d_d == nullptr) {
+        throw std::ios_base::failure(
+            "Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
     }
     auto data_directory = std::string(env_d_d);
 
     std::string surface_file = data_directory + std::string("odd.csv");
-    std::string layer_volume_file = data_directory + std::string("odd-layer-volumes.csv");
-    std::string surface_grid_file = data_directory + std::string("odd-surface-grids.csv");
+    std::string layer_volume_file =
+        data_directory + std::string("odd-layer-volumes.csv");
+    std::string surface_grid_file =
+        data_directory + std::string("odd-surface-grids.csv");
     std::string surface_grid_entries_file = "";
 
-    auto d = detector_from_csv<>("odd", surface_file, layer_volume_file, surface_grid_file, surface_grid_entries_file);
+    auto d = detector_from_csv<>("odd", surface_file, layer_volume_file,
+                                 surface_grid_file, surface_grid_entries_file);
 
     std::cout << d.to_string() << std::endl;
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/masks_annulus2.inl b/tests/common/include/tests/common/masks_annulus2.inl
index efde851ae5..4d346fb439 100644
--- a/tests/common/include/tests/common/masks_annulus2.inl
+++ b/tests/common/include/tests/common/masks_annulus2.inl
@@ -1,23 +1,22 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/annulus2.hpp"
-
 #include <gtest/gtest.h>
 
+#include "masks/annulus2.hpp"
+
 using namespace detray;
 using namespace __plugin;
 
 // This tests the basic function of a rectangle
-TEST(mask, annulus2)
-{
-    using polar     = __plugin::polar2;
+TEST(mask, annulus2) {
+    using polar = __plugin::polar2;
     using cartesian = __plugin::cartesian2;
-    using point2    = __plugin::point2;
+    using point2 = __plugin::point2;
 
     scalar minR = 7.2;
     scalar maxR = 12.0;
@@ -26,15 +25,15 @@ TEST(mask, annulus2)
     point2 offset = {-2., 2.};
 
     // points in cartesian module frame
-    point2 p2_in   = {7., 7.};
+    point2 p2_in = {7., 7.};
     point2 p2_out1 = {5., 5.};
     point2 p2_out2 = {10., 3.};
     point2 p2_out3 = {10., 10.};
     point2 p2_out4 = {4., 10.};
 
-    auto toStripFrame = [&](const point2& xy) -> point2 {
+    auto toStripFrame = [&](const point2 &xy) -> point2 {
         auto shifted = xy + offset;
-        scalar r   = getter::perp(shifted);
+        scalar r = getter::perp(shifted);
         scalar phi = getter::phi(shifted);
         return point2{r, phi};
     };
@@ -49,28 +48,40 @@ TEST(mask, annulus2)
     ASSERT_EQ(ann2[5], static_cast<scalar>(2.0));
     ASSERT_EQ(ann2[6], static_cast<scalar>(0.));
 
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_in + offset) == intersection_status::e_inside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out1 + offset) == intersection_status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out2 + offset) == intersection_status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out3 + offset) == intersection_status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out4 + offset) == intersection_status::e_outside);
+    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_in + offset) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out1 + offset) ==
+                intersection_status::e_outside);
+    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out2 + offset) ==
+                intersection_status::e_outside);
+    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out3 + offset) ==
+                intersection_status::e_outside);
+    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out4 + offset) ==
+                intersection_status::e_outside);
     // Move outside point inside using a tolerance
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out1 + offset, {1.3, 0.}) == intersection_status::e_inside);
-    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out4 + offset, {0., 0.07}) == intersection_status::e_inside);
+    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out1 + offset, {1.3, 0.}) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(ann2.is_inside<cartesian>(p2_out4 + offset, {0., 0.07}) ==
+                intersection_status::e_inside);
 
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_in)) == intersection_status::e_inside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out1)) == intersection_status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out2)) == intersection_status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out3)) == intersection_status::e_outside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out4)) == intersection_status::e_outside);
+    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_in)) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out1)) ==
+                intersection_status::e_outside);
+    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out2)) ==
+                intersection_status::e_outside);
+    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out3)) ==
+                intersection_status::e_outside);
+    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out4)) ==
+                intersection_status::e_outside);
     // Move outside point inside using a tolerance
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out1), {1.3, 0.}) == intersection_status::e_inside);
-    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out4), {0., 0.07}) == intersection_status::e_inside);
+    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out1), {1.3, 0.}) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(ann2.is_inside<polar>(toStripFrame(p2_out4), {0., 0.07}) ==
+                intersection_status::e_inside);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/masks_containers.inl b/tests/common/include/tests/common/masks_containers.inl
index b75aca96da..2a6fad2556 100644
--- a/tests/common/include/tests/common/masks_containers.inl
+++ b/tests/common/include/tests/common/masks_containers.inl
@@ -1,40 +1,36 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/rectangle2.hpp"
-#include "masks/trapezoid2.hpp"
+#include <gtest/gtest.h>
+
 #include "masks/cylinder3.hpp"
+#include "masks/rectangle2.hpp"
 #include "masks/single3.hpp"
-
-#include <gtest/gtest.h>
+#include "masks/trapezoid2.hpp"
 
 using namespace detray;
 using namespace __plugin;
 
 // This tests the construction of a surface
-TEST(mask, tuple)
-{
+TEST(mask, tuple) {
     using rectangle_masks = dvector<rectangle2<>>;
     using cylinder_masks = dvector<cylinder3<>>;
 
     rectangle_masks rectangles;
     cylinder_masks cylinders;
-    dtuple< rectangle_masks, cylinder_masks > all_masks;
+    dtuple<rectangle_masks, cylinder_masks> all_masks;
 
-    std::get<rectangle_masks>(all_masks).push_back( {3.,4.});
-    std::get<rectangle_masks>(all_masks).push_back( {2.,8.});
+    std::get<rectangle_masks>(all_masks).push_back({3., 4.});
+    std::get<rectangle_masks>(all_masks).push_back({2., 8.});
 
     auto intersector = std::get<rectangle_masks>(all_masks)[0].intersector();
-    
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/masks_cylinder3.inl b/tests/common/include/tests/common/masks_cylinder3.inl
index f89db3f27f..9a6a48477f 100644
--- a/tests/common/include/tests/common/masks_cylinder3.inl
+++ b/tests/common/include/tests/common/masks_cylinder3.inl
@@ -1,20 +1,19 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/cylinder3.hpp"
-
 #include <gtest/gtest.h>
 
+#include "masks/cylinder3.hpp"
+
 using namespace detray;
 using namespace __plugin;
 
 // This tests the basic function of a rectangle
-TEST(mask, cylinder3)
-{
+TEST(mask, cylinder3) {
     using local_type = __plugin::transform3;
     using point3 = __plugin::point3;
 
@@ -23,7 +22,8 @@ TEST(mask, cylinder3)
 
     point3 p3_in = {r, 0., -1.};
     point3 p3_edge = {0., r, hz};
-    point3 p3_out = {static_cast<scalar>(r / std::sqrt(2.)), static_cast<scalar>(r / std::sqrt(2.)), 4.5};
+    point3 p3_out = {static_cast<scalar>(r / std::sqrt(2.)),
+                     static_cast<scalar>(r / std::sqrt(2.)), 4.5};
     point3 p3_off = {1., 1., -9.};
 
     cylinder3<> c = {r, -hz, hz};
@@ -32,17 +32,20 @@ TEST(mask, cylinder3)
     ASSERT_EQ(c[1], -hz);
     ASSERT_EQ(c[2], hz);
 
-    ASSERT_TRUE(c.is_inside<local_type>(p3_in) == intersection_status::e_inside);
-    ASSERT_TRUE(c.is_inside<local_type>(p3_edge) == intersection_status::e_inside);
-    ASSERT_TRUE(c.is_inside<local_type>(p3_out) == intersection_status::e_outside);
-    ASSERT_TRUE(c.is_inside<local_type>(p3_off) == intersection_status::e_missed);
+    ASSERT_TRUE(c.is_inside<local_type>(p3_in) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(c.is_inside<local_type>(p3_edge) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(c.is_inside<local_type>(p3_out) ==
+                intersection_status::e_outside);
+    ASSERT_TRUE(c.is_inside<local_type>(p3_off) ==
+                intersection_status::e_missed);
     // Move outside point inside using a tolerance
-    ASSERT_TRUE(c.is_inside<local_type>(p3_out, {0., 0.6}) == intersection_status::e_inside);
+    ASSERT_TRUE(c.is_inside<local_type>(p3_out, {0., 0.6}) ==
+                intersection_status::e_inside);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/masks_rectangle2.inl b/tests/common/include/tests/common/masks_rectangle2.inl
index 934232959f..49e38da484 100644
--- a/tests/common/include/tests/common/masks_rectangle2.inl
+++ b/tests/common/include/tests/common/masks_rectangle2.inl
@@ -1,23 +1,23 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/rectangle2.hpp"
+#include <gtest/gtest.h>
 
 #include <climits>
-#include <gtest/gtest.h>
+
+#include "masks/rectangle2.hpp"
 
 using namespace detray;
 using namespace __plugin;
 
 // This tests the basic function of a rectangle
-TEST(mask, rectangle2)
-{
+TEST(mask, rectangle2) {
     using local_type = __plugin::cartesian2;
-    using point2 =point2;
+    using point2 = point2;
 
     point2 p2_in = {0.5, -9.};
     point2 p2_edge = {1., 9.3};
@@ -31,16 +31,18 @@ TEST(mask, rectangle2)
     ASSERT_EQ(r2[0], hx);
     ASSERT_EQ(r2[1], hy);
 
-    ASSERT_TRUE(r2.is_inside<local_type>(p2_in) == intersection_status::e_inside);
-    ASSERT_TRUE(r2.is_inside<local_type>(p2_edge) == intersection_status::e_inside);
-    ASSERT_TRUE(r2.is_inside<local_type>(p2_out) == intersection_status::e_outside);
+    ASSERT_TRUE(r2.is_inside<local_type>(p2_in) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(r2.is_inside<local_type>(p2_edge) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(r2.is_inside<local_type>(p2_out) ==
+                intersection_status::e_outside);
     // Move outside point inside using a tolerance
-    ASSERT_TRUE(r2.is_inside<local_type>(p2_out, {1., 0.5}) == intersection_status::e_inside);
+    ASSERT_TRUE(r2.is_inside<local_type>(p2_out, {1., 0.5}) ==
+                intersection_status::e_inside);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/masks_ring2.inl b/tests/common/include/tests/common/masks_ring2.inl
index 09b7fa8295..68d797ac26 100644
--- a/tests/common/include/tests/common/masks_ring2.inl
+++ b/tests/common/include/tests/common/masks_ring2.inl
@@ -1,22 +1,21 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/ring2.hpp"
-
 #include <gtest/gtest.h>
 
+#include "masks/ring2.hpp"
+
 using namespace detray;
 using namespace __plugin;
 
 // This tests the basic function of a rectangle
-TEST(mask, ring2)
-{
+TEST(mask, ring2) {
     using cartesian = __plugin::cartesian2;
-    using polar     = __plugin::polar2;
+    using polar = __plugin::polar2;
 
     point2 p2_pl_in = {0.5, -2.};
     point2 p2_pl_edge = {0., 3.5};
@@ -32,21 +31,26 @@ TEST(mask, ring2)
     ASSERT_EQ(r2[1], 3.5);
 
     ASSERT_TRUE(r2.is_inside<polar>(p2_pl_in) == intersection_status::e_inside);
-    ASSERT_TRUE(r2.is_inside<polar>(p2_pl_edge) == intersection_status::e_inside);
-    ASSERT_TRUE(r2.is_inside<polar>(p2_pl_out) == intersection_status::e_outside);
+    ASSERT_TRUE(r2.is_inside<polar>(p2_pl_edge) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(r2.is_inside<polar>(p2_pl_out) ==
+                intersection_status::e_outside);
     // Move outside point inside using a tolerance
-    ASSERT_TRUE(r2.is_inside<polar>(p2_pl_out, 1.2) == intersection_status::e_inside);
-
-    ASSERT_TRUE(r2.is_inside<cartesian>(p2_c_in) == intersection_status::e_inside);
-    ASSERT_TRUE(r2.is_inside<cartesian>(p2_c_edge) == intersection_status::e_inside);
-    ASSERT_TRUE(r2.is_inside<cartesian>(p2_c_out) == intersection_status::e_outside);
+    ASSERT_TRUE(r2.is_inside<polar>(p2_pl_out, 1.2) ==
+                intersection_status::e_inside);
+
+    ASSERT_TRUE(r2.is_inside<cartesian>(p2_c_in) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(r2.is_inside<cartesian>(p2_c_edge) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(r2.is_inside<cartesian>(p2_c_out) ==
+                intersection_status::e_outside);
     // Move outside point inside using a tolerance
-    ASSERT_TRUE(r2.is_inside<cartesian>(p2_c_out, 1.45) == intersection_status::e_inside);
+    ASSERT_TRUE(r2.is_inside<cartesian>(p2_c_out, 1.45) ==
+                intersection_status::e_inside);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/masks_single3.inl b/tests/common/include/tests/common/masks_single3.inl
index 1c6546c73e..73fd29c27f 100644
--- a/tests/common/include/tests/common/masks_single3.inl
+++ b/tests/common/include/tests/common/masks_single3.inl
@@ -1,22 +1,21 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/single3.hpp"
+#include <gtest/gtest.h>
 
 #include <climits>
 
-#include <gtest/gtest.h>
+#include "masks/single3.hpp"
 
 using namespace detray;
 using namespace __plugin;
 
 // This tests the basic function of a rectangle
-TEST(mask, single3_0)
-{
+TEST(mask, single3_0) {
     using local_type = __plugin::transform3;
     using point3 = __plugin::point3;
 
@@ -30,16 +29,19 @@ TEST(mask, single3_0)
     ASSERT_EQ(m1_0[0], -h0);
     ASSERT_EQ(m1_0[1], h0);
 
-    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_in) == intersection_status::e_inside);
-    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_edge) == intersection_status::e_inside);
-    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_out) == intersection_status::e_outside);
+    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_in) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_edge) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_out) ==
+                intersection_status::e_outside);
     // Move outside point inside using a tolerance - take t0 not t1
-    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_out, 0.6) == intersection_status::e_inside);
+    ASSERT_TRUE(m1_0.is_inside<local_type>(p3_out, 0.6) ==
+                intersection_status::e_inside);
 }
 
 // This tests the basic function of a rectangle
-TEST(mask, single3_1)
-{
+TEST(mask, single3_1) {
     using local_type = __plugin::transform3;
     using point3 = __plugin::point3;
 
@@ -53,16 +55,19 @@ TEST(mask, single3_1)
     ASSERT_EQ(m1_1[0], -h1);
     ASSERT_EQ(m1_1[1], h1);
 
-    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_in) == intersection_status::e_inside);
-    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_edge) == intersection_status::e_inside);
-    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_out) == intersection_status::e_outside);
+    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_in) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_edge) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_out) ==
+                intersection_status::e_outside);
     // Move outside point inside using a tolerance - take t1 not t1
-    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_out, 0.6) == intersection_status::e_inside);
+    ASSERT_TRUE(m1_1.is_inside<local_type>(p3_out, 0.6) ==
+                intersection_status::e_inside);
 }
 
 // This tests the basic function of a rectangle
-TEST(mask, single3_2)
-{
+TEST(mask, single3_2) {
     using local_type = __plugin::transform3;
     using point3 = __plugin::point3;
 
@@ -76,16 +81,18 @@ TEST(mask, single3_2)
     ASSERT_EQ(m1_2[0], -h2);
     ASSERT_EQ(m1_2[1], h2);
 
-    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_in) == intersection_status::e_inside);
-    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_edge) == intersection_status::e_inside);
-    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_out) == intersection_status::e_outside);
+    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_in) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_edge) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_out) ==
+                intersection_status::e_outside);
     // Move outside point inside using a tolerance - take t1 not t1
-    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_out, 6.1) == intersection_status::e_inside);
+    ASSERT_TRUE(m1_2.is_inside<local_type>(p3_out, 6.1) ==
+                intersection_status::e_inside);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/masks_trapezoid2.inl b/tests/common/include/tests/common/masks_trapezoid2.inl
index 4b7d063ee6..a5fee75c60 100644
--- a/tests/common/include/tests/common/masks_trapezoid2.inl
+++ b/tests/common/include/tests/common/masks_trapezoid2.inl
@@ -1,22 +1,21 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/trapezoid2.hpp"
-
 #include <gtest/gtest.h>
 
+#include "masks/trapezoid2.hpp"
+
 using namespace detray;
 using namespace __plugin;
 
 // This tests the basic function of a trapezoid
-TEST(mask, trapezoid2)
-{
+TEST(mask, trapezoid2) {
     using local_type = __plugin::cartesian2;
-    using point2 =point2;
+    using point2 = point2;
 
     point2 p2_in = {1., -0.5};
     point2 p2_edge = {2.5, 1.};
@@ -32,16 +31,18 @@ TEST(mask, trapezoid2)
     ASSERT_EQ(t2[1], hx_maxy);
     ASSERT_EQ(t2[2], hy);
 
-    ASSERT_TRUE(t2.is_inside<local_type>(p2_in) == intersection_status::e_inside);
-    ASSERT_TRUE(t2.is_inside<local_type>(p2_edge) == intersection_status::e_inside);
-    ASSERT_TRUE(t2.is_inside<local_type>(p2_out) == intersection_status::e_outside);
+    ASSERT_TRUE(t2.is_inside<local_type>(p2_in) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(t2.is_inside<local_type>(p2_edge) ==
+                intersection_status::e_inside);
+    ASSERT_TRUE(t2.is_inside<local_type>(p2_out) ==
+                intersection_status::e_outside);
     // Move outside point inside using a tolerance
-    ASSERT_TRUE(t2.is_inside<local_type>(p2_out, {1., 0.5}) == intersection_status::e_inside);
+    ASSERT_TRUE(t2.is_inside<local_type>(p2_out, {1., 0.5}) ==
+                intersection_status::e_inside);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/masks_unmasked.inl b/tests/common/include/tests/common/masks_unmasked.inl
index 428e2f6877..a53375b76d 100644
--- a/tests/common/include/tests/common/masks_unmasked.inl
+++ b/tests/common/include/tests/common/masks_unmasked.inl
@@ -1,22 +1,21 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "masks/unmasked.hpp"
-
 #include <gtest/gtest.h>
 
+#include "masks/unmasked.hpp"
+
 using namespace detray;
 using namespace __plugin;
 
 // This tests the construction of a surface
-TEST(mask, unmasked)
-{
+TEST(mask, unmasked) {
     using local_type = __plugin::cartesian2;
-   point2 p2 = {0.5, -9.};
+    point2 p2 = {0.5, -9.};
 
     unmasked u;
     ASSERT_TRUE(u.is_inside<local_type>(p2) == e_hit);
@@ -24,9 +23,7 @@ TEST(mask, unmasked)
     ASSERT_TRUE(u.is_inside<local_type>(p2, false) == e_missed);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/test_core.inl b/tests/common/include/tests/common/test_core.inl
index 0e7a1e08a8..451e123b40 100644
--- a/tests/common/include/tests/common/test_core.inl
+++ b/tests/common/include/tests/common/test_core.inl
@@ -1,17 +1,17 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "core/surface_base.hpp"
-#include "core/intersection.hpp"
+#include <gtest/gtest.h>
 
-#include <cmath>
 #include <climits>
+#include <cmath>
 
-#include <gtest/gtest.h>
+#include "core/intersection.hpp"
+#include "core/surface_base.hpp"
 
 /// @note __plugin has to be defined with a preprocessor command
 
@@ -27,8 +27,7 @@ using point3 = __plugin::point3;
 constexpr scalar epsilon = std::numeric_limits<scalar>::epsilon();
 
 // This tests the construction of a surface_base object
-TEST(ALGEBRA_PLUGIN, surface_base)
-{
+TEST(ALGEBRA_PLUGIN, surface_base) {
     // Preparatioon work, create a transform
     vector3 z = vector::normalize(vector3{3., 2., 1.});
     vector3 x = vector::normalize(vector3{2., -3., 0.});
@@ -40,12 +39,13 @@ TEST(ALGEBRA_PLUGIN, surface_base)
 }
 
 // This tests the construction of a intresection
-TEST(ALGEBRA_PLUGIN, intersection)
-{
+TEST(ALGEBRA_PLUGIN, intersection) {
 
-    intersection i0 = {2., point3{0.3, 0.5, 0.7}, point2{0.2, 0.4}, intersection_status::e_hit};
+    intersection i0 = {2., point3{0.3, 0.5, 0.7}, point2{0.2, 0.4},
+                       intersection_status::e_hit};
 
-    intersection i1 = {1.7, point3{0.2, 0.3, 0.}, point2{0.2, 0.4}, intersection_status::e_inside};
+    intersection i1 = {1.7, point3{0.2, 0.3, 0.}, point2{0.2, 0.4},
+                       intersection_status::e_inside};
 
     intersection invalid;
     ASSERT_TRUE(invalid.status == intersection_status::e_missed);
@@ -58,9 +58,7 @@ TEST(ALGEBRA_PLUGIN, intersection)
     ASSERT_TRUE(std::isinf(intersections[2].path));
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/test_defs.hpp b/tests/common/include/tests/common/test_defs.hpp
index 8df44b104b..bef129107f 100644
--- a/tests/common/include/tests/common/test_defs.hpp
+++ b/tests/common/include/tests/common/test_defs.hpp
@@ -1,15 +1,15 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
+#include <cmath>
 
 #include "utils/containers.hpp"
-#include <cmath>
 
 #ifdef DETRAY_CUSTOM_SCALARTYPE
 using detray_scalar = DETRAY_CUSTOM_SCALARTYPE;
@@ -19,33 +19,28 @@ using detray_scalar = double;
 
 #define __plugin test
 
-namespace detray
-{
-    using scalar = detray_scalar;
+namespace detray {
+using scalar = detray_scalar;
 
-    namespace test
-    {
-        using point2 = darray<scalar, 2>;
-        using point3 = darray<scalar, 3>;
-    } // namespace test
+namespace test {
+using point2 = darray<scalar, 2>;
+using point3 = darray<scalar, 3>;
+}  // namespace test
 
-    namespace getter
-    {
+namespace getter {
 
-        /** Define the perpendicular length 
-         * @param  is the input vector
-         * @return a scalar type */
-        template <typename point_type>
-        scalar perp(const point_type &p)
-        {
-            return std::sqrt(p[0] * p[0] + p[1] * p[1]);
-        }
+/** Define the perpendicular length
+ * @param  is the input vector
+ * @return a scalar type */
+template <typename point_type>
+scalar perp(const point_type &p) {
+    return std::sqrt(p[0] * p[0] + p[1] * p[1]);
+}
 
-    } // namespace vector
+}  // namespace getter
 
-    test::point2 operator-(const test::point2 &a, const test::point2 &b)
-    {
-        return {a[0] - b[0], a[1] - b[1]};
-    }
+test::point2 operator-(const test::point2 &a, const test::point2 &b) {
+    return {a[0] - b[0], a[1] - b[1]};
+}
 
-} // namespace detray
+}  // namespace detray
diff --git a/tests/common/include/tests/common/test_surfaces.hpp b/tests/common/include/tests/common/test_surfaces.hpp
index c1ec55893d..f208900308 100644
--- a/tests/common/include/tests/common/test_surfaces.hpp
+++ b/tests/common/include/tests/common/test_surfaces.hpp
@@ -1,257 +1,269 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
 #pragma once
 
+#include <functional>
+
 #include "core/surface_base.hpp"
 #include "grids/axis.hpp"
 #include "grids/grid2.hpp"
-#include "grids/serializer2.hpp"
 #include "grids/populator.hpp"
-#include "utils/indexing.hpp"
-#include "utils/enumerate.hpp"
+#include "grids/serializer2.hpp"
 #include "tools/local_object_finder.hpp"
+#include "utils/enumerate.hpp"
+#include "utils/indexing.hpp"
 
-#include <functional>
+namespace detray {
+using namespace vector;
 
-namespace detray
-{
-    using namespace vector;
-
-    using transform3 = __plugin::transform3;
-    using point3 = point3;
-    using vector3 = vector3;
-
-    using binned_neighborhood = darray<darray<dindex, 2>, 2>;
-
-    /** This method creates a number (distances.size()) planes along a direction 
-    */
-    dvector<surface_base<transform3>> planes_along_direction(dvector<scalar> distances, vector3 direction)
-    {
-        // Rotation matrix
-        vector3 z = direction;
-        vector3 x = normalize(vector3{0, -z[2], z[1]});
-
-        dvector<surface_base<transform3>> return_surfaces;
-        return_surfaces.reserve(distances.size());
-        for (auto &d : distances)
-        {
-            vector3 t = d * direction;
-            transform3 trf(t, z, x);
-            return_surfaces.push_back(surface_base<transform3>{std::move(trf), 0, 0, false});
-        }
-        return return_surfaces;
+using transform3 = __plugin::transform3;
+using point3 = point3;
+using vector3 = vector3;
+
+using binned_neighborhood = darray<darray<dindex, 2>, 2>;
+
+/** This method creates a number (distances.size()) planes along a direction
+ */
+dvector<surface_base<transform3>> planes_along_direction(
+    dvector<scalar> distances, vector3 direction) {
+    // Rotation matrix
+    vector3 z = direction;
+    vector3 x = normalize(vector3{0, -z[2], z[1]});
+
+    dvector<surface_base<transform3>> return_surfaces;
+    return_surfaces.reserve(distances.size());
+    for (auto &d : distances) {
+        vector3 t = d * direction;
+        transform3 trf(t, z, x);
+        return_surfaces.push_back(
+            surface_base<transform3>{std::move(trf), 0, 0, false});
+    }
+    return return_surfaces;
+}
+
+using cylinder_point2 = __plugin::point2;
+using disc_point2 = __plugin::point2;
+using endcap_surface_finder = std::function<dvector<dindex>(
+    const disc_point2 &, const binned_neighborhood &)>;
+
+/** This method creates a barrel description of surfaces
+ *
+ * @param inner_r The inner radius of the endcap disc
+ * @param outer_r The outer radius of the endcap disc
+ * @param pos_z The nominal z position of the endcap disc
+ * @param stagger_z The possible staggering in z
+ * @param n_phi The number of modules in phi
+ * @param overlap_phi The overlap in phi coverage (approximated)
+ * @param volume_inner_r the volume inner radius for the local finder
+ * @param volume_outer_r the volume outer radius for the local finder
+ * @param volumer_min_z the volume minimum z
+ * @param volume_max_z the volume maximumz
+ * @param transform_offset The offset for the transform grid
+ *
+ * @returns a tuple for rectangle descriptions and transforms
+ */
+dtuple<darray<scalar, 3>, dvector<transform3>, dvector<endcap_surface_finder>>
+create_endcap_components(scalar inner_r, scalar outer_r, scalar pos_z,
+                         scalar stagger_z, unsigned int n_phi,
+                         scalar overlap_phi, scalar volume_inner_r,
+                         scalar volume_outer_r, scalar volume_min_z,
+                         scalar volume_max_z,
+                         unsigned int transform_offset = 0) {
+    scalar module_inner_lx = 2. * inner_r * M_PI * (1. + overlap_phi) / (n_phi);
+    scalar module_outer_lx = 2. * outer_r * M_PI * (1. + overlap_phi) / (n_phi);
+    scalar module_hy = 0.5 * (outer_r - inner_r);
+
+    darray<scalar, 3> trapezoid_values = {
+        static_cast<scalar>(0.5 * module_inner_lx),
+        static_cast<scalar>(0.5 * module_outer_lx), module_hy};
+    scalar step_phi = 2 * M_PI / n_phi;
+    dvector<transform3> transforms;
+
+    // Prepare the local finders
+    replace_populator<> replacer;
+    serializer2 serializer;
+
+    // Declare the inner, outer, ecn, ecp object finder
+    axis::circular<> rphi_axis_inner = {
+        n_phi, static_cast<scalar>(-volume_inner_r * (M_PI + 0.5 * step_phi)),
+        static_cast<scalar>(volume_inner_r * (M_PI - 0.5 * step_phi))};
+    axis::regular<> z_axis_inner = {1, volume_min_z, volume_max_z};
+    axis::circular<> rphi_axis_outer = {
+        n_phi, static_cast<scalar>(-volume_outer_r * (M_PI + 0.5 * step_phi)),
+        static_cast<scalar>(volume_outer_r * (M_PI - 0.5 * step_phi))};
+    axis::regular<> z_axis_outer = {1, volume_min_z, volume_max_z};
+    axis::regular<> r_axis_ecn = {1, volume_inner_r, volume_outer_r};
+    axis::circular<> phi_axis_ecn = {
+        n_phi, static_cast<scalar>(-M_PI - 0.5 * step_phi),
+        static_cast<scalar>(M_PI - 0.5 * step_phi)};
+    axis::regular<> r_axis_ecp = {1, volume_inner_r, volume_outer_r};
+    axis::circular<> phi_axis_ecp = {
+        n_phi, static_cast<scalar>(-M_PI - 0.5 * step_phi),
+        static_cast<scalar>(M_PI - 0.5 * step_phi)};
+
+    using cylinder_grid = grid2<decltype(replacer), decltype(rphi_axis_inner),
+                                decltype(z_axis_inner), decltype(serializer)>;
+    using disc_grid = grid2<decltype(replacer), decltype(r_axis_ecn),
+                            decltype(phi_axis_ecn), decltype(serializer)>;
+
+    cylinder_grid ec_grid_inner(std::move(rphi_axis_inner),
+                                std::move(z_axis_inner));
+    cylinder_grid ec_grid_outer(std::move(rphi_axis_outer),
+                                std::move(z_axis_inner));
+    disc_grid ec_grid_n(std::move(r_axis_ecn), std::move(phi_axis_ecn));
+    disc_grid ec_grid_p(std::move(r_axis_ecp), std::move(phi_axis_ecp));
+
+    scalar r = 0.5 * (inner_r + outer_r);
+
+    for (unsigned int iphi = 0; iphi < n_phi; ++iphi) {
+        scalar phi = -M_PI + iphi * step_phi;
+
+        // Populate the grids
+        ec_grid_inner.populate(cylinder_point2{volume_inner_r * phi, pos_z},
+                               transforms.size() + transform_offset);
+        ec_grid_outer.populate(cylinder_point2{volume_outer_r * phi, pos_z},
+                               transforms.size() + transform_offset);
+        ec_grid_n.populate(disc_point2{r, phi},
+                           transforms.size() + transform_offset);
+        ec_grid_p.populate(disc_point2{r, phi},
+                           transforms.size() + transform_offset);
+
+        scalar z_addon = (iphi % 2) ? -stagger_z : stagger_z;
+        scalar cos_phi = std::cos(phi);
+        scalar sin_phi = std::sin(phi);
+        point3 p = {r * cos_phi, r * sin_phi, pos_z + z_addon};
+        vector3 z = {0., 0., 1.};
+        vector3 x = {sin_phi, -cos_phi, 0.};
+        transforms.push_back(transform3(p, z, x));
     }
 
-    using cylinder_point2 = __plugin::point2;
-    using disc_point2 = __plugin::point2;
-    using endcap_surface_finder = std::function<dvector<dindex>(const disc_point2 &, const binned_neighborhood &)>;
-
-    /** This method creates a barrel description of surfaces
-     * 
-     * @param inner_r The inner radius of the endcap disc
-     * @param outer_r The outer radius of the endcap disc
-     * @param pos_z The nominal z position of the endcap disc
-     * @param stagger_z The possible staggering in z 
-     * @param n_phi The number of modules in phi
-     * @param overlap_phi The overlap in phi coverage (approximated)
-     * @param volume_inner_r the volume inner radius for the local finder
-     * @param volume_outer_r the volume outer radius for the local finder
-     * @param volumer_min_z the volume minimum z
-     * @param volume_max_z the volume maximumz
-     * @param transform_offset The offset for the transform grid
-     * 
-     * @returns a tuple for rectangle descriptions and transforms
-     */
-    dtuple<darray<scalar, 3>, dvector<transform3>, dvector<endcap_surface_finder>>
-    create_endcap_components(scalar inner_r,
-                             scalar outer_r,
-                             scalar pos_z,
-                             scalar stagger_z,
-                             unsigned int n_phi,
-                             scalar overlap_phi,
-                             scalar volume_inner_r,
-                             scalar volume_outer_r,
-                             scalar volume_min_z,
-                             scalar volume_max_z,
-                             unsigned int transform_offset = 0)
-    {
-        scalar module_inner_lx = 2. * inner_r * M_PI * (1. + overlap_phi) / (n_phi);
-        scalar module_outer_lx = 2. * outer_r * M_PI * (1. + overlap_phi) / (n_phi);
-        scalar module_hy = 0.5 * (outer_r - inner_r);
-
-        darray<scalar, 3> trapezoid_values = {static_cast<scalar>(0.5 * module_inner_lx), static_cast<scalar>(0.5 * module_outer_lx), module_hy};
-        scalar step_phi = 2 * M_PI / n_phi;
-        dvector<transform3> transforms;
-
-        // Prepare the local finders
-        replace_populator<> replacer;
-        serializer2 serializer;
-
-        // Declare the inner, outer, ecn, ecp object finder
-        axis::circular<> rphi_axis_inner = {n_phi,
-                                          static_cast<scalar>(-volume_inner_r * (M_PI + 0.5 * step_phi)),
-                                          static_cast<scalar>(volume_inner_r * (M_PI - 0.5 * step_phi))};
-        axis::regular<> z_axis_inner = {1, volume_min_z, volume_max_z};
-        axis::circular<> rphi_axis_outer = {n_phi,
-                                          static_cast<scalar>(-volume_outer_r * (M_PI + 0.5 * step_phi)),
-                                          static_cast<scalar>(volume_outer_r * (M_PI - 0.5 * step_phi))};
-        axis::regular<> z_axis_outer = {1, volume_min_z, volume_max_z};
-        axis::regular<> r_axis_ecn = {1, volume_inner_r, volume_outer_r};
-        axis::circular<> phi_axis_ecn = {n_phi,
-                                       static_cast<scalar>(-M_PI - 0.5 * step_phi),
-                                       static_cast<scalar>(M_PI - 0.5 * step_phi)};
-        axis::regular<> r_axis_ecp = {1, volume_inner_r, volume_outer_r};
-        axis::circular<> phi_axis_ecp = {n_phi,
-                                       static_cast<scalar>(-M_PI - 0.5 * step_phi),
-                                       static_cast<scalar>(M_PI - 0.5 * step_phi)};
-
-        using cylinder_grid = grid2<decltype(replacer), decltype(rphi_axis_inner), decltype(z_axis_inner), decltype(serializer)>;
-        using disc_grid = grid2<decltype(replacer), decltype(r_axis_ecn), decltype(phi_axis_ecn), decltype(serializer)>;
-
-        cylinder_grid ec_grid_inner(std::move(rphi_axis_inner), std::move(z_axis_inner));
-        cylinder_grid ec_grid_outer(std::move(rphi_axis_outer), std::move(z_axis_inner));
-        disc_grid ec_grid_n(std::move(r_axis_ecn), std::move(phi_axis_ecn));
-        disc_grid ec_grid_p(std::move(r_axis_ecp), std::move(phi_axis_ecp));
-
-        scalar r = 0.5 * (inner_r + outer_r);
-
-        for (unsigned int iphi = 0; iphi < n_phi; ++iphi)
-        {
+    local_zone_finder<cylinder_grid> inner_finder(std::move(ec_grid_inner));
+    local_zone_finder<cylinder_grid> outer_finder(std::move(ec_grid_outer));
+    local_zone_finder<disc_grid> ecn_finder(std::move(ec_grid_n));
+    local_zone_finder<disc_grid> ecp_finder(std::move(ec_grid_p));
+
+    return {trapezoid_values,
+            transforms,
+            {inner_finder, outer_finder, ecn_finder, ecp_finder}};
+}
+
+using barrel_surface_finder = std::function<dvector<dindex>(
+    const cylinder_point2 &, const binned_neighborhood &)>;
+
+/** This method creates a barrel description of surfaces
+ *
+ * @param r The radius of the barrel cylinder
+ * @param stagger_r The (optional) staggering in r
+ * @param n_phi The number of modules in phi
+ * @param tilt_phi The tilt of the modules in phi
+ * @param overlap_rphi The overlap in rphi coverage (approximated)
+ * @param length_z The length of the (sensitive) barrel in z
+ * @param overlap_z The (optional) staggering in z
+ * @param volume_inner_r The volume inner r
+ * @param volume_outer_r The volume outer r
+ * @param volume_length_z The volume half length
+ * @param transform_offset The offset for the transform grid
+ *
+ * @returns a tuple for rectangle descriptions, transforms, object finders
+ */
+dtuple<darray<scalar, 2>, dvector<transform3>, dvector<barrel_surface_finder>>
+create_barrel_components(scalar r, scalar stagger_r, unsigned int n_phi,
+                         scalar tilt_phi, scalar overlap_rphi, scalar length_z,
+                         scalar overlap_z, unsigned int n_z,
+                         scalar volume_inner_r, scalar volume_outer_r,
+                         scalar volume_half_z,
+                         unsigned int transform_offset = 0) {
+    // Estimate module dimensions
+    scalar module_lx = 2 * r * M_PI * (1 + overlap_rphi) / n_phi;
+    scalar module_ly = (length_z + (n_z - 1) * overlap_z) / n_z;
+    darray<scalar, 2> rectangle_bounds = {static_cast<scalar>(0.5 * module_lx),
+                                          static_cast<scalar>(0.5 * module_ly)};
+
+    // Prepare the local finders
+    replace_populator<> replacer;
+    serializer2 serializer;
+
+    // The detector transforms
+    dvector<transform3> transforms;
+    scalar step_phi = 2 * M_PI / n_phi;
+    scalar step_z = module_ly - overlap_z;
+    scalar start_z = -0.5 * (n_z - 1) * (module_ly - overlap_z);
+
+    // Declare the inner, outer, ecn, ecp object finder
+    axis::circular<> rphi_axis_inner = {
+        n_phi, static_cast<scalar>(-volume_inner_r * (M_PI + 0.5 * step_phi)),
+        static_cast<scalar>(volume_inner_r * (M_PI - 0.5 * step_phi))};
+    axis::regular<> z_axis_inner = {n_z, static_cast<scalar>(-0.5 * length_z),
+                                    static_cast<scalar>(0.5 * length_z)};
+    axis::circular<> rphi_axis_outer = {
+        n_phi, static_cast<scalar>(-volume_outer_r * (M_PI + 0.5 * step_phi)),
+        static_cast<scalar>(volume_outer_r * (M_PI - 0.5 * step_phi))};
+    axis::regular<> z_axis_outer = {n_z, static_cast<scalar>(-0.5 * length_z),
+                                    static_cast<scalar>(0.5 * length_z)};
+    axis::regular<> r_axis_ecn = {1, volume_inner_r, volume_outer_r};
+    axis::circular<> phi_axis_ecn = {
+        n_phi, static_cast<scalar>(-M_PI - 0.5 * step_phi),
+        static_cast<scalar>(M_PI - 0.5 * step_phi)};
+    axis::regular<> r_axis_ecp = {1, volume_inner_r, volume_outer_r};
+    axis::circular<> phi_axis_ecp = {
+        n_phi, static_cast<scalar>(-M_PI - 0.5 * step_phi),
+        static_cast<scalar>(M_PI - 0.5 * step_phi)};
+
+    using cylinder_grid = grid2<decltype(replacer), decltype(rphi_axis_inner),
+                                decltype(z_axis_inner), decltype(serializer)>;
+    using disc_grid = grid2<decltype(replacer), decltype(r_axis_ecn),
+                            decltype(phi_axis_ecn), decltype(serializer)>;
+
+    cylinder_grid barrel_grid_inner(std::move(rphi_axis_inner),
+                                    std::move(z_axis_inner));
+    cylinder_grid barrel_grid_outer(std::move(rphi_axis_outer),
+                                    std::move(z_axis_inner));
+    disc_grid barrel_grid_n(std::move(r_axis_ecn), std::move(phi_axis_ecn));
+    disc_grid barrel_grid_p(std::move(r_axis_ecp), std::move(phi_axis_ecp));
+
+    for (unsigned int iz = 0; iz < n_z; ++iz) {
+        scalar pos_z = start_z + iz * step_z;
+        for (unsigned int iphi = 0; iphi < n_phi; ++iphi) {
             scalar phi = -M_PI + iphi * step_phi;
-
             // Populate the grids
-            ec_grid_inner.populate(cylinder_point2{volume_inner_r * phi, pos_z}, transforms.size() + transform_offset);
-            ec_grid_outer.populate(cylinder_point2{volume_outer_r * phi, pos_z}, transforms.size() + transform_offset);
-            ec_grid_n.populate(disc_point2{r, phi}, transforms.size() + transform_offset);
-            ec_grid_p.populate(disc_point2{r, phi}, transforms.size() + transform_offset);
-
-            scalar z_addon = (iphi % 2) ? -stagger_z : stagger_z;
-            scalar cos_phi = std::cos(phi);
-            scalar sin_phi = std::sin(phi);
-            point3 p = {r * cos_phi, r * sin_phi, pos_z + z_addon};
-            vector3 z = {0., 0., 1.};
-            vector3 x = {sin_phi, -cos_phi, 0.};
+            barrel_grid_inner.populate(
+                cylinder_point2{volume_inner_r * phi, pos_z},
+                transforms.size() + transform_offset);
+            barrel_grid_outer.populate(
+                cylinder_point2{volume_outer_r * phi, pos_z},
+                transforms.size() + transform_offset);
+            if (iz == 0) {
+                barrel_grid_n.populate(disc_point2{r, phi},
+                                       transforms.size() + transform_offset);
+            }
+            if (iz == n_z - 1) {
+                barrel_grid_p.populate(disc_point2{r, phi},
+                                       transforms.size() + transform_offset);
+            }
+            // Finally create the transform
+            scalar r_addon = (iz % 2) ? -stagger_r : stagger_r;
+            point3 p = {(r + r_addon) * std::cos(phi),
+                        (r + r_addon) * std::sin(phi), pos_z};
+            vector3 z = {std::cos(phi + tilt_phi), std::sin(phi + tilt_phi),
+                         0.};
+            vector3 x = {z[1], -z[0], 0.};
             transforms.push_back(transform3(p, z, x));
         }
-
-        local_zone_finder<cylinder_grid> inner_finder(std::move(ec_grid_inner));
-        local_zone_finder<cylinder_grid> outer_finder(std::move(ec_grid_outer));
-        local_zone_finder<disc_grid> ecn_finder(std::move(ec_grid_n));
-        local_zone_finder<disc_grid> ecp_finder(std::move(ec_grid_p));
-
-        return {trapezoid_values, transforms, {inner_finder, outer_finder, ecn_finder, ecp_finder}};
     }
 
-    using barrel_surface_finder = std::function<dvector<dindex>(const cylinder_point2 &, const binned_neighborhood &)>;
-
-    /** This method creates a barrel description of surfaces
-     * 
-     * @param r The radius of the barrel cylinder
-     * @param stagger_r The (optional) staggering in r
-     * @param n_phi The number of modules in phi
-     * @param tilt_phi The tilt of the modules in phi
-     * @param overlap_rphi The overlap in rphi coverage (approximated)
-     * @param length_z The length of the (sensitive) barrel in z
-     * @param overlap_z The (optional) staggering in z
-     * @param volume_inner_r The volume inner r
-     * @param volume_outer_r The volume outer r
-     * @param volume_length_z The volume half length
-     * @param transform_offset The offset for the transform grid
-     * 
-     * @returns a tuple for rectangle descriptions, transforms, object finders
-     */
-    dtuple<darray<scalar, 2>, dvector<transform3>, dvector<barrel_surface_finder>>
-    create_barrel_components(scalar r,
-                             scalar stagger_r,
-                             unsigned int n_phi,
-                             scalar tilt_phi,
-                             scalar overlap_rphi,
-                             scalar length_z,
-                             scalar overlap_z,
-                             unsigned int n_z,
-                             scalar volume_inner_r,
-                             scalar volume_outer_r,
-                             scalar volume_half_z,
-                             unsigned int transform_offset = 0)
-    {
-        // Estimate module dimensions
-        scalar module_lx = 2 * r * M_PI * (1 + overlap_rphi) / n_phi;
-        scalar module_ly = (length_z + (n_z - 1) * overlap_z) / n_z;
-        darray<scalar, 2> rectangle_bounds = {static_cast<scalar>(0.5 * module_lx), static_cast<scalar>(0.5 * module_ly)};
-
-        // Prepare the local finders
-        replace_populator<> replacer;
-        serializer2 serializer;
-
-        // The detector transforms
-        dvector<transform3> transforms;
-        scalar step_phi = 2 * M_PI / n_phi;
-        scalar step_z = module_ly - overlap_z;
-        scalar start_z = -0.5 * (n_z - 1) * (module_ly - overlap_z);
-
-        // Declare the inner, outer, ecn, ecp object finder
-        axis::circular<> rphi_axis_inner = {n_phi,
-                                          static_cast<scalar>(-volume_inner_r * (M_PI + 0.5 * step_phi)),
-                                          static_cast<scalar>(volume_inner_r * (M_PI - 0.5 * step_phi))};
-        axis::regular<> z_axis_inner = {n_z, static_cast<scalar>(-0.5 * length_z), static_cast<scalar>(0.5 * length_z)};
-        axis::circular<> rphi_axis_outer = {n_phi,
-                                          static_cast<scalar>(-volume_outer_r * (M_PI + 0.5 * step_phi)),
-                                          static_cast<scalar>(volume_outer_r * (M_PI - 0.5 * step_phi))};
-        axis::regular<> z_axis_outer = {n_z, static_cast<scalar>(-0.5 * length_z), static_cast<scalar>(0.5 * length_z)};
-        axis::regular<> r_axis_ecn = {1, volume_inner_r, volume_outer_r};
-        axis::circular<> phi_axis_ecn = {n_phi,
-                                       static_cast<scalar>(-M_PI - 0.5 * step_phi),
-                                       static_cast<scalar>(M_PI - 0.5 * step_phi)};
-        axis::regular<> r_axis_ecp = {1, volume_inner_r, volume_outer_r};
-        axis::circular<> phi_axis_ecp = {n_phi,
-                                       static_cast<scalar>(-M_PI - 0.5 * step_phi),
-                                       static_cast<scalar>(M_PI - 0.5 * step_phi)};
-
-        using cylinder_grid = grid2<decltype(replacer), decltype(rphi_axis_inner), decltype(z_axis_inner), decltype(serializer)>;
-        using disc_grid = grid2<decltype(replacer), decltype(r_axis_ecn), decltype(phi_axis_ecn), decltype(serializer)>;
-
-        cylinder_grid barrel_grid_inner(std::move(rphi_axis_inner), std::move(z_axis_inner));
-        cylinder_grid barrel_grid_outer(std::move(rphi_axis_outer), std::move(z_axis_inner));
-        disc_grid barrel_grid_n(std::move(r_axis_ecn), std::move(phi_axis_ecn));
-        disc_grid barrel_grid_p(std::move(r_axis_ecp), std::move(phi_axis_ecp));
-
-        for (unsigned int iz = 0; iz < n_z; ++iz)
-        {
-            scalar pos_z = start_z + iz * step_z;
-            for (unsigned int iphi = 0; iphi < n_phi; ++iphi)
-            {
-                scalar phi = -M_PI + iphi * step_phi;
-                // Populate the grids
-                barrel_grid_inner.populate(cylinder_point2{volume_inner_r * phi, pos_z}, transforms.size() + transform_offset);
-                barrel_grid_outer.populate(cylinder_point2{volume_outer_r * phi, pos_z}, transforms.size() + transform_offset);
-                if (iz == 0)
-                {
-                    barrel_grid_n.populate(disc_point2{r, phi}, transforms.size() + transform_offset);
-                }
-                if (iz == n_z - 1)
-                {
-                    barrel_grid_p.populate(disc_point2{r, phi}, transforms.size() + transform_offset);
-                }
-                // Finally create the transform
-                scalar r_addon = (iz % 2) ? -stagger_r : stagger_r;
-                point3 p = {(r + r_addon) * std::cos(phi), (r + r_addon) * std::sin(phi), pos_z};
-                vector3 z = {std::cos(phi + tilt_phi), std::sin(phi + tilt_phi), 0.};
-                vector3 x = {z[1], -z[0], 0.};
-                transforms.push_back(transform3(p, z, x));
-            }
-        }
-
-        local_zone_finder<cylinder_grid> inner_finder(std::move(barrel_grid_inner));
-        local_zone_finder<cylinder_grid> outer_finder(std::move(barrel_grid_outer));
-        local_zone_finder<disc_grid> ecn_finder(std::move(barrel_grid_n));
-        local_zone_finder<disc_grid> ecp_finder(std::move(barrel_grid_p));
+    local_zone_finder<cylinder_grid> inner_finder(std::move(barrel_grid_inner));
+    local_zone_finder<cylinder_grid> outer_finder(std::move(barrel_grid_outer));
+    local_zone_finder<disc_grid> ecn_finder(std::move(barrel_grid_n));
+    local_zone_finder<disc_grid> ecp_finder(std::move(barrel_grid_p));
 
-        return {rectangle_bounds, transforms, {inner_finder, outer_finder, ecn_finder, ecp_finder}};
-    }
+    return {rectangle_bounds,
+            transforms,
+            {inner_finder, outer_finder, ecn_finder, ecp_finder}};
+}
 
-} // namespace detray
+}  // namespace detray
diff --git a/tests/common/include/tests/common/tools_cylinder_intersection.inl b/tests/common/include/tests/common/tools_cylinder_intersection.inl
index 8321dc32ce..a05ecf91fa 100644
--- a/tests/common/include/tests/common/tools_cylinder_intersection.inl
+++ b/tests/common/include/tests/common/tools_cylinder_intersection.inl
@@ -1,10 +1,15 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+#include <gtest/gtest.h>
+
+#include <climits>
+#include <cmath>
+
 #include "core/intersection.hpp"
 #include "core/surface_base.hpp"
 #include "masks/cylinder3.hpp"
@@ -12,11 +17,6 @@
 #include "tools/cylinder_intersector.hpp"
 #include "utils/unbound.hpp"
 
-#include <cmath>
-#include <climits>
-
-#include <gtest/gtest.h>
-
 /// @note __plugin has to be defined with a preprocessor command
 using namespace detray;
 
@@ -30,8 +30,7 @@ constexpr scalar not_defined = std::numeric_limits<scalar>::infinity();
 constexpr scalar isclose = 1e-5;
 
 // This defines the local frame test suite
-TEST(ALGEBRA_PLUGIN, translated_cylinder)
-{
+TEST(ALGEBRA_PLUGIN, translated_cylinder) {
     // Create a translated cylinder and test untersection
     transform3 shifted(vector3{3., 2., 10.});
     cylinder3<> cylinder = {4., -10., 10.};
@@ -39,30 +38,31 @@ TEST(ALGEBRA_PLUGIN, translated_cylinder)
 
     // Unbound local frame test
     unbound ub;
-    auto hit_unbound = ci.intersect(shifted, point3{3., 2., 5.}, vector3{1., 0., 0.}, ub, cylinder);
-    ASSERT_TRUE(hit_unbound.status== intersection_status::e_inside);
+    auto hit_unbound = ci.intersect(shifted, point3{3., 2., 5.},
+                                    vector3{1., 0., 0.}, ub, cylinder);
+    ASSERT_TRUE(hit_unbound.status == intersection_status::e_inside);
     ASSERT_NEAR(hit_unbound.p3[0], 7., epsilon);
     ASSERT_NEAR(hit_unbound.p3[1], 2., epsilon);
     ASSERT_NEAR(hit_unbound.p3[2], 5., epsilon);
-    ASSERT_TRUE(hit_unbound.p2[0] == not_defined
-                && hit_unbound.p2[1] == not_defined);
+    ASSERT_TRUE(hit_unbound.p2[0] == not_defined &&
+                hit_unbound.p2[1] == not_defined);
 
     // The same but bound
     __plugin::cylindrical2 cylindrical2;
-    auto hit_bound = ci.intersect(shifted, point3{3., 2., 5.}, vector3{1., 0., 0.}, cylindrical2, cylinder);
-    ASSERT_TRUE(hit_bound.status== intersection_status::e_inside);
+    auto hit_bound = ci.intersect(shifted, point3{3., 2., 5.},
+                                  vector3{1., 0., 0.}, cylindrical2, cylinder);
+    ASSERT_TRUE(hit_bound.status == intersection_status::e_inside);
     ASSERT_NEAR(hit_bound.p3[0], 7., epsilon);
     ASSERT_NEAR(hit_bound.p3[1], 2., epsilon);
     ASSERT_NEAR(hit_bound.p3[2], 5., epsilon);
-    ASSERT_TRUE(hit_bound.p2[0] != not_defined
-                && hit_bound.p2[1] != not_defined);
+    ASSERT_TRUE(hit_bound.p2[0] != not_defined &&
+                hit_bound.p2[1] != not_defined);
     ASSERT_NEAR(hit_bound.p2[0], 0., isclose);
     ASSERT_NEAR(hit_bound.p2[1], -5., isclose);
 }
 
 // This defines the local frame test suite
-TEST(ALGEBRA_PLUGIN, concentric_cylinders)
-{
+TEST(ALGEBRA_PLUGIN, concentric_cylinders) {
     using cylinder_surface = surface_base<transform3, int, int>;
 
     // Create a concentric cylinder and test intersection
@@ -78,11 +78,13 @@ TEST(ALGEBRA_PLUGIN, concentric_cylinders)
 
     // The same but bound
     __plugin::cylindrical2 cylindrical2;
-    auto hit_cylinrical = ci.intersect(identity, ori, dir, cylindrical2, cylinder);
-    auto hit_cocylindrical = cci.intersect(identity, ori, dir, cylindrical2, cylinder);
+    auto hit_cylinrical =
+        ci.intersect(identity, ori, dir, cylindrical2, cylinder);
+    auto hit_cocylindrical =
+        cci.intersect(identity, ori, dir, cylindrical2, cylinder);
 
-    ASSERT_TRUE(hit_cylinrical.status== intersection_status::e_inside);
-    ASSERT_TRUE(hit_cocylindrical.status== intersection_status::e_inside);
+    ASSERT_TRUE(hit_cylinrical.status == intersection_status::e_inside);
+    ASSERT_TRUE(hit_cocylindrical.status == intersection_status::e_inside);
     ASSERT_TRUE(hit_cylinrical.direction == intersection_direction::e_along);
     ASSERT_TRUE(hit_cocylindrical.direction == intersection_direction::e_along);
 
@@ -92,17 +94,15 @@ TEST(ALGEBRA_PLUGIN, concentric_cylinders)
     ASSERT_NEAR(hit_cylinrical.p3[0], hit_cocylindrical.p3[0], isclose);
     ASSERT_NEAR(hit_cylinrical.p3[1], hit_cocylindrical.p3[1], isclose);
     ASSERT_NEAR(hit_cylinrical.p3[2], hit_cocylindrical.p3[2], isclose);
-    ASSERT_TRUE(hit_cylinrical.p2[0] != not_defined
-                && hit_cylinrical.p2[1] != not_defined);
-    ASSERT_TRUE(hit_cocylindrical.p2[0] != not_defined
-                && hit_cocylindrical.p2[1] != not_defined);
+    ASSERT_TRUE(hit_cylinrical.p2[0] != not_defined &&
+                hit_cylinrical.p2[1] != not_defined);
+    ASSERT_TRUE(hit_cocylindrical.p2[0] != not_defined &&
+                hit_cocylindrical.p2[1] != not_defined);
     ASSERT_NEAR(hit_cylinrical.p2[0], hit_cocylindrical.p2[0], isclose);
     ASSERT_NEAR(hit_cylinrical.p2[1], hit_cocylindrical.p2[1], isclose);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/tools_intersection_kernel.inl b/tests/common/include/tests/common/tools_intersection_kernel.inl
index 3f47d2e937..bae8137cf1 100644
--- a/tests/common/include/tests/common/tools_intersection_kernel.inl
+++ b/tests/common/include/tests/common/tools_intersection_kernel.inl
@@ -1,48 +1,53 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+#include <gtest/gtest.h>
+
 #include "core/surface_base.hpp"
 #include "core/track.hpp"
 #include "core/transform_store.hpp"
 #include "masks/masks.hpp"
+#include "tools/concentric_cylinder_intersector.hpp"
+#include "tools/cylinder_intersector.hpp"
 #include "tools/intersection_kernel.hpp"
 #include "tools/planar_intersector.hpp"
-#include "tools/cylinder_intersector.hpp"
-#include "tools/concentric_cylinder_intersector.hpp"
 #include "utils/enumerate.hpp"
 
-#include <gtest/gtest.h>
-
 using namespace detray;
 using namespace __plugin;
 
 // This tests the construction of a surface
-TEST(tools, intersection_kernel_single)
-{
+TEST(tools, intersection_kernel_single) {
     /// Surface components:
     using mask_link = darray<dindex, 1>;
     using surface_link = dindex;
     /// - masks, with mask identifiers 0,1,2
-    using surface_rectangle = rectangle2<planar_intersector, __plugin::cartesian2, mask_link, 0>;
-    using surface_trapezoid = trapezoid2<planar_intersector, __plugin::cartesian2, mask_link, 1>;
-    using surface_annulus = annulus2<planar_intersector, __plugin::cartesian2, mask_link, 2>;
-    using surface_cylinder = cylinder3<false, cylinder_intersector, __plugin::cylindrical2, mask_link, 3>;
-    using surface_concentric_cylinder = cylinder3<false, concentric_cylinder_intersector<>, __plugin::cylindrical2, mask_link, 4>;
+    using surface_rectangle =
+        rectangle2<planar_intersector, __plugin::cartesian2, mask_link, 0>;
+    using surface_trapezoid =
+        trapezoid2<planar_intersector, __plugin::cartesian2, mask_link, 1>;
+    using surface_annulus =
+        annulus2<planar_intersector, __plugin::cartesian2, mask_link, 2>;
+    using surface_cylinder = cylinder3<false, cylinder_intersector,
+                                       __plugin::cylindrical2, mask_link, 3>;
+    using surface_concentric_cylinder =
+        cylinder3<false, concentric_cylinder_intersector<>,
+                  __plugin::cylindrical2, mask_link, 4>;
     /// - mask index: type, entry
     using surface_mask_index = darray<dindex, 2>;
-    using surface_mask_container = dtuple<dvector<surface_rectangle>,
-                                          dvector<surface_trapezoid>,
-                                          dvector<surface_annulus>,
-                                          dvector<surface_cylinder>,
-                                          dvector<surface_concentric_cylinder>>;
+    using surface_mask_container =
+        dtuple<dvector<surface_rectangle>, dvector<surface_trapezoid>,
+               dvector<surface_annulus>, dvector<surface_cylinder>,
+               dvector<surface_concentric_cylinder>>;
 
     /// The Surface definition:
     ///  <transform_link, mask_link, volume_link, source_link >
-    using surface = surface_base<dindex, surface_mask_index, dindex, surface_link>;
+    using surface =
+        surface_base<dindex, surface_mask_index, dindex, surface_link>;
     using surface_container = dvector<surface>;
 
     // The transforms & their store
@@ -66,7 +71,8 @@ TEST(tools, intersection_kernel_single)
     surface rectangle_surface(0u, {0, 0}, 0, 0);
     surface trapezoid_surface(1u, {1, 0}, 0, 1);
     surface annulus_surface(2u, {2, 0}, 0, 2);
-    surface_container surfaces = {rectangle_surface, trapezoid_surface, annulus_surface};
+    surface_container surfaces = {rectangle_surface, trapezoid_surface,
+                                  annulus_surface};
 
     // Try the intersection - first one by one
 
@@ -75,51 +81,57 @@ TEST(tools, intersection_kernel_single)
     track.dir = vector::normalize(vector3{0.01, 0.01, 10.});
 
     // Quick helper to check for within epsilon
-    auto within_epsilon = [](const point3 &a, const point3 &b, scalar epsilon) -> bool
-    {
-        return (std::abs(a[0] - b[0]) < epsilon && std::abs(a[1] - b[1]) < epsilon && std::abs(a[2] - b[2]) < epsilon);
+    auto within_epsilon = [](const point3 &a, const point3 &b,
+                             scalar epsilon) -> bool {
+        return (std::abs(a[0] - b[0]) < epsilon &&
+                std::abs(a[1] - b[1]) < epsilon &&
+                std::abs(a[2] - b[2]) < epsilon);
     };
 
     // Intersect the first surface
-    auto sfi_rectangle = intersect_by_group(
-        track, rectangle_transform, std::get<0>(mask_store), 0);
+    auto sfi_rectangle = intersect_by_group(track, rectangle_transform,
+                                            std::get<0>(mask_store), 0);
 
     point3 expected_rectangle{0.01, 0.01, 10.};
-    ASSERT_TRUE(within_epsilon(std::get<0>(sfi_rectangle).p3, expected_rectangle, 1e-7));
+    ASSERT_TRUE(within_epsilon(std::get<0>(sfi_rectangle).p3,
+                               expected_rectangle, 1e-7));
 
-    auto sfi_trapezoid = intersect_by_group(
-        track, trapezoid_transform, std::get<1>(mask_store), 0);
+    auto sfi_trapezoid = intersect_by_group(track, trapezoid_transform,
+                                            std::get<1>(mask_store), 0);
 
     point3 expected_trapezoid{0.02, 0.02, 20.};
-    ASSERT_TRUE(within_epsilon(std::get<0>(sfi_trapezoid).p3, expected_trapezoid, 1e-7));
+    ASSERT_TRUE(within_epsilon(std::get<0>(sfi_trapezoid).p3,
+                               expected_trapezoid, 1e-7));
 
-    auto sfi_annulus = intersect_by_group(
-        track, annulus_transform, std::get<2>(mask_store), 0);
+    auto sfi_annulus = intersect_by_group(track, annulus_transform,
+                                          std::get<2>(mask_store), 0);
 
     point3 expected_annulus{0.03, 0.03, 30.};
-    ASSERT_TRUE(within_epsilon(std::get<0>(sfi_annulus).p3, expected_annulus, 1e-7));
+    ASSERT_TRUE(
+        within_epsilon(std::get<0>(sfi_annulus).p3, expected_annulus, 1e-7));
 
-    std::vector<point3> expected_points = {expected_rectangle, expected_trapezoid, expected_annulus};
+    std::vector<point3> expected_points = {
+        expected_rectangle, expected_trapezoid, expected_annulus};
     std::vector<point3> result_points = {};
 
     // Try the intersection - with automated dispatching via the kernel
     unsigned int it = 0;
-    for (const auto &surface : surfaces)
-    {
-        auto sfi_surface = intersect(track, surface, transform_store, mask_store);
+    for (const auto &surface : surfaces) {
+        auto sfi_surface =
+            intersect(track, surface, transform_store, mask_store);
 
         const auto &sfi = std::get<0>(sfi_surface);
         result_points.push_back(sfi.p3);
 
-        ASSERT_TRUE(within_epsilon(result_points[it], expected_points[it], 1e-7));
+        ASSERT_TRUE(
+            within_epsilon(result_points[it], expected_points[it], 1e-7));
         ++it;
     }
 
     return;
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/tools_line_stepper.inl b/tests/common/include/tests/common/tools_line_stepper.inl
index acaa3a8858..fa11dfa6aa 100644
--- a/tests/common/include/tests/common/tools_line_stepper.inl
+++ b/tests/common/include/tests/common/tools_line_stepper.inl
@@ -1,21 +1,20 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+#include <gtest/gtest.h>
+
 #include "core/track.hpp"
 #include "core/transform_store.hpp"
 #include "tools/line_stepper.hpp"
 
-#include <gtest/gtest.h>
-
 /// @note __plugin has to be defined with a preprocessor command
 
 // This tests the base functionality of the line stepper
-TEST(ALGEBRA_PLUGIN, line_stepper)
-{
+TEST(ALGEBRA_PLUGIN, line_stepper) {
     using namespace detray;
     using namespace __plugin;
 
@@ -34,8 +33,8 @@ TEST(ALGEBRA_PLUGIN, line_stepper)
     bool heartbeat = lstepper.step(lstate, 10.);
     ASSERT_TRUE(heartbeat);
 
-    ASSERT_FLOAT_EQ(traj.pos[0],  10. / sqrt(2) );
-    ASSERT_FLOAT_EQ(traj.pos[1],  10. / sqrt(2) );
+    ASSERT_FLOAT_EQ(traj.pos[0], 10. / sqrt(2));
+    ASSERT_FLOAT_EQ(traj.pos[1], 10. / sqrt(2));
     ASSERT_FLOAT_EQ(traj.pos[2], 0.);
 
     // Step with limit
@@ -45,14 +44,10 @@ TEST(ALGEBRA_PLUGIN, line_stepper)
 
     heartbeat = lstepper.step(lstate, 10.);
     ASSERT_FALSE(heartbeat);
-
-
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
 }
-
diff --git a/tests/common/include/tests/common/tools_navigator.inl b/tests/common/include/tests/common/tools_navigator.inl
index 0967d9066e..29ff375c3b 100644
--- a/tests/common/include/tests/common/tools_navigator.inl
+++ b/tests/common/include/tests/common/tools_navigator.inl
@@ -1,38 +1,40 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+#include <gtest/gtest.h>
+
 #include "core/detector.hpp"
-#include "core/transform_store.hpp"
 #include "core/track.hpp"
+#include "core/transform_store.hpp"
 #include "io/csv_io.hpp"
 #include "tools/navigator.hpp"
 
-#include <gtest/gtest.h>
-
 /// @note __plugin has to be defined with a preprocessor command
 
 // This tests the construction and general methods of the navigator
-TEST(ALGEBRA_PLUGIN, navigator)
-{
+TEST(ALGEBRA_PLUGIN, navigator) {
     using namespace detray;
 
     auto env_d_d = std::getenv("DETRAY_TEST_DATA_DIR");
-    if (env_d_d == nullptr)
-    {
-        throw std::ios_base::failure("Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
+    if (env_d_d == nullptr) {
+        throw std::ios_base::failure(
+            "Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
     }
     auto data_directory = std::string(env_d_d);
 
     std::string surface_file = data_directory + std::string("tml.csv");
-    std::string layer_volume_file = data_directory + std::string("tml-layer-volumes.csv");
-    std::string surface_grid_file = data_directory + std::string("tml-surface-grids.csv");
+    std::string layer_volume_file =
+        data_directory + std::string("tml-layer-volumes.csv");
+    std::string surface_grid_file =
+        data_directory + std::string("tml-surface-grids.csv");
     std::string surface_grid_entries_file = "";
 
-    auto d = detector_from_csv<>("tml", surface_file, layer_volume_file, surface_grid_file, surface_grid_entries_file);
+    auto d = detector_from_csv<>("tml", surface_file, layer_volume_file,
+                                 surface_grid_file, surface_grid_entries_file);
 
     // Create the navigator
     using detray_navigator = navigator<decltype(d)>;
@@ -57,7 +59,8 @@ TEST(ALGEBRA_PLUGIN, navigator)
     // No portal candidates
     ASSERT_EQ(state.portal_kernel.candidates.size(), 0u);
     // You can not trust the state
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_no_trust);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_no_trust);
     // The status is unkown
     ASSERT_EQ(state.status, detray_navigator::navigation_status::e_unknown);
 
@@ -66,11 +69,13 @@ TEST(ALGEBRA_PLUGIN, navigator)
     // Test that the navigator has a heartbeat
     ASSERT_TRUE(heartbeat);
     // The status is towards surface
-    ASSERT_EQ(state.status, detray_navigator::navigation_status::e_towards_surface);
+    ASSERT_EQ(state.status,
+              detray_navigator::navigation_status::e_towards_surface);
     // Now the volume, surfaces are defined and are trust worthy
     ASSERT_EQ(state.volume_index, 0u);
     ASSERT_EQ(state.surface_kernel.candidates.size(), 1u);
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_full_trust);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_full_trust);
     ASSERT_TRUE(std::abs(state() - 19.) < 0.01);
     // Still no portals defined
     ASSERT_EQ(state.portal_kernel.candidates.size(), 0u);
@@ -80,10 +85,12 @@ TEST(ALGEBRA_PLUGIN, navigator)
     // Test that the navigator has a heartbeat
     ASSERT_TRUE(heartbeat);
     // The status remains: towards surface
-    ASSERT_EQ(state.status, detray_navigator::navigation_status::e_towards_surface);
+    ASSERT_EQ(state.status,
+              detray_navigator::navigation_status::e_towards_surface);
     ASSERT_EQ(state.volume_index, 0u);
     ASSERT_EQ(state.surface_kernel.candidates.size(), 1u);
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_full_trust);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_full_trust);
     ASSERT_TRUE(std::abs(state() - 19.) < 0.01);
 
     // Let's make half the step towards the surface
@@ -94,22 +101,26 @@ TEST(ALGEBRA_PLUGIN, navigator)
     // Test that the navigator has a heartbeat
     ASSERT_TRUE(heartbeat);
     // The status remains: towards surface
-    ASSERT_EQ(state.status, detray_navigator::navigation_status::e_towards_surface);
+    ASSERT_EQ(state.status,
+              detray_navigator::navigation_status::e_towards_surface);
     ASSERT_EQ(state.volume_index, 0u);
     ASSERT_EQ(state.surface_kernel.candidates.size(), 1u);
     ASSERT_TRUE(std::abs(state() - 9.5) < 0.01);
     // Trust level is restored
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_full_trust);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_full_trust);
 
     // Let's immediately target, nothing should change, as there is full trust
     heartbeat = n.target(state, traj);
     // Test that the navigator has a heartbeat
     ASSERT_TRUE(heartbeat);
     // The status remains: towards surface
-    ASSERT_EQ(state.status, detray_navigator::navigation_status::e_towards_surface);
+    ASSERT_EQ(state.status,
+              detray_navigator::navigation_status::e_towards_surface);
     ASSERT_EQ(state.volume_index, 0u);
     ASSERT_EQ(state.surface_kernel.candidates.size(), 1u);
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_full_trust);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_full_trust);
     ASSERT_TRUE(std::abs(state() - 9.5) < 0.01);
 
     // Now step onto the surface
@@ -128,7 +139,8 @@ TEST(ALGEBRA_PLUGIN, navigator)
     const auto &surface = d.surfaces()[state.current_index];
     // Kernel is exhaused, and trust level is gone
     ASSERT_EQ(state.surface_kernel.next, state.surface_kernel.candidates.end());
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_high_trust);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_high_trust);
 
     // New target call
     heartbeat = n.target(state, traj);
@@ -136,11 +148,13 @@ TEST(ALGEBRA_PLUGIN, navigator)
     ASSERT_TRUE(heartbeat);
 
     // The status is: towards portal
-    ASSERT_EQ(state.status, detray_navigator::navigation_status::e_towards_portal);
+    ASSERT_EQ(state.status,
+              detray_navigator::navigation_status::e_towards_portal);
     ASSERT_EQ(state.volume_index, 0u);
     ASSERT_EQ(state.surface_kernel.candidates.size(), 0u);
     ASSERT_EQ(state.portal_kernel.candidates.size(), 1u);
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_full_trust);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_full_trust);
 
     // Now step towards the portal
     traj.pos = traj.pos + state() * traj.dir;
@@ -153,14 +167,16 @@ TEST(ALGEBRA_PLUGIN, navigator)
     ASSERT_EQ(state.volume_index, 16u);
     ASSERT_EQ(state.surface_kernel.candidates.size(), 0u);
     ASSERT_EQ(state.portal_kernel.candidates.size(), 0u);
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_no_trust);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_no_trust);
 
     // Let's target now - new volume should be volume 16 and is empty
     heartbeat = n.target(state, traj);
     // Test that the navigator has a heartbeat
     ASSERT_TRUE(heartbeat);
 
-    ASSERT_EQ(state.status, detray_navigator::navigation_status::e_towards_portal);
+    ASSERT_EQ(state.status,
+              detray_navigator::navigation_status::e_towards_portal);
     ASSERT_EQ(state.volume_index, 16u);
     ASSERT_EQ(state.surface_kernel.candidates.size(), 0u);
 
@@ -175,7 +191,8 @@ TEST(ALGEBRA_PLUGIN, navigator)
     ASSERT_EQ(state.volume_index, 17u);
     ASSERT_EQ(state.surface_kernel.candidates.size(), 0u);
     ASSERT_EQ(state.portal_kernel.candidates.size(), 0u);
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_no_trust);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_no_trust);
 
     // Let's target now - new volume should be volume 17 and should not be empty
     heartbeat = n.target(state, traj);
@@ -184,14 +201,17 @@ TEST(ALGEBRA_PLUGIN, navigator)
 
     ASSERT_EQ(state.volume_index, 17u);
 
-    ASSERT_EQ(state.status, detray_navigator::navigation_status::e_towards_surface);
+    ASSERT_EQ(state.status,
+              detray_navigator::navigation_status::e_towards_surface);
     ASSERT_EQ(state.surface_kernel.candidates.size(), 4u);
-    ASSERT_EQ(std::distance(state.surface_kernel.next, state.surface_kernel.candidates.end()), 4u);
-    ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_full_trust);
+    ASSERT_EQ(std::distance(state.surface_kernel.next,
+                            state.surface_kernel.candidates.end()),
+              4u);
+    ASSERT_EQ(state.trust_level,
+              detray_navigator::navigation_trust_level::e_full_trust);
 
     // Intersect the remaining ones
-    for (unsigned int is = 0; is < 3; ++is)
-    {
+    for (unsigned int is = 0; is < 3; ++is) {
         // Step towards the surface
         traj.pos = traj.pos + state() * traj.dir;
         heartbeat = n.status(state, traj);
@@ -199,21 +219,29 @@ TEST(ALGEBRA_PLUGIN, navigator)
         ASSERT_TRUE(heartbeat);
 
         // The status is: on portal - points towards volume 17
-        ASSERT_EQ(state.status, detray_navigator::navigation_status::e_on_surface);
+        ASSERT_EQ(state.status,
+                  detray_navigator::navigation_status::e_on_surface);
         ASSERT_EQ(state.volume_index, 17u);
         // We should have switched by one
-        ASSERT_EQ(std::distance(state.surface_kernel.next, state.surface_kernel.candidates.end()), 3u - is);
-        ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_high_trust);
+        ASSERT_EQ(std::distance(state.surface_kernel.next,
+                                state.surface_kernel.candidates.end()),
+                  3u - is);
+        ASSERT_EQ(state.trust_level,
+                  detray_navigator::navigation_trust_level::e_high_trust);
 
         heartbeat = n.target(state, traj);
         // Test that the navigator has a heartbeat
         ASSERT_TRUE(heartbeat);
 
-        ASSERT_EQ(state.status, detray_navigator::navigation_status::e_towards_surface);
+        ASSERT_EQ(state.status,
+                  detray_navigator::navigation_status::e_towards_surface);
         ASSERT_EQ(state.volume_index, 17u);
         ASSERT_EQ(state.surface_kernel.candidates.size(), 4u);
-        ASSERT_EQ(std::distance(state.surface_kernel.next, state.surface_kernel.candidates.end()), 3u - is);
-        ASSERT_EQ(state.trust_level, detray_navigator::navigation_trust_level::e_full_trust);
+        ASSERT_EQ(std::distance(state.surface_kernel.next,
+                                state.surface_kernel.candidates.end()),
+                  3u - is);
+        ASSERT_EQ(state.trust_level,
+                  detray_navigator::navigation_trust_level::e_full_trust);
     }
 
     // Surface kernel is now exhausted, status call should invalidate
@@ -227,7 +255,8 @@ TEST(ALGEBRA_PLUGIN, navigator)
     // Test that the navigator has a heartbeat
     ASSERT_TRUE(heartbeat);
 
-    ASSERT_EQ(state.status, detray_navigator::navigation_status::e_towards_portal);
+    ASSERT_EQ(state.status,
+              detray_navigator::navigation_status::e_towards_portal);
 
     // Let's try to see if the heartbeat dies off at the end of world
     traj.pos = point3{1011, 0., 1355};
@@ -247,12 +276,12 @@ TEST(ALGEBRA_PLUGIN, navigator)
     traj.pos = traj.pos + late_state() * traj.dir;
     heartbeat = n.status(late_state, traj);
     // Test that the navigator has a heartbeat
-    ASSERT_EQ(late_state.status, detray_navigator::navigation_status::e_on_portal);
+    ASSERT_EQ(late_state.status,
+              detray_navigator::navigation_status::e_on_portal);
     ASSERT_TRUE(heartbeat);
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/tools_planar_intersection.inl b/tests/common/include/tests/common/tools_planar_intersection.inl
index 64c6e60172..9329b971ab 100644
--- a/tests/common/include/tests/common/tools_planar_intersection.inl
+++ b/tests/common/include/tests/common/tools_planar_intersection.inl
@@ -1,19 +1,18 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-#include "core/intersection.hpp"
-#include "masks/rectangle2.hpp"
-#include "tools/planar_intersector.hpp"
+#include <gtest/gtest.h>
 
-#include <cmath>
 #include <climits>
+#include <cmath>
 
-#include <gtest/gtest.h>
-
+#include "core/intersection.hpp"
+#include "masks/rectangle2.hpp"
+#include "tools/planar_intersector.hpp"
 
 /// @note __plugin has to be defined with a preprocessor command
 using namespace detray;
@@ -31,24 +30,25 @@ constexpr scalar not_defined = std::numeric_limits<scalar>::infinity();
 constexpr scalar isclose = 1e-5;
 
 // This defines the local frame test suite
-TEST(ALGEBRA_PLUGIN, translated_plane)
-{
+TEST(ALGEBRA_PLUGIN, translated_plane) {
     // Create a shifted plane
     transform3 shifted(vector3{3., 2., 10.});
     planar_intersector pi;
 
-    auto hit_unbound = pi.intersect(shifted, point3{2., 1., 0.}, vector3{0., 0., 1.});
+    auto hit_unbound =
+        pi.intersect(shifted, point3{2., 1., 0.}, vector3{0., 0., 1.});
     ASSERT_TRUE(hit_unbound.status == intersection_status::e_hit);
     ASSERT_TRUE(hit_unbound.direction == intersection_direction::e_along);
     // Global intersection information
     ASSERT_NEAR(hit_unbound.p3[0], 2., epsilon);
     ASSERT_NEAR(hit_unbound.p3[1], 1., epsilon);
     ASSERT_NEAR(hit_unbound.p3[2], 10., epsilon);
-    ASSERT_TRUE(hit_unbound.p2[0] == not_defined
-                && hit_unbound.p2[1] == not_defined);
+    ASSERT_TRUE(hit_unbound.p2[0] == not_defined &&
+                hit_unbound.p2[1] == not_defined);
 
     // The same test but bound to local frame
-    auto hit_bound = pi.intersect(shifted, point3{2., 1., 0.}, vector3{0., 0., 1.}, cartesian2);
+    auto hit_bound = pi.intersect(shifted, point3{2., 1., 0.},
+                                  vector3{0., 0., 1.}, cartesian2);
     ASSERT_TRUE(hit_bound.status == intersection_status::e_hit);
     // Global intersection information - unchanged
     ASSERT_NEAR(hit_bound.p3[0], 2., epsilon);
@@ -60,7 +60,9 @@ TEST(ALGEBRA_PLUGIN, translated_plane)
 
     // The same test but bound to local frame & masked - inside
     rectangle2<> rect_for_inside = {3., 3.};
-    auto hit_bound_inside = pi.intersect(shifted, point3{2., 1., 0.}, vector3{0., 0., 1.}, cartesian2, rect_for_inside);
+    auto hit_bound_inside =
+        pi.intersect(shifted, point3{2., 1., 0.}, vector3{0., 0., 1.},
+                     cartesian2, rect_for_inside);
     ASSERT_TRUE(hit_bound_inside.status == intersection_status::e_inside);
     // Global intersection information - unchanged
     ASSERT_NEAR(hit_bound_inside.p3[0], 2., epsilon);
@@ -72,7 +74,9 @@ TEST(ALGEBRA_PLUGIN, translated_plane)
 
     // The same test but bound to local frame & masked - outside
     rectangle2<> rect_for_outside = {0.5, 3.5};
-    auto hit_bound_outside = pi.intersect(shifted, point3{2., 1., 0.}, vector3{0., 0., 1.}, cartesian2, rect_for_outside);
+    auto hit_bound_outside =
+        pi.intersect(shifted, point3{2., 1., 0.}, vector3{0., 0., 1.},
+                     cartesian2, rect_for_outside);
     ASSERT_TRUE(hit_bound_outside.status == intersection_status::e_outside);
     // Global intersection information - unchanged
     ASSERT_NEAR(hit_bound_outside.p3[0], 2., epsilon);
@@ -83,9 +87,7 @@ TEST(ALGEBRA_PLUGIN, translated_plane)
     ASSERT_NEAR(hit_bound_outside.p2[1], -1., epsilon);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/common/include/tests/common/tools_propagator.inl b/tests/common/include/tests/common/tools_propagator.inl
index a5bd921efe..d4ed26998b 100644
--- a/tests/common/include/tests/common/tools_propagator.inl
+++ b/tests/common/include/tests/common/tools_propagator.inl
@@ -1,40 +1,42 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+#include <gtest/gtest.h>
+
 #include "core/track.hpp"
 #include "core/transform_store.hpp"
+#include "io/csv_io.hpp"
 #include "tools/line_stepper.hpp"
 #include "tools/navigator.hpp"
 #include "tools/propagator.hpp"
-#include "io/csv_io.hpp"
-
-#include <gtest/gtest.h>
 
 /// @note __plugin has to be defined with a preprocessor command
 
 // This tests the basic functionality of the propagator
-TEST(ALGEBRA_PLUGIN, propagator)
-{
+TEST(ALGEBRA_PLUGIN, propagator) {
     using namespace detray;
     using namespace __plugin;
 
     auto env_d_d = std::getenv("DETRAY_TEST_DATA_DIR");
-    if (env_d_d == nullptr)
-    {
-        throw std::ios_base::failure("Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
+    if (env_d_d == nullptr) {
+        throw std::ios_base::failure(
+            "Test data directory not found. Please set DETRAY_TEST_DATA_DIR.");
     }
     auto data_directory = std::string(env_d_d);
 
     std::string surface_file = data_directory + std::string("odd.csv");
-    std::string surface_grid_file = data_directory + std::string("odd-surface-grids.csv");
-    std::string layer_volume_file = data_directory + std::string("odd-layer-volumes.csv");
+    std::string surface_grid_file =
+        data_directory + std::string("odd-surface-grids.csv");
+    std::string layer_volume_file =
+        data_directory + std::string("odd-layer-volumes.csv");
     std::string surface_grid_entries_file = "";
 
-    auto d = detector_from_csv<>("odd", surface_file, layer_volume_file, surface_grid_file, surface_grid_entries_file);
+    auto d = detector_from_csv<>("odd", surface_file, layer_volume_file,
+                                 surface_grid_file, surface_grid_entries_file);
 
     // Create the navigator
     using detray_navigator = navigator<decltype(d)>;
@@ -61,8 +63,7 @@ TEST(ALGEBRA_PLUGIN, propagator)
     auto end = p.propagate(traj, vi);
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/unit_tests/array/array_annulus2.cpp b/tests/unit_tests/array/array_annulus2.cpp
index feddae98ab..ccc813ed55 100644
--- a/tests/unit_tests/array/array_annulus2.cpp
+++ b/tests/unit_tests/array/array_annulus2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_core.cpp b/tests/unit_tests/array/array_core.cpp
index df1783172b..103918171f 100644
--- a/tests/unit_tests/array/array_core.cpp
+++ b/tests/unit_tests/array/array_core.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_cylinder3.cpp b/tests/unit_tests/array/array_cylinder3.cpp
index 857e7967e1..be277e060c 100644
--- a/tests/unit_tests/array/array_cylinder3.cpp
+++ b/tests/unit_tests/array/array_cylinder3.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_cylinder_intersection.cpp b/tests/unit_tests/array/array_cylinder_intersection.cpp
index 726ef37363..c1c995d680 100644
--- a/tests/unit_tests/array/array_cylinder_intersection.cpp
+++ b/tests/unit_tests/array/array_cylinder_intersection.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_detector.cpp b/tests/unit_tests/array/array_detector.cpp
index 87d310aa01..d5bf8c9366 100644
--- a/tests/unit_tests/array/array_detector.cpp
+++ b/tests/unit_tests/array/array_detector.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_display_masks.cpp b/tests/unit_tests/array/array_display_masks.cpp
index ccb4da76d8..8ec22a5531 100644
--- a/tests/unit_tests/array/array_display_masks.cpp
+++ b/tests/unit_tests/array/array_display_masks.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_intersection_kernel.cpp b/tests/unit_tests/array/array_intersection_kernel.cpp
index 3b44d4897f..0763216774 100644
--- a/tests/unit_tests/array/array_intersection_kernel.cpp
+++ b/tests/unit_tests/array/array_intersection_kernel.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_line_stepper.cpp b/tests/unit_tests/array/array_line_stepper.cpp
index 680e5f0c4a..80848aa5c4 100644
--- a/tests/unit_tests/array/array_line_stepper.cpp
+++ b/tests/unit_tests/array/array_line_stepper.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_masks_container.cpp b/tests/unit_tests/array/array_masks_container.cpp
index 73460d7b7c..2b503f2137 100644
--- a/tests/unit_tests/array/array_masks_container.cpp
+++ b/tests/unit_tests/array/array_masks_container.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_navigator.cpp b/tests/unit_tests/array/array_navigator.cpp
index 327878ebec..17ef1e4ac3 100644
--- a/tests/unit_tests/array/array_navigator.cpp
+++ b/tests/unit_tests/array/array_navigator.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_planar_intersection.cpp b/tests/unit_tests/array/array_planar_intersection.cpp
index c21ac74885..e2062553a5 100644
--- a/tests/unit_tests/array/array_planar_intersection.cpp
+++ b/tests/unit_tests/array/array_planar_intersection.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_propagator.cpp b/tests/unit_tests/array/array_propagator.cpp
index a058eb0a1d..a3f18868e7 100644
--- a/tests/unit_tests/array/array_propagator.cpp
+++ b/tests/unit_tests/array/array_propagator.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_read_detector.cpp b/tests/unit_tests/array/array_read_detector.cpp
index f565785188..047aa22120 100644
--- a/tests/unit_tests/array/array_read_detector.cpp
+++ b/tests/unit_tests/array/array_read_detector.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_rectangle2.cpp b/tests/unit_tests/array/array_rectangle2.cpp
index 47c816e285..cec0fdec50 100644
--- a/tests/unit_tests/array/array_rectangle2.cpp
+++ b/tests/unit_tests/array/array_rectangle2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_ring2.cpp b/tests/unit_tests/array/array_ring2.cpp
index abd1fd1031..52466e6e50 100644
--- a/tests/unit_tests/array/array_ring2.cpp
+++ b/tests/unit_tests/array/array_ring2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_single3.cpp b/tests/unit_tests/array/array_single3.cpp
index d3e0d94301..a536a8830d 100644
--- a/tests/unit_tests/array/array_single3.cpp
+++ b/tests/unit_tests/array/array_single3.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_transform_store.cpp b/tests/unit_tests/array/array_transform_store.cpp
index a6220b131f..ecd3194973 100644
--- a/tests/unit_tests/array/array_transform_store.cpp
+++ b/tests/unit_tests/array/array_transform_store.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_trapezoid2.cpp b/tests/unit_tests/array/array_trapezoid2.cpp
index 217bccc0a1..1c3ecc6f0e 100644
--- a/tests/unit_tests/array/array_trapezoid2.cpp
+++ b/tests/unit_tests/array/array_trapezoid2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/array/array_unmasked.cpp b/tests/unit_tests/array/array_unmasked.cpp
index 1b5de9427d..66ec8bf129 100644
--- a/tests/unit_tests/array/array_unmasked.cpp
+++ b/tests/unit_tests/array/array_unmasked.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/core/grids_axis.cpp b/tests/unit_tests/core/grids_axis.cpp
index 18bc05240d..6bb037e47c 100644
--- a/tests/unit_tests/core/grids_axis.cpp
+++ b/tests/unit_tests/core/grids_axis.cpp
@@ -1,22 +1,24 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+// detray test
 #include "tests/common/test_defs.hpp"
-#include "grids/axis.hpp"
-#include "utils/indexing.hpp"
 
+// detray core
 #include <gtest/gtest.h>
 
 #include <climits>
 
+#include "grids/axis.hpp"
+#include "utils/indexing.hpp"
+
 using namespace detray;
 
-TEST(grids, regular_closed_axis)
-{
+TEST(grids, regular_closed_axis) {
 
     axis::regular<> ten_bins{10, -3., 7.};
     // N bins
@@ -78,8 +80,7 @@ TEST(grids, regular_closed_axis)
     EXPECT_EQ(ten_bins.zone(2.5, szoneAll), expected_zone);
 }
 
-TEST(grids, regular_circular_axis)
-{
+TEST(grids, regular_circular_axis) {
     scalar epsilon = 10 * std::numeric_limits<scalar>::epsilon();
 
     // Let's say 36 modules, but with 4 directly at 0, pi/2, pi, -pi2
@@ -137,8 +138,7 @@ TEST(grids, regular_circular_axis)
     EXPECT_EQ(full_pi.zone(M_PI + epsilon, szone22), expected_zone);
 }
 
-TEST(grids, irregular_closed_axis)
-{
+TEST(grids, irregular_closed_axis) {
     axis::irregular<> nonreg{{-3., 1., 2, 4., 8., 12.}};
 
     // Axis bin access
@@ -198,8 +198,7 @@ TEST(grids, irregular_closed_axis)
     EXPECT_EQ(nonreg.zone(3., szone10), expected_zone);
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/unit_tests/core/grids_grid2.cpp b/tests/unit_tests/core/grids_grid2.cpp
index e20ccdff76..2e3888c119 100644
--- a/tests/unit_tests/core/grids_grid2.cpp
+++ b/tests/unit_tests/core/grids_grid2.cpp
@@ -1,41 +1,43 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+// detray test
 #include "tests/common/test_defs.hpp"
-#include "grids/axis.hpp"
-#include "grids/grid2.hpp"
-#include "grids/serializer2.hpp"
-#include "grids/populator.hpp"
-#include "utils/indexing.hpp"
 
+// detray core
 #include <gtest/gtest.h>
 
 #include <climits>
 
+#include "grids/axis.hpp"
+#include "grids/grid2.hpp"
+#include "grids/populator.hpp"
+#include "grids/serializer2.hpp"
+#include "utils/indexing.hpp"
+
 using namespace detray;
 
-TEST(grids, grid2_replace_populator)
-{
+TEST(grids, grid2_replace_populator) {
     replace_populator<> replacer;
     serializer2 serializer;
 
     axis::regular<> xaxis{10, -5., 5.};
     axis::regular<> yaxis{10, -5., 5.};
-    using grid2r = grid2<decltype(replacer), decltype(xaxis), decltype(yaxis), decltype(serializer)>;
+    using grid2r = grid2<decltype(replacer), decltype(xaxis), decltype(yaxis),
+                         decltype(serializer)>;
 
     grid2r g2(std::move(xaxis), std::move(yaxis));
 
     // Test the initialization
     test::point2 p = {-4.5, -4.5};
-    for (unsigned int ib0 = 0; ib0 < 10; ++ib0)
-    {
-        for (unsigned int ib1 = 0; ib1 < 10; ++ib1)
-        {
-            p = {static_cast<scalar>(-4.5 + ib0), static_cast<scalar>(-4.5 + ib1)};
+    for (unsigned int ib0 = 0; ib0 < 10; ++ib0) {
+        for (unsigned int ib1 = 0; ib1 < 10; ++ib1) {
+            p = {static_cast<scalar>(-4.5 + ib0),
+                 static_cast<scalar>(-4.5 + ib1)};
             EXPECT_EQ(g2.bin(p), std::numeric_limits<dindex>::max());
         }
     }
@@ -46,14 +48,12 @@ TEST(grids, grid2_replace_populator)
     EXPECT_EQ(g2.bin(p), 3u);
 
     // Fill and read two times, fill first 0-99, then 100-199
-    for (unsigned int il = 0; il < 2; ++il)
-    {
+    for (unsigned int il = 0; il < 2; ++il) {
         unsigned int counter = il * 100;
-        for (unsigned int ib0 = 0; ib0 < 10; ++ib0)
-        {
-            for (unsigned int ib1 = 0; ib1 < 10; ++ib1)
-            {
-                p = {static_cast<scalar>(-4.5 + ib0), static_cast<scalar>(-4.5 + ib1)};
+        for (unsigned int ib0 = 0; ib0 < 10; ++ib0) {
+            for (unsigned int ib1 = 0; ib1 < 10; ++ib1) {
+                p = {static_cast<scalar>(-4.5 + ib0),
+                     static_cast<scalar>(-4.5 + ib1)};
                 g2.populate(p, counter);
                 EXPECT_EQ(g2.bin(p), counter++);
             }
@@ -73,20 +73,21 @@ TEST(grids, grid2_replace_populator)
     darray<dindex, 2> zone22 = {2u, 2u};
 
     test = g2.zone(p, {zone11, zone22}, true);
-    expect = {143u, 144u, 145u, 146u, 147u, 153u, 154u, 155u, 156u, 157u, 163u, 164u, 165u, 166u, 167u};
+    expect = {143u, 144u, 145u, 146u, 147u, 153u, 154u, 155u,
+              156u, 157u, 163u, 164u, 165u, 166u, 167u};
     EXPECT_EQ(test, expect);
 
     axis::circular<> circular{4, -2., 2.};
     axis::regular<> closed{5, 0., 5.};
-    using grid2cc = grid2<decltype(replacer), decltype(circular), decltype(closed), decltype(serializer)>;
+    using grid2cc = grid2<decltype(replacer), decltype(circular),
+                          decltype(closed), decltype(serializer)>;
 
     grid2cc g2cc(std::move(circular), std::move(closed));
     unsigned int counter = 0;
-    for (unsigned icl = 0; icl < 5; ++icl)
-    {
-        for (unsigned ici = 0; ici < 4; ++ici)
-        {
-            p = {static_cast<scalar>(-1.5 + ici), static_cast<scalar>(0.5 + icl)};
+    for (unsigned icl = 0; icl < 5; ++icl) {
+        for (unsigned ici = 0; ici < 4; ++ici) {
+            p = {static_cast<scalar>(-1.5 + ici),
+                 static_cast<scalar>(0.5 + icl)};
             g2cc.populate(p, counter++);
         }
     }
@@ -98,26 +99,26 @@ TEST(grids, grid2_replace_populator)
     EXPECT_EQ(test, expect);
 }
 
-TEST(grids, grid2_complete_populator)
-{
+TEST(grids, grid2_complete_populator) {
 
     complete_populator<3, false> completer;
     serializer2 serializer;
 
     axis::regular<> xaxis{2, -1., 1.};
     axis::regular<> yaxis{2, -1., 1.};
-    using grid2r = grid2<decltype(completer), decltype(xaxis), decltype(yaxis), decltype(serializer)>;
+    using grid2r = grid2<decltype(completer), decltype(xaxis), decltype(yaxis),
+                         decltype(serializer)>;
 
     grid2r g2(std::move(xaxis), std::move(yaxis));
 
     // Test the initialization
     test::point2 p = {-0.5, -0.5};
-    decltype(completer)::store_value invalid = {dindex_invalid, dindex_invalid, dindex_invalid};
-    for (unsigned int ib0 = 0; ib0 < 2; ++ib0)
-    {
-        for (unsigned int ib1 = 0; ib1 < 2; ++ib1)
-        {
-            p = {static_cast<scalar>(-0.5 + ib0), static_cast<scalar>(-0.5 + ib1)};
+    decltype(completer)::store_value invalid = {dindex_invalid, dindex_invalid,
+                                                dindex_invalid};
+    for (unsigned int ib0 = 0; ib0 < 2; ++ib0) {
+        for (unsigned int ib1 = 0; ib1 < 2; ++ib1) {
+            p = {static_cast<scalar>(-0.5 + ib0),
+                 static_cast<scalar>(-0.5 + ib1)};
             EXPECT_EQ(g2.bin(p), invalid);
         }
     }
@@ -126,7 +127,8 @@ TEST(grids, grid2_complete_populator)
     p = {-0.5, -0.5};
     g2.populate(p, 4u);
 
-    decltype(completer)::store_value expected = {4u, dindex_invalid, dindex_invalid};
+    decltype(completer)::store_value expected = {4u, dindex_invalid,
+                                                 dindex_invalid};
     auto test = g2.bin(p);
     EXPECT_EQ(test, expected);
 
@@ -170,26 +172,25 @@ TEST(grids, grid2_complete_populator)
     EXPECT_EQ(zone_test, zone_expected);
 }
 
-TEST(grids, grid2_attach_populator)
-{
+TEST(grids, grid2_attach_populator) {
 
     attach_populator<> attacher;
     serializer2 serializer;
 
     axis::regular<> xaxis{2, -1., 1.};
     axis::regular<> yaxis{2, -1., 1.};
-    using grid2r = grid2<decltype(attacher), decltype(xaxis), decltype(yaxis), decltype(serializer)>;
+    using grid2r = grid2<decltype(attacher), decltype(xaxis), decltype(yaxis),
+                         decltype(serializer)>;
 
     grid2r g2(std::move(xaxis), std::move(yaxis));
 
     // Test the initialization
     test::point2 p = {-0.5, -0.5};
     decltype(attacher)::store_value invalid = {};
-    for (unsigned int ib0 = 0; ib0 < 2; ++ib0)
-    {
-        for (unsigned int ib1 = 0; ib1 < 2; ++ib1)
-        {
-            p = {static_cast<scalar>(-0.5 + ib0), static_cast<scalar>(-0.5 + ib1)};
+    for (unsigned int ib0 = 0; ib0 < 2; ++ib0) {
+        for (unsigned int ib1 = 0; ib1 < 2; ++ib1) {
+            p = {static_cast<scalar>(-0.5 + ib0),
+                 static_cast<scalar>(-0.5 + ib1)};
             EXPECT_EQ(g2.bin(p), invalid);
         }
     }
@@ -225,15 +226,15 @@ TEST(grids, grid2_attach_populator)
     EXPECT_EQ(zone_test, zone_expected);
 }
 
-TEST(grids, grid2_shift)
-{
+TEST(grids, grid2_shift) {
     replace_populator<dindex, 0> replacer;
     serializer2 serializer;
 
     axis::regular<> xaxis{10, -5., 5.};
     axis::regular<> yaxis{10, -5., 5.};
 
-    using grid2r = grid2<decltype(replacer), decltype(xaxis), decltype(yaxis), decltype(serializer)>;
+    using grid2r = grid2<decltype(replacer), decltype(xaxis), decltype(yaxis),
+                         decltype(serializer)>;
 
     grid2r g2(std::move(xaxis), std::move(yaxis));
 
@@ -245,15 +246,15 @@ TEST(grids, grid2_shift)
     EXPECT_EQ(g2.bin(p), 8u);
 }
 
-TEST(grids, grid2_irregular_replace)
-{
+TEST(grids, grid2_irregular_replace) {
     replace_populator<> replacer;
     serializer2 serializer;
 
     axis::irregular<> xaxis{{-3, -2., 1, 0.5, 0.7, 0.71, 4., 1000.}};
     axis::irregular<> yaxis{{0.1, 0.8, 0.9, 10., 12., 15.}};
 
-    using grid2ir = grid2<decltype(replacer), decltype(xaxis), decltype(yaxis), decltype(serializer)>;
+    using grid2ir = grid2<decltype(replacer), decltype(xaxis), decltype(yaxis),
+                          decltype(serializer)>;
 
     grid2ir g2(std::move(xaxis), std::move(yaxis));
 
@@ -262,8 +263,7 @@ TEST(grids, grid2_irregular_replace)
     EXPECT_EQ(g2.bin(p), 4u);
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/unit_tests/core/grids_populator.cpp b/tests/unit_tests/core/grids_populator.cpp
index 8c37939d88..9e350a7e14 100644
--- a/tests/unit_tests/core/grids_populator.cpp
+++ b/tests/unit_tests/core/grids_populator.cpp
@@ -1,22 +1,24 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+// detray test
 #include "tests/common/test_defs.hpp"
-#include "grids/populator.hpp"
-#include "utils/indexing.hpp"
 
+// detray core
 #include <gtest/gtest.h>
 
 #include <climits>
 
+#include "grids/populator.hpp"
+#include "utils/indexing.hpp"
+
 using namespace detray;
 
-TEST(grids, replace_populator)
-{
+TEST(grids, replace_populator) {
     replace_populator<> replacer;
     dindex stored = 3;
     replacer(stored, 2);
@@ -26,14 +28,14 @@ TEST(grids, replace_populator)
     EXPECT_EQ(stored, 42u);
 }
 
-TEST(grids, complete_populator)
-{
+TEST(grids, complete_populator) {
 
     using cpopulator4 = complete_populator<4>;
     cpopulator4 completer;
 
-    cpopulator4::store_value stored = {cpopulator4::invalid_value, cpopulator4::invalid_value, cpopulator4::invalid_value, cpopulator4::invalid_value};
-
+    cpopulator4::store_value stored = {
+        cpopulator4::invalid_value, cpopulator4::invalid_value,
+        cpopulator4::invalid_value, cpopulator4::invalid_value};
 
     cpopulator4::store_value test = stored;
     test[0] = 9u;
@@ -47,15 +49,13 @@ TEST(grids, complete_populator)
     using sort_cpopulator4 = complete_populator<4, true>;
     sort_cpopulator4 sort_completer;
 
-    test = { 0, 3, 9, 1000};
+    test = {0, 3, 9, 1000};
     sort_completer(stored, 1000);
     sort_completer(stored, 0);
     EXPECT_EQ(stored, test);
-
 }
 
-TEST(grids, attach_populator)
-{
+TEST(grids, attach_populator) {
     // Attch populator without sorting
     attach_populator<> attacher;
     attach_populator<>::store_value stored = {3};
@@ -74,9 +74,7 @@ TEST(grids, attach_populator)
     EXPECT_EQ(stored, test);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/unit_tests/core/grids_serializer.cpp b/tests/unit_tests/core/grids_serializer.cpp
index 1bb0c44ba5..d9249b3991 100644
--- a/tests/unit_tests/core/grids_serializer.cpp
+++ b/tests/unit_tests/core/grids_serializer.cpp
@@ -1,23 +1,25 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+// detray test
 #include "tests/common/test_defs.hpp"
-#include "grids/axis.hpp"
-#include "grids/serializer2.hpp"
-#include "utils/indexing.hpp"
 
+// detray core
 #include <gtest/gtest.h>
 
 #include <climits>
 
+#include "grids/axis.hpp"
+#include "grids/serializer2.hpp"
+#include "utils/indexing.hpp"
+
 using namespace detray;
 
-TEST(grids, serialize_deserialize)
-{
+TEST(grids, serialize_deserialize) {
 
     axis::regular<> r6{6, -3., 7.};
     axis::circular<> c12{12, -3., 3.};
@@ -49,9 +51,7 @@ TEST(grids, serialize_deserialize)
     EXPECT_EQ(test_array, expected_array);
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/unit_tests/core/utils_enumerate.cpp b/tests/unit_tests/core/utils_enumerate.cpp
index f6b2111f86..9854b6e2a2 100644
--- a/tests/unit_tests/core/utils_enumerate.cpp
+++ b/tests/unit_tests/core/utils_enumerate.cpp
@@ -1,81 +1,74 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
+// detray test
 #include "tests/common/test_defs.hpp"
-#include "utils/indexing.hpp"
-#include "utils/enumerate.hpp"
 
+// detray core
 #include <gtest/gtest.h>
 
+#include "utils/enumerate.hpp"
+#include "utils/indexing.hpp"
+
 using namespace detray;
 
 // This tests the convenience range_enumeration function: single
-TEST(utils, sequence_single)
-{
+TEST(utils, sequence_single) {
 
     dindex check = 0;
     dindex single = 7;
-    for (auto i : sequence(single))
-    {
+    for (auto i : sequence(single)) {
         check += i;
     }
     ASSERT_EQ(check, single);
 }
 
 // This tests the convenience range_enumeration function: range
-TEST(utils, sequence_range)
-{
+TEST(utils, sequence_range) {
 
     darray<dindex, 2> range = {2, 7};
     std::vector<dindex> reference = {2, 3, 4, 5, 6, 7};
     std::vector<dindex> check = {};
-    for (auto i : sequence(range))
-    {
+    for (auto i : sequence(range)) {
         check.push_back(i);
     }
     ASSERT_EQ(check, reference);
 }
 
 // This tests the convenience enumeration function
-TEST(utils, enumerate)
-{
+TEST(utils, enumerate) {
 
-    struct uint_holder
-    {
+    struct uint_holder {
         unsigned int ui = 0;
     };
 
     dvector<uint_holder> seq = {{0}, {1}, {2}, {3}, {4}, {5}};
 
-    for (auto [i, v] : enumerate(seq))
-    {
+    for (auto [i, v] : enumerate(seq)) {
         ASSERT_EQ(i, v.ui);
     }
 }
 
 // This tests the restricted iterator
-TEST(utils, range)
-{
+TEST(utils, range) {
     size_t begin = 1;
     size_t end = 4;
 
     dvector<int> seq = {0, 1, 2, 3, 4, 5};
 
     size_t i = 1;
-    for (const auto &v : range_iter(seq, std::array<size_t, 2>{begin, end}))
-    {
+    for (const auto &v : range_iter(seq, std::array<size_t, 2>{begin, end})) {
         ASSERT_NE(v, 5);
         ASSERT_EQ(v, seq[i++]);
     }
 }
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
-}
\ No newline at end of file
+}
diff --git a/tests/unit_tests/core/utils_local_object_finder.cpp b/tests/unit_tests/core/utils_local_object_finder.cpp
index f1fc70a248..e1c07c2a4c 100644
--- a/tests/unit_tests/core/utils_local_object_finder.cpp
+++ b/tests/unit_tests/core/utils_local_object_finder.cpp
@@ -1,64 +1,61 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-
+// detray test
 #include "tests/common/test_defs.hpp"
+
+// detray core
+#include <gtest/gtest.h>
+
+#include <functional>
+
 #include "grids/axis.hpp"
 #include "grids/grid2.hpp"
-#include "grids/serializer2.hpp"
 #include "grids/populator.hpp"
+#include "grids/serializer2.hpp"
+#include "tools/local_object_finder.hpp"
 #include "utils/enumerate.hpp"
 #include "utils/indexing.hpp"
-#include "tools/local_object_finder.hpp"
-
-#include <functional>
-
-#include <gtest/gtest.h>
-
 
 using namespace detray;
 
 // This tests the convenience enumeration function
-TEST(utils, local_object_finder)
-{
+TEST(utils, local_object_finder) {
 
     replace_populator<> replacer;
     serializer2 serializer;
 
-    test::point2 p2 = { -4.5, -4.5 };
+    test::point2 p2 = {-4.5, -4.5};
 
     axis::regular<> xaxis{10, -5., 5.};
     axis::regular<> yaxis{10, -5., 5.};
-    using grid2r = grid2<decltype(replacer), decltype(xaxis), decltype(yaxis), decltype(serializer)>;
+    using grid2r = grid2<decltype(replacer), decltype(xaxis), decltype(yaxis),
+                         decltype(serializer)>;
 
     grid2r g2(std::move(xaxis), std::move(yaxis));
 
     g2.populate(p2, 8u);
 
-
-    dvector<dindex> expected = { 8u };
+    dvector<dindex> expected = {8u};
     EXPECT_EQ(g2.zone(p2), expected);
 
     local_zone_finder<grid2r> local_zone(std::move(g2));
 
     local_single_finder<dindex> local_single(8u);
 
-    using local_finder = std::function< dvector<dindex>(const test::point2&) >;
+    using local_finder = std::function<dvector<dindex>(const test::point2 &)>;
 
-    std::vector<local_finder> local_finders = { local_zone, local_single };
+    std::vector<local_finder> local_finders = {local_zone, local_single};
 
     EXPECT_EQ(local_finders[0](p2), expected);
     EXPECT_EQ(local_finders[1](p2), expected);
-
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
diff --git a/tests/unit_tests/core/utils_quadratic_equation.cpp b/tests/unit_tests/core/utils_quadratic_equation.cpp
index aeaa60a29e..9da50df138 100644
--- a/tests/unit_tests/core/utils_quadratic_equation.cpp
+++ b/tests/unit_tests/core/utils_quadratic_equation.cpp
@@ -1,34 +1,32 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
-
+// detray test
 #include "tests/common/test_defs.hpp"
-#include "utils/quadratic_equation.hpp"
 
+// detray core
 #include <gtest/gtest.h>
 
+#include "utils/quadratic_equation.hpp"
+
 using namespace detray;
 
 // This tests the convenience quadratic equation struct
-TEST(utils, quad_equation)
-{
+TEST(utils, quad_equation) {
     quadratic_equation<scalar> qe = {{2., 5., -3.}};
     auto solution = qe();
 
     ASSERT_EQ(std::get<0>(solution), 2);
     ASSERT_NEAR(std::get<1>(solution)[0], -3., 1e-5);
     ASSERT_NEAR(std::get<1>(solution)[1], 0.5, 1e-5);
-
 }
 
-
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
     return RUN_ALL_TESTS();
-}
\ No newline at end of file
+}
diff --git a/tests/unit_tests/eigen/eigen_annulus2.cpp b/tests/unit_tests/eigen/eigen_annulus2.cpp
index ec274474e1..982d59ffa3 100644
--- a/tests/unit_tests/eigen/eigen_annulus2.cpp
+++ b/tests/unit_tests/eigen/eigen_annulus2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_core.cpp b/tests/unit_tests/eigen/eigen_core.cpp
index c10a79d081..d6763a1521 100644
--- a/tests/unit_tests/eigen/eigen_core.cpp
+++ b/tests/unit_tests/eigen/eigen_core.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_cylinder3.cpp b/tests/unit_tests/eigen/eigen_cylinder3.cpp
index 51ec206bdd..9c4a5e1dd8 100644
--- a/tests/unit_tests/eigen/eigen_cylinder3.cpp
+++ b/tests/unit_tests/eigen/eigen_cylinder3.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_cylinder_intersection.cpp b/tests/unit_tests/eigen/eigen_cylinder_intersection.cpp
index 61675b8e81..96e3c157cf 100644
--- a/tests/unit_tests/eigen/eigen_cylinder_intersection.cpp
+++ b/tests/unit_tests/eigen/eigen_cylinder_intersection.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_detector.cpp b/tests/unit_tests/eigen/eigen_detector.cpp
index 6665d0af51..65b0e71c3d 100644
--- a/tests/unit_tests/eigen/eigen_detector.cpp
+++ b/tests/unit_tests/eigen/eigen_detector.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_display_masks.cpp b/tests/unit_tests/eigen/eigen_display_masks.cpp
index ba9a09ccb9..918abc4aa2 100644
--- a/tests/unit_tests/eigen/eigen_display_masks.cpp
+++ b/tests/unit_tests/eigen/eigen_display_masks.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_intersection_kernel.cpp b/tests/unit_tests/eigen/eigen_intersection_kernel.cpp
index 5cb92f0e51..2620024d67 100644
--- a/tests/unit_tests/eigen/eigen_intersection_kernel.cpp
+++ b/tests/unit_tests/eigen/eigen_intersection_kernel.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_line_stepper.cpp b/tests/unit_tests/eigen/eigen_line_stepper.cpp
index dc4872ed0c..185fbc9691 100644
--- a/tests/unit_tests/eigen/eigen_line_stepper.cpp
+++ b/tests/unit_tests/eigen/eigen_line_stepper.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_masks_container.cpp b/tests/unit_tests/eigen/eigen_masks_container.cpp
index d1ff02eec9..9dbbe2e55e 100644
--- a/tests/unit_tests/eigen/eigen_masks_container.cpp
+++ b/tests/unit_tests/eigen/eigen_masks_container.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_navigator.cpp b/tests/unit_tests/eigen/eigen_navigator.cpp
index 22bde78b24..867a50ebe5 100644
--- a/tests/unit_tests/eigen/eigen_navigator.cpp
+++ b/tests/unit_tests/eigen/eigen_navigator.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_planar_intersection.cpp b/tests/unit_tests/eigen/eigen_planar_intersection.cpp
index 820789b9ac..049d3d7047 100644
--- a/tests/unit_tests/eigen/eigen_planar_intersection.cpp
+++ b/tests/unit_tests/eigen/eigen_planar_intersection.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_propagator.cpp b/tests/unit_tests/eigen/eigen_propagator.cpp
index c36b4cd832..18be936353 100644
--- a/tests/unit_tests/eigen/eigen_propagator.cpp
+++ b/tests/unit_tests/eigen/eigen_propagator.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_read_detector.cpp b/tests/unit_tests/eigen/eigen_read_detector.cpp
index 9dddce828a..5d4ad6c6da 100644
--- a/tests/unit_tests/eigen/eigen_read_detector.cpp
+++ b/tests/unit_tests/eigen/eigen_read_detector.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_rectangle2.cpp b/tests/unit_tests/eigen/eigen_rectangle2.cpp
index dc635e3eea..2f2614d764 100644
--- a/tests/unit_tests/eigen/eigen_rectangle2.cpp
+++ b/tests/unit_tests/eigen/eigen_rectangle2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_ring2.cpp b/tests/unit_tests/eigen/eigen_ring2.cpp
index 3f4fe0c45a..f3ddf606ce 100644
--- a/tests/unit_tests/eigen/eigen_ring2.cpp
+++ b/tests/unit_tests/eigen/eigen_ring2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_single3.cpp b/tests/unit_tests/eigen/eigen_single3.cpp
index 487a200b31..de5d015cfd 100644
--- a/tests/unit_tests/eigen/eigen_single3.cpp
+++ b/tests/unit_tests/eigen/eigen_single3.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_transform_store.cpp b/tests/unit_tests/eigen/eigen_transform_store.cpp
index 4b1a69114f..9561661567 100644
--- a/tests/unit_tests/eigen/eigen_transform_store.cpp
+++ b/tests/unit_tests/eigen/eigen_transform_store.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_trapezoid2.cpp b/tests/unit_tests/eigen/eigen_trapezoid2.cpp
index 45ec60d52f..30b9913231 100644
--- a/tests/unit_tests/eigen/eigen_trapezoid2.cpp
+++ b/tests/unit_tests/eigen/eigen_trapezoid2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/eigen/eigen_unmasked.cpp b/tests/unit_tests/eigen/eigen_unmasked.cpp
index 6cf386b2f5..33a92fc587 100644
--- a/tests/unit_tests/eigen/eigen_unmasked.cpp
+++ b/tests/unit_tests/eigen/eigen_unmasked.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_annulus2.cpp b/tests/unit_tests/smatrix/smatrix_annulus2.cpp
index 5e63413be5..f35cf0df38 100644
--- a/tests/unit_tests/smatrix/smatrix_annulus2.cpp
+++ b/tests/unit_tests/smatrix/smatrix_annulus2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_core.cpp b/tests/unit_tests/smatrix/smatrix_core.cpp
index 36b6b1fc51..a0118135cc 100644
--- a/tests/unit_tests/smatrix/smatrix_core.cpp
+++ b/tests/unit_tests/smatrix/smatrix_core.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_cylinder3.cpp b/tests/unit_tests/smatrix/smatrix_cylinder3.cpp
index 8c854ec754..db9e8291b0 100644
--- a/tests/unit_tests/smatrix/smatrix_cylinder3.cpp
+++ b/tests/unit_tests/smatrix/smatrix_cylinder3.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_cylinder_intersection.cpp b/tests/unit_tests/smatrix/smatrix_cylinder_intersection.cpp
index 1f46e6434f..867ca7e34c 100644
--- a/tests/unit_tests/smatrix/smatrix_cylinder_intersection.cpp
+++ b/tests/unit_tests/smatrix/smatrix_cylinder_intersection.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_detector.cpp b/tests/unit_tests/smatrix/smatrix_detector.cpp
index b3d1269403..ed3a632197 100644
--- a/tests/unit_tests/smatrix/smatrix_detector.cpp
+++ b/tests/unit_tests/smatrix/smatrix_detector.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_intersection_kernel.cpp b/tests/unit_tests/smatrix/smatrix_intersection_kernel.cpp
index deb4554905..ac99cd187f 100644
--- a/tests/unit_tests/smatrix/smatrix_intersection_kernel.cpp
+++ b/tests/unit_tests/smatrix/smatrix_intersection_kernel.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_line_stepper.cpp b/tests/unit_tests/smatrix/smatrix_line_stepper.cpp
index b71376b0f1..bcf3c06af3 100644
--- a/tests/unit_tests/smatrix/smatrix_line_stepper.cpp
+++ b/tests/unit_tests/smatrix/smatrix_line_stepper.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_masks_container.cpp b/tests/unit_tests/smatrix/smatrix_masks_container.cpp
index 40c37e0443..1b04e9d3d9 100644
--- a/tests/unit_tests/smatrix/smatrix_masks_container.cpp
+++ b/tests/unit_tests/smatrix/smatrix_masks_container.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_navigator.cpp b/tests/unit_tests/smatrix/smatrix_navigator.cpp
index 7b5696ab67..c45054b423 100644
--- a/tests/unit_tests/smatrix/smatrix_navigator.cpp
+++ b/tests/unit_tests/smatrix/smatrix_navigator.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_planar_intersection.cpp b/tests/unit_tests/smatrix/smatrix_planar_intersection.cpp
index 9f50e3ce5c..915f46e41d 100644
--- a/tests/unit_tests/smatrix/smatrix_planar_intersection.cpp
+++ b/tests/unit_tests/smatrix/smatrix_planar_intersection.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_propagator.cpp b/tests/unit_tests/smatrix/smatrix_propagator.cpp
index b686cb4e56..5a522805a2 100644
--- a/tests/unit_tests/smatrix/smatrix_propagator.cpp
+++ b/tests/unit_tests/smatrix/smatrix_propagator.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_read_detector.cpp b/tests/unit_tests/smatrix/smatrix_read_detector.cpp
index 5b8c907094..63ebed6045 100644
--- a/tests/unit_tests/smatrix/smatrix_read_detector.cpp
+++ b/tests/unit_tests/smatrix/smatrix_read_detector.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_rectangle2.cpp b/tests/unit_tests/smatrix/smatrix_rectangle2.cpp
index 25fcc84dc3..b008b89feb 100644
--- a/tests/unit_tests/smatrix/smatrix_rectangle2.cpp
+++ b/tests/unit_tests/smatrix/smatrix_rectangle2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_ring2.cpp b/tests/unit_tests/smatrix/smatrix_ring2.cpp
index 07637e200e..a3a756c8c5 100644
--- a/tests/unit_tests/smatrix/smatrix_ring2.cpp
+++ b/tests/unit_tests/smatrix/smatrix_ring2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_single3.cpp b/tests/unit_tests/smatrix/smatrix_single3.cpp
index 3d242a7c1d..f0ce2ff5e3 100644
--- a/tests/unit_tests/smatrix/smatrix_single3.cpp
+++ b/tests/unit_tests/smatrix/smatrix_single3.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_single_layer_components.cpp b/tests/unit_tests/smatrix/smatrix_single_layer_components.cpp
index 643d2c0fb3..3584aff3cc 100644
--- a/tests/unit_tests/smatrix/smatrix_single_layer_components.cpp
+++ b/tests/unit_tests/smatrix/smatrix_single_layer_components.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_transform_store.cpp b/tests/unit_tests/smatrix/smatrix_transform_store.cpp
index aa6f54dd68..e2afdda8ff 100644
--- a/tests/unit_tests/smatrix/smatrix_transform_store.cpp
+++ b/tests/unit_tests/smatrix/smatrix_transform_store.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_trapezoid2.cpp b/tests/unit_tests/smatrix/smatrix_trapezoid2.cpp
index 4dcfcf5574..632211cee2 100644
--- a/tests/unit_tests/smatrix/smatrix_trapezoid2.cpp
+++ b/tests/unit_tests/smatrix/smatrix_trapezoid2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/smatrix/smatrix_unmasked.cpp b/tests/unit_tests/smatrix/smatrix_unmasked.cpp
index a75348dacc..e1be9ad420 100644
--- a/tests/unit_tests/smatrix/smatrix_unmasked.cpp
+++ b/tests/unit_tests/smatrix/smatrix_unmasked.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_annulus2.cpp b/tests/unit_tests/vc/vc_array_annulus2.cpp
index d37f76a99d..b386eae9e8 100644
--- a/tests/unit_tests/vc/vc_array_annulus2.cpp
+++ b/tests/unit_tests/vc/vc_array_annulus2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_core.cpp b/tests/unit_tests/vc/vc_array_core.cpp
index 6978be86c0..9539b77044 100644
--- a/tests/unit_tests/vc/vc_array_core.cpp
+++ b/tests/unit_tests/vc/vc_array_core.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_cylinder3.cpp b/tests/unit_tests/vc/vc_array_cylinder3.cpp
index f2f0cfcfaa..1fa5af5796 100644
--- a/tests/unit_tests/vc/vc_array_cylinder3.cpp
+++ b/tests/unit_tests/vc/vc_array_cylinder3.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_cylinder_intersection.cpp b/tests/unit_tests/vc/vc_array_cylinder_intersection.cpp
index 87e619a577..4264657773 100644
--- a/tests/unit_tests/vc/vc_array_cylinder_intersection.cpp
+++ b/tests/unit_tests/vc/vc_array_cylinder_intersection.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_detector.cpp b/tests/unit_tests/vc/vc_array_detector.cpp
index c9eec5cb4d..1e79e3c2c0 100644
--- a/tests/unit_tests/vc/vc_array_detector.cpp
+++ b/tests/unit_tests/vc/vc_array_detector.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_display_masks.cpp b/tests/unit_tests/vc/vc_array_display_masks.cpp
index 476c4780b4..6ebd56a900 100644
--- a/tests/unit_tests/vc/vc_array_display_masks.cpp
+++ b/tests/unit_tests/vc/vc_array_display_masks.cpp
@@ -1,7 +1,7 @@
 /* Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_intersection_kernel.cpp b/tests/unit_tests/vc/vc_array_intersection_kernel.cpp
index 163f18282b..86843f6972 100644
--- a/tests/unit_tests/vc/vc_array_intersection_kernel.cpp
+++ b/tests/unit_tests/vc/vc_array_intersection_kernel.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_line_stepper.cpp b/tests/unit_tests/vc/vc_array_line_stepper.cpp
index 129b7d5594..4c0d07d45e 100644
--- a/tests/unit_tests/vc/vc_array_line_stepper.cpp
+++ b/tests/unit_tests/vc/vc_array_line_stepper.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_masks_container.cpp b/tests/unit_tests/vc/vc_array_masks_container.cpp
index 64a4bbe2d1..82b983b872 100644
--- a/tests/unit_tests/vc/vc_array_masks_container.cpp
+++ b/tests/unit_tests/vc/vc_array_masks_container.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_navigator.cpp b/tests/unit_tests/vc/vc_array_navigator.cpp
index 75a37ab972..bd570d5d2d 100644
--- a/tests/unit_tests/vc/vc_array_navigator.cpp
+++ b/tests/unit_tests/vc/vc_array_navigator.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_planar_intersection.cpp b/tests/unit_tests/vc/vc_array_planar_intersection.cpp
index 6e495954ca..cfc7c9e37e 100644
--- a/tests/unit_tests/vc/vc_array_planar_intersection.cpp
+++ b/tests/unit_tests/vc/vc_array_planar_intersection.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_propagator.cpp b/tests/unit_tests/vc/vc_array_propagator.cpp
index 4c7c6d098c..0f444bee16 100644
--- a/tests/unit_tests/vc/vc_array_propagator.cpp
+++ b/tests/unit_tests/vc/vc_array_propagator.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_read_detector.cpp b/tests/unit_tests/vc/vc_array_read_detector.cpp
index 54d1e0ac95..f7fe5f066b 100644
--- a/tests/unit_tests/vc/vc_array_read_detector.cpp
+++ b/tests/unit_tests/vc/vc_array_read_detector.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_rectangle2.cpp b/tests/unit_tests/vc/vc_array_rectangle2.cpp
index 22988c3245..4548b75f70 100644
--- a/tests/unit_tests/vc/vc_array_rectangle2.cpp
+++ b/tests/unit_tests/vc/vc_array_rectangle2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_ring2.cpp b/tests/unit_tests/vc/vc_array_ring2.cpp
index f906c0e395..7a0eca40c0 100644
--- a/tests/unit_tests/vc/vc_array_ring2.cpp
+++ b/tests/unit_tests/vc/vc_array_ring2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_single3.cpp b/tests/unit_tests/vc/vc_array_single3.cpp
index 1e3f829fa2..e54362f5c0 100644
--- a/tests/unit_tests/vc/vc_array_single3.cpp
+++ b/tests/unit_tests/vc/vc_array_single3.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_transform_store.cpp b/tests/unit_tests/vc/vc_array_transform_store.cpp
index 439df39a12..e6accc985c 100644
--- a/tests/unit_tests/vc/vc_array_transform_store.cpp
+++ b/tests/unit_tests/vc/vc_array_transform_store.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2021 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_trapezoid2.cpp b/tests/unit_tests/vc/vc_array_trapezoid2.cpp
index 3cbb7d2095..bd0bdbf271 100644
--- a/tests/unit_tests/vc/vc_array_trapezoid2.cpp
+++ b/tests/unit_tests/vc/vc_array_trapezoid2.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */
 
diff --git a/tests/unit_tests/vc/vc_array_unmasked.cpp b/tests/unit_tests/vc/vc_array_unmasked.cpp
index ad1b289d1f..a515c6d825 100644
--- a/tests/unit_tests/vc/vc_array_unmasked.cpp
+++ b/tests/unit_tests/vc/vc_array_unmasked.cpp
@@ -1,7 +1,7 @@
 /** Detray library, part of the ACTS project (R&D line)
- * 
+ *
  * (c) 2020 CERN for the benefit of the ACTS project
- * 
+ *
  * Mozilla Public License Version 2.0
  */