Adapted the examples to the SoA track fit EDM.

Author: krasznaa

examples/run/alpaka/full_chain_algorithm.cpp

@@ -182,8 +182,8 @@ full_chain_algorithm::output_type full_chain_algorithm::operator()(
             m_device_detector_view, m_field, {track_candidates, measurements});
 
         // Copy a limited amount of result data back to the host.
-        output_type result{&m_host_mr};
-        m_vecmem_objects.async_copy()(track_states.headers, result)->wait();
+        output_type result{m_host_mr};
+        m_vecmem_objects.async_copy()(track_states.tracks, result)->wait();
         return result;
 
     }
@@ -196,7 +196,7 @@ full_chain_algorithm::output_type full_chain_algorithm::operator()(
         m_vecmem_objects.async_copy()(measurements, measurements_host)->wait();
 
         // Return an empty object.
-        return {};
+        return output_type{m_host_mr};
     }
 }
 

examples/run/alpaka/full_chain_algorithm.hpp

@@ -20,8 +20,8 @@
 #include "traccc/bfield/magnetic_field.hpp"
 #include "traccc/clusterization/clustering_config.hpp"
 #include "traccc/edm/silicon_cell_collection.hpp"
+#include "traccc/edm/track_fit_collection.hpp"
 #include "traccc/edm/track_parameters.hpp"
-#include "traccc/edm/track_state.hpp"
 #include "traccc/fitting/kalman_filter/kalman_fitter.hpp"
 #include "traccc/geometry/detector.hpp"
 #include "traccc/geometry/silicon_detector_description.hpp"
