Remove different smoother options for simplicity

Author: niermann999

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

@@ -48,24 +48,24 @@ struct measurement_updater : detray::base_actor {
     /// Contains the current track states and some statistics
     struct state {
         using scalar_t = detray::dscalar<algebra_t>;
+        using track_state_cand_t = filtered_track_state_candidate<algebra_t>;
 
         constexpr state() = default;
 
         TRACCC_HOST_DEVICE
         explicit state(
             typename edm::measurement_collection::const_device measurements,
             vecmem::data::vector_view<unsigned int> meas_ranges_view,
-            void* track_state_candidates, const smoother_type smoother)
-            : m_cand_ptr{track_state_candidates},
+            vecmem::device_vector<track_state_cand_t>::iterator track_state_itr)
+            : m_track_state_itr{track_state_itr},
               m_measurements{measurements},
-              m_measurement_ranges{meas_ranges_view},
-              m_run_smoother{smoother} {}
+              m_measurement_ranges{meas_ranges_view} {}
 
         /// Calibration configuration
         traccc::measurement_selector::config m_calib_cfg{};
 
         /// Track states for the current track
-        void* m_cand_ptr{nullptr};
+        vecmem::device_vector<track_state_cand_t>::iterator m_track_state_itr{};
 
         /// Statistics for the current track
         track_stats<scalar_t> m_stats{};
@@ -85,9 +85,6 @@ struct measurement_updater : detray::base_actor {
         /// Per surface measurement index ranges into measurement cont.
         vecmem::device_vector<unsigned int> m_measurement_ranges{
             vecmem::data::vector_view<unsigned int>{}};
-
-        /// The track candidate collection type pointed to
-        smoother_type m_run_smoother{smoother_type::e_mbf};
     };
 
     /// Select the optimal next measurement and run the KF update
@@ -98,9 +95,6 @@ struct measurement_updater : detray::base_actor {
             transporter_result) const {
         using scalar_t = detray::dscalar<algebra_t>;
 
-        // Check for a valid measurement updater state
-        assert(updater_state.m_cand_ptr != nullptr);
-
         auto& navigation = propagation.navigation();
         auto& stepping = propagation.stepping();
 
@@ -211,12 +205,9 @@ struct measurement_updater : detray::base_actor {
             TRACCC_VERBOSE_HOST_DEVICE("Assigned measurement: %d",
                                        cand.meas_idx);
 
-            // TODO: Get host-device compatible visitor implementation
-            const auto i{
-                static_cast<int>(updater_state.m_stats.n_track_states)};
-            traccc::make_track_state_candidate(updater_state.m_cand_ptr,
-                                               updater_state.m_run_smoother, i,
-                                               cand, bound_param);
+            *updater_state.m_track_state_itr = {cand.meas_idx, cand.chi2,
+                                                bound_param};
+            updater_state.m_track_state_itr++;
 
             // Update statistics
             updater_state.m_stats.ndf_sum +=

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

@@ -55,7 +55,10 @@ progressive_kalman_filter(
     const typename edm::measurement_collection::const_view& measurements_view,
     const vecmem::data::vector_view<unsigned int> measurement_ranges_view,
     const bound_track_parameters<typename detector_t::algebra_type>& seed,
-    const unsigned int seed_idx, void* track_state_candidate_ptr,
+    const unsigned int seed_idx,
+    vecmem::data::vector_view<
+        filtered_track_state_candidate<typename detector_t::algebra_type>>
+        track_state_cand_view,
     vecmem::data::jagged_vector_view<typename detector_t::surface_type>
         surfaces_view,
     const finding_config& cfg) {
@@ -70,6 +73,10 @@ progressive_kalman_filter(
     typename edm::measurement_collection::const_device measurements{
         measurements_view};
 
+    // Create the candidate track states container
+    vecmem::device_vector<filtered_track_state_candidate<algebra_t>>
+        track_state_cands{track_state_cand_view};
+
     // Create detray propagator
     auto prop_cfg{cfg.propagation};
     prop_cfg.navigation.estimate_scattering_noise = false;
@@ -109,9 +116,12 @@ progressive_kalman_filter(
     typename detray::actor::pointwise_material_interactor<algebra_t>::state
         interactor_state;
     // Do the measurement selection
+    const auto cand_offset{
+        static_cast<int>(seed_idx * cfg.max_track_candidates_per_track)};
+    auto track_state_itr =
+        detray::ranges::detail::next(track_state_cands.begin(), cand_offset);
     typename traccc::measurement_updater<algebra_t>::state meas_updater_state{
-        measurements, measurement_ranges_view, track_state_candidate_ptr,
-        cfg.run_smoother};
+        measurements, measurement_ranges_view, track_state_itr};
     // Collect the surface geometry identifiers for the Kalman smoother
     typename detray::actor::surface_sequencer<
         typename detector_t::surface_type>::state sequencer_state{

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

@@ -125,52 +125,29 @@ run_progressive_kalman_filter(
     // is resizable)
     vecmem::copy copy{};
     typename edm::track_state_collection<algebra_t>::buffer track_states_buffer{
-        cfg.run_smoother == smoother_type::e_none ? 0u : n_max_states, mr,
-        vecmem::data::buffer_type::resizable};
+        n_max_states, mr, vecmem::data::buffer_type::resizable};
     copy.setup(track_states_buffer)->ignore();
 
     // Track data collected by the measurement updater during pattern recog.
-    vecmem::vector<track_state_candidate> track_cands{};
     vecmem::vector<filtered_track_state_candidate<algebra_t>>
-        filtered_track_cands{};
-    vecmem::vector<full_track_state_candidate<algebra_t>> full_track_cands{};
-
-    switch (cfg.run_smoother) {
-        case smoother_type::e_none: {
-            track_cands.resize(n_max_states);
-            break;
-        }
-        case smoother_type::e_kalman: {
-            filtered_track_cands.resize(n_max_states);
-            break;
-        }
-        case smoother_type::e_mbf: {
-            full_track_cands.resize(n_max_states);
-            break;
-        }
-        default: {
-            TRACCC_FATAL_HOST("Unknown smoother option");
-            return track_container;
-        }
-    }
+        track_state_cands{};
+    track_state_cands.resize(n_max_states);
 
     // Setup the surface sequence buffer
     vecmem::data::jagged_vector_buffer<typename detector_t::surface_type>
         sf_sequences_buffer{std::vector<unsigned int>{0u}, mr, &mr,
                             vecmem::data::buffer_type::resizable};
 
-    if (cfg.run_smoother == smoother_type::e_kalman) {
-        const unsigned int n_surfaces_per_track{
-            std::max(cfg.max_track_candidates_per_track *
-                         cfg.kalman_smoother.surface_sequence_size_factor,
-                     cfg.kalman_smoother.min_surface_sequence_capacity)};
-        std::vector<unsigned int> seqs_sizes(n_seeds, n_surfaces_per_track);
-
-        sf_sequences_buffer = vecmem::data::jagged_vector_buffer<
-            typename detector_t::surface_type>{
+    const unsigned int n_surfaces_per_track{
+        std::max(cfg.max_track_candidates_per_track *
+                     cfg.kalman_smoother.surface_sequence_size_factor,
+                 cfg.kalman_smoother.min_surface_sequence_capacity)};
+    std::vector<unsigned int> seqs_sizes(n_seeds, n_surfaces_per_track);
+
+    sf_sequences_buffer =
+        vecmem::data::jagged_vector_buffer<typename detector_t::surface_type>{
             seqs_sizes, mr, &mr, vecmem::data::buffer_type::resizable};
-        copy.setup(sf_sequences_buffer)->ignore();
-    }
+    copy.setup(sf_sequences_buffer)->ignore();
 
     for (unsigned int seed_idx = 0u; seed_idx < seeds.size(); ++seed_idx) {
         const auto& seed = seeds[seed_idx];
@@ -179,20 +156,12 @@ run_progressive_kalman_filter(
         // Add the information also to the clog stream
         TRACCC_VERBOSE_HOST("Seed: " << seed_idx);
 
-        // Set the data pointer to the beginning of the range of the track
-        const auto cand_offset{static_cast<unsigned int>(
-            seed_idx * cfg.max_track_candidates_per_track)};
-
-        track_state_candidate_data<algebra_t> candidate_data(
-            cfg.run_smoother, cand_offset, vecmem::get_data(track_cands),
-            vecmem::get_data(filtered_track_cands),
-            vecmem::get_data(full_track_cands));
-
         // Run the progressive filter for this seed
         const track_stats<scalar_t> trk_stats =
             traccc::details::progressive_kalman_filter(
                 det, field, measurements_view, vecmem::get_data(meas_ranges),
-                seed, seed_idx, candidate_data.ptr(), sf_sequences_buffer, cfg);
+                seed, seed_idx, vecmem::get_data(track_state_cands),
+                sf_sequences_buffer, cfg);
 
         // Check track stats and build the new track object
         const unsigned int n_track_states{trk_stats.n_track_states};
@@ -208,34 +177,30 @@ run_progressive_kalman_filter(
         edm::track track =
             track_container.tracks.at(track_container.tracks.size() - 1u);
 
-        track.fit_outcome() = cfg.run_smoother == smoother_type::e_none
-                                  ? track_fit_outcome::UNKNOWN
-                                  : track_fit_outcome::SUCCESS;
-
+        track.fit_outcome() = track_fit_outcome::SUCCESS;
         track.params() = seed;
         track.ndf() = static_cast<scalar_t>(ndf_sum);
         track.chi2() = trk_stats.chi2_sum;
         track.pval() = prob(trk_stats.chi2_sum, static_cast<scalar_t>(ndf_sum));
         track.nholes() = static_cast<unsigned int>(trk_stats.n_holes);
         track.constituent_links().resize(n_track_states);
 
-        const auto track_state_offset{
-            static_cast<unsigned int>(track_container.states.size())};
+        const auto cand_offset{seed_idx * cfg.max_track_candidates_per_track};
 
         // Generate the track states for this track
-        for (unsigned int state_idx = track_state_offset;
-             state_idx < track_state_offset + n_track_states; state_idx++) {
-
-            const unsigned int link_idx{state_idx - track_state_offset};
+        for (unsigned int link_idx = 0u; link_idx < n_track_states;
+             link_idx++) {
 
             TRACCC_DEBUG_HOST("Adding track state (local idx "
-                              << link_idx << ", global idx " << state_idx
+                              << link_idx << ", global idx "
+                              << link_idx + static_cast<unsigned int>(
+                                                track_container.states.size())
                               << ")");
 
             // Intermediate type required to build a view
             traccc::track_state_from_candidate<algebra_t>(
-                candidate_data.ptr(), cfg.run_smoother, link_idx, measurements,
-                track, track_states_buffer);
+                track_state_cands.at(cand_offset + link_idx), link_idx,
+                measurements, track, track_states_buffer);
         }
 
         TRACCC_DEBUG_HOST("Added track " << track_container.tracks.size() - 1