Core/Clusterization/TimedClusterizationTests.cpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/unit_test.hpp>
0010
0011 #include "Acts/Clusterization/TimedClusterization.hpp"
0012
0013 #include <algorithm>
0014
0015 namespace Acts::Test {
0016
0017 // Define objects
0018 using Identifier = std::size_t;
0019 struct Cell {
0020   Cell(Identifier identifier, int c, int r, double t)
0021       : id(identifier), column(c), row(r), time(t) {}
0022
0023   Identifier id{};
0024   int column{0};
0025   int row{0};
0026   int label{-1};
0027   double time{0.};
0028 };
0029
0030 struct Cluster {
0031   std::vector<Identifier> ids{};
0032 };
0033
0034 using CellCollection = std::vector<Acts::Test::Cell>;
0035 using ClusterCollection = std::vector<Acts::Test::Cluster>;
0036
0037 // Define functions
0038 static inline int getCellRow(const Cell& cell) {
0039   return cell.row;
0040 }
0041
0042 static inline int getCellColumn(const Cell& cell) {
0043   return cell.column;
0044 }
0045
0046 static inline double getCellTime(const Cell& cell) {
0047   return cell.time;
0048 }
0049
0050 static void clusterAddCell(Cluster& cl, const Cell& cell) {
0051   cl.ids.push_back(cell.id);
0052 }
0053
0054 BOOST_AUTO_TEST_CASE(TimedGrid_1D_withtime) {
0055   // 1x10 matrix
0056   /*
0057     X X X Y O X Y Y X X
0058   */
0059   // 6 + 3 cells -> 3 + 2 clusters in total
0060
0061   std::vector<Cell> cells;
0062   // X
0063   cells.emplace_back(0ul, 0, -1, 0);
0064   cells.emplace_back(1ul, 1, -1, 0);
0065   cells.emplace_back(2ul, 2, -1, 0);
0066   cells.emplace_back(3ul, 5, -1, 0);
0067   cells.emplace_back(4ul, 8, -1, 0);
0068   cells.emplace_back(5ul, 9, -1, 0);
0069   // Y
0070   cells.emplace_back(6ul, 3, 0, 1);
0071   cells.emplace_back(7ul, 6, 1, 1);
0072   cells.emplace_back(8ul, 7, 1, 1);
0073
0074   std::vector<std::vector<Identifier>> expectedResults;
0075   expectedResults.push_back({0ul, 1ul, 2ul});
0076   expectedResults.push_back({6ul});
0077   expectedResults.push_back({3ul});
0078   expectedResults.push_back({7ul, 8ul});
0079   expectedResults.push_back({4ul, 5ul});
0080
0081   Acts::Ccl::ClusteringData data;
0082   ClusterCollection clusters;
0083   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 1>(
0084       data, cells, clusters, Acts::Ccl::TimedConnect<Cell, 1>(0.5));
0085
0086   BOOST_CHECK_EQUAL(5ul, clusters.size());
0087
0088   for (std::size_t i(0); i < clusters.size(); ++i) {
0089     std::vector<Identifier>& timedIds = clusters[i].ids;
0090     const std::vector<Identifier>& expected = expectedResults[i];
0091     std::ranges::sort(timedIds);
0092     BOOST_CHECK_EQUAL(timedIds.size(), expected.size());
0093
0094     for (std::size_t j(0); j < timedIds.size(); ++j) {
0095       BOOST_CHECK_EQUAL(timedIds[j], expected[j]);
0096     }
0097   }
0098 }
0099
0100 BOOST_AUTO_TEST_CASE(TimedGrid_2D_notime) {
0101   // 4x4 matrix
0102   /*
0103     X O O X
0104     O O O X
0105     X X O O
0106     X O O X
0107   */
0108   // 7 cells -> 4 clusters in total
0109
0110   std::vector<Cell> cells;
0111   cells.emplace_back(0ul, 0, 0, 0);
0112   cells.emplace_back(1ul, 3, 0, 0);
0113   cells.emplace_back(2ul, 3, 1, 0);
0114   cells.emplace_back(3ul, 0, 2, 0);
0115   cells.emplace_back(4ul, 1, 2, 0);
0116   cells.emplace_back(5ul, 0, 3, 0);
0117   cells.emplace_back(6ul, 3, 3, 0);
0118
0119   std::vector<std::vector<Identifier>> expectedResults;
0120   expectedResults.push_back({0ul});
0121   expectedResults.push_back({3ul, 4ul, 5ul});
0122   expectedResults.push_back({1ul, 2ul});
0123   expectedResults.push_back({6ul});
0124
0125   Acts::Ccl::ClusteringData data;
0126   ClusterCollection clusters;
0127   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>(
0128       data, cells, clusters,
0129       Acts::Ccl::TimedConnect<Cell, 2>(std::numeric_limits<double>::max()));
0130
0131   BOOST_CHECK_EQUAL(4ul, clusters.size());
0132
0133   // Compare against default connect (only space)
0134   data.clear();
0135   ClusterCollection defaultClusters;
0136   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>(
0137       data, cells, defaultClusters, Acts::Ccl::DefaultConnect<Cell, 2>());
0138
0139   BOOST_CHECK_EQUAL(4ul, defaultClusters.size());
0140   BOOST_CHECK_EQUAL(defaultClusters.size(), expectedResults.size());
0141
0142   std::vector<std::size_t> sizes{1, 3, 2, 1};
0143   for (std::size_t i(0); i < clusters.size(); ++i) {
0144     std::vector<Identifier>& timedIds = clusters[i].ids;
0145     std::vector<Identifier>& defaultIds = defaultClusters[i].ids;
0146     const std::vector<Identifier>& expected = expectedResults[i];
0147     BOOST_CHECK_EQUAL(timedIds.size(), defaultIds.size());
0148     BOOST_CHECK_EQUAL(timedIds.size(), sizes[i]);
0149     BOOST_CHECK_EQUAL(timedIds.size(), expected.size());
0150
0151     std::ranges::sort(timedIds);
0152     std::ranges::sort(defaultIds);
0153     for (std::size_t j(0); j < timedIds.size(); ++j) {
0154       BOOST_CHECK_EQUAL(timedIds[j], defaultIds[j]);
0155       BOOST_CHECK_EQUAL(timedIds[j], expected[j]);
0156     }
0157   }
0158 }
0159
0160 BOOST_AUTO_TEST_CASE(TimedGrid_2D_withtime) {
0161   // 4x4 matrix
0162   /*
0163     X Y O X
0164     O Y Y X
0165     X X Z Z
0166     X O O X
0167   */
0168   // 7 + 3 + 2 cells -> 4 + 1 + 1 clusters in total
0169
0170   std::vector<Cell> cells;
0171   // X
0172   cells.emplace_back(0ul, 0, 0, 0);
0173   cells.emplace_back(1ul, 3, 0, 0);
0174   cells.emplace_back(2ul, 3, 1, 0);
0175   cells.emplace_back(3ul, 0, 2, 0);
0176   cells.emplace_back(4ul, 1, 2, 0);
0177   cells.emplace_back(5ul, 0, 3, 0);
0178   cells.emplace_back(6ul, 3, 3, 0);
0179   // Y
0180   cells.emplace_back(7ul, 1, 0, 1);
0181   cells.emplace_back(8ul, 1, 1, 1);
0182   cells.emplace_back(9ul, 2, 1, 1);
0183   // Z
0184   cells.emplace_back(10ul, 2, 2, 2);
0185   cells.emplace_back(11ul, 3, 2, 2);
0186
0187   std::vector<std::vector<Identifier>> expectedResults;
0188   expectedResults.push_back({0ul});
0189   expectedResults.push_back({3ul, 4ul, 5ul});
0190   expectedResults.push_back({7ul, 8ul, 9ul});
0191   expectedResults.push_back({10ul, 11ul});
0192   expectedResults.push_back({1ul, 2ul});
0193   expectedResults.push_back({6ul});
0194
0195   Acts::Ccl::ClusteringData data;
0196   ClusterCollection clusters;
0197   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>(
0198       data, cells, clusters, Acts::Ccl::TimedConnect<Cell, 2>(0.5));
0199
0200   BOOST_CHECK_EQUAL(6ul, clusters.size());
0201
0202   std::vector<std::size_t> sizes{1, 3, 3, 2, 2, 1};
0203   for (std::size_t i(0); i < clusters.size(); ++i) {
0204     std::vector<Identifier>& timedIds = clusters[i].ids;
0205     BOOST_CHECK_EQUAL(timedIds.size(), sizes[i]);
0206     std::ranges::sort(timedIds);
0207
0208     const std::vector<Identifier>& expected = expectedResults[i];
0209     BOOST_CHECK_EQUAL(timedIds.size(), expected.size());
0210
0211     for (std::size_t j(0); j < timedIds.size(); ++j) {
0212       BOOST_CHECK_EQUAL(timedIds[j], expected[j]);
0213     }
0214   }
0215 }
0216
0217 BOOST_AUTO_TEST_CASE(TimedGrid_2D_noTollerance) {
0218   // 4x4 matrix
0219   /*
0220     X O O X
0221     O O O X
0222     X X O O
0223     X O O X
0224    */
0225   // 7 cells -> 7 clusters in total
0226   // since time requirement will never be satisfied
0227
0228   std::vector<Cell> cells;
0229   cells.emplace_back(0ul, 0, 0, 0);
0230   cells.emplace_back(1ul, 3, 0, 0);
0231   cells.emplace_back(2ul, 3, 1, 0);
0232   cells.emplace_back(3ul, 0, 2, 0);
0233   cells.emplace_back(4ul, 1, 2, 0);
0234   cells.emplace_back(5ul, 0, 3, 0);
0235   cells.emplace_back(6ul, 3, 3, 0);
0236
0237   std::vector<std::vector<Identifier>> expectedResults;
0238   expectedResults.push_back({0ul});
0239   expectedResults.push_back({3ul});
0240   expectedResults.push_back({5ul});
0241   expectedResults.push_back({4ul});
0242   expectedResults.push_back({1ul});
0243   expectedResults.push_back({2ul});
0244   expectedResults.push_back({6ul});
0245
0246   Acts::Ccl::ClusteringData data;
0247   ClusterCollection clusters;
0248   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>(
0249       data, cells, clusters, Acts::Ccl::TimedConnect<Cell, 2>(0.));
0250
0251   BOOST_CHECK_EQUAL(7ul, clusters.size());
0252
0253   for (std::size_t i(0); i < clusters.size(); ++i) {
0254     std::vector<Identifier>& timedIds = clusters[i].ids;
0255     const std::vector<Identifier>& expected = expectedResults[i];
0256
0257     BOOST_CHECK_EQUAL(timedIds.size(), 1);
0258     BOOST_CHECK_EQUAL(timedIds.size(), expected.size());
0259     BOOST_CHECK_EQUAL(timedIds[0], expected[0]);
0260   }
0261 }
0262
0263 }  // namespace Acts::Test