Block-Structured AMR Software Framework
amrex::MLMGT< MF > Class Template Reference

#include <AMReX_MLMG.H>

Classes

class  error
 

Public Types

enum class  CFStrategy : int { none , ghostnodes }
 
using MFType = MF
 
using FAB = typename MLLinOpT< MF >::FAB
 
using RT = typename MLLinOpT< MF >::RT
 
using BCMode = typename MLLinOpT< MF >::BCMode
 
using Location = typename MLLinOpT< MF >::Location
 
using BottomSolver = amrex::BottomSolver
 

Public Member Functions

 MLMGT (MLLinOpT< MF > &a_lp)
 
 ~MLMGT ()
 
 MLMGT (MLMGT< MF > const &)=delete
 
 MLMGT (MLMGT< MF > &&)=delete
 
MLMGT< MF > & operator= (MLMGT< MF > const &)=delete
 
MLMGT< MF > & operator= (MLMGT< MF > &&)=delete
 
template<typename AMF >
RT solve (const Vector< AMF * > &a_sol, const Vector< AMF const * > &a_rhs, RT a_tol_rel, RT a_tol_abs, const char *checkpoint_file=nullptr)
 
template<typename AMF >
RT solve (std::initializer_list< AMF * > a_sol, std::initializer_list< AMF const * > a_rhs, RT a_tol_rel, RT a_tol_abs, const char *checkpoint_file=nullptr)
 
template<typename AMF >
void getGradSolution (const Vector< Array< AMF *, AMREX_SPACEDIM > > &a_grad_sol, Location a_loc=Location::FaceCenter)
 
template<typename AMF >
void getGradSolution (std::initializer_list< Array< AMF *, AMREX_SPACEDIM >> a_grad_sol, Location a_loc=Location::FaceCenter)
 
template<typename AMF >
void getFluxes (const Vector< Array< AMF *, AMREX_SPACEDIM > > &a_flux, Location a_loc=Location::FaceCenter)
 For (alpha * a - beta * (del dot b grad)) phi = rhs, flux means -b grad phi More...
 
template<typename AMF >
void getFluxes (std::initializer_list< Array< AMF *, AMREX_SPACEDIM >> a_flux, Location a_loc=Location::FaceCenter)
 
template<typename AMF >
void getFluxes (const Vector< Array< AMF *, AMREX_SPACEDIM > > &a_flux, const Vector< AMF * > &a_sol, Location a_loc=Location::FaceCenter)
 
template<typename AMF >
void getFluxes (std::initializer_list< Array< AMF *, AMREX_SPACEDIM >> a_flux, std::initializer_list< AMF * > a_sol, Location a_loc=Location::FaceCenter)
 
template<typename AMF >
void getFluxes (const Vector< AMF * > &a_flux, Location a_loc=Location::CellCenter)
 
template<typename AMF >
void getFluxes (std::initializer_list< AMF * > a_flux, Location a_loc=Location::CellCenter)
 
template<typename AMF >
void getFluxes (const Vector< AMF * > &a_flux, const Vector< AMF * > &a_sol, Location a_loc=Location::CellCenter)
 
template<typename AMF >
void getFluxes (std::initializer_list< AMF * > a_flux, std::initializer_list< AMF * > a_sol, Location a_loc=Location::CellCenter)
 
void compResidual (const Vector< MF * > &a_res, const Vector< MF * > &a_sol, const Vector< MF const * > &a_rhs)
 
void apply (const Vector< MF * > &out, const Vector< MF * > &in)
 out = L(in). Note that, if no actual solve is needed, one could turn off multigrid coarsening by constructing a MLLinOp object with an appropriate LPInfo object (e.g., with LPInfo().setMaxCoarseningLevel(0)). More...
 
void setThrowException (bool t) noexcept
 
void setVerbose (int v) noexcept
 
void setMaxIter (int n) noexcept
 
void setMaxFmgIter (int n) noexcept
 
void setFixedIter (int nit) noexcept
 
void setPreSmooth (int n) noexcept
 
void setPostSmooth (int n) noexcept
 
void setFinalSmooth (int n) noexcept
 
void setBottomSmooth (int n) noexcept
 
void setBottomSolver (BottomSolver s) noexcept
 
void setCFStrategy (CFStrategy a_cf_strategy) noexcept
 
