diff --git a/src/language/modules/MeshModule.cpp b/src/language/modules/MeshModule.cpp
index fe0e438a80009cf18c15b3f2793361c931d12d68..30505ad73aaf425dbebb3d76e326eaecb6e55fa6 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 4b9dfffd985bc5f400ace5986355f55a591ff9f2..af8fd91292cb54845d0cea9d964feedf6d905484 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 36b120811ad6478af90b89112740d272014b2e7a..f6768af63fd7c4ab9f03370acdb9dcdeb64e864c 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 9459010b69e89acaf3f247866d2f6e81ef00cd81..1041b183e0b1970d40ba7a06f95a0f95d8ea5926 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 33dfbaf4cf7cc8e59eebfc095624d43c5bf038b3..09608a568fad214df3117b4f63b130d5798eaefb 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 df4157c9c19b377f77b754d3f33ac54141539f2f..a9a7ad786e4fdd4ff2c5cdd45f364d5d335911f8 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 2e47cfe21b4790a63e0e4aeba2fcfb9c59699286..a380bcbba5506f8c6a3de8f4cd48814aae100e2d 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 0619736753f2b49a4229c60492ea6fd4c0de7212..c14ae45f1d8b4d662724e2f0931d167afa8ff047 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 9f802eb96d13704235f50e82ad75e84ba9be8a64..7106e3ae28ccb00d8ba55587ba694e3cf03b76f7 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 48cf57d55ebceb7818f755fd9214807a247f6575..f95214955d8192ed36b8fc65c0a19588ccb4310e 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 f315f4b74b01eb371c42eb4bf029f81e93ae6016..cea6b1e4fe00f1fb04d22f873a09db3042c4d13f 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 95b26e0a4964472335139a7afc0cdbf8205ff61f..860ec3560f0e202d98c39b6db9506959a7932bd6 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 97bf0b98fa9beaace5bea6bf427b69dbe75548fc..7559cb2c22a270a8615901a45bdfb0bc9caa7be6 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 0cd2feb9d0765407ee9e6346b91ca768dbe53722..0dc29d27d9260f2f1a92b6a48ea15dc70bb07173 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 9dee9c032b48db4ad51c362b5f47681613039fb5..6d54d7f178d11a02bd94a3aa0bfb8b4e0ce30fb9 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 fa207c91b9b743ffa1986c20a3cdc6e1622c0a1a..5557e1ce4bb2e6f268ba084895cf564732a58456 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();