Class for spectral deferred correction integration. More...

#include <TimeIntegrationSchemeSDC.h>

Inheritance diagram for Nektar::LibUtilities::TimeIntegrationSchemeSDC:

Public Member Functions
	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 Attributes
static std::string	className

Protected Member Functions
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

Protected Attributes
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

Class for spectral deferred correction integration.

Definition at line 54 of file TimeIntegrationSchemeSDC.h.

Constructor & Destructor Documentation

◆ TimeIntegrationSchemeSDC()

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

inline

Definition at line 57 of file TimeIntegrationSchemeSDC.h.

        : TimeIntegrationScheme(variant, order, freeParams),
          m_name("SpectralDeferredCorrection")
    {
        ASSERTL0(freeParams.size() == 2,
                 "SDC Time integration scheme invalid number "
                 "of free parameters, expected two "
                 "<theta, number of quadrature>, received " +
                     std::to_string(freeParams.size()));
 
        ASSERTL0(0.0 <= freeParams[0] && freeParams[0] <= 1.0,
                 "Spectral Deferred Correction Time integration "
                 "scheme bad parameter numbers (0.0 - 1.0): " +
                     std::to_string(freeParams[0]));
 
        // Set scheme properties
        m_variant    = variant;
        m_order      = order;
        m_freeParams = freeParams;
        m_theta      = m_freeParams[0];
        m_nQuadPts   = m_freeParams[1];
 
        if (m_variant == "Equidistant")
        {
            ASSERTL0(1 <= m_nQuadPts,
                     m_variant +
                         " quadrature require quadrature "
                         "numbers (>=1" +
                         "): " + std::to_string(freeParams[1]));
 
            m_first_quadrature = (m_nQuadPts == 1) ? false : true;
            m_last_quadrature  = (m_nQuadPts == 1) ? false : true;
            m_ordermin         = 1;
            m_ordermax         = m_nQuadPts;
            m_pointsKey        = LibUtilities::PointsKey(
                m_nQuadPts, LibUtilities::ePolyEvenlySpaced);
        }
        else if (m_variant == "GaussLobattoLegendre")
        {
            ASSERTL0(2 <= m_nQuadPts,
                     m_variant +
                         " quadrature require quadrature "
                         "numbers (>=2" +
                         "): " + std::to_string(freeParams[1]));
 
            m_first_quadrature = true;
            m_last_quadrature  = true;
            m_ordermin         = 1;
            m_ordermax         = 2 * m_nQuadPts - 2;
            m_pointsKey        = LibUtilities::PointsKey(
                m_nQuadPts, LibUtilities::eGaussLobattoLegendre);
        }
        else if (m_variant == "GaussRadauLegendre")
        {
            ASSERTL0(2 <= m_nQuadPts,
                     m_variant +
                         " quadrature require quadrature "
                         "numbers (>=1" +
                         "): " + std::to_string(freeParams[1]));
 
            m_first_quadrature = false;
            m_last_quadrature  = true;
            m_ordermin         = 1;
            m_ordermax         = 2 * m_nQuadPts - 1;
            m_pointsKey        = LibUtilities::PointsKey(
                m_nQuadPts, LibUtilities::eGaussRadauPLegendre);
        }
        else if (m_variant == "GaussGaussLegendre")
        {
            ASSERTL0(1 <= m_nQuadPts,
                     m_variant +
                         " quadrature require quadrature "
                         "numbers (>=1" +
                         "): " + std::to_string(freeParams[1]));
 
            m_first_quadrature = false;
            m_last_quadrature  = false;
            m_ordermin         = 1;
            m_ordermax         = 2 * m_nQuadPts;
            m_pointsKey        = LibUtilities::PointsKey(
                m_nQuadPts, LibUtilities::eGaussGaussLegendre);
        }
        else
        {
            ASSERTL0(false, "unknow variant (quadrature) type");
        }
 
        ASSERTL0(m_ordermin <= m_order,
                 "Spectral Deferred Correction Time integration "
                 "scheme bad order numbers (>=" +
                     std::to_string(m_ordermin) +
                     "): " + std::to_string(m_order));
 
        ASSERTL0(m_ordermax >= m_order,
                 "Spectral Deferred Correction Time integration "
                 "scheme bad order numbers (<=" +
                     std::to_string(m_ordermax) +
                     "): " + std::to_string(m_order));
 
        // Add one extra quadrature points for i.c., if necessary
        if (!m_first_quadrature)
        {
            m_nQuadPts = m_nQuadPts + 1;
        }
 
        // Get quadrature points and rescale to [0, 1]
        m_tau         = SingleArray(m_nQuadPts, 0.0);
        size_t offset = m_first_quadrature ? 0 : 1;
        for (size_t i = offset; i < m_nQuadPts; i++)
        {
            NekDouble tau = PointsManager()[m_pointsKey]->GetZ()[i - offset];
            m_tau[i]      = (tau + 1.0) / 2.0;
        }
    }

