diff --git a/src/mesh/Connectivity.cpp b/src/mesh/Connectivity.cpp
index e4e003d79531daf4420e9a18662157a017f01d89..7f6b97e5234bfe9d94c0e1f22973b9c58f88f6b4 100644
--- a/src/mesh/Connectivity.cpp
+++ b/src/mesh/Connectivity.cpp
@@ -4,7 +4,7 @@
 template<>
 void Connectivity<3>::_computeCellFaceAndFaceNodeConnectivities()
 {
-  using CellFaceInfo = std::tuple<unsigned int, unsigned short, bool>;
+  using CellFaceInfo = std::tuple<CellId, unsigned short, bool>;
 
   const auto& cell_to_node_matrix
       = this->getMatrix(ItemType::cell, ItemType::node);
@@ -98,11 +98,11 @@ void Connectivity<3>::_computeCellFaceAndFaceNodeConnectivities()
   {
     auto& cell_to_face_matrix
         = m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::face)];
-    std::vector<std::vector<unsigned int>> cell_to_face_vector(this->numberOfCells());
+    std::vector<std::vector<FaceId>> cell_to_face_vector(this->numberOfCells());
     for (CellId j=0; j<cell_to_face_vector.size(); ++j) {
       cell_to_face_vector[j].resize(cell_nb_faces[j]);
     }
-    int l=0;
+    FaceId l=0;
     for (const auto& face_cells_vector : face_cells_map) {
       const auto& cells_vector = face_cells_vector.second;
       for (unsigned short lj=0; lj<cells_vector.size(); ++lj) {
@@ -111,7 +111,7 @@ void Connectivity<3>::_computeCellFaceAndFaceNodeConnectivities()
       }
       ++l;
     }
-    cell_to_face_matrix = cell_to_face_vector;
+    cell_to_face_matrix = reinterpret_cast<std::vector<std::vector<unsigned int>>&>(cell_to_face_vector);
   }
 
   FaceValuePerCell<bool> cell_face_is_reversed(*this);
@@ -120,7 +120,7 @@ void Connectivity<3>::_computeCellFaceAndFaceNodeConnectivities()
       const auto& cells_vector = face_cells_vector.second;
       for (unsigned short lj=0; lj<cells_vector.size(); ++lj) {
         const auto& [cell_number, cell_local_face, reversed] = cells_vector[lj];
-        cell_face_is_reversed(CellId{cell_number}, cell_local_face) = reversed;
+        cell_face_is_reversed(cell_number, cell_local_face) = reversed;
       }
     }
 
@@ -131,14 +131,15 @@ void Connectivity<3>::_computeCellFaceAndFaceNodeConnectivities()
     auto& face_to_node_matrix
         = m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::node)];
 
-    std::vector<std::vector<unsigned int>> face_to_node_vector(face_cells_map.size());
+    std::vector<std::vector<NodeId>> face_to_node_vector(face_cells_map.size());
     int l=0;
     for (const auto& face_info : face_cells_map) {
       const Face& face = face_info.first;
       face_to_node_vector[l] = face.nodeIdList();
       ++l;
     }
