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 {