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 <dune/amdis/Initfile.hpp>
#include <dune/amdis/io/FileWriterInterface.hpp>
#include <dune/amdis/utility/Filesystem.hpp>

namespace AMDiS
{
  template <class Traits, class TreePath>
  class FileWriter
      : public FileWriterInterface
  {
  private: // typedefs and static constants

    using GlobalBasis = typename Traits::GlobalBasis;

    using GridView = typename GlobalBasis::GridView;

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

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

    using Vector = DOFVector<GlobalBasis>;



  public:
    /// Constructor.
    FileWriter(std::string baseName,
               std::shared_ptr<GlobalBasis> const& basis,
               TreePath const& tp,
               std::shared_ptr<Vector> const& vector)
      : FileWriterInterface(baseName)
      , basis_(basis)
      , treePath_(tp)
      , vector_(vector)
    {
      //int subSampling = Parameters::get<int>(baseName + "->subsampling").value_or(0);

      //if (subSampling > 0)
      //  vtkWriter_ = std::make_shared<Dune::SubsamplingVTKWriter<GridView>>(basis_->gridView(), subSampling);
      //else
      vtkWriter_ = std::make_shared<Dune::VTKWriter<GridView>>(basis_->gridView());

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

      mode_ = Parameters::get<int>(baseName + "->ParaView mode").value_or(0);
    }


    /// Implements \ref FileWriterInterface::writeFiles
    virtual void writeFiles(AdaptInfo& adaptInfo, bool force) override
    {
      using Tree = typename GlobalBasis::LocalView::Tree;
      using Node = typename Dune::TypeTree::ChildForTreePath<Tree, TreePath>;

      writeVertexData(typename Node::NodeTag{}, index_<Node::CHILDREN>, [&,this]()
      {
        if (mode_ == 0)
          vtkSeqWriter_->write(adaptInfo.getTime(), Dune::VTK::ascii);
        else if (mode_ == 1)
          vtkSeqWriter_->write(adaptInfo.getTime(), Dune::VTK::appendedraw);
      });
    }

  protected:
    template <class W>
    void writeVertexData(Dune::TypeTree::LeafNodeTag, index_t<0>, W write)
    {
      using Dune::Functions::BasisBuilder::makeBasis;
      using Dune::Functions::BasisBuilder::lagrange;
      auto fct = makeDiscreteFunctionPtr(basis_,treePath_,vector_);

      auto p1basis = makeBasis(basis_->gridView(), lagrange<1>());
      auto data = makeDOFVector(p1basis, name_);
      interpolate(p1basis, data, *fct);

      auto dataFct = Dune::Functions::makeDiscreteGlobalBasisFunction<double>(p1basis,data);

      vtkWriter_->addVertexData(dataFct, Dune::VTK::FieldInfo(name_, Dune::VTK::FieldInfo::Type::scalar, 1));
      write();
      vtkWriter_->clear();
    }

    template <std::size_t C, class W>
    void writeVertexData(Dune::TypeTree::PowerNodeTag, index_t<C>, W write)
    {
      using Dune::Functions::BasisBuilder::makeBasis;
      using Dune::Functions::BasisBuilder::lagrange;
      using Dune::Functions::BasisBuilder::power;
      using Dune::Functions::BasisBuilder::flatLexicographic;

      assert( C == dow );
      auto fct = makeDiscreteFunctionPtr(basis_,treePath_,vector_);

      auto p1basis = makeBasis(basis_->gridView(), power<C>(lagrange<1>(), flatLexicographic()));
      auto data = makeDOFVector(p1basis, name_);
      interpolate(p1basis, data, *fct);

      using Range = Dune::FieldVector<double,C>;
      auto dataFct = Dune::Functions::makeDiscreteGlobalBasisFunction<Range>(p1basis,data);

      vtkWriter_->addVertexData(dataFct, Dune::VTK::FieldInfo(name_, Dune::VTK::FieldInfo::Type::vector, C));
      write();
      vtkWriter_->clear();
    }

    template <class NodeTag, std::size_t C, class W>
    void writeVertexData(NodeTag, index_t<C>, W) {}

  private:
    std::shared_ptr<GlobalBasis> basis_;
    TreePath treePath_;
    std::shared_ptr<Vector> vector_;

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

    // std::vector<double> data_vector;

    // represents VTK::OutputType: 0...ascii, 1...appendedraw
    int mode_;
  };


  template <class Traits, class GlobalBasis, class TreePath, class Vector>
  std::shared_ptr<FileWriter<Traits,TreePath>> makeFileWriterPtr(
      std::string baseName,
      std::shared_ptr<GlobalBasis> const& basis,
      TreePath const& tp,
      std::shared_ptr<Vector> const& vector)
  {
    return std::make_shared<FileWriter<Traits,TreePath>>(baseName, basis, tp, vector);
  }

} // end namespace AMDiS