OGS
Namespaces | Classes | Typedefs | Functions | Variables
MeshLib::IO Namespace Reference

Namespaces

namespace  Legacy
 

Classes

struct  FileCommunicator
 
struct  HdfData
 
class  HdfWriter
 
struct  MeshHdfData
 
struct  NodeData
 struct NodeData used for parallel reading and also partitioning More...
 
class  NodePartitionedMeshReader
 
struct  PartitionInfo
 
struct  PropertyVectorMetaData
 
struct  PropertyVectorPartitionMetaData
 
class  PVDFile
 
struct  TransformedMeshData
 
class  VtuInterface
 Reads and writes VtkXMLUnstructuredGrid-files (vtu) to and from OGS data structures. This class is currently not inherited from Writer because VTK will implement writing to a string from 6.2 onwards. More...
 
struct  XdmfData
 
struct  XdmfHdfData
 
struct  XdmfHdfMesh
 
class  XdmfHdfWriter
 
struct  XdmfTopology
 
class  XdmfWriter
 

Typedefs

using Hdf5DimType = hsize_t
 
using HDFAttributes = std::vector<HdfData>
 
using XdmfDimType = unsigned int
 

Functions

void writePropertyVectorMetaData (std::ostream &os, PropertyVectorMetaData const &pvmd)
 
void writePropertyVectorMetaData (PropertyVectorMetaData const &pvmd)
 
std::optional< PropertyVectorMetaData > readPropertyVectorMetaData (std::istream &is)
 
void writePropertyVectorPartitionMetaData (std::ostream &os, PropertyVectorPartitionMetaData const &pvpmd)
 
std::optional< PropertyVectorPartitionMetaData > readPropertyVectorPartitionMetaData (std::istream &is)
 
MeshLib::Mesh * readMeshFromFile (const std::string &file_name, bool const compute_element_neighbors)
 
std::string getVtuFileNameForPetscOutputWithoutExtension (std::string const &file_name)
 
int writeVtu (MeshLib::Mesh const &mesh, std::string const &file_name, int const data_mode)
 
int writeMeshToFile (const MeshLib::Mesh &mesh, std::filesystem::path const &file_path, std::set< std::string > variable_output_names)
 
int64_t createFile (std::filesystem::path const &filepath, unsigned int n_files)
 
int64_t openHDF5File (std::filesystem::path const &filepath, unsigned int n_files)
 
int64_t createHDF5TransferPolicy ()
 
static hid_t meshPropertyType2HdfType (MeshPropertyDataType const ogs_data_type)
 
std::filesystem::path partitionFilename (std::filesystem::path const &basic_filepath, int const file_group)
 
int getGroupIndex (int const input_index, int const input_size, int const new_group_size)
 
FileCommunicator getCommunicator (unsigned int const n_files)
 
bool isFileManager ()
 
PartitionInfo getPartitionInfo (std::size_t const size, unsigned int const n_files)
 
int64_t openHDF5File (std::filesystem::path const &filepath)
 
static constexpr auto elemOGSTypeToXDMFType ()
 
constexpr auto cellTypeOGS2XDMF (MeshLib::CellType const &cell_type)
 
std::optional< XdmfHdfData > transformAttribute (std::pair< std::string, PropertyVectorBase * > const &property_pair, unsigned int const n_files, unsigned int const chunk_size_bytes)
 
std::vector< XdmfHdfData > transformAttributes (MeshLib::Mesh const &mesh, unsigned int n_files, unsigned int chunk_size_bytes)
 Create meta data for attributes used for hdf5 and xdmf.
 
std::vector< double > transformToXDMFGeometry (MeshLib::Mesh const &mesh)
 Copies all node points into a new vector. Contiguous data used for writing. Conform with XDMF standard in https://xdmf.org/index.php/XDMF_Model_and_Format.
 
XdmfHdfData transformGeometry (MeshLib::Mesh const &mesh, double const *data_ptr, unsigned int n_files, unsigned int chunk_size_bytes)
 Create meta data for geometry used for hdf5 and xdmf.
 
ParentDataType getTopologyType (MeshLib::Mesh const &mesh)
 
std::pair< std::vector< std::size_t >, ParentDataType > transformToXDMFTopology (MeshLib::Mesh const &mesh, std::size_t const offset)
 Copies all cells into a new vector. Contiguous data used for writing. The topology is specific to xdmf because it contains the xdmf cell types!! See section topology in https://xdmf.org/index.php/XDMF_Model_and_Format.
 
XdmfHdfData transformTopology (std::vector< std::size_t > const &values, ParentDataType const parent_data_type, unsigned int n_files, unsigned int chunk_size_bytes)
 Create meta data for topology used for HDF5 and XDMF.
 
static std::string meshItemTypeString (std::optional< MeshItemType > const &item_type)
 
static auto meshPropertyDatatypeString ()
 
static std::string getPropertyDataTypeString (MeshPropertyDataType const &ogs_data_type)
 
static constexpr auto meshPropertyDatatypeSize ()
 
static std::string getPropertyDataTypeSize (MeshPropertyDataType const &ogs_data_type)
 
std::function< std::string(std::vector< double >)> write_xdmf (XdmfData const &geometry, XdmfData const &topology, std::vector< XdmfData > const &constant_attributes, std::vector< XdmfData > const &variable_attributes, std::string const &h5filename, std::string const &ogs_version, std::string const &mesh_name)
 Generator function that creates a function capturing the spatial data of a mesh Temporal data can later be passed as argument.
 
template<typename Data >
std::function< bool(Data)> isVariableAttribute (std::set< std::string > const &variable_output_names)
 

Variables

constexpr auto elem_type_ogs2xdmf = elemOGSTypeToXDMFType()
 
constexpr char const * mesh_item_type_strings []
 
auto ogs_to_xdmf_type_fn = meshPropertyDatatypeSize()
 

Typedef Documentation

◆ Hdf5DimType

using MeshLib::IO::Hdf5DimType = hsize_t

Definition at line 24 of file HdfData.h.

◆ HDFAttributes

using MeshLib::IO::HDFAttributes = std::vector<HdfData>

Definition at line 25 of file HdfWriter.h.

◆ XdmfDimType

using MeshLib::IO::XdmfDimType = unsigned int

Definition at line 27 of file XdmfData.h.

Function Documentation

◆ cellTypeOGS2XDMF()

auto MeshLib::IO::cellTypeOGS2XDMF ( MeshLib::CellType const & cell_type)
constexpr

Definition at line 84 of file transformData.cpp.

85{
86 return elem_type_ogs2xdmf[to_underlying(cell_type)];
87}
BaseLib::to_underlying
constexpr auto to_underlying(E e) noexcept
Converts an enumeration to its underlying type.
Definition cpp23.h:29
MeshLib::IO::elem_type_ogs2xdmf
constexpr auto elem_type_ogs2xdmf
Definition transformData.cpp:82

References elem_type_ogs2xdmf, and BaseLib::to_underlying().

Referenced by getTopologyType(), and transformToXDMFTopology().

◆ createFile()

int64_t MeshLib::IO::createFile ( std::filesystem::path const & filepath,
unsigned int n_files )

Definition at line 38 of file fileIO.cpp.

40{
41 auto const communicator = getCommunicator(n_files);
42 MPI_Comm const comm = communicator.mpi_communicator;
43 MPI_Info const info = MPI_INFO_NULL;
44 hid_t const plist_id = H5Pcreate(H5P_FILE_ACCESS);
45
46 H5Pset_fapl_mpio(plist_id, comm, info);
47 H5Pset_coll_metadata_write(plist_id, true);
48
49 std::filesystem::path const partition_filename =
50 partitionFilename(filepath, communicator.color);
51 hid_t file = H5Fcreate(partition_filename.string().c_str(), H5F_ACC_TRUNC,
52 H5P_DEFAULT, plist_id);
53 H5Pclose(plist_id);
54
55 return file;
56}
MeshLib::IO::partitionFilename
std::filesystem::path partitionFilename(std::filesystem::path const &basic_filepath, int const file_group)
Definition fileIO.cpp:24
MeshLib::IO::getCommunicator
FileCommunicator getCommunicator(unsigned int const n_files)
Definition getCommunicator.cpp:41

References getCommunicator(), and partitionFilename().

◆ createHDF5TransferPolicy()

int64_t MeshLib::IO::createHDF5TransferPolicy ( )

Definition at line 70 of file fileIO.cpp.

71{
72 // property list for collective dataset write
73 hid_t io_transfer_property = H5Pcreate(H5P_DATASET_XFER);
74 H5Pset_dxpl_mpio(io_transfer_property, H5FD_MPIO_COLLECTIVE);
75 return io_transfer_property;
76}

Referenced by writeDataSet().

