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 <dolfinx/common/MPI.h>
#include <dolfinx/mesh/cell_types.h>
#include <filesystem>
#include <memory>
#include <string>
 
namespace pugi
{
class xml_node;
class xml_document;
} // namespace pugi
 
namespace dolfinx::fem
{
class CoordinateElement;
}
 
namespace dolfinx::fem
{
template <typename T>
class Function;
}
 
namespace dolfinx::mesh
{
class Geometry;
enum class GhostMode : int;
class Mesh;
template <typename T>
class MeshTags;
} // namespace dolfinx::mesh
 
namespace dolfinx::io
{
 
 
 
class XDMFFile
{
public:
  enum class Encoding
  {
    HDF5,
    ASCII
  };
 
  static const Encoding default_encoding = Encoding::HDF5;
 
  XDMFFile(MPI_Comm comm, const std::filesystem::path& filename,
           const std::string file_mode,
           const Encoding encoding = default_encoding);
 
  ~XDMFFile();
 
  void close();
 
  void write_mesh(const mesh::Mesh& mesh,
                  const std::string xpath = "/Xdmf/Domain");
 
  void write_geometry(const mesh::Geometry& geometry, const std::string name,
                      const std::string xpath = "/Xdmf/Domain");
 
  mesh::Mesh read_mesh(const fem::CoordinateElement& element,
                       const mesh::GhostMode& mode, const std::string name,
                       const std::string xpath = "/Xdmf/Domain") const;
 
  std::pair<std::vector<std::int64_t>, std::array<std::size_t, 2>>
  read_topology_data(const std::string name,
                     const std::string xpath = "/Xdmf/Domain") const;
 
  std::pair<std::vector<double>, std::array<std::size_t, 2>>
  read_geometry_data(const std::string name,
                     const std::string xpath = "/Xdmf/Domain") const;
 
  std::pair<mesh::CellType, int> read_cell_type(const std::string grid_name,
                                                const std::string xpath
                                                = "/Xdmf/Domain");
 
  void write_function(const fem::Function<double>& u, double t,
                      const std::string& mesh_xpath
                      = "/Xdmf/Domain/Grid[@GridType='Uniform'][1]");
 
  void write_function(const fem::Function<std::complex<double>>& u, double t,
                      const std::string& mesh_xpath
                      = "/Xdmf/Domain/Grid[@GridType='Uniform'][1]");
 
  void write_meshtags(const mesh::MeshTags<std::int32_t>& meshtags,
                      const std::string& geometry_xpath,
                      const std::string& xpath = "/Xdmf/Domain");
 
  mesh::MeshTags<std::int32_t>
  read_meshtags(const std::shared_ptr<const mesh::Mesh>& mesh,
                const std::string name,
                const std::string xpath = "/Xdmf/Domain");
 
  void write_information(const std::string name, const std::string value,
                         const std::string xpath = "/Xdmf/Domain/");
 
  std::string read_information(const std::string name,
                               const 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