References ASSERTL0, Nektar::LibUtilities::eGaussGaussLegendre, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauPLegendre, Nektar::LibUtilities::ePolyEvenlySpaced, m_first_quadrature, m_freeParams, m_last_quadrature, m_nQuadPts, m_order, m_ordermax, m_ordermin, m_pointsKey, m_tau, m_theta, m_variant, and Nektar::LibUtilities::PointsManager().

◆ ~TimeIntegrationSchemeSDC()

Nektar::LibUtilities::TimeIntegrationSchemeSDC::~TimeIntegrationSchemeSDC ( )

inlineoverride

Destructor.

Definition at line 174 of file TimeIntegrationSchemeSDC.h.

175 {

176 }

Member Function Documentation

◆ AddFASCorrectionToSFint()

void Nektar::LibUtilities::TimeIntegrationSchemeSDC::AddFASCorrectionToSFint ( void )

Worker method that add the FASCorrection.

Definition at line 248 of file TimeIntegrationSchemeSDC.cpp.

{
    // Add PFASST correction term
    if (m_PFASST)
    {
        for (size_t n = 1; n < m_nQuadPts; ++n)
        {
            for (size_t i = 0; i < m_nvars; ++i)
            {
                Vmath::Vadd(m_npoints, m_SFint[n][i], 1, m_FAScorr[n][i], 1,
                            m_SFint[n][i], 1);
                Vmath::Vsub(m_npoints, m_SFint[n][i], 1, m_FAScorr[n - 1][i], 1,
                            m_SFint[n][i], 1);
            }
        }
    }
}

References m_FAScorr, m_npoints, m_nQuadPts, m_nvars, m_PFASST, m_SFint, Vmath::Vadd(), and Vmath::Vsub().

Referenced by Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_SDCIterationLoop(), and Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop().

◆ ComputeInitialGuess()

LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::ComputeInitialGuess ( const NekDouble & delta_t )

inline

Definition at line 295 of file TimeIntegrationSchemeSDC.h.

    {
        v_ComputeInitialGuess(delta_t);
    }

References v_ComputeInitialGuess().

Referenced by v_TimeIntegrate().

◆ create()

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

inlinestatic

Definition at line 178 of file TimeIntegrationSchemeSDC.h.

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

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

◆ GetFAScorrectionVector()

LUE const TripleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetFAScorrectionVector ( ) const

inline

Definition at line 275 of file TimeIntegrationSchemeSDC.h.

    {
        return m_FAScorr;
    }

References m_FAScorr.

◆ GetFirstQuadratureSolutionVector()

LUE const DoubleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetFirstQuadratureSolutionVector ( ) const

inline

Definition at line 235 of file TimeIntegrationSchemeSDC.h.

    {
        return m_Y[0];
    }

References m_Y.

◆ GetIntegratedResidualVector()

LUE const TripleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetIntegratedResidualVector ( ) const

inline

Definition at line 265 of file TimeIntegrationSchemeSDC.h.

    {
        return m_QFint;
    }

References m_QFint.

◆ GetLastQuadratureSolutionVector()

LUE const DoubleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetLastQuadratureSolutionVector ( ) const

inline

Definition at line 245 of file TimeIntegrationSchemeSDC.h.

    {
        return m_last_quadrature ? m_Y[m_nQuadPts - 1] : m_Y_f;
    }

References m_last_quadrature, m_nQuadPts, m_Y, and m_Y_f.

◆ GetMaxOrder()

LUE size_t Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetMaxOrder ( ) const

inline

Definition at line 200 of file TimeIntegrationSchemeSDC.h.

    {
        return m_ordermax;
    }

References m_ordermax.

◆ GetNpoints()

LUE size_t Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetNpoints ( ) const

inline