void setBottomVerbose (int v) noexcept
 
void setBottomMaxIter (int n) noexcept
 
void setBottomTolerance (RT t) noexcept
 
void setBottomToleranceAbs (RT t) noexcept
 
RT getBottomToleranceAbs () noexcept
 
void setAlwaysUseBNorm (int flag) noexcept
 
void setFinalFillBC (int flag) noexcept
 
int numAMRLevels () const noexcept
 
void setNSolve (int flag) noexcept
 
void setNSolveGridSize (int s) noexcept
 
void prepareForFluxes (Vector< MF const * > const &a_sol)
 
template<typename AMF >
void prepareForSolve (Vector< AMF * > const &a_sol, Vector< AMF const * > const &a_rhs)
 
void prepareForNSolve ()
 
void prepareLinOp ()
 
void prepareMGcycle ()
 
void prepareForGMRES ()
 
void oneIter (int iter)
 
void miniCycle (int amrlev)
 
void mgVcycle (int amrlev, int mglev)
 
void mgFcycle ()
 
void bottomSolve ()
 
void NSolve (MLMGT< MF > &a_solver, MF &a_sol, MF &a_rhs)
 
void actualBottomSolve ()
 
void computeMLResidual (int amrlevmax)
 
void computeResidual (int alev)
 
void computeResWithCrseSolFineCor (int calev, int falev)
 
void computeResWithCrseCorFineCor (int falev)
 
void interpCorrection (int alev)
 
void interpCorrection (int alev, int mglev)
 
void addInterpCorrection (int alev, int mglev)
 
void computeResOfCorrection (int amrlev, int mglev)
 
RT ResNormInf (int alev, bool local=false)
 
RT MLResNormInf (int alevmax, bool local=false)
 
RT MLRhsNormInf (bool local=false)
 
void makeSolvable ()
 
void makeSolvable (int amrlev, int mglev, MF &mf)
 
int bottomSolveWithCG (MF &x, const MF &b, typename MLCGSolverT< MF >::Type type)
 
RT getInitRHS () const noexcept
 
RT getInitResidual () const noexcept
 
RT getFinalResidual () const noexcept
 
Vector< RT > const & getResidualHistory () const noexcept
 
int getNumIters () const noexcept
 
Vector< int > const & getNumCGIters () const noexcept
 
MLLinOpT< MF > & getLinOp ()
 
template<typename AMF >
auto solve (std::initializer_list< AMF * > a_sol, std::initializer_list< AMF const * > a_rhs, RT a_tol_rel, RT a_tol_abs, const char *checkpoint_file) -> RT
 
template<typename AMF >
auto solve (const Vector< AMF * > &a_sol, const Vector< AMF const * > &a_rhs, RT a_tol_rel, RT a_tol_abs, const char *checkpoint_file) -> RT
 

Private Types

enum  timer_types { solve_time =0 , iter_time , bottom_time , ntimers }
 

Private Member Functions

void checkPoint (const Vector< MultiFab * > &a_sol, const Vector< MultiFab const * > &a_rhs, RT a_tol_rel, RT a_tol_abs, const char *a_file_name) const
 

Private Attributes

bool throw_exception = false
 
int verbose = 1
 
int max_iters = 200
 
int do_fixed_number_of_iters = 0
 
int nu1 = 2
 pre More...
 
int nu2 = 2
 post More...
 
int nuf = 8
 when smoother is used as bottom solver More...
 
int nub = 0
 additional smoothing after bottom cg solver More...
 
int max_fmg_iters = 0
 
BottomSolver bottom_solver = BottomSolver::Default
 
CFStrategy cf_strategy = CFStrategy::none
 
int bottom_verbose = 0
 
int bottom_maxiter = 200
 
RT bottom_reltol = std::is_same<RT,double>() ? RT(1.e-4) : RT(1.e-3)
 
RT bottom_abstol = RT(-1.0)
 
int always_use_bnorm = 0
 
int final_fill_bc = 0
 
MLLinOpT< MF > & linop
 
int ncomp
 
int namrlevs
 
int finest_amr_lev
 
bool linop_prepared = false
 
Long solve_called = 0
 
int do_nsolve = false
 N Solve. More...
 
int nsolve_grid_size = 16
 
std::unique_ptr< MLLinOpT< MF > > ns_linop
 
