gridformat.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2022-2023 Dennis Gläser <dennis.glaeser@iws.uni-stuttgart.de>
// SPDX-License-Identifier: MIT
#ifndef GRIDFORMAT_GRIDFORMAT_HPP_
#define GRIDFORMAT_GRIDFORMAT_HPP_
 
#include <memory>
#include <optional>
#include <type_traits>
#include <concepts>
 
#include <gridformat/reader.hpp>
#include <gridformat/writer.hpp>
 
#include <gridformat/grid/converter.hpp>
#include <gridformat/grid/image_grid.hpp>
 
#include <gridformat/common/exceptions.hpp>
#include <gridformat/common/multi_string.hpp>
#include <gridformat/parallel/communication.hpp>
 
#include <gridformat/vtk/vti_reader.hpp>
#include <gridformat/vtk/vti_writer.hpp>
#include <gridformat/vtk/pvti_writer.hpp>
 
#include <gridformat/vtk/vtr_reader.hpp>
#include <gridformat/vtk/vtr_writer.hpp>
#include <gridformat/vtk/pvtr_writer.hpp>
 
#include <gridformat/vtk/vts_reader.hpp>
#include <gridformat/vtk/vts_writer.hpp>
#include <gridformat/vtk/pvts_writer.hpp>
 
#include <gridformat/vtk/vtp_reader.hpp>
#include <gridformat/vtk/vtp_writer.hpp>
#include <gridformat/vtk/pvtp_writer.hpp>
 
#include <gridformat/vtk/vtu_writer.hpp>
#include <gridformat/vtk/vtu_reader.hpp>
#include <gridformat/vtk/pvtu_writer.hpp>
 
#include <gridformat/vtk/pvd_reader.hpp>
#include <gridformat/vtk/pvd_writer.hpp>
 
#include <gridformat/vtk/xml_time_series_writer.hpp>
 
#ifndef DOXYGEN
namespace GridFormat::APIDetail {
 
    template<typename... T>
    inline constexpr bool always_false = false;
 
    // The converter grid satisfies all grid concepts, but its actual type is only known at runtime
    template<typename G>
    inline constexpr bool is_converter_grid = std::same_as<G, ConverterDetail::ConverterGrid>;
 
    template<typename... T>
    struct DefaultAsserter {
        static constexpr bool do_assert() {
            static_assert(
                always_false<T...>,
                "Requested reader/writer is unavailable due to missing dependency"
            );
            return false;
        }
    };
 
    // Derive from GridWriter to make this a "valid" writer (and abuse some valid grid impl for that)
    template<template<typename...> typename Asserter = DefaultAsserter>
    class UnavailableWriter : public GridWriter<ImageGrid<2, double>> {
     public:
        template<typename... Args>
        UnavailableWriter(Args&&...) { static_assert(Asserter<Args...>::do_assert()); }
     private:
        void _throw() const { throw GridFormat::NotImplemented("Writer unavailable"); }
        void _write(std::ostream&) const { _throw(); }
    };
 
    // Derive from TimeSeriesGridWriter to make this a "valid" writer (and abuse some valid grid impl for that)
    template<template<typename...> typename Asserter = DefaultAsserter>
    class UnavailableTimeSeriesWriter : public TimeSeriesGridWriter<ImageGrid<2, double>> {
     public:
        template<typename... Args>
        UnavailableTimeSeriesWriter(Args&&...) { static_assert(Asserter<Args...>::do_assert()); }
     private:
        void _throw() const { throw GridFormat::NotImplemented("Writer unavailable"); }
        std::string _write(double) override { _throw(); return ""; }
    };
 
    // Derive from Reader to make this a "valid" reader
    template<template<typename...> typename Asserter = DefaultAsserter>
    class UnavailableReader : public GridReader {
     public:
        template<typename... Args>
        UnavailableReader(Args&&...) { static_assert(Asserter<Args...>::do_assert()); }
     private:
        void _throw() const { throw GridFormat::NotImplemented("Reader unavailable"); }
        std::string _name() const override { _throw(); return ""; }
        void _open(const std::string&, typename GridReader::FieldNames&) override { _throw(); }
        void _close() override { _throw(); }
        std::size_t _number_of_cells() const override { _throw(); return 0; }
        std::size_t _number_of_points() const override { _throw(); return 0; }
        FieldPtr _cell_field(std::string_view) const override { _throw(); return nullptr; }
        FieldPtr _point_field(std::string_view) const override { _throw(); return nullptr; }
        FieldPtr _meta_data_field(std::string_view) const override { _throw(); return nullptr; }
        bool _is_sequence() const override { _throw(); return false; }
    };
 
}  // namespace GridFormat::APIDetail
 
