ProblemStat.hpp

#pragma once

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <tuple>
#include <string>
#include <memory>
#include <list>
#include <map>

#include <dune/common/fvector.hh>
#include <dune/common/fmatrix.hh>
#include <dune/istl/matrix.hh>
#include <dune/functions/gridfunctions/discreteglobalbasisfunction.hh>
#include <dune/grid/common/grid.hh>

#include <dune/amdis/AdaptInfo.hpp>
#include <dune/amdis/Assembler.hpp>
#include <dune/amdis/CreatorInterface.hpp>
#include <dune/amdis/DirichletBC.hpp>
#include <dune/amdis/FileWriter.hpp>
#include <dune/amdis/Flag.hpp>
#include <dune/amdis/Initfile.hpp>
#include <dune/amdis/LinearAlgebra.hpp>
#include <dune/amdis/Mesh.hpp>
#include <dune/amdis/Operator.hpp>
#include <dune/amdis/ProblemStatBase.hpp>
#include <dune/amdis/ProblemStatTraits.hpp>
#include <dune/amdis/StandardProblemIteration.hpp>

#include <dune/amdis/common/OptionalDelete.hpp>
#include <dune/amdis/common/Timer.hpp>
#include <dune/amdis/common/TupleUtility.hpp>
#include <dune/amdis/common/TypeDefs.hpp>
#include <dune/amdis/common/Utility.hpp>

#include <dune/amdis/utility/RangeType.hpp>

