tests/alpaka/test_ckf_combinatorics_telescope.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 // Test include(s).
0009 #include "tests/ckf_telescope_test.hpp"
0010 #include "traccc/utils/seed_generator.hpp"
0011
0012 // Project include(s).
0013 #include "traccc/alpaka/finding/combinatorial_kalman_filter_algorithm.hpp"
0014 #include "traccc/alpaka/utils/vecmem_objects.hpp"
0015 #include "traccc/bfield/construct_const_bfield.hpp"
0016 #include "traccc/bfield/magnetic_field_types.hpp"
0017 #include "traccc/io/read_detector.hpp"
0018 #include "traccc/io/read_measurements.hpp"
0019 #include "traccc/io/utils.hpp"
0020 #include "traccc/simulation/event_generators.hpp"
0021 #include "traccc/simulation/simulator.hpp"
0022 #include "traccc/utils/event_data.hpp"
0023 #include "traccc/utils/ranges.hpp"
0024
0025 // VecMem include(s).
0026 #include <vecmem/memory/host_memory_resource.hpp>
0027
0028 // GTest include(s).
0029 #include <gtest/gtest.h>
0030
0031 // System include(s).
0032 #include <filesystem>
0033 #include <string>
0034
0035 namespace traccc {
0036
0037 TEST_P(CkfCombinatoricsTelescopeTests, Run) {
0038   // Only run this test on an accelerator.
0039 #if !(defined(ALPAKA_ACC_GPU_CUDA_ENABLED) || \
0040       defined(ALPAKA_ACC_GPU_HIP_ENABLED) || defined(ALPAKA_ACC_SYCL_ENABLED))
0041   GTEST_SKIP() << "This test is only supported on an accelerator.";
0042 #endif
0043
0044   // Get the parameters
0045   const std::string name = std::get<0>(GetParam());
0046   const std::array<scalar, 3u> origin = std::get<1>(GetParam());
0047   const std::array<scalar, 3u> origin_stddev = std::get<2>(GetParam());
0048   const std::array<scalar, 2u> mom_range = std::get<3>(GetParam());
0049   const std::array<scalar, 2u> eta_range = std::get<4>(GetParam());
0050   const std::array<scalar, 2u> theta_range = eta_to_theta_range(eta_range);
0051   const std::array<scalar, 2u> phi_range = std::get<5>(GetParam());
0052   const traccc::pdg_particle<scalar> ptc = std::get<6>(GetParam());
0053   const unsigned int n_truth_tracks = std::get<7>(GetParam());
0054   const unsigned int n_events = std::get<8>(GetParam());
0055   const bool random_charge = std::get<9>(GetParam());
0056
0057   /*****************************
0058    * Build a telescope geometry
0059    *****************************/
0060
0061   // Alpaka objects.
0062   traccc::alpaka::queue queue;
0063   traccc::alpaka::vecmem_objects vo(queue);
0064
0065   // Memory resources used by the application.
0066   vecmem::host_memory_resource host_mr;
0067   vecmem::memory_resource& device_mr = vo.device_mr();
0068   traccc::memory_resource mr{device_mr, &host_mr};
0069
0070   // Copy objects
0071   vecmem::copy& copy = vo.async_copy();
0072
0073   // Path to the working directory.
0074   const std::filesystem::path path = std::filesystem::current_path() / name;
0075
0076   // Read in the detector geometry that was generated by the test fixture.
0077   traccc::host_detector host_detector;
0078   traccc::io::read_detector(
0079       host_detector, host_mr,
0080       std::filesystem::path(path / "telescope_detector_geometry.json").native(),
0081       std::filesystem::absolute(path /
0082                                 "telescope_detector_homogeneous_material.json")
0083           .native());
0084
0085   const traccc::detector_buffer detector_buffer =
0086       traccc::buffer_from_host_detector(host_detector, device_mr, copy);
0087   queue.synchronize();
0088
0089   auto field = traccc::construct_const_bfield(std::get<13>(GetParam()));
0090
0091   /***************************
0092    * Generate simulation data
0093    ***************************/
0094
0095   // Track generator
0096   using generator_type =
0097       detray::random_track_generator<traccc::free_track_parameters<>,
0098                                      uniform_gen_t>;
0099   generator_type::configuration gen_cfg{};
0100   gen_cfg.n_tracks(n_truth_tracks);
0101   gen_cfg.origin(origin);
0102   gen_cfg.origin_stddev(origin_stddev);
0103   gen_cfg.phi_range(phi_range[0], phi_range[1]);
0104   gen_cfg.theta_range(theta_range[0], theta_range[1]);
0105   gen_cfg.mom_range(mom_range[0], mom_range[1]);
0106   gen_cfg.randomize_charge(random_charge);
0107   generator_type generator(gen_cfg);
0108
0109   // Smearing value for measurements
0110   traccc::measurement_smearer<traccc::default_algebra> meas_smearer(
0111       smearing[0], smearing[1]);
0112
0113   using writer_type = traccc::smearing_writer<
0114       traccc::measurement_smearer<traccc::default_algebra>>;
0115
0116   typename writer_type::config smearer_writer_cfg{meas_smearer};
0117   traccc::seed_generator<host_detector_type>::config seed_cfg{};
0118   seed_cfg.initial_sigmas = stddevs;
0119
0120   // Run simulator
0121   auto sim = traccc::simulator<host_detector_type, b_field_t, generator_type,
0122                                writer_type>(
0123       ptc, n_events, host_detector.as<detector_traits>(),
0124       field.as_field<traccc::const_bfield_backend_t<traccc::scalar>>(),
0125       std::move(generator), std::move(smearer_writer_cfg), path.native());
0126   sim.run();
0127
0128   /*****************************
0129    * Do the reconstruction
0130    *****************************/
0131
0132   // Seed generator
0133   seed_generator<host_detector_type> sg(host_detector.as<detector_traits>(),
0134                                         seed_cfg);
0135
0136   // Finding algorithm configuration
0137   traccc::alpaka::combinatorial_kalman_filter_algorithm::config_type
0138       cfg_no_limit;
0139   cfg_no_limit.ptc_hypothesis = ptc;
0140   cfg_no_limit.max_num_branches_per_seed = 100000;
0141   cfg_no_limit.chi2_max = 30.f;
0142   cfg_no_limit.max_num_branches_per_surface = 10;
0143   cfg_no_limit.duplicate_removal_minimum_length = 100u;
0144   cfg_no_limit.run_smoother = smoother_type::e_none;
0145
0146   traccc::alpaka::combinatorial_kalman_filter_algorithm::config_type cfg_limit;
0147   cfg_limit.ptc_hypothesis = ptc;
0148   cfg_limit.max_num_branches_per_seed = 500;
0149   cfg_limit.chi2_max = 30.f;
0150   cfg_limit.max_num_branches_per_surface = 10;
0151   cfg_limit.duplicate_removal_minimum_length = 100u;
0152   cfg_limit.run_smoother = smoother_type::e_none;
0153
0154   // Finding algorithm object
0155   traccc::alpaka::combinatorial_kalman_filter_algorithm device_finding{
0156       cfg_no_limit, mr, copy, queue};
0157   traccc::alpaka::combinatorial_kalman_filter_algorithm device_finding_limit{
0158       cfg_limit, mr, copy, queue};
0159
0160   // Iterate over events
0161   for (std::size_t i_evt = 0; i_evt < n_events; i_evt++) {
0162     // Truth Track Candidates
0163     traccc::event_data evt_data(path, i_evt, host_mr);
0164
0165     traccc::edm::measurement_collection::host truth_measurements{host_mr};
0166     traccc::edm::track_container<traccc::default_algebra>::host
0167         truth_track_candidates{host_mr};
0168     evt_data.generate_truth_candidates(truth_track_candidates,
0169                                        truth_measurements, sg, host_mr);
0170     truth_track_candidates.measurements = vecmem::get_data(truth_measurements);
0171
0172     ASSERT_EQ(truth_track_candidates.tracks.size(), n_truth_tracks);
0173
0174     // Prepare truth seeds
0175     traccc::bound_track_parameters_collection_types::host seeds(&host_mr);
0176     for (unsigned int i_trk = 0; i_trk < n_truth_tracks; i_trk++) {
0177       seeds.push_back(truth_track_candidates.tracks.at(i_trk).params());
0178     }
0179     ASSERT_EQ(seeds.size(), n_truth_tracks);
0180
0181     traccc::bound_track_parameters_collection_types::buffer seeds_buffer{
0182         static_cast<unsigned int>(seeds.size()), mr.main};
0183     copy.setup(seeds_buffer)->wait();
0184     copy(vecmem::get_data(seeds), seeds_buffer,
0185          vecmem::copy::type::host_to_device)
0186         ->wait();
0187
0188     // Read measurements
0189     traccc::edm::measurement_collection::host measurements_per_event{host_mr};
0190     traccc::io::read_measurements(measurements_per_event, i_evt, path.native());
0191
0192     traccc::edm::measurement_collection::buffer measurements_buffer(
0193         static_cast<unsigned int>(measurements_per_event.size()), mr.main);
0194     copy.setup(measurements_buffer)->wait();
0195     copy(vecmem::get_data(measurements_per_event), measurements_buffer)->wait();
0196
0197     // Run device finding
0198     auto track_candidates_buffer = device_finding(
0199         detector_buffer, field, measurements_buffer, seeds_buffer);
0200
0201     // Run device finding (Limit)
0202     auto track_candidates_limit_buffer = device_finding_limit(
0203         detector_buffer, field, measurements_buffer, seeds_buffer);
0204
0205     traccc::edm::track_collection<traccc::default_algebra>::host
0206         track_candidates{host_mr},
0207         track_candidates_limit{host_mr};
0208     copy(track_candidates_buffer.tracks, track_candidates,
0209          vecmem::copy::type::device_to_host)
0210         ->wait();
0211     copy(track_candidates_limit_buffer.tracks, track_candidates_limit,
0212          vecmem::copy::type::device_to_host)
0213         ->wait();
0214
0215     // Make sure that the number of found tracks = n_track ^ (n_planes + 1)
0216     EXPECT_GT(track_candidates.size(), track_candidates_limit.size());
0217     EXPECT_EQ(track_candidates.size(),
0218               std::pow(n_truth_tracks, std::get<11>(GetParam()) + 1));
0219     EXPECT_EQ(track_candidates_limit.size(),
0220               n_truth_tracks * cfg_limit.max_num_branches_per_seed);
0221   }
0222 }
0223
0224 INSTANTIATE_TEST_SUITE_P(
0225     AlpakaCkfCombinatoricsTelescopeValidation, CkfCombinatoricsTelescopeTests,
0226     ::testing::Values(
0227         std::make_tuple("telescope_combinatorics_twin",
0228                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0229                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0230                         std::array<scalar, 2u>{100.f, 100.f},
0231                         std::array<scalar, 2u>{0.f, 0.f},
0232                         std::array<scalar, 2u>{0.f, 0.f},
0233                         traccc::muon<scalar>(), 2, 1, false, 20.f, 9u, 20.f,
0234                         vector3{2 * traccc::unit<scalar>::T, 0, 0}),
0235         std::make_tuple("telescope_combinatorics_trio",
0236                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0237                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0238                         std::array<scalar, 2u>{100.f, 100.f},
0239                         std::array<scalar, 2u>{0.f, 0.f},
0240                         std::array<scalar, 2u>{0.f, 0.f},
0241                         traccc::muon<scalar>(), 3, 1, false, 20.f, 9u, 20.f,
0242                         vector3{2 * traccc::unit<scalar>::T, 0, 0})));
0243
0244 }  // namespace traccc