cgTerminationCriteria.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2002-2017 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef CGTERMINATIONCRITERIA_HH
#define CGTERMINATIONCRITERIA_HH
 
namespace Kaskade
{
  template <class R>
  class PCGTerminationCriterion {
  public:
    typedef R Real;
 
    virtual void clear() = 0;
 
    virtual void setTolerance(Real tol) = 0;
 
    virtual void setLookAhead(int lah) = 0;
    virtual void addStepQuantities(Real stepLength, Real qAq, Real qPq, Real rPINVr) = 0;
 
 
    virtual int getMaxIterationSteps() = 0;
    virtual operator bool() = 0;
 
    virtual bool minimalDecreaseAchieved() { assert("not implemented"); return false; }
  };
 
 
  template <class R>
  class StrakosTichyEnergyErrorTerminationCriterion: public PCGTerminationCriterion<R> {
  public:
    typedef R Real;
 
    StrakosTichyEnergyErrorTerminationCriterion(Real tol_, int maxit_, double eps_ = 1e-12)
      : tol(tol_), maxit(maxit_), eps(eps_)
    {}
 
    StrakosTichyEnergyErrorTerminationCriterion(Real tol_, Real minTol_, int maxit_, double eps_ = 1e-12)
      : tol(tol_), maxit(maxit_), eps(eps_), minTol(minTol_)
    {}
 
    virtual void clear()
    {
      scaledGamma2.clear();
      energyNorm = 0;
    }
 
    virtual void setTolerance(Real tol_) { tol = tol_; }//minTol = sqrt(tol); }
 
    virtual void setLookAhead(int d_) { d = d_; }
 
    virtual void addStepQuantities(Real stepLength, Real, Real, Real rPINVr)
    {
      scaledGamma2.push_back( stepLength * rPINVr );
      energyNorm += stepLength * rPINVr;
    }
 
    virtual int getMaxIterationSteps()
    {
      return maxit;
    }
    virtual operator bool()
    {
      return scaledGamma2.size() > d && relativeError() < std::max(eps,tol*tol);
    }
 
    Real relativeError()
    {
      if( scaledGamma2.size() < d ) return std::numeric_limits<Real>::max();
      return std::accumulate(scaledGamma2.end() - d, scaledGamma2.end(), 0.) / energyNorm;
    }
 
    bool minimalDecreaseAchieved() { return relativeError() < minTol; }
 
  private:
    Real tol;
    int maxit;
    // squared gammas
    std::vector<Real> scaledGamma2;
    Real energyNorm = 0;
    int d = 50;
    double eps = 1e-12, minTol = 1e-2;
  };
 
 
  template <class R>
  class StrakosTichyPTerminationCriterion: public PCGTerminationCriterion<R> {
  public:
    typedef R Real;
 
    StrakosTichyPTerminationCriterion(Real tol_, int maxit_, double eps_ = 1e-12)
      : tol(tol_), maxit(maxit_), eps(eps_)
    {}
 
    StrakosTichyPTerminationCriterion(Real tol_, Real minTol_, int maxit_, double eps_ = 1e-12)
      : tol(tol_), maxit(maxit_), eps(eps_), minTol(minTol_)
    {}
 
    virtual void clear()
    {
      scaledGamma2.clear();
      energyNorm = 0;
    }
 
    virtual void setTolerance(Real tol_) { tol = tol_; }
 
    virtual void setLookAhead(int d_) { d = d_; }
 
    virtual void addStepQuantities(Real stepLength, Real qAq, Real qPq, Real rPINVr)
    {
      scaledGamma2.push_back( stepLength * rPINVr );
      energyNorm += stepLength * rPINVr;
      steps2.push_back(qPq/qAq);
    }
 
    virtual int getMaxIterationSteps()
    {
      return maxit;
    }
    virtual operator bool()
    {
      return scaledGamma2.size() > 2*d && relativeError() < std::max(eps,tol*tol);
    }
 
    Real relativeError()
    {
      if( scaledGamma2.size() < 2*d ) return std::numeric_limits<Real>::max();
 
      size_t j = scaledGamma2.size() - 2*d;
      double tau = 0;
      for(size_t i = j; i < j + d; ++i)
        tau += steps2[i] * ( scaledGamma2[i] + 2 * std::accumulate(scaledGamma2.begin()+i+1, scaledGamma2.end(),0)  );
      return tau;
    }
 
    bool minimalDecreaseAchieved() { return relativeError() < minTol; }
 
  private:
    Real tol;
    int maxit;
    // squared gammas
    std::vector<Real> scaledGamma2, steps2;
    Real energyNorm = 0;
    int d = 50;
    double eps = 1e-12, minTol = 1e-2;
  };
 
}
 
#endif // CGTERMINATIONCRITERIA_HH