Peano

Searching...

No Matches

An abstract class for any RKDG solver of any order. More...

Inheritance diagram for exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG:

[legend]

Collaboration diagram for exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG:

[legend]

Public Member Functions
	__init__ (self, name, rk_order, polynomial_basis, FaceProjections face_projections, unknowns, auxiliary_variables, min_cell_h, max_cell_h, plot_grid_properties, bool pde_terms_without_state, baseline_action_set_descend_invocation_order=0)
	Constructor of the Runge-Kutta Discontinuous Galerkin solver.
	__str__ (self)
	get_min_number_of_spacetree_levels (self, domain_size)
	get_max_number_of_spacetree_levels (self, domain_size)
	get_coarsest_number_of_cells (self, domain_size)
	get_finest_number_of_cells (self, domain_size)
	create_readme_descriptor (self, domain_offset, domain_size)
	user_action_set_includes (self)
	Add further includes to this property, if your action sets require some additional routines from other header files.
	user_solver_includes (self)
	Add further includes to this property, if your solver requires some additional routines from other header files.
	add_user_action_set_includes (self, value)
	Add further includes to this property, if your action sets require some additional routines from other header files.
	add_user_solver_includes (self, value)
	Add further includes to this property, if your solver requires some additional routines from other header files.
	create_data_structures (self)
	Recall in subclasses if you wanna change the number of unknowns or auxiliary variables.
	create_action_sets (self)
	Overwrite in subclasses if you wanna create different action sets.
	get_name_of_global_instance (self)
	add_to_Peano4_datamodel (self, datamodel, verbose)
	Add all required data to the Peano4 project's datamodel so it is properly built up.
	add_use_data_statements_to_Peano4_solver_step (self, step)
	Tell Peano what data to move around.
	add_actions_to_init_grid (self, step)
	Add the action sets to the grid initialisation.
	add_actions_to_create_grid (self, step, evaluate_refinement_criterion)
	set_plot_description (self, description)
	Use this one to set a description within the output patch file that tells the vis solver what the semantics of the entries are.
	add_actions_to_plot_solution (self, step, output_path)
	Dump snapshot of solution.
	add_actions_to_perform_time_step (self, step)
	The tricky part here is that we have to get the order right.
	add_entries_to_text_replacement_dictionary (self, d)
	add_implementation_files_to_project (self, namespace, output, dimensions, subdirectory="")
	The ExaHyPE project will call this operation when it sets up the overall environment.
	set_solver_constants (self, datastring)
	add_solver_constants (self, datastring)
	unknowns (self)
	auxiliary_variables (self)
	unknowns (self, value)
	auxiliary_variables (self, value)
	number_of_Runge_Kutta_steps (self)
	set_implementation (self, flux=None, ncp=None, eigenvalues=None, boundary_conditions=None, refinement_criterion=None, initial_conditions=None, source_term=None, point_source=None, additional_action_set_includes="", additional_user_includes="")
	If you pass in User_Defined, then the generator will create C++ stubs that you have to befill manually.
	postprocess_updated_cell_after_Runge_Kutta_step (self)
	postprocess_updated_cell_after_final_linear_combination (self)
	postprocess_updated_cell_after_Runge_Kutta_step (self, kernel)
	Define a postprocessing routine over the data.
	postprocess_updated_cell_after_final_linear_combination (self, kernel)
	Define a postprocessing routine over the data.
	switch_storage_scheme (self, Storage cell_data_storage, Storage face_data_storage)
	By default, we hold all data on the call stacks.

Data Fields
str	plot_description = ""
	select_dofs_to_print = None

Protected Member Functions
	_query_fine_grid_cell_in_action_set_if_it_holds_solution (self)
	_provide_cell_data_to_compute_kernels_default_guard (self)
	_provide_face_data_to_compute_kernels_default_guard (self)
	_store_cell_data_default_guard (self)
	Extend the guard via ands only.
	_load_cell_data_default_guard (self)
	Extend the guard via ands only.
	_store_face_data_default_guard (self)
	Extend the guard via ands only.
	_load_face_data_default_guard (self)
	Extend the guard via ands only.
	_unknown_identifier (self)
	_get_default_includes (self)
	_init_dictionary_with_default_parameters (self, d)
	This one is called by all algorithmic steps before I invoke add_entries_to_text_replacement_dictionary().

Protected Attributes
	_name = name
	_rk_order = rk_order
	_basis = polynomial_basis
	_face_projections = face_projections
str	_volumetric_compute_kernel_call = "#error Please set the solver property _volumetric_compute_kernel_call in the Python class"
str	_volumetric_compute_kernel_call_stateless = "#error Please set the solver property _volumetric_compute_kernel_call_stateless in the Python class"
tuple	_Riemann_compute_kernel_call
tuple	_Riemann_compute_kernel_call_stateless
	_pde_terms_without_state = pde_terms_without_state
str	_add_solver_contributions_call = "#error Please set the solver property _add_solver_contributions_call in the Python class"
str	_multiply_with_inverted_mass_matrix_call = "#error Please set the solver property _multiply_with_inverted_mass_matrix_call in the Python class"
str	_kernel_namespace = "#error Please set the solver property _kernel_namespace in the Python class"
bool	_use_var_shortcut = False
list	_variable_names = []
list	_variable_pos = [0]
	_unknowns = sum(unknowns.values())
	_auxiliary_variables = sum(auxiliary_variables.values())
	_min_cell_h = min_cell_h
	_max_cell_h = max_cell_h
	_plot_grid_properties = plot_grid_properties
str	_solver_constants = ""
str	_user_action_set_includes = ""
str	_user_solver_includes = ""
	_solver_template_file_class_name = None
tuple	_action_set_postprocess_solution = None
tuple	_action_set_preprocess_solution = None
bool	_compute_eigenvalue = False
str	_compute_time_step_size = None
	_compute_new_time_step_size = None
str	_preprocess_cell = ""
str	_postprocess_updated_cell_after_Runge_Kutta_step = ""
str	_postprocess_updated_cell_after_final_linear_combination = ""
	_flux_implementation = None
	_ncp_implementation = None
	_eigenvalues_implementation = None
	_source_term_implementation = None
	_point_sources_implementation = None
	_boundary_conditions_implementation = PDETerms.User_Defined_Implementation
	_refinement_criterion_implementation = PDETerms.Empty_Implementation
	_initial_conditions_implementation = PDETerms.User_Defined_Implementation
str	_abstract_solver_user_declarations = ""
str	_abstract_solver_user_definitions = ""
str	_solver_user_declarations = ""
str	_solver_user_definitions = ""
str	_start_time_step_implementation = ""
str	_finish_time_step_implementation = ""
str	_constructor_implementation = ""
	_cell_data_storage = Storage.CallStack
	_face_data_storage = Storage.CallStack
	_baseline_action_set_descend_invocation_order = baseline_action_set_descend_invocation_order
	_current_time_step
	_rhs_estimates
	_linear_combination_of_estimates
	_estimate_projection
	_old_solution_projection
	_Riemann_solution
	_cell_label = exahype2.grid.create_cell_label(self._name)
	_face_label = exahype2.grid.create_face_label(self._name)
tuple	_action_set_initial_conditions
tuple	_action_set_initial_conditions_for_grid_construction
	_action_set_AMR
tuple	_action_set_AMR_commit_without_further_analysis
tuple	_action_set_AMR_throughout_grid_construction
tuple	_action_set_linear_combination_of_estimates
	_action_set_project_linear_combination_onto_faces
tuple	_action_set_solve_volume_integral
tuple	_action_set_handle_boundary
tuple	_action_set_solve_Riemann_problem
tuple	_action_set_add_volume_and_face_solution
	_action_set_compute_final_linear_combination_and_project_solution_onto_faces
	_action_set_couple_resolution_transitions_and_handle_dynamic_mesh_refinement
	_action_set_update_face_label = exahype2.grid.UpdateFaceLabel(self._name)
	_action_set_update_cell_label = exahype2.grid.UpdateCellLabel(self._name)

Static Private Attributes
	__repr__ = __str__

Detailed Description

An abstract class for any RKDG solver of any order.

