#include <NekLinSysIterGMRESLoc.h>

Inheritance diagram for Nektar::LibUtilities::NekLinSysIterGMRESLoc:

Public Member Functions
	NekLinSysIterGMRESLoc (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vRowComm, const int nDimen, const NekSysKey &pKey=NekSysKey())

	~NekLinSysIterGMRESLoc () override=default

int	GetMaxLinIte ()

Public Member Functions inherited from Nektar::LibUtilities::NekLinSysIter
	NekLinSysIter (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vRowComm, const int nDimen, const NekSysKey &pKey)

	~NekLinSysIter () override=default

void	SetUniversalUniqueMap (const Array< OneD, const int > &map)

void	setRhsMagnitude (const NekDouble mag)

void	SetNekLinSysMaxIterations (const unsigned int in)

void	SetLinSysMaxStorage (const unsigned int in)

bool	IsLocal ()

Public Member Functions inherited from Nektar::LibUtilities::NekSys
	NekSys (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vRowComm, const int nDimen, const NekSysKey &pKey)

virtual	~NekSys ()=default

void	InitObject ()

void	SetSysOperators (const NekSysOperators &in)

const NekSysOperators &	GetSysOperators ()

int	SolveSystem (const int nGlobal, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const int nDir, const NekDouble tol=1.0E-7, const NekDouble factor=1.0)

bool	ConvergenceCheck (const int nIteration, const Array< OneD, const NekDouble > &Residual, const NekDouble tol=1.0E-7)

void	SetFlagWarnings (bool in)

Static Public Member Functions
static NekLinSysIterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vRowComm, const int nDimen, const NekSysKey &pKey)

Static Public Member Functions inherited from Nektar::LibUtilities::NekLinSysIter
static NekLinSysIterSharedPtr	CreateInstance (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vRowComm, const int nDimen, const NekSysKey &pKey)

Static Public Member Functions inherited from Nektar::LibUtilities::NekSys
static NekSysSharedPtr	CreateInstance (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vRowComm, const int nDimen, const NekSysKey &pKey)

Static Public Attributes
static std::string	className

Protected Member Functions
void	v_InitObject () override

int	v_SolveSystem (const int nLocal, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const int nDir, const NekDouble tol, const NekDouble factor) override

Protected Member Functions inherited from Nektar::LibUtilities::NekLinSysIter
void	Set_Rhs_Magnitude (const NekVector< NekDouble > &pIn)

void	Set_Rhs_Magnitude (const Array< OneD, NekDouble > &pIn)

void	SetUniversalUniqueMap ()

void	v_InitObject () override

Protected Member Functions inherited from Nektar::LibUtilities::NekSys
virtual void	v_InitObject ()

virtual void	v_SetSysOperators (const NekSysOperators &in)

virtual int	v_SolveSystem (const int nGlobal, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const int nDir, const NekDouble tol, const NekDouble factor)

virtual bool	v_ConvergenceCheck (const int nIteration, const Array< OneD, const NekDouble > &Residual, const NekDouble tol)

virtual void	v_NekSysInitialGuess (const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pguess)

Protected Attributes
int	m_maxrestart

int	m_KrylovMaxHessMatBand

bool	m_NekLinSysLeftPrecon = false

bool	m_NekLinSysRightPrecon = true

bool	m_DifferenceFlag0 = false

bool	m_DifferenceFlag1 = false

Protected Attributes inherited from Nektar::LibUtilities::NekLinSysIter
Array< OneD, int >	m_map
	Global to universal unique map. More...

NekDouble	m_rhs_magnitude = NekConstants::kNekUnsetDouble
	Dot product of rhs to normalise stopping criterion. More...

int	m_totalIterations = 0

NekDouble	m_prec_factor = 1.0

int	m_LinSysMaxStorage

bool	m_isLocal

Protected Attributes inherited from Nektar::LibUtilities::NekSys
int	m_maxiter
	Maximum iterations. More...

NekDouble	m_tolerance
	Tolerance of iterative solver. More...

LibUtilities::CommSharedPtr	m_rowComm
	Communicate. More...

bool	m_converged
	Whether the iteration has been converged. More...

bool	m_root
	Root if parallel. More...

bool	m_verbose
	Verbose. More...

bool	m_FlagWarnings

NekSysOperators	m_operator
	Operators. More...

