Namespaces
namespace	Utilities

Classes
class	ABTimeIntegratorConstants

struct	AdaptiveMeshRefinementData

class	AdditiveSchwarzPreconditioner

struct	AMGData

class	AMTimeIntegratorConstants

class	BalancedGranularityPartitionPolicy

class	BDFTimeIntegratorConstants

class	BlockJacobiPreconditioner

class	BoundaryFaceIntegratorBase

class	BoundaryLayerManifold

class	CGSmoother

class	ChebyshevSmoother

class	CheckMultigrid

struct	CoarseGridData

class	CoarseGridSolverBase

class	ContainerInterfaceData

class	CubeMeshMovementFunctions

class	DealSpectrumWrapper

class	DeformedCubeManifold

class	DeformedMappingBase

class	DeformedMappingFunction

class	DivergenceCalculator

struct	EigenvalueTracker

struct	ErrorCalculationData

class	ErrorCalculator

class	ExplicitRungeKuttaTimeIntegrator

class	ExplicitTimeIntegrator

class	ExtrapolationConstants

struct	FunctionEvaluator

struct	FunctionEvaluator< 0, dim, Number >

struct	FunctionEvaluator< 1, dim, Number >

struct	FunctionEvaluator< 2, dim, Number >

class	FunctionWithNormal

struct	GeneralParameters

class	GMRESSmoother

class	Grid

struct	GridData

struct	GridParameters

class	HelpersALE

struct	HypercubeResolutionParameters

struct	IntegratorFlags

class	InterfaceCoupling

struct	Interpolator

struct	Interpolator< 0, dim, Number >

struct	Interpolator< 1, dim, Number >

class	InverseMassOperator

struct	InverseMassOperatorData

struct	InverseMassOperatorDataHdiv

class	InverseMassOperatorHdiv

struct	InverseMassParameters

struct	InverseMassParametersHdiv

class	InverseMassPreconditioner

class	JacobiPreconditioner

class	JacobiSmoother

class	KineticEnergyCalculator

struct	KineticEnergyData

class	KineticEnergySpectrumCalculator

struct	KineticEnergySpectrumData

class	lazy_ptr

class	LiftAndDragCalculator

struct	LiftAndDragData

class	LowStorageRK3Stage4Reg2C

class	LowStorageRK4Stage5Reg2C

class	LowStorageRK4Stage5Reg3C

class	LowStorageRK5Stage9Reg2S

class	LowStorageRKTD

class	MagnitudeCalculator

class	MappingDoFVector

struct	MappingFlags

class	MassKernel

class	MassOperator

struct	MassOperatorData

struct	MatrixFreeData

class	MeanScalarCalculator

class	MeasureMinimumTime

struct	MeshMovementData

class	MGCoarseAMG

class	MGCoarseChebyshev

class	MGCoarseKrylov

struct	MGDoFHandlerIdentifier

struct	MGLevelInfo

class	MultigridAlgorithm

struct	MultigridData

class	MultigridMappings

class	MultigridOperator

class	MultigridOperatorBase

class	MultigridPreconditionerBase

class	MultigridTransfer

class	MultigridTransferBase

class	MyCylindricalManifold

class	NormalFluxCalculator

struct	NormalFluxCalculatorData

class	OneSidedConicalManifold

class	OneSidedCylindricalManifold

class	OperatorBase

struct	OperatorBaseData

struct	OutputDataBase

class	OutputGenerator

struct	OutputParameters

struct	PointwiseOutputDataBase

class	PointwiseOutputGeneratorBase

class	PreconditionerAMG

class	PreconditionerBase

class	PressureDifferenceCalculator

struct	PressureDifferenceData

class	QCriterionCalculator

class	RectangleMeshMovementFunctions

struct	RestartData

class	RHSOperator

struct	RHSOperatorData

class	ShearRateCalculator

class	SmootherBase

struct	SmootherData

class	SolutionField

class	SolutionInterpolationBetweenTriangulations

class	SolutionTransfer

struct	SolverData

struct	SolverInfoData

struct	SolverResult

struct	SpatialResolutionParameters

struct	SpatialResolutionParametersMinMax

class	SSPRK

class	StatisticsManager

struct	TemporalResolutionParameters

struct	ThroughputParameters

class	TimeControl

struct	TimeControlData

struct	TimeControlDataStatistics

class	TimeControlStatistics

class	TimeIntAdamsBashforthMoultonBase

class	TimeIntBase

class	TimeIntBDFBase

class	TimeIntegratorConstantsBase

class	TimeIntExplRKBase

class	TimeIntGenAlphaBase

class	TimeIntMultistepBase

class	TimerTree

struct	TurbulentChannelData

class	VariableCoefficients

class	VelocityProjection

class	VorticityCalculator

Typedefs
typedef dealii::LinearAlgebra::distributed::Vector< float >	VectorTypeFloat

typedef dealii::LinearAlgebra::distributed::Vector< double >	VectorTypeDouble

Enumerations
enum class	TriangulationType { Serial , Distributed , FullyDistributed }

enum class	ElementType { Hypercube , Simplex }

enum class	PartitioningType { Metis , z_order }

enum class	MeshMovementAdvanceInTime { Undefined , SinSquared , Sin }

