tests/alpaka/test_ckf_toy_detector.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 // Test include(s).
0009 #include "tests/ckf_toy_detector_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/finding/combinatorial_kalman_filter_algorithm.hpp"
0018 #include "traccc/io/read_detector.hpp"
0019 #include "traccc/io/read_measurements.hpp"
0020 #include "traccc/io/utils.hpp"
0021 #include "traccc/performance/container_comparator.hpp"
0022 #include "traccc/simulation/event_generators.hpp"
0023 #include "traccc/simulation/simulator.hpp"
0024 #include "traccc/utils/event_data.hpp"
0025 #include "traccc/utils/ranges.hpp"
0026
0027 // VecMem include(s).
0028 #include <vecmem/memory/host_memory_resource.hpp>
0029
0030 // GTest include(s).
0031 #include <gtest/gtest.h>
0032
0033 // System include(s).
0034 #include <filesystem>
0035 #include <string>
0036
0037 namespace traccc {
0038
0039 TEST_P(CkfToyDetectorTests, Run) {
0040   // Get the parameters
0041   const std::string name = std::get<0>(GetParam());
0042   const traccc::pdg_particle<traccc::scalar> ptc = std::get<6>(GetParam());
0043   const unsigned int n_truth_tracks = std::get<7>(GetParam());
0044   const unsigned int n_events = std::get<8>(GetParam());
0045   const bool random_charge = std::get<9>(GetParam());
0046
0047   /*****************************
0048    * Build a toy detector
0049    *****************************/
0050
0051   // Alpaka objects.
0052   traccc::alpaka::queue queue;
0053   traccc::alpaka::vecmem_objects vo(queue);
0054
0055   // Memory resources used by the application.
0056   vecmem::host_memory_resource host_mr;
0057   vecmem::memory_resource& device_mr = vo.device_mr();
0058   traccc::memory_resource mr{device_mr, &host_mr};
0059
0060   // Copy objects
0061   vecmem::copy& copy = vo.async_copy();
0062
0063   // Path to the working directory.
0064   const std::filesystem::path path = std::filesystem::current_path() / name;
0065
0066   constexpr bool use_material_maps = false;
0067   WriteDetector(use_material_maps, name);
0068
0069   // Read in the detector geometry that was generated by the test fixture.
0070   detray::io::detector_reader_config reader_cfg{};
0071   reader_cfg.add_file((path / "toy_detector_geometry.json").native())
0072       .add_file((path / "toy_detector_surface_grids.json").native())
0073       .add_file((path / "toy_detector_homogeneous_material.json").native())
0074       .do_check(true);
0075
0076   auto [io_det, names] =
0077       detray::io::read_detector<traccc::default_detector::host>(host_mr,
0078                                                                 reader_cfg);
0079   traccc::host_detector host_detector{};
0080   host_detector.template set<
0081       traccc::detector_traits<traccc::default_detector::host::metadata>>(
0082       std::move(io_det));
0083
0084   const traccc::detector_buffer detector_buffer =
0085       traccc::buffer_from_host_detector(host_detector, device_mr, copy);
0086   queue.synchronize();
0087
0088   const auto field = traccc::construct_const_bfield(B);
0089
0090   /***************************
0091    * Generate simulation data
0092    ***************************/
0093
0094   // Track generator
0095   using generator_type =
0096       detray::random_track_generator<traccc::free_track_parameters<>,
0097                                      uniform_gen_t>;
0098   generator_type::configuration gen_cfg{};
0099   gen_cfg.n_tracks(n_truth_tracks);
0100   gen_cfg.origin(std::get<1>(GetParam()));
0101   gen_cfg.origin_stddev(std::get<2>(GetParam()));
0102   gen_cfg.phi_range(std::get<5>(GetParam()));
0103   gen_cfg.eta_range(std::get<4>(GetParam()));
0104   gen_cfg.mom_range(std::get<3>(GetParam()));
0105   gen_cfg.randomize_charge(random_charge);
0106   gen_cfg.seed(42);
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   std::filesystem::create_directories(path);
0122   auto sim = traccc::simulator<host_detector_type, b_field_t, generator_type,
0123                                writer_type>(
0124       ptc, n_events, host_detector.as<detector_traits>(),
0125       field.as_field<traccc::const_bfield_backend_t<traccc::scalar>>(),
0126       std::move(generator), std::move(smearer_writer_cfg), path.native());
0127   sim.get_config().propagation.navigation.search_window = search_window;
0128   sim.run();
0129
0130   /*****************************
0131    * Do the reconstruction
0132    *****************************/
0133
0134   // Seed generator
0135   seed_generator<host_detector_type> sg(host_detector.as<detector_traits>(),
0136                                         seed_cfg);
0137
0138   // Finding algorithm configuration
0139   traccc::alpaka::combinatorial_kalman_filter_algorithm::config_type cfg;
0140   cfg.ptc_hypothesis = ptc;
0141   cfg.max_num_branches_per_seed = 500;
0142   cfg.max_num_branches_per_surface = 2;
0143   cfg.chi2_max = 10.f;
0144   cfg.propagation.navigation.search_window = search_window;
0145   cfg.run_smoother = smoother_type::e_none;
0146
0147   // Finding algorithm object
0148   traccc::host::combinatorial_kalman_filter_algorithm host_finding(cfg,
0149                                                                    host_mr);
0150
0151   // Finding algorithm object
0152   traccc::alpaka::combinatorial_kalman_filter_algorithm device_finding{
0153       cfg, mr, copy, queue};
0154
0155   // Iterate over events
0156   for (std::size_t i_evt = 0; i_evt < n_events; i_evt++) {
0157     // Truth Track Candidates
0158     traccc::event_data evt_data(path.native(), i_evt, host_mr);
0159
0160     traccc::edm::measurement_collection::host truth_measurements{host_mr};
0161     traccc::edm::track_container<traccc::default_algebra>::host
0162         truth_track_candidates{host_mr};
0163     evt_data.generate_truth_candidates(truth_track_candidates,
0164                                        truth_measurements, sg, host_mr);
0165     truth_track_candidates.measurements = vecmem::get_data(truth_measurements);
0166
0167     ASSERT_EQ(truth_track_candidates.tracks.size(), n_truth_tracks);
0168
0169     // Prepare truth seeds
0170     traccc::bound_track_parameters_collection_types::host seeds(&host_mr);
0171     for (unsigned int i_trk = 0; i_trk < n_truth_tracks; i_trk++) {
0172       seeds.push_back(truth_track_candidates.tracks.at(i_trk).params());
0173     }
0174     ASSERT_EQ(seeds.size(), n_truth_tracks);
0175
0176     traccc::bound_track_parameters_collection_types::buffer seeds_buffer{
0177         static_cast<unsigned int>(seeds.size()), mr.main};
0178     copy.setup(seeds_buffer)->wait();
0179     copy(vecmem::get_data(seeds), seeds_buffer,
0180          vecmem::copy::type::host_to_device)
0181         ->wait();
0182
0183     // Read measurements
0184     traccc::edm::measurement_collection::host measurements_per_event{host_mr};
0185     traccc::io::read_measurements(measurements_per_event, i_evt, path.native());
0186
0187     traccc::edm::measurement_collection::buffer measurements_buffer(
0188         static_cast<unsigned int>(measurements_per_event.size()), mr.main);
0189     copy.setup(measurements_buffer)->wait();
0190     copy(vecmem::get_data(measurements_per_event), measurements_buffer)->wait();
0191
0192     // Run host finding
0193     auto track_candidates = host_finding(
0194         host_detector, field, vecmem::get_data(measurements_per_event),
0195         vecmem::get_data(seeds));
0196
0197     // Run device finding
0198     auto track_candidates_alpaka_buffer = device_finding(
0199         detector_buffer, field, measurements_buffer, seeds_buffer);
0200
0201     traccc::edm::track_collection<traccc::default_algebra>::host
0202         track_candidates_alpaka{host_mr};
0203     copy(track_candidates_alpaka_buffer.tracks, track_candidates_alpaka)
0204         ->wait();
0205
0206     // Simple check
0207     ASSERT_LE(static_cast<double>(std::llabs(
0208                   static_cast<long>(track_candidates.tracks.size()) -
0209                   static_cast<long>(track_candidates_alpaka.size()))) /
0210                   static_cast<double>(track_candidates.tracks.size()),
0211               0.001f)
0212         << "No. tracks (host): " << track_candidates.tracks.size() << "/"
0213         << n_truth_tracks
0214         << "\nNo. tracks (device): " << track_candidates_alpaka.size() << "/"
0215         << n_truth_tracks;
0216     ASSERT_GE(track_candidates.tracks.size(), n_truth_tracks);
0217
0218     // Make sure that the outputs from cpu and cuda CKF are equivalent
0219     unsigned int n_matches = 0u;
0220     for (unsigned int i = 0u; i < track_candidates.tracks.size(); i++) {
0221       traccc::details::is_same_object<traccc::edm::track_collection<
0222           traccc::default_algebra>::host::const_proxy_type>
0223           iso{track_candidates.measurements, track_candidates.measurements,
0224               vecmem::get_data(track_candidates.states),
0225               vecmem::get_data(track_candidates.states),
0226               track_candidates.tracks.at(i)};
0227
0228       for (unsigned int j = 0u; j < track_candidates_alpaka.size(); j++) {
0229         if (iso(track_candidates_alpaka.at(j))) {
0230           n_matches++;
0231           break;
0232         }
0233       }
0234     }
0235
0236     float matching_rate =
0237         float(n_matches) /
0238         static_cast<float>(std::max(track_candidates.tracks.size(),
0239                                     track_candidates_alpaka.size()));
0240     EXPECT_GE(matching_rate, 0.998f);
0241   }
0242 }
0243
0244 INSTANTIATE_TEST_SUITE_P(
0245     AlpakaCkfToyDetectorValidation, CkfToyDetectorTests,
0246     ::testing::Values(
0247         std::make_tuple("toy_n_particles_1",
0248                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0249                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0250                         std::array<scalar, 2u>{1.f, 100.f},
0251                         std::array<scalar, 2u>{-4.f, 4.f},
0252                         std::array<scalar, 2u>{-traccc::constant<scalar>::pi,
0253                                                traccc::constant<scalar>::pi},
0254                         traccc::muon<scalar>(), 1, 1, false),
0255         std::make_tuple("toy_n_particles_10000",
0256                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0257                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0258                         std::array<scalar, 2u>{1.f, 100.f},
0259                         std::array<scalar, 2u>{-4.f, 4.f},
0260                         std::array<scalar, 2u>{-traccc::constant<scalar>::pi,
0261                                                traccc::constant<scalar>::pi},
0262                         traccc::muon<scalar>(), 10000, 1, false),
0263         std::make_tuple("toy_n_particles_10000_random_charge",
0264                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0265                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0266                         std::array<scalar, 2u>{1.f, 100.f},
0267                         std::array<scalar, 2u>{-4.f, 4.f},
0268                         std::array<scalar, 2u>{-traccc::constant<scalar>::pi,
0269                                                traccc::constant<scalar>::pi},
0270                         traccc::muon<scalar>(), 10000, 1, true)));
0271
0272 }  // namespace traccc