AdaptInfo.hpp

#pragma once
 
// std c++ headers
#include <algorithm>
#include <cmath>
#include <limits>
#include <map>
#include <string>
#include <utility>
 
// AMDiS includes
#include <amdis/Output.hpp>
#include <amdis/common/ConceptsBase.hpp>
#include <amdis/typetree/TreePath.hpp>
 
namespace AMDiS
{
 
  class AdaptInfo
  {
  public:
    using Key = std::string;
 
  protected:
    class ScalContent
    {
    public:
      explicit ScalContent(std::string const& prefix);
 
      double est_sum = 0.0;
 
      double est_t_sum = 0.0;
 
      double est_max = 0.0;
 
      double est_t_max = 0.0;
 
      double fac_max = 0.0, fac_sum = 1.0;
 
      double spaceTolerance = 0.0;
 
      double timeTolerance = 0.0;
 
      double timeRelativeTolerance = 0.0;
 
      double timeErrLow = 0.0;
 
      int coarsenAllowed = 0;
 
      int refinementAllowed = 1;
    };
 
  public:
    explicit AdaptInfo(std::string const& name);
 
    virtual ~AdaptInfo() = default;
 
    void reset();
 
    virtual bool spaceToleranceReached() const
    {
      for (auto const& scalContent : scalContents_)      {
        if (!(scalContent.second.est_sum < scalContent.second.spaceTolerance))
          return false;
      }
 
      return true;
    }
 
