#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	SetNekLinSysTolerance (const NekDouble in)

void	SetNekLinSysMaxIterations (const unsigned int in)

int	GetNekLinSysTolerance ()

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 ()

int	SolveSystem (const int nGlobal, const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pOutput, const int nDir=0)

const NekSysOperators &	GetSysOperators ()

void	SetSysOperators (const NekSysOperators &in)

void	SetFlagWarnings (bool in)

void	SetRhsMagnitude (const NekDouble mag)

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) override

Protected Member Functions inherited from Nektar::LibUtilities::NekLinSysIter
void	v_InitObject () override

void	SetUniversalUniqueMap ()

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

void	ConvergenceCheck (const Array< OneD, const NekDouble > &Residual)

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)

Protected Attributes
int	m_maxrestart

int	m_KrylovMaxHessMatBand

int	m_LinSysMaxStorage

NekDouble	m_prec_factor = 1.0

bool	m_NekLinSysLeftPrecon = false

bool	m_NekLinSysRightPrecon = true

bool	m_GMRESCentralDifference = false

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

NekDouble	m_NekLinSysTolerance

int	m_NekLinSysMaxIterations

int	m_totalIterations = 0

bool	m_isLocal

Protected Attributes inherited from Nektar::LibUtilities::NekSys
LibUtilities::CommSharedPtr	m_rowComm

bool	m_converged

bool	m_root

bool	m_verbose

bool	m_FlagWarnings

int	m_SysDimen

NekSysOperators	m_operator

NekDouble	m_rhs_magnitude = NekConstants::kNekUnsetDouble

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 46 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_NekLinSysMaxIterations) /
                              NekDouble(pKey.m_LinSysMaxStorage));
    m_LinSysMaxStorage = min(m_NekLinSysMaxIterations, pKey.m_LinSysMaxStorage);
 
    m_GMRESCentralDifference = pKey.m_GMRESCentralDifference;
 
    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);
}

References m_GMRESCentralDifference, Nektar::LibUtilities::NekSysKey::m_GMRESCentralDifference, m_hes, Nektar::LibUtilities::NekLinSysIter::m_isLocal, m_KrylovMaxHessMatBand, Nektar::LibUtilities::NekSysKey::m_KrylovMaxHessMatBand, m_LinSysMaxStorage, Nektar::LibUtilities::NekSysKey::m_LinSysMaxStorage, m_maxrestart, m_NekLinSysLeftPrecon, Nektar::LibUtilities::NekSysKey::m_NekLinSysLeftPrecon, Nektar::LibUtilities::NekLinSysIter::m_NekLinSysMaxIterations, m_NekLinSysRightPrecon, Nektar::LibUtilities::NekSysKey::m_NekLinSysRightPrecon, m_Upper, and m_V_total.

◆ ~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 52 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 406 of file NekLinSysIterGMRESLoc.cpp.

{
    NekDouble alpha, beta, vExchange = 0.0;
    LibUtilities::Timer timer;
    timer.Start();
    m_operator.DoNekSysLhsEval(V1, w, m_GMRESCentralDifference);
    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 511 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 457 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 119 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_GMRESCentralDifference);
 
        // Note this is finding the difference between the whole
        // residual not jsut the non-Dirichlet values.
        // Probably OK since just an monitoring output?
        Vmath::Vsub(nLocal, pInput, 1, r0, 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_NekLinSysTolerance
                 << " (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 205 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_GMRESCentralDifference);
 
        // 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_NekLinSysTolerance * m_NekLinSysTolerance *
                           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 72 of file NekLinSysIterGMRESLoc.h.

    {
        return (m_maxrestart * m_LinSysMaxStorage);
    }

References 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
	)

overrideprotectedvirtual

Reimplemented from Nektar::LibUtilities::NekSys.

Definition at line 98 of file NekLinSysIterGMRESLoc.cpp.

{
    int niterations = DoGMRES(nLocal, pInput, pOutput);
 
    return niterations;
}

References DoGMRES().

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 64 of file NekLinSysIterGMRESLoc.h.

◆ def

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

staticprivate

Definition at line 138 of file NekLinSysIterGMRESLoc.h.

◆ lookupIds

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

staticprivate

Definition at line 137 of file NekLinSysIterGMRESLoc.h.

◆ m_GMRESCentralDifference

bool Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_GMRESCentralDifference = false

protected

Definition at line 95 of file NekLinSysIterGMRESLoc.h.

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

◆ m_hes

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

private

Definition at line 141 of file NekLinSysIterGMRESLoc.h.

Referenced by DoGmresRestart(), and NekLinSysIterGMRESLoc().

◆ m_KrylovMaxHessMatBand

int Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_KrylovMaxHessMatBand

protected

Definition at line 83 of file NekLinSysIterGMRESLoc.h.

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

◆ m_LinSysMaxStorage

int Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_LinSysMaxStorage

protected

Definition at line 89 of file NekLinSysIterGMRESLoc.h.

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

◆ m_maxrestart

int Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_maxrestart

protected

Definition at line 79 of file NekLinSysIterGMRESLoc.h.

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

◆ m_NekLinSysLeftPrecon

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

protected

Definition at line 93 of file NekLinSysIterGMRESLoc.h.

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

◆ m_NekLinSysRightPrecon

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

protected

Definition at line 94 of file NekLinSysIterGMRESLoc.h.

Referenced by DoGmresRestart(), and NekLinSysIterGMRESLoc().

◆ m_prec_factor

NekDouble Nektar::LibUtilities::NekLinSysIterGMRESLoc::m_prec_factor = 1.0

protected

Definition at line 91 of file NekLinSysIterGMRESLoc.h.

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

◆ m_Upper

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

private

Definition at line 143 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 145 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_GMRESCentralDifference

◆ m_hes

◆ m_KrylovMaxHessMatBand

◆ m_LinSysMaxStorage

◆ m_maxrestart

◆ m_NekLinSysLeftPrecon

◆ m_NekLinSysRightPrecon

◆ m_prec_factor

◆ m_Upper

◆ m_V_total