Nektar::LibUtilities::EulerTimeIntegrationScheme Class Reference

#include <EulerTimeIntegrationSchemes.h>

Inheritance diagram for Nektar::LibUtilities::EulerTimeIntegrationScheme:

Public Member Functions
	EulerTimeIntegrationScheme (std::string variant, unsigned int order, std::vector< NekDouble > freeParams)
virtual	~EulerTimeIntegrationScheme ()
virtual LUE std::string	GetFullName () const
virtual LUE std::string	GetName () const
virtual LUE NekDouble	GetTimeStability () const
Public Member Functions inherited from Nektar::LibUtilities::TimeIntegrationSchemeGLM
virtual LUE std::string	GetVariant () const
virtual LUE unsigned int	GetOrder () const
virtual LUE std::vector< NekDouble >	GetFreeParams () const
virtual LUE TimeIntegrationSchemeType	GetIntegrationSchemeType () const
LUE unsigned int	GetNumIntegrationPhases () const
const TripleArray &	GetSolutionVector () const
	Gets the solution vector of the ODE. More...
void	SetSolutionVector (const int Offset, const DoubleArray &y)
	Sets the solution vector of the ODE. More...
virtual LUE void	InitializeScheme (const NekDouble deltaT, ConstDoubleArray &y_0, const NekDouble time, const TimeIntegrationSchemeOperators &op)
	Worker method to initialize the integration scheme. More...
virtual LUE ConstDoubleArray &	TimeIntegrate (const int timestep, const NekDouble delta_t, const TimeIntegrationSchemeOperators &op)
	Worker method that actually does the time integration. More...
virtual LUE void	InitializeSecondaryData (TimeIntegrationAlgorithmGLM *phase, NekDouble deltaT) const
virtual LUE void	print (std::ostream &os) const
	Worker method to print details on the integration scheme. More...
virtual LUE void	printFull (std::ostream &os) const

Static Public Member Functions
static TimeIntegrationSchemeSharedPtr	create (std::string variant, unsigned int order, std::vector< NekDouble > freeParams)
static LUE void	SetupSchemeData (TimeIntegrationAlgorithmGLMSharedPtr &phase, std::string variant)

Static Public Attributes
static std::string	className

Additional Inherited Members
Protected Member Functions inherited from Nektar::LibUtilities::TimeIntegrationSchemeGLM
LUE	TimeIntegrationSchemeGLM (std::string variant, unsigned int order, std::vector< NekDouble > freeParams)
virtual	~TimeIntegrationSchemeGLM ()
Protected Member Functions inherited from Nektar::LibUtilities::TimeIntegrationScheme
LUE	TimeIntegrationScheme (std::string variant, unsigned int order, std::vector< NekDouble > freeParams)
LUE	TimeIntegrationScheme (const TimeIntegrationScheme &in)
virtual	~TimeIntegrationScheme ()
Protected Attributes inherited from Nektar::LibUtilities::TimeIntegrationSchemeGLM
TimeIntegrationAlgorithmGLMVector	m_integration_phases
TimeIntegrationSolutionGLMSharedPtr	m_solVector

Detailed Description

Definition at line 57 of file EulerTimeIntegrationSchemes.h.

Constructor & Destructor Documentation

EulerTimeIntegrationScheme()

Nektar::LibUtilities::EulerTimeIntegrationScheme::EulerTimeIntegrationScheme ( std::string  variant, unsigned int  order, std::vector< NekDouble >  freeParams  )

inline

Definition at line 60 of file EulerTimeIntegrationSchemes.h.

        : TimeIntegrationSchemeGLM(variant, 1, freeParams)
    {
        boost::ignore_unused(order);
 
        ASSERTL1(variant == "Backward" || variant == "Forward",
                 "Euler Time integration scheme unknown variant: " + variant +
                     ". Must be 'Backward' or 'Forward'");
 
        m_integration_phases    = TimeIntegrationAlgorithmGLMVector(1);
        m_integration_phases[0] = TimeIntegrationAlgorithmGLMSharedPtr(
            new TimeIntegrationAlgorithmGLM(this));
 
        EulerTimeIntegrationScheme::SetupSchemeData(m_integration_phases[0],
                                                    variant);
    }

References ASSERTL1, Nektar::LibUtilities::TimeIntegrationSchemeGLM::m_integration_phases, and SetupSchemeData().

~EulerTimeIntegrationScheme()

virtual Nektar::LibUtilities::EulerTimeIntegrationScheme::~EulerTimeIntegrationScheme ( )