int	m_SysDimen
	The dimension of the system. More...

Private Member Functions
int	DoGMRES (const int pNumRows, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
	Actual iterative solve-GMRES. More...

NekDouble	DoGmresRestart (const bool restarted, const bool truncted, const int nLocal, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput)
	Actual iterative gmres solver for one restart. More...

void	DoArnoldi (const int starttem, const int endtem, const int nLocal, Array< OneD, NekDouble > &w, Array< OneD, NekDouble > &wk, Array< OneD, NekDouble > &V1, Array< OneD, NekDouble > &V2, Array< OneD, NekDouble > &h)

void	DoGivensRotation (const int starttem, const int endtem, Array< OneD, NekDouble > &c, Array< OneD, NekDouble > &s, Array< OneD, NekDouble > &h, Array< OneD, NekDouble > &eta)

void	DoBackward (const int number, Array< OneD, Array< OneD, NekDouble > > &A, const Array< OneD, const NekDouble > &b, Array< OneD, NekDouble > &y)

Private Attributes
Array< OneD, Array< OneD, NekDouble > >	m_hes

Array< OneD, Array< OneD, NekDouble > >	m_Upper

Array< OneD, Array< OneD, NekDouble > >	m_V_total

Static Private Attributes
static std::string	lookupIds []

static std::string	def

Friends
class	MemoryManager< NekLinSysIterGMRESLoc >
	Support creation through MemoryManager. More...

Detailed Description

Solves a linear system using iterative methods using local storage rather than global

Definition at line 45 of file NekLinSysIterGMRESLoc.h.

Constructor & Destructor Documentation

◆ NekLinSysIterGMRESLoc()

Nektar::LibUtilities::NekLinSysIterGMRESLoc::NekLinSysIterGMRESLoc	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const LibUtilities::CommSharedPtr &	vRowComm,
		const int	nDimen,
		const NekSysKey &	pKey = `NekSysKey()`
	)

Definition at line 54 of file NekLinSysIterGMRESLoc.cpp.

    : NekLinSysIter(pSession, vRowComm, nDimen, pKey)
{
    m_NekLinSysLeftPrecon  = pKey.m_NekLinSysLeftPrecon;
    m_NekLinSysRightPrecon = pKey.m_NekLinSysRightPrecon;
 
    m_KrylovMaxHessMatBand = pKey.m_KrylovMaxHessMatBand;
 
    m_maxrestart = ceil(NekDouble(m_maxiter) / NekDouble(m_LinSysMaxStorage));
    m_LinSysMaxStorage = min(m_maxiter, m_LinSysMaxStorage);
 
    m_DifferenceFlag0 = pKey.m_DifferenceFlag0;
    m_DifferenceFlag1 = pKey.m_DifferenceFlag1;
 
    m_isLocal = true;
 
    // Allocate array storage of coefficients
    // Hessenburg matrix
    m_hes = Array<OneD, Array<OneD, NekDouble>>(m_LinSysMaxStorage);
    for (size_t nd = 0; nd < m_LinSysMaxStorage; nd++)
    {
        m_hes[nd] = Array<OneD, NekDouble>(m_LinSysMaxStorage + 1, 0.0);
    }
    // Hesseburg matrix after rotation
    m_Upper = Array<OneD, Array<OneD, NekDouble>>(m_LinSysMaxStorage);
    for (size_t nd = 0; nd < m_LinSysMaxStorage; nd++)
    {
        m_Upper[nd] = Array<OneD, NekDouble>(m_LinSysMaxStorage + 1, 0.0);
    }
    // Total search directions
    m_V_total = Array<OneD, Array<OneD, NekDouble>>(m_LinSysMaxStorage + 1);
}

◆ ~NekLinSysIterGMRESLoc()

Nektar::LibUtilities::NekLinSysIterGMRESLoc::~NekLinSysIterGMRESLoc ( )

overridedefault

Member Function Documentation

◆ create()

static NekLinSysIterSharedPtr Nektar::LibUtilities::NekLinSysIterGMRESLoc::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const LibUtilities::CommSharedPtr &	vRowComm,
		const int	nDimen,
		const NekSysKey &	pKey
	)

inlinestatic

