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 using namespace Acts;
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<Cell>;
0035 using ClusterCollection = std::vector<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_SUITE(ClusterizationSuite)
0055
0056 BOOST_AUTO_TEST_CASE(TimedGrid_1D_withtime) {
0057   // 1x10 matrix
0058   /*
0059     X X X Y O X Y Y X X
0060   */
0061   // 6 + 3 cells -> 3 + 2 clusters in total
0062
0063   std::vector<Cell> cells;
0064   // X
0065   cells.emplace_back(0ul, 0, -1, 0);
0066   cells.emplace_back(1ul, 1, -1, 0);
0067   cells.emplace_back(2ul, 2, -1, 0);
0068   cells.emplace_back(3ul, 5, -1, 0);
0069   cells.emplace_back(4ul, 8, -1, 0);
0070   cells.emplace_back(5ul, 9, -1, 0);
0071   // Y
0072   cells.emplace_back(6ul, 3, 0, 1);
0073   cells.emplace_back(7ul, 6, 1, 1);
0074   cells.emplace_back(8ul, 7, 1, 1);
0075
0076   std::vector<std::vector<Identifier>> expectedResults;
0077   expectedResults.push_back({0ul, 1ul, 2ul});
0078   expectedResults.push_back({6ul});
0079   expectedResults.push_back({3ul});
0080   expectedResults.push_back({7ul, 8ul});
0081   expectedResults.push_back({4ul, 5ul});
0082
0083   Acts::Ccl::ClusteringData data;
0084   ClusterCollection clusters;
0085   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 1>(
0086       data, cells, clusters, Acts::Ccl::TimedConnect<Cell, 1>(0.5));
0087
0088   BOOST_CHECK_EQUAL(5ul, clusters.size());
0089
0090   for (std::size_t i(0); i < clusters.size(); ++i) {
0091     std::vector<Identifier>& timedIds = clusters[i].ids;
0092     const std::vector<Identifier>& expected = expectedResults[i];
0093     std::ranges::sort(timedIds);
0094     BOOST_CHECK_EQUAL(timedIds.size(), expected.size());
0095
0096     for (std::size_t j(0); j < timedIds.size(); ++j) {
0097       BOOST_CHECK_EQUAL(timedIds[j], expected[j]);
0098     }
0099   }
0100 }
0101
0102 BOOST_AUTO_TEST_CASE(TimedGrid_2D_notime) {
0103   // 4x4 matrix
0104   /*
0105     X O O X
0106     O O O X
0107     X X O O
0108     X O O X
0109   */
0110   // 7 cells -> 4 clusters in total
0111
0112   std::vector<Cell> cells;
0113   cells.emplace_back(0ul, 0, 0, 0);
0114   cells.emplace_back(1ul, 3, 0, 0);
0115   cells.emplace_back(2ul, 3, 1, 0);
0116   cells.emplace_back(3ul, 0, 2, 0);
0117   cells.emplace_back(4ul, 1, 2, 0);
0118   cells.emplace_back(5ul, 0, 3, 0);
0119   cells.emplace_back(6ul, 3, 3, 0);
0120
0121   std::vector<std::vector<Identifier>> expectedResults;
0122   expectedResults.push_back({0ul});
0123   expectedResults.push_back({3ul, 4ul, 5ul});
0124   expectedResults.push_back({1ul, 2ul});
0125   expectedResults.push_back({6ul});
0126
0127   Acts::Ccl::ClusteringData data;
0128   ClusterCollection clusters;
0129   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>(
0130       data, cells, clusters,
0131       Acts::Ccl::TimedConnect<Cell, 2>(std::numeric_limits<double>::max()));
0132
0133   BOOST_CHECK_EQUAL(4ul, clusters.size());
0134
0135   // Compare against default connect (only space)
0136   data.clear();
0137   ClusterCollection defaultClusters;
0138   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>(
0139       data, cells, defaultClusters, Acts::Ccl::DefaultConnect<Cell, 2>());
0140
0141   BOOST_CHECK_EQUAL(4ul, defaultClusters.size());
0142   BOOST_CHECK_EQUAL(defaultClusters.size(), expectedResults.size());
0143
0144   std::vector<std::size_t> sizes{1, 3, 2, 1};
0145   for (std::size_t i(0); i < clusters.size(); ++i) {
0146     std::vector<Identifier>& timedIds = clusters[i].ids;
0147     std::vector<Identifier>& defaultIds = defaultClusters[i].ids;
0148     const std::vector<Identifier>& expected = expectedResults[i];
0149     BOOST_CHECK_EQUAL(timedIds.size(), defaultIds.size());
0150     BOOST_CHECK_EQUAL(timedIds.size(), sizes[i]);
0151     BOOST_CHECK_EQUAL(timedIds.size(), expected.size());
0152
0153     std::ranges::sort(timedIds);
0154     std::ranges::sort(defaultIds);
0155     for (std::size_t j(0); j < timedIds.size(); ++j) {
0156       BOOST_CHECK_EQUAL(timedIds[j], defaultIds[j]);
0157       BOOST_CHECK_EQUAL(timedIds[j], expected[j]);
0158     }
0159   }
0160 }
0161
0162 BOOST_AUTO_TEST_CASE(TimedGrid_2D_withtime) {
0163   // 4x4 matrix
0164   /*
0165     X Y O X
0166     O Y Y X
0167     X X Z Z
0168     X O O X
0169   */
0170   // 7 + 3 + 2 cells -> 4 + 1 + 1 clusters in total
0171
0172   std::vector<Cell> cells;
0173   // X
0174   cells.emplace_back(0ul, 0, 0, 0);
0175   cells.emplace_back(1ul, 3, 0, 0);
0176   cells.emplace_back(2ul, 3, 1, 0);
0177   cells.emplace_back(3ul, 0, 2, 0);
0178   cells.emplace_back(4ul, 1, 2, 0);
0179   cells.emplace_back(5ul, 0, 3, 0);
0180   cells.emplace_back(6ul, 3, 3, 0);
0181   // Y
0182   cells.emplace_back(7ul, 1, 0, 1);
0183   cells.emplace_back(8ul, 1, 1, 1);
0184   cells.emplace_back(9ul, 2, 1, 1);
0185   // Z
0186   cells.emplace_back(10ul, 2, 2, 2);
0187   cells.emplace_back(11ul, 3, 2, 2);
0188
0189   std::vector<std::vector<Identifier>> expectedResults;
0190   expectedResults.push_back({0ul});
0191   expectedResults.push_back({3ul, 4ul, 5ul});
0192   expectedResults.push_back({7ul, 8ul, 9ul});
0193   expectedResults.push_back({10ul, 11ul});
0194   expectedResults.push_back({1ul, 2ul});
0195   expectedResults.push_back({6ul});
0196
0197   Acts::Ccl::ClusteringData data;
0198   ClusterCollection clusters;
0199   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>(
0200       data, cells, clusters, Acts::Ccl::TimedConnect<Cell, 2>(0.5));
0201
0202   BOOST_CHECK_EQUAL(6ul, clusters.size());
0203
0204   std::vector<std::size_t> sizes{1, 3, 3, 2, 2, 1};
0205   for (std::size_t i(0); i < clusters.size(); ++i) {
0206     std::vector<Identifier>& timedIds = clusters[i].ids;
0207     BOOST_CHECK_EQUAL(timedIds.size(), sizes[i]);
0208     std::ranges::sort(timedIds);
0209
0210     const std::vector<Identifier>& expected = expectedResults[i];
0211     BOOST_CHECK_EQUAL(timedIds.size(), expected.size());
0212
0213     for (std::size_t j(0); j < timedIds.size(); ++j) {
0214       BOOST_CHECK_EQUAL(timedIds[j], expected[j]);
0215     }
0216   }
0217 }
0218
0219 BOOST_AUTO_TEST_CASE(TimedGrid_2D_noTollerance) {
0220   // 4x4 matrix
0221   /*
0222     X O O X
0223     O O O X
0224     X X O O
0225     X O O X
0226    */
0227   // 7 cells -> 7 clusters in total
0228   // since time requirement will never be satisfied
0229
0230   std::vector<Cell> cells;
0231   cells.emplace_back(0ul, 0, 0, 0);
0232   cells.emplace_back(1ul, 3, 0, 0);
0233   cells.emplace_back(2ul, 3, 1, 0);
0234   cells.emplace_back(3ul, 0, 2, 0);
0235   cells.emplace_back(4ul, 1, 2, 0);
0236   cells.emplace_back(5ul, 0, 3, 0);
0237   cells.emplace_back(6ul, 3, 3, 0);
0238
0239   std::vector<std::vector<Identifier>> expectedResults;
0240   expectedResults.push_back({0ul});
0241   expectedResults.push_back({3ul});
0242   expectedResults.push_back({5ul});
0243   expectedResults.push_back({4ul});
0244   expectedResults.push_back({1ul});
0245   expectedResults.push_back({2ul});
0246   expectedResults.push_back({6ul});
0247
0248   Acts::Ccl::ClusteringData data;
0249   ClusterCollection clusters;
0250   Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>(
0251       data, cells, clusters, Acts::Ccl::TimedConnect<Cell, 2>(0.));
0252
0253   BOOST_CHECK_EQUAL(7ul, clusters.size());
0254
0255   for (std::size_t i(0); i < clusters.size(); ++i) {
0256     std::vector<Identifier>& timedIds = clusters[i].ids;
0257     const std::vector<Identifier>& expected = expectedResults[i];
0258
0259     BOOST_CHECK_EQUAL(timedIds.size(), 1);
0260     BOOST_CHECK_EQUAL(timedIds.size(), expected.size());
0261     BOOST_CHECK_EQUAL(timedIds[0], expected[0]);
0262   }
0263 }
0264
0265 BOOST_AUTO_TEST_SUITE_END()