enum class	MeshMovementShape { Undefined , Sin , SineZeroAtBoundary , SineAligned }

enum class	SparseMatrixType { Undefined , Trilinos , PETSc }

enum class	RunType { RefineHAndP , FixedProblemSize , IncreasingProblemSize }

enum class	InverseMassType { MatrixfreeOperator , ElementwiseKrylovSolver , BlockMatrices }

enum class	PreconditionerMass { None , PointJacobi }

enum class	OperatorType { full , homogeneous , inhomogeneous }

enum class	SolutionFieldType { scalar , vector , cellwise }

enum class	MultigridType { Undefined , hMG , chMG , hcMG , cMG , pMG , cpMG , pcMG , hpMG , chpMG , hcpMG , hpcMG , phMG , cphMG , pchMG , phcMG }

enum class	PSequenceType { GoToOne , DecreaseByOne , Bisect , Manual }

enum class	MultigridSmoother { Chebyshev , GMRES , CG , Jacobi }

enum class	AMGType { ML , BoomerAMG }

enum class	MultigridCoarseGridSolver { Chebyshev , CG , GMRES , AMG }

enum class	MultigridCoarseGridPreconditioner { None , PointJacobi , BlockJacobi , AMG }

enum class	PreconditionerSmoother { None , PointJacobi , BlockJacobi , AdditiveSchwarz }

enum class	CFLConditionType { VelocityNorm , VelocityComponents }

enum class	GenAlphaType { Newmark , GenAlpha , HHTAlpha , BossakAlpha }

Functions
void	create_input_file (std::string const &input_file)

template<int dim, typename Number>
void	run (std::string const &input_file, unsigned int const degree, unsigned int const refine_space, unsigned int const refine_time, MPI_Comm const &mpi_comm, bool const is_test)

template<int dim, typename Number>
void	run (ThroughputParameters< Acoustics::OperatorType > const &throughput, std::string const &input_file, unsigned int const degree, unsigned int const refine_space, unsigned int const n_cells_1d, MPI_Comm const &mpi_comm, bool const is_test)

template<int dim, typename Number>
void	run (std::string const &input_file, MPI_Comm const &mpi_comm, bool const is_test)

template<int dim, typename Number>
void	run (ThroughputParameters< CompNS::OperatorType > const &throughput, std::string const &input_file, unsigned int const degree, unsigned int const refine_space, unsigned int const n_cells_1d, MPI_Comm const &mpi_comm, bool const is_test)

template<int dim, typename Number>
void	run (ThroughputParameters< ConvDiff::OperatorType > const &throughput, std::string const &input_file, unsigned int const degree, unsigned int const refine_space, unsigned int const n_cells_1d, MPI_Comm const &mpi_comm, bool const is_test)

template<int dim, typename Number>
Number	linear_interpolation_1d (double const &y, std::vector< Number > const &y_values, std::vector< dealii::Tensor< 1, dim, Number > > const &solution_values, unsigned int const &component)

template float	linear_interpolation_1d (double const &y, std::vector< float > const &y_values, std::vector< dealii::Tensor< 1, 2, float > > const &solution_values, unsigned int const &component)

template double	linear_interpolation_1d (double const &y, std::vector< double > const &y_values, std::vector< dealii::Tensor< 1, 2, double > > const &solution_values, unsigned int const &component)

template float	linear_interpolation_1d (double const &y, std::vector< float > const &y_values, std::vector< dealii::Tensor< 1, 3, float > > const &solution_values, unsigned int const &component)

template double	linear_interpolation_1d (double const &y, std::vector< double > const &y_values, std::vector< dealii::Tensor< 1, 3, double > > const &solution_values, unsigned int const &component)

template<int dim, typename Number>
Number	linear_interpolation_2d_cartesian (dealii::Point< dim > const &point, std::vector< Number > const &y_values, std::vector< Number > const &z_values, std::vector< dealii::Tensor< 1, dim, Number > > const &solution_values, unsigned int const &component)

template float	linear_interpolation_2d_cartesian (dealii::Point< 2 > const &point, std::vector< float > const &y_values, std::vector< float > const &z_values, std::vector< dealii::Tensor< 1, 2, float > > const &solution_values, unsigned int const &component)

template double	linear_interpolation_2d_cartesian (dealii::Point< 2 > const &point, std::vector< double > const &y_values, std::vector< double > const &z_values, std::vector< dealii::Tensor< 1, 2, double > > const &solution_values, unsigned int const &component)

template float	linear_interpolation_2d_cartesian (dealii::Point< 3 > const &point, std::vector< float > const &y_values, std::vector< float > const &z_values, std::vector< dealii::Tensor< 1, 3, float > > const &solution_values, unsigned int const &component)

template double	linear_interpolation_2d_cartesian (dealii::Point< 3 > const &point, std::vector< double > const &y_values, std::vector< double > const &z_values, std::vector< dealii::Tensor< 1, 3, double > > const &solution_values, unsigned int const &component)

template<int dim, typename Number>
Number	linear_interpolation_2d_cylindrical (Number const r_in, Number const phi, std::vector< Number > const &r_values, std::vector< Number > const &phi_values, std::vector< dealii::Tensor< 1, dim, Number > > const &solution_values, unsigned int const &component)

