#include <AMReX_GMRES.H>

Public Types
using	RT = typename M::RT

Public Member Functions
	GMRES ()

void	define (M &linop)

void	solve (V &a_sol, V const &a_rhs, RT a_tol_rel, RT a_tol_abs, int a_its=-1)
	Solve the linear system. More...

void	setVerbose (int v)
	Sets verbosity. More...

void	setRestartLength (int rl)
	Sets restart length. The default is 30. More...

void	setMaxIters (int niters)
	Sets the max number of iterations. More...

int	getNumIters () const
	Gets the number of iterations. More...

int	getStatus () const
	Gets the solver status. More...

RT	getResidualNorm () const
	Gets the 2-norm of the residual. More...

Private Member Functions
void	clear ()

void	allocate_scratch ()

void	cycle (V &a_xx, int &a_status, int &a_itcount, RT &a_rnorm0)

void	build_solution (V &a_xx, int it)

void	compute_residual (V &a_rr, V const &a_xx, V const &a_bb)

bool	converged (RT r0, RT r) const

void	gram_schmidt_orthogonalization (int it)

void	update_hessenberg (int it, bool happyend, RT &res)

Private Attributes
int	m_verbose = 0

int	m_maxiter = 2000

int	m_its = 0

int	m_status = -1

int	m_restrtlen = 30

RT	m_res = std::numeric_limits<RT>::max()

RT	m_rtol = RT(0)

RT	m_atol = RT(0)

Vector< RT >	m_hh_1d

Vector< RT >	m_hes_1d

Table2D< RT >	m_hh

Table2D< RT >	m_hes

Vector< RT >	m_grs

Vector< RT >	m_cc

Vector< RT >	m_ss

std::unique_ptr< V >	m_v_tmp_rhs

std::unique_ptr< V >	m_v_tmp_lhs

Vector< V >	m_vv

M *	m_linop = nullptr

Detailed Description

template<typename V, typename M>
class amrex::GMRES< V, M >

GMRES.

This class implements the GMRES algorithm. The template parameter V is for a linear algebra vector class. For example, it could be amrex::MultiFab. The other template parameter M is for a linear operator class with a number of required member functions. Note that conceptually M contains a matrix. However, it does not mean it needs to have a member variable storing the matrix, because GMRES only needs the matrix vector product, not the matrix itself.

Template Parameters

V linear algebra vector. It must be default constructible, move constructible, and move assignable.

M

linear operator. A list of required member functions for M is shown below. Here RT (typename M::RT) is either double or float. Examples of implementation for V being a single-component MultiFab are also given below.

void apply(V& Ax, V const& x)
Ax = A(x), where A is the linear operator performing matrix vector product. Here x is made with the makeVecLHS function. Therefore, it may have ghost cells and it's safe to cast it with const_cast<V&>(x) and do ghost cell exchange, if necessary.
void assign(V& lhs, V const& rhs)
lhs = rhs. For example, MultiFab::Copy(lhs,rhs,0,0,1,0).
RT dotProduct(V const& v1, V const& v2)
returns v1 * v2. For example, MultiFab::Dot(v1,0,v2,0,1,0).
void increment(V& lhs, V const& rhs, RT a)
lhs += a * rhs. For example, MultiFab::Saxpy(lhs,a,rhs,0,0,1,0).
void linComb(V& lhs, RT a, V const& rhs_a, RT b, V const& rhs_b)
lhs = a * rhs_a + b * rhs_b. For example, MultiFab::LinComb(lhs,a,rhs_a,0,b,rhs_b,0,0,1,0).
V makeVecRHS()
returns a V object that is suitable as RHS in M x = b. The reason we distinguish between LHS and RHS is M might need the distinction for efficiency. For example, if V is MultiFab, we might need the x in the LHS of M x = b to have ghost cells for efficiency, whereas no ghost cells are needed for the RHS (i.e., b). An example of the implementation might be return MultiFab(grids,dmap,1,0).
V makeVecLHS()
returns a V object that is suitable as LHS in M x = b. See the description for makeVecRHS for more details. An example of the implementation might be return MultiFab(grids,dmap,1,1).
RT norm2(V const& v)
returns the 2-norm of v. For example, return v.norm2().
void precond(V& lhs, V const& rhs)
applies right-preconditioning, i.e., solve P(lhs) = rhs, where P is an approximation to A If there is no preconditioner, P = I and thus this function should do lhs = rhs.
void scale(V& v, RT fac)
scales v by fac. For example, v.mult(fac).
void setToZero(V& v)
v = 0. For example, v.setVal(0).