Class for spectral deferred correction integration. More...

#include <TimeIntegrationSchemeGEM.h>

Inheritance diagram for Nektar::LibUtilities::TimeIntegrationSchemeGEM:

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

	~TimeIntegrationSchemeGEM () override
	Destructor. More...

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

LUE TripleArray &	v_UpdateSolutionVector () override

LUE void	v_SetSolutionVector (const size_t Offset, const DoubleArray &y) override

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

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

TripleArray	m_Y

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

TripleArray	m_T0
	Array containing the solution values. More...

DoubleArray	m_F
	Array containing the solution values. More...

DoubleArray	m_F0
	Array corresponding to the stage Derivatives. More...

size_t	m_order {0}
	Array corresponding to the stage Derivatives. More...

size_t	m_nvars {0}

size_t	m_npoints {0}

bool	m_initialized {false}

Detailed Description

Class for spectral deferred correction integration.

Definition at line 50 of file TimeIntegrationSchemeGEM.h.

Constructor & Destructor Documentation

◆ TimeIntegrationSchemeGEM()

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

inline

Definition at line 53 of file TimeIntegrationSchemeGEM.h.

        : TimeIntegrationScheme(variant, order, freeParams),
          m_name("ExtrapolationMethod")
    {
        ASSERTL0(variant == "" || variant == "ExplicitEuler" ||
                     variant == "ImplicitEuler" || variant == "IMEXEuler" ||
                     variant == "ExplicitMidpoint" ||
                     variant == "ImplicitMidpoint",
                 "Extrapolation Time integration "
                 "scheme bad variant (ExplicitEuler, ImplicitEuler, "
                 "ExplicitMidpoint)")
 
        if (variant == "IMEXEuler")
        {
            std::cerr << "WARNING: IMEX Euler extrapolation method has been "
                         "implemented but its use is not recommended as the "
                         "approach is affected by order-reduction problems."
                      << std::endl;
        }
 
        if (variant == "" || variant == "ExplicitEuler" ||
            variant == "ImplicitEuler" || variant == "IMEXEuler")
        {
            ASSERTL0(order >= 1, "Extrapolation Time integration "
                                 "scheme bad order numbers (>=1): " +
                                     std::to_string(order));
        }
        else if (variant == "ExplicitMidpoint" || variant == "ImplicitMidpoint")
        {
            ASSERTL0(order >= 2, "Extrapolation Time integration "
                                 "scheme bad order numbers (>=2): " +
                                     std::to_string(order));
 
            ASSERTL0(order % 2 == 0,
                     "Extrapolation Time integration "
                     "scheme bad order numbers (even number): " +
                         std::to_string(order));
        }
 
        m_variant    = variant;
        m_order      = order;
        m_freeParams = freeParams;
        if (variant == "ExplicitEuler" || variant == "ExplicitMidpoint")
        {
            m_schemeType = eExplicit;
        }
        else if (variant == "ImplicitEuler" || variant == "ImplicitMidpoint")
        {
            m_schemeType = eImplicit;
        }
        else if (variant == "IMEXEuler")
        {
            m_schemeType = eIMEX;
        }
    }

References ASSERTL0, Nektar::LibUtilities::eExplicit, Nektar::LibUtilities::eIMEX, Nektar::LibUtilities::eImplicit, m_freeParams, m_order, m_schemeType, and m_variant.

◆ ~TimeIntegrationSchemeGEM()

Nektar::LibUtilities::TimeIntegrationSchemeGEM::~TimeIntegrationSchemeGEM ( )

inlineoverride

Destructor.

Definition at line 111 of file TimeIntegrationSchemeGEM.h.

112 {

113 }

Member Function Documentation

◆ create()

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

inlinestatic

Definition at line 115 of file TimeIntegrationSchemeGEM.h.

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

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

◆ v_GetFreeParams()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 55 of file TimeIntegrationSchemeGEM.cpp.

{
    return m_freeParams;
}

References m_freeParams.

◆ v_GetIntegrationSchemeType()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 60 of file TimeIntegrationSchemeGEM.cpp.

{
    return m_schemeType;
}

References m_schemeType.

◆ v_GetName()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 40 of file TimeIntegrationSchemeGEM.cpp.

{
    return m_name;
}

References m_name.

◆ v_GetNumIntegrationPhases()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 71 of file TimeIntegrationSchemeGEM.cpp.

