diff --git a/doc/userdoc.org b/doc/userdoc.org
index a91d0d5b850289bb953ab1d172d03bbbaea3e919..b550e3315e0a29551624bd5af91345f64cb706c9 100644
--- a/doc/userdoc.org
+++ b/doc/userdoc.org
@@ -2653,9 +2653,9 @@ edges or faces values cannot be post processed since neither ~VTK~ nor
 This abstract type is handle values defined on the sub items of the
 items of a ~mesh~. Similarly these values are attached to a *connectivity*
 and not to a mesh. Values can bed of type The values on the entities
-can be of type ~B~, ~N~, ~Z~, ~R~, ~R^1~, ~R^2~ or ~R^3~. An example of
-~sub_item_value~ is the $\mathbf{C}_{jr}$ vectors which are defined at each
-node of each cell.
+can be of type ~B~, ~N~, ~Z~, ~R~, ~R^1~, ~R^2~, ~R^3~, ~R^1x1~, ~R^2x2~ or ~R^3x3~. An
+example of ~sub_item_value~ is the $\mathbf{C}_{jr}$ vectors which are
+defined at each node of each cell.
 
 These variables are used to pass data from one function to
 another. They cannot be post processed.
diff --git a/src/mesh/SubItemValuePerItemVariant.hpp b/src/mesh/SubItemValuePerItemVariant.hpp
index d711f400a869b4d2a9431e9425ab7b5e53e09b5b..618fd82d9b9a158941ffc80d00b5b4fa56a25e31 100644
--- a/src/mesh/SubItemValuePerItemVariant.hpp
+++ b/src/mesh/SubItemValuePerItemVariant.hpp
@@ -16,6 +16,9 @@ class SubItemValuePerItemVariant
                                NodeValuePerEdge<const TinyVector<1, double>>,
                                NodeValuePerEdge<const TinyVector<2, double>>,
                                NodeValuePerEdge<const TinyVector<3, double>>,
+                               NodeValuePerEdge<const TinyMatrix<1, 1, double>>,
+                               NodeValuePerEdge<const TinyMatrix<2, 2, double>>,
+                               NodeValuePerEdge<const TinyMatrix<3, 3, double>>,
 
                                NodeValuePerFace<const bool>,
                                NodeValuePerFace<const long int>,
@@ -24,6 +27,9 @@ class SubItemValuePerItemVariant
                                NodeValuePerFace<const TinyVector<1, double>>,
                                NodeValuePerFace<const TinyVector<2, double>>,
                                NodeValuePerFace<const TinyVector<3, double>>,
+                               NodeValuePerFace<const TinyMatrix<1, 1, double>>,
+                               NodeValuePerFace<const TinyMatrix<2, 2, double>>,
+                               NodeValuePerFace<const TinyMatrix<3, 3, double>>,
 
                                NodeValuePerCell<const bool>,
                                NodeValuePerCell<const long int>,
@@ -32,6 +38,9 @@ class SubItemValuePerItemVariant
                                NodeValuePerCell<const TinyVector<1, double>>,
                                NodeValuePerCell<const TinyVector<2, double>>,
                                NodeValuePerCell<const TinyVector<3, double>>,
+                               NodeValuePerCell<const TinyMatrix<1, 1, double>>,
+                               NodeValuePerCell<const TinyMatrix<2, 2, double>>,
+                               NodeValuePerCell<const TinyMatrix<3, 3, double>>,
 
                                EdgeValuePerNode<const bool>,
                                EdgeValuePerNode<const long int>,
@@ -40,6 +49,9 @@ class SubItemValuePerItemVariant
                                EdgeValuePerNode<const TinyVector<1, double>>,
                                EdgeValuePerNode<const TinyVector<2, double>>,
                                EdgeValuePerNode<const TinyVector<3, double>>,
+                               EdgeValuePerNode<const TinyMatrix<1, 1, double>>,
+                               EdgeValuePerNode<const TinyMatrix<2, 2, double>>,
+                               EdgeValuePerNode<const TinyMatrix<3, 3, double>>,
 
                                EdgeValuePerFace<const bool>,
                                EdgeValuePerFace<const long int>,
@@ -48,6 +60,9 @@ class SubItemValuePerItemVariant
                                EdgeValuePerFace<const TinyVector<1, double>>,
                                EdgeValuePerFace<const TinyVector<2, double>>,
                                EdgeValuePerFace<const TinyVector<3, double>>,