Definition at line 51 of file NekLinSysIterGMRESLoc.h.

    {
        NekLinSysIterSharedPtr p =
            MemoryManager<NekLinSysIterGMRESLoc>::AllocateSharedPtr(
                pSession, vRowComm, nDimen, pKey);
        p->InitObject();
        return p;
    }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.

◆ DoArnoldi()

void Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoArnoldi	(	const int	starttem,
		const int	endtem,
		const int	nLocal,
		Array< OneD, NekDouble > &	w,
		Array< OneD, NekDouble > &	wk,
		Array< OneD, NekDouble > &	V1,
		Array< OneD, NekDouble > &	V2,
		Array< OneD, NekDouble > &	h
	)

private

Definition at line 408 of file NekLinSysIterGMRESLoc.cpp.

{
    NekDouble alpha, beta, vExchange = 0.0;
    LibUtilities::Timer timer;
    timer.Start();
    m_operator.DoNekSysLhsEval(V1, w, m_DifferenceFlag1);
    timer.Stop();
    timer.AccumulateRegion("NekSysOperators::DoNekSysLhsEval", 10);
 
    if (m_NekLinSysLeftPrecon)
    {
        m_operator.DoNekSysPrecon(w, w);
    }
 
    Vmath::Smul(nLocal, sqrt(m_prec_factor), w, 1, w, 1);
 
    // Modified Gram-Schmidt
    for (int i = starttem; i < endtem; ++i)
    {
        // Do inner product on equivalent of global values excluding
        // Diriclet conditions. To do this need to assmble (and
        // scatter back vector and then zero Dirichlet conditions.
        m_operator.DoAssembleLoc(m_V_total[i], wk, true);
        vExchange = Vmath::Dot(nLocal, wk, w);
        m_rowComm->AllReduce(vExchange, LibUtilities::ReduceSum);
 
        h[i] = vExchange;
 
        beta = -1.0 * vExchange;
        Vmath::Svtvp(nLocal, beta, m_V_total[i], 1, w, 1, w, 1);
    }
    // end of Modified Gram-Schmidt
 
    // calculate the L2 norm and normalize
    m_operator.DoAssembleLoc(w, wk, true);
    vExchange = Vmath::Dot(nLocal, wk, w);
    m_rowComm->AllReduce(vExchange, LibUtilities::ReduceSum);
 
    h[endtem] = sqrt(vExchange);
 
    alpha = 1.0 / h[endtem];
    Vmath::Smul(nLocal, alpha, w, 1, V2, 1);
}

Referenced by DoGmresRestart().

◆ DoBackward()

void Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoBackward	(	const int	number,
		Array< OneD, Array< OneD, NekDouble > > &	A,
		const Array< OneD, const NekDouble > &	b,
		Array< OneD, NekDouble > &	y
	)

private

Definition at line 513 of file NekLinSysIterGMRESLoc.cpp.

{
    // Number is the entry number
    // but C++'s order need to be one smaller
    int maxid = number - 1;
    NekDouble sum;
    y[maxid] = b[maxid] / A[maxid][maxid];
    for (int i = maxid - 1; i > -1; --i)
    {
        sum = b[i];
        for (int j = i + 1; j < number; ++j)
        {
            // i and j changes due to use Array<OneD,Array<OneD,NekDouble>>
            sum -= y[j] * A[j][i];
        }
        y[i] = sum / A[i][i];
    }
}

Referenced by DoGmresRestart().

◆ DoGivensRotation()

void Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGivensRotation	(	const int	starttem,
		const int	endtem,
		Array< OneD, NekDouble > &	c,
		Array< OneD, NekDouble > &	s,
		Array< OneD, NekDouble > &	h,
		Array< OneD, NekDouble > &	eta
	)

private

Definition at line 459 of file NekLinSysIterGMRESLoc.cpp.

