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.
 
std::vector< int > 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< int > const &values, 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()

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

Definition at line 67 of file transformData.cpp.

68{
69 return elem_type_ogs2xdmf[to_underlying(cell_type)];
70}
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:65

References elem_type_ogs2xdmf, and BaseLib::to_underlying().

Referenced by 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)] = {0x1, 1};
44 elem_type[to_underlying(MeshLib::CellType::LINE2)] = {0x2, 2};
45 elem_type[to_underlying(MeshLib::CellType::LINE3)] = {0x2, 3};
46 elem_type[to_underlying(MeshLib::CellType::TRI3)] = {0x4, 3};
47 elem_type[to_underlying(MeshLib::CellType::TRI6)] = {0x24, 6};
48 elem_type[to_underlying(MeshLib::CellType::QUAD4)] = {0x5, 4};
49 elem_type[to_underlying(MeshLib::CellType::QUAD8)] = {0x25, 8};
50 elem_type[to_underlying(MeshLib::CellType::QUAD9)] = {0x23, 9};
51 elem_type[to_underlying(MeshLib::CellType::TET4)] = {0x6, 4};
52 elem_type[to_underlying(MeshLib::CellType::TET10)] = {0x26, 10};
53 elem_type[to_underlying(MeshLib::CellType::HEX8)] = {0x9, 8};
54 elem_type[to_underlying(MeshLib::CellType::HEX20)] = {0x30, 20};
55 elem_type[to_underlying(MeshLib::CellType::HEX27)] = {0x32, 27};
56 elem_type[to_underlying(MeshLib::CellType::PRISM6)] = {
57 0x8, 6}; // parallel triangle wedge
58 elem_type[to_underlying(MeshLib::CellType::PRISM15)] = {0x28, 15};
59 elem_type[to_underlying(MeshLib::CellType::PRISM18)] = {0x29, 18};
60 elem_type[to_underlying(MeshLib::CellType::PYRAMID5)] = {0x7, 5};
61 elem_type[to_underlying(MeshLib::CellType::PYRAMID13)] = {0x27, 13};
62 return elem_type;
63}

References MeshLib::enum_length, MeshLib::HEX20, MeshLib::HEX27, MeshLib::HEX8, MeshLib::LINE2, MeshLib::LINE3, MeshLib::POINT1, MeshLib::PRISM15, MeshLib::PRISM18, MeshLib::PRISM6, MeshLib::PYRAMID13, MeshLib::PYRAMID5, MeshLib::QUAD4, MeshLib::QUAD8, MeshLib::QUAD9, MeshLib::TET10, MeshLib::TET4, BaseLib::to_underlying(), MeshLib::TRI3, and MeshLib::TRI6.

◆ 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 33 of file partition.cpp.

35{
36 MPI_Comm const mpi_comm = getCommunicator(n_files).mpi_communicator;
37 int mpi_size;
38 int mpi_rank;
39 MPI_Comm_size(mpi_comm, &mpi_size);
40 MPI_Comm_rank(mpi_comm, &mpi_rank);
41
42 std::vector<std::size_t> partition_sizes;
43 partition_sizes.resize(mpi_size);
44
45 MPI_Allgather(&size,
46 1,
47 MPI_UNSIGNED_LONG,
48 partition_sizes.data(),
49 1,
50 MPI_UNSIGNED_LONG,
51 mpi_comm);
52
53 // the first partition's offset is zero, offsets for subsequent
54 // partitions are the accumulated sum of all preceding size (excluding
55 // own size)
56 std::vector<std::size_t> partition_offsets(1, 0);
57 std::partial_sum(partition_sizes.begin(),
58 partition_sizes.end(),
59 back_inserter(partition_offsets));
60
61 // chunked
62 std::size_t longest_partition =
63 *max_element(partition_sizes.begin(), partition_sizes.end());
64
65 // local_offset, local_length, longest_local_length, global_length
66 return {partition_offsets[mpi_rank], size, longest_partition,
67 partition_offsets.back()};
68}

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

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().

◆ getVtuFileNameForPetscOutputWithoutExtension()

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

Definition at line 126 of file VtuInterface.cpp.

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

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 26 of file partition.cpp.

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

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 42 of file XdmfHdfWriter.cpp.

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

◆ 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 67 of file readMeshFromFile.cpp.

