fix: Navigation assertions in validation tools

core/include/detray/navigation/navigation_config.hpp

@@ -32,14 +32,14 @@ struct config {
     /// Minimal tolerance: ~ position uncertainty on surface
     float min_mask_tolerance{1e-5f * unit<float>::mm};
     /// Maximal tolerance: loose tolerance when still far away from surface
-    float max_mask_tolerance{1.f * unit<float>::mm};
+    float max_mask_tolerance{3.f * unit<float>::mm};
     /// Scale factor on the path used for the mask tolerance calculation
     float mask_tolerance_scalor{5e-2f};
     /// @}
     /// Maximal absolute path distance for a track to be considered 'on surface'
     float path_tolerance{1.f * unit<float>::um};
     /// How far behind the track position to look for candidates
-    float overstep_tolerance{-100.f * unit<float>::um};
+    float overstep_tolerance{-300.f * unit<float>::um};
     /// Search window size for grid based acceleration structures
     /// (0, 0): only look at current bin
     std::array<dindex, 2> search_window = {0u, 0u};

core/include/detray/navigation/navigator.hpp

@@ -706,7 +706,8 @@ class navigator {
 
             init(propagation, cfg);
 
-            // Fresh initialization, reset trust and hearbeat
+            // Fresh initialization, reset trust and hearbeat even though we are
+            // on inner portal
             navigation.m_trust_level = navigation::trust_level::e_full;
             navigation.m_heartbeat = true;
 
@@ -717,9 +718,16 @@ class navigator {
         navigation.m_heartbeat &= init(propagation, cfg);
 
         // Sanity check: Should never be the case after complete update call
-        if (navigation.trust_level() != navigation::trust_level::e_full ||
-            navigation.is_exhausted()) {
-            navigation.abort();
+        if (navigation.trust_level() != navigation::trust_level::e_full) {
+            // Try to save the navigation flow: Look further behind the track
+            auto loose_cfg{cfg};
+            loose_cfg.overstep_tolerance = -10.f * cfg.max_mask_tolerance;
+            navigation.m_heartbeat &= init(propagation, loose_cfg);
+
+            // Unrecoverable
+            if (navigation.trust_level() != navigation::trust_level::e_full) {
+                navigation.abort();
+            }
         }
 
         return navigation.m_heartbeat;

core/include/detray/propagator/line_stepper.hpp

@@ -91,7 +91,7 @@ class line_stepper final
     /// @return returning the heartbeat, indicating if the stepping is alive
     template <typename propagation_state_t>
     DETRAY_HOST_DEVICE bool step(propagation_state_t& propagation,
-                                 const stepping::config& cfg = {}) const {
+                                 const stepping::config& cfg) const {
         // Get stepper and navigator states
         state& stepping = propagation._stepping;
         auto& navigation = propagation._navigation;
@@ -125,7 +125,9 @@ class line_stepper final
         stepping.advance_track();
 
         // Advance jacobian transport
-        stepping.advance_jacobian();
+        if (cfg.do_covariance_transport) {
+            stepping.advance_jacobian();
+        }
 
         // Count the number of steps
         stepping.count_trials();

core/include/detray/propagator/propagator.hpp

@@ -52,7 +52,7 @@ struct propagator {
 
     /// Construct from a propagator configuration
     DETRAY_HOST_DEVICE
-    explicit constexpr propagator(const propagation::config &cfg = {})
+    explicit constexpr propagator(const propagation::config &cfg)
         : m_cfg{cfg} {}
 
     /// Propagation that state aggregates a stepping and a navigation state. It

io/include/detray/io/csv/track_parameters.hpp

@@ -134,7 +134,9 @@ inline void write_free_track_params(
         for (const auto &[charge, track_param] : track_params) {
 
             const auto &glob_pos = track_param.pos();
-            const auto &p = track_param.mom(charge);
+            // Momentum may not be retrievable for straight-line tracks
+            const auto &p{charge != 0.f ? track_param.mom(charge)
+                                        : track_param.dir()};
 
             io::csv::free_track_parameters track_param_data{};
             track_param_data.track_id = track_idx;

tests/include/detray/test/utils/inspectors.hpp

@@ -264,6 +264,8 @@ struct print_inspector {
         debug_stream << msg << std::endl;
 
         debug_stream << "Volume" << tabs << state.volume() << std::endl;
+        debug_stream << "Overstep tol:\t\t\t" << cfg.overstep_tolerance
+                     << std::endl;
         debug_stream << "Track pos: [r:" << getter::perp(track_pos)
                      << ", z:" << track_pos[2] << "], dir: [" << track_dir[0]
                      << ", " << track_dir[1] << ", " << track_dir[2] << "]"

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

@@ -92,13 +92,21 @@ struct step_tracer : actor {
         const auto& navigation = prop_state._navigation;
         const auto& stepping = prop_state._stepping;
 
+        const bool is_on_sf{navigation.is_on_module() ||
+                            navigation.is_on_portal()};
+
         // Collect the data whenever requested
-        if (navigation.is_on_module() || navigation.is_on_portal() ||
-            tracer_state.m_collect_every_step) {
+        if (is_on_sf || tracer_state.m_collect_every_step) {
+
+            const geometry::barcode bcd{is_on_sf ? navigation.barcode()
+                                                 : geometry::barcode{}};
 
-            step_data_t sd{stepping.step_size(),         stepping.path_length(),
-                           stepping.n_total_trials(),    navigation.direction(),
-                           navigation.barcode(),         stepping(),
+            step_data_t sd{stepping.step_size(),
+                           stepping.path_length(),
+                           stepping.n_total_trials(),
+                           navigation.direction(),
+                           bcd,
+                           stepping(),
                            stepping.transport_jacobian()};
 
             tracer_state.m_steps.push_back(std::move(sd));

tests/integration_tests/cpu/detectors/telescope_detector_navigation.cpp

@@ -100,7 +100,7 @@ int main(int argc, char **argv) {
     cfg_hel_nav.name("telescope_detector_helix_navigation");
     cfg_hel_nav.whiteboard(white_board);
     cfg_hel_nav.propagation().navigation.overstep_tolerance =
-        -300.f * unit<float>::um;
+        -100.f * unit<float>::um;
 
     detail::register_checks<test::helix_navigation>(tel_det, tel_names,
                                                     cfg_hel_nav);

tests/integration_tests/cpu/material/material_interaction.cpp

@@ -79,7 +79,9 @@ GTEST_TEST(detray_material, telescope_geometry_energy_loss) {
     using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 
     // Propagator is built from the stepper and navigator
-    propagator_t p{};
+    propagation::config prop_cfg{};
+    prop_cfg.navigation.overstep_tolerance = -100.f * unit<float>::um;
+    propagator_t p{prop_cfg};
 
     constexpr scalar q{-1.f};
     constexpr scalar iniP{10.f * unit<scalar>::GeV};
@@ -193,7 +195,7 @@ GTEST_TEST(detray_material, telescope_geometry_energy_loss) {
             interactor_state, parameter_resetter_state);
 
         // Propagator and its state
-        alt_propagator_t alt_p{};
+        alt_propagator_t alt_p{prop_cfg};
         alt_propagator_t::state alt_state(alt_bound_param, det);
 
         // Propagate
@@ -251,7 +253,9 @@ GTEST_TEST(detray_material, telescope_geometry_scattering_angle) {
     using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 
     // Propagator is built from the stepper and navigator
-    propagator_t p{};
+    propagation::config prop_cfg{};
+    prop_cfg.navigation.overstep_tolerance = -100.f * unit<float>::um;
+    propagator_t p{prop_cfg};
 
     constexpr scalar q{-1.f};
     constexpr scalar iniP{10.f * unit<scalar>::GeV};
@@ -381,7 +385,9 @@ GTEST_TEST(detray_material, telescope_geometry_volume_material) {
         using propagator_t = propagator<stepper_t, navigator_t, actor_chain_t>;
 
         // Propagator is built from the stepper and navigator
-        propagator_t p{};
+        propagation::config prop_cfg{};
+        prop_cfg.navigation.overstep_tolerance = -100.f * unit<float>::um;
+        propagator_t p{prop_cfg};
 
         propagator_t::state state(bound_param, const_bfield, det);
 

tests/integration_tests/cpu/propagator/guided_navigator.cpp

@@ -81,7 +81,8 @@ GTEST_TEST(detray_navigation, guided_navigator) {
     pathlimit_aborter::state pathlimit{200.f * unit<scalar_t>::cm};
 
     // Propagator
-    propagator_t p{};
+    propagation::config prop_cfg{};
+    propagator_t p{prop_cfg};
     propagator_t::state guided_state(track, b_field, telescope_det);
 
     // Propagate

tests/integration_tests/cpu/propagator/propagator.cpp

@@ -136,7 +136,8 @@ GTEST_TEST(detray_propagator, propagator_line_stepper) {
     const vector3 mom{1.f, 1.f, 0.f};
     free_track_parameters<algebra_t> track(pos, 0.f, mom, -1.f);
 
-    propagator_t p{};
+    propagation::config prop_cfg{};
+    propagator_t p{prop_cfg};
 
     propagator_t::state state(track, d);
 
@@ -384,23 +385,23 @@ INSTANTIATE_TEST_SUITE_P(
 INSTANTIATE_TEST_SUITE_P(
     detray_propagator_validation2, PropagatorWithRkStepper,
     ::testing::Values(std::make_tuple(-400.f * unit<scalar_t>::um,
-                                      40.f * unit<scalar_t>::mm,
+                                      std::numeric_limits<scalar_t>::max(),
                                       vector3{0.f * unit<scalar_t>::T,
                                               1.f * unit<scalar_t>::T,
                                               1.f * unit<scalar_t>::T})));
 
 INSTANTIATE_TEST_SUITE_P(
     detray_propagator_validation3, PropagatorWithRkStepper,
     ::testing::Values(std::make_tuple(-400.f * unit<scalar_t>::um,
-                                      40.f * unit<scalar_t>::mm,
+                                      std::numeric_limits<scalar_t>::max(),
                                       vector3{1.f * unit<scalar_t>::T,
                                               0.f * unit<scalar_t>::T,
                                               1.f * unit<scalar_t>::T})));
 
 INSTANTIATE_TEST_SUITE_P(
     detray_propagator_validation4, PropagatorWithRkStepper,
     ::testing::Values(std::make_tuple(-600.f * unit<scalar_t>::um,
-                                      35.f * unit<scalar_t>::mm,
+                                      std::numeric_limits<scalar_t>::max(),
                                       vector3{1.f * unit<scalar_t>::T,
                                               1.f * unit<scalar_t>::T,
                                               1.f * unit<scalar_t>::T})));

tests/integration_tests/device/cuda/propagator_cuda.cpp

@@ -97,26 +97,29 @@ INSTANTIATE_TEST_SUITE_P(
                                                 0.f * unit<scalar_t>::T,
                                                 2.f * unit<scalar_t>::T})));
 
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation2, CudaPropConstBFieldMng,
-                         ::testing::Values(std::make_tuple(
-                             -400.f * unit<float>::um, 40.f * unit<float>::mm,
-                             vector3_t{0.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T})));
-
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation3, CudaPropConstBFieldMng,
-                         ::testing::Values(std::make_tuple(
-                             -400.f * unit<float>::um, 40.f * unit<float>::mm,
-                             vector3_t{1.f * unit<scalar_t>::T,
-                                       0.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T})));
-
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation4, CudaPropConstBFieldMng,
-                         ::testing::Values(std::make_tuple(
-                             -600.f * unit<float>::um, 35.f * unit<float>::mm,
-                             vector3_t{1.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T})));
+INSTANTIATE_TEST_SUITE_P(
+    CudaPropagatorValidation2, CudaPropConstBFieldMng,
+    ::testing::Values(std::make_tuple(-400.f * unit<float>::um,
+                                      std::numeric_limits<float>::max(),
+                                      vector3_t{0.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T})));
+
+INSTANTIATE_TEST_SUITE_P(
+    CudaPropagatorValidation3, CudaPropConstBFieldMng,
+    ::testing::Values(std::make_tuple(-400.f * unit<float>::um,
+                                      std::numeric_limits<float>::max(),
+                                      vector3_t{1.f * unit<scalar_t>::T,
+                                                0.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T})));
+
+INSTANTIATE_TEST_SUITE_P(
+    CudaPropagatorValidation4, CudaPropConstBFieldMng,
+    ::testing::Values(std::make_tuple(-600.f * unit<float>::um,
+                                      std::numeric_limits<float>::max(),
+                                      vector3_t{1.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T})));
 
 INSTANTIATE_TEST_SUITE_P(
     CudaPropagatorValidation5, CudaPropConstBFieldCpy,
@@ -126,26 +129,29 @@ INSTANTIATE_TEST_SUITE_P(
                                                 0.f * unit<scalar_t>::T,
                                                 2.f * unit<scalar_t>::T})));
 
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation6, CudaPropConstBFieldCpy,
-                         ::testing::Values(std::make_tuple(
-                             -400.f * unit<float>::um, 40.f * unit<float>::mm,
-                             vector3_t{0.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T})));
-
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation7, CudaPropConstBFieldCpy,
-                         ::testing::Values(std::make_tuple(
-                             -400.f * unit<float>::um, 40.f * unit<float>::mm,
-                             vector3_t{1.f * unit<scalar_t>::T,
-                                       0.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T})));
-
-INSTANTIATE_TEST_SUITE_P(CudaPropagatorValidation8, CudaPropConstBFieldCpy,
-                         ::testing::Values(std::make_tuple(
-                             -600.f * unit<float>::um, 35.f * unit<float>::mm,
-                             vector3_t{1.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T,
-                                       1.f * unit<scalar_t>::T})));
+INSTANTIATE_TEST_SUITE_P(
+    CudaPropagatorValidation6, CudaPropConstBFieldCpy,
+    ::testing::Values(std::make_tuple(-400.f * unit<float>::um,
+                                      std::numeric_limits<float>::max(),
+                                      vector3_t{0.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T})));
+
+INSTANTIATE_TEST_SUITE_P(
+    CudaPropagatorValidation7, CudaPropConstBFieldCpy,
+    ::testing::Values(std::make_tuple(-400.f * unit<float>::um,
+                                      std::numeric_limits<float>::max(),
+                                      vector3_t{1.f * unit<scalar_t>::T,
+                                                0.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T})));
+
+INSTANTIATE_TEST_SUITE_P(
+    CudaPropagatorValidation8, CudaPropConstBFieldCpy,
+    ::testing::Values(std::make_tuple(-600.f * unit<float>::um,
+                                      std::numeric_limits<float>::max(),
+                                      vector3_t{1.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T,
+                                                1.f * unit<scalar_t>::T})));
 
 /// This tests the device propagation in an inhomogenepus magnetic field
 TEST(CudaPropagatorValidation9, inhomogeneous_bfield_cpy) {

tests/integration_tests/device/cuda/telescope_navigation_validation.cpp

@@ -105,7 +105,7 @@ int main(int argc, char **argv) {
     cfg_hel_nav.name("telescope_detector_helix_navigation_cuda");
     cfg_hel_nav.whiteboard(white_board);
     cfg_hel_nav.propagation().navigation.overstep_tolerance =
-        -300.f * unit<float>::um;
+        -100.f * unit<float>::um;
 
     detail::register_checks<detray::cuda::helix_navigation>(tel_det, tel_names,
                                                             cfg_hel_nav);