GBTS seeding example

device/cuda/include/traccc/cuda/gbts_seeding/gbts_seeding_algorithm.hpp

@@ -47,7 +47,7 @@ class gbts_seeding_algorithm
     /// @param str The CUDA stream to perform the operations in
     ///
     gbts_seeding_algorithm(
-        const gbts_seedfinder_config& cfg, traccc::memory_resource& mr,
+        const gbts_seedfinder_config& cfg, const traccc::memory_resource& mr,
         vecmem::copy& copy, stream& str,
         std::unique_ptr<const Logger> logger = getDummyLogger().clone());
 

device/cuda/src/gbts_seeding/gbts_seeding_algorithm.cu

@@ -115,7 +115,7 @@ struct gbts_ctx {
 };
 
 gbts_seeding_algorithm::gbts_seeding_algorithm(
-    const gbts_seedfinder_config& cfg, traccc::memory_resource& mr,
+    const gbts_seedfinder_config& cfg, const traccc::memory_resource& mr,
     vecmem::copy& copy, stream& str, std::unique_ptr<const Logger> logger)
     : messaging(logger->clone()),
       m_config(cfg),
@@ -282,7 +282,6 @@ gbts_seeding_algorithm::output_type gbts_seeding_algorithm::operator()(
         nNodesPerBlock, ctx.nNodes, m_config.n_phi_bins);
 
     cudaStreamSynchronize(stream);
