Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-07-26 08:22:24 

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/kalman_fitting_algorithm.hpp"
0011 #include "traccc/io/read_detector.hpp"
0012 #include "traccc/io/utils.hpp"
0013 #include "traccc/resolution/fitting_performance_writer.hpp"
0014 #include "traccc/simulation/event_generators.hpp"
0015 #include "traccc/simulation/simulator.hpp"
0016 #include "traccc/utils/ranges.hpp"
0017 #include "traccc/utils/seed_generator.hpp"
0018 
0019 // Test include(s).
0020 #include "tests/kalman_fitting_telescope_test.hpp"
0021 
0022 // VecMem include(s).
0023 #include <vecmem/memory/host_memory_resource.hpp>
0024 #include <vecmem/utils/copy.hpp>
0025 
0026 // GTest include(s).
0027 #include <gtest/gtest.h>
0028 
0029 // System include(s).
0030 #include <filesystem>
0031 #include <string>
0032 
0033 using namespace traccc;
0034 
0035 TEST_P(KalmanFittingTelescopeTests, Run) {
0036   // Get the parameters
0037   const std::string name = std::get<0>(GetParam());
0038   const std::array<scalar, 3u> origin = std::get<1>(GetParam());
0039   const std::array<scalar, 3u> origin_stddev = std::get<2>(GetParam());
0040   const std::array<scalar, 2u> mom_range = std::get<3>(GetParam());
0041   const std::array<scalar, 2u> eta_range = std::get<4>(GetParam());
0042   const std::array<scalar, 2u> theta_range = eta_to_theta_range(eta_range);
0043   const std::array<scalar, 2u> phi_range = std::get<5>(GetParam());
0044   const traccc::pdg_particle<scalar> ptc = std::get<6>(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   // Performance writer
0050   traccc::fitting_performance_writer::config fit_writer_cfg;
0051   fit_writer_cfg.file_path = "performance_track_fitting_" + name + ".root";
0052   traccc::fitting_performance_writer fit_performance_writer(
0053       fit_writer_cfg, traccc::getDefaultLogger("FittingPerformanceWriter",
0054                                                traccc::Logging::Level::INFO));
0055   /*****************************
0056    * Build a telescope geometry
0057    *****************************/
0058 
0059   // Memory resources used by the application.
0060   vecmem::host_memory_resource host_mr;
0061   // Copy obejct
0062   vecmem::copy copy;
0063 
0064   // Read back detector file
0065   const std::string path = name + "/";
0066 
0067   traccc::host_detector detector;
0068   traccc::io::read_detector(
0069       detector, host_mr,
0070       std::filesystem::absolute(
0071           std::filesystem::path(path + "telescope_detector_geometry.json"))
0072           .native(),
0073       std::filesystem::absolute(
0074           std::filesystem::path(path +
0075                                 "telescope_detector_homogeneous_material.json"))
0076           .native());
0077   auto field = traccc::construct_const_bfield(std::get<13>(GetParam()));
0078 
0079   /***************************
0080    * Generate simulation data
0081    ***************************/
0082 
0083   // Track generator
0084   using generator_type =
0085       detray::random_track_generator<traccc::free_track_parameters<>,
0086                                      uniform_gen_t>;
0087   generator_type::configuration gen_cfg{};
0088   gen_cfg.n_tracks(n_truth_tracks);
0089   gen_cfg.origin(origin);
0090   gen_cfg.origin_stddev(origin_stddev);
0091   gen_cfg.phi_range(phi_range[0], phi_range[1]);
0092   gen_cfg.theta_range(theta_range[0], theta_range[1]);
0093   gen_cfg.mom_range(mom_range[0], mom_range[1]);
0094   gen_cfg.randomize_charge(random_charge);
0095   generator_type generator(gen_cfg);
0096 
0097   // Smearing value for measurements
0098   traccc::measurement_smearer<traccc::default_algebra> meas_smearer(
0099       smearing[0], smearing[1]);
0100 
0101   using writer_type = traccc::smearing_writer<
0102       traccc::measurement_smearer<traccc::default_algebra>>;
0103 
0104   typename writer_type::config smearer_writer_cfg{meas_smearer};
0105   traccc::seed_generator<host_detector_type>::config seed_cfg{};
0106   seed_cfg.initial_sigmas = stddevs;
0107 
0108   // Run simulator
0109   const std::string full_path = io::data_directory() + path;
0110   std::filesystem::create_directories(full_path);
0111   auto sim = traccc::simulator<host_detector_type, b_field_t, generator_type,
0112                                writer_type>(
0113       ptc, n_events, detector.as<detector_traits>(),
0114       field.as_field<traccc::const_bfield_backend_t<traccc::scalar>>(),
0115       std::move(generator), std::move(smearer_writer_cfg), full_path);
0116   sim.run();
0117 
0118   /***************
0119    * Run fitting
0120    ***************/
0121 
0122   // Seed generator
0123   seed_generator<host_detector_type> sg(detector.as<detector_traits>(),
0124                                         seed_cfg);
0125 
0126   // Fitting algorithm object
0127   traccc::fitting_config fit_cfg;
0128   fit_cfg.ptc_hypothesis = ptc;
0129   fit_cfg.min_pT = 100.f * traccc::unit<float>::MeV;
0130   traccc::host::kalman_fitting_algorithm fitting(fit_cfg, host_mr, copy);
0131 
0132   // Iterate over events
0133   for (std::size_t i_evt = 0; i_evt < n_events; i_evt++) {
0134     // Event map
0135     traccc::event_data evt_data(path, i_evt, host_mr);
0136     // Truth Track Candidates
0137     traccc::edm::measurement_collection::host measurements(host_mr);
0138     traccc::edm::track_container<traccc::default_algebra>::host
0139         track_candidates{host_mr};
0140     evt_data.generate_truth_candidates(track_candidates, measurements, sg,
0141                                        host_mr);
0142     track_candidates.measurements = vecmem::get_data(measurements);
0143 
0144     // n_trakcs = 100
0145     ASSERT_EQ(track_candidates.tracks.size(), n_truth_tracks);
0146 
0147     // Run fitting
0148     auto track_states = fitting(
0149         detector, field,
0150         traccc::edm::track_container<traccc::default_algebra>::const_data(
0151             track_candidates));
0152 
0153     // Iterator over tracks
0154     const std::size_t n_tracks = track_states.tracks.size();
0155     const std::size_t n_fitted_tracks =
0156         count_successfully_fitted_tracks(track_states.tracks);
0157 
0158     // n_trakcs = 100
0159     ASSERT_EQ(n_tracks, n_truth_tracks);
0160     ASSERT_EQ(n_tracks, n_fitted_tracks);
0161 
0162     for (std::size_t i_trk = 0; i_trk < n_tracks; i_trk++) {
0163       EXPECT_EQ(track_states.tracks.at(i_trk).fit_outcome(),
0164                 traccc::track_fit_outcome::SUCCESS);
0165 
0166       consistency_tests(track_states.tracks.at(i_trk), track_states.states);
0167 
0168       ndf_tests(track_states.tracks.at(i_trk), track_states.states,
0169                 measurements);
0170 
0171       ASSERT_EQ(track_states.tracks.at(i_trk).nholes(), 0u);
0172 
0173       fit_performance_writer.write(track_states.tracks.at(i_trk),
0174                                    track_states.states, measurements,
0175                                    detector.as<detector_traits>(), evt_data);
0176     }
0177   }
0178 
0179   fit_performance_writer.finalize();
0180 
0181   /********************
0182    * Pull value test
0183    ********************/
0184 
0185   static const std::vector<std::string> pull_names{
0186       "pull_d0", "pull_z0", "pull_phi", "pull_theta", "pull_qop"};
0187   pull_value_tests(fit_writer_cfg.file_path, pull_names);
0188 
0189   /********************
0190    * P-value test
0191    ********************/
0192 
0193   p_value_tests(fit_writer_cfg.file_path);
0194 
0195   /********************
0196    * Success rate test
0197    ********************/
0198 
0199   float success_rate = static_cast<float>(n_success) /
0200                        static_cast<float>(n_truth_tracks * n_events);
0201 
0202   ASSERT_FLOAT_EQ(success_rate, 1.00f);
0203 }
0204 
0205 INSTANTIATE_TEST_SUITE_P(
0206     KalmanFitTelescopeValidation0, KalmanFittingTelescopeTests,
0207     ::testing::Values(std::make_tuple(
0208         "telescope_1_GeV_0_phi_muon", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0209         std::array<scalar, 3u>{0.f, 0.f, 0.f}, std::array<scalar, 2u>{1.f, 1.f},
0210         std::array<scalar, 2u>{0.f, 0.f}, std::array<scalar, 2u>{0.f, 0.f},
0211         traccc::muon<scalar>(), 100, 100, false, 20.f, 20u, 20.f,
0212         vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0213 
0214 INSTANTIATE_TEST_SUITE_P(
0215     KalmanFitTelescopeValidation1, KalmanFittingTelescopeTests,
0216     ::testing::Values(std::make_tuple(
0217         "telescope_10_GeV_0_phi_muon", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0218         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0219         std::array<scalar, 2u>{10.f, 10.f}, std::array<scalar, 2u>{0.f, 0.f},
0220         std::array<scalar, 2u>{0.f, 0.f}, traccc::muon<scalar>(), 100, 100,
0221         false, 20.f, 9u, 20.f, vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0222 
0223 INSTANTIATE_TEST_SUITE_P(
0224     KalmanFitTelescopeValidation2, KalmanFittingTelescopeTests,
0225     ::testing::Values(std::make_tuple(
0226         "telescope_100_GeV_0_phi_muon", std::array<scalar, 3u>{0.f, 0.f, 0.f},
0227         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0228         std::array<scalar, 2u>{100.f, 100.f}, std::array<scalar, 2u>{0.f, 0.f},
0229         std::array<scalar, 2u>{0.f, 0.f}, traccc::muon<scalar>(), 100, 100,
0230         false, 20.f, 9u, 20.f, vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0231 
0232 INSTANTIATE_TEST_SUITE_P(
0233     KalmanFitTelescopeValidation3, KalmanFittingTelescopeTests,
0234     ::testing::Values(std::make_tuple(
0235         "telescope_1_GeV_0_phi_anti_muon",
0236         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0237         std::array<scalar, 3u>{0.f, 0.f, 0.f}, std::array<scalar, 2u>{1.f, 1.f},
0238         std::array<scalar, 2u>{0.f, 0.f}, std::array<scalar, 2u>{0.f, 0.f},
0239         traccc::antimuon<scalar>(), 100, 100, false, 20.f, 9u, 20.f,
0240         vector3{0, 0, 2 * traccc::unit<scalar>::T})));
0241 
0242 INSTANTIATE_TEST_SUITE_P(
0243     KalmanFitTelescopeValidation4, KalmanFittingTelescopeTests,
0244     ::testing::Values(std::make_tuple(
0245         "telescope_1_GeV_0_random_charge",
0246         std::array<scalar, 3u>{0.f, 0.f, 0.f},
0247         std::array<scalar, 3u>{0.f, 0.f, 0.f}, std::array<scalar, 2u>{1.f, 1.f},
0248         std::array<scalar, 2u>{0.f, 0.f}, std::array<scalar, 2u>{0.f, 0.f},
0249         traccc::antimuon<scalar>(), 100, 100, true, 20.f, 9u, 20.f,
0250         vector3{0, 0, 2 * traccc::unit<scalar>::T})));
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!