{
    return 1;
}

◆ v_GetOrder()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 50 of file TimeIntegrationSchemeGEM.cpp.

{
    return m_order;
}

References m_order.

◆ v_GetSolutionVector()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 76 of file TimeIntegrationSchemeGEM.cpp.

{
    return m_Y;
}

References m_Y.

◆ v_GetTimeStability()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 66 of file TimeIntegrationSchemeGEM.cpp.

{
    return 1.0;
}

◆ v_GetVariant()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 45 of file TimeIntegrationSchemeGEM.cpp.

{
    return m_variant;
}

References m_variant.

◆ v_InitializeScheme()

void Nektar::LibUtilities::TimeIntegrationSchemeGEM::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 TimeIntegrationSchemeGEM.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();
 
        size_t nodes = m_order;
        if (m_variant == "ExplicitMidpoint" || m_variant == "ImplicitMidpoint")
        {
            nodes /= 2;
        }
 
        // Storage of previous states and associated timesteps.
        m_Y  = TripleArray(m_order + 1);
        m_T  = TripleArray(nodes);
        m_T0 = TripleArray(nodes);
 
        for (size_t m = 0; m <= m_order; ++m)
        {
            m_Y[m] = DoubleArray(m_nvars);
 
            for (size_t i = 0; i < m_nvars; ++i)
            {
                m_Y[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_variant == "" || m_variant == "ExplicitEuler" ||
            m_variant == "ExplicitMidpoint")
        {
            m_op.DoProjection(m_Y[0], m_Y[0], m_time);
        }
 
        for (size_t m = 0; m < nodes; ++m)
        {
            m_T[m]  = DoubleArray(m_nvars);
            m_T0[m] = DoubleArray(m_nvars);
 
            for (size_t i = 0; i < m_nvars; ++i)
            {
                m_T[m][i]  = SingleArray(m_npoints, 0.0);
                m_T0[m][i] = SingleArray(m_npoints, 0.0);
            }
        }
 
        // Storage for the stage derivative as the data will be re-used to
        // update the solution.
        m_F  = DoubleArray(m_nvars);
        m_F0 = DoubleArray(m_nvars);
 
        for (size_t i = 0; i < m_nvars; ++i)
        {
            m_F[i]  = SingleArray(m_npoints, 0.0);
            m_F0[i] = SingleArray(m_npoints, 0.0);
        }
 
        m_initialized = true;
    }
}

References Nektar::LibUtilities::TimeIntegrationSchemeOperators::DoProjection(), m_F, m_F0, m_initialized, m_npoints, m_nvars, m_op, m_order, m_T, m_T0, m_time, m_variant, m_Y, and Vmath::Vcopy().

◆ v_print()

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

overrideprotectedvirtual

Worker method to print details on the integration scheme.

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 417 of file TimeIntegrationSchemeGEM.cpp.

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

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

◆ v_printFull()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 422 of file TimeIntegrationSchemeGEM.cpp.

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

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

◆ v_SetSolutionVector()

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

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 86 of file TimeIntegrationSchemeGEM.cpp.

{
    m_Y[Offset] = y;
}

References m_Y.

◆ v_TimeIntegrate()

ConstDoubleArray & Nektar::LibUtilities::TimeIntegrationSchemeGEM::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 179 of file TimeIntegrationSchemeGEM.cpp.

