From 603ade901387ddc1e56871cbd0b51527bcb017e8 Mon Sep 17 00:00:00 2001
From: Stephane Del Pino <stephane.delpino44@gmail.com>
Date: Thu, 7 Mar 2019 15:59:20 +0100
Subject: [PATCH] Continue mesh dispatcher clean-up

Mostly lines displacement and blocks embedding
---
 src/mesh/MeshDispatcher.cpp | 536 +++++++++++++++++++-----------------
 src/mesh/MeshDispatcher.hpp |   2 +
 2 files changed, 285 insertions(+), 253 deletions(-)

diff --git a/src/mesh/MeshDispatcher.cpp b/src/mesh/MeshDispatcher.cpp
index 970a3e281..0677ccce7 100644
--- a/src/mesh/MeshDispatcher.cpp
+++ b/src/mesh/MeshDispatcher.cpp
@@ -130,43 +130,41 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
   std::vector<Array<int>> recv_cell_number_by_proc
       = this->exchange(mesh.connectivity().cellNumber());
 
-  std::vector<Array<CellType>> recv_cell_type_by_proc
-      = this->exchange(mesh.connectivity().cellType());
-
-  std::vector<Array<int>> recv_cell_new_owner_by_proc
-      = this->exchange(m_cell_new_owner);
-
-  CellValue<int> number_of_node_per_cell(mesh.connectivity());
-
   const auto& cell_to_node_matrix = mesh.connectivity().cellToNodeMatrix();
-  parallel_for(mesh.numberOfCells(), PASTIS_LAMBDA(const CellId& j){
-      number_of_node_per_cell[j] = cell_to_node_matrix[j].size();
-    });
 
-  std::vector<Array<int>> recv_number_of_node_per_cell_by_proc
-      = this->exchange(number_of_node_per_cell);
+  std::vector<Array<int>> cell_node_number_to_send_by_proc =
+      [&] () {
+        const NodeValue<const int>& node_number = mesh.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;
+          for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
+            const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
+            const auto& cell_node_list = cell_to_node_matrix[cell_id];
+            for (size_t r=0; r<cell_node_list.size(); ++r) {
+              const NodeId& node_id = cell_node_list[r];
+              node_number_by_cell_vector.push_back(node_number[node_id]);
+            }
+          }
+          cell_node_number_to_send_by_proc[i_rank] = convert_to_array(node_number_by_cell_vector);
+        }
+        return cell_node_number_to_send_by_proc;
+      } ();
 
-  const NodeValue<const int>& node_number = mesh.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;
-    for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
-      const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
-      const auto& cell_node_list = cell_to_node_matrix[cell_id];
-      for (size_t r=0; r<cell_node_list.size(); ++r) {
-        const NodeId& node_id = cell_node_list[r];
-        node_number_by_cell_vector.push_back(node_number[node_id]);
-      }
-    }
-    cell_node_number_to_send_by_proc[i_rank] = convert_to_array(node_number_by_cell_vector);
-  }
+  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){
+              number_of_node_per_cell[j] = cell_to_node_matrix[j].size();
+            });
+          return this->exchange(number_of_node_per_cell);
+        } ();
 
   std::vector<Array<int>> recv_cell_node_number_by_proc(parallel::size());
   for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
     recv_cell_node_number_by_proc[i_rank]
         = Array<int>(sum(recv_number_of_node_per_cell_by_proc[i_rank]));
   }
-
   parallel::exchange(cell_node_number_to_send_by_proc, recv_cell_node_number_by_proc);
 
   const std::unordered_map<int, int> node_number_id_map
@@ -183,12 +181,9 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
           return node_number_id_map;
         } ();
 
-
-  ConnectivityDescriptor new_descriptor;
-
-  new_descriptor.node_number_vector.resize(node_number_id_map.size());
+  m_new_descriptor.node_number_vector.resize(node_number_id_map.size());
   for (const auto& [number, id] : node_number_id_map) {
-    new_descriptor.node_number_vector[id] = number;
+    m_new_descriptor.node_number_vector[id] = number;
   }
 
   for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
@@ -200,7 +195,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
         Assert(searched_node_id != node_number_id_map.end());
         node_vector.push_back(searched_node_id->second);
       }
-      new_descriptor.cell_by_node_vector.emplace_back(node_vector);
+      m_new_descriptor.cell_by_node_vector.emplace_back(node_vector);
     }
   }
 
@@ -218,18 +213,22 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
           return cell_number_id_map;
         } ();
 