std::unique_ptr< MLMGT< MF > > ns_mlmg
 
std::unique_ptr< MF > ns_sol
 
std::unique_ptr< MF > ns_rhs
 
Vector< MF > sol
 Hypre. More...
 
Vector< MF > rhs
 
Vector< intsol_is_alias
 
Vector< Vector< MF > > res
 First Vector: Amr levels. 0 is the coarest level Second Vector: MG levels. 0 is the finest level. More...
 
Vector< Vector< MF > > cor
 = rhs - L(sol) More...
 
Vector< Vector< MF > > cor_hold
 
Vector< Vector< MF > > rescor
 
Vector< double > timer
 
RT m_rhsnorm0 = RT(-1.0)
 
RT m_init_resnorm0 = RT(-1.0)
 
RT m_final_resnorm0 = RT(-1.0)
 
Vector< intm_niters_cg
 
Vector< RTm_iter_fine_resnorm0
 

Friends

template<typename T >
class MLCGSolverT
 
template<typename M >
class GMRESMLMGT
 

Member Typedef Documentation

◆ BCMode

template<typename MF >
using amrex::MLMGT< MF >::BCMode = typename MLLinOpT<MF>::BCMode

◆ BottomSolver

template<typename MF >
using amrex::MLMGT< MF >::BottomSolver = amrex::BottomSolver

◆ FAB

template<typename MF >
using amrex::MLMGT< MF >::FAB = typename MLLinOpT<MF>::FAB

◆ Location

template<typename MF >
using amrex::MLMGT< MF >::Location = typename MLLinOpT<MF>::Location

◆ MFType

template<typename MF >
using amrex::MLMGT< MF >::MFType = MF

◆ RT

template<typename MF >
using amrex::MLMGT< MF >::RT = typename MLLinOpT<MF>::RT

Member Enumeration Documentation

◆ CFStrategy

template<typename MF >
enum amrex::MLMGT::CFStrategy : int
strong
Enumerator
none 
ghostnodes 

◆ timer_types

template<typename MF >
enum amrex::MLMGT::timer_types
private
Enumerator
solve_time 
iter_time 
bottom_time 
ntimers 

Constructor & Destructor Documentation

◆ MLMGT() [1/3]

template<typename MF >
amrex::MLMGT< MF >::MLMGT ( MLLinOpT< MF > &  a_lp)

◆ ~MLMGT()

template<typename MF >
amrex::MLMGT< MF >::~MLMGT ( )
default

◆ MLMGT() [2/3]

template<typename MF >
amrex::MLMGT< MF >::MLMGT ( MLMGT< MF > const &  )
delete

◆ MLMGT() [3/3]

template<typename MF >
amrex::MLMGT< MF >::MLMGT ( MLMGT< MF > &&  )
delete

Member Function Documentation

◆ actualBottomSolve()

template<typename MF >
void amrex::MLMGT< MF >::actualBottomSolve

◆ addInterpCorrection()

template<typename MF >
void amrex::MLMGT< MF >::addInterpCorrection ( int  alev,
int  mglev 
)

◆ apply()

template<typename MF >
void amrex::MLMGT< MF >::apply ( const Vector< MF * > &  out,
const Vector< MF * > &  in 
)

out = L(in). Note that, if no actual solve is needed, one could turn off multigrid coarsening by constructing a MLLinOp object with an appropriate LPInfo object (e.g., with LPInfo().setMaxCoarseningLevel(0)).

◆ bottomSolve()

template<typename MF >
void amrex::MLMGT< MF >::bottomSolve

◆ bottomSolveWithCG()

template<typename MF >
int amrex::MLMGT< MF >::bottomSolveWithCG ( MF &  x,
const MF &  b,
typename MLCGSolverT< MF >::Type  type 
)

◆ checkPoint()

template<typename MF >
void amrex::MLMGT< MF >::checkPoint ( const Vector< MultiFab * > &  a_sol,
const Vector< MultiFab const * > &  a_rhs,
RT  a_tol_rel,
RT  a_tol_abs,
const char *  a_file_name 
) const
private

◆ compResidual()

template<typename MF >
void amrex::MLMGT< MF >::compResidual ( const Vector< MF * > &  a_res,
const Vector< MF * > &  a_sol,
const Vector< MF const * > &  a_rhs 
)

◆ computeMLResidual()

