Fourth-order central Finite Differences with explicit Runge-Kutta time stepping, realised over a block-structured mesh. More...

Inheritance diagram for exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta:

[legend]

Collaboration diagram for exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta:

[legend]

Data Structures
class	RightHandSideKernel
	The kernels which evaluate the right-hand side,. More...

Public Member Functions
	__init__ (self, Solver solver, int patch_size, int rk_order, float time_step_size=None, float cfl_constant=0.5, "CentralDifferencesWithRungeKutta.RightHandSideKernel" right_hand_side_kernel=RightHandSideKernel.CentralDifferences, advection_velocity=None, advected_quantities=None, float min_volume_size=None, float max_volume_size=None, "toolbox.blockstructured.api.InterpolateHangingFaces.Scheme" interpolation=toolbox.blockstructured.api.InterpolateHangingFaces.Scheme.Linear, "toolbox.blockstructured.api.RestrictHangingFaces.Scheme" restriction=toolbox.blockstructured.api.RestrictHangingFaces.Scheme.Averaging)
	The constructor memorises the attributes and creates the data structures.

int	overlap (self)
	Width of the halo, i.e.

int	rk_order (self)

bool	has_adaptive_time_step_size (self)

str	right_hand_side_kernel_name (self)
	Name of the generated right-hand side kernel.

str	max_eigenvalue_kernel_name (self)

Solver.MeshAdaptation	create_default_mesh_adaptation (self)
	The finite differences adapt the mesh and balance the load through exahype2.api.rkfd4.AdaptMeshAndBalanceLoad by default.

"toolbox.blockstructured.api.RestrictHangingFaces"	create_restriction_of_hanging_faces (self)
	Action set which restricts the projected fine data from the hanging faces onto the coarse faces.

	construct_output (self, exahype2_project, peano_project, time_step)
	Add the data to the Peano 4 project, generate the kernels and add the tasks of one Runge-Kutta step to time_step.

Data Fields
	interpolation

	restriction

	right_hand_side_kernel

	advection_velocity

	advected_quantities

	HALO_SIZE

	patch_size

	min_volume_size

	max_volume_size

	butcher_tableau

	time_step_size

	cfl_constant

	kernel_namespace

	max_eigenvalue_kernel_call

	right_hand_side_kernel_name

	max_eigenvalue_kernel_name

	rk_order

Static Public Attributes
int	HALO_SIZE = 2
	Width of the halo.

Protected Member Functions
	_right_hand_side_action_sets (self, stage, cell_guard)
	Action sets of the task which evaluates the right-hand side of one stage.

	_patches (self)
	All patches of this numerical scheme, i.e.

Protected Attributes
	_solver
	Project the outcome onto the faces.

Protected Attributes inherited from exahype2.api.Solver.Solver.NumericalScheme
	_solver

Private Member Functions
	__create_data_structures (self)
	Create the mesh data structures this numerical scheme requires.

	__add_data_to_repository (self, peano_project)
	Add the data from __create_data_structures() to the Peano 4 project and configure their generators.

	__create_kernels (self, output_directory)
	Translate the DSLHyPE kernels into C++.

	__construct_kernel_call (self, function_name, additional_arguments)
	Construct the call of a generated kernel.

Detailed Description

Fourth-order central Finite Differences with explicit Runge-Kutta time stepping, realised over a block-structured mesh.

Each mesh cell hosts a patch of patch_size^d grid cells. The unknowns sit in the grid cells' centres. The scheme evaluates the right-hand side of

\( \\partial _t Q = F(Q) \)

through fourth-order central differences (exahype2.api.rkfd4.FD4Kernels), and integrates in time with the explicit Runge-Kutta scheme from exahype2.api.rungekutta.ButcherTableau. The stencils reach two grid cells into the neighbouring patches, i.e. the halo is HALO_SIZE=2 grid cells wide:

The script central-differences-with-runge-kutta-illustrations.py next to this file generates the illustrations of this page.

Usage

