#include <IMEXTimeIntegrationSchemeSDC.h>

Inheritance diagram for Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC:

Public Member Functions
	IMEXTimeIntegrationSchemeSDC (std::string variant, size_t order, std::vector< NekDouble > freeParams)

Public Member Functions inherited from Nektar::LibUtilities::TimeIntegrationSchemeSDC
	TimeIntegrationSchemeSDC (std::string variant, size_t order, std::vector< NekDouble > freeParams)

	~TimeIntegrationSchemeSDC () override
	Destructor. More...

LUE void	SetPFASST (bool pfasst)

LUE void	SetTime (double time)

LUE size_t	GetMaxOrder () const

LUE bool	HasFirstQuadrature () const

LUE bool	HasLastQuadrature () const

LUE size_t	GetQuadPtsNumber () const

LUE size_t	GetNpoints () const

LUE size_t	GetNvars () const

LUE const PointsKey &	GetPointsKey () const

LUE const DoubleArray &	GetFirstQuadratureSolutionVector () const

LUE DoubleArray &	UpdateFirstQuadratureSolutionVector ()

LUE const DoubleArray &	GetLastQuadratureSolutionVector () const

LUE DoubleArray &	UpdateLastQuadratureSolutionVector ()

LUE const TripleArray &	GetResidualVector () const

LUE TripleArray &	UpdateResidualVector ()

LUE const TripleArray &	GetIntegratedResidualVector () const

LUE TripleArray &	UpdateIntegratedResidualVector ()

LUE const TripleArray &	GetFAScorrectionVector () const

LUE TripleArray &	UpdateFAScorrectionVector ()

LUE void	ResidualEval (const NekDouble &delta_t, const size_t n)

LUE void	ResidualEval (const NekDouble &delta_t)

LUE void	ComputeInitialGuess (const NekDouble &delta_t)

LUE void	SDCIterationLoop (const NekDouble &delta_t)

LUE void	UpdateFirstQuadrature (void)
	Worker method that update the first quadrature. More...

LUE void	UpdateLastQuadrature (void)
	Worker method that update the last quadrature. More...

LUE void	AddFASCorrectionToSFint (void)
	Worker method that add the FASCorrection. More...

LUE void	UpdateIntegratedResidualSFint (const NekDouble &delta_t)
	Worker method that compute residual integral. More...

LUE void	UpdateIntegratedResidualQFint (const NekDouble &delta_t)

Public Member Functions inherited from Nektar::LibUtilities::TimeIntegrationScheme
LUE std::string	GetFullName () const

LUE std::string	GetName () const

LUE std::string	GetVariant () const

LUE size_t	GetOrder () const

LUE std::vector< NekDouble >	GetFreeParams ()

LUE TimeIntegrationSchemeType	GetIntegrationSchemeType ()

LUE NekDouble	GetTimeStability () const

LUE size_t	GetNumIntegrationPhases ()

LUE const TripleArray &	GetSolutionVector () const
	Gets the solution vector of the ODE. More...

LUE TripleArray &	UpdateSolutionVector ()

LUE void	SetSolutionVector (const size_t Offset, const DoubleArray &y)
	Sets the solution vector of the ODE. More...

LUE void	InitializeScheme (const NekDouble deltaT, ConstDoubleArray &y_0, const NekDouble time, const TimeIntegrationSchemeOperators &op)
	Explicit integration of an ODE. More...

LUE ConstDoubleArray &	TimeIntegrate (const size_t timestep, const NekDouble delta_t)

LUE void	print (std::ostream &os) const

LUE void	printFull (std::ostream &os) const

Static Public Member Functions
static TimeIntegrationSchemeSharedPtr	create (std::string variant, size_t order, std::vector< NekDouble > freeParams)

Static Public Member Functions inherited from Nektar::LibUtilities::TimeIntegrationSchemeSDC
static TimeIntegrationSchemeSharedPtr	create (std::string variant, size_t order, std::vector< NekDouble > freeParams)

Public Attributes
TripleArray	m_Fexp

TripleArray	m_Fimp
	Array corresponding to the stage derivatives. More...

DoubleArray	m_tmp
	Array corresponding to the stage derivatives. More...

Static Public Attributes
static std::string	className

Static Public Attributes inherited from Nektar::LibUtilities::TimeIntegrationSchemeSDC
static std::string	className

