From 6add3ad1dd2a238858b0cde45e0584685b7717b0 Mon Sep 17 00:00:00 2001
From: Stephane Del Pino <stephane.delpino44@gmail.com>
Date: Sun, 25 Feb 2024 19:57:34 +0100
Subject: [PATCH] Change Mesh class template argument

Mesh<Connectivity<Dimension>> now writes simply Mesh<Dimension>

Also remove dimension template parameters for Mesh*Interface classes
forgot previously
---
 .../EmbeddedDiscreteFunctionMathFunctions.cpp |  2 +-
 src/mesh/CartesianMeshBuilder.cpp             |  2 +-
 src/mesh/Dual1DMeshBuilder.cpp                |  5 +-
 src/mesh/DualMeshManager.hpp                  |  6 --
 src/mesh/GmshReader.cpp                       |  6 +-
 src/mesh/Mesh.cpp                             | 10 ++--
 src/mesh/Mesh.hpp                             | 13 ++--
 src/mesh/MeshBuilderBase.cpp                  |  6 +-
 src/mesh/MeshCellZone.cpp                     | 10 ++--
 src/mesh/MeshCellZone.hpp                     | 17 +++---
 src/mesh/MeshData.hpp                         |  5 +-
 src/mesh/MeshDataManager.cpp                  |  8 +--
 src/mesh/MeshDataManager.hpp                  |  7 +--
 src/mesh/MeshEdgeBoundary.cpp                 | 16 ++---
 src/mesh/MeshEdgeInterface.cpp                | 40 +++++++------
 src/mesh/MeshEdgeInterface.hpp                | 33 +++++------
 src/mesh/MeshFaceBoundary.cpp                 | 12 ++--
 src/mesh/MeshFaceInterface.cpp                | 25 ++++----
 src/mesh/MeshFaceInterface.hpp                | 30 ++++------
 src/mesh/MeshFlatEdgeBoundary.cpp             |  9 +--
 src/mesh/MeshFlatFaceBoundary.cpp             |  9 +--
 src/mesh/MeshFlatNodeBoundary.cpp             | 25 ++++----
 src/mesh/MeshLineEdgeBoundary.cpp             |  6 +-
 src/mesh/MeshLineFaceBoundary.cpp             |  3 +-
 src/mesh/MeshLineNodeBoundary.cpp             | 10 ++--
 src/mesh/MeshNodeBoundary.cpp                 | 24 ++++----
 src/mesh/MeshNodeBoundaryUtils.cpp            |  4 +-
 src/mesh/MeshNodeInterface.cpp                | 59 ++++++++++---------
 src/mesh/MeshNodeInterface.hpp                | 39 +++++-------
 src/mesh/MeshRandomizer.cpp                   |  2 +-
 src/mesh/MeshRelaxer.hpp                      |  3 -
 src/mesh/MeshSmoother.cpp                     |  2 +-
 src/mesh/MeshTraits.hpp                       |  9 +--
 src/mesh/MeshVariant.hpp                      | 11 ++--
 src/scheme/AcousticSolver.cpp                 |  8 +--
 src/scheme/DiscreteFunctionP0.hpp             |  7 +--
 src/scheme/DiscreteFunctionP0Vector.hpp       |  3 +-
 src/scheme/FluxingAdvectionSolver.cpp         | 13 ++--
 src/scheme/HyperelasticSolver.cpp             |  6 +-
 tests/test_CellIntegrator.cpp                 | 18 +++---
 tests/test_Connectivity.cpp                   | 58 +++++++++---------
 tests/test_DiamondDualConnectivityBuilder.cpp |  8 +--
 tests/test_DiamondDualMeshBuilder.cpp         | 14 ++---
 .../test_DiscreteFunctionIntegratorByZone.cpp |  6 +-
 tests/test_DiscreteFunctionInterpoler.cpp     |  6 +-
 .../test_DiscreteFunctionInterpolerByZone.cpp |  6 +-
 tests/test_DiscreteFunctionP0.cpp             | 55 ++++++++---------
 tests/test_DiscreteFunctionP0Vector.cpp       | 36 +++++------
 tests/test_DiscreteFunctionUtils.cpp          | 18 +++---
 .../test_DiscreteFunctionVectorIntegrator.cpp |  8 +--
 ...DiscreteFunctionVectorIntegratorByZone.cpp |  6 +-
 .../test_DiscreteFunctionVectorInterpoler.cpp |  8 +--
 ...DiscreteFunctionVectorInterpolerByZone.cpp |  8 +--
 tests/test_Dual1DConnectivityBuilder.cpp      |  4 +-
 tests/test_Dual1DMeshBuilder.cpp              |  3 +-
 tests/test_DualConnectivityManager.cpp        |  4 +-
 tests/test_DualMeshManager.cpp                |  6 +-
 tests/test_EdgeIntegrator.cpp                 |  6 +-
 ...mbeddedDiscreteFunctionMathFunctions1D.cpp |  5 +-
 ...mbeddedDiscreteFunctionMathFunctions2D.cpp |  5 +-
 ...mbeddedDiscreteFunctionMathFunctions3D.cpp |  5 +-
 ...st_EmbeddedDiscreteFunctionOperators1D.cpp |  5 +-
 ...st_EmbeddedDiscreteFunctionOperators2D.cpp |  5 +-
 ...st_EmbeddedDiscreteFunctionOperators3D.cpp |  5 +-
 tests/test_EmbeddedDiscreteFunctionUtils.cpp  |  4 +-
 tests/test_FaceIntegrator.cpp                 | 12 ++--
 tests/test_IntegrateCellArray.cpp             | 12 ++--
 tests/test_IntegrateCellValue.cpp             | 12 ++--
 tests/test_IntegrateOnCells.cpp               | 36 +++++------
 tests/test_InterpolateItemArray.cpp           | 30 +++++-----
 tests/test_InterpolateItemValue.cpp           | 14 ++---
 tests/test_ItemArray.cpp                      | 22 +++----
 tests/test_ItemArrayUtils.cpp                 | 28 ++++-----
 tests/test_ItemArrayVariant.cpp               |  2 +-
 ...est_ItemArrayVariantFunctionInterpoler.cpp |  6 +-
 tests/test_ItemValue.cpp                      | 22 +++----
 tests/test_ItemValueUtils.cpp                 | 32 +++++-----
 tests/test_ItemValueVariant.cpp               |  2 +-
 ...est_ItemValueVariantFunctionInterpoler.cpp |  6 +-
 tests/test_MedianDualConnectivityBuilder.cpp  |  4 +-
 tests/test_MedianDualMeshBuilder.cpp          |  3 +-
 tests/test_MeshEdgeBoundary.cpp               | 24 ++++----
 tests/test_MeshEdgeInterface.cpp              | 15 +++--
 tests/test_MeshFaceBoundary.cpp               | 24 ++++----
 tests/test_MeshFaceInterface.cpp              | 24 ++++----
 tests/test_MeshFlatEdgeBoundary.cpp           | 28 ++++-----
 tests/test_MeshFlatFaceBoundary.cpp           | 28 ++++-----
 tests/test_MeshFlatNodeBoundary.cpp           | 36 +++++------
 tests/test_MeshLineEdgeBoundary.cpp           | 24 ++++----
 tests/test_MeshLineFaceBoundary.cpp           | 12 ++--
 tests/test_MeshLineNodeBoundary.cpp           | 24 ++++----
 tests/test_MeshNodeBoundary.cpp               | 24 ++++----
 tests/test_MeshNodeInterface.cpp              | 24 ++++----
 tests/test_ParallelChecker_read.cpp           | 46 +++++++--------
 tests/test_ParallelChecker_write.cpp          | 26 ++++----
 ...malToDiamondDualConnectivityDataMapper.cpp | 12 ++--
 ...t_PrimalToDual1DConnectivityDataMapper.cpp |  4 +-
 ...imalToMedianDualConnectivityDataMapper.cpp |  8 +--
 tests/test_SubItemArrayPerItem.cpp            | 22 +++----
 tests/test_SubItemArrayPerItemUtils.cpp       | 28 ++++-----
 tests/test_SubItemArrayPerItemVariant.cpp     |  4 +-
 tests/test_SubItemValuePerItem.cpp            | 26 ++++----
 tests/test_SubItemValuePerItemUtils.cpp       | 26 ++++----
 tests/test_SubItemValuePerItemVariant.cpp     |  4 +-
 tests/test_Synchronizer.cpp                   | 32 ++++------
 105 files changed, 741 insertions(+), 844 deletions(-)

diff --git a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
index eb7cebd57..b53e19ac6 100644
--- a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
+++ b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
@@ -509,7 +509,7 @@ sum_of_Vh_components(const std::shared_ptr<const DiscreteFunctionVariant>& f)
 template <size_t Dimension>
 void
 vectorize_to(const std::vector<std::shared_ptr<const DiscreteFunctionVariant>>& discrete_function_list,
-             const Mesh<Connectivity<Dimension>>& mesh,
+             const Mesh<Dimension>& mesh,
              DiscreteFunctionP0Vector<Dimension, double>& discrete_vector_function)
 {
   if (hasSameMesh(discrete_function_list)) {
diff --git a/src/mesh/CartesianMeshBuilder.cpp b/src/mesh/CartesianMeshBuilder.cpp
index 7b98ea861..4ae7410ce 100644
--- a/src/mesh/CartesianMeshBuilder.cpp
+++ b/src/mesh/CartesianMeshBuilder.cpp
@@ -117,7 +117,7 @@ CartesianMeshBuilder::_buildCartesianMesh(const TinyVector<Dimension>& a,
 
   NodeValue<TinyVector<Dimension>> xr = _getNodeCoordinates(a, b, cell_size, connectivity);
 
-  m_mesh = std::make_shared<MeshVariant>(std::make_shared<const Mesh<ConnectivityType>>(p_connectivity, xr));
+  m_mesh = std::make_shared<MeshVariant>(std::make_shared<const Mesh<Dimension>>(p_connectivity, xr));
 }
 
 template <size_t Dimension>
diff --git a/src/mesh/Dual1DMeshBuilder.cpp b/src/mesh/Dual1DMeshBuilder.cpp
index c2d0f6342..495bbbe86 100644
--- a/src/mesh/Dual1DMeshBuilder.cpp
+++ b/src/mesh/Dual1DMeshBuilder.cpp
@@ -1,6 +1,5 @@
 #include <mesh/Dual1DMeshBuilder.hpp>
 
-#include <mesh/Connectivity.hpp>
 #include <mesh/DualConnectivityManager.hpp>
 #include <mesh/ItemValueUtils.hpp>
 #include <mesh/Mesh.hpp>
@@ -39,11 +38,11 @@ Dual1DMeshBuilder::_buildDual1DMeshFrom(const MeshType& primal_mesh)
   NodeValue<TinyVector<1>> dual_xr{dual_connectivity};
   primal_to_dual_1d_connectivity_data_mapper->toDualNode(primal_xr, primal_xj, dual_xr);
 
-  m_mesh = std::make_shared<MeshVariant>(std::make_shared<const Mesh<Connectivity<1>>>(p_dual_connectivity, dual_xr));
+  m_mesh = std::make_shared<MeshVariant>(std::make_shared<const Mesh<1>>(p_dual_connectivity, dual_xr));
 }
 
 Dual1DMeshBuilder::Dual1DMeshBuilder(const std::shared_ptr<const MeshVariant>& mesh_v)
 {
   std::cout << "building Dual1DMesh\n";
-  this->_buildDual1DMeshFrom(*(mesh_v->get<Mesh<Connectivity<1>>>()));
+  this->_buildDual1DMeshFrom(*(mesh_v->get<Mesh<1>>()));
 }
diff --git a/src/mesh/DualMeshManager.hpp b/src/mesh/DualMeshManager.hpp
index 040dfd8d6..46ad9c9f8 100644
--- a/src/mesh/DualMeshManager.hpp
+++ b/src/mesh/DualMeshManager.hpp
@@ -10,12 +10,6 @@
 
 class MeshVariant;
 
-template <size_t Dimension>
-class Connectivity;
-
-template <typename ConnectivityType>
-class Mesh;
-
 class DualMeshManager
 {
  private:
diff --git a/src/mesh/GmshReader.cpp b/src/mesh/GmshReader.cpp
index b8ddd2910..50ecb1af1 100644
--- a/src/mesh/GmshReader.cpp
+++ b/src/mesh/GmshReader.cpp
@@ -1502,7 +1502,7 @@ GmshReader::__proceedData()
       std::dynamic_pointer_cast<const Connectivity3D>(connectivity_builder.connectivity());
     const Connectivity3D& connectivity = *p_connectivity;
 
-    using MeshType = Mesh<Connectivity3D>;
+    using MeshType = Mesh<3>;
     using Rd       = TinyVector<3, double>;
 
     NodeValue<Rd> xr(connectivity);
@@ -1523,7 +1523,7 @@ GmshReader::__proceedData()
       std::dynamic_pointer_cast<const Connectivity2D>(connectivity_builder.connectivity());
     const Connectivity2D& connectivity = *p_connectivity;
 
-    using MeshType = Mesh<Connectivity2D>;
+    using MeshType = Mesh<2>;
     using Rd       = TinyVector<2, double>;
 
     NodeValue<Rd> xr(connectivity);
@@ -1543,7 +1543,7 @@ GmshReader::__proceedData()
       std::dynamic_pointer_cast<const Connectivity1D>(connectivity_builder.connectivity());
     const Connectivity1D& connectivity = *p_connectivity;
 
-    using MeshType = Mesh<Connectivity1D>;
+    using MeshType = Mesh<1>;
     using Rd       = TinyVector<1, double>;
 
     NodeValue<Rd> xr(connectivity);
diff --git a/src/mesh/Mesh.cpp b/src/mesh/Mesh.cpp
index b622bfb97..baa0d00d7 100644
--- a/src/mesh/Mesh.cpp
+++ b/src/mesh/Mesh.cpp
@@ -4,13 +4,13 @@
 #include <mesh/DualMeshManager.hpp>
 #include <mesh/MeshDataManager.hpp>
 
-template <typename ConnectivityType>
-Mesh<ConnectivityType>::~Mesh()
+template <size_t Dimension>
+Mesh<Dimension>::~Mesh()
 {
   MeshDataManager::instance().deleteMeshData(this->id());
   DualMeshManager::instance().deleteMesh(this->id());
 }
 
-template Mesh<Connectivity<1>>::~Mesh();
-template Mesh<Connectivity<2>>::~Mesh();
-template Mesh<Connectivity<3>>::~Mesh();
+template Mesh<1>::~Mesh();
+template Mesh<2>::~Mesh();
+template Mesh<3>::~Mesh();
diff --git a/src/mesh/Mesh.hpp b/src/mesh/Mesh.hpp
index 451d53a31..f260dd1fc 100644
--- a/src/mesh/Mesh.hpp
+++ b/src/mesh/Mesh.hpp
@@ -2,20 +2,21 @@
 #define MESH_HPP
 
 #include <algebra/TinyVector.hpp>
+#include <mesh/Connectivity.hpp>
 #include <mesh/ItemValue.hpp>
 #include <mesh/MeshVariant.hpp>
 #include <utils/GlobalVariableManager.hpp>
 
 #include <memory>
 
-template <typename ConnectivityType>
-class Mesh : public std::enable_shared_from_this<Mesh<ConnectivityType>>
+template <size_t MeshDimension>
+class Mesh : public std::enable_shared_from_this<Mesh<MeshDimension>>
 {
  public:
-  using Connectivity = ConnectivityType;
+  static constexpr size_t Dimension = MeshDimension;
+  using Connectivity                = Connectivity<Dimension>;
 
-  static constexpr size_t Dimension = ConnectivityType::Dimension;
-  using Rd                          = TinyVector<Dimension>;
+  using Rd = TinyVector<Dimension>;
 
  private:
   const size_t m_id;
@@ -44,7 +45,7 @@ class Mesh : public std::enable_shared_from_this<Mesh<ConnectivityType>>
   }
 
   PUGS_INLINE
-  std::shared_ptr<const Mesh<ConnectivityType>>
+  std::shared_ptr<const Mesh<Dimension>>
   shared_ptr() const
   {
     return this->shared_from_this();
diff --git a/src/mesh/MeshBuilderBase.cpp b/src/mesh/MeshBuilderBase.cpp
index 6787e4bdc..4537f83b2 100644
--- a/src/mesh/MeshBuilderBase.cpp
+++ b/src/mesh/MeshBuilderBase.cpp
@@ -23,7 +23,7 @@ MeshBuilderBase::_dispatch()
 
   using ConnectivityType = Connectivity<Dimension>;
   using Rd               = TinyVector<Dimension>;
-  using MeshType         = Mesh<ConnectivityType>;
+  using MeshType         = Mesh<Dimension>;
 
   if (not m_mesh) {
     ConnectivityDescriptor descriptor;
@@ -49,8 +49,8 @@ template <size_t Dimension>
 void
 MeshBuilderBase::_checkMesh() const
 {
-  using ConnectivityType = Connectivity<Dimension>;
-  using MeshType         = Mesh<ConnectivityType>;
+  using MeshType         = Mesh<Dimension>;
+  using ConnectivityType = typename MeshType::Connectivity;
 
   if (not m_mesh) {
     throw UnexpectedError("mesh is not built yet");
diff --git a/src/mesh/MeshCellZone.cpp b/src/mesh/MeshCellZone.cpp
index ac63998b6..08bdf64ba 100644
--- a/src/mesh/MeshCellZone.cpp
+++ b/src/mesh/MeshCellZone.cpp
@@ -5,13 +5,13 @@
 #include <utils/Messenger.hpp>
 
 template <size_t Dimension>
-MeshCellZone<Dimension>::MeshCellZone(const Mesh<Connectivity<Dimension>>&, const RefCellList& ref_cell_list)
+MeshCellZone<Dimension>::MeshCellZone(const Mesh<Dimension>&, const RefCellList& ref_cell_list)
   : m_cell_list(ref_cell_list.list()), m_zone_name(ref_cell_list.refId().tagName())
 {}
 
 template <size_t Dimension>
 MeshCellZone<Dimension>
-getMeshCellZone(const Mesh<Connectivity<Dimension>>& mesh, const IZoneDescriptor& zone_descriptor)
+getMeshCellZone(const Mesh<Dimension>& mesh, const IZoneDescriptor& zone_descriptor)
 {
   for (size_t i_ref_cell_list = 0; i_ref_cell_list < mesh.connectivity().template numberOfRefItemList<ItemType::cell>();
        ++i_ref_cell_list) {
@@ -28,6 +28,6 @@ getMeshCellZone(const Mesh<Connectivity<Dimension>>& mesh, const IZoneDescriptor
   throw NormalError(ost.str());
 }
 
-template MeshCellZone<1> getMeshCellZone(const Mesh<Connectivity<1>>&, const IZoneDescriptor&);
-template MeshCellZone<2> getMeshCellZone(const Mesh<Connectivity<2>>&, const IZoneDescriptor&);
-template MeshCellZone<3> getMeshCellZone(const Mesh<Connectivity<3>>&, const IZoneDescriptor&);
+template MeshCellZone<1> getMeshCellZone(const Mesh<1>&, const IZoneDescriptor&);
+template MeshCellZone<2> getMeshCellZone(const Mesh<2>&, const IZoneDescriptor&);
+template MeshCellZone<3> getMeshCellZone(const Mesh<3>&, const IZoneDescriptor&);
diff --git a/src/mesh/MeshCellZone.hpp b/src/mesh/MeshCellZone.hpp
index de4903689..1f8827b1b 100644
--- a/src/mesh/MeshCellZone.hpp
+++ b/src/mesh/MeshCellZone.hpp
@@ -6,9 +6,6 @@
 #include <utils/Array.hpp>
 
 template <size_t Dimension>
-class Connectivity;
-
-template <typename ConnectivityType>
 class Mesh;
 
 template <size_t Dimension>
@@ -20,30 +17,30 @@ class [[nodiscard]] MeshCellZone   // clazy:exclude=copyable-polymorphic
 
  public:
   template <size_t MeshDimension>
-  friend MeshCellZone<MeshDimension> getMeshCellZone(const Mesh<Connectivity<MeshDimension>>& mesh,
+  friend MeshCellZone<MeshDimension> getMeshCellZone(const Mesh<MeshDimension>& mesh,
                                                      const IZoneDescriptor& zone_descriptor);
 
   MeshCellZone& operator=(const MeshCellZone&) = default;
-  MeshCellZone& operator=(MeshCellZone&&) = default;
+  MeshCellZone& operator=(MeshCellZone&&)      = default;
 
-  const Array<const CellId>& cellList() const
+  const Array<const CellId>&
+  cellList() const
   {
     return m_cell_list;
   }
 
  protected:
-  MeshCellZone(const Mesh<Connectivity<Dimension>>& mesh, const RefCellList& ref_cell_list);
+  MeshCellZone(const Mesh<Dimension>& mesh, const RefCellList& ref_cell_list);
 
  public:
   MeshCellZone(const MeshCellZone&) = default;
-  MeshCellZone(MeshCellZone &&)     = default;
+  MeshCellZone(MeshCellZone&&)      = default;
 
   MeshCellZone()          = default;
   virtual ~MeshCellZone() = default;
 };
 
 template <size_t Dimension>
-MeshCellZone<Dimension> getMeshCellZone(const Mesh<Connectivity<Dimension>>& mesh,
-                                        const IZoneDescriptor& zone_descriptor);
+MeshCellZone<Dimension> getMeshCellZone(const Mesh<Dimension>& mesh, const IZoneDescriptor& zone_descriptor);
 
 #endif   // MESH_CELL_ZONE_HPP
diff --git a/src/mesh/MeshData.hpp b/src/mesh/MeshData.hpp
index 78b9b81e6..a198aab45 100644
--- a/src/mesh/MeshData.hpp
+++ b/src/mesh/MeshData.hpp
@@ -9,9 +9,6 @@
 #include <utils/PugsUtils.hpp>
 
 template <size_t Dimension>
-class Connectivity;
-
-template <typename ConnectivityType>
 class Mesh;
 
 template <size_t Dimension>
@@ -21,7 +18,7 @@ class MeshData : public IMeshData
   static_assert(Dimension > 0, "dimension must be strictly positive");
   static_assert((Dimension <= 3), "only 1d, 2d and 3d are implemented");
 
-  using MeshType = Mesh<Connectivity<Dimension>>;
+  using MeshType = Mesh<Dimension>;
 
   using Rd = TinyVector<Dimension>;
 
diff --git a/src/mesh/MeshDataManager.cpp b/src/mesh/MeshDataManager.cpp
index def1d1b61..3607fcad6 100644
--- a/src/mesh/MeshDataManager.cpp
+++ b/src/mesh/MeshDataManager.cpp
@@ -42,7 +42,7 @@ MeshDataManager::deleteMeshData(const size_t mesh_id)
 
 template <size_t Dimension>
 MeshData<Dimension>&
-MeshDataManager::getMeshData(const Mesh<Connectivity<Dimension>>& mesh)
+MeshDataManager::getMeshData(const Mesh<Dimension>& mesh)
 {
   if (auto i_mesh_data = m_mesh_id_mesh_data_map.find(mesh.id()); i_mesh_data != m_mesh_id_mesh_data_map.end()) {
     return dynamic_cast<MeshData<Dimension>&>(*i_mesh_data->second);
@@ -55,6 +55,6 @@ MeshDataManager::getMeshData(const Mesh<Connectivity<Dimension>>& mesh)
   }
 }
 
-template MeshData<1>& MeshDataManager::getMeshData(const Mesh<Connectivity<1>>&);
-template MeshData<2>& MeshDataManager::getMeshData(const Mesh<Connectivity<2>>&);
-template MeshData<3>& MeshDataManager::getMeshData(const Mesh<Connectivity<3>>&);
+template MeshData<1>& MeshDataManager::getMeshData(const Mesh<1>&);
+template MeshData<2>& MeshDataManager::getMeshData(const Mesh<2>&);
+template MeshData<3>& MeshDataManager::getMeshData(const Mesh<3>&);
diff --git a/src/mesh/MeshDataManager.hpp b/src/mesh/MeshDataManager.hpp
index 8b1672b52..0d2bf964b 100644
--- a/src/mesh/MeshDataManager.hpp
+++ b/src/mesh/MeshDataManager.hpp
@@ -8,10 +8,7 @@
 #include <memory>
 #include <unordered_map>
 
-template <size_t>
-class Connectivity;
-
-template <typename ConnectivityType>
+template <size_t Dimension>
 class Mesh;
 
 template <size_t Dimension>
@@ -45,7 +42,7 @@ class MeshDataManager
   void deleteMeshData(const size_t mesh_id);
 
   template <size_t Dimension>
-  MeshData<Dimension>& getMeshData(const Mesh<Connectivity<Dimension>>&);
+  MeshData<Dimension>& getMeshData(const Mesh<Dimension>&);
 };
 
 #endif   // MESH_DATA_MANAGER_HPP
diff --git a/src/mesh/MeshEdgeBoundary.cpp b/src/mesh/MeshEdgeBoundary.cpp
index 0a4aed04b..0ad15dbad 100644
--- a/src/mesh/MeshEdgeBoundary.cpp
+++ b/src/mesh/MeshEdgeBoundary.cpp
@@ -9,9 +9,9 @@ template <typename MeshType>
 MeshEdgeBoundary::MeshEdgeBoundary(const MeshType&, const RefEdgeList& ref_edge_list) : m_ref_edge_list(ref_edge_list)
 {}
 
-template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<1>>&, const RefEdgeList&);
-template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<2>>&, const RefEdgeList&);
-template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<3>>&, const RefEdgeList&);
+template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<1>&, const RefEdgeList&);
+template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<2>&, const RefEdgeList&);
+template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<3>&, const RefEdgeList&);
 
 template <typename MeshType>
 MeshEdgeBoundary::MeshEdgeBoundary(const MeshType& mesh, const RefFaceList& ref_face_list)
@@ -55,8 +55,8 @@ MeshEdgeBoundary::MeshEdgeBoundary(const MeshType& mesh, const RefFaceList& ref_
   const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_edge_list);
 }
 