Definition at line 220 of file TimeIntegrationSchemeSDC.h.

    {
        return m_npoints;
    }

References m_npoints.

◆ GetNvars()

LUE size_t Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetNvars ( ) const

inline

Definition at line 225 of file TimeIntegrationSchemeSDC.h.

    {
        return m_nvars;
    }

References m_nvars.

◆ GetPointsKey()

LUE const PointsKey & Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetPointsKey ( ) const

inline

Definition at line 230 of file TimeIntegrationSchemeSDC.h.

    {
        return m_pointsKey;
    }

References m_pointsKey.

◆ GetQuadPtsNumber()

LUE size_t Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetQuadPtsNumber ( ) const

inline

Definition at line 215 of file TimeIntegrationSchemeSDC.h.

    {
        return m_nQuadPts;
    }

References m_nQuadPts.

◆ GetResidualVector()

LUE const TripleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::GetResidualVector ( ) const

inline

Definition at line 255 of file TimeIntegrationSchemeSDC.h.

    {
        return m_F;
    }

References m_F.

◆ HasFirstQuadrature()

LUE bool Nektar::LibUtilities::TimeIntegrationSchemeSDC::HasFirstQuadrature ( ) const

inline

Definition at line 205 of file TimeIntegrationSchemeSDC.h.

    {
        return m_first_quadrature;
    }

References m_first_quadrature.

◆ HasLastQuadrature()

LUE bool Nektar::LibUtilities::TimeIntegrationSchemeSDC::HasLastQuadrature ( ) const

inline

Definition at line 210 of file TimeIntegrationSchemeSDC.h.

    {
        return m_last_quadrature;
    }

References m_last_quadrature.

◆ ResidualEval() [1/2]

LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::ResidualEval ( const NekDouble & delta_t )

inline

Definition at line 290 of file TimeIntegrationSchemeSDC.h.

    {
        v_ResidualEval(delta_t);
    }

References v_ResidualEval().

◆ ResidualEval() [2/2]

LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::ResidualEval	(	const NekDouble &	delta_t,
		const size_t	n
	)

inline

Definition at line 285 of file TimeIntegrationSchemeSDC.h.

    {
        v_ResidualEval(delta_t, n);
    }

References v_ResidualEval().

◆ SDCIterationLoop()

LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::SDCIterationLoop ( const NekDouble & delta_t )

inline

Definition at line 300 of file TimeIntegrationSchemeSDC.h.

    {
        v_SDCIterationLoop(delta_t);
    }

References v_SDCIterationLoop().

Referenced by v_TimeIntegrate().

◆ SetPFASST()

LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::SetPFASST ( bool pfasst )

inline

Definition at line 190 of file TimeIntegrationSchemeSDC.h.

    {
        m_PFASST = pfasst;
    }

References m_PFASST.

◆ SetTime()

LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::SetTime ( double time )

inline

Definition at line 195 of file TimeIntegrationSchemeSDC.h.

    {
        m_time = time;
    }

References m_time.

◆ UpdateFAScorrectionVector()

LUE TripleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateFAScorrectionVector ( )

inline

Definition at line 280 of file TimeIntegrationSchemeSDC.h.

    {
        return m_FAScorr;
    }

References m_FAScorr.

◆ UpdateFirstQuadrature()

void Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateFirstQuadrature ( void )

Worker method that update the first quadrature.

Definition at line 217 of file TimeIntegrationSchemeSDC.cpp.

{
    DoubleArray Y_f = m_last_quadrature ? m_Y[m_nQuadPts - 1] : m_Y_f;
    for (size_t i = 0; i < m_nvars; ++i)
    {
        Vmath::Vcopy(m_npoints, Y_f[i], 1, m_Y[0][i], 1);
    }
}

References m_last_quadrature, m_npoints, m_nQuadPts, m_nvars, m_Y, m_Y_f, and Vmath::Vcopy().

Referenced by v_TimeIntegrate().

◆ UpdateFirstQuadratureSolutionVector()

LUE DoubleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateFirstQuadratureSolutionVector ( )

inline

Definition at line 240 of file TimeIntegrationSchemeSDC.h.

    {
        return m_Y[0];
    }

References m_Y.

◆ UpdateIntegratedResidualQFint()

void Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateIntegratedResidualQFint ( const NekDouble & delta_t )

Definition at line 299 of file TimeIntegrationSchemeSDC.cpp.