#if GRIDFORMAT_HAVE_HIGH_FIVE
#include <gridformat/vtk/hdf_writer.hpp>
#include <gridformat/vtk/hdf_reader.hpp>
inline constexpr bool _gfmt_api_have_high_five = true;
#else
#include <gridformat/vtk/hdf_common.hpp>
inline constexpr bool _gfmt_api_have_high_five = false;
namespace GridFormat {
 
template<typename... T>
struct VTKHDFAsserter {
    static constexpr bool do_assert() {
        static_assert(
            APIDetail::always_false<T...>,
            "VTKHDF reader/writers require HighFive"
        );
        return false;
    }
};
 
using VTKHDFWriter = APIDetail::UnavailableWriter<VTKHDFAsserter>;
using VTKHDFTimeSeriesWriter = APIDetail::UnavailableTimeSeriesWriter<VTKHDFAsserter>;
using VTKHDFImageGridWriter = APIDetail::UnavailableWriter<VTKHDFAsserter>;
using VTKHDFUnstructuredGridWriter = APIDetail::UnavailableWriter<VTKHDFAsserter>;
using VTKHDFImageGridTimeSeriesWriter = APIDetail::UnavailableTimeSeriesWriter<VTKHDFAsserter>;
using VTKHDFUnstructuredTimeSeriesWriter = APIDetail::UnavailableTimeSeriesWriter<VTKHDFAsserter>;
 
using VTKHDFImageGridReader = APIDetail::UnavailableReader<VTKHDFAsserter>;
template<typename T = void> using VTKHDFUnstructuredGridReader = APIDetail::UnavailableReader<VTKHDFAsserter>;
template<typename T = void> using VTKHDFReader = APIDetail::UnavailableReader<VTKHDFAsserter>;
 
}  // namespace GridFormat
#endif  // GRIDFORMAT_HAVE_HIGH_FIVE
#endif  // DOXYGEN
 
 
namespace GridFormat {

inline constexpr GridFormat::NullCommunicator null_communicator;

template<typename FileFormat> struct WriterFactory;

template<typename FileFormat> struct ReaderFactory;
 
namespace FileFormat {

template<typename Format, typename Opts>
struct FormatWithOptions {
    using Options = Opts;
    std::optional<Options> opts = {};

    constexpr Format operator()(Options _opts) const {
        return with(std::move(_opts));
    }

    constexpr Format with(Options _opts) const {
        Format f;
        f.opts = std::move(_opts);
        return f;
    }
};

template<typename VTKFormat>
struct VTKXMLFormatBase : public FormatWithOptions<VTKFormat, VTK::XMLOptions> {
    constexpr auto with_encoding(VTK::XML::Encoder e) const {
        auto cur_opts = this->opts.value_or(VTK::XMLOptions{});
        Variant::unwrap_to(cur_opts.encoder, e);
        return this->with(std::move(cur_opts));
    }

    constexpr auto with_data_format(VTK::XML::DataFormat f) const {
        auto cur_opts = this->opts.value_or(VTK::XMLOptions{});
        Variant::unwrap_to(cur_opts.data_format, f);
        return this->with(std::move(cur_opts));
    }

    constexpr auto with_compression(VTK::XML::Compressor c) const {
        auto cur_opts = this->opts.value_or(VTK::XMLOptions{});
        Variant::unwrap_to(cur_opts.compressor, c);
        return this->with(std::move(cur_opts));
    }
};
 

struct Any {};
 

struct AnyTimeSeries {};
 

struct VTI : VTKXMLFormatBase<VTI> {};

struct VTR : VTKXMLFormatBase<VTR> {};

struct VTS : VTKXMLFormatBase<VTS> {};

struct VTP : VTKXMLFormatBase<VTP> {};

struct VTU : VTKXMLFormatBase<VTU> {};

template<typename VTX>
struct VTKXMLTimeSeries : VTKXMLFormatBase<VTKXMLTimeSeries<VTX>> {};
 

struct VTKHDFImage {};

struct VTKHDFImageTransient
: FormatWithOptions<VTKHDFImageTransient, VTK::HDFTransientOptions> {};

struct VTKHDFUnstructured {};

struct VTKHDFUnstructuredTransient
: FormatWithOptions<VTKHDFUnstructuredTransient, VTK::HDFTransientOptions> {};

struct VTKHDFTransient : FormatWithOptions<VTKHDFTransient, VTK::HDFTransientOptions> {
    template<typename Grid>
    constexpr auto from(const Grid&) const {
        if constexpr (Concepts::ImageGrid<Grid> && !APIDetail::is_converter_grid<Grid>)
            return VTKHDFImageTransient{this->opts};
        else
            return VTKHDFUnstructuredTransient{this->opts};
    }
};

struct VTKHDF {
    template<typename Grid>
    static constexpr auto from(const Grid&) {
        if constexpr (Concepts::ImageGrid<Grid> && !APIDetail::is_converter_grid<Grid>)
            return VTKHDFImage{};
        else
            return VTKHDFUnstructured{};
    }