Protected Member Functions
LUE void	v_InitializeScheme (const NekDouble deltaT, ConstDoubleArray &y_0, const NekDouble time, const TimeIntegrationSchemeOperators &op) override
	Array for temporary storage. More...

LUE void	v_ResidualEval (const NekDouble &delta_t, const size_t n) override
	Worker method to compute the residual. More...

LUE void	v_ResidualEval (const NekDouble &delta_t) override

LUE void	v_ComputeInitialGuess (const NekDouble &delta_t) override
	Worker method to compute the initial SDC guess. More...

LUE void	v_SDCIterationLoop (const NekDouble &delta_t) override
	Worker method to compute the SDC iteration. More...

Protected Member Functions inherited from Nektar::LibUtilities::TimeIntegrationSchemeSDC
LUE std::string	v_GetName () const override

LUE std::string	v_GetVariant () const override

LUE size_t	v_GetOrder () const override

LUE std::vector< NekDouble >	v_GetFreeParams () const override

LUE TimeIntegrationSchemeType	v_GetIntegrationSchemeType () const override

LUE NekDouble	v_GetTimeStability () const override

LUE size_t	v_GetNumIntegrationPhases () const override

LUE const TripleArray &	v_GetSolutionVector () const override
	Gets the solution vector of the ODE. More...

LUE TripleArray &	v_UpdateSolutionVector () override

LUE void	v_SetSolutionVector (const size_t Offset, const DoubleArray &y) override
	Sets the solution vector of the ODE. More...

LUE void	v_InitializeScheme (const NekDouble deltaT, ConstDoubleArray &y_0, const NekDouble time, const TimeIntegrationSchemeOperators &op) override
	Worker method to initialize the integration scheme. More...

LUE ConstDoubleArray &	v_TimeIntegrate (const size_t timestep, const NekDouble delta_t) override
	Worker method that performs the time integration. More...

virtual LUE void	v_ResidualEval (const NekDouble &delta_t, const size_t n)

virtual LUE void	v_ResidualEval (const NekDouble &delta_t)

virtual LUE void	v_ComputeInitialGuess (const NekDouble &delta_t)

virtual LUE void	v_SDCIterationLoop (const NekDouble &delta_t)

LUE void	v_print (std::ostream &os) const override
	Worker method to print details on the integration scheme. More...

LUE void	v_printFull (std::ostream &os) const override

Protected Member Functions inherited from Nektar::LibUtilities::TimeIntegrationScheme
virtual LUE std::string	v_GetFullName () const

virtual LUE std::string	v_GetName () const =0

virtual LUE std::string	v_GetVariant () const =0

virtual LUE size_t	v_GetOrder () const =0

virtual LUE std::vector< NekDouble >	v_GetFreeParams () const =0

virtual LUE TimeIntegrationSchemeType	v_GetIntegrationSchemeType () const =0

virtual LUE NekDouble	v_GetTimeStability () const =0

virtual LUE size_t	v_GetNumIntegrationPhases () const =0

virtual LUE const TripleArray &	v_GetSolutionVector () const =0

virtual LUE TripleArray &	v_UpdateSolutionVector ()=0

virtual LUE void	v_SetSolutionVector (const size_t Offset, const DoubleArray &y)=0

virtual LUE void	v_InitializeScheme (const NekDouble deltaT, ConstDoubleArray &y_0, const NekDouble time, const TimeIntegrationSchemeOperators &op)=0

virtual LUE ConstDoubleArray &	v_TimeIntegrate (const size_t timestep, const NekDouble delta_t)=0

virtual LUE void	v_print (std::ostream &os) const =0

virtual LUE void	v_printFull (std::ostream &os) const =0

LUE	TimeIntegrationScheme (std::string variant, size_t order, std::vector< NekDouble > freeParams)

LUE	TimeIntegrationScheme (const TimeIntegrationScheme &in)=delete

virtual	~TimeIntegrationScheme ()=default

Private Member Functions
void	ComputeTotalResidual (const size_t n)
	Worker method to compute the total residual. More...

Additional Inherited Members
Protected Attributes inherited from Nektar::LibUtilities::TimeIntegrationSchemeSDC
NekDouble	m_time

std::string	m_name

std::string	m_variant

std::vector< NekDouble >	m_freeParams

