FileWriter.hpp

#pragma once

#include <string>
#include <memory>

#include <dune/functions/functionspacebases/lagrangebasis.hh>
#include <dune/grid/io/file/vtk/vtkwriter.hh>
#include <dune/grid/io/file/vtk/vtksequencewriter.hh>
//#include <dune/geometry/referenceelements.hh>
#include <dune/typetree/childextraction.hh>

#include <amdis/Initfile.hpp>
#include <amdis/common/Size.hpp>
#include <amdis/common/ValueCategory.hpp>
#include <amdis/gridfunctions/DiscreteFunction.hpp>
#include <amdis/io/FileWriterInterface.hpp>
#include <amdis/utility/Filesystem.hpp>

namespace AMDiS
{
  namespace Impl
  {
    template <class Tag> struct VTKFieldTypeImpl;
    template <>
    struct VTKFieldTypeImpl<tag::scalar> {
      static const Dune::VTK::FieldInfo::Type value = Dune::VTK::FieldInfo::Type::scalar;
    };
    template <>
    struct VTKFieldTypeImpl<tag::vector> {
      static const Dune::VTK::FieldInfo::Type value = Dune::VTK::FieldInfo::Type::vector;
    };
    template <>
    struct VTKFieldTypeImpl<tag::matrix> {
      static const Dune::VTK::FieldInfo::Type value = Dune::VTK::FieldInfo::Type::tensor;
    };

  } // end namespace Impl

  template <class Range>
  constexpr Dune::VTK::FieldInfo::Type VTKFieldType = Impl::VTKFieldTypeImpl<ValueCategory_t<Range>>::value;

  template <class Range>
  constexpr std::size_t VTKFieldSize = Size_v<Range>;


  template <class GB, class VT, class TP>
  class FileWriter
      : public FileWriterInterface
  {
    using GlobalBasis = GB;
    using ValueType = VT;
    using TreePath = TP;

  private:
    using GridView = typename GlobalBasis::GridView;
    using Range = typename DiscreteFunction<GB,VT,TP>::Range;

    /// Dimension of the mesh
    static constexpr int dim = GridView::dimension;

    /// Dimension of the world
    static constexpr int dow = GridView::dimensionworld;

  public:
    /// Constructor.
    FileWriter(std::string const& name, DiscreteFunction<GB,VT,TP> const& discreteFct)
      : FileWriterInterface(name)
      , discreteFct_(discreteFct)
      , animation_(false)
    {
      Parameters::get(name + "->ParaView animation", animation_);

      int m = Parameters::get<int>(name + "->ParaView mode").value_or(0);
      mode_ = (m == 0 ? Dune::VTK::ascii : Dune::VTK::appendedraw);

      init(name, ValueCategory_t<Range>{});
    }

    template <class ValueCat>
    void init(std::string const& baseName, ValueCat)
    {
      auto subSampling = Parameters::get<int>(baseName + "->subsampling");
      if (subSampling)
        vtkWriter_ = std::make_shared<Dune::SubsamplingVTKWriter<GridView>>(gridView(), subSampling.value());
      else
        vtkWriter_ = std::make_shared<Dune::VTKWriter<GridView>>(gridView());

      if (animation_)
        vtkSeqWriter_ = std::make_shared<Dune::VTKSequenceWriter<GridView>>(vtkWriter_, filename_, dir_, "");

      vtkWriter_->addVertexData(discreteFct_, Dune::VTK::FieldInfo(name_, VTKFieldType<Range>, VTKFieldSize<Range>));
    }

    void init(std::string const&, tag::unknown) {}

    /// Implements \ref FileWriterInterface::writeFiles
    virtual void writeFiles(AdaptInfo& adaptInfo, bool force) override
    {
      test_exit(filesystem::exists(dir_), "Output directory '{}' does not exist!",dir_);

      if (vtkSeqWriter_)
        vtkSeqWriter_->write(adaptInfo.time(), mode_);
      else if (vtkWriter_)
        vtkWriter_->write(filesystem::path({dir_, filename_}).string(), mode_);
    }

  protected:
    GridView const& gridView() const
    {
      return discreteFct_.basis().gridView();
    }

  private:
    DiscreteFunction<GB,VT,TP> discreteFct_;

    std::shared_ptr<Dune::VTKWriter<GridView>> vtkWriter_;
    std::shared_ptr<Dune::VTKSequenceWriter<GridView>> vtkSeqWriter_;

    // write .pvd if animation=true, otherwise write only .vtu
    bool animation_;

    // represents VTK::OutputType: ascii, appendedraw
    Dune::VTK::OutputType mode_;
  };

  template <class GlobalBasis, class ValueType, class TreePath>
  auto makeFileWriter(std::string const& name,
      DiscreteFunction<GlobalBasis,ValueType,TreePath> const& discreteFct)
  {
    return FileWriter<GlobalBasis,ValueType,TreePath>{name, discreteFct};
  }

  template <class GlobalBasis, class ValueType, class TreePath>
  auto makeFileWriterPtr(std::string const& name,
      DiscreteFunction<GlobalBasis,ValueType,TreePath> const& discreteFct)
  {
    return std::make_unique<FileWriter<GlobalBasis,ValueType,TreePath>>(name, discreteFct);
  }

} // end namespace AMDiS