Handles various ghost layers in mesh data base for tests

tests/MeshDataBaseForTests.cpp

 #include <MeshDataBaseForTests.hpp>
+
 #include <mesh/CartesianMeshBuilder.hpp>
 #include <mesh/Connectivity.hpp>
 #include <mesh/GmshReader.hpp>
 #include <mesh/MeshVariant.hpp>
+#include <utils/GlobalVariableManager.hpp>
 #include <utils/Messenger.hpp>
 #include <utils/PugsAssert.hpp>
 
+#include <NbGhostLayersTester.hpp>
+
 #include <filesystem>
 #include <fstream>
 
@@ -13,17 +17,22 @@ const MeshDataBaseForTests* MeshDataBaseForTests::m_instance = nullptr;
 
 MeshDataBaseForTests::MeshDataBaseForTests()
 {
-  m_cartesian_1d_mesh = CartesianMeshBuilder{TinyVector<1>{-1}, TinyVector<1>{3}, TinyVector<1, size_t>{23}}.mesh();
+  for (size_t nb_ghost_layers = 1; nb_ghost_layers <= m_max_nb_ghost_layers; ++nb_ghost_layers) {
+    NbGhostLayersTester t{nb_ghost_layers};
 
-  m_cartesian_2d_mesh =
-    CartesianMeshBuilder{TinyVector<2>{0, -1}, TinyVector<2>{3, 2}, TinyVector<2, size_t>{6, 7}}.mesh();
+    m_cartesian_1d_mesh.push_back(
+      CartesianMeshBuilder{TinyVector<1>{-1}, TinyVector<1>{3}, TinyVector<1, size_t>{23}}.mesh());
 
-  m_cartesian_3d_mesh =
-    CartesianMeshBuilder{TinyVector<3>{0, 1, 0}, TinyVector<3>{2, -1, 3}, TinyVector<3, size_t>{6, 7, 4}}.mesh();
+    m_cartesian_2d_mesh.push_back(
+      CartesianMeshBuilder{TinyVector<2>{0, -1}, TinyVector<2>{3, 2}, TinyVector<2, size_t>{6, 7}}.mesh());
 
-  m_unordered_1d_mesh = _buildUnordered1dMesh();
-  m_hybrid_2d_mesh    = _buildHybrid2dMesh();
-  m_hybrid_3d_mesh    = _buildHybrid3dMesh();
+    m_cartesian_3d_mesh.push_back(
+      CartesianMeshBuilder{TinyVector<3>{0, 1, 0}, TinyVector<3>{2, -1, 3}, TinyVector<3, size_t>{6, 7, 4}}.mesh());
+
+    m_unordered_1d_mesh.push_back(_buildUnordered1dMesh());
+    m_hybrid_2d_mesh.push_back(_buildHybrid2dMesh());
+    m_hybrid_3d_mesh.push_back(_buildHybrid3dMesh());
+  }
 }
 
 const MeshDataBaseForTests&
@@ -50,37 +59,49 @@ MeshDataBaseForTests::destroy()
 std::shared_ptr<const MeshVariant>
 MeshDataBaseForTests::cartesian1DMesh() const
 {
-  return m_cartesian_1d_mesh;
+  const size_t nb_ghost_layers = GlobalVariableManager::instance().getNumberOfGhostLayers();
+  Assert((nb_ghost_layers >= 1) and (nb_ghost_layers <= m_max_nb_ghost_layers));
+  return m_cartesian_1d_mesh[nb_ghost_layers - 1];
 }
 
 std::shared_ptr<const MeshVariant>
 MeshDataBaseForTests::cartesian2DMesh() const
 {
-  return m_cartesian_2d_mesh;
+  const size_t nb_ghost_layers = GlobalVariableManager::instance().getNumberOfGhostLayers();
+  Assert((nb_ghost_layers >= 1) and (nb_ghost_layers <= m_max_nb_ghost_layers));
+  return m_cartesian_2d_mesh[nb_ghost_layers - 1];
 }
 
 std::shared_ptr<const MeshVariant>
 MeshDataBaseForTests::cartesian3DMesh() const
 {
-  return m_cartesian_3d_mesh;
+  const size_t nb_ghost_layers = GlobalVariableManager::instance().getNumberOfGhostLayers();
+  Assert((nb_ghost_layers >= 1) and (nb_ghost_layers <= m_max_nb_ghost_layers));
+  return m_cartesian_3d_mesh[nb_ghost_layers - 1];
 }
 
 std::shared_ptr<const MeshVariant>
 MeshDataBaseForTests::unordered1DMesh() const
 {
-  return m_unordered_1d_mesh;
+  const size_t nb_ghost_layers = GlobalVariableManager::instance().getNumberOfGhostLayers();
+  Assert((nb_ghost_layers >= 1) and (nb_ghost_layers <= m_max_nb_ghost_layers));
+  return m_unordered_1d_mesh[nb_ghost_layers - 1];
 }
 
 std::shared_ptr<const MeshVariant>
 MeshDataBaseForTests::hybrid2DMesh() const
 {
-  return m_hybrid_2d_mesh;
+  const size_t nb_ghost_layers = GlobalVariableManager::instance().getNumberOfGhostLayers();
+  Assert((nb_ghost_layers >= 1) and (nb_ghost_layers <= m_max_nb_ghost_layers));
+  return m_hybrid_2d_mesh[nb_ghost_layers - 1];
 }
 
 std::shared_ptr<const MeshVariant>
 MeshDataBaseForTests::hybrid3DMesh() const
 {
-  return m_hybrid_3d_mesh;
+  const size_t nb_ghost_layers = GlobalVariableManager::instance().getNumberOfGhostLayers();
+  Assert((nb_ghost_layers >= 1) and (nb_ghost_layers <= m_max_nb_ghost_layers));
+  return m_hybrid_3d_mesh[nb_ghost_layers - 1];
 }
 
 std::shared_ptr<const MeshVariant>