{
    NekDouble temp_dbl;
    NekDouble dd;
    NekDouble hh;
    int idtem = endtem - 1;
    // The starttem and endtem are beginning and ending order of Givens rotation
    // They usually equal to the beginning position and ending position of
    // Hessenburg matrix But sometimes starttem will change, like if it is
    // initial 0 and becomes nonzero because previous Givens rotation See Yu
    // Pan's User Guide
    for (int i = starttem; i < idtem; ++i)
    {
        temp_dbl = c[i] * h[i] - s[i] * h[i + 1];
        h[i + 1] = s[i] * h[i] + c[i] * h[i + 1];
        h[i]     = temp_dbl;
    }
    dd = h[idtem];
    hh = h[endtem];
    if (hh == 0.0)
    {
        c[idtem] = 1.0;
        s[idtem] = 0.0;
    }
    else if (abs(hh) > abs(dd))
    {
        temp_dbl = -dd / hh;
        s[idtem] = 1.0 / sqrt(1.0 + temp_dbl * temp_dbl);
        c[idtem] = temp_dbl * s[idtem];
    }
    else
    {
        temp_dbl = -hh / dd;
        c[idtem] = 1.0 / sqrt(1.0 + temp_dbl * temp_dbl);
        s[idtem] = temp_dbl * c[idtem];
    }
 
    h[idtem]  = c[idtem] * h[idtem] - s[idtem] * h[endtem];
    h[endtem] = 0.0;
 
    temp_dbl    = c[idtem] * eta[idtem] - s[idtem] * eta[endtem];
    eta[endtem] = s[idtem] * eta[idtem] + c[idtem] * eta[endtem];
    eta[idtem]  = temp_dbl;
}

References tinysimd::abs(), and tinysimd::sqrt().

Referenced by DoGmresRestart().

◆ DoGMRES()

int Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGMRES	(	const int	nLocal,
		const Array< OneD, const NekDouble > &	pInput,
		Array< OneD, NekDouble > &	pOutput
	)

private

Actual iterative solve-GMRES.

Solve a global linear system using the Gmres We solve only for the non-Dirichlet modes. The operator is evaluated using an auxiliary function v_DoMatrixMultiply defined by the specific solver. Distributed math routines are used to support parallel execution of the solver.

Parameters

pInput	Input residual in local format.
pOutput	Solution vector in local format but with continuous values

Definition at line 121 of file NekLinSysIterGMRESLoc.cpp.

{
    m_prec_factor = NekConstants::kNekUnsetDouble;
    if (m_rhs_magnitude == NekConstants::kNekUnsetDouble)
    {
        Set_Rhs_Magnitude(pInput);
    }
 
    NekDouble eps = 0.0;
    Array<OneD, NekDouble> tmp;
 
    m_totalIterations = 0;
    m_converged       = false;
 
    bool restarted = false;
    bool truncted  = false;
 
    if (m_KrylovMaxHessMatBand > 0)
    {
        truncted = true;
    }
 
    for (int nrestart = 0; nrestart < m_maxrestart; ++nrestart)
    {
        eps = DoGmresRestart(restarted, truncted, nLocal, pInput, pOutput);
 
        if (m_converged)
        {
            break;
        }
        restarted = true;
    }
 
    if (m_verbose)
    {
        Array<OneD, NekDouble> r0(nLocal);
        Array<OneD, NekDouble> wk(nLocal);
 
        // calculate difference in residual of solution
        m_operator.DoNekSysLhsEval(pOutput, r0, m_DifferenceFlag0);
 
        // Note this is finding the difference between the whole
        // residual not jsut the non-Dirichlet values.
        // Probably OK since just an monitoring output?
        Vmath::Svtvp(nLocal, -1.0, r0, 1, pInput, 1, r0, 1);
 
        m_operator.DoAssembleLoc(r0, wk, true);
        NekDouble vExchange = Vmath::Dot(nLocal, wk, r0);
 
        m_rowComm->AllReduce(vExchange, LibUtilities::ReduceSum);
        NekDouble eps1 = vExchange;
 
        if (m_root)
        {
            int nwidthcolm = 13;
 
            cout << std::scientific << std::setw(nwidthcolm)
                 << std::setprecision(nwidthcolm - 8)
                 << "       GMRES iterations made = " << m_totalIterations
                 << " using tolerance of " << m_tolerance
                 << " (error = " << sqrt(eps * m_prec_factor / m_rhs_magnitude)
                 << ")";
 
            cout << " WITH (GMRES eps = " << eps << " REAL eps= " << eps1
                 << ")";
 
            if (m_converged)
            {
                cout << " CONVERGED" << endl;
            }
            else
            {
                cout << " WARNING: Exceeded maxIt" << endl;
            }
        }
    }
 
    if (m_FlagWarnings)
    {
        WARNINGL1(m_converged, "GMRES did not converge.");
    }
    return m_totalIterations;
}

Referenced by v_SolveSystem().

◆ DoGmresRestart()