-  new_descriptor.cell_number_vector.resize(cell_number_id_map.size());
+  m_new_descriptor.cell_number_vector.resize(cell_number_id_map.size());
   for (const auto& [number, id] : cell_number_id_map) {
-    new_descriptor.cell_number_vector[id] = number;
+    m_new_descriptor.cell_number_vector[id] = number;
   }
 
-  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<recv_cell_number_by_proc[i_rank].size(); ++i) {
-      int cell_number = recv_cell_number_by_proc[i_rank][i];
-      const auto& searched_cell_id = cell_number_id_map.find(cell_number);
-      Assert(searched_cell_id != cell_number_id_map.end());
-      new_descriptor.cell_type_vector[searched_cell_id->second] = recv_cell_type_by_proc[i_rank][i];
+  {
+    std::vector<Array<CellType>> recv_cell_type_by_proc
+        = this->exchange(mesh.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<recv_cell_number_by_proc[i_rank].size(); ++i) {
+        int cell_number = recv_cell_number_by_proc[i_rank][i];
+        const auto& searched_cell_id = cell_number_id_map.find(cell_number);
+        Assert(searched_cell_id != cell_number_id_map.end());
+        m_new_descriptor.cell_type_vector[searched_cell_id->second] = recv_cell_type_by_proc[i_rank][i];
+      }
     }
   }
 
@@ -252,16 +251,6 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
     send_node_id_by_proc[i_rank] = convert_to_array(node_id_vector);
   }
 
-  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());
-    const Array<const NodeId> send_node_id = send_node_id_by_proc[i_rank];
-    parallel_for(send_node_number.size(), PASTIS_LAMBDA(const size_t& j){
-        send_node_number[j] = node_number[send_node_id[j]];
-      });
-    send_node_number_by_proc[i_rank] = send_node_number;
-  }
-
   Array<unsigned int> nb_node_to_send_by_proc(parallel::size());
   for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
     nb_node_to_send_by_proc[i_rank] = send_node_id_by_proc[i_rank].size();
@@ -269,94 +258,119 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
   Array<const unsigned int> nb_node_to_recv_by_proc
       = parallel::allToAll(nb_node_to_send_by_proc);
 
-  std::vector<Array<int>> recv_node_number_by_proc(parallel::size());
-  for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
-    recv_node_number_by_proc[i_rank] = Array<int>(nb_node_to_recv_by_proc[i_rank]);
-  }
-  parallel::exchange(send_node_number_by_proc, recv_node_number_by_proc);
-
   std::vector<Array<const NodeId>> recv_node_id_correspondance_by_proc(parallel::size());
-  for (size_t i_rank=0; i_rank<nb_node_to_recv_by_proc.size(); ++i_rank) {
-    Array<NodeId> node_id_correspondace(nb_node_to_recv_by_proc[i_rank]);
-    for (size_t l=0; l<nb_node_to_recv_by_proc[i_rank]; ++l) {
-      const int& node_number = recv_node_number_by_proc[i_rank][l];
-      const auto& searched_node_id = node_number_id_map.find(node_number);
-      Assert(searched_node_id != node_number_id_map.end());
-      node_id_correspondace[l] = searched_node_id->second;
+  {
+    const NodeValue<const int>& node_number = mesh.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());
+      const Array<const NodeId> send_node_id = send_node_id_by_proc[i_rank];
+      parallel_for(send_node_number.size(), PASTIS_LAMBDA(const size_t& j){
+          send_node_number[j] = node_number[send_node_id[j]];
+        });
+      send_node_number_by_proc[i_rank] = send_node_number;
     }
-    recv_node_id_correspondance_by_proc[i_rank] = node_id_correspondace;
-  }
 
-  new_descriptor.cell_owner_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<recv_cell_number_by_proc[i_rank].size(); ++i) {
-      int cell_number = recv_cell_number_by_proc[i_rank][i];
-      const auto& searched_cell_id = cell_number_id_map.find(cell_number);
-      Assert(searched_cell_id != cell_number_id_map.end());
-      new_descriptor.cell_owner_vector[searched_cell_id->second] = recv_cell_new_owner_by_proc[i_rank][i];
+    std::vector<Array<int>> recv_node_number_by_proc(parallel::size());
+    for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
+      recv_node_number_by_proc[i_rank] = Array<int>(nb_node_to_recv_by_proc[i_rank]);
     }