template float	linear_interpolation_2d_cylindrical (float const r_in, float const phi, std::vector< float > const &r_values, std::vector< float > const &phi_values, std::vector< dealii::Tensor< 1, 2, float > > const &solution_values, unsigned int const &component)

template double	linear_interpolation_2d_cylindrical (double const r_in, double const phi, std::vector< double > const &r_values, std::vector< double > const &phi_values, std::vector< dealii::Tensor< 1, 2, double > > const &solution_values, unsigned int const &component)

template float	linear_interpolation_2d_cylindrical (float const r_in, float const phi, std::vector< float > const &r_values, std::vector< float > const &phi_values, std::vector< dealii::Tensor< 1, 3, float > > const &solution_values, unsigned int const &component)

template double	linear_interpolation_2d_cylindrical (double const r_in, double const phi, std::vector< double > const &r_values, std::vector< double > const &phi_values, std::vector< dealii::Tensor< 1, 3, double > > const &solution_values, unsigned int const &component)

template<int dim, typename BoundaryDescriptor>
void	verify_boundary_conditions (BoundaryDescriptor const &boundary_descriptor, Grid< dim > const &grid)

template<int dim>
double	calculate_minimum_vertex_distance (dealii::Triangulation< dim > const &triangulation, dealii::Mapping< dim > const &mapping, MPI_Comm const &mpi_comm)

template<typename Number>
Number	calculate_characteristic_element_length (Number const element_volume, unsigned int const dim, ElementType const &element_type)

template<typename Number>
Number	calculate_high_order_element_length (Number const element_length, unsigned int const fe_degree, bool const is_dg)

template<int dim>
void	apply_deformed_cube_manifold (dealii::Triangulation< dim > &triangulation, double const left, double const right, double const deformation, unsigned int const frequency)

template<int dim>
ElementType	get_element_type (dealii::Triangulation< dim > const &tria)

template<int dim>
void	create_subdivided_hyper_rectangle (dealii::Triangulation< dim > &tria, std::vector< unsigned int > const &repetitions, dealii::Point< dim > const &p1, dealii::Point< dim > const &p2, ElementType const &element_type, bool const colorize=false)

template<int dim>
void	refine_local (dealii::Triangulation< dim > &tria, std::vector< unsigned int > const &vector_local_refinements)

template<int dim>
void	create_periodic_box (dealii::Triangulation< dim > &triangulation, unsigned int const n_refine_space, std::vector< dealii::GridTools::PeriodicFacePair< typename dealii::Triangulation< dim >::cell_iterator > > &periodic_faces, unsigned int const n_subdivisions, double const left, double const right, bool const curvilinear_mesh=false, double const deformation=0.1)

template<int dim, typename Number>
void	run (ThroughputParameters< IncNS::OperatorType > const &throughput, std::string const &input_file, unsigned int const degree, unsigned int const refine_space, unsigned int const n_cells_1d, MPI_Comm const &mpi_comm, bool const is_test)

bool	trigger_coarsening_and_refinement_now (unsigned int const trigger_every_n_time_steps, unsigned int const time_step_number)

template<int dim>
void	limit_coarsening_and_refinement (dealii::Triangulation< dim > &tria, AdaptiveMeshRefinementData const &amr_data)

template<int dim>
bool	any_cells_flagged_for_coarsening_or_refinement (dealii::Triangulation< dim > const &tria)

template<int dim, typename Number, typename VectorType>
void	mark_cells_kelly_error_estimator (dealii::Triangulation< dim > &tria, dealii::DoFHandler< dim > const &dof_handler, dealii::AffineConstraints< Number > const &constraints, dealii::Mapping< dim > const &mapping, VectorType const &solution, unsigned int const n_face_quadrature_points, AdaptiveMeshRefinementData const &amr_data)

template<int dim, typename Number>
void	add_hanging_node_and_periodicity_constraints (dealii::AffineConstraints< Number > &affine_constraints, Grid< dim > const &grid, dealii::DoFHandler< dim > const &dof_handler)

template<typename Key, typename Data>
void	fill_keys_of_map_into_set (std::set< Key > &set, std::map< Key, Data > const &map)

void	fill_map_bid_to_mask_with_default_mask (std::map< dealii::types::boundary_id, dealii::ComponentMask > &map_bid_to_mask, std::set< dealii::types::boundary_id > const &set_boundary_ids)

template<int dim, typename Number>
void	add_homogeneous_dirichlet_constraints (dealii::AffineConstraints< Number > &affine_constraints, dealii::DoFHandler< dim > const &dof_handler, std::map< dealii::types::boundary_id, dealii::ComponentMask > const &map_boundary_id_to_component_mask)

template<int dim>
std::shared_ptr< dealii::FiniteElement< dim > >	create_finite_element (ElementType const &element_type, bool const is_dg, unsigned int const n_components, unsigned int const degree)

unsigned int	get_dofs_per_element_simplex_scalar (unsigned int const n_points_1d, unsigned int const dim)

double	get_dofs_per_element (ExaDG::ElementType const element_type, bool const is_dg, unsigned int const n_components, unsigned int const degree, unsigned int const dim)