    constexpr VTKHDFTransient with(VTK::HDFTransientOptions opts) const {
        return {std::move(opts)};
    }
};
 
#ifndef DOXYGEN
namespace Detail {
 
    template<typename F> struct IsVTKXMLFormat : public std::false_type {};
    template<> struct IsVTKXMLFormat<VTI> : public std::true_type {};
    template<> struct IsVTKXMLFormat<VTR> : public std::true_type {};
    template<> struct IsVTKXMLFormat<VTS> : public std::true_type {};
    template<> struct IsVTKXMLFormat<VTP> : public std::true_type {};
    template<> struct IsVTKXMLFormat<VTU> : public std::true_type {};
 
}  // namespace Detail
#endif  // DOXYGEN

template<typename PieceFormat = Any>
struct PVD {
    PieceFormat piece_format;
};

struct PVDClosure {
    template<typename Format>
    constexpr auto operator()(const Format& f) const {
        static_assert(
            Detail::IsVTKXMLFormat<Format>::value,
            "The PVD format is only available with vtk-xml file formats"
        );
        return PVD<Format>{f};
    }
};

struct TimeSeriesClosure {
    template<typename Format>
    constexpr auto operator()(const Format& f) const {
        if constexpr (Detail::IsVTKXMLFormat<Format>::value)
            return VTKXMLTimeSeries<Format>{f.opts};
        else if constexpr (std::same_as<VTKHDFImage, Format>)
            return VTKHDFImageTransient{};
        else if constexpr (std::same_as<VTKHDFUnstructured, Format>)
            return VTKHDFUnstructuredTransient{};
        else if constexpr (std::same_as<VTKHDF, Format>)
            return VTKHDFTransient{};
        else if constexpr (std::same_as<Any, Format>)
            return AnyTimeSeries{};
        else {
            static_assert(
                APIDetail::always_false<Format>,
                "Cannot create a time series variant for the given format. This means the format does not "
                "define a variant for time series, or, the selected format is already time series format."
            );
        }
    }
};
 
}  // namespace FileFormat
 
 
#ifndef DOXYGEN
namespace APIDetail {
 
    // Meta-Reader for file formats that have different format flavours in parallel/sequential
    template<typename SeqReader, typename ParReader>
    class SequentialOrParallelReader : public GridReader {
        template<typename R> using CommunicatorAccess = Traits::CommunicatorAccess<R>;
        template<typename R> using Communicator = decltype(CommunicatorAccess<R>::get(std::declval<const R&>()));
        using ParCommunicator = Communicator<ParReader>;
        using SeqCommunicator = Communicator<SeqReader>;
 
     public:
        SequentialOrParallelReader(SeqReader&& seq, ParReader&& par)
        : _seq_reader{std::move(seq)}
        , _par_reader{std::move(par)}
        {}
 
        ParCommunicator communicator() const {
            const bool is_parallel = !_use_sequential.value_or(true);
            if (!is_parallel) {
                if constexpr (!std::is_same_v<ParCommunicator, SeqCommunicator>)
                    throw InvalidState("Cannot access communicator for sequential variant of the reader");
                else
                    return CommunicatorAccess<SeqReader>::get(_seq_reader);
            }
            return CommunicatorAccess<ParReader>::get(_par_reader);
        }
 
     private:
        SeqReader _seq_reader;
        ParReader _par_reader;
        std::optional<bool> _use_sequential = {};
 
        std::string _name() const override {
            return _is_set() ? _access().name() : std::string{"undefined"};
        }
 
        void _open(const std::string& filename, typename GridReader::FieldNames& names) override {
            _close();
            std::string seq_error;
            try {
                _seq_reader.open(filename);
                _use_sequential = true;
            } catch (const std::exception& e) {
                seq_error = e.what();
                _use_sequential.reset();
                _seq_reader.close();
                try {
                    _par_reader.open(filename);
                    _use_sequential = false;
                } catch (const std::exception& par_err) {
                    _use_sequential.reset();
                    _par_reader.close();
                    throw IOError(
                        "Could not read '" + filename + "' neither as sequential nor parallel format.\n"
                        "Error with sequential format (" + _seq_reader.name() + "): " + seq_error + "\n"
                        "Error with parallel format (" + _par_reader.name() + "): " + par_err.what()
                    );
                }
            }
 
            ReaderDetail::copy_field_names(_access(), names);
        }
 
        void _close() override {
            if (_is_set())
                _access().close();
        }
 
        std::size_t _number_of_cells() const override { return _access().number_of_cells(); }
        std::size_t _number_of_points() const override { return _access().number_of_points(); }
        std::size_t _number_of_pieces() const override { return _access().number_of_pieces(); }
 
        FieldPtr _cell_field(std::string_view n) const override { return _access().cell_field(n); }
        FieldPtr _point_field(std::string_view n) const override { return _access().point_field(n); }
        FieldPtr _meta_data_field(std::string_view n) const override { return _access().meta_data_field(n); }
 