This is the base class of all Runge-Kutta DG solvers. It defines what kind of action sets do exist, i.e., what in principle can be done while we run through the grid. It also provides some kind of very basic infrastructure, i.e. what the name of a solver is, what data is to be held per face or cell, or where in the multiscale mesh we actually have to hold data.

The RungeKuttaDG class cannot/should not be instantiated. Its children actually decide which steps are required or invoked in which order.

They do so by setting the guards: Each data structure has a guard which controls if it is to be stored. Each action set has a guard that says if it should be called in this particular mesh traversal. If you want to redefine/reset these guards, you have to redefine create_data_structures() and reset the guards after you have called the superclass' operation. I recommend that you refrain from defining completely new guards. Use the predefined guards instead and refine them by adding more and and or clauses.

If you want to study the mathematics routines used by all the Python-generated code, read the Discontinous Galerkin page in dg.h.

Data structures

Each cell hosts a DG polynomial of order _dg_order. Technically, we store this polynomial in a regular array (blockstructured data) with (_dg_order+1)^d entries. On top of this current time step, we need the shots into the future. for RK(_rk_order), we need _rk_order of these snapshots. They are called estimates.

On the boundary, I store both the left and right solution projections. Per RK step, we project the linear combination onto the face. This is in line with the action set ComputeFinalLinearCombination which simply copies over the old time step into the linear combination field in the very first Runge-Kutta step.

Our DG implementation is not tied to one particular Riemann solver, even though most users will likely use Rusanov. Therefore, it is not clear which data is to be projected onto the faces. For plain Rusanov with only a flux function, the solutions are sufficient. Other Riemann solvers or Rusanov's ncp terms however require the derivatives. So I give the code the opportunity to work with different data cardinalities.

More details are provided in create_data_structures().

Control flow between this class and subclasses

There are three key routines: the constructor, create_data_structures() and create_action_sets(). The constructor sets/memorises some solver variables (such as the name) and then invokes the other two routines.

create_data_structures() establishes all the data structures tied to the grid entities. If you want to alter the configuration of data tied to grid entities, you should redefine create_data_structures(). However, any subclass still should call Runge Kutta's create_data_structures() before that. This will ensure that the baseline configuration of all data is in place. After that, you can modify the properties.

create_action_sets() establishes the action sets, i.e., activities that are to be triggered whenever you run a time step, you plot, you initialise the grid. Same here: If you want to alter the configuration of the code, call create_action_sets() of the superclass first, before you do fancy stuff. This way, all the important action sets are in place.

General control flow and realisation of solver steps

A proper numerical time step is mapped onto a cascade of time step sweeps. Per sweep, we realise the following steps (so step in a computational sense), though their exact orchestration depends on the realisation chosen, i.e. some might merge some subcalculations into one grid sweep while others distribute a calculation over multiple sweeps.

We combine the data of the current time step with all the shots into the future. These shots are held in one large array. This is not super efficient, as we could build up these arrays one by one, but I just use one large scratchpad even for the first line in the Butcher tableau. See create_data_structures() for details. So all the estimates and the current solution are combined according to the Butcher tableau.

It is up to the particular subclass to configure the guard of the linear combination such that it is only computed when it is actually needed.
Next, we project this linear combination onto the faces. At the same time, we compute a new estimate for the volume integral. The time step size for this new estimate again depends on the time step size from the Butcher tableau. The two action sets both are volumetric, i.e. run per cell, but we can run them in parallel. The face projection has to complete immediately (we need the data on the faces), while the volumetric computation, in principle, doesn't have to finish prior to the next grid sweep, as long as the linear combination remains persistent. It is only a temporary thing, so will be destroyed immediately once we leave a cell.

Mandatory step of subclasses

There are different nuances of subclasses/algorithmic realisations, i.e., few solvers inherit directly from RungeKuttaDG. However, even those subclasses still require you do provide some additional information.

These are the fields you have to set:

_compute_time_step_size A simple string which defines a double timeStepSize. This snippet will be used by both the Riemann solver and the volumetric integration. You don't have to care about the Runge-Kutta scaling of time step sizes (or shifts), as this is all done by the source code, but you have to feed an instruction into the solver how to determine a time step size for a cell.

self._compute_new_time_step_size = "const double newTimeStepSize = timeStepSize;"

Semantics of FaceLabel

The update time stamp is the one we update in each and every Runge-Kutta step.
The new time stamp is the valid one, i.e., the one that corresponds to the face's EstimateProjection after a time step.
The old time stamp is the one that corresponds to the (old) face projection.
We set the updated flag if and only if we have finished the last Runge-Kutta step.

Definition at line 38 of file RungeKuttaDG.py.

Constructor & Destructor Documentation

◆ init()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.__init__	(		self,
			name,
			rk_order,
			polynomial_basis,
		FaceProjections	face_projections,
			unknowns,
			auxiliary_variables,
			min_cell_h,
			max_cell_h,
			plot_grid_properties,
		bool	pde_terms_without_state,
			baseline_action_set_descend_invocation_order = 0 )

Constructor of the Runge-Kutta Discontinuous Galerkin solver.

:: Arguments

name: string A unique name for the solver. This one will be used for all generated classes. Also the C++ object instance later on will incorporate this name.

dg_order: int Order of the Discontinuous Galerkin approximation.

rk_order: int Runge-Kutta order, i.e., time stepping order.

polynomials: Polynomials Picks which kind of polynomial to use.

face_projections: Integer How many projections do we need per face. If you are only interested in the left and right solution along a face, pass in 1. If you want to have the fluxes or derivatives as well, pass in 2. The latter version is the type of data structure you need for Rusanov, e.g.

There are a couple of pre-defined values for this guy.

unknowns: int Number of unknowns per Finite Volume voxel.

auxiliary_variables: int Number of auxiliary variables per Finite Volume voxel. Eventually, both unknowns and auxiliary_variables are merged into one big vector if we work with AoS. But the solver has to be able to distinguish them, as only the unknowns are subject to a hyperbolic formulation.

min_cell_h: double This size refers to the individual discretisation cell.

max_cell_h: double This size refers to the individual discretisation cell.

plot_grid_properties: Boolean Clarifies whether a dump of the data should be enriched with grid info (such as enclave status flags), too.

:: Attributes

All the constructor parameters are stored in object attributes. There's a few more which are of interest for subclasses:

_solver_template_file_class_name: String This can be used by subclasses to pick which template is to be used to create the abstract solver and the actual solver blueprint.

_number_of_derivatives_projected_onto_face: Int

_solver_states: [String] Returns a list of strings of the individual solver states. The code will automatically supplement this list with the following states:

GridConstruction, GridInitialisation, Plotting, PlottingAfterGridInitialisation

So you may implicitly assume that these guys do exist always.

Definition at line 163 of file RungeKuttaDG.py.

Member Function Documentation

◆ str()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.__str__ ( self )

Definition at line 378 of file RungeKuttaDG.py.

Referenced by peano4.toolbox.particles.postprocessing.ParticleVTUReader.VTUParticleSet.__repr__().

Here is the caller graph for this function:

◆ _get_default_includes()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._get_default_includes ( self )

protected

Definition at line 1151 of file RungeKuttaDG.py.

◆ _init_dictionary_with_default_parameters()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._init_dictionary_with_default_parameters	(		self,
			d )

protected

This one is called by all algorithmic steps before I invoke add_entries_to_text_replacement_dictionary().

See the remarks on set_postprocess_updated_cell_kernel to understand why we have to apply the (partially befilled) dictionary to create a new entry for this very dictionary.

Definition at line 1426 of file RungeKuttaDG.py.