TimeIntegrationSchemeType	m_schemeType {eNoTimeIntegrationSchemeType}

TimeIntegrationSchemeOperators	m_op

PointsKey	m_pointsKey

SingleArray	m_tau
	Object containing quadrature data. More...

DoubleArray	m_Y_f
	Array containing the quadrature points. More...

TripleArray	m_Y
	Array containing the last stage values. More...

TripleArray	m_F
	Array containing the stage values. More...

TripleArray	m_FAScorr
	Array containing the stage derivatives. More...

TripleArray	m_SFint
	Array containing the FAS correction term. More...

TripleArray	m_QFint
	Array containing the integrated residual term. More...

SingleArray	m_QMat
	Array containing the integrated residual term. More...

SingleArray	m_interp
	Array containing the integration matrix. More...

NekDouble	m_theta {1.0}
	Array containing the interpolation coefficients. More...

size_t	m_ordermin {0}
	SDC parameter. More...

size_t	m_ordermax {0}
	Minimum order of the integration scheme. More...

size_t	m_order {0}
	Maximum order of the integration scheme. More...

size_t	m_nQuadPts {0}
	Order of the integration scheme. More...

size_t	m_nvars {0}
	Number of quadrature points. More...

size_t	m_npoints {0}
	Number of variables in the integration scheme. More...

bool	m_first_quadrature {true}
	Number of points in the integration scheme. More...

bool	m_last_quadrature {true}

bool	m_initialized {false}

bool	m_PFASST {false}

Detailed Description

Definition at line 46 of file IMEXTimeIntegrationSchemeSDC.h.

Constructor & Destructor Documentation

◆ IMEXTimeIntegrationSchemeSDC()

Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::IMEXTimeIntegrationSchemeSDC	(	std::string	variant,
		size_t	order,
		std::vector< NekDouble >	freeParams
	)

inline

Definition at line 49 of file IMEXTimeIntegrationSchemeSDC.h.

        : TimeIntegrationSchemeSDC(variant, order, freeParams)
    {
 
        ASSERTL0(!m_first_quadrature,
                 "Quadrature type that include the left end point (e.g. "
                 "GaussLobattoLegendre) should not be used for IMEXSDC");
 
        std::cerr
            << "WARNING: IMEX Spectral Deferred Correction method has been "
               "implemented but its use is not recommended as the "
               "approach is affected by order-reduction problems."
            << std::endl;
 
        m_name       = "IMEXSpectralDeferredCorrection";
        m_schemeType = eIMEX;
    }

References ASSERTL0, Nektar::LibUtilities::eIMEX, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_first_quadrature, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_name, and Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_schemeType.

Member Function Documentation

◆ ComputeTotalResidual()

void Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::ComputeTotalResidual ( const size_t n )

private

Worker method to compute the total residual.

Definition at line 272 of file IMEXTimeIntegrationSchemeSDC.h.

{
    for (size_t i = 0; i < m_nvars; ++i)
    {
        Vmath::Vadd(m_npoints, m_Fimp[n][i], 1, m_Fexp[n][i], 1, m_F[n][i], 1);
    }
}

References Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_F, m_Fexp, m_Fimp, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_npoints, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_nvars, and Vmath::Vadd().

Referenced by v_ComputeInitialGuess(), and v_SDCIterationLoop().

◆ create()

static TimeIntegrationSchemeSharedPtr Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::create	(	std::string	variant,
		size_t	order,
		std::vector< NekDouble >	freeParams
	)

inlinestatic

Definition at line 68 of file IMEXTimeIntegrationSchemeSDC.h.

    {
        TimeIntegrationSchemeSharedPtr p =
            MemoryManager<IMEXTimeIntegrationSchemeSDC>::AllocateSharedPtr(
                variant, order, freeParams);
 
        return p;
    }

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

◆ v_ComputeInitialGuess()

void Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_ComputeInitialGuess ( const NekDouble & delta_t )

overrideprotectedvirtual

Worker method to compute the initial SDC guess.

Reimplemented from Nektar::LibUtilities::TimeIntegrationSchemeSDC.

Definition at line 163 of file IMEXTimeIntegrationSchemeSDC.h.