{
    // Compute initial residual
    if (m_variant == "" || m_variant == "ExplicitEuler" ||
        m_variant == "ExplicitMidpoint" || m_variant == "IMEXEuler")
    {
        m_op.DoOdeRhs(m_Y[0], m_F0, m_time);
    }
 
    // Euler approach
    if (m_variant == "" || m_variant == "ExplicitEuler" ||
        m_variant == "ImplicitEuler" || m_variant == "IMEXEuler")
    {
        // Compute first order approximation
        for (size_t m = 1; m <= m_order; ++m)
        {
            for (size_t k = 1; k <= m; ++k)
            {
                // Implicit schemes
                if (m_variant == "ImplicitEuler")
                {
                    m_op.DoImplicitSolve(m_Y[k - 1], m_Y[k],
                                         m_time + k * (delta_t / m),
                                         delta_t / m);
                }
 
                // Explicit schemes
                if (m_variant == "" || m_variant == "ExplicitEuler" ||
                    m_variant == "IMEXEuler")
                {
                    // For the first stage, used pre-computed rhs
                    if (k == 1)
                    {
                        for (size_t i = 0; i < m_nvars; ++i)
                        {
                            Vmath::Svtvp(m_npoints, delta_t / m, m_F0[i], 1,
                                         m_Y[k - 1][i], 1, m_Y[k][i], 1);
                        }
                    }
                    // For other stages, compute new rhs
                    else
                    {
                        m_op.DoOdeRhs(m_Y[k - 1], m_F,
                                      m_time + (k - 1) * (delta_t / m));
                        for (size_t i = 0; i < m_nvars; ++i)
                        {
                            Vmath::Svtvp(m_npoints, delta_t / m, m_F[i], 1,
                                         m_Y[k - 1][i], 1, m_Y[k][i], 1);
                        }
                    }
                }
                if (m_variant == "" || m_variant == "ExplicitEuler")
                {
                    m_op.DoProjection(m_Y[k], m_Y[k],
                                      m_time + k * (delta_t / m));
                }
 
                // IMEX schemes (NOTE: Order reduction problems)
                if (m_variant == "IMEXEuler")
                {
                    m_op.DoImplicitSolve(m_Y[k], m_Y[k],
                                         m_time + k * (delta_t / m),
                                         delta_t / m);
                }
            }
 
            // Save solution to m_T0
            for (size_t i = 0; i < m_nvars; ++i)
            {
                Vmath::Vcopy(m_npoints, m_Y[m][i], 1, m_T0[m - 1][i], 1);
            }
        }
 
        // No extrapolation required for first-order
        if (m_order == 1)
        {
            for (size_t i = 0; i < m_nvars; ++i)
            {
                Vmath::Vcopy(m_npoints, m_Y[1][i], 1, m_Y[0][i], 1);
            }
            m_time += delta_t;
            return m_Y[0];
        }
 
        // Extrapolate solution
        for (size_t m = 1; m < m_order; ++m)
        {
            // Aitken - Neville formula
            for (size_t k = m; k < m_order; ++k)
            {
                for (size_t i = 0; i < m_nvars; ++i)
                {
                    Vmath::Vsub(m_npoints, m_T0[k][i], 1, m_T0[k - 1][i], 1,
                                m_T[k][i], 1);
                    Vmath::Svtvp(m_npoints,
                                 (k - m + 1.0) / ((k + 1.0) - (k - m + 1.0)),
                                 m_T[k][i], 1, m_T0[k][i], 1, m_T[k][i], 1);
                }
            }
 
            // Copy new values to old values
            for (size_t k = m; k < m_order; ++k)
            {
                for (size_t i = 0; i < m_nvars; ++i)
                {
                    Vmath::Vcopy(m_npoints, m_T[k][i], 1, m_T0[k][i], 1);
                }
            }
        }
 
        // Copy final solution
        for (size_t i = 0; i < m_nvars; ++i)
        {
            Vmath::Vcopy(m_npoints, m_T[m_order - 1][i], 1, m_Y[0][i], 1);
        }
    }
    // Midpoint approach
    else if (m_variant == "ExplicitMidpoint" || m_variant == "ImplicitMidpoint")
    {
        // Compute second order approximation
        for (size_t m = 1; m <= m_order / 2; ++m)
        {
            // Implicit midpoint
            if (m_variant == "ImplicitMidpoint")
            {
                for (size_t k = 1; k <= m; ++k)
                {
                    m_op.DoImplicitSolve(m_Y[2 * k - 2], m_Y[2 * k - 1],
                                         m_time +
                                             (k - 1 + 0.25) * (delta_t / m),
                                         0.25 * delta_t / m);
                    for (size_t i = 0; i < m_nvars; ++i)
                    {
                        Vmath::Svtsvtp(m_npoints, 2.0, m_Y[2 * k - 1][i], 1,
                                       -1.0, m_Y[2 * k - 2][i], 1,
                                       m_Y[2 * k][i], 1);
                    }
                    m_op.DoImplicitSolve(m_Y[2 * k], m_F,
                                         m_time + (k - 0.25) * (delta_t / m),
                                         0.25 * delta_t / m);
                    for (size_t i = 0; i < m_nvars; ++i)
                    {
                        Vmath::Vsub(m_npoints, m_F[i], 1, m_Y[2 * k][i], 1,
                                    m_F[i], 1);
                        Vmath::Svtvp(m_npoints, 2.0, m_F[i], 1, m_Y[2 * k][i],
                                     1, m_Y[2 * k][i], 1);
                    }
                }
            }
 
            // Explicit midpoint
            if (m_variant == "ExplicitMidpoint")
            {
                // Use precomputed rhs for initial Euler stage
                for (size_t i = 0; i < m_nvars; ++i)
                {
                    Vmath::Svtvp(m_npoints, delta_t / (2 * m), m_F0[i], 1,
                                 m_Y[0][i], 1, m_Y[1][i], 1);
                }
                m_op.DoProjection(m_Y[1], m_Y[1], m_time + delta_t / (2 * m));
 
                // Compute new rhs for midpoint stage
                for (size_t k = 2; k <= 2 * m; ++k)
                {
                    m_op.DoOdeRhs(m_Y[k - 1], m_F,
                                  m_time + (k - 1) * (delta_t / (2 * m)));
                    for (size_t i = 0; i < m_nvars; ++i)
                    {
                        Vmath::Svtvp(m_npoints, delta_t / m, m_F[i], 1,
                                     m_Y[k - 2][i], 1, m_Y[k][i], 1);
                    }
                    m_op.DoProjection(m_Y[k], m_Y[k],
                                      m_time + k * (delta_t / (2 * m)));
                }
            }
 
            // Save solution to m_T0
            for (size_t i = 0; i < m_nvars; ++i)
            {
                Vmath::Vcopy(m_npoints, m_Y[2 * m][i], 1, m_T0[m - 1][i], 1);
            }
        }
 
        // No extrapolation required for second-order
        if (m_order == 2)
        {
            for (size_t i = 0; i < m_nvars; ++i)
            {
                Vmath::Vcopy(m_npoints, m_Y[2][i], 1, m_Y[0][i], 1);
            }
            m_time += delta_t;
            return m_Y[0];
        }
 
        // Extrapolate solution
        for (size_t m = 1; m < m_order / 2; ++m)
        {
            // Aitken - Neville formula
            for (size_t k = m; k < m_order / 2; ++k)
            {
                for (size_t i = 0; i < m_nvars; ++i)
                {
                    Vmath::Vsub(m_npoints, m_T0[k][i], 1, m_T0[k - 1][i], 1,
                                m_T[k][i], 1);
                    Vmath::Svtvp(
                        m_npoints,
                        std::pow(k - m + 1.0, 2) /
                            (std::pow(k + 1.0, 2) - std::pow(k - m + 1.0, 2)),
                        m_T[k][i], 1, m_T0[k][i], 1, m_T[k][i], 1);
                }
            }
 
            // Copy new values to old values
            for (size_t k = m; k < m_order / 2; ++k)
            {
                for (size_t i = 0; i < m_nvars; ++i)
                {
                    Vmath::Vcopy(m_npoints, m_T[k][i], 1, m_T0[k][i], 1);
                }
            }
        }
 
        // Copy final solution
        for (size_t i = 0; i < m_nvars; ++i)
        {
            Vmath::Vcopy(m_npoints, m_T[m_order / 2 - 1][i], 1, m_Y[0][i], 1);
        }
    }
 
    // Return solution
    m_time += delta_t;
    return m_Y[0];
}

