GBTS seeding example

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

@@ -46,7 +46,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

@@ -111,7 +111,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),
@@ -280,7 +280,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) {

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/apps/seq_example_alpaka.cpp

@@ -91,18 +91,7 @@ int seq_run(const traccc::opts::detector& detector_opts,
     traccc::detector_conditions_description::data host_det_cond_data{
         vecmem::get_data(host_det_cond)};
     traccc::detector_design_description::buffer device_det_descr{
-        [&]() {
-            std::vector<unsigned int> sizes(host_det_descr.size());
-            for (std::size_t i = 0; i < host_det_descr.size(); ++i) {
-                auto this_design = host_det_descr.at(i);
-
-                sizes[i] = std::max(static_cast<unsigned int>(
-                                        ((this_design.bin_edges_x()).size())),
-                                    static_cast<unsigned int>(
-                                        ((this_design.bin_edges_y()).size())));
-            }
-            return sizes;
-        }(),
+        vecmem::edm::get_capacities(vecmem::get_data(host_det_descr)),
         device_mr, &host_mr, vecmem::data::buffer_type::resizable};
     copy.setup(device_det_descr)->wait();
     copy(vecmem::get_data(host_det_descr), device_det_descr)->wait();

examples/run/alpaka/include/traccc/examples/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/alpaka/src/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),
@@ -40,20 +41,7 @@ full_chain_algorithm::full_chain_algorithm(
       m_field(make_magnetic_field(field, m_queue)),
       m_det_descr(det_descr),
       m_device_det_descr(
-          [&]() {
-              // number of elements in the detector design description
-              std::vector<unsigned int> sizes(det_descr.size());
-              for (std::size_t i = 0; i < det_descr.size(); ++i) {
-                  auto this_design = det_descr.at(i);
-                  // now for each element, set the size to the largest size of
-                  // that element across all modules
-                  sizes[i] = std::max(static_cast<unsigned int>(
-                                          ((this_design.bin_edges_x()).size())),
-                                      static_cast<unsigned int>((
-                                          (this_design.bin_edges_y()).size())));
-              }
-              return sizes;
-          }(),
+          vecmem::edm::get_capacities(vecmem::get_data(m_det_descr.get())),
           m_cached_device_mr, &m_cached_pinned_host_mr,
           vecmem::data::buffer_type::resizable),
       m_det_cond(det_cond),
@@ -90,10 +78,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.
@@ -122,21 +118,7 @@ full_chain_algorithm::full_chain_algorithm(const full_chain_algorithm& parent)
       m_field(parent.m_field),
       m_det_descr(parent.m_det_descr),
       m_device_det_descr(
-          [&]() {
-              // number of elements in the detector design description
-              std::vector<unsigned int> sizes(parent.m_det_descr.get().size());
-              for (std::size_t i = 0; i < parent.m_det_descr.get().size();
-                   ++i) {
-                  auto this_design = parent.m_det_descr.get().at(i);
-                  // now for each element, set the size to the largest size of
-                  // that element across all modules
-                  sizes[i] = std::max(static_cast<unsigned int>(
-                                          ((this_design.bin_edges_x()).size())),
-                                      static_cast<unsigned int>((
-                                          (this_design.bin_edges_y()).size())));
-              }
-              return sizes;
-          }(),
+          vecmem::edm::get_capacities(vecmem::get_data(m_det_descr.get())),
           m_cached_device_mr, &m_cached_pinned_host_mr,
           vecmem::data::buffer_type::resizable),
       m_det_cond(parent.m_det_cond),
@@ -176,9 +158,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.async_copy().setup(m_device_det_descr)->wait();