tests/cpu/test_ckf_combinatorics_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/bfield/magnetic_field.hpp"
0011 #include "traccc/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/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
0027 // GTest include(s).
0028 #include <gtest/gtest.h>
0029
0030 // System include(s).
0031 #include <filesystem>
0032 #include <string>
0033
0034 using namespace traccc;
0035 // This defines the local frame test suite
0036 TEST_P(CpuCkfCombinatoricsTelescopeTests, Run) {
0037   // Get the parameters
0038   const std::string name = std::get<0>(GetParam());
0039   const std::array<scalar, 3u> origin = std::get<1>(GetParam());
0040   const std::array<scalar, 3u> origin_stddev = std::get<2>(GetParam());
0041   const std::array<scalar, 2u> mom_range = std::get<3>(GetParam());
0042   const std::array<scalar, 2u> eta_range = std::get<4>(GetParam());
0043   const std::array<scalar, 2u> theta_range = eta_to_theta_range(eta_range);
0044   const std::array<scalar, 2u> phi_range = std::get<5>(GetParam());
0045   const unsigned int n_truth_tracks = std::get<7>(GetParam());
0046   const unsigned int n_events = std::get<8>(GetParam());
0047   const bool random_charge = std::get<9>(GetParam());
0048
0049   /*****************************
0050    * Build a telescope geometry
0051    *****************************/
0052
0053   // Memory resources used by the application.
0054   vecmem::host_memory_resource host_mr;
0055
0056   // Read back detector file
0057   const std::string path = name + "/";
0058   traccc::host_detector detector;
0059   traccc::io::read_detector(
0060       detector, host_mr,
0061       std::filesystem::absolute(
0062           std::filesystem::path(path + "telescope_detector_geometry.json"))
0063           .native(),
0064       std::filesystem::absolute(
0065           std::filesystem::path(path +
0066                                 "telescope_detector_homogeneous_material.json"))
0067           .native());
0068
0069   const auto field = traccc::construct_const_bfield(std::get<13>(GetParam()));
0070
0071   /***************************
0072    * Generate simulation data
0073    ***************************/
0074
0075   // Track generator
0076   using generator_type =
0077       detray::random_track_generator<traccc::free_track_parameters<>,
0078                                      uniform_gen_t>;
0079   generator_type::configuration gen_cfg{};
0080   gen_cfg.n_tracks(n_truth_tracks);
0081   gen_cfg.origin(origin);
0082   gen_cfg.origin_stddev(origin_stddev);
0083   gen_cfg.phi_range(phi_range[0], phi_range[1]);
0084   gen_cfg.theta_range(theta_range[0], theta_range[1]);
0085   gen_cfg.mom_range(mom_range[0], mom_range[1]);
0086   gen_cfg.randomize_charge(random_charge);
0087   generator_type generator(gen_cfg);
0088
0089   // Smearing value for measurements
0090   traccc::measurement_smearer<traccc::default_algebra> meas_smearer(
0091       smearing[0], smearing[1]);
0092
0093   using writer_type = traccc::smearing_writer<
0094       traccc::measurement_smearer<traccc::default_algebra>>;
0095
0096   typename writer_type::config smearer_writer_cfg{meas_smearer};
0097   traccc::seed_generator<host_detector_type>::config seed_cfg{};
0098   seed_cfg.initial_sigmas = stddevs;
0099
0100   // Run simulator
0101   const std::string full_path = io::data_directory() + path;
0102   std::filesystem::create_directories(full_path);
0103   auto sim = traccc::simulator<host_detector_type, b_field_t, generator_type,
0104                                writer_type>(
0105       std::get<6>(GetParam()), n_events, detector.as<detector_traits>(),
0106       field.as_field<const_bfield_backend_t<traccc::scalar>>(),
0107       std::move(generator), std::move(smearer_writer_cfg), full_path);
0108   sim.run();
0109
0110   /*****************************
0111    * Do the reconstruction
0112    *****************************/
0113
0114   // Seed generator
0115   seed_generator<host_detector_type> sg(detector.as<detector_traits>(),
0116                                         seed_cfg);
0117
0118   // Finding algorithm configuration
0119   traccc::finding_config cfg_no_limit;
0120   cfg_no_limit.max_num_branches_per_seed =
0121       std::numeric_limits<unsigned int>::max();
0122   cfg_no_limit.max_num_branches_per_surface = 10;
0123   cfg_no_limit.chi2_max = 30.f;
0124   cfg_no_limit.duplicate_removal_minimum_length = 100u;
0125
0126   traccc::finding_config cfg_limit;
0127   cfg_limit.max_num_branches_per_seed = 500;
0128   cfg_limit.max_num_branches_per_surface = 10;
0129   cfg_limit.chi2_max = 30.f;
0130   cfg_limit.duplicate_removal_minimum_length = 100u;
0131
0132   // Finding algorithm object
0133   traccc::host::combinatorial_kalman_filter_algorithm host_finding(cfg_no_limit,
0134                                                                    host_mr);
0135   traccc::host::combinatorial_kalman_filter_algorithm host_finding_limit(
0136       cfg_limit, host_mr);
0137
0138   // Iterate over events
0139   for (std::size_t i_evt = 0; i_evt < n_events; i_evt++) {
0140     // Truth Track Candidates
0141     traccc::event_data evt_data(path, i_evt, host_mr);
0142
0143     traccc::edm::measurement_collection::host truth_measurements{host_mr};
0144     traccc::edm::track_container<traccc::default_algebra>::host
0145         truth_track_candidates{host_mr};
0146     evt_data.generate_truth_candidates(truth_track_candidates,
0147                                        truth_measurements, sg, host_mr);
0148     truth_track_candidates.measurements = vecmem::get_data(truth_measurements);
0149
0150     ASSERT_EQ(truth_track_candidates.tracks.size(), n_truth_tracks);
0151
0152     // Prepare truth seeds
0153     traccc::bound_track_parameters_collection_types::host seeds(&host_mr);
0154     for (unsigned int i_trk = 0; i_trk < n_truth_tracks; i_trk++) {
0155       seeds.push_back(truth_track_candidates.tracks.at(i_trk).params());
0156     }
0157     ASSERT_EQ(seeds.size(), n_truth_tracks);
0158     const traccc::bound_track_parameters_collection_types::const_view
0159         seeds_view = vecmem::get_data(seeds);
0160
0161     // Read measurements
0162     traccc::edm::measurement_collection::host measurements_per_event{host_mr};
0163     traccc::io::read_measurements(measurements_per_event, i_evt, path);
0164     const traccc::edm::measurement_collection::const_view measurements_view =
0165         vecmem::get_data(measurements_per_event);
0166
0167     // Run finding
0168     auto track_candidates =
0169         host_finding(detector, field, measurements_view, seeds_view);
0170
0171     auto track_candidates_limit =
0172         host_finding_limit(detector, field, measurements_view, seeds_view);
0173
0174     // Make sure that the number of found tracks = n_track ^ (n_planes + 1)
0175     ASSERT_TRUE(track_candidates.tracks.size() >
0176                 track_candidates_limit.tracks.size());
0177     ASSERT_EQ(track_candidates.tracks.size(),
0178               std::pow(n_truth_tracks, std::get<11>(GetParam()) + 1));
0179     ASSERT_EQ(track_candidates_limit.tracks.size(),
0180               n_truth_tracks * cfg_limit.max_num_branches_per_seed);
0181   }
0182 }
0183
0184 // Testing two identical tracks
0185 INSTANTIATE_TEST_SUITE_P(
0186     CpuCkfCombinatoricsTelescopeValidation0, CpuCkfCombinatoricsTelescopeTests,
0187     ::testing::Values(std::make_tuple(
0188         "telescope_combinatorics_twin", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0189         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0190         std::array<scalar, 2u>{100.f, 100.f}, std::array<scalar, 2u>{0.f, 0.f},
0191         std::array<scalar, 2u>{0.f, 0.f}, traccc::muon<scalar>(), 2, 1, false,
0192         20.f, 9u, 20.f, vector3{2 * traccc::unit<scalar>::T, 0, 0})));
0193
0194 // Testing three identical tracks
0195 INSTANTIATE_TEST_SUITE_P(
0196     CpuCkfCombinatoricsTelescopeValidation1, CpuCkfCombinatoricsTelescopeTests,
0197     ::testing::Values(std::make_tuple(
0198         "telescope_combinatorics_trio", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0199         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0200         std::array<scalar, 2u>{100.f, 100.f}, std::array<scalar, 2u>{0.f, 0.f},
0201         std::array<scalar, 2u>{0.f, 0.f}, traccc::muon<scalar>(), 3, 1, false,
0202         20.f, 9u, 20.f, vector3{2 * traccc::unit<scalar>::T, 0, 0})));