-template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<2>&, const RefFaceList&);
+template MeshEdgeBoundary::MeshEdgeBoundary(const Mesh<3>&, const RefFaceList&);
 
 template <typename MeshType>
 MeshEdgeBoundary
@@ -107,6 +107,6 @@ getMeshEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_de
   throw NormalError(ost.str());
 }
 
-template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&);
-template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&);
-template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&);
+template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<1>&, const IBoundaryDescriptor&);
+template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshEdgeBoundary getMeshEdgeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshEdgeInterface.cpp b/src/mesh/MeshEdgeInterface.cpp
index da4d0bc9f..55235d8c7 100644
--- a/src/mesh/MeshEdgeInterface.cpp
+++ b/src/mesh/MeshEdgeInterface.cpp
@@ -5,19 +5,19 @@
 #include <mesh/Mesh.hpp>
 #include <utils/Messenger.hpp>
 
-template <size_t Dimension>
-MeshEdgeInterface<Dimension>::MeshEdgeInterface(const Mesh<Connectivity<Dimension>>&, const RefEdgeList& ref_edge_list)
-  : m_ref_edge_list(ref_edge_list)
+template <typename MeshType>
+MeshEdgeInterface::MeshEdgeInterface(const MeshType&, const RefEdgeList& ref_edge_list) : m_ref_edge_list(ref_edge_list)
 {}
 
-template MeshEdgeInterface<1>::MeshEdgeInterface(const Mesh<Connectivity<1>>&, const RefEdgeList&);
-template MeshEdgeInterface<2>::MeshEdgeInterface(const Mesh<Connectivity<2>>&, const RefEdgeList&);
-template MeshEdgeInterface<3>::MeshEdgeInterface(const Mesh<Connectivity<3>>&, const RefEdgeList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<1>&, const RefEdgeList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<2>&, const RefEdgeList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<3>&, const RefEdgeList&);
 
-template <size_t Dimension>
-MeshEdgeInterface<Dimension>::MeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh,
-                                                const RefFaceList& ref_face_list)
+template <typename MeshType>
+MeshEdgeInterface::MeshEdgeInterface(const MeshType& mesh, const RefFaceList& ref_face_list)
 {
+  constexpr size_t Dimension = MeshType::Dimension;
+
   const Array<const FaceId>& face_list = ref_face_list.list();
   static_assert(Dimension > 1, "conversion from to edge from face is valid in dimension > 1");
 
@@ -55,13 +55,15 @@ MeshEdgeInterface<Dimension>::MeshEdgeInterface(const Mesh<Connectivity<Dimensio
   const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_edge_list);
 }
 
-template MeshEdgeInterface<2>::MeshEdgeInterface(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshEdgeInterface<3>::MeshEdgeInterface(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<2>&, const RefFaceList&);
+template MeshEdgeInterface::MeshEdgeInterface(const Mesh<3>&, const RefFaceList&);
 
-template <size_t Dimension>
-MeshEdgeInterface<Dimension>
-getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterfaceDescriptor& interface_descriptor)
+template <typename MeshType>
+MeshEdgeInterface
+getMeshEdgeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor)
 {
+  constexpr size_t Dimension = MeshType::Dimension;
+
   for (size_t i_ref_edge_list = 0; i_ref_edge_list < mesh.connectivity().template numberOfRefItemList<ItemType::edge>();
        ++i_ref_edge_list) {
     const auto& ref_edge_list = mesh.connectivity().template refItemList<ItemType::edge>(i_ref_edge_list);
@@ -76,7 +78,7 @@ getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
         throw NormalError(ost.str());
       }
 
-      return MeshEdgeInterface<Dimension>{mesh, ref_edge_list};
+      return MeshEdgeInterface{mesh, ref_edge_list};
     }
   }
   if constexpr (Dimension > 1) {
@@ -95,7 +97,7 @@ getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
           throw NormalError(ost.str());
         }
 
-        return MeshEdgeInterface<Dimension>{mesh, ref_face_list};
+        return MeshEdgeInterface{mesh, ref_face_list};
       }
     }
   }
@@ -106,6 +108,6 @@ getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
   throw NormalError(ost.str());
 }
 
-template MeshEdgeInterface<1> getMeshEdgeInterface(const Mesh<Connectivity<1>>&, const IInterfaceDescriptor&);
-template MeshEdgeInterface<2> getMeshEdgeInterface(const Mesh<Connectivity<2>>&, const IInterfaceDescriptor&);
-template MeshEdgeInterface<3> getMeshEdgeInterface(const Mesh<Connectivity<3>>&, const IInterfaceDescriptor&);
+template MeshEdgeInterface getMeshEdgeInterface(const Mesh<1>&, const IInterfaceDescriptor&);
+template MeshEdgeInterface getMeshEdgeInterface(const Mesh<2>&, const IInterfaceDescriptor&);
+template MeshEdgeInterface getMeshEdgeInterface(const Mesh<3>&, const IInterfaceDescriptor&);
diff --git a/src/mesh/MeshEdgeInterface.hpp b/src/mesh/MeshEdgeInterface.hpp
index 25226264c..45bcdbe84 100644
--- a/src/mesh/MeshEdgeInterface.hpp
+++ b/src/mesh/MeshEdgeInterface.hpp
@@ -6,52 +6,47 @@
 #include <mesh/RefItemList.hpp>
 #include <utils/Array.hpp>
 
-template <size_t Dimension>
-class Connectivity;
-
-template <typename ConnectivityType>
-class Mesh;
-
-template <size_t Dimension>
 class [[nodiscard]] MeshEdgeInterface   // clazy:exclude=copyable-polymorphic
 {
  protected:
   RefEdgeList m_ref_edge_list;
 
  public:
-  template <size_t MeshDimension>
-  friend MeshEdgeInterface<MeshDimension> getMeshEdgeInterface(const Mesh<Connectivity<MeshDimension>>& mesh,
-                                                               const IInterfaceDescriptor& interface_descriptor);
+  template <typename MeshType>
+  friend MeshEdgeInterface getMeshEdgeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
 
   MeshEdgeInterface& operator=(const MeshEdgeInterface&) = default;
-  MeshEdgeInterface& operator=(MeshEdgeInterface&&) = default;
+  MeshEdgeInterface& operator=(MeshEdgeInterface&&)      = default;
 
   PUGS_INLINE
-  const RefEdgeList& refEdgeList() const
+  const RefEdgeList&
+  refEdgeList() const
   {
     return m_ref_edge_list;
   }
 
   PUGS_INLINE
-  const Array<const EdgeId>& edgeList() const
+  const Array<const EdgeId>&
+  edgeList() const
   {
     return m_ref_edge_list.list();
   }
 
  protected:
-  MeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefEdgeList& ref_edge_list);
-  MeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list);
+  template <typename MeshType>
+  MeshEdgeInterface(const MeshType& mesh, const RefEdgeList& ref_edge_list);
+  template <typename MeshType>
+  MeshEdgeInterface(const MeshType& mesh, const RefFaceList& ref_face_list);
 
  public:
   MeshEdgeInterface(const MeshEdgeInterface&) = default;   // LCOV_EXCL_LINE
-  MeshEdgeInterface(MeshEdgeInterface &&)     = default;   // LCOV_EXCL_LINE
+  MeshEdgeInterface(MeshEdgeInterface&&)      = default;   // LCOV_EXCL_LINE
 
   MeshEdgeInterface()          = default;
   virtual ~MeshEdgeInterface() = default;
 };
 
-template <size_t Dimension>
-MeshEdgeInterface<Dimension> getMeshEdgeInterface(const Mesh<Connectivity<Dimension>>& mesh,
-                                                  const IInterfaceDescriptor& interface_descriptor);
+template <typename MeshType>
+MeshEdgeInterface getMeshEdgeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
 
 #endif   // MESH_EDGE_INTERFACE_HPP
diff --git a/src/mesh/MeshFaceBoundary.cpp b/src/mesh/MeshFaceBoundary.cpp
index 3a578bb78..d883ba63a 100644
--- a/src/mesh/MeshFaceBoundary.cpp
+++ b/src/mesh/MeshFaceBoundary.cpp
@@ -8,9 +8,9 @@ template <typename MeshType>
 MeshFaceBoundary::MeshFaceBoundary(const MeshType&, const RefFaceList& ref_face_list) : m_ref_face_list(ref_face_list)
 {}
 
-template MeshFaceBoundary::MeshFaceBoundary(const Mesh<Connectivity<1>>&, const RefFaceList&);
-template MeshFaceBoundary::MeshFaceBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshFaceBoundary::MeshFaceBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshFaceBoundary::MeshFaceBoundary(const Mesh<1>&, const RefFaceList&);
+template MeshFaceBoundary::MeshFaceBoundary(const Mesh<2>&, const RefFaceList&);
+template MeshFaceBoundary::MeshFaceBoundary(const Mesh<3>&, const RefFaceList&);
 
 template <typename MeshType>
 MeshFaceBoundary
@@ -40,6 +40,6 @@ getMeshFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_de
   throw NormalError(ost.str());
 }
 
-template MeshFaceBoundary getMeshFaceBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&);
-template MeshFaceBoundary getMeshFaceBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&);
-template MeshFaceBoundary getMeshFaceBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&);
+template MeshFaceBoundary getMeshFaceBoundary(const Mesh<1>&, const IBoundaryDescriptor&);
+template MeshFaceBoundary getMeshFaceBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshFaceBoundary getMeshFaceBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshFaceInterface.cpp b/src/mesh/MeshFaceInterface.cpp
index afb73bf18..663ac8d44 100644
--- a/src/mesh/MeshFaceInterface.cpp
+++ b/src/mesh/MeshFaceInterface.cpp
@@ -4,18 +4,17 @@
 #include <mesh/Mesh.hpp>
 #include <utils/Messenger.hpp>
 
-template <size_t Dimension>
-MeshFaceInterface<Dimension>::MeshFaceInterface(const Mesh<Connectivity<Dimension>>&, const RefFaceList& ref_face_list)
-  : m_ref_face_list(ref_face_list)
+template <typename MeshType>
+MeshFaceInterface::MeshFaceInterface(const MeshType&, const RefFaceList& ref_face_list) : m_ref_face_list(ref_face_list)
 {}
 
-template MeshFaceInterface<1>::MeshFaceInterface(const Mesh<Connectivity<1>>&, const RefFaceList&);
-template MeshFaceInterface<2>::MeshFaceInterface(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshFaceInterface<3>::MeshFaceInterface(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshFaceInterface::MeshFaceInterface(const Mesh<1>&, const RefFaceList&);
+template MeshFaceInterface::MeshFaceInterface(const Mesh<2>&, const RefFaceList&);
+template MeshFaceInterface::MeshFaceInterface(const Mesh<3>&, const RefFaceList&);
 
-template <size_t Dimension>
-MeshFaceInterface<Dimension>
-getMeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterfaceDescriptor& interface_descriptor)
+template <typename MeshType>
+MeshFaceInterface
+getMeshFaceInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor)
 {
   for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>();
        ++i_ref_face_list) {
@@ -30,7 +29,7 @@ getMeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
         throw NormalError(ost.str());
       }
 
-      return MeshFaceInterface<Dimension>{mesh, ref_face_list};
+      return MeshFaceInterface{mesh, ref_face_list};
     }
   }
 
@@ -40,6 +39,6 @@ getMeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
   throw NormalError(ost.str());
 }
 
-template MeshFaceInterface<1> getMeshFaceInterface(const Mesh<Connectivity<1>>&, const IInterfaceDescriptor&);
-template MeshFaceInterface<2> getMeshFaceInterface(const Mesh<Connectivity<2>>&, const IInterfaceDescriptor&);
-template MeshFaceInterface<3> getMeshFaceInterface(const Mesh<Connectivity<3>>&, const IInterfaceDescriptor&);
+template MeshFaceInterface getMeshFaceInterface(const Mesh<1>&, const IInterfaceDescriptor&);
+template MeshFaceInterface getMeshFaceInterface(const Mesh<2>&, const IInterfaceDescriptor&);
+template MeshFaceInterface getMeshFaceInterface(const Mesh<3>&, const IInterfaceDescriptor&);
diff --git a/src/mesh/MeshFaceInterface.hpp b/src/mesh/MeshFaceInterface.hpp
index 87d836a37..0d8277e0b 100644
--- a/src/mesh/MeshFaceInterface.hpp
+++ b/src/mesh/MeshFaceInterface.hpp
@@ -6,51 +6,45 @@
 #include <mesh/RefItemList.hpp>
 #include <utils/Array.hpp>
 
-template <size_t Dimension>
-class Connectivity;
-
-template <typename ConnectivityType>
-class Mesh;
-
-template <size_t Dimension>
 class [[nodiscard]] MeshFaceInterface   // clazy:exclude=copyable-polymorphic
 {
  protected:
   RefFaceList m_ref_face_list;
 
  public:
-  template <size_t MeshDimension>
-  friend MeshFaceInterface<MeshDimension> getMeshFaceInterface(const Mesh<Connectivity<MeshDimension>>& mesh,
-                                                               const IInterfaceDescriptor& interface_descriptor);
+  template <typename MeshType>
+  friend MeshFaceInterface getMeshFaceInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
 
   MeshFaceInterface& operator=(const MeshFaceInterface&) = default;
-  MeshFaceInterface& operator=(MeshFaceInterface&&) = default;
+  MeshFaceInterface& operator=(MeshFaceInterface&&)      = default;
 
   PUGS_INLINE
-  const RefFaceList& refFaceList() const
+  const RefFaceList&
+  refFaceList() const
   {
     return m_ref_face_list;
   }
 
   PUGS_INLINE
-  const Array<const FaceId>& faceList() const
+  const Array<const FaceId>&
+  faceList() const
   {
     return m_ref_face_list.list();
   }
 
  protected:
-  MeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list);
+  template <typename MeshType>
+  MeshFaceInterface(const MeshType& mesh, const RefFaceList& ref_face_list);
 
  public:
   MeshFaceInterface(const MeshFaceInterface&) = default;   // LCOV_EXCL_LINE
-  MeshFaceInterface(MeshFaceInterface &&)     = default;   // LCOV_EXCL_LINE
+  MeshFaceInterface(MeshFaceInterface&&)      = default;   // LCOV_EXCL_LINE
 
   MeshFaceInterface()          = default;
   virtual ~MeshFaceInterface() = default;
 };
 
-template <size_t Dimension>
-MeshFaceInterface<Dimension> getMeshFaceInterface(const Mesh<Connectivity<Dimension>>& mesh,
-                                                  const IInterfaceDescriptor& interface_descriptor);
+template <typename MeshType>
+MeshFaceInterface getMeshFaceInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
 
 #endif   // MESH_FACE_INTERFACE_HPP