69{
70#ifdef USE_PETSC
71 int mpi_init;
72 MPI_Initialized(&mpi_init);
73 if (mpi_init == 1)
74 {
75 int world_size;
76 MPI_Comm_size(MPI_COMM_WORLD, &world_size);
77 if (world_size > 1)
78 {
79 MeshLib::IO::NodePartitionedMeshReader read_pmesh(MPI_COMM_WORLD);
80 const std::string file_name_base =
81 BaseLib::dropFileExtension(file_name);
82 return read_pmesh.read(file_name_base);
83 }
84 if (world_size == 1)
85 {
86 std::unique_ptr<Mesh> mesh{
87 readMeshFromFileSerial(file_name, compute_element_neighbors)};
88 return new MeshLib::NodePartitionedMesh(*mesh);
89 }
90 return nullptr;
91 }
92#endif
93 return readMeshFromFileSerial(file_name, compute_element_neighbors);
94}
BaseLib::dropFileExtension
std::string dropFileExtension(std::string const &filename)
Definition FileTools.cpp:176
anonymous_namespace{readMeshFromFile.cpp}::readMeshFromFileSerial
MeshLib::Mesh * readMeshFromFileSerial(const std::string &file_name, bool const compute_element_neighbors)
Definition readMeshFromFile.cpp:36

References BaseLib::dropFileExtension(), and MeshLib::IO::NodePartitionedMeshReader::read().

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 72 of file transformData.cpp.

75{
76 // 3 data that will be captured and written by lambda f below
77 MeshPropertyDataType data_type = MeshPropertyDataType::unknown;
78 std::size_t num_of_tuples = 0;
79 void const* data_ptr = 0;
80
81 // lambda f : Collects properties from the propertyVectorBase. It captures
82 // (and overwrites) data that can only be collected via the typed property.
83 // It has boolean return type to allow kind of pipe using || operator.
84 auto f = [&data_type, &num_of_tuples, &data_ptr,
85 &property_pair](auto basic_type) -> bool
86 {
87 auto const property_base = property_pair.second;
88 auto const typed_property =
89 dynamic_cast<PropertyVector<decltype(basic_type)> const*>(
90 property_base);
91 if (typed_property == nullptr)
92 {
93 return false;
94 }
95 // overwrite captured data
96 num_of_tuples = typed_property->getNumberOfTuples();
97 data_ptr = typed_property->data();
98
99 if constexpr (std::is_same_v<double, decltype(basic_type)>)
100 {
101 // The standard 64-bit IEEE 754 floating-point type
102 // (double-precision) has a 53 bit fractional part (52 bits written,
103 // one implied)
104 static_assert((std::numeric_limits<double>::digits == 53),
105 "Double has 52 bits fractional part");
106 data_type = MeshPropertyDataType::float64;
107 }
108 else if constexpr (std::is_same_v<float, decltype(basic_type)>)
109 {
110 // The standard 32-bit IEEE 754 floating-point type
111 // (single-precision) has a 24 bit fractional part (23 bits written,
112 // one implied)
113 static_assert((std::numeric_limits<float>::digits == 24),
114 "Float has 23 bits fractional part");
115 data_type = MeshPropertyDataType::float32;
116 }
117 else if constexpr (std::is_same_v<int, decltype(basic_type)>)
118 {
119 static_assert((std::numeric_limits<int>::digits == 31),
120 "Signed int has 32-1 bits");
121 data_type = MeshPropertyDataType::int32;
122 }
123 // ToDo (tm) These tests are platform specific and currently fail on
124 // Windows else if constexpr (std::is_same_v<long,
125 // decltype(basic_type)>)
126 //{
127 // static_assert((std::numeric_limits<long>::digits == 63),
128 // "Signed int has 64-1 bits");
129 // data_type = MeshPropertyDataType::int64;
130 //}
131 // else if constexpr (std::is_same_v<unsigned long,
132 // decltype(basic_type)>)
133 //{
134 // static_assert((std::numeric_limits<unsigned long>::digits == 64),
135 // "Unsigned long has 64 bits");
136 // data_type = MeshPropertyDataType::uint64;
137 //}
138 else if constexpr (std::is_same_v<unsigned int, decltype(basic_type)>)
139 {
140 static_assert((std::numeric_limits<unsigned int>::digits == 32),
141 "Unsigned int has 32 bits");
142 data_type = MeshPropertyDataType::uint32;
143 }
144 else if constexpr (std::is_same_v<std::size_t, decltype(basic_type)>)
145 {
146 static_assert((std::numeric_limits<std::size_t>::digits == 64),
147 "size_t has 64 bits");
148 data_type = MeshPropertyDataType::uint64;
149 }
150 else if constexpr (std::is_same_v<char, decltype(basic_type)>)
151 {
152 data_type = MeshPropertyDataType::char_native;
153 }
154 else if constexpr (std::is_same_v<unsigned char, decltype(basic_type)>)
155 {
156 static_assert((std::numeric_limits<unsigned char>::digits == 8),
157 "Unsigned char has 8 bits");
158 data_type = MeshPropertyDataType::uchar;
159 }
160 else
161 {
162 return false;
163 }
164 return true;
165 };
166
167 f(double{}) || f(float{}) || f(int{}) || f(long{}) || f(unsigned{}) ||
168 f(long{}) || f(static_cast<unsigned long>(0)) || f(std::size_t{}) ||
169 f(char{}) || f(static_cast<unsigned char>(0));
170
171 if (data_type == MeshPropertyDataType::unknown)
172 {
173 return std::nullopt;
174 }
175
176 auto const& property_base = property_pair.second;
177 auto const& global_components =
178 property_base->getNumberOfGlobalComponents();
179 // TODO (tm) property_pair vector::getNumberOfGlobalComponents should return
180 // unsigned value. Then explicit cast from signed to unsigned int and
181 // assert can be removed here. Implicit cast to long long is fine and
182 // can be kept
183 assert(global_components >= 0);
184 auto const ui_global_components =
185 static_cast<unsigned int>(global_components);
186
187 MeshLib::MeshItemType const mesh_item_type =
188 property_base->getMeshItemType();
189
190 std::string const& name = property_base->getPropertyName();
191
192 HdfData hdf = {data_ptr, num_of_tuples, ui_global_components, name,
193 data_type, n_files, chunk_size_bytes};
194
195 XdmfData xdmf = {num_of_tuples, ui_global_components, data_type,
196 name, mesh_item_type, 0,
197 n_files};
198
199 return XdmfHdfData{std::move(hdf), std::move(xdmf)};
200}
MeshPropertyDataType
MeshPropertyDataType
Definition MeshPropertyDataType.h:17
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, uchar, uint32, uint64, 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 202 of file transformData.cpp.

