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>