double	calculate_time_step_max_efficiency (double const h, unsigned int const fe_degree, unsigned int const order_time_integration)

double	calculate_const_time_step_diff (double const diffusivity, double const global_min_cell_diameter, unsigned int const fe_degree, double const exponent_fe_degree=3.0)

template<int dim>
double	calculate_max_velocity (dealii::Triangulation< dim > const &triangulation, std::shared_ptr< dealii::Function< dim > > velocity, double const time, MPI_Comm const &mpi_comm)

template<int dim, typename value_type>
double	calculate_time_step_cfl_local (dealii::MatrixFree< dim, value_type > const &data, unsigned int const dof_index, unsigned int const quad_index, std::shared_ptr< dealii::Function< dim > > const velocity, double const time, unsigned int const degree, double const exponent_fe_degree, CFLConditionType const cfl_condition_type, MPI_Comm const &mpi_comm)

template<int dim, typename value_type>
double	calculate_time_step_cfl_local (dealii::MatrixFree< dim, value_type > const &data, unsigned int const dof_index, unsigned int const quad_index, dealii::LinearAlgebra::distributed::Vector< value_type > const &velocity, unsigned int const degree, double const exponent_fe_degree, CFLConditionType const cfl_condition_type, MPI_Comm const &mpi_comm)

template<int dim, typename value_type>
void	calculate_cfl (dealii::LinearAlgebra::distributed::Vector< value_type > &cfl, dealii::Triangulation< dim > const &triangulation, dealii::MatrixFree< dim, value_type > const &data, unsigned int const dof_index, unsigned int const quad_index, dealii::LinearAlgebra::distributed::Vector< value_type > const &velocity, double const time_step, unsigned int const degree, double const exponent_fe_degree)

void	fill_resolutions_vector (std::vector< std::tuple< unsigned int, unsigned int, unsigned int > > &resolutions, unsigned int const dim, unsigned int const degree, double const dofs_per_element, dealii::types::global_dof_index const n_dofs_min, dealii::types::global_dof_index const n_dofs_max, RunType const &run_type, ElementType const &element_type)

template<int dim>
std::shared_ptr< dealii::Quadrature< dim > >	create_quadrature (ElementType const &element_type, unsigned int const n_q_points_1d)

double	measure_operator_evaluation_time (std::function< void(void)> const &evaluate_operator, unsigned int const degree, unsigned int const n_repetitions_inner, unsigned int const n_repetitions_outer, MPI_Comm const &mpi_comm)

template<int dim, int n_components, typename Number>
void	run (std::string const &input_file, MPI_Comm const &mpi_comm)

template<int dim, typename Number>
void	run (std::vector< SolverResult > &results, std::string const &input_file, unsigned int const degree, unsigned int const refine_space, MPI_Comm const &mpi_comm, bool const is_test)

template<int dim, typename Number>
void	run (ThroughputParameters< Poisson::OperatorType > const &throughput, std::string const &input_file, unsigned int const degree, unsigned int const refine_space, unsigned int const n_cells_1d, MPI_Comm const &mpi_comm, bool const is_test)

template<int dim, typename VectorType>
double	calculate_error (MPI_Comm const &mpi_comm, bool const &relative_error, dealii::DoFHandler< dim > const &dof_handler, dealii::Mapping< dim > const &mapping, VectorType const &numerical_solution, std::shared_ptr< dealii::Function< dim > > const analytical_solution, double const &time, dealii::VectorTools::NormType const &norm_type, bool const spatially_weight_error, std::shared_ptr< dealii::Function< dim > > const &weight, unsigned int const additional_quadrature_points=3)

template<int dim, typename Number>
void	apply_taylor_green_symmetry (dealii::DoFHandler< dim > const &dof_handler_symm, dealii::DoFHandler< dim > const &dof_handler, double const n_cells_1d, double const delta, const dealii::LinearAlgebra::distributed::Vector< Number > &vector_symm, dealii::LinearAlgebra::distributed::Vector< Number > &vector)

template<typename MeshType, typename Number>
void	initialize_dof_vector (dealii::LinearAlgebra::distributed::Vector< Number > &vec, const MeshType &dof_handler)

template<int dim, typename Number>
void	calculate_lift_and_drag_force (dealii::Tensor< 1, dim, Number > &Force, dealii::MatrixFree< dim, Number > const &matrix_free, unsigned int const dof_index_velocity, unsigned int const quad_index_velocity, unsigned int const dof_index_pressure, std::set< dealii::types::boundary_id > const &boundary_IDs, dealii::LinearAlgebra::distributed::Vector< Number > const &velocity, dealii::LinearAlgebra::distributed::Vector< Number > const &pressure, double const viscosity, MPI_Comm const &mpi_comm)

template<int dim, typename VectorType>
void	write_output (OutputDataBase const &output_data, dealii::DoFHandler< dim > const &dof_handler, dealii::Mapping< dim > const &mapping, VectorType const &solution_vector, unsigned int const output_counter, MPI_Comm const &mpi_comm)

