Nektar::LibUtilities::NekNonlinSysNewton Class Reference

#include <NekNonlinSysNewton.h>

Inheritance diagram for Nektar::LibUtilities::NekNonlinSysNewton:

Public Member Functions
	NekNonlinSysNewton (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vComm, const int nscale, const NekSysKey &pKey)
	~NekNonlinSysNewton ()
Public Member Functions inherited from Nektar::LibUtilities::NekNonlinSys
	NekNonlinSys (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vComm, const int nDimen, const NekSysKey &pKey)
	~NekNonlinSys ()
const Array< OneD, const NekDouble > &	GetRefSolution () const
const Array< OneD, const NekDouble > &	GetRefResidual () const
const Array< OneD, const NekDouble > &	GetRefSourceVec () const
void	SetRefResidual (const Array< OneD, const NekDouble > &in)
void	SetNekNonlinSysTolerance (const NekDouble in)
void	SetNekNonlinSysMaxIterations (const unsigned int in)
const NekLinSysIterSharedPtr &	GetLinSys ()
void	SetNonlinIterTolRelativeL2 (const NekDouble in)
void	SetLinSysRelativeTolInNonlin (const NekDouble in)
int	GetNtotLinSysIts ()
Public Member Functions inherited from Nektar::LibUtilities::NekSys
	NekSys (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vComm, 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)
virtual void	v_NekSysInitialGuess (const Array< OneD, const NekDouble > &pInput, Array< OneD, NekDouble > &pguess)
void	SetFlagWarnings (bool in)

Static Public Member Functions
static NekNonlinSysSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vComm, const int nDimen, const NekSysKey &pKey)
Static Public Member Functions inherited from Nektar::LibUtilities::NekNonlinSys
static NekNonlinSysSharedPtr	CreateInstance (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &vComm, 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 &vComm, const int nDimen, const NekSysKey &pKey)

Static Public Attributes
static std::string	className

Protected Member Functions
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)
void	CalcInexactNewtonForcing (const int &k, NekDouble &resnormOld, const NekDouble &resnorm, NekDouble &forcing)
virtual void	v_SetupNekNonlinSystem (const int nGlobal, const Array< OneD, const NekDouble > &pInput, const Array< OneD, const NekDouble > &pSource, const int nDir)

Protected Attributes
NekDouble	m_SysResNorm0
NekDouble	m_SysResNorm
int	m_InexactNewtonForcing = 0
NekDouble	m_forcingGamma = 1.0
NekDouble	m_forcingAlpha = 0.5 * (1.0 + sqrt(5))
Protected Attributes inherited from Nektar::LibUtilities::NekNonlinSys
NekLinSysIterSharedPtr	m_linsol
NekDouble	m_NonlinIterTolRelativeL2
NekDouble	m_LinSysRelativeTolInNonlin
std::string	m_LinSysIterSolverType
int	m_totalIterations = 0
int	m_NtotLinSysIts = 0
Array< OneD, NekDouble >	m_Solution
Array< OneD, NekDouble >	m_Residual
Array< OneD, NekDouble >	m_DeltSltn
Array< OneD, NekDouble >	m_SourceVec
bool	m_ResidualUpdated = false
Protected Attributes inherited from Nektar::LibUtilities::NekSys
int	m_maxiter
	Maximum iterations. More...
NekDouble	m_tolerance
	Tolerance of iterative solver. More...
LibUtilities::CommSharedPtr	m_Comm
	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< NekNonlinSysNewton >
	Constructor for full direct matrix solve. More...

Detailed Description

Solves a nonlinear system using iterative methods.

Definition at line 48 of file NekNonlinSysNewton.h.

Constructor & Destructor Documentation

NekNonlinSysNewton()

Nektar::LibUtilities::NekNonlinSysNewton::NekNonlinSysNewton	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const LibUtilities::CommSharedPtr &	vComm,
		const int	nscale,
		const NekSysKey &	pKey
	)

