diff --git a/src/mesh/Connectivity.cpp b/src/mesh/Connectivity.cpp
index 22e722a11f0a53aabbde7a243386f854fcd41a59..9dd3bf5463b094ba556895ba1fd84c2f20d74bd8 100644
--- a/src/mesh/Connectivity.cpp
+++ b/src/mesh/Connectivity.cpp
@@ -47,10 +47,9 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
     m_cell_type = cell_type;
   }
 
-  m_cell_number = WeakCellValue<int>(*this, convert_to_array(descriptor.cell_number_vector));
+  m_cell_number = WeakCellValue<int>(*this, descriptor.cell_number_vector);
 
-  Array node_number_array = convert_to_array(descriptor.node_number_vector);
-  m_node_number           = WeakNodeValue<int>(*this, node_number_array);
+  m_node_number = WeakNodeValue<int>(*this, descriptor.node_number_vector);
 
   {
     WeakCellValue<int> cell_global_index(*this);
@@ -60,7 +59,7 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
     m_cell_global_index = cell_global_index;
   }
 
-  m_cell_owner = WeakCellValue<int>(*this, convert_to_array(descriptor.cell_owner_vector));
+  m_cell_owner = WeakCellValue<int>(*this, descriptor.cell_owner_vector);
 
   {
     const int rank = parallel::rank();
@@ -70,8 +69,7 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
     m_cell_is_owned = cell_is_owned;
   }
 