-
     error = cudaGetLastError();
 
     if (error != cudaSuccess) {

device/cuda/src/gbts_seeding/kernels/GbtsNodesMakingKernels.cuh

@@ -50,10 +50,12 @@ __global__ void count_sp_by_layer(
 
         // some volume_ids map one to one with layer others need searching
         if (barcode.volume() > volumeMapSize) {
+            reducedSP[spIdx].w = -CHAR_MAX - 1;
             continue;  // unconfigured volume
         }
         short begin_or_bin = volumeToLayerMap[barcode.volume()];
         if (begin_or_bin == SHRT_MAX) {
+            reducedSP[spIdx].w = -CHAR_MAX - 1;
             continue;  // unconfigured volume
         }
         unsigned int layerIdx;

examples/options/CMakeLists.txt

@@ -27,6 +27,7 @@ traccc_add_library( traccc_options options TYPE SHARED
   "include/traccc/options/track_propagation.hpp"
   "include/traccc/options/track_resolution.hpp"
   "include/traccc/options/track_seeding.hpp"
+  "include/traccc/options/track_gbts_seeding.hpp"
   # source files
   "src/details/interface.cpp"
   "src/accelerator.cpp"
@@ -49,6 +50,7 @@ traccc_add_library( traccc_options options TYPE SHARED
   "src/track_propagation.cpp"
   "src/track_resolution.cpp"
   "src/track_seeding.cpp"
+  "src/track_gbts_seeding.cpp"
   "src/truth_finding.cpp"
   )
 target_link_libraries( traccc_options

examples/options/include/traccc/options/track_gbts_seeding.hpp

@@ -0,0 +1,47 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022-2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/gbts_seeding/gbts_seeding_config.hpp"
+#include "traccc/options/details/interface.hpp"
+
+// System include(s).
+#include <cstddef>
+
+namespace traccc::opts {
+
+/// Option(s) for multi-threaded code execution
+class track_gbts_seeding : public interface {
+
+    public:
+    /// @name Options
+    /// @{
+
+    bool useGBTS = false;
+    std::string config_dir = "DEFAULT";
+
+    /// @}
+    // config info from file
+    std::vector<std::pair<uint64_t, short>> barcodeBinning;
+    std::vector<std::pair<int, std::vector<int>>> binTables;
+    traccc::device::gbts_layerInfo layerInfo;
+
+    /// Constructor
+    track_gbts_seeding();
+
+    /// Read/process the command line options
+    ///
+    /// @param vm The command line options to interpret/read
+    ///
+    void read(const boost::program_options::variables_map& vm) override;
+
+    std::unique_ptr<configuration_printable> as_printable() const override;
+};
+
+}  // namespace traccc::opts

examples/options/src/track_gbts_seeding.cpp

@@ -0,0 +1,94 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2022-2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+// Local include(s).
+#include "traccc/options/track_gbts_seeding.hpp"
+
+#include "traccc/examples/utils/printable.hpp"
+
+// System include(s).
+#include <filesystem>
+#include <fstream>
+#include <stdexcept>
+
+namespace traccc::opts {
+
+track_gbts_seeding::track_gbts_seeding() : interface("GBTS Options") {
+    m_desc.add_options()("useGBTS",
+                         boost::program_options::bool_switch(&useGBTS),
+                         "use gbts algorithm");
+
+    m_desc.add_options()(
+        "gbts_config_dir",
+        boost::program_options::value(&config_dir)->default_value(config_dir),
+        "directory for gbts config files");
+}
+
+void track_gbts_seeding::read(const boost::program_options::variables_map &) {
+    // fill config
+    if (!useGBTS) {
+        return;
+    }
+    std::ifstream barcodeBinningFile(
+        std::filesystem::path(config_dir + "/barcodeBinning.txt"));
+
+    unsigned int nBarcodes = 0;
+    barcodeBinningFile >> nBarcodes;
+    barcodeBinning.reserve(nBarcodes);
+
+    std::pair<uint64_t, short> barcodeLayerPair;
+    for (; nBarcodes > 0u; --nBarcodes) {
+        barcodeBinningFile >> barcodeLayerPair.first;
+        barcodeBinningFile >> barcodeLayerPair.second;
+
+        barcodeBinning.push_back(barcodeLayerPair);
+    }
+
+    std::ifstream binTablesFile(
+        std::filesystem::path(config_dir + "/binTables.txt"));
+
+    unsigned int nBinPairs = 0;
+    binTablesFile >> nBinPairs;
+    binTables.reserve(nBinPairs);
+    int bin1 = 0;
+    std::vector<int> bin2 = {0};
+    for (; nBinPairs > 0; --nBinPairs) {
+        binTablesFile >> bin1;
+        binTablesFile >> bin2[0];
+        binTables.emplace_back(bin1, bin2);
+    }
+
+    std::ifstream layerInfoFile(
+        std::filesystem::path(config_dir + "/layerInfo.txt"));
+
+    unsigned int nLayers = 0;
+    layerInfoFile >> nLayers;
+    layerInfo.reserve(nLayers);
+    char type = 0;
+    std::array<int, 2> info = {0, 0};
+    std::array<float, 2> geo = {0, 0};
+    for (; nLayers > 0u; --nLayers) {
+        layerInfoFile >> type;
+        layerInfoFile >> info[0] >> info[1];
+        layerInfoFile >> geo[0] >> geo[1];
+        layerInfo.addLayer(type, info[0], info[1], geo[0], geo[1]);
+    }
+}
+
+std::unique_ptr<configuration_printable> track_gbts_seeding::as_printable()
+    const {
+    auto cat = std::make_unique<configuration_category>(m_description);
+
+    cat->add_child(std::make_unique<configuration_kv_pair>(
+        "using gbts algorithm ", std::to_string(useGBTS)));
+    cat->add_child(std::make_unique<configuration_kv_pair>(
+        "gbts config directory ", config_dir));
+
+    return cat;
+}
+
+}  // namespace traccc::opts

examples/run/alpaka/full_chain_algorithm.cpp

@@ -23,13 +23,14 @@ full_chain_algorithm::full_chain_algorithm(
     const seedfinder_config& finder_config,
     const spacepoint_grid_config& grid_config,
     const seedfilter_config& filter_config,
+    const gbts_seedfinder_config& gbts_config,
     const track_params_estimation_config& track_params_estimation_config,
     const finding_algorithm::config_type& finding_config,
     const fitting_algorithm::config_type& fitting_config,
     const detector_design_description::host& det_descr,
     const detector_conditions_description::host& det_cond,
     const magnetic_field& field, host_detector* detector,
-    std::unique_ptr<const traccc::Logger> logger)
+    std::unique_ptr<const traccc::Logger> logger, bool useGBTS)
     : messaging(logger->clone()),
       m_queue(),
       m_vecmem_objects(m_queue),
@@ -90,10 +91,18 @@ full_chain_algorithm::full_chain_algorithm(
       m_finder_config(finder_config),
       m_grid_config(grid_config),
       m_filter_config(filter_config),
+      m_gbts_config(gbts_config),
       m_track_params_estimation_config(track_params_estimation_config),
       m_finding_config(finding_config),
-      m_fitting_config(fitting_config) {
+      m_fitting_config(fitting_config),
+      usingGBTS(useGBTS) {
 
+    if (usingGBTS) {
+        TRACCC_LOCAL_LOGGER(std::move(logger));
+        TRACCC_ERROR(
+            "GBTS not implemented for alpaka, this will run with "
+            "triplet seeding");
+    }
     std::cout << traccc::alpaka::get_device_info() << std::endl;
 
     // Copy the detector (description) to the device.
@@ -172,9 +181,11 @@ full_chain_algorithm::full_chain_algorithm(const full_chain_algorithm& parent)
       m_finder_config(parent.m_finder_config),
       m_grid_config(parent.m_grid_config),
       m_filter_config(parent.m_filter_config),
+      m_gbts_config(parent.m_gbts_config),
       m_track_params_estimation_config(parent.m_track_params_estimation_config),
       m_finding_config(parent.m_finding_config),
-      m_fitting_config(parent.m_fitting_config) {
+      m_fitting_config(parent.m_fitting_config),
+      usingGBTS(parent.usingGBTS) {
 
     // Copy the detector (description) to the device.
     m_vecmem_objects

examples/run/alpaka/full_chain_algorithm.hpp

@@ -31,6 +31,8 @@
 #include "traccc/utils/algorithm.hpp"
 #include "traccc/utils/messaging.hpp"
 #include "traccc/utils/propagation.hpp"
+// GBTS include for placeholder input (not implemented)
+#include "traccc/gbts_seeding/gbts_seeding_config.hpp"
 
 // VecMem include(s).
 #include <vecmem/containers/vector.hpp>
@@ -79,13 +81,14 @@ class full_chain_algorithm
         const seedfinder_config& finder_config,
         const spacepoint_grid_config& grid_config,
         const seedfilter_config& filter_config,
+        const gbts_seedfinder_config& gbts_config,
         const track_params_estimation_config& track_params_estimation_config,
         const finding_algorithm::config_type& finding_config,
         const fitting_algorithm::config_type& fitting_config,
         const detector_design_description::host& det_descr,
         const detector_conditions_description::host& det_cond,
         const magnetic_field& field, host_detector* detector,
-        std::unique_ptr<const traccc::Logger> logger);
+        std::unique_ptr<const traccc::Logger> logger, bool useGBTS = false);
 
     /// Copy constructor
     ///
@@ -181,13 +184,18 @@ class full_chain_algorithm
     spacepoint_grid_config m_grid_config;
     /// Configuration for the seed filtering
     seedfilter_config m_filter_config;
+    /// placeholder GBTS config
+    [[maybe_unused]] gbts_seedfinder_config m_gbts_config;
     /// Configuration for track parameter estimation
     track_params_estimation_config m_track_params_estimation_config;
+
     /// Configuration for the track finding
     finding_algorithm::config_type m_finding_config;
     /// Configuration for the track fitting
     fitting_algorithm::config_type m_fitting_config;
 
+    bool usingGBTS;
+
     /// @}
 
 };  // class full_chain_algorithm

examples/run/common/throughput_mt.ipp

@@ -26,6 +26,7 @@
 #include "traccc/options/throughput.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_seeding.hpp"
 
@@ -77,6 +78,7 @@ int throughput_mt(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;
@@ -86,8 +88,8 @@ int throughput_mt(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, threading_opts, logging_opts},
+         seeding_opts, seeding_gbts_opts, finding_opts, propagation_opts,
+         fitting_opts, throughput_opts, threading_opts, logging_opts},
         argc,
         argv,
         prelogger->cloneWithSuffix("Options")};
@@ -147,10 +149,23 @@ int throughput_mt(std::string_view description, int argc, char* argv[]) {
     // Algorithm configuration(s).
     typename FULL_CHAIN_ALG::clustering_algorithm::config_type clustering_cfg(
         clusterization_opts);
+
     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);
     const traccc::track_params_estimation_config track_params_estimation_config;
+
+    traccc::gbts_seedfinder_config gbts_config;
+    if (seeding_gbts_opts.useGBTS) {
+        if (!gbts_config.setLinkingScheme(
+                seeding_gbts_opts.binTables, seeding_gbts_opts.layerInfo,
+                seeding_gbts_opts.barcodeBinning, 900.0f,
+                prelogger->clone("GBTSconfig"))) {
+            TRACCC_ERROR("failure in setting gbts linking scheme");
+            return -1;
+        }
+    }
+
     detray::propagation::config propagation_config(propagation_opts);
     typename FULL_CHAIN_ALG::finding_algorithm::config_type finding_cfg(
         finding_opts);
@@ -165,10 +180,10 @@ int throughput_mt(std::string_view description, int argc, char* argv[]) {
     algs.reserve(threading_opts.threads + 1);
     for (std::size_t i = 0; i < threading_opts.threads + 1; ++i) {
         algs.push_back({host_mr, clustering_cfg, seedfinder_config,
-                        spacepoint_grid_config, seedfilter_config,
+                        spacepoint_grid_config, seedfilter_config, gbts_config,
                         track_params_estimation_config, finding_cfg,
                         fitting_cfg, det_descr, det_cond, field, &detector,
-                        logger().clone()});
+                        logger().clone(), seeding_gbts_opts.useGBTS});
     }
 
     // Set up a lambda that calls the correct function on the algorithms.

examples/run/common/throughput_st.ipp

@@ -25,6 +25,7 @@
 #include "traccc/options/throughput.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_seeding.hpp"
 
@@ -131,7 +132,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::track_params_estimation_config track_params_estimation_config;
 
     typename FULL_CHAIN_ALG::finding_algorithm::config_type finding_cfg(
@@ -145,8 +146,8 @@ int throughput_st(std::string_view description, int argc, char* argv[]) {
     // Set up the full-chain algorithm.
     std::unique_ptr<FULL_CHAIN_ALG> alg = std::make_unique<FULL_CHAIN_ALG>(
         host_mr, clustering_cfg, seedfinder_config, spacepoint_grid_config,
-        seedfilter_config, track_params_estimation_config, finding_cfg,
-        fitting_cfg, det_descr, det_cond, field, &detector,
+        seedfilter_config, gbts_config, track_params_estimation_config,
+        finding_cfg, fitting_cfg, det_descr, det_cond, field, &detector,
         logger().clone("FullChainAlg"));
 
     // Seed the random number generator.