From 97560045584fe0430616d9a6f789269b4add1958 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?St=C3=A9phane=20Del=20Pino?= <stephane.delpino44@gmail.com>
Date: Thu, 9 Dec 2021 17:33:34 +0100
Subject: [PATCH] Prepare add of new dual meshes and connectivities

---
 src/language/modules/MeshModule.cpp         |  6 ++--
 src/main.cpp                                |  8 ++---
 src/mesh/DiamondDualConnectivityBuilder.hpp |  2 +-
 src/mesh/DiamondDualConnectivityManager.cpp | 35 ++++++++++-----------
 src/mesh/DiamondDualConnectivityManager.hpp | 16 +++++-----
 src/mesh/DiamondDualMeshBuilder.cpp         |  2 +-
 src/mesh/DiamondDualMeshBuilder.hpp         |  2 +-
 src/mesh/DiamondDualMeshManager.cpp         | 22 ++++++-------
 src/mesh/DiamondDualMeshManager.hpp         | 22 ++++++++-----
 src/mesh/IConnectivity.cpp                  |  2 +-
 src/mesh/IMesh.cpp                          |  2 +-
 tests/mpi_test_main.cpp                     |  8 ++---
 tests/test_CellIntegrator.cpp               |  3 +-
 tests/test_EdgeIntegrator.cpp               |  3 +-
 tests/test_FaceIntegrator.cpp               |  3 +-
 tests/test_main.cpp                         |  8 ++---
 16 files changed, 73 insertions(+), 71 deletions(-)

diff --git a/src/language/modules/MeshModule.cpp b/src/language/modules/MeshModule.cpp
index fe0e438a8..30505ad73 100644
--- a/src/language/modules/MeshModule.cpp
+++ b/src/language/modules/MeshModule.cpp
@@ -146,19 +146,19 @@ MeshModule::MeshModule()
                                   using MeshType = Mesh<Connectivity<1>>;
 
                                   std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
