diff --git a/src/mesh/Connectivity.hpp b/src/mesh/Connectivity.hpp
index e07a26a275e5765cb21c2f2a4549015865c927ce..4c19ae6b53a97523f977fdb56a5d310c84227b1d 100644
--- a/src/mesh/Connectivity.hpp
+++ b/src/mesh/Connectivity.hpp
@@ -158,11 +158,11 @@ class Connectivity final
   const SubItemValuePerItemType&
   _lazzyBuildItemNumberInTheirChild(const SubItemValuePerItemType& sub_item_value_per_item) const
   {
+    using ReversedItemOfItem = typename SubItemValuePerItemType::ItemOfItemType::Reversed;
     if (not sub_item_value_per_item.isBuilt()) {
       const_cast<SubItemValuePerItemType&>(sub_item_value_per_item)
           = m_connectivity_computer
-          . computeLocalItemNumberInChildItem<SubItemValuePerItemType::item_t,
-                                              SubItemValuePerItemType::sub_item_t>(*this);
+          . computeLocalItemNumberInChildItem<ReversedItemOfItem>(*this);
     }
     return sub_item_value_per_item;
   }
diff --git a/src/mesh/ConnectivityComputer.cpp b/src/mesh/ConnectivityComputer.cpp
index b820370987cee240fcd34e1a6ed2ad59134d6372..294b15591eac18ab8ac11951b74a0effd84c1827 100644
--- a/src/mesh/ConnectivityComputer.cpp
+++ b/src/mesh/ConnectivityComputer.cpp
@@ -76,18 +76,22 @@ _computeInverse(const ConnectivityMatrix& item_to_child_matrix) const
   return ConnectivityMatrix(child_to_items_vector);
 }
 
-template <ItemType item_type,
-          ItemType child_item_type,
+template <typename ItemOfItem,
           typename ConnectivityType>
