update to detray v0.104.0

Author: niermann999

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

@@ -38,7 +38,7 @@ struct ckf_aborter : detray::actor {
                                        propagator_state_t &prop_state) const {
 
         auto &navigation = prop_state._navigation;
-        auto &stepping = prop_state._stepping;
+        const auto &stepping = prop_state._stepping;
 
         abrt_state.count++;
         abrt_state.path_from_surface += stepping.step_size();
@@ -47,7 +47,7 @@ struct ckf_aborter : detray::actor {
         if (navigation.is_on_sensitive() &&
             abrt_state.path_from_surface > abrt_state.min_step_length) {
             prop_state._heartbeat &= navigation.pause();
-            abrt_state.success = true;
+            abrt_state.success = navigation.is_alive();
         }
 
         // Reset path from surface
@@ -60,6 +60,7 @@ struct ckf_aborter : detray::actor {
             prop_state._heartbeat &= navigation.abort(
                 "CKF: Maximum number of steps to reach next sensitive surface "
                 "exceeded");
+            abrt_state.success = false;
         }
     }
 };

core/include/traccc/finding/candidate_link.hpp

@@ -28,6 +28,9 @@ struct candidate_link {
     // Index to the initial seed
     unsigned int seed_idx;
 
+    // How many candidates were added to the track
+    unsigned int n_cand;
+
     // How many times it skipped a surface
     unsigned int n_skipped;
 

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

@@ -139,6 +139,9 @@ 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;
+
     for (unsigned int step = 0u; step < config.max_track_candidates_per_track;
          step++) {
 
@@ -156,6 +159,7 @@ combinatorial_kalman_filter(
 
         // Rough estimation on out parameters size
         out_params.reserve(n_in_params);
+        out_is_edge.reserve(n_in_params);
 
         // Previous step ID
         std::fill(n_trks_per_seed.begin(), n_trks_per_seed.end(), 0u);
@@ -169,13 +173,20 @@ combinatorial_kalman_filter(
             bound_track_parameters<algebra_type>& in_param =
                 in_params[in_param_id];
 
+            const bool is_edge{in_is_edge[in_param_id] > 0u};
+
             assert(!in_param.is_invalid());
 
             const unsigned int orig_param_id =
                 (step == 0
                      ? in_param_id
                      : links[step - 1][param_to_link[step - 1][in_param_id]]
                            .seed_idx);
+            const unsigned int n_cand =
+                (step == 0
+                     ? 0
+                     : links[step - 1][param_to_link[step - 1][in_param_id]]
+                           .n_cand);
             const unsigned int skip_counter =
                 (step == 0
                      ? 0
@@ -261,6 +272,7 @@ combinatorial_kalman_filter(
                           .previous_candidate_idx = in_param_id,
                           .meas_idx = meas_id,
                           .seed_idx = orig_param_id,
+                          .n_cand = n_cand + 1,
                           .n_skipped = skip_counter,
                           .chi2 = chi2,
                           .chi2_sum = prev_chi2_sum + chi2,
@@ -306,7 +318,8 @@ combinatorial_kalman_filter(
                      .previous_candidate_idx = in_param_id,
                      .meas_idx = std::numeric_limits<unsigned int>::max(),
                      .seed_idx = orig_param_id,
-                     .n_skipped = skip_counter + 1,
+                     .n_cand = n_cand,
+                     .n_skipped = is_edge ? skip_counter : skip_counter + 1,
                      .chi2 = std::numeric_limits<traccc::scalar>::max(),
                      .chi2_sum = prev_chi2_sum,
                      .ndf_sum = prev_ndf_sum});
@@ -356,7 +369,7 @@ combinatorial_kalman_filter(
                         prob(Lthisbase.chi2_sum,
                              static_cast<scalar>(Lthisbase.ndf_sum - 5));
 
-                    if (step + 1 - Lthisbase.n_skipped <=
+                    if (Lthisbase.n_cand <=
                             config.duplicate_removal_minimum_length ||
                         Lthisbase.ndf_sum <= 5) {
                         continue;
@@ -370,7 +383,7 @@ combinatorial_kalman_filter(
                         auto Lthis = Lthisbase;
                         auto Lthat = links.at(step).at(tracks.at(j));
 
-                        if (step + 1 - Lthat.n_skipped <=
+                        if (Lthat.n_cand <=
                                 config.duplicate_removal_minimum_length ||
                             Lthisbase.ndf_sum <= 5) {
                             continue;
@@ -495,6 +508,8 @@ combinatorial_kalman_filter(
                 assert(!propagation._stepping.bound_params().is_invalid());
 
                 out_params.push_back(propagation._stepping.bound_params());
+                out_is_edge.push_back(
+                    propagation._navigation.is_edge_candidate());
                 param_to_link[step].push_back(link_id);
             }
             // Unless the track found a surface, it is considered a
@@ -513,7 +528,9 @@ combinatorial_kalman_filter(
         }
 
         in_params = std::move(out_params);
+        in_is_edge = std::move(out_is_edge);
         out_params.clear();
+        out_is_edge.clear();
     }
 
     /**********************
@@ -529,7 +546,7 @@ combinatorial_kalman_filter(
         // Get the link corresponding to tip
         auto L = links.at(tip.first).at(tip.second);
 
-        const unsigned int n_cands = tip.first + 1 - L.n_skipped;
+        const unsigned int n_cands = L.n_cand;
 
         // Skip if the number of tracks candidates is too small
         if (n_cands < config.min_track_candidates_per_track ||

core/include/traccc/fitting/details/kalman_fitting.hpp

@@ -91,7 +91,7 @@ typename edm::track_fit_container<algebra_t>::host kalman_fitting(
             result_tracks_device.at(result_tracks_device.size() - 1),
             typename edm::track_state_collection<algebra_t>::device{
                 vecmem::get_data(result.states)},
-            measurements, seqs_buffer);
+            measurements, seqs_buffer, fitter.config().propagation);
 
         // Run the fitter. The status that it returns is not used here. The main
         // failure modes are saved onto the fitted track itself. Not sure what

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

@@ -110,28 +110,31 @@ class kalman_fitter {
                 track_states,
             const measurement_collection_types::const_device& measurements,
             vecmem::data::vector_view<detray::geometry::barcode>
-                sequence_buffer)
+                sequence_buffer,
+            const detray::propagation::config& prop_cfg)
             : m_fit_actor_state{track, track_states, measurements},
               m_sequencer_state(
                   vecmem::device_vector<detray::geometry::barcode>(
                       sequence_buffer)),
+              m_parameter_resetter{prop_cfg},
               m_fit_res{track},
               m_sequence_buffer(sequence_buffer) {}
 
         /// @return the actor chain state
         TRACCC_HOST_DEVICE
         typename forward_actor_chain_type::state_ref_tuple operator()() {
             return detray::tie(m_aborter_state, m_interactor_state,
-                               m_fit_actor_state, m_sequencer_state,
-                               m_step_aborter_state);
+                               m_fit_actor_state, m_parameter_resetter,
+                               m_sequencer_state, m_step_aborter_state);
         }
 
         /// @return the actor chain state
         TRACCC_HOST_DEVICE
         typename backward_actor_chain_type::state_ref_tuple
         backward_actor_state() {
             return detray::tie(m_aborter_state, m_fit_actor_state,
-                               m_interactor_state, m_step_aborter_state);
+                               m_interactor_state, m_parameter_resetter,
+                               m_step_aborter_state);
         }
 
         /// Individual actor states
@@ -140,6 +143,7 @@ class kalman_fitter {
         typename forward_fit_actor::state m_fit_actor_state;
         typename barcode_sequencer::state m_sequencer_state;
         kalman_step_aborter::state m_step_aborter_state{};
+        typename resetter::state m_parameter_resetter{};
 
         /// Fitting result per track
         typename edm::track_fit_collection<algebra_type>::device::proxy_type

device/alpaka/src/finding/combinatorial_kalman_filter.hpp

@@ -236,6 +236,11 @@ combinatorial_kalman_filter(
     copy.setup(param_liveness_buffer)->wait();
     copy.memset(param_liveness_buffer, 1)->wait();
 
+    // On the first measurement, so parameter can be a hole
+    vecmem::data::vector_buffer<std::uint8_t> is_edges_buffer(n_seeds, mr.main);
+    copy.setup(is_edges_buffer)->wait();
+    copy.memset(is_edges_buffer, 0)->wait();
+
     // Number of tracks per seed
     vecmem::data::vector_buffer<unsigned int> n_tracks_per_seed_buffer(n_seeds,
                                                                        mr.main);
@@ -300,6 +305,11 @@ combinatorial_kalman_filter(
             n_max_candidates, mr.main);
         copy.setup(updated_liveness_buffer)->wait();
 
+        // Updated edges buffer after branching
+        vecmem::data::vector_buffer<std::uint8_t> is_edges_updated_buffer(
+            n_max_candidates, mr.main);
+        copy.setup(is_edges_updated_buffer)->wait();
+
         // Reset the number of tracks per seed
         copy.memset(n_tracks_per_seed_buffer, 0)->wait();
 
@@ -343,6 +353,7 @@ combinatorial_kalman_filter(
                 .in_params_view = in_params_buffer,
                 .in_params_liveness_view = param_liveness_buffer,
                 .n_in_params = n_in_params,
+                .is_edges_view = is_edges_buffer,
                 .measurement_ranges_view = meas_ranges_buffer,
                 .links_view = links_buffer,
                 .prev_links_idx =
@@ -506,6 +517,7 @@ combinatorial_kalman_filter(
                     .params_view = in_params_buffer,
                     .params_liveness_view = param_liveness_buffer,
                     .param_ids_view = param_ids_buffer,
+                    .is_edges_view = is_edges_updated_buffer,
                     .links_view = links_buffer,
                     .prev_links_idx = step_to_link_idx_map[step],
                     .step = step,
@@ -536,6 +548,8 @@ combinatorial_kalman_filter(
                         bfield_t>{},
                     config, device_payload.ptr());
                 ::alpaka::wait(queue);
+
+                std::swap(is_edges_buffer, is_edges_updated_buffer);
             }
         }
 

device/common/include/traccc/finding/device/find_tracks.hpp

@@ -59,6 +59,12 @@ struct find_tracks_payload {
      */
     unsigned int n_in_params;
 
+    /**
+     * @brief View object to the vector of booleans that flags if the sensor
+     * was hit due to tolerance inflation
+     */
+    vecmem::data::vector_view<std::uint8_t> is_edges_view;
+
     /**
      * @brief View object to the vector of measurement index ranges per surface
      */

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

@@ -57,6 +57,7 @@ TRACCC_HOST_DEVICE inline void find_tracks(
         payload.in_params_view);
     vecmem::device_vector<const unsigned int> in_params_liveness(
         payload.in_params_liveness_view);
+    vecmem::device_vector<const std::uint8_t> is_edges(payload.is_edges_view);
     vecmem::device_vector<candidate_link> links(payload.links_view);
     vecmem::device_vector<candidate_link> tmp_links(payload.tmp_links_view);
     bound_track_parameters_collection_types::device tmp_params(
@@ -406,6 +407,8 @@ TRACCC_HOST_DEVICE inline void find_tracks(
                      * Now, simply insert the temporary link at the found
                      * position. Different cases for step 0 and other steps.
                      */
+                    const unsigned int n_cand =
+                        payload.step == 0 ? 0 : links.at(prev_link_idx).n_cand;
                     const unsigned int n_skipped =
                         payload.step == 0 ? 0
                                           : links.at(prev_link_idx).n_skipped;
@@ -423,6 +426,7 @@ TRACCC_HOST_DEVICE inline void find_tracks(
                         .previous_candidate_idx = prev_link_idx,
                         .meas_idx = meas_idx,
                         .seed_idx = seed_idx,
+                        .n_cand = n_cand + 1,
                         .n_skipped = n_skipped,
                         .chi2 = chi2,
                         .chi2_sum = prev_chi2_sum + chi2,
@@ -493,6 +497,7 @@ TRACCC_HOST_DEVICE inline void find_tracks(
 
     unsigned int prev_link_idx = std::numeric_limits<unsigned int>::max();
     unsigned int seed_idx = std::numeric_limits<unsigned int>::max();
+    unsigned int n_cand = 0u;
     unsigned int n_skipped = std::numeric_limits<unsigned int>::max();
     unsigned int prev_ndf_sum = 0u;
     scalar prev_chi2_sum = 0.f;
@@ -510,9 +515,11 @@ TRACCC_HOST_DEVICE inline void find_tracks(
         prev_link_idx = payload.prev_links_idx + in_param_id;
         seed_idx =
             payload.step > 0 ? links.at(prev_link_idx).seed_idx : in_param_id;
+        n_cand = payload.step == 0 ? 0 : links.at(prev_link_idx).n_cand;
         n_skipped = payload.step == 0 ? 0 : links.at(prev_link_idx).n_skipped;
         in_param_can_create_hole =
-            (n_skipped < cfg.max_num_skipping_per_cand) && (!last_step);
+            (n_skipped < cfg.max_num_skipping_per_cand) && (!last_step) &&
+            !is_edges.at(in_param_id);
         prev_ndf_sum = payload.step == 0 ? 0 : links.at(prev_link_idx).ndf_sum;
         prev_chi2_sum =
             payload.step == 0 ? 0.f : links.at(prev_link_idx).chi2_sum;
@@ -581,12 +588,14 @@ TRACCC_HOST_DEVICE inline void find_tracks(
                 const unsigned int out_offset =
                     shared_payload.shared_out_offset + local_out_offset;
 
+                const bool is_edge{is_edges.at(in_param_id) > 0u};
                 links.at(out_offset) = {
                     .step = payload.step,
                     .previous_candidate_idx = prev_link_idx,
                     .meas_idx = std::numeric_limits<unsigned int>::max(),
                     .seed_idx = seed_idx,
-                    .n_skipped = n_skipped + 1,
+                    .n_cand = n_cand,
+                    .n_skipped = is_edge ? n_skipped : n_skipped + 1,
                     .chi2 = std::numeric_limits<traccc::scalar>::max(),
                     .chi2_sum = prev_chi2_sum,
                     .ndf_sum = prev_ndf_sum};
@@ -597,11 +606,9 @@ TRACCC_HOST_DEVICE inline void find_tracks(
                 out_params_liveness.at(param_pos) =
                     static_cast<unsigned int>(!last_step);
             } else {
-                const unsigned int n_cands = payload.step - n_skipped;
-
-                if (n_cands >= cfg.min_track_candidates_per_track) {
+                if (n_cand >= cfg.min_track_candidates_per_track) {
                     auto tip_pos = tips.push_back(prev_link_idx);
-                    tip_lengths.at(tip_pos) = n_cands;
+                    tip_lengths.at(tip_pos) = n_cand;
                 }
             }
         } else {
@@ -620,12 +627,9 @@ TRACCC_HOST_DEVICE inline void find_tracks(
                     static_cast<unsigned int>(!last_step);
                 links.at(out_offset) = tmp_links.at(in_offset);
 
-                const unsigned int n_cands = payload.step + 1 - n_skipped;
-
-                if (last_step &&
-                    n_cands >= cfg.min_track_candidates_per_track) {
+                if (last_step && n_cand >= cfg.min_track_candidates_per_track) {
                     auto tip_pos = tips.push_back(out_offset);
-                    tip_lengths.at(tip_pos) = n_cands;
+                    tip_lengths.at(tip_pos) = n_cand;
                 }
             }
         }

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

@@ -38,12 +38,15 @@ TRACCC_HOST_DEVICE inline void propagate_to_next_surface(
     const unsigned int link_idx = payload.prev_links_idx + param_id;
     const auto& link = links.at(link_idx);
     assert(link.step == payload.step);
-    const unsigned int n_cands = link.step + 1 - link.n_skipped;
+    const unsigned int n_cands = link.n_cand;
 
     // Parameter liveness
     vecmem::device_vector<unsigned int> params_liveness(
         payload.params_liveness_view);
 
+    // Whether the surface was hit in the tolerance band
+    vecmem::device_vector<std::uint8_t> is_edges(payload.is_edges_view);
+
     // tips
     vecmem::device_vector<unsigned int> tips(payload.tips_view);
     vecmem::device_vector<unsigned int> tip_lengths(payload.tip_lengths_view);
@@ -101,6 +104,7 @@ TRACCC_HOST_DEVICE inline void propagate_to_next_surface(
 
         params[param_id] = propagation._stepping.bound_params();
         params_liveness[param_id] = 1u;
+        is_edges[param_id] = propagation._navigation.is_edge_candidate();
     } else {
         params_liveness[param_id] = 0u;
 

device/common/include/traccc/finding/device/propagate_to_next_surface.hpp

@@ -50,6 +50,12 @@ struct propagate_to_next_surface_payload {
      */
     vecmem::data::vector_view<const unsigned int> param_ids_view;
 
+    /**
+     * @brief View object to the vector of booleans that flags if the sensor
+     * was hit due to tolerance inflation
+     */
+    vecmem::data::vector_view<std::uint8_t> is_edges_view;
+
     /**
      * @brief View object to the vector of candidate links
      */