AbsoluteOrRelativeConvergenceMeasure.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <iomanip>
#include <limits>
#include <math.h>
#include <ostream>
#include <string>
#include "../CouplingData.hpp"
#include "ConvergenceMeasure.hpp"
#include "logging/Logger.hpp"
#include "math/differences.hpp"
#include "math/math.hpp"
#include "utils/IntraComm.hpp"
#include "utils/assertion.hpp"
 
namespace precice::cplscheme::tests {
class AbsoluteOrRelativeConvergenceMeasureTest;
}
 
// ----------------------------------------------------------- CLASS DEFINITION
 
namespace precice::cplscheme::impl {
 
class AbsoluteOrRelativeConvergenceMeasure : public ConvergenceMeasure {
public:
  AbsoluteOrRelativeConvergenceMeasure(double absLimit, double relLimit);
 
  ~AbsoluteOrRelativeConvergenceMeasure() override = default;
 
  void newMeasurementSeries() override
  {
    _isConvergence = false;
  }
  void newMeasurementSeries() override {…}
 
  void measure(
      const Eigen::VectorXd &oldValues,
      const Eigen::VectorXd &newValues) override
  {
    PRECICE_ASSERT(oldValues.size() == newValues.size());
    _normDiff      = utils::IntraComm::l2norm(newValues - oldValues);
    _norm          = utils::IntraComm::l2norm(newValues);
    _isConvergence = (_normDiff <= _norm * _convergenceLimitPercent) or (_normDiff <= _convergenceLimit);
  }
  void measure( {…}
 
  bool isConvergence() const override
  {
    return _isConvergence;
  }
  bool isConvergence() const override {…}
 
  std::string printState(const std::string &dataName) override
  {
    std::ostringstream os;
    os << "absolute convergence measure: ";
    os << "two-norm diff of data \"" << dataName << "\" = ";
    os << std::scientific << std::setprecision(2) << getNormAbsResidual();
    os << ", limit = " << _convergenceLimit;
 
    os << ", relative convergence measure: ";
    os << "relative two-norm diff of data \"" << dataName << "\" = ";
    os << std::scientific << std::setprecision(2) << getNormRelResidual();
    os << ", limit = " << _convergenceLimitPercent;
    os << ", normalization = " << _norm;
    os << ", conv = ";
    if (_isConvergence)
      os << "true";
    else
      os << "false";
    return os.str();
  }
  std::string printState(const std::string &dataName) override {…}
 
  virtual double getNormAbsResidual()
  {
    return _normDiff;
  }
  virtual double getNormAbsResidual() {…}
 
  virtual double getNormRelResidual()
  {
    if (math::equals(_norm, 0.))
      return std::numeric_limits<double>::infinity();
    else
      return _normDiff / _norm;
  }
  virtual double getNormRelResidual() {…}
 
  std::string getAbbreviation() const override
  {
    return "AbsOrRel";
  }
  std::string getAbbreviation() const override {…}
 
private:
  logging::Logger _log{"cplscheme::AbsoluteOrRelativeConvergenceMeasure"};
 
  double _convergenceLimit;
 
  double _convergenceLimitPercent;
 
  double _normDiff = 0;
 
  double _norm = 0;
 
  bool _isConvergence = false;
};
class AbsoluteOrRelativeConvergenceMeasure : public ConvergenceMeasure {…};
} // namespace precice::cplscheme::impl