        FieldPtr _points() const override { return _access().points(); }
        void _visit_cells(const typename GridReader::CellVisitor& v) const override { _access().visit_cells(v); }
        std::vector<double> _ordinates(unsigned int i) const override { return _access().ordinates(i); }
 
        typename GridReader::PieceLocation _location() const override { return _access().location(); }
        typename GridReader::Vector _spacing() const override { return _access().spacing(); }
        typename GridReader::Vector _origin() const override { return _access().origin(); }
        typename GridReader::Vector _basis_vector(unsigned int i) const override { return _access().basis_vector(i); }
 
        bool _is_sequence() const override { return _access().is_sequence(); }
        std::size_t _number_of_steps() const override { return _access().number_of_steps(); }
        double _time_at_step(std::size_t i) const override { return _access().time_at_step(i); }
        void _set_step(std::size_t i, typename GridReader::FieldNames& names) override {
            _access().set_step(i);
            names.clear();
            ReaderDetail::copy_field_names(_access(), names);
        }
 
        bool _is_set() const { return _use_sequential.has_value(); }
        void _throw_if_not_set() const {
            if (!_is_set())
                throw IOError("No data has been read");
        }
 
        GridReader& _access() {
            _throw_if_not_set();
            return _use_sequential.value()
                ? static_cast<GridReader&>(_seq_reader)
                : static_cast<GridReader&>(_par_reader);
        }
 
        const GridReader& _access() const {
            _throw_if_not_set();
            return _use_sequential.value()
                ? static_cast<const GridReader&>(_seq_reader)
                : static_cast<const GridReader&>(_par_reader);
        }
    };
 
    template<typename S, typename P>
    SequentialOrParallelReader(S&&, P&&) -> SequentialOrParallelReader<std::remove_cvref_t<S>, std::remove_cvref_t<P>>;
 
    template<typename Format, typename SeqReader, typename ParReader>
    struct SequentialOrParallelReaderFactory {
        template<Concepts::Communicator C = NullCommunicator>
        static auto make(const Format&, const C& comm = null_communicator) {
            return SequentialOrParallelReader{SeqReader{}, ParReader{comm}};
        }
    };
 
    template<typename Format, typename SequentialReader, typename ParallelReader>
    struct DefaultReaderFactory {
        static auto make(const Format&) { return SequentialReader{}; }
        static auto make(const Format&, const Concepts::Communicator auto& comm) { return ParallelReader{comm}; }
    };
 
