special_writer.hh

#ifndef SRC_SPECIAL_WRITER_HH
#define SRC_SPECIAL_WRITER_HH

#include <fstream>
#include <utility>

#include <dune/common/fvector.hh>
#include <dune/grid/utility/hierarchicsearch.hh>
#include <dune/fufem/functions/virtualgridfunction.hh>

#include "mygeometry.hh"

template <class GridView, int dimension> class SpecialWriter {
  using LocalVector = Dune::FieldVector<double, dimension>;
  using Element = typename GridView::Grid::template Codim<0>::Entity;
  using ElementPointer =
      typename GridView::Grid::template Codim<0>::EntityPointer;

  void writeHorizontal(LocalVector const &v) {
    writer_ << MyGeometry::horizontalProjection(v) << " ";
  }
  void writeVertical(LocalVector const &v) {
    writer_ << MyGeometry::verticalProjection(v) << " ";
  }

  std::pair<ElementPointer, LocalVector> globalToLocal(LocalVector const &x)
      const {
    auto const element = hsearch_.findEntity(x);
    return std::pair<ElementPointer, LocalVector>(element,
                                                  element->geometry().local(x));
  }

  std::fstream writer_;

  Dune::HierarchicSearch<typename GridView::Grid, GridView> const hsearch_;

  std::pair<ElementPointer, LocalVector> const G;
  std::pair<ElementPointer, LocalVector> const H;
  std::pair<ElementPointer, LocalVector> const J;
  std::pair<ElementPointer, LocalVector> const I;
  std::pair<ElementPointer, LocalVector> const U;
  std::pair<ElementPointer, LocalVector> const Z;

public:
  SpecialWriter(std::string filename, GridView const &gridView)
      : writer_(filename, std::fstream::out),
        hsearch_(gridView.grid(), gridView),
        G(globalToLocal(MyGeometry::G)),
        H(globalToLocal(MyGeometry::H)),
        J(globalToLocal(MyGeometry::J)),
        I(globalToLocal(MyGeometry::I)),
        U(globalToLocal(MyGeometry::U)),
        Z(globalToLocal(MyGeometry::Z)) {
    writer_ << "Gh Hh Jh Ih Uv Uh Zv Zh" << std::endl;
  }

  void write(VirtualGridFunction<typename GridView::Grid, LocalVector> const &
                 specialField) {
    LocalVector value;

    specialField.evaluateLocal(*G.first, G.second, value);
    writeHorizontal(value);

    specialField.evaluateLocal(*H.first, H.second, value);
    writeHorizontal(value);

    specialField.evaluateLocal(*J.first, J.second, value);
    writeHorizontal(value);

    specialField.evaluateLocal(*I.first, I.second, value);
    writeHorizontal(value);

    specialField.evaluateLocal(*U.first, U.second, value);
    writeVertical(value);
    writeHorizontal(value);

    specialField.evaluateLocal(*Z.first, Z.second, value);
    writeVertical(value);
    writeHorizontal(value);

    writer_ << std::endl;
  }
};
#endif