tests/cuda/test_clusterization.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 "tests/cca_test.hpp"
0010 #include "traccc/clusterization/clustering_config.hpp"
0011 #include "traccc/cuda/clusterization/clusterization_algorithm.hpp"
0012 #include "traccc/definitions/common.hpp"
0013 #include "traccc/geometry/detector_design_description.hpp"
0014 #include "traccc/performance/collection_comparator.hpp"
0015
0016 // VecMem include(s).
0017 #include <vecmem/memory/cuda/managed_memory_resource.hpp>
0018 #include <vecmem/utils/cuda/async_copy.hpp>
0019 #include <vecmem/utils/cuda/stream_wrapper.hpp>
0020
0021 // GTest include(s).
0022 #include <gtest/gtest.h>
0023
0024 using namespace traccc;
0025
0026 namespace {
0027 void run_clustering_test(
0028     const traccc::edm::silicon_cell_collection::host& cells,
0029     const edm::measurement_collection::host& references,
0030     const std::vector<std::vector<unsigned int>>& reference_disjoint_set,
0031     auto& mng_mr, const auto& cfg) {
0032   traccc::memory_resource mr{mng_mr};
0033
0034   // Cuda stream
0035   vecmem::cuda::stream_wrapper vecmem_stream;
0036   traccc::cuda::stream_wrapper stream{vecmem_stream.stream()};
0037
0038   // Cuda copy objects
0039   vecmem::cuda::async_copy copy{stream.cudaStream()};
0040
0041   // Create a dummy detector description.
0042   traccc::detector_design_description::host det_desc{mng_mr};
0043   traccc::detector_conditions_description::host det_cond{mng_mr};
0044   det_desc.resize(1u);
0045   det_cond.resize(1u);
0046   det_desc.bin_edges_x()[0] = {0.f, 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f};
0047   det_desc.bin_edges_y()[0] = {0.f, 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f};
0048   det_desc.dimensions()[0] = 2;
0049   det_cond.geometry_id()[0] = detray::geometry::identifier{0u};
0050   det_cond.measurement_translation()[0] = {0.f, 0.f};
0051
0052   // Run Clusterization
0053   traccc::cuda::clusterization_algorithm ca_cuda(mr, copy, stream, cfg);
0054
0055   auto measurements_buffer =
0056       ca_cuda(vecmem::get_data(cells), vecmem::get_data(det_desc),
0057               vecmem::get_data(det_cond));
0058   auto [measurements_buffer_wdjs, disjoint_set] = ca_cuda(
0059       vecmem::get_data(cells), vecmem::get_data(det_desc),
0060       vecmem::get_data(det_cond), device::clustering_keep_disjoint_set{});
0061   edm::measurement_collection::const_device measurements(measurements_buffer);
0062   edm::measurement_collection::const_device measurements_wdjs(
0063       measurements_buffer_wdjs);
0064
0065   // Check the results
0066   ASSERT_EQ(copy.get_size(measurements_buffer), references.size());
0067   ASSERT_EQ(copy.get_size(measurements_buffer_wdjs), references.size());
0068
0069   auto check_all_matched = [&references](const auto& meas) {
0070     for (unsigned int i = 0; i < meas.size(); ++i) {
0071       const auto test = meas.at(i);
0072       // 0.01 % uncertainty
0073       auto iso = traccc::details::is_same_object<
0074           edm::measurement_collection::const_device::object_type>(test,
0075                                                                   0.0001f);
0076       bool matched = false;
0077
0078       for (std::size_t j = 0; j < references.size(); ++j) {
0079         const auto ref = references.at(j);
0080         if (iso(ref)) {
0081           matched = true;
0082           break;
0083         }
0084       }
0085
0086       ASSERT_TRUE(matched);
0087     }
0088   };
0089
0090   check_all_matched(measurements);
0091   check_all_matched(measurements_wdjs);
0092
0093   edm::silicon_cluster_collection::const_view disjoint_set_view{disjoint_set};
0094   edm::silicon_cluster_collection::const_device disjoint_set_device{
0095       disjoint_set_view};
0096
0097   ASSERT_EQ(reference_disjoint_set.size(), disjoint_set_device.size());
0098
0099   auto disjoint_set_matched = [&disjoint_set_device](const auto& ref) {
0100     std::vector<unsigned int> reference_set = ref;
0101     std::sort(reference_set.begin(), reference_set.end());
0102
0103     for (unsigned int i = 0; i < disjoint_set_device.size(); ++i) {
0104       std::vector<unsigned int> found_set;
0105       for (unsigned int j = 0;
0106            j < disjoint_set_device.cell_indices().at(i).size(); ++j) {
0107         found_set.push_back(disjoint_set_device.cell_indices().at(i).at(j));
0108       }
0109       std::sort(found_set.begin(), found_set.end());
0110
0111       if (reference_set.size() != found_set.size()) {
0112         continue;
0113       }
0114
0115       bool equal = true;
0116       for (unsigned int j = 0; j < reference_set.size(); ++j) {
0117         if (reference_set.at(j) != found_set.at(j)) {
0118           equal = false;
0119           break;
0120         }
0121       }
0122
0123       if (equal) {
0124         return true;
0125       }
0126     }
0127
0128     return false;
0129   };
0130
0131   for (const auto& i : reference_disjoint_set) {
0132     ASSERT_TRUE(disjoint_set_matched(i));
0133   }
0134 }
0135 }  // namespace
0136
0137 TEST(CUDAClustering, SingleModule) {
0138   // Memory resource used by the EDM.
0139   vecmem::cuda::managed_memory_resource mng_mr;
0140
0141   // Create cell collection
0142   traccc::edm::silicon_cell_collection::host cells{mng_mr};
0143   cells.reserve(8u);
0144   cells.push_back({1u, 2u, 1.f, 0.f, 0u});
0145   cells.push_back({2u, 2u, 1.f, 0.f, 0u});
0146   cells.push_back({3u, 2u, 1.f, 0.f, 0u});
0147   cells.push_back({6u, 4u, 1.f, 0.f, 0u});
0148   cells.push_back({5u, 5u, 1.f, 0.f, 0u});
0149   cells.push_back({6u, 5u, 1.f, 0.f, 0u});
0150   cells.push_back({7u, 5u, 1.f, 0.f, 0u});
0151   cells.push_back({6u, 6u, 1.f, 0.f, 0u});
0152
0153   edm::measurement_collection::host references{mng_mr};
0154   references.push_back({{2.5f, 2.5f},
0155                         {0.75f, 0.0833333f},
0156                         2u,
0157                         0.f,
0158                         0.f,
0159                         0u,
0160                         detray::geometry::identifier{0u},
0161                         {1u, 1u},
0162                         0u});
0163   references.push_back({{6.5f, 5.5f},
0164                         {0.483333f, 0.483333f},
0165                         2u,
0166                         0.f,
0167                         0.f,
0168                         0u,
0169                         detray::geometry::identifier{0u},
0170                         {1u, 1u},
0171                         1u});
0172
0173   std::vector<std::vector<unsigned int>> reference_disjoint_set{
0174       {0, 1, 2}, {3, 4, 5, 6, 7}};
0175
0176   auto cfg = default_ccl_test_config();
0177
0178   run_clustering_test(cells, references, reference_disjoint_set, mng_mr, cfg);
0179 }
0180
0181 TEST(CUDAClustering, SingleModuleUnsorted) {
0182   // Memory resource used by the EDM.
0183   vecmem::cuda::managed_memory_resource mng_mr;
0184
0185   // Create cell collection
0186   traccc::edm::silicon_cell_collection::host cells{mng_mr};
0187   cells.reserve(8u);
0188   cells.push_back({7u, 5u, 1.f, 0.f, 0u});
0189   cells.push_back({3u, 2u, 1.f, 0.f, 0u});
0190   cells.push_back({5u, 5u, 1.f, 0.f, 0u});
0191   cells.push_back({6u, 5u, 1.f, 0.f, 0u});
0192   cells.push_back({2u, 2u, 1.f, 0.f, 0u});
0193   cells.push_back({1u, 2u, 1.f, 0.f, 0u});
0194   cells.push_back({6u, 6u, 1.f, 0.f, 0u});
0195   cells.push_back({6u, 4u, 1.f, 0.f, 0u});
0196
0197   edm::measurement_collection::host references{mng_mr};
0198   references.push_back({{2.5f, 2.5f},
0199                         {0.75f, 0.0833333f},
0200                         2u,
0201                         0.f,
0202                         0.f,
0203                         0u,
0204                         detray::geometry::identifier{0u},
0205                         {1u, 1u},
0206                         0u});
0207   references.push_back({{6.5f, 5.5f},
0208                         {0.483333f, 0.483333f},
0209                         2u,
0210                         0.f,
0211                         0.f,
0212                         0u,
0213                         detray::geometry::identifier{0u},
0214                         {1u, 1u},
0215                         1u});
0216
0217   std::vector<std::vector<unsigned int>> reference_disjoint_set{
0218       {5, 4, 1}, {7, 2, 3, 0, 6}};
0219
0220   auto cfg = default_ccl_test_config();
0221   cfg.sort_cells = true;
0222
0223   run_clustering_test(cells, references, reference_disjoint_set, mng_mr, cfg);
0224 }