-  }
+    parallel::exchange(send_node_number_by_proc, recv_node_number_by_proc);
 
-  std::vector<Array<const int>> send_node_owner_by_proc(parallel::size());
-  for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-    Array<int> send_node_owner(nb_node_to_send_by_proc[i_rank]);
-    const Array<const NodeId> send_node_id = send_node_id_by_proc[i_rank];
-    parallel_for(send_node_id.size(), PASTIS_LAMBDA(const size_t& r) {
-        const NodeId& node_id = send_node_id[r];
-        send_node_owner[r] = m_node_new_owner[node_id];
-      });
-    send_node_owner_by_proc[i_rank] = send_node_owner;
+    for (size_t i_rank=0; i_rank<nb_node_to_recv_by_proc.size(); ++i_rank) {
+      Array<NodeId> node_id_correspondace(nb_node_to_recv_by_proc[i_rank]);
+      for (size_t l=0; l<nb_node_to_recv_by_proc[i_rank]; ++l) {
+        const int& node_number = recv_node_number_by_proc[i_rank][l];
+        const auto& searched_node_id = node_number_id_map.find(node_number);
+        Assert(searched_node_id != node_number_id_map.end());
+        node_id_correspondace[l] = searched_node_id->second;
+      }
+      recv_node_id_correspondance_by_proc[i_rank] = node_id_correspondace;
+    }
   }
 
-  std::vector<Array<int>> recv_node_owner_by_proc(parallel::size());
-  for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-    recv_node_owner_by_proc[i_rank] = Array<int>(nb_node_to_recv_by_proc[i_rank]);
+  {
+    std::vector<Array<int>> recv_cell_new_owner_by_proc
+        = this->exchange(m_cell_new_owner);
+    m_new_descriptor.cell_owner_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<recv_cell_number_by_proc[i_rank].size(); ++i) {
+        int cell_number = recv_cell_number_by_proc[i_rank][i];
+        const auto& searched_cell_id = cell_number_id_map.find(cell_number);
+        Assert(searched_cell_id != cell_number_id_map.end());
+        m_new_descriptor.cell_owner_vector[searched_cell_id->second] = recv_cell_new_owner_by_proc[i_rank][i];
+      }
+    }
   }
-  parallel::exchange(send_node_owner_by_proc, recv_node_owner_by_proc);
 
-  new_descriptor.node_owner_vector.resize(new_descriptor.node_number_vector.size());
-  for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-    for (size_t r=0; r<recv_node_owner_by_proc[i_rank].size(); ++r) {
-      const NodeId& node_id = recv_node_id_correspondance_by_proc[i_rank][r];
-      new_descriptor.node_owner_vector[node_id] = recv_node_owner_by_proc[i_rank][r];
+  {
+    std::vector<Array<const int>> send_node_owner_by_proc(parallel::size());
+    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+      Array<int> send_node_owner(nb_node_to_send_by_proc[i_rank]);
+      const Array<const NodeId> send_node_id = send_node_id_by_proc[i_rank];
+      parallel_for(send_node_id.size(), PASTIS_LAMBDA(const size_t& r) {
+          const NodeId& node_id = send_node_id[r];
+          send_node_owner[r] = m_node_new_owner[node_id];
+        });
+      send_node_owner_by_proc[i_rank] = send_node_owner;
     }
-  }
 
-  if constexpr(Dimension>1) {  // Faces
-    CellValue<int> number_of_face_per_cell(mesh.connectivity());
-    const auto& cell_to_face_matrix = mesh.connectivity().cellToFaceMatrix();
-    parallel_for(mesh.numberOfCells(), PASTIS_LAMBDA(const CellId& j){
-        number_of_face_per_cell[j] = cell_to_face_matrix[j].size();
-      });
+    std::vector<Array<int>> recv_node_owner_by_proc(parallel::size());
+    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+      recv_node_owner_by_proc[i_rank] = Array<int>(nb_node_to_recv_by_proc[i_rank]);
+    }
+    parallel::exchange(send_node_owner_by_proc, recv_node_owner_by_proc);
 
-    std::vector<Array<int>> recv_number_of_face_per_cell_by_proc
-        = this->exchange(number_of_face_per_cell);
+    m_new_descriptor.node_owner_vector.resize(m_new_descriptor.node_number_vector.size());
+    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+      for (size_t r=0; r<recv_node_owner_by_proc[i_rank].size(); ++r) {
+        const NodeId& node_id = recv_node_id_correspondance_by_proc[i_rank][r];
+        m_new_descriptor.node_owner_vector[node_id] = recv_node_owner_by_proc[i_rank][r];
+      }
+    }
+  }
 