-    face_to_node_matrix = face_to_node_vector;
+#warning remove all reinterpret_cast
+    face_to_node_matrix = reinterpret_cast<std::vector<std::vector<unsigned int>>&>(face_to_node_vector);
   }
 
   {
@@ -160,13 +161,13 @@ void Connectivity<2>::_computeCellFaceAndFaceNodeConnectivities()
       = this->getMatrix(ItemType::cell, ItemType::node);
 
   // In 2D faces are simply define
-  using CellFaceId = std::pair<unsigned int, unsigned short>;
+  using CellFaceId = std::pair<CellId, unsigned short>;
   std::map<Face, std::vector<CellFaceId>> face_cells_map;
-  for (unsigned int j=0; j<this->numberOfCells(); ++j) {
+  for (CellId j=0; j<this->numberOfCells(); ++j) {
     const auto& cell_nodes = cell_to_node_matrix.rowConst(j);
     for (unsigned short r=0; r<cell_nodes.length; ++r) {
-      unsigned int node0_id = cell_nodes(r);
-      unsigned int node1_id = cell_nodes((r+1)%cell_nodes.length);
+      NodeId node0_id = cell_nodes(r);
+      NodeId node1_id = cell_nodes((r+1)%cell_nodes.length);
       if (node1_id<node0_id) {
         std::swap(node0_id, node1_id);
       }
@@ -175,7 +176,7 @@ void Connectivity<2>::_computeCellFaceAndFaceNodeConnectivities()
   }
 
   {
-    int l=0;
+    FaceId l=0;
     for (const auto& face_cells_vector : face_cells_map) {
       const Face& face = face_cells_vector.first;
       m_face_number_map[face] = l;
@@ -184,7 +185,7 @@ void Connectivity<2>::_computeCellFaceAndFaceNodeConnectivities()
   }
 
   {
-    std::vector<std::vector<unsigned int>> face_to_node_vector(face_cells_map.size());
+    std::vector<std::vector<NodeId>> face_to_node_vector(face_cells_map.size());
     int l=0;
     for (const auto& face_info : face_cells_map) {
       const Face& face = face_info.first;
@@ -193,11 +194,11 @@ void Connectivity<2>::_computeCellFaceAndFaceNodeConnectivities()
     }
     auto& face_to_node_matrix
         = m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::node)];
-    face_to_node_matrix = face_to_node_vector;
+    face_to_node_matrix = reinterpret_cast<std::vector<std::vector<unsigned int>>&>(face_to_node_vector);
   }
 
   {
-    std::vector<std::vector<unsigned int>> face_to_cell_vector(face_cells_map.size());
+    std::vector<std::vector<CellId>> face_to_cell_vector(face_cells_map.size());
     int l=0;
     for (const auto& face_cells_vector : face_cells_map) {
       const auto& [face, cell_info_vector] = face_cells_vector;
@@ -208,21 +209,21 @@ void Connectivity<2>::_computeCellFaceAndFaceNodeConnectivities()
     }
     auto& face_to_cell_matrix
         = m_item_to_item_matrix[itemTId(ItemType::face)][itemTId(ItemType::cell)];
-    face_to_cell_matrix = face_to_cell_vector;
+    face_to_cell_matrix = reinterpret_cast<std::vector<std::vector<unsigned int>>&>(face_to_cell_vector);
   }
 }
 
 
 template<size_t Dimension>
 Connectivity<Dimension>::
-Connectivity(const std::vector<std::vector<unsigned int>>& cell_by_node_vector,
+Connectivity(const std::vector<std::vector<CellId>>& cell_by_node_vector,
              const std::vector<CellType>& cell_type_vector)
 {
   Assert(cell_by_node_vector.size() == cell_type_vector.size());
 
   auto& cell_to_node_matrix
       = m_item_to_item_matrix[itemTId(ItemType::cell)][itemTId(ItemType::node)];
-  cell_to_node_matrix = cell_by_node_vector;
+  cell_to_node_matrix = reinterpret_cast<const std::vector<std::vector<unsigned int>>&>(cell_by_node_vector);
 
   Assert(this->numberOfCells()>0);
 
@@ -249,13 +250,13 @@ Connectivity(const std::vector<std::vector<unsigned int>>& cell_by_node_vector,
 
 
 template Connectivity1D::
-Connectivity(const std::vector<std::vector<unsigned int>>& cell_by_node_vector,
+Connectivity(const std::vector<std::vector<CellId>>& cell_by_node_vector,
              const std::vector<CellType>& cell_type_vector);
 
 template Connectivity2D::
-Connectivity(const std::vector<std::vector<unsigned int>>& cell_by_node_vector,
+Connectivity(const std::vector<std::vector<CellId>>& cell_by_node_vector,
              const std::vector<CellType>& cell_type_vector);
 
 template Connectivity3D::
-Connectivity(const std::vector<std::vector<unsigned int>>& cell_by_node_vector,
+Connectivity(const std::vector<std::vector<CellId>>& cell_by_node_vector,
              const std::vector<CellType>& cell_type_vector);
diff --git a/src/mesh/Connectivity.hpp b/src/mesh/Connectivity.hpp
index 0948f1bf19e7bfc8be2f115c7d2c519a13051264..6d437d15c217a99814d25ca558c09926963c4c94 100644
--- a/src/mesh/Connectivity.hpp
+++ b/src/mesh/Connectivity.hpp
@@ -53,14 +53,14 @@ class ConnectivityFace<2>
   {
     size_t operator()(const ConnectivityFace& f) const {
       size_t hash = 0;
-      hash ^= std::hash<unsigned int>()(f.m_node0_id);
-      hash ^= std::hash<unsigned int>()(f.m_node1_id) >> 1;
+      hash ^= std::hash<NodeId::base_type>()(f.m_node0_id);
+      hash ^= std::hash<NodeId::base_type>()(f.m_node1_id) >> 1;
       return hash;
     }
   };
 
-  unsigned int m_node0_id;
-  unsigned int m_node1_id;
+  NodeId m_node0_id;
+  NodeId m_node1_id;
 
   friend std::ostream& operator<<(std::ostream& os, const ConnectivityFace& f)
   {
@@ -90,7 +90,7 @@ class ConnectivityFace<2>
   ConnectivityFace& operator=(ConnectivityFace&&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  ConnectivityFace(const std::vector<unsigned int>& given_node_id_list)
+  ConnectivityFace(const std::vector<NodeId>& given_node_id_list)
   {
     Assert(given_node_id_list.size()==2);
 #warning rework this dirty constructor
@@ -120,14 +120,14 @@ class ConnectivityFace<3>
     size_t operator()(const ConnectivityFace& f) const {
       size_t hash = 0;
       for (size_t i=0; i<f.m_node_id_list.size(); ++i) {
-        hash ^= std::hash<unsigned int>()(f.m_node_id_list[i]) >> i;
+        hash ^= std::hash<NodeId::base_type>()(f.m_node_id_list[i]) >> i;
       }
       return hash;
     }
   };
 
   bool m_reversed;
-  std::vector<unsigned int> m_node_id_list;
+  std::vector<NodeId> m_node_id_list;
 
   friend std::ostream& operator<<(std::ostream& os, const ConnectivityFace& f)
   {
@@ -144,18 +144,18 @@ class ConnectivityFace<3>
   }
 
   KOKKOS_INLINE_FUNCTION
-  const std::vector<unsigned int>& nodeIdList() const
+  const std::vector<NodeId>& nodeIdList() const
   {
     return m_node_id_list;
   }
 
   KOKKOS_INLINE_FUNCTION
-  std::vector<unsigned int> _sort(const std::vector<unsigned int>& node_list)
+  std::vector<NodeId> _sort(const std::vector<NodeId>& node_list)
   {
     const auto min_id = std::min_element(node_list.begin(), node_list.end());
     const int shift = std::distance(node_list.begin(), min_id);
 
-    std::vector<unsigned int> rotated_node_list(node_list.size());
+    std::vector<NodeId> rotated_node_list(node_list.size());
     if (node_list[(shift+1)%node_list.size()] > node_list[(shift+node_list.size()-1)%node_list.size()]) {
       for (size_t i=0; i<node_list.size(); ++i) {
         rotated_node_list[i] = node_list[(shift+node_list.size()-i)%node_list.size()];
@@ -171,7 +171,7 @@ class ConnectivityFace<3>
   }
 
   KOKKOS_INLINE_FUNCTION
-  ConnectivityFace(const std::vector<unsigned int>& given_node_id_list)
+  ConnectivityFace(const std::vector<NodeId>& given_node_id_list)
       : m_reversed(false),
         m_node_id_list(_sort(given_node_id_list))
   {
@@ -264,7 +264,7 @@ class Connectivity final
 
   using Face = ConnectivityFace<Dimension>;
 
-  std::unordered_map<Face, unsigned int, typename Face::Hash> m_face_number_map;
+  std::unordered_map<Face, FaceId, typename Face::Hash> m_face_number_map;
 
   void _computeCellFaceAndFaceNodeConnectivities();
 
@@ -477,7 +477,7 @@ class Connectivity final
     return m_inv_cell_nb_nodes;
   }
 
-  unsigned int getFaceNumber(const std::vector<unsigned int>& face_nodes) const
+  FaceId getFaceNumber(const std::vector<NodeId>& face_nodes) const
   {
     const Face face(face_nodes);
     auto i_face = m_face_number_map.find(face);
@@ -491,7 +491,7 @@ class Connectivity final
 
   Connectivity(const Connectivity&) = delete;
 
-  Connectivity(const std::vector<std::vector<unsigned int>>& cell_by_node_vector,
+  Connectivity(const std::vector<std::vector<CellId>>& cell_by_node_vector,
                const std::vector<CellType>& cell_type_vector);
 
   ~Connectivity()
diff --git a/src/mesh/GmshReader.cpp b/src/mesh/GmshReader.cpp
index be77c6ac16eefb092c858ac80231747d4e3ae0a0..92e7f2086f251adc302a1b688b6d92f9deeeb51c 100644
--- a/src/mesh/GmshReader.cpp
+++ b/src/mesh/GmshReader.cpp
@@ -791,7 +791,7 @@ GmshReader::__proceedData()
 
     std::vector<CellType> cell_type_vector(nb_cells);
 
-    std::vector<std::vector<unsigned int>> cell_by_node_vector(nb_cells);
+    std::vector<std::vector<CellId>> cell_by_node_vector(nb_cells);
     const size_t nb_tetrahedra = __tetrahedra.size();
     for (size_t j=0; j<nb_tetrahedra; ++j) {
       cell_by_node_vector[j].resize(4);
@@ -829,7 +829,7 @@ GmshReader::__proceedData()
       ref_faces_map[ref].push_back(face_number);
     }
     for (const auto& ref_face_list : ref_faces_map) {
-      Array<unsigned int> face_list(ref_face_list.second.size());
+      Array<FaceId> face_list(ref_face_list.second.size());
       for (size_t j=0; j<ref_face_list.second.size(); ++j) {
         face_list[j]=ref_face_list.second[j];
       }
@@ -853,7 +853,7 @@ GmshReader::__proceedData()
 
     std::vector<CellType> cell_type_vector(nb_cells);
 
-    std::vector<std::vector<unsigned int>> cell_by_node_vector(nb_cells);
+    std::vector<std::vector<CellId>> cell_by_node_vector(nb_cells);
     const size_t nb_triangles = __triangles.size();
     for (size_t j=0; j<nb_triangles; ++j) {
       cell_by_node_vector[j].resize(3);
@@ -885,7 +885,7 @@ GmshReader::__proceedData()
     }
 
     for (const auto& ref_face_list : ref_faces_map) {
-      Array<unsigned int> face_list(ref_face_list.second.size());
+      Array<FaceId> face_list(ref_face_list.second.size());
       for (size_t j=0; j<ref_face_list.second.size(); ++j) {
         face_list[j]=ref_face_list.second[j];
       }
@@ -901,7 +901,7 @@ GmshReader::__proceedData()
     }
 
     for (const auto& ref_point_list : ref_points_map) {
-      Array<unsigned int> point_list(ref_point_list.second.size());
+      Array<NodeId> point_list(ref_point_list.second.size());
       for (size_t j=0; j<ref_point_list.second.size(); ++j) {
         point_list[j]=ref_point_list.second[j];
       }
@@ -924,7 +924,7 @@ GmshReader::__proceedData()
 
     std::vector<CellType> cell_type_vector(nb_cells);
 
-    std::vector<std::vector<unsigned int>> cell_by_node_vector(nb_cells);
+    std::vector<std::vector<CellId>> cell_by_node_vector(nb_cells);
     for (size_t j=0; j<nb_cells; ++j) {
       cell_by_node_vector[j].resize(2);
       for (int r=0; r<2; ++r) {
@@ -945,7 +945,7 @@ GmshReader::__proceedData()
     }
 
     for (const auto& ref_point_list : ref_points_map) {
-      Array<unsigned int> point_list(ref_point_list.second.size());
+      Array<NodeId> point_list(ref_point_list.second.size());
       for (size_t j=0; j<ref_point_list.second.size(); ++j) {
         point_list[j]=ref_point_list.second[j];
       }
diff --git a/src/mesh/ItemId.hpp b/src/mesh/ItemId.hpp
index 20f538a0f2e1b83f8e3c4426458fe847c82341f8..11b87f7082bddbbbef76826bdc32b6272bc87d27 100644
--- a/src/mesh/ItemId.hpp
+++ b/src/mesh/ItemId.hpp
@@ -6,11 +6,14 @@
 template <ItemType item_type>
 class ItemIdT
 {
+ public:
+  using base_type = unsigned int;
+
  private:
-  unsigned int m_id;
+  base_type m_id;
 
  public:
-  operator const unsigned int&() const
+  operator const base_type&() const
   {
     return m_id;
   }
@@ -28,7 +31,7 @@ class ItemIdT
     return *this;
   }
 
-  ItemIdT& operator=(const unsigned int& id)
+  ItemIdT& operator=(const base_type& id)
   {
     m_id = id;
     return *this;
@@ -37,7 +40,7 @@ class ItemIdT
   ItemIdT& operator=(const ItemIdT&) = default;
   ItemIdT& operator=(ItemIdT&&) = default;
 
-  ItemIdT(const unsigned int& id) : m_id{id}{}
+  ItemIdT(const base_type& id) : m_id{id}{}
 
   ItemIdT(const ItemIdT&) = default;
 
diff --git a/src/mesh/MeshNodeBoundary.hpp b/src/mesh/MeshNodeBoundary.hpp
index 768671115bfb3def2e05add89413e425434ff322..8500e2e9f50c2017959689a6b5e7e5f7975737a3 100644
--- a/src/mesh/MeshNodeBoundary.hpp
+++ b/src/mesh/MeshNodeBoundary.hpp
@@ -18,12 +18,12 @@ template <size_t dimension>
 class MeshNodeBoundary
 {
  protected:
-  Array<const unsigned int> m_node_list;
+  Array<const NodeId> m_node_list;
  public:
   MeshNodeBoundary& operator=(const MeshNodeBoundary&) = default;
   MeshNodeBoundary& operator=(MeshNodeBoundary&&) = default;
 
-  const Array<const unsigned int>& nodeList() const
+  const Array<const NodeId>& nodeList() const
   {
     return m_node_list;
   }
@@ -36,7 +36,7 @@ class MeshNodeBoundary
     const auto& face_to_cell_matrix
         = mesh.connectivity().getMatrix(ItemType::face, ItemType::cell);
 
-    const Array<const unsigned int>& face_list = ref_face_list.faceList();
+    const Array<const FaceId>& face_list = ref_face_list.faceList();
     Kokkos::parallel_for(face_list.size(), KOKKOS_LAMBDA(const int& l){
         const auto& face_cells = face_to_cell_matrix.rowConst(face_list[l]);
         if (face_cells.length>1) {
@@ -64,7 +64,7 @@ class MeshNodeBoundary
     auto last = std::unique(node_ids.begin(), node_ids.end());
     node_ids.resize(std::distance(node_ids.begin(), last));
 
-    Array<unsigned int> node_list(node_ids.size());
+    Array<NodeId> node_list(node_ids.size());
     Kokkos::parallel_for(node_ids.size(), KOKKOS_LAMBDA(const int& r){
         node_list[r] = node_ids[r];
       });
@@ -157,7 +157,7 @@ _checkBoundaryIsFlat(const TinyVector<2,double>& normal,
   const NodeValue<const R2>& xr = mesh.xr();
 
   Kokkos::parallel_for(m_node_list.size(), KOKKOS_LAMBDA(const size_t& r) {
-      const R2& x = xr[NodeId{m_node_list[r]}];
+      const R2& x = xr[m_node_list[r]];
       if ((x-origin,normal)>1E-13*length) {
         std::cerr << "this FlatBoundary is not flat!\n";
         std::exit(1);
@@ -200,7 +200,7 @@ _getNormal(const MeshType& mesh)
           -std::numeric_limits<double>::max());
 
   for (size_t r=0; r<m_node_list.size(); ++r) {
-    const R2& x = xr[NodeId{m_node_list[r]}];
+    const R2& x = xr[m_node_list[r]];
     if ((x[0]<xmin[0]) or ((x[0] == xmin[0]) and (x[1] < xmin[1]))) {
       xmin = x;
     }
@@ -247,7 +247,7 @@ _getNormal(const MeshType& mesh)
   const NodeValue<const R3>& xr = mesh.xr();
 
   for (size_t r=0; r<m_node_list.size(); ++r) {
-    const R3& x = xr[NodeId{m_node_list[r]}];
+    const R3& x = xr[m_node_list[r]];
     if (x[0]<xmin[0]) {
       xmin = x;
     }
@@ -328,12 +328,12 @@ _getOutgoingNormal(const MeshType& mesh)
       = mesh.connectivity().getMatrix(ItemType::node,
                                       ItemType::cell);
 
-  const size_t r0 = m_node_list[0];
+  const NodeId r0 = m_node_list[0];
   const size_t j0 = node_to_cell_matrix.rowConst(r0)(0);
   const auto& j0_nodes = cell_to_node_matrix.rowConst(j0);
   double max_height = 0;
   for (size_t r=0; r<j0_nodes.length; ++r) {
-    const double height = (xr[NodeId{j0_nodes(r)}]-xr[NodeId{r0}], normal);
+    const double height = (xr[NodeId{j0_nodes(r)}]-xr[r0], normal);
     if (std::abs(height) > std::abs(max_height)) {
       max_height = height;
     }
@@ -365,12 +365,12 @@ _getOutgoingNormal(const MeshType& mesh)
       = mesh.connectivity().getMatrix(ItemType::node,
                                       ItemType::cell);
 
-  const size_t r0 = m_node_list[0];
+  const NodeId r0 = m_node_list[0];
   const size_t j0 = node_to_cell_matrix.rowConst(r0)(0);
   const auto& j0_nodes = cell_to_node_matrix.rowConst(j0);
   double max_height = 0;
   for (size_t r=0; r<j0_nodes.length; ++r) {
-    const double height = (xr[NodeId{j0_nodes(r)}]-xr[NodeId{r0}], normal);
+    const double height = (xr[NodeId{j0_nodes(r)}]-xr[r0], normal);
     if (std::abs(height) > std::abs(max_height)) {
       max_height = height;
     }
@@ -402,12 +402,12 @@ _getOutgoingNormal(const MeshType& mesh)
       = mesh.connectivity().getMatrix(ItemType::node,
                                       ItemType::cell);
 
-  const size_t r0 = m_node_list[0];
+  const NodeId r0 = m_node_list[0];
   const size_t j0 = node_to_cell_matrix.rowConst(r0)(0);
   const auto& j0_nodes = cell_to_node_matrix.rowConst(j0);
   double max_height = 0;
   for (size_t r=0; r<j0_nodes.length; ++r) {
-    const double height = (xr[NodeId{j0_nodes(r)}]-xr[NodeId{r0}], normal);
+    const double height = (xr[NodeId{j0_nodes(r)}]-xr[r0], normal);
     if (std::abs(height) > std::abs(max_height)) {
       max_height = height;
     }
diff --git a/src/mesh/RefFaceList.hpp b/src/mesh/RefFaceList.hpp
index da08dd63e8a64e303a601cdec79831877f6e5c5b..ab66943936c091735c404b287d587a15d81a1a9f 100644
--- a/src/mesh/RefFaceList.hpp
+++ b/src/mesh/RefFaceList.hpp
@@ -8,7 +8,7 @@ class RefFaceList
 {
  private:
   const RefId m_ref_id;
-  const Array<const unsigned int> m_face_id_list;
+  const Array<const FaceId> m_face_id_list;
 
  public:
   const RefId& refId() const
@@ -16,13 +16,13 @@ class RefFaceList
     return m_ref_id;
   }
 
-  const Array<const unsigned int>& faceList() const
+  const Array<const FaceId>& faceList() const
   {
     return m_face_id_list;
   }
 
   RefFaceList(const RefId& ref_id,
-              const Array<const unsigned int>& face_id_list)
+              const Array<const FaceId>& face_id_list)
       : m_ref_id(ref_id),
         m_face_id_list(face_id_list)
   {
diff --git a/src/mesh/RefNodeList.hpp b/src/mesh/RefNodeList.hpp
index da65635511cc328c278bd03578cdff9ef05e31bc..462d23bb3d35a6384fcd5176d0584419a586abc3 100644
--- a/src/mesh/RefNodeList.hpp
+++ b/src/mesh/RefNodeList.hpp
@@ -8,7 +8,7 @@ class RefNodeList
 {
  private:
   RefId m_ref_id;
-  Array<const unsigned int> m_node_id_list;
+  Array<const NodeId> m_node_id_list;
 
  public:
   const RefId& refId() const
@@ -16,13 +16,13 @@ class RefNodeList
     return m_ref_id;
   }
 
-  const Array<const unsigned int>& nodeList() const
+  const Array<const NodeId>& nodeList() const
   {
     return m_node_id_list;
   }
 
   RefNodeList(const RefId& ref_id,
-              const Array<const unsigned int>& node_id_list)
+              const Array<const NodeId>& node_id_list)
       : m_ref_id(ref_id),
         m_node_id_list(node_id_list)
   {
diff --git a/src/scheme/AcousticSolver.hpp b/src/scheme/AcousticSolver.hpp
index 6139b022b3fc5b15f47418cf4882f189e212d4b0..e6d8d289d3d31fd1dbdf49db6d79f9fb9cdeff81 100644
--- a/src/scheme/AcousticSolver.hpp
+++ b/src/scheme/AcousticSolver.hpp
@@ -144,7 +144,7 @@ class AcousticSolver
           const Rdd nxn = tensorProduct(n,n);
           const Rdd P = I-nxn;
 
-          const Array<const unsigned int>& node_list
+          const Array<const NodeId>& node_list
               = symmetry_bc.nodeList();
           Kokkos::parallel_for(symmetry_bc.numberOfNodes(), KOKKOS_LAMBDA(const int& r_number) {
               const NodeId r = node_list[r_number];
diff --git a/src/scheme/BoundaryCondition.hpp b/src/scheme/BoundaryCondition.hpp
index fc62f8e9eee9abd4988bcb3c0727ddde2bbd12d1..8747cb0c5cff48ca787e4186638cb03902966ca7 100644
--- a/src/scheme/BoundaryCondition.hpp
+++ b/src/scheme/BoundaryCondition.hpp
@@ -99,7 +99,7 @@ public:
     return m_mesh_flat_node_boundary.nodeList().size();
   }
 
-  const Array<const unsigned int>& nodeList() const
+  const Array<const NodeId>& nodeList() const
   {
     return m_mesh_flat_node_boundary.nodeList();
   }