fixedpointiterator.hh

#ifndef SRC_SPATIAL_SOLVING_FIXEDPOINTITERATOR_HH
#define SRC_SPATIAL_SOLVING_FIXEDPOINTITERATOR_HH

#include <memory>

#include <dune/common/parametertree.hh>

#include <dune/solvers/norms/norm.hh>
#include <dune/solvers/solvers/solver.hh>

#include <dune/contact/assemblers/nbodyassembler.hh>

struct FixedPointIterationCounter {
  size_t iterations = 0;
  size_t multigridIterations = 0;

  void operator+=(FixedPointIterationCounter const &other);
};

std::ostream &operator<<(std::ostream &stream,
                         FixedPointIterationCounter const &fpic);

template <class Factory, class Updaters, class ErrorNorm>
class FixedPointIterator {
  using ScalarVector = typename Updaters::StateUpdater::ScalarVector;
  using Vector = typename Factory::Vector;
  using Matrix = typename Factory::Matrix;
  using Nonlinearity = typename Factory::Nonlinearity;

 // using Nonlinearity = typename ConvexProblem::NonlinearityType;

  using DeformedGrid = typename Factory::DeformedGrid;

private:
  void relativeVelocities(const std::vector<Vector>& v, std::vector<Vector>& v_rel) const;

public:
  FixedPointIterator(Factory& factory, const Dune::ParameterTree& parset,
                     std::vector<std::shared_ptr<Nonlinearity>>& globalFriction,
                     const std::vector<const ErrorNorm* >& errorNorms);

  FixedPointIterationCounter run(Updaters updaters,
                                 const std::vector<Matrix>& velocityMatrices,
                                 const std::vector<Vector>& velocityRHSs,
                                 std::vector<Vector>& velocityIterates);

private:
  Factory& factory_;
  std::shared_ptr<typename Factory::Step> step_;
  Dune::ParameterTree const &parset_;
  std::vector<std::shared_ptr<Nonlinearity>>& globalFriction_;

  size_t fixedPointMaxIterations_;
  double fixedPointTolerance_;
  double lambda_;
  size_t velocityMaxIterations_;
  double velocityTolerance_;
  Solver::VerbosityMode verbosity_;
  const std::vector<const ErrorNorm* >& errorNorms_;
};
#endif