+  if constexpr(Dimension>1) {  // Faces
+    std::vector<Array<int>> recv_number_of_face_per_cell_by_proc =
+        [&] () {
+          CellValue<int> number_of_face_per_cell(mesh.connectivity());
+          const auto& cell_to_face_matrix = mesh.connectivity().cellToFaceMatrix();
+          parallel_for(mesh.numberOfCells(), PASTIS_LAMBDA(const CellId& j){
+              number_of_face_per_cell[j] = cell_to_face_matrix[j].size();
+            });
+
+          return this->exchange(number_of_face_per_cell);
+        } ();
 
-    const FaceValue<const int>& face_number = mesh.connectivity().faceNumber();
-    std::vector<Array<int>> cell_face_number_to_send_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
-      std::vector<int> face_number_by_cell_vector;
-      for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
-        const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
-        const auto& cell_face_list = cell_to_face_matrix[cell_id];
-        for (size_t r=0; r<cell_face_list.size(); ++r) {
-          const FaceId& face_id = cell_face_list[r];
-          face_number_by_cell_vector.push_back(face_number[face_id]);
+    std::vector<Array<int>> recv_cell_face_number_by_proc(parallel::size());
+    {
+      const auto& cell_to_face_matrix = mesh.connectivity().cellToFaceMatrix();
+      const FaceValue<const int>& face_number = mesh.connectivity().faceNumber();
+
+      std::vector<Array<int>> cell_face_number_to_send_by_proc(parallel::size());
+      {
+        for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
+          std::vector<int> face_number_by_cell_vector;
+          for (size_t j=0; j<m_cell_list_to_send_by_proc[i_rank].size(); ++j) {
+            const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
+            const auto& cell_face_list = cell_to_face_matrix[cell_id];
+            for (size_t r=0; r<cell_face_list.size(); ++r) {
+              const FaceId& face_id = cell_face_list[r];
+              face_number_by_cell_vector.push_back(face_number[face_id]);
+            }
+          }
+          cell_face_number_to_send_by_proc[i_rank] = convert_to_array(face_number_by_cell_vector);
         }
       }
-      cell_face_number_to_send_by_proc[i_rank] = convert_to_array(face_number_by_cell_vector);
-    }
 
+      for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
+        recv_cell_face_number_by_proc[i_rank]
+            = Array<int>(sum(recv_number_of_face_per_cell_by_proc[i_rank]));
+      }
 
-    std::vector<Array<int>> recv_cell_face_number_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
-      recv_cell_face_number_by_proc[i_rank]
-          = Array<int>(sum(recv_number_of_face_per_cell_by_proc[i_rank]));
+      parallel::exchange(cell_face_number_to_send_by_proc, recv_cell_face_number_by_proc);
     }
 
-    parallel::exchange(cell_face_number_to_send_by_proc, recv_cell_face_number_by_proc);
-
     const std::unordered_map<int, int> face_number_id_map
         = [&] () {
             std::unordered_map<int, int> face_number_id_map;
@@ -372,9 +386,9 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
           } ();
 
 
-    new_descriptor.face_number_vector.resize(face_number_id_map.size());
+    m_new_descriptor.face_number_vector.resize(face_number_id_map.size());
     for (const auto& [number, id] : face_number_id_map) {
-      new_descriptor.face_number_vector[id] = number;
+      m_new_descriptor.face_number_vector[id] = number;
     }
 
     for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
@@ -386,72 +400,82 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
           Assert(searched_face_id != face_number_id_map.end());
           face_vector.push_back(searched_face_id->second);
         }
-        new_descriptor.cell_to_face_vector.emplace_back(face_vector);
+        m_new_descriptor.cell_to_face_vector.emplace_back(face_vector);
       }
     }
 
