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 <string_view>
#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 : std::uint8_t;
template <std::floating_point T>
class Mesh;
template <typename T>
class MeshTags;
} // namespace dolfinx::mesh
 
namespace dolfinx::io
{

class XDMFFile
{
public:
  enum class Encoding : std::int8_t
  {
    HDF5,
    ASCII
  };

  XDMFFile(MPI_Comm comm, const std::filesystem::path& filename,
           std::string_view file_mode, Encoding encoding = Encoding::HDF5);
 
  // Copy constructor (deleted)
  XDMFFile(const XDMFFile& file) = delete;

  XDMFFile(XDMFFile&& file) noexcept;

  ~XDMFFile();
 
  // Copy assignment (deleted)
  XDMFFile& operator=(const XDMFFile& file) = delete;

  XDMFFile& operator=(XDMFFile&& file) noexcept;

  void close();

  template <std::floating_point U>
  void write_mesh(const mesh::Mesh<U>& mesh,
                  std::string_view xpath = "/Xdmf/Domain");

  void write_geometry(const mesh::Geometry<double>& geometry,
                      std::string_view name,
                      std::string_view xpath = "/Xdmf/Domain");

  mesh::Mesh<double>
  read_mesh(const fem::CoordinateElement<double>& element, mesh::GhostMode mode,
            std::string_view name, std::string_view xpath = "/Xdmf/Domain",
            std::optional<std::int32_t> max_facet_to_cell_links = 2,
            int num_threads = 1) const;

  std::pair<std::vector<std::int64_t>, std::array<std::size_t, 2>>
  read_topology_data(std::string_view name,
                     std::string_view 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_view name,
                     std::string_view xpath = "/Xdmf/Domain") const;

  std::pair<mesh::CellType, int> read_cell_type(std::string_view grid_name,
                                                std::string_view xpath
                                                = "/Xdmf/Domain") const;

  template <dolfinx::scalar T, std::floating_point U = scalar_value_t<T>>
  void write_function(const fem::Function<T, U>& u, double t,
                      std::string_view 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_view geometry_xpath,
                      std::string_view xpath = "/Xdmf/Domain");

  mesh::MeshTags<std::int32_t>
  read_meshtags(const mesh::Mesh<double>& mesh, std::string_view name,
                std::optional<std::string_view> attribute_name,
                std::string_view xpath = "/Xdmf/Domain") const;

  void write_information(std::string_view name, std::string_view value,
                         std::string_view xpath = "/Xdmf/Domain/");

  std::string read_information(std::string_view name,
                               std::string_view xpath = "/Xdmf/Domain/") const;

  void flush();

  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. Owning, so that the identifier is released if the
  // constructor throws after opening the file, and on destruction.
  hdf5::Handle _h5_id{H5I_INVALID_HID, H5Fclose};
 
  // 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