alpaka/apps/seeding_example_alpaka.cpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2023-2026 CERN for the benefit of the ACTS project
0004  *
0005  * Mozilla Public License Version 2.0
0006  */
0007
0008 // Project include(s).
0009 #include "traccc/alpaka/finding/combinatorial_kalman_filter_algorithm.hpp"
0010 #include "traccc/alpaka/fitting/kalman_fitting_algorithm.hpp"
0011 #include "traccc/alpaka/gbts_seeding/gbts_seeding_algorithm.hpp"
0012 #include "traccc/alpaka/seeding/seed_parameter_estimation_algorithm.hpp"
0013 #include "traccc/alpaka/seeding/triplet_seeding_algorithm.hpp"
0014 #include "traccc/alpaka/utils/queue.hpp"
0015 #include "traccc/alpaka/utils/vecmem_objects.hpp"
0016 #include "traccc/definitions/common.hpp"
0017 #include "traccc/device/container_d2h_copy_alg.hpp"
0018 #include "traccc/device/container_h2d_copy_alg.hpp"
0019 #include "traccc/efficiency/finding_performance_writer.hpp"
0020 #include "traccc/efficiency/nseed_performance_writer.hpp"
0021 #include "traccc/efficiency/seeding_performance_writer.hpp"
0022 #include "traccc/efficiency/track_filter.hpp"
0023 #include "traccc/examples/make_magnetic_field.hpp"
0024 #include "traccc/finding/combinatorial_kalman_filter_algorithm.hpp"
0025 #include "traccc/fitting/kalman_filter/kalman_fitter.hpp"
0026 #include "traccc/fitting/kalman_fitting_algorithm.hpp"
0027 #include "traccc/gbts_seeding/gbts_seeding_config.hpp"
0028 #include "traccc/geometry/detector.hpp"
0029 #include "traccc/io/read_detector.hpp"
0030 #include "traccc/io/read_detector_description.hpp"
0031 #include "traccc/io/read_measurements.hpp"
0032 #include "traccc/io/read_spacepoints.hpp"
0033 #include "traccc/io/utils.hpp"
0034 #include "traccc/options/accelerator.hpp"
0035 #include "traccc/options/detector.hpp"
0036 #include "traccc/options/input_data.hpp"
0037 #include "traccc/options/performance.hpp"
0038 #include "traccc/options/program_options.hpp"
0039 #include "traccc/options/seed_matching.hpp"
0040 #include "traccc/options/track_finding.hpp"
0041 #include "traccc/options/track_fitting.hpp"
0042 #include "traccc/options/track_gbts_seeding.hpp"
0043 #include "traccc/options/track_matching.hpp"
0044 #include "traccc/options/track_propagation.hpp"
0045 #include "traccc/options/track_seeding.hpp"
0046 #include "traccc/options/truth_finding.hpp"
0047 #include "traccc/performance/collection_comparator.hpp"
0048 #include "traccc/performance/soa_comparator.hpp"
0049 #include "traccc/performance/timer.hpp"
0050 #include "traccc/resolution/fitting_performance_writer.hpp"
0051 #include "traccc/seeding/detail/track_params_estimation_config.hpp"
0052 #include "traccc/seeding/seeding_algorithm.hpp"
0053 #include "traccc/seeding/track_params_estimation.hpp"
0054 #include "traccc/utils/propagation.hpp"
0055
0056 // System include(s).
0057 #include <cmath>
0058 #include <exception>
0059 #include <iomanip>
0060 #include <iostream>
0061
0062 using namespace traccc;
0063
0064 int seq_run(const traccc::opts::track_seeding& seeding_opts,
0065             const traccc::opts::track_gbts_seeding& seeding_gbts_opts,
0066             const traccc::opts::track_finding& finding_opts,
0067             const traccc::opts::track_propagation& propagation_opts,
0068             const traccc::opts::track_fitting& fitting_opts,
0069             const traccc::opts::input_data& input_opts,
0070             const traccc::opts::detector& detector_opts,
0071             const traccc::opts::magnetic_field& bfield_opts,
0072             const traccc::opts::performance& performance_opts,
0073             const traccc::opts::accelerator& accelerator_opts,
0074             const traccc::opts::truth_finding& truth_finding_opts,
0075             const traccc::opts::seed_matching& seed_matching_opts,
0076             const traccc::opts::track_matching& track_matching_opts,
0077             [[maybe_unused]] std::unique_ptr<const traccc::Logger> ilogger,
0078             bool usingGBTS) {
0079   TRACCC_LOCAL_LOGGER(std::move(ilogger));
0080
0081   // Memory resources used by the application.
0082   traccc::alpaka::queue queue;
0083   traccc::alpaka::vecmem_objects vo(queue);
0084
0085   vecmem::memory_resource& host_mr = vo.host_mr();
0086   vecmem::memory_resource& device_mr = vo.device_mr();
0087   vecmem::memory_resource& mng_mr = vo.shared_mr();
0088   traccc::memory_resource mr{device_mr, &host_mr};
0089
0090   // Performance writer
0091   traccc::seeding_performance_writer sd_performance_writer(
0092       traccc::seeding_performance_writer::config{
0093           .truth_config = truth_finding_opts,
0094           .seed_truth_config = seed_matching_opts},
0095       logger().clone("SeedingPerformanceWriter"));
0096   traccc::finding_performance_writer find_performance_writer(
0097       traccc::finding_performance_writer::config{
0098           .truth_config = truth_finding_opts,
0099           .track_truth_config = track_matching_opts},
0100       logger().clone("FindingPerformanceWriter"));
0101   traccc::fitting_performance_writer fit_performance_writer(
0102       traccc::fitting_performance_writer::config{},
0103       logger().clone("FittingPerformanceWriter"));
0104
0105   traccc::nseed_performance_writer nsd_performance_writer(
0106       "nseed_performance_",
0107       std::make_unique<traccc::simple_charged_eta_pt_cut>(
0108           2.7f, 1.f * traccc::unit<traccc::scalar>::GeV),
0109       std::make_unique<traccc::stepped_percentage>(0.6f));
0110
0111   if (performance_opts.run) {
0112     nsd_performance_writer.initialize();
0113   }
0114
0115   // Output stats
0116   uint64_t n_spacepoints = 0;
0117   uint64_t n_seeds = 0;
0118   uint64_t n_seeds_alpaka = 0;
0119   uint64_t n_found_tracks = 0;
0120   uint64_t n_found_tracks_alpaka = 0;
0121   uint64_t n_fitted_tracks = 0;
0122   uint64_t n_fitted_tracks_alpaka = 0;
0123
0124   /*****************************
0125    * Build a geometry
0126    *****************************/
0127
0128   // B field value and its type
0129   const auto field = traccc::details::make_magnetic_field(bfield_opts);
0130   const traccc::vector3 field_vec(seeding_opts);
0131
0132   // Detector view object
0133   traccc::host_detector host_det;
0134   traccc::io::read_detector(host_det, mng_mr, detector_opts.detector_file,
0135                             detector_opts.material_file,
0136                             detector_opts.grid_file);
0137
0138   // Copy objects
0139   vecmem::copy host_copy;
0140   vecmem::copy& copy = vo.copy();
0141   vecmem::copy& async_copy = vo.async_copy();
0142
0143   const traccc::detector_buffer detector_buffer =
0144       traccc::buffer_from_host_detector(host_det, mng_mr, copy);
0145
0146   // GBTS seeding configuration
0147   const traccc::gbts_seedfinder_config gbts_config(seeding_gbts_opts);
0148
0149   // Seeding algorithms
0150   const traccc::seedfinder_config seedfinder_config(seeding_opts);
0151   const traccc::seedfilter_config seedfilter_config(seeding_opts);
0152   const traccc::spacepoint_grid_config spacepoint_grid_config(seeding_opts);
0153   traccc::host::seeding_algorithm sa(seedfinder_config, spacepoint_grid_config,
0154                                      seedfilter_config, host_mr,
0155                                      logger().clone("HostSeedingAlg"));
0156   const traccc::track_params_estimation_config track_params_estimation_config;
0157   traccc::host::track_params_estimation tp(
0158       track_params_estimation_config, host_mr,
0159       logger().clone("HostTrackParEstAlg"));
0160
0161   // Alpaka Algorithms
0162   traccc::alpaka::triplet_seeding_algorithm sa_alpaka{
0163       seedfinder_config,
0164       spacepoint_grid_config,
0165       seedfilter_config,
0166       mr,
0167       async_copy,
0168       queue,
0169       logger().clone("AlpakaSeedingAlg")};
0170   traccc::alpaka::gbts_seeding_algorithm gbts_sa_alpaka(
0171       gbts_config, mr, copy, queue, logger().clone("AlpakaGbtsSeedingAlg"));
0172   traccc::alpaka::seed_parameter_estimation_algorithm tp_alpaka{
0173       track_params_estimation_config, mr, async_copy, queue,
0174       logger().clone("AlpakaTrackParEstAlg")};
0175
0176   // Propagation configuration
0177   detray::propagation::config propagation_config(propagation_opts);
0178
0179   // Finding algorithm configuration
0180   traccc::finding_config cfg(finding_opts);
0181   cfg.propagation = propagation_config;
0182
0183   // Finding algorithm object
0184   traccc::host::combinatorial_kalman_filter_algorithm host_finding(
0185       cfg, host_mr, logger().clone("HostFindingAlg"));
0186   traccc::alpaka::combinatorial_kalman_filter_algorithm device_finding(
0187       cfg, mr, copy, queue, logger().clone("AlpakaFindingAlg"));
0188
0189   // Fitting algorithm object
0190   traccc::fitting_config fit_cfg(fitting_opts);
0191   fit_cfg.propagation = propagation_config;
0192
0193   traccc::host::kalman_fitting_algorithm host_fitting(
0194       fit_cfg, host_mr, host_copy, logger().clone("HostFittingAlg"));
0195   traccc::alpaka::kalman_fitting_algorithm device_fitting(
0196       fit_cfg, mr, copy, queue, logger().clone("AlpakaFittingAlg"));
0197
0198   traccc::performance::timing_info elapsedTimes;
0199
0200   // Loop over events
0201   for (std::size_t event = input_opts.skip;
0202        event < input_opts.events + input_opts.skip; ++event) {
0203     // Instantiate host containers/collections
0204     traccc::edm::spacepoint_collection::host spacepoints_per_event{host_mr};
0205     traccc::edm::measurement_collection::host measurements_per_event{host_mr};
0206     traccc::host::seeding_algorithm::output_type seeds{host_mr};
0207     traccc::host::track_params_estimation::output_type params;
0208     traccc::edm::track_container<traccc::default_algebra>::host
0209         track_candidates{host_mr};
0210     traccc::edm::track_container<traccc::default_algebra>::host track_states{
0211         host_mr};
0212
0213     traccc::edm::seed_collection::buffer seeds_alpaka_buffer;
0214     traccc::bound_track_parameters_collection_types::buffer
0215         params_alpaka_buffer(0, *mr.host);
0216
0217     traccc::edm::track_container<traccc::default_algebra>::buffer
0218         track_candidates_alpaka_buffer;
0219
0220     traccc::edm::track_container<traccc::default_algebra>::buffer
0221         track_states_alpaka_buffer;
0222
0223     {  // Start measuring wall time
0224       traccc::performance::timer wall_t("Wall time", elapsedTimes);
0225
0226       /*-----------------
0227       hit file reading
0228       -----------------*/
0229       {
0230         traccc::performance::timer t("Hit reading  (cpu)", elapsedTimes);
0231         // Read the hits from the relevant event file
0232         traccc::io::read_spacepoints(
0233             spacepoints_per_event, measurements_per_event, event,
0234             input_opts.directory,
0235             (input_opts.use_acts_geom_source ? &host_det : nullptr), nullptr,
0236             nullptr, input_opts.format);
0237
0238       }  // stop measuring hit reading timer
0239
0240       /*----------------------------
0241           Seeding algorithm
0242       ----------------------------*/
0243
0244       // Alpaka
0245
0246       // Copy the spacepoint data to the device.
0247       traccc::edm::spacepoint_collection::buffer spacepoints_alpaka_buffer(
0248           static_cast<unsigned int>(spacepoints_per_event.size()), mr.main);
0249       async_copy.setup(spacepoints_alpaka_buffer)->wait();
0250       async_copy(vecmem::get_data(spacepoints_per_event),
0251                  spacepoints_alpaka_buffer)
0252           ->wait();
0253
0254       traccc::edm::measurement_collection::buffer measurements_alpaka_buffer(
0255           static_cast<unsigned int>(measurements_per_event.size()), mr.main);
0256       async_copy.setup(measurements_alpaka_buffer)->wait();
0257       async_copy(vecmem::get_data(measurements_per_event),
0258                  measurements_alpaka_buffer)
0259           ->wait();
0260
0261       {
0262         traccc::performance::timer t("Seeding (alpaka)", elapsedTimes);
0263         // Reconstruct the spacepoints into seeds.
0264         if (usingGBTS) {
0265           seeds_alpaka_buffer =
0266               gbts_sa_alpaka(vecmem::get_data(spacepoints_alpaka_buffer),
0267                              vecmem::get_data(measurements_alpaka_buffer));
0268         } else {
0269           seeds_alpaka_buffer =
0270               sa_alpaka(vecmem::get_data(spacepoints_alpaka_buffer));
0271         }
0272         queue.synchronize();
0273       }
0274
0275       // CPU
0276
0277       if (accelerator_opts.compare_with_cpu) {
0278         traccc::performance::timer t("Seeding  (cpu)", elapsedTimes);
0279         seeds = sa(vecmem::get_data(spacepoints_per_event));
0280       }  // stop measuring seeding cpu timer
0281
0282       /*----------------------------
0283       Track params estimation
0284       ----------------------------*/
0285
0286       // Alpaka
0287
0288       {
0289         traccc::performance::timer t("Track params (alpaka)", elapsedTimes);
0290         params_alpaka_buffer =
0291             tp_alpaka(field, measurements_alpaka_buffer,
0292                       spacepoints_alpaka_buffer, seeds_alpaka_buffer);
0293         queue.synchronize();
0294       }  // stop measuring track params alpaka timer
0295
0296       // CPU
0297       if (accelerator_opts.compare_with_cpu) {
0298         traccc::performance::timer t("Track params  (cpu)", elapsedTimes);
0299         params = tp(vecmem::get_data(measurements_per_event),
0300                     vecmem::get_data(spacepoints_per_event),
0301                     vecmem::get_data(seeds), field_vec);
0302       }  // stop measuring track params cpu timer
0303
0304       /*------------------------
0305          Track Finding with CKF
0306         ------------------------*/
0307
0308       {
0309         traccc::performance::timer t("Track finding with CKF (alpaka)",
0310                                      elapsedTimes);
0311         track_candidates_alpaka_buffer =
0312             device_finding(detector_buffer, field, measurements_alpaka_buffer,
0313                            params_alpaka_buffer);
0314       }
0315
0316       if (accelerator_opts.compare_with_cpu) {
0317         traccc::performance::timer t("Track finding with CKF (cpu)",
0318                                      elapsedTimes);
0319         track_candidates = host_finding(
0320             host_det, field, vecmem::get_data(measurements_per_event),
0321             vecmem::get_data(params));
0322       }
0323
0324       /*------------------------
0325          Track Fitting with KF
0326         ------------------------*/
0327
0328       {
0329         traccc::performance::timer t("Track fitting with KF (alpaka)",
0330                                      elapsedTimes);
0331
0332         track_states_alpaka_buffer = device_fitting(
0333             detector_buffer, field, track_candidates_alpaka_buffer);
0334       }
0335
0336       if (accelerator_opts.compare_with_cpu) {
0337         traccc::performance::timer t("Track fitting with KF (cpu)",
0338                                      elapsedTimes);
0339         track_states = host_fitting(
0340             host_det, field,
0341             traccc::edm::track_container<traccc::default_algebra>::const_data(
0342                 track_candidates));
0343       }
0344
0345     }  // Stop measuring wall time
0346
0347     /*----------------------------------
0348       compare seeds from cpu and alpaka
0349       ----------------------------------*/
0350
0351     // Copy the seeds to the host for comparisons
0352     traccc::edm::seed_collection::host seeds_alpaka{host_mr};
0353     traccc::bound_track_parameters_collection_types::host params_alpaka{
0354         &host_mr};
0355     async_copy(seeds_alpaka_buffer, seeds_alpaka)->wait();
0356     async_copy(params_alpaka_buffer, params_alpaka)->wait();
0357
0358     // Copy track candidates from device to host
0359     traccc::edm::track_collection<traccc::default_algebra>::host
0360         track_candidates_alpaka{host_mr};
0361     copy(track_candidates_alpaka_buffer.tracks, track_candidates_alpaka)
0362         ->wait();
0363
0364     // Copy track states from device to host
0365     traccc::edm::track_container<traccc::default_algebra>::host
0366         track_states_alpaka{host_mr};
0367     async_copy(track_states_alpaka_buffer.tracks, track_states_alpaka.tracks)
0368         ->wait();
0369     async_copy(track_states_alpaka_buffer.states, track_states_alpaka.states)
0370         ->wait();
0371
0372     if (accelerator_opts.compare_with_cpu) {
0373       // Show which event we are currently presenting the results for.
0374       std::cout << "===>>> Event " << event << " <<<===" << std::endl;
0375
0376       // Compare the seeds made on the host and on the device
0377       traccc::soa_comparator<traccc::edm::seed_collection> compare_seeds{
0378           "seeds",
0379           traccc::details::comparator_factory<
0380               traccc::edm::seed_collection::const_device::const_proxy_type>{
0381               vecmem::get_data(spacepoints_per_event),
0382               vecmem::get_data(spacepoints_per_event)}};
0383       compare_seeds(vecmem::get_data(seeds), vecmem::get_data(seeds_alpaka));
0384
0385       // Compare the track parameters made on the host and on the device.
0386       traccc::collection_comparator<traccc::bound_track_parameters<>>
0387           compare_track_parameters{"track parameters"};
0388       compare_track_parameters(vecmem::get_data(params),
0389                                vecmem::get_data(params_alpaka));
0390
0391       // Compare the track candidates made on the host and on the
0392       // device
0393       traccc::soa_comparator<
0394           traccc::edm::track_collection<traccc::default_algebra>>
0395           compare_track_candidates{
0396               "track candidates",
0397               traccc::details::comparator_factory<traccc::edm::track_collection<
0398                   traccc::default_algebra>::const_device::const_proxy_type>{
0399                   vecmem::get_data(measurements_per_event),
0400                   vecmem::get_data(measurements_per_event),
0401                   {},
0402                   {}}};
0403       compare_track_candidates(vecmem::get_data(track_candidates.tracks),
0404                                vecmem::get_data(track_candidates_alpaka));
0405     }
0406
0407     /*----------------
0408          Statistics
0409       ---------------*/
0410
0411     n_spacepoints += spacepoints_per_event.size();
0412     n_seeds_alpaka += seeds_alpaka.size();
0413     n_seeds += seeds.size();
0414     n_found_tracks_alpaka += track_candidates_alpaka.size();
0415     n_found_tracks += track_candidates.tracks.size();
0416     n_fitted_tracks_alpaka += track_states_alpaka.tracks.size();
0417     n_fitted_tracks += track_states.tracks.size();
0418
0419     /*------------
0420       Writer
0421       ------------*/
0422
0423     if (performance_opts.run) {
0424       traccc::event_data evt_data(input_opts.directory, event, host_mr,
0425                                   input_opts.use_acts_geom_source, &host_det,
0426                                   input_opts.format, false);
0427
0428       sd_performance_writer.write(
0429           vecmem::get_data(seeds), vecmem::get_data(spacepoints_per_event),
0430           vecmem::get_data(measurements_per_event), evt_data);
0431     }
0432   }
0433
0434   if (performance_opts.run) {
0435     sd_performance_writer.finalize();
0436     nsd_performance_writer.finalize();
0437     find_performance_writer.finalize();
0438     fit_performance_writer.finalize();
0439     std::cout << nsd_performance_writer.generate_report_str();
0440   }
0441
0442   std::cout << "==> Statistics ... " << std::endl;
0443   std::cout << "- read    " << n_spacepoints << " spacepoints" << std::endl;
0444   std::cout << "- created  (cpu)  " << n_seeds << " seeds" << std::endl;
0445   std::cout << "- created (alpaka)  " << n_seeds_alpaka << " seeds"
0446             << std::endl;
0447   std::cout << "- created  (cpu) " << n_found_tracks << " found tracks"
0448             << std::endl;
0449   std::cout << "- created (alpaka) " << n_found_tracks_alpaka << " found tracks"
0450             << std::endl;
0451   std::cout << "- created  (cpu) " << n_fitted_tracks << " fitted tracks"
0452             << std::endl;
0453   std::cout << "- created (alpaka) " << n_fitted_tracks_alpaka
0454             << " fitted tracks" << std::endl;
0455   std::cout << "==>Elapsed times...\n" << elapsedTimes << std::endl;
0456
0457   return 0;
0458 }
0459
0460 // The main routine
0461 //
0462 int main(int argc, char* argv[]) {
0463   std::unique_ptr<const traccc::Logger> logger = traccc::getDefaultLogger(
0464       "TracccExampleSeedingAlpaka", traccc::Logging::Level::INFO);
0465
0466   // Program options.
0467   traccc::opts::detector detector_opts;
0468   traccc::opts::magnetic_field bfield_opts;
0469   traccc::opts::input_data input_opts;
0470   traccc::opts::track_seeding seeding_opts;
0471   traccc::opts::track_gbts_seeding seeding_gbts_opts;
0472   traccc::opts::track_finding finding_opts;
0473   traccc::opts::track_propagation propagation_opts;
0474   traccc::opts::track_fitting fitting_opts;
0475   traccc::opts::performance performance_opts;
0476   traccc::opts::accelerator accelerator_opts;
0477   traccc::opts::truth_finding truth_finding_opts;
0478   traccc::opts::seed_matching seed_matching_opts;
0479   traccc::opts::track_matching track_matching_opts;
0480   traccc::opts::program_options program_opts{
0481       "Full Tracking Chain Using Alpaka (without clusterization)",
0482       {detector_opts, bfield_opts, input_opts, seeding_opts, seeding_gbts_opts,
0483        finding_opts, propagation_opts, fitting_opts, performance_opts,
0484        accelerator_opts, truth_finding_opts, seed_matching_opts,
0485        track_matching_opts},
0486       argc,
0487       argv,
0488       logger->cloneWithSuffix("Options")};
0489
0490   // Run the application.
0491   return seq_run(seeding_opts, seeding_gbts_opts, finding_opts,
0492                  propagation_opts, fitting_opts, input_opts, detector_opts,
0493                  bfield_opts, performance_opts, accelerator_opts,
0494                  truth_finding_opts, seed_matching_opts, track_matching_opts,
0495                  logger->clone(), seeding_gbts_opts.useGBTS);
0496 }