The scheme plugs into an exahype2.api.Solver like the Finite Volumes of exahype2.api.fv, but with the grid construction and the plotter of exahype2.api.rkfd4:

solver.numerical_scheme  = exahype2.api.rkfd4.CentralDifferencesWithRungeKutta(solver, patch_size=9, rk_order=4)
solver.grid_construction = exahype2.api.rkfd4.SetupSimulationOverRegularGrid(solver, volume_size=0.01)
solver.plotter           = exahype2.api.rkfd4.PlotAsVTKFile(solver, time_in_between_plots=0.1)

The solver can have a Flux, a NonconservativeProduct and a VolumetricSource. It needs an InitPointWisely term, a MaxEigenvalue term unless the time step size is fixed, and either a DirichletBoundaryConditions or a SommerfeldBoundaryConditions term unless all axes are periodic (exahype2.api.blockstructured.BoundaryConditions.get_boundary_conditions()). Sommerfeld conditions also require a MaxEigenvalue term, and a Butcher tableau whose stage time stamps do not decrease. Convergence Tests with Fourth-Order Finite Differences (Euler Equations) demonstrates fourth-order convergence for the Euler equations.

Extending the scheme

The scheme has no artificial dissipation. Subclasses can add further terms to the right-hand side:

_right_hand_side_action_sets() returns the action sets of the task which evaluates the right-hand side of one stage. Subclasses can append action sets which add their terms to the stage's estimate. They run after the right-hand side kernel, within the same task.
Subclasses which need wider stencils override HALO_SIZE.

exagrype.api.FD4WithKODissipation adds the Kreiss-Oliger dissipation this way.

Right-hand side kernels

The constructor's argument right_hand_side_kernel selects how the scheme evaluates the right-hand side (CentralDifferencesWithRungeKutta.RightHandSideKernel):

CentralDifferences: all derivatives through fourth-order central differences (exahype2.api.rkfd4.FD4Kernels). This is the default.
CentralDifferencesWithLopsidedAdvection: the central differences plus advection terms \( v_d \\partial _d Q_q \), which a separate kernel discretises through lopsided (upwind-biased) fourth-order stencils (exahype2::fd::addLopsidedAdvection()). The kernel runs after the central differences within each Runge-Kutta stage. You specify the velocity v, which has to be part of Q, and the advected quantities q. The PDE terms of the solver must not contain these advection terms themselves. As the lopsided stencils reach three grid cells into the neighbouring patches, the halo is three grid cells wide.

Data flow

__create_data_structures() documents the data per mesh cell and face. Per time step, the scheme runs through the Runge-Kutta stages k=0,...,s-1. Stage k

reconstructs its input \( Y_k \) with a halo (solver._patch_with_halo). The interior is solver._patch for the first stage and solver._stage_input for all others, the halo is taken from the faces (solver._patch_overlap_current_time_step);
evaluates the right-hand side \( K_k = F(Y_k) \) and stores it in the stage's slot of solver._rhs_estimates;
computes the input of the next stage \( Y_{k+1} = Q^n + \\Delta t \\sum _{j \\leq k} a_{k+1,j} K_j \) into solver._stage_input and projects it onto the faces, so the neighbours can reconstruct their halo from it in the next stage.

The last stage computes \( Q^{n+1} = Q^n + \\Delta t \\sum _k b_k K_k \) instead, i.e. it overwrites solver._patch, and projects the new solution onto the faces, where the first stage of the next time step picks it up.

As the reconstruction of a stage reads the face data the previous stage has written, the task graph compiler maps each stage onto a mesh traversal of its own (peano4.api.taskgraph.compiler.FuseSteps). For a second-order Runge-Kutta scheme with Dirichlet boundary conditions, the time step's task graph reads:

The boundary values are evaluated at the time stamp of the respective stage, i.e. at \( t^n + c_k \\Delta t \). Otherwise, the scheme would drop to first order along the boundary.

Time step sizes

If you pass a time_step_size, the scheme uses this fixed time step size. Otherwise, it derives the time step size from the maximum eigenvalue of the solution after each time step through the CFL condition with cfl_constant (exahype2.api.rkfd4.actionsets.ComputeTimeStepSize). This requires a non-stateless MaxEigenvalue PDE term.

