VtuPlot.hpp

#ifndef VTUPLOT_H
#define VTUPLOT_H

#include "Algebra.hpp"

enum PlotStatus {
  CLEAR,
  FLUSH,
  SAVE
};


class PointData {
  vector<double> data;
public:
  explicit PointData(int dim = 1) : data(dim) {}

  PointData(const vector<double> &d) : data(d.size()) {
    for (int i = 0; i < d.size(); i++)
      data[i] = d[i];
  }

  void AddData(int index, double d) { data[index] = d; }

  double GetData(int i) { return data.at(i); }

  // TODO: Research vector.back()
  double PlotData() { return data.back(); }
};

/**
 * Helper Class to allow lazy initialization of Mesh references.
 * PlotMesh is never responsible for cleaning up the underlying pointer!
 */
class PlotMesh {
  const Mesh *mesh = nullptr;
public:
  PlotMesh() = default;

  explicit PlotMesh(const Mesh &other) {
    (*this).mesh = &other;
  }

  void operator()(const Mesh &other) {
    (*this).mesh = &other;
  }

  const Mesh &operator()() const {
    return *mesh;
  }

  bool IsInstatiated() const {
    return mesh != nullptr;
  }

  void Reset(){
    mesh = nullptr;
  }
};

/**
 * A VtuPlotter Object is responsible for creating .vtu files using vtks XML-format.
 */
class VtuPlot {
protected:
  string dataPath = Config::getDataPath() + "vtu/";
  string plotName{"default"};

  PlotMesh plotMesh;

  int pointN = 0;
  int cellN = 0;

  string cellConnectivity{""};
  string cellOffset{""};
  string cellTypes{""};

  std::pair<string, string> activeArrays = {"", ""};

  std::unordered_map<int, Point> points{};
  std::unordered_map<int, Point> displacement{};

  std::unordered_map<string, std::unordered_map<Point, PointData> *> pointData{};
  std::unordered_map<string, int> pointDataSize{};

  std::unordered_map<int, Point> cells{};
  std::unordered_map<string, std::unordered_map<Point, PointData> *> cellData{};
  std::unordered_map<string, int> cellDataSize{};

  // == Default linebreak and indentation arguments ==
  int lineBreakP = 5;
  int lineBreakC = 8;
  int lineBreakZ = 16;
  string standardIndent = "  ";

  string plotIndent(int i);

  string plotLineBreak(int i, int limit, int indent = 0);

  void plotPoint(std::ostream &os, const Point &p);
  // =================================================

  void createVtu(const string &filename, const string& filecontent);


  int pointID(const Point &p) {
    return (int) pointData["ID"]->at(p).GetData(0);
  }

public:
  VtuPlot() : plotMesh() {}

  explicit VtuPlot(const Mesh &init) : plotMesh(init){};

  /// Creates a Plotter where the Vector init defines the Grid on which the VtuPlotter operates.
  explicit VtuPlot(const Vector &init) : VtuPlot(init.GetMesh()) {};

  int DataCount() {
    return pointData.size() + cellData.size();
  }

  void FileName(const string &name) { plotName = name; }
  const std::string& FileName() const { return plotName; }

  void ChangeDataPath(const string &dataPath) {
    this->dataPath = dataPath;
  }

  /**
   * Adds a deformation on all Points of the grid. The initial Grid is not distorted, the deformation
   * is applied at the time of plotting.
   *
   * @param deformation Vector containing the displacement of all points (not the new location, just the
   *                      difference from their stating position).
   */
  virtual void DeformGrid(const Vector &diplacement) = 0;

  virtual void AddData(const string &name, const Vector& data) = 0;
  /**
   * Adds a PointData Container to the plotted file.
   *
   * @param name Name of the DataContainer. This name is shown in Paraview when selecting the specified vector.
   * @param data Contains the data to be plotted.
   * @param dim
   */
 //virtual void AddPointData(const string &name, const Vector &data) = 0;

  /**
   * Adds a CellData Container to the plotted file. As a Vector typically stores values in the vertices of the mesh,
   * a cell average is calculated.
   *
   * @param name Name of the DataContainer. This name is shown in Paraview when selecting the specified vector.
   * @param data Contains the data to be plotted.
   * @param dim
   */
  //virtual void AddCellData(const string &name, const Vector &data) = 0;

  /**
   * Adds a CellData Container containing the subdomain of each cell.
   *
   * @param grid Vector containing the current mesh, including possibly changed subdomains
   */
  virtual void AddSubdomain(const Mesh &grid) = 0;

  void AddSubdomain() { AddSubdomain(plotMesh()); }

  void AddSubdomain(const Vector &gridVector) { AddSubdomain(gridVector.GetMesh()); }

  virtual void AddProcLoad(const Mesh &grid) = 0;

  void AddProcLoad() { AddSubdomain(plotMesh()); }

  void AddProcLoad(const Vector &gridVector) { AddSubdomain(gridVector.GetMesh()); }

  virtual string FileString();
  virtual void PlotFile(const string &filename) = 0;
  virtual void PlotFile() { PlotFile(plotName); };

  void ClearData();
  void ClearMesh();
  void Erase();
  void Flush(PlotStatus s);

  ~VtuPlot() {
    ClearData();
  }

  void plotData(std::ostream &os, const Point &p);
};

class SerialVtuPlot : public VtuPlot {
  void initialize(const Mesh& init);
  void initPoints(const Mesh &init);
  void initCells(const Mesh &init);

  void checkMesh(const Mesh& init);

  void addPointData(const string& name, const Vector& data);
  void addCellData(const string& name, const Vector& data);
public:

  SerialVtuPlot();
  explicit SerialVtuPlot(const Mesh &init);

  /// Creates a Plotter where the Vector init defines the Grid on which the VtuPlotter operates.
  explicit SerialVtuPlot(const Vector &init) : SerialVtuPlot(init.GetMesh()) {}

  void AddData(const string& name, const Vector& data) override;

  void PlotFile(const string &filename) override;

  void DeformGrid(const Vector &diplacement) override;

  void AddSubdomain(const Mesh &grid) override;

  void AddProcLoad(const Mesh &grid) override;

  int dataDim(int dim) const;
};

// TODO: Reimplement
/*
class ParallelVtuPlot : public VtuPlot {

  void createMasterFile(const string &filename);

public:
  explicit ParallelVtuPlot(const Mesh &init);

  /// Creates a Plotter where the Vector init defines the Grid on which the VtuPlotter operates.
  explicit ParallelVtuPlot(const Vector &init) : ParallelVtuPlot(init.GetMesh()) {}

  void PlotFile(const string &filename, bool flush) override;

  void DeformGrid(const Vector &diplacement) override;

  void AddPointData(const string &name, const Vector &data, int dim) override;

  void AddCellData(const string &name, const Vector &data, int dim) override;

  void AddSubdomain(const Mesh &grid) override;

  void AddProcLoad(const Mesh &grid) override;
};
*/

int vtkCellType(CELLTYPE cType);

VtuPlot &operator<<(VtuPlot &plot, const Vector &v);
VtuPlot &operator<<(VtuPlot &plot, PlotStatus status);
VtuPlot &operator<<(VtuPlot &plot, const string &name);

// Use as global macro to quickly save plot
VtuPlot &operator<<(VtuPlot &plot, const std::pair<std::string, PlotStatus>& saveoptions);

#endif //VTUPLOT_H