    // Specialization for cases where the parallel reader is templated on the communicator
    template<typename F, typename S, template<typename> typename P>
    struct DefaultTemplatedReaderFactory {
        static auto make(const F&) { return S{}; }
        template<Concepts::Communicator Communicator>
        static auto make(const F&, const Communicator& comm) { return P<Communicator>{comm}; }
    };
 
}  // namespace APIDetail
#endif  // DOXYGEN
 
// Traits specializations for SequentialOrParallelReader
namespace Traits {
 
template<typename S, typename P>
struct WritesConnectivity<APIDetail::SequentialOrParallelReader<S, P>>
: public std::bool_constant<WritesConnectivity<S>::value || WritesConnectivity<P>::value>
{};
 
}  // namespace Traits

template<> struct WriterFactory<FileFormat::VTI> {
    static auto make(const FileFormat::VTI& format,
                     const Concepts::ImageGrid auto& grid) {
        return VTIWriter{grid, format.opts.value_or(VTK::XMLOptions{})};
    }
 
    static auto make(const FileFormat::VTI& format,
                     const Concepts::ImageGrid auto& grid,
                     const Concepts::Communicator auto& comm) {
        return PVTIWriter{grid, comm, format.opts.value_or(VTK::XMLOptions{})};
    }
};

template<>
struct ReaderFactory<FileFormat::VTI> : APIDetail::SequentialOrParallelReaderFactory<FileFormat::VTI, VTIReader, PVTIReader> {};

template<> struct WriterFactory<FileFormat::VTR> {
    static auto make(const FileFormat::VTR& format,
                     const Concepts::RectilinearGrid auto& grid) {
        return VTRWriter{grid, format.opts.value_or(VTK::XMLOptions{})};
    }
    static auto make(const FileFormat::VTR& format,
                     const Concepts::RectilinearGrid auto& grid,
                     const Concepts::Communicator auto& comm) {
        return PVTRWriter{grid, comm, format.opts.value_or(VTK::XMLOptions{})};
    }
};

template<>
struct ReaderFactory<FileFormat::VTR> : APIDetail::SequentialOrParallelReaderFactory<FileFormat::VTR, VTRReader, PVTRReader> {};

template<> struct WriterFactory<FileFormat::VTS> {
    static auto make(const FileFormat::VTS& format,
                     const Concepts::StructuredGrid auto& grid) {
        return VTSWriter{grid, format.opts.value_or(VTK::XMLOptions{})};
    }
    static auto make(const FileFormat::VTS& format,
                     const Concepts::StructuredGrid auto& grid,
                     const Concepts::Communicator auto& comm) {
        return PVTSWriter{grid, comm, format.opts.value_or(VTK::XMLOptions{})};
    }
};

template<>
struct ReaderFactory<FileFormat::VTS> : APIDetail::SequentialOrParallelReaderFactory<FileFormat::VTS, VTSReader, PVTSReader> {};

template<> struct WriterFactory<FileFormat::VTP> {
    static auto make(const FileFormat::VTP& format,
                     const Concepts::UnstructuredGrid auto& grid) {
        return VTPWriter{grid, format.opts.value_or(VTK::XMLOptions{})};
    }
    static auto make(const FileFormat::VTP& format,
                     const Concepts::UnstructuredGrid auto& grid,
                     const Concepts::Communicator auto& comm) {
        return PVTPWriter{grid, comm, format.opts.value_or(VTK::XMLOptions{})};
    }
};

template<>
struct ReaderFactory<FileFormat::VTP> : APIDetail::SequentialOrParallelReaderFactory<FileFormat::VTP, VTPReader, PVTPReader> {};

template<> struct WriterFactory<FileFormat::VTU> {
    static auto make(const FileFormat::VTU& format,
                     const Concepts::UnstructuredGrid auto& grid) {
        return VTUWriter{grid, format.opts.value_or(VTK::XMLOptions{})};
    }
    static auto make(const FileFormat::VTU& format,
                     const Concepts::UnstructuredGrid auto& grid,
                     const Concepts::Communicator auto& comm) {
        return PVTUWriter{grid, comm, format.opts.value_or(VTK::XMLOptions{})};
    }
};

template<>
struct ReaderFactory<FileFormat::VTU> : APIDetail::SequentialOrParallelReaderFactory<FileFormat::VTU, VTUReader, PVTUReader> {};

template<typename F> struct WriterFactory<FileFormat::VTKXMLTimeSeries<F>> {
    static auto make(const FileFormat::VTKXMLTimeSeries<F>& format,
                     const Concepts::UnstructuredGrid auto& grid,
                     const std::string& base_filename) {
        return VTKXMLTimeSeriesWriter{
            WriterFactory<F>::make(F{format.opts.value_or(VTK::XMLOptions{})}, grid),
            base_filename
        };
    }
    static auto make(const FileFormat::VTKXMLTimeSeries<F>& format,
                     const Concepts::UnstructuredGrid auto& grid,
                     const Concepts::Communicator auto& comm,
                     const std::string& base_filename) {
        return VTKXMLTimeSeriesWriter{
            WriterFactory<F>::make(F{format.opts.value_or(VTK::XMLOptions{})}, grid, comm),
            base_filename
        };
    }
};

template<> struct WriterFactory<FileFormat::VTKHDFImage> {
    static auto make(const FileFormat::VTKHDFImage&,
                     const Concepts::ImageGrid auto& grid) {
        return VTKHDFImageGridWriter{grid};
    }
    static auto make(const FileFormat::VTKHDFImage&,
                     const Concepts::ImageGrid auto& grid,
                     const Concepts::Communicator auto& comm) {
        return VTKHDFImageGridWriter{grid, comm};
    }
};

template<>
struct ReaderFactory<FileFormat::VTKHDFImage>
: APIDetail::DefaultReaderFactory<FileFormat::VTKHDFImage,
                                  VTKHDFImageGridReader,
                                  VTKHDFImageGridReader>
{};

template<> struct WriterFactory<FileFormat::VTKHDFImageTransient> {
    static auto make(const FileFormat::VTKHDFImageTransient& f,
                     const Concepts::ImageGrid auto& grid,
                     const std::string& base_filename) {
        if (f.opts.has_value())
            return VTKHDFImageGridTimeSeriesWriter{grid, base_filename, f.opts.value()};
        return VTKHDFImageGridTimeSeriesWriter{grid, base_filename};
    }
    static auto make(const FileFormat::VTKHDFImageTransient& f,
                     const Concepts::ImageGrid auto& grid,
                     const Concepts::Communicator auto& comm,
                     const std::string& base_filename) {
        if (f.opts.has_value())
            return VTKHDFImageGridTimeSeriesWriter{grid, comm, base_filename, f.opts.value()};
        return VTKHDFImageGridTimeSeriesWriter{grid, comm, base_filename};
    }
};

template<>
struct ReaderFactory<FileFormat::VTKHDFImageTransient>
: APIDetail::DefaultReaderFactory<FileFormat::VTKHDFImageTransient,
                                  VTKHDFImageGridReader,
                                  VTKHDFImageGridReader>
{};

template<> struct WriterFactory<FileFormat::VTKHDFUnstructured> {
    static auto make(const FileFormat::VTKHDFUnstructured&,
                     const Concepts::UnstructuredGrid auto& grid) {
        return VTKHDFUnstructuredGridWriter{grid};
    }
    static auto make(const FileFormat::VTKHDFUnstructured&,
                     const Concepts::UnstructuredGrid auto& grid,
                     const Concepts::Communicator auto& comm) {
        return VTKHDFUnstructuredGridWriter{grid, comm};
    }
};

template<>
struct ReaderFactory<FileFormat::VTKHDFUnstructured>
: APIDetail::DefaultTemplatedReaderFactory<FileFormat::VTKHDFUnstructured,
                                           VTKHDFUnstructuredGridReader<>,
                                           VTKHDFUnstructuredGridReader>
{};

template<> struct WriterFactory<FileFormat::VTKHDFUnstructuredTransient> {
    static auto make(const FileFormat::VTKHDFUnstructuredTransient& f,
                     const Concepts::UnstructuredGrid auto& grid,
                     const std::string& base_filename) {
        if (f.opts.has_value())
            return VTKHDFUnstructuredTimeSeriesWriter{grid, base_filename, f.opts.value()};
        return VTKHDFUnstructuredTimeSeriesWriter{grid, base_filename};
    }
    static auto make(const FileFormat::VTKHDFUnstructuredTransient& f,
                     const Concepts::UnstructuredGrid auto& grid,
                     const Concepts::Communicator auto& comm,
                     const std::string& base_filename) {
        if (f.opts.has_value())
            return VTKHDFUnstructuredTimeSeriesWriter{grid, comm, base_filename, f.opts.value()};
        return VTKHDFUnstructuredTimeSeriesWriter{grid, comm, base_filename};
    }
};

template<>
struct ReaderFactory<FileFormat::VTKHDFUnstructuredTransient>
: APIDetail::DefaultTemplatedReaderFactory<FileFormat::VTKHDFUnstructuredTransient,
                                           VTKHDFUnstructuredGridReader<>,
                                           VTKHDFUnstructuredGridReader>
{};

template<> struct WriterFactory<FileFormat::VTKHDF> {
    static auto make(const FileFormat::VTKHDF& format,
                     const Concepts::Grid auto& grid) {
        return _make(format.from(grid), grid);
    }
    static auto make(const FileFormat::VTKHDF& format,
                     const Concepts::Grid auto& grid,
                     const Concepts::Communicator auto& comm) {
        return _make(format.from(grid), grid, comm);
    }
 private:
    template<typename F, typename... Args>
    static auto _make(F&& format, Args&&... args) {
        return WriterFactory<F>::make(format, std::forward<Args>(args)...);
    }
};

template<>
struct ReaderFactory<FileFormat::VTKHDF>
: APIDetail::DefaultTemplatedReaderFactory<FileFormat::VTKHDF, VTKHDFReader<>, VTKHDFReader>
{};

template<> struct WriterFactory<FileFormat::VTKHDFTransient> {
    static auto make(const FileFormat::VTKHDFTransient& format,
                     const Concepts::Grid auto& grid,
                     const std::string& base_filename) {
        return _make(format.from(grid), grid, base_filename);
    }
    static auto make(const FileFormat::VTKHDFTransient& format,
                     const Concepts::Grid auto& grid,
                     const Concepts::Communicator auto& comm,
                     const std::string& base_filename) {
        return _make(format.from(grid), grid, comm, base_filename);
    }
 private:
    template<typename F, typename... Args>
    static auto _make(F&& format, Args&&... args) {
        return WriterFactory<F>::make(format, std::forward<Args>(args)...);
    }
};

template<>
struct ReaderFactory<FileFormat::VTKHDFTransient>
: APIDetail::DefaultTemplatedReaderFactory<FileFormat::VTKHDFTransient, VTKHDFReader<>, VTKHDFReader>
{};

template<typename F>
struct WriterFactory<FileFormat::PVD<F>> {
    static auto make(const FileFormat::PVD<F>& format,
                     const Concepts::Grid auto& grid,
                     const std::string& base_filename) {
        return PVDWriter{WriterFactory<F>::make(format.piece_format, grid), base_filename};
    }
    static auto make(const FileFormat::PVD<F>& format,
                     const Concepts::Grid auto& grid,
                     const Concepts::Communicator auto& comm,
                     const std::string& base_filename) {
        return PVDWriter{WriterFactory<F>::make(format.piece_format, grid, comm), base_filename};
    }
};

template<typename PieceFormat>
struct ReaderFactory<FileFormat::PVD<PieceFormat>>
: APIDetail::DefaultTemplatedReaderFactory<FileFormat::PVD<PieceFormat>, PVDReader<>, PVDReader>
{};

template<>
struct ReaderFactory<FileFormat::PVDClosure>
: APIDetail::DefaultTemplatedReaderFactory<FileFormat::PVDClosure, PVDReader<>, PVDReader>
{};
 

template<> struct WriterFactory<FileFormat::Any> {
 private:
    template<typename F, typename... Args>
    static auto _make(F&& format, Args&&... args) {
        return WriterFactory<F>::make(format, std::forward<Args>(args)...);
    }
 
 public:
    template<Concepts::Grid G>
    static constexpr auto default_format_for() {
        if constexpr (Concepts::ImageGrid<G> && !APIDetail::is_converter_grid<G>)
            return FileFormat::VTI{};
        else if constexpr (Concepts::RectilinearGrid<G> && !APIDetail::is_converter_grid<G>)
            return FileFormat::VTR{};
        else if constexpr (Concepts::StructuredGrid<G> && !APIDetail::is_converter_grid<G>)
            return FileFormat::VTS{};
        else if constexpr (Concepts::UnstructuredGrid<G>)
            return FileFormat::VTU{};
        else
            static_assert(APIDetail::always_false<G>, "Cannot deduce a default format for the given grid");
    }
 
    template<Concepts::Grid G>
    static auto make(const FileFormat::Any&, const G& grid) {
        return _make(default_format_for<G>(), grid);
    }
 
    template<Concepts::Grid G, Concepts::Communicator C>
    static auto make(const FileFormat::Any&, const G& grid, const C& comm) {
        return _make(default_format_for<G>(), grid, comm);
    }
};

template<> struct WriterFactory<FileFormat::AnyTimeSeries> {
    static auto make(const FileFormat::AnyTimeSeries&,
                     const Concepts::Grid auto& grid,
                     const std::string& base_filename) {
        return _make(grid, base_filename);
    }
 
    static auto make(const FileFormat::AnyTimeSeries&,
                     const Concepts::Grid auto& grid,
                     const Concepts::Communicator auto& comm,
                     const std::string& base_filename) {
        return _make(grid, comm, base_filename);
    }
 
 private:
    template<typename Grid, typename... Args>
    static auto _make(const Grid& grid, Args&&... args) {
        auto fmt = WriterFactory<FileFormat::Any>::template default_format_for<Grid>();
        auto ts_fmt = FileFormat::TimeSeriesClosure{}(fmt);
        return WriterFactory<decltype(ts_fmt)>::make(ts_fmt, grid, std::forward<Args>(args)...);
    }
};
 
#ifndef DOXYGEN
namespace APIDetail {
    inline bool has_hdf_file_extension(const std::string& filename) {
        return filename.ends_with(".hdf")
            || filename.ends_with(".hdf5")
            || filename.ends_with(".he5")
            || filename.ends_with(".h5");
    }
 