diff --git a/src/mesh/MeshFlatEdgeBoundary.cpp b/src/mesh/MeshFlatEdgeBoundary.cpp
index 3783049ff..8b5669a34 100644
--- a/src/mesh/MeshFlatEdgeBoundary.cpp
+++ b/src/mesh/MeshFlatEdgeBoundary.cpp
@@ -15,9 +15,6 @@ getMeshFlatEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
                                               mesh_flat_node_boundary.outgoingNormal()};
 }
 
-template MeshFlatEdgeBoundary<const Mesh<Connectivity<1>>> getMeshFlatEdgeBoundary(const Mesh<Connectivity<1>>&,
-                                                                                   const IBoundaryDescriptor&);
-template MeshFlatEdgeBoundary<const Mesh<Connectivity<2>>> getMeshFlatEdgeBoundary(const Mesh<Connectivity<2>>&,
-                                                                                   const IBoundaryDescriptor&);
-template MeshFlatEdgeBoundary<const Mesh<Connectivity<3>>> getMeshFlatEdgeBoundary(const Mesh<Connectivity<3>>&,
-                                                                                   const IBoundaryDescriptor&);
+template MeshFlatEdgeBoundary<const Mesh<1>> getMeshFlatEdgeBoundary(const Mesh<1>&, const IBoundaryDescriptor&);
+template MeshFlatEdgeBoundary<const Mesh<2>> getMeshFlatEdgeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshFlatEdgeBoundary<const Mesh<3>> getMeshFlatEdgeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshFlatFaceBoundary.cpp b/src/mesh/MeshFlatFaceBoundary.cpp
index e05373897..12d7f439f 100644
--- a/src/mesh/MeshFlatFaceBoundary.cpp
+++ b/src/mesh/MeshFlatFaceBoundary.cpp
@@ -15,9 +15,6 @@ getMeshFlatFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
                                               mesh_flat_node_boundary.outgoingNormal()};
 }
 
-template MeshFlatFaceBoundary<const Mesh<Connectivity<1>>> getMeshFlatFaceBoundary(const Mesh<Connectivity<1>>&,
-                                                                                   const IBoundaryDescriptor&);
-template MeshFlatFaceBoundary<const Mesh<Connectivity<2>>> getMeshFlatFaceBoundary(const Mesh<Connectivity<2>>&,
-                                                                                   const IBoundaryDescriptor&);
-template MeshFlatFaceBoundary<const Mesh<Connectivity<3>>> getMeshFlatFaceBoundary(const Mesh<Connectivity<3>>&,
-                                                                                   const IBoundaryDescriptor&);
+template MeshFlatFaceBoundary<const Mesh<1>> getMeshFlatFaceBoundary(const Mesh<1>&, const IBoundaryDescriptor&);
+template MeshFlatFaceBoundary<const Mesh<2>> getMeshFlatFaceBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshFlatFaceBoundary<const Mesh<3>> getMeshFlatFaceBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshFlatNodeBoundary.cpp b/src/mesh/MeshFlatNodeBoundary.cpp
index 3ee564332..df7631988 100644
--- a/src/mesh/MeshFlatNodeBoundary.cpp
+++ b/src/mesh/MeshFlatNodeBoundary.cpp
@@ -34,7 +34,7 @@ MeshFlatNodeBoundary<MeshType>::_checkBoundaryIsFlat(const TinyVector<MeshType::
 
 template <>
 TinyVector<1, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<1>>>::_getNormal(const Mesh<Connectivity<1>>& mesh)
+MeshFlatNodeBoundary<const Mesh<1>>::_getNormal(const Mesh<1>& mesh)
 {
   using R = TinyVector<1, double>;
 
@@ -60,7 +60,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<1>>>::_getNormal(const Mesh<Connect
 
 template <>
 TinyVector<2, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getNormal(const Mesh<Connectivity<2>>& mesh)
+MeshFlatNodeBoundary<const Mesh<2>>::_getNormal(const Mesh<2>& mesh)
 {
   using R2 = TinyVector<2, double>;
 
@@ -88,9 +88,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getNormal(const Mesh<Connect
 
 template <>
 TinyVector<3, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getFarestNode(const Mesh<Connectivity<3>>& mesh,
-                                                                  const Rd& x0,
-                                                                  const Rd& x1)
+MeshFlatNodeBoundary<const Mesh<3>>::_getFarestNode(const Mesh<3>& mesh, const Rd& x0, const Rd& x1)
 {
   const NodeValue<const Rd>& xr = mesh.xr();
   const auto node_number        = mesh.connectivity().nodeNumber();
@@ -141,7 +139,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getFarestNode(const Mesh<Con
 
 template <>
 TinyVector<3, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getNormal(const Mesh<Connectivity<3>>& mesh)
+MeshFlatNodeBoundary<const Mesh<3>>::_getNormal(const Mesh<3>& mesh)
 {
   using R3 = TinyVector<3, double>;
 
@@ -198,7 +196,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getNormal(const Mesh<Connect
 
 template <>
 TinyVector<1, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<1>>>::_getOutgoingNormal(const Mesh<Connectivity<1>>& mesh)
+MeshFlatNodeBoundary<const Mesh<1>>::_getOutgoingNormal(const Mesh<1>& mesh)
 {
   using R = TinyVector<1, double>;
 
@@ -241,7 +239,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<1>>>::_getOutgoingNormal(const Mesh
 
 template <>
 TinyVector<2, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getOutgoingNormal(const Mesh<Connectivity<2>>& mesh)
+MeshFlatNodeBoundary<const Mesh<2>>::_getOutgoingNormal(const Mesh<2>& mesh)
 {
   using R2 = TinyVector<2, double>;
 
@@ -284,7 +282,7 @@ MeshFlatNodeBoundary<const Mesh<Connectivity<2>>>::_getOutgoingNormal(const Mesh
 
 template <>
 TinyVector<3, double>
-MeshFlatNodeBoundary<const Mesh<Connectivity<3>>>::_getOutgoingNormal(const Mesh<Connectivity<3>>& mesh)
+MeshFlatNodeBoundary<const Mesh<3>>::_getOutgoingNormal(const Mesh<3>& mesh)
 {
   using R3 = TinyVector<3, double>;
 
@@ -352,9 +350,6 @@ getMeshFlatNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
   throw NormalError(ost.str());
 }
 
-template MeshFlatNodeBoundary<const Mesh<Connectivity<1>>> getMeshFlatNodeBoundary(const Mesh<Connectivity<1>>&,
-                                                                                   const IBoundaryDescriptor&);
-template MeshFlatNodeBoundary<const Mesh<Connectivity<2>>> getMeshFlatNodeBoundary(const Mesh<Connectivity<2>>&,
-                                                                                   const IBoundaryDescriptor&);
-template MeshFlatNodeBoundary<const Mesh<Connectivity<3>>> getMeshFlatNodeBoundary(const Mesh<Connectivity<3>>&,
-                                                                                   const IBoundaryDescriptor&);
+template MeshFlatNodeBoundary<const Mesh<1>> getMeshFlatNodeBoundary(const Mesh<1>&, const IBoundaryDescriptor&);
+template MeshFlatNodeBoundary<const Mesh<2>> getMeshFlatNodeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshFlatNodeBoundary<const Mesh<3>> getMeshFlatNodeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshLineEdgeBoundary.cpp b/src/mesh/MeshLineEdgeBoundary.cpp
index 31c4bb524..1d0c37526 100644
--- a/src/mesh/MeshLineEdgeBoundary.cpp
+++ b/src/mesh/MeshLineEdgeBoundary.cpp
@@ -16,7 +16,5 @@ getMeshLineEdgeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
                                               mesh_line_node_boundary.direction()};
 }
 
-template MeshLineEdgeBoundary<const Mesh<Connectivity<2>>> getMeshLineEdgeBoundary(const Mesh<Connectivity<2>>&,
-                                                                                   const IBoundaryDescriptor&);
-template MeshLineEdgeBoundary<const Mesh<Connectivity<3>>> getMeshLineEdgeBoundary(const Mesh<Connectivity<3>>&,
-                                                                                   const IBoundaryDescriptor&);
+template MeshLineEdgeBoundary<const Mesh<2>> getMeshLineEdgeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshLineEdgeBoundary<const Mesh<3>> getMeshLineEdgeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshLineFaceBoundary.cpp b/src/mesh/MeshLineFaceBoundary.cpp
index e81aef554..83bfdf8cf 100644
--- a/src/mesh/MeshLineFaceBoundary.cpp
+++ b/src/mesh/MeshLineFaceBoundary.cpp
@@ -16,5 +16,4 @@ getMeshLineFaceBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
                                               mesh_line_node_boundary.direction()};
 }
 
-template MeshLineFaceBoundary<const Mesh<Connectivity<2>>> getMeshLineFaceBoundary(const Mesh<Connectivity<2>>&,
-                                                                                   const IBoundaryDescriptor&);
+template MeshLineFaceBoundary<const Mesh<2>> getMeshLineFaceBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshLineNodeBoundary.cpp b/src/mesh/MeshLineNodeBoundary.cpp
index a03c6102b..dd145d889 100644
--- a/src/mesh/MeshLineNodeBoundary.cpp
+++ b/src/mesh/MeshLineNodeBoundary.cpp
@@ -38,7 +38,7 @@ MeshLineNodeBoundary<MeshType>::_checkBoundaryIsLine(const TinyVector<MeshType::
 
 template <>
 TinyVector<2>
-MeshLineNodeBoundary<const Mesh<Connectivity<2>>>::_getDirection(const Mesh<Connectivity<2>>& mesh)
+MeshLineNodeBoundary<const Mesh<2>>::_getDirection(const Mesh<2>& mesh)
 {
   using R2 = TinyVector<2, double>;
 
@@ -65,7 +65,7 @@ MeshLineNodeBoundary<const Mesh<Connectivity<2>>>::_getDirection(const Mesh<Conn
 
 template <>
 TinyVector<3>
-MeshLineNodeBoundary<const Mesh<Connectivity<3>>>::_getDirection(const Mesh<Connectivity<3>>& mesh)
+MeshLineNodeBoundary<const Mesh<3>>::_getDirection(const Mesh<3>& mesh)
 {
   using R3 = TinyVector<3, double>;
 
@@ -140,7 +140,5 @@ getMeshLineNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundar
   throw NormalError(ost.str());
 }
 
-template MeshLineNodeBoundary<const Mesh<Connectivity<2>>> getMeshLineNodeBoundary(const Mesh<Connectivity<2>>&,
-                                                                                   const IBoundaryDescriptor&);
-template MeshLineNodeBoundary<const Mesh<Connectivity<3>>> getMeshLineNodeBoundary(const Mesh<Connectivity<3>>&,
-                                                                                   const IBoundaryDescriptor&);
+template MeshLineNodeBoundary<const Mesh<2>> getMeshLineNodeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshLineNodeBoundary<const Mesh<3>> getMeshLineNodeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshNodeBoundary.cpp b/src/mesh/MeshNodeBoundary.cpp
index 97f32e9d4..e750580ce 100644
--- a/src/mesh/MeshNodeBoundary.cpp
+++ b/src/mesh/MeshNodeBoundary.cpp
@@ -109,17 +109,17 @@ MeshNodeBoundary::MeshNodeBoundary(const MeshType&, const RefNodeList& ref_node_
   }
 }
 
-template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<1>>&, const RefFaceList&);
-template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<1>&, const RefFaceList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<2>&, const RefFaceList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<3>&, const RefFaceList&);
 
-template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<1>>&, const RefEdgeList&);
-template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<2>>&, const RefEdgeList&);
-template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<3>>&, const RefEdgeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<1>&, const RefEdgeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<2>&, const RefEdgeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<3>&, const RefEdgeList&);
 
-template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<1>>&, const RefNodeList&);
-template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<2>>&, const RefNodeList&);
-template MeshNodeBoundary::MeshNodeBoundary(const Mesh<Connectivity<3>>&, const RefNodeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<1>&, const RefNodeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<2>&, const RefNodeList&);
+template MeshNodeBoundary::MeshNodeBoundary(const Mesh<3>&, const RefNodeList&);
 
 template <typename MeshType>
 MeshNodeBoundary
@@ -156,6 +156,6 @@ getMeshNodeBoundary(const MeshType& mesh, const IBoundaryDescriptor& boundary_de
   throw NormalError(ost.str());
 }
 
-template MeshNodeBoundary getMeshNodeBoundary(const Mesh<Connectivity<1>>&, const IBoundaryDescriptor&);
-template MeshNodeBoundary getMeshNodeBoundary(const Mesh<Connectivity<2>>&, const IBoundaryDescriptor&);
-template MeshNodeBoundary getMeshNodeBoundary(const Mesh<Connectivity<3>>&, const IBoundaryDescriptor&);
+template MeshNodeBoundary getMeshNodeBoundary(const Mesh<1>&, const IBoundaryDescriptor&);
+template MeshNodeBoundary getMeshNodeBoundary(const Mesh<2>&, const IBoundaryDescriptor&);
+template MeshNodeBoundary getMeshNodeBoundary(const Mesh<3>&, const IBoundaryDescriptor&);
diff --git a/src/mesh/MeshNodeBoundaryUtils.cpp b/src/mesh/MeshNodeBoundaryUtils.cpp
index 63df3e364..d6a0e31cd 100644
--- a/src/mesh/MeshNodeBoundaryUtils.cpp
+++ b/src/mesh/MeshNodeBoundaryUtils.cpp
@@ -6,7 +6,7 @@
 
 template <>
 std::array<TinyVector<2>, 2>
-getBounds(const Mesh<Connectivity<2>>& mesh, const RefNodeList& ref_node_list)
+getBounds(const Mesh<2>& mesh, const RefNodeList& ref_node_list)
 {
   using R2 = TinyVector<2, double>;
 
@@ -54,7 +54,7 @@ getBounds(const Mesh<Connectivity<2>>& mesh, const RefNodeList& ref_node_list)
 
 template <>
 std::array<TinyVector<3>, 6>
-getBounds(const Mesh<Connectivity<3>>& mesh, const RefNodeList& ref_node_list)
+getBounds(const Mesh<3>& mesh, const RefNodeList& ref_node_list)
 {
   using R3 = TinyVector<3, double>;
 
diff --git a/src/mesh/MeshNodeInterface.cpp b/src/mesh/MeshNodeInterface.cpp
index 84a5b2669..1703f36a0 100644
--- a/src/mesh/MeshNodeInterface.cpp
+++ b/src/mesh/MeshNodeInterface.cpp
@@ -1,14 +1,16 @@
 #include <mesh/MeshNodeInterface.hpp>
 
 #include <Kokkos_Vector.hpp>
-#include <mesh/Connectivity.hpp>
 #include <mesh/Mesh.hpp>
+#include <mesh/MeshTraits.hpp>
 #include <utils/Messenger.hpp>
 
-template <size_t Dimension>
-MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh,
-                                                const RefFaceList& ref_face_list)
+template <typename MeshType>
+MeshNodeInterface::MeshNodeInterface(const MeshType& mesh, const RefFaceList& ref_face_list)
 {
+  static_assert(is_polygonal_mesh<MeshType>);
+  constexpr size_t Dimension = MeshType::Dimension;
+
   const Array<const FaceId>& face_list = ref_face_list.list();
   if (ref_face_list.type() != RefItemListBase::Type::interface) {
     std::ostringstream ost;
@@ -51,10 +53,12 @@ MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimensio
   const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_node_list);
 }
 
-template <size_t Dimension>
-MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh,
-                                                const RefEdgeList& ref_edge_list)
+template <typename MeshType>
+MeshNodeInterface::MeshNodeInterface(const MeshType& mesh, const RefEdgeList& ref_edge_list)
 {
+  static_assert(is_polygonal_mesh<MeshType>);
+  constexpr size_t Dimension = MeshType::Dimension;
+
   const Array<const EdgeId>& edge_list = ref_edge_list.list();
   if (ref_edge_list.type() != RefItemListBase::Type::interface) {
     std::ostringstream ost;
@@ -96,9 +100,8 @@ MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimensio
   const_cast<Connectivity<Dimension>&>(mesh.connectivity()).addRefItemList(m_ref_node_list);
 }
 
-template <size_t Dimension>
-MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimension>>&, const RefNodeList& ref_node_list)
-  : m_ref_node_list(ref_node_list)
+template <typename MeshType>
+MeshNodeInterface::MeshNodeInterface(const MeshType&, const RefNodeList& ref_node_list) : m_ref_node_list(ref_node_list)
 {
   if (ref_node_list.type() != RefItemListBase::Type::interface) {
     std::ostringstream ost;
@@ -108,28 +111,28 @@ MeshNodeInterface<Dimension>::MeshNodeInterface(const Mesh<Connectivity<Dimensio
   }
 }
 
-template MeshNodeInterface<1>::MeshNodeInterface(const Mesh<Connectivity<1>>&, const RefFaceList&);
-template MeshNodeInterface<2>::MeshNodeInterface(const Mesh<Connectivity<2>>&, const RefFaceList&);
-template MeshNodeInterface<3>::MeshNodeInterface(const Mesh<Connectivity<3>>&, const RefFaceList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<1>&, const RefFaceList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<2>&, const RefFaceList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<3>&, const RefFaceList&);
 
-template MeshNodeInterface<1>::MeshNodeInterface(const Mesh<Connectivity<1>>&, const RefEdgeList&);
-template MeshNodeInterface<2>::MeshNodeInterface(const Mesh<Connectivity<2>>&, const RefEdgeList&);
-template MeshNodeInterface<3>::MeshNodeInterface(const Mesh<Connectivity<3>>&, const RefEdgeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<1>&, const RefEdgeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<2>&, const RefEdgeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<3>&, const RefEdgeList&);
 
-template MeshNodeInterface<1>::MeshNodeInterface(const Mesh<Connectivity<1>>&, const RefNodeList&);
-template MeshNodeInterface<2>::MeshNodeInterface(const Mesh<Connectivity<2>>&, const RefNodeList&);
-template MeshNodeInterface<3>::MeshNodeInterface(const Mesh<Connectivity<3>>&, const RefNodeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<1>&, const RefNodeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<2>&, const RefNodeList&);
+template MeshNodeInterface::MeshNodeInterface(const Mesh<3>&, const RefNodeList&);
 
-template <size_t Dimension>
-MeshNodeInterface<Dimension>
-getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterfaceDescriptor& interface_descriptor)
+template <typename MeshType>
+MeshNodeInterface
+getMeshNodeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor)
 {
   for (size_t i_ref_node_list = 0; i_ref_node_list < mesh.connectivity().template numberOfRefItemList<ItemType::node>();
        ++i_ref_node_list) {
     const auto& ref_node_list = mesh.connectivity().template refItemList<ItemType::node>(i_ref_node_list);
     const RefId& ref          = ref_node_list.refId();
     if (ref == interface_descriptor) {
-      return MeshNodeInterface<Dimension>{mesh, ref_node_list};
+      return MeshNodeInterface{mesh, ref_node_list};
     }
   }
   for (size_t i_ref_edge_list = 0; i_ref_edge_list < mesh.connectivity().template numberOfRefItemList<ItemType::edge>();
@@ -137,7 +140,7 @@ getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
     const auto& ref_edge_list = mesh.connectivity().template refItemList<ItemType::edge>(i_ref_edge_list);
     const RefId& ref          = ref_edge_list.refId();
     if (ref == interface_descriptor) {
-      return MeshNodeInterface<Dimension>{mesh, ref_edge_list};
+      return MeshNodeInterface{mesh, ref_edge_list};
     }
   }
   for (size_t i_ref_face_list = 0; i_ref_face_list < mesh.connectivity().template numberOfRefItemList<ItemType::face>();
@@ -145,7 +148,7 @@ getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
     const auto& ref_face_list = mesh.connectivity().template refItemList<ItemType::face>(i_ref_face_list);
     const RefId& ref          = ref_face_list.refId();
     if (ref == interface_descriptor) {
-      return MeshNodeInterface<Dimension>{mesh, ref_face_list};
+      return MeshNodeInterface{mesh, ref_face_list};
     }
   }
 
@@ -155,6 +158,6 @@ getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const IInterface
   throw NormalError(ost.str());
 }
 
-template MeshNodeInterface<1> getMeshNodeInterface(const Mesh<Connectivity<1>>&, const IInterfaceDescriptor&);
-template MeshNodeInterface<2> getMeshNodeInterface(const Mesh<Connectivity<2>>&, const IInterfaceDescriptor&);
-template MeshNodeInterface<3> getMeshNodeInterface(const Mesh<Connectivity<3>>&, const IInterfaceDescriptor&);
+template MeshNodeInterface getMeshNodeInterface(const Mesh<1>&, const IInterfaceDescriptor&);
+template MeshNodeInterface getMeshNodeInterface(const Mesh<2>&, const IInterfaceDescriptor&);
+template MeshNodeInterface getMeshNodeInterface(const Mesh<3>&, const IInterfaceDescriptor&);
diff --git a/src/mesh/MeshNodeInterface.hpp b/src/mesh/MeshNodeInterface.hpp
index 8fcbb6704..4eaafd06b 100644
--- a/src/mesh/MeshNodeInterface.hpp
+++ b/src/mesh/MeshNodeInterface.hpp
@@ -6,56 +6,49 @@
 #include <mesh/RefItemList.hpp>
 #include <utils/Array.hpp>
 
-template <size_t Dimension>
-class Connectivity;
-
-template <typename ConnectivityType>
-class Mesh;
-
-template <size_t Dimension>
 class [[nodiscard]] MeshNodeInterface   // clazy:exclude=copyable-polymorphic
 {
  protected:
   RefNodeList m_ref_node_list;
 
-  std::array<TinyVector<Dimension>, Dimension*(Dimension - 1)> _getBounds(const Mesh<Connectivity<Dimension>>& mesh)
-    const;
-
  public:
-  template <size_t MeshDimension>
-  friend MeshNodeInterface<MeshDimension> getMeshNodeInterface(const Mesh<Connectivity<MeshDimension>>& mesh,
-                                                               const IInterfaceDescriptor& interface_descriptor);
+  template <typename MeshType>
+  friend MeshNodeInterface getMeshNodeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
 
   MeshNodeInterface& operator=(const MeshNodeInterface&) = default;
-  MeshNodeInterface& operator=(MeshNodeInterface&&) = default;
+  MeshNodeInterface& operator=(MeshNodeInterface&&)      = default;
 
   PUGS_INLINE
-  const RefNodeList& refNodeList() const
+  const RefNodeList&
+  refNodeList() const
   {
     return m_ref_node_list;
   }
 
   PUGS_INLINE
-  const Array<const NodeId>& nodeList() const
+  const Array<const NodeId>&
+  nodeList() const
   {
     return m_ref_node_list.list();
   }
 
  protected:
-  MeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefFaceList& ref_face_list);
-  MeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh, const RefEdgeList& ref_edge_list);
-  MeshNodeInterface(const Mesh<Connectivity<Dimension>>&, const RefNodeList& ref_node_list);
+  template <typename MeshType>
+  MeshNodeInterface(const MeshType& mesh, const RefFaceList& ref_face_list);
+  template <typename MeshType>
+  MeshNodeInterface(const MeshType& mesh, const RefEdgeList& ref_edge_list);
+  template <typename MeshType>
+  MeshNodeInterface(const MeshType&, const RefNodeList& ref_node_list);
 
  public:
   MeshNodeInterface(const MeshNodeInterface&) = default;
-  MeshNodeInterface(MeshNodeInterface &&)     = default;
+  MeshNodeInterface(MeshNodeInterface&&)      = default;
 
   MeshNodeInterface()          = default;
   virtual ~MeshNodeInterface() = default;
 };
 
-template <size_t Dimension>
-MeshNodeInterface<Dimension> getMeshNodeInterface(const Mesh<Connectivity<Dimension>>& mesh,
-                                                  const IInterfaceDescriptor& interface_descriptor);
+template <typename MeshType>
+MeshNodeInterface getMeshNodeInterface(const MeshType& mesh, const IInterfaceDescriptor& interface_descriptor);
 
 #endif   // MESH_NODE_INTERFACE_HPP
diff --git a/src/mesh/MeshRandomizer.cpp b/src/mesh/MeshRandomizer.cpp
index 9a2a56d5a..a5b0e0351 100644
--- a/src/mesh/MeshRandomizer.cpp
+++ b/src/mesh/MeshRandomizer.cpp
@@ -306,7 +306,7 @@ class MeshRandomizerHandler::MeshRandomizer<MeshType>::AxisBoundaryCondition
 };
 
 template <>
