Add the greedy ambiguity solver to throughput examples

Author: beomki-yeo

examples/run/common/throughput_mt.ipp

@@ -24,6 +24,7 @@
 #include "traccc/options/track_finding.hpp"
 #include "traccc/options/track_fitting.hpp"
 #include "traccc/options/track_propagation.hpp"
+#include "traccc/options/track_resolution.hpp"
 #include "traccc/options/track_seeding.hpp"
 
 // I/O include(s).
@@ -75,6 +76,7 @@ int throughput_mt(std::string_view description, int argc, char* argv[],
     opts::track_seeding seeding_opts;
     opts::track_finding finding_opts;
     opts::track_propagation propagation_opts;
+    opts::track_resolution resolution_opts;
     opts::track_fitting fitting_opts;
     opts::throughput throughput_opts;
     opts::threading threading_opts;
@@ -159,6 +161,9 @@ int throughput_mt(std::string_view description, int argc, char* argv[],
         finding_opts);
     finding_cfg.propagation = propagation_config;
 
+    typename FULL_CHAIN_ALG::ambiguity_solving_algorithm::config_type
+        resolution_cfg(resolution_opts);
+
     typename FULL_CHAIN_ALG::fitting_algorithm::config_type fitting_cfg(
         fitting_opts);
     fitting_cfg.propagation = propagation_config;
@@ -180,6 +185,7 @@ int throughput_mt(std::string_view description, int argc, char* argv[],
              {seeding_opts.seedfinder},
              seeding_opts.seedfilter,
              finding_cfg,
+             resolution_cfg,
              fitting_cfg,
              det_descr,
              field,

examples/run/common/throughput_st.ipp

@@ -23,6 +23,7 @@
 #include "traccc/options/track_finding.hpp"
 #include "traccc/options/track_fitting.hpp"
 #include "traccc/options/track_propagation.hpp"
+#include "traccc/options/track_resolution.hpp"
 #include "traccc/options/track_seeding.hpp"
 
 // I/O include(s).
@@ -64,13 +65,14 @@ int throughput_st(std::string_view description, int argc, char* argv[],
     opts::track_seeding seeding_opts;
     opts::track_finding finding_opts;
     opts::track_propagation propagation_opts;
+    opts::track_resolution resolution_opts;
     opts::track_fitting fitting_opts;
     opts::throughput throughput_opts;
     opts::program_options program_opts{
         description,
         {detector_opts, bfield_opts, input_opts, clusterization_opts,
-         seeding_opts, finding_opts, propagation_opts, fitting_opts,
-         throughput_opts},
+         seeding_opts, finding_opts, propagation_opts, resolution_opts,
+         fitting_opts, throughput_opts},
         argc,
         argv,
         logger->cloneWithSuffix("Options")};
@@ -132,6 +134,9 @@ int throughput_st(std::string_view description, int argc, char* argv[],
         finding_opts);
     finding_cfg.propagation = propagation_config;
 
+    typename FULL_CHAIN_ALG::ambiguity_solving_algorithm::config_type
+        resolution_cfg(resolution_opts);
+
     typename FULL_CHAIN_ALG::fitting_algorithm::config_type fitting_cfg(
         fitting_opts);
     fitting_cfg.propagation = propagation_config;
@@ -140,7 +145,8 @@ int throughput_st(std::string_view description, int argc, char* argv[],
     std::unique_ptr<FULL_CHAIN_ALG> alg = std::make_unique<FULL_CHAIN_ALG>(
         alg_host_mr, clustering_cfg, seeding_opts.seedfinder,
         spacepoint_grid_config{seeding_opts.seedfinder},
-        seeding_opts.seedfilter, finding_cfg, fitting_cfg, det_descr, field,
+        seeding_opts.seedfilter, finding_cfg, resolution_cfg, fitting_cfg,
+        det_descr, field,
         (detector_opts.use_detray_detector ? &detector : nullptr),
         logger->clone("FullChainAlg"));
 

examples/run/cpu/full_chain_algorithm.cpp

@@ -16,6 +16,7 @@ full_chain_algorithm::full_chain_algorithm(
     const spacepoint_grid_config& grid_config,
     const seedfilter_config& filter_config,
     const finding_algorithm::config_type& finding_config,
+    const ambiguity_solving_algorithm::config_type& resolution_config,
     const fitting_algorithm::config_type& fitting_config,
     const silicon_detector_description::host& det_descr, const bfield& field,
     detector_type* detector, std::unique_ptr<const traccc::Logger> logger)
@@ -32,6 +33,8 @@ full_chain_algorithm::full_chain_algorithm(
       m_track_parameter_estimation(mr,
                                    logger->cloneWithSuffix("TrackParamEstAlg")),
       m_finding(finding_config, mr, logger->cloneWithSuffix("TrackFindingAlg")),
+      m_ambiguity_solving(resolution_config, mr,
+                          logger->cloneWithSuffix("AmbiguityResolutionAlg")),
       m_fitting(fitting_config, mr, *m_copy,
                 logger->cloneWithSuffix("TrackFittingAlg")),
       m_finder_config(finder_config),
@@ -76,10 +79,14 @@ full_chain_algorithm::output_type full_chain_algorithm::operator()(
         const finding_algorithm::output_type track_candidates = m_finding(
             *m_detector, m_field, measurements_view, track_params_view);
 
+        const ambiguity_solving_algorithm::output_type
+            resolved_track_candidates = m_ambiguity_solving(
+                {vecmem::get_data(track_candidates), measurements_view});
+
         // Run the track fitting, and return its results.
         return m_fitting(
             *m_detector, m_field,
-            {vecmem::get_data(track_candidates), measurements_view});
+            {vecmem::get_data(resolved_track_candidates), measurements_view});
     }
     // If not, just return an empty object.
     else {

examples/run/cpu/full_chain_algorithm.hpp

@@ -8,6 +8,7 @@
 #pragma once
 
 // Project include(s).
+#include "traccc/ambiguity_resolution/greedy_ambiguity_resolution_algorithm.hpp"
 #include "traccc/clusterization/clusterization_algorithm.hpp"
 #include "traccc/edm/silicon_cell_collection.hpp"
 #include "traccc/edm/track_state.hpp"
@@ -56,6 +57,9 @@ class full_chain_algorithm : public algorithm<track_state_container_types::host(
     /// Track finding algorithm type
     using finding_algorithm =
         traccc::host::combinatorial_kalman_filter_algorithm;
+    /// Ambiguity solving algorithm type
+    using ambiguity_solving_algorithm =
+        traccc::host::greedy_ambiguity_resolution_algorithm;
     /// Track fitting algorithm type
     using fitting_algorithm = traccc::host::kalman_fitting_algorithm;
 
@@ -68,16 +72,18 @@ class full_chain_algorithm : public algorithm<track_state_container_types::host(
     /// @param dummy This is not used anywhere. Allows templating CPU/Device
     /// algorithm.
     ///
-    full_chain_algorithm(vecmem::memory_resource& mr,
-                         const clustering_algorithm::config_type& dummy,
-                         const seedfinder_config& finder_config,
-                         const spacepoint_grid_config& grid_config,
-                         const seedfilter_config& filter_config,
-                         const finding_algorithm::config_type& finding_config,
-                         const fitting_algorithm::config_type& fitting_config,
-                         const silicon_detector_description::host& det_descr,
-                         const bfield& field, detector_type* detector,
-                         std::unique_ptr<const traccc::Logger> logger);
+    full_chain_algorithm(
+        vecmem::memory_resource& mr,
+        const clustering_algorithm::config_type& dummy,
+        const seedfinder_config& finder_config,
+        const spacepoint_grid_config& grid_config,
+        const seedfilter_config& filter_config,
+        const finding_algorithm::config_type& finding_config,
+        const ambiguity_solving_algorithm::config_type& resolution_config,
+        const fitting_algorithm::config_type& fitting_config,
+        const silicon_detector_description::host& det_descr,
+        const bfield& field, detector_type* detector,
+        std::unique_ptr<const traccc::Logger> logger);
 
     /// Reconstruct track parameters in the entire detector
     ///
@@ -115,6 +121,8 @@ class full_chain_algorithm : public algorithm<track_state_container_types::host(
 
     /// Track finding algorithm
     finding_algorithm m_finding;
+    /// Ambiguity solving algorithm
+    ambiguity_solving_algorithm m_ambiguity_solving;
     /// Track fitting algorithm
     fitting_algorithm m_fitting;
 
@@ -132,6 +140,8 @@ class full_chain_algorithm : public algorithm<track_state_container_types::host(
 
     /// Configuration for the track finding
     finding_algorithm::config_type m_finding_config;
+    /// Configuration for the ambiguity solving
+    ambiguity_solving_algorithm::config_type m_resolution_config;
     /// Configuration for the track fitting
     fitting_algorithm::config_type m_fitting_config;
 

examples/run/cuda/full_chain_algorithm.cpp

@@ -37,6 +37,7 @@ full_chain_algorithm::full_chain_algorithm(
     const spacepoint_grid_config& grid_config,
     const seedfilter_config& filter_config,
     const finding_algorithm::config_type& finding_config,
+    const ambiguity_solving_algorithm::config_type& resolution_config,
     const fitting_algorithm::config_type& fitting_config,
     const silicon_detector_description::host& det_descr, const bfield& field,
     host_detector_type* detector, std::unique_ptr<const traccc::Logger> logger)
@@ -72,6 +73,9 @@ full_chain_algorithm::full_chain_algorithm(
       m_finding(finding_config,
                 memory_resource{*m_cached_device_mr, &m_host_mr}, m_copy,
                 m_stream, logger->cloneWithSuffix("TrackFindingAlg")),
+      m_ambiguity_solving(
+          resolution_config, memory_resource{*m_cached_device_mr, &m_host_mr},
+          m_copy, m_stream, logger->cloneWithSuffix("AmbiguityResolutionAlg")),
       m_fitting(fitting_config,
                 memory_resource{*m_cached_device_mr, &m_host_mr}, m_copy,
                 m_stream, logger->cloneWithSuffix("TrackFittingAlg")),
@@ -80,6 +84,7 @@ full_chain_algorithm::full_chain_algorithm(
       m_grid_config(grid_config),
       m_filter_config(filter_config),
       m_finding_config(finding_config),
+      m_resolution_config(resolution_config),
       m_fitting_config(fitting_config) {
 
     // Tell the user what device is being used.
@@ -134,6 +139,10 @@ full_chain_algorithm::full_chain_algorithm(const full_chain_algorithm& parent)
       m_finding(parent.m_finding_config,
                 memory_resource{*m_cached_device_mr, &m_host_mr}, m_copy,
                 m_stream, parent.logger().cloneWithSuffix("TrackFindingAlg")),
+      m_ambiguity_solving(
+          parent.m_resolution_config,
+          memory_resource{*m_cached_device_mr, &m_host_mr}, m_copy, m_stream,
+          parent.logger().cloneWithSuffix("AmbiguityResolutionAlg")),
       m_fitting(parent.m_fitting_config,
                 memory_resource{*m_cached_device_mr, &m_host_mr}, m_copy,
                 m_stream, parent.logger().cloneWithSuffix("TrackFittingAlg")),
@@ -142,6 +151,7 @@ full_chain_algorithm::full_chain_algorithm(const full_chain_algorithm& parent)
       m_grid_config(parent.m_grid_config),
       m_filter_config(parent.m_filter_config),
       m_finding_config(parent.m_finding_config),
+      m_resolution_config(parent.m_resolution_config),
       m_fitting_config(parent.m_fitting_config) {
 
     // Copy the detector (description) to the device.
@@ -182,9 +192,15 @@ full_chain_algorithm::output_type full_chain_algorithm::operator()(
         const finding_algorithm::output_type track_candidates = m_finding(
             m_device_detector_view, m_field, measurements, track_params);
 
+        // Run the ambiguity solver (asynchronously).
+        const ambiguity_solving_algorithm::output_type
+            resolved_track_candidates =
+                m_ambiguity_solving({track_candidates, measurements});
+
         // Run the track fitting (asynchronously).
-        const fitting_algorithm::output_type track_states = m_fitting(
-            m_device_detector_view, m_field, {track_candidates, measurements});
+        const fitting_algorithm::output_type track_states =
+            m_fitting(m_device_detector_view, m_field,
+                      {resolved_track_candidates, measurements});
 
         // Copy a limited amount of result data back to the host.
         output_type result{&m_host_mr};

examples/run/cuda/full_chain_algorithm.hpp

@@ -9,6 +9,7 @@
 
 // Project include(s).
 #include "traccc/clusterization/clustering_config.hpp"
+#include "traccc/cuda/ambiguity_resolution/greedy_ambiguity_resolution_algorithm.hpp"
 #include "traccc/cuda/clusterization/clusterization_algorithm.hpp"
 #include "traccc/cuda/clusterization/measurement_sorting_algorithm.hpp"
 #include "traccc/cuda/finding/combinatorial_kalman_filter_algorithm.hpp"
@@ -66,6 +67,9 @@ class full_chain_algorithm
     /// Track finding algorithm type
     using finding_algorithm =
         traccc::cuda::combinatorial_kalman_filter_algorithm;
+    /// Ambiguity solving algorithm type
+    using ambiguity_solving_algorithm =
+        traccc::cuda::greedy_ambiguity_resolution_algorithm;
     /// Track fitting algorithm type
     using fitting_algorithm = traccc::cuda::kalman_fitting_algorithm;
 
@@ -76,16 +80,18 @@ class full_chain_algorithm
     /// @param mr The memory resource to use for the intermediate and result
     ///           objects
     ///
-    full_chain_algorithm(vecmem::memory_resource& host_mr,
-                         const clustering_config& clustering_config,
-                         const seedfinder_config& finder_config,
-                         const spacepoint_grid_config& grid_config,
-                         const seedfilter_config& filter_config,
-                         const finding_algorithm::config_type& finding_config,
-                         const fitting_algorithm::config_type& fitting_config,
-                         const silicon_detector_description::host& det_descr,
-                         const bfield& field, host_detector_type* detector,
-                         std::unique_ptr<const traccc::Logger> logger);
+    full_chain_algorithm(
+        vecmem::memory_resource& host_mr,
+        const clustering_config& clustering_config,
+        const seedfinder_config& finder_config,
+        const spacepoint_grid_config& grid_config,
+        const seedfilter_config& filter_config,
+        const finding_algorithm::config_type& finding_config,
+        const ambiguity_solving_algorithm::config_type& resolution_config,
+        const fitting_algorithm::config_type& fitting_config,
+        const silicon_detector_description::host& det_descr,
+        const bfield& field, host_detector_type* detector,
+        std::unique_ptr<const traccc::Logger> logger);
 
     /// Copy constructor
     ///
@@ -153,6 +159,8 @@ class full_chain_algorithm
 
     /// Track finding algorithm
     finding_algorithm m_finding;
+    /// Ambiguity solving algorithm
+    ambiguity_solving_algorithm m_ambiguity_solving;
     /// Track fitting algorithm
     fitting_algorithm m_fitting;
 
@@ -172,6 +180,8 @@ class full_chain_algorithm
 
     /// Configuration for the track finding
     finding_algorithm::config_type m_finding_config;
+    /// Configuration for the ambiguity solving
+    ambiguity_solving_algorithm::config_type m_resolution_config;
     /// Configuration for the track fitting
     fitting_algorithm::config_type m_fitting_config;