-    std::vector<Array<bool>> cell_face_is_reversed_to_send_by_proc(parallel::size());
     {
-      const auto& cell_face_is_reversed = mesh.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) {
-          const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
-          const auto& face_is_reversed = cell_face_is_reversed.itemValues(cell_id);
-          for (size_t L=0; L<face_is_reversed.size(); ++L) {
-            face_is_reversed_by_cell_vector.push_back(face_is_reversed[L]);
+      std::vector<Array<bool>> cell_face_is_reversed_to_send_by_proc(parallel::size());
+      {
+        const auto& cell_face_is_reversed = mesh.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) {
+            const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
+            const auto& face_is_reversed = cell_face_is_reversed.itemValues(cell_id);
+            for (size_t L=0; L<face_is_reversed.size(); ++L) {
+              face_is_reversed_by_cell_vector.push_back(face_is_reversed[L]);
+            }
           }
+          cell_face_is_reversed_to_send_by_proc[i_rank] = convert_to_array(face_is_reversed_by_cell_vector);
         }
-        cell_face_is_reversed_to_send_by_proc[i_rank] = convert_to_array(face_is_reversed_by_cell_vector);
       }
-    }
 
-    std::vector<Array<bool>> recv_cell_face_is_reversed_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
-      recv_cell_face_is_reversed_by_proc[i_rank]
-          = Array<bool>(sum(recv_number_of_face_per_cell_by_proc[i_rank]));
-    }
+      std::vector<Array<bool>> recv_cell_face_is_reversed_by_proc(parallel::size());
+      for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
+        recv_cell_face_is_reversed_by_proc[i_rank]
+            = Array<bool>(sum(recv_number_of_face_per_cell_by_proc[i_rank]));
+      }
 
-    parallel::exchange(cell_face_is_reversed_to_send_by_proc, recv_cell_face_is_reversed_by_proc);
+      parallel::exchange(cell_face_is_reversed_to_send_by_proc, recv_cell_face_is_reversed_by_proc);
 
-    for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
-      int l=0;
-      for (size_t i=0; i<recv_cell_number_by_proc[i_rank].size(); ++i) {
-        std::vector<bool> face_is_reversed_vector;
-        for (int k=0; k<recv_number_of_face_per_cell_by_proc[i_rank][i]; ++k) {
-          face_is_reversed_vector.push_back(recv_cell_face_is_reversed_by_proc[i_rank][l++]);
+      for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
+        int l=0;
+        for (size_t i=0; i<recv_cell_number_by_proc[i_rank].size(); ++i) {
+          std::vector<bool> face_is_reversed_vector;
+          for (int k=0; k<recv_number_of_face_per_cell_by_proc[i_rank][i]; ++k) {
+            face_is_reversed_vector.push_back(recv_cell_face_is_reversed_by_proc[i_rank][l++]);
+          }
+          m_new_descriptor.cell_face_is_reversed_vector.emplace_back(face_is_reversed_vector);
         }
-        new_descriptor.cell_face_is_reversed_vector.emplace_back(face_is_reversed_vector);
       }
     }
 
     std::vector<Array<const FaceId>> send_face_id_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-      Array<bool> tag(mesh.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) {
-        const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
-        const auto& cell_face_list = cell_to_face_matrix[cell_id];
-        for (size_t l=0; l<cell_face_list.size(); ++l) {
-          const FaceId& face_id = cell_face_list[l];
-          if (not tag[face_id]) {
-            face_id_vector.push_back(face_id);
-            tag[face_id] = true;
+    {
+      const auto& cell_to_face_matrix = mesh.connectivity().cellToFaceMatrix();
+
+      for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+        Array<bool> tag(mesh.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) {
+          const CellId& cell_id = m_cell_list_to_send_by_proc[i_rank][j];
+          const auto& cell_face_list = cell_to_face_matrix[cell_id];
+          for (size_t l=0; l<cell_face_list.size(); ++l) {
+            const FaceId& face_id = cell_face_list[l];
+            if (not tag[face_id]) {
+              face_id_vector.push_back(face_id);
+              tag[face_id] = true;
+            }
           }
         }
+        send_face_id_by_proc[i_rank] = convert_to_array(face_id_vector);
       }
-      send_face_id_by_proc[i_rank] = convert_to_array(face_id_vector);
     }
 
     std::vector<Array<const int>> send_face_number_by_proc(parallel::size());
-    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());
-      const Array<const FaceId> send_face_id = send_face_id_by_proc[i_rank];
-      parallel_for(send_face_number.size(), PASTIS_LAMBDA(const size_t& j){
-          send_face_number[j] = face_number[send_face_id[j]];
-        });
-      send_face_number_by_proc[i_rank] = send_face_number;
+    {
+      const FaceValue<const int>& face_number = mesh.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());
+        const Array<const FaceId> send_face_id = send_face_id_by_proc[i_rank];
+        parallel_for(send_face_number.size(), PASTIS_LAMBDA(const size_t& j){
+            send_face_number[j] = face_number[send_face_id[j]];
+          });
+        send_face_number_by_proc[i_rank] = send_face_number;
+      }
     }
 
     Array<unsigned int> nb_face_to_send_by_proc(parallel::size());
