evolution::dg Namespace Reference

Functionality for evolving hyperbolic partial differential equations using the discontinuous Galerkin method. More...

Namespaces
namespace	Actions
	Actions for using the discontinuous Galerkin to evolve hyperbolic partial differential equations.
namespace	Initialization
	Functionality for initializing the discontinuous Galerkin to evolve hyperbolic partial differential equations.
namespace	subcell
	Combine the volume subcell variables and the ghost variables contained as DataVector into a single combined DataVector.
namespace	Tags
	Tags used for DG evolution scheme.

Classes
struct	ApplyBoundaryCorrections
	Apply corrections from boundary communication. More...
struct	ApplyLtsDenseBoundaryCorrections
	Apply corrections from boundary communication for LTS dense output. More...
struct	AtomicInboxBoundaryData
	Holds the data in the different directions for the nodegroup DgElementArray implementation. More...
struct	BackgroundGrVars
	Allocate or assign background general relativity quantities needed for evolution systems run on a curved spacetime without solving Einstein equations (e.g. ValenciaDivclean, ForceFree). More...
struct	BoundaryData
	The data communicated between neighber elements. More...
struct	BoundaryMessage
	[Charm++ Message] (https://charm.readthedocs.io/en/latest/charm%2B%2B/manual.html#messages) intended to be used in receive_data calls on the elements to send boundary data from one element on one node, to a different element on a (potentially) different node. More...
struct	CleanMortarHistory
	Mutator to remove old entries from the mortar histories in a local-time-stepping DG evolution. More...
struct	EqualRateRegionId
	Unique identifier for an equal-rate region. More...
class	EqualRateRegions
	Regions of the domain that cannot perform local time-stepping. More...
class	EqualRateRegions< Dim, tmpl::list< RegionGenerators... >, tmpl::list< CreationTags... > >
	Regions of the domain that cannot perform local time-stepping. More...
class	EqualRateRegionsBase
	Regions of the domain that cannot perform local time-stepping. More...
struct	InboxBoundaryData
	Class wrapping a map and mirroring the AtomicInboxBoundaryData interface so that code accessing the inbox doesn't need to care which implementation is in use. More...
class	InterpolatedBoundaryData
	Information sent by a non-conforming Element that interpolates its boundary data to a subset of the points of the Element receiving this. More...
struct	is_atomic_inbox_boundary_data
	std::true if T is a AtomicInboxBoundaryData More...
struct	MortarData
	Data on the mortar used to compute the boundary correction for the DG scheme. More...
class	MortarDataHolder
	Data on each side of the mortar used to compute the boundary correction for the DG scheme using global time stepping. More...
class	MortarInfo
	Information about the mortar between two Elements. More...
class	NonconformingEqualRateRegions
	Equal-rate region generator for regions on nonconforming block boundaries. More...
struct	TimeDerivativeDecisions
	Runtime control over time derivative work done. More...
struct	using_subcell
	If Metavars has a SubcellOptions member struct and SubcellOptions::subcell_enabled is true then inherits from std::true_type, otherwise inherits from std::false_type. More...

Concepts
concept	equal_rate_region_generator
	Concept for a class usable in EqualRateRegions.

Typedefs
template<typename System>
using	boundary_variables_tag
	The Tags::BoundaryVariables entry of the system's list-valued variables_tag, or NoSuchType if the system does not declare boundary-evolved variables.
template<typename Metavariables, size_t Dim>
using	element_distribution_cache_tags
	The global cache tags needed to distribute elements, for use as the const_global_cache_tags of a component that creates the elements.

Enumerations
enum class	InterfaceDataPolicy : uint8_t {   Uninitialized = 0 , CopyProject = 1 , OrientCopyProject = 2 , NonconformingBothInterpolate = 3 ,   NonconformingSelfInterpolates = 4 , NonconformingNeighborInterpolates = 5 }
	Label for a neighboring Element (or Block) that determines how information is exchanged between neighboring Elements. More...
enum class	TimeSteppingPolicy : uint8_t { Uninitialized , EqualRate , Conservative }
	Treatment of time stepping across an element boundary. More...

Functions
template<bool UseNodegroupDgElements, typename Metavariables, bool LocalTimeStepping, bool DenseOutput, bool ComputeAuxiliary = false, typename DbTagsList, typename... InboxTags>
bool	receive_boundary_data (const gsl::not_null< db::DataBox< DbTagsList > * > box, const gsl::not_null< tuples::TaggedTuple< InboxTags... > * > inboxes)
	Move boundary data from the inbox to the DataBox. Returns true if all necessary data has been received.
template<size_t Dim>
bool	block_supports_subcell (const Block< Dim > &block)
	Returns whether the Block's topology is compatible with subcell.
template<size_t Dim>
bool	operator== (const BoundaryData< Dim > &lhs, const BoundaryData< Dim > &rhs)
template<size_t Dim>
bool	operator!= (const BoundaryData< Dim > &lhs, const BoundaryData< Dim > &rhs)
template<size_t Dim>
std::ostream &	operator<< (std::ostream &os, const BoundaryData< Dim > &value)
std::ostream &	operator<< (std::ostream &os, const EqualRateRegionId &id)
std::ostream &	operator<< (std::ostream &os, InterfaceDataPolicy value)
	Output operator for a InterfaceDataPolicy.
template<size_t VolumeDim>
bool	operator== (const InterpolatedBoundaryData< VolumeDim > &lhs, const InterpolatedBoundaryData< VolumeDim > &rhs)
template<size_t VolumeDim>
bool	operator!= (const InterpolatedBoundaryData< VolumeDim > &lhs, const InterpolatedBoundaryData< VolumeDim > &rhs)
template<size_t VolumeDim>
std::ostream &	operator<< (std::ostream &os, const InterpolatedBoundaryData< VolumeDim > &value)
template<size_t Dim>
bool	operator== (const BoundaryMessage< Dim > &lhs, const BoundaryMessage< Dim > &rhs)
template<size_t Dim>
bool	operator!= (const BoundaryMessage< Dim > &lhs, const BoundaryMessage< Dim > &rhs)
template<size_t Dim>
std::ostream &	operator<< (std::ostream &os, const BoundaryMessage< Dim > &message)
template<size_t Dim>
bool	p_project_geometric_data (gsl::not_null<::evolution::dg::MortarData< Dim > * > mortar_data, const Mesh< Dim - 1 > &new_face_mesh, const Mesh< Dim > &new_volume_mesh)
	Projects the geometric data (but not the data on the mortar grid) when p-refined.
template<size_t Dim>
bool	p_project_mortar_data (gsl::not_null<::evolution::dg::MortarData< Dim > * > mortar_data, const Mesh< Dim - 1 > &new_mortar_mesh)
	Projects the mortar data (but not the geometric data) when p-refined.
template<size_t Dim>
bool	operator== (const MortarData< Dim > &lhs, const MortarData< Dim > &rhs)
template<size_t Dim>
bool	operator!= (const MortarData< Dim > &lhs, const MortarData< Dim > &rhs)
template<size_t Dim>
std::ostream &	operator<< (std::ostream &os, const MortarData< Dim > &mortar_data)
template<size_t Dim>
bool	operator== (const MortarDataHolder< Dim > &lhs, const MortarDataHolder< Dim > &rhs)
template<size_t Dim>
bool	operator!= (const MortarDataHolder< Dim > &lhs, const MortarDataHolder< Dim > &rhs)
template<size_t Dim>
std::ostream &	operator<< (std::ostream &os, const MortarDataHolder< Dim > &mortar_data_holder)
template<size_t VolumeDim>
bool	operator== (const MortarInfo< VolumeDim > &lhs, const MortarInfo< VolumeDim > &rhs)
template<size_t VolumeDim>
bool	operator!= (const MortarInfo< VolumeDim > &lhs, const MortarInfo< VolumeDim > &rhs)
template<size_t VolumeDim>
std::ostream &	operator<< (std::ostream &os, const MortarInfo< VolumeDim > &mortar_info)
template<size_t Dim>
std::vector< size_t >	compute_only_dg_block_ids (const std::optional< std::vector< std::string > > &only_dg_block_and_group_names, const std::vector< std::string > &block_names, const std::unordered_map< std::string, std::unordered_set< std::string > > &block_groups, const std::vector< Block< Dim > > &blocks)
	Returns the IDs of the Blocks on which only the DG scheme is allowed to run, i.e. that are not subcell-capable.
template<size_t Dim>
std::vector< size_t >	compute_only_dg_block_ids (const std::optional< std::vector< std::string > > &only_dg_block_and_group_names, const DomainCreator< Dim > &domain_creator)
	Returns the IDs of the Blocks on which only the DG scheme is allowed to run, i.e. that are not subcell-capable.
template<size_t Dim>
std::unordered_map< size_t, std::array< size_t, Dim > >	compute_weighting_extents_override (const std::vector< size_t > &only_dg_block_ids, const std::vector< std::array< size_t, Dim > > &initial_extents)
	Returns the per-block extents to use in place of initial_extents when weighting subcell-capable elements by their finite-difference grid instead of their DG grid (see evolution::dg::Tags::UseSubcellGridPointsForDistribution).
template<size_t Dim, typename Metavariables>
std::optional< std::unordered_map< size_t, std::array< size_t, Dim > > >	weighting_extents_override_from_cache (const Parallel::GlobalCache< Metavariables > &cache, const std::vector< std::array< size_t, Dim > > &initial_extents)
	Reads element_distribution_cache_tags out of the cache and returns the weighting_extents_override to pass to Parallel::create_elements_using_distribution.
std::ostream &	operator<< (std::ostream &os, TimeSteppingPolicy value)
	Output operator for a TimeSteppingPolicy.
	CREATE_GET_TYPE_ALIAS_OR_DEFAULT (boundary_field_time_derivatives_evolved_variables_tags) template< typename BoundaryCondition > using boundary_field_time_derivatives_interior_tags
	The projected interior inputs to a boundary condition's boundary_field_time_derivatives method, in the order evolved, primitive, temporary.

Variables
template<typename T>
constexpr size_t	is_atomic_inbox_boundary_data_v
	true if T is a AtomicInboxBoundaryData
template<typename System>
constexpr bool	system_has_boundary_variables_v
	Whether the system declares boundary-evolved variables, i.e. whether System::variables_tag is a tmpl::list whose last entry is a Tags::BoundaryVariables. Such a list has exactly two entries, the first holding the volume variables.
template<typename Metavars>
constexpr bool	using_subcell_v = using_subcell<Metavars>::value
	If Metavars has a SubcellOptions member struct and SubcellOptions::subcell_enabled is true then is true, otherwise false.
template<typename BoundaryCondition>
constexpr bool	evolves_boundary_variables_v
	Whether a boundary condition evolves the system's boundary-evolved variables: the opt-in is the marker static constexpr bool evolves_boundary_variables = true; on the boundary condition. An opt-in boundary condition must declare the method boundary_field_time_derivatives.

Detailed Description

Functionality for evolving hyperbolic partial differential equations using the discontinuous Galerkin method.

Typedef Documentation

element_distribution_cache_tags

template<typename Metavariables, size_t Dim>

using evolution::dg::element_distribution_cache_tags

Initial value:

 tmpl::append<
    tmpl::list<domain::Tags::Domain<Dim>, domain::Tags::ElementDistribution>,
    tmpl::conditional_t<using_subcell_v<Metavariables>,
                        tmpl::list<Tags::UseSubcellGridPointsForDistribution,
                                   Tags::OnlyDgBlockIds<Dim>>,
                        tmpl::list<>>>

The global cache tags needed to distribute elements, for use as the const_global_cache_tags of a component that creates the elements.

The subcell-specific tags are only included for executables with DG-subcell support, since the options they are built from only exist there.

Enumeration Type Documentation

InterfaceDataPolicy

enum class evolution::dg::InterfaceDataPolicy : uint8_t

strong

Label for a neighboring Element (or Block) that determines how information is exchanged between neighboring Elements.

Details

The specific label is determined by the relationship between the block logical coordinates of the neighboring Elements (Blocks) for the points on the interface between them. In two cases there is a simple relationship between the coordinates:

• CopyProject: in this case the block logical coordinates are identical. Therefore a DataVector can be either copied (if the Mesh on each side of the interface are at the same points) or projected to the Mesh of the neighbor.
• OrientCopyProject: in this case the block logical coordinates are related by a discrete rotation (represented by an OrientationMap). Therefore a DataVector can be reoriented (with the OrientationMap), and then either copied or projected to the Mesh of the neighbor.

In the following cases, there is no simple relationship between the block logical coordinates. Therefore a DataVector must be interpolated to the points of the neighboring Mesh. The cases differ in which Element does the interpolation:

• NonconformingBothInterpolate: in this case both the Element and its neighbor interpolate data to the grid points of each others Mesh.
• NonconformingSelfInterpolates: in this case the Element will receive the neighbor's boundary data and will interpolate it to the Mesh of the Element. The Element will then need to send boundary correction data to the neighbor.
• NonconformingNeighborInterpolates: in this case the Element send its boundary data to the neighbor who will then interpolate it to its own Mesh. The neighbor will need to send boundary correction data back to the Element.

The Element and its neighbor will need to use consistent values of this enum:

• In the cases CopyProject, OrientCopyProject, and NonconformingBothInterpolate, neighboring elements should agree on the values.
• For NonconformingSelfInterpolates and NonconformingNeighborInterpolates neighboring elements should have different values. These cases should be used when one Element has many neighboring Elements (e.g. when a single spherical shell abuts a cubes sphere). In this case it should be more efficient for the single element to send its boundary data to its neighbors which then do the interpolation to their meshes.

Enumerator
Uninitialized	default value is uninitialized
CopyProject	Boundary data can be copied or projected to Mesh of neighbor.
OrientCopyProject	Boundary data should be reoriented, and then copied or projected to Mesh of neighbor.
NonconformingBothInterpolate	Boundary data should be interpolated to Mesh of neighbor.
NonconformingSelfInterpolates	Neighbor will send boundary data to be interpolated onto the Mesh of this Element. Boundary correction data will then need to be sent to the neighbor.
NonconformingNeighborInterpolates	Boundary data should be sent to the neighbor, who will interpolate the data to its own Mesh. The neighbor will send boundary correction data back.

TimeSteppingPolicy

enum class evolution::dg::TimeSteppingPolicy : uint8_t

strong

Treatment of time stepping across an element boundary.

Details

Indicates how boundary corrections should be handled for local time-stepping across a mortar. This controls the communication algorithm and data structures used.

Note

The code controlling the time step will not directly check this policy, but must be configured to make choices consistent with it.

Enumerator
Uninitialized	Default value is uninitialized.
EqualRate	The elements on the two sides of the mortar must have the same step size. Communicated boundary corrections will be added directly to the volume RHS calculation, and algorithms that are not local-time-stepping aware (such as subcell) can be used at this boundary. This is the only valid policy in a global time-stepping evolution.
Conservative	The elements on the two sides of the mortar may have different step sizes. A flux-conservative boundary integral will be performed to couple the elements.

Function Documentation

block_supports_subcell()

template<size_t Dim>

bool evolution::dg::block_supports_subcell

(

const Block< Dim > &

block

)

Returns whether the Block's topology is compatible with subcell.

Returns true only if every dimension of the Block has a topology for which domain::topology_supports_subcell is true, i.e. hypercubes and the cartoon topologies. Anything else, such as a spherical shell, returns false.

compute_only_dg_block_ids() [1/2]

template<size_t Dim>

std::vector< size_t > evolution::dg::compute_only_dg_block_ids	(	const std::optional< std::vector< std::string > > &	only_dg_block_and_group_names,
		const DomainCreator< Dim > &	domain_creator )

Returns the IDs of the Blocks on which only the DG scheme is allowed to run, i.e. that are not subcell-capable.

Convenience overload that builds the Domain from the domain_creator. If you already have a Domain, use the overload taking the blocks directly to avoid constructing a second one.

compute_only_dg_block_ids() [2/2]

template<size_t Dim>

std::vector< size_t > evolution::dg::compute_only_dg_block_ids	(	const std::optional< std::vector< std::string > > &	only_dg_block_and_group_names,
		const std::vector< std::string > &	block_names,
		const std::unordered_map< std::string, std::unordered_set< std::string > > &	block_groups,
		const std::vector< Block< Dim > > &	blocks )

Returns the IDs of the Blocks on which only the DG scheme is allowed to run, i.e. that are not subcell-capable.

This is the union of the blocks and groups listed in evolution::dg::OptionTags::OnlyDgBlocksAndGroups and the blocks whose topology does not support subcell (see block_supports_subcell).

Note

This is not inside the DgSubcell library so that it can be used by code (like the element distribution) that must not depend on DgSubcell.

compute_weighting_extents_override()

template<size_t Dim>

std::unordered_map< size_t, std::array< size_t, Dim > > evolution::dg::compute_weighting_extents_override	(	const std::vector< size_t > &	only_dg_block_ids,
		const std::vector< std::array< size_t, Dim > > &	initial_extents )

Returns the per-block extents to use in place of initial_extents when weighting subcell-capable elements by their finite-difference grid instead of their DG grid (see evolution::dg::Tags::UseSubcellGridPointsForDistribution).

For each block not in only_dg_block_ids, the returned extents are the number of finite-difference grid points \(2N-1\) corresponding to the \(N\) DG grid points in initial_extents, matching the subcell mesh built by evolution::dg::subcell::fd::mesh. Blocks in only_dg_block_ids are omitted from the returned map, since they always run on the DG grid.

p_project_geometric_data()

template<size_t Dim>

bool evolution::dg::p_project_geometric_data	(	gsl::not_null<::evolution::dg::MortarData< Dim > * >	mortar_data,
		const Mesh< Dim - 1 > &	new_face_mesh,
		const Mesh< Dim > &	new_volume_mesh )

Projects the geometric data (but not the data on the mortar grid) when p-refined.

Details

only updates the stored mesh if the corresponding data exists

Note

The DG-subcell code stores the face mesh in the MortarData even when the geometric data are not used. Currently projection of MortarData is only needed for local time-stepping which is not yet supported for DG-subcell.

Returns: If the data was modified

p_project_mortar_data()

template<size_t Dim>

bool evolution::dg::p_project_mortar_data	(	gsl::not_null<::evolution::dg::MortarData< Dim > * >	mortar_data,
		const Mesh< Dim - 1 > &	new_mortar_mesh )

Projects the mortar data (but not the geometric data) when p-refined.

Details

Used to re-project mortar data when the mortar mesh changes reactively after the neighbor face mesh is received. In this case, the geometric data does not need to be updated as it already used the correct face/volume mesh.

Returns: If the data was modified

receive_boundary_data()

template<bool UseNodegroupDgElements, typename Metavariables, bool LocalTimeStepping, bool DenseOutput, bool ComputeAuxiliary = false, typename DbTagsList, typename... InboxTags>

bool evolution::dg::receive_boundary_data	(	const gsl::not_null< db::DataBox< DbTagsList > * >	box,
		const gsl::not_null< tuples::TaggedTuple< InboxTags... > * >	inboxes )

Move boundary data from the inbox to the DataBox. Returns true if all necessary data has been received.

Setting DenseOutput to true receives data required for output at Tags::Time instead of Tags::Next<::Tags::TimeStepId>.

If LocalTimeStepping is true, it will process all data necessary for conservative LTS, otherwise it will process all data necessary for GTS. Some data for the other mode may also be processed to simplify the message handling.

weighting_extents_override_from_cache()

template<size_t Dim, typename Metavariables>

std::optional< std::unordered_map< size_t, std::array< size_t, Dim > > > evolution::dg::weighting_extents_override_from_cache	(	const Parallel::GlobalCache< Metavariables > &	cache,
		const std::vector< std::array< size_t, Dim > > &	initial_extents )

Reads element_distribution_cache_tags out of the cache and returns the weighting_extents_override to pass to Parallel::create_elements_using_distribution.

Always std::nullopt for executables without DG-subcell support, and for those with it whenever evolution::dg::Tags::UseSubcellGridPointsForDistribution is false.

Variable Documentation

is_atomic_inbox_boundary_data_v

template<typename T>

size_t evolution::dg::is_atomic_inbox_boundary_data_v

constexpr

Initial value:

=
    is_atomic_inbox_boundary_data<T>::value

true if T is a AtomicInboxBoundaryData

using_subcell_v

template<typename Metavars>

bool evolution::dg::using_subcell_v = using_subcell<Metavars>::value

constexpr

If Metavars has a SubcellOptions member struct and SubcellOptions::subcell_enabled is true then is true, otherwise false.

Note

This check is intentionally not inside the DgSubcell library so that executables that do not use subcell do not need to link against it.