diff --git a/src/language/modules/MeshModule.cpp b/src/language/modules/MeshModule.cpp
index e3464e3753b9c07380d5ee38679bc788502f79c4..395400f28ae73ee34af06c2769b414ebf93bdafa 100644
--- a/src/language/modules/MeshModule.cpp
+++ b/src/language/modules/MeshModule.cpp
@@ -364,4 +364,17 @@ MeshModule::registerCheckpointResume() const
}),
std::function([](const std::string& symbol_name, const HighFive::Group& symbol_table_group)
-> EmbeddedData { return readItemType(symbol_name, symbol_table_group); }));
+
+ CheckpointResumeRepository::instance()
+ .addCheckpointResume(ast_node_data_type_from<std::shared_ptr<const ItemValueVariant>>,
+ std::function([](const std::string& symbol_name, const EmbeddedData& embedded_data,
+ HighFive::File& file, HighFive::Group& checkpoint_group,
+ HighFive::Group& symbol_table_group) {
+ writeItemValueVariant(symbol_name, embedded_data, file, checkpoint_group,
+ symbol_table_group);
+ }),
+ std::function([](const std::string& symbol_name,
+ const HighFive::Group& symbol_table_group) -> EmbeddedData {
+ return readItemValueVariant(symbol_name, symbol_table_group);
+ }));
}
diff --git a/src/language/modules/WriterModule.cpp b/src/language/modules/WriterModule.cpp
index ad48be7f92fd73614af8d0ba7e21697729f07520..fbfcbfd62f6aec2213b0c005b6cc0f4f58412ce3 100644
--- a/src/language/modules/WriterModule.cpp
+++ b/src/language/modules/WriterModule.cpp
@@ -1,6 +1,9 @@
#include <language/modules/WriterModule.hpp>
+#include <language/modules/MeshModule.hpp>
+#include <language/modules/SchemeModule.hpp>
#include <language/utils/BuiltinFunctionEmbedder.hpp>
+#include <language/utils/CheckpointResumeRepository.hpp>
#include <language/utils/TypeDescriptor.hpp>
#include <mesh/Connectivity.hpp>
#include <mesh/GmshReader.hpp>
@@ -15,9 +18,8 @@
#include <output/NamedItemValueVariant.hpp>
#include <output/VTKWriter.hpp>
#include <scheme/DiscreteFunctionVariant.hpp>
-
-#include <language/modules/MeshModule.hpp>
-#include <language/modules/SchemeModule.hpp>
+#include <utils/checkpointing/CheckpointUtils.hpp>
+#include <utils/checkpointing/ResumeUtils.hpp>
WriterModule::WriterModule()
{
@@ -189,5 +191,16 @@ WriterModule::registerOperators() const
void
WriterModule::registerCheckpointResume() const
{
- throw NotImplementedError("registerCheckpointResume()");
+ CheckpointResumeRepository::instance()
+ .addCheckpointResume(ast_node_data_type_from<std::shared_ptr<const INamedDiscreteData>>,
+ std::function([](const std::string& symbol_name, const EmbeddedData& embedded_data,
+ HighFive::File& file, HighFive::Group& checkpoint_group,
+ HighFive::Group& symbol_table_group) {
+ writeINamedDiscreteData(symbol_name, embedded_data, file, checkpoint_group,
+ symbol_table_group);
+ }),
+ std::function([](const std::string& symbol_name,
+ const HighFive::Group& symbol_table_group) -> EmbeddedData {
+ return readINamedDiscreteData(symbol_name, symbol_table_group);
+ }));
}
diff --git a/src/utils/checkpointing/CheckpointUtils.cpp b/src/utils/checkpointing/CheckpointUtils.cpp
index 4d77a25fa58ec05042dd1892981b56a1b6510328..bb370b7fa7e7f84debbf3a730eaa0fb64ffe4e48 100644
--- a/src/utils/checkpointing/CheckpointUtils.cpp
+++ b/src/utils/checkpointing/CheckpointUtils.cpp
@@ -3,11 +3,13 @@
#include <analysis/IQuadratureDescriptor.hpp>
#include <language/modules/MeshModuleTypes.hpp>
#include <language/modules/SchemeModuleTypes.hpp>
+#include <language/modules/WriterModuleTypes.hpp>
#include <language/utils/ASTNodeDataTypeTraits.hpp>
#include <language/utils/DataHandler.hpp>
#include <language/utils/OFStream.hpp>
#include <language/utils/OStream.hpp>
#include <mesh/ItemType.hpp>
+#include <mesh/ItemValueVariant.hpp>
#include <mesh/Mesh.hpp>
#include <mesh/MeshVariant.hpp>
#include <mesh/NamedBoundaryDescriptor.hpp>
@@ -16,6 +18,10 @@
#include <mesh/NumberedBoundaryDescriptor.hpp>
#include <mesh/NumberedInterfaceDescriptor.hpp>
#include <mesh/NumberedZoneDescriptor.hpp>
+#include <output/INamedDiscreteData.hpp>
+#include <output/NamedDiscreteFunction.hpp>
+#include <output/NamedItemArrayVariant.hpp>
+#include <output/NamedItemValueVariant.hpp>
#include <scheme/DiscreteFunctionP0.hpp>
#include <scheme/DiscreteFunctionP0Vector.hpp>
#include <scheme/DiscreteFunctionVariant.hpp>
@@ -24,6 +30,7 @@
#include <utils/checkpointing/IBoundaryConditionDescriptorHFType.hpp>
#include <utils/checkpointing/IBoundaryDescriptorHFType.hpp>
#include <utils/checkpointing/IInterfaceDescriptorHFType.hpp>
+#include <utils/checkpointing/INamedDiscreteDataHF.hpp>
#include <utils/checkpointing/IZoneDescriptorHFType.hpp>
#include <utils/checkpointing/ItemTypeHFType.hpp>
#include <utils/checkpointing/OStreamTypeHFType.hpp>
@@ -41,6 +48,26 @@
#include <scheme/OutflowBoundaryConditionDescriptor.hpp>
#include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
+void writeMesh(std::shared_ptr<const MeshVariant> mesh_v, HighFive::File& file, HighFive::Group& checkpoint_group);
+
+template <typename DataType, ItemType item_type, typename ConnectivityPtr>
+void
+write(HighFive::Group& group,
+ const std::string& name,
+ const ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
+{
+ write(group, name, item_value.arrayView());
+}
+
+template <typename DataType, ItemType item_type, typename ConnectivityPtr>
+void
+write(HighFive::Group& group,
+ const std::string& name,
+ const ItemArray<DataType, item_type, ConnectivityPtr>& item_array)
+{
+ write(group, name, item_array.tableView());
+}
+
template <ItemType item_type, size_t Dimension>
void
writeRefItemList(const Connectivity<Dimension>& connectivity, HighFive::Group& connectivity_group)
@@ -157,6 +184,72 @@ writeConnectivity(const Connectivity<Dimension>& connectivity, HighFive::File& f
}
}
+void
+writeConnectivity(const IConnectivity& connectivity, HighFive::File& file, HighFive::Group& checkpoint_group)
+{
+ switch (connectivity.dimension()) {
+ case 1: {
+ writeConnectivity(dynamic_cast<const Connectivity<1>&>(connectivity), file, checkpoint_group);
+ break;
+ }
+ case 2: {
+ writeConnectivity(dynamic_cast<const Connectivity<2>&>(connectivity), file, checkpoint_group);
+ break;
+ }
+ case 3: {
+ writeConnectivity(dynamic_cast<const Connectivity<3>&>(connectivity), file, checkpoint_group);
+ break;
+ }
+ default: {
+ throw UnexpectedError("invalid connectivity dimension");
+ }
+ }
+}
+
+void
+writeDiscreteFunctionVariant(HighFive::Group& variable_group,
+ std::shared_ptr<const DiscreteFunctionVariant> discrete_function_v,
+ HighFive::File& file,
+ HighFive::Group& checkpoint_group)
+{
+ variable_group.createAttribute("type", dataTypeName(ast_node_data_type_from<decltype(discrete_function_v)>));
+
+ std::visit(
+ [&](auto&& discrete_function) {
+ auto mesh_v = discrete_function.meshVariant();
+ using DFType = std::decay_t<decltype(discrete_function)>;
+ variable_group.createAttribute("Vh_type", discrete_function.descriptor().type());
+
+ variable_group.createAttribute("mesh_id", mesh_v->id());
+ writeMesh(mesh_v, file, checkpoint_group);
+ if constexpr (is_discrete_function_P0_v<DFType>) {
+ using data_type = std::decay_t<typename DFType::data_type>;
+ variable_group.createAttribute("data_type", dataTypeName(ast_node_data_type_from<data_type>));
+ write(variable_group, "values", discrete_function.cellValues());
+ } else if constexpr (is_discrete_function_P0_vector_v<DFType>) {
+ using data_type = std::decay_t<typename DFType::data_type>;
+ variable_group.createAttribute("data_type", dataTypeName(ast_node_data_type_from<data_type>));
+ write(variable_group, "values", discrete_function.cellArrays());
+ }
+ },
+ discrete_function_v->discreteFunction());
+}
+
+void
+writeDiscreteFunctionVariant(const std::string& symbol_name,
+ const EmbeddedData& embedded_data,
+ HighFive::File& file,
+ HighFive::Group& checkpoint_group,
+ HighFive::Group& symbol_table_group)
+{
+ HighFive::Group variable_group = symbol_table_group.createGroup("embedded/" + symbol_name);
+
+ std::shared_ptr<const DiscreteFunctionVariant> discrete_function_p =
+ dynamic_cast<const DataHandler<const DiscreteFunctionVariant>&>(embedded_data.get()).data_ptr();
+
+ writeDiscreteFunctionVariant(variable_group, discrete_function_p, file, checkpoint_group);
+}
+
void
writeIBoundaryDescriptor(HighFive::Group& variable_group, const IBoundaryDescriptor& iboundary_descriptor)
{
@@ -340,6 +433,51 @@ writeIInterfaceDescriptor(const std::string& symbol_name,
}
}
+void
+writeINamedDiscreteData(const std::string& symbol_name,
+ const EmbeddedData& embedded_data,
+ HighFive::File& file,
+ HighFive::Group& checkpoint_group,
+ HighFive::Group& symbol_table_group)
+{
+ HighFive::Group variable_group = symbol_table_group.createGroup("embedded/" + symbol_name);
+
+ std::shared_ptr<const INamedDiscreteData> inamed_discrete_data_p =
+ dynamic_cast<const DataHandler<const INamedDiscreteData>&>(embedded_data.get()).data_ptr();
+
+ const INamedDiscreteData& inamed_discrete_data = *inamed_discrete_data_p;
+
+ variable_group.createAttribute("type", dataTypeName(ast_node_data_type_from<decltype(inamed_discrete_data_p)>));
+ variable_group.createAttribute("named_discrete_data_type", inamed_discrete_data.type());
+ variable_group.createAttribute("named_discrete_data_name", inamed_discrete_data.name());
+
+ switch (inamed_discrete_data.type()) {
+ case INamedDiscreteData::Type::discrete_function: {
+ const NamedDiscreteFunction& named_discrete_function =
+ dynamic_cast<const NamedDiscreteFunction&>(inamed_discrete_data);
+
+ HighFive::Group discrete_function_group = variable_group.createGroup("discrete_function_variant");
+ writeDiscreteFunctionVariant(discrete_function_group, named_discrete_function.discreteFunctionVariant(), file,
+ checkpoint_group);
+ break;
+ }
+ 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
+ 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
+ break;
+ }
+ }
+}
+
void
writeIQuadratureDescriptor(const std::string& symbol_name,
const EmbeddedData& embedded_data,
@@ -377,6 +515,46 @@ writeItemType(const std::string& symbol_name,
variable_group.createAttribute("item_type", item_type);
}
+void
+writeItemValueVariant(HighFive::Group& variable_group,
+ std::shared_ptr<const ItemValueVariant> item_value_variant_v,
+ HighFive::File& file,
+ HighFive::Group& checkpoint_group)
+{
+ variable_group.createAttribute("type", dataTypeName(ast_node_data_type_from<decltype(item_value_variant_v)>));
+
+ std::visit(
+ [&](auto&& item_value) {
+ using ItemValueT = std::decay_t<decltype(item_value)>;
+
+ variable_group.createAttribute("item_type", ItemValueT::item_t);
+ using data_type = std::decay_t<typename ItemValueT::data_type>;
+ variable_group.createAttribute("data_type", dataTypeName(ast_node_data_type_from<data_type>));
+
+ const IConnectivity& connectivity = *item_value.connectivity_ptr();
+ variable_group.createAttribute("connectivity_id", connectivity.id());
+ writeConnectivity(connectivity, file, checkpoint_group);
+
+ write(variable_group, "values", item_value);
+ },
+ item_value_variant_v->itemValue());
+}
+
+void
+writeItemValueVariant(const std::string& symbol_name,
+ const EmbeddedData& embedded_data,
+ HighFive::File& file,
+ HighFive::Group& checkpoint_group,
+ HighFive::Group& symbol_table_group)
+{
+ HighFive::Group variable_group = symbol_table_group.createGroup("embedded/" + symbol_name);
+
+ std::shared_ptr<const ItemValueVariant> item_value_variant_p =
+ dynamic_cast<const DataHandler<const ItemValueVariant>&>(embedded_data.get()).data_ptr();
+
+ writeItemValueVariant(variable_group, item_value_variant_p, file, checkpoint_group);
+}
+
void
writeIZoneDescriptor(const std::string& symbol_name,
const EmbeddedData& embedded_data,
@@ -470,41 +648,6 @@ writeMesh(const std::string& symbol_name,
writeMesh(mesh_v, file, checkpoint_group);
}
-void
-writeDiscreteFunctionVariant(const std::string& symbol_name,
- const EmbeddedData& embedded_data,
- HighFive::File& file,
- HighFive::Group& checkpoint_group,
- HighFive::Group& symbol_table_group)
-{
- HighFive::Group variable_group = symbol_table_group.createGroup("embedded/" + symbol_name);
-
- std::shared_ptr<const DiscreteFunctionVariant> discrete_function_v =
- dynamic_cast<const DataHandler<const DiscreteFunctionVariant>&>(embedded_data.get()).data_ptr();
-
- variable_group.createAttribute("type", dataTypeName(ast_node_data_type_from<decltype(discrete_function_v)>));
-
- std::visit(
- [&](auto&& discrete_function) {
- auto mesh_v = discrete_function.meshVariant();
- using DFType = std::decay_t<decltype(discrete_function)>;
- variable_group.createAttribute("Vh_type", discrete_function.descriptor().type());
-
- variable_group.createAttribute("mesh_id", mesh_v->id());
- writeMesh(mesh_v, file, checkpoint_group);
- if constexpr (is_discrete_function_P0_v<DFType>) {
- using data_type = std::decay_t<typename DFType::data_type>;
- variable_group.createAttribute("data_type", dataTypeName(ast_node_data_type_from<data_type>));
- write(variable_group, "values", discrete_function.cellValues());
- } else if constexpr (is_discrete_function_P0_vector_v<DFType>) {
- using data_type = std::decay_t<typename DFType::data_type>;
- variable_group.createAttribute("data_type", dataTypeName(ast_node_data_type_from<data_type>));
- write(variable_group, "values", discrete_function.cellArrays());
- }
- },
- discrete_function_v->discreteFunction());
-}
-
void
writeOStream(const std::string& symbol_name,
const EmbeddedData& embedded_data,
diff --git a/src/utils/checkpointing/CheckpointUtils.hpp b/src/utils/checkpointing/CheckpointUtils.hpp
index 491d95386fa982c4f51c03e5160933f5fe3f8270..7edee7b2c6b361249da4946acc900f19fdbba12e 100644
--- a/src/utils/checkpointing/CheckpointUtils.hpp
+++ b/src/utils/checkpointing/CheckpointUtils.hpp
@@ -104,22 +104,14 @@ write(HighFive::Group& group, const std::string& name, const Table<DataType>& ta
}
template <typename DataType, ItemType item_type, typename ConnectivityPtr>
-PUGS_INLINE void
-write(HighFive::Group& group,
- const std::string& name,
- const ItemValue<DataType, item_type, ConnectivityPtr>& item_value)
-{
- write(group, name, item_value.arrayView());
-}
+void write(HighFive::Group& group,
+ const std::string& name,
+ const ItemValue<DataType, item_type, ConnectivityPtr>& item_value);
template <typename DataType, ItemType item_type, typename ConnectivityPtr>
-PUGS_INLINE void
-write(HighFive::Group& group,
- const std::string& name,
- const ItemArray<DataType, item_type, ConnectivityPtr>& item_array)
-{
- write(group, name, item_array.tableView());
-}
+void write(HighFive::Group& group,
+ const std::string& name,
+ const ItemArray<DataType, item_type, ConnectivityPtr>& item_array);
void writeDiscreteFunctionVariant(const std::string& symbol_name,
const EmbeddedData& embedded_data,
@@ -151,6 +143,12 @@ void writeIInterfaceDescriptor(const std::string& symbol_name,
HighFive::Group& checkpoint_group,
HighFive::Group& symbol_table_group);
+void writeINamedDiscreteData(const std::string& symbol_name,
+ const EmbeddedData& embedded_data,
+ HighFive::File& file,
+ HighFive::Group& checkpoint_group,
+ HighFive::Group& symbol_table_group);
+
void writeIQuadratureDescriptor(const std::string& symbol_name,
const EmbeddedData& embedded_data,
HighFive::File& file,
@@ -163,6 +161,12 @@ void writeItemType(const std::string& symbol_name,
HighFive::Group& checkpoint_group,
HighFive::Group& symbol_table_group);
+void writeItemValueVariant(const std::string& symbol_name,
+ const EmbeddedData& embedded_data,
+ HighFive::File& file,
+ HighFive::Group& checkpoint_group,
+ HighFive::Group& symbol_table_group);
+
void writeIZoneDescriptor(const std::string& symbol_name,
const EmbeddedData& embedded_data,
HighFive::File& file,
diff --git a/src/utils/checkpointing/INamedDiscreteDataHF.hpp b/src/utils/checkpointing/INamedDiscreteDataHF.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..9d775e5ea24e1f13fa7eb0afc6c4f600bd3390d7
--- /dev/null
+++ b/src/utils/checkpointing/INamedDiscreteDataHF.hpp
@@ -0,0 +1,16 @@
+#ifndef I_NAMED_DISCRETE_DATA_HF_HPP
+#define I_NAMED_DISCRETE_DATA_HF_HPP
+
+#include <output/INamedDiscreteData.hpp>
+#include <utils/checkpointing/CheckpointUtils.hpp>
+
+HighFive::EnumType<INamedDiscreteData::Type> PUGS_INLINE
+create_enum_i_named_discrete_data_type()
+{
+ return {{"discrete_function", INamedDiscreteData::Type::discrete_function},
+ {"item_array", INamedDiscreteData::Type::item_array},
+ {"item_value", INamedDiscreteData::Type::item_value}};
+}
+HIGHFIVE_REGISTER_TYPE(INamedDiscreteData::Type, create_enum_i_named_discrete_data_type);
+
+#endif // I_NAMED_DISCRETE_DATA_HF_HPP
diff --git a/src/utils/checkpointing/ResumeUtils.cpp b/src/utils/checkpointing/ResumeUtils.cpp
index 367372bd4ba3469847f6db88b60320279ee223d1..d0726277925055b4cb2a3a7268fab4e587095155 100644
--- a/src/utils/checkpointing/ResumeUtils.cpp
+++ b/src/utils/checkpointing/ResumeUtils.cpp
@@ -6,12 +6,14 @@
#include <language/utils/DataHandler.hpp>
#include <language/utils/OFStream.hpp>
#include <language/utils/SymbolTable.hpp>
+#include <mesh/ItemValueVariant.hpp>
#include <mesh/NamedBoundaryDescriptor.hpp>
#include <mesh/NamedInterfaceDescriptor.hpp>
#include <mesh/NamedZoneDescriptor.hpp>
#include <mesh/NumberedBoundaryDescriptor.hpp>
#include <mesh/NumberedInterfaceDescriptor.hpp>
#include <mesh/NumberedZoneDescriptor.hpp>
+#include <output/NamedDiscreteFunction.hpp>
#include <scheme/AxisBoundaryConditionDescriptor.hpp>
#include <scheme/DirichletBoundaryConditionDescriptor.hpp>
#include <scheme/DiscreteFunctionDescriptorP0.hpp>
@@ -31,12 +33,15 @@
#include <utils/checkpointing/IBoundaryConditionDescriptorHFType.hpp>
#include <utils/checkpointing/IBoundaryDescriptorHFType.hpp>
#include <utils/checkpointing/IInterfaceDescriptorHFType.hpp>
+#include <utils/checkpointing/INamedDiscreteDataHF.hpp>
#include <utils/checkpointing/IZoneDescriptorHFType.hpp>
#include <utils/checkpointing/ItemTypeHFType.hpp>
#include <utils/checkpointing/OStreamTypeHFType.hpp>
#include <utils/checkpointing/QuadratureTypeHFType.hpp>
#include <utils/checkpointing/ResumingData.hpp>
+std::shared_ptr<DiscreteFunctionVariant> readDiscreteFunctionVariant(const HighFive::Group& discrete_function_group);
+
template <typename T, ItemType item_type>
ItemValue<T, item_type>
readItemValue(const HighFive::Group& group, const std::string& name, const IConnectivity& connectivity)
@@ -212,6 +217,38 @@ readIInterfaceDescriptor(const std::string& symbol_name, const HighFive::Group&
return {std::make_shared<DataHandler<const IInterfaceDescriptor>>(iinterface_descriptor)};
}
+EmbeddedData
+readINamedDiscreteData(const std::string& symbol_name, const HighFive::Group& symbol_table_group)
+{
+ const HighFive::Group inamed_discrete_data_group = symbol_table_group.getGroup("embedded/" + symbol_name);
+
+ const INamedDiscreteData::Type& type =
+ inamed_discrete_data_group.getAttribute("named_discrete_data_type").read<INamedDiscreteData::Type>();
+
+ const std::string name = inamed_discrete_data_group.getAttribute("named_discrete_data_name").read<std::string>();
+
+ std::shared_ptr<const INamedDiscreteData> inamed_discrete_data;
+
+ switch (type) {
+ case INamedDiscreteData::Type::discrete_function: {
+ HighFive::Group discrete_function_group = inamed_discrete_data_group.getGroup("discrete_function_variant");
+ inamed_discrete_data =
+ std::make_shared<const NamedDiscreteFunction>(readDiscreteFunctionVariant(discrete_function_group), name);
+ break;
+ }
+ case INamedDiscreteData::Type::item_array: {
+ throw NotImplementedError("readINamedDiscreteData");
+ break;
+ }
+ case INamedDiscreteData::Type::item_value: {
+ throw NotImplementedError("readINamedDiscreteData");
+ break;
+ }
+ }
+
+ return {std::make_shared<DataHandler<const INamedDiscreteData>>(inamed_discrete_data)};
+}
+
EmbeddedData
readIQuadratureDescriptor(const std::string& symbol_name, const HighFive::Group& symbol_table_group)
{
@@ -249,6 +286,89 @@ readItemType(const std::string& symbol_name, const HighFive::Group& symbol_table
return {std::make_shared<DataHandler<const ItemType>>(std::make_shared<const ItemType>(item_type))};
}
+template <ItemType item_type>
+EmbeddedData
+readItemValueVariant(const HighFive::Group& item_value_variant_group)
+{
+ const std::string data_type = item_value_variant_group.getAttribute("data_type").read<std::string>();
+ const size_t connectivity_id = item_value_variant_group.getAttribute("connectivity_id").read<size_t>();
+
+ const IConnectivity& connectivity = *ResumingData::instance().iConnectivity(connectivity_id);
+
+ std::shared_ptr<ItemValueVariant> p_item_value;
+
+ if (data_type == dataTypeName(ast_node_data_type_from<bool>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<bool, item_type>(item_value_variant_group, "values", connectivity));
+ } else if (data_type == dataTypeName(ast_node_data_type_from<long int>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<long int, item_type>(item_value_variant_group, "values", connectivity));
+ } else if (data_type == dataTypeName(ast_node_data_type_from<unsigned long int>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<unsigned long int, item_type>(item_value_variant_group, "values", connectivity));
+ } else if (data_type == dataTypeName(ast_node_data_type_from<double>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<double, item_type>(item_value_variant_group, "values", connectivity));
+ } else if (data_type == dataTypeName(ast_node_data_type_from<TinyVector<1>>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<TinyVector<1>, item_type>(item_value_variant_group, "values", connectivity));
+ } else if (data_type == dataTypeName(ast_node_data_type_from<TinyVector<2>>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<TinyVector<2>, item_type>(item_value_variant_group, "values", connectivity));
+ } else if (data_type == dataTypeName(ast_node_data_type_from<TinyVector<3>>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<TinyVector<3>, item_type>(item_value_variant_group, "values", connectivity));
+ } else if (data_type == dataTypeName(ast_node_data_type_from<TinyMatrix<1>>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<TinyMatrix<1>, item_type>(item_value_variant_group, "values", connectivity));
+ } else if (data_type == dataTypeName(ast_node_data_type_from<TinyMatrix<2>>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<TinyMatrix<2>, item_type>(item_value_variant_group, "values", connectivity));
+ } else if (data_type == dataTypeName(ast_node_data_type_from<TinyMatrix<3>>)) {
+ p_item_value = std::make_shared<ItemValueVariant>(
+ readItemValue<TinyMatrix<3>, item_type>(item_value_variant_group, "values", connectivity));
+ } else {
+ throw UnexpectedError("unexpected discrete function data type: " + data_type);
+ }
+ return {std::make_shared<DataHandler<const ItemValueVariant>>(p_item_value)};
+}
+
+EmbeddedData
+readItemValueVariant(const HighFive::Group& item_value_variant_group)
+{
+ const ItemType item_type = item_value_variant_group.getAttribute("item_type").read<ItemType>();
+
+ EmbeddedData embedded_data;
+
+ switch (item_type) {
+ case ItemType::cell: {
+ embedded_data = readItemValueVariant<ItemType::cell>(item_value_variant_group);
+ break;
+ }
+ case ItemType::face: {
+ embedded_data = readItemValueVariant<ItemType::face>(item_value_variant_group);
+ break;
+ }
+ case ItemType::edge: {
+ embedded_data = readItemValueVariant<ItemType::edge>(item_value_variant_group);
+ break;
+ }
+ case ItemType::node: {
+ embedded_data = readItemValueVariant<ItemType::node>(item_value_variant_group);
+ break;
+ }
+ }
+
+ return embedded_data;
+}
+
+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);
+}
+
EmbeddedData
readIZoneDescriptor(const std::string& symbol_name, const HighFive::Group& symbol_table_group)
{
@@ -284,10 +404,9 @@ readMesh(const std::string& symbol_name, const HighFive::Group& symbol_table_gro
return {std::make_shared<DataHandler<const MeshVariant>>(ResumingData::instance().meshVariant(mesh_id))};
}
-EmbeddedData
-readDiscreteFunctionVariant(const std::string& symbol_name, const HighFive::Group& symbol_table_group)
+std::shared_ptr<DiscreteFunctionVariant>
+readDiscreteFunctionVariant(const HighFive::Group& discrete_function_group)
{
- const HighFive::Group discrete_function_group = symbol_table_group.getGroup("embedded/" + symbol_name);
DiscreteFunctionType type = discrete_function_group.getAttribute("Vh_type").read<DiscreteFunctionType>();
size_t mesh_id = discrete_function_group.getAttribute("mesh_id").read<size_t>();
@@ -356,6 +475,16 @@ readDiscreteFunctionVariant(const std::string& symbol_name, const HighFive::Grou
break;
}
}
+ return p_discrete_function;
+}
+
+EmbeddedData
+readDiscreteFunctionVariant(const std::string& symbol_name, const HighFive::Group& symbol_table_group)
+{
+ const HighFive::Group discrete_function_group = symbol_table_group.getGroup("embedded/" + symbol_name);
+
+ std::shared_ptr<DiscreteFunctionVariant> p_discrete_function = readDiscreteFunctionVariant(discrete_function_group);
+
return {std::make_shared<DataHandler<const DiscreteFunctionVariant>>(p_discrete_function)};
}
diff --git a/src/utils/checkpointing/ResumeUtils.hpp b/src/utils/checkpointing/ResumeUtils.hpp
index 2e4fb05d62c47c9b7a0919904210dc1dcc6a4f67..419751f5b03bfb5ff909da546838888cb777555d 100644
--- a/src/utils/checkpointing/ResumeUtils.hpp
+++ b/src/utils/checkpointing/ResumeUtils.hpp
@@ -87,8 +87,10 @@ EmbeddedData readIBoundaryConditionDescriptor(const std::string& symbol_name,
EmbeddedData readIBoundaryDescriptor(const std::string& symbol_name, const HighFive::Group& symbol_table_group);
EmbeddedData readIDiscreteFunctionDescriptor(const std::string& symbol_name, const HighFive::Group& symbol_table_group);
EmbeddedData readIInterfaceDescriptor(const std::string& symbol_name, const HighFive::Group& symbol_table_group);
+EmbeddedData readINamedDiscreteData(const std::string& symbol_name, const HighFive::Group& symbol_table_group);
EmbeddedData readIQuadratureDescriptor(const std::string& symbol_name, const HighFive::Group& symbol_table_group);
EmbeddedData readItemType(const std::string& symbol_name, const HighFive::Group& symbol_table_group);
+EmbeddedData readItemValueVariant(const std::string& symbol_name, const HighFive::Group& symbol_table_group);
EmbeddedData readIZoneDescriptor(const std::string& symbol_name, const HighFive::Group& symbol_table_group);
EmbeddedData readMesh(const std::string& symbol_name, const HighFive::Group& symbol_table_group);
EmbeddedData readOStream(const std::string& symbol_name, const HighFive::Group& symbol_table_group);