NewtonIteration.hpp

#pragma once

#include <memory>
#include <string>

#include <amdis/AdaptInfo.hpp>
#include <amdis/Flag.hpp>
#include <amdis/Initfile.hpp>
#include <amdis/ProblemIterationInterface.hpp>
#include <amdis/ProblemStatBase.hpp>

namespace AMDiS
{
  template <class ProblemType>
  class NewtonIteration
      : public ProblemIterationInterface
  {
    using Self    = NewtonIteration;
    using Problem = ProblemType;

    using SolutionVector = typename Problem::SolutionVector;

  public:
    NewtonIteration (std::string name, Problem& prob)
      : name_(std::move(name))
      , prob_(&prob)
    {
      stepSolution_.reset(new SolutionVector(*prob_->solutionVector()));

      Parameters::get(name_ + "->build cycle", buildCycle_);
      Parameters::get(name_ + "->norm", norm_);
    }

    void beginIteration(AdaptInfo& /*adaptInfo*/) override { /* do nothing */ }

    Flag oneIteration(AdaptInfo& adaptInfo, Flag toDo) override;

    void endIteration(AdaptInfo& adaptInfo) override
    {
      msg("{:>5} | {:>12} | {:>8} | {:>8} ", "iter.", "error", "red.", "tol");
      if (errOld_ <= 0)
        msg("{:5d} | {:12.5e} | {:->8} | {:8.2} ",
          adaptInfo.spaceIteration()+1, err_, "-",adaptInfo.spaceTolerance(""));
      else
        msg("{:5d} | {:12.5e} | {:8.2e} | {:8.2} ",
           adaptInfo.spaceIteration()+1, err_, err_/errOld_,adaptInfo.spaceTolerance(""));

      errOld_ = err_;
    }

    ProblemStatBase& problem([[maybe_unused]] int n = 0) override
    {
      assert(n == 0); return *prob_;
    }

    int numProblems() const override { return 1; }

    ProblemStatBase& problem([[maybe_unused]] std::string const& name) override
    {
      assert(prob_->name() == name);
      return *prob_;
    }

    std::string const& name() const override { return name_; }


    std::shared_ptr<SolutionVector const> stepSolutionVector() const
    {
      return stepSolution_;
    }


    template <class Range = void, class... Indices>
    auto stepSolution(Indices... ii) const
    {
      return valueOf<Range>(*stepSolution_, ii...);
    }

  protected:
    std::string name_;

    Problem* prob_;

    std::shared_ptr<SolutionVector> stepSolution_;


    int buildCycle_ = 1;


    int norm_ = 1;

  private:
    double err_ = 0.0;
    double errOld_ = -1.0;
  };

} // end namespace AMDiS

#include <amdis/nonlin/NewtonIteration.inc.hpp>