template<typename MF >
void amrex::MLMGT< MF >::computeMLResidual ( int  amrlevmax)

◆ computeResidual()

template<typename MF >
void amrex::MLMGT< MF >::computeResidual ( int  alev)

◆ computeResOfCorrection()

template<typename MF >
void amrex::MLMGT< MF >::computeResOfCorrection ( int  amrlev,
int  mglev 
)

◆ computeResWithCrseCorFineCor()

template<typename MF >
void amrex::MLMGT< MF >::computeResWithCrseCorFineCor ( int  falev)

◆ computeResWithCrseSolFineCor()

template<typename MF >
void amrex::MLMGT< MF >::computeResWithCrseSolFineCor ( int  calev,
int  falev 
)

◆ getBottomToleranceAbs()

template<typename MF >
RT amrex::MLMGT< MF >::getBottomToleranceAbs ( )
inlinenoexcept

◆ getFinalResidual()

template<typename MF >
RT amrex::MLMGT< MF >::getFinalResidual ( ) const
inlinenoexcept

◆ getFluxes() [1/8]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getFluxes ( const Vector< AMF * > &  a_flux,
const Vector< AMF * > &  a_sol,
Location  a_loc = Location::CellCenter 
)

◆ getFluxes() [2/8]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getFluxes ( const Vector< AMF * > &  a_flux,
Location  a_loc = Location::CellCenter 
)

◆ getFluxes() [3/8]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getFluxes ( const Vector< Array< AMF *, AMREX_SPACEDIM > > &  a_flux,
const Vector< AMF * > &  a_sol,
Location  a_loc = Location::FaceCenter 
)

◆ getFluxes() [4/8]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getFluxes ( const Vector< Array< AMF *, AMREX_SPACEDIM > > &  a_flux,
Location  a_loc = Location::FaceCenter 
)

For (alpha * a - beta * (del dot b grad)) phi = rhs, flux means -b grad phi

◆ getFluxes() [5/8]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getFluxes ( std::initializer_list< AMF * >  a_flux,
Location  a_loc = Location::CellCenter 
)

◆ getFluxes() [6/8]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getFluxes ( std::initializer_list< AMF * >  a_flux,
std::initializer_list< AMF * >  a_sol,
Location  a_loc = Location::CellCenter 
)

◆ getFluxes() [7/8]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getFluxes ( std::initializer_list< Array< AMF *, AMREX_SPACEDIM >>  a_flux,
Location  a_loc = Location::FaceCenter 
)

◆ getFluxes() [8/8]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getFluxes ( std::initializer_list< Array< AMF *, AMREX_SPACEDIM >>  a_flux,
std::initializer_list< AMF * >  a_sol,
Location  a_loc = Location::FaceCenter 
)

◆ getGradSolution() [1/2]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getGradSolution ( const Vector< Array< AMF *, AMREX_SPACEDIM > > &  a_grad_sol,
Location  a_loc = Location::FaceCenter 
)

◆ getGradSolution() [2/2]

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::getGradSolution ( std::initializer_list< Array< AMF *, AMREX_SPACEDIM >>  a_grad_sol,
Location  a_loc = Location::FaceCenter 
)

◆ getInitResidual()

template<typename MF >
RT amrex::MLMGT< MF >::getInitResidual ( ) const
inlinenoexcept

◆ getInitRHS()

template<typename MF >
RT amrex::MLMGT< MF >::getInitRHS ( ) const
inlinenoexcept

◆ getLinOp()

template<typename MF >
MLLinOpT<MF>& amrex::MLMGT< MF >::getLinOp ( )
inline

◆ getNumCGIters()

template<typename MF >
Vector<int> const& amrex::MLMGT< MF >::getNumCGIters ( ) const
inlinenoexcept

◆ getNumIters()

template<typename MF >
int amrex::MLMGT< MF >::getNumIters ( ) const
inlinenoexcept

◆ getResidualHistory()

template<typename MF >
Vector<RT> const& amrex::MLMGT< MF >::getResidualHistory ( ) const
inlinenoexcept

◆ interpCorrection() [1/2]

template<typename MF >
void amrex::MLMGT< MF >::interpCorrection ( int  alev)

◆ interpCorrection() [2/2]

template<typename MF >
void amrex::MLMGT< MF >::interpCorrection ( int  alev,
int  mglev 
)