Definition at line 54 of file NekNonlinSysNewton.cpp.

    : NekNonlinSys(pSession, vComm, nscale, pKey)
{
}

~NekNonlinSysNewton()

Nektar::LibUtilities::NekNonlinSysNewton::~NekNonlinSysNewton

(

)

Definition at line 70 of file NekNonlinSysNewton.cpp.

{
}

Member Function Documentation

CalcInexactNewtonForcing()

void Nektar::LibUtilities::NekNonlinSysNewton::CalcInexactNewtonForcing ( const int &  k, NekDouble &  resnormOld, const NekDouble &  resnorm, NekDouble &  forcing  )

protected

Definition at line 164 of file NekNonlinSysNewton.cpp.

{
    if (0 == k)
    {
        forcing    = m_LinSysRelativeTolInNonlin;
        resnormOld = resnorm;
    }
    else
    {
        switch (m_InexactNewtonForcing)
        {
            case 0:
            {
                forcing = m_LinSysRelativeTolInNonlin;
                break;
            }
            case 1:
            {
                NekDouble tmpForc = m_forcingGamma *
                                    pow((resnorm / resnormOld), m_forcingAlpha);
                NekDouble tmp = m_forcingGamma * pow(forcing, m_forcingAlpha);
                if (tmp > 0.1)
                {
                    forcing =
                        min(m_LinSysRelativeTolInNonlin, max(tmp, tmpForc));
                }
                else
                {
                    forcing = min(m_LinSysRelativeTolInNonlin, tmpForc);
                }
 
                forcing = max(forcing, 1.0E-6);
                break;
            }
        }
    }
}

References m_forcingAlpha, m_forcingGamma, m_InexactNewtonForcing, and Nektar::LibUtilities::NekNonlinSys::m_LinSysRelativeTolInNonlin.

Referenced by v_SolveSystem().

create()

static NekNonlinSysSharedPtr Nektar::LibUtilities::NekNonlinSysNewton::create ( const LibUtilities::SessionReaderSharedPtr &  pSession, const LibUtilities::CommSharedPtr &  vComm, const int  nDimen, const NekSysKey &  pKey  )

inlinestatic

Definition at line 54 of file NekNonlinSysNewton.h.

    {
        NekNonlinSysSharedPtr p =
            MemoryManager<NekNonlinSysNewton>::AllocateSharedPtr(
                pSession, vComm, nDimen, pKey);
        p->InitObject();
        return p;
    }

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

v_ConvergenceCheck()

bool Nektar::LibUtilities::NekNonlinSysNewton::v_ConvergenceCheck ( const int  nIteration, const Array< OneD, const NekDouble > &  Residual, const NekDouble  tol  )

protectedvirtual

Reimplemented from Nektar::LibUtilities::NekSys.

Definition at line 134 of file NekNonlinSysNewton.cpp.

{
    bool converged     = false;
    NekDouble resratio = 1.0;
    int ntotal         = Residual.size();
 
    m_SysResNorm = Vmath::Dot(ntotal, Residual, Residual);
    m_Comm->AllReduce(m_SysResNorm, Nektar::LibUtilities::ReduceSum);
 
    if (0 == nIteration)
    {
        m_SysResNorm0 = m_SysResNorm;
        resratio      = 1.0;
    }
    else
    {
        resratio = m_SysResNorm / m_SysResNorm0;
    }
 
    if (resratio < (m_NonlinIterTolRelativeL2 * m_NonlinIterTolRelativeL2) ||
        m_SysResNorm < tol)
    {
        converged = true;
    }
 
    return converged;
}

References Vmath::Dot(), Nektar::LibUtilities::NekSys::m_Comm, Nektar::LibUtilities::NekNonlinSys::m_NonlinIterTolRelativeL2, m_SysResNorm, m_SysResNorm0, and Nektar::LibUtilities::ReduceSum.

Referenced by v_SolveSystem().

v_InitObject()

void Nektar::LibUtilities::NekNonlinSysNewton::v_InitObject ( )