tests/MeshDataBaseForTests.hpp

@@ -4,6 +4,7 @@
 #include <array>
 #include <memory>
 #include <string>
+#include <vector>
 
 class MeshVariant;
 
@@ -35,15 +36,17 @@ class MeshDataBaseForTests
  private:
   explicit MeshDataBaseForTests();
 
+  constexpr static size_t m_max_nb_ghost_layers = 3;
+
   static const MeshDataBaseForTests* m_instance;
 
-  std::shared_ptr<const MeshVariant> m_cartesian_1d_mesh;
-  std::shared_ptr<const MeshVariant> m_cartesian_2d_mesh;
-  std::shared_ptr<const MeshVariant> m_cartesian_3d_mesh;
+  std::vector<std::shared_ptr<const MeshVariant>> m_cartesian_1d_mesh;
+  std::vector<std::shared_ptr<const MeshVariant>> m_cartesian_2d_mesh;
+  std::vector<std::shared_ptr<const MeshVariant>> m_cartesian_3d_mesh;
 
-  std::shared_ptr<const MeshVariant> m_unordered_1d_mesh;
-  std::shared_ptr<const MeshVariant> m_hybrid_2d_mesh;
-  std::shared_ptr<const MeshVariant> m_hybrid_3d_mesh;
+  std::vector<std::shared_ptr<const MeshVariant>> m_unordered_1d_mesh;
+  std::vector<std::shared_ptr<const MeshVariant>> m_hybrid_2d_mesh;
+  std::vector<std::shared_ptr<const MeshVariant>> m_hybrid_3d_mesh;
 
   std::shared_ptr<const MeshVariant> _buildUnordered1dMesh();
   std::shared_ptr<const MeshVariant> _buildHybrid2dMesh();

tests/test_PolynomialReconstruction_degree_2.cpp

@@ -14,12 +14,17 @@
 #include <DiscreteFunctionDPkForTests.hpp>
 #include <MeshDataBaseForTests.hpp>
 
+#include <NbGhostLayersTester.hpp>
+
 // clazy:excludeall=non-pod-global-static
 
 TEST_CASE("PolynomialReconstruction_degree_2", "[scheme]")
 {
   constexpr size_t degree = 2;
 
+  constexpr size_t nb_ghost_layers = 2;
+  NbGhostLayersTester t{nb_ghost_layers};
+
   SECTION("without symmetries")
   {
     std::vector<PolynomialReconstructionDescriptor> descriptor_list =
@@ -158,9 +163,7 @@ TEST_CASE("PolynomialReconstruction_degree_2", "[scheme]")
                                -1.7 + 2.1 * x[0] - 0.7 * x[0] * x[0],   //
                                +1.4 - 0.6 * x[0] + 1.9 * x[0] * x[0]};
                    },
-                   [](const R1& x) -> R3 {
-                     return R3{+1.6 + 0.7 * x[0], -2.1 + 1.2 * x[0], +1.1 - 0.3 * x[0]};
-                   }};
+                   [](const R1& x) -> R3 { return R3{+1.6 + 0.7 * x[0], -2.1 + 1.2 * x[0], +1.1 - 0.3 * x[0]}; }};
 
                 DiscreteFunctionP0Vector Vh = test_only::exact_projection(mesh, degree, vector_exact);