diff --git a/core/include/detray/definitions/indexing.hpp b/core/include/detray/definitions/indexing.hpp
index 50ee27b03..57829bcce 100644
--- a/core/include/detray/definitions/indexing.hpp
+++ b/core/include/detray/definitions/indexing.hpp
@@ -296,8 +296,6 @@ DETRAY_HOST_DEVICE constexpr decltype(auto) get(
     return index.index();
 }
 
-}  // namespace detail
-
 /// Overload to check for an invalid typed index link @param ti
 template <typename id_t, typename index_t, typename value_t, value_t id_mask,
           value_t index_mask>
@@ -307,4 +305,6 @@ DETRAY_HOST_DEVICE inline constexpr bool is_invalid_value(
     return ti.is_invalid();
 }
 
+}  // namespace detail
+
 }  // namespace detray
diff --git a/core/include/detray/geometry/detector_volume.hpp b/core/include/detray/geometry/detector_volume.hpp
index 3c6dac986..3f6a87ec2 100644
--- a/core/include/detray/geometry/detector_volume.hpp
+++ b/core/include/detray/geometry/detector_volume.hpp
@@ -166,7 +166,7 @@ class detector_volume {
                << *this << std::endl;
             return false;
         }
-        if (is_invalid_value(index())) {
+        if (detail::is_invalid_value(index())) {
             os << "ERROR: Volume index undefined in volume:\n"
                << *this << std::endl;
             return false;
@@ -176,7 +176,7 @@ class detector_volume {
                << *this << std::endl;
             return false;
         }
-        if (is_invalid_value(m_desc.transform())) {
+        if (detail::is_invalid_value(m_desc.transform())) {
             os << "ERROR: Volume transform undefined in volume:\n"
                << *this << std::endl;
             return false;
@@ -187,7 +187,7 @@ class detector_volume {
             return false;
         }
         const auto &acc_link = m_desc.full_link();
-        if (is_invalid_value(acc_link[0])) {
+        if (detail::is_invalid_value(acc_link[0])) {
             os << "ERROR: Link to portal lookup broken in volume: " << acc_link
                << "\n in volume: " << *this << std::endl;
             return false;
diff --git a/core/include/detray/geometry/surface.hpp b/core/include/detray/geometry/surface.hpp
index fb9949f2f..00c909be8 100644
--- a/core/include/detray/geometry/surface.hpp
+++ b/core/include/detray/geometry/surface.hpp
@@ -328,7 +328,7 @@ class surface {
                << *this << std::endl;
             return false;
         }
-        if (is_invalid_value(m_desc.transform())) {
+        if (detail::is_invalid_value(m_desc.transform())) {
             os << "ERROR: Surface transform undefined for surface:\n"
                << *this << std::endl;
             return false;
@@ -338,7 +338,7 @@ class surface {
                << *this << std::endl;
             return false;
         }
-        if (is_invalid_value(m_desc.mask())) {
+        if (detail::is_invalid_value(m_desc.mask())) {
             os << "ERROR: Surface does not have a valid mask link:\n"
                << *this << std::endl;
             return false;
diff --git a/core/include/detray/intersection/detail/trajectories.hpp b/core/include/detray/intersection/detail/trajectories.hpp
index 3f3eb005b..215a0cd0e 100644
--- a/core/include/detray/intersection/detail/trajectories.hpp
+++ b/core/include/detray/intersection/detail/trajectories.hpp
@@ -16,7 +16,6 @@
 
 // System include(s).
 #include <cmath>
-#include <limits>
 #include <ostream>
 
 namespace detray::detail {
@@ -195,7 +194,7 @@ class helix {
 
         // Handle the case of pT ~ 0
         if (getter::norm(pT) < 1e-6f) {
-            _vz_over_vt = std::numeric_limits<scalar_type>::infinity();
+            _vz_over_vt = detail::invalid_value<scalar_type>();
         } else {
             // Get vz over vt in new coordinate
             _vz_over_vt = pz / getter::norm(pT);
@@ -226,7 +225,7 @@ class helix {
     point3 pos(const scalar_type s) const {
 
         // Handle the case of pT ~ 0
-        if (_vz_over_vt == std::numeric_limits<scalar_type>::infinity()) {
+        if (_vz_over_vt == detail::invalid_value<scalar_type>()) {
             return _pos + s * _h0;
         }
 
@@ -246,7 +245,7 @@ class helix {
     vector3 dir(const scalar_type s) const {
 
         // Handle the case of pT ~ 0
-        if (_vz_over_vt == std::numeric_limits<scalar_type>::infinity()) {
+        if (_vz_over_vt == detail::invalid_value<scalar_type>()) {
             return _t0;
         }
 
diff --git a/core/include/detray/masks/annulus2D.hpp b/core/include/detray/masks/annulus2D.hpp
index a88cf2a73..e34a9e091 100644
--- a/core/include/detray/masks/annulus2D.hpp
+++ b/core/include/detray/masks/annulus2D.hpp
@@ -198,8 +198,8 @@ class annulus2D {
                                   c[1], c_pos[0] * math_ns::sin(c_pos[1]) - o_y,
                                   t[1]};
 
-        constexpr scalar_t inf{std::numeric_limits<scalar_t>::infinity()};
-        scalar_t min_x{inf}, min_y{inf}, max_x{-inf}, max_y{-inf};
+        constexpr scalar_t inv{detail::invalid_value<scalar_t>()};
+        scalar_t min_x{inv}, min_y{inv}, max_x{-inv}, max_y{-inv};
         for (unsigned int i{0u}; i < 5u; ++i) {
             min_x = x_pos[i] < min_x ? x_pos[i] : min_x;
             max_x = x_pos[i] > max_x ? x_pos[i] : max_x;
diff --git a/core/include/detray/masks/unmasked.hpp b/core/include/detray/masks/unmasked.hpp
index 8ae632ed5..dd5061a8f 100644
--- a/core/include/detray/masks/unmasked.hpp
+++ b/core/include/detray/masks/unmasked.hpp
@@ -90,8 +90,8 @@ class unmasked {
         const bounds_t<scalar_t, kDIM>& /*bounds*/,
         const scalar_t /*env*/ =
             std::numeric_limits<scalar_t>::epsilon()) const {
-        constexpr scalar_t inf{std::numeric_limits<scalar_t>::infinity()};
-        return {-inf, -inf, -inf, inf, inf, inf};
+        constexpr scalar_t inv{detail::invalid_value<scalar_t>()};
+        return {-inv, -inv, -inv, inv, inv, inv};
     }
 
     /// @returns the shapes centroid in global cartesian coordinates
diff --git a/core/include/detray/materials/material.hpp b/core/include/detray/materials/material.hpp
index 6acd3087f..0e38b3e29 100644
--- a/core/include/detray/materials/material.hpp
+++ b/core/include/detray/materials/material.hpp
@@ -104,7 +104,7 @@ struct material {
         if constexpr (ratio::num == 0) {
             return 0.f;
         } else if constexpr (ratio::den == 0) {
-            return std::numeric_limits<scalar_type>::infinity();
+            return detail::invalid_value<scalar_type>();
         } else {
             return static_cast<scalar_type>(ratio::num) /
                    static_cast<scalar_type>(ratio::den);
diff --git a/core/include/detray/propagator/navigator.hpp b/core/include/detray/propagator/navigator.hpp
index 11bdbd850..6badd0ec5 100644
--- a/core/include/detray/propagator/navigator.hpp
+++ b/core/include/detray/propagator/navigator.hpp
@@ -574,7 +574,7 @@ class navigator {
             navigation.set_volume(navigation.current()->volume_link);
 
             // Navigation reached the end of the detector world
-            if (is_invalid_value(navigation.volume())) {
+            if (detail::is_invalid_value(navigation.volume())) {
                 navigation.exit();
                 return navigation.m_heartbeat;
             }
diff --git a/core/include/detray/tools/bounding_volume.hpp b/core/include/detray/tools/bounding_volume.hpp
index 1c973aaa7..aca9e9687 100644
--- a/core/include/detray/tools/bounding_volume.hpp
+++ b/core/include/detray/tools/bounding_volume.hpp
@@ -82,9 +82,9 @@ class axis_aligned_bounding_volume {
             std::array<scalar_t, other_shape_t::template axes<>::dim>;
 
         // Find min/max extent of the local aabb in local coordinates
-        constexpr scalar_t inf{std::numeric_limits<scalar_t>::infinity()};
-        scalar_t min_x{inf}, min_y{inf}, min_z{inf}, max_x{-inf}, max_y{-inf},
-            max_z{-inf};
+        constexpr scalar_t inv{detail::invalid_value<scalar_t>()};
+        scalar_t min_x{inv}, min_y{inv}, min_z{inv}, max_x{-inv}, max_y{-inv},
+            max_z{-inv};
         for (const auto& vol : aabbs) {
             const auto min_point = vol.template loc_min<loc_point_t>();
             const auto max_point = vol.template loc_max<loc_point_t>();
@@ -136,8 +136,8 @@ class axis_aligned_bounding_volume {
 
         // If the volume shape is not supported, return universal minimum
         assert(false);
-        constexpr scalar_t inf{std::numeric_limits<scalar_t>::infinity()};
-        return point_t{-inf, -inf, -inf};
+        constexpr scalar_t inv{detail::invalid_value<scalar_t>()};
+        return point_t{-inv, -inv, -inv};
     }
 
     /// @returns the maximum bounds of the volume in local coordinates
@@ -155,8 +155,8 @@ class axis_aligned_bounding_volume {
         // If the volume shape is not supported, return universal minimum
         // (or compilation error for 2D point)
         assert(false);
-        constexpr scalar_t inf{std::numeric_limits<scalar_t>::infinity()};
-        return point_t{inf, inf, inf};
+        constexpr scalar_t inv{detail::invalid_value<scalar_t>()};
+        return point_t{inv, inv, inv};
     }
     /// @returns the minimum bounds of the volume in global cartesian
     /// coordinates
@@ -176,8 +176,8 @@ class axis_aligned_bounding_volume {
         // If the volume shape is not supported, return universal minimum
         // (or compilation error for 2D point)
         assert(false);
-        constexpr scalar_t inf{std::numeric_limits<scalar_t>::infinity()};
-        return point3_t{-inf, -inf, -inf};
+        constexpr scalar_t inv{detail::invalid_value<scalar_t>()};
+        return point3_t{-inv, -inv, -inv};
     }
 
     /// @returns the maximum bounds of the volume in global cartesian
@@ -197,8 +197,8 @@ class axis_aligned_bounding_volume {
 
         // If the volume shape is not supported, return universal minimum
         assert(false);
-        constexpr scalar_t inf{std::numeric_limits<scalar_t>::infinity()};
-        return point3_t{inf, inf, inf};
+        constexpr scalar_t inv{detail::invalid_value<scalar_t>()};
+        return point3_t{inv, inv, inv};
     }
 
     /// @returns the geometric center position in global cartesian system
@@ -212,9 +212,9 @@ class axis_aligned_bounding_volume {
         const scalar_t center_z{
             0.5f * (m_mask[cuboid3D<>::e_max_z] + m_mask[cuboid3D<>::e_min_z])};
 
-        return {std::isinf(center_x) ? 0.f : center_x,
-                std::isinf(center_y) ? 0.f : center_y,
-                std::isinf(center_z) ? 0.f : center_z};
+        return {detail::is_invalid_value(center_x) ? 0.f : center_x,
+                detail::is_invalid_value(center_y) ? 0.f : center_y,
+                detail::is_invalid_value(center_z) ? 0.f : center_z};
     }
 
     /// @brief Lower and upper point for minimum axis aligned bounding box of
@@ -241,12 +241,14 @@ class axis_aligned_bounding_volume {
         const scalar_t scalor_z{
             (m_mask[cuboid3D<>::e_max_z] - m_mask[cuboid3D<>::e_min_z])};
 
-        // Cannot handle 'inf' propagation through the calculation for now
-        if (std::isinf(scalor_x) or std::isinf(scalor_y) or
-            std::isinf(scalor_z)) {
+        // Cannot handle 'inv' propagation through the calculation for now
+        if (detail::is_invalid_value(scalor_x) or
+            detail::is_invalid_value(scalor_y) or
+            detail::is_invalid_value(scalor_z)) {
             // If the box was infinite to begin with, it stays that way
-            assert(std::isinf(scalor_x) and std::isinf(scalor_y) and
-                   std::isinf(scalor_z));
+            assert(detail::is_invalid_value(scalor_x) and
+                   detail::is_invalid_value(scalor_y) and
+                   detail::is_invalid_value(scalor_z));
 
             return *this;
         }
@@ -270,9 +272,9 @@ class axis_aligned_bounding_volume {
         glob_c_points[7] = glob_c_points[1] - new_box_z;
 
         // Find min/max extent of the local aabb in global coordinates
-        constexpr scalar_t inf{std::numeric_limits<scalar_t>::infinity()};
-        scalar_t min_x{inf}, min_y{inf}, min_z{inf}, max_x{-inf}, max_y{-inf},
-            max_z{-inf};
+        constexpr scalar_t inv{detail::invalid_value<scalar_t>()};
+        scalar_t min_x{inv}, min_y{inv}, min_z{inv}, max_x{-inv}, max_y{-inv},
+            max_z{-inv};
         for (const point3_t& p : glob_c_points) {
             // Check every coordinate of the point
             min_x = p[0] < min_x ? p[0] : min_x;
diff --git a/core/include/detray/tools/surface_factory.hpp b/core/include/detray/tools/surface_factory.hpp
index 5efcade06..130da307b 100644
--- a/core/include/detray/tools/surface_factory.hpp
+++ b/core/include/detray/tools/surface_factory.hpp
@@ -181,7 +181,7 @@ class surface_factory : public surface_factory_interface<detector_t> {
 
                 // Append the surfaces relative to the current number of
                 // surfaces in the stores
-                const dindex sf_idx{is_invalid_value(m_indices[idx])
+                const dindex sf_idx{detail::is_invalid_value(m_indices[idx])
                                         ? dindex_invalid
                                         : m_indices[idx]};
 
diff --git a/core/include/detray/tools/surface_factory_interface.hpp b/core/include/detray/tools/surface_factory_interface.hpp
index 03c33f3d5..00d6a8350 100644
--- a/core/include/detray/tools/surface_factory_interface.hpp
+++ b/core/include/detray/tools/surface_factory_interface.hpp
@@ -133,7 +133,7 @@ class surface_factory_interface {
         container_t &cont, const typename container_t::value_type value,
         const dindex idx, Args &&... args) const {
         // If no valid position is given, perform push back
-        if (is_invalid_value(idx)) {
+        if (detail::is_invalid_value(idx)) {
             cont.push_back(value, std::forward<Args>(args)...);
 
             return static_cast<dindex>(cont.size() - 1u);
diff --git a/core/include/detray/utils/consistency_checker.hpp b/core/include/detray/utils/consistency_checker.hpp
index 79be55a68..8e87187c1 100644
--- a/core/include/detray/utils/consistency_checker.hpp
+++ b/core/include/detray/utils/consistency_checker.hpp
@@ -56,7 +56,7 @@ struct surface_checker {
         }
 
         // Does the mask link to an existing volume?
-        if (!is_invalid_value(sf.volume_link()) &&
+        if (!detail::is_invalid_value(sf.volume_link()) &&
             (sf.volume_link() >= det.volumes().size())) {
             err_stream << "ERROR: Incorrect volume link to non-existent volume "
                        << sf.volume_link();
@@ -131,7 +131,7 @@ inline void check_empty(const detector_t &det) {
     auto find_volumes =
         [](const typename detector_t::volume_finder &vf) -> bool {
         for (const auto &v : vf.all()) {
-            if (not is_invalid_value(v)) {
+            if (not detail::is_invalid_value(v)) {
                 return true;
             }
         }
diff --git a/core/include/detray/utils/inspectors.hpp b/core/include/detray/utils/inspectors.hpp
index ee33a5654..961a7d8db 100644
--- a/core/include/detray/utils/inspectors.hpp
+++ b/core/include/detray/utils/inspectors.hpp
@@ -224,7 +224,7 @@ struct print_inspector : actor {
                 break;
         };
 
-        if (is_invalid_value(navigation.volume())) {
+        if (detail::is_invalid_value(navigation.volume())) {
             printer.stream << "volume: " << std::setw(10) << "invalid";
         } else {
             printer.stream << "volume: " << std::setw(10)
diff --git a/core/include/detray/utils/invalid_values.hpp b/core/include/detray/utils/invalid_values.hpp
index 7b82ae71d..f7aa594c4 100644
--- a/core/include/detray/utils/invalid_values.hpp
+++ b/core/include/detray/utils/invalid_values.hpp
@@ -8,15 +8,14 @@
 #pragma once
 
 // Project include(s).
+#include "detray/definitions/math.hpp"
 #include "detray/definitions/qualifiers.hpp"
 
 // System include(s)
 #include <limits>
 #include <type_traits>
 
-namespace detray {
-
-namespace detail {
+namespace detray::detail {
 
 /// Invalid value for fundamental types - constexpr
 template <typename T,
@@ -34,13 +33,15 @@ DETRAY_HOST_DEVICE inline T invalid_value() noexcept {
     return T{};
 }
 
-}  // namespace detail
-
 template <typename T,
           typename std::enable_if_t<std::is_fundamental_v<T>, bool> = true>
 DETRAY_HOST_DEVICE inline constexpr bool is_invalid_value(
     const T value) noexcept {
-    return (value == detail::invalid_value<T>());
+    if constexpr (std::is_signed_v<T>) {
+        return (math_ns::abs(value) == detail::invalid_value<T>());
+    } else {
+        return (value == detail::invalid_value<T>());
+    }
 }
 
 template <typename T,
@@ -50,4 +51,4 @@ DETRAY_HOST_DEVICE inline constexpr bool is_invalid_value(
     return (value == detail::invalid_value<T>());
 }
 
-}  // namespace detray
+}  // namespace detray::detail
diff --git a/plugins/svgtools/include/detray/plugins/svgtools/utils/link_utils.hpp b/plugins/svgtools/include/detray/plugins/svgtools/utils/link_utils.hpp
index 6e1525403..ddd5f42b3 100644
--- a/plugins/svgtools/include/detray/plugins/svgtools/utils/link_utils.hpp
+++ b/plugins/svgtools/include/detray/plugins/svgtools/utils/link_utils.hpp
@@ -22,7 +22,7 @@ namespace detray::svgtools::utils {
 template <typename detector_t>
 inline auto is_not_world_portal(const detray::surface<detector_t>& d_portal) {
     const auto d_link_idx = d_portal.template visit_mask<link_getter>();
-    return !is_invalid_value(d_link_idx);
+    return !detail::is_invalid_value(d_link_idx);
 }
 
 /// @note expects that the detray surface has a volume link.
@@ -60,4 +60,4 @@ inline auto link_points(const typename detector_t::geometry_context& context,
     return std::make_tuple(start, end);
 }
 
-}  // namespace detray::svgtools::utils
\ No newline at end of file
+}  // namespace detray::svgtools::utils
diff --git a/tests/common/include/tests/common/tools/hash_tree.hpp b/tests/common/include/tests/common/tools/hash_tree.hpp
index 577ee0bc4..c562bd315 100644
--- a/tests/common/include/tests/common/tools/hash_tree.hpp
+++ b/tests/common/include/tests/common/tools/hash_tree.hpp
@@ -57,9 +57,9 @@ class hash_tree {
 
         hashed_node(hash_t hash)
             : _key(hash),
-              _parent(std::numeric_limits<dindex>::infinity()),
-              _left_child(std::numeric_limits<dindex>::infinity()),
-              _right_child(std::numeric_limits<dindex>::infinity()) {}
+              _parent(detail::invalid_value<dindex>()),
+              _left_child(detail::invalid_value<dindex>()),
+              _right_child(detail::invalid_value<dindex>()) {}
 
         hash_t _key;
         dindex _parent, _left_child, _right_child;
diff --git a/tests/unit_tests/core/utils_invalid_values.cpp b/tests/unit_tests/core/utils_invalid_values.cpp
index 0957aaa9d..9d4db198d 100644
--- a/tests/unit_tests/core/utils_invalid_values.cpp
+++ b/tests/unit_tests/core/utils_invalid_values.cpp
@@ -52,34 +52,37 @@ TEST(utils, invalid_values) {
     ASSERT_EQ(std::numeric_limits<double>::max(),
               detail::invalid_value<double>());
 
-    ASSERT_TRUE(is_invalid_value(std::numeric_limits<int>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(std::numeric_limits<int>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(
+        std::numeric_limits<std::int_least8_t>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(
+        std::numeric_limits<std::int_least16_t>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(
+        std::numeric_limits<std::int_least32_t>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(
+        std::numeric_limits<std::int_least64_t>::max()));
     ASSERT_TRUE(
-        is_invalid_value(std::numeric_limits<std::int_least8_t>::max()));
+        detail::is_invalid_value(std::numeric_limits<unsigned int>::max()));
     ASSERT_TRUE(
-        is_invalid_value(std::numeric_limits<std::int_least16_t>::max()));
+        detail::is_invalid_value(std::numeric_limits<std::size_t>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(
+        std::numeric_limits<std::uint_least8_t>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(
+        std::numeric_limits<std::uint_least16_t>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(
+        std::numeric_limits<std::uint_least32_t>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(
+        std::numeric_limits<std::uint_least64_t>::max()));
     ASSERT_TRUE(
-        is_invalid_value(std::numeric_limits<std::int_least32_t>::max()));
-    ASSERT_TRUE(
-        is_invalid_value(std::numeric_limits<std::int_least64_t>::max()));
-    ASSERT_TRUE(is_invalid_value(std::numeric_limits<unsigned int>::max()));
-    ASSERT_TRUE(is_invalid_value(std::numeric_limits<std::size_t>::max()));
-    ASSERT_TRUE(
-        is_invalid_value(std::numeric_limits<std::uint_least8_t>::max()));
-    ASSERT_TRUE(
-        is_invalid_value(std::numeric_limits<std::uint_least16_t>::max()));
-    ASSERT_TRUE(
-        is_invalid_value(std::numeric_limits<std::uint_least32_t>::max()));
-    ASSERT_TRUE(
-        is_invalid_value(std::numeric_limits<std::uint_least64_t>::max()));
-    ASSERT_TRUE(is_invalid_value(std::numeric_limits<std::uintmax_t>::max()));
-    ASSERT_TRUE(is_invalid_value(std::numeric_limits<float>::max()));
-    ASSERT_TRUE(is_invalid_value(std::numeric_limits<double>::max()));
+        detail::is_invalid_value(std::numeric_limits<std::uintmax_t>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(std::numeric_limits<float>::max()));
+    ASSERT_TRUE(detail::is_invalid_value(std::numeric_limits<double>::max()));
 
-    ASSERT_FALSE(is_invalid_value(1));
-    ASSERT_FALSE(is_invalid_value(0));
-    ASSERT_FALSE(is_invalid_value(-1));
-    ASSERT_FALSE(is_invalid_value(1u));
-    ASSERT_FALSE(is_invalid_value(1ul));
-    ASSERT_FALSE(is_invalid_value(1.));
-    ASSERT_FALSE(is_invalid_value(1.f));
+    ASSERT_FALSE(detail::is_invalid_value(1));
+    ASSERT_FALSE(detail::is_invalid_value(0));
+    ASSERT_FALSE(detail::is_invalid_value(-1));
+    ASSERT_FALSE(detail::is_invalid_value(1u));
+    ASSERT_FALSE(detail::is_invalid_value(1ul));
+    ASSERT_FALSE(detail::is_invalid_value(1.));
+    ASSERT_FALSE(detail::is_invalid_value(1.f));
 }
diff --git a/tests/unit_tests/cpu/coordinate_cylindrical2.cpp b/tests/unit_tests/cpu/coordinate_cylindrical2.cpp
index f4b85c6b8..923891d67 100644
--- a/tests/unit_tests/cpu/coordinate_cylindrical2.cpp
+++ b/tests/unit_tests/cpu/coordinate_cylindrical2.cpp
@@ -47,7 +47,7 @@ GTEST_TEST(detray_coordinates, cylindrical2) {
     const scalar charge{-1.f};
 
     const scalar r{2.f};
-    const scalar hz{std::numeric_limits<scalar>::infinity()};
+    const scalar hz{detail::invalid_value<scalar>()};
     mask<cylinder2D<>> mask{0u, r, -hz, hz};
 
     // Global to local transformation
diff --git a/tests/unit_tests/cpu/core_detector.cpp b/tests/unit_tests/cpu/core_detector.cpp
index 5d551b27a..b02074085 100644
--- a/tests/unit_tests/cpu/core_detector.cpp
+++ b/tests/unit_tests/cpu/core_detector.cpp
@@ -567,7 +567,7 @@ GTEST_TEST(detray_tools, detector_volume_construction) {
     EXPECT_EQ(vol.link<geo_obj_id::e_portal>(), acc_link);
     EXPECT_EQ(vol.link<geo_obj_id::e_passive>(), acc_link);
     // Not set by the vanilla volume builder
-    EXPECT_TRUE(is_invalid_value(vol.link<geo_obj_id::e_sensitive>()));
+    EXPECT_TRUE(detail::is_invalid_value(vol.link<geo_obj_id::e_sensitive>()));
 
     EXPECT_EQ(d.portals().size(), 19u);
     EXPECT_EQ(d.mask_store().template size<mask_id::e_portal_cylinder2>(), 2u);
diff --git a/tests/unit_tests/cpu/masks_unmasked.cpp b/tests/unit_tests/cpu/masks_unmasked.cpp
index 26b08720f..a3a494f78 100644
--- a/tests/unit_tests/cpu/masks_unmasked.cpp
+++ b/tests/unit_tests/cpu/masks_unmasked.cpp
@@ -29,12 +29,12 @@ GTEST_TEST(detray_masks, unmasked) {
     // Check bounding box
     constexpr scalar envelope{0.01f};
     const auto loc_bounds = u.local_min_bounds(envelope);
-    ASSERT_TRUE(std::isinf(loc_bounds[cuboid3D<>::e_min_x]));
-    ASSERT_TRUE(std::isinf(loc_bounds[cuboid3D<>::e_min_y]));
-    ASSERT_TRUE(std::isinf(loc_bounds[cuboid3D<>::e_min_z]));
-    ASSERT_TRUE(std::isinf(loc_bounds[cuboid3D<>::e_max_x]));
-    ASSERT_TRUE(std::isinf(loc_bounds[cuboid3D<>::e_max_y]));
-    ASSERT_TRUE(std::isinf(loc_bounds[cuboid3D<>::e_max_z]));
+    ASSERT_TRUE(detail::is_invalid_value(loc_bounds[cuboid3D<>::e_min_x]));
+    ASSERT_TRUE(detail::is_invalid_value(loc_bounds[cuboid3D<>::e_min_y]));
+    ASSERT_TRUE(detail::is_invalid_value(loc_bounds[cuboid3D<>::e_min_z]));
+    ASSERT_TRUE(detail::is_invalid_value(loc_bounds[cuboid3D<>::e_max_x]));
+    ASSERT_TRUE(detail::is_invalid_value(loc_bounds[cuboid3D<>::e_max_y]));
+    ASSERT_TRUE(detail::is_invalid_value(loc_bounds[cuboid3D<>::e_max_z]));
 
     const auto centroid = u.centroid();
     ASSERT_NEAR(centroid[0], 0.f, tol);
diff --git a/tests/unit_tests/cpu/test_core.cpp b/tests/unit_tests/cpu/test_core.cpp
index 000a0211a..7720bfed8 100644
--- a/tests/unit_tests/cpu/test_core.cpp
+++ b/tests/unit_tests/cpu/test_core.cpp
@@ -103,5 +103,5 @@ GTEST_TEST(detray_intersection, intersection) {
 
     ASSERT_NEAR(intersections[0].path, 1.7f, tol);
     ASSERT_NEAR(intersections[1].path, 2.f, tol);
-    ASSERT_TRUE(is_invalid_value(intersections[2].path));
+    ASSERT_TRUE(detail::is_invalid_value(intersections[2].path));
 }
diff --git a/tests/unit_tests/cpu/tools_helix_intersectors.cpp b/tests/unit_tests/cpu/tools_helix_intersectors.cpp
index ec885f019..0d49e6145 100644
--- a/tests/unit_tests/cpu/tools_helix_intersectors.cpp
+++ b/tests/unit_tests/cpu/tools_helix_intersectors.cpp
@@ -91,7 +91,7 @@ GTEST_TEST(detray_intersection, helix_plane_intersector_no_bfield) {
     ASSERT_NEAR(hit_bound.local[0], -1.f, tol);
     ASSERT_NEAR(hit_bound.local[1], -1.f, tol);
     // Incidence angle
-    ASSERT_TRUE(is_invalid_value(hit_bound.cos_incidence_angle));
+    ASSERT_TRUE(detail::is_invalid_value(hit_bound.cos_incidence_angle));
 
     // The same test but bound to local frame & masked - inside
     mask<rectangle2D<>> rect_for_inside{0u, 3.f, 3.f};
@@ -193,7 +193,7 @@ GTEST_TEST(detray_intersection, helix_cylinder_intersector_no_bfield) {
     // p2[0] = r * phi : 180deg in the opposite direction with r = 4
     EXPECT_NEAR(hits_bound[0].local[0], 4.f * M_PI, tol);
     EXPECT_NEAR(hits_bound[0].local[1], -5.f, tol);
-    EXPECT_TRUE(is_invalid_value(hits_bound[0].cos_incidence_angle));
+    EXPECT_TRUE(detail::is_invalid_value(hits_bound[0].cos_incidence_angle));
 
     // first intersection lies behind the track
     const auto global1 = cylinder.to_global_frame(shifted, hits_bound[1].local);
@@ -206,7 +206,7 @@ GTEST_TEST(detray_intersection, helix_cylinder_intersector_no_bfield) {
                 hits_bound[1].local[1] != not_defined);
     EXPECT_NEAR(hits_bound[1].local[0], 0.f, tol);
     EXPECT_NEAR(hits_bound[1].local[1], -5., tol);
-    EXPECT_TRUE(is_invalid_value(hits_bound[1].cos_incidence_angle));
+    EXPECT_TRUE(detail::is_invalid_value(hits_bound[1].cos_incidence_angle));
 }
 
 /// Test the intersection between a helical trajectory and a cylinder
diff --git a/tests/unit_tests/cpu/tools_navigator.cpp b/tests/unit_tests/cpu/tools_navigator.cpp
index a0ca75fb9..e9650eabd 100644
--- a/tests/unit_tests/cpu/tools_navigator.cpp
+++ b/tests/unit_tests/cpu/tools_navigator.cpp
@@ -252,7 +252,7 @@ GTEST_TEST(detray_navigator, toy_geometry) {
             // The status is: exited
             ASSERT_EQ(navigation.status(), status::e_on_target);
             // Switch to next volume leads out of the detector world -> exit
-            ASSERT_TRUE(is_invalid_value(navigation.volume()));
+            ASSERT_TRUE(detail::is_invalid_value(navigation.volume()));
             // We know we went out of the detector
             ASSERT_EQ(navigation.trust_level(), trust_level::e_full);
         } else {
@@ -403,7 +403,7 @@ GTEST_TEST(detray_navigator, wire_chamber) {
             // The status is: exited
             ASSERT_EQ(navigation.status(), status::e_on_target);
             // Switch to next volume leads out of the detector world -> exit
-            ASSERT_TRUE(is_invalid_value(navigation.volume()));
+            ASSERT_TRUE(detail::is_invalid_value(navigation.volume()));
             // We know we went out of the detector
             ASSERT_EQ(navigation.trust_level(), trust_level::e_full);
         } else {