{
    // Zeroing integrated flux
    for (size_t n = 0; n < m_nQuadPts; ++n)
    {
        for (size_t i = 0; i < m_nvars; ++i)
        {
            Vmath::Zero(m_npoints, m_QFint[n][i], 1);
        }
    }
 
    // Update integrated flux
    size_t offset = m_first_quadrature ? 0 : 1;
    for (size_t n = 0; n < m_nQuadPts; ++n)
    {
        for (size_t p = 0; p < m_nQuadPts - offset; ++p)
        {
            for (size_t i = 0; i < m_nvars; ++i)
            {
                Vmath::Svtvp(
                    m_npoints, delta_t * m_QMat[n * (m_nQuadPts - offset) + p],
                    m_F[p + offset][i], 1, m_QFint[n][i], 1, m_QFint[n][i], 1);
            }
        }
    }
}

References m_F, m_first_quadrature, m_npoints, m_nQuadPts, m_nvars, m_QFint, m_QMat, CellMLToNektar.cellml_metadata::p, Vmath::Svtvp(), and Vmath::Zero().

◆ UpdateIntegratedResidualSFint()

void Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateIntegratedResidualSFint ( const NekDouble & delta_t )

Worker method that compute residual integral.

Definition at line 269 of file TimeIntegrationSchemeSDC.cpp.

{
    // Zeroing integrated flux
    for (size_t n = 0; n < m_nQuadPts; ++n)
    {
        for (size_t i = 0; i < m_nvars; ++i)
        {
            Vmath::Zero(m_npoints, m_SFint[n][i], 1);
        }
    }
 
    // Update integrated flux
    size_t offset = m_first_quadrature ? 0 : 1;
    for (size_t n = 1; n < m_nQuadPts; ++n)
    {
        for (size_t p = 0; p < m_nQuadPts - offset; ++p)
        {
            for (size_t i = 0; i < m_nvars; ++i)
            {
                Vmath::Svtvp(
                    m_npoints,
                    delta_t * (m_QMat[n * (m_nQuadPts - offset) + p] -
                               m_QMat[(n - 1) * (m_nQuadPts - offset) + p]),
                    m_F[p + offset][i], 1, m_SFint[n][i], 1, m_SFint[n][i], 1);
            }
        }
    }
}

References m_F, m_first_quadrature, m_npoints, m_nQuadPts, m_nvars, m_QMat, m_SFint, CellMLToNektar.cellml_metadata::p, Vmath::Svtvp(), and Vmath::Zero().

Referenced by Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_SDCIterationLoop(), and Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop().

◆ UpdateIntegratedResidualVector()

LUE TripleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateIntegratedResidualVector ( )

inline

Definition at line 270 of file TimeIntegrationSchemeSDC.h.

    {
        return m_QFint;
    }

References m_QFint.

◆ UpdateLastQuadrature()

void Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateLastQuadrature ( void )

Worker method that update the last quadrature.

Definition at line 229 of file TimeIntegrationSchemeSDC.cpp.

{
    if (!m_last_quadrature)
    {
        for (size_t i = 0; i < m_nvars; ++i)
        {
            Vmath::Zero(m_npoints, m_Y_f[i], 1);
            for (size_t n = 0; n < m_nQuadPts; ++n)
            {
                Vmath::Svtvp(m_npoints, m_interp[n], m_Y[n][i], 1, m_Y_f[i], 1,
                             m_Y_f[i], 1);
            }
        }
    }
}

References m_interp, m_last_quadrature, m_npoints, m_nQuadPts, m_nvars, m_Y, m_Y_f, Vmath::Svtvp(), and Vmath::Zero().

Referenced by v_TimeIntegrate().

◆ UpdateLastQuadratureSolutionVector()

LUE DoubleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateLastQuadratureSolutionVector ( )

inline

Definition at line 250 of file TimeIntegrationSchemeSDC.h.

    {
        return m_last_quadrature ? m_Y[m_nQuadPts - 1] : m_Y_f;
    }

References m_last_quadrature, m_nQuadPts, m_Y, and m_Y_f.

◆ UpdateResidualVector()

LUE TripleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateResidualVector ( )

inline

Definition at line 260 of file TimeIntegrationSchemeSDC.h.

    {
        return m_F;
    }

References m_F.

◆ v_ComputeInitialGuess()