@@ -462,112 +486,118 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
         = parallel::allToAll(nb_face_to_send_by_proc);
 
     std::vector<Array<int>> recv_face_number_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
-      recv_face_number_by_proc[i_rank] = Array<int>(nb_face_to_recv_by_proc[i_rank]);
+    {
+      for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
+        recv_face_number_by_proc[i_rank] = Array<int>(nb_face_to_recv_by_proc[i_rank]);
+      }
+      parallel::exchange(send_face_number_by_proc, recv_face_number_by_proc);
     }
-    parallel::exchange(send_face_number_by_proc, recv_face_number_by_proc);
 
     std::vector<Array<const FaceId>> recv_face_id_correspondance_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank<nb_face_to_recv_by_proc.size(); ++i_rank) {
-      Array<FaceId> face_id_correspondace(nb_face_to_recv_by_proc[i_rank]);
-      for (size_t l=0; l<nb_face_to_recv_by_proc[i_rank]; ++l) {
-        const int& face_number = recv_face_number_by_proc[i_rank][l];
-        const auto& searched_face_id = face_number_id_map.find(face_number);
-        Assert(searched_face_id != face_number_id_map.end());
-        face_id_correspondace[l] = searched_face_id->second;
+    {
+      for (size_t i_rank=0; i_rank<nb_face_to_recv_by_proc.size(); ++i_rank) {
+        Array<FaceId> face_id_correspondace(nb_face_to_recv_by_proc[i_rank]);
+        for (size_t l=0; l<nb_face_to_recv_by_proc[i_rank]; ++l) {
+          const int& face_number = recv_face_number_by_proc[i_rank][l];
+          const auto& searched_face_id = face_number_id_map.find(face_number);
+          Assert(searched_face_id != face_number_id_map.end());
+          face_id_correspondace[l] = searched_face_id->second;
+        }
+        recv_face_id_correspondance_by_proc[i_rank] = face_id_correspondace;
       }
-      recv_face_id_correspondance_by_proc[i_rank] = face_id_correspondace;
     }
 
 
-    std::vector<Array<const int>> send_face_owner_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-      Array<int> send_face_owner(nb_face_to_send_by_proc[i_rank]);
-      const Array<const FaceId> send_face_id = send_face_id_by_proc[i_rank];
-      parallel_for(send_face_id.size(), PASTIS_LAMBDA(const size_t& l) {
-          const FaceId& face_id = send_face_id[l];
-          send_face_owner[l] = m_face_new_owner[face_id];
-        });
-      send_face_owner_by_proc[i_rank] = send_face_owner;
-    }
-
-    std::vector<Array<int>> recv_face_owner_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-      recv_face_owner_by_proc[i_rank] = Array<int>(nb_face_to_recv_by_proc[i_rank]);
-    }
-    parallel::exchange(send_face_owner_by_proc, recv_face_owner_by_proc);
+    {
+      std::vector<Array<const int>> send_face_owner_by_proc(parallel::size());
+      for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+        Array<int> send_face_owner(nb_face_to_send_by_proc[i_rank]);
+        const Array<const FaceId> send_face_id = send_face_id_by_proc[i_rank];
+        parallel_for(send_face_id.size(), PASTIS_LAMBDA(const size_t& l) {
+            const FaceId& face_id = send_face_id[l];
+            send_face_owner[l] = m_face_new_owner[face_id];
+          });
+        send_face_owner_by_proc[i_rank] = send_face_owner;
+      }
 
-    new_descriptor.face_owner_vector.resize(new_descriptor.face_number_vector.size());
-    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-      for (size_t r=0; r<recv_face_owner_by_proc[i_rank].size(); ++r) {
-        const FaceId& face_id = recv_face_id_correspondance_by_proc[i_rank][r];
-        new_descriptor.face_owner_vector[face_id] = recv_face_owner_by_proc[i_rank][r];
+      std::vector<Array<int>> recv_face_owner_by_proc(parallel::size());
+      for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+        recv_face_owner_by_proc[i_rank] = Array<int>(nb_face_to_recv_by_proc[i_rank]);
       }
-    }
+      parallel::exchange(send_face_owner_by_proc, recv_face_owner_by_proc);
 