Definition at line 37 of file CentralDifferencesWithRungeKutta.py.

Constructor & Destructor Documentation

◆ init()

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__init__	(		self,
		Solver	solver,
		int	patch_size,
		int	rk_order,
		float	time_step_size = `None`,
		float	cfl_constant = `0.5`,
		"CentralDifferencesWithRungeKutta.RightHandSideKernel"	right_hand_side_kernel = `RightHandSideKernel.CentralDifferences`,
			advection_velocity = `None`,
			advected_quantities = `None`,
		float	min_volume_size = `None`,
		float	max_volume_size = `None`,
		"toolbox.blockstructured.api.InterpolateHangingFaces.Scheme"	interpolation = `toolbox.blockstructured.api.InterpolateHangingFaces.Scheme.Linear`,
		"toolbox.blockstructured.api.RestrictHangingFaces.Scheme"	restriction = `toolbox.blockstructured.api.RestrictHangingFaces.Scheme.Averaging`
	)

The constructor memorises the attributes and creates the data structures.

It does not add the data to the solver's Peano 4 project yet, but it assigns them to the solver, so anybody else working against this solver, such as the grid construction or the plotter, finds them there.

Parameters

solver	exahype2.api.Solver The solver this numerical scheme realises.
patch_size	int Number of grid cells per axis within one patch, i.e. within one mesh cell. Has to be at least HALO_SIZE, as the projection onto the faces takes the HALO_SIZE outermost layers of the patch.
rk_order	int Order of the Runge-Kutta scheme, i.e. its number of stages. Has to be between one and four, exahype2.api.rungekutta.ButcherTableau.
time_step_size	float or None Fixed time step size. If None, the time step size is adaptive.
cfl_constant	float CFL constant for adaptive time step sizes. It scales the time step size h / (d lambda_max), with h the grid cell size, d the dimension and lambda_max the maximum eigenvalue. Ignored if time_step_size is set. Fourth-order central differences with the classic fourth-order Runge-Kutta scheme are stable up to roughly two for linear advection without dissipation, so 0.5 is a conservative default.
right_hand_side_kernel	CentralDifferencesWithRungeKutta.RightHandSideKernel The kernel which evaluates the right-hand side,

See also: the class documentation.

Parameters

advection_velocity	str or List[str or int] or None Only for CentralDifferencesWithLopsidedAdvection: the entries of Q which hold the advection velocity, one per dimension. Pass the name of a variable with one entry per dimension (e.g. "shift" for exagrype.api.CCZ4Solver), or a list of names or indices. The velocity may be an auxiliary variable.
advected_quantities	List[str or int] or None Only for CentralDifferencesWithLopsidedAdvection: the unknowns which are advected, as names of variables or indices of entries,

See also: exahype2.api.rkfd4.Quantities.resolve_quantities().

Parameters

min_volume_size	float The time step asks for a refinement of a cell only if its grid cells are at least of this size (exahype2.api.blockstructured.DynamicMeshRefinement). None (the default) does not bound the refinement.
max_volume_size	float The time step asks for an erase, i.e. coarsening, of a cell only if the grid cells of the coarser cell would be strictly smaller than this size. None (the default) does not bound the coarsening.
interpolation	toolbox.blockstructured.api.InterpolateHangingFaces.Scheme How the scheme initialises the halo of a fine patch next to a coarser patch on an adaptive mesh. Whenever a Runge-Kutta stage reconstructs the halo of a fine cell, it interpolates the data of the adjacent coarse face onto the fine cell's hanging face (toolbox.blockstructured.api.InterpolateHangingFaces). The default is linear interpolation.
restriction	toolbox.blockstructured.api.RestrictHangingFaces.Scheme How the scheme hands the data of fine patches over to an adjacent coarser patch. Whenever the fine cells project their data onto their faces, the scheme restricts the data of the hanging faces onto the coarse face (toolbox.blockstructured.api.RestrictHangingFaces). The default is averaging.