NekDouble Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart	(	const bool	restarted,
		const bool	truncted,
		const int	nLocal,
		const Array< OneD, const NekDouble > &	pInput,
		Array< OneD, NekDouble > &	pOutput
	)

private

Actual iterative gmres solver for one restart.

Definition at line 207 of file NekLinSysIterGMRESLoc.cpp.

{
    // Allocate array storage of coefficients
    // Residual
    Array<OneD, NekDouble> eta(m_LinSysMaxStorage + 1, 0.0);
    // Givens rotation c
    Array<OneD, NekDouble> cs(m_LinSysMaxStorage, 0.0);
    // Givens rotation s
    Array<OneD, NekDouble> sn(m_LinSysMaxStorage, 0.0);
    // Total coefficients, just for check
    Array<OneD, NekDouble> y_total(m_LinSysMaxStorage, 0.0);
    // Search direction order
    Array<OneD, int> id(m_LinSysMaxStorage, 0);
    Array<OneD, int> id_start(m_LinSysMaxStorage, 0);
    Array<OneD, int> id_end(m_LinSysMaxStorage, 0);
    // Temporary variables
    int idtem;
    int starttem;
    int endtem;
 
    NekDouble eps;
    NekDouble beta, alpha;
    NekDouble vExchange = 0;
    // Temporary Array
    Array<OneD, NekDouble> w(nLocal, 0.0);
    Array<OneD, NekDouble> wk(nLocal, 0.0);
    Array<OneD, NekDouble> r0(nLocal, 0.0);
    Array<OneD, NekDouble> V1;
    Array<OneD, NekDouble> V2;
    Array<OneD, NekDouble> h1;
    Array<OneD, NekDouble> h2;
 
    if (restarted)
    {
        // This is A*x
        m_operator.DoNekSysLhsEval(pOutput, r0, m_DifferenceFlag0);
 
        // The first search direction
        beta = -1.0;
 
        // This is r0 = b-A*x
        Vmath::Svtvp(nLocal, beta, r0, 1, pInput, 1, r0, 1);
    }
    else
    {
        // If not restarted, x0 should be zero
        Vmath::Vcopy(nLocal, pInput, 1, r0, 1);
    }
 
    if (m_NekLinSysLeftPrecon)
    {
        m_operator.DoNekSysPrecon(r0, r0);
    }
 
    // Norm of (r0)
    // The m_map tells how to connect
    m_operator.DoAssembleLoc(r0, wk, true);
    vExchange = Vmath::Dot(nLocal, wk, r0);
    m_rowComm->AllReduce(vExchange, LibUtilities::ReduceSum);
    eps = vExchange;
 
    if (!restarted)
    {
        if (m_prec_factor == NekConstants::kNekUnsetDouble)
        {
            if (m_NekLinSysLeftPrecon)
            {
                // Evaluate initial residual error for exit check
                ASSERTL0(false, "Need to set up/debugging");
 
                m_operator.DoAssembleLoc(pInput, wk, true);
                vExchange = Vmath::Dot(nLocal, wk, pInput);
                m_rowComm->AllReduce(vExchange, LibUtilities::ReduceSum);
                m_prec_factor = vExchange / eps;
            }
            else
            {
                m_prec_factor = 1.0;
            }
        }
    }
 
    Vmath::Smul(nLocal, sqrt(m_prec_factor), r0, 1, r0, 1);
    eps    = eps * m_prec_factor;
    eta[0] = sqrt(eps);
 
    // Give an order for the entries in Hessenburg matrix
    for (int nd = 0; nd < m_LinSysMaxStorage; ++nd)
    {
        id[nd]     = nd;
        id_end[nd] = nd + 1;
        starttem   = id_end[nd] - m_KrylovMaxHessMatBand;
        if (truncted && (starttem) > 0)
        {
            id_start[nd] = starttem;
        }
        else
        {
            id_start[nd] = 0;
        }
    }
 
    // Normlized by r0 norm V(:,1)=r0/norm(r0)
    alpha = 1.0 / eta[0];
 
    // Scalar multiplication
    if (m_V_total[0].size() == 0)
    {
        m_V_total[0] = Array<OneD, NekDouble>(nLocal, 0.0);
    }
    Vmath::Smul(nLocal, alpha, r0, 1, m_V_total[0], 1);
 
    // restarted Gmres(m) process
    if (m_NekLinSysRightPrecon)
    {
        V1 = Array<OneD, NekDouble>(nLocal, 0.0);
    }
 
    int nswp = 0;
    for (int nd = 0; nd < m_LinSysMaxStorage; ++nd)
    {
        if (m_V_total[nd + 1].size() == 0)
        {
            m_V_total[nd + 1] = Array<OneD, NekDouble>(nLocal, 0.0);
        }
        Vmath::Zero(nLocal, m_V_total[nd + 1], 1);
        Vmath::Zero(m_LinSysMaxStorage + 1, m_hes[nd], 1);
        V2 = m_V_total[nd + 1];
        h1 = m_hes[nd];
 
        if (m_NekLinSysRightPrecon)
        {
            m_operator.DoNekSysPrecon(m_V_total[nd], V1, true);
        }
        else
        {
            V1 = m_V_total[nd];
        }
 
        // w here is no need to add nDir due to temporary Array
        idtem    = id[nd];
        starttem = id_start[idtem];
        endtem   = id_end[idtem];
 
        DoArnoldi(starttem, endtem, nLocal, w, wk, V1, V2, h1);
 
        if (starttem > 0)
        {
            starttem = starttem - 1;
        }
 
        h2 = m_Upper[nd];
        Vmath::Vcopy(m_LinSysMaxStorage + 1, &h1[0], 1, &h2[0], 1);
        DoGivensRotation(starttem, endtem, cs, sn, h2, eta);
 
        eps = eta[nd + 1] * eta[nd + 1];
 
        // This Gmres merge truncted Gmres to accelerate.
        // If truncted, cannot jump out because
        // the last term of eta is not residual
        if ((!truncted) || (nd < m_KrylovMaxHessMatBand))
        {
            if ((eps <
                 m_tolerance * m_tolerance * m_rhs_magnitude)) //&& nd > 0)
            {
                m_converged = true;
            }
        }
        nswp++;
        m_totalIterations++;
 
        if (m_converged)
        {
            break;
        }
    }
 
    DoBackward(nswp, m_Upper, eta, y_total);
 
    // calculate output y_total*V_total
    Array<OneD, NekDouble> solution(nLocal, 0.0);
    for (int i = 0; i < nswp; ++i)
    {
        beta = y_total[i];
        Vmath::Svtvp(nLocal, beta, m_V_total[i], 1, solution, 1, solution, 1);
    }
 
    if (m_NekLinSysRightPrecon)
    {
        m_operator.DoNekSysPrecon(solution, solution, true);
    }
 
    // Update output.
    Vmath::Vadd(nLocal, solution, 1, pOutput, 1, pOutput, 1);
 
    return eps;
}

