Add all item local number in child items

Access function are defined to forbid inappropriate use and to match classical
nomenclature
- edge <-> face/node are forbidden except in dimension>2
- face <-> node are forbidden except in dimension>1
- when calling edge <-> cell in dimension<2 use face <-> cell
...

src/mesh/Connectivity.hpp

@@ -236,16 +236,20 @@ class Connectivity final
   FaceValuePerCell<const bool> m_cell_face_is_reversed;
 
   NodeValuePerCell<const unsigned short> m_cell_local_numbers_in_their_nodes;
+  EdgeValuePerCell<const unsigned short> m_cell_local_numbers_in_their_edges;
+  FaceValuePerCell<const unsigned short> m_cell_local_numbers_in_their_faces;
 
   CellValuePerFace<const unsigned short> m_face_local_numbers_in_their_cells;
+  EdgeValuePerFace<const unsigned short> m_face_local_numbers_in_their_edges;
+  NodeValuePerFace<const unsigned short> m_face_local_numbers_in_their_nodes;
 
-  CellValuePerNode<const unsigned short> m_node_local_numbers_in_their_cells;
+  CellValuePerEdge<const unsigned short> m_edge_local_numbers_in_their_cells;
+  FaceValuePerEdge<const unsigned short> m_edge_local_numbers_in_their_faces;
+  NodeValuePerEdge<const unsigned short> m_edge_local_numbers_in_their_nodes;
 
-  // not plugged ...
-#warning remaining def
-  NodeValuePerFace<unsigned short> m_node_local_numbers_in_their_faces;
-  FaceValuePerNode<unsigned short> m_face_local_numbers_in_their_nodes;
-  // ... not plugged
+  CellValuePerNode<const unsigned short> m_node_local_numbers_in_their_cells;
+  EdgeValuePerNode<const unsigned short> m_node_local_numbers_in_their_edges;
+  FaceValuePerNode<const unsigned short> m_node_local_numbers_in_their_faces;
 
   ConnectivityComputer m_connectivity_computer;
 
@@ -300,34 +304,104 @@ class Connectivity final
     return connectivity_matrix;
   }
 
+  KOKKOS_INLINE_FUNCTION
   const auto& cellFaceIsReversed() const
   {
     static_assert(dimension>1, "reversed faces makes no sense in dimension 1");
     return m_cell_face_is_reversed;
   }
 
+  KOKKOS_INLINE_FUNCTION
   const auto& cellLocalNumbersInTheirNodes() const
   {
     return _lazzyBuildItemNumberInTheirChild(m_cell_local_numbers_in_their_nodes);
   }
 
-  const auto& nodeLocalNumbersInTheirCells() const
+  KOKKOS_INLINE_FUNCTION
+  const auto& cellLocalNumbersInTheirEdges() const
   {
-    return _lazzyBuildItemNumberInTheirChild(m_node_local_numbers_in_their_cells);
+    if constexpr (dimension>2) {
+      return _lazzyBuildItemNumberInTheirChild(m_cell_local_numbers_in_their_edges);
+    } else {
+      return cellLocalNumbersInTheirFaces();
+    }
   }
 
