cpu/apps/truth_finding_example.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/definitions/common.hpp"
0010 #include "traccc/definitions/primitives.hpp"
0011 #include "traccc/efficiency/finding_performance_writer.hpp"
0012 #include "traccc/examples/make_magnetic_field.hpp"
0013 #include "traccc/examples/print_fitted_tracks_statistics.hpp"
0014 #include "traccc/finding/combinatorial_kalman_filter_algorithm.hpp"
0015 #include "traccc/fitting/kalman_fitting_algorithm.hpp"
0016 #include "traccc/geometry/detector.hpp"
0017 #include "traccc/geometry/host_detector.hpp"
0018 #include "traccc/io/read_detector.hpp"
0019 #include "traccc/io/read_detector_description.hpp"
0020 #include "traccc/io/read_measurements.hpp"
0021 #include "traccc/io/utils.hpp"
0022 #include "traccc/options/detector.hpp"
0023 #include "traccc/options/input_data.hpp"
0024 #include "traccc/options/magnetic_field.hpp"
0025 #include "traccc/options/performance.hpp"
0026 #include "traccc/options/program_options.hpp"
0027 #include "traccc/options/track_finding.hpp"
0028 #include "traccc/options/track_fitting.hpp"
0029 #include "traccc/options/track_matching.hpp"
0030 #include "traccc/options/track_propagation.hpp"
0031 #include "traccc/options/truth_finding.hpp"
0032 #include "traccc/resolution/fitting_performance_writer.hpp"
0033 #include "traccc/utils/propagation.hpp"
0034 #include "traccc/utils/seed_generator.hpp"
0035
0036 // VecMem include(s).
0037 #include <vecmem/memory/host_memory_resource.hpp>
0038 #include <vecmem/utils/copy.hpp>
0039
0040 // System include(s).
0041 #include <cassert>
0042 #include <cstdlib>
0043 #include <exception>
0044 #include <iomanip>
0045 #include <iostream>
0046
0047 using namespace traccc;
0048
0049 int seq_run(const traccc::opts::track_finding& finding_opts,
0050             const traccc::opts::track_propagation& propagation_opts,
0051             const traccc::opts::track_fitting& fitting_opts,
0052             const traccc::opts::input_data& input_opts,
0053             const traccc::opts::detector& detector_opts,
0054             const traccc::opts::magnetic_field& bfield_opts,
0055             const traccc::opts::performance& performance_opts,
0056             const traccc::opts::truth_finding& truth_finding_opts,
0057             const traccc::opts::track_matching& track_matching_opts,
0058             std::unique_ptr<const traccc::Logger> ilogger) {
0059   TRACCC_LOCAL_LOGGER(std::move(ilogger));
0060
0061   // Memory resources used by the application.
0062   vecmem::host_memory_resource host_mr;
0063   // Copy obejct
0064   vecmem::copy copy;
0065
0066   // Performance writer
0067   traccc::finding_performance_writer find_performance_writer(
0068       traccc::finding_performance_writer::config{
0069           .truth_config = truth_finding_opts,
0070           .track_truth_config = track_matching_opts},
0071       logger().clone("FindingPerformanceWriter"));
0072   traccc::fitting_performance_writer fit_performance_writer(
0073       traccc::fitting_performance_writer::config{},
0074       logger().clone("FittingPerformanceWriter"));
0075
0076   /*****************************
0077    * Build a geometry
0078    *****************************/
0079
0080   // B field value
0081   const auto field = traccc::details::make_magnetic_field(bfield_opts);
0082
0083   // Construct a Detray detector object, if supported by the configuration.
0084   traccc::host_detector polymorphic_detector;
0085   traccc::io::read_detector(
0086       polymorphic_detector, host_mr, detector_opts.detector_file,
0087       detector_opts.material_file, detector_opts.grid_file);
0088
0089   /*****************************
0090    * Do the reconstruction
0091    *****************************/
0092
0093   // Standard deviations for seed track parameters
0094   static constexpr std::array<double, traccc::e_bound_size> stddevs = {
0095       1e-4 * traccc::unit<double>::mm,
0096       1e-4 * traccc::unit<double>::mm,
0097       1e-3,
0098       1e-3,
0099       1e-4 / traccc::unit<double>::GeV,
0100       1e-4 * traccc::unit<double>::ns};
0101
0102   // Propagation configuration
0103   detray::propagation::config propagation_config(propagation_opts);
0104
0105   // Finding algorithm configuration
0106   typename traccc::finding_config cfg(finding_opts);
0107   cfg.propagation = propagation_config;
0108
0109   // Finding algorithm object
0110   traccc::host::combinatorial_kalman_filter_algorithm host_finding(
0111       cfg, host_mr, logger().clone("FindingAlg"));
0112
0113   // Fitting algorithm object
0114   traccc::fitting_config fit_cfg(fitting_opts);
0115   fit_cfg.propagation = propagation_config;
0116
0117   traccc::host::kalman_fitting_algorithm host_fitting(
0118       fit_cfg, host_mr, copy, logger().clone("FittingAlg"));
0119
0120   // Iterate over events
0121   for (std::size_t event = input_opts.skip;
0122        event < input_opts.events + input_opts.skip; ++event) {
0123     // Truth Track Candidates
0124     traccc::event_data evt_data(
0125         input_opts.directory, event, host_mr, input_opts.use_acts_geom_source,
0126         &polymorphic_detector, input_opts.format, false);
0127
0128     traccc::edm::measurement_collection::host truth_measurements{host_mr};
0129     traccc::edm::track_container<traccc::default_algebra>::host
0130         truth_track_candidates{host_mr};
0131
0132     // Seed generator
0133     host_detector_visitor<detector_type_list>(
0134         polymorphic_detector, [&]<typename detector_traits_t>(
0135                                   const typename detector_traits_t::host& det) {
0136           typename traccc::seed_generator<
0137               typename detector_traits_t::host>::config seed_cfg{};
0138           seed_cfg.initial_sigmas = stddevs;
0139           traccc::seed_generator<typename detector_traits_t::host> sg(det,
0140                                                                       seed_cfg);
0141           evt_data.generate_truth_candidates(truth_track_candidates,
0142                                              truth_measurements, sg, host_mr,
0143                                              truth_finding_opts.m_pT_min);
0144         });
0145     truth_track_candidates.measurements = vecmem::get_data(truth_measurements);
0146
0147     // Prepare truth seeds
0148     traccc::bound_track_parameters_collection_types::host seeds(&host_mr);
0149     const std::size_t n_tracks = truth_track_candidates.tracks.size();
0150     for (std::size_t i_trk = 0; i_trk < n_tracks; i_trk++) {
0151       seeds.push_back(truth_track_candidates.tracks.at(i_trk).params());
0152     }
0153
0154     std::cout << "Number of seeds: " << seeds.size() << std::endl;
0155
0156     // Read measurements
0157     traccc::edm::measurement_collection::host measurements_per_event{host_mr};
0158     traccc::io::read_measurements(
0159         measurements_per_event, event, input_opts.directory,
0160         (input_opts.use_acts_geom_source ? &polymorphic_detector : nullptr),
0161         nullptr, nullptr, input_opts.format);
0162
0163     // Run finding
0164     auto track_candidates = host_finding(
0165         polymorphic_detector, field, vecmem::get_data(measurements_per_event),
0166         vecmem::get_data(seeds));
0167
0168     std::cout << "Number of found tracks: " << track_candidates.tracks.size()
0169               << std::endl;
0170
0171     // Run fitting
0172     auto track_states = host_fitting(
0173         polymorphic_detector, field,
0174         traccc::edm::track_container<traccc::default_algebra>::const_data(
0175             track_candidates));
0176
0177     details::print_fitted_tracks_statistics(track_states, logger());
0178
0179     const std::size_t n_fitted_tracks = track_states.tracks.size();
0180
0181     if (performance_opts.run) {
0182       find_performance_writer.write(
0183           traccc::edm::track_container<traccc::default_algebra>::const_data(
0184               track_candidates),
0185           evt_data);
0186
0187       for (std::size_t i = 0; i < n_fitted_tracks; i++) {
0188         host_detector_visitor<detector_type_list>(
0189             polymorphic_detector,
0190             [&]<typename detector_traits_t>(
0191                 const typename detector_traits_t::host& det) {
0192               fit_performance_writer.write(
0193                   track_states.tracks.at(i), track_states.states,
0194                   measurements_per_event, det, evt_data);
0195             });
0196       }
0197     }
0198   }
0199
0200   if (performance_opts.run) {
0201     find_performance_writer.finalize();
0202     fit_performance_writer.finalize();
0203   }
0204
0205   return EXIT_SUCCESS;
0206 }
0207
0208 // The main routine
0209 //
0210 int main(int argc, char* argv[]) {
0211   std::unique_ptr<const traccc::Logger> logger = traccc::getDefaultLogger(
0212       "TracccExampleTruthFinding", traccc::Logging::Level::INFO);
0213
0214   // Program options.
0215   traccc::opts::detector detector_opts;
0216   traccc::opts::magnetic_field bfield_opts;
0217   traccc::opts::input_data input_opts;
0218   traccc::opts::track_finding finding_opts;
0219   traccc::opts::track_propagation propagation_opts;
0220   traccc::opts::track_fitting fitting_opts;
0221   traccc::opts::performance performance_opts;
0222   traccc::opts::truth_finding truth_finding_config;
0223   traccc::opts::track_matching track_matching_opts;
0224   traccc::opts::program_options program_opts{
0225       "Truth Track Finding on the Host",
0226       {detector_opts, bfield_opts, input_opts, finding_opts, propagation_opts,
0227        fitting_opts, performance_opts, truth_finding_config,
0228        track_matching_opts},
0229       argc,
0230       argv,
0231       logger->cloneWithSuffix("Options")};
0232
0233   // Run the application.
0234   return seq_run(finding_opts, propagation_opts, fitting_opts, input_opts,
0235                  detector_opts, bfield_opts, performance_opts,
0236                  truth_finding_config, track_matching_opts, logger->clone());
0237 }