On a regular mesh, there are no hanging faces, and the two schemes are never used. At resolution transitions, the halo of a fine patch is only as accurate as the interpolation, i.e. the scheme drops to low order there.

Reimplemented from exahype2.api.Solver.Solver.NumericalScheme.

Reimplemented in exagrype.api.FD4WithKODissipation.FD4WithKODissipation.

Definition at line 172 of file CentralDifferencesWithRungeKutta.py.

References exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__init__().

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__init__().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ __add_data_to_repository()

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__add_data_to_repository	(	self,
		peano_project
	)

private

Add the data from __create_data_structures() to the Peano 4 project and configure their generators.

Only _patch_overlap_current_time_step is exchanged between ranks, and only on the faces the solver's grid selector holds for. The task graph compiler uses, loads and stores data only where the solver's grid selector holds, too (peano4.api.datamodel.DoF).

Definition at line 518 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.construct_output(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.construct_output(), and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __construct_kernel_call()

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__construct_kernel_call	(	self,
		function_name,
		additional_arguments
	)

private

Construct the call of a generated kernel.

The kernel takes a exahype2::CellData called patchData, the additional arguments and one functor per PDE term the solver has, in the order flux, nonconservativeProduct, volumetricSource, maxEigenvalue (see __create_kernels()). Each functor forwards to the solver instance.

If PDE terms are registered both with and without state, the generated code asks cellCanUseStatelessPDETerms() before it invokes the kernel, and hands over the stateless variants if it returns true. This logic is a copy of the one of exahype2.api.fv, as rkfd4 does not depend on the Finite Volume package.

Parameters

function_name	str Unqualified name of the kernel.
additional_arguments	[str] C++ expressions passed after patchData.

Definition at line 715 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.construct_output(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.construct_output(), and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

Here is the caller graph for this function:

◆ __create_data_structures()

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__create_data_structures ( self )

private

Create the mesh data structures this numerical scheme requires.

All of them are assigned to self._solver rather than self, so the solver's grid construction and plotter, as well as the action sets, find them there:

_patch: the solution \( Q^n \), i.e. patch_size^d grid cells per mesh cell, with the unknowns and the auxiliary variables per grid cell.
_stage_input: the input \( Y_k \) of the next Runge-Kutta stage, with the same layout as _patch. It is written at the end of one stage and read by the next one.
_patch_with_halo: the input of the current Runge-Kutta stage with its halo, i.e. (patch_size+2*HALO_SIZE)^d grid cells, reconstructed from _patch or _stage_input and the faces (see toolbox.blockstructured.api.ReconstructPatchWithHalo). It is logically temporary.
_rhs_estimates: the right-hand side estimates \( K_k \) of all rk_order stages. They hold the unknowns only, as the auxiliary variables do not evolve in time. The estimates of the stages are stored one after the other, i.e. as rk_order patches of patch_size^d grid cells each. This is why the first dimension is rk_order*patch_size.
_patch_overlap_current_time_step: the face data the halo is reconstructed from, i.e. 2*HALO_SIZE layers along the face's normal. The face data are exchanged between ranks.
_patch_overlap_update: the projection of the patches onto the faces which the current sweep accumulates (exahype2.api.rkfd4.actionsets.ProjectPatchOntoFaces). It is rolled over into _patch_overlap_current_time_step once complete (exahype2.api.rkfd4.actionsets.RollOverUpdatedFace).
_max_eigenvalue: only with adaptive time step sizes. One double per cell, named after the solver followed by MaxEigenvalue. It holds the maximum eigenvalue of the patch after the last time step. It is modelled via DaStGen2 as array of cardinality one on the heap (peano4.api.dastgen2.Peano4SmartPointerDoubleArray).

All patches use smart pointers (peano4.api.datamodel.PatchToDoubleArrayWithSmartPointer), like the Finite Volumes of exahype2.api.fv. The legacy exahype2.solvers.rkfd.CellCenteredFiniteDifferences held a third face overlap with the data of the previous time step. It is required for AMR and local time stepping only, so we do not create it.

Definition at line 410 of file CentralDifferencesWithRungeKutta.py.

Here is the call graph for this function:

◆ __create_kernels()

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__create_kernels	(	self,
		output_directory
	)

private

Translate the DSLHyPE kernels into C++.

The kernels end up in the kernels/ subdirectory of output_directory:

{SolverName}_fd4_2d.h/.cpph and {SolverName}_fd4_3d.h/.cpph hold the right-hand side (exahype2.api.rkfd4.FD4Kernels).
{SolverName}_fd4_eigenvalue_2d.h/.cpph and {SolverName}_fd4_eigenvalue_3d.h/.cpph hold the maximum eigenvalue over a patch. They exist only with adaptive time step sizes.
{SolverName}_fd4.h includes the variants for the dimension the code is compiled for.
rungekutta_linear_combination.h/.cpph holds the linear combination of the Runge-Kutta estimates (exahype2.api.rungekutta.LinearCombination).

Calling this function is delayed until all PDE term information is provided, as the kernels contain only the PDE terms the solver has.

Definition at line 587 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

Here is the caller graph for this function:

◆ _patches()

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta._patches ( self )

protected

All patches of this numerical scheme, i.e.

all data besides the maximum eigenvalue.

Definition at line 504 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__add_data_to_repository().

Here is the caller graph for this function:

◆ _right_hand_side_action_sets()

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta._right_hand_side_action_sets	(	self,
		stage,
		cell_guard
	)

protected

Action sets of the task which evaluates the right-hand side of one stage.

The task reads solver._patch_with_halo, i.e. the stage's input with its halo, and writes the stage's slot of solver._rhs_estimates. By default, it holds one action set, which invokes the fourth-order Finite Differences kernel. Subclasses can append action sets which add further terms to the estimate. The action sets of one task run one after the other, in the order of the list. For the kernel CentralDifferencesWithLopsidedAdvection, the list holds the lopsided advection as second action set.

Parameters

stage	int Number of the Runge-Kutta stage, starting with zero.
cell_guard	str C++ boolean expression, evaluated per cell.

Returns: List[peano4.api.solversteps.ActionSet]

Reimplemented in exagrype.api.FD4WithKODissipation.FD4WithKODissipation.

Definition at line 371 of file CentralDifferencesWithRungeKutta.py.

◆ construct_output()

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output	(	self,
		exahype2_project,
		peano_project,
		time_step
	)

Add the data to the Peano 4 project, generate the kernels and add the tasks of one Runge-Kutta step to time_step.

Per stage k, the time step holds the following tasks (see the class documentation for the data flow):

{SolverName}_Apply Dirichlet BCs stage k: sets the ghost grid cells along the domain boundary for Dirichlet boundary conditions. The task does not exist if all axes are periodic, or for Sommerfeld boundary conditions, which advance the ghost grid cells within the roll over of the projection onto the faces.
{SolverName}_Reconstruct stage k: reconstructs the stage's input with its halo.
{SolverName}_Evaluate right hand side stage k.
{SolverName}_Prepare stage k+1, or {SolverName}_Complete time step after the last stage: computes the linear combination of the estimates. Prepare stage k+1 is tagged with exahype2.api.Solver.IntermediateSolutionUpdateTag, Complete time step with exahype2.api.Solver.SolutionUpdateTaskTag, i.e. postprocessing such as the enforcement of constraints can be inserted directly after them (see Manipulate an existing solver's steps (e.g. inserting additional sweeps)).
{SolverName}_Project stage k+1 onto faces, or {SolverName}_Project solution onto faces after the last stage: projects the outcome of the linear combination onto the faces. After the last stage, it also computes the maximum eigenvalue of the new solution.

After the last stage, {SolverName}_Compute time step size determines the time step size of the next time step and advances the solver's time stamp. {SolverName}_Dynamic mesh refinement finally evaluates the adaptivity criterion if the solver has one (exahype2.api.blockstructured.create_dynamic_mesh_refinement_action_set.create_dynamic_mesh_refinement_action_set()), switches the load balancing on again and informs it that the time step has finished.

Reimplemented from exahype2.api.Solver.Solver.NumericalScheme.

Reimplemented in 20_additional-solver-steps.RungeKuttaWithDensityFloor.

Definition at line 856 of file CentralDifferencesWithRungeKutta.py.

Here is the call graph for this function:

◆ create_default_mesh_adaptation()

Solver.MeshAdaptation exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.create_default_mesh_adaptation ( self )

The finite differences adapt the mesh and balance the load through exahype2.api.rkfd4.AdaptMeshAndBalanceLoad by default.

Reimplemented from exahype2.api.Solver.Solver.NumericalScheme.

Definition at line 823 of file CentralDifferencesWithRungeKutta.py.

◆ create_restriction_of_hanging_faces()

"toolbox.blockstructured.api.RestrictHangingFaces" exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.create_restriction_of_hanging_faces ( self )

Action set which restricts the projected fine data from the hanging faces onto the coarse faces.

Every task which projects the solution onto the faces has to host this action set, so the faces between coarse and fine patches hold consistent data afterwards. The task has to write all of _patch_overlap_update, as averaging clears it first.

Definition at line 834 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.construct_output().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_adaptive_time_step_size()

bool exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.has_adaptive_time_step_size ( self )

Definition at line 355 of file CentralDifferencesWithRungeKutta.py.

References exahype2.api.fv.actionsets.UpdateCellInterior.UpdateCellInterior.time_step_size, exahype2.api.rkfd4.actionsets.ComputeTimeStepSize.ComputeTimeStepSize.time_step_size, and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.time_step_size.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__add_data_to_repository(), exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__create_data_structures(), and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

Here is the caller graph for this function:

◆ max_eigenvalue_kernel_name()

str exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.max_eigenvalue_kernel_name ( self )

Definition at line 368 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

Here is the caller graph for this function:

◆ overlap()

int exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.overlap ( self )

Width of the halo, i.e.

number of grid cells each face holds per adjacent patch. Always HALO_SIZE.

Definition at line 343 of file CentralDifferencesWithRungeKutta.py.

References exagrype.api.FD4WithKODissipation.FD4WithKODissipation.HALO_SIZE, and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.HALO_SIZE.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.__create_data_structures(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.__create_data_structures(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.construct_output(), and exahype2.api.fv.actionsets.InsertPatchInterior.InsertPatchInterior.get_body_of_operation().

Here is the caller graph for this function:

◆ right_hand_side_kernel_name()

str exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.right_hand_side_kernel_name ( self )

Name of the generated right-hand side kernel.

It carries the solver name, as do the kernels/{SolverName}_fd4*.h files holding it, so two solvers' kernels do not clash.

Definition at line 359 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

Here is the caller graph for this function:

◆ rk_order()

int exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.rk_order ( self )

Definition at line 351 of file CentralDifferencesWithRungeKutta.py.

References exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.butcher_tableau.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__create_data_structures().

Here is the caller graph for this function:

Field Documentation

◆ _solver

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta._solver

protected

Project the outcome onto the faces.

After the last stage, also determine the maximum eigenvalue of the new solution

Definition at line 401 of file CentralDifferencesWithRungeKutta.py.

◆ advected_quantities

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.advected_quantities

Definition at line 308 of file CentralDifferencesWithRungeKutta.py.

◆ advection_velocity

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.advection_velocity

Definition at line 305 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

◆ butcher_tableau

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.butcher_tableau

Definition at line 333 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output(), and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.rk_order().

◆ cfl_constant

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.cfl_constant

Definition at line 335 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.construct_output(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.construct_output(), and exahype2.api.rkfd4.actionsets.ComputeTimeStepSize.ComputeTimeStepSize.is_adaptive().

◆ HALO_SIZE [1/2]

int exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.HALO_SIZE = 2

static

Width of the halo.

Subclasses with wider stencils override it.

Definition at line 162 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__create_data_structures(), and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.overlap().

◆ HALO_SIZE [2/2]

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.HALO_SIZE

Definition at line 310 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__create_data_structures(), and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.overlap().

◆ interpolation

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.interpolation

Definition at line 268 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.construct_output().

◆ kernel_namespace

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.kernel_namespace

Definition at line 338 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.__create_time_step_functions(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.__create_time_step_functions(), exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.construct_output(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.construct_output(), and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

◆ max_eigenvalue_kernel_call

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.max_eigenvalue_kernel_call

Definition at line 339 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

◆ max_eigenvalue_kernel_name

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.max_eigenvalue_kernel_name

Definition at line 668 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

◆ max_volume_size

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.max_volume_size

Definition at line 332 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.construct_output(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.construct_output(), and exahype2.api.blockstructured.DynamicMeshRefinement.DynamicMeshRefinement.get_body_of_operation().

◆ min_volume_size

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.min_volume_size

Definition at line 331 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.SetupSimulationWithUserCodedRefinementCriterion.SetupSimulationWithUserCodedRefinementCriterion._create_adapt_mesh_task(), exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.construct_output(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.construct_output(), and exahype2.api.blockstructured.DynamicMeshRefinement.DynamicMeshRefinement.get_body_of_operation().

◆ patch_size

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.patch_size

Definition at line 325 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.__create_data_structures(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.__create_data_structures(), exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__create_data_structures(), exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.construct_output(), exahype2.api.fv.RusanovWithOptimisticExplicitEuler.RusanovWithOptimisticExplicitEuler.construct_output(), exahype2.api.blockstructured.DynamicMeshRefinement.DynamicMeshRefinement.get_body_of_operation(), and exahype2.api.fv.actionsets.InsertPatchInterior.InsertPatchInterior.get_body_of_operation().

◆ restriction

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.restriction

Definition at line 269 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.RusanovWithExplicitEuler.RusanovWithExplicitEuler.create_restriction_of_hanging_faces(), and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.create_restriction_of_hanging_faces().

◆ right_hand_side_kernel

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.right_hand_side_kernel

Definition at line 294 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta._right_hand_side_action_sets().

◆ right_hand_side_kernel_name

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.right_hand_side_kernel_name

Definition at line 655 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.construct_output().

◆ rk_order

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.rk_order

Definition at line 963 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.__create_data_structures().

◆ time_step_size

exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.time_step_size

Definition at line 334 of file CentralDifferencesWithRungeKutta.py.

Referenced by exahype2.api.fv.actionsets.UpdateCellInterior.UpdateCellInterior.get_body_of_operation(), and exahype2.api.rkfd4.CentralDifferencesWithRungeKutta.CentralDifferencesWithRungeKutta.has_adaptive_time_step_size().

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

src/exahype2/api/rkfd4/CentralDifferencesWithRungeKutta.py

Data Structures

Public Member Functions

Data Fields

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Usage

Extending the scheme

Right-hand side kernels

Data flow

Time step sizes

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __add_data_to_repository()

◆ __construct_kernel_call()

◆ __create_data_structures()

◆ __create_kernels()

◆ _patches()

◆ _right_hand_side_action_sets()

◆ construct_output()

◆ create_default_mesh_adaptation()

◆ create_restriction_of_hanging_faces()

◆ has_adaptive_time_step_size()

◆ max_eigenvalue_kernel_name()

◆ overlap()

◆ right_hand_side_kernel_name()

◆ rk_order()

Field Documentation

◆ _solver

◆ advected_quantities

◆ advection_velocity

◆ butcher_tableau

◆ cfl_constant

◆ HALO_SIZE [1/2]

◆ HALO_SIZE [2/2]

◆ interpolation

◆ kernel_namespace

◆ max_eigenvalue_kernel_call

◆ max_eigenvalue_kernel_name

◆ max_volume_size

◆ min_volume_size

◆ patch_size

◆ restriction

◆ right_hand_side_kernel

◆ right_hand_side_kernel_name

◆ rk_order

◆ time_step_size

◆ init()