    virtual bool spaceToleranceReached(Key key) const
    {
      if (!(scalContent(key).est_sum < scalContent(key).spaceTolerance))
        return false;
      else
        return true;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    bool spaceToleranceReached(const TP& tp) const
    {
      return spaceToleranceReached(to_string(tp));
    }
 
    virtual bool timeToleranceReached() const
    {
      for (auto const& scalContent : scalContents_)
        if (!(timeEstCombined(scalContent.first) < scalContent.second.timeTolerance))
          return false;
 
      return true;
    }
 
    virtual bool timeToleranceReached(Key key) const
    {
      if (!(timeEstCombined(key) < scalContent(key).timeTolerance))
        return false;
      else
        return true;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    bool timeToleranceReached(const TP& tp) const
    {
      return timeToleranceReached(to_string(tp));
    }
 
    virtual bool timeErrorLow() const
    {
      for (auto const& scalContent : scalContents_)
        if (!(timeEstCombined(scalContent.first) < scalContent.second.timeErrLow))
          return false;
 
      return true;
    }
 
    double timeEstCombined(Key key) const
    {
      return
        scalContent(key).est_t_max * scalContent(key).fac_max +
        scalContent(key).est_t_sum * scalContent(key).fac_sum;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double timeEstCombined(const TP& tp) const
    {
      return tTimeEstCombined(to_string(tp));
    }
 
    void printTimeErrorLowInfo() const;
 
    int spaceIteration() const
    {
      return spaceIteration_;
    }
 
    void setSpaceIteration(int it)
    {
      spaceIteration_ = it;
    }
 
    int maxSpaceIteration() const
    {
      return maxSpaceIteration_;
    }
 
    void maxSpaceIteration(int it)
    {
      maxSpaceIteration_ = it;
    }
 
    void incSpaceIteration()
    {
      spaceIteration_++;
    }
 
    void setTimestepIteration(int it)
    {
      timestepIteration_ = it;
    }
 
    int timestepIteration() const
    {
      return timestepIteration_;
    }
 
    void incTimestepIteration()
    {
      timestepIteration_++;
    }
 
    int maxTimestepIteration() const
    {
      return maxTimestepIteration_;
    }
 
    void setMaxTimestepIteration(int it)
    {
      maxTimestepIteration_ = it;
    }
 
    void setTimeIteration(int it)
    {
      timeIteration_ = it;
    }
 
    int timeIteration() const
    {
      return timeIteration_;
    }
 
    void incTimeIteration()
    {
      timeIteration_++;
    }
 
    int maxTimeIteration() const
    {
      return maxTimeIteration_;
    }
 
    void setMaxTimeIteration(int it)
    {
      maxTimeIteration_ = it;
    }
 
    int timestepNumber() const
    {
      return timestepNumber_;
    }
 
    void setTimestepNumber(int num)
    {
      if (nTimesteps_)
        timestepNumber_ = std::min(nTimesteps_, num);
      else
        timestepNumber_ = num;
    }
 
    int numberOfTimesteps() const
    {
      return nTimesteps_;
    }
 
    void setNumberOfTimesteps(int num)
    {
      nTimesteps_ = std::max(0, num);
    }
 
    void incTimestepNumber()
    {
      timestepNumber_++;
    }
 
    void setEstSum(double e, Key key)
    {
      scalContent(key).est_sum = e;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    void setEstSum(double e, const TP& tp)
    {
      setEstSum(e, to_string(tp));
    }
 
    void setEstMax(double e, Key key)
    {
      scalContent(key).est_max = e;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    void setEstMax(double e, const TP& tp)
    {
      setEstMax(e, to_string(tp));
    }
 
    void setTimeEstMax(double e, Key key)
    {
      scalContent(key).est_t_max = e;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    void setTimeEstMax(double e, const TP& tp)
    {
      setTimeEstMax(e, to_string(tp));
    }
 
    void setTimeEstSum(double e, Key key)
    {
      scalContent(key).est_t_sum = e;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    void setTimeEstSum(double e, const TP& tp)
    {
      setTimeEstSum(e, to_string(tp));
    }
 
    double estSum(Key key) const
    {
      return scalContent(key).est_sum;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double estSum(const TP& tp)
    {
      return estSum(to_string(tp));
    }
 
    double estTSum(Key key) const
    {
      return scalContent(key).est_t_sum;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double estTSum(const TP& tp)
    {
      return estTSum(to_string(tp));
    }
 
    double estMax(Key key) const
    {
      return scalContent(key).est_max;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double estMax(const TP& tp)
    {
      return estMax(to_string(tp));
    }
 
    double timeEstMax(Key key) const
    {
      return scalContent(key).est_t_max;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double timeEstmax(const TP& tp)
    {
      return timeEstMax(to_string(tp));
    }
 
    double timeEstSum(Key key) const
    {
      return scalContent(key).est_t_sum;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double timeEstSum(const TP& tp)
    {
      return timeEstSum(to_string(tp));
    }
 
    double timeEst() const
    {
      return timeEst_;
    }
 
    void setTimeEst(double value)
    {
      timeEst_ = value;
    }
 
    double spaceTolerance(Key key) const
    {
      return scalContent(key).spaceTolerance;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double spaceTolerance(const TP& tp)
    {
      return spaceTolerance(to_string(tp));
    }
 
    void setSpaceTolerance(Key key, double tol)
    {
      scalContent(key).spaceTolerance = tol;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    void setSpaceTolerance(const TP& tp, double tol)
    {
      return setSpaceTolerance(to_string(tp), tol);
    }
 
    double timeTolerance(Key key) const
    {
      return scalContent(key).timeTolerance;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double timeTolerance(const TP& tp)
    {
      return timeTolerance(to_string(tp));
    }
 
    double timeRelativeTolerance(Key key) const
    {
      return scalContent(key).timeRelativeTolerance;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double timeRelativeTolerance(const TP& tp)
    {
      return timeRelativeTolerance(to_string(tp));
    }
 
    double setTime(double t)
    {
      time_ = t;
      if (time_ > endTime_)
        time_ = endTime_;
      if (time_ < startTime_)
        time_ = startTime_;
 
      return time_;
    }
 
    double const& time() const
    {
      return time_;
    }
 
    double setTimestep(double t)
    {
      timestep_ = t;
      if (timestep_ > maxTimestep_)
        timestep_ = maxTimestep_;
      if (timestep_ < minTimestep_)
        timestep_ = minTimestep_;
      if (time_ + timestep_ > endTime_)
        timestep_ = endTime_ - time_;
 
      return timestep_;
    }
    double const& timestep() const
    {
      return timestep_;
    }
 
    void setLastProcessedTimestep(double t)
    {
      lastProcessedTimestep_ = t;
    }
 
    double lastProcessedTimestep() const
    {
      return lastProcessedTimestep_;
    }
 
    bool reachedEndTime() const
    {
      if (nTimesteps_ > 0)
        return !(timestepNumber_ < nTimesteps_);
 
      return !(std::abs(time_ - endTime_) > std::numeric_limits<double>::epsilon());
    }
 
 
    void setMinTimestep(double t)
    {
      minTimestep_ = t;
    }
 
    double minTimestep() const
    {
      return minTimestep_;
    }
 
    void setMaxTimestep(double t)
    {
      maxTimestep_ = t;
    }
 
    double maxTimestep() const
    {
      return maxTimestep_;
    }
 
    void setStartTime(double time)
    {
      startTime_ = time;
    }
 
    void setEndTime(double time)
    {
      endTime_ = time;
    }
 
    double startTime() const
    {
      return startTime_;
    }
 
    double endTime() const
    {
      return endTime_;
    }
 
    double timeErrLow(Key key) const
    {
      return scalContent(key).timeErrLow;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    double timeErrLow(const TP& tp)
    {
      return timeErrLow(to_string(tp));
    }
 
    bool isCoarseningAllowed(Key key) const
    {
      return (scalContent(key).coarsenAllowed == 1);
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    bool isCoarseningAllowed(const TP& tp)
    {
      return isCoarseningAllowed(to_string(tp));
    }
 
    bool isRefinementAllowed(Key key) const
    {
      return (scalContent(key).refinementAllowed == 1);
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    bool isRefinementAllowed(const TP& tp)
    {
      return isRefinementAllowed(to_string(tp));
    }
 
    void allowRefinement(bool allow, Key key)
    {
      scalContent(key).refinementAllowed = allow;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    void allowRefinement(bool allow, const TP& tp)
    {
      return allowRefinement(allow, to_string(tp));
    }
 
    void allowCoarsening(bool allow, Key key)
    {
      scalContent(key).coarsenAllowed = allow;
    }
 
    template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
    void allowCoarsening(bool allow, const TP& tp)
    {
      return allowCoarsening(allow, to_string(tp));
    }
 
    int size() const
    {
      return int(scalContents_.size());
    }
 
    void setSolverIterations(int it)
    {
      solverIterations_ = it;
    }
 
    int solverIterations() const
    {
      return solverIterations_;
    }
 
    void setMaxSolverIterations(int it)
    {
      maxSolverIterations_ = it;
    }
 
    int maxSolverIterations() const
    {
      return maxSolverIterations_;
    }
 
    void setSolverTolerance(double tol)
    {
      solverTolerance_ = tol;
    }
 
    double solverTolerance() const
    {
      return solverTolerance_;
    }
 
    void setSolverResidual(double res)
    {
      solverResidual_ = res;
    }
 
    double solverResidual() const
    {
      return solverResidual_;
    }
 
    void setGlobalTimeTolerance(double tol)
    {
      globalTimeTolerance_ = tol;
    }
 
    double globalTimeTolerance() const
    {
      return globalTimeTolerance_;
    }
 
 
    void resetTimeValues(double newTimeStep,
                         double newStartTime,
                         double newEndTime)
    {
      time_ = newStartTime;
      startTime_ = newStartTime;
      endTime_ = newEndTime;
      timestep_ = newTimeStep;
      timestepNumber_ = 0;
    }
 
  private:
    ScalContent& scalContent(Key key) const
    {
      auto result = scalContents_.emplace(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(name_ + "[" + key + "]") );
      return result.first->second;
    }
 
  protected:
    std::string name_;
 
    int spaceIteration_ = -1;
 
    int maxSpaceIteration_ = -1;
 
    int timestepIteration_ = 0;
 
    int maxTimestepIteration_ = 30;
 
    int timeIteration_ = 0;
 
    int maxTimeIteration_ = 30;
 
    double time_ = 0.0;
 
    double startTime_ = 0.0;
 
    double endTime_ = 1.0;
 
    double timestep_ = 0.0;
 
    double lastProcessedTimestep_ = 0.0;
 
    double minTimestep_ = std::sqrt(std::numeric_limits<double>::epsilon());
 
    double maxTimestep_ = std::sqrt(std::numeric_limits<double>::max());
 
    int timestepNumber_ = 0;
 
    int nTimesteps_ = 0;
 
    int solverIterations_ = 0;
 
    int maxSolverIterations_ = 0;
 
    double solverTolerance_ = 1.e-8;
 
    double solverResidual_ = 0.0;
 
    double globalTimeTolerance_ = 1.0;
 
    mutable std::map<Key, ScalContent> scalContents_;
 
    double timeEst_ = 0.0;
  };
 
} // end namespace AMDiS