tests/cpu/test_triplet_fitter_telescope.cpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2022-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/triplet_fitting_algorithm.hpp"
0011 #include "traccc/io/detector.hpp"
0012 #include "traccc/io/read_detector.hpp"
0013 #include "traccc/io/utils.hpp"
0014 #include "traccc/resolution/fitting_performance_writer.hpp"
0015 #include "traccc/simulation/event_generators.hpp"
0016 #include "traccc/simulation/simulator.hpp"
0017 #include "traccc/utils/ranges.hpp"
0018 #include "traccc/utils/seed_generator.hpp"
0019
0020 // Test include(s).
0021 #include "tests/triplet_fitting_telescope_test.hpp"
0022
0023 // VecMem include(s).
0024 #include <vecmem/memory/host_memory_resource.hpp>
0025 #include <vecmem/utils/copy.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
0036 TEST_P(TripletFittingTelescopeTests, 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 detray::pdg_particle<scalar> ptc = std::get<6>(GetParam());
0046   const unsigned int n_truth_tracks = std::get<7>(GetParam());
0047   const unsigned int n_events = std::get<8>(GetParam());
0048   const bool random_charge = std::get<9>(GetParam());
0049
0050   // Performance writer
0051   traccc::fitting_performance_writer::config fit_writer_cfg;
0052   fit_writer_cfg.file_path = "performance_track_fitting_" + name + ".root";
0053   traccc::fitting_performance_writer fit_performance_writer(
0054       fit_writer_cfg, traccc::getDefaultLogger("FittingPerformanceWriter",
0055                                                traccc::Logging::Level::INFO));
0056
0057   /*****************************
0058    * Build a telescope geometry
0059    *****************************/
0060
0061   // Memory resources used by the application.
0062   vecmem::host_memory_resource host_mr;
0063   // Copy obejct
0064   vecmem::copy copy;
0065
0066   // Read back detector file
0067   const std::string path = name + "/";
0068
0069   traccc::host_detector detector;
0070   traccc::io::read_detector(
0071       detector, host_mr,
0072       std::filesystem::absolute(
0073           std::filesystem::path(path + "telescope_detector_geometry.json"))
0074           .native(),
0075       std::filesystem::absolute(
0076           std::filesystem::path(path +
0077                                 "telescope_detector_homogeneous_material.json"))
0078           .native());
0079   auto field = traccc::construct_const_bfield(std::get<13>(GetParam()));
0080
0081   /***************************
0082    * Generate simulation data
0083    ***************************/
0084
0085   // Track generator
0086   using generator_type =
0087       detray::random_track_generator<traccc::free_track_parameters<>,
0088                                      uniform_gen_t>;
0089   generator_type::configuration gen_cfg{};
0090   gen_cfg.n_tracks(n_truth_tracks);
0091   gen_cfg.origin(origin);
0092   gen_cfg.origin_stddev(origin_stddev);
0093   gen_cfg.phi_range(phi_range[0], phi_range[1]);
0094   gen_cfg.theta_range(theta_range[0], theta_range[1]);
0095   gen_cfg.mom_range(mom_range[0], mom_range[1]);
0096   gen_cfg.randomize_charge(random_charge);
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<detector_traits>(),
0116       field.as_field<traccc::const_bfield_backend_t<traccc::scalar>>(),
0117       std::move(generator), std::move(smearer_writer_cfg), full_path);
0118   sim.run();
0119
0120   /***************
0121    * Run fitting
0122    ***************/
0123
0124   // Seed generator
0125   seed_generator<host_detector_type> sg(detector.as<detector_traits>(),
0126                                         seed_cfg);
0127
0128   // Fitting algorithm object
0129   traccc::fitting_config fit_cfg;
0130   fit_cfg.ptc_hypothesis = ptc;
0131   traccc::host::triplet_fitting_algorithm fitting(fit_cfg, host_mr, copy);
0132
0133   // Iterate over events
0134   for (std::size_t i_evt = 0; i_evt < n_events; i_evt++) {
0135     // Event map
0136     traccc::event_data evt_data(path, i_evt, host_mr);
0137     // Truth Track Candidates
0138     traccc::edm::measurement_collection::host measurements(host_mr);
0139     traccc::edm::track_container<traccc::default_algebra>::host
0140         track_candidates{host_mr};
0141     evt_data.generate_truth_candidates(track_candidates, measurements, sg,
0142                                        host_mr);
0143     track_candidates.measurements = vecmem::get_data(measurements);
0144
0145     // n_trakcs = 100
0146     ASSERT_EQ(track_candidates.tracks.size(), n_truth_tracks);
0147
0148     // Run fitting
0149     auto track_states = fitting(
0150         detector, field,
0151         traccc::edm::track_container<traccc::default_algebra>::const_data(
0152             track_candidates));
0153
0154     // Iterator over tracks
0155     const std::size_t n_tracks = track_states.tracks.size();
0156     const std::size_t n_fitted_tracks =
0157         count_successfully_fitted_tracks(track_states.tracks);
0158
0159     // n_trakcs = 100
0160     ASSERT_EQ(n_tracks, n_truth_tracks);
0161     ASSERT_EQ(n_tracks, n_fitted_tracks);
0162
0163     for (std::size_t i_trk = 0; i_trk < n_tracks; i_trk++) {
0164       EXPECT_EQ(track_states.tracks.at(i_trk).fit_outcome(),
0165                 traccc::track_fit_outcome::SUCCESS);
0166
0167       consistency_tests(track_states.tracks.at(i_trk), track_states.states);
0168
0169       ndf_tests(track_states.tracks.at(i_trk), track_states.states,
0170                 measurements);
0171
0172       ASSERT_EQ(track_states.tracks.at(i_trk).nholes(), 0u);
0173
0174       fit_performance_writer.write(track_states.tracks.at(i_trk),
0175                                    track_states.states, measurements,
0176                                    detector.as<detector_traits>(), evt_data);
0177     }
0178   }
0179
0180   fit_performance_writer.finalize();
0181
0182   /********************
0183    * Pull value test
0184    ********************/
0185
0186   static const std::vector<std::string> pull_names{
0187       "pull_d0", "pull_z0", "pull_phi", "pull_theta", "pull_qop"};
0188   pull_value_tests(fit_writer_cfg.file_path, pull_names);
0189
0190   /********************
0191    * P-value test
0192    ********************/
0193
0194   p_value_tests(fit_writer_cfg.file_path);
0195
0196   /********************
0197    * Success rate test
0198    ********************/
0199
0200   float success_rate = static_cast<float>(n_success) /
0201                        static_cast<float>(n_truth_tracks * n_events);
0202
0203   ASSERT_FLOAT_EQ(success_rate, 1.00f);
0204 }
0205
0206 /// Test parameters:
0207 /// (1) name
0208 /// (2) origin
0209 /// (3) origin stddev
0210 /// (4) momentum range
0211 /// (5) eta range
0212 /// (6) phi range
0213 /// (7) particle type
0214 /// (8) number of tracks per event
0215 /// (9) number of events
0216 /// (10) random charge
0217 /// (11) offset from origin of the first plane in mm
0218 /// (12) Number of planes
0219 /// (13) Spacing between planes in mm
0220 /// (14) Magnetic field
0221
0222 INSTANTIATE_TEST_SUITE_P(
0223     DISABLED_TripletFitTelescopeValidation0, TripletFittingTelescopeTests,
0224     ::testing::Values(std::make_tuple(
0225         "telescope_1_GeV_0_phi_muon", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0226         std::array<scalar, 3u>{0.f, 0.f, 0.f}, std::array<scalar, 2u>{1.f, 1.f},
0227         std::array<scalar, 2u>{0.f, 0.f}, std::array<scalar, 2u>{0.f, 0.f},
0228         detray::muon<scalar>(), 100, 100, false, 20.f, 20u, 20.f,
0229         vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0230
0231 INSTANTIATE_TEST_SUITE_P(
0232     DISABLED_TripletFitTelescopeValidation1, TripletFittingTelescopeTests,
0233     ::testing::Values(std::make_tuple(
0234         "telescope_10_GeV_0_phi_muon", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0235         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0236         std::array<scalar, 2u>{10.f, 10.f}, std::array<scalar, 2u>{0.f, 0.f},
0237         std::array<scalar, 2u>{0.f, 0.f}, detray::muon<scalar>(), 100, 100,
0238         false, 20.f, 9u, 20.f, vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0239
0240 INSTANTIATE_TEST_SUITE_P(
0241     DISABLED_TripletFitTelescopeValidation2, TripletFittingTelescopeTests,
0242     ::testing::Values(std::make_tuple(
0243         "telescope_100_GeV_0_phi_muon", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0244         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0245         std::array<scalar, 2u>{100.f, 100.f}, std::array<scalar, 2u>{0.f, 0.f},
0246         std::array<scalar, 2u>{0.f, 0.f}, detray::muon<scalar>(), 100, 100,
0247         false, 20.f, 9u, 20.f, vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0248
0249 INSTANTIATE_TEST_SUITE_P(
0250     DISABLED_TripletFitTelescopeValidation3, TripletFittingTelescopeTests,
0251     ::testing::Values(std::make_tuple(
0252         "telescope_1_GeV_0_phi_anti_muon",
0253         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0254         std::array<scalar, 3u>{0.f, 0.f, 0.f}, std::array<scalar, 2u>{1.f, 1.f},
0255         std::array<scalar, 2u>{0.f, 0.f}, std::array<scalar, 2u>{0.f, 0.f},
0256         detray::antimuon<scalar>(), 100, 100, false, 20.f, 9u, 20.f,
0257         vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0258
0259 INSTANTIATE_TEST_SUITE_P(
0260     DISABLED_TripletFitTelescopeValidation4, TripletFittingTelescopeTests,
0261     ::testing::Values(std::make_tuple(
0262         "telescope_1_GeV_0_random_charge",
0263         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0264         std::array<scalar, 3u>{0.f, 0.f, 0.f}, std::array<scalar, 2u>{1.f, 1.f},
0265         std::array<scalar, 2u>{0.f, 0.f}, std::array<scalar, 2u>{0.f, 0.f},
0266         detray::antimuon<scalar>(), 100, 100, true, 20.f, 9u, 20.f,
0267         vector3{0, 0, 2 * traccc::unit<scalar>::T})));