-    new_descriptor.face_owner_vector.resize(new_descriptor.face_number_vector.size());
-    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-      for (size_t r=0; r<recv_face_owner_by_proc[i_rank].size(); ++r) {
-        const FaceId& face_id = recv_face_id_correspondance_by_proc[i_rank][r];
-        new_descriptor.face_owner_vector[face_id] = recv_face_owner_by_proc[i_rank][r];
+      m_new_descriptor.face_owner_vector.resize(m_new_descriptor.face_number_vector.size());
+      for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+        for (size_t r=0; r<recv_face_owner_by_proc[i_rank].size(); ++r) {
+          const FaceId& face_id = recv_face_id_correspondance_by_proc[i_rank][r];
+          m_new_descriptor.face_owner_vector[face_id] = recv_face_owner_by_proc[i_rank][r];
+        }
       }
     }
 
-    FaceValue<int> number_of_node_per_face(mesh.connectivity());
-    const auto& face_to_node_matrix = mesh.connectivity().faceToNodeMatrix();
-    parallel_for(mesh.numberOfFaces(), PASTIS_LAMBDA(const FaceId& j){
-        number_of_node_per_face[j] = face_to_node_matrix[j].size();
-      });
-
-    std::vector<Array<const int>> send_face_number_of_node_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-      Array<int> send_face_number_of_node(nb_face_to_send_by_proc[i_rank]);
-      const Array<const FaceId> send_face_id = send_face_id_by_proc[i_rank];
-      parallel_for(send_face_id.size(), PASTIS_LAMBDA(const size_t& l) {
-          const FaceId& face_id = send_face_id[l];
-          send_face_number_of_node[l] = number_of_node_per_face[face_id];
+    std::vector<Array<int>> recv_face_number_of_node_by_proc(parallel::size());
+    {
+      const auto& face_to_node_matrix = mesh.connectivity().faceToNodeMatrix();
+      FaceValue<int> number_of_node_per_face(mesh.connectivity());
+      parallel_for(mesh.numberOfFaces(), PASTIS_LAMBDA(const FaceId& j){
+          number_of_node_per_face[j] = face_to_node_matrix[j].size();
         });
-      send_face_number_of_node_by_proc[i_rank] = send_face_number_of_node;
-    }
 
-    std::vector<Array<int>> recv_face_number_of_node_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-      recv_face_number_of_node_by_proc[i_rank] = Array<int>(nb_face_to_recv_by_proc[i_rank]);
+      std::vector<Array<const int>> send_face_number_of_node_by_proc(parallel::size());
+      for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+        Array<int> send_face_number_of_node(nb_face_to_send_by_proc[i_rank]);
+        const Array<const FaceId> send_face_id = send_face_id_by_proc[i_rank];
+        parallel_for(send_face_id.size(), PASTIS_LAMBDA(const size_t& l) {
+            const FaceId& face_id = send_face_id[l];
+            send_face_number_of_node[l] = number_of_node_per_face[face_id];
+          });
+        send_face_number_of_node_by_proc[i_rank] = send_face_number_of_node;
+      }
+
+      for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
+        recv_face_number_of_node_by_proc[i_rank] = Array<int>(nb_face_to_recv_by_proc[i_rank]);
+      }
+      parallel::exchange(send_face_number_of_node_by_proc, recv_face_number_of_node_by_proc);
     }
-    parallel::exchange(send_face_number_of_node_by_proc, recv_face_number_of_node_by_proc);
 
     std::vector<Array<int>> face_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_face_vector;
-      for (size_t l=0; l<send_face_id_by_proc[i_rank].size(); ++l) {
-        const FaceId& face_id = send_face_id_by_proc[i_rank][l];
-        const auto& face_node_list = face_to_node_matrix[face_id];
-        for (size_t r=0; r<face_node_list.size(); ++r) {
-          const NodeId& node_id = face_node_list[r];
-          node_number_by_face_vector.push_back(node_number[node_id]);
+    {
+      const auto& face_to_node_matrix = mesh.connectivity().faceToNodeMatrix();
+      const NodeValue<const int>& node_number = mesh.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) {
+          const FaceId& face_id = send_face_id_by_proc[i_rank][l];
+          const auto& face_node_list = face_to_node_matrix[face_id];
+          for (size_t r=0; r<face_node_list.size(); ++r) {
+            const NodeId& node_id = face_node_list[r];
+            node_number_by_face_vector.push_back(node_number[node_id]);
+          }
         }
+        face_node_number_to_send_by_proc[i_rank] = convert_to_array(node_number_by_face_vector);
       }
-      face_node_number_to_send_by_proc[i_rank] = convert_to_array(node_number_by_face_vector);
     }
 