template<int dim, typename Number>
void	my_point_value (dealii::Vector< Number > &result, dealii::Mapping< dim > const &mapping, dealii::DoFHandler< dim > const &dof_handler, dealii::LinearAlgebra::distributed::Vector< Number > const &dof_vector, typename dealii::DoFHandler< dim >::active_cell_iterator const &cell, dealii::Point< dim > const &point_in_ref_coord)

template<int dim, typename Number>
void	evaluate_scalar_quantity_in_point (Number &solution_value, dealii::DoFHandler< dim > const &dof_handler, dealii::Mapping< dim > const &mapping, dealii::LinearAlgebra::distributed::Vector< Number > const &numerical_solution, dealii::Point< dim > const &point, MPI_Comm const &mpi_comm, double const tolerance=1.e-10)

template<int dim, typename Number>
void	evaluate_vectorial_quantity_in_point (dealii::Tensor< 1, dim, Number > &solution_value, dealii::DoFHandler< dim > const &dof_handler, dealii::Mapping< dim > const &mapping, dealii::LinearAlgebra::distributed::Vector< Number > const &numerical_solution, dealii::Point< dim > const &point, MPI_Comm const &mpi_comm, double const tolerance=1.e-10)

template<int dim, typename Number>
std::vector< std::pair< std::vector< dealii::types::global_dof_index >, std::vector< Number > > >	get_dof_indices_and_shape_values (std::vector< std::pair< typename dealii::Triangulation< dim >::active_cell_iterator, dealii::Point< dim > > > const &adjacent_cells, dealii::DoFHandler< dim > const &dof_handler, dealii::Mapping< dim > const &mapping, dealii::LinearAlgebra::distributed::Vector< Number > const &solution)

TimeControlData::UnsteadyEvalType	get_unsteady_evaluation_type (TimeControlData const &data)

template<int dim>
void	write_surface_mesh (dealii::Triangulation< dim > const &triangulation, dealii::Mapping< dim > const &mapping, unsigned int const n_subdivisions, std::string const &folder, std::string const &file, unsigned int const counter, MPI_Comm const &mpi_comm)

template<int dim>
void	write_boundary_IDs (dealii::Triangulation< dim > const &triangulation, std::string const &folder, std::string const &file, MPI_Comm const &mpi_communicator)

template<int dim>
void	write_grid (dealii::Triangulation< dim > const &triangulation, dealii::Mapping< dim > const &mapping, unsigned int const n_subdivisions, std::string const &folder, std::string const &file, unsigned int const &counter, MPI_Comm const &mpi_comm)

template<int dim>
void	write_points (dealii::Triangulation< dim > const &triangulation, dealii::Mapping< dim > const &mapping, std::vector< dealii::Point< dim > > const &points, std::string const &folder, std::string const &file, unsigned int const counter, MPI_Comm const &mpi_comm)

template<int dim>
void	write_points_in_dummy_triangulation (std::vector< dealii::Point< dim > > const &points, std::string const &folder, std::string const &file, unsigned int const counter, MPI_Comm const &mpi_comm)

template<int dim, int spacedim>
std::unique_ptr< MPI_Comm, void()(MPI_Comm )>	create_subcommunicator (dealii::DoFHandler< dim, spacedim > const &dof_handler)

template<typename Number>
void	initialize_block_jacobi_matrices_with_zero (std::vector< dealii::LAPACKFullMatrix< Number > > &matrices)

template<typename Number>
void	calculate_lu_factorization_block_jacobi (std::vector< dealii::LAPACKFullMatrix< Number > > &matrices)

template<typename Operator, typename VectorType>
std::pair< double, double >	compute_eigenvalues (Operator const &op, VectorType const &inverse_diagonal, bool const operator_is_singular, unsigned int const eig_n_iter=10000)

template<typename Number>
void	invert_diagonal (dealii::LinearAlgebra::distributed::Vector< Number > &diagonal)

template<typename Number>
void	apply_function_in_double_precision (dealii::LinearAlgebra::distributed::Vector< Number > &dst, dealii::LinearAlgebra::distributed::Vector< Number > const &src, std::function< void(dealii::LinearAlgebra::distributed::Vector< double > &, dealii::LinearAlgebra::distributed::Vector< double > const &)> operation)

template<typename Operator, typename value_type>
void	verify_calculation_of_diagonal (Operator &op, dealii::LinearAlgebra::distributed::Vector< value_type > &diagonal, MPI_Comm const &mpi_comm)

template<int dim, typename Number>
void	run (ThroughputParameters< ExaDG::Structure::OperatorType > const &throughput, std::string const &input_file, unsigned int const degree, unsigned int const refine_space, unsigned int const n_cells_1d, MPI_Comm const &mpi_comm, bool const is_test)

template<typename VectorType>
void	compute_bdf_time_derivative (VectorType &derivative, VectorType const &solution_np, std::vector< VectorType const * > const &previous_solutions, BDFTimeIntegratorConstants const &bdf, double const &time_step_size)

template<typename VectorType>
void	compute_bdf_time_derivative (VectorType &derivative, VectorType const &solution_np, std::vector< VectorType > const &previous_solutions, BDFTimeIntegratorConstants const &bdf, double const &time_step_size)

template<typename VectorType>
void	compute_bdf_time_derivative (VectorType &derivative, std::vector< VectorType const * > const &previous_solutions_np, std::vector< double > const &times_np)