◆ makeSolvable() [1/2]

template<typename MF >
void amrex::MLMGT< MF >::makeSolvable

◆ makeSolvable() [2/2]

template<typename MF >
void amrex::MLMGT< MF >::makeSolvable ( int  amrlev,
int  mglev,
MF &  mf 
)

◆ mgFcycle()

template<typename MF >
void amrex::MLMGT< MF >::mgFcycle

◆ mgVcycle()

template<typename MF >
void amrex::MLMGT< MF >::mgVcycle ( int  amrlev,
int  mglev 
)

◆ miniCycle()

template<typename MF >
void amrex::MLMGT< MF >::miniCycle ( int  amrlev)

◆ MLResNormInf()

template<typename MF >
auto amrex::MLMGT< MF >::MLResNormInf ( int  alevmax,
bool  local = false 
)

◆ MLRhsNormInf()

template<typename MF >
auto amrex::MLMGT< MF >::MLRhsNormInf ( bool  local = false)

◆ NSolve()

template<typename MF >
void amrex::MLMGT< MF >::NSolve ( MLMGT< MF > &  a_solver,
MF &  a_sol,
MF &  a_rhs 
)

◆ numAMRLevels()

template<typename MF >
int amrex::MLMGT< MF >::numAMRLevels ( ) const
inlinenoexcept

◆ oneIter()

template<typename MF >
void amrex::MLMGT< MF >::oneIter ( int  iter)

◆ operator=() [1/2]

template<typename MF >
MLMGT<MF>& amrex::MLMGT< MF >::operator= ( MLMGT< MF > &&  )
delete

◆ operator=() [2/2]

template<typename MF >
MLMGT<MF>& amrex::MLMGT< MF >::operator= ( MLMGT< MF > const &  )
delete

◆ prepareForFluxes()

template<typename MF >
void amrex::MLMGT< MF >::prepareForFluxes ( Vector< MF const * > const &  a_sol)

◆ prepareForGMRES()

template<typename MF >
void amrex::MLMGT< MF >::prepareForGMRES

◆ prepareForNSolve()

template<typename MF >
void amrex::MLMGT< MF >::prepareForNSolve

◆ prepareForSolve()

template<typename MF >
template<typename AMF >
void amrex::MLMGT< MF >::prepareForSolve ( Vector< AMF * > const &  a_sol,
Vector< AMF const * > const &  a_rhs 
)

◆ prepareLinOp()

template<typename MF >
void amrex::MLMGT< MF >::prepareLinOp

◆ prepareMGcycle()

template<typename MF >
void amrex::MLMGT< MF >::prepareMGcycle

◆ ResNormInf()

template<typename MF >
auto amrex::MLMGT< MF >::ResNormInf ( int  alev,
bool  local = false 
)

◆ setAlwaysUseBNorm()

template<typename MF >
void amrex::MLMGT< MF >::setAlwaysUseBNorm ( int  flag)
inlinenoexcept

◆ setBottomMaxIter()

template<typename MF >
void amrex::MLMGT< MF >::setBottomMaxIter ( int  n)
inlinenoexcept

◆ setBottomSmooth()

template<typename MF >
void amrex::MLMGT< MF >::setBottomSmooth ( int  n)
inlinenoexcept

◆ setBottomSolver()

template<typename MF >
void amrex::MLMGT< MF >::setBottomSolver ( BottomSolver  s)
inlinenoexcept

◆ setBottomTolerance()

template<typename MF >
void amrex::MLMGT< MF >::setBottomTolerance ( RT  t)
inlinenoexcept

◆ setBottomToleranceAbs()

template<typename MF >
void amrex::MLMGT< MF >::setBottomToleranceAbs ( RT  t)
inlinenoexcept

◆ setBottomVerbose()

template<typename MF >
void amrex::MLMGT< MF >::setBottomVerbose ( int  v)
inlinenoexcept

◆ setCFStrategy()

template<typename MF >
void amrex::MLMGT< MF >::setCFStrategy ( CFStrategy  a_cf_strategy)
inlinenoexcept

◆ setFinalFillBC()

template<typename MF >
void amrex::MLMGT< MF >::setFinalFillBC ( int  flag)
inlinenoexcept

◆ setFinalSmooth()

template<typename MF >
void amrex::MLMGT< MF >::setFinalSmooth ( int  n)
inlinenoexcept