◆ elemOGSTypeToXDMFType()

static constexpr auto MeshLib::IO::elemOGSTypeToXDMFType ( )
staticconstexpr

Definition at line 39 of file transformData.cpp.

40{
41 std::array<XdmfTopology, to_underlying(MeshLib::CellType::enum_length)>
42 elem_type{};
43 elem_type[to_underlying(MeshLib::CellType::POINT1)] = {
44 ParentDataType::POLYVERTEX, 1};
45 elem_type[to_underlying(MeshLib::CellType::LINE2)] = {
46 ParentDataType::POLYLINE, 2};
47 elem_type[to_underlying(MeshLib::CellType::LINE3)] = {
48 ParentDataType::EDGE_3, 3};
49 elem_type[to_underlying(MeshLib::CellType::TRI3)] = {
50 ParentDataType::TRIANGLE, 3};
51 elem_type[to_underlying(MeshLib::CellType::TRI6)] = {
52 ParentDataType::TRIANGLE_6, 6};
53 elem_type[to_underlying(MeshLib::CellType::QUAD4)] = {
54 ParentDataType::QUADRILATERAL, 4};
55 elem_type[to_underlying(MeshLib::CellType::QUAD8)] = {
56 ParentDataType::QUADRILATERAL_8, 8};
57 elem_type[to_underlying(MeshLib::CellType::QUAD9)] = {
58 ParentDataType::QUADRILATERAL_9, 9};
59 elem_type[to_underlying(MeshLib::CellType::TET4)] = {
60 ParentDataType::TETRAHEDRON, 4};
61 elem_type[to_underlying(MeshLib::CellType::TET10)] = {
62 ParentDataType::TETRAHEDRON_10, 10};
63 elem_type[to_underlying(MeshLib::CellType::HEX8)] = {
64 ParentDataType::HEXAHEDRON, 8};
65 elem_type[to_underlying(MeshLib::CellType::HEX20)] = {
66 ParentDataType::HEXAHEDRON_20, 20};
67 elem_type[to_underlying(MeshLib::CellType::HEX27)] = {
68 ParentDataType::HEXAHEDRON_27, 27};
69 elem_type[to_underlying(MeshLib::CellType::PRISM6)] = {
70 ParentDataType::WEDGE, 6}; // parallel triangle wedge
71 elem_type[to_underlying(MeshLib::CellType::PRISM15)] = {
72 ParentDataType::WEDGE_15, 15};
73 elem_type[to_underlying(MeshLib::CellType::PRISM18)] = {
74 ParentDataType::WEDGE_18, 18};
75 elem_type[to_underlying(MeshLib::CellType::PYRAMID5)] = {
76 ParentDataType::PYRAMID, 5};
77 elem_type[to_underlying(MeshLib::CellType::PYRAMID13)] = {
78 ParentDataType::PYRAMID_13, 13};
79 return elem_type;
80}

References EDGE_3, MeshLib::enum_length, MeshLib::HEX20, MeshLib::HEX27, MeshLib::HEX8, HEXAHEDRON, HEXAHEDRON_20, HEXAHEDRON_27, MeshLib::LINE2, MeshLib::LINE3, MeshLib::POINT1, POLYLINE, POLYVERTEX, MeshLib::PRISM15, MeshLib::PRISM18, MeshLib::PRISM6, PYRAMID, MeshLib::PYRAMID13, MeshLib::PYRAMID5, PYRAMID_13, MeshLib::QUAD4, MeshLib::QUAD8, MeshLib::QUAD9, QUADRILATERAL, QUADRILATERAL_8, QUADRILATERAL_9, MeshLib::TET10, MeshLib::TET4, TETRAHEDRON, TETRAHEDRON_10, BaseLib::to_underlying(), MeshLib::TRI3, MeshLib::TRI6, TRIANGLE, TRIANGLE_6, WEDGE, WEDGE_15, and WEDGE_18.

◆ getCommunicator()

FileCommunicator MeshLib::IO::getCommunicator ( unsigned int const n_files)

Definition at line 41 of file getCommunicator.cpp.

42{
43 int num_procs;
44 MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
45 int rank_id;
46 MPI_Comm_rank(MPI_COMM_WORLD, &rank_id);
47 int const file_group_id = getGroupIndex(rank_id, num_procs, n_files);
48 MPI_Comm new_communicator;
49 MPI_Comm_split(MPI_COMM_WORLD, file_group_id, rank_id, &new_communicator);
50 return FileCommunicator{std::move(new_communicator),
51 std::move(file_group_id), ""};
52}
MeshLib::IO::getGroupIndex
int getGroupIndex(int const input_index, int const input_size, int const new_group_size)
Definition getCommunicator.cpp:27

References getGroupIndex().

Referenced by createFile(), getPartitionInfo(), and openHDF5File().

◆ getGroupIndex()

int MeshLib::IO::getGroupIndex ( int const input_index,
int const input_size,
int const new_group_size )

Definition at line 27 of file getCommunicator.cpp.

29{
30 // A grouping algorithm that determines the number of groups and return the
31 // group idx of the specified input_index
32 assert(input_size >= new_group_size);
33 int const minimum_output_group_size =
34 std::lround(input_size / new_group_size);
35 int const maximum_output_group_size = (input_size % new_group_size)
36 ? minimum_output_group_size + 1
37 : minimum_output_group_size;
38 return std::lround(input_index / maximum_output_group_size);
39};

Referenced by getCommunicator().

◆ getPartitionInfo()

PartitionInfo MeshLib::IO::getPartitionInfo ( std::size_t const size,
unsigned int const n_files )

Definition at line 35 of file partition.cpp.

37{
38 BaseLib::MPI::Mpi const mpi{getCommunicator(n_files).mpi_communicator};
39
40 std::vector<std::size_t> const partition_sizes =
41 BaseLib::MPI::allgather(size, mpi);
42
43 // the first partition's offset is zero, offsets for subsequent
44 // partitions are the accumulated sum of all preceding size.
45 std::vector<std::size_t> const partition_offsets =
46 BaseLib::sizesToOffsets(partition_sizes);
47
48 // chunked
49 std::size_t longest_partition =
50 *max_element(partition_sizes.begin(), partition_sizes.end());
51
52 // local_offset, local_length, longest_local_length, global_length
53 return {partition_offsets[mpi.rank], size, longest_partition,
54 partition_offsets.back()};
55}
BaseLib::MPI::allgather
static std::vector< T > allgather(T const &value, Mpi const &mpi)
Definition MPI.h:100
BaseLib::sizesToOffsets
std::vector< ranges::range_value_t< R > > sizesToOffsets(R const &sizes)
Definition Algorithm.h:283

References BaseLib::MPI::allgather(), getCommunicator(), MeshLib::IO::FileCommunicator::mpi_communicator, and BaseLib::sizesToOffsets().

Referenced by MeshLib::IO::HdfData::HdfData().

◆ getPropertyDataTypeSize()

static std::string MeshLib::IO::getPropertyDataTypeSize ( MeshPropertyDataType const & ogs_data_type)
static

Definition at line 98 of file writeXdmf.cpp.

100{
101 return fmt::format("{}", ogs_to_xdmf_type_fn[to_underlying(ogs_data_type)]);
102}

References ogs_to_xdmf_type_fn, and BaseLib::to_underlying().

Referenced by write_xdmf().

◆ getPropertyDataTypeString()

static std::string MeshLib::IO::getPropertyDataTypeString ( MeshPropertyDataType const & ogs_data_type)
static

Definition at line 73 of file writeXdmf.cpp.

75{
76 return meshPropertyDatatypeString()[to_underlying(ogs_data_type)];
77}
MeshLib::IO::meshPropertyDatatypeString
static auto meshPropertyDatatypeString()
Definition writeXdmf.cpp:55

References meshPropertyDatatypeString(), and BaseLib::to_underlying().

Referenced by write_xdmf().

◆ getTopologyType()

ParentDataType MeshLib::IO::getTopologyType ( MeshLib::Mesh const & mesh)

Definition at line 322 of file transformData.cpp.

323{
324 auto const& elements = mesh.getElements();
325
326 if (elements.empty())
327 {
328 return ParentDataType::MIXED;
329 }
330 auto const ogs_cell_type = elements[0]->getCellType();
331
332 if (std::any_of(elements.begin(), elements.end(),
333 [&](auto const& cell)
334 { return cell->getCellType() != ogs_cell_type; }))
335 {
336 return ParentDataType::MIXED;
337 }
338
339 return cellTypeOGS2XDMF(ogs_cell_type).id;
340}

References cellTypeOGS2XDMF(), MeshLib::Mesh::getElements(), and MIXED.

Referenced by transformToXDMFTopology().

◆ getVtuFileNameForPetscOutputWithoutExtension()

