ResidualRelativeConvergenceMeasure.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <iomanip>
#include <limits>
#include <ostream>
#include <string>
#include "../CouplingData.hpp"
#include "ConvergenceMeasure.hpp"
#include "logging/Logger.hpp"
#include "math/differences.hpp"
#include "utils/IntraComm.hpp"
 
namespace precice {
namespace cplscheme {
namespace impl {
 
class ResidualRelativeConvergenceMeasure : public ConvergenceMeasure {
public:
  explicit ResidualRelativeConvergenceMeasure(double convergenceLimitPercent);
 
  virtual ~ResidualRelativeConvergenceMeasure(){};
 
  virtual void newMeasurementSeries()
  {
    _isConvergence     = false;
    _isFirstIteration  = true;
    _normFirstResidual = std::numeric_limits<double>::max();
  }
 
  virtual void measure(
      const Eigen::VectorXd &oldValues,
      const Eigen::VectorXd &newValues)
  {
    _normDiff = utils::IntraComm::l2norm(newValues - oldValues);
    if (_isFirstIteration) {
      _normFirstResidual = _normDiff;
      _isFirstIteration  = false;
    }
    _isConvergence = _normDiff < _normFirstResidual * _convergenceLimitPercent;
  }
 
  virtual bool isConvergence() const
  {
    return _isConvergence;
  }
 
  virtual std::string printState(const std::string &dataName)
  {
    std::ostringstream os;
    os << "residual relative convergence measure: ";
    os << "relative two-norm diff of data \"" << dataName << "\" = ";
    os << std::scientific << std::setprecision(2) << getNormResidual();
    os << ", limit = " << _convergenceLimitPercent;
    os << ", normalization = " << _normFirstResidual;
    os << ", conv = ";
    if (_isConvergence)
      os << "true";
    else
      os << "false";
    return os.str();
  }
 
  virtual double getNormResidual()
  {
    if (math::equals(_normFirstResidual, 0.))
      return std::numeric_limits<double>::infinity();
    else
      return _normDiff / _normFirstResidual;
  }
 
  virtual std::string getAbbreviation() const
  {
    return "Drop";
  }
 
private:
  logging::Logger _log{"cplscheme::ResidualRelativeConvergenceMeasure"};
 
  double _convergenceLimitPercent;
 
  bool _isFirstIteration = true;
 
  double _normFirstResidual = std::numeric_limits<double>::max();
 
  double _normDiff = 0;
 
  bool _isConvergence = false;
};
} // namespace impl
} // namespace cplscheme
} // namespace precice