template<typename VectorType>
void	interpolate (VectorType &dst, double const &time, std::vector< VectorType const * > const &solutions, std::vector< double > const &times)

template<typename VectorType>
void	push_back (std::vector< VectorType > &vector)

std::string	restart_filename (std::string const &name, MPI_Comm const &mpi_comm)

void	rename_restart_files (std::string const &filename)

void	write_restart_file (std::ostringstream &oss, std::string const &filename)

template<typename VectorType>
void	print_vector_l2_norm (VectorType const &vector)

template<typename VectorType, typename BoostArchiveType>
void	read_write_distributed_vector (VectorType &vector, BoostArchiveType &archive)

void	limit_time_step_change (double &new_time_step, double const &last_time_step, double const &fac)

double	adjust_time_step_to_hit_end_time (double const start_time, double const end_time, double const time_step)

double	calculate_const_time_step (double const dt, unsigned int const n_refine_time)

void	create_directories (std::string const &directory, MPI_Comm const &mpi_comm)

	DeclExceptionMsg (ExcNotImplemented, "You are trying to use functionality in ExaDG that is " "currently not implemented. In many cases, this indicates " "that there simply didn't appear much of a need for it, or " "that the author of the original code did not have the " "time to implement a particular case. If you hit this " "exception, it is therefore worth the time to look into " "the code to find out whether you may be able to " "implement the missing functionality. If you do, please " "consider providing a patch to the ExaDG development " "sources (see the ExaDG Wiki page on how to contribute).")

std::tuple< bool, unsigned int >	identify_first_process_on_node (MPI_Comm const &mpi_comm)

template<typename ParameterType>
void	print_parameter (dealii::ConditionalOStream const &pcout, std::string const name, ParameterType const value)

void	print_name (dealii::ConditionalOStream const &pcout, std::string const name)

template<typename ParameterType>
void	print_value (dealii::ConditionalOStream const &pcout, ParameterType const value)

template<>
void	print_value (dealii::ConditionalOStream const &pcout, bool const value)

template<>
void	print_value (dealii::ConditionalOStream const &pcout, double const value)

template<>
void	print_value (dealii::ConditionalOStream const &pcout, bool const value)

template<>
void	print_value (dealii::ConditionalOStream const &pcout, double const value)

std::string	print_horizontal_line ()

void	print_write_output_time (double const time, unsigned int const counter, bool const unsteady, MPI_Comm const &mpi_comm)

void	print_exadg_header (dealii::ConditionalOStream const &pcout)

void	print_MPI_info (dealii::ConditionalOStream const &pcout, MPI_Comm const &mpi_comm)

void	print_dealii_info (dealii::ConditionalOStream const &pcout)

void	print_exadg_info (dealii::ConditionalOStream const &pcout)

template<typename Number>
std::string	get_type (Number)

std::string	get_type (float)

std::string	get_type (double)

template<typename Number>
void	print_matrixfree_info (dealii::ConditionalOStream const &pcout)

template<int dim>
void	print_grid_info (dealii::ConditionalOStream const &pcout, Grid< dim > const &grid)

template<typename Number>
void	print_general_info (dealii::ConditionalOStream const &pcout, MPI_Comm const &mpi_comm, bool const is_test)

void	print_throughput (std::vector< std::tuple< unsigned int, dealii::types::global_dof_index, double > > const &wall_times, std::string const &operator_type, MPI_Comm const &mpi_comm)

void	print_throughput_steady (dealii::ConditionalOStream const &pcout, dealii::types::global_dof_index const n_dofs, double const overall_time_avg, unsigned int const N_mpi_processes)

void	print_throughput_10 (dealii::ConditionalOStream const &pcout, dealii::types::global_dof_index const n_dofs, double const t_10, unsigned int const N_mpi_processes)

void	print_throughput_unsteady (dealii::ConditionalOStream const &pcout, dealii::types::global_dof_index const n_dofs, double const overall_time_avg, unsigned int const N_time_steps, unsigned int const N_mpi_processes)

void	print_throughput_unsteady (dealii::ConditionalOStream const &pcout, double const avg_n_dofs, double const overall_time_avg, unsigned int const N_time_steps, unsigned int const N_mpi_processes)

void	print_costs (dealii::ConditionalOStream const &pcout, double const overall_time_avg, unsigned int const N_mpi_processes)

void	print_solver_info_nonlinear (dealii::ConditionalOStream const &pcout, unsigned int const N_iter_nonlinear, unsigned int const N_iter_linear, double const wall_time)

void	print_solver_info_linear (dealii::ConditionalOStream const &pcout, unsigned int const N_iter_linear, double const wall_time)

void	print_wall_time (dealii::ConditionalOStream const &pcout, double const wall_time)

void	print_list_of_iterations (dealii::ConditionalOStream const &pcout, std::vector< std::string > const &names, std::vector< double > const &iterations_avg)

void	print_results (std::vector< SolverResult > const &results, MPI_Comm const &mpi_comm)

template<int n_components1, int n_components2, typename Number>
void	extract_component_from_tensors (dealii::Vector< Number > &dst, std::vector< dealii::Tensor< n_components1, n_components2, Number > > const &values, unsigned int const comp1, unsigned int const comp2)

