cpu/apps/seeding_example.cpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2022-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/definitions/common.hpp"
0010 #include "traccc/definitions/primitives.hpp"
0011 #include "traccc/examples/make_magnetic_field.hpp"
0012 #include "traccc/examples/print_fitted_tracks_statistics.hpp"
0013 #include "traccc/geometry/detector.hpp"
0014 #include "traccc/geometry/host_detector.hpp"
0015 #include "traccc/utils/memory_resource.hpp"
0016 #include "traccc/utils/propagation.hpp"
0017
0018 // io
0019 #include "traccc/io/read_detector.hpp"
0020 #include "traccc/io/read_detector_description.hpp"
0021 #include "traccc/io/read_measurements.hpp"
0022 #include "traccc/io/read_spacepoints.hpp"
0023 #include "traccc/io/utils.hpp"
0024
0025 // algorithms
0026 #include "traccc/ambiguity_resolution/greedy_ambiguity_resolution_algorithm.hpp"
0027 #include "traccc/finding/combinatorial_kalman_filter_algorithm.hpp"
0028 #include "traccc/fitting/kalman_fitting_algorithm.hpp"
0029 #include "traccc/seeding/seeding_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/resolution/fitting_performance_writer.hpp"
0036
0037 // options
0038 #include "traccc/options/detector.hpp"
0039 #include "traccc/options/input_data.hpp"
0040 #include "traccc/options/magnetic_field.hpp"
0041 #include "traccc/options/performance.hpp"
0042 #include "traccc/options/program_options.hpp"
0043 #include "traccc/options/seed_matching.hpp"
0044 #include "traccc/options/track_finding.hpp"
0045 #include "traccc/options/track_fitting.hpp"
0046 #include "traccc/options/track_matching.hpp"
0047 #include "traccc/options/track_propagation.hpp"
0048 #include "traccc/options/track_resolution.hpp"
0049 #include "traccc/options/track_seeding.hpp"
0050 #include "traccc/options/truth_finding.hpp"
0051
0052 // VecMem include(s).
0053 #include <vecmem/memory/host_memory_resource.hpp>
0054 #include <vecmem/utils/copy.hpp>
0055
0056 // System include(s).
0057 #include <cassert>
0058 #include <cstdlib>
0059 #include <iostream>
0060
0061 using namespace traccc;
0062
0063 int seq_run(const traccc::opts::track_seeding& seeding_opts,
0064             const traccc::opts::track_finding& finding_opts,
0065             const traccc::opts::track_propagation& propagation_opts,
0066             const traccc::opts::track_resolution& resolution_opts,
0067             const traccc::opts::track_fitting& fitting_opts,
0068             const traccc::opts::input_data& input_opts,
0069             const traccc::opts::detector& detector_opts,
0070             const traccc::opts::magnetic_field& bfield_opts,
0071             const traccc::opts::performance& performance_opts,
0072             const traccc::opts::truth_finding& truth_finding_opts,
0073             const traccc::opts::seed_matching& seed_matching_opts,
0074             const traccc::opts::track_matching& track_matching_opts,
0075             std::unique_ptr<const traccc::Logger> ilogger) {
0076   TRACCC_LOCAL_LOGGER(std::move(ilogger));
0077
0078   // Memory resource used by the EDM.
0079   vecmem::host_memory_resource host_mr;
0080
0081   // Copy obejct
0082   vecmem::copy copy;
0083
0084   // Performance writer
0085   traccc::seeding_performance_writer sd_performance_writer(
0086       traccc::seeding_performance_writer::config{
0087           .truth_config = truth_finding_opts,
0088           .seed_truth_config = seed_matching_opts},
0089       logger().clone("SeedingPerformanceWriter"));
0090   traccc::finding_performance_writer find_performance_writer(
0091       traccc::finding_performance_writer::config{
0092           .truth_config = truth_finding_opts,
0093           .track_truth_config = track_matching_opts},
0094       logger().clone("FindingPerformanceWriter"));
0095   traccc::finding_performance_writer::config ar_writer_cfg;
0096   ar_writer_cfg.file_path = "performance_track_ambiguity_resolution.root";
0097   ar_writer_cfg.algorithm_name = "ambiguity_resolution";
0098   traccc::finding_performance_writer ar_performance_writer(
0099       ar_writer_cfg, logger().clone("AmbiResFindingPerformanceWriter"));
0100   traccc::fitting_performance_writer fit_performance_writer(
0101       traccc::fitting_performance_writer::config{},
0102       logger().clone("FittingPerformanceWriter"));
0103
0104   // Output stats
0105   uint64_t n_spacepoints = 0;
0106   uint64_t n_measurements = 0;
0107   uint64_t n_seeds = 0;
0108   uint64_t n_found_tracks = 0;
0109   uint64_t n_ambiguity_free_tracks = 0;
0110   uint64_t n_fitted_tracks = 0;
0111
0112   /*****************************
0113    * Build a geometry
0114    *****************************/
0115
0116   // B field value
0117   const auto field = traccc::details::make_magnetic_field(bfield_opts);
0118   const traccc::vector3 field_vec(seeding_opts);
0119
0120   // Construct a Detray detector object, if supported by the configuration.
0121   traccc::host_detector detector;
0122   traccc::io::read_detector(detector, host_mr, detector_opts.detector_file,
0123                             detector_opts.material_file,
0124                             detector_opts.grid_file);
0125
0126   // Seeding algorithm
0127   const traccc::seedfinder_config seedfinder_config(seeding_opts);
0128   const traccc::seedfilter_config seedfilter_config(seeding_opts);
0129   const traccc::spacepoint_grid_config spacepoint_grid_config(seeding_opts);
0130   traccc::host::seeding_algorithm sa(seedfinder_config, spacepoint_grid_config,
0131                                      seedfilter_config, host_mr,
0132                                      logger().clone("SeedingAlg"));
0133   traccc::track_params_estimation_config track_params_estimation_config;
0134   traccc::host::track_params_estimation tp(track_params_estimation_config,
0135                                            host_mr,
0136                                            logger().clone("TrackParEstAlg"));
0137
0138   // Propagation configuration
0139   detray::propagation::config propagation_config(propagation_opts);
0140
0141   // Finding algorithm configuration
0142   traccc::finding_config cfg(finding_opts);
0143   cfg.propagation = propagation_config;
0144
0145   traccc::host::combinatorial_kalman_filter_algorithm host_finding(
0146       cfg, host_mr, logger().clone("FindingAlg"));
0147
0148   traccc::host::greedy_ambiguity_resolution_algorithm::config_type
0149       host_ambiguity_config(resolution_opts);
0150   traccc::host::greedy_ambiguity_resolution_algorithm host_ambiguity_resolution(
0151       host_ambiguity_config, host_mr, logger().clone("AmbiguityResolution"));
0152
0153   // Fitting algorithm object
0154   traccc::fitting_config fit_cfg(fitting_opts);
0155   fit_cfg.propagation = propagation_config;
0156
0157   traccc::host::kalman_fitting_algorithm host_fitting(
0158       fit_cfg, host_mr, copy, logger().clone("FittingAlg"));
0159
0160   // Loop over events
0161   for (std::size_t event = input_opts.skip;
0162        event < input_opts.events + input_opts.skip; ++event) {
0163     TRACCC_INFO("EVENT: " << event);
0164
0165     // Read the hits from the relevant event file
0166     traccc::edm::measurement_collection::host measurements_per_event{host_mr};
0167     traccc::edm::spacepoint_collection::host spacepoints_per_event{host_mr};
0168     traccc::io::read_spacepoints(
0169         spacepoints_per_event, measurements_per_event, event,
0170         input_opts.directory,
0171         (input_opts.use_acts_geom_source ? &detector : nullptr), nullptr,
0172         nullptr, input_opts.format);
0173     n_measurements += measurements_per_event.size();
0174     n_spacepoints += spacepoints_per_event.size();
0175
0176     /*----------------
0177          Seeding
0178       ---------------*/
0179
0180     auto seeds = sa(vecmem::get_data(spacepoints_per_event));
0181
0182     /*----------------------------
0183        Track Parameter Estimation
0184       ----------------------------*/
0185
0186     auto params = tp(vecmem::get_data(measurements_per_event),
0187                      vecmem::get_data(spacepoints_per_event),
0188                      vecmem::get_data(seeds), field_vec);
0189
0190     /*------------------------
0191        Track Finding with CKF
0192       ------------------------*/
0193
0194     auto track_candidates =
0195         host_finding(detector, field, vecmem::get_data(measurements_per_event),
0196                      vecmem::get_data(params));
0197     n_found_tracks += track_candidates.tracks.size();
0198
0199     /*-----------------------------------------
0200        Ambiguity Resolution with Greedy Solver
0201       -----------------------------------------*/
0202
0203     // TODO: Fix me
0204     /*auto track_candidates_ar = host_ambiguity_resolution(
0205         traccc::edm::track_container<default_algebra>::const_data(
0206             track_candidates));
0207     n_ambiguity_free_tracks += track_candidates_ar.tracks.size();*/
0208
0209     /*------------------------
0210        Track Fitting with KF
0211       ------------------------*/
0212
0213     /*auto track_states = host_fitting(
0214         detector, field,
0215         traccc::edm::track_container<default_algebra>::const_data(
0216             track_candidates));
0217     n_fitted_tracks += track_states.tracks.size();*/
0218
0219     /*------------
0220        Statistics
0221       ------------*/
0222
0223     details::print_fitted_tracks_statistics(track_candidates, logger());
0224     n_spacepoints += spacepoints_per_event.size();
0225     n_seeds += seeds.size();
0226
0227     /*------------
0228       Writer
0229       ------------*/
0230
0231     if (performance_opts.run) {
0232       traccc::event_data evt_data(input_opts.directory, event, host_mr,
0233                                   input_opts.use_acts_geom_source, &detector,
0234                                   input_opts.format, false);
0235
0236       sd_performance_writer.write(
0237           vecmem::get_data(seeds), vecmem::get_data(spacepoints_per_event),
0238           vecmem::get_data(measurements_per_event), evt_data);
0239
0240       find_performance_writer.write(
0241           traccc::edm::track_container<traccc::default_algebra>::const_data(
0242               track_candidates),
0243           evt_data);
0244
0245       /*ar_performance_writer.write(
0246           traccc::edm::track_container<
0247               traccc::default_algebra>::const_data(track_candidates_ar),
0248           evt_data);*/
0249
0250       for (unsigned int i = 0; i < track_candidates.tracks.size(); i++) {
0251         host_detector_visitor<detector_type_list>(
0252             detector, [&]<typename detector_traits_t>(
0253                           const typename detector_traits_t::host& det) {
0254               fit_performance_writer.write(
0255                   track_candidates.tracks.at(i), track_candidates.states,
0256                   measurements_per_event, det, evt_data);
0257             });
0258       }
0259     }
0260   }
0261
0262   if (performance_opts.run) {
0263     sd_performance_writer.finalize();
0264     find_performance_writer.finalize();
0265     ar_performance_writer.finalize();
0266     fit_performance_writer.finalize();
0267   }
0268
0269   TRACCC_INFO("==> Statistics ... ");
0270   TRACCC_INFO("- read    " << n_spacepoints << " spacepoints");
0271   TRACCC_INFO("- read    " << n_measurements << " measurements");
0272   TRACCC_INFO("- created (cpu)  " << n_seeds << " seeds");
0273   TRACCC_INFO("- created (cpu)  " << n_found_tracks << " found tracks");
0274   TRACCC_INFO("- created (cpu)  " << n_ambiguity_free_tracks
0275                                   << " ambiguity free tracks");
0276   TRACCC_INFO("- created (cpu)  " << n_fitted_tracks << " fitted tracks");
0277
0278   return EXIT_SUCCESS;
0279 }
0280
0281 // The main routine
0282 //
0283 int main(int argc, char* argv[]) {
0284   std::unique_ptr<const traccc::Logger> logger = traccc::getDefaultLogger(
0285       "TracccExampleSeeding", traccc::Logging::Level::INFO);
0286
0287   // Program options.
0288   traccc::opts::detector detector_opts;
0289   traccc::opts::magnetic_field bfield_opts;
0290   traccc::opts::input_data input_opts;
0291   traccc::opts::track_seeding seeding_opts;
0292   traccc::opts::track_finding finding_opts;
0293   traccc::opts::track_propagation propagation_opts;
0294   traccc::opts::track_resolution resolution_opts;
0295   traccc::opts::track_fitting fitting_opts;
0296   traccc::opts::performance performance_opts;
0297   traccc::opts::truth_finding truth_finding_opts;
0298   traccc::opts::seed_matching seed_matching_opts;
0299   traccc::opts::track_matching track_matching_opts;
0300   traccc::opts::program_options program_opts{
0301       "Full Tracking Chain on the Host (without clusterization)",
0302       {detector_opts, bfield_opts, input_opts, seeding_opts, finding_opts,
0303        propagation_opts, resolution_opts, fitting_opts, performance_opts,
0304        truth_finding_opts, seed_matching_opts, track_matching_opts},
0305       argc,
0306       argv,
0307       logger->cloneWithSuffix("Options")};
0308
0309   // Run the application.
0310   return seq_run(seeding_opts, finding_opts, propagation_opts, resolution_opts,
0311                  fitting_opts, input_opts, detector_opts, bfield_opts,
0312                  performance_opts, truth_finding_opts, seed_matching_opts,
0313                  track_matching_opts, logger->clone());
0314 }