cpu/apps/seq_example.cpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2021-2025 CERN for the benefit of the ACTS project
0004  *
0005  * Mozilla Public License Version 2.0
0006  */
0007
0008 // core
0009 #include "traccc/geometry/detector.hpp"
0010 #include "traccc/geometry/host_detector.hpp"
0011 #include "traccc/seeding/detail/track_params_estimation_config.hpp"
0012 #include "traccc/utils/memory_resource.hpp"
0013 #include "traccc/utils/propagation.hpp"
0014
0015 // io
0016 #include "traccc/io/read_cells.hpp"
0017 #include "traccc/io/read_detector.hpp"
0018 #include "traccc/io/read_detector_description.hpp"
0019 #include "traccc/io/utils.hpp"
0020 #include "traccc/io/write.hpp"
0021
0022 // algorithms
0023 #include "traccc/ambiguity_resolution/greedy_ambiguity_resolution_algorithm.hpp"
0024 #include "traccc/clusterization/clusterization_algorithm.hpp"
0025 #include "traccc/finding/combinatorial_kalman_filter_algorithm.hpp"
0026 #include "traccc/fitting/kalman_fitting_algorithm.hpp"
0027 #include "traccc/fitting/triplet_fitting_algorithm.hpp"
0028 #include "traccc/seeding/seeding_algorithm.hpp"
0029 #include "traccc/seeding/silicon_pixel_spacepoint_formation_algorithm.hpp"
0030 #include "traccc/seeding/track_params_estimation.hpp"
0031
0032 // performance
0033 #include "traccc/efficiency/finding_performance_writer.hpp"
0034 #include "traccc/efficiency/seeding_performance_writer.hpp"
0035 #include "traccc/performance/timer.hpp"
0036 #include "traccc/resolution/fitting_performance_writer.hpp"
0037
0038 // options
0039 #include "traccc/options/clusterization.hpp"
0040 #include "traccc/options/detector.hpp"
0041 #include "traccc/options/input_data.hpp"
0042 #include "traccc/options/magnetic_field.hpp"
0043 #include "traccc/options/output_data.hpp"
0044 #include "traccc/options/performance.hpp"
0045 #include "traccc/options/program_options.hpp"
0046 #include "traccc/options/seed_matching.hpp"
0047 #include "traccc/options/track_finding.hpp"
0048 #include "traccc/options/track_fitting.hpp"
0049 #include "traccc/options/track_matching.hpp"
0050 #include "traccc/options/track_propagation.hpp"
0051 #include "traccc/options/track_resolution.hpp"
0052 #include "traccc/options/track_seeding.hpp"
0053 #include "traccc/options/truth_finding.hpp"
0054
0055 // examples
0056 #include "traccc/examples/make_magnetic_field.hpp"
0057
0058 // VecMem include(s).
0059 #include <vecmem/memory/host_memory_resource.hpp>
0060 #include <vecmem/utils/copy.hpp>
0061
0062 // System include(s).
0063 #include <cstdint>
0064 #include <cstdlib>
0065 #include <exception>
0066 #include <iostream>
0067 #include <map>
0068 #include <memory>
0069
0070 int seq_run(const traccc::opts::input_data& input_opts,
0071             const traccc::opts::output_data& output_opts,
0072             const traccc::opts::detector& detector_opts,
0073             const traccc::opts::magnetic_field& bfield_opts,
0074             const traccc::opts::clusterization& /*clusterization_opts*/,
0075             const traccc::opts::track_seeding& seeding_opts,
0076             const traccc::opts::track_finding& finding_opts,
0077             const traccc::opts::track_propagation& propagation_opts,
0078             const traccc::opts::track_resolution& resolution_opts,
0079             const traccc::opts::track_fitting& fitting_opts,
0080             const traccc::opts::performance& performance_opts,
0081             const traccc::opts::truth_finding& truth_finding_opts,
0082             const traccc::opts::seed_matching& seed_matching_opts,
0083             const traccc::opts::track_matching& track_matching_opts,
0084             std::unique_ptr<const traccc::Logger> ilogger) {
0085   TRACCC_LOCAL_LOGGER(std::move(ilogger));
0086
0087   // Memory resource used by the application.
0088   vecmem::host_memory_resource host_mr;
0089
0090   // Copy obejct
0091   vecmem::copy copy;
0092
0093   // Construct the detector description object.
0094   traccc::detector_design_description::host det_descr{host_mr};
0095   traccc::detector_conditions_description::host det_cond{host_mr};
0096   traccc::io::read_detector_description(
0097       det_descr, det_cond, detector_opts.detector_file,
0098       detector_opts.digitization_file, detector_opts.conditions_file,
0099       traccc::data_format::json);
0100   traccc::detector_design_description::data det_descr_data{
0101       vecmem::get_data(det_descr)};
0102   traccc::detector_conditions_description::data det_cond_data{
0103       vecmem::get_data(det_cond)};
0104
0105   // Construct a Detray detector object, if supported by the configuration.
0106   traccc::host_detector polymorphic_detector;
0107   traccc::io::read_detector(
0108       polymorphic_detector, host_mr, detector_opts.detector_file,
0109       detector_opts.material_file, detector_opts.grid_file);
0110
0111   // Output stats
0112   uint64_t n_cells = 0;
0113   uint64_t n_measurements = 0;
0114   uint64_t n_spacepoints = 0;
0115   uint64_t n_seeds = 0;
0116   uint64_t n_found_tracks = 0;
0117   uint64_t n_ambiguity_free_tracks = 0;
0118   uint64_t n_fitted_tracks = 0;
0119
0120   // Type definitions
0121   using spacepoint_formation_algorithm =
0122       traccc::host::silicon_pixel_spacepoint_formation_algorithm;
0123   using finding_algorithm = traccc::host::combinatorial_kalman_filter_algorithm;
0124   using fitting_algorithm = traccc::host::kalman_fitting_algorithm;
0125
0126   // Constant B field for the track finding and fitting
0127   const traccc::vector3 field_vec(seeding_opts);
0128   const auto field = traccc::details::make_magnetic_field(bfield_opts);
0129
0130   // Algorithm configuration(s).
0131   detray::propagation::config propagation_config(propagation_opts);
0132
0133   const traccc::seedfinder_config seedfinder_config(seeding_opts);
0134   const traccc::seedfilter_config seedfilter_config(seeding_opts);
0135   const traccc::spacepoint_grid_config spacepoint_grid_config(seeding_opts);
0136
0137   finding_algorithm::config_type finding_cfg(finding_opts);
0138   finding_cfg.propagation = propagation_config;
0139
0140   traccc::host::greedy_ambiguity_resolution_algorithm::config_type
0141       resolution_config(resolution_opts);
0142
0143   fitting_algorithm::config_type fitting_cfg(fitting_opts);
0144   fitting_cfg.propagation = propagation_config;
0145
0146   // Algorithms
0147   traccc::host::sparse_ccl_algorithm cc(host_mr,
0148                                         logger().clone("SparseCclAlg"));
0149   traccc::host::measurement_creation_algorithm mc(
0150       host_mr, logger().clone("MeasCreationAlg"));
0151   spacepoint_formation_algorithm sf(host_mr, logger().clone("SpFormationAlg"));
0152   traccc::host::seeding_algorithm sa(seedfinder_config, spacepoint_grid_config,
0153                                      seedfilter_config, host_mr,
0154                                      logger().clone("SeedingAlg"));
0155   traccc::track_params_estimation_config track_params_estimation_config;
0156   traccc::host::track_params_estimation tp(track_params_estimation_config,
0157                                            host_mr,
0158                                            logger().clone("TrackParEstAlg"));
0159
0160   finding_algorithm finding_alg(finding_cfg, host_mr,
0161                                 logger().clone("FindingAlg"));
0162   traccc::host::greedy_ambiguity_resolution_algorithm resolution_alg(
0163       resolution_config, host_mr, logger().clone("AmbiguityResolutionAlg"));
0164   fitting_algorithm fitting_alg(fitting_cfg, host_mr, copy,
0165                                 logger().clone("FittingAlg"));
0166
0167   // performance writer
0168   traccc::seeding_performance_writer sd_performance_writer(
0169       traccc::seeding_performance_writer::config{
0170           .truth_config = truth_finding_opts,
0171           .seed_truth_config = seed_matching_opts},
0172       logger().clone("SeedingPerformanceWriter"));
0173   traccc::finding_performance_writer find_performance_writer(
0174       traccc::finding_performance_writer::config{
0175           .truth_config = truth_finding_opts,
0176           .track_truth_config = track_matching_opts},
0177       logger().clone("FindingPerformanceWriter"));
0178   traccc::finding_performance_writer::config ar_writer_cfg;
0179   ar_writer_cfg.file_path = "performance_track_ambiguity_resolution.root";
0180   ar_writer_cfg.algorithm_name = "ambiguity_resolution";
0181   traccc::finding_performance_writer ar_performance_writer(
0182       ar_writer_cfg, logger().clone("AmbiResFindingPerformanceWriter"));
0183   traccc::fitting_performance_writer fit_performance_writer(
0184       traccc::fitting_performance_writer::config{},
0185       logger().clone("FittingPerformanceWriter"));
0186
0187   // Timers
0188   traccc::performance::timing_info elapsedTimes;
0189
0190   // Loop over events
0191   for (std::size_t event = input_opts.skip;
0192        event < input_opts.events + input_opts.skip; ++event) {
0193     traccc::edm::silicon_cell_collection::host cells_per_event{host_mr};
0194     traccc::host::sparse_ccl_algorithm::output_type clusters_per_event{host_mr};
0195     traccc::host::measurement_creation_algorithm::output_type
0196         measurements_per_event{host_mr};
0197     spacepoint_formation_algorithm::output_type spacepoints_per_event{host_mr};
0198     traccc::host::seeding_algorithm::output_type seeds{host_mr};
0199     traccc::host::track_params_estimation::output_type params{&host_mr};
0200     finding_algorithm::output_type track_candidates{host_mr};
0201     traccc::host::greedy_ambiguity_resolution_algorithm::output_type
0202         resolved_track_candidates{host_mr};
0203     fitting_algorithm::output_type track_states{host_mr};
0204
0205     {  // Start measuring wall time.
0206       traccc::performance::timer timer_wall{"Wall time", elapsedTimes};
0207
0208       {
0209         traccc::performance::timer timer{"Read cells", elapsedTimes};
0210         // Read the cells from the relevant event file
0211         static constexpr bool DEDUPLICATE = true;
0212         traccc::io::read_cells(cells_per_event, event, input_opts.directory,
0213                                logger().clone(), &det_cond, input_opts.format,
0214                                DEDUPLICATE, input_opts.use_acts_geom_source);
0215       }
0216
0217       /*-------------------
0218           Clusterization
0219         -------------------*/
0220
0221       {
0222         traccc::performance::timer timer{"Clusterization", elapsedTimes};
0223
0224         clusters_per_event =
0225             cc(vecmem::get_data(cells_per_event), vecmem::get_data(det_cond));
0226         measurements_per_event = mc(vecmem::get_data(cells_per_event),
0227                                     vecmem::get_data(clusters_per_event),
0228                                     det_descr_data, det_cond_data);
0229       }
0230
0231       // Perform seeding, track finding and fitting only when using a
0232       // Detray geometry.
0233       /*------------------------
0234           Spacepoint formation
0235         ------------------------*/
0236
0237       {
0238         traccc::performance::timer timer{"Spacepoint formation", elapsedTimes};
0239         spacepoints_per_event =
0240             sf(polymorphic_detector, vecmem::get_data(measurements_per_event));
0241       }
0242       if (output_opts.directory != "") {
0243         traccc::io::write(event, output_opts.directory, output_opts.format,
0244                           vecmem::get_data(spacepoints_per_event),
0245                           vecmem::get_data(measurements_per_event));
0246       }
0247
0248       /*-----------------------
0249         Seeding algorithm
0250         -----------------------*/
0251       {
0252         traccc::performance::timer timer{"Seeding", elapsedTimes};
0253         seeds = sa(vecmem::get_data(spacepoints_per_event));
0254       }
0255       if (output_opts.directory != "") {
0256         traccc::io::write(event, output_opts.directory, output_opts.format,
0257                           vecmem::get_data(seeds),
0258                           vecmem::get_data(spacepoints_per_event));
0259       }
0260
0261       /*----------------------------
0262         Track params estimation
0263         ----------------------------*/
0264
0265       {
0266         traccc::performance::timer timer{"Track params estimation",
0267                                          elapsedTimes};
0268         params = tp(vecmem::get_data(measurements_per_event),
0269                     vecmem::get_data(spacepoints_per_event),
0270                     vecmem::get_data(seeds), field_vec);
0271       }
0272
0273       {
0274         traccc::performance::timer timer{"Track finding", elapsedTimes};
0275         track_candidates = finding_alg(polymorphic_detector, field,
0276                                        vecmem::get_data(measurements_per_event),
0277                                        vecmem::get_data(params));
0278       }
0279       if (output_opts.directory != "") {
0280         traccc::io::write(
0281             event, output_opts.directory, output_opts.format,
0282             traccc::edm::track_container<traccc::default_algebra>::const_data(
0283                 track_candidates),
0284             polymorphic_detector);
0285       }
0286
0287       {
0288         // Perform ambiguity resolution only if asked for.
0289         traccc::performance::timer timer{"Track ambiguity resolution",
0290                                          elapsedTimes};
0291         resolved_track_candidates = resolution_alg(
0292             traccc::edm::track_container<traccc::default_algebra>::const_data(
0293                 track_candidates));
0294       }
0295
0296       {
0297         traccc::performance::timer timer{"Track fitting", elapsedTimes};
0298         track_states = fitting_alg(
0299             polymorphic_detector, field,
0300             traccc::edm::track_container<traccc::default_algebra>::const_data(
0301                 resolved_track_candidates));
0302       }
0303
0304       /*----------------------------
0305         Statistics
0306         ----------------------------*/
0307
0308       n_cells += cells_per_event.size();
0309       n_measurements += measurements_per_event.size();
0310       n_spacepoints += spacepoints_per_event.size();
0311       n_seeds += seeds.size();
0312       n_found_tracks += track_candidates.tracks.size();
0313       n_ambiguity_free_tracks += resolved_track_candidates.tracks.size();
0314       n_fitted_tracks += track_states.tracks.size();
0315
0316     }  // Stop measuring Wall time.
0317
0318     /*------------
0319          Writer
0320       ------------*/
0321
0322     if (performance_opts.run) {
0323       traccc::event_data evt_data(
0324           input_opts.directory, event, host_mr, input_opts.use_acts_geom_source,
0325           &polymorphic_detector, input_opts.format, true);
0326       evt_data.fill_cca_result(cells_per_event, clusters_per_event,
0327                                measurements_per_event, det_cond);
0328
0329       sd_performance_writer.write(
0330           vecmem::get_data(seeds), vecmem::get_data(spacepoints_per_event),
0331           vecmem::get_data(measurements_per_event), evt_data);
0332       find_performance_writer.write(
0333           traccc::edm::track_container<traccc::default_algebra>::const_data(
0334               track_candidates),
0335           evt_data);
0336       ar_performance_writer.write(
0337           traccc::edm::track_container<traccc::default_algebra>::const_data(
0338               resolved_track_candidates),
0339           evt_data);
0340
0341       for (unsigned int i = 0; i < track_states.tracks.size(); i++) {
0342         host_detector_visitor<traccc::detector_type_list>(
0343             polymorphic_detector,
0344             [&]<typename detector_traits_t>(
0345                 const typename detector_traits_t::host& det) {
0346               fit_performance_writer.write(
0347                   track_states.tracks.at(i), track_states.states,
0348                   measurements_per_event, det, evt_data);
0349             });
0350       }
0351     }
0352   }
0353
0354   if (performance_opts.run) {
0355     sd_performance_writer.finalize();
0356     find_performance_writer.finalize();
0357     ar_performance_writer.finalize();
0358     fit_performance_writer.finalize();
0359   }
0360
0361   std::cout << "==> Statistics ... " << std::endl;
0362   std::cout << "- read     " << n_cells << " cells" << std::endl;
0363   std::cout << "- created  " << n_measurements << " measurements. "
0364             << std::endl;
0365   std::cout << "- created  " << n_spacepoints << " space points. " << std::endl;
0366   std::cout << "- created  " << n_seeds << " seeds" << std::endl;
0367   std::cout << "- found    " << n_found_tracks << " tracks" << std::endl;
0368   std::cout << "- resolved " << n_ambiguity_free_tracks << " tracks"
0369             << std::endl;
0370   std::cout << "- fitted   " << n_fitted_tracks << " tracks" << std::endl;
0371   std::cout << "==> Elapsed times...\n" << elapsedTimes << std::endl;
0372
0373   return EXIT_SUCCESS;
0374 }
0375
0376 // The main routine
0377 //
0378 int main(int argc, char* argv[]) {
0379   std::unique_ptr<const traccc::Logger> logger = traccc::getDefaultLogger(
0380       "TracccExampleSeqCpu", traccc::Logging::Level::INFO);
0381
0382   // Program options.
0383   traccc::opts::detector detector_opts;
0384   traccc::opts::magnetic_field bfield_opts;
0385   traccc::opts::input_data input_opts;
0386   traccc::opts::output_data output_opts{traccc::data_format::obj, ""};
0387   traccc::opts::clusterization clusterization_opts;
0388   traccc::opts::track_seeding seeding_opts;
0389   traccc::opts::track_finding finding_opts;
0390   traccc::opts::track_propagation propagation_opts;
0391   traccc::opts::track_resolution resolution_opts;
0392   traccc::opts::track_fitting fitting_opts;
0393   traccc::opts::performance performance_opts;
0394   traccc::opts::truth_finding truth_finding_opts;
0395   traccc::opts::seed_matching seed_matching_opts;
0396   traccc::opts::track_matching track_matching_opts;
0397   traccc::opts::program_options program_opts{
0398       "Full Tracking Chain on the Host",
0399       {detector_opts, bfield_opts, input_opts, output_opts, clusterization_opts,
0400        seeding_opts, finding_opts, resolution_opts, fitting_opts,
0401        propagation_opts, performance_opts, truth_finding_opts,
0402        seed_matching_opts, track_matching_opts},
0403       argc,
0404       argv,
0405       logger->cloneWithSuffix("Options")};
0406
0407   // Run the application.
0408   return seq_run(input_opts, output_opts, detector_opts, bfield_opts,
0409                  clusterization_opts, seeding_opts, finding_opts,
0410                  propagation_opts, resolution_opts, fitting_opts,
0411                  performance_opts, truth_finding_opts, seed_matching_opts,
0412                  track_matching_opts, logger->clone());
0413 }