XDMFFile.h

// Copyright (C) 2012-2020 Chris N. Richardson, Garth N. Wells and Michal Habera
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include "HDF5Interface.h"
#include <concepts>
#include <dolfinx/common/MPI.h>
#include <dolfinx/mesh/cell_types.h>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <variant>
 
namespace pugi
{
class xml_node;
class xml_document;
} // namespace pugi
 
namespace dolfinx::fem
{
template <std::floating_point T>
class CoordinateElement;
template <dolfinx::scalar T, std::floating_point U>
class Function;
} // namespace dolfinx::fem
 
namespace dolfinx::mesh
{
template <std::floating_point T>
class Geometry;
enum class GhostMode : int;
template <std::floating_point T>
class Mesh;
template <typename T>
class MeshTags;
} // namespace dolfinx::mesh
 
namespace dolfinx::io
{
 
class XDMFFile
{
public:
  enum class Encoding
  {
    HDF5,
    ASCII
  };
 
  XDMFFile(MPI_Comm comm, const std::filesystem::path& filename,
           std::string file_mode, Encoding encoding = Encoding::HDF5);
 
  XDMFFile(XDMFFile&&) = default;
 
  ~XDMFFile();
 
  void close();
 
  template <std::floating_point U>
  void write_mesh(const mesh::Mesh<U>& mesh,
                  std::string xpath = "/Xdmf/Domain");
 
  void write_geometry(const mesh::Geometry<double>& geometry, std::string name,
                      std::string xpath = "/Xdmf/Domain");
 
  mesh::Mesh<double> read_mesh(const fem::CoordinateElement<double>& element,
                               mesh::GhostMode mode, std::string name,
                               std::string xpath = "/Xdmf/Domain") const;
 
  std::pair<std::vector<std::int64_t>, std::array<std::size_t, 2>>
  read_topology_data(std::string name,
                     std::string xpath = "/Xdmf/Domain") const;
 
  std::pair<std::variant<std::vector<float>, std::vector<double>>,
            std::array<std::size_t, 2>>
  read_geometry_data(std::string name,
                     std::string xpath = "/Xdmf/Domain") const;
 
  std::pair<mesh::CellType, int>
  read_cell_type(std::string grid_name, std::string xpath = "/Xdmf/Domain");
 
  template <dolfinx::scalar T, std::floating_point U = scalar_value_type_t<T>>
  void write_function(const fem::Function<T, U>& u, double t,
                      std::string mesh_xpath
                      = "/Xdmf/Domain/Grid[@GridType='Uniform'][1]");
 
  template <std::floating_point T>
  void write_meshtags(const mesh::MeshTags<std::int32_t>& meshtags,
                      const mesh::Geometry<T>& x, std::string geometry_xpath,
                      std::string xpath = "/Xdmf/Domain");
 
  mesh::MeshTags<std::int32_t>
  read_meshtags(const mesh::Mesh<double>& mesh, std::string name,
                std::optional<std::string> attribute_name,
                std::string xpath = "/Xdmf/Domain");
 
  void write_information(std::string name, std::string value,
                         std::string xpath = "/Xdmf/Domain/");
 
  std::string read_information(std::string name,
                               std::string xpath = "/Xdmf/Domain/");
 
  MPI_Comm comm() const;
 
private:
  // MPI communicator
  dolfinx::MPI::Comm _comm;
 
  // Filename
  std::filesystem::path _filename;
 
  // File mode
  std::string _file_mode;
 
  // HDF5 file handle
  hid_t _h5_id;
 
  // The XML document currently representing the XDMF which needs to be
  // kept open for time series etc.
  std::unique_ptr<pugi::xml_document> _xml_doc;
 
  Encoding _encoding;
};
 
} // namespace dolfinx::io