205{
206 MeshLib::Properties const& properties = mesh.getProperties();
207
208 // \TODO (tm) use c++20 ranges
209 // a = p | filter (first!=OGS_VERSION) | filter null_opt | transformAttr |
210 std::vector<XdmfHdfData> attributes;
211 for (auto const& [name, property_base] : properties)
212 {
213 if (name == GitInfoLib::GitInfo::OGS_VERSION)
214 {
215 continue;
216 }
217
218 if (!property_base->is_for_output)
219 {
220 continue;
221 }
222
223 if (auto const attribute = transformAttribute(
224
225 std::pair(std::string(name), property_base), n_files,
226 chunk_size_bytes))
227
228 {
229 attributes.push_back(attribute.value());
230 }
231 else
232 {
233 WARN("Could not create attribute meta of {:s}.", name);
234 }
235 }
236 return attributes;
237}
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 255 of file transformData.cpp.

258{
259 std::string const name = "geometry";
260 std::vector<MeshLib::Node*> const& nodes = mesh.getNodes();
261
262 int const point_size = 3;
263 auto const& partition_dim = nodes.size();
264
265 HdfData const hdf = {data_ptr,
266 partition_dim,
267 point_size,
268 name,
269 MeshPropertyDataType::float64,
270 n_files,
271 chunk_size_bytes};
272 XdmfData const xdmf = {
273 partition_dim, point_size, MeshPropertyDataType::float64,
274 name, std::nullopt, 2,
275 n_files};
276
277 return XdmfHdfData{std::move(hdf), std::move(xdmf)};
278}

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

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

◆ transformTopology()

