tests/cpu/test_kalman_fitter_hole_count.cpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2024-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/fitting/kalman_fitting_algorithm.hpp"
0011 #include "traccc/io/read_detector.hpp"
0012 #include "traccc/io/utils.hpp"
0013 #include "traccc/resolution/fitting_performance_writer.hpp"
0014 #include "traccc/simulation/event_generators.hpp"
0015 #include "traccc/simulation/simulator.hpp"
0016 #include "traccc/utils/ranges.hpp"
0017 #include "traccc/utils/seed_generator.hpp"
0018
0019 // Test include(s).
0020 #include "tests/kalman_fitting_telescope_test.hpp"
0021
0022 // VecMem include(s).
0023 #include <vecmem/memory/host_memory_resource.hpp>
0024 #include <vecmem/utils/copy.hpp>
0025
0026 // GTest include(s).
0027 #include <gtest/gtest.h>
0028
0029 // System include(s).
0030 #include <filesystem>
0031 #include <string>
0032
0033 using namespace traccc;
0034
0035 class KalmanFittingHoleCountTests : public KalmanFittingTelescopeTests {};
0036
0037 TEST_P(KalmanFittingHoleCountTests, 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   // We only test one track of one event
0052   ASSERT_EQ(n_truth_tracks, 1u);
0053   ASSERT_EQ(n_events, 1u);
0054
0055   /*****************************
0056    * Build a telescope geometry
0057    *****************************/
0058
0059   // Memory resources used by the application.
0060   vecmem::host_memory_resource host_mr;
0061   // Copy obejct
0062   vecmem::copy copy;
0063
0064   // Read back detector file
0065   const std::string path = name + "/";
0066   traccc::host_detector detector;
0067   traccc::io::read_detector(
0068       detector, host_mr,
0069       std::filesystem::absolute(
0070           std::filesystem::path(path + "telescope_detector_geometry.json"))
0071           .native(),
0072       std::filesystem::absolute(
0073           std::filesystem::path(path +
0074                                 "telescope_detector_homogeneous_material.json"))
0075           .native());
0076   auto field = traccc::construct_const_bfield(std::get<13>(GetParam()));
0077
0078   /***************************
0079    * Generate simulation data
0080    ***************************/
0081
0082   // Track generator
0083   using generator_type =
0084       detray::random_track_generator<traccc::free_track_parameters<>,
0085                                      uniform_gen_t>;
0086   generator_type::configuration gen_cfg{};
0087   gen_cfg.n_tracks(n_truth_tracks);
0088   gen_cfg.origin(origin);
0089   gen_cfg.origin_stddev(origin_stddev);
0090   gen_cfg.phi_range(phi_range[0], phi_range[1]);
0091   gen_cfg.theta_range(theta_range[0], theta_range[1]);
0092   gen_cfg.mom_range(mom_range[0], mom_range[1]);
0093   gen_cfg.randomize_charge(random_charge);
0094   generator_type generator(gen_cfg);
0095
0096   // Smearing value for measurements
0097   traccc::measurement_smearer<traccc::default_algebra> meas_smearer(
0098       smearing[0], smearing[1]);
0099
0100   using writer_type = traccc::smearing_writer<
0101       traccc::measurement_smearer<traccc::default_algebra>>;
0102
0103   typename writer_type::config smearer_writer_cfg{meas_smearer};
0104   traccc::seed_generator<host_detector_type>::config seed_cfg{};
0105   seed_cfg.initial_sigmas = stddevs;
0106
0107   // Run simulator
0108   const std::string full_path = io::data_directory() + path;
0109   std::filesystem::create_directories(full_path);
0110   auto sim = traccc::simulator<host_detector_type, b_field_t, generator_type,
0111                                writer_type>(
0112       ptc, n_events, detector.as<detector_traits>(),
0113       field.as_field<traccc::const_bfield_backend_t<traccc::scalar>>(),
0114       std::move(generator), std::move(smearer_writer_cfg), full_path);
0115   sim.run();
0116
0117   /***************
0118    * Run fitting
0119    ***************/
0120
0121   // Seed generator
0122   seed_generator<host_detector_type> sg(detector.as<detector_traits>(),
0123                                         seed_cfg);
0124
0125   // Fitting algorithm object
0126   traccc::fitting_config fit_cfg;
0127   fit_cfg.ptc_hypothesis = ptc;
0128   fit_cfg.min_p = 10.f * traccc::unit<float>::MeV;
0129   fit_cfg.min_pT = 60.f * traccc::unit<float>::MeV;
0130   traccc::host::kalman_fitting_algorithm fitting(fit_cfg, host_mr, copy);
0131
0132   // Event map
0133   traccc::event_data evt_data(path, 0u, host_mr);
0134
0135   // Truth Track Candidates
0136   traccc::edm::measurement_collection::host measurements(host_mr);
0137   traccc::edm::track_container<traccc::default_algebra>::host track_candidates{
0138       host_mr};
0139   evt_data.generate_truth_candidates(track_candidates, measurements, sg,
0140                                      host_mr);
0141   track_candidates.measurements = vecmem::get_data(measurements);
0142   // Measurement index vector
0143   auto& cands = track_candidates.tracks.at(0u).constituent_links();
0144
0145   // Some sanity checks
0146   ASSERT_EQ(track_candidates.tracks.size(), n_truth_tracks);
0147   const auto n_planes = std::get<11>(GetParam());
0148   ASSERT_EQ(cands.size(), n_planes);
0149
0150   // Pop some track candidates to create holes
0151   // => The number of holes = 8
0152   ASSERT_TRUE(cands.size() > 8u);
0153   cands.erase(cands.begin());
0154   cands.erase(cands.begin());
0155   cands.erase(cands.begin() + 2);
0156   cands.erase(cands.begin() + 2);
0157   cands.erase(cands.begin() + 7);
0158   cands.pop_back();
0159   cands.pop_back();
0160   cands.pop_back();
0161
0162   // A sanity check on the number of candidiates
0163   ASSERT_EQ(cands.size(), n_planes - 8u);
0164
0165   // Run fitting
0166   auto track_states =
0167       fitting(detector, field,
0168               traccc::edm::track_container<traccc::default_algebra>::const_data(
0169                   track_candidates));
0170
0171   // A sanity check
0172   const std::size_t n_tracks = track_states.tracks.size();
0173   ASSERT_EQ(n_tracks, n_truth_tracks);
0174
0175   // Check the number of holes
0176   // The three holes at the end are not counted as KF aborts once it goes
0177   // through all track candidates
0178   const auto track = track_states.tracks.at(0u);
0179   ASSERT_EQ(track.nholes(), 5u);
0180
0181   // Some sanity checks
0182   ASSERT_FLOAT_EQ(
0183       static_cast<float>(track.ndf()),
0184       static_cast<float>(track.constituent_links().size()) * 2.f - 5.f);
0185 }
0186
0187 INSTANTIATE_TEST_SUITE_P(
0188     KalmanFittingHoleCount, KalmanFittingHoleCountTests,
0189     ::testing::Values(std::make_tuple(
0190         "telescope_1_GeV_0_phi_muon", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0191         std::array<scalar, 3u>{0.f, 0.f, 0.f}, std::array<scalar, 2u>{1.f, 1.f},
0192         std::array<scalar, 2u>{0.f, 0.f}, std::array<scalar, 2u>{0.f, 0.f},
0193         traccc::muon<scalar>(), 1, 1, false, 20.f, 20u, 20.f,
0194         vector3{2 * traccc::unit<scalar>::T, 0, 0})));