Patched unit tests and benchmarks to adapt them to the changes in detray core

The changes required for passing geometry context to the transform store

Author: Vakho Tsulaia

tests/benchmarks/cpu/intersect_all.cpp

@@ -80,7 +80,7 @@ void BM_INTERSECT_ALL(benchmark::State &state) {
                 const auto sf = tracking_surface{d, sf_desc};
                 sf.template visit_mask<
                     intersection_initialize<ray_intersector>>(
-                    intersections, detail::ray(track), sf_desc, transforms,
+                    intersections, detail::ray(track), sf_desc, transforms, geo_context,
                     std::array<scalar_t, 2>{1.f * unit<scalar_t>::um,
                                             1.f * unit<scalar_t>::mm},
                     scalar_t{0.f});

tests/include/detray/test/validation/detector_scanner.hpp

@@ -56,7 +56,7 @@ struct brute_force_scan {
     using trajectory_type = trajectory_t;
 
     template <typename detector_t>
-    inline auto operator()(const typename detector_t::geometry_context,
+    inline auto operator()(const typename detector_t::geometry_context ctx,
                            const detector_t &detector, const trajectory_t &traj,
                            const std::array<typename detector_t::scalar_type, 2>
                                mask_tolerance = {0.f, 0.f},
@@ -89,7 +89,7 @@ struct brute_force_scan {
             // Retrieve candidate(s) from the surface
             const auto sf = tracking_surface{detector, sf_desc};
             sf.template visit_mask<intersection_kernel_t>(
-                intersections, traj, sf_desc, trf_store,
+                intersections, traj, sf_desc, trf_store, ctx,
                 sf.is_portal() ? std::array<scalar_t, 2>{0.f, 0.f}
                                : mask_tolerance);
 

tests/unit_tests/cpu/detectors/telescope_detector.cpp

@@ -46,14 +46,17 @@ using algebra_t = test::algebra;
 // dummy propagator state
 template <typename stepping_t, typename navigation_t>
 struct prop_state {
+    using context_t = typename navigation_t::detector_type::geometry_context;
 
     stepping_t _stepping;
     navigation_t _navigation;
+    context_t _context;
 
     template <typename track_t, typename field_type>
     prop_state(const track_t &t_in, const field_type &field,
-               const typename navigation_t::detector_type &det)
-        : _stepping(t_in, field), _navigation(det) {}
+               const typename navigation_t::detector_type &det,
+	       const context_t &ctx = {})
+        : _stepping(t_in, field), _navigation(det), _context(ctx) {}
 };
 
 inline constexpr bool verbose_check = true;
@@ -193,9 +196,9 @@ GTEST_TEST(detray_detectors, telescope_detector) {
     navigation_state_t &navigation_x = propgation_x._navigation;
 
     // propagate all telescopes
-    navigator_z1.init(stepping_z1(), navigation_z1, prop_cfg.navigation);
-    navigator_z2.init(stepping_z2(), navigation_z2, prop_cfg.navigation);
-    navigator_x.init(stepping_x(), navigation_x, prop_cfg.navigation);
+    navigator_z1.init(stepping_z1(), navigation_z1, prop_cfg.navigation, prop_cfg.context);
+    navigator_z2.init(stepping_z2(), navigation_z2, prop_cfg.navigation, prop_cfg.context);
+    navigator_x.init(stepping_x(), navigation_x, prop_cfg.navigation, prop_cfg.context);
 
     bool heartbeat_z1 = navigation_z1.is_alive();
     bool heartbeat_z2 = navigation_z2.is_alive();
@@ -292,7 +295,7 @@ GTEST_TEST(detray_detectors, telescope_detector) {
     stepping_state_t &tel_stepping = tel_propagation._stepping;
 
     // run propagation
-    tel_navigator.init(tel_stepping(), tel_navigation, prop_cfg.navigation);
+    tel_navigator.init(tel_stepping(), tel_navigation, prop_cfg.navigation, prop_cfg.context);
     bool heartbeat_tel = tel_navigation.is_alive();
 
     bool do_reset_tel{true};

tests/unit_tests/cpu/navigation/brute_force_finder.cpp

@@ -103,7 +103,9 @@ GTEST_TEST(detray_navigation, brute_force_search) {
     const auto [det, names] = build_toy_detector(host_mr);
 
     using detector_t = decltype(det);
-
+    using context_t = detector_t::geometry_context;
+    context_t ctx{};
+    
     struct navigation_cfg {
         std::array<dindex, 2> search_window;
     };
@@ -116,6 +118,6 @@ GTEST_TEST(detray_navigation, brute_force_search) {
     detail::ray<typename detector_t::algebra_type> trk({0.f, 0.f, 0.f}, 0.f,
                                                        {1.f, 0.f, 0.f}, -1.f);
 
-    vol.template visit_neighborhood<neighbor_visit_test>(trk, navigation_cfg{},
+    vol.template visit_neighborhood<neighbor_visit_test>(trk, navigation_cfg{}, ctx,
                                                          test_vol_idx);
 }

tests/unit_tests/cpu/navigation/intersection/intersection_kernel.cpp

@@ -161,7 +161,7 @@ GTEST_TEST(detray_intersection, intersection_kernel_ray) {
     for (const auto &surface : surfaces) {
         mask_store.visit<intersection_initialize<ray_intersector>>(
             surface.mask(), sfi_init, detail::ray(track), surface,
-            transform_store, std::array<scalar_t, 2>{tol, tol});
+            transform_store, static_context, std::array<scalar_t, 2>{tol, tol});
     }
 
     ASSERT_TRUE(expected_points.size() == sfi_init.size());
@@ -291,7 +291,7 @@ GTEST_TEST(detray_intersection, intersection_kernel_helix) {
     // Try the intersections - with automated dispatching via the kernel
     for (const auto [sf_idx, surface] : detray::views::enumerate(surfaces)) {
         mask_store.visit<intersection_initialize<helix_intersector>>(
-            surface.mask(), sfi_helix, h, surface, transform_store,
+            surface.mask(), sfi_helix, h, surface, transform_store, static_context,
             std::array<scalar_t, 2>{0.f, 0.f}, scalar_t{0.f}, scalar_t{0.f});
 
         vector3 global;

tests/unit_tests/cpu/navigation/navigator.cpp

@@ -39,8 +39,10 @@ constexpr std::size_t cache_size{navigation::default_cache_size};
 // dummy propagator state
 template <typename stepping_t, typename navigation_t>
 struct prop_state {
+    using context_t = typename navigation_t::detector_type::geometry_context;
     stepping_t _stepping;
     navigation_t _navigation;
+    context_t _context{};
 };
 
 /// Checks for a correct 'towards_surface' state
@@ -163,6 +165,7 @@ GTEST_TEST(detray_navigation, navigator_toy_geometry) {
         stepper_t::state{traj}, navigator_t::state(toy_det)};
     navigator_t::state &navigation = propagation._navigation;
     stepper_t::state &stepping = propagation._stepping;
+    const auto& ctx = propagation._context;
 
     // Check that the state is unitialized
     // Default volume is zero
@@ -180,7 +183,7 @@ GTEST_TEST(detray_navigation, navigator_toy_geometry) {
 
     // Initialize navigation
     // Test that the navigator has a heartbeat
-    nav.init(stepping(), navigation, nav_cfg);
+    nav.init(stepping(), navigation, nav_cfg, ctx);
     ASSERT_TRUE(navigation.is_alive());
     // The status is towards beampipe
     // Two candidates: beampipe and portal
@@ -358,6 +361,7 @@ GTEST_TEST(detray_navigation, navigator_wire_chamber) {
         stepper_t::state{traj}, navigator_t::state(wire_det)};
     navigator_t::state &navigation = propagation._navigation;
     stepper_t::state &stepping = propagation._stepping;
+    const auto& ctx = propagation._context;
 
     // Check that the state is unitialized
     // Default volume is zero
@@ -375,7 +379,7 @@ GTEST_TEST(detray_navigation, navigator_wire_chamber) {
 
     // Initialize navigation
     // Test that the navigator has a heartbeat
-    nav.init(stepping(), navigation, nav_cfg);
+    nav.init(stepping(), navigation, nav_cfg, ctx);
     ASSERT_TRUE(navigation.is_alive());
     // The status is towards portal
     // One candidates: barrel cylinder portal

tests/unit_tests/device/cuda/navigator_cuda.cpp

@@ -73,9 +73,10 @@ TEST(navigator_cuda, navigator) {
 
         navigator_host_t::state& navigation = propagation._navigation;
         stepper_t::state& stepping = propagation._stepping;
+	const auto& ctx = propagation._context;
 
         // Start propagation and record volume IDs
-        nav.init(stepping(), navigation, nav_cfg);
+        nav.init(stepping(), navigation, nav_cfg, ctx);
         bool heartbeat = navigation.is_alive();
         bool do_reset{true};
 

tests/unit_tests/device/cuda/navigator_cuda_kernel.cu

@@ -41,12 +41,13 @@ __global__ void navigator_test_kernel(
 
     navigator_device_t::state& navigation = propagation._navigation;
     stepper_t::state& stepping = propagation._stepping;
+    const auto& ctx = propagation._context;
 
     // Set initial volume
     navigation.set_volume(0u);
 
     // Start propagation and record volume IDs
-    nav.init(stepping(), navigation, nav_cfg);
+    nav.init(stepping(), navigation, nav_cfg, ctx);
     bool heartbeat = navigation.is_alive();
     bool do_reset{true};
 

tests/unit_tests/device/cuda/navigator_cuda_kernel.hpp

@@ -47,8 +47,10 @@ constexpr dscalar<algebra_t> pos_diff_tolerance{1e-3f};
 // dummy propagator state
 template <typename navigation_t>
 struct prop_state {
+    using context_t = typename navigation_t::detector_type::geometry_context;
     stepper_t::state _stepping;
     navigation_t _navigation;
+    context_t _context{};
 };
 
 /// test function for navigator with single state