options/src/track_gbts_seeding.cpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2022-2025 CERN for the benefit of the ACTS project
0004  *
0005  * Mozilla Public License Version 2.0
0006  */
0007
0008 // Local include(s).
0009 #include "traccc/options/track_gbts_seeding.hpp"
0010
0011 #include "traccc/examples/utils/printable.hpp"
0012
0013 // System include(s).
0014 #include <filesystem>
0015 #include <format>
0016 #include <fstream>
0017 #include <stdexcept>
0018
0019 namespace traccc::opts {
0020
0021 /// Convenience namespace int16_thand
0022 namespace po = boost::program_options;
0023
0024 track_gbts_seeding::track_gbts_seeding() : interface("GBTS Options") {
0025   // get linking scheme
0026   m_desc.add_options()(
0027       "gbts_config_dir",
0028       boost::program_options::value(&config_dir)->default_value(config_dir),
0029       "directory for gbts config files");
0030   m_desc.add_options()("useGBTS", boost::program_options::bool_switch(&useGBTS),
0031                        "use gbts algorithm");
0032   // set CLI tunings for graph building
0033   m_desc.add_options()(
0034       "min_pt", po::value(&min_pt)->default_value(min_pt),
0035       "min_pt to scale other cuts by with refrence to 900 MeV [MeV]");
0036   m_desc.add_options()("max_edges_factor",
0037                        po::value(&gbts_config.max_edges_factor)
0038                            ->default_value(gbts_config.max_edges_factor),
0039                        "number of edges allocated for per node ");
0040
0041   m_desc.add_options()(
0042       "min_delta_phi",
0043       po::value(&gbts_config.gbts_dphi_window_params.min_delta_phi)
0044           ->default_value(gbts_config.gbts_dphi_window_params.min_delta_phi),
0045       "min_delta_phi for the sliding window [rads]");
0046   m_desc.add_options()(
0047       "dphi_coeff for the sliding window",
0048       po::value(&gbts_config.gbts_dphi_window_params.dphi_coeff)
0049           ->default_value(gbts_config.gbts_dphi_window_params.dphi_coeff),
0050       "dphi_coeff for the sliding window");
0051   m_desc.add_options()(
0052       "min_delta_phi_low_dr",
0053       po::value(&gbts_config.gbts_dphi_window_params.min_delta_phi_low_dr)
0054           ->default_value(
0055               gbts_config.gbts_dphi_window_params.min_delta_phi_low_dr),
0056       "min_delta_phi_low_dr for the sliding window [rads]");
0057   m_desc.add_options()(
0058       "dphi_coeff_low_dr",
0059       po::value(&gbts_config.gbts_dphi_window_params.dphi_coeff_low_dr)
0060           ->default_value(
0061               gbts_config.gbts_dphi_window_params.dphi_coeff_low_dr),
0062       "dphi_coeff_low_dr for the sliding window");
0063   m_desc.add_options()(
0064       "max_Kappa",
0065       po::value(&gbts_config.gbts_make_graph_edges_params.max_Kappa)
0066           ->default_value(gbts_config.gbts_make_graph_edges_params.max_Kappa),
0067       "max curvature for an edge + origin triplet [1/mm]");
0068
0069   m_desc.add_options()(
0070       "min_z0",
0071       po::value(&gbts_config.gbts_make_graph_edges_params.min_z0)
0072           ->default_value(gbts_config.gbts_make_graph_edges_params.min_z0),
0073       "min projected z0 for an edge [mm]");
0074   m_desc.add_options()(
0075       "max_z0",
0076       po::value(&gbts_config.gbts_make_graph_edges_params.max_z0)
0077           ->default_value(gbts_config.gbts_make_graph_edges_params.max_z0),
0078       "max projected z0 for an edge [mm]");
0079   m_desc.add_options()(
0080       "maxOuterRadius projected for an edge",
0081       po::value(&gbts_config.gbts_make_graph_edges_params.maxOuterRadius)
0082           ->default_value(
0083               gbts_config.gbts_make_graph_edges_params.maxOuterRadius),
0084       "maxOuterRadius [mm]");
0085
0086   m_desc.add_options()(
0087       "cut_dphi_max",
0088       po::value(&gbts_config.gbts_match_graph_edges_params.cut_dphi_max)
0089           ->default_value(
0090               gbts_config.gbts_match_graph_edges_params.cut_dphi_max),
0091       "cut_dphi_max for edge matching [rads]");
0092   m_desc.add_options()(
0093       "cut_dcurv_max",
0094       po::value(&gbts_config.gbts_match_graph_edges_params.cut_dcurv_max)
0095           ->default_value(
0096               gbts_config.gbts_match_graph_edges_params.cut_dcurv_max),
0097       "cut_dcurv_max for edge matching [1/mm]");
0098   m_desc.add_options()(
0099       "cut_tau_ratio_max",
0100       po::value(&gbts_config.gbts_match_graph_edges_params.cut_tau_ratio_max)
0101           ->default_value(
0102               gbts_config.gbts_match_graph_edges_params.cut_tau_ratio_max),
0103       "cut_tau_ratio_max for edge matching");
0104   m_desc.add_options()("max_num_neighbours",
0105                        po::value(&gbts_config.max_num_neighbours)
0106                            ->default_value(gbts_config.max_num_neighbours),
0107                        "max connected neighbours for each edge");
0108   // set CLI tuning for seed extraction kalman filter
0109   m_desc.add_options()(
0110       "sigmaMS",
0111       po::value(&gbts_config.gbts_fit_segments_params.sigmaMS)
0112           ->default_value(gbts_config.gbts_fit_segments_params.sigmaMS),
0113       "sigmaMS for a 900MeV track at eta=0, used in seed fitting");
0114   m_desc.add_options()(
0115       "radLen",
0116       po::value(&gbts_config.gbts_fit_segments_params.radLen)
0117           ->default_value(gbts_config.gbts_fit_segments_params.radLen),
0118       "% radLen per layer for seed fitting");
0119   m_desc.add_options()(
0120       "sigma_x",
0121       po::value(&gbts_config.gbts_fit_segments_params.sigma_x)
0122           ->default_value(gbts_config.gbts_fit_segments_params.sigma_x),
0123       "sigma_x for a seed's fit");
0124   m_desc.add_options()(
0125       "sigma_y",
0126       po::value(&gbts_config.gbts_fit_segments_params.sigma_y)
0127           ->default_value(gbts_config.gbts_fit_segments_params.sigma_y),
0128       "sigma_y for a seed's fit");
0129   m_desc.add_options()(
0130       "maxDChi2_x",
0131       po::value(&gbts_config.gbts_fit_segments_params.maxDChi2_x)
0132           ->default_value(gbts_config.gbts_fit_segments_params.maxDChi2_x),
0133       "maxDChi2_x for a seed's fit");
0134   m_desc.add_options()(
0135       "maxDChi2_y ",
0136       po::value(&gbts_config.gbts_fit_segments_params.maxDChi2_y)
0137           ->default_value(gbts_config.gbts_fit_segments_params.maxDChi2_y),
0138       "maxDChi2_y for a seed's fit");
0139   m_desc.add_options()(
0140       "add_hit",
0141       po::value(&gbts_config.gbts_fit_segments_params.add_hit)
0142           ->default_value(gbts_config.gbts_fit_segments_params.add_hit),
0143       "base quality to add for each hit on seed");
0144   m_desc.add_options()(
0145       "inv_max_curvature",
0146       po::value(&gbts_config.gbts_fit_segments_params.inv_max_curvature)
0147           ->default_value(
0148               gbts_config.gbts_fit_segments_params.inv_max_curvature),
0149       "inv_max_curvature to stop following a seed [1/mm]");
0150 }
0151
0152 track_gbts_seeding::operator gbts_seedfinder_config() const {
0153   return gbts_config;
0154 }
0155
0156 void track_gbts_seeding::read(const boost::program_options::variables_map&) {
0157   // fill config
0158   if (!useGBTS) {
0159     return;
0160   }
0161   // config info from file
0162   std::vector<std::pair<uint64_t, int16_t>> geoidBinning;
0163   std::vector<std::pair<unsigned int, std::vector<unsigned int>>> binTables;
0164   traccc::device::gbts_layerInfo layerInfo;
0165
0166   auto geoidBinningPath =
0167       std::filesystem::path(config_dir + "/geoidBinning.txt");
0168   if (!std::filesystem::exists(geoidBinningPath)) {
0169     throw std::runtime_error("geoidBinning.txt file not found");
0170   }
0171   std::ifstream geoidBinningFile(geoidBinningPath);
0172
0173   unsigned int nGeoIDs = 0;
0174   geoidBinningFile >> nGeoIDs;
0175   geoidBinning.reserve(nGeoIDs);
0176
0177   std::pair<uint64_t, int16_t> geoidLayerPair;
0178   for (; nGeoIDs > 0u; --nGeoIDs) {
0179     geoidBinningFile >> geoidLayerPair.first;
0180     geoidBinningFile >> geoidLayerPair.second;
0181
0182     geoidBinning.push_back(geoidLayerPair);
0183   }
0184
0185   auto binTablesPath = std::filesystem::path(config_dir + "/binTables.txt");
0186   if (!std::filesystem::exists(binTablesPath)) {
0187     throw std::runtime_error("binTables.txt file not found");
0188   }
0189   std::ifstream binTablesFile(binTablesPath);
0190
0191   unsigned int nBinPairs = 0;
0192   binTablesFile >> nBinPairs;
0193   binTables.reserve(nBinPairs);
0194   unsigned int bin1 = 0;
0195   std::vector<unsigned int> bin2 = {0};
0196   for (; nBinPairs > 0; --nBinPairs) {
0197     binTablesFile >> bin1;
0198     binTablesFile >> bin2[0];
0199     binTables.emplace_back(bin1, bin2);
0200   }
0201
0202   auto layerInfoPath = std::filesystem::path(config_dir + "/layerInfo.txt");
0203   if (!std::filesystem::exists(layerInfoPath)) {
0204     throw std::runtime_error("layerInfo.txt file not found");
0205   }
0206   std::ifstream layerInfoFile(layerInfoPath);
0207
0208   unsigned int nLayers = 0;
0209   layerInfoFile >> nLayers;
0210   layerInfo.reserve(nLayers);
0211   unsigned int type = 0;
0212   std::array<unsigned int, 2> info = {0, 0};
0213   std::array<float, 2> geo = {0, 0};
0214   for (; nLayers > 0u; --nLayers) {
0215     layerInfoFile >> type;
0216     layerInfoFile >> info[0] >> info[1];
0217     layerInfoFile >> geo[0] >> geo[1];
0218     layerInfo.addLayer(static_cast<char>(type), info[0], info[1], geo[0],
0219                        geo[1]);
0220   }
0221   // Set linking scheme
0222   gbts_config.setLinkingScheme(binTables, layerInfo, geoidBinning, min_pt,
0223                                getDefaultLogger("GBTSconfig"));
0224 }
0225
0226 std::unique_ptr<configuration_printable> track_gbts_seeding::as_printable()
0227     const {
0228   auto cat = std::make_unique<configuration_category>(m_description);
0229
0230   cat->add_child(std::make_unique<configuration_kv_pair>(
0231       "using gbts algorithm ", std::to_string(useGBTS)));
0232   cat->add_child(std::make_unique<configuration_kv_pair>(
0233       "gbts config directory ", config_dir));
0234   // Graph building flags
0235   cat->add_child(std::make_unique<configuration_kv_pair>(
0236       "max edges factor ", std::format("{}", gbts_config.max_edges_factor)));
0237   cat->add_child(std::make_unique<configuration_kv_pair>(
0238       "min_delta_phi ",
0239       std::format("{:.5f} ",
0240                   gbts_config.gbts_dphi_window_params.min_delta_phi)));
0241   cat->add_child(std::make_unique<configuration_kv_pair>(
0242       "dphi_coeff ",
0243       std::format("{:.5f} ", gbts_config.gbts_dphi_window_params.dphi_coeff)));
0244   cat->add_child(std::make_unique<configuration_kv_pair>(
0245       "min_delta_phi_low_dr ",
0246       std::format("{:.5f} ",
0247                   gbts_config.gbts_dphi_window_params.min_delta_phi_low_dr)));
0248   cat->add_child(std::make_unique<configuration_kv_pair>(
0249       "dphi_coeff_low_dr ",
0250       std::format("{:.5f} ",
0251                   gbts_config.gbts_dphi_window_params.dphi_coeff_low_dr)));
0252   cat->add_child(std::make_unique<configuration_kv_pair>(
0253       "max_Kappa ",
0254       std::format("{:.5f} ",
0255                   gbts_config.gbts_make_graph_edges_params.max_Kappa)));
0256   cat->add_child(std::make_unique<configuration_kv_pair>(
0257       "min_z0 ",
0258       std::format("{:.5f} ", gbts_config.gbts_make_graph_edges_params.min_z0)));
0259   cat->add_child(std::make_unique<configuration_kv_pair>(
0260       "max_z0 ",
0261       std::format("{:.5f} ", gbts_config.gbts_make_graph_edges_params.max_z0)));
0262   cat->add_child(std::make_unique<configuration_kv_pair>(
0263       "maxOuterRadius ",
0264       std::format("{:.5f} ",
0265                   gbts_config.gbts_make_graph_edges_params.maxOuterRadius)));
0266
0267   cat->add_child(std::make_unique<configuration_kv_pair>(
0268       "edge matching dphi max ",
0269       std::format("{:.5f} ",
0270                   gbts_config.gbts_match_graph_edges_params.cut_dphi_max)));
0271   cat->add_child(std::make_unique<configuration_kv_pair>(
0272       "edge matching dcurv max ",
0273       std::format("{:.5f} ",
0274                   gbts_config.gbts_match_graph_edges_params.cut_dcurv_max)));
0275   cat->add_child(std::make_unique<configuration_kv_pair>(
0276       "edge matching tau ratio max ",
0277       std::format(
0278           "{:.5f} ",
0279           gbts_config.gbts_match_graph_edges_params.cut_tau_ratio_max)));
0280   cat->add_child(std::make_unique<configuration_kv_pair>(
0281       "max neighbours ", std::format("{} ", gbts_config.max_num_neighbours)));
0282   // Seed extraction flags
0283   cat->add_child(std::make_unique<configuration_kv_pair>(
0284       "sigmaMS ",
0285       std::format("{:.5f} ", gbts_config.gbts_fit_segments_params.sigmaMS)));
0286   cat->add_child(std::make_unique<configuration_kv_pair>(
0287       "% radLen per layer ",
0288       std::format("{:.5f} ", gbts_config.gbts_fit_segments_params.radLen)));
0289   cat->add_child(std::make_unique<configuration_kv_pair>(
0290       "sigma_x ",
0291       std::format("{:.5f} ", gbts_config.gbts_fit_segments_params.sigma_x)));
0292   cat->add_child(std::make_unique<configuration_kv_pair>(
0293       "sigma_y ",
0294       std::format("{:.5f} ", gbts_config.gbts_fit_segments_params.sigma_y)));
0295   cat->add_child(std::make_unique<configuration_kv_pair>(
0296       "maxDChi2_x ",
0297       std::format("{:.5f} ", gbts_config.gbts_fit_segments_params.maxDChi2_x)));
0298   cat->add_child(std::make_unique<configuration_kv_pair>(
0299       "maxDChi2_y ",
0300       std::format("{:.5f} ", gbts_config.gbts_fit_segments_params.maxDChi2_y)));
0301   cat->add_child(std::make_unique<configuration_kv_pair>(
0302       "quality per hit ",
0303       std::format("{:.5f} ", gbts_config.gbts_fit_segments_params.add_hit)));
0304   cat->add_child(std::make_unique<configuration_kv_pair>(
0305       "inv_max_curvature ",
0306       std::format("{:.5f} ",
0307                   gbts_config.gbts_fit_segments_params.inv_max_curvature)));
0308
0309   return cat;
0310 }
0311
0312 }  // namespace traccc::opts