std::string MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension ( std::string const & file_name)

Definition at line 122 of file VtuInterface.cpp.

124{
125 auto const file_name_extension = BaseLib::getFileExtension(file_name);
126 if (file_name_extension != ".vtu")
127 {
128 OGS_FATAL("Expected a .vtu file for petsc output.");
129 }
130
131 auto const file_name_base = boost::erase_last_copy(file_name, ".vtu");
132 auto basename = BaseLib::extractBaseName(file_name_base);
133
134 // Replace dots to underscores since the pvtu writing function drops all
135 // characters starting from a dot.
136 std::replace(basename.begin(), basename.end(), '.', '_');
137
138 // Restore the dirname if any.
139 auto const dirname = BaseLib::extractPath(file_name_base);
140 return BaseLib::joinPaths(dirname, basename);
141}
OGS_FATAL
#define OGS_FATAL(...)
Definition Error.h:26
BaseLib::getFileExtension
std::string getFileExtension(const std::string &path)
Definition FileTools.cpp:196
BaseLib::extractPath
std::string extractPath(std::string const &pathname)
Definition FileTools.cpp:206
BaseLib::joinPaths
std::string joinPaths(std::string const &pathA, std::string const &pathB)
Definition FileTools.cpp:211
BaseLib::extractBaseName
std::string extractBaseName(std::string const &pathname)
Definition FileTools.cpp:185

References BaseLib::extractBaseName(), BaseLib::extractPath(), BaseLib::getFileExtension(), BaseLib::joinPaths(), and OGS_FATAL.

Referenced by ApplicationsLib::TestDefinition::TestDefinition(), MeshLib::IO::PVDFile::addVTUFile(), and MeshLib::IO::VtuInterface::writeToFile().

◆ isFileManager()

bool MeshLib::IO::isFileManager ( )

Definition at line 28 of file partition.cpp.

29{
30 int mpi_rank;
31 MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
32 return mpi_rank == 0;
33}

Referenced by MeshLib::IO::XdmfHdfWriter::XdmfHdfWriter(), and MeshLib::IO::XdmfHdfWriter::writeStep().

◆ isVariableAttribute()

template<typename Data >
std::function< bool(Data)> MeshLib::IO::isVariableAttribute ( std::set< std::string > const & variable_output_names)

Definition at line 43 of file XdmfHdfWriter.cpp.

45{
46 if (variable_output_names.empty())
47 {
48 return [](Data const& data) -> bool
49 {
50 constexpr std::array constant_output_names{
51 "MaterialIDs"sv,
52 "topology"sv,
53 "geometry"sv,
54 "OGS_VERSION"sv,
55 MeshLib::getBulkIDString(MeshLib::MeshItemType::Node),
56 MeshLib::getBulkIDString(MeshLib::MeshItemType::Cell),
57 MeshLib::getBulkIDString(MeshLib::MeshItemType::Edge),
58 MeshLib::getBulkIDString(MeshLib::MeshItemType::Face)};
59 return !ranges::contains(constant_output_names, data.name);
60 };
61 }
62 return [&variable_output_names](Data const& data) -> bool
63 { return variable_output_names.contains(data.name); };
64}
MeshLib::getBulkIDString
constexpr std::string_view getBulkIDString(MeshItemType mesh_item_type)
Definition Properties.h:188

References MeshLib::Cell, MeshLib::Edge, MeshLib::Face, MeshLib::getBulkIDString(), and MeshLib::Node.

Referenced by MeshLib::IO::XdmfHdfWriter::XdmfHdfWriter().

◆ meshItemTypeString()

static std::string MeshLib::IO::meshItemTypeString ( std::optional< MeshItemType > const & item_type)
static

Definition at line 43 of file writeXdmf.cpp.

45{
46 if (item_type)
47 {
48 return mesh_item_type_strings[static_cast<int>(item_type.value())];
49 }
50 OGS_FATAL("Cannot convert an empty optional mesh item type.");
51}
MeshLib::IO::mesh_item_type_strings
constexpr char const * mesh_item_type_strings[]
Definition writeXdmf.cpp:39

References mesh_item_type_strings, and OGS_FATAL.

Referenced by write_xdmf().

◆ meshPropertyDatatypeSize()

static constexpr auto MeshLib::IO::meshPropertyDatatypeSize ( )
staticconstexpr

Definition at line 80 of file writeXdmf.cpp.

81{
82 std::array<int, to_underlying(MeshPropertyDataType::enum_length)>
83 property_sizes{};
84 property_sizes[to_underlying(MeshPropertyDataType::float64)] = 8;
85 property_sizes[to_underlying(MeshPropertyDataType::float32)] = 4,
86 property_sizes[to_underlying(MeshPropertyDataType::int32)] = 4,
87 property_sizes[to_underlying(MeshPropertyDataType::int64)] = 8,
88 property_sizes[to_underlying(MeshPropertyDataType::uint32)] = 4,
89 property_sizes[to_underlying(MeshPropertyDataType::uint64)] = 8,
90 property_sizes[to_underlying(MeshPropertyDataType::int8)] = 1,
91 property_sizes[to_underlying(MeshPropertyDataType::uint8)] = 1;
92 return property_sizes;
93}

References enum_length, float32, float64, int32, int64, int8, BaseLib::to_underlying(), uint32, uint64, and uint8.

◆ meshPropertyDatatypeString()

static auto MeshLib::IO::meshPropertyDatatypeString ( )
static

Definition at line 55 of file writeXdmf.cpp.

56{
57 std::array<std::string, to_underlying(MeshPropertyDataType::enum_length)>
58 ogs_to_xdmf_type = {};
59 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::float64)] = "Float";
60 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::float32)] = "Float";
61 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::int32)] = "Int";
62 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::int64)] = "Int";
63 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::uint32)] = "UInt";
64 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::uint64)] = "UInt";
65 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::int8)] = "Int";
66 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::uint8)] = "UInt";
67 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::char_native)] = "Char";
68 ogs_to_xdmf_type[to_underlying(MeshPropertyDataType::uchar)] = "UChar";
69 return ogs_to_xdmf_type;
70}

References char_native, enum_length, float32, float64, int32, int64, int8, BaseLib::to_underlying(), uchar, uint32, uint64, and uint8.

Referenced by getPropertyDataTypeString().

◆ meshPropertyType2HdfType()

static hid_t MeshLib::IO::meshPropertyType2HdfType ( MeshPropertyDataType const ogs_data_type)
static

Definition at line 22 of file HdfData.cpp.

23{
24 std::map<MeshPropertyDataType const, hid_t> ogs_to_hdf_type = {
25 {MeshPropertyDataType::float64, H5T_NATIVE_DOUBLE},
26 {MeshPropertyDataType::float32, H5T_NATIVE_FLOAT},
27 {MeshPropertyDataType::int32, H5T_NATIVE_INT32},
28 {MeshPropertyDataType::int64, H5T_NATIVE_INT64},
29 {MeshPropertyDataType::uint32, H5T_NATIVE_UINT32},
30 {MeshPropertyDataType::uint64, H5T_NATIVE_UINT64},
31 {MeshPropertyDataType::int8, H5T_NATIVE_INT8},
32 {MeshPropertyDataType::uint8, H5T_NATIVE_UINT8},
33 {MeshPropertyDataType::char_native, H5T_NATIVE_CHAR},
34 {MeshPropertyDataType::uchar, H5T_NATIVE_UCHAR}};
35 try
36 {
37 return ogs_to_hdf_type.at(ogs_data_type);
38 }
39 catch (std::exception const& e)
40 {
41 OGS_FATAL("No known HDF5 type for OGS type. {:s}", e.what());
42 }
43}

References char_native, float32, float64, int32, int64, int8, OGS_FATAL, uchar, uint32, uint64, and uint8.

Referenced by MeshLib::IO::HdfData::HdfData().

◆ openHDF5File() [1/2]

int64_t MeshLib::IO::openHDF5File ( std::filesystem::path const & filepath)

Definition at line 25 of file fileIO.cpp.