virtual LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_ComputeInitialGuess ( const NekDouble & delta_t )

inlineprotectedvirtual

Reimplemented in Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC, Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC, and Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC.

Definition at line 353 of file TimeIntegrationSchemeSDC.h.

    {
        ASSERTL0(false, "Specific version of spectral deferred correction "
                        "not implemented");
    }

References ASSERTL0.

Referenced by ComputeInitialGuess().

◆ v_GetFreeParams()

std::vector< NekDouble > Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_GetFreeParams ( ) const

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 55 of file TimeIntegrationSchemeSDC.cpp.

{
    return m_freeParams;
}

References m_freeParams.

◆ v_GetIntegrationSchemeType()

TimeIntegrationSchemeType Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_GetIntegrationSchemeType ( ) const

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 60 of file TimeIntegrationSchemeSDC.cpp.

{
    return m_schemeType;
}

References m_schemeType.

◆ v_GetName()

std::string Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_GetName ( ) const

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 40 of file TimeIntegrationSchemeSDC.cpp.

{
    return m_name;
}

References m_name.

◆ v_GetNumIntegrationPhases()

size_t Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_GetNumIntegrationPhases ( ) const

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 71 of file TimeIntegrationSchemeSDC.cpp.

{
    return 1;
}

◆ v_GetOrder()

size_t Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_GetOrder ( ) const

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 50 of file TimeIntegrationSchemeSDC.cpp.

{
    return m_order;
}

References m_order.

◆ v_GetSolutionVector()

const TripleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_GetSolutionVector ( ) const

overrideprotectedvirtual

Gets the solution vector of the ODE.

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 76 of file TimeIntegrationSchemeSDC.cpp.

{
    return m_Y;
}

References m_Y.

◆ v_GetTimeStability()

NekDouble Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_GetTimeStability ( ) const

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 66 of file TimeIntegrationSchemeSDC.cpp.

{
    return 1.0;
}

◆ v_GetVariant()

std::string Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_GetVariant ( ) const

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 45 of file TimeIntegrationSchemeSDC.cpp.

{
    return m_variant;
}

References m_variant.

◆ v_InitializeScheme()

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

overrideprotectedvirtual

Worker method to initialize the integration scheme.

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 95 of file TimeIntegrationSchemeSDC.cpp.

{
    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
    {
        m_op      = op;
        m_time    = time;
        m_nvars   = y_0.size();
        m_npoints = y_0[0].size();
 
        // Compute integration matrix.
        size_t colOffset = m_first_quadrature ? 0 : 1;
        size_t rowOffset = m_first_quadrature ? 0 : m_nQuadPts - 1;
        size_t nCols     = m_nQuadPts - colOffset;
        size_t nRows     = m_nQuadPts;
        m_QMat           = SingleArray(nRows * nCols, 0.0);
        Polylib::Qg(&m_QMat[rowOffset], &m_tau[colOffset], nCols);
 
        // Compute intepolation coefficient.
        m_interp = SingleArray(m_nQuadPts, 0.0);
        for (size_t i = 0; i < m_nQuadPts; i++)
        {
            m_interp[i] = Polylib::hgj(i, 1.0, &m_tau[0], m_nQuadPts, 0.0, 0.0);
        }
 
        // Storage of previous states and associated timesteps.
        m_Y     = TripleArray(m_nQuadPts);
        m_F     = TripleArray(m_nQuadPts);
        m_SFint = TripleArray(m_nQuadPts);
        m_QFint = TripleArray(m_nQuadPts);
        for (size_t m = 0; m < m_nQuadPts; ++m)
        {
            m_Y[m]     = DoubleArray(m_nvars);
            m_F[m]     = DoubleArray(m_nvars);
            m_SFint[m] = DoubleArray(m_nvars);
            m_QFint[m] = DoubleArray(m_nvars);
            for (size_t i = 0; i < m_nvars; ++i)
            {
                m_Y[m][i]     = SingleArray(m_npoints, 0.0);
                m_F[m][i]     = SingleArray(m_npoints, 0.0);
                m_SFint[m][i] = SingleArray(m_npoints, 0.0);
                m_QFint[m][i] = SingleArray(m_npoints, 0.0);
                // Store the initial values as the first previous state.
                if (m == 0)
                {
                    Vmath::Vcopy(m_npoints, y_0[i], 1, m_Y[m][i], 1);
                }
            }
        }
 
        if (!m_last_quadrature)
        {
            m_Y_f = DoubleArray(m_nvars);
            for (size_t i = 0; i < m_nvars; ++i)
            {
                m_Y_f[i] = SingleArray(m_npoints, 0.0);
            }
        }
 
        if (m_PFASST)
        {
            m_FAScorr = TripleArray(m_nQuadPts);
            for (size_t m = 0; m < m_nQuadPts; ++m)
            {
                m_FAScorr[m] = DoubleArray(m_nvars);
                for (size_t i = 0; i < m_nvars; ++i)
                {
                    m_FAScorr[m][i] = SingleArray(m_npoints, 0.0);
                }
            }
        }
 
        m_initialized = true;
    }
}