    template<std::derived_from<GridReader> Reader, typename Communicator>
    std::unique_ptr<Reader> make_reader(const Communicator& c) {
        if constexpr (std::is_same_v<Communicator, NullCommunicator> ||
                        !std::is_constructible_v<Reader, const Communicator&>)
            return std::make_unique<Reader>();
        else
            return std::make_unique<Reader>(c);
    }
 
    template<Concepts::Communicator C>
    std::unique_ptr<GridReader> make_reader_for(const std::string& filename, const C& c) {
        if (filename.ends_with(".vtu")) return make_reader<VTUReader>(c);
        else if (filename.ends_with(".vtp")) return make_reader<VTPReader>(c);
        else if (filename.ends_with(".vti")) return make_reader<VTIReader>(c);
        else if (filename.ends_with(".vtr")) return make_reader<VTRReader>(c);
        else if (filename.ends_with(".vts")) return make_reader<VTSReader>(c);
        else if (filename.ends_with(".pvtu")) return make_reader<PVTUReader>(c);
        else if (filename.ends_with(".pvtp")) return make_reader<PVTPReader>(c);
        else if (filename.ends_with(".pvti")) return make_reader<PVTIReader>(c);
        else if (filename.ends_with(".pvtr")) return make_reader<PVTRReader>(c);
        else if (filename.ends_with(".pvts")) return make_reader<PVTSReader>(c);
        else if (filename.ends_with(".pvd")) return make_reader<PVDReader<C>>(c);
#if GRIDFORMAT_HAVE_HIGH_FIVE
        else if (has_hdf_file_extension(filename)) return make_reader<VTKHDFReader<C>>(c);
#endif
        throw IOError("Could not deduce an available file format for '" + filename + "'");
    }
 
}  // namespace APIDetail
#endif  // DOXYGEN
 
// Implementation of the AnyReaderFactory function
template<Concepts::Communicator C>
std::unique_ptr<GridReader> AnyReaderFactory<C>::make_for(const std::string& filename) const {
    return APIDetail::make_reader_for(filename, _comm);
}

template<typename OutFormat, typename InFormat = FileFormat::Any>
struct ConversionOptions {
    OutFormat out_format = {};
    InFormat in_format = {};
    int verbosity = 0;
};

template<typename OutFormat,
         typename InFormat,
         typename Communicator = None>
std::string convert(const std::string& in,
                    const std::string& out,
                    const ConversionOptions<OutFormat, InFormat>& opts,
                    const Communicator& communicator = {}) {
    static constexpr bool use_communicator = !std::same_as<Communicator, None>;
    static_assert(
        !use_communicator || Concepts::Communicator<Communicator>,
        "Given communicator does not satisfy the communicator concepts."
    );
 
    using WriterDetail::has_parallel_factory;
    using WriterDetail::has_sequential_factory;
    using WriterDetail::has_parallel_time_series_factory;
    using WriterDetail::has_sequential_time_series_factory;
    using CG = ConverterDetail::ConverterGrid;
 
    static constexpr bool is_single_file_out_format = [&] () {
        if constexpr (use_communicator) return has_parallel_factory<OutFormat, CG, Communicator>;
        else return has_sequential_factory<OutFormat, CG>;
    } ();
 
    static constexpr bool is_time_series_out_format = [&] () {
        if constexpr (use_communicator) return has_parallel_time_series_factory<OutFormat, CG, Communicator>;
        else return has_sequential_time_series_factory<OutFormat, CG>;
    } ();
 
    if (opts.verbosity > 0)
        std::cout << "Opening '" << in << "'" << std::endl;
 
    auto reader = [&] () {
        if constexpr (use_communicator) return Reader{opts.in_format, communicator};
        else return Reader{opts.in_format};
    } ();
    reader.open(in);
    if constexpr (use_communicator)
        if (reader.number_of_pieces() > 1
            && reader.number_of_pieces() != static_cast<unsigned>(Parallel::size(communicator)))
            throw IOError(
                "Can only convert parallel files if the number of processes matches "
                "the number of processes that were used to write the original file "
                "(" + std::to_string(reader.number_of_pieces()) + ")"
            );
 
    const bool print_progress_output = opts.verbosity > 1 && [&] () {
        if constexpr (use_communicator) return GridFormat::Parallel::rank(communicator) == 0;
        else return true;
    } ();
 
    const auto step_call_back = [&] (std::size_t step_idx, const std::string& filename) {
        if (print_progress_output)
            std::cout << "Wrote step " << step_idx << " to '" << filename << "'" << std::endl;
    };
 
    const auto invoke_factory = [&] <typename Fmt, typename... T> (const Fmt& fmt, const auto& grid, T&&... args) {
        if constexpr (use_communicator)
            return WriterFactory<Fmt>::make(fmt, grid, communicator, std::forward<T>(args)...);
        else
            return WriterFactory<Fmt>::make(fmt, grid, std::forward<T>(args)...);
    };
 
    if constexpr (is_single_file_out_format) {
        if (reader.is_sequence())
            return convert(reader, [&] (const auto& grid) {
                return invoke_factory(FileFormat::TimeSeriesClosure{}(opts.out_format), grid, out);
            }, step_call_back);
 
        const auto filename = convert(reader, out, [&] (const auto& grid) {
            return invoke_factory(opts.out_format, grid);
        });
        if (print_progress_output)
            std::cout << "Wrote '" << filename << "'" << std::endl;
        return filename;
    } else if constexpr (is_time_series_out_format) {
        return convert(reader, [&] (const auto& grid) {
            return invoke_factory(opts.out_format, grid, out);
        }, step_call_back);
    } else {
        static_assert(
            APIDetail::always_false<OutFormat>,
            "No viable factory found for the requested format"
        );
    }
}
 
 
// We place the format instances in a namespace different from FileFormats, in which
// the format types are defined above. Further below, we make these instances available
// in the GridFormat namespace directly. Having a separate namespace allows downstream ´
// projects to expose the format instances in their own namespace without having to expose
// all of GridFormat. Also, separating the format types from the instances further allows
// "hiding" the former and only expose the latter.
namespace Formats {

 
inline constexpr FileFormat::Any any;
inline constexpr FileFormat::VTI vti;
inline constexpr FileFormat::VTR vtr;
inline constexpr FileFormat::VTS vts;
inline constexpr FileFormat::VTP vtp;
inline constexpr FileFormat::VTU vtu;
inline constexpr FileFormat::PVD pvd;
inline constexpr FileFormat::PVDClosure pvd_with;
inline constexpr FileFormat::TimeSeriesClosure time_series;
inline constexpr FileFormat::VTKHDF vtk_hdf;
inline constexpr FileFormat::VTKHDFTransient vtk_hdf_transient;


template<Concepts::Grid G>
constexpr auto default_for() { return WriterFactory<FileFormat::Any>::template default_format_for<G>(); }

template<Concepts::Grid G>
constexpr auto default_for(const G&) { return default_for<G>(); }
 
}  // namespace Formats
 
// expose format instances
using namespace Formats;
 
// bring the format instances into the FileFormat namespace
namespace FileFormat { using namespace Formats; }
 
}  // namespace GridFormat
 
#endif  // GRIDFORMAT_GRIDFORMAT_HPP_