tests/hip/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 // Project include(s).
0009 #include "traccc/bfield/construct_const_bfield.hpp"
0010 #include "traccc/bfield/magnetic_field_types.hpp"
0011 #include "traccc/hip/finding/combinatorial_kalman_filter_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/simulation/event_generators.hpp"
0016 #include "traccc/simulation/simulator.hpp"
0017 #include "traccc/utils/event_data.hpp"
0018 #include "traccc/utils/ranges.hpp"
0019 #include "traccc/utils/seed_generator.hpp"
0020
0021 // Test include(s).
0022 #include "tests/ckf_toy_detector_test.hpp"
0023
0024 // VecMem include(s).
0025 #include <vecmem/memory/hip/device_memory_resource.hpp>
0026 #include <vecmem/memory/hip/managed_memory_resource.hpp>
0027 #include <vecmem/memory/host_memory_resource.hpp>
0028 #include <vecmem/utils/hip/async_copy.hpp>
0029 #include <vecmem/utils/hip/stream_wrapper.hpp>
0030
0031 // GTest include(s).
0032 #include <gtest/gtest.h>
0033
0034 // System include(s).
0035 #include <filesystem>
0036 #include <string>
0037
0038 using namespace traccc;
0039
0040 TEST_P(CkfToyDetectorTests, Run) {
0041   // Get the parameters
0042   const std::string name = std::get<0>(GetParam());
0043   const traccc::pdg_particle<scalar> ptc = std::get<6>(GetParam());
0044   const unsigned int n_truth_tracks = std::get<7>(GetParam());
0045   const unsigned int n_events = std::get<8>(GetParam());
0046   const bool random_charge = std::get<9>(GetParam());
0047
0048   constexpr bool use_material_maps = false;
0049   WriteDetector(use_material_maps, name);
0050
0051   /*****************************
0052    * Build a toy detector
0053    *****************************/
0054
0055   // Memory resources used by the application.
0056   vecmem::host_memory_resource host_mr;
0057   vecmem::hip::device_memory_resource device_mr;
0058   traccc::memory_resource mr{device_mr, &host_mr};
0059   vecmem::hip::managed_memory_resource mng_mr;
0060   vecmem::copy host_copy;
0061
0062   // Read back detector file
0063   const std::string path = name + "/";
0064   detray::io::detector_reader_config reader_cfg{};
0065   reader_cfg.add_file(path + "toy_detector_geometry.json")
0066       .add_file(path + "toy_detector_surface_grids.json")
0067       .add_file(path + "toy_detector_homogeneous_material.json")
0068       .do_check(true);
0069
0070   auto [io_det, names] =
0071       detray::io::read_detector<traccc::default_detector>(host_mr, reader_cfg);
0072   traccc::host_detector detector{};
0073   detector.template set<traccc::default_detector>(std::move(io_det));
0074
0075   traccc::detector_buffer detector_buffer =
0076       traccc::buffer_from_host_detector(detector, mng_mr, host_copy);
0077
0078   const auto field = traccc::construct_const_bfield(B);
0079
0080   /***************************
0081    * Generate simulation data
0082    ***************************/
0083
0084   // Track generator
0085   using generator_type =
0086       detray::random_track_generator<traccc::free_track_parameters<>,
0087                                      uniform_gen_t>;
0088   generator_type::configuration gen_cfg{};
0089   gen_cfg.n_tracks(n_truth_tracks);
0090   gen_cfg.origin(std::get<1>(GetParam()));
0091   gen_cfg.origin_stddev(std::get<2>(GetParam()));
0092   gen_cfg.phi_range(std::get<5>(GetParam()));
0093   gen_cfg.eta_range(std::get<4>(GetParam()));
0094   gen_cfg.mom_range(std::get<3>(GetParam()));
0095   gen_cfg.randomize_charge(random_charge);
0096   gen_cfg.seed(42);
0097   generator_type generator(gen_cfg);
0098
0099   // Smearing value for measurements
0100   traccc::measurement_smearer<traccc::default_algebra> meas_smearer(
0101       smearing[0], smearing[1]);
0102
0103   using writer_type = traccc::smearing_writer<
0104       traccc::measurement_smearer<traccc::default_algebra>>;
0105
0106   typename writer_type::config smearer_writer_cfg{meas_smearer};
0107   traccc::seed_generator<host_detector_type>::config seed_cfg{};
0108   seed_cfg.initial_sigmas = stddevs;
0109
0110   // Run simulator
0111   const std::string full_path = io::data_directory() + path;
0112   std::filesystem::create_directories(full_path);
0113   auto sim = traccc::simulator<host_detector_type, b_field_t, generator_type,
0114                                writer_type>(
0115       ptc, n_events, detector.as<host_detector_type>(),
0116       field.as_field<traccc::const_bfield_backend_t<traccc::scalar>>(),
0117       std::move(generator), std::move(smearer_writer_cfg), full_path);
0118   sim.get_config().propagation.navigation.search_window = search_window;
0119   sim.run();
0120
0121   /*****************************
0122    * Do the reconstruction
0123    *****************************/
0124
0125   // Stream object
0126   vecmem::hip::stream_wrapper vecmem_stream;
0127   traccc::hip::stream_wrapper stream{vecmem_stream.stream()};
0128
0129   // Copy objects
0130   vecmem::hip::async_copy copy{stream.hipStream()};
0131
0132   // Seed generator
0133   seed_generator<host_detector_type> sg(detector.as<host_detector_type>(),
0134                                         seed_cfg);
0135
0136   // Finding algorithm configuration
0137   typename traccc::hip::combinatorial_kalman_filter_algorithm::config_type cfg;
0138   cfg.ptc_hypothesis = ptc;
0139   cfg.max_num_branches_per_seed = 500;
0140   cfg.max_num_branches_per_surface = 2;
0141   cfg.chi2_max = 10.f;
0142   cfg.propagation.navigation.search_window = search_window;
0143   cfg.run_smoother = smoother_type::e_none;
0144
0145   // Finding algorithm object
0146   traccc::hip::combinatorial_kalman_filter_algorithm device_finding(
0147       cfg, mr, copy, stream);
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     traccc::bound_track_parameters_collection_types::buffer seeds_buffer{
0171         static_cast<unsigned int>(seeds.size()), mr.main};
0172     copy.setup(seeds_buffer)->wait();
0173     copy(vecmem::get_data(seeds), seeds_buffer,
0174          vecmem::copy::type::host_to_device)
0175         ->wait();
0176
0177     // Prepare the measurements
0178     traccc::edm::measurement_collection::host measurements_per_event{host_mr};
0179     traccc::io::read_measurements(measurements_per_event, i_evt, path);
0180
0181     traccc::edm::measurement_collection::buffer measurements_buffer(
0182         static_cast<unsigned int>(measurements_per_event.size()), mr.main);
0183     copy.setup(measurements_buffer)->wait();
0184     copy(vecmem::get_data(measurements_per_event), measurements_buffer)->wait();
0185
0186     // Run device finding
0187     traccc::edm::track_container<traccc::default_algebra>::buffer
0188         track_candidates_hip_buffer = device_finding(
0189             detector_buffer, field, measurements_buffer, seeds_buffer);
0190
0191     traccc::edm::track_collection<traccc::default_algebra>::host
0192         track_candidates_hip{host_mr};
0193     copy(track_candidates_hip_buffer.tracks, track_candidates_hip)->wait();
0194
0195     // Simple check
0196     ASSERT_GE(track_candidates_hip.size(), n_truth_tracks)
0197         << "No. tracks (device): " << track_candidates_hip.size() << "/"
0198         << n_truth_tracks;
0199   }
0200 }
0201
0202 INSTANTIATE_TEST_SUITE_P(
0203     HIPCkfToyDetectorValidation, CkfToyDetectorTests,
0204     ::testing::Values(
0205         std::make_tuple("toy_n_particles_1",
0206                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0207                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0208                         std::array<scalar, 2u>{1.f, 100.f},
0209                         std::array<scalar, 2u>{-4.f, 4.f},
0210                         std::array<scalar, 2u>{-traccc::constant<scalar>::pi,
0211                                                traccc::constant<scalar>::pi},
0212                         traccc::muon<scalar>(), 1, 1, false),
0213         std::make_tuple("toy_n_particles_10000",
0214                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0215                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0216                         std::array<scalar, 2u>{1.f, 100.f},
0217                         std::array<scalar, 2u>{-4.f, 4.f},
0218                         std::array<scalar, 2u>{-traccc::constant<scalar>::pi,
0219                                                traccc::constant<scalar>::pi},
0220                         traccc::muon<scalar>(), 10000, 1, false),
0221         std::make_tuple("toy_n_particles_10000_random_charge",
0222                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0223                         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0224                         std::array<scalar, 2u>{1.f, 100.f},
0225                         std::array<scalar, 2u>{-4.f, 4.f},
0226                         std::array<scalar, 2u>{-traccc::constant<scalar>::pi,
0227                                                traccc::constant<scalar>::pi},
0228                         traccc::muon<scalar>(), 10000, 1, true)));