References Nektar::LibUtilities::TimeIntegrationSchemeOperators::DoImplicitSolve(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DoOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DoProjection(), m_F, m_F0, m_npoints, m_nvars, m_op, m_order, m_T, m_T0, m_time, m_variant, m_Y, Vmath::Svtsvtp(), Vmath::Svtvp(), Vmath::Vcopy(), and Vmath::Vsub().

◆ v_UpdateSolutionVector()

TripleArray & Nektar::LibUtilities::TimeIntegrationSchemeGEM::v_UpdateSolutionVector ( )

overrideprotectedvirtual

Implements Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 81 of file TimeIntegrationSchemeGEM.cpp.

{
    return m_Y;
}

References m_Y.

Member Data Documentation

◆ className

std::string Nektar::LibUtilities::TimeIntegrationSchemeGEM::className

static

Initial value:

=
    GetTimeIntegrationSchemeFactory().RegisterCreatorFunction(
        "ExtrapolationMethod", TimeIntegrationSchemeGEM::create)

Definition at line 125 of file TimeIntegrationSchemeGEM.h.

◆ m_F

DoubleArray Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_F

protected

Array containing the solution values.

Definition at line 159 of file TimeIntegrationSchemeGEM.h.

Referenced by v_InitializeScheme(), and v_TimeIntegrate().

◆ m_F0

DoubleArray Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_F0

protected

Array corresponding to the stage Derivatives.

Definition at line 160 of file TimeIntegrationSchemeGEM.h.

Referenced by v_InitializeScheme(), and v_TimeIntegrate().

◆ m_freeParams

std::vector<NekDouble> Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_freeParams

protected

Definition at line 151 of file TimeIntegrationSchemeGEM.h.

Referenced by TimeIntegrationSchemeGEM(), and v_GetFreeParams().

◆ m_initialized

bool Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_initialized {false}

protected

Definition at line 166 of file TimeIntegrationSchemeGEM.h.

Referenced by v_InitializeScheme().

◆ m_name

std::string Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_name

protected

Definition at line 149 of file TimeIntegrationSchemeGEM.h.

Referenced by v_GetName().

◆ m_npoints

size_t Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_npoints {0}

protected

Definition at line 165 of file TimeIntegrationSchemeGEM.h.

Referenced by v_InitializeScheme(), and v_TimeIntegrate().

◆ m_nvars

size_t Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_nvars {0}

protected

Definition at line 164 of file TimeIntegrationSchemeGEM.h.

Referenced by v_InitializeScheme(), and v_TimeIntegrate().

◆ m_op

TimeIntegrationSchemeOperators Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_op

protected

Definition at line 153 of file TimeIntegrationSchemeGEM.h.

Referenced by v_InitializeScheme(), and v_TimeIntegrate().

◆ m_order

size_t Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_order {0}

protected

Array corresponding to the stage Derivatives.

Definition at line 163 of file TimeIntegrationSchemeGEM.h.

Referenced by TimeIntegrationSchemeGEM(), v_GetOrder(), v_InitializeScheme(), and v_TimeIntegrate().

◆ m_schemeType

TimeIntegrationSchemeType Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_schemeType {eNoTimeIntegrationSchemeType}

protected

Definition at line 152 of file TimeIntegrationSchemeGEM.h.

Referenced by TimeIntegrationSchemeGEM(), and v_GetIntegrationSchemeType().

◆ m_T

TripleArray Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_T

protected

Array containing the stage values.

Definition at line 157 of file TimeIntegrationSchemeGEM.h.

Referenced by v_InitializeScheme(), and v_TimeIntegrate().

◆ m_T0

TripleArray Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_T0

protected

Array containing the solution values.

Definition at line 158 of file TimeIntegrationSchemeGEM.h.

Referenced by v_InitializeScheme(), and v_TimeIntegrate().

◆ m_time

NekDouble Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_time

protected

Definition at line 148 of file TimeIntegrationSchemeGEM.h.

Referenced by v_InitializeScheme(), and v_TimeIntegrate().

◆ m_variant

std::string Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_variant

protected

Definition at line 150 of file TimeIntegrationSchemeGEM.h.

Referenced by TimeIntegrationSchemeGEM(), v_GetVariant(), v_InitializeScheme(), and v_TimeIntegrate().

◆ m_Y

TripleArray Nektar::LibUtilities::TimeIntegrationSchemeGEM::m_Y

protected

Definition at line 156 of file TimeIntegrationSchemeGEM.h.

Referenced by v_GetSolutionVector(), v_InitializeScheme(), v_SetSolutionVector(), v_TimeIntegrate(), and v_UpdateSolutionVector().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TimeIntegrationSchemeGEM()

◆ ~TimeIntegrationSchemeGEM()

Member Function Documentation

◆ create()

◆ v_GetFreeParams()

◆ v_GetIntegrationSchemeType()

◆ v_GetName()

◆ v_GetNumIntegrationPhases()

◆ v_GetOrder()

◆ v_GetSolutionVector()

◆ v_GetTimeStability()

◆ v_GetVariant()

◆ v_InitializeScheme()

◆ v_print()

◆ v_printFull()

◆ v_SetSolutionVector()

◆ v_TimeIntegrate()

◆ v_UpdateSolutionVector()

Member Data Documentation

◆ className

◆ m_F

◆ m_F0

◆ m_freeParams

◆ m_initialized

◆ m_name

◆ m_npoints

◆ m_nvars

◆ m_op

◆ m_order

◆ m_schemeType

◆ m_T

◆ m_T0

◆ m_time

◆ m_variant

◆ m_Y