Referenced by DoGMRES().

◆ GetMaxLinIte()

int Nektar::LibUtilities::NekLinSysIterGMRESLoc::GetMaxLinIte ( )

inline

Definition at line 70 of file NekLinSysIterGMRESLoc.h.

    {
        return (m_maxrestart * m_LinSysMaxStorage);
    }

References Nektar::LibUtilities::NekLinSysIter::m_LinSysMaxStorage, and m_maxrestart.

◆ v_InitObject()

void Nektar::LibUtilities::NekLinSysIterGMRESLoc::v_InitObject ( )

overrideprotectedvirtual

Reimplemented from Nektar::LibUtilities::NekLinSysIter.

Definition at line 90 of file NekLinSysIterGMRESLoc.cpp.

{
    NekLinSysIter::v_InitObject();
}

References Nektar::LibUtilities::NekLinSysIter::v_InitObject().

◆ v_SolveSystem()

int Nektar::LibUtilities::NekLinSysIterGMRESLoc::v_SolveSystem	(	const int	nLocal,
		const Array< OneD, const NekDouble > &	pInput,
		Array< OneD, NekDouble > &	pOutput,
		const int	nDir,
		const NekDouble	tol,
		const NekDouble	factor
	)

overrideprotectedvirtual

Reimplemented from Nektar::LibUtilities::NekSys.

Definition at line 98 of file NekLinSysIterGMRESLoc.cpp.

{
    m_tolerance     = max(tol, 1.0E-15);
    int niterations = DoGMRES(nLocal, pInput, pOutput);
 
    return niterations;
}

References DoGMRES(), and Nektar::LibUtilities::NekSys::m_tolerance.