+                               EdgeValuePerFace<const TinyMatrix<1, 1, double>>,
+                               EdgeValuePerFace<const TinyMatrix<2, 2, double>>,
+                               EdgeValuePerFace<const TinyMatrix<3, 3, double>>,
 
                                EdgeValuePerCell<const bool>,
                                EdgeValuePerCell<const long int>,
@@ -56,6 +71,9 @@ class SubItemValuePerItemVariant
                                EdgeValuePerCell<const TinyVector<1, double>>,
                                EdgeValuePerCell<const TinyVector<2, double>>,
                                EdgeValuePerCell<const TinyVector<3, double>>,
+                               EdgeValuePerCell<const TinyMatrix<1, 1, double>>,
+                               EdgeValuePerCell<const TinyMatrix<2, 2, double>>,
+                               EdgeValuePerCell<const TinyMatrix<3, 3, double>>,
 
                                FaceValuePerNode<const bool>,
                                FaceValuePerNode<const long int>,
@@ -64,6 +82,9 @@ class SubItemValuePerItemVariant
                                FaceValuePerNode<const TinyVector<1, double>>,
                                FaceValuePerNode<const TinyVector<2, double>>,
                                FaceValuePerNode<const TinyVector<3, double>>,
+                               FaceValuePerNode<const TinyMatrix<1, 1, double>>,
+                               FaceValuePerNode<const TinyMatrix<2, 2, double>>,
+                               FaceValuePerNode<const TinyMatrix<3, 3, double>>,
 
                                FaceValuePerEdge<const bool>,
                                FaceValuePerEdge<const long int>,
@@ -72,6 +93,9 @@ class SubItemValuePerItemVariant
                                FaceValuePerEdge<const TinyVector<1, double>>,
                                FaceValuePerEdge<const TinyVector<2, double>>,
                                FaceValuePerEdge<const TinyVector<3, double>>,
+                               FaceValuePerEdge<const TinyMatrix<1, 1, double>>,
+                               FaceValuePerEdge<const TinyMatrix<2, 2, double>>,
+                               FaceValuePerEdge<const TinyMatrix<3, 3, double>>,
 
                                FaceValuePerCell<const bool>,
                                FaceValuePerCell<const long int>,
@@ -80,6 +104,9 @@ class SubItemValuePerItemVariant
                                FaceValuePerCell<const TinyVector<1, double>>,
                                FaceValuePerCell<const TinyVector<2, double>>,
                                FaceValuePerCell<const TinyVector<3, double>>,
+                               FaceValuePerCell<const TinyMatrix<1, 1, double>>,
+                               FaceValuePerCell<const TinyMatrix<2, 2, double>>,
+                               FaceValuePerCell<const TinyMatrix<3, 3, double>>,
 
                                CellValuePerNode<const bool>,
                                CellValuePerNode<const long int>,
@@ -88,6 +115,9 @@ class SubItemValuePerItemVariant
                                CellValuePerNode<const TinyVector<1, double>>,
                                CellValuePerNode<const TinyVector<2, double>>,
                                CellValuePerNode<const TinyVector<3, double>>,
+                               CellValuePerNode<const TinyMatrix<1, 1, double>>,
+                               CellValuePerNode<const TinyMatrix<2, 2, double>>,
+                               CellValuePerNode<const TinyMatrix<3, 3, double>>,
 
                                CellValuePerEdge<const bool>,
                                CellValuePerEdge<const long int>,
@@ -96,6 +126,9 @@ class SubItemValuePerItemVariant
                                CellValuePerEdge<const TinyVector<1, double>>,
                                CellValuePerEdge<const TinyVector<2, double>>,
                                CellValuePerEdge<const TinyVector<3, double>>,
+                               CellValuePerEdge<const TinyMatrix<1, 1, double>>,
+                               CellValuePerEdge<const TinyMatrix<2, 2, double>>,
+                               CellValuePerEdge<const TinyMatrix<3, 3, double>>,
 
                                CellValuePerFace<const bool>,
                                CellValuePerFace<const long int>,
@@ -103,7 +136,10 @@ class SubItemValuePerItemVariant
                                CellValuePerFace<const double>,
                                CellValuePerFace<const TinyVector<1, double>>,
                                CellValuePerFace<const TinyVector<2, double>>,
