diff --git a/src/mesh/MeshDispatcher.cpp b/src/mesh/MeshDispatcher.cpp
index a75d31fcfb4df07041f710053a600398381f0529..a5201895f3dbae6426fa9fafec088f207918d02a 100644
--- a/src/mesh/MeshDispatcher.cpp
+++ b/src/mesh/MeshDispatcher.cpp
@@ -7,11 +7,11 @@ template <int Dimension>
 CellValue<int>
 MeshDispatcher<Dimension>::_getCellNewOwner()
 {
-  CSRGraph mesh_graph = m_mesh.cellToCellGraph();
+  CSRGraph connectivity_graph = m_connectivity.cellToCellGraph();
   Partitioner P;
 
-  CellValue<int> cell_new_owner(m_mesh.connectivity());
-  cell_new_owner = P.partition(mesh_graph);
+  CellValue<int> cell_new_owner(m_connectivity);
+  cell_new_owner = P.partition(connectivity_graph);
   return cell_new_owner;
 }
 
@@ -20,11 +20,11 @@ FaceValue<int>
 MeshDispatcher<Dimension>::_getFaceNewOwner()
 {
   const auto& face_to_cell_matrix
-      = m_mesh.connectivity().faceToCellMatrix();
-  const auto& cell_number = m_mesh.connectivity().cellNumber();
+      = m_connectivity.faceToCellMatrix();
+  const auto& cell_number = m_connectivity.cellNumber();
 
-  FaceValue<int> face_new_owner(m_mesh.connectivity());
-  parallel_for(m_mesh.numberOfFaces(), PASTIS_LAMBDA(const FaceId& l) {
+  FaceValue<int> face_new_owner(m_connectivity);
+  parallel_for(m_connectivity.numberOfFaces(), PASTIS_LAMBDA(const FaceId& l) {
       const auto& face_to_cell = face_to_cell_matrix[l];
       CellId Jmin = face_to_cell[0];
 
@@ -45,12 +45,11 @@ template <int Dimension>
 NodeValue<int>
 MeshDispatcher<Dimension>::_getNodeNewOwner()
 {
-  const auto& node_to_cell_matrix
-      = m_mesh.connectivity().nodeToCellMatrix();
-  const auto& cell_number = m_mesh.connectivity().cellNumber();
+  const auto& node_to_cell_matrix = m_connectivity.nodeToCellMatrix();
+  const auto& cell_number = m_connectivity.cellNumber();
 
-  NodeValue<int> node_new_owner(m_mesh.connectivity());
-  parallel_for(m_mesh.numberOfNodes(), PASTIS_LAMBDA(const NodeId& r) {
+  NodeValue<int> node_new_owner(m_connectivity);
+  parallel_for(m_connectivity.numberOfNodes(), PASTIS_LAMBDA(const NodeId& r) {
       const auto& node_to_cell = node_to_cell_matrix[r];
       CellId Jmin = node_to_cell[0];
 
@@ -72,13 +71,13 @@ const typename MeshDispatcher<Dimension>::CellListToSendByProc
 MeshDispatcher<Dimension>::_buildCellListToSend() const
 {
   const auto& node_to_cell_matrix
-      = m_mesh.connectivity().nodeToCellMatrix();
+      = m_connectivity.nodeToCellMatrix();
   const auto& cell_to_node_matrix
-      = m_mesh.connectivity().cellToNodeMatrix();
+      = m_connectivity.cellToNodeMatrix();
 
   std::vector<std::vector<CellId>> cell_vector_to_send_by_proc(parallel::size());
   Array<bool> send_to_rank(parallel::size());
-  for (CellId j=0; j<m_mesh.numberOfCells(); ++j) {
+  for (CellId j=0; j<m_connectivity.numberOfCells(); ++j) {
     send_to_rank.fill(false);
     const auto& cell_to_node = cell_to_node_matrix[j];
 
@@ -124,9 +123,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
   if constexpr (Dimension>1) {
     std::vector<Array<int>> recv_number_of_face_per_cell_by_proc =
         [&] () {
-          CellValue<int> number_of_face_per_cell(m_mesh.connectivity());
-          const auto& cell_to_face_matrix = m_mesh.connectivity().cellToFaceMatrix();
-          parallel_for(m_mesh.numberOfCells(), PASTIS_LAMBDA(const CellId& j){
+          CellValue<int> number_of_face_per_cell(m_connectivity);
+          const auto& cell_to_face_matrix = m_connectivity.cellToFaceMatrix();
+          parallel_for(m_connectivity.numberOfCells(), PASTIS_LAMBDA(const CellId& j){
               number_of_face_per_cell[j] = cell_to_face_matrix[j].size();
             });
 
@@ -135,8 +134,8 @@ MeshDispatcher<Dimension>::_dispatchFaces()
 
     std::vector<Array<int>> recv_cell_face_number_by_proc(parallel::size());
     {
-      const auto& cell_to_face_matrix = m_mesh.connectivity().cellToFaceMatrix();
-      const FaceValue<const int>& face_number = m_mesh.connectivity().faceNumber();
+      const auto& cell_to_face_matrix = m_connectivity.cellToFaceMatrix();
+      const FaceValue<const int>& face_number = m_connectivity.faceNumber();
 
       std::vector<Array<int>> cell_face_number_to_send_by_proc(parallel::size());
       {
@@ -198,7 +197,7 @@ MeshDispatcher<Dimension>::_dispatchFaces()
     {
       std::vector<Array<bool>> cell_face_is_reversed_to_send_by_proc(parallel::size());
       {
-        const auto& cell_face_is_reversed = m_mesh.connectivity().cellFaceIsReversed();
+        const auto& cell_face_is_reversed = m_connectivity.cellFaceIsReversed();
         for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
           std::vector<bool> face_is_reversed_by_cell_vector;
           for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
@@ -234,10 +233,10 @@ MeshDispatcher<Dimension>::_dispatchFaces()
 
     std::vector<Array<const FaceId>> send_face_id_by_proc(parallel::size());
     {
-      const auto& cell_to_face_matrix = m_mesh.connectivity().cellToFaceMatrix();
+      const auto& cell_to_face_matrix = m_connectivity.cellToFaceMatrix();
 
       for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-        Array<bool> tag(m_mesh.numberOfFaces());
+        Array<bool> tag(m_connectivity.numberOfFaces());
         tag.fill(false);
         std::vector<FaceId> face_id_vector;
         for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
@@ -257,7 +256,7 @@ MeshDispatcher<Dimension>::_dispatchFaces()
 
     std::vector<Array<const int>> send_face_number_by_proc(parallel::size());
     {
-      const FaceValue<const int>& face_number = m_mesh.connectivity().faceNumber();
+      const FaceValue<const int>& face_number = m_connectivity.faceNumber();
 
       for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
         Array<int> send_face_number(send_face_id_by_proc[i_rank].size());
@@ -328,9 +327,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
 
     std::vector<Array<int>> recv_face_number_of_node_by_proc(parallel::size());
     {
-      const auto& face_to_node_matrix = m_mesh.connectivity().faceToNodeMatrix();
-      FaceValue<int> number_of_node_per_face(m_mesh.connectivity());
-      parallel_for(m_mesh.numberOfFaces(), PASTIS_LAMBDA(const FaceId& j){
+      const auto& face_to_node_matrix = m_connectivity.faceToNodeMatrix();
+      FaceValue<int> number_of_node_per_face(m_connectivity);
+      parallel_for(m_connectivity.numberOfFaces(), PASTIS_LAMBDA(const FaceId& j){
           number_of_node_per_face[j] = face_to_node_matrix[j].size();
         });
 
@@ -353,8 +352,8 @@ MeshDispatcher<Dimension>::_dispatchFaces()
 
     std::vector<Array<int>> face_node_number_to_send_by_proc(parallel::size());
     {
-      const auto& face_to_node_matrix = m_mesh.connectivity().faceToNodeMatrix();
-      const NodeValue<const int>& node_number = m_mesh.connectivity().nodeNumber();
+      const auto& face_to_node_matrix = m_connectivity.faceToNodeMatrix();
+      const NodeValue<const int>& node_number = m_connectivity.nodeNumber();
       for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
         std::vector<int> node_number_by_face_vector;
         for (size_t l=0; l<send_face_id_by_proc[i_rank].size(); ++l) {
@@ -394,7 +393,7 @@ MeshDispatcher<Dimension>::_dispatchFaces()
 
     // Getting references
     Array<const size_t> number_of_ref_face_list_per_proc
-        = parallel::allGather(m_mesh.connectivity().numberOfRefFaceList());
+        = parallel::allGather(m_connectivity.numberOfRefFaceList());
 
     const size_t number_of_face_list_sender
         = [&] () {
@@ -431,9 +430,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
         // sending references tags
         Array<RefId::TagNumberType> ref_tag_list{number_of_ref_face_list_per_proc[sender_rank]};
         if (parallel::rank() == sender_rank){
-          for (size_t i_ref_face_list=0; i_ref_face_list<m_mesh.connectivity().numberOfRefFaceList();
+          for (size_t i_ref_face_list=0; i_ref_face_list<m_connectivity.numberOfRefFaceList();
                ++i_ref_face_list) {
-            auto ref_face_list = m_mesh.connectivity().refFaceList(i_ref_face_list);
+            auto ref_face_list = m_connectivity.refFaceList(i_ref_face_list);
             ref_tag_list[i_ref_face_list] = ref_face_list.refId().tagNumber();
           }
         }
@@ -442,9 +441,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
         // sending references name size
         Array<size_t> ref_name_size_list{number_of_ref_face_list_per_proc[sender_rank]};
         if (parallel::rank() == sender_rank){
-          for (size_t i_ref_face_list=0; i_ref_face_list<m_mesh.connectivity().numberOfRefFaceList();
+          for (size_t i_ref_face_list=0; i_ref_face_list<m_connectivity.numberOfRefFaceList();
                ++i_ref_face_list) {
-            auto ref_face_list = m_mesh.connectivity().refFaceList(i_ref_face_list);
+            auto ref_face_list = m_connectivity.refFaceList(i_ref_face_list);
             ref_name_size_list[i_ref_face_list] = ref_face_list.refId().tagName().size();
           }
         }
@@ -454,9 +453,9 @@ MeshDispatcher<Dimension>::_dispatchFaces()
         Array<RefId::TagNameType::value_type> ref_name_cat{sum(ref_name_size_list)};
         if (parallel::rank() == sender_rank){
           size_t i_char=0;
-          for (size_t i_ref_face_list=0; i_ref_face_list<m_mesh.connectivity().numberOfRefFaceList();
+          for (size_t i_ref_face_list=0; i_ref_face_list<m_connectivity.numberOfRefFaceList();
                ++i_ref_face_list) {
-            auto ref_face_list = m_mesh.connectivity().refFaceList(i_ref_face_list);
+            auto ref_face_list = m_connectivity.refFaceList(i_ref_face_list);
             for (auto c : ref_face_list.refId().tagName()) {
               ref_name_cat[i_char++] = c;
             }
@@ -482,14 +481,14 @@ MeshDispatcher<Dimension>::_dispatchFaces()
         constexpr size_t block_size = sizeof(block_type);
         const size_t nb_block = ref_id_list.size()/block_size + (ref_id_list.size()%block_size != 0);
         for (size_t i_block=0; i_block<nb_block; ++i_block) {
-          FaceValue<block_type> face_references(m_mesh.connectivity());
+          FaceValue<block_type> face_references(m_connectivity);
           face_references.fill(0);
 
-          if (m_mesh.connectivity().numberOfRefFaceList() > 0) {
+          if (m_connectivity.numberOfRefFaceList() > 0) {
             const size_t max_i_ref = std::min(ref_id_list.size(), block_size*(i_block+1));
             for (size_t i_ref=block_size*i_block, i=0; i_ref<max_i_ref; ++i_ref, ++i) {
               block_type ref_bit{1<<i};
-              auto ref_face_list = m_mesh.connectivity().refFaceList(i_ref);
+              auto ref_face_list = m_connectivity.refFaceList(i_ref);
 
               const auto& face_list = ref_face_list.faceList();
               for (size_t i_face=0; i_face<face_list.size(); ++i_face) {
@@ -551,8 +550,8 @@ MeshDispatcher<Dimension>::_dispatchFaces()
 
 
 template <int Dimension>
-MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
-    : m_mesh(mesh),
+MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh_deprecated)
+    : m_connectivity(mesh_deprecated.connectivity()),
       m_cell_new_owner(_getCellNewOwner()),
       m_face_new_owner(_getFaceNewOwner()),
       m_node_new_owner(_getNodeNewOwner()),
@@ -560,13 +559,13 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
       m_nb_cell_to_send_by_proc(_buildNbCellToSend()),
       m_nb_cell_to_recv_by_proc(parallel::allToAll(m_nb_cell_to_send_by_proc))
 {
-  m_recv_cell_number_by_proc = this->exchange(mesh.connectivity().cellNumber());
+  m_recv_cell_number_by_proc = this->exchange(m_connectivity.cellNumber());
 
-  const auto& cell_to_node_matrix = mesh.connectivity().cellToNodeMatrix();
+  const auto& cell_to_node_matrix = m_connectivity.cellToNodeMatrix();
 
   std::vector<Array<int>> cell_node_number_to_send_by_proc =
       [&] () {
-        const NodeValue<const int>& node_number = mesh.connectivity().nodeNumber();
+        const NodeValue<const int>& node_number = m_connectivity.nodeNumber();
         std::vector<Array<int>> cell_node_number_to_send_by_proc(parallel::size());
         for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
           std::vector<int> node_number_by_cell_vector;
@@ -585,8 +584,8 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
 
   std::vector<Array<int>> recv_number_of_node_per_cell_by_proc
       = [&] () {
-          CellValue<int> number_of_node_per_cell(mesh.connectivity());
-          parallel_for(mesh.numberOfCells(), PASTIS_LAMBDA(const CellId& j){
+          CellValue<int> number_of_node_per_cell(m_connectivity);
+          parallel_for(m_connectivity.numberOfCells(), PASTIS_LAMBDA(const CellId& j){
               number_of_node_per_cell[j] = cell_to_node_matrix[j].size();
             });
           return this->exchange(number_of_node_per_cell);
@@ -652,7 +651,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
 
   {
     std::vector<Array<CellType>> recv_cell_type_by_proc
-        = this->exchange(mesh.connectivity().cellType());
+        = this->exchange(m_connectivity.cellType());
     m_new_descriptor.cell_type_vector.resize(cell_number_id_map.size());
     for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
       for (size_t i=0; i<m_recv_cell_number_by_proc[i_rank].size(); ++i) {
@@ -666,7 +665,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
 
   std::vector<Array<const NodeId>> send_node_id_by_proc(parallel::size());
   for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-    Array<bool> tag(mesh.numberOfNodes());
+    Array<bool> tag(m_connectivity.numberOfNodes());
     tag.fill(false);
     std::vector<NodeId> node_id_vector;
     for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
@@ -692,7 +691,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
 
   std::vector<Array<const NodeId>> recv_node_id_correspondance_by_proc(parallel::size());
   {
-    const NodeValue<const int>& node_number = mesh.connectivity().nodeNumber();
+    const NodeValue<const int>& node_number = m_connectivity.nodeNumber();
     std::vector<Array<const int>> send_node_number_by_proc(parallel::size());
     for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
       Array<int> send_node_number(send_node_id_by_proc[i_rank].size());
@@ -765,12 +764,12 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
   this->_dispatchFaces();
 
   using ConnectivityType = Connectivity<Dimension>;
-  std::shared_ptr p_connectivity
+  std::shared_ptr m_dispatched_connectivity
       = ConnectivityType::build(m_new_descriptor);
 
   using Rd = TinyVector<Dimension, double>;
 
-  const NodeValue<const Rd>& xr = m_mesh.xr();
+  const NodeValue<const Rd>& xr = mesh_deprecated.xr();
   std::vector<Array<const Rd>> send_node_coord_by_proc(parallel::size());
   for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
     Array<Rd> send_node_coord(nb_node_to_send_by_proc[i_rank]);
@@ -789,7 +788,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
   parallel::exchange(send_node_coord_by_proc, recv_node_coord_by_proc);
 
   Array<const size_t> number_of_ref_node_list_per_proc
-      = parallel::allGather(m_mesh.connectivity().numberOfRefNodeList());
+      = parallel::allGather(m_connectivity.numberOfRefNodeList());
   if (max(number_of_ref_node_list_per_proc) > 0) {
     perr() << __FILE__ << ':' << __LINE__ << ": "
            << rang::fgB::red << "exchange of node ref list not implemented yet!"
@@ -797,7 +796,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
   }
 
   // Finally build the mesh
-  NodeValue<Rd> new_xr(*p_connectivity);
+  NodeValue<Rd> new_xr(*m_dispatched_connectivity);
   for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
     for (size_t r=0; r<recv_node_coord_by_proc[i_rank].size(); ++r) {
       const NodeId& node_id = recv_node_id_correspondance_by_proc[i_rank][r];
@@ -805,7 +804,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
     }
   }
 
-  m_dispatched_mesh = std::make_shared<MeshType>(p_connectivity, new_xr);
+  m_dispatched_mesh = std::make_shared<MeshType>(m_dispatched_connectivity, new_xr);
 }
 
 template MeshDispatcher<1>::MeshDispatcher(const MeshType& mesh);
diff --git a/src/mesh/MeshDispatcher.hpp b/src/mesh/MeshDispatcher.hpp
index 097245672992699f0d61ed16250040b2246d5cd5..878a5a70775134c98db2d608a803770a16df6f2a 100644
--- a/src/mesh/MeshDispatcher.hpp
+++ b/src/mesh/MeshDispatcher.hpp
@@ -7,19 +7,24 @@
 
 #include <unordered_map>
 
+#warning use MeshType instead of dimension as template parameter?
 template <int Dimension>
 class MeshDispatcher
 {
  public:
-  using MeshType = Mesh<Connectivity<Dimension>>;
+  using ConnectivityType = Connectivity<Dimension>;
+  using MeshType = Mesh<ConnectivityType>;
 
  private:
-  const MeshType& m_mesh;
+  const ConnectivityType& m_connectivity;
 
   ConnectivityDescriptor m_new_descriptor;
 
+  [[deprecated]]
   std::shared_ptr<MeshType> m_dispatched_mesh;
 
+  std::shared_ptr<ConnectivityType> m_dispatched_connectivity;
+
   CellValue<const int> m_cell_new_owner;
   FaceValue<const int> m_face_new_owner;
   NodeValue<const int> m_node_new_owner;
@@ -44,11 +49,17 @@ class MeshDispatcher
   void _dispatchFaces();
  public:
 
-  const std::shared_ptr<MeshType> dispatchedMesh() const
+  [[deprecated]]
+  std::shared_ptr<MeshType> dispatchedMesh() const
   {
     return m_dispatched_mesh;
   }
 
+  const std::shared_ptr<ConnectivityType>& dispatchedConnectivity() const
+  {
+    return m_dispatched_connectivity;
+  }
+
   PASTIS_INLINE
   const CellValue<const int>& cellNewOwner() const
   {