-WeakSubItemValuePerItem<const unsigned short, child_item_type, item_type>
+WeakSubItemValuePerItem<const unsigned short, typename ItemOfItem::Reversed>
 ConnectivityComputer::computeLocalItemNumberInChildItem(const ConnectivityType& connectivity) const
 {
+  using ReversedItemOfItem = typename ItemOfItem::Reversed;
+
+  constexpr ItemType item_type = ReversedItemOfItem::item_type;
+  constexpr ItemType child_item_type = ReversedItemOfItem::sub_item_type;
+
   const ConnectivityMatrix& child_item_to_items_matrix
       = connectivity._getMatrix(child_item_type, item_type);
   const ConnectivityMatrix& item_to_child_items_matrix
       = connectivity._getMatrix(item_type, child_item_type);
 
-  WeakSubItemValuePerItem<unsigned short, child_item_type, item_type> item_number_in_child_item(connectivity);
+  WeakSubItemValuePerItem<unsigned short, ReversedItemOfItem> item_number_in_child_item(connectivity);
   for (ItemIdT<item_type> r=0; r<item_to_child_items_matrix.numRows(); ++r) {
     const auto& item_to_child_items = item_to_child_items_matrix.rowConst(r);
     for (unsigned short J=0; J<item_to_child_items.length; ++J) {
@@ -108,51 +112,89 @@ ConnectivityComputer::computeLocalItemNumberInChildItem(const ConnectivityType&
 
 // 1D
 
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::node>
+template WeakSubItemValuePerItem<const unsigned short, CellOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfCell>(const Connectivity1D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, NodeOfCell>
 ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::node,
-                                  ItemType::cell>(const Connectivity1D&) const;
+computeLocalItemNumberInChildItem<CellOfNode>(const Connectivity1D&) const;
 
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::face>
+// 2D
+
+template WeakSubItemValuePerItem<const unsigned short, CellOfNode>
 ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::face,
-                                  ItemType::cell>(const Connectivity1D&) const;
+computeLocalItemNumberInChildItem<NodeOfCell>(const Connectivity2D&) const;
 
-template WeakSubItemValuePerItem<const unsigned short, ItemType::node, ItemType::cell>
+template WeakSubItemValuePerItem<const unsigned short, CellOfFace>
 ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::cell,
-                                  ItemType::node>(const Connectivity1D&) const;
+computeLocalItemNumberInChildItem<FaceOfCell>(const Connectivity2D&) const;
 
-// 2D
+template WeakSubItemValuePerItem<const unsigned short, FaceOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfFace>(const Connectivity2D&) const;
 
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::node>
+template WeakSubItemValuePerItem<const unsigned short, FaceOfCell>
 ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::node,
-                                  ItemType::cell>(const Connectivity2D&) const;
+computeLocalItemNumberInChildItem<CellOfFace>(const Connectivity2D&) const;
 
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::face>
+template WeakSubItemValuePerItem<const unsigned short, NodeOfFace>
 ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::face,
-                                  ItemType::cell>(const Connectivity2D&) const;
+computeLocalItemNumberInChildItem<FaceOfNode>(const Connectivity2D&) const;
 
-template WeakSubItemValuePerItem<const unsigned short, ItemType::node, ItemType::cell>
+template WeakSubItemValuePerItem<const unsigned short, NodeOfCell>
 ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::cell,
-                                  ItemType::node>(const Connectivity2D&) const;
+computeLocalItemNumberInChildItem<CellOfNode>(const Connectivity2D&) const;
 
 // 3D
 
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::node>
+template WeakSubItemValuePerItem<const unsigned short, CellOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfCell>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, CellOfEdge>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<EdgeOfCell>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, CellOfFace>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<FaceOfCell>(const Connectivity3D&) const;
+
+
+template WeakSubItemValuePerItem<const unsigned short, FaceOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfFace>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, FaceOfEdge>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<EdgeOfFace>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, FaceOfCell>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<CellOfFace>(const Connectivity3D&) const;
+
+
+template WeakSubItemValuePerItem<const unsigned short, EdgeOfNode>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<NodeOfEdge>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, EdgeOfFace>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<FaceOfEdge>(const Connectivity3D&) const;
+
+template WeakSubItemValuePerItem<const unsigned short, EdgeOfCell>
+ConnectivityComputer::
+computeLocalItemNumberInChildItem<CellOfEdge>(const Connectivity3D&) const;
+
+
+template WeakSubItemValuePerItem<const unsigned short, NodeOfEdge>
 ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::node,
-                                  ItemType::cell>(const Connectivity3D&) const;
+computeLocalItemNumberInChildItem<EdgeOfNode>(const Connectivity3D&) const;
 
-template WeakSubItemValuePerItem<const unsigned short, ItemType::cell, ItemType::face>
+template WeakSubItemValuePerItem<const unsigned short, NodeOfFace>
 ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::face,
-                                  ItemType::cell>(const Connectivity3D&) const;
+computeLocalItemNumberInChildItem<FaceOfNode>(const Connectivity3D&) const;
 
-template WeakSubItemValuePerItem<const unsigned short, ItemType::node, ItemType::cell>
+template WeakSubItemValuePerItem<const unsigned short, NodeOfCell>
 ConnectivityComputer::
-computeLocalItemNumberInChildItem<ItemType::cell,
-                                  ItemType::node>(const Connectivity3D&) const;
+computeLocalItemNumberInChildItem<CellOfNode>(const Connectivity3D&) const;
diff --git a/src/mesh/ConnectivityComputer.hpp b/src/mesh/ConnectivityComputer.hpp
index 17b620459ff7f41db91fd4cdeb1c85b30f1b6168..d5c6019d54b57d6f18ad1eab0af3797f2e0108cb 100644
--- a/src/mesh/ConnectivityComputer.hpp
+++ b/src/mesh/ConnectivityComputer.hpp
@@ -18,10 +18,9 @@ class ConnectivityComputer
                             const ItemType& child_item_type) const;
 
 
-  template <ItemType item_type,
-            ItemType child_item_type,
+  template <typename ItemOfItem,
             typename ConnectivityType>
-  WeakSubItemValuePerItem<const unsigned short, child_item_type, item_type>
+  WeakSubItemValuePerItem<const unsigned short, typename ItemOfItem::Reversed>
   computeLocalItemNumberInChildItem(const ConnectivityType& connectivity) const;
 
   ConnectivityComputer(const ConnectivityComputer&) = default;
diff --git a/src/mesh/IConnectivity.hpp b/src/mesh/IConnectivity.hpp
index 359c9c75c75ebb9a83d1ffc26fe16f4c93e6ce0c..63ae03f3aa9e30f477db20c044e90822dd8dd046 100644
--- a/src/mesh/IConnectivity.hpp
+++ b/src/mesh/IConnectivity.hpp
@@ -2,6 +2,7 @@
 #define ICONNECTIVITY_HPP
 
 #include <ItemType.hpp>
+#include <ItemOfItemType.hpp>
 #include <ConnectivityMatrix.hpp>
 #include <memory>
 
@@ -9,10 +10,8 @@ class IConnectivity : public std::enable_shared_from_this<IConnectivity>
 {
  protected:
   template <typename DataType,
-            ItemType sub_item_type,
-            ItemType item_type,
-            typename ConnectivityPtr,
-            typename Allowed>
+            typename ItemOfItem,
+            typename ConnectivityPtr>
   friend
   class SubItemValuePerItem;
 
diff --git a/src/mesh/ItemOfItemType.hpp b/src/mesh/ItemOfItemType.hpp
index ce588bb9a786fd01344a569178c151693ba299d4..53a7d5ffe8d339d99e8be2e2fed0639542f83772 100644
--- a/src/mesh/ItemOfItemType.hpp
+++ b/src/mesh/ItemOfItemType.hpp
@@ -3,7 +3,6 @@
 
 #include <ItemType.hpp>
 
-#warning Should use this type in all sub item constructions
 template <ItemType sub_item_t,
           ItemType item_t>
 struct ItemOfItemType
@@ -12,21 +11,23 @@ struct ItemOfItemType
 
   constexpr static ItemType sub_item_type = sub_item_t;
   constexpr static ItemType item_type = item_t;
+
+  using Reversed = ItemOfItemType<item_type, sub_item_type>;
 };
 
 using FaceOfCell = ItemOfItemType<ItemType::face, ItemType::cell>;
 using EdgeOfCell = ItemOfItemType<ItemType::edge, ItemType::cell>;
 using NodeOfCell = ItemOfItemType<ItemType::node, ItemType::cell>;
 
-using CellofFace = ItemOfItemType<ItemType::cell, ItemType::face>;
+using CellOfFace = ItemOfItemType<ItemType::cell, ItemType::face>;
 using EdgeOfFace = ItemOfItemType<ItemType::edge, ItemType::face>;
 using NodeOfFace = ItemOfItemType<ItemType::node, ItemType::face>;
 
-using CellofEdge = ItemOfItemType<ItemType::cell, ItemType::edge>;
+using CellOfEdge = ItemOfItemType<ItemType::cell, ItemType::edge>;
 using FaceOfEdge = ItemOfItemType<ItemType::face, ItemType::edge>;
 using NodeOfEdge = ItemOfItemType<ItemType::node, ItemType::edge>;
 
-using CellofNode = ItemOfItemType<ItemType::cell, ItemType::node>;
+using CellOfNode = ItemOfItemType<ItemType::cell, ItemType::node>;
 using FaceOfNode = ItemOfItemType<ItemType::face, ItemType::node>;
 using EdgeOfNode = ItemOfItemType<ItemType::edge, ItemType::node>;
 
diff --git a/src/mesh/SubItemValuePerItem.hpp b/src/mesh/SubItemValuePerItem.hpp
index 2460e971c517dec3b00f07d3106e036213645a15..821acbd2b8df2a213b78af085d5115e26827a7f8 100644
--- a/src/mesh/SubItemValuePerItem.hpp
+++ b/src/mesh/SubItemValuePerItem.hpp
@@ -6,35 +6,37 @@
 #include <PastisAssert.hpp>
 
 #include <Array.hpp>
-#include <ItemType.hpp>
 
 #include <ItemId.hpp>
 
 #include <ConnectivityMatrix.hpp>
 #include <IConnectivity.hpp>
+
+#include <ItemType.hpp>
+#include <ItemOfItemType.hpp>
+
 #include <memory>
 
-template <typename DataType,
-          ItemType sub_item_type,
-          ItemType item_type,
-          typename ConnectivityPtr = std::shared_ptr<const IConnectivity>,
-          typename Allowed=void>
-class SubItemValuePerItem;
+// template <typename DataType,
+//           typename ItemOfItem,
+//           typename ConnectivityPtr = std::shared_ptr<const IConnectivity>,
+//           typename Allowed=void>
+// class SubItemValuePerItem;
 
 template <typename DataType,
-          ItemType sub_item_type,
-          ItemType item_type,
-          typename ConnectivityPtr>
-class SubItemValuePerItem<DataType,
-                          sub_item_type,
-                          item_type,
-                          ConnectivityPtr,
-                          std::enable_if_t<sub_item_type != item_type>>
+          typename ItemOfItem,
+          typename ConnectivityPtr = std::shared_ptr<const IConnectivity>>
+class SubItemValuePerItem// <DataType,
+                         //  ItemOfItem,
+                         //  ConnectivityPtr// ,
+                         //  // std::enable_if_t<sub_item_type != item_type>
+                         //  >
 {
  public:
-  static const ItemType item_t{item_type};
-  static const ItemType sub_item_t{sub_item_type};
+  static constexpr ItemType item_type{ItemOfItem::item_type};
+  static constexpr ItemType sub_item_type{ItemOfItem::sub_item_type};
 
+  using ItemOfItemType = ItemOfItem;
   using data_type = DataType;
   using ItemId = ItemIdT<item_type>;
   using index_type = ItemId;
@@ -53,22 +55,18 @@ class SubItemValuePerItem<DataType,
 
   // Allow const std:shared_ptr version to access our data
   friend SubItemValuePerItem<std::add_const_t<DataType>,
-                             sub_item_type,
-                             item_type,
+                             ItemOfItem,
                              ConnectivitySharedPtr>;
 
   // Allow const std:weak_ptr version to access our data
   friend SubItemValuePerItem<std::add_const_t<DataType>,
-                             sub_item_type,
-                             item_type,
+                             ItemOfItem,
                              ConnectivityWeakPtr>;
 
  public:
   using ToShared = SubItemValuePerItem<DataType,
-                                       sub_item_type,
-                                       item_type,
-                                       ConnectivitySharedPtr,
-                                       std::enable_if_t<sub_item_type != item_type>>;
+                                       ItemOfItem,
+                                       ConnectivitySharedPtr>;
 
   class SubView
   {
@@ -136,7 +134,7 @@ class SubItemValuePerItem<DataType,
   PASTIS_FORCEINLINE
   DataType& operator()(const IndexType& j, const size_t& r) const noexcept(NO_ASSERT)
   {
-    static_assert(std::is_same_v<IndexType, size_t>,
+    static_assert(std::is_same_v<IndexType, ItemId>,
                   "SubItemValuePerItem indexed by ItemId");
     Assert(this->isBuilt());
     return m_values[m_host_row_map(size_t{j})+r];
@@ -206,7 +204,7 @@ class SubItemValuePerItem<DataType,
             typename ConnectivityPtr2>
   PASTIS_INLINE
   SubItemValuePerItem&
-  operator=(const SubItemValuePerItem<DataType2, sub_item_type, item_type, ConnectivityPtr2>& sub_item_value_per_item) noexcept
+  operator=(const SubItemValuePerItem<DataType2, ItemOfItem, ConnectivityPtr2>& sub_item_value_per_item) noexcept
   {
     // ensures that DataType is the same as source DataType2
     static_assert(std::is_same_v<std::remove_const_t<DataType>, std::remove_const_t<DataType2>>,
@@ -231,7 +229,7 @@ class SubItemValuePerItem<DataType,
   template <typename DataType2,
             typename ConnectivityPtr2>
   PASTIS_INLINE
-  SubItemValuePerItem(const SubItemValuePerItem<DataType2, sub_item_type, item_type, ConnectivityPtr2>& sub_item_value_per_item) noexcept
+  SubItemValuePerItem(const SubItemValuePerItem<DataType2, ItemOfItem, ConnectivityPtr2>& sub_item_value_per_item) noexcept
   {
     this->operator=(sub_item_value_per_item);
   }
@@ -257,95 +255,94 @@ class SubItemValuePerItem<DataType,
 // Item values at nodes
 
 template <typename DataType>
-using NodeValuePerEdge = SubItemValuePerItem<DataType, ItemType::node, ItemType::edge>;
+using NodeValuePerEdge = SubItemValuePerItem<DataType, NodeOfEdge>;
 
 template <typename DataType>
-using NodeValuePerFace = SubItemValuePerItem<DataType, ItemType::node, ItemType::face>;
+using NodeValuePerFace = SubItemValuePerItem<DataType, NodeOfFace>;
 
 template <typename DataType>
-using NodeValuePerCell = SubItemValuePerItem<DataType, ItemType::node, ItemType::cell>;
+using NodeValuePerCell = SubItemValuePerItem<DataType, NodeOfCell>;
 
 // Item values at edges
 
 template <typename DataType>
-using EdgeValuePerNode = SubItemValuePerItem<DataType, ItemType::edge, ItemType::node>;
+using EdgeValuePerNode = SubItemValuePerItem<DataType, EdgeOfNode>;
 
 template <typename DataType>
-using EdgeValuePerFace = SubItemValuePerItem<DataType, ItemType::edge, ItemType::face>;
+using EdgeValuePerFace = SubItemValuePerItem<DataType, EdgeOfFace>;
 
 template <typename DataType>
-using EdgeValuePerCell = SubItemValuePerItem<DataType, ItemType::edge, ItemType::cell>;
+using EdgeValuePerCell = SubItemValuePerItem<DataType, EdgeOfCell>;
 
 // Item values at faces
 
 template <typename DataType>
-using FaceValuePerNode = SubItemValuePerItem<DataType, ItemType::face, ItemType::node>;
+using FaceValuePerNode = SubItemValuePerItem<DataType, FaceOfNode>;
 
 template <typename DataType>
-using FaceValuePerEdge = SubItemValuePerItem<DataType, ItemType::face, ItemType::edge>;
+using FaceValuePerEdge = SubItemValuePerItem<DataType, FaceOfEdge>;
 
 template <typename DataType>
-using FaceValuePerCell = SubItemValuePerItem<DataType, ItemType::face, ItemType::cell>;
+using FaceValuePerCell = SubItemValuePerItem<DataType, FaceOfCell>;
 
 // Item values at cells
 
 template <typename DataType>
-using CellValuePerNode = SubItemValuePerItem<DataType, ItemType::cell, ItemType::node>;
+using CellValuePerNode = SubItemValuePerItem<DataType, CellOfNode>;
 
 template <typename DataType>
-using CellValuePerEdge = SubItemValuePerItem<DataType, ItemType::cell, ItemType::edge>;
+using CellValuePerEdge = SubItemValuePerItem<DataType, CellOfEdge>;
 
 template <typename DataType>
-using CellValuePerFace = SubItemValuePerItem<DataType, ItemType::cell, ItemType::face>;
+using CellValuePerFace = SubItemValuePerItem<DataType, CellOfFace>;
 
 // Weak versions: should not be used outside of Connectivity
 // Item values at nodes
 
 template <typename DataType,
-          ItemType sub_item_type,
-          ItemType item_type>
-using WeakSubItemValuePerItem = SubItemValuePerItem<DataType, sub_item_type, item_type, std::weak_ptr<const IConnectivity>>;
+          typename ItemOfItem>
+using WeakSubItemValuePerItem = SubItemValuePerItem<DataType, ItemOfItem, std::weak_ptr<const IConnectivity>>;
 
 template <typename DataType>
-using WeakNodeValuePerEdge = WeakSubItemValuePerItem<DataType, ItemType::node, ItemType::edge>;
+using WeakNodeValuePerEdge = WeakSubItemValuePerItem<DataType, NodeOfEdge>;
 
 template <typename DataType>
-using WeakNodeValuePerFace = WeakSubItemValuePerItem<DataType, ItemType::node, ItemType::face>;
+using WeakNodeValuePerFace = WeakSubItemValuePerItem<DataType, NodeOfFace>;
 
 template <typename DataType>
-using WeakNodeValuePerCell = WeakSubItemValuePerItem<DataType, ItemType::node, ItemType::cell>;
+using WeakNodeValuePerCell = WeakSubItemValuePerItem<DataType, NodeOfCell>;
 
 // Item values at edges
 
 template <typename DataType>
-using WeakEdgeValuePerNode = WeakSubItemValuePerItem<DataType, ItemType::edge, ItemType::node>;
+using WeakEdgeValuePerNode = WeakSubItemValuePerItem<DataType, EdgeOfNode>;
 
 template <typename DataType>
-using WeakEdgeValuePerFace = WeakSubItemValuePerItem<DataType, ItemType::edge, ItemType::face>;
+using WeakEdgeValuePerFace = WeakSubItemValuePerItem<DataType, EdgeOfFace>;
 
 template <typename DataType>
-using WeakEdgeValuePerCell = WeakSubItemValuePerItem<DataType, ItemType::edge, ItemType::cell>;
+using WeakEdgeValuePerCell = WeakSubItemValuePerItem<DataType, EdgeOfCell>;
 
 // Item values at faces
 
 template <typename DataType>
-using WeakFaceValuePerNode = WeakSubItemValuePerItem<DataType, ItemType::face, ItemType::node>;
+using WeakFaceValuePerNode = WeakSubItemValuePerItem<DataType, FaceOfNode>;
 
 template <typename DataType>
-using WeakFaceValuePerEdge = WeakSubItemValuePerItem<DataType, ItemType::face, ItemType::edge>;
+using WeakFaceValuePerEdge = WeakSubItemValuePerItem<DataType, FaceOfEdge>;
 
 template <typename DataType>
-using WeakFaceValuePerCell = WeakSubItemValuePerItem<DataType, ItemType::face, ItemType::cell>;
+using WeakFaceValuePerCell = WeakSubItemValuePerItem<DataType, FaceOfCell>;
 
 // Item values at cells
 
 template <typename DataType>
-using WeakCellValuePerNode = WeakSubItemValuePerItem<DataType, ItemType::cell, ItemType::node>;
+using WeakCellValuePerNode = WeakSubItemValuePerItem<DataType, CellOfNode>;
 
 template <typename DataType>
-using WeakCellValuePerEdge = WeakSubItemValuePerItem<DataType, ItemType::cell, ItemType::edge>;
+using WeakCellValuePerEdge = WeakSubItemValuePerItem<DataType, CellOfEdge>;
 
 template <typename DataType>
-using WeakCellValuePerFace = WeakSubItemValuePerItem<DataType, ItemType::cell, ItemType::face>;
+using WeakCellValuePerFace = WeakSubItemValuePerItem<DataType, CellOfFace>;
 
 #endif // SUBITEM_VALUE_PER_ITEM_HPP