Add checkpoint/resume for INamedDiscreteData

src/utils/checkpointing/CheckpointUtils.cpp

@@ -434,6 +434,16 @@ writeIInterfaceDescriptor(const std::string& symbol_name,
   }
 }
 
+void writeItemArrayVariant(HighFive::Group& variable_group,
+                           std::shared_ptr<const ItemArrayVariant> item_array_variant_v,
+                           HighFive::File& file,
+                           HighFive::Group& checkpoint_group);
+
+void writeItemValueVariant(HighFive::Group& variable_group,
+                           std::shared_ptr<const ItemValueVariant> item_value_variant_v,
+                           HighFive::File& file,
+                           HighFive::Group& checkpoint_group);
+
 void
 writeINamedDiscreteData(const std::string& symbol_name,
                         const EmbeddedData& embedded_data,
@@ -465,15 +475,17 @@ writeINamedDiscreteData(const std::string& symbol_name,
   case INamedDiscreteData::Type::item_array: {
     const NamedItemArrayVariant& named_item_array_v = dynamic_cast<const NamedItemArrayVariant&>(inamed_discrete_data);
 
-    throw NotImplementedError("INamedDiscreteData::Type::item_array");
-#warning NOT IMPLEMENTED
+    HighFive::Group item_array_group = variable_group.createGroup("item_array_variant");
+
+    writeItemArrayVariant(item_array_group, named_item_array_v.itemArrayVariant(), file, checkpoint_group);
     break;
   }
   case INamedDiscreteData::Type::item_value: {
     const NamedItemValueVariant& named_item_value_v = dynamic_cast<const NamedItemValueVariant&>(inamed_discrete_data);
 
-    throw NotImplementedError("INamedDiscreteData::Type::item_value");
-#warning NOT IMPLEMENTED
+    HighFive::Group item_value_group = variable_group.createGroup("item_value_variant");
+
+    writeItemValueVariant(item_value_group, named_item_value_v.itemValueVariant(), file, checkpoint_group);
     break;
   }
   }

src/utils/checkpointing/ResumeUtils.cpp

@@ -15,6 +15,8 @@
 #include <mesh/NumberedInterfaceDescriptor.hpp>
 #include <mesh/NumberedZoneDescriptor.hpp>
 #include <output/NamedDiscreteFunction.hpp>
+#include <output/NamedItemArrayVariant.hpp>
+#include <output/NamedItemValueVariant.hpp>
 #include <scheme/AxisBoundaryConditionDescriptor.hpp>
 #include <scheme/DirichletBoundaryConditionDescriptor.hpp>
 #include <scheme/DiscreteFunctionDescriptorP0.hpp>
@@ -41,6 +43,8 @@
 #include <utils/checkpointing/QuadratureTypeHFType.hpp>
 #include <utils/checkpointing/ResumingData.hpp>
 
+std::shared_ptr<ItemArrayVariant> readItemArrayVariant(const HighFive::Group& item_array_variant_group);
+std::shared_ptr<ItemValueVariant> readItemValueVariant(const HighFive::Group& item_value_variant_group);
 std::shared_ptr<DiscreteFunctionVariant> readDiscreteFunctionVariant(const HighFive::Group& discrete_function_group);
 
 template <typename T, ItemType item_type>
@@ -238,11 +242,13 @@ readINamedDiscreteData(const std::string& symbol_name, const HighFive::Group& sy
     break;
   }
   case INamedDiscreteData::Type::item_array: {
-    throw NotImplementedError("readINamedDiscreteData");
+    HighFive::Group item_array_group = inamed_discrete_data_group.getGroup("item_array_variant");
+    inamed_discrete_data = std::make_shared<const NamedItemArrayVariant>(readItemArrayVariant(item_array_group), name);
     break;
   }
   case INamedDiscreteData::Type::item_value: {
-    throw NotImplementedError("readINamedDiscreteData");
+    HighFive::Group item_value_group = inamed_discrete_data_group.getGroup("item_value_variant");
+    inamed_discrete_data = std::make_shared<const NamedItemValueVariant>(readItemValueVariant(item_value_group), name);
     break;
   }
   }
@@ -279,7 +285,7 @@ readIQuadratureDescriptor(const std::string& symbol_name, const HighFive::Group&
 }
 
 template <ItemType item_type>
-EmbeddedData
+std::shared_ptr<ItemArrayVariant>
 readItemArrayVariant(const HighFive::Group& item_array_variant_group)
 {
   const std::string data_type  = item_array_variant_group.getAttribute("data_type").read<std::string>();
@@ -322,43 +328,43 @@ readItemArrayVariant(const HighFive::Group& item_array_variant_group)
   } else {
     throw UnexpectedError("unexpected discrete function data type: " + data_type);
   }