inlinevirtual

Definition at line 78 of file EulerTimeIntegrationSchemes.h.

    {
    }

Member Function Documentation

create()

static TimeIntegrationSchemeSharedPtr Nektar::LibUtilities::EulerTimeIntegrationScheme::create ( std::string  variant, unsigned int  order, std::vector< NekDouble >  freeParams  )

inlinestatic

Definition at line 82 of file EulerTimeIntegrationSchemes.h.

    {
        boost::ignore_unused(order);
 
        TimeIntegrationSchemeSharedPtr p =
            MemoryManager<EulerTimeIntegrationScheme>::AllocateSharedPtr(
                variant, 1, freeParams);
        return p;
    }

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

GetFullName()

virtual LUE std::string Nektar::LibUtilities::EulerTimeIntegrationScheme::GetFullName ( ) const

inlinevirtual

Reimplemented from Nektar::LibUtilities::TimeIntegrationScheme.

Definition at line 96 of file EulerTimeIntegrationSchemes.h.

    {
        return m_integration_phases[m_integration_phases.size() - 1]->m_name;
    }

References Nektar::LibUtilities::TimeIntegrationSchemeGLM::m_integration_phases.

GetName()

virtual LUE std::string Nektar::LibUtilities::EulerTimeIntegrationScheme::GetName ( ) const

inlinevirtual

Implements Nektar::LibUtilities::TimeIntegrationSchemeGLM.

Definition at line 101 of file EulerTimeIntegrationSchemes.h.

    {
        return std::string("Euler");
    }

GetTimeStability()

virtual LUE NekDouble Nektar::LibUtilities::EulerTimeIntegrationScheme::GetTimeStability ( ) const

inlinevirtual

Implements Nektar::LibUtilities::TimeIntegrationSchemeGLM.

Definition at line 106 of file EulerTimeIntegrationSchemes.h.

    {
        if (GetVariant() == "Backward")
        {
            return 1.0;
        }
        else
        {
            return 2.784;
        }
    }

References Nektar::LibUtilities::TimeIntegrationSchemeGLM::GetVariant().

SetupSchemeData()

static LUE void Nektar::LibUtilities::EulerTimeIntegrationScheme::SetupSchemeData ( TimeIntegrationAlgorithmGLMSharedPtr &  phase, std::string  variant  )

inlinestatic

Definition at line 118 of file EulerTimeIntegrationSchemes.h.

    {
        double A = 0;
 
        if (variant == "Backward")
        {
            phase->m_schemeType = eDiagonallyImplicit;
 
            A = 1;
        }
        else if (variant == "Forward")
        {
            phase->m_schemeType = eExplicit;
 
            A = 0;
        }
 
        phase->m_variant = variant;
        phase->m_order   = 1;
        phase->m_name    = variant + std::string("EulerOrder") +
                        std::to_string(phase->m_order);
 
        phase->m_numsteps  = 1;
        phase->m_numstages = 1;
 
        phase->m_A = Array<OneD, Array<TwoD, NekDouble>>(1);
        phase->m_B = Array<OneD, Array<TwoD, NekDouble>>(1);
 
        phase->m_A[0] =
            Array<TwoD, NekDouble>(phase->m_numstages, phase->m_numstages, A);
        phase->m_B[0] =
            Array<TwoD, NekDouble>(phase->m_numsteps, phase->m_numstages, 1.0);
        phase->m_U =
            Array<TwoD, NekDouble>(phase->m_numstages, phase->m_numsteps, 1.0);
        phase->m_V =
            Array<TwoD, NekDouble>(phase->m_numsteps, phase->m_numsteps, 1.0);
 
        phase->m_numMultiStepValues = 1;
        phase->m_numMultiStepDerivs = 0;
        phase->m_timeLevelOffset = Array<OneD, unsigned int>(phase->m_numsteps);
        phase->m_timeLevelOffset[0] = 0;
 
        phase->CheckAndVerify();
    }

References Nektar::LibUtilities::eDiagonallyImplicit, and Nektar::LibUtilities::eExplicit.

Referenced by Nektar::LibUtilities::AdamsMoultonTimeIntegrationScheme::AdamsMoultonTimeIntegrationScheme(), and EulerTimeIntegrationScheme().

Member Data Documentation

className

std::string Nektar::LibUtilities::EulerTimeIntegrationScheme::className

static

Definition at line 94 of file EulerTimeIntegrationSchemes.h.