VTKSequenceWriter.hpp

#pragma once
 
#include <vector>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <memory>
 
#include <dune/grid/io/file/vtk/common.hh>
#include <dune/common/path.hh>
 
#include <dune/grid/io/file/vtk/vtkwriter.hh>
 
#include <amdis/Environment.hpp>
 
namespace AMDiS
{
 
  template <class GridView>
  class VTKSequenceWriter
  {
    using VTKWriter = Dune::VTKWriter<GridView>;
 
  public:
 
    VTKSequenceWriter(std::shared_ptr<VTKWriter> vtkWriter)
      : vtkWriter_(std::move(vtkWriter))
    {}
 
 
    template <class... Args>
    VTKSequenceWriter(GridView const& gridView, Args&&... args)
      : VTKSequenceWriter<GridView>(std::make_shared<VTKWriter>(gridView, FWD(args)...))
    {}
 
    virtual ~VTKSequenceWriter() = default;
 
    std::shared_ptr<VTKWriter> const& vtkWriter() const
    {
      return vtkWriter_;
    }
 
    template <class... Args>
    void addCellData(Args&&... args)
    {
      vtkWriter_->addCellData(FWD(args)...);
    }
 
    template <class... Args>
    void addVertexData (Args&&... args)
    {
      vtkWriter_->addVertexData(FWD(args)...);
    }
 
 
    virtual void write(double time, std::string const& name, Dune::VTK::OutputType type = Dune::VTK::ascii)
    {
      pwrite(time, name, ".", "", type);
    }
 
 
    virtual void pwrite(double time, std::string const& name, std::string const& path, std::string const& extendpath,
                        Dune::VTK::OutputType type = Dune::VTK::ascii)
    {
      // remember current time step
      unsigned int count = timesteps_.size();
      timesteps_.push_back(time);
 
      // write VTK file
      vtkWriter_->pwrite(seqName(name, count), Dune::concatPaths(path, extendpath), "", type);
 
      // write pvd file ... only on rank 0
      if (Environment::mpiRank() == 0) {
        std::ofstream pvdFile;
        pvdFile.exceptions(std::ios_base::badbit | std::ios_base::failbit |
                           std::ios_base::eofbit);
        std::string pvdname = path + "/" + name + ".pvd";
        pvdFile.open(pvdname.c_str());
        pvdFile << "<?xml version=\"1.0\"?>\n"
                << "<VTKFile type=\"Collection\" version=\"0.1\" byte_order=\"" << Dune::VTK::getEndiannessString() << "\">\n"
                << "<Collection>\n";
        for (unsigned int i = 0; i <= count; ++i) {
          std::string piecepath = extendpath;
          std::string fullname = getParallelHeaderName(seqName(name,i), piecepath, Environment::mpiSize());
          pvdFile << "<DataSet timestep=\"" << timesteps_[i]
                  << "\" part=\"0\" file=\""
                  << fullname << "\"/>\n";
        }
        pvdFile << "</Collection>\n"
                << "</VTKFile>\n" << std::flush;
        pvdFile.close();
      }
    }
 
  protected:
    // create sequence name
    static std::string seqName(std::string const& name, unsigned int count)
    {
      std::stringstream n;
      n.fill('0');
      n << name << "-" << std::setw(5) << count;
      return n.str();
    }
 
    static std::string getParallelHeaderName(std::string const& name, std::string const& path, int commSize)
    {
      std::ostringstream s;
      if (path.size() > 0) {
        s << path;
        if (path[path.size()-1] != '/')
          s << '/';
      }
      s << 's' << std::setw(4) << std::setfill('0') << commSize << '-';
      s << name;
      if (GridView::dimension > 1)
        s << ".pvtu";
      else
        s << ".pvtp";
      return s.str();
    }
 
  private:
    std::shared_ptr<VTKWriter> vtkWriter_;
    std::vector<double> timesteps_;
  };
 
} // end namespace AMDiS