namespace AMDiS
{
  template <class GlobalBasis>
  class ProblemStat
      : public ProblemStatBase
      , public StandardProblemIteration
  {
    using Self = ProblemStat;

  public: // typedefs and static constants

    using GridView = typename GlobalBasis::GridView;
    using Grid     = typename GridView::Grid;

    using Element  = typename GridView::template Codim<0>::Entity;

    static const int nComponents = 1; // TODO: count leaf nodes in GlobalBasis

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

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

    using WorldVector = typename Element::Geometry::GlobalCoordinate;

    using SystemMatrix = DOFMatrix<GlobalBasis, GlobalBasis, double>;
    using SystemVector = DOFVector<GlobalBasis, double>;

    using ElementOperator = Operator<GridView, Element>;
    using IntersectionOperator = Operator<GridView, typename GridView::Intersection>;

    using LinearSolverType = LinearSolverInterface<typename SystemMatrix::BaseMatrix, typename SystemVector::BaseVector>;

  public:
    /**
     * \brief Constructor. Takes the name of the problem that is used to
     * access values correpsonding to this püroblem in the parameter file.
     *
     * Parameters read by ProblemStat, with name 'PROB'
     *   PROB->names: \ref componentNames
     **/
    ProblemStat(std::string name)
      : StandardProblemIteration(dynamic_cast<ProblemStatBase&>(*this))
      , name(name)
    {
      Parameters::get(name + "->names", componentNames);
      for (std::size_t i = componentNames.size(); i < nComponents; ++i)
        componentNames.push_back("solution[" + std::to_string(i) + "]");
    }

    /// Constructor taking additionally a reference to a mesh that is used
    /// instead of the default created mesh, \ref ProblemStat
    ProblemStat(std::string name, Grid& grid)
      : ProblemStat(name)
    {
      this->grid = std::shared_ptr<Grid>(&grid, optional_delete(false));
      componentGrids.resize(nComponents, this->grid.get());

      gridName = "";
      Parameters::get(name + "->mesh", gridName);
    }


    /**
     * \brief Initialisation of the problem.
     *
     * Parameters read in initialize() for problem with name 'PROB'
     *   MESH[0]->global refinements:  nr of initial global refinements
     **/
    void initialize(Flag initFlag,
                    Self* adoptProblem = nullptr,
                    Flag adoptFlag = INIT_NOTHING);


    /// Adds an operator to \ref A.
    /** @{ */
    template <class RowTreePath, class ColTreePath>
    void addMatrixOperator(ElementOperator const& op, RowTreePath, ColTreePath,
                           double* factor = nullptr, double* estFactor = nullptr);

    template <class RowTreePath, class ColTreePath>
    void addMatrixOperator(IntersectionOperator const& op, RowTreePath, ColTreePath,
                           double* factor = nullptr, double* estFactor = nullptr);

    // operator evaluated on the boundary
    template <class RowTreePath, class ColTreePath>
    void addMatrixOperator(BoundaryType b, IntersectionOperator const& op, RowTreePath, ColTreePath,
                           double* factor = nullptr, double* estFactor = nullptr);

#if 0
    template <class RowTreePath, class ColTreePath>
    void addMatrixOperator(std::map< std::pair<RowTreePath,ColTreePath>, ElementOperator> ops);

    template <class RowTreePath, class ColTreePath>
    void addMatrixOperator(std::map< std::pair<RowTreePath,ColTreePath>, std::pair<ElementOperator, bool> > ops);
#endif
    /** @} */


    /// Adds an operator to \ref rhs.
    /** @{ */
    template <class TreePath>
    void addVectorOperator(ElementOperator const& op, TreePath,
                           double* factor = nullptr, double* estFactor = nullptr);

    template <class TreePath>
    void addVectorOperator(IntersectionOperator const& op, TreePath,
                           double* factor = nullptr, double* estFactor = nullptr);

    // operator evaluated on the boundary
    template <class TreePath>
    void addVectorOperator(BoundaryType b, IntersectionOperator const& op, TreePath,
                           double* factor = nullptr, double* estFactor = nullptr);

#if 0
    template <class TreePath>
    void addVectorOperator(std::map<TreePath, ElementOperator> ops);

    template <class TreePath>
    void addVectorOperator(std::map<TreePath, std::pair<ElementOperator, bool> > ops);
#endif
    /** @} */


    /// Adds a Dirichlet boundary condition
    template <class Predicate, class Values>
    void addDirichletBC(Predicate const& predicate,
                        int row, int col,
                        Values const& values);


    /// Implementation of \ref ProblemStatBase::solve
    virtual void solve(AdaptInfo& adaptInfo,
                       bool createMatrixData = true,
                       bool storeMatrixData = false) override;


    /// Implementation of \ref ProblemStatBase::buildAfterCoarse
    virtual void buildAfterCoarsen(AdaptInfo& adaptInfo,
                                   Flag flag,
                                   bool asmMatrix = true,
                                   bool asmVector = true) override;


    /// Writes output files.
    void writeFiles(AdaptInfo& adaptInfo, bool force = false);


  public: // implementation of iteration interface methods

    /**
      * \brief Determines the execution order of the single adaption steps.
      *
      * If adapt is true, mesh adaption will be performed. This allows to avoid
      * mesh adaption, e.g. in timestep adaption loops of timestep adaptive
      * strategies.
      *
      * Implementation of \ref StandardProblemIteration::oneIteration.
      **/
    virtual Flag oneIteration(AdaptInfo& adaptInfo, Flag toDo = FULL_ITERATION) override
    {
      for (std::size_t i = 0; i < getNumComponents(); ++i)
        if (adaptInfo.spaceToleranceReached(i))
          adaptInfo.allowRefinement(false, i);
        else
          adaptInfo.allowRefinement(true, i);

      return StandardProblemIteration::oneIteration(adaptInfo, toDo);
    }

    /// Implementation of \ref ProblemStatBase::buildBeforeRefine.
    virtual void buildBeforeRefine(AdaptInfo&, Flag) override { /* Does nothing. */ }

    /// Implementation of \ref ProblemStatBase::buildBeforeCoarsen.
    virtual void buildBeforeCoarsen(AdaptInfo&, Flag) override { /* Does nothing. */ }

    /// Implementation of \ref ProblemStatBase::estimate.
    virtual void estimate(AdaptInfo& adaptInfo) override { /* Does nothing. */ }

    /// Implementation of \ref ProblemStatBase::refineMesh.
    virtual Flag refineMesh(AdaptInfo& adaptInfo) override { return 0; }

    /// Implementation of \ref ProblemStatBase::coarsenMesh.
    virtual Flag coarsenMesh(AdaptInfo& adaptInfo) override { return 0; }

    /// Implementation of \ref ProblemStatBase::markElements.
    virtual Flag markElements(AdaptInfo& adaptInfo) override { return 0; }


  public: // get-methods

    /// Returns a pointer to system-matrix, \ref systemMatrix
    auto getSystemMatrix()       { return systemMatrix; }
    auto getSystemMatrix() const { return systemMatrix; }


    /// Return a pointer to the solution, \ref solution
    auto getSolution()       { return solution; }
    auto getSolution() const { return solution; }

    /// Return the i'th \ref solution component
    template <class TreePath>
    auto getSolution(TreePath path)
    {
      using namespace Dune::Functions;

      auto tp = makeTreePath(path);

      using Node = typename GlobalBasis::NodeFactory::template Node<decltype(tp)>;
      using Range = RangeType<Node, double>;

      return makeDiscreteGlobalBasisFunction<Range>(
        subspaceBasis(*globalBasis, tp),
        *solution);
    }


    /// Return a point to the rhs system-vector, \ref rhs
    auto getRhs()       { return rhs; }
    auto getRhs() const { return rhs; }


    /// Return a pointer to the linear solver, \ref linearSolver
    std::shared_ptr<LinearSolverType> getSolver() { return linearSolver; }

    void setSolver(std::shared_ptr<LinearSolverType> const& solver)
    {
      linearSolver = solver;
    }

    /// Return a pointer to the grid, \ref grid
    std::shared_ptr<Grid> getGrid() { return grid; }

    /// Set the mesh. Stores pointer to passed reference and initializes feSpaces
    /// matrices and vectors, as well as the file-writer.
    void setGrid(Grid& grid_)
    {
      grid = std::shared_ptr<Grid>(&grid_, optional_delete(false));
      std::fill(componentGrids.begin(), componentGrids.end(), this->grid.get());

      createGlobalBasis();
      createMatricesAndVectors();
      createFileWriter();
    }


    /// Return the gridView of the leaf-level
    auto leafGridView() { return grid->leafGridView(); }

    /// Return the gridView of levle `level`
    auto levelGridView(int level) { return grid->levelGridView(level); }

    /// Return the \ref feSpaces
    std::shared_ptr<GlobalBasis> const& getGlobalBasis() { return globalBasis; }


    /// Implementation of \ref ProblemStatBase::getName
    virtual std::string getName() const override
    {
      return name;
    }

    /// Return a vector of names of the problem components
    std::vector<std::string> getComponentNames() const
    {
      return componentNames;
    }

    int getNumComponents() const
    {
      return nComponents;
    }

  protected: // initialization methods

    void createGrid()
    {
      gridName = "";
      Parameters::get(name + "->mesh", gridName);
      test_exit(!gridName.empty(), "No mesh name specified for '", name, "->mesh'!");

      grid = MeshCreator<Grid>::create(gridName);

      msg("Create grid:");
      msg("#elements = "   , grid->size(0));
      msg("#faces/edges = ", grid->size(1));
      msg("#vertices = "   , grid->size(dim));
      msg("");
    }

    void createGlobalBasis()
    {
      globalBasis = std::make_shared<GlobalBasis>(makeGlobalBasis<GlobalBasis>(leafGridView()));
      matrixOperators.init(*globalBasis);
      rhsOperators.init(*globalBasis);
    }

    void createMatricesAndVectors()
    {
      systemMatrix = std::make_shared<SystemMatrix>(*globalBasis, *globalBasis, "mat");
      solution = std::make_shared<SystemVector>(*globalBasis, componentNames[0]);

      auto rhsNames = std::vector<std::string>(nComponents, "rhs");
      rhs = std::make_shared<SystemVector>(*globalBasis, rhsNames[0]);
    }

    void createSolver()
    {
      std::string solverName = "cg";
      Parameters::get(name + "->solver->name", solverName);

      auto solverCreator
        = named(CreatorMap<LinearSolverType>::getCreator(solverName, name + "->solver->name"));

      linearSolver = solverCreator->create(name + "->solver");
    }

    void createFileWriter()
    {
      filewriter = std::make_shared<FileWriter<GlobalBasis>>(name + "->output", leafGridView(), componentNames);
    }


  private:
    /// Name of this problem.
    std::string name;

    /// Stores the names for all components. Is used for naming the solution
    /// vectors, \ref solution.
    std::vector<std::string> componentNames;

    /// Grid of this problem.
    std::shared_ptr<Grid> grid; // TODO: generalize to multi-mesh problems

    /// Name of the mesh
    std::string gridName = "none";

    /// Pointer to the meshes for the different problem components
    std::vector<Grid*> componentGrids;

    /// FE spaces of this problem.
    std::shared_ptr<GlobalBasis> globalBasis; // eventuell const

    /// A FileWriter object
    std::shared_ptr<FileWriter<GlobalBasis>> filewriter;

    /// An object of the linearSolver Interface
    std::shared_ptr<LinearSolverType> linearSolver;

    /// A block-matrix that is filled during assembling
    std::shared_ptr<SystemMatrix> systemMatrix;

    /// A block-vector with the solution components
    std::shared_ptr<SystemVector> solution;

    /// A block-vector (load-vector) corresponding to the right.hand side
    /// of the equation, filled during assembling
    std::shared_ptr<SystemVector> rhs;


  private: // some internal data-structures

    MatrixOperators<GlobalBasis> matrixOperators;
    VectorOperators<GlobalBasis> rhsOperators;

    template <class Node>
    struct DirichletData
    {
      std::list<std::shared_ptr<DirichletBC<WorldVector>>> bc;
    };

    MatrixData<GlobalBasis, DirichletData> matrixConstraints;
  };


#ifndef AMDIS_NO_EXTERN_PROBLEMSTAT
  extern template class ProblemStat<YaspGridBasis<2,1,2>>; // 2 components with different polynomial degree
#endif

} // end namespace AMDiS

#include "ProblemStat.inc.hpp"