Referenced by exahype2.solvers.aderdg.LagrangeBasis.LagrangeBasis.__str__(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_checkpoint_solution(), add_actions_to_perform_time_step(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_perform_time_step(), add_actions_to_plot_solution(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_plot_solution(), exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _load_cell_data_default_guard()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._load_cell_data_default_guard ( self )

protected

Extend the guard via ands only.

Never use an or, as subclasses might extend it as well, and they will append further ends.

Definition at line 1048 of file RungeKuttaDG.py.

Referenced by exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_checkpoint_solution(), add_actions_to_plot_solution(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_plot_solution(), exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps.create_data_structures(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.create_data_structures().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _load_face_data_default_guard()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._load_face_data_default_guard ( self )

protected

Extend the guard via ands only.

Never use an or, as subclasses might extend it as well, and they will append further ends.

Definition at line 1083 of file RungeKuttaDG.py.

Here is the call graph for this function:

◆ _provide_cell_data_to_compute_kernels_default_guard()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._provide_cell_data_to_compute_kernels_default_guard ( self )

protected

Definition at line 1011 of file RungeKuttaDG.py.

Referenced by create-dg-benchmark-executable-with-limiter.MyDGSolver.__init__(), exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_data_structures(), exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps.create_data_structures(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.create_data_structures().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _provide_face_data_to_compute_kernels_default_guard()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._provide_face_data_to_compute_kernels_default_guard ( self )

protected

Definition at line 1022 of file RungeKuttaDG.py.

Here is the call graph for this function:

◆ _query_fine_grid_cell_in_action_set_if_it_holds_solution()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._query_fine_grid_cell_in_action_set_if_it_holds_solution ( self )

protected

Definition at line 849 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._store_cell_data_default_guard(), exahype2.solvers.fv.FV.FV._store_cell_data_default_guard(), exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._store_cell_data_default_guard(), exahype2.solvers.limiting.StaticLimiting.StaticLimiting._store_cell_data_default_guard(), and _store_cell_data_default_guard().

Here is the call graph for this function:

◆ _store_cell_data_default_guard()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._store_cell_data_default_guard ( self )

protected

Extend the guard via ands only.

Never use an or, as subclasses might extend it as well, and they will append further ends.

Definition at line 1033 of file RungeKuttaDG.py.

Referenced by _query_fine_grid_cell_in_action_set_if_it_holds_solution(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_init_grid(), exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.create_action_sets(), exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps.create_data_structures(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.create_data_structures().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _store_face_data_default_guard()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._store_face_data_default_guard ( self )

protected

Extend the guard via ands only.

Never use an or, as subclasses might extend it as well, and they will append further ends.

Definition at line 1068 of file RungeKuttaDG.py.

Here is the call graph for this function:

◆ _unknown_identifier()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._unknown_identifier ( self )

protected

Definition at line 1103 of file RungeKuttaDG.py.

Here is the caller graph for this function:

◆ add_actions_to_create_grid()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_actions_to_create_grid	(	self,
		step,
		evaluate_refinement_criterion )

Todo: : The boundary information is set only once. It is therefore important that we ues the face label and initialise it properly.

Definition at line 1189 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_AMR_commit_without_further_analysis, exahype2.solvers.fv.FV.FV._action_set_AMR_commit_without_further_analysis, _action_set_AMR_commit_without_further_analysis, exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_AMR_throughout_grid_construction, exahype2.solvers.fv.FV.FV._action_set_AMR_throughout_grid_construction, _action_set_AMR_throughout_grid_construction, exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_initial_conditions_for_grid_construction, exahype2.solvers.fv.FV.FV._action_set_initial_conditions_for_grid_construction, _action_set_initial_conditions_for_grid_construction, exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_update_cell_label, exahype2.solvers.fv.FV.FV._action_set_update_cell_label, _action_set_update_cell_label, exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_update_face_label, exahype2.solvers.fv.FV.FV._action_set_update_face_label, and _action_set_update_face_label.

◆ add_actions_to_init_grid()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_actions_to_init_grid	(		self,
			step )

Add the action sets to the grid initialisation.

The AMR stuff has to be the very first thing. Actually, the AMR routines' interpolation doesn't play any role here. But the restriction indeed is very important, as we have to get the face data for BCs et al. The action set order is inverted while we ascend within the tree again. Therefore, we add the AMR action set first which means it will be called last when we go from fine to coarse levels within the tree.

Ordering

The order of the action sets is preserved throughout the steps down within the tree hierarchy. It is inverted throughout the backrolling.

This is what we want to achieve:

Restrict the data to the coarser level if we are on a hanging face.

Definition at line 1161 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_AMR, exahype2.solvers.fv.FV.FV._action_set_AMR, _action_set_AMR, exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_initial_conditions, exahype2.solvers.fv.FV.FV._action_set_initial_conditions, _action_set_initial_conditions, exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_postprocess_solution, exahype2.solvers.fv.FV.FV._action_set_postprocess_solution, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._action_set_postprocess_solution, _action_set_postprocess_solution, exahype2.solvers.fv.FV.FV._action_set_preprocess_solution, _action_set_preprocess_solution, exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_update_cell_label, exahype2.solvers.fv.FV.FV._action_set_update_cell_label, _action_set_update_cell_label, exahype2.solvers.aderdg.ADERDG.ADERDG._action_set_update_face_label, exahype2.solvers.fv.FV.FV._action_set_update_face_label, and _action_set_update_face_label.

◆ add_actions_to_perform_time_step()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_actions_to_perform_time_step	(		self,
			step )

The tricky part here is that we have to get the order right.

Update of the labels: This can be done as very first step, as it might feed into follow-up steps.
Linear combination: This has to be the first step of a Runge-Kutta scheme. Without this first step, there's absolutely nothing we can do properly.
Couple resolutions and AMR: Once we have the linear combination, we can couple different resolutions.
Project linear combination onto faces: This should be done as soon as possible but after we've determined the linear combination. After all, we need the solution representation on the faces asap.
Solve volume integral: can run in parallel to the projection onto the faces.
Handle boundary: doesn't really matter when we insert it, as it plugs into the first face load, while all the other stuff so far are volumetric operations. It is important that we do the inter-grid transfer operators before we apply the boundary conditions.
Solve Riemann problem: the constraint here is that it has to come after the boundary handling.
Add volume and face solution: last

If we use enclave tasking, we have to be careful when we insert the merger. See SeparateSweepsWithEnclaveTasking.add_actions_to_perform_time_step() for a discussion of the details.

Reimplemented in exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.

Definition at line 1287 of file RungeKuttaDG.py.

Here is the call graph for this function:

◆ add_actions_to_plot_solution()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_actions_to_plot_solution	(	self,
		step,
		output_path )

Dump snapshot of solution.

Consult the discussion in add_actions_to_init_grid() around the order of the individual action sets.

It is important that we have the coupling/dynamic AMR part in here, as there might be pending AMR refinement requests that now are realised. For the same reason, we need the update of the face label and the update of the cell label in here: The AMR might just propagate over into the plotting, i.e. we might create new grid entities throughout the plot. These entities (faces and cells) have to be initialised properly. Otherwise, their un-initialised data will propagate through to the next time step.

To make the restriction work, we have to project the solutions onto the faces.

Definition at line 1213 of file RungeKuttaDG.py.

Here is the call graph for this function:

◆ add_entries_to_text_replacement_dictionary()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_entries_to_text_replacement_dictionary	(		self,
			d )

Reimplemented in exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.

Definition at line 1340 of file RungeKuttaDG.py.

Referenced by exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_checkpoint_solution(), add_actions_to_perform_time_step(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_perform_time_step(), add_actions_to_plot_solution(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_plot_solution(), exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project().

Here is the caller graph for this function:

◆ add_implementation_files_to_project()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_implementation_files_to_project	(	self,
		namespace,
		output,
		dimensions,
		subdirectory = "" )

The ExaHyPE project will call this operation when it sets up the overall environment.

This routine is typically not invoked by a user.

output: peano4.output.Output

Reimplemented in exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.

Definition at line 1344 of file RungeKuttaDG.py.

◆ add_solver_constants()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_solver_constants	(		self,
			datastring )

Definition at line 1422 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._solver_constants, exahype2.solvers.fv.FV.FV._solver_constants, and _solver_constants.

Referenced by CCZ4Solver.AbstractCCZ4Solver.add_all_solver_constants().

Here is the caller graph for this function:

◆ add_to_Peano4_datamodel()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_to_Peano4_datamodel	(	self,
		datamodel,
		verbose )

Add all required data to the Peano4 project's datamodel so it is properly built up.

Definition at line 1111 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._basis, _basis, exahype2.solvers.aderdg.ADERDG.ADERDG._cell_label, exahype2.solvers.fv.FV.FV._cell_label, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._cell_label, exahype2.solvers.limiting.StaticLimiting.StaticLimiting._cell_label, _cell_label, exahype2.solvers.aderdg.ADERDG.ADERDG._current_time_step, _current_time_step, _estimate_projection, exahype2.solvers.aderdg.ADERDG.ADERDG._face_label, exahype2.solvers.fv.FV.FV._face_label, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._face_label, exahype2.solvers.limiting.StaticLimiting.StaticLimiting._face_label, _face_label, exahype2.solvers.rkdg.actionsets.ComputeFinalLinearCombination.ComputeFinalLinearCombination._face_projections, _face_projections, _linear_combination_of_estimates, _old_solution_projection, _rhs_estimates, and _Riemann_solution.

◆ add_use_data_statements_to_Peano4_solver_step()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_use_data_statements_to_Peano4_solver_step	(		self,
			step )

Tell Peano what data to move around.

Inform Peano4 step which data are to be moved around via the use_cell and use_face commands. This operation is generic from ExaHyPE's point of view, i.e. I use it for all grid sweep types.

Definition at line 1133 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._cell_label, exahype2.solvers.fv.FV.FV._cell_label, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._cell_label, exahype2.solvers.limiting.StaticLimiting.StaticLimiting._cell_label, _cell_label, exahype2.solvers.aderdg.ADERDG.ADERDG._current_time_step, _current_time_step, _estimate_projection, exahype2.solvers.aderdg.ADERDG.ADERDG._face_label, exahype2.solvers.fv.FV.FV._face_label, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting._face_label, exahype2.solvers.limiting.StaticLimiting.StaticLimiting._face_label, _face_label, _linear_combination_of_estimates, _old_solution_projection, _rhs_estimates, and _Riemann_solution.

◆ add_user_action_set_includes()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_user_action_set_includes	(		self,
			value )

Add further includes to this property, if your action sets require some additional routines from other header files.

Definition at line 517 of file RungeKuttaDG.py.

References exahype2.solvers.fv.FV.FV._user_action_set_includes, and _user_action_set_includes.

Referenced by CCZ4Solver.AbstractCCZ4Solver._add_standard_includes(), and set_implementation().

Here is the caller graph for this function:

◆ add_user_solver_includes()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.add_user_solver_includes	(		self,
			value )

Add further includes to this property, if your solver requires some additional routines from other header files.

Definition at line 525 of file RungeKuttaDG.py.

References exahype2.solvers.fv.FV.FV._user_solver_includes, and _user_solver_includes.

Referenced by CCZ4Solver.AbstractCCZ4Solver._add_standard_includes(), and set_implementation().

Here is the caller graph for this function:

◆ auxiliary_variables() [1/2]

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.auxiliary_variables ( self )

Definition at line 1567 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._auxiliary_variables, exahype2.solvers.fv.FV.FV._auxiliary_variables, and _auxiliary_variables.

Referenced by CCZ4Solver.CCZ4Solver_FD4_SecondOrderFormulation_GlobalAdaptiveTimeStepWithEnclaveTasking.add_tracer().

Here is the caller graph for this function:

◆ auxiliary_variables() [2/2]

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.auxiliary_variables	(		self,
			value )

Definition at line 1579 of file RungeKuttaDG.py.

Referenced by CCZ4Solver.CCZ4Solver_FD4_SecondOrderFormulation_GlobalAdaptiveTimeStepWithEnclaveTasking.add_tracer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_action_sets()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.create_action_sets ( self )

Overwrite in subclasses if you wanna create different action sets.

:: Call order and ownership

This operation can be called multiple times over the construction of a solver. However, only the very last call matters. All previous calls are wiped out.

If you have a hierarchy of solvers, every create_data_structure() should first(!) call its parent version. This way, you always ensure that all data are in place before you continue to alter the more specialised versions. So it is (logically) a top-down (general to specialised) run through all create_data_structure() variants within the inheritance tree.

Reimplemented in exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps, and exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.

Definition at line 854 of file RungeKuttaDG.py.

Here is the caller graph for this function:

◆ create_data_structures()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.create_data_structures ( self )

Recall in subclasses if you wanna change the number of unknowns or auxiliary variables.

See class description's subsection on data flow.

:: Call order and ownership

This operation can be called multiple times. However, only the very last call matters. All previous calls are wiped out.

:: Solver fields built up

_time_step: Patch ( (_dg_order+1)x(_dg_order+1)x(_dg_order+1) ) Actual polynomial data of the DG patch in the current time step.

_rhs_estimates: Patch ( (_dg_order+1)x(_dg_order+1)x(_dg_order+1)xno of RK steps ) These are the Runge-Kutta extrapolations. It is important that the rk_order is mixed into the first argument, as the triple is automatically truncated to a tuple if the code is translated with 2d. Please note that the term rhs refers to the right-hand side of an ODE

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

and thus does not include auxiliary variables.

_linear_combination_of_estimates: Patch ( (_dg_order+1)x(_dg_order+1)x(_dg_order+1) ) Non-persistent helper data structure.

_current_time_step_projection: Patch ( 2xface_projectionsx(_dg_order+1)x(_dg_order+1) ) This is the projection of the polynomial data of the current guess onto the faces. It is important that the first dimension is only a 2. This way, we can (logically) handle the projected data again as an overlap of two patches with the width 1.

_estimate_projection: Patch ( Nxface_projectionsx(_dg_order+1)x(_dg_order+1) ) The N is usually 2. Usually this estimate projection holds the data from the latest Runge-Kutta step. This implies that it never ever holds the projection of the solution unless after the very first Runge-Kutta step. After that, it is always a linear combination of estimates.

To avoid this plain behaviour, I make the last and final linear combination project the solution again onto the faces, i.e. after the very last step of the Runge-Kutta scheme, there will be a valid representation of the solution _estimate_projection. Consult the documentation of exahype2.solvers.rkdg.actionsets.ComputeFinalLinearCombination for some further information. Also consult the semantics of the FaceLabel in this context.

_old_solution_projection: Same as _estimate_projection This is a backup of the final solution stored in _estimate_projection. It correlates to

_face_label: FaceLabel See class description. General information such as "is boundary".

_cell_label: CellLabel See class description. General information such as "is enclave".

Per default, I do always store the projections onto faces, and I always keep the actual time step data and the cell projections. It is up to the subclasses to alter this storage behaviour.

By default, I do not exchange any face data in-between two grid sweeps. You will have to overwrite the behaviour in subclasses. Please note that a face is communicated between two tree/domain partitions if and only if it is stored persistently and the exchange flag is set, too.

Reimplemented in exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps, and exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.

Definition at line 534 of file RungeKuttaDG.py.

Here is the caller graph for this function:

◆ create_readme_descriptor()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.create_readme_descriptor	(	self,
		domain_offset,
		domain_size )

Definition at line 460 of file RungeKuttaDG.py.

References _rk_order, get_coarsest_number_of_cells(), get_finest_number_of_cells(), exahype2.solvers.fv.FV.FV.get_max_number_of_spacetree_levels(), get_max_number_of_spacetree_levels(), exahype2.solvers.fv.FV.FV.get_min_number_of_spacetree_levels(), and get_min_number_of_spacetree_levels().

Here is the call graph for this function:

◆ get_coarsest_number_of_cells()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.get_coarsest_number_of_cells	(		self,
			domain_size )

Definition at line 452 of file RungeKuttaDG.py.

References exahype2.solvers.fv.FV.FV.get_min_number_of_spacetree_levels(), and get_min_number_of_spacetree_levels().

Referenced by create_readme_descriptor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_finest_number_of_cells()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.get_finest_number_of_cells	(		self,
			domain_size )

Definition at line 456 of file RungeKuttaDG.py.

References exahype2.solvers.fv.FV.FV.get_max_number_of_spacetree_levels(), and get_max_number_of_spacetree_levels().

Referenced by create_readme_descriptor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_max_number_of_spacetree_levels()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.get_max_number_of_spacetree_levels	(		self,
			domain_size )

Definition at line 445 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._min_cell_h, and _min_cell_h.

Referenced by create_readme_descriptor(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.create_readme_descriptor(), get_finest_number_of_cells(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.get_finest_number_of_patches().

Here is the caller graph for this function:

◆ get_min_number_of_spacetree_levels()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.get_min_number_of_spacetree_levels	(		self,
			domain_size )

Definition at line 438 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._max_cell_h, and _max_cell_h.

Referenced by create_readme_descriptor(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.create_readme_descriptor(), get_coarsest_number_of_cells(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.get_coarsest_number_of_patches().

Here is the caller graph for this function:

◆ get_name_of_global_instance()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.get_name_of_global_instance ( self )

Definition at line 1107 of file RungeKuttaDG.py.

Here is the caller graph for this function:

◆ number_of_Runge_Kutta_steps()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.number_of_Runge_Kutta_steps ( self )

Definition at line 1585 of file RungeKuttaDG.py.

References _rk_order.

Referenced by _init_dictionary_with_default_parameters(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters(), exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets(), and exahype2.solvers.rkfd.SeparateSweeps.SeparateSweeps.create_data_structures().

Here is the caller graph for this function:

◆ postprocess_updated_cell_after_final_linear_combination() [1/2]

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.postprocess_updated_cell_after_final_linear_combination ( self )

Definition at line 1645 of file RungeKuttaDG.py.

References _postprocess_updated_cell_after_final_linear_combination.

Referenced by CCZ4Solver.CCZ4Solver_RKDG_GlobalAdaptiveTimeStep.__init__(), and CCZ4Solver.CCZ4Solver_RKDG_GlobalAdaptiveTimeStepWithEnclaveTasking.__init__().

Here is the caller graph for this function:

◆ postprocess_updated_cell_after_final_linear_combination() [2/2]

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.postprocess_updated_cell_after_final_linear_combination	(		self,
			kernel )

Define a postprocessing routine over the data.

This routine allows you to update the patch data immediately after the patch update. The routine provides the whole patch, and therefore you can write stuff similar to

 my_solver.postprocess_updated_cell = " ""
 {
   constexpr int itmax = ({{DG_ORDER}} +1 ) * ({{DG_ORDER}} + 1) * ({{DG_ORDER}} + 1);
   int index = 0;
   for (int i = 0; i < itmax; i++) {
     applications::exahype2::ccz4::enforceCCZ4constraints(dQdt + index);
     index += {{NUMBER_OF_UNKNOWNS}};
   }
 }

Difference to Finite Volume solvers

Different to the Finite Volume solvers, you don't have the auxiliary variables in this routine. You also don't have the new solution, but the time derivative instead.

Available constants

This list is not complete. You might want to consult the generated code to spot more variables that are on offer. Whenever I use the brackets below, these are symbolic constants which will be befilled with the proper constants when the postprocessing code snippet is inserted into the generated code. The other variables are directly available, i.e., no text replacement is done here.

{{DG_ORDER}} Spatial discretisation order.

Runge-Kutta steps

This postprocessing is called after each and every Runge-Kutta step.

Definition at line 1700 of file RungeKuttaDG.py.

Here is the call graph for this function:

◆ postprocess_updated_cell_after_Runge_Kutta_step() [1/2]

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.postprocess_updated_cell_after_Runge_Kutta_step ( self )

Definition at line 1640 of file RungeKuttaDG.py.

References _postprocess_updated_cell_after_Runge_Kutta_step.

◆ postprocess_updated_cell_after_Runge_Kutta_step() [2/2]

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.postprocess_updated_cell_after_Runge_Kutta_step	(		self,
			kernel )

Define a postprocessing routine over the data.

This routine allows you to update the patch data immediately after the patch update. The routine provides the whole patch, and therefore you can write stuff similar to

 my_solver.postprocess_updated_cell = " ""
 {
   constexpr int itmax = ({{DG_ORDER}} + 1) * ({{DG_ORDER}} + 1) * ({{DG_ORDER}} + 1);
   int index = 0;
   for (int i = 0; i < itmax; i++) {
     applications::exahype2::ccz4::enforceCCZ4constraints(dQdt + index);
     index += {{NUMBER_OF_UNKNOWNS}};
   }
 }

Difference to Finite Volume solvers

Different to the Finite Volume solvers, you don't have the auxiliary variables in this routine. You also don't have the new solution, but the time derivative instead.

Available constants

{{DG_ORDER}} Spatial discretisation order.
timeStamp
timeStepSize
dQdt

Runge-Kutta steps

This postprocessing is called after each and every Runge-Kutta step.

Definition at line 1650 of file RungeKuttaDG.py.

Here is the call graph for this function:

◆ set_implementation()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.set_implementation	(	self,
		flux = None,
		ncp = None,
		eigenvalues = None,
		boundary_conditions = None,
		refinement_criterion = None,
		initial_conditions = None,
		source_term = None,
		point_source = None,
		additional_action_set_includes = "",
		additional_user_includes = "" )

If you pass in User_Defined, then the generator will create C++ stubs that you have to befill manually.

If you pass in None_Implementation, it will create nop, i.e., no implementation or defaults. Any other string is copied 1:1 into the implementation. If you pass in None, then the set value so far won't be overwritten.

Reimplemented in exahype2.solvers.rkdg.rusanov.GlobalAdaptiveTimeStep.GlobalAdaptiveTimeStep, exahype2.solvers.rkdg.rusanov.GlobalAdaptiveTimeStepWithEnclaveTasking.GlobalAdaptiveTimeStepWithEnclaveTasking, and exahype2.solvers.rkdg.rusanov.GlobalFixedTimeStep.GlobalFixedTimeStep.

Definition at line 1589 of file RungeKuttaDG.py.

Referenced by ccz4.CCZ4Solver.__init__(), CCZ4Solver.CCZ4Solver_FD4_GlobalAdaptiveTimeStep.__init__(), CCZ4Solver.CCZ4Solver_FD4_GlobalAdaptiveTimeStepWithEnclaveTasking.__init__(), CCZ4Solver.CCZ4Solver_RKDG_GlobalAdaptiveTimeStep.__init__(), and CCZ4Solver.CCZ4Solver_RKDG_GlobalAdaptiveTimeStepWithEnclaveTasking.__init__().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_plot_description()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.set_plot_description	(		self,
			description )

Use this one to set a description within the output patch file that tells the vis solver what the semantics of the entries are.

Typicallly, I use a comma-separated list here.

Definition at line 1204 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG.plot_description, exahype2.solvers.limiting.PosterioriLimiting.PosterioriLimiting.plot_description, exahype2.solvers.limiting.StaticLimiting.StaticLimiting.plot_description, and plot_description.

◆ set_solver_constants()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.set_solver_constants	(		self,
			datastring )

Definition at line 1418 of file RungeKuttaDG.py.

References exahype2.solvers.aderdg.ADERDG.ADERDG._solver_constants, exahype2.solvers.fv.FV.FV._solver_constants, and _solver_constants.

◆ switch_storage_scheme()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.switch_storage_scheme	(		self,
		Storage	cell_data_storage,
		Storage	face_data_storage )

By default, we hold all data on the call stacks.

You can explicitly switch to storage on the heap via smart pointers.

See also: create_data_structures()

Reimplemented in exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.

Definition at line 1747 of file RungeKuttaDG.py.

Here is the call graph for this function:

◆ unknowns() [1/2]

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.unknowns ( self )

Definition at line 1562 of file RungeKuttaDG.py.

Referenced by CCZ4Solver.CCZ4Solver_FD4_SecondOrderFormulation_GlobalAdaptiveTimeStepWithEnclaveTasking.add_tracer().

Here is the caller graph for this function:

◆ unknowns() [2/2]

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.unknowns	(		self,
			value )

Definition at line 1572 of file RungeKuttaDG.py.

Referenced by CCZ4Solver.CCZ4Solver_FD4_SecondOrderFormulation_GlobalAdaptiveTimeStepWithEnclaveTasking.add_tracer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ user_action_set_includes()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.user_action_set_includes ( self )

Add further includes to this property, if your action sets require some additional routines from other header files.

Definition at line 500 of file RungeKuttaDG.py.

References exahype2.solvers.fv.FV.FV._user_action_set_includes, and _user_action_set_includes.

Referenced by exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project().

Here is the caller graph for this function:

◆ user_solver_includes()

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.user_solver_includes ( self )

Add further includes to this property, if your solver requires some additional routines from other header files.

Definition at line 509 of file RungeKuttaDG.py.

References exahype2.solvers.fv.FV.FV._user_solver_includes, and _user_solver_includes.

Referenced by _init_dictionary_with_default_parameters(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters(), exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_implementation_files_to_project().

Here is the caller graph for this function:

Field Documentation

◆ repr

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.__repr__ = __str__

staticprivate

Definition at line 435 of file RungeKuttaDG.py.

◆ _abstract_solver_user_declarations

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._abstract_solver_user_declarations = ""

protected

Definition at line 361 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _abstract_solver_user_definitions

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._abstract_solver_user_definitions = ""

protected

Definition at line 362 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _action_set_add_volume_and_face_solution

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_add_volume_and_face_solution

protected

Initial value:

=  (
            exahype2.solvers.rkdg.actionsets.AddVolumeAndFaceSolution(self)
        )

Definition at line 936 of file RungeKuttaDG.py.

Referenced by add_actions_to_perform_time_step(), and exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets().

◆ _action_set_AMR

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_AMR

protected

Initial value:

=  exahype2.solvers.rkdg.actionsets.AdaptivityCriterion(
            solver=self,
            guard=self._store_cell_data_default_guard()
            + " and (repositories::"
            + self.get_name_of_global_instance()
            + ".isLastGridSweepOfTimeStep() or repositories::"
            + self.get_name_of_global_instance()
            + ".getSolverState()=="
            + self._name
            + "::SolverState::GridInitialisation)",
            build_up_new_refinement_instructions=True,
            implement_previous_refinement_instructions=True,
            called_by_grid_construction=False,
        )

Definition at line 886 of file RungeKuttaDG.py.

Referenced by add_actions_to_init_grid(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_init_grid(), add_actions_to_perform_time_step(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_perform_time_step(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.create_action_sets().

◆ _action_set_AMR_commit_without_further_analysis

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_AMR_commit_without_further_analysis

protected

Initial value:

=  (
            exahype2.solvers.rkdg.actionsets.AdaptivityCriterion(
                solver=self,
                guard=self._store_cell_data_default_guard(),
                build_up_new_refinement_instructions=False,
                implement_previous_refinement_instructions=True,
                called_by_grid_construction=False,
            )
        )

Definition at line 900 of file RungeKuttaDG.py.

Referenced by add_actions_to_create_grid(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_create_grid(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.create_action_sets().

◆ _action_set_AMR_throughout_grid_construction

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_AMR_throughout_grid_construction

protected

Initial value:

=  (
            exahype2.solvers.rkdg.actionsets.AdaptivityCriterion(
                solver=self,
                guard=self._store_cell_data_default_guard(),
                build_up_new_refinement_instructions=True,
                implement_previous_refinement_instructions=True,
                called_by_grid_construction=True,
            )
        )

Definition at line 909 of file RungeKuttaDG.py.

Referenced by add_actions_to_create_grid(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_create_grid().

◆ _action_set_compute_final_linear_combination_and_project_solution_onto_faces

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_compute_final_linear_combination_and_project_solution_onto_faces

protected

Initial value:

=  exahype2.solvers.rkdg.actionsets.ComputeFinalLinearCombination(
            solver=self,
            guard=self._store_cell_data_default_guard(),
            face_projections=self._face_projections,
        )

Definition at line 939 of file RungeKuttaDG.py.

Referenced by add_actions_to_perform_time_step(), and exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets().

◆ _action_set_couple_resolution_transitions_and_handle_dynamic_mesh_refinement

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_couple_resolution_transitions_and_handle_dynamic_mesh_refinement

protected

Initial value:

=  exahype2.solvers.rkdg.actionsets.DynamicAMR(
            solver=self, face_projections=self._face_projections
        )

Definition at line 944 of file RungeKuttaDG.py.

◆ _action_set_handle_boundary

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_handle_boundary

protected

Initial value:

=  (
            exahype2.solvers.rkdg.actionsets.HandleBoundary(
                self, self._store_face_data_default_guard()
            )
        )

Definition at line 928 of file RungeKuttaDG.py.

Referenced by add_actions_to_perform_time_step(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_perform_time_step(), exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets(), SBH.FD4SolverWithLimiter.create_action_sets(), and SBH.FD4SolverWithoutLimiter.create_action_sets().

◆ _action_set_initial_conditions

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_initial_conditions

protected

Initial value:

=  (
            exahype2.solvers.rkdg.actionsets.InitialCondition(
                self,
                self._query_fine_grid_cell_in_action_set_if_it_holds_solution(),
                "true",
            )
        )

Definition at line 872 of file RungeKuttaDG.py.

Referenced by add_actions_to_init_grid(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_init_grid(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.create_action_sets().

◆ _action_set_initial_conditions_for_grid_construction

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_initial_conditions_for_grid_construction

protected

Initial value:

=  (
            exahype2.solvers.rkdg.actionsets.InitialCondition(
                self,
                self._query_fine_grid_cell_in_action_set_if_it_holds_solution(),
                "false",
            )
        )

Definition at line 879 of file RungeKuttaDG.py.

◆ _action_set_linear_combination_of_estimates

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_linear_combination_of_estimates

protected

Initial value:

=  (
            exahype2.solvers.rkdg.actionsets.LinearCombinationOfEstimates(self)
        )

Definition at line 918 of file RungeKuttaDG.py.

Referenced by add_actions_to_perform_time_step(), and exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets().

◆ _action_set_postprocess_solution

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_postprocess_solution = None

protected

Definition at line 337 of file RungeKuttaDG.py.

Referenced by add_actions_to_init_grid(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_init_grid(), add_actions_to_perform_time_step(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_perform_time_step().

◆ _action_set_preprocess_solution

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_preprocess_solution = None

protected

Definition at line 338 of file RungeKuttaDG.py.

Referenced by add_actions_to_init_grid(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_init_grid(), add_actions_to_perform_time_step(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_perform_time_step().

◆ _action_set_project_linear_combination_onto_faces

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_project_linear_combination_onto_faces

protected

Initial value:

=  exahype2.solvers.rkdg.actionsets.ProjectLinearCombinationOfEstimatesOntoFaces(
            solver=self, face_projections=self._face_projections
        )

Definition at line 922 of file RungeKuttaDG.py.

Referenced by add_actions_to_perform_time_step(), and exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets().

◆ _action_set_solve_Riemann_problem

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_solve_Riemann_problem

protected

Initial value:

=  (
            exahype2.solvers.rkdg.actionsets.SolveRiemannProblem(self)
        )

Definition at line 933 of file RungeKuttaDG.py.

Referenced by add_actions_to_perform_time_step(), and exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets().

◆ _action_set_solve_volume_integral

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_solve_volume_integral

protected

Initial value:

=  (
            exahype2.solvers.rkdg.actionsets.SolveVolumeIntegral(self)
        )

Definition at line 925 of file RungeKuttaDG.py.

Referenced by add_actions_to_perform_time_step(), exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_action_sets(), and exahype2.solvers.rkdg.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.create_action_sets().

◆ _action_set_update_cell_label

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_update_cell_label = exahype2.grid.UpdateCellLabel(self._name)

protected

Definition at line 958 of file RungeKuttaDG.py.

◆ _action_set_update_face_label

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._action_set_update_face_label = exahype2.grid.UpdateFaceLabel(self._name)

protected

Definition at line 957 of file RungeKuttaDG.py.

◆ _add_solver_contributions_call

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._add_solver_contributions_call = "#error Please set the solver property _add_solver_contributions_call in the Python class"

protected

Definition at line 264 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters().

◆ _auxiliary_variables

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._auxiliary_variables = sum(auxiliary_variables.values())

protected

Definition at line 303 of file RungeKuttaDG.py.

◆ _baseline_action_set_descend_invocation_order

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._baseline_action_set_descend_invocation_order = baseline_action_set_descend_invocation_order

protected

Definition at line 374 of file RungeKuttaDG.py.

◆ _basis

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._basis = polynomial_basis

protected

Definition at line 252 of file RungeKuttaDG.py.

Referenced by __str__(), _init_dictionary_with_default_parameters(), add_actions_to_plot_solution(), and add_to_Peano4_datamodel().

◆ _boundary_conditions_implementation

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._boundary_conditions_implementation = PDETerms.User_Defined_Implementation

protected

Definition at line 355 of file RungeKuttaDG.py.

Referenced by __str__(), _init_dictionary_with_default_parameters(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters(), and set_implementation().

◆ _cell_data_storage

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._cell_data_storage = Storage.CallStack

protected

Definition at line 371 of file RungeKuttaDG.py.

Referenced by switch_storage_scheme(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.switch_storage_scheme().

◆ _cell_label

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._cell_label = exahype2.grid.create_cell_label(self._name)

protected

Definition at line 845 of file RungeKuttaDG.py.

Referenced by add_to_Peano4_datamodel(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_to_Peano4_datamodel(), add_use_data_statements_to_Peano4_solver_step(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_use_data_statements_to_Peano4_solver_step().

◆ _compute_eigenvalue

bool exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._compute_eigenvalue = False

protected

Definition at line 340 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _compute_new_time_step_size

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._compute_new_time_step_size = None

protected

Definition at line 343 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _compute_time_step_size

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._compute_time_step_size = None

protected

Definition at line 342 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _constructor_implementation

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._constructor_implementation = ""

protected

Definition at line 369 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _current_time_step

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._current_time_step

protected

Initial value:

=  peano4.datamodel.Patch(
            (
                self._basis.dofs_per_axis,
                self._basis.dofs_per_axis,
                self._basis.dofs_per_axis,
            ),
            self._unknowns + self._auxiliary_variables,
            self._unknown_identifier(),
        )

Definition at line 609 of file RungeKuttaDG.py.

Referenced by create-dg-benchmark-executable-with-limiter.MyDGSolver.__init__(), add_actions_to_plot_solution(), add_to_Peano4_datamodel(), and add_use_data_statements_to_Peano4_solver_step().

◆ _eigenvalues_implementation

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._eigenvalues_implementation = None

protected

Definition at line 351 of file RungeKuttaDG.py.

Referenced by exahype2.solvers.fv.FV.FV.__str__(), __str__(), and set_implementation().

◆ _estimate_projection

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._estimate_projection

protected

Initial value:

=  peano4.datamodel.Patch(
            (
                compute_number_of_face_projection_quantities(self._face_projections)
                * 2,
                self._basis.dofs_per_axis,
                self._basis.dofs_per_axis,
            ),
            self._unknowns + self._auxiliary_variables,
            self._unknown_identifier() + "EstimateProjection",
        )

Definition at line 636 of file RungeKuttaDG.py.

Referenced by add_to_Peano4_datamodel(), add_use_data_statements_to_Peano4_solver_step(), and exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_data_structures().

◆ _face_data_storage

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._face_data_storage = Storage.CallStack

protected

Definition at line 372 of file RungeKuttaDG.py.

Referenced by switch_storage_scheme(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.switch_storage_scheme().

◆ _face_label

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._face_label = exahype2.grid.create_face_label(self._name)

protected

Definition at line 846 of file RungeKuttaDG.py.

◆ _face_projections

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._face_projections = face_projections

protected

Definition at line 253 of file RungeKuttaDG.py.

Referenced by add_to_Peano4_datamodel().

◆ _finish_time_step_implementation

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._finish_time_step_implementation = ""

protected

Definition at line 367 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _flux_implementation

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._flux_implementation = None

protected

Definition at line 349 of file RungeKuttaDG.py.

Referenced by ccz4.CCZ4Solver.__init__(), exahype2.solvers.fv.FV.FV.__str__(), __str__(), _init_dictionary_with_default_parameters(), and set_implementation().

◆ _initial_conditions_implementation

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._initial_conditions_implementation = PDETerms.User_Defined_Implementation

protected

Definition at line 357 of file RungeKuttaDG.py.

◆ _kernel_namespace

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._kernel_namespace = "#error Please set the solver property _kernel_namespace in the Python class"

protected

Definition at line 266 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _linear_combination_of_estimates

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._linear_combination_of_estimates

protected

Initial value:

=  peano4.datamodel.Patch(
            (
                self._basis.dofs_per_axis,
                self._basis.dofs_per_axis,
                self._basis.dofs_per_axis,
            ),
            self._unknowns + self._auxiliary_variables,
            self._unknown_identifier() + "LinearCombination",
        )

Definition at line 627 of file RungeKuttaDG.py.

Referenced by add_to_Peano4_datamodel(), add_use_data_statements_to_Peano4_solver_step(), and exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_data_structures().

◆ _max_cell_h

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._max_cell_h = max_cell_h

protected

Definition at line 316 of file RungeKuttaDG.py.

Referenced by __str__(), _init_dictionary_with_default_parameters(), and get_min_number_of_spacetree_levels().

◆ _min_cell_h

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._min_cell_h = min_cell_h

protected

Definition at line 315 of file RungeKuttaDG.py.

Referenced by __str__(), _init_dictionary_with_default_parameters(), and get_max_number_of_spacetree_levels().

◆ _multiply_with_inverted_mass_matrix_call

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._multiply_with_inverted_mass_matrix_call = "#error Please set the solver property _multiply_with_inverted_mass_matrix_call in the Python class"

protected

Definition at line 265 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters().

◆ _name

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._name = name

protected

Definition at line 249 of file RungeKuttaDG.py.

◆ _ncp_implementation

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._ncp_implementation = None

protected

Definition at line 350 of file RungeKuttaDG.py.

Referenced by ccz4.CCZ4Solver.__init__(), exahype2.solvers.fv.FV.FV.__str__(), __str__(), _init_dictionary_with_default_parameters(), and set_implementation().

◆ _old_solution_projection

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._old_solution_projection

protected

Initial value:

=  peano4.datamodel.Patch(
            (
                compute_number_of_face_projection_quantities(self._face_projections)
                * 2,
                self._basis.dofs_per_axis,
                self._basis.dofs_per_axis,
            ),
            self._unknowns + self._auxiliary_variables,
            self._unknown_identifier() + "OldSolutionProjection",
        )

Definition at line 646 of file RungeKuttaDG.py.

Referenced by add_to_Peano4_datamodel(), and add_use_data_statements_to_Peano4_solver_step().

◆ _pde_terms_without_state

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._pde_terms_without_state = pde_terms_without_state

protected

Definition at line 263 of file RungeKuttaDG.py.

Referenced by __str__(), _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.SeparateSweepsWithEnclaveTasking.SeparateSweepsWithEnclaveTasking.add_entries_to_text_replacement_dictionary().

◆ _plot_grid_properties

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._plot_grid_properties = plot_grid_properties

protected

Definition at line 317 of file RungeKuttaDG.py.

Referenced by add_actions_to_plot_solution(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_plot_solution().

◆ _point_sources_implementation

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._point_sources_implementation = None

protected

Definition at line 353 of file RungeKuttaDG.py.

Referenced by __str__(), _init_dictionary_with_default_parameters(), and set_implementation().

◆ _postprocess_updated_cell_after_final_linear_combination

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._postprocess_updated_cell_after_final_linear_combination = ""

protected

Definition at line 347 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), postprocess_updated_cell_after_final_linear_combination(), and postprocess_updated_cell_after_final_linear_combination().

◆ _postprocess_updated_cell_after_Runge_Kutta_step

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._postprocess_updated_cell_after_Runge_Kutta_step = ""

protected

Definition at line 346 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), postprocess_updated_cell_after_Runge_Kutta_step(), and postprocess_updated_cell_after_Runge_Kutta_step().

◆ _preprocess_cell

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._preprocess_cell = ""

protected

Definition at line 345 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters().

◆ _refinement_criterion_implementation

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._refinement_criterion_implementation = PDETerms.Empty_Implementation

protected

Definition at line 356 of file RungeKuttaDG.py.

◆ _rhs_estimates

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._rhs_estimates

protected

Initial value:

=  peano4.datamodel.Patch(
            (
                self.number_of_Runge_Kutta_steps() * (self._basis.dofs_per_axis),
                self._basis.dofs_per_axis,
                self._basis.dofs_per_axis,
            ),
            self._unknowns,
            self._unknown_identifier() + "RhsEstimates",
        )

Definition at line 618 of file RungeKuttaDG.py.

Referenced by add_to_Peano4_datamodel(), and add_use_data_statements_to_Peano4_solver_step().

◆ _Riemann_compute_kernel_call

tuple exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._Riemann_compute_kernel_call

protected

Initial value:

=  (
            "#error Please set the solver property _Riemann_compute_kernel_call in the Python class"
        )

Definition at line 257 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters().

◆ _Riemann_compute_kernel_call_stateless

tuple exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._Riemann_compute_kernel_call_stateless

protected

Initial value:

=  (
            "#error Please set the solver property _Riemann_compute_kernel_call_stateless in the Python class"
        )

Definition at line 260 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters().

◆ _Riemann_solution

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._Riemann_solution

protected

Initial value:

=  peano4.datamodel.Patch(
            (2, self._basis.dofs_per_axis, self._basis.dofs_per_axis),
            self._unknowns,
            self._unknown_identifier() + "RiemannSolution",
        )

Definition at line 656 of file RungeKuttaDG.py.

Referenced by add_to_Peano4_datamodel(), add_use_data_statements_to_Peano4_solver_step(), and exahype2.solvers.rkdg.SeparateSweeps.SeparateSweeps.create_data_structures().

◆ _rk_order

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._rk_order = rk_order

protected

Definition at line 251 of file RungeKuttaDG.py.

◆ _solver_constants

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._solver_constants = ""

protected

Definition at line 319 of file RungeKuttaDG.py.

◆ _solver_template_file_class_name

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._solver_template_file_class_name = None

protected

Definition at line 332 of file RungeKuttaDG.py.

Referenced by exahype2.solvers.aderdg.ADERDG.ADERDG.add_implementation_files_to_project().

◆ _solver_user_declarations

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._solver_user_declarations = ""

protected

Definition at line 363 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _solver_user_definitions

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._solver_user_definitions = ""

protected

Definition at line 364 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _source_term_implementation

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._source_term_implementation = None

protected

Definition at line 352 of file RungeKuttaDG.py.

Referenced by ccz4.CCZ4Solver.__init__(), exahype2.solvers.fv.FV.FV.__str__(), __str__(), _init_dictionary_with_default_parameters(), and set_implementation().

◆ _start_time_step_implementation

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._start_time_step_implementation = ""

protected

Definition at line 366 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _unknowns

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._unknowns = sum(unknowns.values())

protected

Definition at line 290 of file RungeKuttaDG.py.

◆ _use_var_shortcut

bool exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._use_var_shortcut = False

protected

Definition at line 285 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _user_action_set_includes

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._user_action_set_includes = ""

protected

Definition at line 320 of file RungeKuttaDG.py.

Referenced by add_user_action_set_includes(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_user_action_set_includes(), user_action_set_includes(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.user_action_set_includes().

◆ _user_solver_includes

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._user_solver_includes = ""

protected

Definition at line 321 of file RungeKuttaDG.py.

Referenced by add_user_solver_includes(), exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_user_solver_includes(), user_solver_includes(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.user_solver_includes().

◆ _variable_names

list exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._variable_names = []

protected

Definition at line 286 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _variable_pos

list exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._variable_pos = [0]

protected

Definition at line 287 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences._init_dictionary_with_default_parameters().

◆ _volumetric_compute_kernel_call

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._volumetric_compute_kernel_call = "#error Please set the solver property _volumetric_compute_kernel_call in the Python class"

protected

Definition at line 255 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters().

◆ _volumetric_compute_kernel_call_stateless

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG._volumetric_compute_kernel_call_stateless = "#error Please set the solver property _volumetric_compute_kernel_call_stateless in the Python class"

protected

Definition at line 256 of file RungeKuttaDG.py.

Referenced by _init_dictionary_with_default_parameters().

◆ plot_description

str exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.plot_description = ""

Definition at line 334 of file RungeKuttaDG.py.

Referenced by add_actions_to_plot_solution(), and set_plot_description().

◆ select_dofs_to_print

exahype2.solvers.rkdg.RungeKuttaDG.RungeKuttaDG.select_dofs_to_print = None

Definition at line 335 of file RungeKuttaDG.py.

Referenced by add_actions_to_plot_solution(), and exahype2.solvers.rkfd.CellCenteredFiniteDifferences.CellCenteredFiniteDifferences.add_actions_to_plot_solution().

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

python/exahype2/solvers/rkdg/RungeKuttaDG.py

Public Member Functions

Data Fields

Protected Member Functions

Protected Attributes

Static Private Attributes

Detailed Description

Data structures

Control flow between this class and subclasses

General control flow and realisation of solver steps

Mandatory step of subclasses

Semantics of FaceLabel

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __str__()

◆ _get_default_includes()

◆ _init_dictionary_with_default_parameters()

◆ _load_cell_data_default_guard()

◆ _load_face_data_default_guard()

◆ _provide_cell_data_to_compute_kernels_default_guard()

◆ _provide_face_data_to_compute_kernels_default_guard()

◆ _query_fine_grid_cell_in_action_set_if_it_holds_solution()

◆ _store_cell_data_default_guard()

◆ _store_face_data_default_guard()

◆ _unknown_identifier()

◆ add_actions_to_create_grid()

◆ add_actions_to_init_grid()

Ordering

◆ add_actions_to_perform_time_step()

◆ add_actions_to_plot_solution()

◆ add_entries_to_text_replacement_dictionary()

◆ add_implementation_files_to_project()

◆ add_solver_constants()

◆ add_to_Peano4_datamodel()

◆ add_use_data_statements_to_Peano4_solver_step()

◆ add_user_action_set_includes()

◆ add_user_solver_includes()

◆ auxiliary_variables() [1/2]

◆ auxiliary_variables() [2/2]

◆ create_action_sets()

◆ create_data_structures()

◆ create_readme_descriptor()

◆ get_coarsest_number_of_cells()

◆ get_finest_number_of_cells()

◆ get_max_number_of_spacetree_levels()

◆ get_min_number_of_spacetree_levels()

◆ get_name_of_global_instance()

◆ number_of_Runge_Kutta_steps()

◆ postprocess_updated_cell_after_final_linear_combination() [1/2]

◆ postprocess_updated_cell_after_final_linear_combination() [2/2]

Difference to Finite Volume solvers

Available constants

Runge-Kutta steps

◆ postprocess_updated_cell_after_Runge_Kutta_step() [1/2]

◆ postprocess_updated_cell_after_Runge_Kutta_step() [2/2]

Difference to Finite Volume solvers

Available constants

Runge-Kutta steps

◆ set_implementation()

◆ set_plot_description()

◆ set_solver_constants()

◆ switch_storage_scheme()

◆ unknowns() [1/2]

◆ unknowns() [2/2]

◆ user_action_set_includes()

◆ user_solver_includes()

Field Documentation

◆ __repr__

◆ _abstract_solver_user_declarations

◆ _abstract_solver_user_definitions

◆ _action_set_add_volume_and_face_solution

◆ _action_set_AMR

◆ _action_set_AMR_commit_without_further_analysis

◆ _action_set_AMR_throughout_grid_construction

◆ _action_set_compute_final_linear_combination_and_project_solution_onto_faces

◆ _action_set_couple_resolution_transitions_and_handle_dynamic_mesh_refinement

◆ _action_set_handle_boundary

◆ _action_set_initial_conditions

◆ _action_set_initial_conditions_for_grid_construction

◆ _action_set_linear_combination_of_estimates

◆ init()

◆ str()

◆ repr