-  return {std::make_shared<DataHandler<const ItemArrayVariant>>(p_item_array)};
+  return p_item_array;
 }
 
-EmbeddedData
+std::shared_ptr<ItemArrayVariant>
 readItemArrayVariant(const HighFive::Group& item_array_variant_group)
 {
   const ItemType item_type = item_array_variant_group.getAttribute("item_type").read<ItemType>();
 
-  EmbeddedData embedded_data;
+  std::shared_ptr<ItemArrayVariant> p_item_array;
 
   switch (item_type) {
   case ItemType::cell: {
-    embedded_data = readItemArrayVariant<ItemType::cell>(item_array_variant_group);
+    p_item_array = readItemArrayVariant<ItemType::cell>(item_array_variant_group);
     break;
   }
   case ItemType::face: {
-    embedded_data = readItemArrayVariant<ItemType::face>(item_array_variant_group);
+    p_item_array = readItemArrayVariant<ItemType::face>(item_array_variant_group);
     break;
   }
   case ItemType::edge: {
-    embedded_data = readItemArrayVariant<ItemType::edge>(item_array_variant_group);
+    p_item_array = readItemArrayVariant<ItemType::edge>(item_array_variant_group);
     break;
   }
   case ItemType::node: {
-    embedded_data = readItemArrayVariant<ItemType::node>(item_array_variant_group);
+    p_item_array = readItemArrayVariant<ItemType::node>(item_array_variant_group);
     break;
   }
   }
 
-  return embedded_data;
+  return p_item_array;
 }
 
 EmbeddedData
 readItemArrayVariant(const std::string& symbol_name, const HighFive::Group& symbol_table_group)
 {
   const HighFive::Group item_array_variant_group = symbol_table_group.getGroup("embedded/" + symbol_name);
-  return readItemArrayVariant(item_array_variant_group);
+  return {std::make_shared<DataHandler<const ItemArrayVariant>>(readItemArrayVariant(item_array_variant_group))};
 }
 
 EmbeddedData
@@ -371,7 +377,7 @@ readItemType(const std::string& symbol_name, const HighFive::Group& symbol_table
 }
 
 template <ItemType item_type>
-EmbeddedData
+std::shared_ptr<ItemValueVariant>
 readItemValueVariant(const HighFive::Group& item_value_variant_group)
 {
   const std::string data_type  = item_value_variant_group.getAttribute("data_type").read<std::string>();
@@ -414,43 +420,43 @@ readItemValueVariant(const HighFive::Group& item_value_variant_group)
   } else {
     throw UnexpectedError("unexpected discrete function data type: " + data_type);
   }
-  return {std::make_shared<DataHandler<const ItemValueVariant>>(p_item_value)};
+  return p_item_value;
 }
 
-EmbeddedData
+std::shared_ptr<ItemValueVariant>
 readItemValueVariant(const HighFive::Group& item_value_variant_group)
 {
   const ItemType item_type = item_value_variant_group.getAttribute("item_type").read<ItemType>();
 
-  EmbeddedData embedded_data;
+  std::shared_ptr<ItemValueVariant> p_item_value;
 
   switch (item_type) {
   case ItemType::cell: {
-    embedded_data = readItemValueVariant<ItemType::cell>(item_value_variant_group);
+    p_item_value = readItemValueVariant<ItemType::cell>(item_value_variant_group);
     break;
   }
   case ItemType::face: {
-    embedded_data = readItemValueVariant<ItemType::face>(item_value_variant_group);
+    p_item_value = readItemValueVariant<ItemType::face>(item_value_variant_group);
     break;
   }
   case ItemType::edge: {
-    embedded_data = readItemValueVariant<ItemType::edge>(item_value_variant_group);
+    p_item_value = readItemValueVariant<ItemType::edge>(item_value_variant_group);
     break;
   }
   case ItemType::node: {
-    embedded_data = readItemValueVariant<ItemType::node>(item_value_variant_group);
+    p_item_value = readItemValueVariant<ItemType::node>(item_value_variant_group);
     break;
   }
   }
 
-  return embedded_data;
+  return p_item_value;
 }
 
 EmbeddedData
 readItemValueVariant(const std::string& symbol_name, const HighFive::Group& symbol_table_group)
 {
   const HighFive::Group item_value_variant_group = symbol_table_group.getGroup("embedded/" + symbol_name);
-  return readItemValueVariant(item_value_variant_group);
+  return {std::make_shared<DataHandler<const ItemValueVariant>>(readItemValueVariant(item_value_variant_group))};
 }
 
 EmbeddedData