+  KOKKOS_INLINE_FUNCTION
+  const auto& cellLocalNumbersInTheirFaces() const
+  {
+    if constexpr (dimension>1) {
+      return _lazzyBuildItemNumberInTheirChild(m_cell_local_numbers_in_their_faces);
+    } else {
+      return cellLocalNumbersInTheirNodes();
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
   const auto& faceLocalNumbersInTheirCells() const
   {
     if constexpr(dimension>1) {
       return _lazzyBuildItemNumberInTheirChild(m_face_local_numbers_in_their_cells);
     } else {
+      return nodeLocalNumbersInTheirCells();
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto& faceLocalNumbersInTheirEdges() const
+  {
+    static_assert(dimension>2,"this function has no meaning in 1d or 2d");
+    return _lazzyBuildItemNumberInTheirChild(m_face_local_numbers_in_their_edges);
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto& faceLocalNumbersInTheirNodes() const
+  {
+    static_assert(dimension>1,"this function has no meaning in 1d");
+    return _lazzyBuildItemNumberInTheirChild(m_face_local_numbers_in_their_nodes);
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto& edgeLocalNumbersInTheirCells() const
+  {
+    if constexpr (dimension>2) {
+      return _lazzyBuildItemNumberInTheirChild(m_edge_local_numbers_in_their_cells);
+    } else {
+      return faceLocalNumbersInTheirCells();
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto& edgeLocalNumbersInTheirFaces() const
+  {
+    static_assert(dimension>2, "this function has no meaning in 1d or 2d");
+    return _lazzyBuildItemNumberInTheirChild(m_edge_local_numbers_in_their_faces);
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto& edgeLocalNumbersInTheirNodes() const
+  {
+    static_assert(dimension>2, "this function has no meaning in 1d or 2d");
+    return _lazzyBuildItemNumberInTheirChild(m_edge_local_numbers_in_their_nodes);
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto& nodeLocalNumbersInTheirCells() const
+  {
     return _lazzyBuildItemNumberInTheirChild(m_node_local_numbers_in_their_cells);
   }
+
+  KOKKOS_INLINE_FUNCTION
+  const auto& nodeLocalNumbersInTheirEdges() const
+  {
+    static_assert(dimension>2, "this function has no meaning in 1d or 2d");
+    return _lazzyBuildItemNumberInTheirChild(m_node_local_numbers_in_their_edges);
   }
 
+  KOKKOS_INLINE_FUNCTION
   const auto& nodeLocalNumbersInTheirFaces() const
   {
-    static_assert(Dimension==1,"this function has no meaning in 1d");
+    static_assert(dimension>1,"this function has no meaning in 1d");
     return _lazzyBuildItemNumberInTheirChild(m_node_local_numbers_in_their_faces);
   }
 

src/mesh/SubItemValuePerItem.hpp

@@ -202,21 +202,47 @@ class SubItemValuePerItem<DataType,
   ~SubItemValuePerItem() = default;
 };
 
+// Item values at nodes
+
 template <typename DataType>
-using NodeValuePerCell = SubItemValuePerItem<DataType, ItemType::node, ItemType::cell>;
+using NodeValuePerEdge = SubItemValuePerItem<DataType, ItemType::node, ItemType::edge>;
 
 template <typename DataType>
 using NodeValuePerFace = SubItemValuePerItem<DataType, ItemType::node, ItemType::face>;
 
+template <typename DataType>
+using NodeValuePerCell = SubItemValuePerItem<DataType, ItemType::node, ItemType::cell>;
+
+// Item values at edges
+
+template <typename DataType>
+using EdgeValuePerNode = SubItemValuePerItem<DataType, ItemType::edge, ItemType::node>;
+
+template <typename DataType>
+using EdgeValuePerFace = SubItemValuePerItem<DataType, ItemType::edge, ItemType::face>;
+
+template <typename DataType>
+using EdgeValuePerCell = SubItemValuePerItem<DataType, ItemType::edge, ItemType::cell>;
+
+// Item values at faces
+
 template <typename DataType>
 using FaceValuePerNode = SubItemValuePerItem<DataType, ItemType::face, ItemType::node>;
 
+template <typename DataType>
+using FaceValuePerEdge = SubItemValuePerItem<DataType, ItemType::face, ItemType::edge>;
+
 template <typename DataType>
 using FaceValuePerCell = SubItemValuePerItem<DataType, ItemType::face, ItemType::cell>;
 
+// Item values at cells
+
 template <typename DataType>
 using CellValuePerNode = SubItemValuePerItem<DataType, ItemType::cell, ItemType::node>;
 
+template <typename DataType>
+using CellValuePerEdge = SubItemValuePerItem<DataType, ItemType::cell, ItemType::edge>;
+
 template <typename DataType>
 using CellValuePerFace = SubItemValuePerItem<DataType, ItemType::cell, ItemType::face>;