template<int n_components, typename Number>
void	extract_component_from_tensors (dealii::Vector< Number > &dst, std::vector< dealii::Tensor< 1, n_components, Number > > const &values, unsigned int const comp)

template<int rank, int dim>
constexpr unsigned int	rank_to_n_components ()

template<int n_components, int dim>
constexpr unsigned int	n_components_to_rank ()

Detailed Description

This class provides information at which time steps a certain action should be triggered. It is typically used in postprocessing routines that shall not be invoked after every time step. The user can specify an evaluation interval in terms of number of time steps or an amount of time.

Function Documentation

◆ add_hanging_node_and_periodicity_constraints()

template<int dim, typename Number>

void ExaDG::add_hanging_node_and_periodicity_constraints	(	dealii::AffineConstraints< Number > &	affine_constraints,
		Grid< dim > const &	grid,
		dealii::DoFHandler< dim > const &	dof_handler )

This function adds hanging-node and periodicity constraints. This function combines these two types of constraints since deal.II requires to add these constraints in a certain order.

◆ add_homogeneous_dirichlet_constraints()

template<int dim, typename Number>

void ExaDG::add_homogeneous_dirichlet_constraints	(	dealii::AffineConstraints< Number > &	affine_constraints,
		dealii::DoFHandler< dim > const &	dof_handler,
		std::map< dealii::types::boundary_id, dealii::ComponentMask > const &	map_boundary_id_to_component_mask )

This function calls dealii::DoFTools::make_zero_boundary_constraints() for all boundary IDs with corresponding dealii::ComponentMask handed over to this function. This is necessary as a utility function in ExaDG, since deal.II does not allow to provide independent component masks for each boundary ID in a set of boundary IDs.

◆ any_cells_flagged_for_coarsening_or_refinement()

template<int dim>

bool ExaDG::any_cells_flagged_for_coarsening_or_refinement ( dealii::Triangulation< dim > const & tria )

Loop over cells and check for refinement/coarsening flags set.

◆ apply_function_in_double_precision()

template<typename Number>

void ExaDG::apply_function_in_double_precision	(	dealii::LinearAlgebra::distributed::Vector< Number > &	dst,
		dealii::LinearAlgebra::distributed::Vector< Number > const &	src,
		std::function< void(dealii::LinearAlgebra::distributed::Vector< double > &, dealii::LinearAlgebra::distributed::Vector< double > const &)>	operation )

Certain functionality of e.g. Trilinos is only available in double precision. The aim of this function is to hide this circumstance from the user code (that uses the template parameter Number) and to perform Number -> double conversions and then call the double-version of a certain Trilinos functionality.

◆ calculate_characteristic_element_length()

template<typename Number>

Number ExaDG::calculate_characteristic_element_length	(	Number const	element_volume,
		unsigned int const	dim,
		ElementType const &	element_type )

inline

This function calculates a characteristic element length given the volume of the element, the number of space dimensions, and the element type.

◆ calculate_high_order_element_length()

template<typename Number>

Number ExaDG::calculate_high_order_element_length	(	Number const	element_length,
		unsigned int const	fe_degree,
		bool const	is_dg )

inline

This function calculates a characteristic resolution limit for high-order Lagrange polynomials given a mesh size h. This one-dimensional resolution limit is calculated as the grid size divided by the number of nodes per coordinate direction. Hence, the result depends on the function space (H^1 vs. L^2).

◆ calculate_minimum_vertex_distance()

template<int dim>

double ExaDG::calculate_minimum_vertex_distance	(	dealii::Triangulation< dim > const &	triangulation,
		dealii::Mapping< dim > const &	mapping,
		MPI_Comm const &	mpi_comm )

inline

This function calculates the characteristic element length h defined as h = min_{e=1,...,N_el} h_e, where h_e is the minimum vertex distance of element e.

◆ create_directories()

void ExaDG::create_directories	(	std::string const &	directory,
		MPI_Comm const &	mpi_comm )

inline

Creates directories if not already existing. An MPI barrier ensures that directories have been created for all processes when completing this function.

◆ create_finite_element()

template<int dim>

std::shared_ptr< dealii::FiniteElement< dim > > ExaDG::create_finite_element	(	ElementType const &	element_type,
		bool const	is_dg,
		unsigned int const	n_components,
		unsigned int const	degree )

Creates and returns a shared pointer to dealii::FiniteElement<dim> depending on the element type, the type of function space, the number of components of the solution field, and the polynomial degree of the shape functions. Regarding the function space, the code assumes an H^1 conforming space (Continuous Galerkin) if is_dg (= L^2-conforming space, Discontinuous Galerkin) is false.

◆ create_quadrature()

template<int dim>

std::shared_ptr< dealii::Quadrature< dim > > ExaDG::create_quadrature	(	ElementType const &	element_type,
		unsigned int const	n_q_points_1d )

This function creates a Gauss-type quadrature rule depending on the ElementType and the number of one-dimensional quadrature points.

◆ create_subdivided_hyper_rectangle()

template<int dim>