@@ -44,7 +44,7 @@ namespace traccc::alpaka {
 /// At least as much as is implemented in the project at any given moment.
 ///
 class full_chain_algorithm
-    : public algorithm<vecmem::vector<fitting_result<default_algebra>>(
+    : public algorithm<edm::track_fit_collection<default_algebra>::host(
           const edm::silicon_cell_collection::host&)>,
       public messaging {
 

examples/run/alpaka/seeding_example_alpaka.cpp

@@ -137,9 +137,6 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
     vecmem::copy& copy = vo.copy();
     vecmem::copy& async_copy = vo.async_copy();
 
-    traccc::device::container_d2h_copy_alg<traccc::track_state_container_types>
-        track_state_d2h{mr, copy, logger().clone("TrackStateD2HCopyAlg")};
-
     // Seeding algorithms
     const traccc::seedfinder_config seedfinder_config(seeding_opts);
     const traccc::seedfilter_config seedfilter_config(seeding_opts);
@@ -198,7 +195,8 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
         traccc::host::track_params_estimation::output_type params;
         traccc::edm::track_candidate_collection<traccc::default_algebra>::host
             track_candidates{host_mr};
-        traccc::track_state_container_types::host track_states;
+        traccc::edm::track_fit_container<traccc::default_algebra>::host
+            track_states{host_mr};
 
         traccc::edm::seed_collection::buffer seeds_alpaka_buffer;
         traccc::bound_track_parameters_collection_types::buffer
@@ -207,8 +205,8 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
         traccc::edm::track_candidate_collection<traccc::default_algebra>::buffer
             track_candidates_alpaka_buffer;
 
-        traccc::track_state_container_types::buffer track_states_alpaka_buffer{
-            {{}, *(mr.host)}, {{}, *(mr.host), mr.host}};
+        traccc::edm::track_fit_container<traccc::default_algebra>::buffer
+            track_states_alpaka_buffer;
 
         {  // Start measuring wall time
             traccc::performance::timer wall_t("Wall time", elapsedTimes);
@@ -354,8 +352,14 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
         copy(track_candidates_alpaka_buffer, track_candidates_alpaka)->wait();
 
         // Copy track states from device to host
-        traccc::track_state_container_types::host track_states_alpaka =
-            track_state_d2h(track_states_alpaka_buffer);
+        traccc::edm::track_fit_container<traccc::default_algebra>::host
+            track_states_alpaka{host_mr};
+        async_copy(track_states_alpaka_buffer.tracks,
+                   track_states_alpaka.tracks)
+            ->wait();
+        async_copy(track_states_alpaka_buffer.states,
+                   track_states_alpaka.states)
+            ->wait();
 
         if (accelerator_opts.compare_with_cpu) {
             // Show which event we are currently presenting the results for.
@@ -402,8 +406,8 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
         n_seeds += seeds.size();
         n_found_tracks_alpaka += track_candidates_alpaka.size();
         n_found_tracks += track_candidates.size();
-        n_fitted_tracks_alpaka += track_states_alpaka.size();
-        n_fitted_tracks += track_states.size();
+        n_fitted_tracks_alpaka += track_states_alpaka.tracks.size();
+        n_fitted_tracks += track_states.tracks.size();
 
         /*------------
           Writer

examples/run/alpaka/seq_example_alpaka.cpp

@@ -184,9 +184,6 @@ int seq_run(const traccc::opts::detector& detector_opts,
     device_fitting_algorithm fitting_alg_alpaka(
         fitting_cfg, mr, copy, queue, logger().clone("AlpakaFittingAlg"));
 
-    traccc::device::container_d2h_copy_alg<traccc::track_state_container_types>
-        copy_track_states(mr, copy, logger().clone("TrackStateD2HCopyAlg"));
-
     // performance writer
     traccc::seeding_performance_writer sd_performance_writer(
         traccc::seeding_performance_writer::config{},
@@ -206,7 +203,7 @@ int seq_run(const traccc::opts::detector& detector_opts,
         traccc::host::seeding_algorithm::output_type seeds{host_mr};
         traccc::host::track_params_estimation::output_type params{&host_mr};
         host_finding_algorithm::output_type track_candidates{host_mr};
-        host_fitting_algorithm::output_type track_states;
+        host_fitting_algorithm::output_type track_states{host_mr};
 
         // Instantiate alpaka containers/collections
         traccc::measurement_collection_types::buffer measurements_alpaka_buffer(
@@ -217,7 +214,8 @@ int seq_run(const traccc::opts::detector& detector_opts,
             params_alpaka_buffer(0, *mr.host);
         traccc::edm::track_candidate_collection<traccc::default_algebra>::buffer
             track_candidates_buffer;
-        traccc::track_state_container_types::buffer track_states_buffer;
+        traccc::edm::track_fit_container<traccc::default_algebra>::buffer
+            track_states_buffer;
 
         {
             traccc::performance::timer wall_t("Wall time", elapsedTimes);
@@ -371,13 +369,16 @@ int seq_run(const traccc::opts::detector& detector_opts,
             &host_mr};
         traccc::edm::track_candidate_collection<traccc::default_algebra>::host
             track_candidates_alpaka{host_mr};
+        traccc::edm::track_fit_container<traccc::default_algebra>::host
+            track_states_alpaka{host_mr};
 
         copy(measurements_alpaka_buffer, measurements_per_event_alpaka)->wait();
         copy(spacepoints_alpaka_buffer, spacepoints_per_event_alpaka)->wait();
         copy(seeds_alpaka_buffer, seeds_alpaka)->wait();
         copy(params_alpaka_buffer, params_alpaka)->wait();
         copy(track_candidates_buffer, track_candidates_alpaka)->wait();
-        auto track_states_alpaka = copy_track_states(track_states_buffer);
+        copy(track_states_buffer.tracks, track_states_alpaka.tracks)->wait();
+        copy(track_states_buffer.states, track_states_alpaka.states)->wait();
         queue.synchronize();
 
         if (accelerator_opts.compare_with_cpu) {
@@ -429,12 +430,20 @@ int seq_run(const traccc::opts::detector& detector_opts,
                                      vecmem::get_data(track_candidates_alpaka));
 
             // Compare tracks fitted on the host and on the device.
-            traccc::collection_comparator<
-                traccc::track_state_container_types::host::header_type>
-                compare_track_states{"track states"};
-            compare_track_states(
-                vecmem::get_data(track_states.get_headers()),
-                vecmem::get_data(track_states_alpaka.get_headers()));
+            traccc::soa_comparator<
+                traccc::edm::track_fit_collection<traccc::default_algebra>>
+                compare_track_fits{
+                    "track fits",
+                    traccc::details::comparator_factory<
+                        traccc::edm::track_fit_collection<
+                            traccc::default_algebra>::const_device::
+                            const_proxy_type>{
+                        vecmem::get_data(measurements_per_event),
+                        vecmem::get_data(measurements_per_event_alpaka),
+                        vecmem::get_data(track_states.states),
+                        vecmem::get_data(track_states_alpaka.states)}};
+            compare_track_fits(vecmem::get_data(track_states.tracks),
+                               vecmem::get_data(track_states_alpaka.tracks));
         }
         /// Statistics
         n_measurements += measurements_per_event.size();
@@ -445,8 +454,8 @@ int seq_run(const traccc::opts::detector& detector_opts,
         n_seeds_alpaka += seeds_alpaka.size();
         n_found_tracks += track_candidates.size();
         n_found_tracks_alpaka += track_candidates_alpaka.size();
-        n_fitted_tracks += track_states.size();
-        n_fitted_tracks_alpaka += track_states_alpaka.size();
+        n_fitted_tracks += track_states.tracks.size();
+        n_fitted_tracks_alpaka += track_states_alpaka.tracks.size();
 
         if (performance_opts.run) {
 

examples/run/cpu/full_chain_algorithm.cpp

@@ -21,6 +21,7 @@ full_chain_algorithm::full_chain_algorithm(
     const magnetic_field& field, detector_type* detector,
     std::unique_ptr<const traccc::Logger> logger)
     : messaging(logger->clone()),
+      m_mr(mr),
       m_copy{std::make_unique<vecmem::copy>()},
       m_field_vec{0.f, 0.f, finder_config.bFieldInZ},
       m_field(field),
@@ -79,14 +80,15 @@ full_chain_algorithm::output_type full_chain_algorithm::operator()(
 
         // Run the track fitting, and return its results.
         return m_fitting(
-            *m_detector, m_field,
-            {vecmem::get_data(track_candidates), measurements_view});
+                   *m_detector, m_field,
+                   {vecmem::get_data(track_candidates), measurements_view})
+            .tracks;
     }
     // If not, just return an empty object.
     else {
 
         // Return an empty object.
-        return {};
+        return output_type{m_mr.get()};
     }
 }
 

examples/run/cpu/full_chain_algorithm.hpp

@@ -11,8 +11,8 @@
 #include "traccc/bfield/magnetic_field.hpp"
 #include "traccc/clusterization/clusterization_algorithm.hpp"
 #include "traccc/edm/silicon_cell_collection.hpp"
+#include "traccc/edm/track_fit_collection.hpp"
 #include "traccc/edm/track_parameters.hpp"
-#include "traccc/edm/track_state.hpp"
 #include "traccc/finding/combinatorial_kalman_filter_algorithm.hpp"
 #include "traccc/fitting/kalman_fitting_algorithm.hpp"
 #include "traccc/geometry/detector.hpp"
@@ -38,9 +38,10 @@ namespace traccc {
 ///
 /// At least as much as is implemented in the project at any given moment.
 ///
-class full_chain_algorithm : public algorithm<track_state_container_types::host(
-                                 const edm::silicon_cell_collection::host&)>,
-                             public messaging {
+class full_chain_algorithm
+    : public algorithm<edm::track_fit_collection<default_algebra>::host(
+          const edm::silicon_cell_collection::host&)>,
+      public messaging {
 
     public:
     /// @name Type declaration(s)
@@ -97,6 +98,8 @@ class full_chain_algorithm : public algorithm<track_state_container_types::host(
         const edm::silicon_cell_collection::host& cells) const;
 
     private:
+    /// Memory resource
+    std::reference_wrapper<vecmem::memory_resource> m_mr;
     /// Vecmem copy object
     std::unique_ptr<vecmem::copy> m_copy;
     /// Constant B field for the (seed) track parameter estimation

examples/run/cpu/misaligned_truth_fitting_example.cpp

@@ -166,21 +166,17 @@ int main(int argc, char* argv[]) {
                 {vecmem::get_data(truth_track_candidates.tracks),
                  vecmem::get_data(truth_track_candidates.measurements)});
 
-            print_fitted_tracks_statistics(track_states);
+            // print_fitted_tracks_statistics(track_states);
 
-            const decltype(track_states)::size_type n_fitted_tracks =
-                track_states.size();
+            const std::size_t n_fitted_tracks = track_states.tracks.size();
 
             if (performance_opts.run) {
 
                 for (unsigned int i = 0; i < n_fitted_tracks; i++) {
-                    const auto& trk_states_per_track = track_states.at(i).items;
-
-                    const auto& fit_res = track_states[i].header;
-
-                    fit_performance_writer.write(trk_states_per_track, fit_res,
-                                                 host_det, evt_data,
-                                                 fit_cfg0.propagation.context);
+                    fit_performance_writer.write(
+                        track_states.tracks.at(i), track_states.states,
+                        truth_track_candidates.measurements, host_det, evt_data,
+                        fit_cfg0.propagation.context);
                 }
             }
         } else {
@@ -195,21 +191,17 @@ int main(int argc, char* argv[]) {
                 {vecmem::get_data(truth_track_candidates.tracks),
                  vecmem::get_data(truth_track_candidates.measurements)});
 
-            print_fitted_tracks_statistics(track_states);
+            // print_fitted_tracks_statistics(track_states);
 
-            const decltype(track_states)::size_type n_fitted_tracks =
-                track_states.size();
+            const std::size_t n_fitted_tracks = track_states.tracks.size();
 
             if (performance_opts.run) {
 
                 for (unsigned int i = 0; i < n_fitted_tracks; i++) {
-                    const auto& trk_states_per_track = track_states.at(i).items;
-
-                    const auto& fit_res = track_states[i].header;
-
-                    fit_performance_writer.write(trk_states_per_track, fit_res,
-                                                 host_det, evt_data,
-                                                 fit_cfg1.propagation.context);
+                    fit_performance_writer.write(
+                        track_states.tracks.at(i), track_states.states,
+                        truth_track_candidates.measurements, host_det, evt_data,
+                        fit_cfg1.propagation.context);
                 }
             }
         }

examples/run/cpu/seeding_example.cpp

@@ -190,7 +190,8 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
             track_candidates{host_mr};
         traccc::edm::track_candidate_collection<traccc::default_algebra>::host
             track_candidates_ar{host_mr};
-        traccc::track_state_container_types::host track_states;
+        traccc::edm::track_fit_container<traccc::default_algebra>::host
+            track_states{host_mr};
 
         /*------------------------
            Track Finding with CKF
@@ -217,7 +218,7 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
         track_states = host_fitting(detector, field,
                                     {vecmem::get_data(track_candidates_ar),
                                      vecmem::get_data(measurements_per_event)});
-        n_fitted_tracks += track_states.size();
+        n_fitted_tracks += track_states.tracks.size();
 
         /*------------
            Statistics
@@ -249,13 +250,10 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
                 vecmem::get_data(track_candidates_ar),
                 vecmem::get_data(measurements_per_event), evt_data);
 
-            for (unsigned int i = 0; i < track_states.size(); i++) {
-                const auto& trk_states_per_track = track_states.at(i).items;
-
-                const auto& fit_res = track_states[i].header;
-
-                fit_performance_writer.write(trk_states_per_track, fit_res,
-                                             detector, evt_data);
+            for (unsigned int i = 0; i < track_states.tracks.size(); i++) {
+                fit_performance_writer.write(
+                    track_states.tracks.at(i), track_states.states,
+                    measurements_per_event, detector, evt_data);
             }
         }
     }

examples/run/cpu/seq_example.cpp

@@ -199,7 +199,7 @@ int seq_run(const traccc::opts::input_data& input_opts,
         finding_algorithm::output_type track_candidates{host_mr};
         traccc::host::greedy_ambiguity_resolution_algorithm::output_type
             resolved_track_candidates{host_mr};
-        fitting_algorithm::output_type track_states{&host_mr};
+        fitting_algorithm::output_type track_states{host_mr};
 
         {  // Start measuring wall time.
             traccc::performance::timer timer_wall{"Wall time", elapsedTimes};
@@ -320,7 +320,7 @@ int seq_run(const traccc::opts::input_data& input_opts,
             n_seeds += seeds.size();
             n_found_tracks += track_candidates.size();
             n_ambiguity_free_tracks += resolved_track_candidates.size();
-            n_fitted_tracks += track_states.size();
+            n_fitted_tracks += track_states.tracks.size();
 
         }  // Stop measuring Wall time.
 
@@ -347,13 +347,10 @@ int seq_run(const traccc::opts::input_data& input_opts,
                 vecmem::get_data(resolved_track_candidates),
                 vecmem::get_data(measurements_per_event), evt_data);
 
-            for (unsigned int i = 0; i < track_states.size(); i++) {
-                const auto& trk_states_per_track = track_states.at(i).items;
-
-                const auto& fit_res = track_states[i].header;
-
-                fit_performance_writer.write(trk_states_per_track, fit_res,
-                                             detector, evt_data);
+            for (unsigned int i = 0; i < track_states.tracks.size(); i++) {
+                fit_performance_writer.write(
+                    track_states.tracks.at(i), track_states.states,
+                    measurements_per_event, detector, evt_data);
             }
         }
     }

examples/run/cpu/truth_finding_example.cpp

@@ -163,22 +163,19 @@ int seq_run(const traccc::opts::track_finding& finding_opts,
                          {vecmem::get_data(track_candidates),
                           vecmem::get_data(measurements_per_event)});
 
-        print_fitted_tracks_statistics(track_states);
+        // print_fitted_tracks_statistics(track_states);
 
-        const std::size_t n_fitted_tracks = track_states.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++) {
-                const auto& trk_states_per_track = track_states.at(i).items;
-
-                const auto& fit_res = track_states[i].header;
-
-                fit_performance_writer.write(trk_states_per_track, fit_res,
-                                             detector, evt_data);
+                fit_performance_writer.write(
+                    track_states.tracks.at(i), track_states.states,
+                    measurements_per_event, detector, evt_data);
             }
         }
     }