Merge branch 'main' into feat-change-material-to-proto-axis

Author: asalzburger

Core/include/Acts/Clusterization/Clusterization.ipp

@@ -65,15 +65,17 @@ struct ConnectionsBase {
 template <std::size_t GridDim>
 class Connections {};
 
-// On 1-D grid, cells have 1 backward neighbor
+// On 1-D grid, cells have 1 backward space neighbor, but there can be up to 2
+// cells with different times in that space that can connect
 template <>
-struct Connections<1> : public ConnectionsBase<1> {
+struct Connections<1> : public ConnectionsBase<2> {
   using ConnectionsBase::ConnectionsBase;
 };
 
-// On a 2-D grid, cells have 4 backward neighbors
+// On a 2-D grid, cells have 4 backward space neighbors, but there can be up to
+// 2 cells with different times in each of those spaces that can connect
 template <>
-struct Connections<2> : public ConnectionsBase<4> {
+struct Connections<2> : public ConnectionsBase<8> {
   using ConnectionsBase::ConnectionsBase;
 };
 

Core/include/Acts/Clusterization/TimedClusterization.ipp

@@ -25,15 +25,14 @@ Acts::Ccl::ConnectResult TimedConnect<Cell, N>::operator()(
     const Cell& ref, const Cell& iter) const {
   Acts::Ccl::ConnectResult spaceCompatibility =
       Acts::Ccl::DefaultConnect<Cell, N>::operator()(ref, iter);
-  if (spaceCompatibility != Acts::Ccl::ConnectResult::eConn) {
-    return spaceCompatibility;
-  }
+  double timeDiff = std::abs(getCellTime(iter) - getCellTime(ref));
 
-  if (std::abs(getCellTime(ref) - getCellTime(iter)) < timeTolerance) {
-    return Acts::Ccl::ConnectResult::eConn;
+  if (spaceCompatibility == Acts::Ccl::ConnectResult::eDuplicate ||
+      spaceCompatibility == Acts::Ccl::ConnectResult::eConn) {
+    return (timeDiff < timeTolerance) ? spaceCompatibility
+                                      : Acts::Ccl::ConnectResult::eNoConn;
   }
-
-  return Acts::Ccl::ConnectResult::eNoConn;
+  return spaceCompatibility;
 }
 
 }  // namespace Acts::Ccl

Tests/UnitTests/Core/Clusterization/TimedClusterizationTests.cpp

@@ -99,6 +99,44 @@ BOOST_AUTO_TEST_CASE(TimedGrid_1D_withtime) {
   }
 }
 
+BOOST_AUTO_TEST_CASE(TimedGrid_1D_duplicate_cells) {
+  // Cells with same position but time difference larger than tolerance should
+  // not be considered duplicates
+  CellCollection cells = {Cell(0ul, 0, 0, 0.0), Cell(1ul, 0, 0, 1.0)};
+  ClusterCollection clusters;
+  Ccl::ClusteringData data;
+
+  Ccl::createClusters<CellCollection, ClusterCollection, 1>(
+      data, cells, clusters, Ccl::TimedConnect<Cell, 1>(0.5));
+  BOOST_CHECK_EQUAL(2ul, clusters.size());
+
+  // Cells with same position and time difference within tolerance should be
+  // considered duplicates
+  cells = {Cell(0ul, 0, 0, 0.0), Cell(1ul, 0, 0, 0.4)};
+  clusters.clear();
+  data.clear();
+
+  BOOST_CHECK_THROW(
+      (Ccl::createClusters<CellCollection, ClusterCollection, 1>(
+          data, cells, clusters, Ccl::TimedConnect<Cell, 1>(0.5))),
+      std::invalid_argument);
+}
+
+BOOST_AUTO_TEST_CASE(TimedGrid_1D_space_and_time) {
+  // Cells with the same position but large time differences are not duplicates.
+  // However, they can still be clustered through a neighboring cell if it is
+  // within the time tolerance for both.
+  CellCollection cells = {Cell(0ul, 0, 0, 0.0), Cell(1ul, 1, 0, 0.4),
+                          Cell(2ul, 0, 0, 0.8)};
+  ClusterCollection clusters;
+  Ccl::ClusteringData data;
+
+  Ccl::createClusters<CellCollection, ClusterCollection, 1>(
+      data, cells, clusters, Ccl::TimedConnect<Cell, 1>(0.5));
+  BOOST_CHECK_EQUAL(1ul, clusters.size());
+  BOOST_CHECK_EQUAL(clusters[0].ids.size(), 3ul);
+}
+
 BOOST_AUTO_TEST_CASE(TimedGrid_2D_notime) {
   // 4x4 matrix
   /*
@@ -262,4 +300,72 @@ BOOST_AUTO_TEST_CASE(TimedGrid_2D_noTollerance) {
   }
 }
 
+BOOST_AUTO_TEST_CASE(TimedGrid_2D_duplicate_cells) {
+  // Cells with same position but time difference larger than tolerance should
+  // not be considered duplicates
+  CellCollection cells = {Cell(0ul, 0, 0, 0.0), Cell(1ul, 0, 0, 1.0)};
+  ClusterCollection clusters;
+  Ccl::ClusteringData data;
+
+  Ccl::createClusters<CellCollection, ClusterCollection, 2>(
+      data, cells, clusters, Ccl::TimedConnect<Cell, 2>(0.5));
+  BOOST_CHECK_EQUAL(2ul, clusters.size());
+
+  // Cells with same position and time difference within tolerance should be
+  // considered duplicates
+  cells = {Cell(0ul, 0, 0, 0.0), Cell(1ul, 0, 0, 0.4)};
+  clusters.clear();
+  data.clear();
+
+  BOOST_CHECK_THROW(
+      (Ccl::createClusters<CellCollection, ClusterCollection, 2>(
+          data, cells, clusters, Ccl::TimedConnect<Cell, 2>(0.5))),
+      std::invalid_argument);
+}
+
+BOOST_AUTO_TEST_CASE(TimedGrid_2D_space_and_time_conn4) {
+  // Cells with the same position but large time differences are not duplicates.
+  // However, they can still be clustered through a neighboring cell if it is
+  // within the time tolerance for both:
+  // 3x3 matrix
+  /*
+    O  X/Z  O
+   X/Z  Y  X/Z
+    O  X/Z  O
+  */
+  CellCollection cells = {
+      Cell(0ul, 1, 0, 0.0), Cell(1ul, 0, 1, 0.0), Cell(2ul, 2, 1, 0.0),
+      Cell(3ul, 1, 2, 0.0), Cell(4ul, 1, 0, 0.8), Cell(5ul, 0, 1, 0.8),
+      Cell(6ul, 2, 1, 0.8), Cell(7ul, 1, 2, 0.8), Cell(8ul, 1, 1, 0.4)};
+  ClusterCollection clusters;
+  Ccl::ClusteringData data;
+
+  Ccl::createClusters<CellCollection, ClusterCollection, 2>(
+      data, cells, clusters, Ccl::TimedConnect<Cell, 2>(0.5, false));
+  BOOST_CHECK_EQUAL(1ul, clusters.size());
+  BOOST_CHECK_EQUAL(clusters[0].ids.size(), 9ul);
+}
+
+BOOST_AUTO_TEST_CASE(TimedGrid_2D_space_and_time_conn8) {
+  // Cells with the same position but large time differences are not duplicates.
+  // However, they can still be clustered through a neighboring cell if it is
+  // within the time tolerance for both:
+  // 3x3 matrix
+  /*
+    Z   X   O
+    X   Y   O
+   X/Z  O   O
+  */
+  CellCollection cells = {Cell(0ul, 0, 0, 0.0), Cell(1ul, 0, 2, 0.0),
+                          Cell(2ul, 1, 0, 0.8), Cell(3ul, 0, 1, 0.8),
+                          Cell(4ul, 0, 2, 0.8), Cell(5ul, 1, 1, 0.4)};
+  ClusterCollection clusters;
+  Ccl::ClusteringData data;
+
+  Ccl::createClusters<CellCollection, ClusterCollection, 2>(
+      data, cells, clusters, Ccl::TimedConnect<Cell, 2>(0.5, true));
+  BOOST_CHECK_EQUAL(1ul, clusters.size());
+  BOOST_CHECK_EQUAL(clusters[0].ids.size(), 6ul);
+}
+
 BOOST_AUTO_TEST_SUITE_END()