#include <NekLinSysIter.h>

Inheritance diagram for Nektar::LibUtilities::NekLinSysIter:

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

virtual	~NekLinSysIter ()

void	setUniversalUniqueMap (Array< OneD, int > &map)

void	setRhsMagnitude (const NekDouble mag)

void	SetNekLinSysTolerance (const NekDouble in)

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)

void	InitObject ()

virtual	~NekSys ()

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

Protected Member Functions
void	Set_Rhs_Magnitude (const NekVector< NekDouble > &pIn)

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

void	setUniversalUniqueMap ()

virtual void	v_InitObject () override

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

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
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_rhs_mag_sm = 0.9

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...

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

Detailed Description

Solves a linear system using iterative methods.

Definition at line 56 of file NekLinSysIter.h.

Constructor & Destructor Documentation

◆ NekLinSysIter()

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

Definition at line 56 of file NekLinSysIter.cpp.

    : NekSys(pSession, vRowComm, nDimen, pKey)
{
    std::vector<std::string> variables(1);
    variables[0]    = pSession->GetVariable(0);
    string variable = variables[0];
 
    if (pSession->DefinesGlobalSysSolnInfo(variable, "NekLinSysTolerance"))
    {
        m_tolerance = boost::lexical_cast<NekDouble>(
            pSession->GetGlobalSysSolnInfo(variable, "NekLinSysTolerance")
                .c_str());
    }
    else
    {
        pSession->LoadParameter("NekLinSysTolerance", m_tolerance,
                                pKey.m_NekLinSysTolerance);
    }
 
    if (pSession->DefinesGlobalSysSolnInfo(variable, "NekLinSysMaxIterations"))
    {
        m_maxiter = boost::lexical_cast<int>(
            pSession->GetGlobalSysSolnInfo(variable, "NekLinSysMaxIterations")
                .c_str());
    }
    else
    {
        pSession->LoadParameter("NekLinSysMaxIterations", m_maxiter,
                                pKey.m_NekLinSysMaxIterations);
    }
 
    if (pSession->DefinesGlobalSysSolnInfo(variable, "LinSysMaxStorage"))
    {
        m_LinSysMaxStorage = boost::lexical_cast<int>(
            pSession->GetGlobalSysSolnInfo(variable, "LinSysMaxStorage")
                .c_str());
    }
    else
    {
        pSession->LoadParameter("LinSysMaxStorage", m_LinSysMaxStorage,
                                pKey.m_LinSysMaxStorage);
    }
 
    m_isLocal = false;
}

References m_isLocal, m_LinSysMaxStorage, Nektar::LibUtilities::NekSysKey::m_LinSysMaxStorage, Nektar::LibUtilities::NekSys::m_maxiter, Nektar::LibUtilities::NekSysKey::m_NekLinSysMaxIterations, Nektar::LibUtilities::NekSysKey::m_NekLinSysTolerance, and Nektar::LibUtilities::NekSys::m_tolerance.

◆ ~NekLinSysIter()

Nektar::LibUtilities::NekLinSysIter::~NekLinSysIter ( )

virtual

Definition at line 111 of file NekLinSysIter.cpp.

112{

113}

Member Function Documentation

◆ CreateInstance()

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

inlinestatic

Definition at line 62 of file NekLinSysIter.h.

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

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

◆ IsLocal()

bool Nektar::LibUtilities::NekLinSysIter::IsLocal ( )

inline

Definition at line 98 of file NekLinSysIter.h.

    {
        return m_isLocal;
    }

References m_isLocal.

◆ Set_Rhs_Magnitude() [1/2]

void Nektar::LibUtilities::NekLinSysIter::Set_Rhs_Magnitude ( const Array< OneD, NekDouble > & pIn )

protected

Definition at line 157 of file NekLinSysIter.cpp.

{
    Array<OneD, NekDouble> vExchange(1, 0.0);
 
    Array<OneD, NekDouble> wk(pIn.size());
    m_operator.DoAssembleLoc(pIn, wk);
    vExchange[0] = Vmath::Dot(pIn.size(), wk, pIn);
    m_rowComm->AllReduce(vExchange, LibUtilities::ReduceSum);
 
    // To ensure that very different rhs values are not being
    // used in subsequent solvers such as the velocit solve in
    // INC NS. If this works we then need to work out a better
    // way to control this.
    NekDouble new_rhs_mag = (vExchange[0] > 1e-6) ? vExchange[0] : 1.0;
 
    if (m_rhs_magnitude == NekConstants::kNekUnsetDouble)
    {
        m_rhs_magnitude = new_rhs_mag;
    }
    else
    {
        m_rhs_magnitude = (m_rhs_mag_sm * (m_rhs_magnitude) +
                           (1.0 - m_rhs_mag_sm) * new_rhs_mag);
    }
}