void ExaDG::create_subdivided_hyper_rectangle	(	dealii::Triangulation< dim > &	tria,
		std::vector< unsigned int > const &	repetitions,
		dealii::Point< dim > const &	p1,
		dealii::Point< dim > const &	p2,
		ElementType const &	element_type,
		bool const	colorize = false )

This function wraps around dealii::GridGenerator::subdivided_hyper_rectangle() taking an additional argument ElementType.

◆ DeclExceptionMsg()

ExaDG::DeclExceptionMsg	(	ExcNotImplemented	,
		"You are trying to use functionality in ExaDG that is " "currently not implemented. In many	cases,
		this indicates " "that there simply didn 't appear much of a need for	it,
		or " "that the author of the original code did not have the " "time to implement a particular case. If you hit this " "	exception,
		it is therefore worth the time to look into " "the code to find out whether you may be able to " "implement the missing functionality. If you	do,
		please " "consider providing a patch to the ExaDG development " "sources(see the ExaDG Wiki page on how to contribute)."	)

The following exception is based on and motivated by dealii::ExcNotImplemented.

◆ extract_component_from_tensors() [1/2]

template<int n_components, typename Number>

void ExaDG::extract_component_from_tensors	(	dealii::Vector< Number > &	dst,
		std::vector< dealii::Tensor< 1, n_components, Number > > const &	values,
		unsigned int const	comp )

inline

Same as above for a Tensor with one column.

◆ extract_component_from_tensors() [2/2]

template<int n_components1, int n_components2, typename Number>

void ExaDG::extract_component_from_tensors	(	dealii::Vector< Number > &	dst,
		std::vector< dealii::Tensor< n_components1, n_components2, Number > > const &	values,
		unsigned int const	comp1,
		unsigned int const	comp2 )

inline

Extract a certain component of a list of tensors.

◆ fill_keys_of_map_into_set()

template<typename Key, typename Data>

void ExaDG::fill_keys_of_map_into_set	(	std::set< Key > &	set,
		std::map< Key, Data > const &	map )

inline

This utility function extracts the keys of a map provided as second argument and inserts these keys into the set provided as first argument.

◆ fill_map_bid_to_mask_with_default_mask()

void ExaDG::fill_map_bid_to_mask_with_default_mask	(	std::map< dealii::types::boundary_id, dealii::ComponentMask > &	map_bid_to_mask,
		std::set< dealii::types::boundary_id > const &	set_boundary_ids )

inline

This function inserts additional boundary IDs together with a default dealii::ComponentMask into map_bid_to_mask in case that the given boundary ID is not already an element of map_bid_to_mask.

◆ get_element_type()

template<int dim>

ElementType ExaDG::get_element_type ( dealii::Triangulation< dim > const & tria )

Returns the type of elements, where we currently only allow triangulations consisting of the same type of elements.

◆ limit_coarsening_and_refinement()

template<int dim>

void ExaDG::limit_coarsening_and_refinement	(	dealii::Triangulation< dim > &	tria,
		AdaptiveMeshRefinementData const &	amr_data )

Limit the coarsening and refinement by adapting the flags set in the triangulation. This considers the maximum and minimum refinement levels provided and might remove refinement flags set on the boundary if requested.

◆ read_write_distributed_vector()

template<typename VectorType, typename BoostArchiveType>

void ExaDG::read_write_distributed_vector	(	VectorType &	vector,
		BoostArchiveType &	archive )

inline

Utility function to read or write the local entries of a dealii::LinearAlgebra::distributed::(Block)Vector from/to a boost archive per block and entry. Using the & operator, loading from or writing to the archive is determined from the type.

◆ refine_local()

template<int dim>

void ExaDG::refine_local	(	dealii::Triangulation< dim > &	tria,
		std::vector< unsigned int > const &	vector_local_refinements )

This function performs local refinements on a given triangulation, where the number of local refinements is described by a vector containing the number of local refinements for each material id, i.e. vector[material_id] = n_local_refinements.

TODO: change the design of this function from a vector towards a map from material IDs to the number of local refinements.

◆ trigger_coarsening_and_refinement_now()

bool ExaDG::trigger_coarsening_and_refinement_now	(	unsigned int const	trigger_every_n_time_steps,
		unsigned int const	time_step_number )

inline

Check if adaptive mesh refinement should be triggered depending on the time_step_number.

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Function Documentation

◆ add_hanging_node_and_periodicity_constraints()

◆ add_homogeneous_dirichlet_constraints()

◆ any_cells_flagged_for_coarsening_or_refinement()

◆ apply_function_in_double_precision()

◆ calculate_characteristic_element_length()

◆ calculate_high_order_element_length()

◆ calculate_minimum_vertex_distance()

◆ create_directories()

◆ create_finite_element()

◆ create_quadrature()

◆ create_subdivided_hyper_rectangle()

◆ DeclExceptionMsg()

◆ extract_component_from_tensors() [1/2]

◆ extract_component_from_tensors() [2/2]

◆ fill_keys_of_map_into_set()

◆ fill_map_bid_to_mask_with_default_mask()

◆ get_element_type()

◆ limit_coarsening_and_refinement()

◆ read_write_distributed_vector()

◆ refine_local()

◆ trigger_coarsening_and_refinement_now()