pvdwriter.hh

Go to the documentation of this file.

#pragma once
 
#include <iosfwd>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include <tuple>
 
#include <dune/common/typeutilities.hh>
#include <dune/vtk/types.hh>
#include <dune/vtk/filewriter.hh>
 
namespace Dune::Vtk
{
  template <class W>
  class PvdWriter
      : public Vtk::FileWriter
  {
    using Self = PvdWriter;
 
  public:
    using Writer = W;
 
  public:
    explicit PvdWriter (std::shared_ptr<Writer> vtkWriter)
      : vtkWriter_(std::move(vtkWriter))
      , format_(vtkWriter_->getFormat())
      , datatype_(vtkWriter_->getDatatype())
    {}
 
    explicit PvdWriter (Writer& vtkWriter)
      : PvdWriter(stackobject_to_shared_ptr(vtkWriter))
    {}
 
    template <class... Args,
      disableCopyMove<Self,Args...> = 0>
    explicit PvdWriter (Args&&... args)
      : PvdWriter(std::make_shared<Writer>(std::forward<Args>(args)...))
    {}
 
 
    void writeTimestep (double time, std::string const& fn, std::optional<std::string> dir = {},
                        bool writeCollection = true) const;
 
    // NOTE: requires an aforegoing call to \ref writeTimestep
    std::string write (std::string const& fn, std::optional<std::string> dir = {}) const override;
 
    template <class Function, class... Args>
    PvdWriter& addPointData (Function const& fct, Args&&... args)
    {
      vtkWriter_->addPointData(fct, std::forward<Args>(args)...);
      return *this;
    }
 
    template <class Function, class... Args>
    PvdWriter& addCellData (Function const& fct, Args&&... args)
    {
      vtkWriter_->addCellData(fct, std::forward<Args>(args)...);
      return *this;
    }
 
  protected:
    void writeFile (std::ofstream& out) const;
 
  private:
    std::shared_ptr<Writer> vtkWriter_;
    Vtk::FormatTypes format_ = Vtk::FormatTypes::UNKNOWN;
    Vtk::DataTypes datatype_ = Vtk::DataTypes::UNKNOWN;
 
    mutable std::vector<std::pair<double, std::string>> timesteps_;
  };
 
} // end namespace Dune::Vtk
 
namespace Dune
{
  template <class VtkWriter>
  class [[deprecated("Use Vtk::PvdWriter instead.")]] PvdWriter
    : public Vtk::PvdWriter<VtkWriter>
  {
    using Base =  Vtk::PvdWriter<VtkWriter>;
  public:
    using Base::Base;
  };
 
} // end namespace Dune
 
#include "pvdwriter.impl.hh"