◆ setFixedIter()

template<typename MF >
void amrex::MLMGT< MF >::setFixedIter ( int  nit)
inlinenoexcept

◆ setMaxFmgIter()

template<typename MF >
void amrex::MLMGT< MF >::setMaxFmgIter ( int  n)
inlinenoexcept

◆ setMaxIter()

template<typename MF >
void amrex::MLMGT< MF >::setMaxIter ( int  n)
inlinenoexcept

◆ setNSolve()

template<typename MF >
void amrex::MLMGT< MF >::setNSolve ( int  flag)
inlinenoexcept

◆ setNSolveGridSize()

template<typename MF >
void amrex::MLMGT< MF >::setNSolveGridSize ( int  s)
inlinenoexcept

◆ setPostSmooth()

template<typename MF >
void amrex::MLMGT< MF >::setPostSmooth ( int  n)
inlinenoexcept

◆ setPreSmooth()

template<typename MF >
void amrex::MLMGT< MF >::setPreSmooth ( int  n)
inlinenoexcept

◆ setThrowException()

template<typename MF >
void amrex::MLMGT< MF >::setThrowException ( bool  t)
inlinenoexcept

◆ setVerbose()

template<typename MF >
void amrex::MLMGT< MF >::setVerbose ( int  v)
inlinenoexcept

◆ solve() [1/4]

template<typename MF >
template<typename AMF >
auto amrex::MLMGT< MF >::solve ( const Vector< AMF * > &  a_sol,
const Vector< AMF const * > &  a_rhs,
RT  a_tol_rel,
RT  a_tol_abs,
const char *  checkpoint_file 
) -> RT

◆ solve() [2/4]

template<typename MF >
template<typename AMF >
RT amrex::MLMGT< MF >::solve ( const Vector< AMF * > &  a_sol,
const Vector< AMF const * > &  a_rhs,
RT  a_tol_rel,
RT  a_tol_abs,
const char *  checkpoint_file = nullptr 
)

◆ solve() [3/4]

template<typename MF >
template<typename AMF >
auto amrex::MLMGT< MF >::solve ( std::initializer_list< AMF * >  a_sol,
std::initializer_list< AMF const * >  a_rhs,
RT  a_tol_rel,
RT  a_tol_abs,
const char *  checkpoint_file 
) -> RT

◆ solve() [4/4]

template<typename MF >
template<typename AMF >
RT amrex::MLMGT< MF >::solve ( std::initializer_list< AMF * >  a_sol,
std::initializer_list< AMF const * >  a_rhs,
RT  a_tol_rel,
RT  a_tol_abs,
const char *  checkpoint_file = nullptr 
)

Friends And Related Function Documentation

◆ GMRESMLMGT

template<typename MF >
template<typename M >
friend class GMRESMLMGT
friend

◆ MLCGSolverT

template<typename MF >
template<typename T >
friend class MLCGSolverT
friend

Member Data Documentation

◆ always_use_bnorm

template<typename MF >
int amrex::MLMGT< MF >::always_use_bnorm = 0
private

◆ bottom_abstol

template<typename MF >
RT amrex::MLMGT< MF >::bottom_abstol = RT(-1.0)
private

◆ bottom_maxiter

template<typename MF >
int amrex::MLMGT< MF >::bottom_maxiter = 200
private

◆ bottom_reltol

template<typename MF >
RT amrex::MLMGT< MF >::bottom_reltol = std::is_same<RT,double>() ? RT(1.e-4) : RT(1.e-3)
private

◆ bottom_solver

template<typename MF >
BottomSolver amrex::MLMGT< MF >::bottom_solver = BottomSolver::Default
private

◆ bottom_verbose

template<typename MF >
int amrex::MLMGT< MF >::bottom_verbose = 0
private

◆ cf_strategy

template<typename MF >
CFStrategy amrex::MLMGT< MF >::cf_strategy = CFStrategy::none
private

◆ cor

template<typename MF >
Vector<Vector<MF> > amrex::MLMGT< MF >::cor
private

= rhs - L(sol)

L(cor) = res

◆ cor_hold

template<typename MF >
Vector<Vector<MF> > amrex::MLMGT< MF >::cor_hold
private

◆ do_fixed_number_of_iters

template<typename MF >
int amrex::MLMGT< MF >::do_fixed_number_of_iters = 0
private

