GBTS seeding example (#1286)

* Add GBTS options for mt runner

* setting up gbts algs in full_chain cpu/cuda compilation

* GBTS working in the mt

* adding placeholders for backends without GBTS impl

* formatting and placeholders for sycl alpaka

* testing with extra compiler flags

* formatting

* reverting extra compilation flags

* removing submodule

* more itk_throughput tyding

* sign conversion and array type fixes

* rebase fixes

* reabse fixes and adding GBTS to full_chain seeding

* formatting

* reorder arguments

* fixes and adding asserts to alpaka and sycl

* changing asserts to print statments

* add unused to gbts config

* update GBTS not implemented logging

* fix logger

* formatting

* fixed: forgotten rebase conflict

* revert to triplet_seeding_alg output type for the common seed type

* GBTS seeding example

Adding the seeding example for the ability to run physics performance
testing on the GBTS algorithm. This is building on PR-1194 and PR-1284.

* Adding throughput st to make baseline performance optimisations, and testing for that

* Adding seq_example for testing

* VecMem Update, main branch (2026.04.10.) (#1291)

* Updated the project to vecmem 1.24.0.

* Switched to creating detector design buffers more easily.

Using the code that's now available from vecmem directly.

* GBTS example changes

I have add the cuda seeding and seq example, while extending the
thoughput_st to also have the option for GBTS

* reformating

I just ran pre-commit

* gbts runtime error if input is missing

I have just added a small check to see if the files exists, so it throws
a proper error instead of a seg fault

* GBTS cleanup

Here i have cleaned the code a bit so there should be no more wrong
changes

* gbts formating

I forgot to run precommit again

---------

Co-authored-by: Mark Brettell <mbrettel@lxplus902.cern.ch>
Co-authored-by: Mark <markbrettel@cern.ch>
Co-authored-by: Mark Brettell <egi71871@hepacc09.pp.rl.ac.uk>
Co-authored-by: Fabrice Le Goff <fabrice.le.goff@cern.ch>
Co-authored-by: Attila Krasznahorkay <30694331+krasznaa@users.noreply.github.com>

Author: 6 people

examples/options/src/track_gbts_seeding.cpp

@@ -167,8 +167,12 @@ void track_gbts_seeding::read(const boost::program_options::variables_map &) {
     std::vector<std::pair<int, std::vector<int>>> binTables;
     traccc::device::gbts_layerInfo layerInfo;
 
-    std::ifstream barcodeBinningFile(
-        std::filesystem::path(config_dir + "/barcodeBinning.txt"));
+    auto barcodeBinningPath =
+        std::filesystem::path(config_dir + "/barcodeBinning.txt");
+    if (!std::filesystem::exists(barcodeBinningPath)) {
+        throw std::runtime_error("barcodeBinning.txt file not found");
+    }
+    std::ifstream barcodeBinningFile(barcodeBinningPath);
 
     unsigned int nBarcodes = 0;
     barcodeBinningFile >> nBarcodes;
@@ -182,8 +186,11 @@ void track_gbts_seeding::read(const boost::program_options::variables_map &) {
         barcodeBinning.push_back(barcodeLayerPair);
     }
 
-    std::ifstream binTablesFile(
-        std::filesystem::path(config_dir + "/binTables.txt"));
+    auto binTablesPath = std::filesystem::path(config_dir + "/binTables.txt");
+    if (!std::filesystem::exists(binTablesPath)) {
+        throw std::runtime_error("binTables.txt file not found");
+    }
+    std::ifstream binTablesFile(binTablesPath);
 
     unsigned int nBinPairs = 0;
     binTablesFile >> nBinPairs;
@@ -196,8 +203,11 @@ void track_gbts_seeding::read(const boost::program_options::variables_map &) {
         binTables.emplace_back(bin1, bin2);
     }
 
-    std::ifstream layerInfoFile(
-        std::filesystem::path(config_dir + "/layerInfo.txt"));
+    auto layerInfoPath = std::filesystem::path(config_dir + "/layerInfo.txt");
+    if (!std::filesystem::exists(layerInfoPath)) {
+        throw std::runtime_error("layerInfo.txt file not found");
+    }
+    std::ifstream layerInfoFile(layerInfoPath);
 
     unsigned int nLayers = 0;
     layerInfoFile >> nLayers;

examples/run/common/include/traccc/examples/impl/throughput_st.ipp

@@ -67,6 +67,7 @@ int throughput_st(std::string_view description, int argc, char* argv[]) {
     opts::input_data input_opts;
     opts::clusterization clusterization_opts;
     opts::track_seeding seeding_opts;
+    opts::track_gbts_seeding seeding_gbts_opts;
     opts::track_finding finding_opts;
     opts::track_propagation propagation_opts;
     opts::track_fitting fitting_opts;
@@ -75,8 +76,8 @@ int throughput_st(std::string_view description, int argc, char* argv[]) {
     opts::program_options program_opts{
         description,
         {detector_opts, bfield_opts, input_opts, clusterization_opts,
-         seeding_opts, finding_opts, propagation_opts, fitting_opts,
-         throughput_opts, logging_opts},
+         seeding_opts, seeding_gbts_opts, finding_opts, propagation_opts,
+         fitting_opts, throughput_opts, logging_opts},
         argc,
         argv,
         prelogger->cloneWithSuffix("Options")};
@@ -132,7 +133,7 @@ int throughput_st(std::string_view description, int argc, char* argv[]) {
     const traccc::seedfinder_config seedfinder_config(seeding_opts);
     const traccc::seedfilter_config seedfilter_config(seeding_opts);
     const traccc::spacepoint_grid_config spacepoint_grid_config(seeding_opts);
-    traccc::gbts_seedfinder_config gbts_config;
+    const traccc::gbts_seedfinder_config gbts_config(seeding_gbts_opts);
     const traccc::track_params_estimation_config track_params_estimation_config;
 
     typename FULL_CHAIN_ALG::finding_algorithm::config_type finding_cfg(
@@ -148,7 +149,7 @@ int throughput_st(std::string_view description, int argc, char* argv[]) {
         host_mr, clustering_cfg, seedfinder_config, spacepoint_grid_config,
         seedfilter_config, gbts_config, track_params_estimation_config,
         finding_cfg, fitting_cfg, det_descr, det_cond, field, &detector,
-        logger().clone("FullChainAlg"));
+        logger().clone("FullChainAlg"), seeding_gbts_opts.useGBTS);
 
     // Seed the random number generator.
     if (throughput_opts.random_seed == 0) {

examples/run/cuda/apps/seeding_example_cuda.cpp

@@ -59,6 +59,10 @@
 #include <vecmem/utils/cuda/async_copy.hpp>
 #include <vecmem/utils/cuda/copy.hpp>
 
+#include "traccc/cuda/gbts_seeding/gbts_seeding_algorithm.hpp"
+#include "traccc/gbts_seeding/gbts_seeding_config.hpp"
+#include "traccc/options/track_gbts_seeding.hpp"
+
 // System include(s).
 #include <exception>
 #include <iomanip>
@@ -67,6 +71,7 @@
 using namespace traccc;
 
 int seq_run(const traccc::opts::track_seeding& seeding_opts,
+            const traccc::opts::track_gbts_seeding& seeding_gbts_opts,
             const traccc::opts::track_finding& finding_opts,
             const traccc::opts::track_propagation& propagation_opts,
             [[maybe_unused]] const traccc::opts::track_fitting& fitting_opts,
@@ -78,7 +83,7 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
             const traccc::opts::truth_finding& truth_finding_opts,
             const traccc::opts::seed_matching& seed_matching_opts,
             const traccc::opts::track_matching& track_matching_opts,
-            std::unique_ptr<const traccc::Logger> ilogger) {
+            std::unique_ptr<const traccc::Logger> ilogger, bool usingGBTS) {
     TRACCC_LOCAL_LOGGER(std::move(ilogger));
 
     // Memory resources used by the application.
@@ -156,6 +161,8 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
     const traccc::detector_buffer detector_buffer =
         traccc::buffer_from_host_detector(host_det, mng_mr, host_copy);
 
+    // GBTS seeding configuration
+    const traccc::gbts_seedfinder_config gbts_config(seeding_gbts_opts);
     // Seeding algorithm
     const traccc::seedfinder_config seedfinder_config(seeding_opts);
     const traccc::seedfilter_config seedfilter_config(seeding_opts);
@@ -180,6 +187,8 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
         async_copy,
         stream,
         logger().clone("CudaSeedingAlg")};
+    traccc::cuda::gbts_seeding_algorithm gbts_sa_cuda(
+        gbts_config, mr, copy, stream, logger().clone("CudaGbtsSeedingAlg"));
     traccc::cuda::seed_parameter_estimation_algorithm tp_cuda{
         track_params_estimation_config, mr, async_copy, stream,
         logger().clone("CudaTrackParEstAlg")};
@@ -264,7 +273,12 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
             {
                 traccc::performance::timer t("Seeding (cuda)", elapsedTimes);
                 // Reconstruct the spacepoints into seeds.
-                seeds_cuda_buffer = sa_cuda(spacepoints_cuda_buffer);
+                if (usingGBTS) {
+                    seeds_cuda_buffer = gbts_sa_cuda(spacepoints_cuda_buffer,
+                                                     measurements_cuda_buffer);
+                } else {
+                    seeds_cuda_buffer = sa_cuda(spacepoints_cuda_buffer);
+                }
                 stream.synchronize();
             }  // stop measuring seeding cuda timer
 
@@ -452,6 +466,7 @@ int main(int argc, char* argv[]) {
     traccc::opts::magnetic_field bfield_opts;
     traccc::opts::input_data input_opts;
     traccc::opts::track_seeding seeding_opts;
+    traccc::opts::track_gbts_seeding seeding_gbts_opts;
     traccc::opts::track_finding finding_opts;
     traccc::opts::track_propagation propagation_opts;
     traccc::opts::track_fitting fitting_opts;
@@ -462,16 +477,18 @@ int main(int argc, char* argv[]) {
     traccc::opts::track_matching track_matching_opts;
     traccc::opts::program_options program_opts{
         "Full Tracking Chain Using CUDA (without clusterization)",
-        {detector_opts, bfield_opts, input_opts, seeding_opts, finding_opts,
-         propagation_opts, fitting_opts, performance_opts, accelerator_opts,
-         truth_finding_opts, seed_matching_opts, track_matching_opts},
+        {detector_opts, bfield_opts, input_opts, seeding_opts,
+         seeding_gbts_opts, finding_opts, propagation_opts, fitting_opts,
+         performance_opts, accelerator_opts, truth_finding_opts,
+         seed_matching_opts, track_matching_opts},
         argc,
         argv,
         logger->cloneWithSuffix("Options")};
 
     // Run the application.
-    return seq_run(seeding_opts, finding_opts, propagation_opts, fitting_opts,
-                   input_opts, detector_opts, bfield_opts, performance_opts,
-                   accelerator_opts, truth_finding_opts, seed_matching_opts,
-                   track_matching_opts, logger->clone());
+    return seq_run(seeding_opts, seeding_gbts_opts, finding_opts,
+                   propagation_opts, fitting_opts, input_opts, detector_opts,
+                   bfield_opts, performance_opts, accelerator_opts,
+                   truth_finding_opts, seed_matching_opts, track_matching_opts,
+                   logger->clone(), seeding_gbts_opts.useGBTS);
 }

examples/run/cuda/apps/seq_example_cuda.cpp

@@ -13,6 +13,7 @@
 #include "traccc/cuda/clusterization/measurement_sorting_algorithm.hpp"
 #include "traccc/cuda/finding/combinatorial_kalman_filter_algorithm.hpp"
 #include "traccc/cuda/fitting/kalman_fitting_algorithm.hpp"
+#include "traccc/cuda/gbts_seeding/gbts_seeding_algorithm.hpp"
 #include "traccc/cuda/seeding/seed_parameter_estimation_algorithm.hpp"
 #include "traccc/cuda/seeding/silicon_pixel_spacepoint_formation_algorithm.hpp"
 #include "traccc/cuda/seeding/triplet_seeding_algorithm.hpp"
@@ -23,6 +24,7 @@
 #include "traccc/examples/make_magnetic_field.hpp"
 #include "traccc/finding/combinatorial_kalman_filter_algorithm.hpp"
 #include "traccc/fitting/kalman_fitting_algorithm.hpp"
+#include "traccc/gbts_seeding/gbts_seeding_config.hpp"
 #include "traccc/geometry/detector.hpp"
 #include "traccc/geometry/detector_buffer.hpp"
 #include "traccc/geometry/host_detector.hpp"
@@ -39,6 +41,7 @@
 #include "traccc/options/program_options.hpp"
 #include "traccc/options/track_finding.hpp"
 #include "traccc/options/track_fitting.hpp"
+#include "traccc/options/track_gbts_seeding.hpp"
 #include "traccc/options/track_propagation.hpp"
 #include "traccc/options/track_resolution.hpp"
 #include "traccc/options/track_seeding.hpp"
@@ -68,13 +71,14 @@ int seq_run(const traccc::opts::detector& detector_opts,
             const traccc::opts::input_data& input_opts,
             const traccc::opts::clusterization& clusterization_opts,
             const traccc::opts::track_seeding& seeding_opts,
+            const traccc::opts::track_gbts_seeding& seeding_gbts_opts,
             const traccc::opts::track_finding& finding_opts,
             const traccc::opts::track_propagation& propagation_opts,
             const traccc::opts::track_resolution& resolution_opts,
             const traccc::opts::track_fitting& fitting_opts,
             const traccc::opts::performance& performance_opts,
             const traccc::opts::accelerator& accelerator_opts,
-            std::unique_ptr<const traccc::Logger> ilogger) {
+            std::unique_ptr<const traccc::Logger> ilogger, bool usingGBTS) {
     TRACCC_LOCAL_LOGGER(std::move(ilogger));
 
     // Memory resources used by the application.
@@ -172,6 +176,9 @@ int seq_run(const traccc::opts::detector& detector_opts,
     const traccc::seedfilter_config seedfilter_config(seeding_opts);
     const traccc::spacepoint_grid_config spacepoint_grid_config(seeding_opts);
 
+    // GBTS seeding configuration
+    traccc::gbts_seedfinder_config gbts_config(seeding_gbts_opts);
+
     traccc::finding_config finding_cfg(finding_opts);
     finding_cfg.propagation = propagation_config;
 
@@ -219,6 +226,8 @@ int seq_run(const traccc::opts::detector& detector_opts,
     traccc::cuda::triplet_seeding_algorithm sa_cuda(
         seedfinder_config, spacepoint_grid_config, seedfilter_config, mr, copy,
         stream, logger().clone("CudaSeedingAlg"));
+    traccc::cuda::gbts_seeding_algorithm gbts_sa_cuda(
+        gbts_config, mr, copy, stream, logger().clone("CudaGbtsSeedingAlg"));
     traccc::cuda::seed_parameter_estimation_algorithm tp_cuda(
         track_params_estimation_config, mr, copy, stream,
         logger().clone("CudaTrackParEstAlg"));
@@ -332,7 +341,12 @@ int seq_run(const traccc::opts::detector& detector_opts,
             // CUDA
             {
                 traccc::performance::timer t("Seeding (cuda)", elapsedTimes);
-                seeds_cuda_buffer = sa_cuda(spacepoints_cuda_buffer);
+                if (usingGBTS) {
+                    seeds_cuda_buffer = gbts_sa_cuda(spacepoints_cuda_buffer,
+                                                     measurements_cuda_buffer);
+                } else {
+                    seeds_cuda_buffer = sa_cuda(spacepoints_cuda_buffer);
+                }
                 stream.synchronize();
             }  // stop measuring seeding cuda timer
 
@@ -593,6 +607,7 @@ int main(int argc, char* argv[]) {
     traccc::opts::input_data input_opts;
     traccc::opts::clusterization clusterization_opts;
     traccc::opts::track_seeding seeding_opts;
+    traccc::opts::track_gbts_seeding seeding_gbts_opts;
     traccc::opts::track_finding finding_opts;
     traccc::opts::track_propagation propagation_opts;
     traccc::opts::track_resolution resolution_opts;
@@ -602,15 +617,16 @@ int main(int argc, char* argv[]) {
     traccc::opts::program_options program_opts{
         "Full Tracking Chain Using CUDA",
         {detector_opts, bfield_opts, input_opts, clusterization_opts,
-         seeding_opts, finding_opts, propagation_opts, resolution_opts,
-         performance_opts, fitting_opts, accelerator_opts},
+         seeding_opts, seeding_gbts_opts, finding_opts, propagation_opts,
+         resolution_opts, performance_opts, fitting_opts, accelerator_opts},
         argc,
         argv,
         logger->cloneWithSuffix("Options")};
 
     // Run the application.
     return seq_run(detector_opts, bfield_opts, input_opts, clusterization_opts,
-                   seeding_opts, finding_opts, propagation_opts,
-                   resolution_opts, fitting_opts, performance_opts,
-                   accelerator_opts, logger->clone());
+                   seeding_opts, seeding_gbts_opts, finding_opts,
+                   propagation_opts, resolution_opts, fitting_opts,
+                   performance_opts, accelerator_opts, logger->clone(),
+                   seeding_gbts_opts.useGBTS);
 }