{
    for (size_t n = 0; n < m_nQuadPts; ++n)
    {
        if (n == 0)
        {
            // Apply time-dependent boundary condition
            m_op.DoProjection(m_Y[0], m_Y[0], m_time);
        }
        else
        {
            NekDouble dtn = delta_t * (m_tau[n] - m_tau[n - 1]);
 
            // Add explicit contribution to rhs
            for (size_t i = 0; i < m_nvars; ++i)
            {
                Vmath::Svtvp(m_npoints, dtn, m_Fexp[n - 1][i], 1, m_Y[n - 1][i],
                             1, m_tmp[i], 1);
            }
 
            // Solve implicit system from rhs
            m_op.DoImplicitSolve(m_tmp, m_Y[n], m_time + delta_t * m_tau[n],
                                 dtn);
 
            // Compute implicit flux from updated solution
            for (size_t i = 0; i < m_nvars; ++i)
            {
                Vmath::Vsub(m_npoints, m_Y[n][i], 1, m_tmp[i], 1, m_Fimp[n][i],
                            1);
                Vmath::Smul(m_npoints, 1.0 / dtn, m_Fimp[n][i], 1, m_Fimp[n][i],
                            1);
            }
        }
 
        // Compute explicit residual
        m_op.DoOdeRhs(m_Y[n], m_Fexp[n], m_time + delta_t * m_tau[n]);
 
        // Compute total residual
        ComputeTotalResidual(n);
    }
}

◆ v_InitializeScheme()

void Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_InitializeScheme	(	const NekDouble	deltaT,
		ConstDoubleArray &	y_0,
		const NekDouble	time,
		const TimeIntegrationSchemeOperators &	op
	)

overrideprotectedvirtual

Array for temporary storage.

Worker method to initialize the integration scheme.

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 105 of file IMEXTimeIntegrationSchemeSDC.h.

{
    if (m_initialized)
    {
        m_time = time;
        for (size_t i = 0; i < m_nvars; ++i)
        {
            // Store the initial values as the first previous state.
            Vmath::Vcopy(m_npoints, y_0[i], 1, m_Y[0][i], 1);
        }
    }
    else
    {
        TimeIntegrationSchemeSDC::v_InitializeScheme(deltaT, y_0, time, op);
 
        m_Fexp = TripleArray(m_nQuadPts);
        m_Fimp = TripleArray(m_nQuadPts);
        for (size_t m = 0; m < m_nQuadPts; ++m)
        {
            m_Fexp[m] = DoubleArray(m_nvars);
            m_Fimp[m] = DoubleArray(m_nvars);
            for (size_t i = 0; i < m_nvars; ++i)
            {
                m_Fexp[m][i] = SingleArray(m_npoints, 0.0);
                m_Fimp[m][i] = SingleArray(m_npoints, 0.0);
            }
        }
 
        m_tmp = DoubleArray(m_nvars);
        for (size_t i = 0; i < m_nvars; ++i)
        {
            m_tmp[i] = SingleArray(m_npoints, 0.0);
        }
    }
}

References m_Fexp, m_Fimp, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_initialized, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_npoints, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_nQuadPts, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_nvars, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_time, m_tmp, Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_Y, Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_InitializeScheme(), and Vmath::Vcopy().

◆ v_ResidualEval() [1/2]

void Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_ResidualEval ( const NekDouble & delta_t )

overrideprotectedvirtual

Reimplemented from Nektar::LibUtilities::TimeIntegrationSchemeSDC.

Definition at line 152 of file IMEXTimeIntegrationSchemeSDC.h.

{
    for (size_t n = 0; n < m_nQuadPts; ++n)
    {
        v_ResidualEval(delta_t, n);
    }
}

References Nektar::LibUtilities::TimeIntegrationSchemeSDC::m_nQuadPts, and v_ResidualEval().

◆ v_ResidualEval() [2/2]

void Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_ResidualEval	(	const NekDouble &	delta_t,
		const size_t	n
	)

overrideprotectedvirtual

Worker method to compute the residual.

Reimplemented from Nektar::LibUtilities::TimeIntegrationSchemeSDC.

Definition at line 146 of file IMEXTimeIntegrationSchemeSDC.h.

{
    ASSERTL0(false, "v_ResidualEval not implemented for IMEX SDC");
}

References ASSERTL0.

Referenced by v_ResidualEval().

◆ v_SDCIterationLoop()

void Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_SDCIterationLoop ( const NekDouble & delta_t )

