ADIOS2Writers.h

// Copyright (C) 2021 Jørgen S. Dokken and Garth N. Wells
//
// This file is part of DOLFINX (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#ifdef HAS_ADIOS2
 
#include <cassert>
#include <complex>
#include <filesystem>
#include <memory>
#include <mpi.h>
#include <string>
#include <variant>
#include <vector>
 
namespace adios2
{
class ADIOS;
class IO;
class Engine;
} // namespace adios2
 
namespace dolfinx::fem
{
template <typename T>
class Function;
}
 
namespace dolfinx::mesh
{
class Mesh;
}
 
namespace dolfinx::io
{
 
class ADIOS2Writer
{
public:
  using Fd32 = fem::Function<float>;
  using Fd64 = fem::Function<double>;
  using Fc64 = fem::Function<std::complex<float>>;
  using Fc128 = fem::Function<std::complex<double>>;
  using U = std::vector<
      std::variant<std::shared_ptr<const Fd32>, std::shared_ptr<const Fd64>,
                   std::shared_ptr<const Fc64>, std::shared_ptr<const Fc128>>>;
 
private:
  ADIOS2Writer(MPI_Comm comm, const std::filesystem::path& filename,
               std::string tag, std::shared_ptr<const mesh::Mesh> mesh,
               const U& u);
 
protected:
  ADIOS2Writer(MPI_Comm comm, const std::filesystem::path& filename,
               std::string tag, std::shared_ptr<const mesh::Mesh> mesh);
 
  ADIOS2Writer(MPI_Comm comm, const std::filesystem::path& filename,
               std::string tag, const U& u);
 
  ADIOS2Writer(ADIOS2Writer&& writer) = default;
 
  ADIOS2Writer(const ADIOS2Writer&) = delete;
 
  ~ADIOS2Writer();
 
  ADIOS2Writer& operator=(ADIOS2Writer&& writer) = default;
 
  // Copy assignment
  ADIOS2Writer& operator=(const ADIOS2Writer&) = delete;
 
public:
  void close();
 
protected:
  std::unique_ptr<adios2::ADIOS> _adios;
  std::unique_ptr<adios2::IO> _io;
  std::unique_ptr<adios2::Engine> _engine;
  std::shared_ptr<const mesh::Mesh> _mesh;
  U _u;
};
 
class FidesWriter : public ADIOS2Writer
{
public:
  enum class MeshPolicy
  {
    update, 
    reuse   
  };
 
  FidesWriter(MPI_Comm comm, const std::filesystem::path& filename,
              std::shared_ptr<const mesh::Mesh> mesh);
 
  FidesWriter(MPI_Comm comm, const std::filesystem::path& filename,
              const ADIOS2Writer::U& u,
              const MeshPolicy mesh_policy = MeshPolicy::update);
 
  // Copy constructor
  FidesWriter(const FidesWriter&) = delete;
 
  FidesWriter(FidesWriter&& file) = default;
 
  ~FidesWriter() = default;
 
  FidesWriter& operator=(FidesWriter&&) = default;
 
  // Copy assignment
  FidesWriter& operator=(const FidesWriter&) = delete;
 
  void write(double t);
 
private:
  // Control whether the mesh is written to file once or at every time step
  MeshPolicy _mesh_reuse_policy;
};
 
class VTXWriter : public ADIOS2Writer
{
public:
  VTXWriter(MPI_Comm comm, const std::filesystem::path& filename,
            std::shared_ptr<const mesh::Mesh> mesh);
 
  VTXWriter(MPI_Comm comm, const std::filesystem::path& filename, const U& u);
 
  // Copy constructor
  VTXWriter(const VTXWriter&) = delete;
 
  VTXWriter(VTXWriter&& file) = default;
 
  ~VTXWriter() = default;
 
  VTXWriter& operator=(VTXWriter&&) = default;
 
  // Copy assignment
  VTXWriter& operator=(const VTXWriter&) = delete;
 
  void write(double t);
};
 
} // namespace dolfinx::io
 
#endif