new stuff

Author: niermann999

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

@@ -12,7 +12,9 @@
 #include "traccc/definitions/qualifiers.hpp"
 
 // detray include(s)
+#include <detray/definitions/indexing.hpp>
 #include <detray/propagator/base_actor.hpp>
+#include <detray/utils/log.hpp>
 
 // System include(s)
 #include <limits>
@@ -24,35 +26,34 @@ 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;
 
+        detray::dindex surface_index{detray::dindex_invalid};
         bool success = false;
-        unsigned int count = 0;
-
-        scalar path_from_surface{0.f};
     };
 
     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();
+
+        DETRAY_DEBUG_HOST("Checking CKF aborter...");
+        DETRAY_DEBUG_HOST("=> last sensitive: " << abrt_state.surface_index);
 
         // 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();
-        }
+            (abrt_state.surface_index != navigation.barcode().index())) {
+            abrt_state.surface_index = navigation.barcode().index();
 
-        // Reset path from surface
-        if (navigation.is_on_sensitive()) {
-            abrt_state.path_from_surface = 0.f;
+            DETRAY_DEBUG_HOST("FOUND SURFACE : " << abrt_state.surface_index);
+            prop_state._heartbeat &= navigation.pause();
+            abrt_state.success = true;
         }
 
         if (abrt_state.count > abrt_state.max_count) {

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

@@ -128,6 +128,8 @@ combinatorial_kalman_filter(
     std::vector<std::pair<unsigned int, unsigned int>> tips;
 
     // Create propagator
+    // auto config_alt{config.propagation};
+    // config_alt.navigation.estimate_scattering_noise = false;
     traccc::details::ckf_propagator_t<detector_t, bfield_t> propagator(
         config.propagation);
 
@@ -336,9 +338,9 @@ combinatorial_kalman_filter(
                      .previous_candidate_idx = in_param_id,
                      .meas_idx = std::numeric_limits<unsigned int>::max(),
                      .seed_idx = orig_param_id,
+                     .n_cand = n_cand,
                      .n_skipped = is_edge ? skip_counter : skip_counter + 1,
                      .n_consecutive_skipped = consecutive_skipped + 1,
-                     .n_cand = n_cand,
                      .chi2 = std::numeric_limits<traccc::scalar>::max(),
                      .chi2_sum = prev_chi2_sum,
                      .ndf_sum = prev_ndf_sum});
@@ -519,9 +521,11 @@ combinatorial_kalman_filter(
                 config.propagation};
             typename detray::momentum_aborter<scalar_type>::state s4{};
             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.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;
 
@@ -531,7 +535,7 @@ combinatorial_kalman_filter(
                                  detray::tie(s0, s1, s2, s3, s4, s5));
 
             DETRAY_DEBUG_HOST(
-                "FINISHED PROPAGATING. PATH:  " << s5.path_from_surface);
+                "FINISHED PROPAGATING. SF:  " << s5.surface_index);
 
             // If a surface found, add the parameter for the next
             // step

core/include/traccc/finding/finding_config.hpp

@@ -27,7 +27,7 @@ struct finding_config {
 
     /// Min/Max number of track candidates per track
     unsigned int min_track_candidates_per_track = 3;
-    unsigned int max_track_candidates_per_track = 100;
+    unsigned int max_track_candidates_per_track = 200;
 
     /// Maximum allowed number of skipped steps per candidate
     unsigned int max_num_skipping_per_cand = 3;

core/include/traccc/fitting/kalman_filter/gain_matrix_updater.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 // Project include(s).
+#include <detray/utils/log.hpp>
+
 #include "traccc/definitions/qualifiers.hpp"
 #include "traccc/definitions/track_parametrization.hpp"
 #include "traccc/edm/measurement.hpp"
@@ -161,6 +163,11 @@ struct gain_matrix_updater {
         trk_state.filtered_params().set_covariance(filtered_cov);
         trk_state.filtered_chi2() = getter::element(chi2, 0, 0);
 
+        DETRAY_DEBUG_HOST("MEASUREMENT POS: " << meas_local);
+        DETRAY_DEBUG_HOST("MEASUREMENT VARIANCE: " << V);
+        DETRAY_DEBUG_HOST("FILTERED PARAM: " << trk_state.filtered_params());
+        DETRAY_DEBUG_HOST("CHI2: " << trk_state.filtered_chi2());
+
         // Wrap the phi in the range of [-pi, pi]
         wrap_phi(trk_state.filtered_params());
 

device/common/include/traccc/finding/device/impl/find_tracks.ipp

@@ -593,9 +593,9 @@ TRACCC_HOST_DEVICE inline void find_tracks(
                     .previous_candidate_idx = prev_link_idx,
                     .meas_idx = std::numeric_limits<unsigned int>::max(),
                     .seed_idx = seed_idx,
+                    .n_cand = n_cand,
                     .n_skipped = is_edge ? n_skipped : n_skipped + 1,
                     .n_consecutive_skipped = n_consecutive_skipped + 1,
-                    .n_cand = n_cand,
                     .chi2 = std::numeric_limits<traccc::scalar>::max(),
                     .chi2_sum = prev_chi2_sum,
                     .ndf_sum = prev_ndf_sum};

device/common/include/traccc/finding/device/impl/propagate_to_next_surface.ipp

@@ -65,9 +65,7 @@ TRACCC_HOST_DEVICE inline void propagate_to_next_surface(
     const bound_track_parameters<> in_par = params.at(param_id);
 
     // Create propagator
-    auto alt_prop_cfg{cfg.propagation};
-    alt_prop_cfg.navigation.estimate_scattering_noise = false;
-    propagator_t propagator(alt_prop_cfg);
+    propagator_t propagator(cfg.propagation);
 
     // Create propagator state
     typename propagator_t::state propagation(in_par, payload.field_data, det);
@@ -93,15 +91,17 @@ TRACCC_HOST_DEVICE inline void propagate_to_next_surface(
         s3};
     // Parameter resetter
     typename detray::detail::tuple_element<4, actor_tuple_type>::type::state s4{
-        alt_prop_cfg};
+        cfg.propagation};
     // Momentum aborter
     typename detray::detail::tuple_element<5, actor_tuple_type>::type::state s5;
     // CKF aborter
     typename detray::detail::tuple_element<6, actor_tuple_type>::type::state s6;
-    s6.min_step_length = cfg.min_step_length_for_next_surface;
-    s6.max_count = cfg.max_step_counts_for_next_surface;
+
     s5.min_pT(static_cast<scalar_t>(cfg.min_pT));
     s5.min_p(static_cast<scalar_t>(cfg.min_p));
+    s6.surface_index = in_par.surface_link().index();
+    s6.min_step_length = cfg.min_step_length_for_next_surface;
+    s6.max_count = cfg.max_step_counts_for_next_surface;
 
     // Propagate to the next surface
     propagator.propagate(propagation, detray::tie(s0, s2, s3, s4, s5, s6));

examples/run/cpu/truth_finding_example.cpp

@@ -168,22 +168,22 @@ int seq_run(const traccc::opts::track_finding& finding_opts,
                   << std::endl;
 
         // Run fitting
-        auto track_states =
+        /*auto track_states =
             host_fitting(polymorphic_detector, field,
                          {vecmem::get_data(track_candidates),
                           vecmem::get_data(measurements_per_event)});
 
         details::print_fitted_tracks_statistics(track_states, logger());
 
-        const std::size_t n_fitted_tracks = track_states.tracks.size();
+        const std::size_t n_fitted_tracks = track_states.tracks.size();*/
 
         if (performance_opts.run) {
             find_performance_writer.write(
                 {vecmem::get_data(track_candidates),
                  vecmem::get_data(measurements_per_event)},
                 evt_data);
 
-            for (std::size_t i = 0; i < n_fitted_tracks; i++) {
+            /*for (std::size_t i = 0; i < n_fitted_tracks; i++) {
                 host_detector_visitor<detector_type_list>(
                     polymorphic_detector,
                     [&]<typename detector_traits_t>(
@@ -192,13 +192,13 @@ int seq_run(const traccc::opts::track_finding& finding_opts,
                             track_states.tracks.at(i), track_states.states,
                             measurements_per_event, det, evt_data);
                     });
-            }
+            }*/
         }
     }
 
     if (performance_opts.run) {
         find_performance_writer.finalize();
-        fit_performance_writer.finalize();
+        // fit_performance_writer.finalize();
     }
 
     return EXIT_SUCCESS;

performance/src/efficiency/finding_performance_writer.cpp

@@ -284,6 +284,7 @@ void finding_performance_writer::write_common(
             n_matched_seeds_for_particle = it->second;
             total_duplicate_tracks += n_matched_seeds_for_particle - 1;
         } else {
+            std::cout << pid << std::endl;
             TRACCC_DEBUG("Not matched: " << pid);
         }