◆ do_nsolve

template<typename MF >
int amrex::MLMGT< MF >::do_nsolve = false
private

N Solve.

◆ final_fill_bc

template<typename MF >
int amrex::MLMGT< MF >::final_fill_bc = 0
private

◆ finest_amr_lev

template<typename MF >
int amrex::MLMGT< MF >::finest_amr_lev
private

◆ linop

template<typename MF >
MLLinOpT<MF>& amrex::MLMGT< MF >::linop
private

◆ linop_prepared

template<typename MF >
bool amrex::MLMGT< MF >::linop_prepared = false
private

◆ m_final_resnorm0

template<typename MF >
RT amrex::MLMGT< MF >::m_final_resnorm0 = RT(-1.0)
private

◆ m_init_resnorm0

template<typename MF >
RT amrex::MLMGT< MF >::m_init_resnorm0 = RT(-1.0)
private

◆ m_iter_fine_resnorm0

template<typename MF >
Vector<RT> amrex::MLMGT< MF >::m_iter_fine_resnorm0
private

◆ m_niters_cg

template<typename MF >
Vector<int> amrex::MLMGT< MF >::m_niters_cg
private

◆ m_rhsnorm0

template<typename MF >
RT amrex::MLMGT< MF >::m_rhsnorm0 = RT(-1.0)
private

◆ max_fmg_iters

template<typename MF >
int amrex::MLMGT< MF >::max_fmg_iters = 0
private

◆ max_iters

template<typename MF >
int amrex::MLMGT< MF >::max_iters = 200
private

◆ namrlevs

template<typename MF >
int amrex::MLMGT< MF >::namrlevs
private

◆ ncomp

template<typename MF >
int amrex::MLMGT< MF >::ncomp
private

◆ ns_linop

template<typename MF >
std::unique_ptr<MLLinOpT<MF> > amrex::MLMGT< MF >::ns_linop
private

◆ ns_mlmg

template<typename MF >
std::unique_ptr<MLMGT<MF> > amrex::MLMGT< MF >::ns_mlmg
private

◆ ns_rhs

template<typename MF >
std::unique_ptr<MF> amrex::MLMGT< MF >::ns_rhs
private

◆ ns_sol

template<typename MF >
std::unique_ptr<MF> amrex::MLMGT< MF >::ns_sol
private

◆ nsolve_grid_size

template<typename MF >
int amrex::MLMGT< MF >::nsolve_grid_size = 16
private

◆ nu1

template<typename MF >
int amrex::MLMGT< MF >::nu1 = 2
private

pre

◆ nu2

template<typename MF >
int amrex::MLMGT< MF >::nu2 = 2
private

post

◆ nub

template<typename MF >
int amrex::MLMGT< MF >::nub = 0
private

additional smoothing after bottom cg solver

◆ nuf

template<typename MF >
int amrex::MLMGT< MF >::nuf = 8
private

when smoother is used as bottom solver

◆ res

template<typename MF >
Vector<Vector<MF> > amrex::MLMGT< MF >::res
private

First Vector: Amr levels. 0 is the coarest level Second Vector: MG levels. 0 is the finest level.

◆ rescor

template<typename MF >
Vector<Vector<MF> > amrex::MLMGT< MF >::rescor
private

= res - L(cor) Residual of the correction form

◆ rhs

template<typename MF >
Vector<MF> amrex::MLMGT< MF >::rhs
private

Copy of original rhs L(sol) = rhs

◆ sol

template<typename MF >
Vector<MF> amrex::MLMGT< MF >::sol
private

Hypre.

PETSc

To avoid confusion, terms like sol, cor, rhs, res, ... etc. are in the frame of the original equation, not the correction form Might be alias to argument a_sol

◆ sol_is_alias

template<typename MF >
Vector<int> amrex::MLMGT< MF >::sol_is_alias
private

◆ solve_called

template<typename MF >
Long amrex::MLMGT< MF >::solve_called = 0
private

◆ throw_exception

template<typename MF >
bool amrex::MLMGT< MF >::throw_exception = false
private

◆ timer

template<typename MF >
Vector<double> amrex::MLMGT< MF >::timer
private

◆ verbose

template<typename MF >
int amrex::MLMGT< MF >::verbose = 1
private

The documentation for this class was generated from the following files: