vtkwriterbase.hh

Go to the documentation of this file.

#pragma once
 
#include <iosfwd>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <type_traits>
#include <vector>
 
#include <dune/common/parallel/mpihelper.hh>
#include <dune/vtk/filewriter.hh>
#include <dune/vtk/types.hh>
#include <dune/vtk/gridfunctions/gridfunction.hh>
 
namespace Dune::Vtk
{
 
  template <class GV, class DC>
  class VtkWriterBase
      : public Vtk::FileWriter
  {
    template <class> friend class TimeseriesWriter;
    template <class> friend class PvdWriter;
 
    static_assert(not std::is_reference_v<DC> and not std::is_const_v<DC>, "Passing const or reference types as DataCollector is not supported");
 
  public:
    using GridView = GV;
    using DataCollector = DC;
 
  protected:
    using VtkFunction = Dune::Vtk::GridFunction<GridView>;
    using Domain = typename GridView::template Codim<0>::Entity::Geometry::GlobalCoordinate;
    using pos_type = typename std::ostream::pos_type;
 
    enum PositionTypes {
      POINT_DATA,
      CELL_DATA
    };
 
  public:
 
    VtkWriterBase (GridView const& gridView,
                   Vtk::FormatTypes format = Vtk::FormatTypes::BINARY,
                   Vtk::DataTypes datatype = Vtk::DataTypes::FLOAT32,
                   Vtk::DataTypes headertype = Vtk::DataTypes::UINT32)
      : VtkWriterBase(std::make_shared<DataCollector>(gridView), format, datatype, headertype)
    {}
 
    VtkWriterBase (DataCollector& dataCollector,
                   Vtk::FormatTypes format = Vtk::FormatTypes::BINARY,
                   Vtk::DataTypes datatype = Vtk::DataTypes::FLOAT32,
                   Vtk::DataTypes headertype = Vtk::DataTypes::UINT32)
      : VtkWriterBase(stackobject_to_shared_ptr(dataCollector), format, datatype, headertype)
    {}
 
    VtkWriterBase (DataCollector&& dataCollector,
                   Vtk::FormatTypes format = Vtk::FormatTypes::BINARY,
                   Vtk::DataTypes datatype = Vtk::DataTypes::FLOAT32,
                   Vtk::DataTypes headertype = Vtk::DataTypes::UINT32)
      : VtkWriterBase(std::make_shared<DataCollector>(std::move(dataCollector)), format, datatype, headertype)
    {}
 
    VtkWriterBase (std::shared_ptr<DataCollector> dataCollector,
                   Vtk::FormatTypes format = Vtk::FormatTypes::BINARY,
                   Vtk::DataTypes datatype = Vtk::DataTypes::FLOAT32,
                   Vtk::DataTypes headertype = Vtk::DataTypes::UINT32)
      : dataCollector_(std::move(dataCollector))
    {
      setFormat(format);
      setDatatype(datatype);
      setHeadertype(headertype);
    }
 
 
 
    virtual std::string write (std::string const& fn, std::optional<std::string> dir = {}) const override;
 
 
    template <class Function>
    VtkWriterBase& addPointData (Function&& fct, const Vtk::FieldInfo& info)
    {
      pointData_.emplace_back(std::forward<Function>(fct), info);
      return *this;
    }
 
    template <class Function,
      class R = RangeType<ResolveRef_t<Function>,Domain>>
    VtkWriterBase& addPointData (Function&& fct, std::string name, int size = dimRange<R>())
    {
      pointData_.emplace_back(std::forward<Function>(fct),
        Vtk::FieldInfo{name, size, datatype_, RangeTypes::AUTO});
      return *this;
    }
 
    VtkWriterBase& addPointData (const std::shared_ptr<VTKFunction<GridView> const>& fct)
    {
      pointData_.emplace_back(VTKFunctionWrapper<GridView>(fct),
        Vtk::FieldInfo{fct->name(), fct->ncomps(), dataTypeOf(fct->precision()), rangeTypeOf(fct->ncomps())});
      return *this;
    }
 
    VtkWriterBase& addPointData (const Vtk::GridFunction<GridView>& fct)
    {
      pointData_.emplace_back(fct);
      return *this;
    }
 
 
    template <class Function>
    VtkWriterBase& addCellData (Function&& fct, const Vtk::FieldInfo& info)
    {
      cellData_.emplace_back(std::forward<Function>(fct), info);
      return *this;
    }
 
    template <class Function,
      class R = RangeType<ResolveRef_t<Function>,Domain>>
    VtkWriterBase& addCellData (Function&& fct, std::string name, int size = dimRange<R>())
    {
      cellData_.emplace_back(std::forward<Function>(fct),
        Vtk::FieldInfo{name, size, datatype_, RangeTypes::AUTO});
      return *this;
    }
 
    VtkWriterBase& addCellData (const std::shared_ptr<VTKFunction<GridView> const>& fct)
    {
      cellData_.emplace_back(VTKFunctionWrapper<GridView>(fct),
        Vtk::FieldInfo{fct->name(), fct->ncomps(), dataTypeOf(fct->precision()), rangeTypeOf(fct->ncomps())});
      return *this;
    }
 
    VtkWriterBase& addCellData (const Vtk::GridFunction<GridView>& fct)
    {
      cellData_.emplace_back(fct);
      return *this;
    }
 
    // Sets the VTK file format
    void setFormat (Vtk::FormatTypes format)
    {
      format_ = format;
 
      if (format_ == Vtk::FormatTypes::COMPRESSED &&
          compressor_ == Vtk::CompressorTypes::NONE) {
#if HAVE_VTK_ZLIB
        compressor_ = Vtk::CompressorTypes::ZLIB;
#else
        std::cout << "Dune is compiled without ZLIB. Falling back to BINARY VTK output!\n";
        format_ = Vtk::FormatTypes::BINARY;
#endif
      } else {
        compressor_ = Vtk::CompressorTypes::NONE;
      }
 
    }
 
    void setDatatype (Vtk::DataTypes datatype)
    {
      datatype_ = datatype;
    }
 
    void setHeadertype (Vtk::DataTypes datatype)
    {
      headertype_ = datatype;
    }
 
    void setCompressor (Vtk::CompressorTypes compressor, int level = -1)
    {
      compressor_ = compressor;
      compression_level = level;
      VTK_ASSERT(level >= -1 && level <= 9);
 
      if (compressor_ != Vtk::CompressorTypes::NONE)
        format_ = Vtk::FormatTypes::COMPRESSED;
    }
 
  private:
    virtual void writeSerialFile (std::ofstream& out) const = 0;
 
    virtual void writeParallelFile (std::ofstream& out, std::string const& pfilename, int size) const = 0;
 
    virtual std::string fileExtension () const = 0;
 
    virtual void writeGridAppended (std::ofstream& out, std::vector<std::uint64_t>& blocks) const = 0;
 
  protected:
    // Write the point or cell values given by the grid function `fct` to the
    // output stream `out`. In case of binary format, append the streampos of XML
    // attributes "offset" to the vector `offsets`.
    void writeData (std::ofstream& out,
                    std::vector<pos_type>& offsets,
                    VtkFunction const& fct,
                    PositionTypes type,
                    std::optional<std::size_t> timestep = {}) const;
 
    // Write point-data and cell-data in raw/compressed format to output stream
    void writeDataAppended (std::ofstream& out, std::vector<std::uint64_t>& blocks) const;
 
    // Write the coordinates of the vertices to the output stream `out`. In case
    // of binary format, appends the streampos of XML attributes "offset" to the
    // vector `offsets`.
    void writePoints (std::ofstream& out,
                      std::vector<pos_type>& offsets,
                      std::optional<std::size_t> timestep = {}) const;
 
    // Write Appended section and fill-in offset values to XML attributes
    void writeAppended (std::ofstream& out, std::vector<pos_type> const& offsets) const;
 
    // Write the `values` in blocks (possibly compressed) to the output
    // stream `out`. Return the written block size.
    template <class HeaderType, class FloatType>
    std::uint64_t writeValuesAppended (std::ofstream& out, std::vector<FloatType> const& values) const;
 
    // Write the `values` in a space and newline separated list of ascii representations.
    // The precision is controlled by the datatype and numerical_limits::digits10.
    template <class T>
    void writeValuesAscii (std::ofstream& out, std::vector<T> const& values) const;
 
    // Write the XML file header of a VTK file `<VTKFile ...>`
    void writeHeader (std::ofstream& out, std::string const& type) const;
 
    std::string getNames (std::vector<VtkFunction> const& data) const;
 
    // Returns endianness
    std::string getEndian () const
    {
      short i = 1;
      return (reinterpret_cast<char*>(&i)[1] == 1 ? "BigEndian" : "LittleEndian");
    }
 
    // provide accessor to \ref fileExtension virtual method
    std::string getFileExtension () const
    {
      return fileExtension();
    }
 
    // Returns the VTK file format initialized in the constructor
    Vtk::FormatTypes getFormat () const
    {
      return format_;
    }
 
    // Returns the global datatype used for coordinates and other global float values
    Vtk::DataTypes getDatatype () const
    {
      return datatype_;
    }
 
    // Return the MPI communicator of the grid.
    auto comm () const
    {
      return dataCollector_->comm();
    }
 
  protected:
    std::shared_ptr<DataCollector> dataCollector_;
 
    Vtk::FormatTypes format_;
    Vtk::DataTypes datatype_;
    Vtk::DataTypes headertype_;
    Vtk::CompressorTypes compressor_ = Vtk::CompressorTypes::NONE;
 
    // attached data
    std::vector<VtkFunction> pointData_;
    std::vector<VtkFunction> cellData_;
 
    std::size_t const block_size = 1024*32;
    int compression_level = -1; // in [0,9], -1 ... use default value
  };
 
 
  template <class Writer>
  struct IsVtkWriter
  {
    template <class GV, class DC>
    static std::uint16_t test(VtkWriterBase<GV,DC> const&);
    static std::uint8_t  test(...); // fall-back overload
 
    static constexpr bool value = sizeof(test(std::declval<Writer>())) > sizeof(std::uint8_t);
  };
 
} // end namespace Dune::Vtk
 
#include "vtkwriterbase.impl.hh"