solver_minres.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2000 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_solver_minres_h
#define dealii_solver_minres_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/enable_observer_pointer.h>
#include <deal.II/base/logstream.h>
#include <deal.II/base/signaling_nan.h>
#include <deal.II/base/template_constraints.h>
 
#include <deal.II/lac/solver.h>
#include <deal.II/lac/solver_control.h>
 
#include <cmath>
 
DEAL_II_NAMESPACE_OPEN
 
template <typename VectorType = Vector<double>>
DEAL_II_CXX20_REQUIRES(concepts::is_vector_space_vector<VectorType>)
class SolverMinRes : public SolverBase<VectorType>
{
public:
  struct AdditionalData
  {};
 
  SolverMinRes(SolverControl            &cn,
               VectorMemory<VectorType> &mem,
               const AdditionalData     &data = AdditionalData());
 
  SolverMinRes(SolverControl        &cn,
               const AdditionalData &data = AdditionalData());
 
  virtual ~SolverMinRes() override = default;
 
  template <typename MatrixType, typename PreconditionerType>
  DEAL_II_CXX20_REQUIRES(
    (concepts::is_linear_operator_on<MatrixType, VectorType> &&
     concepts::is_linear_operator_on<PreconditionerType, VectorType>))
  void solve(const MatrixType         &A,
             VectorType               &x,
             const VectorType         &b,
             const PreconditionerType &preconditioner);
 
  DeclExceptionMsg(ExcPreconditionerNotDefinite,
                   "The preconditioner for MinRes must be a symmetric and "
                   "definite operator, even though MinRes can solve linear "
                   "systems with symmetric and *indefinite* operators. "
                   "During iterations, MinRes has detected that the "
                   "preconditioner is apparently not definite.");
protected:
  virtual double
  criterion();
 
  virtual void
  print_vectors(const unsigned int step,
                const VectorType  &x,
                const VectorType  &r,
                const VectorType  &d) const;
 
  double res2;
};
 
/*------------------------- Implementation ----------------------------*/
 
#ifndef DOXYGEN
 
template <typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_vector_space_vector<VectorType>)
SolverMinRes<VectorType>::SolverMinRes(SolverControl            &cn,
                                       VectorMemory<VectorType> &mem,
                                       const AdditionalData &)
  : SolverBase<VectorType>(cn, mem)
  , res2(numbers::signaling_nan<double>())
{}
 
 
 
template <typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_vector_space_vector<VectorType>)
SolverMinRes<VectorType>::SolverMinRes(SolverControl &cn,
                                       const AdditionalData &)
  : SolverBase<VectorType>(cn)
  , res2(numbers::signaling_nan<double>())
{}
 
 
 
template <typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_vector_space_vector<VectorType>)
double SolverMinRes<VectorType>::criterion()
{
  return res2;
}
 
 
template <typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_vector_space_vector<VectorType>)
void SolverMinRes<VectorType>::print_vectors(const unsigned int,
                                             const VectorType &,
                                             const VectorType &,
                                             const VectorType &) const
{}
 
 
 
template <typename VectorType>
DEAL_II_CXX20_REQUIRES(concepts::is_vector_space_vector<VectorType>)
template <typename MatrixType, typename PreconditionerType>
DEAL_II_CXX20_REQUIRES(
  (concepts::is_linear_operator_on<MatrixType, VectorType> &&
   concepts::is_linear_operator_on<PreconditionerType, VectorType>))