protectedvirtual

Reimplemented from Nektar::LibUtilities::NekNonlinSys.

Definition at line 62 of file NekNonlinSysNewton.cpp.

{
    NekSys::v_InitObject();
    m_Residual  = Array<OneD, NekDouble>(m_SysDimen, 0.0);
    m_DeltSltn  = Array<OneD, NekDouble>(m_SysDimen, 0.0);
    m_SourceVec = Array<OneD, NekDouble>(m_SysDimen, 0.0);
}

References Nektar::LibUtilities::NekNonlinSys::m_DeltSltn, Nektar::LibUtilities::NekNonlinSys::m_Residual, Nektar::LibUtilities::NekNonlinSys::m_SourceVec, Nektar::LibUtilities::NekSys::m_SysDimen, and Nektar::LibUtilities::NekSys::v_InitObject().

v_SetupNekNonlinSystem()

void Nektar::LibUtilities::NekNonlinSysNewton::v_SetupNekNonlinSystem ( const int  nGlobal, const Array< OneD, const NekDouble > &  pInput, const Array< OneD, const NekDouble > &  pSource, const int  nDir  )

protectedvirtual

Reimplemented from Nektar::LibUtilities::NekNonlinSys.

Definition at line 205 of file NekNonlinSysNewton.cpp.

{
    boost::ignore_unused(nGlobal, nDir);
 
    ASSERTL0(0 == nDir, "0 != nDir not tested");
    ASSERTL0(m_SysDimen == nGlobal, "m_SysDimen!=nGlobal");
 
    m_SourceVec = pSource;
    Vmath::Vcopy(nGlobal - nDir, pSource, 1, m_SourceVec, 1);
 
    if (!m_ResidualUpdated)
    {
        m_operator.DoNekSysResEval(pInput, m_Residual);
        m_ResidualUpdated = true;
    }
    m_linsol->SetSysOperators(m_operator);
}

References ASSERTL0, Nektar::LibUtilities::NekSysOperators::DoNekSysResEval(), Nektar::LibUtilities::NekNonlinSys::m_linsol, Nektar::LibUtilities::NekSys::m_operator, Nektar::LibUtilities::NekNonlinSys::m_Residual, Nektar::LibUtilities::NekNonlinSys::m_ResidualUpdated, Nektar::LibUtilities::NekNonlinSys::m_SourceVec, Nektar::LibUtilities::NekSys::m_SysDimen, and Vmath::Vcopy().

Referenced by v_SolveSystem().

v_SolveSystem()

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

protectedvirtual

Reimplemented from Nektar::LibUtilities::NekSys.

Definition at line 77 of file NekNonlinSysNewton.cpp.

{
    boost::ignore_unused(factor);
 
    int nwidthcolm = 11;
 
    v_SetupNekNonlinSystem(nGlobal, pInput, pInput, nDir);
 
    m_Solution = pOutput;
    Vmath::Vcopy(nGlobal - nDir, pInput, 1, m_Solution, 1);
 
    int ntotal      = nGlobal - nDir;
    m_NtotLinSysIts = 0;
 
    int NttlNonlinIte = 0;
    m_converged       = false;
 
    NekDouble resnormOld = 0.0;
    for (int k = 0; k < m_maxiter; ++k)
    {
        m_converged = v_ConvergenceCheck(k, m_Residual, tol);
        if (m_converged)
            break;
 
        NekDouble LinSysRelativeIteTol;
        CalcInexactNewtonForcing(k, resnormOld, m_SysResNorm,
                                 LinSysRelativeIteTol);
 
        resnormOld = m_SysResNorm;
 
        NekDouble LinSysTol = LinSysRelativeIteTol * sqrt(m_SysResNorm);
        int ntmpLinSysIts =
            m_linsol->SolveSystem(ntotal, m_Residual, m_DeltSltn, 0, LinSysTol);
        m_NtotLinSysIts += ntmpLinSysIts;
        Vmath::Vsub(ntotal, m_Solution, 1, m_DeltSltn, 1, m_Solution, 1);
        NttlNonlinIte++;
        m_operator.DoNekSysResEval(m_Solution, m_Residual);
    }
 
    if (((!m_converged) || m_verbose) && m_root && m_FlagWarnings)
    {
        WARNINGL0(m_converged,
                  "     # Nonlinear solver not converge in DoImplicitSolve");
        cout << right << scientific << setw(nwidthcolm)
             << setprecision(nwidthcolm - 6)
             << "     * Newton-Its converged (RES=" << sqrt(m_SysResNorm)
             << " Res/(DtRHS): " << sqrt(m_SysResNorm / m_SysResNorm0)
             << " with " << setw(3) << NttlNonlinIte << " Non-Its)" << endl;
    }
 
    m_ResidualUpdated = false;
    return NttlNonlinIte;
}