-class MeshRandomizerHandler::MeshRandomizer<Mesh<Connectivity<1>>>::AxisBoundaryCondition
+class MeshRandomizerHandler::MeshRandomizer<Mesh<1>>::AxisBoundaryCondition
 {
  public:
   AxisBoundaryCondition()  = default;
diff --git a/src/mesh/MeshRelaxer.hpp b/src/mesh/MeshRelaxer.hpp
index deb9f8a4a..1e2b08206 100644
--- a/src/mesh/MeshRelaxer.hpp
+++ b/src/mesh/MeshRelaxer.hpp
@@ -3,9 +3,6 @@
 
 class MeshVariant;
 
-template <typename ConnectivityType>
-class Mesh;
-
 #include <memory>
 
 class MeshRelaxer
diff --git a/src/mesh/MeshSmoother.cpp b/src/mesh/MeshSmoother.cpp
index d90b95a4d..5eee712d8 100644
--- a/src/mesh/MeshSmoother.cpp
+++ b/src/mesh/MeshSmoother.cpp
@@ -353,7 +353,7 @@ class MeshSmootherHandler::MeshSmoother<MeshType>::AxisBoundaryCondition
 };
 
 template <>
-class MeshSmootherHandler::MeshSmoother<Mesh<Connectivity<1>>>::AxisBoundaryCondition
+class MeshSmootherHandler::MeshSmoother<Mesh<1>>::AxisBoundaryCondition
 {
  public:
   AxisBoundaryCondition()  = default;
diff --git a/src/mesh/MeshTraits.hpp b/src/mesh/MeshTraits.hpp
index 62ea22825..bf1a8a8f9 100644
--- a/src/mesh/MeshTraits.hpp
+++ b/src/mesh/MeshTraits.hpp
@@ -3,19 +3,16 @@
 
 #include <cstddef>
 
-template <size_t>
-class Connectivity;
-
-template <typename ConnectivityType>
+template <size_t Dimension>
 class Mesh;
 
 template <typename MeshType>
 constexpr inline bool is_polygonal_mesh = false;
 
 template <size_t Dimension>
-constexpr inline bool is_polygonal_mesh<Mesh<Connectivity<Dimension>>> = true;
+constexpr inline bool is_polygonal_mesh<Mesh<Dimension>> = true;
 
 template <size_t Dimension>
-constexpr inline bool is_polygonal_mesh<const Mesh<Connectivity<Dimension>>> = true;
+constexpr inline bool is_polygonal_mesh<const Mesh<Dimension>> = true;
 
 #endif   // MESH_TRAITS_HPP
diff --git a/src/mesh/MeshVariant.hpp b/src/mesh/MeshVariant.hpp
index bcc57e4cb..53e432795 100644
--- a/src/mesh/MeshVariant.hpp
+++ b/src/mesh/MeshVariant.hpp
@@ -7,18 +7,15 @@
 #include <memory>
 #include <variant>
 
-template <size_t>
-class Connectivity;
-
-template <typename ConnectivityType>
+template <size_t Dimension>
 class Mesh;
 
 class MeshVariant
 {
  private:
-  using Variant = std::variant<std::shared_ptr<const Mesh<Connectivity<1>>>,
-                               std::shared_ptr<const Mesh<Connectivity<2>>>,
-                               std::shared_ptr<const Mesh<Connectivity<3>>>>;
+  using Variant = std::variant<std::shared_ptr<const Mesh<1>>,   //
+                               std::shared_ptr<const Mesh<2>>,   //
+                               std::shared_ptr<const Mesh<3>>>;
 
   Variant m_p_mesh;
 
diff --git a/src/scheme/AcousticSolver.cpp b/src/scheme/AcousticSolver.cpp
index e60372f0c..3cd71fe5d 100644
--- a/src/scheme/AcousticSolver.cpp
+++ b/src/scheme/AcousticSolver.cpp
@@ -26,7 +26,7 @@ template <size_t Dimension>
 double
 acoustic_dt(const DiscreteFunctionP0<Dimension, const double>& c)
 {
-  const Mesh<Connectivity<Dimension>>& mesh = dynamic_cast<const Mesh<Connectivity<Dimension>>&>(*c.mesh());
+  const Mesh<Dimension>& mesh = dynamic_cast<const Mesh<Dimension>&>(*c.mesh());
 
   const auto Vj = MeshDataManager::instance().getMeshData(mesh).Vj();
   const auto Sj = MeshDataManager::instance().getMeshData(mesh).sumOverRLjr();
@@ -205,7 +205,7 @@ class AcousticSolverHandler::AcousticSolver final : public AcousticSolverHandler
   }
 
   NodeValue<Rd>
-  _computeBr(const Mesh<Connectivity<Dimension>>& mesh,
+  _computeBr(const Mesh<Dimension>& mesh,
              const NodeValuePerCell<const Rdxd>& Ajr,
              const DiscreteVectorFunction& u,
              const DiscreteScalarFunction& p) const
@@ -735,7 +735,7 @@ class AcousticSolverHandler::AcousticSolver<MeshType>::PressureBoundaryCondition
 };
 
 template <>
-class AcousticSolverHandler::AcousticSolver<const Mesh<Connectivity<1>>>::PressureBoundaryCondition
+class AcousticSolverHandler::AcousticSolver<const Mesh<1>>::PressureBoundaryCondition
 {
  private:
   const MeshNodeBoundary m_mesh_node_boundary;
@@ -794,7 +794,7 @@ class AcousticSolverHandler::AcousticSolver<MeshType>::ExternalFSIVelocityBounda
     return m_value_list;
   }
 
-  ExternalFSIVelocityBoundaryCondition(const Mesh<Connectivity<Dimension>>& mesh,
+  ExternalFSIVelocityBoundaryCondition(const Mesh<Dimension>& mesh,
                                        const MeshNodeBoundary& mesh_node_boundary,
                                        const std::shared_ptr<const Socket>& socket)
     : m_node_to_cell_matrix{mesh.connectivity().nodeToCellMatrix()},
diff --git a/src/scheme/DiscreteFunctionP0.hpp b/src/scheme/DiscreteFunctionP0.hpp
index 0e11b608a..9f7fc39c5 100644
--- a/src/scheme/DiscreteFunctionP0.hpp
+++ b/src/scheme/DiscreteFunctionP0.hpp
@@ -3,7 +3,6 @@
 
 #include <language/utils/ASTNodeDataTypeTraits.hpp>
 
-#include <mesh/Connectivity.hpp>
 #include <mesh/ItemValueUtils.hpp>
 #include <mesh/Mesh.hpp>
 #include <mesh/MeshData.hpp>
@@ -16,7 +15,7 @@ class DiscreteFunctionP0
 {
  public:
   using data_type = DataType;
-  using MeshType  = Mesh<Connectivity<Dimension>>;
+  using MeshType  = Mesh<Dimension>;
 
   friend class DiscreteFunctionP0<Dimension, std::add_const_t<DataType>>;
   friend class DiscreteFunctionP0<Dimension, std::remove_const_t<DataType>>;
@@ -714,8 +713,8 @@ class DiscreteFunctionP0
   {
     Assert(f.m_cell_values.isBuilt());
 
-    const Mesh<Connectivity<Dimension>>& mesh = *f.m_mesh;
-    CellValue<const double> cell_volume       = MeshDataManager::instance().getMeshData(mesh).Vj();
+    const Mesh<Dimension>& mesh         = *f.m_mesh;
+    CellValue<const double> cell_volume = MeshDataManager::instance().getMeshData(mesh).Vj();
 
     CellValue<std::remove_const_t<DataType>> f_v{mesh.connectivity()};
     parallel_for(
diff --git a/src/scheme/DiscreteFunctionP0Vector.hpp b/src/scheme/DiscreteFunctionP0Vector.hpp
index 7801626a4..ada6df3ad 100644
--- a/src/scheme/DiscreteFunctionP0Vector.hpp
+++ b/src/scheme/DiscreteFunctionP0Vector.hpp
@@ -2,7 +2,6 @@
 #define DISCRETE_FUNCTION_P0_VECTOR_HPP
 
 #include <algebra/Vector.hpp>
-#include <mesh/Connectivity.hpp>
 #include <mesh/ItemArray.hpp>
 #include <mesh/Mesh.hpp>
 #include <mesh/MeshData.hpp>
@@ -16,7 +15,7 @@ class DiscreteFunctionP0Vector
 {
  public:
   using data_type = DataType;
-  using MeshType  = Mesh<Connectivity<Dimension>>;
+  using MeshType  = Mesh<Dimension>;
 
   friend class DiscreteFunctionP0Vector<Dimension, std::add_const_t<DataType>>;
   friend class DiscreteFunctionP0Vector<Dimension, std::remove_const_t<DataType>>;
diff --git a/src/scheme/FluxingAdvectionSolver.cpp b/src/scheme/FluxingAdvectionSolver.cpp
index 25d9cf3de..0ee4e25f5 100644
--- a/src/scheme/FluxingAdvectionSolver.cpp
+++ b/src/scheme/FluxingAdvectionSolver.cpp
@@ -96,7 +96,7 @@ class FluxingAdvectionSolver
   _storeValueBCList(const size_t i_quantity,
                     const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_list)
   {
-    const Mesh<Connectivity<Dimension>>& mesh = *m_old_mesh;
+    const Mesh<Dimension>& mesh = *m_old_mesh;
 
     for (auto& i_bc : bc_list) {
       switch (i_bc->type()) {
@@ -139,7 +139,7 @@ class FluxingAdvectionSolver
   _storeArrayBCList(const size_t i_quantity,
                     const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_list)
   {
-    const Mesh<Connectivity<Dimension>>& mesh = *m_old_mesh;
+    const Mesh<Dimension>& mesh = *m_old_mesh;
 
     for (auto& i_bc : bc_list) {
       switch (i_bc->type()) {
@@ -240,8 +240,7 @@ FluxingAdvectionSolver<MeshType>::_computeDonorCells(FaceValue<const double> alg
 
 template <>
 void
-FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeDonorCells(
-  FaceValue<const double> algebraic_fluxing_volumes)
+FluxingAdvectionSolver<const Mesh<1>>::_computeDonorCells(FaceValue<const double> algebraic_fluxing_volumes)
 {
   m_donnor_cell = [&] {
     const auto face_to_cell_matrix = m_new_mesh->connectivity().faceToCellMatrix();
@@ -275,7 +274,7 @@ FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeDonorCells(
 
 template <>
 FaceValue<double>
-FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeAlgebraicFluxingVolume()
+FluxingAdvectionSolver<const Mesh<1>>::_computeAlgebraicFluxingVolume()
 {
   Array<double> fluxing_volumes{m_new_mesh->numberOfNodes()};
   NodeValue<double> nodal_fluxing_volume(m_new_mesh->connectivity(), fluxing_volumes);
@@ -294,7 +293,7 @@ FluxingAdvectionSolver<const Mesh<Connectivity<1>>>::_computeAlgebraicFluxingVol
 
 template <>
 FaceValue<double>
-FluxingAdvectionSolver<const Mesh<Connectivity<2>>>::_computeAlgebraicFluxingVolume()
+FluxingAdvectionSolver<const Mesh<2>>::_computeAlgebraicFluxingVolume()
 {
   const auto face_to_node_matrix = m_old_mesh->connectivity().faceToNodeMatrix();
   FaceValue<double> algebraic_fluxing_volume(m_new_mesh->connectivity());
@@ -321,7 +320,7 @@ FluxingAdvectionSolver<const Mesh<Connectivity<2>>>::_computeAlgebraicFluxingVol
 
 template <>
 FaceValue<double>
-FluxingAdvectionSolver<const Mesh<Connectivity<3>>>::_computeAlgebraicFluxingVolume()
+FluxingAdvectionSolver<const Mesh<3>>::_computeAlgebraicFluxingVolume()
 {
   // due to the z component of the jacobian determinant, degree 3
   // polynomials must be exactly integrated
diff --git a/src/scheme/HyperelasticSolver.cpp b/src/scheme/HyperelasticSolver.cpp
index 1e0654aeb..edd4e4950 100644
--- a/src/scheme/HyperelasticSolver.cpp
+++ b/src/scheme/HyperelasticSolver.cpp
@@ -209,7 +209,7 @@ class HyperelasticSolverHandler::HyperelasticSolver final : public HyperelasticS
   }
 
   NodeValue<Rd>
-  _computeBr(const Mesh<Connectivity<Dimension>>& mesh,
+  _computeBr(const Mesh<Dimension>& mesh,
              const NodeValuePerCell<const Rdxd>& Ajr,
              const DiscreteVectorFunction& u,
              const DiscreteTensorFunction& sigma) const
@@ -800,7 +800,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::PressureBoundaryC
 };
 
 template <>
-class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<Connectivity<1>>>::PressureBoundaryCondition
+class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<1>>::PressureBoundaryCondition
 {
  private:
   const MeshNodeBoundary m_mesh_node_boundary;
@@ -854,7 +854,7 @@ class HyperelasticSolverHandler::HyperelasticSolver<MeshType>::NormalStressBound
 };
 
 template <>
-class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<Connectivity<1>>>::NormalStressBoundaryCondition
+class HyperelasticSolverHandler::HyperelasticSolver<const Mesh<1>>::NormalStressBoundaryCondition
 {
  private:
   const MeshNodeBoundary m_mesh_node_boundary;
diff --git a/tests/test_CellIntegrator.cpp b/tests/test_CellIntegrator.cpp
index cce926b68..d5e7dddec 100644
--- a/tests/test_CellIntegrator.cpp
+++ b/tests/test_CellIntegrator.cpp
@@ -21,7 +21,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
     {
       using R1 = TinyVector<1>;
 
-      const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
       auto f          = [](const R1& x) -> double { return x[0] * x[0] + 1; };
 
       Array<const double> int_f_per_cell = [=] {
@@ -236,7 +236,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
     {
       using R2 = TinyVector<2>;
 
-      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
       auto f = [](const R2& X) -> double {
         const double x = X[0];
@@ -499,7 +499,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
 
       for (const auto& mesh_info : mesh_list) {
         auto mesh_name = mesh_info.first;
-        auto mesh      = mesh_info.second->get<Mesh<Connectivity<3>>>();
+        auto mesh      = mesh_info.second->get<Mesh<3>>();
 
         SECTION(mesh_name)
         {
@@ -943,7 +943,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
     {
       using R1 = TinyVector<1>;
 
-      const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
       auto f          = [](const R1& x) -> R2 { return R2{x[0] * x[0] + 1, 2 * x[0]}; };
 
       Array<const R2> int_f_per_cell = [=] {
@@ -1156,7 +1156,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
 
     SECTION("2D")
     {
-      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
       auto f = [](const R2& X) -> R2 {
         const double x = X[0];
@@ -1418,7 +1418,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
 
       for (const auto& mesh_info : mesh_list) {
         auto mesh_name = mesh_info.first;
-        auto mesh      = mesh_info.second->get<Mesh<Connectivity<3>>>();
+        auto mesh      = mesh_info.second->get<Mesh<3>>();
 
         SECTION(mesh_name)
         {
@@ -1863,7 +1863,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
     {
       using R1 = TinyVector<1>;
 
-      const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      const auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
       auto f          = [](const R1& x) -> R2x2 { return R2x2{x[0] * x[0] + 1, 2 * x[0], 3 - x[0], 3 * x[0] - 1}; };
 
       Array<const R2x2> int_f_per_cell = [=] {
@@ -2081,7 +2081,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
     {
       using R2 = TinyVector<2>;
 
-      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
       auto f = [](const R2& X) -> R2x2 {
         const double x = X[0];
@@ -2345,7 +2345,7 @@ TEST_CASE("CellIntegrator", "[scheme]")
 
       for (const auto& mesh_info : mesh_list) {
         auto mesh_name = mesh_info.first;
-        auto mesh      = mesh_info.second->get<Mesh<Connectivity<3>>>();
+        auto mesh      = mesh_info.second->get<Mesh<3>>();
 
         SECTION(mesh_name)
         {
diff --git a/tests/test_Connectivity.cpp b/tests/test_Connectivity.cpp
index a0277eaf6..c64988ec2 100644
--- a/tests/test_Connectivity.cpp
+++ b/tests/test_Connectivity.cpp
@@ -20,7 +20,7 @@ TEST_CASE("Connectivity", "[mesh]")
     {
       SECTION("unordered 1D mesh")
       {
-        const auto& mesh = *MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+        const auto& mesh = *MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
 
         if (parallel::size() == 1) {
           REQUIRE(mesh.numberOfNodes() == 35);
@@ -37,7 +37,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
       SECTION("cartesian 1D mesh")
       {
-        const auto& mesh = *MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+        const auto& mesh = *MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
 
         if (parallel::size() == 1) {
           REQUIRE(mesh.numberOfNodes() == 24);
@@ -57,7 +57,7 @@ TEST_CASE("Connectivity", "[mesh]")
     {
       SECTION("hybrid 2D mesh")
       {
-        const auto& mesh = *MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+        const auto& mesh = *MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
         if (parallel::size() == 1) {
           REQUIRE(mesh.numberOfNodes() == 53);
@@ -74,7 +74,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
       SECTION("cartesian 2D mesh")
       {
-        const auto& mesh = *MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+        const auto& mesh = *MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
 
         if (parallel::size() == 1) {
           REQUIRE(mesh.numberOfNodes() == 56);
@@ -94,7 +94,7 @@ TEST_CASE("Connectivity", "[mesh]")
     {
       SECTION("hybrid 3D mesh")
       {
-        const auto& mesh = *MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+        const auto& mesh = *MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
         if (parallel::size() == 1) {
           REQUIRE(mesh.numberOfNodes() == 132);
@@ -111,7 +111,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
       SECTION("cartesian 3D mesh")
       {
-        const auto& mesh = *MeshDataBaseForTests::get().cartesian3DMesh()->get<Mesh<Connectivity<3>>>();
+        const auto& mesh = *MeshDataBaseForTests::get().cartesian3DMesh()->get<Mesh<3>>();
 
         if (parallel::size() == 1) {
           REQUIRE(mesh.numberOfNodes() == 280);
@@ -137,7 +137,7 @@ TEST_CASE("Connectivity", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d                        = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d                        = named_mesh.mesh()->get<Mesh<1>>();
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
           SECTION("nodes/edges/faces")
@@ -228,7 +228,7 @@ TEST_CASE("Connectivity", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d                        = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d                        = named_mesh.mesh()->get<Mesh<2>>();
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
           SECTION("nodes")
@@ -331,7 +331,7 @@ TEST_CASE("Connectivity", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -448,7 +448,7 @@ TEST_CASE("Connectivity", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d                        = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d                        = named_mesh.mesh()->get<Mesh<1>>();
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
           auto is_boundary_node = connectivity.isBoundaryNode();
@@ -497,7 +497,7 @@ TEST_CASE("Connectivity", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d                        = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d                        = named_mesh.mesh()->get<Mesh<2>>();
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
           SECTION("faces/edges")
@@ -575,7 +575,7 @@ TEST_CASE("Connectivity", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -683,7 +683,7 @@ TEST_CASE("Connectivity", "[mesh]")
         {
           SECTION("cell -> nodes")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<1>>();
             auto xr   = mesh->xr();
 
             const Connectivity<1>& connectivity = mesh->connectivity();
@@ -702,7 +702,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("node -> cells")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<1>>();
 
             const Connectivity<1>& connectivity = mesh->connectivity();
 
@@ -731,7 +731,7 @@ TEST_CASE("Connectivity", "[mesh]")
         {
           SECTION("face -> nodes")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<2>>();
 
             const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -751,7 +751,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("node -> faces")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<2>>();
 
             const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -770,7 +770,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("node -> cells")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<2>>();
 
             const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -789,7 +789,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("face -> cells")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<2>>();
 
             const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -818,7 +818,7 @@ TEST_CASE("Connectivity", "[mesh]")
         {
           SECTION("edge -> nodes")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
             const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -838,7 +838,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("face -> nodes")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
             const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -865,7 +865,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("node -> edges")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
             const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -887,7 +887,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("node -> faces")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
             const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -906,7 +906,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("node -> cells")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
             const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -925,7 +925,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("edge -> faces")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
             const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -944,7 +944,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("edge -> cells")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
             const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -963,7 +963,7 @@ TEST_CASE("Connectivity", "[mesh]")
 
           SECTION("face -> cells")
           {
-            auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+            auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
             const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -1020,7 +1020,7 @@ TEST_CASE("Connectivity", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh                           = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh                           = named_mesh.mesh()->get<Mesh<1>>();
           const Connectivity<1>& connectivity = mesh->connectivity();
 
           SECTION("node <-> cell")
@@ -1092,7 +1092,7 @@ TEST_CASE("Connectivity", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh                           = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh                           = named_mesh.mesh()->get<Mesh<2>>();
           const Connectivity<2>& connectivity = mesh->connectivity();
 
           SECTION("node <-> cell")
@@ -1194,7 +1194,7 @@ TEST_CASE("Connectivity", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh                           = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh                           = named_mesh.mesh()->get<Mesh<3>>();
           const Connectivity<3>& connectivity = mesh->connectivity();
 
           SECTION("node <-> cell")
diff --git a/tests/test_DiamondDualConnectivityBuilder.cpp b/tests/test_DiamondDualConnectivityBuilder.cpp
index 5c9df535a..2a5d1d4b6 100644
--- a/tests/test_DiamondDualConnectivityBuilder.cpp
+++ b/tests/test_DiamondDualConnectivityBuilder.cpp
@@ -37,8 +37,8 @@ TEST_CASE("DiamondDualConnectivityBuilder", "[mesh]")
   {
     constexpr static size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().hybrid2DMesh()->get<MeshType>();
     const ConnectivityType& primal_connectivity = mesh->connectivity();
@@ -147,8 +147,8 @@ TEST_CASE("DiamondDualConnectivityBuilder", "[mesh]")
   {
     constexpr static size_t Dimension = 3;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().hybrid3DMesh()->get<MeshType>();
     const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_DiamondDualMeshBuilder.cpp b/tests/test_DiamondDualMeshBuilder.cpp
index debdf09f5..c1f95caab 100644
--- a/tests/test_DiamondDualMeshBuilder.cpp
+++ b/tests/test_DiamondDualMeshBuilder.cpp
@@ -18,18 +18,17 @@ TEST_CASE("DiamondDualMeshBuilder", "[mesh]")
   {
     constexpr static size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType = Mesh<Dimension>;
 
     std::shared_ptr primal_mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
-    const MeshType& primal_mesh   = *primal_mesh_v->get<Mesh<Connectivity<Dimension>>>();
+    const MeshType& primal_mesh   = *primal_mesh_v->get<Mesh<Dimension>>();
 
     REQUIRE(primal_mesh.numberOfNodes() == 53);
     REQUIRE(primal_mesh.numberOfFaces() == 110);
     REQUIRE(primal_mesh.numberOfCells() == 58);
 
     std::shared_ptr diamond_dual_mesh_v = DualMeshManager::instance().getDiamondDualMesh(primal_mesh_v);
-    const MeshType& dual_mesh           = *diamond_dual_mesh_v->get<Mesh<Connectivity<Dimension>>>();
+    const MeshType& dual_mesh           = *diamond_dual_mesh_v->get<Mesh<Dimension>>();
 
     REQUIRE(dual_mesh.numberOfNodes() == 111);
     REQUIRE(dual_mesh.numberOfFaces() == 220);
@@ -85,11 +84,10 @@ TEST_CASE("DiamondDualMeshBuilder", "[mesh]")
   {
     constexpr static size_t Dimension = 3;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType = Mesh<Dimension>;
 
     std::shared_ptr primal_mesh_v = MeshDataBaseForTests::get().hybrid3DMesh();
-    const MeshType& primal_mesh   = *primal_mesh_v->get<Mesh<Connectivity<Dimension>>>();
+    const MeshType& primal_mesh   = *primal_mesh_v->get<Mesh<Dimension>>();
 
     REQUIRE(primal_mesh.numberOfNodes() == 132);
     REQUIRE(primal_mesh.numberOfEdges() == 452);
@@ -97,7 +95,7 @@ TEST_CASE("DiamondDualMeshBuilder", "[mesh]")
     REQUIRE(primal_mesh.numberOfCells() == 199);
 
     std::shared_ptr diamond_dual_mesh_v = DualMeshManager::instance().getDiamondDualMesh(primal_mesh_v);
-    const MeshType& dual_mesh           = *diamond_dual_mesh_v->get<Mesh<Connectivity<Dimension>>>();
+    const MeshType& dual_mesh           = *diamond_dual_mesh_v->get<Mesh<Dimension>>();
 
     REQUIRE(dual_mesh.numberOfNodes() == 331);
     REQUIRE(dual_mesh.numberOfEdges() == 1461);
diff --git a/tests/test_DiscreteFunctionIntegratorByZone.cpp b/tests/test_DiscreteFunctionIntegratorByZone.cpp
index c556cf6ca..2e0d3dad2 100644
--- a/tests/test_DiscreteFunctionIntegratorByZone.cpp
+++ b/tests/test_DiscreteFunctionIntegratorByZone.cpp
@@ -54,7 +54,7 @@ TEST_CASE("DiscreteFunctionIntegratorByZone", "[scheme]")
     std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
 
     auto mesh_1d_v = MeshDataBaseForTests::get().unordered1DMesh();
-    auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+    auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -384,7 +384,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
     std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
 
     auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
-    auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+    auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -714,7 +714,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
     std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
 
     auto mesh_3d_v = MeshDataBaseForTests::get().hybrid3DMesh();
-    auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+    auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
diff --git a/tests/test_DiscreteFunctionInterpoler.cpp b/tests/test_DiscreteFunctionInterpoler.cpp
index 21bec01b1..b4c024d3f 100644
--- a/tests/test_DiscreteFunctionInterpoler.cpp
+++ b/tests/test_DiscreteFunctionInterpoler.cpp
@@ -53,7 +53,7 @@ TEST_CASE("DiscreteFunctionInterpoler", "[scheme]")
       SECTION(named_mesh.name())
       {
         auto mesh_1d_v = named_mesh.mesh();
-        auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+        auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
 
@@ -343,7 +343,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
 
@@ -634,7 +634,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
diff --git a/tests/test_DiscreteFunctionInterpolerByZone.cpp b/tests/test_DiscreteFunctionInterpolerByZone.cpp
index 9a95d7ffd..e62ab89fe 100644
--- a/tests/test_DiscreteFunctionInterpolerByZone.cpp
+++ b/tests/test_DiscreteFunctionInterpolerByZone.cpp
@@ -50,7 +50,7 @@ TEST_CASE("DiscreteFunctionInterpolerByZone", "[scheme]")
     constexpr size_t Dimension = 1;
 
     auto mesh_1d_v = MeshDataBaseForTests::get().unordered1DMesh();
-    auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+    auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -384,7 +384,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
     constexpr size_t Dimension = 2;
 
     auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
-    auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+    auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -719,7 +719,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
     constexpr size_t Dimension = 3;
 
     auto mesh_3d_v = MeshDataBaseForTests::get().hybrid3DMesh();
-    auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+    auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
diff --git a/tests/test_DiscreteFunctionP0.cpp b/tests/test_DiscreteFunctionP0.cpp
index ccf962754..e43e1958d 100644
--- a/tests/test_DiscreteFunctionP0.cpp
+++ b/tests/test_DiscreteFunctionP0.cpp
@@ -33,7 +33,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<1>>();
           DiscreteFunctionP0<Dimension, double> f{mesh};
           REQUIRE(f.dataType() == ASTNodeDataType::double_t);
           REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0);
@@ -81,7 +81,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<2>>();
           DiscreteFunctionP0<Dimension, double> f{mesh};
           REQUIRE(f.dataType() == ASTNodeDataType::double_t);
           REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0);
@@ -129,7 +129,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
           DiscreteFunctionP0<Dimension, double> f{mesh};
           REQUIRE(f.dataType() == ASTNodeDataType::double_t);
@@ -191,7 +191,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<1>>();
 
           DiscreteFunctionP0<Dimension, double> f{mesh};
           f.fill(3);
@@ -220,7 +220,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<2>>();
 
           DiscreteFunctionP0<Dimension, double> f{mesh};
           f.fill(3);
@@ -249,7 +249,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
           DiscreteFunctionP0<Dimension, double> f{mesh};
           f.fill(3);
@@ -291,7 +291,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<1>>();
 
           SECTION("scalar")
           {
@@ -393,7 +393,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<2>>();
 
           SECTION("scalar")
           {
@@ -495,7 +495,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
           SECTION("scalar")
           {
@@ -599,7 +599,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<1>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -684,7 +684,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<1>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -1265,7 +1265,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<2>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -1851,7 +1851,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -2500,7 +2500,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<1>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -2844,7 +2844,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<2>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -3188,7 +3188,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<3>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -3439,7 +3439,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
               mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
                 const double x = xj[cell_id][0];
                 Ah[cell_id]    = TinyMatrix<2>{x + 1, 2 * x - 3,   //
-                                            -0.2 * x - 1, 2 + x};
+                                               -0.2 * x - 1, 2 + x};
               });
 
             {
@@ -3461,7 +3461,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
               mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
                 const double x = xj[cell_id][0];
                 Ah[cell_id]    = TinyMatrix<2>{x + 1, 2 * x - 3,   //
-                                            -0.2 * x - 1, 2 + x};
+                                               -0.2 * x - 1, 2 + x};
               });
 
             {
@@ -3483,7 +3483,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
               mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
                 const double x = xj[cell_id][0];
                 Ah[cell_id]    = TinyMatrix<2>{x + 1, 2 * x - 3,   //
-                                            -0.2 * x - 1, 2 + x};
+                                               -0.2 * x - 1, 2 + x};
               });
 
             {
@@ -3505,7 +3505,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
               mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
                 const double x = xj[cell_id][0];
                 Ah[cell_id]    = TinyMatrix<2>{x + 1, 2 * x - 3,   //
-                                            -0.2 * x - 1, 2 + x};
+                                               -0.2 * x - 1, 2 + x};
               });
 
             {
@@ -3626,10 +3626,9 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
         for (const auto& named_mesh : mesh_list) {
           SECTION(named_mesh.name())
           {
-            auto mesh_1 = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+            auto mesh_1 = named_mesh.mesh()->get<Mesh<1>>();
 
-            std::shared_ptr mesh_2 =
-              std::make_shared<Mesh<Connectivity<Dimension>>>(mesh_1->shared_connectivity(), mesh_1->xr());
+            std::shared_ptr mesh_2 = std::make_shared<Mesh<Dimension>>(mesh_1->shared_connectivity(), mesh_1->xr());
 
             DiscreteFunctionP0<Dimension, double> f1{mesh_1};
             DiscreteFunctionP0<Dimension, double> f2{mesh_2};
@@ -3653,10 +3652,9 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
         for (const auto& named_mesh : mesh_list) {
           SECTION(named_mesh.name())
           {
-            auto mesh_1 = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+            auto mesh_1 = named_mesh.mesh()->get<Mesh<2>>();
 
-            std::shared_ptr mesh_2 =
-              std::make_shared<Mesh<Connectivity<Dimension>>>(mesh_1->shared_connectivity(), mesh_1->xr());
+            std::shared_ptr mesh_2 = std::make_shared<Mesh<Dimension>>(mesh_1->shared_connectivity(), mesh_1->xr());
 
             DiscreteFunctionP0<Dimension, double> f1{mesh_1};
             DiscreteFunctionP0<Dimension, double> f2{mesh_2};
@@ -3680,10 +3678,9 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
         for (const auto& named_mesh : mesh_list) {
           SECTION(named_mesh.name())
           {
-            auto mesh_1 = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+            auto mesh_1 = named_mesh.mesh()->get<Mesh<3>>();
 
-            std::shared_ptr mesh_2 =
-              std::make_shared<Mesh<Connectivity<Dimension>>>(mesh_1->shared_connectivity(), mesh_1->xr());
+            std::shared_ptr mesh_2 = std::make_shared<Mesh<Dimension>>(mesh_1->shared_connectivity(), mesh_1->xr());
 
             DiscreteFunctionP0<Dimension, double> f1{mesh_1};
             DiscreteFunctionP0<Dimension, double> f2{mesh_2};
diff --git a/tests/test_DiscreteFunctionP0Vector.cpp b/tests/test_DiscreteFunctionP0Vector.cpp
index 1bf27ddb2..4521e8fa8 100644
--- a/tests/test_DiscreteFunctionP0Vector.cpp
+++ b/tests/test_DiscreteFunctionP0Vector.cpp
@@ -34,7 +34,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
           DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
           REQUIRE(f.dataType() == ASTNodeDataType::double_t);
           REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0Vector);
@@ -82,7 +82,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
           DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
           REQUIRE(f.dataType() == ASTNodeDataType::double_t);
           REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0Vector);
@@ -130,7 +130,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
           DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
           REQUIRE(f.dataType() == ASTNodeDataType::double_t);
           REQUIRE(f.descriptor().type() == DiscreteFunctionType::P0Vector);
@@ -193,7 +193,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
         SECTION(named_mesh.name())
         {
           constexpr size_t Dimension = 1;
-          auto mesh                  = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh                  = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
           f.fill(3);
@@ -214,7 +214,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
           DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
           f.fill(2.3);
 
@@ -234,7 +234,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
           DiscreteFunctionP0Vector<Dimension, double> f{mesh, size};
           f.fill(3.2);
 
@@ -269,7 +269,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           const size_t size       = 3;
           const size_t value      = parallel::rank() + 1;
@@ -315,7 +315,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           const size_t size       = 3;
           const size_t value      = parallel::rank() + 1;
@@ -362,7 +362,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           const size_t size       = 3;
           const size_t value      = parallel::rank() + 1;
@@ -413,7 +413,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -456,7 +456,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -500,7 +500,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -548,7 +548,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -631,7 +631,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -714,7 +714,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -800,7 +800,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -934,7 +934,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
@@ -1072,7 +1072,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
diff --git a/tests/test_DiscreteFunctionUtils.cpp b/tests/test_DiscreteFunctionUtils.cpp
index e7b547f40..f7adede0e 100644
--- a/tests/test_DiscreteFunctionUtils.cpp
+++ b/tests/test_DiscreteFunctionUtils.cpp
@@ -22,7 +22,7 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
       SECTION(named_mesh.name())
       {
         auto mesh_v = named_mesh.mesh();
-        auto mesh   = mesh_v->get<Mesh<Connectivity<Dimension>>>();
+        auto mesh   = mesh_v->get<Mesh<Dimension>>();
 
         std::shared_ptr mesh_copy =
           std::make_shared<const std::decay_t<decltype(*mesh)>>(mesh->shared_connectivity(), mesh->xr());
@@ -210,7 +210,7 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
       SECTION(named_mesh.name())
       {
         auto mesh_v = named_mesh.mesh();
-        auto mesh   = mesh_v->get<Mesh<Connectivity<Dimension>>>();
+        auto mesh   = mesh_v->get<Mesh<Dimension>>();
         std::shared_ptr mesh_copy =
           std::make_shared<const std::decay_t<decltype(*mesh)>>(mesh->shared_connectivity(), mesh->xr());
         std::shared_ptr mesh_copy_v = std::make_shared<const MeshVariant>(mesh_copy);
@@ -397,7 +397,7 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
       SECTION(named_mesh.name())
       {
         auto mesh_v = named_mesh.mesh();
-        auto mesh   = mesh_v->get<Mesh<Connectivity<3>>>();
+        auto mesh   = mesh_v->get<Mesh<3>>();
 
         std::shared_ptr mesh_copy =
           std::make_shared<const std::decay_t<decltype(*mesh)>>(mesh->shared_connectivity(), mesh->xr());
@@ -586,12 +586,10 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
           std::shared_ptr other_mesh =
-            CartesianMeshBuilder{TinyVector<1>{-1}, TinyVector<1>{3}, TinyVector<1, size_t>{19}}
-              .mesh()
-              ->get<Mesh<Connectivity<1>>>();
+            CartesianMeshBuilder{TinyVector<1>{-1}, TinyVector<1>{3}, TinyVector<1, size_t>{19}}.mesh()->get<Mesh<1>>();
           std::shared_ptr other_mesh_v = std::make_shared<const MeshVariant>(other_mesh);
 
           std::shared_ptr uh = std::make_shared<DiscreteFunctionVariant>(DiscreteFunctionP0<Dimension, double>(mesh));
@@ -605,9 +603,9 @@ TEST_CASE("DiscreteFunctionUtils", "[scheme]")
     {
       constexpr size_t Dimension = 1;
 
-      std::shared_ptr mesh_1d   = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
-      std::shared_ptr mesh_2d_v = std::make_shared<const MeshVariant>(
-        MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>());
+      std::shared_ptr mesh_1d = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
+      std::shared_ptr mesh_2d_v =
+        std::make_shared<const MeshVariant>(MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>());
 
       std::shared_ptr uh = std::make_shared<DiscreteFunctionVariant>(DiscreteFunctionP0<Dimension, double>(mesh_1d));
 
diff --git a/tests/test_DiscreteFunctionVectorIntegrator.cpp b/tests/test_DiscreteFunctionVectorIntegrator.cpp
index 79cd612e5..58ad9cdf2 100644
--- a/tests/test_DiscreteFunctionVectorIntegrator.cpp
+++ b/tests/test_DiscreteFunctionVectorIntegrator.cpp
@@ -68,7 +68,7 @@ TEST_CASE("DiscreteFunctionVectorIntegrator", "[scheme]")
       SECTION(named_mesh.name())
       {
         auto mesh_1d_v = named_mesh.mesh();
-        auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+        auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
         std::string_view data = R"(
 import math;
@@ -158,7 +158,7 @@ let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
         std::string_view data = R"(
 import math;
@@ -248,7 +248,7 @@ let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0] + x[1]) + 3;
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         std::string_view data = R"(
 import math;
@@ -336,7 +336,7 @@ let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         std::string_view data = R"(
 import math;
diff --git a/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp b/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp
index f26721770..2522f3651 100644
--- a/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp
+++ b/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp
@@ -65,7 +65,7 @@ TEST_CASE("DiscreteFunctionVectorIntegratorByZone", "[scheme]")
     std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
 
     auto mesh_1d_v = MeshDataBaseForTests::get().unordered1DMesh();
-    auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+    auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -194,7 +194,7 @@ let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
     std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
 
     auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
-    auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+    auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -323,7 +323,7 @@ let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0] + x[1]) + 3;
     std::shared_ptr<const IQuadratureDescriptor> quadrature_descriptor = std::make_shared<GaussQuadratureDescriptor>(3);
 
     auto mesh_3d_v = MeshDataBaseForTests::get().hybrid3DMesh();
-    auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+    auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
diff --git a/tests/test_DiscreteFunctionVectorInterpoler.cpp b/tests/test_DiscreteFunctionVectorInterpoler.cpp
index 0c0d60795..b86f833a2 100644
--- a/tests/test_DiscreteFunctionVectorInterpoler.cpp
+++ b/tests/test_DiscreteFunctionVectorInterpoler.cpp
@@ -63,7 +63,7 @@ TEST_CASE("DiscreteFunctionVectorInterpoler", "[scheme]")
       SECTION(named_mesh.name())
       {
         auto mesh_1d_v = named_mesh.mesh();
-        auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+        auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
 
@@ -168,7 +168,7 @@ let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
 
@@ -273,7 +273,7 @@ let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0] + x[1]) + 3;
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
@@ -376,7 +376,7 @@ let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
diff --git a/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp b/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
index 7468ce997..c17a9b397 100644
--- a/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
+++ b/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
@@ -60,7 +60,7 @@ TEST_CASE("DiscreteFunctionVectorInterpolerByZone", "[scheme]")
     constexpr size_t Dimension = 1;
 
     auto mesh_1d_v = MeshDataBaseForTests::get().unordered1DMesh();
-    auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+    auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -186,7 +186,7 @@ let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
     constexpr size_t Dimension = 2;
 
     auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
-    auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+    auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -312,7 +312,7 @@ let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0] + x[1]) + 3;
     constexpr size_t Dimension = 3;
 
     auto mesh_3d_v = MeshDataBaseForTests::get().hybrid3DMesh();
-    auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+    auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
     std::vector<std::shared_ptr<const IZoneDescriptor>> zone_list;
     zone_list.push_back(std::make_shared<NamedZoneDescriptor>("LEFT"));
@@ -441,7 +441,7 @@ let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
diff --git a/tests/test_Dual1DConnectivityBuilder.cpp b/tests/test_Dual1DConnectivityBuilder.cpp
index b8eb91e42..d08d53b22 100644
--- a/tests/test_Dual1DConnectivityBuilder.cpp
+++ b/tests/test_Dual1DConnectivityBuilder.cpp
@@ -36,8 +36,8 @@ TEST_CASE("Dual1DConnectivityBuilder", "[mesh]")
 {
   constexpr static size_t Dimension = 1;
 
-  using ConnectivityType = Connectivity<Dimension>;
-  using MeshType         = Mesh<ConnectivityType>;
+  using MeshType         = Mesh<Dimension>;
+  using ConnectivityType = typename MeshType::Connectivity;
 
   std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().unordered1DMesh()->get<MeshType>();
   const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_Dual1DMeshBuilder.cpp b/tests/test_Dual1DMeshBuilder.cpp
index 50b130f12..88ac2de4f 100644
--- a/tests/test_Dual1DMeshBuilder.cpp
+++ b/tests/test_Dual1DMeshBuilder.cpp
@@ -18,8 +18,7 @@ TEST_CASE("Dual1DMeshBuilder", "[mesh]")
 {
   constexpr static size_t Dimension = 1;
 
-  using ConnectivityType = Connectivity<Dimension>;
-  using MeshType         = Mesh<ConnectivityType>;
+  using MeshType = Mesh<Dimension>;
 
   std::shared_ptr primal_mesh_v = MeshDataBaseForTests::get().unordered1DMesh();
 
diff --git a/tests/test_DualConnectivityManager.cpp b/tests/test_DualConnectivityManager.cpp
index f3b670390..8c24eb079 100644
--- a/tests/test_DualConnectivityManager.cpp
+++ b/tests/test_DualConnectivityManager.cpp
@@ -11,8 +11,8 @@
 
 TEST_CASE("DualConnectivityManager", "[mesh]")
 {
-  using ConnectivityType = Connectivity<2>;
-  using MeshType         = Mesh<ConnectivityType>;
+  using MeshType         = Mesh<2>;
+  using ConnectivityType = typename MeshType::Connectivity;
 
   std::shared_ptr mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
   std::shared_ptr mesh   = mesh_v->get<MeshType>();
diff --git a/tests/test_DualMeshManager.cpp b/tests/test_DualMeshManager.cpp
index da9aac557..9c60d8a27 100644
--- a/tests/test_DualMeshManager.cpp
+++ b/tests/test_DualMeshManager.cpp
@@ -26,8 +26,7 @@ TEST_CASE("DualMeshManager", "[mesh]")
 
   SECTION("2D")
   {
-    using ConnectivityType = Connectivity<2>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType = Mesh<2>;
 
     std::shared_ptr mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
 
@@ -117,8 +116,7 @@ TEST_CASE("DualMeshManager", "[mesh]")
 
   SECTION("3D")
   {
-    using ConnectivityType = Connectivity<3>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType = Mesh<3>;
 
     std::shared_ptr mesh_v = MeshDataBaseForTests::get().hybrid3DMesh();
     std::shared_ptr mesh   = mesh_v->get<MeshType>();
diff --git a/tests/test_EdgeIntegrator.cpp b/tests/test_EdgeIntegrator.cpp
index b20cb925f..5415a03f1 100644
--- a/tests/test_EdgeIntegrator.cpp
+++ b/tests/test_EdgeIntegrator.cpp
@@ -38,7 +38,7 @@ TEST_CASE("EdgeIntegrator", "[scheme]")
 
       for (const auto& mesh_info : mesh_list) {
         auto mesh_name = mesh_info.first;
-        auto mesh      = mesh_info.second->get<Mesh<Connectivity<3>>>();
+        auto mesh      = mesh_info.second->get<Mesh<3>>();
 
         Array<const double> int_f_per_edge = [=] {
           Array<double> int_f(mesh->numberOfEdges());
@@ -288,7 +288,7 @@ TEST_CASE("EdgeIntegrator", "[scheme]")
 
       for (const auto& mesh_info : mesh_list) {
         auto mesh_name = mesh_info.first;
-        auto mesh      = mesh_info.second->get<Mesh<Connectivity<3>>>();
+        auto mesh      = mesh_info.second->get<Mesh<3>>();
 
         Array<const R2> int_f_per_edge = [=] {
           Array<R2> int_f(mesh->numberOfEdges());
@@ -540,7 +540,7 @@ TEST_CASE("EdgeIntegrator", "[scheme]")
 
       for (const auto& mesh_info : mesh_list) {
         auto mesh_name = mesh_info.first;
-        auto mesh      = mesh_info.second->get<Mesh<Connectivity<3>>>();
+        auto mesh      = mesh_info.second->get<Mesh<3>>();
 
         Array<const R2x2> int_f_per_edge = [=] {
           Array<R2x2> int_f(mesh->numberOfEdges());
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp
index aa48d3ffc..7ebb75f85 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions1D.cpp
@@ -34,10 +34,9 @@ TEST_CASE("EmbeddedDiscreteFunctionVariantMathFunctions1D", "[scheme]")
   for (const auto& named_mesh : mesh_list) {
     SECTION(named_mesh.name())
     {
-      auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+      auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
-      std::shared_ptr other_mesh =
-        std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+      std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
 
       CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp
index 8658aa3da..989b66d39 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions2D.cpp
@@ -36,10 +36,9 @@ TEST_CASE("EmbeddedDiscreteFunctionVariantMathFunctions2D", "[scheme]")
     for (const auto& named_mesh : mesh_list) {
       SECTION(named_mesh.name())
       {
-        auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+        auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
-        std::shared_ptr other_mesh =
-          std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+        std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
 
         CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp
index 415173393..25afe5c0a 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions3D.cpp
@@ -34,10 +34,9 @@ TEST_CASE("EmbeddedDiscreteFunctionVariantMathFunctions3D", "[scheme]")
   for (const auto& named_mesh : mesh_list) {
     SECTION(named_mesh.name())
     {
-      auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+      auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
-      std::shared_ptr other_mesh =
-        std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+      std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
 
       CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
diff --git a/tests/test_EmbeddedDiscreteFunctionOperators1D.cpp b/tests/test_EmbeddedDiscreteFunctionOperators1D.cpp
index fbbcc8bc1..e790e4608 100644
--- a/tests/test_EmbeddedDiscreteFunctionOperators1D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionOperators1D.cpp
@@ -25,10 +25,9 @@ TEST_CASE("EmbeddedDiscreteFunctionOperators1D", "[scheme]")
   for (const auto& named_mesh : mesh_list) {
     SECTION(named_mesh.name())
     {
-      auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+      auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
-      std::shared_ptr other_mesh =
-        std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+      std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
 
       CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
diff --git a/tests/test_EmbeddedDiscreteFunctionOperators2D.cpp b/tests/test_EmbeddedDiscreteFunctionOperators2D.cpp
index d3fece0d8..0efe0cfbe 100644
--- a/tests/test_EmbeddedDiscreteFunctionOperators2D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionOperators2D.cpp
@@ -25,10 +25,9 @@ TEST_CASE("EmbeddedDiscreteFunctionOperators2D", "[scheme]")
   for (const auto& named_mesh : mesh_list) {
     SECTION(named_mesh.name())
     {
-      auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+      auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
-      std::shared_ptr other_mesh =
-        std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+      std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
 
       CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
diff --git a/tests/test_EmbeddedDiscreteFunctionOperators3D.cpp b/tests/test_EmbeddedDiscreteFunctionOperators3D.cpp
index eb30d18d5..a024c2dde 100644
--- a/tests/test_EmbeddedDiscreteFunctionOperators3D.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionOperators3D.cpp
@@ -25,10 +25,9 @@ TEST_CASE("EmbeddedDiscreteFunctionOperators3D", "[scheme]")
   for (const auto& named_mesh : mesh_list) {
     SECTION(named_mesh.name())
     {
-      auto mesh = named_mesh.mesh()->get<Mesh<Connectivity<Dimension>>>();
+      auto mesh = named_mesh.mesh()->get<Mesh<Dimension>>();
 
-      std::shared_ptr other_mesh =
-        std::make_shared<Mesh<Connectivity<Dimension>>>(mesh->shared_connectivity(), mesh->xr());
+      std::shared_ptr other_mesh = std::make_shared<Mesh<Dimension>>(mesh->shared_connectivity(), mesh->xr());
 
       CellValue<const Rd> xj = MeshDataManager::instance().getMeshData(*mesh).xj();
 
diff --git a/tests/test_EmbeddedDiscreteFunctionUtils.cpp b/tests/test_EmbeddedDiscreteFunctionUtils.cpp
index 3640ea5b5..464313cb5 100644
--- a/tests/test_EmbeddedDiscreteFunctionUtils.cpp
+++ b/tests/test_EmbeddedDiscreteFunctionUtils.cpp
@@ -34,7 +34,7 @@ TEST_CASE("EmbeddedDiscreteFunctionUtils", "[language]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0<1, double>{mesh_1d}) ==
                   "Vh(P0:R)");
@@ -63,7 +63,7 @@ TEST_CASE("EmbeddedDiscreteFunctionUtils", "[language]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           REQUIRE(EmbeddedDiscreteFunctionUtils::getOperandTypeName(DiscreteFunctionP0Vector<1, double>{mesh_1d, 2}) ==
                   "Vh(P0Vector:R)");
diff --git a/tests/test_FaceIntegrator.cpp b/tests/test_FaceIntegrator.cpp
index 092ab55c3..73e6ecad9 100644
--- a/tests/test_FaceIntegrator.cpp
+++ b/tests/test_FaceIntegrator.cpp
@@ -22,7 +22,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
       using R2 = TinyVector<2>;
 
       const auto mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
-      const auto mesh   = mesh_v->get<Mesh<Connectivity<2>>>();
+      const auto mesh   = mesh_v->get<Mesh<2>>();
 
       auto f = [](const R2& X) -> double {
         const double x = X[0];
@@ -265,7 +265,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
 
       for (const auto& mesh_info : mesh_list) {
         auto mesh_name = mesh_info.first;
-        auto mesh      = mesh_info.second->get<Mesh<Connectivity<3>>>();
+        auto mesh      = mesh_info.second->get<Mesh<3>>();
 
         Array<const double> int_f_per_face = [=] {
           Array<double> int_f(mesh->numberOfFaces());
@@ -514,7 +514,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
     {
       using R2 = TinyVector<2>;
 
-      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
       auto f = [](const R2& X) -> R2 {
         const double x = X[0];
@@ -757,7 +757,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
 
       for (const auto& mesh_info : mesh_list) {
         auto mesh_name = mesh_info.first;
-        auto mesh      = mesh_info.second->get<Mesh<Connectivity<3>>>();
+        auto mesh      = mesh_info.second->get<Mesh<3>>();
 
         Array<const R2> int_f_per_face = [=] {
           Array<R2> int_f(mesh->numberOfFaces());
@@ -1009,7 +1009,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
     {
       using R2 = TinyVector<2>;
 
-      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
       auto f = [](const R2& X) -> R2x2 {
         const double x = X[0];
@@ -1252,7 +1252,7 @@ TEST_CASE("FaceIntegrator", "[scheme]")
 
       for (const auto& mesh_info : mesh_list) {
         auto mesh_name = mesh_info.first;
-        auto mesh      = mesh_info.second->get<Mesh<Connectivity<3>>>();
+        auto mesh      = mesh_info.second->get<Mesh<3>>();
 
         Array<const R2x2> int_f_per_face = [=] {
           Array<R2x2> int_f(mesh->numberOfFaces());
diff --git a/tests/test_IntegrateCellArray.cpp b/tests/test_IntegrateCellArray.cpp
index 6e45d92a7..738fad05f 100644
--- a/tests/test_IntegrateCellArray.cpp
+++ b/tests/test_IntegrateCellArray.cpp
@@ -55,7 +55,7 @@ TEST_CASE("IntegrateCellArray", "[language]")
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           std::string_view data = R"(
 import math;
@@ -142,7 +142,7 @@ let g: R^1 -> R, x -> 2 * exp(x[0]) + 3;
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           std::string_view data = R"(
 import math;
@@ -240,7 +240,7 @@ let g: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           std::string_view data = R"(
 import math;
@@ -343,7 +343,7 @@ let g: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
 
@@ -438,7 +438,7 @@ let g: R^1 -> R, x -> 2 * exp(x[0]) + 3;
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
 
@@ -545,7 +545,7 @@ let g: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
 
diff --git a/tests/test_IntegrateCellValue.cpp b/tests/test_IntegrateCellValue.cpp
index 88d4e356d..ab2c86f82 100644
--- a/tests/test_IntegrateCellValue.cpp
+++ b/tests/test_IntegrateCellValue.cpp
@@ -53,7 +53,7 @@ TEST_CASE("IntegrateCellValue", "[language]")
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           std::string_view data = R"(
 import math;
@@ -111,7 +111,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           std::string_view data = R"(
 import math;
@@ -181,7 +181,7 @@ let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           std::string_view data = R"(
 import math;
@@ -251,7 +251,7 @@ let scalar_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
 
@@ -316,7 +316,7 @@ let scalar_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
 
@@ -396,7 +396,7 @@ let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
 
diff --git a/tests/test_IntegrateOnCells.cpp b/tests/test_IntegrateOnCells.cpp
index f2f46e73d..93d1c6806 100644
--- a/tests/test_IntegrateOnCells.cpp
+++ b/tests/test_IntegrateOnCells.cpp
@@ -55,7 +55,7 @@ TEST_CASE("IntegrateOnCells", "[language]")
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
             std::string_view data = R"(
 import math;
@@ -156,7 +156,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
             std::string_view data = R"(
 import math;
@@ -270,7 +270,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
             std::string_view data = R"(
 import math;
@@ -389,7 +389,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
             Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
 
@@ -500,7 +500,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
             Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
 
@@ -624,7 +624,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
             Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
 
@@ -758,7 +758,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
             std::string_view data = R"(
 import math;
@@ -859,7 +859,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
             std::string_view data = R"(
 import math;
@@ -973,7 +973,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
             std::string_view data = R"(
 import math;
@@ -1092,7 +1092,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
             Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
 
@@ -1203,7 +1203,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
             Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
 
@@ -1327,7 +1327,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
             Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
 
@@ -1461,7 +1461,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
             std::string_view data = R"(
 import math;
@@ -1562,7 +1562,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
             std::string_view data = R"(
 import math;
@@ -1676,7 +1676,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
             std::string_view data = R"(
 import math;
@@ -1795,7 +1795,7 @@ let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
             Array<CellId> cell_list{mesh_1d->numberOfCells() / 2 + mesh_1d->numberOfCells() % 2};
 
@@ -1906,7 +1906,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 *
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
             Array<CellId> cell_list{mesh_2d->numberOfCells() / 2 + mesh_2d->numberOfCells() % 2};
 
@@ -2030,7 +2030,7 @@ let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
             Array<CellId> cell_list{mesh_3d->numberOfCells() / 2 + mesh_3d->numberOfCells() % 2};
 
diff --git a/tests/test_InterpolateItemArray.cpp b/tests/test_InterpolateItemArray.cpp
index c23dedeaa..cab00ae0a 100644
--- a/tests/test_InterpolateItemArray.cpp
+++ b/tests/test_InterpolateItemArray.cpp
@@ -57,7 +57,7 @@ TEST_CASE("InterpolateItemArray", "[language]")
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
 
@@ -127,7 +127,7 @@ let scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
 
@@ -187,7 +187,7 @@ let f_1d: R^1 -> (R), x -> (2*x[0] + 2, 2 * exp(x[0]) + 3);
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
 
@@ -256,7 +256,7 @@ let f_1d: R^1 -> (R^1), x -> (2*x[0] + 2, [2 * exp(x[0]) + 3]);
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
 
@@ -326,7 +326,7 @@ let scalar_non_linear_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
 
@@ -393,7 +393,7 @@ let f_2d: R^2 -> (R), x -> (2*x[0] + 3*x[1] + 2, 2*exp(x[0])*sin(x[1])+3);
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
@@ -463,7 +463,7 @@ let scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
@@ -544,7 +544,7 @@ let f_3d: R^3 -> (R), x -> (2 * x[0] + 3 * x[1] + 2 * x[2] - 1, 2 * exp(x[0]) *
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
 
@@ -623,7 +623,7 @@ let scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
           SECTION(named_mesh.name())
           {
             auto mesh_1d_v = named_mesh.mesh();
-            auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
 
@@ -699,7 +699,7 @@ let f_1d: R^1 -> (R), x -> (2*x[0] + 2, 2 * exp(x[0]) + 3);
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
 
@@ -775,7 +775,7 @@ let scalar_non_linear_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
 
@@ -841,7 +841,7 @@ let f_2d: R^2 -> (R), x -> (2*x[0] + 3*x[1] + 2, 2*exp(x[0])*sin(x[1])+3);
           SECTION(named_mesh.name())
           {
             auto mesh_2d_v = named_mesh.mesh();
-            auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
 
@@ -919,7 +919,7 @@ let f_2d: R^2 -> (R^2x2), x -> ([[x[0],0],[2-x[1], x[0]*x[1]]], [[2*x[0], x[1]],
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
@@ -995,7 +995,7 @@ let scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
@@ -1061,7 +1061,7 @@ let f_3d: R^3 -> (R), x -> (2 * x[0] + 3 * x[1] + 2 * x[2] - 1, 2 * exp(x[0]) *
           SECTION(named_mesh.name())
           {
             auto mesh_3d_v = named_mesh.mesh();
-            auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+            auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
             auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
diff --git a/tests/test_InterpolateItemValue.cpp b/tests/test_InterpolateItemValue.cpp
index 8cb3ac498..370b8b401 100644
--- a/tests/test_InterpolateItemValue.cpp
+++ b/tests/test_InterpolateItemValue.cpp
@@ -52,7 +52,7 @@ TEST_CASE("InterpolateItemValue", "[language]")
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
 
@@ -224,7 +224,7 @@ let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
 
@@ -390,7 +390,7 @@ let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
@@ -536,7 +536,7 @@ let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos
               cell_value.numberOfItems(), PUGS_LAMBDA(const CellId cell_id) {
                 const TinyVector<Dimension>& x = xj[cell_id];
                 cell_value[cell_id]            = TinyMatrix<2>{2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]),
-                                                    sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]};
+                                                               sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]};
               });
             CellValue<const TinyMatrix<2>> interpolate_value =
               InterpolateItemValue<TinyMatrix<2>(TinyVector<Dimension>)>::interpolate(function_symbol_id, xj);
@@ -570,7 +570,7 @@ let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
 
@@ -753,7 +753,7 @@ let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh_2d).xj();
 
@@ -928,7 +928,7 @@ let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<Dimension>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<Dimension>>();
 
           auto xj = MeshDataManager::instance().getMeshData(*mesh_3d).xj();
 
diff --git a/tests/test_ItemArray.cpp b/tests/test_ItemArray.cpp
index 313e51972..212e12141 100644
--- a/tests/test_ItemArray.cpp
+++ b/tests/test_ItemArray.cpp
@@ -34,7 +34,7 @@ TEST_CASE("ItemArray", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_1d_v = named_mesh.mesh();
-        auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+        auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
         const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -73,7 +73,7 @@ TEST_CASE("ItemArray", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
         const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -110,7 +110,7 @@ TEST_CASE("ItemArray", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -145,7 +145,7 @@ TEST_CASE("ItemArray", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -197,7 +197,7 @@ TEST_CASE("ItemArray", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -233,7 +233,7 @@ TEST_CASE("ItemArray", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
         const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -280,7 +280,7 @@ TEST_CASE("ItemArray", "[mesh]")
   SECTION("output")
   {
     auto mesh_v = MeshDataBaseForTests::get().unordered1DMesh();
-    auto mesh   = mesh_v->get<Mesh<Connectivity<1>>>();
+    auto mesh   = mesh_v->get<Mesh<1>>();
 
     Table<int> table{mesh->numberOfCells(), 3};
     for (size_t i = 0; i < table.numberOfRows(); ++i) {
@@ -324,7 +324,7 @@ TEST_CASE("ItemArray", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -355,7 +355,7 @@ TEST_CASE("ItemArray", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -373,7 +373,7 @@ TEST_CASE("ItemArray", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity_2d = mesh_2d->connectivity();
 
@@ -383,7 +383,7 @@ TEST_CASE("ItemArray", "[mesh]")
             SECTION(named_mesh_3d.name())
             {
               auto mesh_3d_v = named_mesh_3d.mesh();
-              auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+              auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
               const Connectivity<3>& connectivity_3d = mesh_3d->connectivity();
 
diff --git a/tests/test_ItemArrayUtils.cpp b/tests/test_ItemArrayUtils.cpp
index cd0ea471f..8d0484284 100644
--- a/tests/test_ItemArrayUtils.cpp
+++ b/tests/test_ItemArrayUtils.cpp
@@ -26,7 +26,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -301,7 +301,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -576,7 +576,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -854,7 +854,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -884,7 +884,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -914,7 +914,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -947,7 +947,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -977,7 +977,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -1007,7 +1007,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -1040,7 +1040,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -1070,7 +1070,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name() + " for double data")
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -1098,7 +1098,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name() + " for N^2 data")
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -1131,7 +1131,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name() + " for size_t data")
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -1154,7 +1154,7 @@ TEST_CASE("ItemArrayUtils", "[mesh]")
         SECTION(named_mesh.name() + " for N^3x2 data")
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
diff --git a/tests/test_ItemArrayVariant.cpp b/tests/test_ItemArrayVariant.cpp
index 878ee2a7f..1f0d1d822 100644
--- a/tests/test_ItemArrayVariant.cpp
+++ b/tests/test_ItemArrayVariant.cpp
@@ -12,7 +12,7 @@
 TEST_CASE("ItemArrayVariant", "[mesh]")
 {
   std::shared_ptr mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
-  std::shared_ptr mesh   = mesh_v->get<Mesh<Connectivity<2>>>();
+  std::shared_ptr mesh   = mesh_v->get<Mesh<2>>();
 
   const Connectivity<2>& connectivity = *mesh->shared_connectivity();
 
diff --git a/tests/test_ItemArrayVariantFunctionInterpoler.cpp b/tests/test_ItemArrayVariantFunctionInterpoler.cpp
index 50af9207e..95f9d9b5c 100644
--- a/tests/test_ItemArrayVariantFunctionInterpoler.cpp
+++ b/tests/test_ItemArrayVariantFunctionInterpoler.cpp
@@ -56,7 +56,7 @@ TEST_CASE("ItemArrayVariantFunctionInterpoler", "[scheme]")
       SECTION(named_mesh.name())
       {
         auto mesh_1d_v = named_mesh.mesh();
-        auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+        auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
         auto xr = mesh_1d->xr();
@@ -431,7 +431,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
         auto xl = MeshDataManager::instance().getMeshData(*mesh_2d).xl();
 
@@ -565,7 +565,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         auto xe = MeshDataManager::instance().getMeshData(*mesh_3d).xe();
 
diff --git a/tests/test_ItemValue.cpp b/tests/test_ItemValue.cpp
index 79b54c22b..43a8dd459 100644
--- a/tests/test_ItemValue.cpp
+++ b/tests/test_ItemValue.cpp
@@ -32,7 +32,7 @@ TEST_CASE("ItemValue", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_1d_v = named_mesh.mesh();
-        auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+        auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
         const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -66,7 +66,7 @@ TEST_CASE("ItemValue", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
         const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -96,7 +96,7 @@ TEST_CASE("ItemValue", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -121,7 +121,7 @@ TEST_CASE("ItemValue", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -152,7 +152,7 @@ TEST_CASE("ItemValue", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -191,7 +191,7 @@ TEST_CASE("ItemValue", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
         const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -226,7 +226,7 @@ TEST_CASE("ItemValue", "[mesh]")
   SECTION("output")
   {
     auto mesh_v = MeshDataBaseForTests::get().unordered1DMesh();
-    auto mesh   = mesh_v->get<Mesh<Connectivity<1>>>();
+    auto mesh   = mesh_v->get<Mesh<1>>();
 
     Array<int> array{mesh->numberOfCells()};
     for (size_t i = 0; i < array.size(); ++i) {
@@ -268,7 +268,7 @@ TEST_CASE("ItemValue", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -299,7 +299,7 @@ TEST_CASE("ItemValue", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -317,7 +317,7 @@ TEST_CASE("ItemValue", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity_2d = mesh_2d->connectivity();
 
@@ -327,7 +327,7 @@ TEST_CASE("ItemValue", "[mesh]")
             SECTION(named_mesh_3d.name())
             {
               auto mesh_3d_v = named_mesh_3d.mesh();
-              auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+              auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
               const Connectivity<3>& connectivity_3d = mesh_3d->connectivity();
 
diff --git a/tests/test_ItemValueUtils.cpp b/tests/test_ItemValueUtils.cpp
index 6c5d8b0af..f80819f2c 100644
--- a/tests/test_ItemValueUtils.cpp
+++ b/tests/test_ItemValueUtils.cpp
@@ -24,7 +24,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
         const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -78,7 +78,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -106,7 +106,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -134,7 +134,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -165,7 +165,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -193,7 +193,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -221,7 +221,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name())
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -252,7 +252,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name() + " for size_t data")
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -280,7 +280,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name() + " for double data")
         {
           auto mesh_1d_v = named_mesh.mesh();
-          auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -317,7 +317,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name() + "for size_t data")
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -345,7 +345,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name() + "for double data")
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -375,7 +375,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name() + "for N^3 data")
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -407,7 +407,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name() + "for R2 data")
         {
           auto mesh_2d_v = named_mesh.mesh();
-          auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -452,7 +452,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name() + " for size_t data")
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -475,7 +475,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name() + " for N^3x2 data")
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -502,7 +502,7 @@ TEST_CASE("ItemValueUtils", "[mesh]")
         SECTION(named_mesh.name() + "for R^2x3 data")
         {
           auto mesh_3d_v = named_mesh.mesh();
-          auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
diff --git a/tests/test_ItemValueVariant.cpp b/tests/test_ItemValueVariant.cpp
index fb4180f4a..6eed537b9 100644
--- a/tests/test_ItemValueVariant.cpp
+++ b/tests/test_ItemValueVariant.cpp
@@ -12,7 +12,7 @@
 TEST_CASE("ItemValueVariant", "[mesh]")
 {
   auto mesh_2d_v = MeshDataBaseForTests::get().hybrid2DMesh();
-  auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+  auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
   const Connectivity<2>& connectivity = *mesh_2d->shared_connectivity();
 
diff --git a/tests/test_ItemValueVariantFunctionInterpoler.cpp b/tests/test_ItemValueVariantFunctionInterpoler.cpp
index a55435208..4bc251aba 100644
--- a/tests/test_ItemValueVariantFunctionInterpoler.cpp
+++ b/tests/test_ItemValueVariantFunctionInterpoler.cpp
@@ -50,7 +50,7 @@ TEST_CASE("ItemValueVariantFunctionInterpoler", "[scheme]")
       SECTION(named_mesh.name())
       {
         auto mesh_1d_v = named_mesh.mesh();
-        auto mesh_1d   = mesh_1d_v->get<Mesh<Connectivity<1>>>();
+        auto mesh_1d   = mesh_1d_v->get<Mesh<1>>();
 
         auto xj = MeshDataManager::instance().getMeshData(*mesh_1d).xj();
         auto xr = mesh_1d->xr();
@@ -331,7 +331,7 @@ let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(
       SECTION(named_mesh.name())
       {
         auto mesh_2d_v = named_mesh.mesh();
-        auto mesh_2d   = mesh_2d_v->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d   = mesh_2d_v->get<Mesh<2>>();
 
         auto xl = MeshDataManager::instance().getMeshData(*mesh_2d).xl();
 
@@ -451,7 +451,7 @@ let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
       SECTION(named_mesh.name())
       {
         auto mesh_3d_v = named_mesh.mesh();
-        auto mesh_3d   = mesh_3d_v->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d   = mesh_3d_v->get<Mesh<3>>();
 
         auto xe = MeshDataManager::instance().getMeshData(*mesh_3d).xe();
 
diff --git a/tests/test_MedianDualConnectivityBuilder.cpp b/tests/test_MedianDualConnectivityBuilder.cpp
index 34728918d..ab418f24a 100644
--- a/tests/test_MedianDualConnectivityBuilder.cpp
+++ b/tests/test_MedianDualConnectivityBuilder.cpp
@@ -37,8 +37,8 @@ TEST_CASE("MedianDualConnectivityBuilder", "[mesh]")
   {
     constexpr static size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().hybrid2DMesh()->get<MeshType>();
     const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_MedianDualMeshBuilder.cpp b/tests/test_MedianDualMeshBuilder.cpp
index ac2fe9bb4..f4f96d240 100644
--- a/tests/test_MedianDualMeshBuilder.cpp
+++ b/tests/test_MedianDualMeshBuilder.cpp
@@ -18,8 +18,7 @@ TEST_CASE("MedianDualMeshBuilder", "[mesh]")
   {
     constexpr static size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType = Mesh<Dimension>;
 
     std::shared_ptr primal_mesh_v = MeshDataBaseForTests::get().hybrid2DMesh();
     const MeshType& primal_mesh   = *primal_mesh_v->get<MeshType>();
diff --git a/tests/test_MeshEdgeBoundary.cpp b/tests/test_MeshEdgeBoundary.cpp
index 0659a644b..307d73fdc 100644
--- a/tests/test_MeshEdgeBoundary.cpp
+++ b/tests/test_MeshEdgeBoundary.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
   {
     static constexpr size_t Dimension = 1;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("cartesian 1d")
     {
@@ -120,8 +120,8 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
   {
     static constexpr size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("cartesian 2d")
     {
@@ -192,8 +192,8 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
   {
     static constexpr size_t Dimension = 3;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("cartesian 3d")
     {
@@ -266,8 +266,7 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType = Mesh<Dimension>;
 
       std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
       const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -284,8 +283,7 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
       {
         static constexpr size_t Dimension = 1;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -301,8 +299,7 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
       {
         static constexpr size_t Dimension = 2;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -318,8 +315,7 @@ TEST_CASE("MeshEdgeBoundary", "[mesh]")
       {
         static constexpr size_t Dimension = 3;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshEdgeInterface.cpp b/tests/test_MeshEdgeInterface.cpp
index b42324c5a..328a1ce63 100644
--- a/tests/test_MeshEdgeInterface.cpp
+++ b/tests/test_MeshEdgeInterface.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshEdgeInterface", "[mesh]")
   {
     static constexpr size_t Dimension = 1;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("unordered 1d")
     {
@@ -87,8 +87,8 @@ TEST_CASE("MeshEdgeInterface", "[mesh]")
   {
     static constexpr size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("hybrid 2d")
     {
@@ -127,8 +127,8 @@ TEST_CASE("MeshEdgeInterface", "[mesh]")
   {
     static constexpr size_t Dimension = 3;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("hybrid 3d")
     {
@@ -169,8 +169,7 @@ TEST_CASE("MeshEdgeInterface", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType = Mesh<Dimension>;
 
       std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
       const MeshType& mesh   = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshFaceBoundary.cpp b/tests/test_MeshFaceBoundary.cpp
index 9345506d7..40de5b4e1 100644
--- a/tests/test_MeshFaceBoundary.cpp
+++ b/tests/test_MeshFaceBoundary.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
   {
     static constexpr size_t Dimension = 1;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("cartesian 1d")
     {
@@ -120,8 +120,8 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
   {
     static constexpr size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("cartesian 2d")
     {
@@ -192,8 +192,8 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
   {
     static constexpr size_t Dimension = 3;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("cartesian 3d")
     {
@@ -266,8 +266,7 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType = Mesh<Dimension>;
 
       std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
       const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -284,8 +283,7 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
       {
         static constexpr size_t Dimension = 1;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -301,8 +299,7 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
       {
         static constexpr size_t Dimension = 2;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -318,8 +315,7 @@ TEST_CASE("MeshFaceBoundary", "[mesh]")
       {
         static constexpr size_t Dimension = 3;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshFaceInterface.cpp b/tests/test_MeshFaceInterface.cpp
index d762b712c..b213ffd48 100644
--- a/tests/test_MeshFaceInterface.cpp
+++ b/tests/test_MeshFaceInterface.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
   {
     static constexpr size_t Dimension = 1;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("unordered 1d")
     {
@@ -87,8 +87,8 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
   {
     static constexpr size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("hybrid 2d")
     {
@@ -127,8 +127,8 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
   {
     static constexpr size_t Dimension = 3;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("hybrid 3d")
     {
@@ -169,8 +169,7 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType = Mesh<Dimension>;
 
       std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
       const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -187,8 +186,7 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
       {
         static constexpr size_t Dimension = 1;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -204,8 +202,7 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
       {
         static constexpr size_t Dimension = 2;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -221,8 +218,7 @@ TEST_CASE("MeshFaceInterface", "[mesh]")
       {
         static constexpr size_t Dimension = 3;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshFlatEdgeBoundary.cpp b/tests/test_MeshFlatEdgeBoundary.cpp
index 18070e5db..f71756546 100644
--- a/tests/test_MeshFlatEdgeBoundary.cpp
+++ b/tests/test_MeshFlatEdgeBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 1;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R1 = TinyVector<1>;
 
@@ -186,8 +186,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -389,8 +389,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -752,8 +752,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -932,8 +932,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -1143,8 +1143,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -1244,8 +1244,8 @@ TEST_CASE("MeshFlatEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
diff --git a/tests/test_MeshFlatFaceBoundary.cpp b/tests/test_MeshFlatFaceBoundary.cpp
index f7a3ea2fa..f5630ee1d 100644
--- a/tests/test_MeshFlatFaceBoundary.cpp
+++ b/tests/test_MeshFlatFaceBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 1;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R1 = TinyVector<1>;
 
@@ -186,8 +186,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -345,8 +345,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -532,8 +532,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -712,8 +712,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -923,8 +923,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -1024,8 +1024,8 @@ TEST_CASE("MeshFlatFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
diff --git a/tests/test_MeshFlatNodeBoundary.cpp b/tests/test_MeshFlatNodeBoundary.cpp
index bb5cbff8a..60348c53b 100644
--- a/tests/test_MeshFlatNodeBoundary.cpp
+++ b/tests/test_MeshFlatNodeBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 1;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R1 = TinyVector<1>;
 
@@ -186,8 +186,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -389,8 +389,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -752,8 +752,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -932,8 +932,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -1143,8 +1143,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -1237,8 +1237,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -1350,8 +1350,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -1451,8 +1451,8 @@ TEST_CASE("MeshFlatNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
diff --git a/tests/test_MeshLineEdgeBoundary.cpp b/tests/test_MeshLineEdgeBoundary.cpp
index 7eb85182b..39a93e888 100644
--- a/tests/test_MeshLineEdgeBoundary.cpp
+++ b/tests/test_MeshLineEdgeBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -253,8 +253,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -552,8 +552,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -732,8 +732,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -929,8 +929,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -1030,8 +1030,8 @@ TEST_CASE("MeshLineEdgeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
diff --git a/tests/test_MeshLineFaceBoundary.cpp b/tests/test_MeshLineFaceBoundary.cpp
index dc0a1b8f8..559986225 100644
--- a/tests/test_MeshLineFaceBoundary.cpp
+++ b/tests/test_MeshLineFaceBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshLineFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -256,8 +256,8 @@ TEST_CASE("MeshLineFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -439,8 +439,8 @@ TEST_CASE("MeshLineFaceBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
diff --git a/tests/test_MeshLineNodeBoundary.cpp b/tests/test_MeshLineNodeBoundary.cpp
index cccc65686..748c45335 100644
--- a/tests/test_MeshLineNodeBoundary.cpp
+++ b/tests/test_MeshLineNodeBoundary.cpp
@@ -50,8 +50,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -253,8 +253,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -552,8 +552,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -732,8 +732,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
@@ -929,8 +929,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 2;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R2 = TinyVector<2>;
 
@@ -1030,8 +1030,8 @@ TEST_CASE("MeshLineNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType         = Mesh<Dimension>;
+      using ConnectivityType = typename MeshType::Connectivity;
 
       using R3 = TinyVector<3>;
 
diff --git a/tests/test_MeshNodeBoundary.cpp b/tests/test_MeshNodeBoundary.cpp
index b91de432f..68d398095 100644
--- a/tests/test_MeshNodeBoundary.cpp
+++ b/tests/test_MeshNodeBoundary.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
   {
     static constexpr size_t Dimension = 1;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("cartesian 1d")
     {
@@ -120,8 +120,8 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
   {
     static constexpr size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("cartesian 2d")
     {
@@ -194,8 +194,8 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
   {
     static constexpr size_t Dimension = 3;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("cartesian 3d")
     {
@@ -284,8 +284,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType = Mesh<Dimension>;
 
       std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
       const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -302,8 +301,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
       {
         static constexpr size_t Dimension = 1;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -319,8 +317,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
       {
         static constexpr size_t Dimension = 2;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -336,8 +333,7 @@ TEST_CASE("MeshNodeBoundary", "[mesh]")
       {
         static constexpr size_t Dimension = 3;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
diff --git a/tests/test_MeshNodeInterface.cpp b/tests/test_MeshNodeInterface.cpp
index 88884df79..f8ce8a5fb 100644
--- a/tests/test_MeshNodeInterface.cpp
+++ b/tests/test_MeshNodeInterface.cpp
@@ -47,8 +47,8 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
   {
     static constexpr size_t Dimension = 1;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("unordered 1d")
     {
@@ -87,8 +87,8 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
   {
     static constexpr size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("hybrid 2d")
     {
@@ -127,8 +127,8 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
   {
     static constexpr size_t Dimension = 3;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     SECTION("hybrid 3d")
     {
@@ -169,8 +169,7 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
     {
       static constexpr size_t Dimension = 3;
 
-      using ConnectivityType = Connectivity<Dimension>;
-      using MeshType         = Mesh<ConnectivityType>;
+      using MeshType = Mesh<Dimension>;
 
       std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
       const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -187,8 +186,7 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
       {
         static constexpr size_t Dimension = 1;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().unordered1DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -204,8 +202,7 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
       {
         static constexpr size_t Dimension = 2;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid2DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
@@ -221,8 +218,7 @@ TEST_CASE("MeshNodeInterface", "[mesh]")
       {
         static constexpr size_t Dimension = 3;
 
-        using ConnectivityType = Connectivity<Dimension>;
-        using MeshType         = Mesh<ConnectivityType>;
+        using MeshType = Mesh<Dimension>;
 
         std::shared_ptr p_mesh = MeshDataBaseForTests::get().hybrid3DMesh();
         const MeshType& mesh   = *p_mesh->get<MeshType>();
diff --git a/tests/test_ParallelChecker_read.cpp b/tests/test_ParallelChecker_read.cpp
index b7996db7b..026cd4063 100644
--- a/tests/test_ParallelChecker_read.cpp
+++ b/tests/test_ParallelChecker_read.cpp
@@ -199,7 +199,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
   {
     // ItemValues
     {   // 1d
-      auto mesh                           = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      auto mesh                           = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<1>& connectivity = mesh->connectivity();
 
@@ -363,7 +363,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
         const Connectivity<1>& other_connectivity = other_mesh->connectivity();
 
         CellValue<double> other_shape{other_connectivity};
@@ -377,7 +377,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // ItemArray
     {   // 1d
-      auto mesh                           = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      auto mesh                           = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<1>& connectivity = mesh->connectivity();
 
@@ -503,7 +503,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
         const Connectivity<1>& other_connectivity = other_mesh->connectivity();
 
         CellArray<double> other_shape{other_connectivity, 2};
@@ -517,7 +517,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // ItemValues
     {   // 2d
-      auto mesh                           = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      auto mesh                           = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -610,7 +610,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // ItemArray
     {   // 2d
-      auto mesh                           = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      auto mesh                           = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -747,7 +747,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
         const Connectivity<2>& other_connectivity = other_mesh->connectivity();
 
         FaceArray<DataType> other_shape{other_connectivity, 2};
@@ -761,7 +761,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // ItemValues
     {   // 3d
-      auto mesh                           = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh                           = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -858,7 +858,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // ItemArray
     {   // 3d
-      auto mesh                           = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh                           = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -991,7 +991,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
         const Connectivity<2>& other_connectivity = other_mesh->connectivity();
 
         FaceArray<DataType> other_shape{other_connectivity, 2};
@@ -1007,7 +1007,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
   {
     // SubItemValuePerItem
     {   // 1d
-      auto mesh                           = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      auto mesh                           = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<1>& connectivity = mesh->connectivity();
 
@@ -1198,7 +1198,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
         const Connectivity<1>& other_connectivity = other_mesh->connectivity();
 
         CellValuePerNode<double> other_shape{other_connectivity};
@@ -1212,7 +1212,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // SubItemArrayPerItem
     {   // 1d
-      auto mesh                           = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      auto mesh                           = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<1>& connectivity = mesh->connectivity();
 
@@ -1352,7 +1352,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<Connectivity<1>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian1DMesh()->get<Mesh<1>>();
         const Connectivity<1>& other_connectivity = other_mesh->connectivity();
 
         CellArray<double> other_shape{other_connectivity, 2};
@@ -1366,7 +1366,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // SubItemValuePerItem
     {   // 2d
-      auto mesh                           = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      auto mesh                           = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -1503,7 +1503,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
         const Connectivity<2>& other_connectivity = other_mesh->connectivity();
 
         FaceArray<DataType> other_shape{other_connectivity, 2};
@@ -1517,7 +1517,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // SubItemArrayPerItem
     {   // 2d
-      auto mesh                           = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      auto mesh                           = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -1708,7 +1708,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
         const Connectivity<2>& other_connectivity = other_mesh->connectivity();
 
         CellValuePerNode<double> other_shape{other_connectivity};
@@ -1722,7 +1722,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // SubItemValuePerItem
     {   // 3d
-      auto mesh                           = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh                           = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -1855,7 +1855,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<Connectivity<2>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian2DMesh()->get<Mesh<2>>();
         const Connectivity<2>& other_connectivity = other_mesh->connectivity();
 
         FaceArray<DataType> other_shape{other_connectivity, 2};
@@ -1868,7 +1868,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
     // SubItemArrayPerItem
     {   // 3d
-      auto mesh                           = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh                           = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
       std::string filename                = ParallelChecker::instance().filename();
       const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -2008,7 +2008,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        auto other_mesh = MeshDataBaseForTests::get().cartesian3DMesh()->get<Mesh<Connectivity<3>>>();
+        auto other_mesh                           = MeshDataBaseForTests::get().cartesian3DMesh()->get<Mesh<3>>();
         const Connectivity<3>& other_connectivity = other_mesh->connectivity();
 
         CellArray<double> other_shape{other_connectivity, 2};
@@ -2046,7 +2046,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
   REQUIRE_NOTHROW(ParallelChecker::instance().setMode(ParallelChecker::Mode::read));
   REQUIRE_NOTHROW(not ParallelChecker::instance().isWriting());
 
-  auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+  auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
 
   const Connectivity<1>& connectivity = mesh->connectivity();
 
diff --git a/tests/test_ParallelChecker_write.cpp b/tests/test_ParallelChecker_write.cpp
index d9237c7da..e34165999 100644
--- a/tests/test_ParallelChecker_write.cpp
+++ b/tests/test_ParallelChecker_write.cpp
@@ -131,7 +131,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
 
     // ItemValues
     {   // 1d
-      auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
 
       const Connectivity<1>& connectivity = mesh->connectivity();
 
@@ -172,7 +172,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
     }
 
     {   // 2d
-      auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
       const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -202,7 +202,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
     }
 
     {   // 3d
-      auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
       const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -244,7 +244,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
 
     // ItemArrays
     {   // 1d
-      auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
 
       const Connectivity<1>& connectivity = mesh->connectivity();
 
@@ -285,7 +285,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
     }
 
     {   // 2d
-      auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
       const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -315,7 +315,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
     }
 
     {   // 3d
-      auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
       const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -394,7 +394,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
 
     // ItemValues
     {   // 1d
-      auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
 
       const Connectivity<1>& connectivity = mesh->connectivity();
 
@@ -424,7 +424,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
     }
 
     {   // 2d
-      auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
       const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -454,7 +454,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
     }
 
     {   // 3d
-      auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
       const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -485,7 +485,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
 
     // ItemArrays
     {   // 1d
-      auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+      auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
 
       const Connectivity<1>& connectivity = mesh->connectivity();
 
@@ -515,7 +515,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
     }
 
     {   // 2d
-      auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>();
+      auto mesh = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>();
 
       const Connectivity<2>& connectivity = mesh->connectivity();
 
@@ -545,7 +545,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
     }
 
     {   // 3d
-      auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
       const Connectivity<3>& connectivity = mesh->connectivity();
 
@@ -620,7 +620,7 @@ TEST_CASE("ParallelChecker_write", "[dev]")
   REQUIRE_NOTHROW(ParallelChecker::instance().setMode(ParallelChecker::Mode::automatic));
   REQUIRE_NOTHROW(ParallelChecker::instance().isWriting() == (parallel::size() == 1));
 
-  auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>();
+  auto mesh = MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>();
 
   const Connectivity<1>& connectivity = mesh->connectivity();
 
diff --git a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
index 76882047e..68a2301df 100644
--- a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
@@ -17,8 +17,8 @@ TEST_CASE("PrimalToDiamondDualConnectivityDataMapper", "[mesh]")
   {
     constexpr static size_t Dimension = 1;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().unordered1DMesh()->get<MeshType>();
     const ConnectivityType& primal_connectivity = mesh->connectivity();
@@ -44,8 +44,8 @@ TEST_CASE("PrimalToDiamondDualConnectivityDataMapper", "[mesh]")
   {
     constexpr static size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().hybrid2DMesh()->get<MeshType>();
     const ConnectivityType& primal_connectivity = mesh->connectivity();
@@ -223,8 +223,8 @@ TEST_CASE("PrimalToDiamondDualConnectivityDataMapper", "[mesh]")
   {
     constexpr static size_t Dimension = 3;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().hybrid3DMesh()->get<MeshType>();
     const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_PrimalToDual1DConnectivityDataMapper.cpp b/tests/test_PrimalToDual1DConnectivityDataMapper.cpp
index df4e58046..10a6fc4b7 100644
--- a/tests/test_PrimalToDual1DConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToDual1DConnectivityDataMapper.cpp
@@ -14,8 +14,8 @@ TEST_CASE("PrimalToDual1DConnectivityDataMapper", "[mesh]")
 {
   constexpr static size_t Dimension = 1;
 
-  using ConnectivityType = Connectivity<Dimension>;
-  using MeshType         = Mesh<ConnectivityType>;
+  using MeshType         = Mesh<Dimension>;
+  using ConnectivityType = typename MeshType::Connectivity;
 
   std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().unordered1DMesh()->get<MeshType>();
   const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
index 7c9a25d68..7fb1e02a0 100644
--- a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
@@ -17,8 +17,8 @@ TEST_CASE("PrimalToMedianDualConnectivityDataMapper", "[mesh]")
   {
     constexpr static size_t Dimension = 1;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().unordered1DMesh()->get<MeshType>();
     const ConnectivityType& primal_connectivity = mesh->connectivity();
@@ -44,8 +44,8 @@ TEST_CASE("PrimalToMedianDualConnectivityDataMapper", "[mesh]")
   {
     constexpr static size_t Dimension = 2;
 
-    using ConnectivityType = Connectivity<Dimension>;
-    using MeshType         = Mesh<ConnectivityType>;
+    using MeshType         = Mesh<Dimension>;
+    using ConnectivityType = typename MeshType::Connectivity;
 
     std::shared_ptr<const MeshType> mesh        = MeshDataBaseForTests::get().hybrid2DMesh()->get<MeshType>();
     const ConnectivityType& primal_connectivity = mesh->connectivity();
diff --git a/tests/test_SubItemArrayPerItem.cpp b/tests/test_SubItemArrayPerItem.cpp
index f027c56be..23f32a41b 100644
--- a/tests/test_SubItemArrayPerItem.cpp
+++ b/tests/test_SubItemArrayPerItem.cpp
@@ -69,7 +69,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -192,7 +192,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -358,7 +358,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -555,7 +555,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -628,7 +628,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -700,7 +700,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -772,7 +772,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
     for (const auto& named_mesh : mesh_list) {
       SECTION(named_mesh.name())
       {
-        auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
         const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -883,7 +883,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
     for (const auto& named_mesh : mesh_list) {
       SECTION(named_mesh.name())
       {
-        auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
         const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -994,7 +994,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
     for (const auto& named_mesh : mesh_list) {
       SECTION(named_mesh.name())
       {
-        auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
         const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -1068,7 +1068,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
 
     SECTION("checking invalid table size in constructor")
     {
-      auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
       const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -1090,7 +1090,7 @@ TEST_CASE("SubItemArrayPerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
diff --git a/tests/test_SubItemArrayPerItemUtils.cpp b/tests/test_SubItemArrayPerItemUtils.cpp
index 8d4c75167..1ff8bb17f 100644
--- a/tests/test_SubItemArrayPerItemUtils.cpp
+++ b/tests/test_SubItemArrayPerItemUtils.cpp
@@ -23,7 +23,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
     for (const auto& named_mesh : mesh_list) {
       SECTION(named_mesh.name())
       {
-        auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
         const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -95,7 +95,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -127,7 +127,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -159,7 +159,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -194,7 +194,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -226,7 +226,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -258,7 +258,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -294,7 +294,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -324,7 +324,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name() + " for size_t data")
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -347,7 +347,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
 
         SECTION(named_mesh.name() + " for N^2 data")
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -373,7 +373,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
 
         SECTION(named_mesh.name() + " for float data")
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -417,7 +417,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name() + " for size_t data")
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -440,7 +440,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
 
         SECTION(named_mesh.name() + " for N^2x3 data")
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -466,7 +466,7 @@ TEST_CASE("SubItemArrayPerItemUtils", "[mesh]")
 
         SECTION(named_mesh.name() + " for R^2x3 data")
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
diff --git a/tests/test_SubItemArrayPerItemVariant.cpp b/tests/test_SubItemArrayPerItemVariant.cpp
index e40386701..7a224e10a 100644
--- a/tests/test_SubItemArrayPerItemVariant.cpp
+++ b/tests/test_SubItemArrayPerItemVariant.cpp
@@ -11,9 +11,9 @@
 
 TEST_CASE("SubItemArrayPerItemVariant", "[mesh]")
 {
-  std::shared_ptr mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+  std::shared_ptr mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
-  const Connectivity<3>& connectivity = *mesh->shared_connectivity();
+  const Connectivity<3>& connectivity = mesh->connectivity();
 
   using R1   = TinyVector<1>;
   using R2   = TinyVector<2>;
diff --git a/tests/test_SubItemValuePerItem.cpp b/tests/test_SubItemValuePerItem.cpp
index 92569d982..72b794bb1 100644
--- a/tests/test_SubItemValuePerItem.cpp
+++ b/tests/test_SubItemValuePerItem.cpp
@@ -79,7 +79,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -215,7 +215,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -391,7 +391,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -596,7 +596,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -712,7 +712,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -898,7 +898,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -1119,7 +1119,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -1164,7 +1164,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -1208,7 +1208,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -1254,7 +1254,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
     for (const auto& named_mesh : mesh_list) {
       SECTION(named_mesh.name())
       {
-        auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+        auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
         const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -1353,7 +1353,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
     for (const auto& named_mesh : mesh_list) {
       SECTION(named_mesh.name())
       {
-        auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
         const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -1420,7 +1420,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
 
     SECTION("checking invalid array size in constructor")
     {
-      auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+      auto mesh_3d = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
       const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -1442,7 +1442,7 @@ TEST_CASE("SubItemValuePerItem", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
diff --git a/tests/test_SubItemValuePerItemUtils.cpp b/tests/test_SubItemValuePerItemUtils.cpp
index ee73b6072..69214c1c9 100644
--- a/tests/test_SubItemValuePerItemUtils.cpp
+++ b/tests/test_SubItemValuePerItemUtils.cpp
@@ -23,7 +23,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
     for (const auto& named_mesh : mesh_list) {
       SECTION(named_mesh.name())
       {
-        auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+        auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
         const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -90,7 +90,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -120,7 +120,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -150,7 +150,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -183,7 +183,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -213,7 +213,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -243,7 +243,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -278,7 +278,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name())
         {
-          auto mesh_1d = named_mesh.mesh()->get<Mesh<Connectivity<1>>>();
+          auto mesh_1d = named_mesh.mesh()->get<Mesh<1>>();
 
           const Connectivity<1>& connectivity = mesh_1d->connectivity();
 
@@ -307,7 +307,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name() + " for size_t data")
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -329,7 +329,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
 
         SECTION(named_mesh.name() + " for R^2 data")
         {
-          auto mesh_2d = named_mesh.mesh()->get<Mesh<Connectivity<2>>>();
+          auto mesh_2d = named_mesh.mesh()->get<Mesh<2>>();
 
           const Connectivity<2>& connectivity = mesh_2d->connectivity();
 
@@ -366,7 +366,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
       for (const auto& named_mesh : mesh_list) {
         SECTION(named_mesh.name() + " for size_t data")
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -388,7 +388,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
 
         SECTION(named_mesh.name() + " for N^2x3 data")
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
@@ -413,7 +413,7 @@ TEST_CASE("SubItemValuePerItemUtils", "[mesh]")
 
         SECTION(named_mesh.name() + " for R^3x2 float")
         {
-          auto mesh_3d = named_mesh.mesh()->get<Mesh<Connectivity<3>>>();
+          auto mesh_3d = named_mesh.mesh()->get<Mesh<3>>();
 
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
diff --git a/tests/test_SubItemValuePerItemVariant.cpp b/tests/test_SubItemValuePerItemVariant.cpp
index 01ff40651..28f62ace4 100644
--- a/tests/test_SubItemValuePerItemVariant.cpp
+++ b/tests/test_SubItemValuePerItemVariant.cpp
@@ -11,9 +11,9 @@
 
 TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
 {
-  std::shared_ptr mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>();
+  std::shared_ptr mesh = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>();
 
-  const Connectivity<3>& connectivity = *mesh->shared_connectivity();
+  const Connectivity<3>& connectivity = mesh->connectivity();
 
   using R1   = TinyVector<1>;
   using R2   = TinyVector<2>;
diff --git a/tests/test_Synchronizer.cpp b/tests/test_Synchronizer.cpp
index e14aff66a..b54f9321a 100644
--- a/tests/test_Synchronizer.cpp
+++ b/tests/test_Synchronizer.cpp
@@ -29,7 +29,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       using ConnectivityType     = Connectivity<Dimension>;
 
       const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>()->connectivity();
+        MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>()->connectivity();
 
       SECTION("synchonize NodeValue")
       {
@@ -137,8 +137,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       constexpr size_t Dimension = 2;
       using ConnectivityType     = Connectivity<Dimension>;
 
-      const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>()->connectivity();
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>()->connectivity();
 
       SECTION("synchonize NodeValue")
       {
@@ -246,8 +245,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       constexpr size_t Dimension = 3;
       using ConnectivityType     = Connectivity<Dimension>;
 
-      const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>()->connectivity();
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>()->connectivity();
 
       SECTION("synchonize NodeValue")
       {
@@ -370,7 +368,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       using ConnectivityType     = Connectivity<Dimension>;
 
       const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>()->connectivity();
+        MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>()->connectivity();
 
       SECTION("synchonize NodeArray")
       {
@@ -502,8 +500,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       constexpr size_t Dimension = 2;
       using ConnectivityType     = Connectivity<Dimension>;
 
-      const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>()->connectivity();
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>()->connectivity();
 
       SECTION("synchonize NodeArray")
       {
@@ -635,8 +632,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       constexpr size_t Dimension = 3;
       using ConnectivityType     = Connectivity<Dimension>;
 
-      const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>()->connectivity();
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>()->connectivity();
 
       SECTION("synchonize NodeArray")
       {
@@ -796,7 +792,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       using ConnectivityType     = Connectivity<Dimension>;
 
       const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>()->connectivity();
+        MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>()->connectivity();
 
       SECTION("synchonize NodeValuePerCell")
       {
@@ -1071,8 +1067,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       constexpr size_t Dimension = 2;
       using ConnectivityType     = Connectivity<Dimension>;
 
-      const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>()->connectivity();
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>()->connectivity();
 
       SECTION("synchonize NodeValuePerCell")
       {
@@ -1525,8 +1520,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       constexpr size_t Dimension = 3;
       using ConnectivityType     = Connectivity<Dimension>;
 
-      const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>()->connectivity();
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>()->connectivity();
 
       SECTION("synchonize NodeValuePerCell")
       {
@@ -2103,7 +2097,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       using ConnectivityType     = Connectivity<Dimension>;
 
       const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<Connectivity<1>>>()->connectivity();
+        MeshDataBaseForTests::get().unordered1DMesh()->get<Mesh<1>>()->connectivity();
 
       SECTION("synchonize NodeArrayPerCell")
       {
@@ -2408,8 +2402,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       constexpr size_t Dimension = 2;
       using ConnectivityType     = Connectivity<Dimension>;
 
-      const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<Connectivity<2>>>()->connectivity();
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->get<Mesh<2>>()->connectivity();
 
       SECTION("synchonize NodeArrayPerCell")
       {
@@ -2912,8 +2905,7 @@ TEST_CASE("Synchronizer", "[mesh]")
       constexpr size_t Dimension = 3;
       using ConnectivityType     = Connectivity<Dimension>;
 
-      const ConnectivityType& connectivity =
-        MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<Connectivity<3>>>()->connectivity();
+      const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->get<Mesh<3>>()->connectivity();
 
       SECTION("synchonize NodeArrayPerCell")
       {
-- 
GitLab