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)
    {
      timestepNumber_ = std::min(nTimesteps_, 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 maxTimestep(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