References CalcInexactNewtonForcing(), Nektar::LibUtilities::NekSysOperators::DoNekSysResEval(), Nektar::LibUtilities::NekSys::m_converged, Nektar::LibUtilities::NekNonlinSys::m_DeltSltn, Nektar::LibUtilities::NekSys::m_FlagWarnings, Nektar::LibUtilities::NekNonlinSys::m_linsol, Nektar::LibUtilities::NekSys::m_maxiter, Nektar::LibUtilities::NekNonlinSys::m_NtotLinSysIts, Nektar::LibUtilities::NekSys::m_operator, Nektar::LibUtilities::NekNonlinSys::m_Residual, Nektar::LibUtilities::NekNonlinSys::m_ResidualUpdated, Nektar::LibUtilities::NekSys::m_root, Nektar::LibUtilities::NekNonlinSys::m_Solution, m_SysResNorm, m_SysResNorm0, Nektar::LibUtilities::NekSys::m_verbose, tinysimd::sqrt(), v_ConvergenceCheck(), v_SetupNekNonlinSystem(), Vmath::Vcopy(), Vmath::Vsub(), and WARNINGL0.

Friends And Related Function Documentation

MemoryManager< NekNonlinSysNewton >

friend class MemoryManager< NekNonlinSysNewton >

friend

Constructor for full direct matrix solve.

Definition at line 1 of file NekNonlinSysNewton.h.

Member Data Documentation

className

string Nektar::LibUtilities::NekNonlinSysNewton::className

static

Initial value:

=
    LibUtilities::GetNekNonlinSysFactory().RegisterCreatorFunction(
        "Newton", NekNonlinSysNewton::create, "NekNonlinSysNewton solver.")

Definition at line 66 of file NekNonlinSysNewton.h.

m_forcingAlpha

NekDouble Nektar::LibUtilities::NekNonlinSysNewton::m_forcingAlpha = 0.5 * (1.0 + sqrt(5))

protected

Definition at line 79 of file NekNonlinSysNewton.h.

Referenced by CalcInexactNewtonForcing().

m_forcingGamma

NekDouble Nektar::LibUtilities::NekNonlinSysNewton::m_forcingGamma = 1.0

protected

Definition at line 78 of file NekNonlinSysNewton.h.

Referenced by CalcInexactNewtonForcing().

m_InexactNewtonForcing

int Nektar::LibUtilities::NekNonlinSysNewton::m_InexactNewtonForcing = 0

protected

Definition at line 77 of file NekNonlinSysNewton.h.

Referenced by CalcInexactNewtonForcing().

m_SysResNorm

NekDouble Nektar::LibUtilities::NekNonlinSysNewton::m_SysResNorm

protected

Definition at line 75 of file NekNonlinSysNewton.h.

Referenced by v_ConvergenceCheck(), and v_SolveSystem().

m_SysResNorm0

NekDouble Nektar::LibUtilities::NekNonlinSysNewton::m_SysResNorm0

protected

Definition at line 74 of file NekNonlinSysNewton.h.

Referenced by v_ConvergenceCheck(), and v_SolveSystem().