26{
27 return H5Fopen(filepath.string().c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
28}

◆ openHDF5File() [2/2]

hid_t MeshLib::IO::openHDF5File ( std::filesystem::path const & filepath,
unsigned int n_files )

Definition at line 58 of file fileIO.cpp.

60{
61 MPI_Comm const comm = getCommunicator(n_files).mpi_communicator;
62 MPI_Info info = MPI_INFO_NULL;
63 hid_t const plist_id = H5Pcreate(H5P_FILE_ACCESS);
64 H5Pset_fapl_mpio(plist_id, comm, info);
65 hid_t file = H5Fopen(filepath.string().c_str(), H5F_ACC_RDWR, plist_id);
66 H5Pclose(plist_id);
67 return file;
68}

References getCommunicator(), and MeshLib::IO::FileCommunicator::mpi_communicator.

◆ partitionFilename()

std::filesystem::path MeshLib::IO::partitionFilename ( std::filesystem::path const & basic_filepath,
int const file_group )

Definition at line 24 of file fileIO.cpp.

26{
27 std::string const filename = (file_group > 0)
28 ? basic_filepath.stem().string() + '_' +
29 std::to_string(file_group) +
30 basic_filepath.extension().string()
31 : basic_filepath.filename().string();
32 std::filesystem::path const filepathwithextension =
33 basic_filepath.parent_path() / filename;
34 DBUG("HDF Filepath: {:s}.", filepathwithextension.string());
35 return filepathwithextension;
36};
DBUG
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:30

References DBUG().

Referenced by createFile().

◆ readMeshFromFile()

MeshLib::Mesh * MeshLib::IO::readMeshFromFile ( const std::string & file_name,
bool const compute_element_neighbors )

Definition at line 68 of file readMeshFromFile.cpp.

70{
71#ifdef USE_PETSC
72 BaseLib::MPI::Mpi mpi;
73 if (mpi.size > 1)
74 {
75 MeshLib::IO::NodePartitionedMeshReader read_pmesh(mpi.communicator);
76 const std::string file_name_base =
77 BaseLib::dropFileExtension(file_name);
78 return read_pmesh.read(file_name_base);
79 }
80 if (mpi.size == 1)
81 {
82 std::unique_ptr<Mesh> mesh{
83 readMeshFromFileSerial(file_name, compute_element_neighbors)};
84
85 if (!mesh)
86 {
87 return nullptr;
88 }
89
90 return new MeshLib::NodePartitionedMesh(*mesh);
91 }
92 return nullptr;
93#endif
94 return readMeshFromFileSerial(file_name, compute_element_neighbors);
95}
BaseLib::dropFileExtension
std::string dropFileExtension(std::string const &filename)
Definition FileTools.cpp:179
anonymous_namespace{readMeshFromFile.cpp}::readMeshFromFileSerial
MeshLib::Mesh * readMeshFromFileSerial(const std::string &file_name, bool const compute_element_neighbors)
Definition readMeshFromFile.cpp:37
BaseLib::MPI::Mpi::communicator
MPI_Comm communicator
Definition MPI.h:60

References BaseLib::MPI::Mpi::communicator, BaseLib::dropFileExtension(), MeshLib::IO::NodePartitionedMeshReader::read(), and BaseLib::MPI::Mpi::size.

Referenced by createGeometries(), FileIO::createSurface(), MainWindow::loadFile(), main(), main(), MainWindow::mapGeometry(), anonymous_namespace{postLIE.cpp}::postVTU(), FileIO::XmlPrjInterface::readFile(), readMeshes(), and anonymous_namespace{ProjectData.cpp}::readSingleMesh().

◆ readPropertyVectorMetaData()

std::optional< PropertyVectorMetaData > MeshLib::IO::readPropertyVectorMetaData ( std::istream & is)
inline

Definition at line 85 of file PropertyVectorMetaData.h.

87{
88 // read the size of the name of the PropertyVector
89 std::string::size_type s = 0;
90 if (!is.read(reinterpret_cast<char*>(&s), sizeof(std::string::size_type)))
91 {
92 return std::optional<PropertyVectorMetaData>();
93 }
94
95 PropertyVectorMetaData pvmd;
96 char *dummy = new char[s];
97 if (!is.read(dummy, s))
98 {
99 return std::nullopt;
100 }
101 pvmd.property_name = std::string(dummy, s);
102 delete [] dummy;
103
104 if(!is.read(reinterpret_cast<char*>(&pvmd.is_int_type), sizeof(bool)))
105 return std::nullopt;
106 if(!is.read(reinterpret_cast<char*>(&pvmd.is_data_type_signed), sizeof(bool)))
107 return std::nullopt;
108 if(!is.read(reinterpret_cast<char*>(&pvmd.data_type_size_in_bytes),
109 sizeof(unsigned long)))
110 return std::nullopt;
111 if(!is.read(reinterpret_cast<char*>(&pvmd.number_of_components),
112 sizeof(unsigned long)))
113 return std::nullopt;
114 if(!is.read(reinterpret_cast<char*>(&pvmd.number_of_tuples),
115 sizeof(unsigned long)))
116 return std::nullopt;
117 return std::optional<PropertyVectorMetaData>(pvmd);
118}

References MeshLib::IO::PropertyVectorMetaData::data_type_size_in_bytes, MeshLib::IO::PropertyVectorMetaData::is_data_type_signed, MeshLib::IO::PropertyVectorMetaData::is_int_type, MeshLib::IO::PropertyVectorMetaData::number_of_components, MeshLib::IO::PropertyVectorMetaData::number_of_tuples, and MeshLib::IO::PropertyVectorMetaData::property_name.

Referenced by MeshLib::IO::NodePartitionedMeshReader::readProperties().

◆ readPropertyVectorPartitionMetaData()

std::optional< PropertyVectorPartitionMetaData > MeshLib::IO::readPropertyVectorPartitionMetaData ( std::istream & is)
inline

Definition at line 140 of file PropertyVectorMetaData.h.

141{
142 PropertyVectorPartitionMetaData pvpmd;
143 if (!is.read(reinterpret_cast<char*>(&pvpmd.offset), sizeof(unsigned long)))
144 {
145 return std::optional<PropertyVectorPartitionMetaData>();
146 }
147 if (!is.read(reinterpret_cast<char*>(&pvpmd.number_of_tuples),
148 sizeof(unsigned long)))
149 {
150 return std::optional<PropertyVectorPartitionMetaData>();
151 }
152 return std::optional<PropertyVectorPartitionMetaData>(pvpmd);
153}

References MeshLib::IO::PropertyVectorPartitionMetaData::number_of_tuples, and MeshLib::IO::PropertyVectorPartitionMetaData::offset.

Referenced by MeshLib::IO::NodePartitionedMeshReader::readProperties().

◆ transformAttribute()

std::optional< XdmfHdfData > MeshLib::IO::transformAttribute ( std::pair< std::string, PropertyVectorBase * > const & property_pair,
unsigned int const n_files,
unsigned int const chunk_size_bytes )

Definition at line 89 of file transformData.cpp.

92{
93 // 3 data that will be captured and written by lambda f below
94 MeshPropertyDataType data_type = MeshPropertyDataType::unknown;
95 std::size_t num_of_tuples = 0;
96 void const* data_ptr = 0;
97
98 // lambda f : Collects properties from the PropertyVectorBase. It captures
99 // (and overwrites) data that can only be collected via the typed property.
100 // It has boolean return type to allow kind of pipe using || operator.
101 auto f = [&data_type, &num_of_tuples, &data_ptr,
102 &property_pair](auto basic_type) -> bool
103 {
104 auto const property_base = property_pair.second;
105 auto const typed_property =
106 dynamic_cast<PropertyVector<decltype(basic_type)> const*>(
107 property_base);
108 if (typed_property == nullptr)
109 {
110 return false;
111 }
112 // overwrite captured data
113 num_of_tuples = typed_property->getNumberOfTuples();
114 data_ptr = typed_property->data();
115
116 if constexpr (std::is_same_v<double, decltype(basic_type)>)
117 {
118 // The standard 64-bit IEEE 754 floating-point type
119 // (double-precision) has a 53 bit fractional part (52 bits written,
120 // one implied)
121 static_assert((std::numeric_limits<double>::digits == 53),
122 "Double has 52 bits fractional part");
123 data_type = MeshPropertyDataType::float64;
124 }
125 else if constexpr (std::is_same_v<float, decltype(basic_type)>)
126 {
127 // The standard 32-bit IEEE 754 floating-point type
128 // (single-precision) has a 24 bit fractional part (23 bits written,
129 // one implied)
130 static_assert((std::numeric_limits<float>::digits == 24),
131 "Float has 23 bits fractional part");
132 data_type = MeshPropertyDataType::float32;
133 }
134 else if constexpr (std::is_same_v<int32_t, decltype(basic_type)>)
135 {
136 data_type = MeshPropertyDataType::int32;
137 }
138 else if constexpr (std::is_same_v<uint32_t, decltype(basic_type)>)
139 {
140 data_type = MeshPropertyDataType::uint32;
141 }
142 else if constexpr (std::is_same_v<int64_t, decltype(basic_type)>)
143 {
144 data_type = MeshPropertyDataType::int64;
145 }
146 else if constexpr (std::is_same_v<uint64_t, decltype(basic_type)>)
147 {
148 data_type = MeshPropertyDataType::uint64;
149 }
150 else if constexpr (std::is_same_v<int8_t, decltype(basic_type)>)
151 {
152 data_type = MeshPropertyDataType::int8;
153 }
154 else if constexpr (std::is_same_v<uint8_t, decltype(basic_type)>)
155 {
156 data_type = MeshPropertyDataType::uint8;
157 }
158 else if constexpr (std::is_same_v<char, decltype(basic_type)>)
159 {
160 data_type = MeshPropertyDataType::char_native;
161 }
162 else if constexpr (std::is_same_v<unsigned char, decltype(basic_type)>)
163 {
164 static_assert((std::numeric_limits<unsigned char>::digits == 8),
165 "Unsigned char has 8 bits");
166 data_type = MeshPropertyDataType::uchar;
167 }
168 else if constexpr (std::is_same_v<unsigned long, decltype(basic_type)>)
169 {
170 if (sizeof(unsigned long) == 8 &&
171 std::numeric_limits<unsigned long>::digits == 64)
172 {
173 data_type = MeshPropertyDataType::uint64;
174 }
175 else if (sizeof(unsigned long) == 4 &&
176 std::numeric_limits<unsigned long>::digits == 32)
177 {
178 data_type = MeshPropertyDataType::uint32;
179 }
180 else
181 {
182 return false;
183 }
184 }
185 else if constexpr (std::is_same_v<std::size_t, decltype(basic_type)>)
186 {
187 if (sizeof(std::size_t) == 8 &&
188 std::numeric_limits<std::size_t>::digits == 64)
189 {
190 data_type = MeshPropertyDataType::uint64;
191 }
192 else if (sizeof(std::size_t) == 4 &&
193 std::numeric_limits<std::size_t>::digits == 32)
194 {
195 data_type = MeshPropertyDataType::uint32;
196 }
197 else
198 {
199 return false;
200 }
201 }
202 else
203 {
204 return false;
205 }
206 return true;
207 };
208
209 f(double{}) || f(float{}) || f(int{}) || f(long{}) || f(unsigned{}) ||
210 f(long{}) || f(static_cast<unsigned long>(0)) || f(std::size_t{}) ||
211 f(char{}) || f(static_cast<unsigned char>(0));
212
213 if (data_type == MeshPropertyDataType::unknown)
214 {
215 return std::nullopt;
216 }
217
218 auto const& property_base = property_pair.second;
219 auto const& global_components =
220 property_base->getNumberOfGlobalComponents();
221 // TODO (tm) property_pair vector::getNumberOfGlobalComponents should return
222 // unsigned value. Then explicit cast from signed to unsigned int and
223 // assert can be removed here. Implicit cast to long long is fine and
224 // can be kept
225 assert(global_components >= 0);
226 auto const ui_global_components =
227 static_cast<unsigned int>(global_components);
228
229 MeshLib::MeshItemType const mesh_item_type =
230 property_base->getMeshItemType();
231
232 std::string const& name = property_base->getPropertyName();
233
234 HdfData hdf = {data_ptr, num_of_tuples, ui_global_components, name,
235 data_type, n_files, chunk_size_bytes};
236
237 XdmfData xdmf{num_of_tuples, ui_global_components, data_type,
238 name, mesh_item_type, 0,
239 n_files, std::nullopt};
240
241 return XdmfHdfData{std::move(hdf), std::move(xdmf)};
242}
MeshPropertyDataType
MeshPropertyDataType
Definition MeshPropertyDataType.h:19
MeshLib::PropertyVector::getNumberOfTuples
std::size_t getNumberOfTuples() const
Definition PropertyVector.h:61
MeshLib::MeshItemType
MeshItemType
Definition Location.h:21

References char_native, float32, float64, MeshLib::PropertyVector< PROP_VAL_TYPE >::getNumberOfTuples(), int32, int64, int8, uchar, uint32, uint64, uint8, and unknown.

Referenced by transformAttributes().

◆ transformAttributes()

std::vector< XdmfHdfData > MeshLib::IO::transformAttributes ( MeshLib::Mesh const & mesh,
unsigned int n_files,
unsigned int chunk_size_bytes )

Create meta data for attributes used for hdf5 and xdmf.

Parameters
meshOGS mesh can be mesh or partitionedMesh
n_filesspecifies the number of files. If greater than 1 it groups the data of each process to n_files
chunk_size_bytesData will be split into chunks. The parameter specifies the size (in bytes) of the largest chunk.
Returns
vector of meta data

Definition at line 244 of file transformData.cpp.

247{
248 MeshLib::Properties const& properties = mesh.getProperties();
249
250 // \TODO (tm) use c++20 ranges
251 // a = p | filter (first!=OGS_VERSION) | filter null_opt | transformAttr |
252 std::vector<XdmfHdfData> attributes;
253 for (auto const& [name, property_base] : properties)
254 {
255 if (name == GitInfoLib::GitInfo::OGS_VERSION)
256 {
257 continue;
258 }
259
260 if (!property_base->is_for_output)
261 {
262 continue;
263 }
264
265 if (auto const attribute = transformAttribute(
266
267 std::pair(std::string(name), property_base), n_files,
268 chunk_size_bytes))
269
270 {
271 attributes.push_back(attribute.value());
272 }
273 else
274 {
275 WARN("Could not create attribute meta of {:s}.", name);
276 }
277 }
278 return attributes;
279}
WARN
void WARN(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:40
MeshLib::Properties
Property manager on mesh items. Class Properties manages scalar, vector or matrix properties....
Definition Properties.h:36
GitInfoLib::GitInfo::OGS_VERSION
const std::string OGS_VERSION
Definition GitInfo.cpp:20

References MeshLib::Mesh::getProperties(), GitInfoLib::GitInfo::OGS_VERSION, transformAttribute(), and WARN().

Referenced by MeshLib::IO::XdmfHdfWriter::XdmfHdfWriter().

◆ transformGeometry()

XdmfHdfData MeshLib::IO::transformGeometry ( MeshLib::Mesh const & mesh,
double const * data_ptr,
unsigned int n_files,
unsigned int chunk_size_bytes )

Create meta data for geometry used for hdf5 and xdmf.

Parameters
meshOGS mesh can be mesh or partitionedMesh
data_ptrMemory location of geometry values.
n_filesspecifies the number of files. If greater than 1 it groups the data of each process to n_files
chunk_size_bytesData will be split into chunks. The parameter specifies the size (in bytes) of the largest chunk.
Returns
Geometry meta data

Definition at line 297 of file transformData.cpp.

300{
301 std::string const name = "geometry";
302 std::vector<MeshLib::Node*> const& nodes = mesh.getNodes();
303
304 int const point_size = 3;
305 auto const& partition_dim = nodes.size();
306
307 HdfData const hdf = {data_ptr,
308 partition_dim,
309 point_size,
310 name,
311 MeshPropertyDataType::float64,
312 n_files,
313 chunk_size_bytes};
314 XdmfData const xdmf = {
315 partition_dim, point_size, MeshPropertyDataType::float64,
316 name, std::nullopt, 2,
317 n_files, std::nullopt};
318
319 return XdmfHdfData{std::move(hdf), std::move(xdmf)};
320}

References float64, and MeshLib::Mesh::getNodes().

Referenced by MeshLib::IO::XdmfHdfWriter::XdmfHdfWriter().

◆ transformTopology()

XdmfHdfData MeshLib::IO::transformTopology ( std::vector< std::size_t > const & values,
ParentDataType const parent_data_type,
unsigned int n_files,
unsigned int chunk_size_bytes )

Create meta data for topology used for HDF5 and XDMF.

Parameters
valuesactual topology values to get size and memory location
parent_data_typeXDMF topological element data types as listed in the enum ParentDataTypei
n_filesspecifies the number of files. If greater than 1 it groups the data of each process to n_files
chunk_size_bytesData will be split into chunks. The parameter specifies the size (in bytes) of the largest chunk.
Returns
Topology meta data

Definition at line 391 of file transformData.cpp.

395{
396 std::string const name = "topology";
397 auto const tuple_size = ParentDataType2String(parent_data_type).second;
398 HdfData const hdf = {values.data(),
399 values.size() / tuple_size,
400 tuple_size,
401 name,
402 MeshPropertyDataType::uint64,
403 n_files,
404 chunk_size_bytes};
405 XdmfData const xdmf{values.size() / tuple_size,
406 tuple_size,
407 MeshPropertyDataType::uint64,
408 name,
409 std::nullopt,
410 3,
411 n_files,
412 parent_data_type};
413
414 return XdmfHdfData{std::move(hdf), std::move(xdmf)};
415}
ParentDataType2String
std::pair< std::string, std::size_t > ParentDataType2String(ParentDataType p)
Definition MeshPropertyDataType.cpp:14

References ParentDataType2String(), and uint64.

Referenced by MeshLib::IO::XdmfHdfWriter::XdmfHdfWriter().

◆ transformToXDMFGeometry()

std::vector< double > MeshLib::IO::transformToXDMFGeometry ( MeshLib::Mesh const & mesh)

Copies all node points into a new vector. Contiguous data used for writing. Conform with XDMF standard in https://xdmf.org/index.php/XDMF_Model_and_Format.

Parameters
meshOGS mesh can be mesh or partitionedMesh
Returns
vector containing a copy of the data

Definition at line 281 of file transformData.cpp.

282{
283 std::vector<MeshLib::Node*> const& nodes = mesh.getNodes();
284
285 int const point_size = 3;
286 std::vector<double> values;
287 values.reserve(nodes.size() * point_size);
288 for (auto const& n : nodes)
289 {
290 const double* x = n->data();
291 values.insert(values.cend(), x, x + point_size);
292 }
293
294 return values;
295}

References MeshLib::Mesh::getNodes().

Referenced by MeshLib::IO::XdmfHdfWriter::XdmfHdfWriter().

◆ transformToXDMFTopology()

std::pair< std::vector< std::size_t >, ParentDataType > MeshLib::IO::transformToXDMFTopology ( MeshLib::Mesh const & mesh,
std::size_t const offset )

Copies all cells into a new vector. Contiguous data used for writing. The topology is specific to xdmf because it contains the xdmf cell types!! See section topology in https://xdmf.org/index.php/XDMF_Model_and_Format.

Parameters
meshOGS mesh can be mesh or partitionedMesh
offsetLocal offset to transform local to global cell ID. Offset must be zero in serial and must be defined for each process in parallel execution.
Returns
vector containing a copy of the data and the computed ParentDataType

Definition at line 342 of file transformData.cpp.

344{
345 std::vector<MeshLib::Element*> const& elements = mesh.getElements();
346 std::vector<std::size_t> values;
347
348 auto const push_cellnode_ids_to_vector =
349 [&values, &offset](auto const& cell)
350 {
351 values |= ranges::actions::push_back(
352 cell->nodes() | MeshLib::views::ids |
353 ranges::views::transform([&offset](auto const node_id)
354 { return node_id + offset; }));
355 };
356
357 auto const topology_type = getTopologyType(mesh);
358 if (topology_type == ParentDataType::MIXED)
359 {
360 values.reserve(elements.size() * 2); // each cell has at least two
361 // numbers
362 for (auto const& cell : elements)
363 {
364 auto const ogs_cell_type = cell->getCellType();
365 auto const xdmf_cell_id = cellTypeOGS2XDMF(ogs_cell_type).id;
366 values.push_back(to_underlying(xdmf_cell_id));
367 push_cellnode_ids_to_vector(cell);
368 }
369 }
370 else if (topology_type == ParentDataType::POLYLINE)
371 {
372 // '+ 1' for number of nodes of the cell
373 values.reserve(elements.size() * elements[0]->getNumberOfNodes());
374 for (auto const& cell : elements)
375 {
376 push_cellnode_ids_to_vector(cell);
377 }
378 }
379 else
380 {
381 values.reserve(elements.size() * elements[0]->getNumberOfNodes());
382 for (auto const& cell : elements)
383 {
384 push_cellnode_ids_to_vector(cell);
385 }
386 }
387
388 return {values, topology_type};
389}
MeshLib::views::ids
constexpr ranges::views::view_closure ids
For an element of a range view return its id.
Definition Mesh.h:225

References cellTypeOGS2XDMF(), MeshLib::Mesh::getElements(), getTopologyType(), MeshLib::views::ids, MIXED, POLYLINE, and BaseLib::to_underlying().

Referenced by MeshLib::IO::XdmfHdfWriter::XdmfHdfWriter().

◆ write_xdmf()

std::function< std::string(std::vector< double >)> MeshLib::IO::write_xdmf ( XdmfData const & geometry,
XdmfData const & topology,
std::vector< XdmfData > const & constant_attributes,
std::vector< XdmfData > const & variable_attributes,
std::string const & h5filename,
std::string const & ogs_version,
std::string const & mesh_name )

Generator function that creates a function capturing the spatial data of a mesh Temporal data can later be passed as argument.

Parameters
geometryMetadata for the geometry (points) of the mesh
topologyMetadata for the topology of the mesh
variable_attributesMeta data for attributes changing over time
constant_attributesMeta data for attributes NOT changing over time
h5filenameName of the file where the actual data was written
ogs_versionOGS Version to be added to XdmfInformation tag
mesh_nameName of the output mesh
Returns
unary function with vector of time step values, returning XDMF string

Definition at line 106 of file writeXdmf.cpp.

112{
113 // Generates function that writes <DataItem>. Late binding needed because
114 // maximum number of steps unknown. Time step and h5filename are captured to
115 // return a unary function
116 // _a suffix is a user defined literal for fmt named arguments
117 auto const time_dataitem_genfn =
118 [](unsigned long long const time_step, int const max_step,
119 std::string const& h5filename, std::string const& mesh_name)
120 {
121 return
122 [time_step, max_step, h5filename, mesh_name](auto const& xdmfdata)
123 {
124 return fmt::format(
125 fmt::runtime("\n\t\t<DataItem DataType=\"{datatype}\" "
126 "Dimensions=\"{local_dimensions}\" "
127 "Format=\"HDF\" "
128 "Precision=\"{precision}\">"
129 "{filename}:/meshes/{meshname}/{datasetname}|"
130 "{time_step} {starts}:1 {strides}:1 "
131 "{local_dimensions}:{max_step} "
132 "{global_dimensions}</"
133 "DataItem>"),
134 "datatype"_a = getPropertyDataTypeString(xdmfdata.data_type),
135 "local_dimensions"_a =
136 fmt::join(xdmfdata.global_block_dims, " "),
137 "precision"_a = getPropertyDataTypeSize(xdmfdata.data_type),
138 "filename"_a = h5filename,
139 "meshname"_a = mesh_name,
140 "datasetname"_a = xdmfdata.name,
141 "starts"_a = fmt::join(xdmfdata.starts, " "),
142 "strides"_a = fmt::join(xdmfdata.strides, " "),
143 "global_dimensions"_a =
144 fmt::join(xdmfdata.global_block_dims, " "),
145 "time_step"_a = fmt::format("{}", time_step),
146 "max_step"_a = fmt::format("{}", max_step));
147 };
148 };
149
150 // string_join could be moved to ogs lib if used more
151 auto const string_join_fn = [](auto const& collection)
152 { return fmt::to_string(fmt::join(collection, "")); };
153
154 // m_bind could be moved to ogs lib if used more
155 auto const m_bind_fn = [](auto const& transform, auto const& join)
156 {
157 return [join, transform](auto const& collection)
158 {
159 std::vector<std::string> temp;
160 temp.reserve(collection.size());
161 std::transform(collection.begin(), collection.end(),
162 std::back_inserter(temp), transform);
163 return join(temp);
164 };
165 };
166
167 // XDMF if part of the data that is already written in any previous step
168 // subsequent steps can refer to this data collection of elements navigates
169 // the xml tree (take first child, then in child take 2nd child ...)
170 auto const pointer_transfrom = [](auto const& elements)
171 {
172 return fmt::format(
173 fmt::runtime("\n\t<xi:include xpointer=\"element(/{elements})\"/>"),
174 "elements"_a = fmt::join(elements, "/"));
175 };
176
177 // Defines content of <Attribute> in XDMF, child of Attribute is a single
178 // <DataItem>
179 auto const attribute_transform =
180 [](XdmfData const& attribute, auto const& dataitem_transform)
181 {
182 return fmt::format(
183 "\n\t<Attribute Center=\"{center}\" ElementCell=\"\" "
184 "ElementDegree=\"0\" "
185 "ElementFamily=\"\" ItemType=\"\" Name=\"{name}\" "
186 "Type=\"None\">{dataitem}\n\t</Attribute>",
187 "center"_a = meshItemTypeString(attribute.attribute_center),
188 "name"_a = attribute.name,
189 "dataitem"_a = dataitem_transform(attribute));
190 };
191
192 // Define content of <Geometry> in XDMF, same as attribute_transform
193 auto const geometry_transform =
194 [](XdmfData const& geometry, auto const& dataitem_transform)
195 {
196 return fmt::format(
197 fmt::runtime("\n\t<Geometry Origin=\"\" "
198 "Type=\"XYZ\">{dataitem}\n\t</Geometry>"),
199 "dataitem"_a = dataitem_transform(geometry));
200 };
201
202 auto tag_string = [](auto const& topology, int nodes_per_element,
203 auto const& dataitem_transform)
204 {
205 return fmt::format(
206 fmt::runtime("\n\t<Topology Type=\"{topology_type}\" "
207 "NodesPerElement=\"{nodes_per_element}\" "
208 "NumberOfElements=\"{number_of_elements}\">{dataitem}"
209 "\n\t</Topology>"),
210 "topology_type"_a =
211 ParentDataType2String(*topology.parent_data_type).first,
212 "dataitem"_a = dataitem_transform(topology),
213 "nodes_per_element"_a = nodes_per_element,
214 "number_of_elements"_a = topology.size_partitioned_dim);
215 };
216
217 // Define content of <Topology> in XDMF, same as attribute_transform
218 auto const topology_transform =
219 [&tag_string](XdmfData const& topology, auto const& dataitem_transform)
220 {
221 switch (*topology.parent_data_type)
222 {
223 case ParentDataType::POLYVERTEX:
224 return tag_string(topology, 1, dataitem_transform);
225 case ParentDataType::POLYLINE:
226 return tag_string(topology, 2, dataitem_transform);
227 case ParentDataType::MIXED:
228 case ParentDataType::EDGE_3:
229 case ParentDataType::TRIANGLE:
230 case ParentDataType::TRIANGLE_6:
231 case ParentDataType::QUADRILATERAL:
232 case ParentDataType::QUADRILATERAL_8:
233 case ParentDataType::QUADRILATERAL_9:
234 case ParentDataType::TETRAHEDRON:
235 case ParentDataType::TETRAHEDRON_10:
236 case ParentDataType::HEXAHEDRON:
237 case ParentDataType::HEXAHEDRON_20:
238 case ParentDataType::HEXAHEDRON_27:
239 case ParentDataType::WEDGE:
240 case ParentDataType::WEDGE_15:
241 case ParentDataType::WEDGE_18:
242 case ParentDataType::PYRAMID:
243 case ParentDataType::PYRAMID_13:
244 return fmt::format(
245 fmt::runtime(
246 "\n\t<Topology "
247 "Type=\"{topology_type}\">{dataitem}\n\t</Topology>"),
248 "topology_type"_a =
249 ParentDataType2String(*topology.parent_data_type).first,
250 "dataitem"_a = dataitem_transform(topology));
251 }
252 OGS_FATAL("Could not transform unknown XDMF topology type");
253 return std::string{};
254 };
255
256 // Defines content of <Grid> of a single time step, takes specific transform
257 // functions for all of its child elements
258 auto const grid_transform =
259 [](double const& time_value, auto const& geometry, auto const& topology,
260 auto const& constant_attributes, auto const& variable_attributes)
261 {
262 return fmt::format(
263 R"(
264<Grid Name="Grid" GridType="Uniform">
265 <Time Value="{time_value:.{precision}g}"/>
266{geometry}
267{topology}
268{fix_attributes}
269{variable_attributes}
270</Grid>)",
271 "time_value"_a = time_value,
272 // Output of "Time Value" with sufficient precision.
273 "precision"_a = std::numeric_limits<double>::max_digits10,
274 "geometry"_a = geometry,
275 "topology"_a = topology,
276 "fix_attributes"_a = constant_attributes,
277 "variable_attributes"_a = variable_attributes);
278 };
279
280 // An attribute may change over time (variable) or stay constant
281 enum class time_attribute
282 {
283 constant,
284 variable
285 };
286
287 // Generates a function that either writes the data or points to existing
288 // data
289 auto const time_step_fn = [time_dataitem_genfn, pointer_transfrom,
290 h5filename,
291 mesh_name](auto const& component_transform,
292 unsigned long long const time_step,
293 int const max_step,
294 time_attribute const variable)
295 {
296 return [component_transform, time_dataitem_genfn, pointer_transfrom,
297 variable, time_step, max_step, h5filename,
298 mesh_name](XdmfData const& attr)
299 {
300 // new data arrived
301 bool const changed =
302 ((time_step > 0 && (variable == time_attribute::variable)) ||
303 time_step == 0);
304 if (changed)
305 {
306 auto dataitem = time_dataitem_genfn(time_step, max_step,
307 h5filename, mesh_name);
308 return component_transform(attr, dataitem);
309 }
310 else
311 {
312 std::array<unsigned int, 5> position = {1, 1, 2, 1, attr.index};
313 return pointer_transfrom(position);
314 };
315 };
316 };
317
318 // Top-Level transform function (take spatial and temporal transform
319 // functions) and return the time depended grid transform function
320 // ToDo (tm) Remove capturing m_bind and string_join as helper function
321
322 auto const time_grid_transform =
323 [time_step_fn, m_bind_fn, string_join_fn, grid_transform,
324 geometry_transform, topology_transform, attribute_transform](
325 double const time, int const step, int const max_step,
326 auto const& geometry, auto const& topology,
327 auto const& constant_attributes, auto const& variable_attributes)
328 {
329 auto const time_step_geometry_transform = time_step_fn(
330 geometry_transform, step, max_step, time_attribute::constant);
331 auto const time_step_topology_transform = time_step_fn(
332 topology_transform, step, max_step, time_attribute::constant);
333 auto const time_step_const_attribute_fn = time_step_fn(
334 attribute_transform, step, max_step, time_attribute::constant);
335 auto const time_step_variable_attribute_fn = time_step_fn(
336 attribute_transform, step, max_step, time_attribute::variable);
337
338 // lift both functions from handling single attributes to work with
339 // collection of attributes
340 auto const variable_attributes_transform =
341 m_bind_fn(time_step_variable_attribute_fn, string_join_fn);
342 auto const constant_attributes_transform =
343 m_bind_fn(time_step_const_attribute_fn, string_join_fn);
344
345 return grid_transform(
346 time, time_step_geometry_transform(geometry),
347 time_step_topology_transform(topology),
348 constant_attributes_transform(constant_attributes),
349 variable_attributes_transform(variable_attributes));
350 };
351
352 // Function that combines all the data from spatial (geometry, topology,
353 // attribute) and temporal domain (time) with the time domain
354 // (time_step_fn). And writes <Grid CollectionType="Temporal">
355 auto const temporal_grid_collection_transform =
356 [time_grid_transform](
357 auto const& times, auto const& geometry, auto const& topology,
358 auto const& constant_attributes, auto const& variable_attributes)
359 {
360 // c++20 ranges zip missing
361 auto const max_step = times.size();
362 std::vector<std::string> grids;
363 grids.reserve(max_step);
364 for (size_t time_step = 0; time_step < max_step; ++time_step)
365 {
366 grids.push_back(time_grid_transform(
367 times[time_step], time_step, max_step, geometry, topology,
368 constant_attributes, variable_attributes));
369 }
370 return fmt::format(
371 fmt::runtime(
372 "\n<Grid CollectionType=\"Temporal\" GridType=\"Collection\" "
373 "Name=\"Collection\">{grids}\n</Grid>\n"),
374 "grids"_a = fmt::join(grids, ""));
375 };
376
377 // Generator function that return a function that represents complete xdmf
378 // structure
379 auto const xdmf_writer_fn = [temporal_grid_collection_transform](
380 auto ogs_version, auto geometry,
381 auto topology, auto constant_attributes,
382 auto variable_attributes)
383 {
384 // This function will be the return of the surrounding named function
385 // capture by copy - it is the function that will survive this scope!!
386 // Use generalized lambda capture to move for optimization
387 return [temporal_grid_collection_transform,
388 ogs_version = std::move(ogs_version),
389 geometry = std::move(geometry), topology = std::move(topology),
390 constant_attributes = std::move(constant_attributes),
391 variable_attributes = std::move(variable_attributes)](
392 std::vector<double> const& times)
393 {
394 return fmt::format(
395 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Xdmf "
396 "xmlns:xi=\"http://www.w3.org/2001/XInclude\" "
397 "Version=\"3.0\">\n<Domain>\n<Information Name=\"OGS_VERSION\" "
398 "Value=\"{ogs_version}\"/>{grid_collection}</Domain>\n</Xdmf>",
399 "ogs_version"_a = ogs_version,
400 "grid_collection"_a = temporal_grid_collection_transform(
401 times, geometry, topology, constant_attributes,
GitInfoLib::GitInfo::ogs_version
GITINFOLIB_EXPORT const std::string ogs_version
MeshLib::IO::getPropertyDataTypeString
static std::string getPropertyDataTypeString(MeshPropertyDataType const &ogs_data_type)
Definition writeXdmf.cpp:73
MeshLib::IO::meshItemTypeString
static std::string meshItemTypeString(std::optional< MeshItemType > const &item_type)
Definition writeXdmf.cpp:43
MeshLib::IO::getPropertyDataTypeSize
static std::string getPropertyDataTypeSize(MeshPropertyDataType const &ogs_data_type)
Definition writeXdmf.cpp:98

References MeshLib::IO::XdmfData::attribute_center, EDGE_3, getPropertyDataTypeSize(), getPropertyDataTypeString(), HEXAHEDRON, HEXAHEDRON_20, HEXAHEDRON_27, meshItemTypeString(), MIXED, MeshLib::IO::XdmfData::name, OGS_FATAL, MeshLib::IO::XdmfData::parent_data_type, ParentDataType2String(), POLYLINE, POLYVERTEX, PYRAMID, PYRAMID_13, QUADRILATERAL, QUADRILATERAL_8, QUADRILATERAL_9, MeshLib::IO::XdmfData::size_partitioned_dim, TETRAHEDRON, TETRAHEDRON_10, TRIANGLE, TRIANGLE_6, WEDGE, WEDGE_15, and WEDGE_18.

Referenced by MeshLib::IO::XdmfHdfWriter::XdmfHdfWriter().

◆ writeMeshToFile()

int MeshLib::IO::writeMeshToFile ( const MeshLib::Mesh & mesh,
std::filesystem::path const & file_path,
std::set< std::string > variable_output_names )

Definition at line 24 of file writeMeshToFile.cpp.

28{
29 if (file_path.extension().string() == ".msh")
30 {
31 MeshLib::IO::Legacy::MeshIO meshIO;
32 meshIO.setMesh(&mesh);
33 BaseLib::IO::writeStringToFile(meshIO.writeToString(), file_path);
34 return 0;
35 }
36 if (file_path.extension().string() == ".vtu")
37 {
38 MeshLib::IO::VtuInterface writer(&mesh);
39 auto const result = writer.writeToFile(file_path);
40 if (!result)
41 {
42 ERR("writeMeshToFile(): Could not write mesh to '{:s}'.",
43 file_path.string());
44 return -1;
45 }
46 return 0;
47 }
48 if (file_path.extension().string() == ".xdmf")
49 {
50 std::vector<std::reference_wrapper<const MeshLib::Mesh>> meshes;
51 const std::reference_wrapper<const MeshLib::Mesh> mr = mesh;
52 meshes.push_back(mr);
53 MeshLib::IO::XdmfHdfWriter(std::move(meshes), file_path, 0, 0.0,
54 variable_output_names, true, 1, 1048576);
55 return 0;
56 }
57 ERR("writeMeshToFile(): Unknown file extension '{:s}'. Can not write file "
58 "'{:s}'.",
59 file_path.extension().string(), file_path.string());
60 return 0;
61}
ERR
void ERR(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:45
BaseLib::IO::Writer::writeToString
std::string writeToString()
Writes the object to a string.
Definition Writer.cpp:31
MeshLib::IO::Legacy::MeshIO
Interface for handling mesh files from OGS-5 and below. (*.msh files)
Definition MeshIO.h:37
MeshLib::IO::Legacy::MeshIO::setMesh
void setMesh(const MeshLib::Mesh *mesh)
Set mesh for writing.
Definition MeshIO.cpp:439
MeshLib::IO::VtuInterface
Reads and writes VtkXMLUnstructuredGrid-files (vtu) to and from OGS data structures....
Definition VtuInterface.h:38
BaseLib::IO::writeStringToFile
int writeStringToFile(std::string_view content, std::filesystem::path const &file_path)
Definition Writer.cpp:45

References ERR(), MeshLib::IO::Legacy::MeshIO::setMesh(), BaseLib::IO::writeStringToFile(), MeshLib::IO::VtuInterface::writeToFile(), and BaseLib::IO::Writer::writeToString().

Referenced by FileIO::Gocad::generateFaceSets(), identifyAndWriteBoundaryMeshes(), main(), main(), anonymous_namespace{postLIE.cpp}::postVTU(), and FileIO::XmlPrjInterface::write().

◆ writePropertyVectorMetaData() [1/2]

void MeshLib::IO::writePropertyVectorMetaData ( PropertyVectorMetaData const & pvmd)
inline

Definition at line 74 of file PropertyVectorMetaData.h.

75{
76 DBUG(
77 "name: '{:s}':\t is_int_data_type: {:d}, is_data_type_signed: "
78 "{:d}, data_type_size_in_bytes: {:d}, number of components / "
79 "tuples: {:d} / {:d}",
80 pvmd.property_name, pvmd.is_int_type, pvmd.is_data_type_signed,
81 pvmd.data_type_size_in_bytes, pvmd.number_of_components,
82 pvmd.number_of_tuples);
83}

References MeshLib::IO::PropertyVectorMetaData::data_type_size_in_bytes, DBUG(), MeshLib::IO::PropertyVectorMetaData::is_data_type_signed, MeshLib::IO::PropertyVectorMetaData::is_int_type, MeshLib::IO::PropertyVectorMetaData::number_of_components, MeshLib::IO::PropertyVectorMetaData::number_of_tuples, and MeshLib::IO::PropertyVectorMetaData::property_name.

◆ writePropertyVectorMetaData() [2/2]

void MeshLib::IO::writePropertyVectorMetaData ( std::ostream & os,
PropertyVectorMetaData const & pvmd )
inline

Definition at line 47 of file PropertyVectorMetaData.h.

49{
50 std::string::size_type s(pvmd.property_name.length());
51 os.write(reinterpret_cast<char*>(&s), sizeof(std::string::size_type));
52
53 os.write(
54 const_cast<char*>(
55 const_cast<PropertyVectorMetaData&>(pvmd).property_name.data()),
56 s);
57 os.write(reinterpret_cast<char*>(
58 &const_cast<PropertyVectorMetaData&>(pvmd).is_int_type),
59 sizeof(bool));
60 os.write(reinterpret_cast<char*>(&const_cast<PropertyVectorMetaData&>(
61 pvmd).is_data_type_signed),
62 sizeof(bool));
63 os.write(reinterpret_cast<char*>(&const_cast<PropertyVectorMetaData&>(
64 pvmd).data_type_size_in_bytes),
65 sizeof(unsigned long));
66 os.write(reinterpret_cast<char*>(&const_cast<PropertyVectorMetaData&>(
67 pvmd).number_of_components),
68 sizeof(unsigned long));
69 os.write(reinterpret_cast<char*>(
70 &const_cast<PropertyVectorMetaData&>(pvmd).number_of_tuples),
71 sizeof(unsigned long));
72}

References MeshLib::IO::PropertyVectorMetaData::property_name.

Referenced by MeshLib::IO::NodePartitionedMeshReader::readProperties(), and ApplicationUtils::writePropertyVector().

◆ writePropertyVectorPartitionMetaData()

void MeshLib::IO::writePropertyVectorPartitionMetaData ( std::ostream & os,
PropertyVectorPartitionMetaData const & pvpmd )
inline

Definition at line 126 of file PropertyVectorMetaData.h.

128{
129 os.write(reinterpret_cast<char*>(
130 &const_cast<PropertyVectorPartitionMetaData&>(pvpmd)
131 .offset),
132 sizeof(unsigned long));
133 os.write(reinterpret_cast<char*>(
134 &const_cast<PropertyVectorPartitionMetaData&>(pvpmd)
135 .number_of_tuples),
136 sizeof(unsigned long));
137}

Referenced by ApplicationUtils::writeProperties().

◆ writeVtu()

int MeshLib::IO::writeVtu ( MeshLib::Mesh const & mesh,
std::string const & file_name,
int const data_mode )

Definition at line 160 of file VtuInterface.cpp.

162{
163 MeshLib::IO::VtuInterface writer(&mesh, data_mode);
164 auto const result = writer.writeToFile(file_name);
165 if (!result)
166 {
167 ERR("writeMeshToFile(): Could not write mesh to '{:s}'.", file_name);
168 return -1;
169 }
170 return 0;
171}

References ERR(), and MeshLib::IO::VtuInterface::writeToFile().

Referenced by main().

Variable Documentation

◆ elem_type_ogs2xdmf

auto MeshLib::IO::elem_type_ogs2xdmf = elemOGSTypeToXDMFType()
constexpr

Definition at line 82 of file transformData.cpp.

Referenced by cellTypeOGS2XDMF().

◆ mesh_item_type_strings

char const* MeshLib::IO::mesh_item_type_strings[]
constexpr
Initial value:
= {"Node", "Edge", "Face",
"Cell", "Other"}

Definition at line 39 of file writeXdmf.cpp.

39 {"Node", "Edge", "Face",
40 "Cell", "Other"};

Referenced by meshItemTypeString().

◆ ogs_to_xdmf_type_fn

auto MeshLib::IO::ogs_to_xdmf_type_fn = meshPropertyDatatypeSize()
inline

Definition at line 95 of file writeXdmf.cpp.

Referenced by getPropertyDataTypeSize().