-    std::vector<Array<int>> recv_face_node_number_by_proc(parallel::size());
-    for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
-      recv_face_node_number_by_proc[i_rank]
-          = Array<int>(sum(recv_face_number_of_node_by_proc[i_rank]));
-    }
+    {
+      std::vector<Array<int>> recv_face_node_number_by_proc(parallel::size());
+      for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
+        recv_face_node_number_by_proc[i_rank]
+            = Array<int>(sum(recv_face_number_of_node_by_proc[i_rank]));
+      }
 
-    parallel::exchange(face_node_number_to_send_by_proc, recv_face_node_number_by_proc);
+      parallel::exchange(face_node_number_to_send_by_proc, recv_face_node_number_by_proc);
 
-    for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
-      int l=0;
-      for (size_t i=0; i<recv_face_number_by_proc[i_rank].size(); ++i) {
-        std::vector<unsigned int> node_vector;
-        for (int k=0; k<recv_face_number_of_node_by_proc[i_rank][i]; ++k) {
-          const auto& searched_node_id = node_number_id_map.find(recv_face_node_number_by_proc[i_rank][l++]);
-          Assert(searched_node_id != node_number_id_map.end());
-          node_vector.push_back(searched_node_id->second);
+      for (size_t i_rank=0; i_rank < parallel::size(); ++i_rank) {
+        int l=0;
+        for (size_t i=0; i<recv_face_number_by_proc[i_rank].size(); ++i) {
+          std::vector<unsigned int> node_vector;
+          for (int k=0; k<recv_face_number_of_node_by_proc[i_rank][i]; ++k) {
+            const auto& searched_node_id = node_number_id_map.find(recv_face_node_number_by_proc[i_rank][l++]);
+            Assert(searched_node_id != node_number_id_map.end());
+            node_vector.push_back(searched_node_id->second);
+          }
+          m_new_descriptor.face_to_node_vector.emplace_back(node_vector);
         }
-        new_descriptor.face_to_node_vector.emplace_back(node_vector);
       }
     }
 
@@ -695,9 +725,9 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
           }
           parallel::exchange(send_face_refs_by_proc, recv_face_refs_by_proc);
 
-          std::vector<block_type> face_refs(new_descriptor.face_number_vector.size());
+          std::vector<block_type> face_refs(m_new_descriptor.face_number_vector.size());
           for (size_t i_rank=0; i_rank<parallel::size(); ++i_rank) {
-            for (size_t r=0; r<recv_face_owner_by_proc[i_rank].size(); ++r) {
+            for (size_t r=0; r<recv_face_refs_by_proc[i_rank].size(); ++r) {
               const FaceId& face_id = recv_face_id_correspondance_by_proc[i_rank][r];
               face_refs[face_id] = recv_face_refs_by_proc[i_rank][r];
             }
@@ -718,7 +748,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
 
             Array<const FaceId> face_id_array = convert_to_array(face_id_vector);
 
-            new_descriptor.addRefFaceList(RefFaceList(ref_id_list[i_ref], face_id_array));
+            m_new_descriptor.addRefFaceList(RefFaceList(ref_id_list[i_ref], face_id_array));
           }
 
           pout() << __FILE__ << ':' << __LINE__ << ": remains to build lists\n";
@@ -730,7 +760,7 @@ MeshDispatcher<Dimension>::MeshDispatcher(const MeshType& mesh)
 
   using ConnectivityType = Connectivity<Dimension>;
   std::shared_ptr p_connectivity
-      = ConnectivityType::build(new_descriptor);
+      = ConnectivityType::build(m_new_descriptor);
 
   using Rd = TinyVector<Dimension, double>;
 
diff --git a/src/mesh/MeshDispatcher.hpp b/src/mesh/MeshDispatcher.hpp
index c4d27f086..f6a209e92 100644
--- a/src/mesh/MeshDispatcher.hpp
+++ b/src/mesh/MeshDispatcher.hpp
@@ -14,6 +14,8 @@ class MeshDispatcher
  private:
   const MeshType& m_mesh;
 
+  ConnectivityDescriptor m_new_descriptor;
+
   std::shared_ptr<MeshType> m_dispatched_mesh;
 
   CellValue<const int> m_cell_new_owner;
-- 
GitLab