-                               CellValuePerFace<const TinyVector<3, double>>>;
+                               CellValuePerFace<const TinyVector<3, double>>,
+                               CellValuePerFace<const TinyMatrix<1, 1, double>>,
+                               CellValuePerFace<const TinyMatrix<2, 2, double>>,
+                               CellValuePerFace<const TinyMatrix<3, 3, double>>>;
 
   Variant m_sub_item_value_per_item;
 
@@ -140,13 +176,16 @@ class SubItemValuePerItemVariant
   SubItemValuePerItemVariant(const SubItemValuePerItem<DataType, ItemOfItemTypeT>& sub_item_value_per_item)
     : m_sub_item_value_per_item{SubItemValuePerItem<const DataType, ItemOfItemTypeT>{sub_item_value_per_item}}
   {
-    static_assert(std::is_same_v<std::remove_const_t<DataType>, bool> or                      //
-                    std::is_same_v<std::remove_const_t<DataType>, long int> or                //
-                    std::is_same_v<std::remove_const_t<DataType>, unsigned long int> or       //
-                    std::is_same_v<std::remove_const_t<DataType>, double> or                  //
-                    std::is_same_v<std::remove_const_t<DataType>, TinyVector<1, double>> or   //
-                    std::is_same_v<std::remove_const_t<DataType>, TinyVector<2, double>> or   //
-                    std::is_same_v<std::remove_const_t<DataType>, TinyVector<3, double>>,
+    static_assert(std::is_same_v<std::remove_const_t<DataType>, bool> or                         //
+                    std::is_same_v<std::remove_const_t<DataType>, long int> or                   //
+                    std::is_same_v<std::remove_const_t<DataType>, unsigned long int> or          //
+                    std::is_same_v<std::remove_const_t<DataType>, double> or                     //
+                    std::is_same_v<std::remove_const_t<DataType>, TinyVector<1, double>> or      //
+                    std::is_same_v<std::remove_const_t<DataType>, TinyVector<2, double>> or      //
+                    std::is_same_v<std::remove_const_t<DataType>, TinyVector<3, double>> or      //
+                    std::is_same_v<std::remove_const_t<DataType>, TinyMatrix<1, 1, double>> or   //
+                    std::is_same_v<std::remove_const_t<DataType>, TinyMatrix<2, 2, double>> or   //
+                    std::is_same_v<std::remove_const_t<DataType>, TinyMatrix<3, 3, double>>,
                   "SubItemValuePerItem with this DataType is not allowed in variant");
   }
 
diff --git a/tests/test_SubItemValuePerItemVariant.cpp b/tests/test_SubItemValuePerItemVariant.cpp
index d37e9ab403421c7f706583537b4ca724f25f4774..d36be5e42b7644f4bfd1abdcfb0c763d8e24029c 100644
--- a/tests/test_SubItemValuePerItemVariant.cpp
+++ b/tests/test_SubItemValuePerItemVariant.cpp
@@ -15,9 +15,12 @@ TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
 
   const Connectivity<3>& connectivity = *mesh->shared_connectivity();
 
-  using R1 = TinyVector<1>;
-  using R2 = TinyVector<2>;
-  using R3 = TinyVector<3>;
+  using R1   = TinyVector<1>;
+  using R2   = TinyVector<2>;
+  using R3   = TinyVector<3>;
+  using R1x1 = TinyMatrix<1>;
+  using R2x2 = TinyMatrix<2>;
+  using R3x3 = TinyMatrix<3>;
 
   SECTION("NodeValuePerCell<double>")
   {
@@ -29,6 +32,9 @@ TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
     REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
   SECTION("NodeValuePerFace<R1>")
@@ -41,6 +47,9 @@ TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
     REQUIRE_NOTHROW(v.get<NodeValuePerFace<const R1>>());
     REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<const R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<const R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<const R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<const R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<const R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
   SECTION("NodeValuePerEdge<int64_t>")
@@ -53,6 +62,9 @@ TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
     REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
   SECTION("EdgeValuePerCell<R2>")
@@ -65,6 +77,9 @@ TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
     REQUIRE_THROWS_WITH(v.get<EdgeValuePerCell<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_NOTHROW(v.get<EdgeValuePerCell<R2>>());
     REQUIRE_THROWS_WITH(v.get<EdgeValuePerCell<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<EdgeValuePerCell<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<EdgeValuePerCell<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<EdgeValuePerCell<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
   SECTION("EdgeValuePerFace<R1>")
@@ -77,6 +92,9 @@ TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
     REQUIRE_NOTHROW(v.get<EdgeValuePerFace<R1>>());
     REQUIRE_THROWS_WITH(v.get<EdgeValuePerFace<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<EdgeValuePerFace<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<EdgeValuePerFace<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<EdgeValuePerFace<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<EdgeValuePerFace<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
   SECTION("EdgeValuePerNode<double>")
@@ -89,54 +107,69 @@ TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
     REQUIRE_THROWS_WITH(v.get<EdgeValuePerNode<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<EdgeValuePerNode<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<EdgeValuePerNode<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<EdgeValuePerNode<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<EdgeValuePerNode<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<EdgeValuePerNode<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
-  SECTION("FaceValuePerCell<uint64_t>")
+  SECTION("FaceValuePerCell<R3x3>")
   {
-    FaceValuePerCell<uint64_t> node_value{connectivity};
+    FaceValuePerCell<R3x3> node_value{connectivity};
     SubItemValuePerItemVariant v(node_value);
     REQUIRE_THROWS_WITH(v.get<FaceValuePerCell<double>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerCell<int64_t>>(), "error: invalid SubItemValuePerItem type");
-    REQUIRE_NOTHROW(v.get<FaceValuePerCell<uint64_t>>());
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerCell<uint64_t>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerCell<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerCell<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerCell<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerCell<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerCell<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_NOTHROW(v.get<FaceValuePerCell<R3x3>>());
   }
 
-  SECTION("FaceValuePerEdge<double>")
+  SECTION("FaceValuePerEdge<R2x2>")
   {
-    FaceValuePerEdge<double> node_value{connectivity};
+    FaceValuePerEdge<R2x2> node_value{connectivity};
     SubItemValuePerItemVariant v(node_value);
-    REQUIRE_NOTHROW(v.get<FaceValuePerEdge<double>>());
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerEdge<double>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerEdge<int64_t>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerEdge<uint64_t>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerEdge<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerEdge<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerEdge<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerEdge<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_NOTHROW(v.get<FaceValuePerEdge<R2x2>>());
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerEdge<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
-  SECTION("FaceValuePerNode<double>")
+  SECTION("FaceValuePerNode<uint64_t>")
   {
-    FaceValuePerNode<double> node_value{connectivity};
+    FaceValuePerNode<uint64_t> node_value{connectivity};
     SubItemValuePerItemVariant v(node_value);
-    REQUIRE_NOTHROW(v.get<FaceValuePerNode<double>>());
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerNode<double>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerNode<int64_t>>(), "error: invalid SubItemValuePerItem type");
-    REQUIRE_THROWS_WITH(v.get<FaceValuePerNode<uint64_t>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_NOTHROW(v.get<FaceValuePerNode<uint64_t>>());
     REQUIRE_THROWS_WITH(v.get<FaceValuePerNode<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerNode<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<FaceValuePerNode<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerNode<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerNode<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<FaceValuePerNode<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
-  SECTION("NodeValuePerCell<double>")
+  SECTION("NodeValuePerCell<R1x1>")
   {
-    NodeValuePerCell<double> node_value{connectivity};
+    NodeValuePerCell<R1x1> node_value{connectivity};
     SubItemValuePerItemVariant v(node_value);
-    REQUIRE_NOTHROW(v.get<NodeValuePerCell<double>>());
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<double>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<int64_t>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<uint64_t>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_NOTHROW(v.get<NodeValuePerCell<R1x1>>());
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerCell<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
   SECTION("NodeValuePerFace<R3>")
@@ -149,6 +182,9 @@ TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
     REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_NOTHROW(v.get<NodeValuePerFace<R3>>());
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerFace<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 
   SECTION("NodeValuePerEdge<double>")
@@ -161,5 +197,8 @@ TEST_CASE("SubItemValuePerItemVariant", "[mesh]")
     REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R1>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R2>>(), "error: invalid SubItemValuePerItem type");
     REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R3>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R1x1>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R2x2>>(), "error: invalid SubItemValuePerItem type");
+    REQUIRE_THROWS_WITH(v.get<NodeValuePerEdge<R3x3>>(), "error: invalid SubItemValuePerItem type");
   }
 }