-  Array node_owner_array = convert_to_array(descriptor.node_owner_vector);
-  m_node_owner           = WeakNodeValue<int>{*this, node_owner_array};
+  m_node_owner = WeakNodeValue<int>{*this, descriptor.node_owner_vector};
 
   Array<bool> node_is_owned_array(this->numberOfNodes());
   {
@@ -87,13 +85,13 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
 
   if constexpr (Dimension == 1) {
     // faces are similar to nodes
-    m_face_number   = WeakFaceValue<int>(*this, node_number_array);
-    m_face_owner    = WeakFaceValue<int>(*this, node_owner_array);
+    m_face_number   = WeakFaceValue<int>(*this, descriptor.node_number_vector);
+    m_face_owner    = WeakFaceValue<int>(*this, descriptor.node_owner_vector);
     m_face_is_owned = WeakFaceValue<bool>(*this, node_is_owned_array);
 
     // edges are similar to nodes
-    m_edge_number   = WeakEdgeValue<int>(*this, node_number_array);
-    m_edge_owner    = WeakEdgeValue<int>(*this, node_owner_array);
+    m_edge_number   = WeakEdgeValue<int>(*this, descriptor.node_number_vector);
+    m_edge_owner    = WeakEdgeValue<int>(*this, descriptor.node_owner_vector);
     m_edge_is_owned = WeakEdgeValue<bool>(*this, node_is_owned_array);
 
     // edge and face references are set equal to node references
@@ -129,11 +127,9 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
       m_cell_face_is_reversed = cell_face_is_reversed;
     }
 
-    Array face_number_array = convert_to_array(descriptor.face_number_vector);
-    m_face_number           = WeakFaceValue<int>(*this, face_number_array);
+    m_face_number = WeakFaceValue<int>(*this, descriptor.face_number_vector);
 
-    Array face_owner_array = convert_to_array(descriptor.face_owner_vector);
-    m_face_owner           = WeakFaceValue<int>(*this, face_owner_array);
+    m_face_owner = WeakFaceValue<int>(*this, descriptor.face_owner_vector);
 
     Array<bool> face_is_owned_array(this->numberOfFaces());
     {
@@ -148,8 +144,8 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
 
     if constexpr (Dimension == 2) {
       // edges are similar to faces
-      m_edge_number   = WeakEdgeValue<int>(*this, face_number_array);
-      m_edge_owner    = WeakEdgeValue<int>(*this, face_owner_array);
+      m_edge_number   = WeakEdgeValue<int>(*this, descriptor.face_number_vector);
+      m_edge_owner    = WeakEdgeValue<int>(*this, descriptor.face_owner_vector);
       m_edge_is_owned = WeakEdgeValue<bool>(*this, face_is_owned_array);
 
       // edge references are set equal to face references
@@ -183,8 +179,8 @@ Connectivity<Dimension>::_buildFrom(const ConnectivityDescriptor& descriptor)
         m_face_edge_is_reversed = face_edge_is_reversed;
       }
 
-      m_edge_number = WeakEdgeValue<int>(*this, convert_to_array(descriptor.edge_number_vector));
-      m_edge_owner  = WeakEdgeValue<int>(*this, convert_to_array(descriptor.edge_owner_vector));
+      m_edge_number = WeakEdgeValue<int>(*this, descriptor.edge_number_vector);
+      m_edge_owner  = WeakEdgeValue<int>(*this, descriptor.edge_owner_vector);
 
       {
         const int rank = parallel::rank();
diff --git a/src/mesh/ConnectivityBuilderBase.cpp b/src/mesh/ConnectivityBuilderBase.cpp
index 9a02e30931998e629b1f6b480ff28191d6453405..1657507ec030a95b6ba5238d091c4426e1764f9f 100644
--- a/src/mesh/ConnectivityBuilderBase.cpp
+++ b/src/mesh/ConnectivityBuilderBase.cpp
@@ -513,10 +513,13 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
 
   {
     // Face numbers may change if numbers are provided in the file
-    descriptor.face_number_vector.resize(total_number_of_faces - nb_dup_faces);
-    for (size_t l = 0; l < descriptor.face_number_vector.size(); ++l) {
-      descriptor.face_number_vector[l] = l;
-    }
+    descriptor.face_number_vector = [&] {
+      Array<int> face_number_vector(total_number_of_faces - nb_dup_faces);
+      for (size_t l = 0; l < face_number_vector.size(); ++l) {
+        face_number_vector[l] = l;
+      }
+      return face_number_vector;
+    }();
   }
 
   {
@@ -687,10 +690,13 @@ ConnectivityBuilderBase::_computeFaceEdgeAndEdgeNodeAndCellEdgeConnectivities(Co
 
   {
     // Edge numbers may change if numbers are provided in the file
-    descriptor.edge_number_vector.resize(total_number_of_edges - nb_duplicate_edges);
-    for (size_t i_edge = 0; i_edge < descriptor.edge_number_vector.size(); ++i_edge) {
-      descriptor.edge_number_vector[i_edge] = i_edge;
-    }
+    descriptor.edge_number_vector = [&] {
+      Array<int> edge_number_vector(total_number_of_edges - nb_duplicate_edges);
+      for (size_t i_edge = 0; i_edge < edge_number_vector.size(); ++i_edge) {
+        edge_number_vector[i_edge] = i_edge;
+      }
+      return edge_number_vector;
+    }();
   }
 
   descriptor.edge_to_node_vector.resize(total_number_of_edges - nb_duplicate_edges);
diff --git a/src/mesh/ConnectivityBuilderBase.hpp b/src/mesh/ConnectivityBuilderBase.hpp
index f9b0d28a7a9389093348648573c85875f1e4a7de..9ae5df81d4792f978747877fb9c904faa1f6de07 100644
--- a/src/mesh/ConnectivityBuilderBase.hpp
+++ b/src/mesh/ConnectivityBuilderBase.hpp
@@ -56,7 +56,7 @@ class ConnectivityBuilderBase::ConnectivityFace<2>
   };
 
  private:
-  const std::vector<int>& m_node_number_vector;
+  const Array<int>& m_node_number_vector;
 
   unsigned int m_node0_id;
   unsigned int m_node1_id;
@@ -93,7 +93,7 @@ class ConnectivityBuilderBase::ConnectivityFace<2>
   }
 
   PUGS_INLINE
-  ConnectivityFace(const std::vector<unsigned int>& node_id_list, const std::vector<int>& node_number_vector)
+  ConnectivityFace(const std::vector<unsigned int>& node_id_list, const Array<int>& node_number_vector)
     : m_node_number_vector(node_number_vector)
   {
     Assert(node_id_list.size() == 2);
@@ -138,7 +138,7 @@ class ConnectivityBuilderBase::ConnectivityFace<3>
  private:
   bool m_reversed;
   std::vector<NodeId::base_type> m_node_id_list;
-  const std::vector<int>& m_node_number_vector;
+  const Array<int>& m_node_number_vector;
 
   PUGS_INLINE
   std::vector<unsigned int>
@@ -178,7 +178,7 @@ class ConnectivityBuilderBase::ConnectivityFace<3>
   }
 
   PUGS_INLINE
-  ConnectivityFace(const std::vector<unsigned int>& given_node_id_list, const std::vector<int>& node_number_vector)
+  ConnectivityFace(const std::vector<unsigned int>& given_node_id_list, const Array<int>& node_number_vector)
     : m_reversed(false), m_node_id_list(_sort(given_node_id_list)), m_node_number_vector(node_number_vector)
   {
     ;
diff --git a/src/mesh/ConnectivityDescriptor.hpp b/src/mesh/ConnectivityDescriptor.hpp
index 0c7f60b38b9b83e95a244fb5c7d4c4b1d13bfeaf..6e8733895aa6c942af199a96f65780d5533e87ca 100644
--- a/src/mesh/ConnectivityDescriptor.hpp
+++ b/src/mesh/ConnectivityDescriptor.hpp
@@ -50,15 +50,15 @@ class ConnectivityDescriptor
   std::vector<std::vector<bool>> cell_face_is_reversed_vector;
   std::vector<std::vector<bool>> face_edge_is_reversed_vector;
 
-  std::vector<CellType> cell_type_vector;
+  Array<CellType> cell_type_vector;
 
-  std::vector<int> cell_number_vector;
-  std::vector<int> face_number_vector;
-  std::vector<int> edge_number_vector;
-  std::vector<int> node_number_vector;
+  Array<int> cell_number_vector;
+  Array<int> face_number_vector;
+  Array<int> edge_number_vector;
+  Array<int> node_number_vector;
 
   template <ItemType item_type>
-  const std::vector<int>&
+  Array<const int>
   itemNumberVector() const
   {
     if constexpr (item_type == ItemType::cell) {
@@ -74,10 +74,10 @@ class ConnectivityDescriptor
     }
   }
 
-  std::vector<int> cell_owner_vector;
-  std::vector<int> face_owner_vector;
-  std::vector<int> edge_owner_vector;
-  std::vector<int> node_owner_vector;
+  Array<int> cell_owner_vector;
+  Array<int> face_owner_vector;
+  Array<int> edge_owner_vector;
+  Array<int> node_owner_vector;
 
   template <ItemType item_type>
   const std::vector<RefItemList<item_type>>&
diff --git a/src/mesh/ConnectivityDispatcher.cpp b/src/mesh/ConnectivityDispatcher.cpp
index 2cd8965f2929a8453d4f53b5d692c981fcf44906..94ece0650d26333e10037d19368bb84d4850abc0 100644
--- a/src/mesh/ConnectivityDispatcher.cpp
+++ b/src/mesh/ConnectivityDispatcher.cpp
@@ -145,14 +145,14 @@ template <int Dimension>
 template <typename DataType, ItemType item_type, typename ConnectivityPtr>
 void
 ConnectivityDispatcher<Dimension>::_gatherFrom(const ItemValue<DataType, item_type, ConnectivityPtr>& data_to_gather,
-                                               std::vector<std::remove_const_t<DataType>>& gathered_vector)
+                                               Array<std::remove_const_t<DataType>>& gathered_vector)
 {
   std::vector<Array<const DataType>> recv_item_data_by_proc = this->exchange(data_to_gather);
 
   const auto& recv_id_correspondance_by_proc = this->_dispatchedInfo<item_type>().m_recv_id_correspondance_by_proc;
   Assert(recv_id_correspondance_by_proc.size() == parallel::size());
 
-  gathered_vector.resize(this->_dispatchedInfo<item_type>().m_number_to_id_map.size());
+  gathered_vector = Array<std::remove_const_t<DataType>>(this->_dispatchedInfo<item_type>().m_number_to_id_map.size());
   for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
     Assert(recv_id_correspondance_by_proc[i_rank].size() == recv_item_data_by_proc[i_rank].size());
     for (size_t r = 0; r < recv_id_correspondance_by_proc[i_rank].size(); ++r) {
diff --git a/src/mesh/ConnectivityDispatcher.hpp b/src/mesh/ConnectivityDispatcher.hpp
index ef1f385bcd4676a0c1afe1c9a6a53989830712bf..58b9e8b5100308453b9508646a164ed1b369fe43 100644
--- a/src/mesh/ConnectivityDispatcher.hpp
+++ b/src/mesh/ConnectivityDispatcher.hpp
@@ -180,7 +180,7 @@ class ConnectivityDispatcher
 
   template <typename DataType, ItemType item_type, typename ConnectivityPtr>
   void _gatherFrom(const ItemValue<DataType, item_type, ConnectivityPtr>& data_to_gather,
-                   std::vector<std::remove_const_t<DataType>>& gathered_vector);
+                   Array<std::remove_const_t<DataType>>& gathered_vector);
 
   template <typename DataType, typename ItemOfItem, typename ConnectivityPtr>
   void _gatherFrom(const SubItemValuePerItem<DataType, ItemOfItem, ConnectivityPtr>& data_to_gather,
diff --git a/src/mesh/DiamondDualConnectivityBuilder.cpp b/src/mesh/DiamondDualConnectivityBuilder.cpp
index 71e316461d94a0891b721a0fff85e85c145ef26f..80fbc2661694bb2ed10f06726867f935951941c3 100644
--- a/src/mesh/DiamondDualConnectivityBuilder.cpp
+++ b/src/mesh/DiamondDualConnectivityBuilder.cpp
@@ -44,7 +44,7 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityDescriptor(const Connec
     }
   }
 
-  diamond_descriptor.node_number_vector.resize(diamond_number_of_nodes);
+  diamond_descriptor.node_number_vector = Array<int>(diamond_number_of_nodes);
 
   parallel_for(m_primal_node_to_dual_node_map.size(), [&](size_t i) {
     const auto [primal_node_id, diamond_dual_node_id] = m_primal_node_to_dual_node_map[i];
@@ -68,14 +68,14 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityDescriptor(const Connec
     }
   }
 
-  diamond_descriptor.cell_number_vector.resize(diamond_number_of_cells);
-  const auto& primal_face_number = primal_connectivity.faceNumber();
+  diamond_descriptor.cell_number_vector = Array<int>(diamond_number_of_cells);
+  const auto& primal_face_number        = primal_connectivity.faceNumber();
   parallel_for(diamond_number_of_cells, [&](size_t i) {
     const auto [primal_face_id, dual_cell_id]           = m_primal_face_to_dual_cell_map[i];
     diamond_descriptor.cell_number_vector[dual_cell_id] = primal_face_number[primal_face_id];
   });
 
-  diamond_descriptor.cell_type_vector.resize(diamond_number_of_cells);
+  diamond_descriptor.cell_type_vector = Array<CellType>(diamond_number_of_cells);
 
   const auto& primal_face_to_cell_matrix = primal_connectivity.faceToCellMatrix();
   const auto& primal_face_to_node_matrix = primal_connectivity.faceToNodeMatrix();
@@ -305,11 +305,15 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
     }();
 
     {
-      const size_t number_of_edges = diamond_descriptor.edge_to_node_vector.size();
-      diamond_descriptor.edge_number_vector.resize(number_of_edges);
-      for (size_t i_edge = 0; i_edge < number_of_edges; ++i_edge) {
-        diamond_descriptor.edge_number_vector[i_edge] = i_edge;
-      }
+      const size_t number_of_edges          = diamond_descriptor.edge_to_node_vector.size();
+      diamond_descriptor.edge_number_vector = [&] {
+        Array<int> edge_number_vector(number_of_edges);
+        for (size_t i_edge = 0; i_edge < number_of_edges; ++i_edge) {
+          edge_number_vector[i_edge] = i_edge;
+        }
+        return edge_number_vector;
+      }();
+
       // LCOV_EXCL_START
       if (parallel::size() > 1) {
         throw NotImplementedError("parallel edge numbering is undefined");
@@ -359,8 +363,7 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
   const size_t primal_number_of_nodes = primal_connectivity.numberOfNodes();
   const size_t primal_number_of_cells = primal_connectivity.numberOfCells();
 
-  diamond_descriptor.node_owner_vector.resize(diamond_descriptor.node_number_vector.size());
-
+  diamond_descriptor.node_owner_vector = Array<int>(diamond_descriptor.node_number_vector.size());
   {
     const auto& primal_node_owner = primal_connectivity.nodeOwner();
     for (NodeId primal_node_id = 0; primal_node_id < primal_connectivity.numberOfNodes(); ++primal_node_id) {
@@ -373,48 +376,40 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
   }
 
   {
-    diamond_descriptor.cell_owner_vector.resize(diamond_descriptor.cell_number_vector.size());
-    const size_t primal_number_of_faces = primal_connectivity.numberOfFaces();
-    const auto& primal_face_owner       = primal_connectivity.faceOwner();
+    diamond_descriptor.cell_owner_vector = Array<int>(diamond_descriptor.cell_number_vector.size());
+    const size_t primal_number_of_faces  = primal_connectivity.numberOfFaces();
+    const auto& primal_face_owner        = primal_connectivity.faceOwner();
     for (FaceId primal_face_id = 0; primal_face_id < primal_number_of_faces; ++primal_face_id) {
       diamond_descriptor.cell_owner_vector[primal_face_id] = primal_face_owner[primal_face_id];
     }
   }
 
   {
-    std::vector<int> face_cell_owner(diamond_descriptor.face_number_vector.size());
-    std::fill(std::begin(face_cell_owner), std::end(face_cell_owner), parallel::size());
+    diamond_descriptor.face_owner_vector = Array<int>(diamond_descriptor.face_number_vector.size());
+    diamond_descriptor.face_owner_vector.fill(parallel::size());
 
     for (size_t i_cell = 0; i_cell < diamond_descriptor.cell_to_face_vector.size(); ++i_cell) {
       const auto& cell_face_list = diamond_descriptor.cell_to_face_vector[i_cell];
       for (size_t i_face = 0; i_face < cell_face_list.size(); ++i_face) {
-        const size_t face_id     = cell_face_list[i_face];
-        face_cell_owner[face_id] = std::min(face_cell_owner[face_id], diamond_descriptor.cell_number_vector[i_cell]);
+        const size_t face_id = cell_face_list[i_face];
+        diamond_descriptor.face_owner_vector[face_id] =
+          std::min(diamond_descriptor.face_owner_vector[face_id], diamond_descriptor.cell_owner_vector[i_cell]);
       }
     }
-
-    diamond_descriptor.face_owner_vector.resize(face_cell_owner.size());
-    for (size_t i_face = 0; i_face < face_cell_owner.size(); ++i_face) {
-      diamond_descriptor.face_owner_vector[i_face] = diamond_descriptor.cell_owner_vector[face_cell_owner[i_face]];
-    }
   }
 
   if constexpr (Dimension == 3) {
-    std::vector<int> edge_cell_owner(diamond_descriptor.edge_number_vector.size());
-    std::fill(std::begin(edge_cell_owner), std::end(edge_cell_owner), parallel::size());
+    diamond_descriptor.edge_owner_vector = Array<int>(diamond_descriptor.edge_number_vector.size());
+    diamond_descriptor.edge_owner_vector.fill(parallel::size());
 
     for (size_t i_cell = 0; i_cell < diamond_descriptor.cell_to_face_vector.size(); ++i_cell) {
       const auto& cell_edge_list = diamond_descriptor.cell_to_edge_vector[i_cell];
       for (size_t i_edge = 0; i_edge < cell_edge_list.size(); ++i_edge) {
-        const size_t edge_id     = cell_edge_list[i_edge];
-        edge_cell_owner[edge_id] = std::min(edge_cell_owner[edge_id], diamond_descriptor.cell_number_vector[i_cell]);
+        const size_t edge_id = cell_edge_list[i_edge];
+        diamond_descriptor.edge_owner_vector[edge_id] =
+          std::min(diamond_descriptor.edge_owner_vector[edge_id], diamond_descriptor.cell_owner_vector[i_cell]);
       }
     }
-
-    diamond_descriptor.edge_owner_vector.resize(edge_cell_owner.size());
-    for (size_t i_edge = 0; i_edge < edge_cell_owner.size(); ++i_edge) {
-      diamond_descriptor.edge_owner_vector[i_edge] = diamond_descriptor.cell_owner_vector[edge_cell_owner[i_edge]];
-    }
   }
 
   m_connectivity = ConnectivityType::build(diamond_descriptor);
diff --git a/src/mesh/Dual1DConnectivityBuilder.cpp b/src/mesh/Dual1DConnectivityBuilder.cpp
index 30c465b8b07375fce9f82fb76a26ac24848f3c67..4a4137b4998c852b0176207d1179d65c24aacfcf 100644
--- a/src/mesh/Dual1DConnectivityBuilder.cpp
+++ b/src/mesh/Dual1DConnectivityBuilder.cpp
@@ -28,7 +28,7 @@ Dual1DConnectivityBuilder::_buildConnectivityDescriptor(const Connectivity<1>& p
   const auto& primal_node_to_cell_matrix = primal_connectivity.nodeToCellMatrix();
   size_t next_kept_node_id               = 0;
 
-  dual_descriptor.node_number_vector.resize(dual_number_of_nodes);
+  dual_descriptor.node_number_vector = Array<int>(dual_number_of_nodes);
 
   const auto& primal_node_number = primal_connectivity.nodeNumber();
 
@@ -52,12 +52,13 @@ Dual1DConnectivityBuilder::_buildConnectivityDescriptor(const Connectivity<1>& p
 
   Assert(number_of_kept_nodes == next_kept_node_id, "unexpected number of kept nodes");
 
-  dual_descriptor.cell_number_vector.resize(dual_number_of_cells);
+  dual_descriptor.cell_number_vector = Array<int>(dual_number_of_cells);
   for (NodeId primal_node_id = 0; primal_node_id < primal_number_of_nodes; ++primal_node_id) {
     dual_descriptor.cell_number_vector[primal_node_id] = primal_node_number[primal_node_id];
   }
 
-  dual_descriptor.cell_type_vector = std::vector<CellType>(dual_number_of_cells, CellType::Line);
+  dual_descriptor.cell_type_vector = Array<CellType>(dual_number_of_cells);
+  dual_descriptor.cell_type_vector.fill(CellType::Line);
 
   dual_descriptor.cell_to_node_vector.resize(dual_number_of_cells);
 
@@ -138,7 +139,7 @@ Dual1DConnectivityBuilder::_buildConnectivityFrom(const IConnectivity& i_primal_
   const size_t primal_number_of_nodes = primal_connectivity.numberOfNodes();
   const size_t primal_number_of_cells = primal_connectivity.numberOfCells();
 
-  dual_descriptor.node_owner_vector.resize(dual_descriptor.node_number_vector.size());
+  dual_descriptor.node_owner_vector = Array<int>(dual_descriptor.node_number_vector.size());
 
   {
     const auto& node_to_cell_matrix = primal_connectivity.nodeToCellMatrix();
@@ -157,8 +158,8 @@ Dual1DConnectivityBuilder::_buildConnectivityFrom(const IConnectivity& i_primal_
   }
 
   {
-    dual_descriptor.cell_owner_vector.resize(dual_descriptor.cell_number_vector.size());
-    const auto& primal_node_owner = primal_connectivity.nodeOwner();
+    dual_descriptor.cell_owner_vector = Array<int>(dual_descriptor.cell_number_vector.size());
+    const auto& primal_node_owner     = primal_connectivity.nodeOwner();
     for (NodeId primal_node_id = 0; primal_node_id < primal_number_of_nodes; ++primal_node_id) {
       dual_descriptor.cell_owner_vector[primal_node_id] = primal_node_owner[primal_node_id];
     }
diff --git a/src/mesh/GmshReader.cpp b/src/mesh/GmshReader.cpp
index c033433f807b2313c2dab4132f9ecc287ad413fc..f2030623a72e2262ce5dbb391caac0c304f846da 100644
--- a/src/mesh/GmshReader.cpp
+++ b/src/mesh/GmshReader.cpp
@@ -35,9 +35,9 @@ GmshConnectivityBuilder<1>::GmshConnectivityBuilder(const GmshReader::GmshData&
 {
   ConnectivityDescriptor descriptor;
 
-  descriptor.node_number_vector = gmsh_data.__verticesNumbers;
-  descriptor.cell_type_vector.resize(nb_cells);
-  descriptor.cell_number_vector.resize(nb_cells);
+  descriptor.node_number_vector = convert_to_array(gmsh_data.__verticesNumbers);
+  descriptor.cell_type_vector   = Array<CellType>(nb_cells);
+  descriptor.cell_number_vector = Array<int>(nb_cells);
   descriptor.cell_to_node_vector.resize(nb_cells);
 
   for (size_t j = 0; j < nb_cells; ++j) {
@@ -116,11 +116,11 @@ GmshConnectivityBuilder<1>::GmshConnectivityBuilder(const GmshReader::GmshData&
     descriptor.addRefItemList(RefCellList(ref_id, cell_list, false));
   }
 
-  descriptor.cell_owner_vector.resize(nb_cells);
-  std::fill(descriptor.cell_owner_vector.begin(), descriptor.cell_owner_vector.end(), parallel::rank());
+  descriptor.cell_owner_vector = Array<int>(nb_cells);
+  descriptor.cell_owner_vector.fill(parallel::rank());
 
-  descriptor.node_owner_vector.resize(descriptor.node_number_vector.size());
-  std::fill(descriptor.node_owner_vector.begin(), descriptor.node_owner_vector.end(), parallel::rank());
+  descriptor.node_owner_vector = Array<int>(descriptor.node_number_vector.size());
+  descriptor.node_owner_vector.fill(parallel::rank());
 
   m_connectivity = Connectivity1D::build(descriptor);
 }
@@ -130,9 +130,9 @@ GmshConnectivityBuilder<2>::GmshConnectivityBuilder(const GmshReader::GmshData&
 {
   ConnectivityDescriptor descriptor;
 
-  descriptor.node_number_vector = gmsh_data.__verticesNumbers;
-  descriptor.cell_type_vector.resize(nb_cells);
-  descriptor.cell_number_vector.resize(nb_cells);
+  descriptor.node_number_vector = convert_to_array(gmsh_data.__verticesNumbers);
+  descriptor.cell_type_vector   = Array<CellType>(nb_cells);
+  descriptor.cell_number_vector = Array<int>(nb_cells);
   descriptor.cell_to_node_vector.resize(nb_cells);
 
   const size_t nb_triangles = gmsh_data.__triangles.size();
@@ -319,14 +319,14 @@ GmshConnectivityBuilder<2>::GmshConnectivityBuilder(const GmshReader::GmshData&
     descriptor.addRefItemList(RefNodeList(ref_id, point_list, is_boundary));
   }
 
-  descriptor.cell_owner_vector.resize(nb_cells);
-  std::fill(descriptor.cell_owner_vector.begin(), descriptor.cell_owner_vector.end(), parallel::rank());
+  descriptor.cell_owner_vector = Array<int>(nb_cells);
+  descriptor.cell_owner_vector.fill(parallel::rank());
 
-  descriptor.face_owner_vector.resize(descriptor.face_number_vector.size());
-  std::fill(descriptor.face_owner_vector.begin(), descriptor.face_owner_vector.end(), parallel::rank());
+  descriptor.face_owner_vector = Array<int>(descriptor.face_number_vector.size());
+  descriptor.face_owner_vector.fill(parallel::rank());
 
-  descriptor.node_owner_vector.resize(descriptor.node_number_vector.size());
-  std::fill(descriptor.node_owner_vector.begin(), descriptor.node_owner_vector.end(), parallel::rank());
+  descriptor.node_owner_vector = Array<int>(descriptor.node_number_vector.size());
+  descriptor.node_owner_vector.fill(parallel::rank());
 
   m_connectivity = Connectivity2D::build(descriptor);
 }
@@ -336,9 +336,9 @@ GmshConnectivityBuilder<3>::GmshConnectivityBuilder(const GmshReader::GmshData&
 {
   ConnectivityDescriptor descriptor;
 
-  descriptor.node_number_vector = gmsh_data.__verticesNumbers;
-  descriptor.cell_type_vector.resize(nb_cells);
-  descriptor.cell_number_vector.resize(nb_cells);
+  descriptor.node_number_vector = convert_to_array(gmsh_data.__verticesNumbers);
+  descriptor.cell_type_vector   = Array<CellType>(nb_cells);
+  descriptor.cell_number_vector = Array<int>(nb_cells);
   descriptor.cell_to_node_vector.resize(nb_cells);
 
   const size_t nb_tetrahedra = gmsh_data.__tetrahedra.size();
@@ -688,17 +688,17 @@ GmshConnectivityBuilder<3>::GmshConnectivityBuilder(const GmshReader::GmshData&
     descriptor.addRefItemList(RefNodeList(ref_id, point_list, is_boundary));
   }
 
-  descriptor.cell_owner_vector.resize(nb_cells);
-  std::fill(descriptor.cell_owner_vector.begin(), descriptor.cell_owner_vector.end(), parallel::rank());
+  descriptor.cell_owner_vector = Array<int>(nb_cells);
+  descriptor.cell_owner_vector.fill(parallel::rank());
 
-  descriptor.face_owner_vector.resize(descriptor.face_number_vector.size());
-  std::fill(descriptor.face_owner_vector.begin(), descriptor.face_owner_vector.end(), parallel::rank());
+  descriptor.face_owner_vector = Array<int>(descriptor.face_number_vector.size());
+  descriptor.face_owner_vector.fill(parallel::rank());
 
-  descriptor.edge_owner_vector.resize(descriptor.edge_number_vector.size());
-  std::fill(descriptor.edge_owner_vector.begin(), descriptor.edge_owner_vector.end(), parallel::rank());
+  descriptor.edge_owner_vector = Array<int>(descriptor.edge_number_vector.size());
+  descriptor.edge_owner_vector.fill(parallel::rank());
 
-  descriptor.node_owner_vector.resize(descriptor.node_number_vector.size());
-  std::fill(descriptor.node_owner_vector.begin(), descriptor.node_owner_vector.end(), parallel::rank());
+  descriptor.node_owner_vector = Array<int>(descriptor.node_number_vector.size());
+  descriptor.node_owner_vector.fill(parallel::rank());
 
   m_connectivity = Connectivity3D::build(descriptor);
 }
diff --git a/src/mesh/LogicalConnectivityBuilder.cpp b/src/mesh/LogicalConnectivityBuilder.cpp
index 5314f956c27de580ee227f8f8519648d4b105629..319e29f6da89f429b3e0ecc657d929497a0f7832 100644
--- a/src/mesh/LogicalConnectivityBuilder.cpp
+++ b/src/mesh/LogicalConnectivityBuilder.cpp
@@ -433,18 +433,24 @@ LogicalConnectivityBuilder::_buildConnectivity(
   const size_t number_of_nodes = cell_size[0] + 1;
 
   ConnectivityDescriptor descriptor;
-  descriptor.node_number_vector.resize(number_of_nodes);
-  for (size_t i = 0; i < number_of_nodes; ++i) {
-    descriptor.node_number_vector[i] = i;
-  }
+  descriptor.node_number_vector = [&] {
+    Array<int> node_number_vector(number_of_nodes);
+    for (size_t i = 0; i < number_of_nodes; ++i) {
+      node_number_vector[i] = i;
+    }
+    return node_number_vector;
+  }();
 
-  descriptor.cell_number_vector.resize(number_of_cells);
-  for (size_t i = 0; i < number_of_cells; ++i) {
-    descriptor.cell_number_vector[i] = i;
-  }
+  descriptor.cell_number_vector = [&] {
+    Array<int> cell_number_vector(number_of_cells);
+    for (size_t i = 0; i < number_of_cells; ++i) {
+      cell_number_vector[i] = i;
+    }
+    return cell_number_vector;
+  }();
 
-  descriptor.cell_type_vector.resize(number_of_cells);
-  std::fill(descriptor.cell_type_vector.begin(), descriptor.cell_type_vector.end(), CellType::Line);
+  descriptor.cell_type_vector = Array<CellType>(number_of_cells);
+  descriptor.cell_type_vector.fill(CellType::Line);
 
   descriptor.cell_to_node_vector.resize(number_of_cells);
   constexpr size_t nb_node_per_cell = 2;
@@ -458,11 +464,11 @@ LogicalConnectivityBuilder::_buildConnectivity(
 
   this->_buildBoundaryNodeList(cell_size, descriptor);
 
-  descriptor.cell_owner_vector.resize(number_of_cells);
-  std::fill(descriptor.cell_owner_vector.begin(), descriptor.cell_owner_vector.end(), parallel::rank());
+  descriptor.cell_owner_vector = Array<int>(number_of_cells);
+  descriptor.cell_owner_vector.fill(parallel::rank());
 
-  descriptor.node_owner_vector.resize(descriptor.node_number_vector.size());
-  std::fill(descriptor.node_owner_vector.begin(), descriptor.node_owner_vector.end(), parallel::rank());
+  descriptor.node_owner_vector = Array<int>(descriptor.node_number_vector.size());
+  descriptor.node_owner_vector.fill(parallel::rank());
 
   m_connectivity = Connectivity1D::build(descriptor);
 }
@@ -480,18 +486,24 @@ LogicalConnectivityBuilder::_buildConnectivity(
   const size_t number_of_nodes = node_size[0] * node_size[1];
 
   ConnectivityDescriptor descriptor;
-  descriptor.node_number_vector.resize(number_of_nodes);
-  for (size_t i = 0; i < number_of_nodes; ++i) {
-    descriptor.node_number_vector[i] = i;
-  }
+  descriptor.node_number_vector = [&] {
+    Array<int> node_number_vector(number_of_nodes);
+    for (size_t i = 0; i < number_of_nodes; ++i) {
+      node_number_vector[i] = i;
+    }
+    return node_number_vector;
+  }();
 
-  descriptor.cell_number_vector.resize(number_of_cells);
-  for (size_t i = 0; i < number_of_cells; ++i) {
-    descriptor.cell_number_vector[i] = i;
-  }
+  descriptor.cell_number_vector = [&] {
+    Array<int> cell_number_vector(number_of_cells);
+    for (size_t i = 0; i < number_of_cells; ++i) {
+      cell_number_vector[i] = i;
+    }
+    return cell_number_vector;
+  }();
 
-  descriptor.cell_type_vector.resize(number_of_cells);
-  std::fill(descriptor.cell_type_vector.begin(), descriptor.cell_type_vector.end(), CellType::Quadrangle);
+  descriptor.cell_type_vector = Array<CellType>(number_of_cells);
+  descriptor.cell_type_vector.fill(CellType::Quadrangle);
 
   const auto node_number = [&](const TinyVector<Dimension, uint64_t> node_logic_id) {
     return node_logic_id[0] * node_size[1] + node_logic_id[1];
@@ -521,14 +533,14 @@ LogicalConnectivityBuilder::_buildConnectivity(
   this->_buildBoundaryNodeList(cell_size, descriptor);
   this->_buildBoundaryFaceList(cell_size, descriptor);
 
-  descriptor.cell_owner_vector.resize(number_of_cells);
-  std::fill(descriptor.cell_owner_vector.begin(), descriptor.cell_owner_vector.end(), parallel::rank());
+  descriptor.cell_owner_vector = Array<int>(number_of_cells);
+  descriptor.cell_owner_vector.fill(parallel::rank());
 
-  descriptor.face_owner_vector.resize(descriptor.face_number_vector.size());
-  std::fill(descriptor.face_owner_vector.begin(), descriptor.face_owner_vector.end(), parallel::rank());
+  descriptor.face_owner_vector = Array<int>(descriptor.face_number_vector.size());
+  descriptor.face_owner_vector.fill(parallel::rank());
 
-  descriptor.node_owner_vector.resize(descriptor.node_number_vector.size());
-  std::fill(descriptor.node_owner_vector.begin(), descriptor.node_owner_vector.end(), parallel::rank());
+  descriptor.node_owner_vector = Array<int>(descriptor.node_number_vector.size());
+  descriptor.node_owner_vector.fill(parallel::rank());
 
   m_connectivity = Connectivity<Dimension>::build(descriptor);
 }
@@ -565,18 +577,24 @@ LogicalConnectivityBuilder::_buildConnectivity(const TinyVector<3, uint64_t>& ce
   const size_t number_of_nodes = count_items(node_size);
 
   ConnectivityDescriptor descriptor;
-  descriptor.node_number_vector.resize(number_of_nodes);
-  for (size_t i = 0; i < number_of_nodes; ++i) {
-    descriptor.node_number_vector[i] = i;
-  }
+  descriptor.node_number_vector = [&] {
+    Array<int> node_number_vector(number_of_nodes);
+    for (size_t i = 0; i < number_of_nodes; ++i) {
+      node_number_vector[i] = i;
+    }
+    return node_number_vector;
+  }();
 
-  descriptor.cell_number_vector.resize(number_of_cells);
-  for (size_t i = 0; i < number_of_cells; ++i) {
-    descriptor.cell_number_vector[i] = i;
-  }
+  descriptor.cell_number_vector = [&] {
+    Array<int> cell_number_vector(number_of_cells);
+    for (size_t i = 0; i < number_of_cells; ++i) {
+      cell_number_vector[i] = i;
+    }
+    return cell_number_vector;
+  }();
 
-  descriptor.cell_type_vector.resize(number_of_cells);
-  std::fill(descriptor.cell_type_vector.begin(), descriptor.cell_type_vector.end(), CellType::Hexahedron);
+  descriptor.cell_type_vector = Array<CellType>(number_of_cells);
+  descriptor.cell_type_vector.fill(CellType::Hexahedron);
 
   const auto cell_logic_id = [&](size_t j) {
     const size_t slice1  = cell_size[1] * cell_size[2];
@@ -642,17 +660,17 @@ LogicalConnectivityBuilder::_buildConnectivity(const TinyVector<3, uint64_t>& ce
   t.stop();
 
   t.start();
-  descriptor.cell_owner_vector.resize(number_of_cells);
-  std::fill(descriptor.cell_owner_vector.begin(), descriptor.cell_owner_vector.end(), parallel::rank());
+  descriptor.cell_owner_vector = Array<int>(number_of_cells);
+  descriptor.cell_owner_vector.fill(parallel::rank());
 
-  descriptor.face_owner_vector.resize(descriptor.face_number_vector.size());
-  std::fill(descriptor.face_owner_vector.begin(), descriptor.face_owner_vector.end(), parallel::rank());
+  descriptor.face_owner_vector = Array<int>(descriptor.face_number_vector.size());
+  descriptor.face_owner_vector.fill(parallel::rank());
 
-  descriptor.edge_owner_vector.resize(descriptor.edge_number_vector.size());
-  std::fill(descriptor.edge_owner_vector.begin(), descriptor.edge_owner_vector.end(), parallel::rank());
+  descriptor.edge_owner_vector = Array<int>(descriptor.edge_number_vector.size());
+  descriptor.edge_owner_vector.fill(parallel::rank());
 
-  descriptor.node_owner_vector.resize(descriptor.node_number_vector.size());
-  std::fill(descriptor.node_owner_vector.begin(), descriptor.node_owner_vector.end(), parallel::rank());
+  descriptor.node_owner_vector = Array<int>(descriptor.node_number_vector.size());
+  descriptor.node_owner_vector.fill(parallel::rank());
   std::cout << " - final infos t = " << t << '\n';
   t.stop();
 
diff --git a/src/mesh/MedianDualConnectivityBuilder.cpp b/src/mesh/MedianDualConnectivityBuilder.cpp
index c6770d05ee1d93891d560bd1b1373fd2e68da5eb..9c8762b606c3e79b4d86f72139a775c5c197fbf7 100644
--- a/src/mesh/MedianDualConnectivityBuilder.cpp
+++ b/src/mesh/MedianDualConnectivityBuilder.cpp
@@ -92,7 +92,7 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit
     Assert(i_boundary_node == primal_number_of_boundary_nodes);
   }
 
-  dual_descriptor.node_number_vector.resize(dual_number_of_nodes);
+  dual_descriptor.node_number_vector = Array<int>(dual_number_of_nodes);
   {
     parallel_for(m_primal_cell_to_dual_node_map.size(), [&](size_t i) {
       const auto [primal_cell_id, dual_node_id]        = m_primal_cell_to_dual_node_map[i];
@@ -112,13 +112,13 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit
     });
   }
 
-  dual_descriptor.cell_number_vector.resize(dual_number_of_cells);
+  dual_descriptor.cell_number_vector = Array<int>(dual_number_of_cells);
   parallel_for(dual_number_of_cells, [&](size_t i) {
     const auto [primal_node_id, dual_cell_id]        = m_primal_node_to_dual_cell_map[i];
     dual_descriptor.cell_number_vector[dual_cell_id] = primal_node_number[primal_node_id];
   });
 
-  dual_descriptor.cell_type_vector.resize(dual_number_of_cells);
+  dual_descriptor.cell_type_vector = Array<CellType>(dual_number_of_cells);
 
   const auto& primal_node_to_cell_matrix = primal_connectivity.nodeToCellMatrix();
 
@@ -277,23 +277,24 @@ MedianDualConnectivityBuilder::_buildConnectivityFrom<2>(const IConnectivity& i_
       const auto& primal_node_list     = primal_ref_node_list.list();
 
       const std::vector<NodeId> dual_node_list = [&]() {
-        std::vector<NodeId> dual_node_list;
+        std::vector<NodeId> tmp_dual_node_list;
 
         for (size_t i_primal_node = 0; i_primal_node < primal_node_list.size(); ++i_primal_node) {
           auto primal_node_id = primal_node_list[i_primal_node];
           const auto i_dual_node =
             primal_boundary_node_id_to_dual_node_id_map.find(primal_connectivity.nodeNumber()[primal_node_id]);
           if (i_dual_node != primal_boundary_node_id_to_dual_node_id_map.end()) {
-            dual_node_list.push_back(i_dual_node->second);
+            tmp_dual_node_list.push_back(i_dual_node->second);
           }
         }
 
-        return dual_node_list;
+        return tmp_dual_node_list;
       }();
 
       if (parallel::allReduceOr(dual_node_list.size() > 0)) {
-        dual_descriptor.addRefItemList(RefNodeList{primal_ref_node_list.refId(), convert_to_array(dual_node_list),
-                                                   primal_ref_node_list.isBoundary()});
+        auto dual_node_array = convert_to_array(dual_node_list);
+        dual_descriptor.addRefItemList(
+          RefNodeList{primal_ref_node_list.refId(), dual_node_array, primal_ref_node_list.isBoundary()});
       }
     }
   }
@@ -352,41 +353,50 @@ MedianDualConnectivityBuilder::_buildConnectivityFrom<2>(const IConnectivity& i_
     }
   }
 
-  const size_t primal_number_of_nodes = primal_connectivity.numberOfNodes();
-  const size_t primal_number_of_cells = primal_connectivity.numberOfCells();
-
-  dual_descriptor.node_owner_vector.resize(dual_descriptor.node_number_vector.size());
+  dual_descriptor.node_owner_vector = Array<int>(dual_descriptor.node_number_vector.size());
 
   const auto& primal_node_owner = primal_connectivity.nodeOwner();
-  for (NodeId primal_node_id = 0; primal_node_id < primal_connectivity.numberOfNodes(); ++primal_node_id) {
-    dual_descriptor.node_owner_vector[primal_node_id] = primal_node_owner[primal_node_id];
+
+  dual_descriptor.node_owner_vector.fill(-1);
+  for (size_t i_primal_node_to_dual_node = 0;
+       i_primal_node_to_dual_node < m_primal_boundary_node_to_dual_node_map.size(); ++i_primal_node_to_dual_node) {
+    const auto& [primal_node_id, dual_node_id] = m_primal_boundary_node_to_dual_node_map[i_primal_node_to_dual_node];
+    dual_descriptor.node_owner_vector[dual_node_id] = primal_node_owner[primal_node_id];
+  }
+
+  const auto& primal_face_owner = primal_connectivity.faceOwner();
+  for (size_t i_primal_face_to_dual_node = 0; i_primal_face_to_dual_node < m_primal_face_to_dual_node_map.size();
+       ++i_primal_face_to_dual_node) {
+    const auto& [primal_face_id, dual_node_id]      = m_primal_face_to_dual_node_map[i_primal_face_to_dual_node];
+    dual_descriptor.node_owner_vector[dual_node_id] = primal_face_owner[primal_face_id];
   }
+
   const auto& primal_cell_owner = primal_connectivity.cellOwner();
-  for (CellId primal_cell_id = 0; primal_cell_id < primal_number_of_cells; ++primal_cell_id) {
-    dual_descriptor.node_owner_vector[primal_number_of_nodes + primal_cell_id] = primal_cell_owner[primal_cell_id];
+  for (size_t i_primal_cell_to_dual_node = 0; i_primal_cell_to_dual_node < m_primal_cell_to_dual_node_map.size();
+       ++i_primal_cell_to_dual_node) {
+    const auto& [primal_cell_id, dual_node_id]      = m_primal_cell_to_dual_node_map[i_primal_cell_to_dual_node];
+    dual_descriptor.node_owner_vector[dual_node_id] = primal_cell_owner[primal_cell_id];
   }
 
-  dual_descriptor.cell_owner_vector.resize(dual_descriptor.cell_number_vector.size());
-  for (NodeId primal_node_id = 0; primal_node_id < primal_number_of_nodes; ++primal_node_id) {
-    dual_descriptor.cell_owner_vector[primal_node_id] = primal_node_owner[primal_node_id];
+  dual_descriptor.cell_owner_vector = Array<int>(dual_descriptor.cell_number_vector.size());
+  dual_descriptor.cell_owner_vector.fill(-1);
+  for (size_t i_primal_cell_to_dual_node = 0; i_primal_cell_to_dual_node < m_primal_node_to_dual_cell_map.size();
+       ++i_primal_cell_to_dual_node) {
+    const auto& [primal_node_id, dual_cell_id]      = m_primal_node_to_dual_cell_map[i_primal_cell_to_dual_node];
+    dual_descriptor.cell_owner_vector[dual_cell_id] = primal_node_owner[primal_node_id];
   }
 
   {
-    std::vector<int> face_cell_owner(dual_descriptor.face_number_vector.size());
-    std::fill(std::begin(face_cell_owner), std::end(face_cell_owner), parallel::size());
-
+    dual_descriptor.face_owner_vector = Array<int>(dual_descriptor.face_number_vector.size());
+    dual_descriptor.face_owner_vector.fill(parallel::size());
     for (size_t i_cell = 0; i_cell < dual_descriptor.cell_to_face_vector.size(); ++i_cell) {
       const auto& cell_face_list = dual_descriptor.cell_to_face_vector[i_cell];
       for (size_t i_face = 0; i_face < cell_face_list.size(); ++i_face) {
-        const size_t face_id     = cell_face_list[i_face];
-        face_cell_owner[face_id] = std::min(face_cell_owner[face_id], dual_descriptor.cell_number_vector[i_cell]);
+        const size_t face_id = cell_face_list[i_face];
+        dual_descriptor.face_owner_vector[face_id] =
+          std::min(dual_descriptor.face_owner_vector[face_id], dual_descriptor.cell_owner_vector[i_cell]);
       }
     }
-
-    dual_descriptor.face_owner_vector.resize(face_cell_owner.size());
-    for (size_t i_face = 0; i_face < face_cell_owner.size(); ++i_face) {
-      dual_descriptor.face_owner_vector[i_face] = dual_descriptor.cell_owner_vector[face_cell_owner[i_face]];
-    }
   }
 
   m_connectivity = ConnectivityType::build(dual_descriptor);