#include <ode.hpp>

Inheritance diagram for mfem::ExplicitRKSolver:

Collaboration diagram for mfem::ExplicitRKSolver:

Public Member Functions
	ExplicitRKSolver (int s_, const real_t a_, const real_t b_, const real_t *c_)

void	Init (TimeDependentOperator &f_) override
	Associate a TimeDependentOperator with the ODE solver.

void	Step (Vector &x, real_t &t, real_t &dt) override
	Perform a time step from time t [in] to time t [out] based on the requested step size dt [in].

virtual	~ExplicitRKSolver ()

Public Member Functions inherited from mfem::ODESolver
	ODESolver ()

virtual void	Run (Vector &x, real_t &t, real_t &dt, real_t tf)
	Perform time integration from time t [in] to time tf [in].

virtual int	GetStateSize ()
	Returns how many State vectors the ODE requires.

virtual bool	SupportsImplicitVariableType (ImplicitVariableType var) const
	Returns true if the ODESolver supports the given ImplicitVariableType, var, and returns false otherwise. Default implementation returns true if var is ImplicitVariableType::SLOPE and false otherwise.

void	SetImplicitVariableType (const ImplicitVariableType variable_type)
	Sets the ImplicitVariableType for the TimeDependentOperator, if supported.

virtual void	ComputeSlopeFromState (const real_t dt, const Vector &u, Vector &k)
	Compute the finite-difference slope, \(\frac{du}{dt} \approx \frac{u(t+dt)-u(t)}{dt}\), and store it in k.

virtual	~ODESolver ()

Additional Inherited Members
Static Public Member Functions inherited from mfem::ODESolver
static MFEM_EXPORT std::unique_ptr< ODESolver >	Select (const int ode_solver_type)

static MFEM_EXPORT std::unique_ptr< ODESolver >	SelectExplicit (const int ode_solver_type)

static MFEM_EXPORT std::unique_ptr< ODESolver >	SelectImplicit (const int ode_solver_type)

static MFEM_EXPORT std::unique_ptr< ODESolver >	SelectIMEX (const int ode_solver_type)

Static Public Attributes inherited from mfem::ODESolver
static MFEM_EXPORT std::string	ExplicitTypes

static MFEM_EXPORT std::string	ImplicitTypes

static MFEM_EXPORT std::string	IMEXTypes

static MFEM_EXPORT std::string	Types

Protected Types inherited from mfem::ODESolver
using	ImplicitVariableType = TimeDependentOperator::ImplicitVariableType

Protected Attributes inherited from mfem::ODESolver
TimeDependentOperator *	f
	Pointer to the associated TimeDependentOperator.

MemoryType	mem_type

Detailed Description

An explicit Runge-Kutta method corresponding to a general Butcher tableau +-----—+-------------------—+ | c[0] | a[0] | | c[1] | a[1] a[2] | | ... | ... | | c[s-2] | ... a[s(s-1)/2-1] | +-----—+-------------------—+ | | b[0] b[1] ... b[s-1] | +-----—+-------------------—+

Definition at line 347 of file ode.hpp.

Constructor & Destructor Documentation

◆ ExplicitRKSolver()

mfem::ExplicitRKSolver::ExplicitRKSolver	(	int	s_,
		const real_t *	a_,
		const real_t *	b_,
		const real_t *	c_ )

Definition at line 325 of file ode.cpp.

◆ ~ExplicitRKSolver()

mfem::ExplicitRKSolver::~ExplicitRKSolver ( )

virtual

Definition at line 376 of file ode.cpp.

Member Function Documentation

◆ Init()

void mfem::ExplicitRKSolver::Init ( TimeDependentOperator & f_ )

overridevirtual

Associate a TimeDependentOperator with the ODE solver.

This method has to be called:

Before the first call to Step().
When the dimensions of the associated TimeDependentOperator change.
When a time stepping sequence has to be restarted.
To change the associated TimeDependentOperator.

Reimplemented from mfem::ODESolver.

Definition at line 335 of file ode.cpp.

◆ Step()

void mfem::ExplicitRKSolver::Step	(	Vector &	x,
		real_t &	t,
		real_t &	dt )

overridevirtual

Perform a time step from time t [in] to time t [out] based on the requested step size dt [in].

Parameters

[in,out]	x	Approximate solution.
[in,out]	t	Time associated with the approximate solution x.
[in,out]	dt	Time step size.

The following rules describe the common behavior of the method:

The input x [in] is the approximate solution for the input time t [in].
The input dt [in] is the desired time step size, defining the desired target time: t [target] = t [in] + dt [in].
The output x [out] is the approximate solution for the output time t [out].
The output dt [out] is the last time step taken by the method which may be smaller or larger than the input dt [in] value, e.g. because of time step control.
The method may perform more than one time step internally; in this case dt [out] is the last internal time step size.
The output value of t [out] may be smaller or larger than t [target], however, it is not smaller than t [in] + dt [out], if at least one internal time step was performed.
The value x [out] may be obtained by interpolation using internally stored data.
In some cases, the contents of x [in] may not be used, e.g. when x [out] from a previous Step() call was obtained by interpolation.
In consecutive calls to this method, the output t [out] of one Step() call has to be the same as the input t [in] to the next Step() call.
If the previous rule has to be broken, e.g. to restart a time stepping sequence, then the ODE solver must be re-initialized by calling Init() between the two Step() calls.

Implements mfem::ODESolver.

Definition at line 346 of file ode.cpp.

The documentation for this class was generated from the following files:

linalg/ode.hpp
linalg/ode.cpp

Public Member Functions