MeshLib::IO::XdmfHdfWriter Class Reference

Detailed Description

Definition at line 26 of file XdmfHdfWriter.h.

#include <XdmfHdfWriter.h>

Public Member Functions
	XdmfHdfWriter (std::vector< std::reference_wrapper< const MeshLib::Mesh >> meshes, std::filesystem::path const &filepath, unsigned long long time_step, double initial_time, std::set< std::string > const &variable_output_names, bool use_compression, unsigned int n_files)
	Write xdmf and h5 file with geometry and topology data. More...
void	writeStep (double time)
	Adds data for either lazy (xdmf) or eager (hdf) writing algorithm. More...

Private Attributes
std::unique_ptr< HdfWriter >	_hdf_writer
std::vector< std::unique_ptr< XdmfWriter > >	_xdmf_writer

Constructor & Destructor Documentation

XdmfHdfWriter()

MeshLib::IO::XdmfHdfWriter::XdmfHdfWriter	(	std::vector< std::reference_wrapper< const MeshLib::Mesh >>	meshes,
		std::filesystem::path const &	filepath,
		unsigned long long	time_step,
		double	initial_time,
		std::set< std::string > const &	variable_output_names,
		bool	use_compression,
		unsigned int	n_files
	)

Write xdmf and h5 file with geometry and topology data.

Parameters

meshes	Meshes or NodePartitionedMeshes to be written to file(s)
filepath	absolute or relative filepath to the hdf5 file
time_step	number of the step (temporal collection)
initial_time	time in seconds of the first time step
variable_output_names	names of all process variables (attributes) that change over time
use_compression	if true, zlib compression in HDFWriter component is used
n_files	number of hdf5 output files

Definition at line 37 of file XdmfHdfWriter.cpp.

{
    // ogs meshes to vector of Xdmf/HDF meshes (we keep Xdmf and HDF together
    // because XDMF depends on HDF) to meta
 
    // if no output name is specified, all data will be assumened to be
    // variable over the timesteps. The xdmfhdfwriter is an alternative to
    // other writers, that do not consider the constantness of data Callers
    // of xdmfwriter (e.g. ogs tools) do not provide these information yet
    // and indicate with empty list
    std::function<bool(HdfData)> const is_variable_hdf_attribute =
        [&variable_output_names](
            bool outputnames) -> std::function<bool(HdfData)>
    {
        if (outputnames)
        {
            return [&variable_output_names](HdfData const& data) -> bool
            {
                return std::find(variable_output_names.begin(),
                                 variable_output_names.end(),
                                 data.name) != variable_output_names.end();
            };
        }
        else
        {
            return [](HdfData const&) -> bool { return true; };
        }
    }(!variable_output_names.empty());
 
    auto is_variable_xdmf_attribute =
        [&variable_output_names](XdmfData const& data) -> bool
    {
        return std::find(variable_output_names.begin(),
                         variable_output_names.end(),
                         data.name) != variable_output_names.end();
    };
 
    // Transform the data to be written into a format conforming with the rules
    // of xdmf topology and geometry
    auto const transform_ogs_mesh_data_to_xdmf_conforming_data =
        [&n_files](auto const& mesh)
    {
        auto flattened_geometry_values = transformToXDMFGeometry(mesh);
        // actually this line is only needed to calculate the offset
        XdmfHdfData const& geometry =
            transformGeometry(mesh, flattened_geometry_values.data(), n_files);
        auto const flattened_topology_values =
            transformToXDMFTopology(mesh, geometry.hdf.offsets[0]);
        return std::make_unique<TransformedMeshData>(
            TransformedMeshData{std::move(flattened_geometry_values),
                                std::move(flattened_topology_values)});
    };
 
    // create metadata for transformed data and original ogs mesh data
    auto const transform_to_meta_data =
        [&transform_ogs_mesh_data_to_xdmf_conforming_data,
         &n_files](auto const& mesh)
    {
        // important: transformed data must survive and be unique, raw pointer
        // to its memory!
        std::unique_ptr<TransformedMeshData> xdmf_conforming_data =
            transform_ogs_mesh_data_to_xdmf_conforming_data(mesh);
        auto const geometry = transformGeometry(
            mesh, xdmf_conforming_data->flattened_geometry_values.data(),
            n_files);
        auto const topology = transformTopology(
            xdmf_conforming_data->flattened_topology_values, n_files);
        auto const attributes = transformAttributes(mesh, n_files);
        return XdmfHdfMesh{std::move(geometry), std::move(topology),
                           std::move(attributes), mesh.get().getName(),
                           std::move(xdmf_conforming_data)};
    };
 
    // extract meta data relevant for HDFWriter
    auto const transform_metamesh_to_hdf =
        [&is_variable_hdf_attribute](auto const& metamesh)
    {
        // topology and geometry can be treated as any other attribute
        std::vector<HdfData> hdf_data_attributes = {metamesh.geometry.hdf,
                                                    metamesh.topology.hdf};
 
        hdf_data_attributes.reserve(hdf_data_attributes.size() +
                                    metamesh.attributes.size());
        std::transform(metamesh.attributes.begin(), metamesh.attributes.end(),
                       std::back_inserter(hdf_data_attributes),
                       [](XdmfHdfData att) -> HdfData { return att.hdf; });
 
        HDFAttributes constant_attributes;
        std::copy_if(hdf_data_attributes.begin(), hdf_data_attributes.end(),
                     back_inserter(constant_attributes),
                     std::not_fn(is_variable_hdf_attribute));
        HDFAttributes variable_attributes;
        std::copy_if(hdf_data_attributes.begin(), hdf_data_attributes.end(),
                     back_inserter(variable_attributes),
                     is_variable_hdf_attribute);
 
        return MeshHdfData{
            .constant_attributes = std::move(constant_attributes),
            .variable_attributes = std::move(variable_attributes),
            .name = std::move(metamesh.name)};
    };
 
    // --------------- XDMF + HDF ---------------------
    std::vector<XdmfHdfMesh> xdmf_hdf_meshes;
    xdmf_hdf_meshes.reserve(meshes.size());
    std::transform(meshes.begin(), meshes.end(),
                   std::back_inserter(xdmf_hdf_meshes), transform_to_meta_data);
 
    std::vector<MeshHdfData> hdf_meshes;
    hdf_meshes.reserve(xdmf_hdf_meshes.size());
    std::transform(xdmf_hdf_meshes.begin(), xdmf_hdf_meshes.end(),
                   std::back_inserter(hdf_meshes), transform_metamesh_to_hdf);
 
    // --------------- HDF ---------------------
    std::filesystem::path const hdf_filepath =
        filepath.parent_path() / (filepath.stem().string() + ".h5");
 
    auto const is_file_manager = isFileManager();
    _hdf_writer = std::make_unique<HdfWriter>(std::move(hdf_meshes), time_step,
                                              hdf_filepath, use_compression,
                                              is_file_manager, n_files);
 
    // --------------- XDMF ---------------------
    // The light data is only written by just one process
    if (!is_file_manager)
    {
        return;
    }
 
    // xdmf section
    // extract meta data relevant for XDMFWriter
    auto const transform_metamesh_to_xdmf =
        [&is_variable_xdmf_attribute, &filepath, &hdf_filepath,
         &initial_time](XdmfHdfMesh& metamesh)
    {
        std::string const xdmf_name = metamesh.name;
        std::filesystem::path const xdmf_filepath =
            filepath.parent_path() /
            (filepath.stem().string() + "_" + xdmf_name + ".xdmf");
 
        std::vector<XdmfData> xdmf_attributes;
        std::transform(metamesh.attributes.begin(), metamesh.attributes.end(),
                       std::back_inserter(xdmf_attributes),
                       [](XdmfHdfData const& att) -> XdmfData
                       { return att.xdmf; });
 
        for (std::size_t i = 0; i < metamesh.attributes.size(); ++i)
        {
            // index 1 time,  index 2 geo, index 3 topology, attributes start at
            // index 4
            xdmf_attributes[i].index = i + 4;
        }
 
        std::vector<XdmfData> xdmf_variable_attributes;
        std::copy_if(xdmf_attributes.begin(), xdmf_attributes.end(),
                     back_inserter(xdmf_variable_attributes),
                     is_variable_xdmf_attribute);
        std::vector<XdmfData> xdmf_constant_attributes;
        std::copy_if(xdmf_attributes.begin(), xdmf_attributes.end(),
                     back_inserter(xdmf_constant_attributes),
                     std::not_fn(is_variable_xdmf_attribute));
 
        auto const xdmf_writer_fn =
            write_xdmf(metamesh.geometry.xdmf, metamesh.topology.xdmf,
                       xdmf_constant_attributes, xdmf_variable_attributes,
                       hdf_filepath.filename().string(),
                       GitInfoLib::GitInfo::ogs_version, xdmf_name);
        auto xdmf_writer = std::make_unique<XdmfWriter>(xdmf_filepath.string(),
                                                        xdmf_writer_fn);
        xdmf_writer->addTimeStep(initial_time);
        return xdmf_writer;
    };
 
    std::transform(xdmf_hdf_meshes.begin(), xdmf_hdf_meshes.end(),
                   std::back_inserter(_xdmf_writer),
                   transform_metamesh_to_xdmf);
}