References Nektar::LibUtilities::NekSysOperators::DoAssembleLoc(), Vmath::Dot(), Nektar::NekConstants::kNekUnsetDouble, Nektar::LibUtilities::NekSys::m_operator, m_rhs_mag_sm, m_rhs_magnitude, Nektar::LibUtilities::NekSys::m_rowComm, and Nektar::LibUtilities::ReduceSum.

◆ Set_Rhs_Magnitude() [2/2]

void Nektar::LibUtilities::NekLinSysIter::Set_Rhs_Magnitude ( const NekVector< NekDouble > & pIn )

protected

Definition at line 130 of file NekLinSysIter.cpp.

{
    NekDouble vExchange(0.0);
    if (m_map.size() > 0)
    {
        vExchange =
            Vmath::Dot2(pIn.GetDimension(), &pIn[0], &pIn[0], &m_map[0]);
    }
    m_rowComm->AllReduce(vExchange, LibUtilities::ReduceSum);
 
    // To ensure that very different rhs values are not being
    // used in subsequent solvers such as the velocit solve in
    // INC NS. If this works we then need to work out a better
    // way to control this.
    NekDouble new_rhs_mag = (vExchange > 1.0e-6) ? vExchange : 1.0;
 
    if (m_rhs_magnitude == NekConstants::kNekUnsetDouble)
    {
        m_rhs_magnitude = new_rhs_mag;
    }
    else
    {
        m_rhs_magnitude = (m_rhs_mag_sm * (m_rhs_magnitude) +
                           (1.0 - m_rhs_mag_sm) * new_rhs_mag);
    }
}

References Vmath::Dot2(), Nektar::NekVector< DataType >::GetDimension(), Nektar::NekConstants::kNekUnsetDouble, m_map, m_rhs_mag_sm, m_rhs_magnitude, Nektar::LibUtilities::NekSys::m_rowComm, and Nektar::LibUtilities::ReduceSum.

Referenced by Nektar::LibUtilities::NekLinSysIterCGLoc::DoConjugateGradient(), and Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient().

◆ SetLinSysMaxStorage()

void Nektar::LibUtilities::NekLinSysIter::SetLinSysMaxStorage ( const unsigned int in )

inline

Definition at line 93 of file NekLinSysIter.h.

    {
        m_LinSysMaxStorage = in;
    }

References m_LinSysMaxStorage.

◆ SetNekLinSysMaxIterations()

void Nektar::LibUtilities::NekLinSysIter::SetNekLinSysMaxIterations ( const unsigned int in )

inline

Definition at line 88 of file NekLinSysIter.h.

    {
        m_maxiter = in;
    }

References Nektar::LibUtilities::NekSys::m_maxiter.

◆ SetNekLinSysTolerance()

void Nektar::LibUtilities::NekLinSysIter::SetNekLinSysTolerance ( const NekDouble in )

inline

Definition at line 83 of file NekLinSysIter.h.

    {
        m_tolerance = in;
    }

References Nektar::LibUtilities::NekSys::m_tolerance.

◆ setRhsMagnitude()

void Nektar::LibUtilities::NekLinSysIter::setRhsMagnitude ( const NekDouble mag )

inline

Definition at line 79 of file NekLinSysIter.h.

    {
        m_rhs_magnitude = mag;
    }

References m_rhs_magnitude.

◆ setUniversalUniqueMap() [1/2]

void Nektar::LibUtilities::NekLinSysIter::setUniversalUniqueMap ( )

protected

Definition at line 125 of file NekLinSysIter.cpp.

{
    m_map = Array<OneD, int>(m_SysDimen, 1);
}

References m_map, and Nektar::LibUtilities::NekSys::m_SysDimen.

Referenced by v_InitObject().

◆ setUniversalUniqueMap() [2/2]

void Nektar::LibUtilities::NekLinSysIter::setUniversalUniqueMap ( Array< OneD, int > & map )

Definition at line 115 of file NekLinSysIter.cpp.

{
    int nmap = map.size();
    if (m_map.size() != nmap)
    {
        m_map = Array<OneD, int>(nmap, 0);
    }
    Vmath::Vcopy(nmap, map, 1, m_map, 1);
}

References m_map, and Vmath::Vcopy().

◆ v_InitObject()

void Nektar::LibUtilities::NekLinSysIter::v_InitObject ( )

overrideprotectedvirtual

Reimplemented from Nektar::LibUtilities::NekSys.