References Polylib::hgj(), m_F, m_FAScorr, m_first_quadrature, m_initialized, m_interp, m_last_quadrature, m_npoints, m_nQuadPts, m_nvars, m_op, m_PFASST, m_QFint, m_QMat, m_SFint, m_tau, m_time, m_Y, m_Y_f, Polylib::Qg(), and Vmath::Vcopy().

Referenced by Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC::v_InitializeScheme(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_InitializeScheme(), and Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_InitializeScheme().

◆ v_print()

void Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_print ( std::ostream & os ) const

overrideprotectedvirtual

Worker method to print details on the integration scheme.

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 330 of file TimeIntegrationSchemeSDC.cpp.

{
    os << "Time Integration Scheme: " << GetFullName() << std::endl;
}

References Nektar::LibUtilities::TimeIntegrationScheme::GetFullName().

◆ v_printFull()

void Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_printFull ( std::ostream & os ) const

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 335 of file TimeIntegrationSchemeSDC.cpp.

{
    os << "Time Integration Scheme: " << GetFullName() << std::endl;
}

References Nektar::LibUtilities::TimeIntegrationScheme::GetFullName().

◆ v_ResidualEval() [1/2]

virtual LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_ResidualEval ( const NekDouble & delta_t )

inlineprotectedvirtual

Reimplemented in Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC, Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC, and Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC.

Definition at line 347 of file TimeIntegrationSchemeSDC.h.

    {
        ASSERTL0(false, "Specific version of spectral deferred correction "
                        "not implemented");
    }

References ASSERTL0.

◆ v_ResidualEval() [2/2]

virtual LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_ResidualEval	(	const NekDouble &	delta_t,
		const size_t	n
	)

inlineprotectedvirtual

Reimplemented in Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC, Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC, and Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC.

Definition at line 340 of file TimeIntegrationSchemeSDC.h.

    {
        ASSERTL0(false, "Specific version of spectral deferred correction "
                        "not implemented");
    }

References ASSERTL0.

Referenced by ResidualEval().

◆ v_SDCIterationLoop()

virtual LUE void Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_SDCIterationLoop ( const NekDouble & delta_t )

inlineprotectedvirtual

Reimplemented in Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC, Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC, and Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC.

Definition at line 360 of file TimeIntegrationSchemeSDC.h.

    {
        ASSERTL0(false, "Specific version of spectral deferred correction "
                        "not implemented");
    }

References ASSERTL0.

Referenced by SDCIterationLoop().

◆ v_SetSolutionVector()

void Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_SetSolutionVector	(	const size_t	Offset,
		const DoubleArray &	y
	)

overrideprotectedvirtual

Sets the solution vector of the ODE.

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 86 of file TimeIntegrationSchemeSDC.cpp.

{
    m_Y[Offset] = y;
}

References m_Y.

◆ v_TimeIntegrate()

ConstDoubleArray & Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_TimeIntegrate	(	const size_t	timestep,
		const NekDouble	delta_t
	)

overrideprotectedvirtual

Worker method that performs the time integration.

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 184 of file TimeIntegrationSchemeSDC.cpp.

{
    for (size_t k = 0; k < m_order; ++k)
    {
        // Compute initial guess
        if (k == 0)
        {
            ComputeInitialGuess(delta_t);
        }
        // Apply SDC correction loop
        else
        {
            SDCIterationLoop(delta_t);
        }
    }
 
    // Update last quadrature
    UpdateLastQuadrature();
 
    // Update first quadrature
    UpdateFirstQuadrature();
 
    // Update time step
    m_time += delta_t;
 
    // Return solution
    return m_Y[0];
}