References _hdf_writer, _xdmf_writer, MeshLib::IO::MeshHdfData::constant_attributes, MeshLib::IO::XdmfHdfMesh::geometry, MeshLib::IO::XdmfHdfData::hdf, MeshLib::IO::isFileManager(), MeshLib::IO::HdfData::offsets, GitInfoLib::GitInfo::ogs_version, MeshLib::IO::transformAttributes(), MeshLib::IO::transformGeometry(), MeshLib::IO::transformTopology(), MeshLib::IO::transformToXDMFGeometry(), MeshLib::IO::transformToXDMFTopology(), and MeshLib::IO::write_xdmf().

Member Function Documentation

writeStep()

void MeshLib::IO::XdmfHdfWriter::writeStep

(

double

time

)

Adds data for either lazy (xdmf) or eager (hdf) writing algorithm.

Parameters

time	time value of the current time_step

Definition at line 220 of file XdmfHdfWriter.cpp.

{
    // ToDo (tm) time_step will be used for simulation continuation (restart)
    _hdf_writer->writeStep(time);
    // The light data is only written by just one process
    if (isFileManager())
    {
        for (auto const& xdmf_writer : _xdmf_writer)
        {
            xdmf_writer->addTimeStep(time);
        }
    }
}

References _hdf_writer, _xdmf_writer, and MeshLib::IO::isFileManager().

Member Data Documentation

_hdf_writer

std::unique_ptr<HdfWriter> MeshLib::IO::XdmfHdfWriter::_hdf_writer

private

Definition at line 55 of file XdmfHdfWriter.h.

Referenced by XdmfHdfWriter(), and writeStep().

_xdmf_writer

std::vector<std::unique_ptr<XdmfWriter> > MeshLib::IO::XdmfHdfWriter::_xdmf_writer

private

Definition at line 56 of file XdmfHdfWriter.h.

Referenced by XdmfHdfWriter(), and writeStep().

---

The documentation for this class was generated from the following files:

• MeshLib/IO/XDMF/XdmfHdfWriter.h
• MeshLib/IO/XDMF/XdmfHdfWriter.cpp