XdmfHdfData MeshLib::IO::transformTopology ( std::vector< int > const & values,
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
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 307 of file transformData.cpp.

310{
311 std::string const name = "topology";
312 HdfData const hdf = {
313 values.data(), values.size(), 1, name, MeshPropertyDataType::int32,
314 n_files, chunk_size_bytes};
315 XdmfData const xdmf = {
316 values.size(), 1, MeshPropertyDataType::int32, name, std::nullopt, 3,
317 n_files};
318
319 return XdmfHdfData{std::move(hdf), std::move(xdmf)};
320}

References int32.

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 239 of file transformData.cpp.

240{
241 std::vector<MeshLib::Node*> const& nodes = mesh.getNodes();
242
243 int const point_size = 3;
244 std::vector<double> values;
245 values.reserve(nodes.size() * point_size);
246 for (auto const& n : nodes)
247 {
248 const double* x = n->data();
249 values.insert(values.cend(), x, x + point_size);
250 }
251
252 return values;
253}

References MeshLib::Mesh::getNodes().

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

◆ transformToXDMFTopology()

std::vector< int > 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

Definition at line 280 of file transformData.cpp.

282{
283 std::vector<MeshLib::Element*> const& elements = mesh.getElements();
284 std::vector<int> values;
285 values.reserve(elements.size());
286
287 for (auto const& cell : elements)
288 {
289 auto const ogs_cell_type = cell->getCellType();
290 auto const xdmf_cell_id = cellTypeOGS2XDMF(ogs_cell_type).id;
291 values.push_back(xdmf_cell_id);
292 if (ogs_cell_type == MeshLib::CellType::LINE2 ||
293 ogs_cell_type == MeshLib::CellType::LINE3)
294 {
295 values.push_back(cellTypeOGS2XDMF(ogs_cell_type).number_of_nodes);
296 }
297
298 for (std::size_t i = 0; i < cell->getNumberOfNodes(); ++i)
299 {
300 MeshLib::Node const* node = cell->getNode(i);
301 values.push_back(node->getID() + offset);
302 }
303 }
304 return values;
305}
MathLib::Point3dWithID::getID
std::size_t getID() const
Definition Point3dWithID.h:62
MeshLib::IO::cellTypeOGS2XDMF
constexpr auto cellTypeOGS2XDMF(MeshLib::CellType const &cell_type)
Definition transformData.cpp:67

References cellTypeOGS2XDMF(), MeshLib::Mesh::getElements(), MathLib::Point3dWithID::getID(), MeshLib::LINE2, and MeshLib::LINE3.

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 // Define content of <Topology> in XDMF, same as attribute_transform
203 auto const topology_transform =
204 [](XdmfData const& topology, auto const& dataitem_transform)
205 {
206 return fmt::format(
207 fmt::runtime("\n\t<Topology Dimensions=\"{dimensions}\" "
208 "Type=\"Mixed\">{dataitem}\n\t</Topology>"),
209 "dataitem"_a = dataitem_transform(topology),
210 "dimensions"_a = fmt::join(topology.global_block_dims, " "));
211 };
212
213 // Defines content of <Grid> of a single time step, takes specific transform
214 // functions for all of its child elements
215 auto const grid_transform =
216 [](double const& time_value, auto const& geometry, auto const& topology,
217 auto const& constant_attributes, auto const& variable_attributes)
218 {
219 // Output of "Time Value" with sufficient precision.
220 static_assert(15 == std::numeric_limits<double>::digits10);
221 return fmt::format(
222 R"(
223<Grid Name="Grid" GridType="Uniform">
224 <Time Value="{time_value:.15g}"/>
225{geometry}
226{topology}
227{fix_attributes}
228{variable_attributes}
229</Grid>)",
230 "time_value"_a = time_value, "geometry"_a = geometry,
231 "topology"_a = topology, "fix_attributes"_a = constant_attributes,
232 "variable_attributes"_a = variable_attributes);
233 };
234
235 // An attribute may change over time (variable) or stay constant
236 enum class time_attribute
237 {
238 constant,
239 variable
240 };
241
242 // Generates a function that either writes the data or points to existing
243 // data
244 auto const time_step_fn = [time_dataitem_genfn, pointer_transfrom,
245 h5filename,
246 mesh_name](auto const& component_transform,
247 unsigned long long const time_step,
248 int const max_step,
249 time_attribute const variable)
250 {
251 return [component_transform, time_dataitem_genfn, pointer_transfrom,
252 variable, time_step, max_step, h5filename,
253 mesh_name](XdmfData const& attr)
254 {
255 // new data arrived
256 bool const changed =
257 ((time_step > 0 && (variable == time_attribute::variable)) ||
258 time_step == 0);
259 if (changed)
260 {
261 auto dataitem = time_dataitem_genfn(time_step, max_step,
262 h5filename, mesh_name);
263 return component_transform(attr, dataitem);
264 }
265 else
266 {
267 std::array<unsigned int, 5> position = {1, 1, 2, 1, attr.index};
268 return pointer_transfrom(position);
269 };
270 };
271 };
272
273 // Top-Level transform function (take spatial and temporal transform
274 // functions) and return the time depended grid transform function
275 // ToDo (tm) Remove capturing m_bind and string_join as helper function
276
277 auto const time_grid_transform =
278 [time_step_fn, m_bind_fn, string_join_fn, grid_transform,
279 geometry_transform, topology_transform, attribute_transform](
280 double const time, int const step, int const max_step,
281 auto const& geometry, auto const& topology,
282 auto const& constant_attributes, auto const& variable_attributes)
283 {
284 auto const time_step_geometry_transform = time_step_fn(
285 geometry_transform, step, max_step, time_attribute::constant);
286 auto const time_step_topology_transform = time_step_fn(
287 topology_transform, step, max_step, time_attribute::constant);
288 auto const time_step_const_attribute_fn = time_step_fn(
289 attribute_transform, step, max_step, time_attribute::constant);
290 auto const time_step_variable_attribute_fn = time_step_fn(
291 attribute_transform, step, max_step, time_attribute::variable);
292
293 // lift both functions from handling single attributes to work with
294 // collection of attributes
295 auto const variable_attributes_transform =
296 m_bind_fn(time_step_variable_attribute_fn, string_join_fn);
297 auto const constant_attributes_transform =
298 m_bind_fn(time_step_const_attribute_fn, string_join_fn);
299
300 return grid_transform(
301 time, time_step_geometry_transform(geometry),
302 time_step_topology_transform(topology),
303 constant_attributes_transform(constant_attributes),
304 variable_attributes_transform(variable_attributes));
305 };
306
307 // Function that combines all the data from spatial (geometry, topology,
308 // attribute) and temporal domain (time) with the time domain
309 // (time_step_fn). And writes <Grid CollectionType="Temporal">
310 auto const temporal_grid_collection_transform =
311 [time_grid_transform](
312 auto const& times, auto const& geometry, auto const& topology,
313 auto const& constant_attributes, auto const& variable_attributes)
314 {
315 // c++20 ranges zip missing
316 auto const max_step = times.size();
317 std::vector<std::string> grids;
318 grids.reserve(max_step);
319 for (size_t time_step = 0; time_step < max_step; ++time_step)
320 {
321 grids.push_back(time_grid_transform(
322 times[time_step], time_step, max_step, geometry, topology,
323 constant_attributes, variable_attributes));
324 }
325 return fmt::format(
326 fmt::runtime(
327 "\n<Grid CollectionType=\"Temporal\" GridType=\"Collection\" "
328 "Name=\"Collection\">{grids}\n</Grid>\n"),
329 "grids"_a = fmt::join(grids, ""));
330 };
331
332 // Generator function that return a function that represents complete xdmf
333 // structure
334 auto const xdmf_writer_fn = [temporal_grid_collection_transform](
335 auto ogs_version, auto geometry,
336 auto topology, auto constant_attributes,
337 auto variable_attributes)
338 {
339 // This function will be the return of the surrounding named function
340 // capture by copy - it is the function that will survive this scope!!
341 // Use generalized lambda capture to move for optimization
342 return [temporal_grid_collection_transform,
343 ogs_version = std::move(ogs_version),
344 geometry = std::move(geometry), topology = std::move(topology),
345 constant_attributes = std::move(constant_attributes),
346 variable_attributes = std::move(variable_attributes)](
347 std::vector<double> const& times)
348 {
349 return fmt::format(
350 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Xdmf "
351 "xmlns:xi=\"http://www.w3.org/2001/XInclude\" "
352 "Version=\"3.0\">\n<Domain>\n<Information Name=\"OGS_VERSION\" "
353 "Value=\"{ogs_version}\"/>{grid_collection}</Domain>\n</Xdmf>",
354 "ogs_version"_a = ogs_version,
355 "grid_collection"_a = temporal_grid_collection_transform(
356 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, getPropertyDataTypeSize(), getPropertyDataTypeString(), MeshLib::IO::XdmfData::global_block_dims, meshItemTypeString(), and MeshLib::IO::XdmfData::name.

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:434
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 172 of file VtuInterface.cpp.

174{
175 MeshLib::IO::VtuInterface writer(&mesh, data_mode);
176 auto const result = writer.writeToFile(file_name);
177 if (!result)
178 {
179 ERR("writeMeshToFile(): Could not write mesh to '{:s}'.", file_name);
180 return -1;
181 }
182 return 0;
183}

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

Referenced by main().

Variable Documentation

◆ elem_type_ogs2xdmf

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

Definition at line 65 of file transformData.cpp.

Referenced by cellTypeOGS2XDMF().

◆ mesh_item_type_strings

constexpr 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().