void SolverMinRes<VectorType>::solve(const MatrixType         &A,
                                     VectorType               &x,
                                     const VectorType         &b,
                                     const PreconditionerType &preconditioner)
{
  LogStream::Prefix prefix("minres");
 
  // Memory allocation
  typename VectorMemory<VectorType>::Pointer Vu0(this->memory);
  typename VectorMemory<VectorType>::Pointer Vu1(this->memory);
  typename VectorMemory<VectorType>::Pointer Vu2(this->memory);
 
  typename VectorMemory<VectorType>::Pointer Vm0(this->memory);
  typename VectorMemory<VectorType>::Pointer Vm1(this->memory);
  typename VectorMemory<VectorType>::Pointer Vm2(this->memory);
 
  typename VectorMemory<VectorType>::Pointer Vv(this->memory);
 
  // define some aliases for simpler access
  using vecptr     = VectorType *;
  vecptr      u[3] = {Vu0.get(), Vu1.get(), Vu2.get()};
  vecptr      m[3] = {Vm0.get(), Vm1.get(), Vm2.get()};
  VectorType &v    = *Vv;
 
  // resize the vectors, but do not set the values since they'd be overwritten
  // soon anyway.
  u[0]->reinit(b, true);
  u[1]->reinit(b, true);
  u[2]->reinit(b, true);
  m[0]->reinit(b, true);
  m[1]->reinit(b, true);
  m[2]->reinit(b, true);
  v.reinit(b, true);
 
  // some values needed
  double delta[3] = {0, 0, 0};
  double f[2]     = {0, 0};
  double e[2]     = {0, 0};
 
  double r_l2 = 0;
  double r0   = 0;
  double tau  = 0;
  double c    = 0;
  double s    = 0;
  double d_   = 0;
 
  // The iteration step.
  unsigned int j = 1;
 
 
  // Start of the solution process
  A.vmult(*m[0], x);
  *u[1] = b;
  *u[1] -= *m[0];
  // Precondition is applied.
  // The preconditioner has to be
  // positive definite and symmetric
 
  // M v = u[1]
  preconditioner.vmult(v, *u[1]);
 
  delta[1] = v * (*u[1]);
  // Preconditioner positive
  Assert(delta[1] >= 0, ExcPreconditionerNotDefinite());
 
  r0   = std::sqrt(delta[1]);
  r_l2 = r0;
 
 
  u[0]->reinit(b);
  delta[0] = 1.;
  m[0]->reinit(b);
  m[1]->reinit(b);
  m[2]->reinit(b);
 
  SolverControl::State conv = this->iteration_status(0, r_l2, x);
  while (conv == SolverControl::iterate)
    {
      const double beta     = std::sqrt(delta[1]);
      const double inv_beta = 1.0 / beta; // Compute inverse once
      if (delta[1] != 0)
        v *= inv_beta;
      else
        v.reinit(b);
 
      A.vmult(*u[2], v);
      u[2]->add(-beta / std::sqrt(delta[0]), *u[0]);
 
      const double gamma = *u[2] * v;
      u[2]->add(-gamma * inv_beta, *u[1]);
      *m[0] = v;
 
      // precondition: solve M v = u[2]
      // Preconditioner has to be positive
      // definite and symmetric.
      preconditioner.vmult(v, *u[2]);
 
      delta[2] = v * (*u[2]);
 
      Assert(delta[2] >= 0, ExcPreconditionerNotDefinite());
 
      if (j == 1)
        {
          d_   = gamma;
          e[1] = std::sqrt(delta[2]);
        }
      if (j > 1)
        {
          d_   = s * e[0] - c * gamma;
          e[0] = c * e[0] + s * gamma;
          f[1] = s * std::sqrt(delta[2]);
          e[1] = -c * std::sqrt(delta[2]);
        }
 
      const double d     = std::sqrt(d_ * d_ + delta[2]);
      const double inv_d = 1.0 / d; // Compute inverse once
 
      if (j > 1)
        tau *= s / c;
      c = d_ * inv_d;
      tau *= c;
 
      s = std::sqrt(delta[2]) * inv_d;
 
      if (j == 1)
        tau = r0 * c;
 
      m[0]->add(-e[0], *m[1]);
      if (j > 1)
        m[0]->add(-f[0], *m[2]);
      *m[0] *= inv_d;
      x.add(tau, *m[0]);
      r_l2 *= std::fabs(s);
 
      conv = this->iteration_status(j, r_l2, x);
 
      // next iteration step
      ++j;
      // All vectors have to be shifted
      // one iteration step.
      // This should be changed one time.
      swap(*m[2], *m[1]);
      swap(*m[1], *m[0]);
 
      // likewise, but reverse direction:
      //   u[0] = u[1];
      //   u[1] = u[2];
      swap(*u[0], *u[1]);
      swap(*u[1], *u[2]);
 
      // these are scalars, so need
      // to bother
      f[0]     = f[1];
      e[0]     = e[1];
      delta[0] = delta[1];
      delta[1] = delta[2];
    }
 
  // in case of failure: throw exception
  AssertThrow(conv == SolverControl::success,
              SolverControl::NoConvergence(j, r_l2));
 
  // otherwise exit as normal
}
 
#endif // DOXYGEN
 
DEAL_II_NAMESPACE_CLOSE
 
#endif