-                                  return DiamondDualMeshManager::instance().getDiamondDualMesh(p_mesh);
+                                  return DualMeshManager::instance().getDiamondDualMesh(p_mesh);
                                 }
                                 case 2: {
                                   using MeshType = Mesh<Connectivity<2>>;
 
                                   std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
-                                  return DiamondDualMeshManager::instance().getDiamondDualMesh(p_mesh);
+                                  return DualMeshManager::instance().getDiamondDualMesh(p_mesh);
                                 }
                                 case 3: {
                                   using MeshType = Mesh<Connectivity<3>>;
 
                                   std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
-                                  return DiamondDualMeshManager::instance().getDiamondDualMesh(p_mesh);
+                                  return DualMeshManager::instance().getDiamondDualMesh(p_mesh);
                                 }
                                 default: {
                                   throw UnexpectedError("invalid dimension");
diff --git a/src/main.cpp b/src/main.cpp
index 4b9dfffd9..af8fd9129 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -16,13 +16,13 @@ main(int argc, char* argv[])
   RandomEngine::create();
   QuadratureManager::create();
   MeshDataManager::create();
-  DiamondDualConnectivityManager::create();
-  DiamondDualMeshManager::create();
+  DualConnectivityManager::create();
+  DualMeshManager::create();
 
   parser(filename);
 
-  DiamondDualMeshManager::destroy();
-  DiamondDualConnectivityManager::destroy();
+  DualMeshManager::destroy();
+  DualConnectivityManager::destroy();
   MeshDataManager::destroy();
   RandomEngine::destroy();
   QuadratureManager::destroy();
diff --git a/src/mesh/DiamondDualConnectivityBuilder.hpp b/src/mesh/DiamondDualConnectivityBuilder.hpp
index 36b120811..f6768af63 100644
--- a/src/mesh/DiamondDualConnectivityBuilder.hpp
+++ b/src/mesh/DiamondDualConnectivityBuilder.hpp
@@ -27,7 +27,7 @@ class DiamondDualConnectivityBuilder : public ConnectivityBuilderBase
   template <size_t Dimension>
   void _buildDiamondConnectivityFrom(const IConnectivity&);
 
-  friend class DiamondDualConnectivityManager;
+  friend class DualConnectivityManager;
   DiamondDualConnectivityBuilder(const IConnectivity&);
 
  public:
diff --git a/src/mesh/DiamondDualConnectivityManager.cpp b/src/mesh/DiamondDualConnectivityManager.cpp
index 9459010b6..1041b183e 100644
--- a/src/mesh/DiamondDualConnectivityManager.cpp
+++ b/src/mesh/DiamondDualConnectivityManager.cpp
@@ -8,19 +8,19 @@
 
 #include <sstream>
 
-DiamondDualConnectivityManager* DiamondDualConnectivityManager::m_instance{nullptr};
+DualConnectivityManager* DualConnectivityManager::m_instance{nullptr};
 
 void
-DiamondDualConnectivityManager::create()
+DualConnectivityManager::create()
 {
-  Assert(m_instance == nullptr, "DiamondDualConnectivityManager is already created");
-  m_instance = new DiamondDualConnectivityManager;
+  Assert(m_instance == nullptr, "DualConnectivityManager is already created");
+  m_instance = new DualConnectivityManager;
 }
 
 void
-DiamondDualConnectivityManager::destroy()
+DualConnectivityManager::destroy()
 {
-  Assert(m_instance != nullptr, "DiamondDualConnectivityManager was not created!");
+  Assert(m_instance != nullptr, "DualConnectivityManager was not created!");
 
   if (m_instance->m_connectivity_to_diamond_dual_connectivity_info_map.size() > 0) {
     std::stringstream error;
@@ -36,13 +36,13 @@ DiamondDualConnectivityManager::destroy()
 }
 
 void
-DiamondDualConnectivityManager::deleteConnectivity(const IConnectivity* p_connectivity)
+DualConnectivityManager::deleteConnectivity(const IConnectivity* p_connectivity)
 {
   m_connectivity_to_diamond_dual_connectivity_info_map.erase(p_connectivity);
 }
 
-DiamondDualConnectivityManager::DiamondDualConnectivityInfo
-DiamondDualConnectivityManager::_getDiamondDualConnectivityInfo(const IConnectivity& connectivity)
+DualConnectivityManager::DiamondDualConnectivityInfo
+DualConnectivityManager::_getDiamondDualConnectivityInfo(const IConnectivity& connectivity)
 {
   const IConnectivity* p_connectivity = &connectivity;
 
@@ -62,7 +62,7 @@ DiamondDualConnectivityManager::_getDiamondDualConnectivityInfo(const IConnectiv
 
 template <size_t Dimension>
 std::shared_ptr<const Connectivity<Dimension>>
-DiamondDualConnectivityManager::getDiamondDualConnectivity(const Connectivity<Dimension>& connectivity)
+DualConnectivityManager::getDiamondDualConnectivity(const Connectivity<Dimension>& connectivity)
 {
   return std::dynamic_pointer_cast<const Connectivity<Dimension>>(
     this->_getDiamondDualConnectivityInfo(connectivity).diamondDualConnectivity());
@@ -70,27 +70,26 @@ DiamondDualConnectivityManager::getDiamondDualConnectivity(const Connectivity<Di
 
 template <size_t Dimension>
 std::shared_ptr<const ConnectivityToDiamondDualConnectivityDataMapper<Dimension>>
-DiamondDualConnectivityManager::getConnectivityToDiamondDualConnectivityDataMapper(
-  const Connectivity<Dimension>& connectivity)
+DualConnectivityManager::getConnectivityToDiamondDualConnectivityDataMapper(const Connectivity<Dimension>& connectivity)
 {
   return std::dynamic_pointer_cast<const ConnectivityToDiamondDualConnectivityDataMapper<Dimension>>(
     this->_getDiamondDualConnectivityInfo(connectivity).connectivityToDiamondDualConnectivityDataMapper());
 }
 
-template std::shared_ptr<const Connectivity<1>> DiamondDualConnectivityManager::getDiamondDualConnectivity(
+template std::shared_ptr<const Connectivity<1>> DualConnectivityManager::getDiamondDualConnectivity(
   const Connectivity<1>& connectivity);
 
-template std::shared_ptr<const Connectivity<2>> DiamondDualConnectivityManager::getDiamondDualConnectivity(
+template std::shared_ptr<const Connectivity<2>> DualConnectivityManager::getDiamondDualConnectivity(
   const Connectivity<2>& connectivity);
 
-template std::shared_ptr<const Connectivity<3>> DiamondDualConnectivityManager::getDiamondDualConnectivity(
+template std::shared_ptr<const Connectivity<3>> DualConnectivityManager::getDiamondDualConnectivity(
   const Connectivity<3>& connectivity);
 
 template std::shared_ptr<const ConnectivityToDiamondDualConnectivityDataMapper<1>>
-DiamondDualConnectivityManager::getConnectivityToDiamondDualConnectivityDataMapper(const Connectivity<1>&);
+DualConnectivityManager::getConnectivityToDiamondDualConnectivityDataMapper(const Connectivity<1>&);
 
 template std::shared_ptr<const ConnectivityToDiamondDualConnectivityDataMapper<2>>
-DiamondDualConnectivityManager::getConnectivityToDiamondDualConnectivityDataMapper(const Connectivity<2>&);
+DualConnectivityManager::getConnectivityToDiamondDualConnectivityDataMapper(const Connectivity<2>&);
 
 template std::shared_ptr<const ConnectivityToDiamondDualConnectivityDataMapper<3>>
-DiamondDualConnectivityManager::getConnectivityToDiamondDualConnectivityDataMapper(const Connectivity<3>&);
+DualConnectivityManager::getConnectivityToDiamondDualConnectivityDataMapper(const Connectivity<3>&);
diff --git a/src/mesh/DiamondDualConnectivityManager.hpp b/src/mesh/DiamondDualConnectivityManager.hpp
index 33dfbaf4c..09608a568 100644
--- a/src/mesh/DiamondDualConnectivityManager.hpp
+++ b/src/mesh/DiamondDualConnectivityManager.hpp
@@ -14,7 +14,7 @@ class IConnectivityToDiamondDualConnectivityDataMapper;
 template <size_t Dimension>
 class ConnectivityToDiamondDualConnectivityDataMapper;
 
-class DiamondDualConnectivityManager
+class DualConnectivityManager
 {
  private:
   class DiamondDualConnectivityInfo
@@ -61,23 +61,23 @@ class DiamondDualConnectivityManager
   std::unordered_map<const IConnectivity*, DiamondDualConnectivityInfo>
     m_connectivity_to_diamond_dual_connectivity_info_map;
 
-  static DiamondDualConnectivityManager* m_instance;
+  static DualConnectivityManager* m_instance;
 
-  DiamondDualConnectivityManager(const DiamondDualConnectivityManager&) = delete;
-  DiamondDualConnectivityManager(DiamondDualConnectivityManager&&)      = delete;
+  DualConnectivityManager(const DualConnectivityManager&) = delete;
+  DualConnectivityManager(DualConnectivityManager&&)      = delete;
 
-  DiamondDualConnectivityManager()  = default;
-  ~DiamondDualConnectivityManager() = default;
+  DualConnectivityManager()  = default;
+  ~DualConnectivityManager() = default;
 
  public:
   static void create();
   static void destroy();
 
   PUGS_INLINE
-  static DiamondDualConnectivityManager&
+  static DualConnectivityManager&
   instance()
   {
-    Assert(m_instance != nullptr, "DiamondDualConnectivityManager was not created!");
+    Assert(m_instance != nullptr, "DualConnectivityManager was not created!");
     return *m_instance;
   }
 
diff --git a/src/mesh/DiamondDualMeshBuilder.cpp b/src/mesh/DiamondDualMeshBuilder.cpp
index df4157c9c..a9a7ad786 100644
--- a/src/mesh/DiamondDualMeshBuilder.cpp
+++ b/src/mesh/DiamondDualMeshBuilder.cpp
@@ -19,7 +19,7 @@ DiamondDualMeshBuilder::_buildDualDiamondMeshFrom(const std::shared_ptr<const IM
   std::shared_ptr p_primal_mesh = std::dynamic_pointer_cast<const MeshType>(p_i_mesh);
   const MeshType& primal_mesh   = *p_primal_mesh;
 
-  DiamondDualConnectivityManager& manager = DiamondDualConnectivityManager::instance();
+  DualConnectivityManager& manager = DualConnectivityManager::instance();
 
   std::shared_ptr<const ConnectivityType> p_diamond_connectivity =
     manager.getDiamondDualConnectivity(primal_mesh.connectivity());
diff --git a/src/mesh/DiamondDualMeshBuilder.hpp b/src/mesh/DiamondDualMeshBuilder.hpp
index 2e47cfe21..a380bcbba 100644
--- a/src/mesh/DiamondDualMeshBuilder.hpp
+++ b/src/mesh/DiamondDualMeshBuilder.hpp
@@ -11,7 +11,7 @@ class DiamondDualMeshBuilder : public MeshBuilderBase
   template <size_t Dimension>
   void _buildDualDiamondMeshFrom(const std::shared_ptr<const IMesh>&);
 
-  friend class DiamondDualMeshManager;
+  friend class DualMeshManager;
   DiamondDualMeshBuilder(const std::shared_ptr<const IMesh>&);
 
  public:
diff --git a/src/mesh/DiamondDualMeshManager.cpp b/src/mesh/DiamondDualMeshManager.cpp
index 061973675..c14ae45f1 100644
--- a/src/mesh/DiamondDualMeshManager.cpp
+++ b/src/mesh/DiamondDualMeshManager.cpp
@@ -8,19 +8,19 @@
 
 #include <sstream>
 
-DiamondDualMeshManager* DiamondDualMeshManager::m_instance{nullptr};
+DualMeshManager* DualMeshManager::m_instance{nullptr};
 
 void
-DiamondDualMeshManager::create()
+DualMeshManager::create()
 {
-  Assert(m_instance == nullptr, "DiamondDualMeshManager is already created");
-  m_instance = new DiamondDualMeshManager;
+  Assert(m_instance == nullptr, "DualMeshManager is already created");
+  m_instance = new DualMeshManager;
 }
 
 void
-DiamondDualMeshManager::destroy()
+DualMeshManager::destroy()
 {
-  Assert(m_instance != nullptr, "DiamondDualMeshManager was not created!");
+  Assert(m_instance != nullptr, "DualMeshManager was not created!");
 
   if (m_instance->m_mesh_to_diamond_dual_mesh_map.size() > 0) {
     std::stringstream error;
@@ -35,14 +35,14 @@ DiamondDualMeshManager::destroy()
 }
 
 void
-DiamondDualMeshManager::deleteMesh(const IMesh* p_mesh)
+DualMeshManager::deleteMesh(const IMesh* p_mesh)
 {
   m_mesh_to_diamond_dual_mesh_map.erase(p_mesh);
 }
 
 template <size_t Dimension>
 std::shared_ptr<const Mesh<Connectivity<Dimension>>>
-DiamondDualMeshManager::getDiamondDualMesh(std::shared_ptr<const Mesh<Connectivity<Dimension>>> mesh)
+DualMeshManager::getDiamondDualMesh(std::shared_ptr<const Mesh<Connectivity<Dimension>>> mesh)
 {
   const IMesh* p_mesh = mesh.get();
 
@@ -57,9 +57,9 @@ DiamondDualMeshManager::getDiamondDualMesh(std::shared_ptr<const Mesh<Connectivi
   }
 }
 
-template std::shared_ptr<const Mesh<Connectivity<1>>> DiamondDualMeshManager::getDiamondDualMesh(
+template std::shared_ptr<const Mesh<Connectivity<1>>> DualMeshManager::getDiamondDualMesh(
   std::shared_ptr<const Mesh<Connectivity<1>>>);
-template std::shared_ptr<const Mesh<Connectivity<2>>> DiamondDualMeshManager::getDiamondDualMesh(
+template std::shared_ptr<const Mesh<Connectivity<2>>> DualMeshManager::getDiamondDualMesh(
   std::shared_ptr<const Mesh<Connectivity<2>>>);
-template std::shared_ptr<const Mesh<Connectivity<3>>> DiamondDualMeshManager::getDiamondDualMesh(
+template std::shared_ptr<const Mesh<Connectivity<3>>> DualMeshManager::getDiamondDualMesh(
   std::shared_ptr<const Mesh<Connectivity<3>>>);
diff --git a/src/mesh/DiamondDualMeshManager.hpp b/src/mesh/DiamondDualMeshManager.hpp
index 9f802eb96..7106e3ae2 100644
--- a/src/mesh/DiamondDualMeshManager.hpp
+++ b/src/mesh/DiamondDualMeshManager.hpp
@@ -14,28 +14,34 @@ class Connectivity;
 template <typename ConnectivityType>
 class Mesh;
 
-class DiamondDualMeshManager
+enum class DualMeshType
+{
+  Diamond,
+  Classic
+};
+
+class DualMeshManager
 {
  private:
   std::unordered_map<const IMesh*, std::shared_ptr<const IMesh>> m_mesh_to_diamond_dual_mesh_map;
 
-  static DiamondDualMeshManager* m_instance;
+  static DualMeshManager* m_instance;
 
-  DiamondDualMeshManager(const DiamondDualMeshManager&) = delete;
-  DiamondDualMeshManager(DiamondDualMeshManager&&)      = delete;
+  DualMeshManager(const DualMeshManager&) = delete;
+  DualMeshManager(DualMeshManager&&)      = delete;
 
-  DiamondDualMeshManager()  = default;
-  ~DiamondDualMeshManager() = default;
+  DualMeshManager()  = default;
+  ~DualMeshManager() = default;
 
  public:
   static void create();
   static void destroy();
 
   PUGS_INLINE
-  static DiamondDualMeshManager&
+  static DualMeshManager&
   instance()
   {
-    Assert(m_instance != nullptr, "DiamondDualMeshManager was not created!");
+    Assert(m_instance != nullptr, "DualMeshManager was not created!");
     return *m_instance;
   }
 
diff --git a/src/mesh/IConnectivity.cpp b/src/mesh/IConnectivity.cpp
index 48cf57d55..f95214955 100644
--- a/src/mesh/IConnectivity.cpp
+++ b/src/mesh/IConnectivity.cpp
@@ -6,5 +6,5 @@
 IConnectivity::~IConnectivity()
 {
   SynchronizerManager::instance().deleteConnectivitySynchronizer(this);
-  DiamondDualConnectivityManager::instance().deleteConnectivity(this);
+  DualConnectivityManager::instance().deleteConnectivity(this);
 }
diff --git a/src/mesh/IMesh.cpp b/src/mesh/IMesh.cpp
index f315f4b74..cea6b1e4f 100644
--- a/src/mesh/IMesh.cpp
+++ b/src/mesh/IMesh.cpp
@@ -6,5 +6,5 @@
 IMesh::~IMesh()
 {
   MeshDataManager::instance().deleteMeshData(this);
-  DiamondDualMeshManager::instance().deleteMesh(this);
+  DualMeshManager::instance().deleteMesh(this);
 }
diff --git a/tests/mpi_test_main.cpp b/tests/mpi_test_main.cpp
index 95b26e0a4..860ec3560 100644
--- a/tests/mpi_test_main.cpp
+++ b/tests/mpi_test_main.cpp
@@ -62,8 +62,8 @@ main(int argc, char* argv[])
       RandomEngine::create();
       QuadratureManager::create();
       MeshDataManager::create();
-      DiamondDualConnectivityManager::create();
-      DiamondDualMeshManager::create();
+      DualConnectivityManager::create();
+      DualMeshManager::create();
 
       MeshDataBaseForTests::create();
 
@@ -90,8 +90,8 @@ main(int argc, char* argv[])
 
       MeshDataBaseForTests::destroy();
 
-      DiamondDualMeshManager::destroy();
-      DiamondDualConnectivityManager::destroy();
+      DualMeshManager::destroy();
+      DualConnectivityManager::destroy();
       MeshDataManager::destroy();
       QuadratureManager::destroy();
       RandomEngine::destroy();
diff --git a/tests/test_CellIntegrator.cpp b/tests/test_CellIntegrator.cpp
index 97bf0b98f..7559cb2c2 100644
--- a/tests/test_CellIntegrator.cpp
+++ b/tests/test_CellIntegrator.cpp
@@ -493,8 +493,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
 
     std::vector<std::pair<std::string, decltype(hybrid_mesh)>> mesh_list;
     mesh_list.push_back(std::make_pair("hybrid mesh", hybrid_mesh));
-    mesh_list.push_back(
-      std::make_pair("diamond mesh", DiamondDualMeshManager::instance().getDiamondDualMesh(hybrid_mesh)));
+    mesh_list.push_back(std::make_pair("diamond mesh", DualMeshManager::instance().getDiamondDualMesh(hybrid_mesh)));
 
     for (auto mesh_info : mesh_list) {
       auto mesh_name = mesh_info.first;
diff --git a/tests/test_EdgeIntegrator.cpp b/tests/test_EdgeIntegrator.cpp
index 0cd2feb9d..0dc29d27d 100644
--- a/tests/test_EdgeIntegrator.cpp
+++ b/tests/test_EdgeIntegrator.cpp
@@ -30,8 +30,7 @@ TEST_CASE("EdgeIntegrator", "[scheme]")
 
     std::vector<std::pair<std::string, decltype(hybrid_mesh)>> mesh_list;
     mesh_list.push_back(std::make_pair("hybrid mesh", hybrid_mesh));
-    mesh_list.push_back(
-      std::make_pair("diamond mesh", DiamondDualMeshManager::instance().getDiamondDualMesh(hybrid_mesh)));
+    mesh_list.push_back(std::make_pair("diamond mesh", DualMeshManager::instance().getDiamondDualMesh(hybrid_mesh)));
 
     for (auto mesh_info : mesh_list) {
       auto mesh_name = mesh_info.first;
diff --git a/tests/test_FaceIntegrator.cpp b/tests/test_FaceIntegrator.cpp
index 9dee9c032..6d54d7f17 100644
--- a/tests/test_FaceIntegrator.cpp
+++ b/tests/test_FaceIntegrator.cpp
@@ -258,8 +258,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
 
     std::vector<std::pair<std::string, decltype(hybrid_mesh)>> mesh_list;
     mesh_list.push_back(std::make_pair("hybrid mesh", hybrid_mesh));
-    mesh_list.push_back(
-      std::make_pair("diamond mesh", DiamondDualMeshManager::instance().getDiamondDualMesh(hybrid_mesh)));
+    mesh_list.push_back(std::make_pair("diamond mesh", DualMeshManager::instance().getDiamondDualMesh(hybrid_mesh)));
 
     for (auto mesh_info : mesh_list) {
       auto mesh_name = mesh_info.first;
diff --git a/tests/test_main.cpp b/tests/test_main.cpp
index fa207c91b..5557e1ce4 100644
--- a/tests/test_main.cpp
+++ b/tests/test_main.cpp
@@ -39,8 +39,8 @@ main(int argc, char* argv[])
       RandomEngine::create();
       QuadratureManager::create();
       MeshDataManager::create();
-      DiamondDualConnectivityManager::create();
-      DiamondDualMeshManager::create();
+      DualConnectivityManager::create();
+      DualMeshManager::create();
 
       MeshDataBaseForTests::create();
 
@@ -52,8 +52,8 @@ main(int argc, char* argv[])
 
       MeshDataBaseForTests::destroy();
 
-      DiamondDualMeshManager::destroy();
-      DiamondDualConnectivityManager::destroy();
+      DualMeshManager::destroy();
+      DualConnectivityManager::destroy();
       MeshDataManager::destroy();
       QuadratureManager::destroy();
       RandomEngine::destroy();
-- 
GitLab