overrideprotectedvirtual

Worker method to compute the SDC iteration.

Reimplemented from Nektar::LibUtilities::TimeIntegrationSchemeSDC.

Definition at line 209 of file IMEXTimeIntegrationSchemeSDC.h.

{
    // Update integrated residual
    UpdateIntegratedResidualSFint(delta_t);
 
    // Add FAS correction to integrated residual
    AddFASCorrectionToSFint();
 
    // Loop over quadrature points
    for (size_t n = 1; n < m_nQuadPts; ++n)
    {
        NekDouble dtn = delta_t * (m_tau[n] - m_tau[n - 1]);
 
        // Add rhs terms
        for (size_t i = 0; i < m_nvars; ++i)
        {
            // Add SFint contribution to rhs
            Vmath::Vadd(m_npoints, m_Y[n - 1][i], 1, m_SFint[n][i], 1, m_tmp[i],
                        1);
 
            // Add explicit contribution to rhs
            if (n > 1)
            {
                Vmath::Svtvp(m_npoints, m_theta * dtn, m_Fexp[n - 1][i], 1,
                             m_tmp[i], 1, m_tmp[i], 1);
            }
 
            // Add explicit contribution to SFint
            if (n < m_nQuadPts - 1)
            {
                NekDouble dtnp = delta_t * (m_tau[n + 1] - m_tau[n]);
                Vmath::Svtvp(m_npoints, -m_theta * dtnp, m_Fexp[n][i], 1,
                             m_SFint[n + 1][i], 1, m_SFint[n + 1][i], 1);
            }
 
            // Add implicit contribution to rhs
            Vmath::Svtvp(m_npoints, -m_theta * dtn, m_Fimp[n][i], 1, m_tmp[i],
                         1, m_tmp[i], 1);
        }
 
        // Solve implicit system from rhs
        m_op.DoImplicitSolve(m_tmp, m_Y[n], m_time + delta_t * m_tau[n],
                             m_theta * dtn);
 
        // Compute implicit residual from updated solution
        for (size_t i = 0; i < m_nvars; ++i)
        {
            Vmath::Vsub(m_npoints, m_Y[n][i], 1, m_tmp[i], 1, m_Fimp[n][i], 1);
            Vmath::Smul(m_npoints, 1.0 / (m_theta * dtn), m_Fimp[n][i], 1,
                        m_Fimp[n][i], 1);
        }
 
        // Compute explicit residual
        m_op.DoOdeRhs(m_Y[n], m_Fexp[n], m_time + delta_t * m_tau[n]);
 
        // Compute total residual
        ComputeTotalResidual(n);
    }
}

Member Data Documentation

◆ className

std::string Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::className

static

Initial value:

=
    GetTimeIntegrationSchemeFactory().RegisterCreatorFunction(
        "IMEXSDC", IMEXTimeIntegrationSchemeSDC::create)

Definition at line 78 of file IMEXTimeIntegrationSchemeSDC.h.

◆ m_Fexp

TripleArray Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::m_Fexp

Definition at line 80 of file IMEXTimeIntegrationSchemeSDC.h.

Referenced by ComputeTotalResidual(), v_ComputeInitialGuess(), v_InitializeScheme(), and v_SDCIterationLoop().

◆ m_Fimp

TripleArray Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::m_Fimp

Array corresponding to the stage derivatives.

Definition at line 81 of file IMEXTimeIntegrationSchemeSDC.h.

Referenced by ComputeTotalResidual(), v_ComputeInitialGuess(), v_InitializeScheme(), and v_SDCIterationLoop().

◆ m_tmp

DoubleArray Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::m_tmp

Array corresponding to the stage derivatives.

Definition at line 82 of file IMEXTimeIntegrationSchemeSDC.h.

Referenced by v_ComputeInitialGuess(), v_InitializeScheme(), and v_SDCIterationLoop().

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ IMEXTimeIntegrationSchemeSDC()

Member Function Documentation

◆ ComputeTotalResidual()

◆ create()

◆ v_ComputeInitialGuess()

◆ v_InitializeScheme()

◆ v_ResidualEval() [1/2]

◆ v_ResidualEval() [2/2]

◆ v_SDCIterationLoop()

Member Data Documentation

◆ className

◆ m_Fexp

◆ m_Fimp

◆ m_tmp