Friends And Related Function Documentation

◆ MemoryManager< NekLinSysIterGMRESLoc >

friend class MemoryManager< NekLinSysIterGMRESLoc >

friend

Support creation through MemoryManager.

Definition at line 1 of file NekLinSysIterGMRESLoc.h.

Member Data Documentation

◆ className

string Nektar::LibUtilities::NekLinSysIterGMRESLoc::className

static

Initial value:

=
    LibUtilities::GetNekLinSysIterFactory().RegisterCreatorFunction(
        "GMRESLoc", NekLinSysIterGMRESLoc::create,
        "NekLinSysIterGMRES local storage solver.")

Definition at line 62 of file NekLinSysIterGMRESLoc.h.

◆ def

std::string Nektar::LibUtilities::NekLinSysIterGMRESLoc::def

staticprivate

Definition at line 131 of file NekLinSysIterGMRESLoc.h.

◆ lookupIds

std::string Nektar::LibUtilities::NekLinSysIterGMRESLoc::lookupIds[]

staticprivate

Definition at line 130 of file NekLinSysIterGMRESLoc.h.

◆ m_DifferenceFlag0

bool Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_DifferenceFlag0 = false

protected

Definition at line 86 of file NekLinSysIterGMRESLoc.h.

Referenced by DoGMRES(), DoGmresRestart(), and NekLinSysIterGMRESLoc().

◆ m_DifferenceFlag1

bool Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_DifferenceFlag1 = false

protected

Definition at line 87 of file NekLinSysIterGMRESLoc.h.

Referenced by DoArnoldi(), and NekLinSysIterGMRESLoc().

◆ m_hes

Array<OneD, Array<OneD, NekDouble> > Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_hes

private

Definition at line 134 of file NekLinSysIterGMRESLoc.h.

Referenced by DoGmresRestart(), and NekLinSysIterGMRESLoc().

◆ m_KrylovMaxHessMatBand

int Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_KrylovMaxHessMatBand

protected

Definition at line 81 of file NekLinSysIterGMRESLoc.h.

Referenced by DoGMRES(), DoGmresRestart(), and NekLinSysIterGMRESLoc().

◆ m_maxrestart

int Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_maxrestart

protected

Definition at line 77 of file NekLinSysIterGMRESLoc.h.

Referenced by DoGMRES(), GetMaxLinIte(), and NekLinSysIterGMRESLoc().

◆ m_NekLinSysLeftPrecon

bool Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_NekLinSysLeftPrecon = false

protected

Definition at line 83 of file NekLinSysIterGMRESLoc.h.

Referenced by DoArnoldi(), DoGmresRestart(), and NekLinSysIterGMRESLoc().

◆ m_NekLinSysRightPrecon

bool Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_NekLinSysRightPrecon = true

protected

Definition at line 84 of file NekLinSysIterGMRESLoc.h.

Referenced by DoGmresRestart(), and NekLinSysIterGMRESLoc().

◆ m_Upper

Array<OneD, Array<OneD, NekDouble> > Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_Upper

private

Definition at line 136 of file NekLinSysIterGMRESLoc.h.

Referenced by DoGmresRestart(), and NekLinSysIterGMRESLoc().

◆ m_V_total

Array<OneD, Array<OneD, NekDouble> > Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_V_total

private

Definition at line 138 of file NekLinSysIterGMRESLoc.h.

Referenced by DoArnoldi(), DoGmresRestart(), and NekLinSysIterGMRESLoc().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ NekLinSysIterGMRESLoc()

◆ ~NekLinSysIterGMRESLoc()

Member Function Documentation

◆ create()

◆ DoArnoldi()

◆ DoBackward()

◆ DoGivensRotation()

◆ DoGMRES()

◆ DoGmresRestart()

◆ GetMaxLinIte()

◆ v_InitObject()

◆ v_SolveSystem()

Friends And Related Function Documentation

◆ MemoryManager< NekLinSysIterGMRESLoc >

Member Data Documentation

◆ className

◆ def

◆ lookupIds

◆ m_DifferenceFlag0

◆ m_DifferenceFlag1

◆ m_hes

◆ m_KrylovMaxHessMatBand

◆ m_maxrestart

◆ m_NekLinSysLeftPrecon

◆ m_NekLinSysRightPrecon

◆ m_Upper

◆ m_V_total