Reimplemented in Nektar::LibUtilities::NekLinSysIterCG, Nektar::LibUtilities::NekLinSysIterCGLoc, Nektar::LibUtilities::NekLinSysIterFixedpointJacobi, Nektar::LibUtilities::NekLinSysIterGMRES, and Nektar::LibUtilities::NekLinSysIterGMRESLoc.

Definition at line 105 of file NekLinSysIter.cpp.

{
    NekSys::v_InitObject();
    setUniversalUniqueMap();
}

References setUniversalUniqueMap(), and Nektar::LibUtilities::NekSys::v_InitObject().

Referenced by Nektar::LibUtilities::NekLinSysIterCG::v_InitObject(), Nektar::LibUtilities::NekLinSysIterCGLoc::v_InitObject(), Nektar::LibUtilities::NekLinSysIterFixedpointJacobi::v_InitObject(), Nektar::LibUtilities::NekLinSysIterGMRES::v_InitObject(), and Nektar::LibUtilities::NekLinSysIterGMRESLoc::v_InitObject().

Friends And Related Function Documentation

◆ MemoryManager< NekLinSysIter >

friend class MemoryManager< NekLinSysIter >

friend

Support creation through MemoryManager.

Definition at line 54 of file NekLinSysIter.h.

Member Data Documentation

◆ m_isLocal

bool Nektar::LibUtilities::NekLinSysIter::m_isLocal

protected

Definition at line 122 of file NekLinSysIter.h.

Referenced by IsLocal(), NekLinSysIter(), Nektar::LibUtilities::NekLinSysIterCGLoc::NekLinSysIterCGLoc(), and Nektar::LibUtilities::NekLinSysIterGMRESLoc::NekLinSysIterGMRESLoc().

◆ m_LinSysMaxStorage

int Nektar::LibUtilities::NekLinSysIter::m_LinSysMaxStorage

protected

Definition at line 119 of file NekLinSysIter.h.

Referenced by Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRES::GetMaxLinIte(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::GetMaxLinIte(), NekLinSysIter(), Nektar::LibUtilities::NekLinSysIterGMRES::NekLinSysIterGMRES(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::NekLinSysIterGMRESLoc(), and SetLinSysMaxStorage().

◆ m_map

Array<OneD, int> Nektar::LibUtilities::NekLinSysIter::m_map

protected

Global to universal unique map.

Definition at line 105 of file NekLinSysIter.h.

Referenced by Nektar::LibUtilities::NekLinSysIterGMRES::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Set_Rhs_Magnitude(), and setUniversalUniqueMap().

◆ m_prec_factor

NekDouble Nektar::LibUtilities::NekLinSysIter::m_prec_factor = 1.0

protected

Definition at line 113 of file NekLinSysIter.h.

◆ m_rhs_mag_sm

NekDouble Nektar::LibUtilities::NekLinSysIter::m_rhs_mag_sm = 0.9

protected

Definition at line 111 of file NekLinSysIter.h.

Referenced by Set_Rhs_Magnitude().

◆ m_rhs_magnitude

NekDouble Nektar::LibUtilities::NekLinSysIter::m_rhs_magnitude = NekConstants::kNekUnsetDouble

protected

Dot product of rhs to normalise stopping criterion.

Definition at line 108 of file NekLinSysIter.h.

Referenced by Nektar::LibUtilities::NekLinSysIterCGLoc::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Set_Rhs_Magnitude(), and setRhsMagnitude().

◆ m_totalIterations

int Nektar::LibUtilities::NekLinSysIter::m_totalIterations = 0

protected

Definition at line 110 of file NekLinSysIter.h.

Referenced by Nektar::LibUtilities::NekLinSysIterCGLoc::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterCG::v_SolveSystem(), and Nektar::LibUtilities::NekLinSysIterCGLoc::v_SolveSystem().

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ NekLinSysIter()

◆ ~NekLinSysIter()

Member Function Documentation

◆ CreateInstance()

◆ IsLocal()

◆ Set_Rhs_Magnitude() [1/2]

◆ Set_Rhs_Magnitude() [2/2]

◆ SetLinSysMaxStorage()

◆ SetNekLinSysMaxIterations()

◆ SetNekLinSysTolerance()

◆ setRhsMagnitude()

◆ setUniversalUniqueMap() [1/2]

◆ setUniversalUniqueMap() [2/2]

◆ v_InitObject()

Friends And Related Function Documentation

◆ MemoryManager< NekLinSysIter >

Member Data Documentation

◆ m_isLocal

◆ m_LinSysMaxStorage

◆ m_map

◆ m_prec_factor

◆ m_rhs_mag_sm

◆ m_rhs_magnitude

◆ m_totalIterations