Add missing tests for sums of TinyVector or TinyMatrix data

Also remove useless forced instantiating

tests/test_ItemArrayUtils.cpp

@@ -2,15 +2,14 @@
 #include <catch2/matchers/catch_matchers_all.hpp>
 
 #include <MeshDataBaseForTests.hpp>
+#include <algebra/TinyMatrix.hpp>
+#include <algebra/TinyVector.hpp>
 #include <mesh/Connectivity.hpp>
 #include <mesh/ItemArray.hpp>
 #include <mesh/ItemArrayUtils.hpp>
 #include <mesh/Mesh.hpp>
 #include <utils/Messenger.hpp>
 
-// Instantiate to ensure full coverage is performed
-template class ItemArray<int, ItemType::cell>;
-
 // clazy:excludeall=non-pod-global-static
 
 TEST_CASE("ItemArrayUtils", "[mesh]")
@@ -1056,7 +1055,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
       std::array mesh_list = MeshDataBaseForTests::get().all2DMeshes();
 
       for (auto named_mesh : mesh_list) {
-        SECTION(named_mesh.name())
+        SECTION(named_mesh.name() + " for size_t data")
         {
           auto mesh_2d = named_mesh.mesh();
 
@@ -1077,6 +1076,31 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
 
           REQUIRE(sum(face_array) == 2 * face_array.sizeOfArrays() * global_number_of_faces);
         }
+
+        SECTION(named_mesh.name() + " for N^2 data")
+        {
+          auto mesh_2d = named_mesh.mesh();
+
+          const Connectivity<2>& connectivity = mesh_2d->connectivity();
+
+          using N2 = TinyVector<2, size_t>;
+          FaceArray<N2> face_array{connectivity, 3};
+
+          const N2 data(3, 1);
+          face_array.fill(data);
+
+          auto face_is_owned = connectivity.faceIsOwned();
+
+          const size_t global_number_of_faces = [&] {
+            size_t number_of_faces = 0;
+            for (FaceId face_id = 0; face_id < face_is_owned.numberOfItems(); ++face_id) {
+              number_of_faces += face_is_owned[face_id];
+            }
+            return parallel::allReduceSum(number_of_faces);
+          }();
+
+          REQUIRE(sum(face_array) == face_array.sizeOfArrays() * global_number_of_faces * data);
+        }
       }
     }
 
@@ -1085,7 +1109,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
       std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes();
 
       for (auto named_mesh : mesh_list) {
-        SECTION(named_mesh.name())
+        SECTION(named_mesh.name() + " for size_t data")
         {
           auto mesh_3d = named_mesh.mesh();
 
@@ -1106,6 +1130,32 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
 
           REQUIRE(sum(node_array) == 3 * node_array.sizeOfArrays() * global_number_of_nodes);
         }
+
+        SECTION(named_mesh.name() + " for N^3x2 data")
+        {
+          auto mesh_3d = named_mesh.mesh();
+
+          const Connectivity<3>& connectivity = mesh_3d->connectivity();
+
+          using N3x2 = TinyMatrix<3, 2, size_t>;
+
+          NodeArray<N3x2> node_array{connectivity, 3};
+
+          const N3x2 data(1, 3, 2, 4, 6, 5);
+          node_array.fill(data);
+
+          auto node_is_owned = connectivity.nodeIsOwned();
+
+          const size_t global_number_of_nodes = [&] {
+            size_t number_of_nodes = 0;
+            for (NodeId node_id = 0; node_id < node_is_owned.numberOfItems(); ++node_id) {
+              number_of_nodes += node_is_owned[node_id];
+            }
+            return parallel::allReduceSum(number_of_nodes);
+          }();
+
+          REQUIRE(sum(node_array) == node_array.sizeOfArrays() * global_number_of_nodes * data);
+        }
       }
     }
   }

tests/test_ItemValueUtils.cpp

@@ -2,15 +2,14 @@
 #include <catch2/matchers/catch_matchers_all.hpp>
 
 #include <MeshDataBaseForTests.hpp>
+#include <algebra/TinyMatrix.hpp>
+#include <algebra/TinyVector.hpp>
 #include <mesh/Connectivity.hpp>
 #include <mesh/ItemValue.hpp>
 #include <mesh/ItemValueUtils.hpp>
 #include <mesh/Mesh.hpp>
 #include <utils/Messenger.hpp>
 
-// Instantiate to ensure full coverage is performed
-template class ItemValue<int, ItemType::cell>;
-
 // clazy:excludeall=non-pod-global-static
 
 TEST_CASE("ItemValueUtils", "[mesh]")
@@ -270,7 +269,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
       std::array mesh_list = MeshDataBaseForTests::get().all2DMeshes();
 
       for (auto named_mesh : mesh_list) {
-        SECTION(named_mesh.name())
+        SECTION(named_mesh.name() + "for size_t data")
         {
           auto mesh_2d = named_mesh.mesh();
 
@@ -291,6 +290,30 @@ TEST_CASE("ItemValueUtils", "[mesh]")
 
           REQUIRE(sum(face_value) == 2 * global_number_of_faces);
         }
+
+        SECTION(named_mesh.name() + "for N^3 data")
+        {
+          auto mesh_2d = named_mesh.mesh();
+
+          const Connectivity<2>& connectivity = mesh_2d->connectivity();
+
+          using N3 = TinyVector<3, size_t>;
+          FaceValue<N3> face_value{connectivity};
+          const N3 data(2, 1, 4);
+          face_value.fill(data);
+
+          auto face_is_owned = connectivity.faceIsOwned();
+
+          const size_t global_number_of_faces = [&] {
+            size_t number_of_faces = 0;
+            for (FaceId face_id = 0; face_id < face_is_owned.numberOfItems(); ++face_id) {
+              number_of_faces += face_is_owned[face_id];
+            }
+            return parallel::allReduceSum(number_of_faces);
+          }();
+
+          REQUIRE(sum(face_value) == global_number_of_faces * data);
+        }
       }
     }
 
@@ -299,7 +322,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
       std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes();
 
       for (auto named_mesh : mesh_list) {
-        SECTION(named_mesh.name())
+        SECTION(named_mesh.name() + " for size_t data")
         {
           auto mesh_3d = named_mesh.mesh();
 
@@ -320,6 +343,32 @@ TEST_CASE("ItemValueUtils", "[mesh]")
 
           REQUIRE(sum(node_value) == 3 * global_number_of_nodes);
         }
+
+        SECTION(named_mesh.name() + " for N^3x2 data")
+        {
+          auto mesh_3d = named_mesh.mesh();
+
+          const Connectivity<3>& connectivity = mesh_3d->connectivity();
+
+          using N3x2 = TinyMatrix<3, 2, size_t>;
+
+          NodeValue<N3x2> node_value{connectivity};
+          const N3x2 data(3, 6, 1, 4, 5, 7);
+
+          node_value.fill(data);
+
+          auto node_is_owned = connectivity.nodeIsOwned();
+
+          const size_t global_number_of_nodes = [&] {
+            size_t number_of_nodes = 0;
+            for (NodeId node_id = 0; node_id < node_is_owned.numberOfItems(); ++node_id) {
+              number_of_nodes += node_is_owned[node_id];
+            }
+            return parallel::allReduceSum(number_of_nodes);
+          }();
+
+          REQUIRE(sum(node_value) == global_number_of_nodes * data);
+        }
       }
     }
   }