PDESolver.hpp

#ifndef PDESOLVER_HPP
#define PDESOLVER_HPP

#include "IStochasticDummyAssemble.hpp"
#include "Sample.hpp"

#include "TimeIntegrator.hpp"
#include "Newton.hpp"
#include "GMRES.hpp"
#include "Plotting.hpp"

#include <typeinfo>


class PDESolver {
protected:
  int verbose = 1;

  int plotting = 0;

  const Meshes &meshes;

  std::string quantity;

  std::string costMeasure;

  virtual void run(SampleSolution &solution) = 0;

  virtual void computeQ(SampleSolution &solution) = 0;

  virtual void computeCost(SampleSolution &solution) = 0;

  virtual void plotSolution(SampleSolution &solution) = 0;

public:
  PDESolver(const Meshes &meshes, const std::string &quantity,
            const std::string &costMeasure) :
    meshes(meshes), quantity(quantity), costMeasure(costMeasure) {
    config.get("PDESolverVerbose", verbose);
    config.get("PDESolverPlotting", plotting);
  }

  virtual ~PDESolver() {};

  virtual void PrintInfo() const {
    if (verbose > 0)
      mout.PrintInfo(Name(), verbose,
                     PrintInfoEntry("Quantity", quantity),
                     PrintInfoEntry("Cost measure", costMeasure));
  }

  void Run(SampleSolution &solution) {
    mout.StartBlock("PDE Solver");
    vout(2) << solution.IdString() << endl;
    run(solution);
    computeQ(solution);
    computeCost(solution);
    plotSolution(solution);
    vout(2) << "Q=" << solution.Q << " cost=" << solution.Cost << endl;
    mout.EndBlock(verbose <= 1);
  }

  virtual IAssemble *GetAssemble() const = 0;

  virtual IDiscretization *GetDisc() const = 0;

  virtual IStochasticProblem *GetProblem() const = 0;

  virtual void DrawSample(const SampleID &id) = 0;

  virtual std::string Name() const = 0;
};

class DummyPDESolver : public PDESolver {
private:
  IStochasticDummyAssemble *assemble;

protected:
  void run(SampleSolution &solution) override {}

  void computeQ(SampleSolution &solution) override {
    if (quantity == "GeneratorValue") solution.Q = assemble->GeneratorValue();
    else Exit("Quantity of interest not implemented")
  }

  void computeCost(SampleSolution &solution) override {
    if (costMeasure == "size") solution.Cost = solution.U.size();
//    else if (costMeasure == "time") solution.Cost = solution.U.size(); // Todo
    else Exit("Cost measure not implemented")
  }

  void plotSolution(SampleSolution &solution) override {
    mpp::plot_mesh(solution.U.GetMesh());
  }

public:
  DummyPDESolver(IStochasticDummyAssemble *assemble,
                 const Meshes &meshes,
                 const std::string &quantity = "L2",
                 const std::string &costMeasure = "size") :
    PDESolver(meshes, quantity, costMeasure), assemble(assemble) {
    if (verbose > 0) {
      PrintInfo();
      assemble->PrintInfo();
    }
  }

  IAssemble *GetAssemble() const override { return assemble; }

  IDiscretization *GetDisc() const override { return assemble->GetDisc(); }

  IStochasticProblem *GetProblem() const override { return assemble->GetProblem(); }

  void DrawSample(const SampleID &id) override { assemble->DrawSample(id); }

  std::string Name() const override { return "DummyPDESolver"; }
};

#endif //PDESOLVER_HPP