tests/cpu/test_ckf_sparse_tracks_telescope.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/bfield/construct_const_bfield.hpp"
0010 #include "traccc/finding/combinatorial_kalman_filter_algorithm.hpp"
0011 #include "traccc/fitting/kalman_fitting_algorithm.hpp"
0012 #include "traccc/io/read_detector.hpp"
0013 #include "traccc/io/read_measurements.hpp"
0014 #include "traccc/io/utils.hpp"
0015 #include "traccc/resolution/fitting_performance_writer.hpp"
0016 #include "traccc/simulation/event_generators.hpp"
0017 #include "traccc/simulation/simulator.hpp"
0018 #include "traccc/utils/ranges.hpp"
0019
0020 // Test include(s).
0021 #include "tests/ckf_telescope_test.hpp"
0022 #include "traccc/utils/seed_generator.hpp"
0023
0024 // VecMem include(s).
0025 #include <vecmem/memory/host_memory_resource.hpp>
0026 #include <vecmem/utils/copy.hpp>
0027
0028 // GTest include(s).
0029 #include <gtest/gtest.h>
0030
0031 // System include(s).
0032 #include <filesystem>
0033 #include <string>
0034
0035 using namespace traccc;
0036 // This defines the local frame test suite
0037 TEST_P(CkfSparseTrackTelescopeTests, Run) {
0038   // Get the parameters
0039   const std::string name = std::get<0>(GetParam());
0040   const std::array<scalar, 3u> origin = std::get<1>(GetParam());
0041   const std::array<scalar, 3u> origin_stddev = std::get<2>(GetParam());
0042   const std::array<scalar, 2u> mom_range = std::get<3>(GetParam());
0043   const std::array<scalar, 2u> eta_range = std::get<4>(GetParam());
0044   const std::array<scalar, 2u> theta_range = eta_to_theta_range(eta_range);
0045   const std::array<scalar, 2u> phi_range = std::get<5>(GetParam());
0046   const traccc::pdg_particle<scalar> ptc = std::get<6>(GetParam());
0047   const unsigned int n_truth_tracks = std::get<7>(GetParam());
0048   const unsigned int n_events = std::get<8>(GetParam());
0049   const bool random_charge = std::get<9>(GetParam());
0050
0051   // Performance writer
0052   traccc::fitting_performance_writer::config fit_writer_cfg;
0053   fit_writer_cfg.file_path = "performance_track_fitting_" + name + ".root";
0054   traccc::fitting_performance_writer fit_performance_writer(
0055       fit_writer_cfg, traccc::getDefaultLogger("FittingPerformanceWriter",
0056                                                traccc::Logging::Level::INFO));
0057
0058   /*****************************
0059    * Build a telescope geometry
0060    *****************************/
0061
0062   // Memory resources used by the application.
0063   vecmem::host_memory_resource host_mr;
0064   // Copy obejct
0065   vecmem::copy copy;
0066
0067   // Read back detector file
0068   const std::string path = name + "/";
0069   traccc::host_detector detector;
0070   traccc::io::read_detector(
0071       detector, host_mr,
0072       std::filesystem::absolute(
0073           std::filesystem::path(path + "telescope_detector_geometry.json"))
0074           .native(),
0075       std::filesystem::absolute(
0076           std::filesystem::path(path +
0077                                 "telescope_detector_homogeneous_material.json"))
0078           .native());
0079
0080   auto field = traccc::construct_const_bfield(std::get<13>(GetParam()));
0081
0082   /***************************
0083    * Generate simulation data
0084    ***************************/
0085
0086   // Track generator
0087   using generator_type =
0088       detray::random_track_generator<traccc::free_track_parameters<>,
0089                                      uniform_gen_t>;
0090   generator_type::configuration gen_cfg{};
0091   gen_cfg.n_tracks(n_truth_tracks);
0092   gen_cfg.origin(origin);
0093   gen_cfg.origin_stddev(origin_stddev);
0094   gen_cfg.phi_range(phi_range[0], phi_range[1]);
0095   gen_cfg.theta_range(theta_range[0], theta_range[1]);
0096   gen_cfg.mom_range(mom_range[0], mom_range[1]);
0097   gen_cfg.randomize_charge(random_charge);
0098   generator_type generator(gen_cfg);
0099
0100   // Smearing value for measurements
0101   traccc::measurement_smearer<traccc::default_algebra> meas_smearer(
0102       smearing[0], smearing[1]);
0103
0104   using writer_type = traccc::smearing_writer<
0105       traccc::measurement_smearer<traccc::default_algebra>>;
0106
0107   typename writer_type::config smearer_writer_cfg{meas_smearer};
0108   traccc::seed_generator<host_detector_type>::config seed_cfg{};
0109   seed_cfg.initial_sigmas = stddevs;
0110
0111   // Run simulator
0112   const std::string full_path = io::data_directory() + path;
0113   std::filesystem::create_directories(full_path);
0114   auto sim = traccc::simulator<host_detector_type, b_field_t, generator_type,
0115                                writer_type>(
0116       ptc, n_events, detector.as<detector_traits>(),
0117       field.as_field<traccc::const_bfield_backend_t<traccc::scalar>>(),
0118       std::move(generator), std::move(smearer_writer_cfg), full_path);
0119
0120   sim.run();
0121
0122   /*****************************
0123    * Do the reconstruction
0124    *****************************/
0125
0126   // Seed generator
0127   seed_generator<host_detector_type> sg(detector.as<detector_traits>(),
0128                                         seed_cfg);
0129
0130   // Finding algorithm configuration
0131   typename traccc::finding_config cfg;
0132   cfg.ptc_hypothesis = ptc;
0133   cfg.chi2_max = 200.f;
0134   cfg.min_p = 0;
0135   cfg.min_pT = 10.f * unit<float>::MeV;
0136   // The fitting/smoothing is run as a dedicated step
0137   cfg.run_smoother = smoother_type::e_none;
0138
0139   // Finding algorithm object
0140   traccc::host::combinatorial_kalman_filter_algorithm host_finding(cfg,
0141                                                                    host_mr);
0142
0143   // Fitting algorithm object
0144   traccc::fitting_config fit_cfg;
0145   fit_cfg.ptc_hypothesis = ptc;
0146   fit_cfg.min_pT = 100.f * traccc::unit<float>::MeV;
0147   traccc::host::kalman_fitting_algorithm host_fitting(fit_cfg, host_mr, copy);
0148
0149   // Iterate over events
0150   for (std::size_t i_evt = 0; i_evt < n_events; i_evt++) {
0151     // Truth Track Candidates
0152     traccc::event_data evt_data(path, i_evt, host_mr);
0153
0154     traccc::edm::measurement_collection::host truth_measurements{host_mr};
0155     traccc::edm::track_container<traccc::default_algebra>::host
0156         truth_track_candidates{host_mr};
0157     evt_data.generate_truth_candidates(truth_track_candidates,
0158                                        truth_measurements, sg, host_mr);
0159     truth_track_candidates.measurements = vecmem::get_data(truth_measurements);
0160
0161     ASSERT_EQ(truth_track_candidates.tracks.size(), n_truth_tracks);
0162
0163     // Prepare truth seeds
0164     traccc::bound_track_parameters_collection_types::host seeds(&host_mr);
0165     for (unsigned int i_trk = 0; i_trk < n_truth_tracks; i_trk++) {
0166       seeds.push_back(truth_track_candidates.tracks.at(i_trk).params());
0167     }
0168     ASSERT_EQ(seeds.size(), n_truth_tracks);
0169
0170     // Read measurements
0171     traccc::edm::measurement_collection::host measurements_per_event{host_mr};
0172     traccc::io::read_measurements(measurements_per_event, i_evt, path);
0173
0174     // Run finding
0175     auto track_candidates =
0176         host_finding(detector, field, vecmem::get_data(measurements_per_event),
0177                      vecmem::get_data(seeds));
0178
0179     ASSERT_EQ(track_candidates.tracks.size(), n_truth_tracks);
0180
0181     for (unsigned int i_trk = 0; i_trk < n_truth_tracks; i_trk++) {
0182       consistency_tests(track_candidates.tracks.at(i_trk),
0183                         track_candidates.states);
0184
0185       ndf_tests(track_candidates.tracks.at(i_trk), track_candidates.states,
0186                 measurements_per_event);
0187     }
0188
0189     // Run fitting
0190     auto track_states = host_fitting(
0191         detector, field,
0192         traccc::edm::track_container<traccc::default_algebra>::const_data(
0193             track_candidates));
0194     const std::size_t n_fitted_tracks =
0195         count_successfully_fitted_tracks(track_states.tracks);
0196
0197     ASSERT_EQ(track_states.tracks.size(), n_truth_tracks);
0198     ASSERT_EQ(track_states.tracks.size(), n_fitted_tracks);
0199
0200     for (unsigned int i_trk = 0; i_trk < n_truth_tracks; i_trk++) {
0201       consistency_tests(track_states.tracks.at(i_trk), track_states.states);
0202
0203       ndf_tests(track_states.tracks.at(i_trk), track_states.states,
0204                 measurements_per_event);
0205
0206       fit_performance_writer.write(track_states.tracks.at(i_trk),
0207                                    track_states.states, measurements_per_event,
0208                                    detector.as<detector_traits>(), evt_data);
0209     }
0210   }
0211
0212   fit_performance_writer.finalize();
0213
0214   /********************
0215    * Pull value test
0216    ********************/
0217
0218   static const std::vector<std::string> pull_names{
0219       "pull_d0", "pull_z0", "pull_phi", "pull_theta", "pull_qop"};
0220   pull_value_tests(fit_writer_cfg.file_path, pull_names);
0221
0222   /********************
0223    * P-value test
0224    ********************/
0225
0226   p_value_tests(fit_writer_cfg.file_path);
0227
0228   /********************
0229    * Success rate test
0230    ********************/
0231
0232   float success_rate = static_cast<float>(n_success) /
0233                        static_cast<float>(n_truth_tracks * n_events);
0234
0235   ASSERT_FLOAT_EQ(success_rate, 1.00f);
0236 }
0237
0238 INSTANTIATE_TEST_SUITE_P(
0239     CkfSparseTrackTelescopeValidation0, CkfSparseTrackTelescopeTests,
0240     ::testing::Values(std::make_tuple(
0241         "telescope_single_tracks", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0242         std::array<scalar, 3u>{0.f, 400.f, 400.f},
0243         std::array<scalar, 2u>{1.f, 1.f}, std::array<scalar, 2u>{0.f, 0.f},
0244         std::array<scalar, 2u>{0.f, 0.f}, traccc::muon<scalar>(), 1, 5000,
0245         false, 20.f, 9u, 20.f, vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0246
0247 INSTANTIATE_TEST_SUITE_P(
0248     CkfSparseTrackTelescopeValidation1, CkfSparseTrackTelescopeTests,
0249     ::testing::Values(std::make_tuple(
0250         "telescope_double_tracks", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0251         std::array<scalar, 3u>{0.f, 400.f, 400.f},
0252         std::array<scalar, 2u>{1.f, 1.f}, std::array<scalar, 2u>{0.f, 0.f},
0253         std::array<scalar, 2u>{0.f, 0.f}, traccc::muon<scalar>(), 2, 2500,
0254         false, 20.f, 9u, 20.f, vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0255
0256 INSTANTIATE_TEST_SUITE_P(
0257     CkfSparseTrackTelescopeValidation2, CkfSparseTrackTelescopeTests,
0258     ::testing::Values(std::make_tuple(
0259         "telescope_quadra_tracks", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0260         std::array<scalar, 3u>{0.f, 400.f, 400.f},
0261         std::array<scalar, 2u>{1.f, 1.f}, std::array<scalar, 2u>{0.f, 0.f},
0262         std::array<scalar, 2u>{0.f, 0.f}, traccc::muon<scalar>(), 4, 1250,
0263         false, 20.f, 9u, 20.f, vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0264
0265 INSTANTIATE_TEST_SUITE_P(
0266     CkfSparseTrackTelescopeValidation3, CkfSparseTrackTelescopeTests,
0267     ::testing::Values(std::make_tuple(
0268         "telescope_decade_tracks", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0269         std::array<scalar, 3u>{0.f, 400.f, 400.f},
0270         std::array<scalar, 2u>{1.f, 1.f}, std::array<scalar, 2u>{0.f, 0.f},
0271         std::array<scalar, 2u>{0.f, 0.f}, traccc::muon<scalar>(), 10, 500,
0272         false, 20.f, 9u, 20.f, vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0273
0274 INSTANTIATE_TEST_SUITE_P(
0275     CkfSparseTrackTelescopeValidation4, CkfSparseTrackTelescopeTests,
0276     ::testing::Values(std::make_tuple(
0277         "telescope_decade_tracks_random_charge",
0278         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0279         std::array<scalar, 3u>{0.f, 400.f, 400.f},
0280         std::array<scalar, 2u>{1.f, 1.f}, std::array<scalar, 2u>{0.f, 0.f},
0281         std::array<scalar, 2u>{0.f, 0.f}, traccc::muon<scalar>(), 10, 500, true,
0282         20.f, 9u, 20.f, vector3{0, 0, 2 * traccc::unit<scalar>::T})));