new stuff

Author: niermann999

CMakeLists.txt

@@ -52,6 +52,10 @@ include( traccc-functions )
 set( TRACCC_CUSTOM_SCALARTYPE "float" CACHE STRING
    "Scalar type to use in the TRACCC code" )
 
+# Temporary setting for the traccc device log level, until it can be removed.
+set( TRACCC_DEVICE_LOG_LVL "NONE" CACHE STRING
+   "Log level for traccc and detray device code" )
+
 # Flags controlling which parts of traccc to build.
 option( TRACCC_BUILD_CUDA "Build the CUDA sources included in traccc" FALSE )
 option( TRACCC_BUILD_HIP "Build the HIP sources included in traccc" FALSE)

core/include/traccc/finding/actors/ckf_aborter.hpp

@@ -10,8 +10,10 @@
 // Project include(s)
 #include "traccc/definitions/primitives.hpp"
 #include "traccc/definitions/qualifiers.hpp"
+#include "traccc/utils/logging.hpp"
 
 // detray include(s)
+#include <detray/definitions/indexing.hpp>
 #include <detray/propagator/base_actor.hpp>
 
 // System include(s)
@@ -24,37 +26,55 @@ struct ckf_aborter : detray::actor {
     struct state {
         // minimal step length to prevent from staying on the same surface
         scalar min_step_length = 0.5f;
+
         /// Maximum step counts that track can make to reach the next surface
-        unsigned int max_count = 100;
+        unsigned int max_count = 100u;
+        unsigned int count = 0u;
 
-        bool success = false;
-        unsigned int count = 0;
+        /// Previous sensitive surface index
+        detray::dindex prev_surface_index{detray::dindex_invalid};
+        /// Current sensitive surface index
+        detray::dindex surface_index{detray::dindex_invalid};
 
-        scalar path_from_surface{0.f};
+        /// Whether a surface was found
+        bool success = false;
     };
 
     template <typename propagator_state_t>
     TRACCC_HOST_DEVICE void operator()(state &abrt_state,
                                        propagator_state_t &prop_state) const {
 
         auto &navigation = prop_state._navigation;
-        const auto &stepping = prop_state._stepping;
 
         abrt_state.count++;
-        abrt_state.path_from_surface += stepping.step_size();
 
-        // Stop at the next sensitive surface
-        if (navigation.is_on_sensitive() &&
-            abrt_state.path_from_surface > abrt_state.min_step_length) {
-            prop_state._heartbeat &= navigation.pause();
-            abrt_state.success = navigation.is_alive();
-        }
+        TRACCC_VERBOSE_HOST_DEVICE("Checking CKF aborter...");
+        TRACCC_DEBUG_HOST_DEVICE("=> second last sensitive: %d",
+                                 abrt_state.prev_surface_index);
+        TRACCC_DEBUG_HOST_DEVICE("=> last sensitive: %d",
+                                 abrt_state.surface_index);
 
-        // Reset path from surface
-        if (navigation.is_on_sensitive()) {
-            abrt_state.path_from_surface = 0.f;
+        // Is this a valid sensitive surface to run the CKF on?
+        const detray::dindex sf_idx{navigation.barcode().index()};
+        if (!navigation.is_on_sensitive() ||
+            (abrt_state.surface_index == sf_idx) ||
+            (abrt_state.prev_surface_index == sf_idx)) {
+            return;
         }
 
+        // Update the visited sensitive surfaces and pause the propagation
+        abrt_state.prev_surface_index = abrt_state.surface_index;
+        abrt_state.surface_index = sf_idx;
+
+        TRACCC_VERBOSE_HOST_DEVICE("Found surface: %d",
+                                   abrt_state.surface_index);
+
+        prop_state._heartbeat &= navigation.pause();
+        abrt_state.success = true;
+
+        assert(abrt_state.surface_index <
+               navigation.detector().surfaces().size());
+
         if (abrt_state.count > abrt_state.max_count) {
             prop_state._heartbeat &= navigation.abort(
                 "CKF: Maximum number of steps to reach next sensitive surface "

core/include/traccc/finding/details/combinatorial_kalman_filter.hpp

@@ -7,8 +7,6 @@
 #pragma once
 
 // Project include(s).
-#include <detray/utils/log.hpp>
-
 #include "traccc/edm/measurement.hpp"
 #include "traccc/edm/track_candidate_collection.hpp"
 #include "traccc/edm/track_state_helpers.hpp"
@@ -17,6 +15,7 @@
 #include "traccc/finding/candidate_link.hpp"
 #include "traccc/finding/details/combinatorial_kalman_filter_types.hpp"
 #include "traccc/finding/finding_config.hpp"
+#include "traccc/finding/propagation_data.hpp"
 #include "traccc/fitting/kalman_filter/gain_matrix_updater.hpp"
 #include "traccc/fitting/kalman_filter/is_line_visitor.hpp"
 #include "traccc/fitting/status_codes.hpp"
@@ -73,6 +72,8 @@ combinatorial_kalman_filter(
            "overstep tolerance");
     assert(config.min_track_candidates_per_track >= 1);
 
+    const float chi2_min{math::max(10.f, 0.1f * config.chi2_max)};
+
     /// The algebra type
     using algebra_type = typename detector_t::algebra_type;
     /// The scalar type
@@ -128,8 +129,11 @@ combinatorial_kalman_filter(
     std::vector<std::pair<unsigned int, unsigned int>> tips;
 
     // Create propagator
+    // @TODO: Turn off the mask tolerance scaling for now
+    auto prop_config{config.propagation};
+    prop_config.navigation.estimate_scattering_noise = false;
     traccc::details::ckf_propagator_t<detector_t, bfield_t> propagator(
-        config.propagation);
+        prop_config);
 
     // Create the input seeds container.
     bound_track_parameters_collection_types::const_device seeds{seeds_view};
@@ -141,20 +145,19 @@ combinatorial_kalman_filter(
 
     std::vector<bound_track_parameters<algebra_type>> out_params;
 
-    std::vector<std::uint8_t> in_is_edge(seeds.size(), false);
-    std::vector<std::uint8_t> out_is_edge;
+    std::vector<propagation_data> in_prop_data(seeds.size());
+    std::vector<propagation_data> out_prop_data;
 
     for (unsigned int step = 0u; step < config.max_track_candidates_per_track;
          step++) {
 
-        DETRAY_DEBUG_HOST("PRPGAGATION STEP: " << step);
         TRACCC_VERBOSE("Starting step "
                        << step + 1 << " / "
                        << config.max_track_candidates_per_track);
 
         // Iterate over input parameters
         const std::size_t n_in_params = in_params.size();
-        DETRAY_DEBUG_HOST("# PARAMS: " << n_in_params);
+        TRACCC_VERBOSE("No. Params: " << n_in_params);
 
         // Terminate if there is no parameter to proceed
         if (n_in_params == 0) {
@@ -163,23 +166,22 @@ combinatorial_kalman_filter(
 
         // Rough estimation on out parameters size
         out_params.reserve(n_in_params);
-        out_is_edge.reserve(n_in_params);
+        out_prop_data.reserve(n_in_params);
 
         // Previous step ID
         std::fill(n_trks_per_seed.begin(), n_trks_per_seed.end(), 0u);
 
         // Parameters updated by Kalman fitter
         std::vector<bound_track_parameters<algebra_type>> updated_params;
+        std::vector<propagation_data> updated_prop_data;
 
         for (unsigned int in_param_id = 0; in_param_id < n_in_params;
              in_param_id++) {
 
             bound_track_parameters<algebra_type>& in_param =
                 in_params[in_param_id];
 
-            DETRAY_DEBUG_HOST("PARAMS: " << in_param);
-
-            const bool is_edge{in_is_edge[in_param_id] > 0u};
+            const propagation_data& prop_data = in_prop_data[in_param_id];
 
             assert(!in_param.is_invalid());
 
@@ -256,9 +258,9 @@ combinatorial_kalman_filter(
                 best_links;
 
             // Iterate over the measurements
-            DETRAY_DEBUG_HOST("# MEAS: " << (up - lo));
+            TRACCC_VERBOSE("No. measurements: " << (up - lo));
             for (unsigned int meas_id = lo; meas_id < up; meas_id++) {
-                DETRAY_DEBUG_HOST("TESTING MEAS: " << meas_id);
+                TRACCC_DEBUG("Testing measurement: " << meas_id);
 
                 // The measurement on surface to handle.
                 const measurement& meas = measurements.at(meas_id);
@@ -276,13 +278,14 @@ combinatorial_kalman_filter(
 
                 const traccc::scalar chi2 = trk_state.filtered_chi2();
 
-                DETRAY_DEBUG_HOST("KF STATUS: " << fitter_debug_msg{res}());
+                TRACCC_DEBUG("KF status: " << fitter_debug_msg{res}());
 
                 // The chi2 from Kalman update should be less than chi2_max
                 if (res == kalman_fitter_status::SUCCESS &&
-                    chi2 < config.chi2_max) {
+                    ((!prop_data.is_edge && chi2 <= config.chi2_max) ||
+                     (chi2 <= chi2_min))) {
 
-                    DETRAY_DEBUG_HOST("FOUND MEAS: " << meas_id);
+                    TRACCC_VERBOSE("Found measurement: " << meas_id);
 
                     best_links.push_back(
                         {{.step = step,
@@ -319,9 +322,10 @@ combinatorial_kalman_filter(
 
                 // Add the updated parameter to the updated parameters
                 updated_params.push_back(filtered_params);
-                TRACCC_VERBOSE("updated_params["
-                               << updated_params.size() - 1
-                               << "] = " << updated_params.back());
+                updated_prop_data.push_back(prop_data);
+                TRACCC_DEBUG("updated_params["
+                             << updated_params.size() - 1
+                             << "] = " << updated_params.back());
             }
 
             /*****************************************************************
@@ -336,19 +340,22 @@ combinatorial_kalman_filter(
                      .previous_candidate_idx = in_param_id,
                      .meas_idx = std::numeric_limits<unsigned int>::max(),
                      .seed_idx = orig_param_id,
-                     .n_skipped = is_edge ? skip_counter : skip_counter + 1,
-                     .n_consecutive_skipped = consecutive_skipped + 1,
                      .n_cand = n_cand,
+                     .n_skipped =
+                         prop_data.is_edge ? skip_counter : skip_counter + 1,
+                     .n_consecutive_skipped = consecutive_skipped + 1,
                      .chi2 = std::numeric_limits<traccc::scalar>::max(),
                      .chi2_sum = prev_chi2_sum,
                      .ndf_sum = prev_ndf_sum});
 
-                DETRAY_DEBUG_HOST("HOLE: " << std::boolalpha << !is_edge);
+                TRACCC_VERBOSE("Is hole: " << std::boolalpha
+                                           << !prop_data.is_edge);
 
                 updated_params.push_back(in_param);
-                TRACCC_VERBOSE("updated_params["
-                               << updated_params.size() - 1
-                               << "] = " << updated_params.back());
+                updated_prop_data.push_back(prop_data);
+                TRACCC_DEBUG("updated_params["
+                             << updated_params.size() - 1
+                             << "] = " << updated_params.back());
             }
         }
 
@@ -465,7 +472,7 @@ combinatorial_kalman_filter(
                         }
 
                         if (this_is_dominated) {
-                            DETRAY_DEBUG_HOST("Track is DEAD!");
+                            TRACCC_VERBOSE("Track is dead (deduplication)!");
                             param_liveness.at(tracks.at(i)) = 0u;
                             break;
                         }
@@ -491,15 +498,20 @@ combinatorial_kalman_filter(
 
             // If number of skips is larger than the maximum value, consider the
             // link to be a tip
-            if (links.at(step).at(link_id).n_skipped >
-                config.max_num_skipping_per_cand) {
+            if ((links.at(step).at(link_id).n_skipped >
+                 config.max_num_skipping_per_cand) ||
+                (links.at(step).at(link_id).n_consecutive_skipped >
+                 config.max_num_consecutive_skipped)) {
 
-                DETRAY_DEBUG_HOST("MAKE TIP: MAX NO. HOLES");
+                TRACCC_WARNING("Create tip: max no. of holes reached");
                 tips.push_back({step, link_id});
                 continue;
             }
 
+            assert(updated_params.size() == updated_prop_data.size());
             const auto& param = updated_params[link_id];
+            const propagation_data& prop_data = updated_prop_data[link_id];
+
             // Create propagator state
             typename traccc::details::ckf_propagator_t<
                 detector_t, bfield_t>::state propagation(param, field, det);
@@ -515,23 +527,25 @@ combinatorial_kalman_filter(
             typename interaction_register<
                 traccc::details::ckf_interactor_t>::state s1{s2};
             typename detray::parameter_resetter<
-                typename detector_t::algebra_type>::state s3{
-                config.propagation};
+                typename detector_t::algebra_type>::state s3{prop_config};
             typename detray::momentum_aborter<scalar_type>::state s4{};
-            typename ckf_aborter::state s5;
+            typename ckf_aborter::state s5{};
+
             // Update the actor config
             s4.min_pT(static_cast<scalar_type>(config.min_pT));
             s4.min_p(static_cast<scalar_type>(config.min_p));
+            s5.prev_surface_index = prop_data.prev_surface;
+            s5.surface_index = param.surface_link().index();
             s5.min_step_length = config.min_step_length_for_next_surface;
             s5.max_count = config.max_step_counts_for_next_surface;
 
-            DETRAY_DEBUG_HOST("PROPAGATING... ");
+            TRACCC_DEBUG("Propagating... ");
             // Propagate to the next surface
             propagator.propagate(propagation,
                                  detray::tie(s0, s1, s2, s3, s4, s5));
 
-            DETRAY_DEBUG_HOST(
-                "FINISHED PROPAGATING. PATH:  " << s5.path_from_surface);
+            TRACCC_DEBUG("Finished propagation: On surface "
+                         << s5.surface_index);
 
             // If a surface found, add the parameter for the next
             // step
@@ -540,32 +554,32 @@ combinatorial_kalman_filter(
                 assert(!propagation._stepping.bound_params().is_invalid());
 
                 out_params.push_back(propagation._stepping.bound_params());
-                out_is_edge.push_back(
+                out_prop_data.emplace_back(
+                    s5.prev_surface_index,
                     propagation._navigation.is_edge_candidate());
                 param_to_link[step].push_back(link_id);
             }
             // Unless the track found a surface, it is considered a
             // tip
             else if (!s5.success &&
                      (step >= (config.min_track_candidates_per_track - 1u))) {
-
-                DETRAY_DEBUG_HOST("MAKE TIP: NO SENSITIVE");
+                TRACCC_VERBOSE("Create tip: No next sensitive found");
                 tips.push_back({step, link_id});
             }
 
             // If no more CKF step is expected, current candidate is
             // kept as a tip
             if (s5.success &&
                 (step == (config.max_track_candidates_per_track - 1u))) {
-                DETRAY_DEBUG_HOST("MAKE TIP: MAX CANDIDATES");
+                TRACCC_ERROR("Create tip: Max no. candidates");
                 tips.push_back({step, link_id});
             }
         }
 
         in_params = std::move(out_params);
-        in_is_edge = std::move(out_is_edge);
+        in_prop_data = std::move(out_prop_data);
         out_params.clear();
-        out_is_edge.clear();
+        out_prop_data.clear();
     }
 
     /**********************

core/include/traccc/finding/propagation_data.hpp

@@ -0,0 +1,25 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Detray include(s).
+#include <detray/definitions/indexing.hpp>
+
+namespace traccc {
+
+/// Data from the propagation loop that has to be kept between CKF steps
+struct propagation_data {
+    /// The surface that was visited before the current one (overlaps
+    /// resolution)
+    detray::dindex prev_surface{detray::dindex_invalid};
+
+    /// Is the current surface hit in the extended tolerance band?
+    bool is_edge{false};
+};
+
+}  // namespace traccc