fub Namespace Reference

The fub namespace. More...

Namespaces
	amrex
	The amrex namespace.
	euler
	execution
	ideal_gas
	meta
	The meta namespace.
	perfect_gas
	perfect_gas_mix
	samrai

Classes
class	AnyBoundaryCondition
	This is a polymorphic value type that wraps any BoundaryCondition object. More...
class	AnyInitialData
	This class is a polymoprhic value type which stores components to initialize a gridding algorithm during its initialization procedure. More...
struct	TaggingMethodStrategy_
class	AnyTaggingMethod
	This class is a polymorphic value type that stores objects which satisfies the TaggingMethod<GriddingAlgorithm> concept. More...
struct	TaggingMethodWrapper_
class	CartesianCoordinates
	This class handles uniform cartesian cell coordinates. More...
struct	CompleteFromConsFn
struct	CutCellData
struct	Location
struct	EinfeldtSignalVelocities
	This is a customization point for equations which can define two signal velocities for usage with the HllMethod. More...
struct	HasScalarFlux
struct	HasVectorizedFlux
struct	HasScalarReconstruction
struct	HasVectorizedReconstruction
struct	HasReconstruction
class	ExactRiemannSolver
class	AnyReconstruction
	This is a polymorphic wrapper class for reconstruction strategies used by IntegratorContext. More...
class	AnyTimeIntegrator
	This is a polymorphic wrapper class for TimeIntegator strategies used by IntegratorContext. More...
class	AnyFluxMethod
	This is a polymorphic wrapper class for FluxMethod strategies used by IntegratorContext. More...
struct	HyperbolicMethod
struct	HyperbolicPatchIntegrator
struct	GridTraits
struct	IndexBox
struct	PatchDataView
struct	PatchDataViewBase
struct	PatchDataViewBase< const T, Rank, Layout >
struct	RunOptions
struct	StateTraits
struct	NumVariables
struct	ScalarDepth
	This type is used to tag scalar quantities. More...
struct	VectorDepth
	This type is used to tag quantities with a depth known at compile time. More...
struct	ToConcreteDepthImpl
struct	ToConcreteDepthImpl< VectorDepth<-1 > >
struct	Type
struct	DepthsFn
struct	ScalarState
struct	StateTraits< ScalarState< Depths > >
struct	Conservative
	This type has a constructor which takes an equation and might allocate any dynamically sized member variable. More...
struct	StateTraits< Conservative< Eq > >
struct	Primitive
struct	StateTraits< Primitive< Eq > >
struct	KineticState
struct	StateTraits< KineticState< Eq > >
struct	Characteristics
struct	StateTraits< Characteristics< Eq > >
struct	Complete
	This type has a constructor which takes an equation and might allocate any dynamically sized member variable. More...
struct	StateTraits< Complete< Eq > >
struct	BasicView
struct	StateTraits< BasicView< S, L, R > >
struct	IsView
struct	IsView< BasicView< State, Layout, Rank > >
struct	ViewPointer
struct	StateTraits< ViewPointer< State > >
struct	IndexMapping
struct	StateTraits< IndexMapping< Eq > >
struct	ArrayState
struct	StateTraits< ArrayState< Depths, Width > >
struct	PrimitiveArray
struct	StateTraits< PrimitiveArray< Eq, Width > >
struct	CharacteristicsArray
struct	KineticStateArray
struct	StateTraits< KineticStateArray< Eq, Width > >
struct	StateTraits< CharacteristicsArray< Eq, Width > >
struct	ConservativeArray
struct	StateTraits< ConservativeArray< Eq, Width > >
struct	CompleteArray
struct	StateTraits< CompleteArray< Eq, Width > >
struct	DepthToRowType
struct	DepthToRowType< T, ScalarDepth >
struct	RowBaseImpl
struct	RowBaseImpl< const State >
struct	Row
struct	StateTraits< Row< State > >
struct	ToStride
struct	ToRow
class	TimeStepErrcCategory
struct	TimeStepTooLarge
class	AsOutput
class	AnyOutput
struct	BasicOutput
	This is a abstract base class for an output strategy. More...
class	CounterOutput
struct	H5Handle
struct	H5Fdeleter
struct	H5Sdeleter
struct	H5Ddeleter
struct	H5Adeleter
struct	H5Pdeleter
class	MultipleOutputs
class	OutputAtFrequencyOrInterval
class	OutputFactory
class	FluxMethod
	This class applies a base flux nethod on a view of states. More...
class	Godunov
struct	GodunovMethod
struct	NoLimiter2
struct	UpwindLimiter
struct	MinModLimiter
struct	VanLeerLimiter
class	CentralDifferenceGradient
class	ConservativeGradient
class	PrimitiveGradient
class	CharacteristicsGradient
class	HllBase
class	HllArrayBase
class	HllArrayBase< Equation, SignalSpeeds, true >
class	HllArrayBase< Equation, SignalSpeeds, false >
class	Hll
struct	HllMethod
struct	NoLimiter
struct	NoGradient
struct	MinMod
struct	VanLeer
struct	MusclHancock
struct	MusclHancockMethod
struct	MusclHancock2
class	ConservativeReconstruction
class	PrimitiveReconstruction
class	CharacteristicsReconstruction
class	GradientDetectorBase_
class	ScalarGradientDetector_
class	ArrayGradientDetector_
struct	GradientDetectorImpl_
struct	GradientDetectorImpl_< false, Eq, Ps... >
struct	GradientDetector
	This class tags cells with a relative error to their neighbors. More...
struct	TagBuffer
struct	TagCutCells
struct	NoBoundary
class	ReflectiveBoundary
struct	TransmissiveBoundary
struct	LogOptions
class	OmpLocal
class	Timer
class	function_ref
	An efficient, type-erasing, non-owning reference to a callable. More...
struct	IsInvocable
class	function_ref< Ret(Params...)>
	An efficient, type-erasing, non-owning reference to a callable. More...
class	basic_mdarray
class	ExtentsStorage_
	This is the storage type for the extents class and only takes storage for dynamic extents. More...
class	ExtentsStorage_< Rank, 0, StaticExtents... >
	This is the class template specialisation if all extents are statically known. More...
class	ExtentsStorage_< Rank, Rank, StaticExtents... >
class	extents
	An extents object defines a multidimensional index space which is the Cartesian product of integers extents [0..N0) * [0..N1) * ... More...
struct	is_extents
	This is true std::true_type iff E is extents<Es...> for some std::ptrdiff_t... More...
struct	is_extents< extents< StaticExtents... > >
struct	layout_left
	This layout creates mappings which do row first indexing (as in Fortran). More...
struct	layout_right
struct	layout_stride
struct	accessor_basic
class	basic_mdspan
struct	dynamic_extents_
struct	dynamic_extents_< integer_sequence< I, Is... > >
struct	all_type
struct	mdspan_subspan
struct	is_mdspan
struct	is_mdspan< basic_mdspan< T, E, L, A > >
class	span
	A span is a view over a contiguous sequence of objects, the storage of which is owned by some other object. More...
struct	is_span
	Returns true if the specified T is a span<S, N> for some type S and integer N. More...
struct	is_span< span< T, N > >
	Returns true if the specified T is a span<S, N> for some type S and integer N. More...
class	span< T, 0 >
	A span is a view over a contiguous sequence of objects, the storage of which is owned by some other object. More...
class	span< T, dynamic_extent >
	span is a compact view over a contiguous range of data. More...
struct	nodeduce
struct	nonesuch
struct	is_detected
	This is std::true_type if Op<Args...> is a valid SFINAE expression. More...
struct	detected_or
	Returns the type of Op<Args...> or Default More...
struct	is_detected_exact
	This is std::true_type if Op<Args...> is a valid SFINAE expression and the return type is exactly Expected. More...
struct	conjunction
struct	conjunction< B1 >
struct	conjunction< B1, Bn... >
struct	disjunction
struct	disjunction< B1 >
struct	disjunction< B1, Bn... >
struct	integer_sequence
struct	MakeIntegerSequence_
struct	MakeIntegerSequence_< T, N, N, Ints... >
struct	invoke_result
	This is std::true_type if F is a function type and can be invoked with arguments of types Args.... More...
struct	is_invocable
	This is std::true_type if a given object f of type T is callable by fub::invoke(f, args...) for Args... More...
struct	remove_cvref
	This is equivalent to std::remove_cv_t<std::remove_reference_t<T>>. More...
struct	value_type
struct	is_equality_comparable_impl
struct	is_equality_comparable
	This is std::true_type if T and S are equality comparable. More...
struct	is_nothrow_equality_comparable
	This is std::true_type if T and S are nothrow equality comparable. More...
struct	is_regular
	This type trait checks if a specified type T fulfills the Regular concept. More...
struct	overloaded
struct	is_tag_invocable
struct	is_nothrow_tag_invocable
class	DimensionalSplitLevelIntegrator
	This Level Integrator applies a very general AMR integration scheme in context of dimensional splitting. More...
class	NoSubcycleSolver
	This is a solver class which does a AMR integration scheme without subcycling on finer levels. More...
class	SolverFacade
class	SplitSystemSourceLevelIntegrator
class	SubcycleFineFirstSolver
	This Level Integrator applies a very general AMR integration scheme in context of dimensional splitting. More...
class	KbnCutCellMethod
struct	BasicHGridReconstruction
struct	ConservativeHGridReconstruction
class	MyCutCellMethod
struct	AdvectionVariables
struct	StateTraits< AdvectionVariables< Xs... > >
struct	Advection2d
	This class descibes the 2-dimensional advection equation with constant transport velocity. More...
class	ExactRiemannSolver< Advection2d >
struct	BurgersVariables
struct	StateTraits< BurgersVariables< Xs... > >
struct	Burgers1d
class	ExactRiemannSolver< Burgers1d >
struct	CompressibleAdvectionConservative
	This is a template class for constructing conservative states for the perfect gas equations. More...
struct	StateTraits< CompressibleAdvectionConservative< Xs... > >
struct	CompressibleAdvectionComplete
struct	StateTraits< CompressibleAdvectionComplete< Xs... > >
struct	CompressibleAdvection
struct	CompressibleAdvectionFluxMethod
	This is a special FluxMethod class that uses the stored Pv field within the CompressibleAdvectionIntegratorContext sa advection velocities. More...
struct	IdealGasMixConservative
	This is a template class for constructing conservative states for the perfect gas equations. More...
struct	StateTraits< IdealGasMixConservative< Xs... > >
struct	IdealGasMixComplete
struct	StateTraits< IdealGasMixComplete< Xs... > >
class	IdealGasMix
struct	PerfectGas
struct	PerfectGasConservative
	This is a template class for constructing conservative states for the perfect gas equations. More...
struct	StateTraits< PerfectGasConservative< Xs... > >
struct	PerfectGasPrimitive
struct	StateTraits< PerfectGasPrimitive< Xs... > >
struct	PerfectGasCharacteristics
struct	StateTraits< PerfectGasCharacteristics< Xs... > >
struct	PerfectGasComplete
struct	StateTraits< PerfectGasComplete< Xs... > >
struct	PerfectGasMix
struct	PerfectGasMixConservative
	This is a template class for constructing conservative states for the perfect gas equations. More...
struct	StateTraits< PerfectGasMixConservative< Xs... > >
struct	PerfectGasMixPrimitive
struct	StateTraits< PerfectGasMixPrimitive< Xs... > >
struct	PerfectGasMixKineticState
struct	StateTraits< PerfectGasMixKineticState< Xs... > >
struct	PerfectGasMixCharacteristics
struct	StateTraits< PerfectGasMixCharacteristics< Xs... > >
struct	PerfectGasMixComplete
struct	StateTraits< PerfectGasMixComplete< Xs... > >
struct	ShallowWaterVariables
struct	StateTraits< ShallowWaterVariables< Xs... > >
struct	ShallowWater
class	ExactRiemannSolver< ShallowWater >
struct	ShallowWaterSignalVelocities
struct	EinfeldtSignalVelocities< IdealGasMix< Dim > >
class	FlameMasterReactorException
	This class encapsulates all exceptions which can occur in the FlameMasterReactor class. More...
struct	FlameMasterMechanism
	This abstract base class encapsulates the underlying chemistry for the FlameMasterReactor. More...
struct	FlameMasterState
struct	FlameMasterArrayState
class	FlameMasterReactor
	A class mimicking the IdealGasMix / Reactor / ReactorNet interface of Cantera, but with FlameMaster chemistry. More...
struct	EinfeldtSignalVelocities< PerfectGas< Dim > >
class	ExactRiemannSolver< PerfectGas< Dim > >
class	Ambient
class	Ball
class	ConeIF
class	ExpandTube
struct	Geometry
class	Halfspace
class	Invert
class	Polygon
struct	GeometryWrapper
class	PolymorphicGeometry
class	RotateAxis
class	PolymorphicUnion
struct	GridTraits< amrex::GriddingAlgorithm >
struct	GridTraits< amrex::cutcell::GriddingAlgorithm >
struct	RequireMassflow_Jirasek
	Compute the new complete state from the old complete state to enforce the required massflow. More...
struct	RequireMassflow_SolveExactRiemannProblem
	Compute the new complete state from the old complete state to enforce the required massflow. More...
class	CounterOutput< amrex::MultiBlockGriddingAlgorithm, PrintDuration >
class	CounterOutput< amrex::MultiBlockGriddingAlgorithm2, PrintDuration >
struct	GridTraits< samrai::GriddingAlgorithm >

Typedefs
template<typename Eq , typename... Args>
using	CompleteFromConsMemberFunction = decltype(std::declval< Eq >().CompleteFromCons(std::declval< Args >()...))
using	Duration = std::chrono::duration< double >
template<typename Eq , typename... Args>
using	FluxT = decltype(std::declval< Eq >().Flux(std::declval< Args >()...))
template<typename Eq >
using	ScalarFluxT = decltype(std::declval< const Eq & >().Flux(std::declval< Conservative< Eq > & >(), std::declval< const Complete< Eq > & >(), Direction::X))
template<typename Eq , typename N = int_constant<kDefaultChunkSize>>
using	VectorizedFluxT = decltype(std::declval< const Eq & >().Flux(std::declval< ConservativeArray< Eq, N::value > & >(), std::declval< const CompleteArray< Eq, N::value > & >(), Direction::X))
template<typename Eq >
using	ScalarReconstructT = decltype(std::declval< const Eq & >().Reconstruct(std::declval< Complete< Eq > & >(), std::declval< const Conservative< Eq > & >()))
template<typename Eq , typename N = int_constant<kDefaultChunkSize>>
using	VectorizedReconstructT = decltype(std::declval< const Eq & >().Reconstruct(std::declval< CompleteArray< Eq, N::value > & >(), std::declval< const ConservativeArray< Eq, N::value > & >()))
template<typename Tag , typename T >
using	Local = typename detail::LocalType< Tag, T >::type
template<int Rank>
using	Index = std::array< std::ptrdiff_t, static_cast< std::size_t >(Rank)>
template<typename T , int Rank>
using	StridedDataView = PatchDataView< T, Rank, layout_stride >
template<typename Depth >
using	ToConcreteDepth = typename ToConcreteDepthImpl< Depth >::type
template<typename Depths >
using	ToConcreteDepths = boost::mp11::mp_transform< ToConcreteDepth, Depths >
template<typename Depths >
using	ScalarStateBase = boost::mp11::mp_transform< detail::DepthToStateValueType, Depths >
template<typename Equation >
using	ConservativeBase = boost::mp11::mp_transform< detail::DepthToStateValueType, typename Equation::ConservativeDepths >
	This type alias transforms state depths into a conservative state associated with a specified equation. More...
template<typename Equation >
using	CompleteBase = boost::mp11::mp_transform< detail::DepthToStateValueType, typename Equation::CompleteDepths >
template<typename State , typename Layout , int Rank>
using	ViewBase = typename detail::ViewBaseImpl< State, Layout, Rank >::type
template<typename State , int Rank = State::Equation::Rank()>
using	View = BasicView< State, layout_stride, Rank >
template<typename State >
using	ViewPointerBase = typename detail::ViewPointerBaseImpl< State >::type
template<typename Equation >
using	IndexMappingBase = boost::mp11::mp_transform< detail::DepthToIndexMappingType, typename Equation::CompleteDepths >
template<typename Depths , int Width>
using	ArrayStateBase = typename detail::ArrayStateBaseImpl< Depths, Width >::type
template<typename Eq , int Width = kDefaultChunkSize>
using	ConservativeArrayBase = typename detail::ConservativeArrayBaseImpl< Eq, Width >::type
template<typename Eq , int Width>
using	CompleteArrayBase = typename detail::CompleteArrayBaseImpl< Eq, Width >::type
template<typename State >
using	RowBase = typename RowBaseImpl< State >::type
using	H5File = H5Handle< H5Fdeleter >
using	H5Space = H5Handle< H5Sdeleter >
using	H5Dataset = H5Handle< H5Ddeleter >
using	H5Attribute = H5Handle< H5Adeleter >
using	H5Properties = H5Handle< H5Pdeleter >
template<typename FM , typename... Args>
using	HasComputeNumericFluxType = decltype(std::declval< FM >().ComputeNumericFlux(std::declval< Args >()...))
template<typename FM , typename... Args>
using	HasComputeNumericFlux = is_detected< HasComputeNumericFluxType, FM, Args... >
template<typename Proj , typename State >
using	Projection_t = decltype(std::invoke(std::declval< Proj >(), std::declval< State >()))
template<typename Proj , typename State >
using	IsProjection = is_detected< Projection_t, Proj, State >
template<typename T , int N, int M = kDefaultChunkSize>
using	Array = std::conditional_t< N==1||M==1, Eigen::Array< T, N, M >, Eigen::Array< T, N, M, Eigen::RowMajor > >
using	Array1d = Array< double, 1 >
using	Array2d = Array< double, 2 >
using	Array3d = Array< double, 3 >
using	ArrayXd = Array< double, Eigen::Dynamic >
using	MaskArray = Array< bool, 1 >
using	SeverityLogger = boost::log::sources::severity_logger< boost::log::trivial::severity_level >
template<typename T , typename E >
using	Result = boost::outcome_v2::result< T, E >
using	ProgramOptions = std::map< std::string, pybind11::object >
template<typename F , typename... Args>
using	IsInvocableT_ = decltype(std::declval< F >()(std::declval< Args >()...))
template<typename ValueType , typename... Is>
using	mdarray = basic_mdarray< ValueType, extents< Is... >, layout_left, std_vector_policy >
template<typename ValueType , std::ptrdiff_t Rank>
using	dynamic_mdarray = basic_mdarray< ValueType, dynamic_extents< Rank >, layout_left, std_vector_policy >
template<typename T , ptrdiff_t... Extents>
using	static_mdspan = basic_mdspan< T, extents< Extents... > >
template<std::size_t Rank>
using	dynamic_extents = typename dynamic_extents_< make_index_sequence< Rank > >::type
template<typename T , std::size_t Rank, typename Layout = layout_left>
using	mdspan = basic_mdspan< T, dynamic_extents< Rank >, Layout >
template<typename T , typename E , typename A = accessor_basic<T>>
using	strided_mdspan = basic_mdspan< T, E, layout_stride, A >
template<class ElementType , class Extents , class LayoutPolicy , class AccessorPolicy , class... SliceSpecifiers>
using	mdspan_subspan_t = typename mdspan_subspan< ElementType, Extents, LayoutPolicy, AccessorPolicy, SliceSpecifiers... >::type
using	byte = unsigned char
template<class... >
using	void_t = void
template<typename T >
using	nodeduce_t = typename nodeduce< T >::type
template<template< class... > class Op, class... Args>
using	detected_t = detail::detected_t< Op, Args... >
	Returns the type of Op<Args...> or nonesuch More...
template<class Bool >
using	negation = std::integral_constant< bool, !bool(Bool::value)>
template<std::size_t... Is>
using	index_sequence = integer_sequence< std::size_t, Is... >
template<typename T , T N>
using	make_integer_sequence = typename MakeIntegerSequence_< T, N, T{0}>::type
template<std::size_t N>
using	make_index_sequence = make_integer_sequence< std::size_t, N >
using	index = std::ptrdiff_t
template<bool Bool>
using	bool_constant = std::integral_constant< bool, Bool >
template<index I>
using	index_constant = std::integral_constant< index, I >
template<int I>
using	int_constant = std::integral_constant< int, I >
template<std::size_t I>
using	size_constant = std::integral_constant< std::size_t, I >
template<typename T >
using	remove_cvref_t = typename remove_cvref< T >::type
template<typename Var >
using	value_type_t = typename value_type< Var >::type
template<typename X , typename Y >
using	decays_to = std::is_same< std::decay_t< X >, Y >
template<typename _Tag , typename... _Args>
using	tag_invoke_result = invoke_result< decltype(fub::meta::tag_invoke), _Tag, _Args... >
template<typename _Tag , typename... _Args>
using	tag_invoke_result_t = invoke_result_t< decltype(fub::meta::tag_invoke), _Tag, _Args... >
template<auto & T>
using	tag_t = std::decay_t< decltype(T)>
template<int Rank>
using	Coordinates = Eigen::Matrix< double, Rank, 1 >
template<int VelocityRank>
using	CompressibleAdvectionConsShape = CompressibleAdvectionConservative< ScalarDepth, VectorDepth< VelocityRank >, ScalarDepth >
template<int VelocityRank>
using	CompressibleAdvectionCompleteShape = CompressibleAdvectionComplete< ScalarDepth, VectorDepth< VelocityRank >, ScalarDepth, ScalarDepth >
template<int Rank>
using	IdealGasConservativeShape = IdealGasMixConservative< ScalarDepth, VectorDepth< Rank >, ScalarDepth, VectorDepth<-1 > >
template<int Rank>
using	IdealGasMixCompleteShape = IdealGasMixComplete< ScalarDepth, VectorDepth< Rank >, ScalarDepth, VectorDepth<-1 >, ScalarDepth, ScalarDepth, ScalarDepth, ScalarDepth, ScalarDepth >
template<int Rank>
using	PerfectGasConsShape = PerfectGasConservative< ScalarDepth, VectorDepth< Rank >, ScalarDepth >
template<int Rank>
using	PerfectGasPrimShape = PerfectGasPrimitive< ScalarDepth, VectorDepth< Rank >, ScalarDepth >
template<int Rank>
using	PerfectGasCharShape = PerfectGasCharacteristics< ScalarDepth, VectorDepth< Rank >, ScalarDepth >
template<int Rank>
using	PerfectGasCompleteShape = PerfectGasComplete< ScalarDepth, VectorDepth< Rank >, ScalarDepth, ScalarDepth, ScalarDepth >
template<int Rank>
using	PerfectGasMixConsShape = PerfectGasMixConservative< ScalarDepth, VectorDepth< Rank >, ScalarDepth, VectorDepth<-1 > >
template<int Rank>
using	PerfectGasMixPrimShape = PerfectGasMixPrimitive< ScalarDepth, VectorDepth< Rank >, ScalarDepth, VectorDepth<-1 > >
using	PerfectGasMixKineticStateShape = PerfectGasMixKineticState< ScalarDepth, ScalarDepth, VectorDepth<-1 > >
template<int Rank>
using	PerfectGasMixCharShape = PerfectGasMixCharacteristics< ScalarDepth, VectorDepth< Rank >, ScalarDepth, VectorDepth<-1 > >
template<int Rank>
using	PerfectGasMixCompleteShape = PerfectGasMixComplete< ScalarDepth, VectorDepth< Rank >, ScalarDepth, VectorDepth<-1 >, ScalarDepth, ScalarDepth >
template<typename F , typename... Args>
using	invoke_result_t = typename invoke_result< F, Args... >::type

Enumerations
enum class	Direction : std::size_t { X , Y , Z }
	This is a type safe type to denote a dimensional split direction. More...
enum class	Side : int { Lower , Upper }
	This is a type safe type to denote a side. More...
enum class	TimeStepErrc { success , time_step_too_large }

Functions
int	GetSign (int side)
template<typename Equation >
void	CompleteFromCons (Equation &&equation, Complete< std::decay_t< Equation >> &complete, const Conservative< std::decay_t< Equation >> &cons)
template<typename Equation >
void	CompleteFromCons (Equation &&equation, Complete< std::decay_t< Equation >> &complete, const Complete< std::decay_t< Equation >> &cons)
template<typename Equation >
void	CompleteFromCons (Equation &&equation, CompleteArray< std::decay_t< Equation >> &complete, const ConservativeArray< std::decay_t< Equation >> &cons)
template<typename Equation >
void	CompleteFromCons (Equation &&equation, CompleteArray< std::decay_t< Equation >> &complete, const ConservativeArrayBase< std::decay_t< Equation >> &cons, MaskArray mask)
template<typename Equation >
void	CompleteFromCons (Equation &&equation, CompleteArray< std::decay_t< Equation >> &complete, const CompleteArray< std::decay_t< Equation >> &cons)
template<typename Equation >
void	CompleteFromCons (Equation &&eq, const View< Complete< std::decay_t< Equation >>> &complete_view, const View< const Conservative< std::decay_t< Equation >>> &cons_view)
std::array< double, 2 >	Intersect (const std::array< double, 2 > &i1, const std::array< double, 2 > &i2)
bool	IsCutCell (const CutCellData< 2 > &geom, const std::array< std::ptrdiff_t, 2 > &index)
bool	IsCutCell (const CutCellData< 3 > &geom, const std::array< std::ptrdiff_t, 3 > &index)
Eigen::Vector2d	GetBoundaryNormal (const CutCellData< 2 > &ccdata, const std::array< std::ptrdiff_t, 2 > &index)
Eigen::Vector3d	GetBoundaryNormal (const CutCellData< 3 > &ccdata, const std::array< std::ptrdiff_t, 3 > &index)
Eigen::Vector2d	GetBoundaryCentroid (const CutCellData< 2 > &ccdata, const std::array< std::ptrdiff_t, 2 > &index)
Eigen::Vector3d	GetBoundaryCentroid (const CutCellData< 3 > &ccdata, const std::array< std::ptrdiff_t, 3 > &index)
Eigen::Vector2d	GetVolumeCentroid (const CutCellData< 2 > &ccdata, const std::array< std::ptrdiff_t, 2 > &index)
Eigen::Vector3d	GetVolumeCentroid (const CutCellData< 3 > &ccdata, const std::array< std::ptrdiff_t, 3 > &index)
Eigen::Vector2d	GetUnshieldedCentroid (const CutCellData< 2 > &geom, const Index< 2 > &face, const Eigen::Vector2d &dx, Direction dir)
template<std::size_t Rank>
Eigen::Matrix< double, Rank, 1 >	GetOffset (const std::array< std::ptrdiff_t, Rank > &index)
template<int Rank>
Eigen::Matrix< double, Rank, 1 >	GetAbsoluteVolumeCentroid (const CutCellData< Rank > &geom, const Index< Rank > &index, const Eigen::Matrix< double, Rank, 1 > &dx)
template<int Rank>
Eigen::Matrix< double, Rank, 1 >	GetAbsoluteBoundaryCentroid (const CutCellData< Rank > &geom, const Index< Rank > &index, const Eigen::Matrix< double, Rank, 1 > &dx)
template<typename Extent >
auto	Shrink (const layout_left::mapping< Extent > &layout, Direction dir, std::ptrdiff_t n=1)
template<typename State , typename Layout , int Rank>
View< State >	Subview (const BasicView< State, Layout, Rank > &state, const IndexBox< Rank > &box)
template<typename Eq , typename Equation = std::decay_t<Eq>>
void	Flux (Eq &&equation, Conservative< Equation > &flux, const Complete< Equation > &state, Direction dir, [[maybe_unused]] double x=0.0)
template<typename Eq , typename Equation = std::decay_t<Eq>>
void	Flux (Eq &&equation, ConservativeArray< Equation > &flux, const CompleteArray< Equation > &state, Direction dir, [[maybe_unused]] double x=0.0)
template<typename Eq , typename Equation = std::decay_t<Eq>>
void	Flux (Eq &&equation, ConservativeArray< Equation > &flux, const CompleteArray< Equation > &state, MaskArray mask, Direction dir, [[maybe_unused]] double x=0.0)
template<typename State , typename ReturnType , typename Equation >
ReturnType	VarNames (const Equation &equation)
template<typename T >
const T &	Min (const std::optional< T > &x)
template<typename T >
const T &	Min (const OmpLocal< T > &x)
template<int Rank, typename Function >
Function	ForEachIndex (const IndexBox< Rank > &box, Function function)
template<typename T , typename Grid >
void	ResetHierarchyConfigurationIfDetected (T &&obj, Grid &&grid)
	Invokes member function obj.ResetHierarchyConfiguration(grid) More...
template<typename Function , typename Derivative >
double	NewtonIteration (Function &&f, Derivative &&Df, double x0, double tolerance=1e-7, int max_iterations=5000)
template<std::size_t N>
std::array< std::ptrdiff_t, N >	Shift (const std::array< std::ptrdiff_t, N > &idx, Direction dir, std::ptrdiff_t shift)
template<std::size_t N>
std::array< std::ptrdiff_t, N >	LeftTo (const std::array< std::ptrdiff_t, N > &idx, Direction dir, std::ptrdiff_t shift=1)
template<std::size_t N>
std::array< std::ptrdiff_t, N >	RightTo (const std::array< std::ptrdiff_t, N > &idx, Direction dir, std::ptrdiff_t shift=1)
template<int Rank>
bool	operator== (const IndexBox< Rank > &b1, const IndexBox< Rank > &b2)
template<int Rank>
bool	operator!= (const IndexBox< Rank > &b1, const IndexBox< Rank > &b2)
template<int Rank>
bool	Contains (const IndexBox< Rank > &b1, const IndexBox< Rank > &b2)
template<int Rank>
bool	Contains (const IndexBox< Rank > &box, const Index< Rank > &index)
template<int Rank>
IndexBox< Rank >	Intersect (const IndexBox< Rank > &b1, const IndexBox< Rank > &b2)
template<int Rank>
IndexBox< Rank >	Grow (const IndexBox< Rank > &box, Direction dir, const std::array< std::ptrdiff_t, 2 > &shifts)
template<int Rank>
IndexBox< Rank >	Shrink (const IndexBox< Rank > &box, Direction dir, const std::array< std::ptrdiff_t, 2 > &shifts)
template<int Rank>
IndexBox< Rank >	Embed (const IndexBox< Rank - 1 > &box, const std::array< std::ptrdiff_t, 2 > &limits)
template<int Rank, int OtherRank>
IndexBox< Rank >	Project (const IndexBox< OtherRank > &box)
template<typename Extents >
constexpr std::array< std::ptrdiff_t, Extents::rank()>	AsArray (Extents e) noexcept
template<typename T , int Rank, typename Layout >
PatchDataView< T, Rank - 1, Layout >	SliceLast (const PatchDataView< T, Rank, Layout > &pdv, int component=0)
std::string	FormatTimeStepLine (std::ptrdiff_t cycle, std::chrono::duration< double > time_point, std::chrono::duration< double > time_step_size, std::chrono::duration< double > final_time, std::chrono::steady_clock::duration wall_time, std::chrono::steady_clock::duration wall_time_difference)
template<typename DestGrid , typename SrcGrid >
void	MakeBackup (std::shared_ptr< DestGrid > &dest, const std::shared_ptr< SrcGrid > &src, CounterRegistry &counter_database)
template<typename Solver , typename Grid = std::decay_t< decltype(*std::declval<Solver&>().GetGriddingAlgorithm())>>
void	RunSimulation (Solver &solver, RunOptions options, std::chrono::steady_clock::time_point wall_time_reference, BasicOutput< Grid > &output)
template<typename... Ts>
constexpr auto	Zip (Ts &&... ts)
template<typename... Ts>
constexpr auto	Unzip (const std::tuple< Ts... > &zipped)
template<std::size_t I, typename State >
constexpr decltype(auto)	get (State &&x)
template<typename F , typename... Ts>
void	ForEachVariable (F function, Ts &&... states)
template<typename State >
auto	StateToTuple (const State &x)
template<typename S , typename L , int R>
	BasicView (const BasicView< S, L, R > &) -> BasicView< S, L, R >
template<typename State , typename Layout , int Rank>
BasicView< const State, Layout, Rank >	AsConst (const BasicView< State, Layout, Rank > &v)
template<typename Eq >
const Conservative< Eq > &	AsCons (const Conservative< Eq > &x)
template<typename Eq >
Conservative< Eq > &	AsCons (Conservative< Eq > &x)
template<typename Eq >
const ConservativeBase< Eq > &	AsCons (const Complete< Eq > &x)
template<typename Eq >
ConservativeBase< Eq > &	AsCons (Complete< Eq > &x)
template<typename State , typename L , int R>
auto	AsCons (const BasicView< State, L, R > &view)
template<int N, typename State , typename Layout , int Rank>
dynamic_extents< static_cast< std::size_t >Rank)>	Extents (const BasicView< State, Layout, Rank > &view)
template<int N, typename State , typename Layout , int Rank>
IndexBox< Rank >	Box (const BasicView< State, Layout, Rank > &view)
template<int N, typename State , typename Layout , int Rank>
Layout::template mapping< dynamic_extents< static_cast< std::size_t >Rank)> >	Mapping (const BasicView< State, Layout, Rank > &view)
template<typename F , typename... Ts>
void	ForEachComponent (F function, Ts &&... states)
template<typename State , typename Layout , int Rank>
void	Load (State &state, const BasicView< const State, Layout, Rank > &view, const std::array< std::ptrdiff_t, State::Equation::Rank()> &index)
template<typename State , typename Layout , int Rank>
void	Load (State &state, const BasicView< State, Layout, Rank > &view, const std::array< std::ptrdiff_t, State::Equation::Rank()> &index)
template<typename Eq , typename Layout >
void	Store (const BasicView< Conservative< Eq >, Layout, Eq::Rank()> &view, const Conservative< Eq > &state, const std::array< std::ptrdiff_t, Eq::Rank()> &index)
template<typename Eq , typename Layout >
void	Store (const BasicView< Complete< Eq >, Layout, Eq::Rank()> &view, const Complete< Eq > &state, const std::array< std::ptrdiff_t, Eq::Rank()> &index)
template<Direction dir, typename T , typename L , int Rank, typename SliceSpecifier >
auto	Slice (const BasicView< T, L, Rank > &view, SliceSpecifier slice)
template<typename State , int Rank, typename Layout >
View< State, Rank >	Shrink (const BasicView< State, Layout, Rank > &view, Direction dir, std::array< std::ptrdiff_t, 2 > offsets)
template<typename Equation >
bool	AnyNaN (const Complete< Equation > &state)
template<typename State >
	ViewPointer (const ViewPointer< State > &) -> ViewPointer< State >
template<typename State >
ViewPointer< std::add_const_t< State > >	AsConst (const ViewPointer< State > &p) noexcept
template<typename State , typename Layout , int Rank>
ViewPointer< State >	Begin (const BasicView< State, Layout, Rank > &view)
template<typename State , typename Layout , int Rank>
ViewPointer< State >	End (const BasicView< State, Layout, Rank > &view)
template<typename Eq >
void	Load (Complete< Eq > &state, nodeduce_t< ViewPointer< const Complete< Eq >>> pointer)
template<typename Eq >
void	Load (Conservative< Eq > &state, nodeduce_t< ViewPointer< const Conservative< Eq >>> pointer)
template<typename State >
void	Advance (ViewPointer< State > &pointer, std::ptrdiff_t n) noexcept
template<typename Equation >
void	CopyFromBuffer (Complete< Equation > &state, span< const double > buffer)
template<typename Equation >
void	CopyFromBuffer (Conservative< Equation > &state, span< const double > buffer)
template<typename Equation >
void	CopyToBuffer (span< double > buffer, const Conservative< Equation > &state)
template<typename Eq , int N>
const ConservativeArray< Eq, N > &	AsCons (const ConservativeArray< Eq, N > &x)
template<typename Eq , int N>
ConservativeArray< Eq, N > &	AsCons (ConservativeArray< Eq, N > &x)
template<typename Eq , int N>
const ConservativeArrayBase< Eq, N > &	AsCons (const CompleteArray< Eq, N > &x)
template<typename Eq , int N>
ConservativeArrayBase< Eq, N > &	AsCons (CompleteArray< Eq, N > &x)
template<typename Eq , int N>
void	Load (Conservative< Eq > &q, const ConservativeArray< Eq, N > &qs, int i)
template<typename Eq , int N>
void	Load (Complete< Eq > &q, const CompleteArray< Eq, N > &qs, int i)
template<typename Eq , int N, typename Layout , std::size_t Rank>
void	Load (ConservativeArray< Eq, N > &state, nodeduce_t< const BasicView< const Conservative< Eq >, Layout, static_cast< int >(Rank)> & > view, std::array< std::ptrdiff_t, Rank > index)
template<typename Eq , int N, typename Layout , int Rank>
void	Load (ConservativeArray< Eq, N > &state, const BasicView< const Conservative< Eq >, Layout, Rank > &view, nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & > index)
template<typename Eq >
void	Load (ConservativeArray< Eq > &state, nodeduce_t< ViewPointer< const Conservative< Eq >>> pointer)
template<typename Eq , int N, typename Layout , int Rank>
void	Load (CompleteArray< Eq, N > &state, const BasicView< const Complete< Eq >, Layout, Rank > &view, nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & > index)
template<typename Eq >
void	Load (CompleteArray< Eq > &state, nodeduce_t< ViewPointer< const Complete< Eq >>> pointer)
template<typename Eq , int N, typename Layout , int Rank>
void	LoadN (CompleteArray< Eq, N > &state, const BasicView< const Complete< Eq >, Layout, Rank > &view, int size, nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & > pos)
template<typename Eq , int N, typename Layout , int Rank>
void	LoadN (ConservativeArray< Eq, N > &state, const BasicView< const Conservative< Eq >, Layout, Rank > &view, int size, nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & > pos)
template<typename Eq >
void	LoadN (CompleteArray< Eq > &state, nodeduce_t< ViewPointer< const Complete< Eq >>> pointer, int n)
template<typename Eq >
void	LoadN (ConservativeArray< Eq > &state, nodeduce_t< ViewPointer< const Conservative< Eq >>> pointer, int n)
template<typename Eq >
void	Store (nodeduce_t< ViewPointer< Conservative< Eq >>> pointer, const ConservativeArray< Eq > &state)
template<typename Eq >
void	Store (nodeduce_t< ViewPointer< Complete< Eq >>> pointer, const CompleteArray< Eq > &state)
template<typename Eq >
void	StoreN (nodeduce_t< ViewPointer< Conservative< Eq >>> pointer, const ConservativeArray< Eq > &state, int n)
template<typename Eq >
void	StoreN (nodeduce_t< ViewPointer< Complete< Eq >>> pointer, const CompleteArray< Eq > &state, int n)
template<typename Eq , int N, typename Layout , int Rank>
void	Store (const BasicView< Conservative< Eq >, Layout, Rank > &view, const ConservativeArray< Eq, N > &state, nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & > index)
template<typename Eq , int N, typename Layout , int Rank>
void	Store (const BasicView< Complete< Eq >, Layout, Rank > &view, const CompleteArray< Eq, N > &state, nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & > index)
template<typename Eq , int N, typename Layout , int Rank>
void	StoreN (const BasicView< Complete< Eq >, Layout, Rank > &view, const CompleteArray< Eq, N > &state, int size, nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & > pos)
template<typename Eq , int N, typename Layout , int Rank>
void	StoreN (const BasicView< Conservative< Eq >, Layout, Rank > &view, const ConservativeArray< Eq, N > &state, int size, nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & > pos)
template<typename State >
ViewPointer< State >	Begin (const Row< State > &row)
template<typename State >
ViewPointer< State >	End (const Row< State > &row)
template<Direction Dir, typename T , int R, typename L >
std::ptrdiff_t	Extent (const PatchDataView< T, R, L > &pdv)
template<Direction Dir, typename T , typename L , int R>
std::ptrdiff_t	Extent (const BasicView< T, L, R > &view)
template<typename T >
void	Advance (T *&pointer, std::ptrdiff_t n)
template<typename T , int R, typename L >
T *	Begin (const PatchDataView< T, R, L > &pdv)
template<typename T , int R, typename L >
T *	End (const PatchDataView< T, R, L > &pdv)
template<int N, typename T >
constexpr T *	GetOrForward (T *pointer) noexcept
template<int N, typename T >
constexpr decltype(auto)	GetOrForward (const ViewPointer< T > &pointer) noexcept
template<typename Tuple , typename Function >
void	ForEachRow (const Tuple &views, Function f)
const TimeStepErrcCategory &	TimeStepErrc_category ()
std::error_code	make_error_code (TimeStepErrc error)
std::error_code	make_error_code (const TimeStepTooLarge &)
template<typename Grid , typename Fn >
std::unique_ptr< AsOutput< Grid, Fn > >	MakeOutput (std::vector< std::ptrdiff_t > frequencies, std::vector< Duration > intervals, Fn fn)
template<typename T , typename... Ts>
T	Head (T &&head, Ts &&...)
template<typename Equation >
	GodunovMethod (const Equation &eq) -> GodunovMethod< Equation >
template<typename Equation >
void	ComputeAmplitudes (Characteristics< Equation > &amplitudes, const Primitive< Equation > &left, const Primitive< Equation > &right, double rhoc, double ooc2, double dx, int ix)
template<typename Equation >
void	ComputeAmplitudes (CharacteristicsArray< Equation > &amplitudes, const PrimitiveArray< Equation > &left, const PrimitiveArray< Equation > &right, Array1d rhoc, Array1d ooc2, double dx, int ix)
template<typename Equation , typename Signals >
	Hll (const Equation &eq, const Signals &signals) -> Hll< Equation, Signals >
template<typename Equation , typename Signals >
	HllMethod (const Equation &eq, const Signals &signals) -> HllMethod< Equation, Signals >
template<typename Equation >
	MusclHancockMethod (const Equation &) -> MusclHancockMethod< Equation >
template<typename Equation , typename Method >
	MusclHancockMethod (const Equation &, const Method &) -> MusclHancockMethod< Equation, Method >
template<std::size_t DestRank, std::size_t SrcRank>
std::array< std::ptrdiff_t, DestRank >	EmbedInSpace (const std::array< std::ptrdiff_t, SrcRank > &index)
template<typename Eq , typename... Ps>
	GradientDetector (const Eq &, const std::pair< Ps, double > &...) -> GradientDetector< Eq, Ps... >
Index< 1 >	ReflectIndex (Index< 1 > i, const IndexBox< 1 > &domain, Direction dir, int side)
Index< 2 >	ReflectIndex (Index< 2 > i, const IndexBox< 2 > &domain, Direction dir, int side)
Index< 3 >	ReflectIndex (Index< 3 > i, const IndexBox< 3 > &domain, Direction dir, int side)
template<std::size_t N>
Eigen::Matrix< double, static_cast< int >N), 1 >	AsEigenVector (const std::array< double, N > &x)
void	LoadN (Array< char, 1 > &array, const char *pointer, int n)
void	StoreN (char *pointer, const Array< char, 1 > &array, int n)
template<int N, typename T , int Rank, typename Layout , typename... Indices>
std::enable_if_t< boost::mp11::mp_all< std::is_integral< Indices >... >::value, Eigen::Array< std::remove_cv_t< T >, N, 1 > >	LoadN (int_constant< N >, const PatchDataView< T, Rank, Layout > &pdv, int size, std::ptrdiff_t i0, Indices... indices)
template<int Rank>
Eigen::Matrix< double, Rank, 1 >	Shift (const Eigen::Matrix< double, Rank, 1 > &v, Direction dir, double shift)
template<int Rank>
Eigen::Matrix< double, Rank, 1 >	UnitVector (Direction dir) noexcept
Eigen::Matrix< double, 2, 2 >	MakeRotation (const Eigen::Matrix< double, 2, 1 > &a, const Eigen::Matrix< double, 2, 1 > &b)
Eigen::Matrix< double, 3, 3 >	MakeRotation (const Eigen::Matrix< double, 3, 1 > &a, const Eigen::Matrix< double, 3, 1 > &b)
template<int N, typename T , int Rank, typename Layout , typename... Indices>
Eigen::Array< std::remove_cv_t< T >, N, 1 >	LoadN (int_constant< N >, const PatchDataView< T, Rank, Layout > &pdv, int size, nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & > index)
template<int N, typename T , int Rank, typename Layout , typename... Indices>
Eigen::Array< std::remove_cv_t< T >, N, 1 >	Load (int_constant< N > n, const PatchDataView< T, Rank, Layout > &pdv, Indices... indices)
template<typename T , int Rank, typename Layout , typename... Indices>
auto	Load (const PatchDataView< T, Rank, Layout > &pdv, Indices... indices)
template<typename T , typename A , int N, bool B, typename Layout >
void	StoreN (const PatchDataView< T, 1, Layout > &pdv, int n, const Eigen::Block< A, 1, N, B > &chunk, std::ptrdiff_t offset)
template<typename T , int Rank, typename Layout , int N, int Options, typename... Indices>
void	Store (const PatchDataView< T, Rank, Layout > &view, const Eigen::Array< T, 1, N, Options > &chunk, const nodeduce_t< std::array< std::ptrdiff_t, static_cast< std::size_t >(Rank)>> &index)
template<typename T , typename Base , int Rank, typename Layout , int N, bool Options, typename... Indices>
void	Store (const PatchDataView< T, Rank, Layout > &view, const Eigen::Block< Base, 1, N, Options > &chunk, const nodeduce_t< std::array< std::ptrdiff_t, static_cast< std::size_t >(Rank)>> &index)
template<typename T , int Rank, typename L >
void	Store (const PatchDataView< T, Rank, L > &view, nodeduce_t< const T & > value, const nodeduce_t< std::array< std::ptrdiff_t, static_cast< std::size_t >(Rank)>> &index)
void	InitializeLogging (MPI_Comm comm, const LogOptions &log={})
SeverityLogger	GetInfoLogger ()
SeverityLogger	GetLogger (boost::log::trivial::severity_level level)
void	Log (std::string message, Duration timepoint, boost::log::trivial::severity_level level=boost::log::trivial::severity_level::info)
std::string	ReadAndBroadcastFile (std::string filepath, MPI_Comm comm)
Duration	MinAll (MPI_Comm comm, Duration local_duration)
Result< void, TimeStepTooLarge >	Reduceall (MPI_Comm comm, Result< void, TimeStepTooLarge > result)
ProgramOptions	ParsePythonScript (const boost::filesystem::path &path, MPI_Comm comm)
ProgramOptions	ToMap (const pybind11::dict &dict)
template<typename T >
T	GetOptionOr (const ProgramOptions &map, const std::string &name, const T &value)
template<>
Direction	GetOptionOr (const ProgramOptions &map, const std::string &name, const Direction &value)
ProgramOptions	GetOptions (const ProgramOptions &options, const std::string &name)
std::optional< ProgramOptions >	ParseCommandLine (int argc, char **argv)
std::string	MakeUniqueName ()
template<typename Abi >
Vc::Vector< double, Abi >	mask_load (const double *p, Vc::Mask< double, Abi > mask)
template<class T , class Compare >
constexpr const T &	clamp (const T &v, const T &lo, const T &hi, Compare comp)
template<class T >
constexpr const T &	clamp (const T &v, const T &lo, const T &hi)
constexpr std::ptrdiff_t	ipow (int base, int exponent)
template<typename... IndexType>
constexpr std::size_t	count_dynamic_extents (IndexType... extent) noexcept
template<std::ptrdiff_t... StaticExtentsL, std::ptrdiff_t... StaticExtentsR>
constexpr bool	operator== (const extents< StaticExtentsL... > &lhs, const extents< StaticExtentsR... > &rhs) noexcept
	Returns: true if lhs.rank() == rhs.rank() and lhs.extents(r) == rhs.extents(r) for all r in the range [0, lhs.rank()), or false otherwise. More...
template<std::ptrdiff_t... StaticExtentsL, std::ptrdiff_t... StaticExtentsR>
constexpr bool	operator!= (const extents< StaticExtentsL... > &left, const extents< StaticExtentsR... > &right) noexcept
template<std::ptrdiff_t... StaticExtents>
constexpr std::ptrdiff_t	Size_ (const extents< StaticExtents... > e) noexcept
constexpr std::ptrdiff_t	SliceExtent_ (const std::pair< std::ptrdiff_t, std::ptrdiff_t > &p)
template<class ElementType , class Extents , class LayoutPolicy , class AccessorPolicy , class... SliceSpecifiers>
mdspan_subspan_t< ElementType, Extents, LayoutPolicy, AccessorPolicy, SliceSpecifiers... >	subspan (const basic_mdspan< ElementType, Extents, LayoutPolicy, AccessorPolicy > &src, SliceSpecifiers... slices) noexcept
template<class T , typename I >
	span (T *, I) -> span< T >
template<class T , size_t N>
	span (T(&)[N]) -> span< T, static_cast< std::ptrdiff_t >(N)>
template<class T , size_t N>
	span (std::array< T, N > &) -> span< T, static_cast< std::ptrdiff_t >(N)>
template<class T , size_t N>
	span (const std::array< T, N > &) -> span< const T, static_cast< std::ptrdiff_t >(N)>
template<class Container >
	span (Container &) -> span< typename Container::value_type >
template<class Container >
	span (const Container &) -> span< const typename Container::value_type >
template<class T , size_t N>
auto	make_span (T(&array)[N]) -> span< T, static_cast< std::ptrdiff_t >(N)>
template<class T , size_t N>
auto	make_span (std::array< T, N > &array) -> span< T, static_cast< std::ptrdiff_t >(N)>
template<class T , size_t N>
auto	make_span (const std::array< T, N > &array) -> span< const T, static_cast< std::ptrdiff_t >(N)>
template<class Container >
auto	make_span (Container &array) -> span< typename Container::value_type >
template<class Container >
auto	make_span (const Container &array) -> span< const typename Container::value_type >
template<std::size_t... Is, typename... Ts>
constexpr auto	Take (std::index_sequence< Is... >, const std::tuple< Ts... > &t)
template<std::size_t N, typename... Ts>
constexpr auto	Take (const std::tuple< Ts... > &t)
template<std::size_t N, std::size_t... Is, typename... Ts>
constexpr auto	Drop (std::index_sequence< Is... >, const std::tuple< Ts... > &t)
template<std::size_t N, typename... Ts>
constexpr auto	Drop (const std::tuple< Ts... > &t)
template<typename Tuple , typename Function >
constexpr auto	Transform (Tuple &&tuple, Function f)
template<std::size_t... Is, typename T , typename... Ts>
constexpr auto	AsArray (std::index_sequence< Is... >, const std::tuple< T, Ts... > &t)
template<typename T , typename... Ts>
constexpr auto	AsArray (const std::tuple< T, Ts... > &t)
template<typename TupleLike >
constexpr auto	AsTuple (const TupleLike &t)
template<class... Ts>
	overloaded (Ts...) -> overloaded< Ts... >
void	ComputeStableFluxComponents (const PatchDataView< double, 2, layout_stride > &stabilised_fluxes, const PatchDataView< double, 2, layout_stride > &shielded_left_fluxes, const PatchDataView< double, 2, layout_stride > &shielded_right_fluxes, const PatchDataView< const double, 2, layout_stride > &regular_fluxes, const PatchDataView< const double, 2, layout_stride > &boundary_fluxes, const CutCellData< 2 > &geom, Duration dt, double dx, Direction dir)
void	ComputeStableFluxComponents (const PatchDataView< double, 3, layout_stride > &stabilised_fluxes, const PatchDataView< double, 3, layout_stride > &shielded_left_fluxes, const PatchDataView< double, 3, layout_stride > &shielded_right_fluxes, const PatchDataView< const double, 3, layout_stride > &regular_fluxes, const PatchDataView< const double, 3, layout_stride > &boundary_fluxes, const CutCellData< 3 > &geom, Duration dt, double dx, Direction dir)
void	MyStab_ComputeStableFluxComponents (const PatchDataView< double, 2, layout_stride > &stabilised_fluxes, const PatchDataView< double, 2, layout_stride > &shielded_left_fluxes, const PatchDataView< double, 2, layout_stride > &shielded_right_fluxes, const PatchDataView< const double, 2, layout_stride > &regular_fluxes, const PatchDataView< const double, 2, layout_stride > &boundary_fluxes, const CutCellData< 2 > &geom, Duration dt, double dx, Direction dir)
void	MyStab_ComputeStableFluxComponents (const PatchDataView< double, 3, layout_stride > &stabilised_fluxes, const PatchDataView< double, 3, layout_stride > &shielded_left_fluxes, const PatchDataView< double, 3, layout_stride > &shielded_right_fluxes, const PatchDataView< const double, 3, layout_stride > &regular_fluxes, const PatchDataView< const double, 3, layout_stride > &boundary_fluxes, const CutCellData< 3 > &geom, Duration dt, double dx, Direction dir)
Coordinates< 2 >	ComputeReflectedCoordinates (const Coordinates< 2 > &offset, const Coordinates< 2 > &boundary_normal)
template<int Rank>
Index< Rank >	RelativeCellIndex (const Coordinates< Rank > &x, const Coordinates< Rank > &dx)
template<int Rank>
Index< Rank+1 >	EmbedIndex (const Index< Rank > &index, Direction dir)
template<typename State , std::ptrdiff_t Rank>
void	ApplyGradient (State &u, span< const State, Rank > grad, nodeduce_t< const Eigen::Matrix< double, Rank, 1 > & > x) noexcept
template<typename Equation , typename FluxMethod >
	MyCutCellMethod (const Equation &, const FluxMethod &) -> MyCutCellMethod< Equation, FluxMethod >
template<int Dim>
double	KineticEnergy (double density, const Eigen::Array< double, Dim, 1 > &momentum) noexcept
template<int Dim>
Array1d	KineticEnergy (Array1d density, const Eigen::Array< double, Dim, kDefaultChunkSize, Eigen::RowMajor > &momentum) noexcept
template<int Dim>
Array1d	KineticEnergy (Array1d density, const Eigen::Array< double, Dim, kDefaultChunkSize, Eigen::RowMajor > &momentum, MaskArray mask) noexcept
void	Reflect (Complete< IdealGasMix< 1 >> &reflected, const Complete< IdealGasMix< 1 >> &state, const Eigen::Matrix< double, 1, 1 > &normal, const IdealGasMix< 1 > &gas)
void	Reflect (Complete< IdealGasMix< 2 >> &reflected, const Complete< IdealGasMix< 2 >> &state, const Eigen::Vector2d &normal, const IdealGasMix< 2 > &gas)
void	Reflect (Complete< IdealGasMix< 3 >> &reflected, const Complete< IdealGasMix< 3 >> &state, const Eigen::Vector3d &normal, const IdealGasMix< 3 > &gas)
template<int Rank>
void	CompleteFromPrim (const PerfectGas< Rank > &equation, Complete< PerfectGas< Rank >> &complete, const Primitive< PerfectGas< Rank >> &prim)
template<int Rank>
void	PrimFromComplete (const PerfectGas< Rank > &, Primitive< PerfectGas< Rank >> &prim, const Complete< PerfectGas< Rank >> &complete)
template<int Rank>
void	CompleteFromPrim (const PerfectGas< Rank > &equation, CompleteArray< PerfectGas< Rank >> &complete, const PrimitiveArray< PerfectGas< Rank >> &prim)
template<int Rank>
void	PrimFromComplete (const PerfectGas< Rank > &, PrimitiveArray< PerfectGas< Rank >> &prim, const CompleteArray< PerfectGas< Rank >> &complete)
void	Reflect (Conservative< PerfectGas< 1 >> &reflected, const Conservative< PerfectGas< 1 >> &state, const Eigen::Matrix< double, 1, 1 > &normal, const PerfectGas< 1 > &gas)
void	Reflect (Conservative< PerfectGas< 2 >> &reflected, const Conservative< PerfectGas< 2 >> &state, const Eigen::Vector2d &normal, const PerfectGas< 2 > &gas)
void	Reflect (Conservative< PerfectGas< 3 >> &reflected, const Conservative< PerfectGas< 3 >> &state, const Eigen::Vector3d &normal, const PerfectGas< 3 > &gas)
void	Reflect (Complete< PerfectGas< 1 >> &reflected, const Complete< PerfectGas< 1 >> &state, const Eigen::Matrix< double, 1, 1 > &normal, const PerfectGas< 1 > &gas)
void	Reflect (Complete< PerfectGas< 2 >> &reflected, const Complete< PerfectGas< 2 >> &state, const Eigen::Vector2d &normal, const PerfectGas< 2 > &gas)
void	Reflect (Complete< PerfectGas< 3 >> &reflected, const Complete< PerfectGas< 3 >> &state, const Eigen::Vector3d &normal, const PerfectGas< 3 > &gas)
template<int Rank>
void	CompleteFromPrim (const PerfectGasMix< Rank > &equation, Complete< PerfectGasMix< Rank >> &complete, const Primitive< PerfectGasMix< Rank >> &prim)
template<int Rank>
void	CompleteFromPrim (const PerfectGasMix< Rank > &equation, CompleteArray< PerfectGasMix< Rank >> &complete, const PrimitiveArray< PerfectGasMix< Rank >> &prim)
template<int Rank>
void	PrimFromComplete (const PerfectGasMix< Rank > &equation, Primitive< PerfectGasMix< Rank >> &prim, const Complete< PerfectGasMix< Rank >> &complete)
template<int Rank>
void	PrimFromComplete (const PerfectGasMix< Rank > &equation, PrimitiveArray< PerfectGasMix< Rank >> &prim, const CompleteArray< PerfectGasMix< Rank >> &complete)
template<int Rank>
void	tag_invoke (tag_t< euler::CompleteFromKineticState >, const PerfectGasMix< Rank > &eq, CompleteArray< PerfectGasMix< Rank >> &q, const KineticStateArray< PerfectGasMix< Rank >> &kin, const Array< double, Rank > &u) noexcept
template<int Rank>
void	tag_invoke (tag_t< euler::CompleteFromKineticState >, const PerfectGasMix< Rank > &eq, Complete< PerfectGasMix< Rank >> &q, const KineticState< PerfectGasMix< Rank >> &kin) noexcept
template<int Rank>
void	tag_invoke (tag_t< euler::KineticStateFromComplete >, const PerfectGasMix< Rank > &eq, KineticStateArray< PerfectGasMix< Rank >> &kin, const CompleteArray< PerfectGasMix< Rank >> &q) noexcept
template<int Rank>
double	tag_invoke (tag_t< euler::Temperature >, const PerfectGasMix< Rank > &eq, const Complete< PerfectGasMix< Rank >> &q) noexcept
template<int Rank>
Array1d	tag_invoke (tag_t< euler::Temperature >, const PerfectGasMix< Rank > &eq, const CompleteArray< PerfectGasMix< Rank >> &q) noexcept
void	Reflect (Conservative< PerfectGasMix< 1 >> &reflected, const Conservative< PerfectGasMix< 1 >> &state, const Eigen::Matrix< double, 1, 1 > &normal, const PerfectGasMix< 1 > &gas)
void	Reflect (Conservative< PerfectGasMix< 2 >> &reflected, const Conservative< PerfectGasMix< 2 >> &state, const Eigen::Vector2d &normal, const PerfectGasMix< 2 > &gas)
void	Reflect (Conservative< PerfectGasMix< 3 >> &reflected, const Conservative< PerfectGasMix< 3 >> &state, const Eigen::Vector3d &normal, const PerfectGasMix< 3 > &gas)
void	Reflect (Complete< PerfectGasMix< 1 >> &reflected, const Complete< PerfectGasMix< 1 >> &state, const Eigen::Matrix< double, 1, 1 > &normal, const PerfectGasMix< 1 > &gas)
void	Reflect (Complete< PerfectGasMix< 2 >> &reflected, const Complete< PerfectGasMix< 2 >> &state, const Eigen::Vector2d &normal, const PerfectGasMix< 2 > &gas)
void	Reflect (Complete< PerfectGasMix< 3 >> &reflected, const Complete< PerfectGasMix< 3 >> &state, const Eigen::Vector3d &normal, const PerfectGasMix< 3 > &gas)
template<int Rank, typename State >
constexpr auto	tag_invoke (tag_t< Depths >, const PerfectGasMix< Rank > &eq, Type< State >) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr auto	tag_invoke (tag_t< euler::Gamma >, const PerfectGasMix &eq, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr const Density &	tag_invoke (tag_t< euler::Density >, const PerfectGasMix &, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &q) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr auto	tag_invoke (tag_t< euler::InternalEnergy >, const PerfectGasMix &eq, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &q) noexcept
template<typename Density , typename Temperature , typename MoleFractions >
constexpr auto	tag_invoke (tag_t< euler::InternalEnergy >, const PerfectGasMix &eq, const PerfectGasMixKineticState< Density, Temperature, MoleFractions > &q) noexcept
constexpr void	tag_invoke (tag_t< euler::CompleteFromKineticState >, const PerfectGasMix &eq, Complete &q, const KineticState &kin, const Array< double, N, 1 > &u) noexcept
constexpr void	tag_invoke (tag_t< euler::KineticStateFromComplete >, const PerfectGasMix &eq, KineticState &kin, const Complete &q) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr const Momentum &	tag_invoke (tag_t< euler::Momentum >, const PerfectGasMix &, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &q) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr decltype(auto)	tag_invoke (tag_t< euler::Momentum >, const PerfectGasMix &, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &q, int d) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr Momentum	tag_invoke (tag_t< euler::Velocity >, const PerfectGasMix &, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &q) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr auto	tag_invoke (tag_t< euler::Velocity >, const PerfectGasMix &, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &q, int d) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr const Energy &	tag_invoke (tag_t< euler::Energy >, const PerfectGasMix &, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &q) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr const Species &	tag_invoke (tag_t< euler::Species >, const PerfectGasMix &, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &q) noexcept
template<typename Density , typename Velocity , typename Pressure , typename Species >
constexpr const Species &	tag_invoke (tag_t< euler::Species >, const PerfectGasMix &, const PerfectGasMixPrimitive< Density, Velocity, Pressure, Species > &q) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species >
constexpr decltype(auto)	tag_invoke (tag_t< euler::Species >, const PerfectGasMix &, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &q, int d) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species , typename Pressure , typename SpeedOfSound >
constexpr const Pressure &	tag_invoke (tag_t< euler::Pressure >, const PerfectGasMix &, const PerfectGasMixComplete< Density, Momentum, Energy, Species, Pressure, SpeedOfSound > &q) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species , typename Pressure , typename SpeedOfSound >
constexpr const SpeedOfSound &	tag_invoke (tag_t< euler::SpeedOfSound >, const PerfectGasMix &, const PerfectGasMixComplete< Density, Momentum, Energy, Species, Pressure, SpeedOfSound > &q) noexcept
template<typename Density , typename Momentum , typename Energy , typename Species , typename Pressure , typename SpeedOfSound >
constexpr auto	tag_invoke (tag_t< euler::SetIsentropicPressure >, const PerfectGasMix &eq, PerfectGasMixComplete< Density, Momentum, Energy, Species, Pressure, SpeedOfSound > &q, const PerfectGasMixComplete< Density, Momentum, Energy, Species, Pressure, SpeedOfSound > &q0, Pressure p_new) noexcept
template<std::size_t Rank>
	Ball (const std::array< double, Rank > &, double) -> Ball< Rank >
Eigen::Matrix< double, 3, Eigen::Dynamic >	ReadPointsFromFile (const std::string &filename)
template<>
::amrex::IntVect	GetOptionOr (const ProgramOptions &map, const std::string &name, const ::amrex::IntVect &value)
template<>
::amrex::Box	GetOptionOr (const ProgramOptions &map, const std::string &name, const ::amrex::Box &value)
template<>
::amrex::RealBox	GetOptionOr (const ProgramOptions &map, const std::string &name, const ::amrex::RealBox &value)
template<typename Extents , typename Function >
Function	ForEachIndex (const layout_left::mapping< Extents > &mapping, Function function)
	Iterate through the multi-dimensional index space descibed by mapping and invoke function for each such indices. More...
template<typename Extents , typename Function >
Function	ForEachIndex (const layout_stride::mapping< Extents > &mapping, Function function)
	Iterate through the multi-dimensional index space descibed by mapping and invoke function for each such indices. More...
void	Rotate (Conservative< IdealGasMix< 2 >> &rotated, const Conservative< IdealGasMix< 2 >> &state, const Eigen::Matrix< double, 2, 2 > &rotation, const IdealGasMix< 2 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Complete< IdealGasMix< 2 >> &rotated, const Complete< IdealGasMix< 2 >> &state, const Eigen::Matrix< double, 2, 2 > &rotation, const IdealGasMix< 2 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Conservative< IdealGasMix< 3 >> &rotated, const Conservative< IdealGasMix< 3 >> &state, const Eigen::Matrix< double, 3, 3 > &rotation, const IdealGasMix< 3 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Complete< IdealGasMix< 3 >> &rotated, const Complete< IdealGasMix< 3 >> &state, const Eigen::Matrix< double, 3, 3 > &rotation, const IdealGasMix< 3 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Conservative< PerfectGas< 2 >> &rotated, const Conservative< PerfectGas< 2 >> &state, const Eigen::Matrix< double, 2, 2 > &rotation, const PerfectGas< 2 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Complete< PerfectGas< 2 >> &rotated, const Complete< PerfectGas< 2 >> &state, const Eigen::Matrix< double, 2, 2 > &rotation, const PerfectGas< 2 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Conservative< PerfectGas< 3 >> &rotated, const Conservative< PerfectGas< 3 >> &state, const Eigen::Matrix< double, 3, 3 > &rotation, const PerfectGas< 3 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Complete< PerfectGas< 3 >> &rotated, const Complete< PerfectGas< 3 >> &state, const Eigen::Matrix< double, 3, 3 > &rotation, const PerfectGas< 3 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Conservative< PerfectGasMix< 2 >> &rotated, const Conservative< PerfectGasMix< 2 >> &state, const Eigen::Matrix< double, 2, 2 > &rotation, const PerfectGasMix< 2 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Complete< PerfectGasMix< 2 >> &rotated, const Complete< PerfectGasMix< 2 >> &state, const Eigen::Matrix< double, 2, 2 > &rotation, const PerfectGasMix< 2 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Conservative< PerfectGasMix< 3 >> &rotated, const Conservative< PerfectGasMix< 3 >> &state, const Eigen::Matrix< double, 3, 3 > &rotation, const PerfectGasMix< 3 > &)
	Defines how to rotate a given state of the euler equations. More...
void	Rotate (Complete< PerfectGasMix< 3 >> &rotated, const Complete< PerfectGasMix< 3 >> &state, const Eigen::Matrix< double, 3, 3 > &rotation, const PerfectGasMix< 3 > &)
	Defines how to rotate a given state of the euler equations. More...

Variables
constexpr struct fub::DepthsFn	Depths
constexpr const int	kDefaultChunkSize
static constexpr std::ptrdiff_t	dynamic_extent
	This is a magic value to denote runtime-known extents. More...
static constexpr all_type	all
template<typename T >
static constexpr bool	is_mdspan_v
template<typename T >
static constexpr bool	is_span_v
	Returns true if the specified T is a span<S, N> for some type S and integer N. More...
template<int I>
static constexpr int_constant< I >	int_c
template<bool B>
static constexpr bool_constant< B >	bool_c
template<index I>
static constexpr index_constant< I >	index_c
template<std::size_t I>
static constexpr size_constant< I >	size_c
template<typename E >
static constexpr bool	is_extents_v

Detailed Description

The fub namespace.

Typedef Documentation

Array

template<typename T , int N, int M = kDefaultChunkSize>

using fub::Array = typedef std::conditional_t<N == 1 || M == 1, Eigen::Array<T, N, M>, Eigen::Array<T, N, M, Eigen::RowMajor> >

Array1d

using fub::Array1d = typedef Array<double, 1>

Array2d

using fub::Array2d = typedef Array<double, 2>

Array3d

using fub::Array3d = typedef Array<double, 3>

ArrayStateBase

template<typename Depths , int Width>

using fub::ArrayStateBase = typedef typename detail::ArrayStateBaseImpl<Depths, Width>::type

ArrayXd

using fub::ArrayXd = typedef Array<double, Eigen::Dynamic>

bool_constant

template<bool Bool>

using fub::bool_constant = typedef std::integral_constant<bool, Bool>

byte

using fub::byte = typedef unsigned char

CompleteArrayBase

template<typename Eq , int Width>

using fub::CompleteArrayBase = typedef typename detail::CompleteArrayBaseImpl<Eq, Width>::type

CompleteBase

template<typename Equation >

using fub::CompleteBase = typedef boost::mp11::mp_transform<detail::DepthToStateValueType, typename Equation::CompleteDepths>

CompleteFromConsMemberFunction

template<typename Eq , typename... Args>

using fub::CompleteFromConsMemberFunction = typedef decltype(std::declval<Eq>().CompleteFromCons(std::declval<Args>()...))

CompressibleAdvectionCompleteShape

template<int VelocityRank>

using fub::CompressibleAdvectionCompleteShape = typedef CompressibleAdvectionComplete<ScalarDepth, VectorDepth<VelocityRank>, ScalarDepth, ScalarDepth>

CompressibleAdvectionConsShape

template<int VelocityRank>

using fub::CompressibleAdvectionConsShape = typedef CompressibleAdvectionConservative<ScalarDepth, VectorDepth<VelocityRank>, ScalarDepth>

ConservativeArrayBase

template<typename Eq , int Width = kDefaultChunkSize>

using fub::ConservativeArrayBase = typedef typename detail::ConservativeArrayBaseImpl<Eq, Width>::type

ConservativeBase

template<typename Equation >

using fub::ConservativeBase = typedef boost::mp11::mp_transform<detail::DepthToStateValueType, typename Equation::ConservativeDepths>

This type alias transforms state depths into a conservative state associated with a specified equation.

Coordinates

template<int Rank>

using fub::Coordinates = typedef Eigen::Matrix<double, Rank, 1>

decays_to

template<typename X , typename Y >

using fub::decays_to = typedef std::is_same<std::decay_t<X>, Y>

Duration

using fub::Duration = typedef std::chrono::duration<double>

dynamic_extents

template<std::size_t Rank>

using fub::dynamic_extents = typedef typename dynamic_extents_<make_index_sequence<Rank> >::type

dynamic_mdarray

template<typename ValueType , std::ptrdiff_t Rank>

using fub::dynamic_mdarray = typedef basic_mdarray<ValueType, dynamic_extents<Rank>, layout_left, std_vector_policy>

FluxT

template<typename Eq , typename... Args>

using fub::FluxT = typedef decltype(std::declval<Eq>().Flux(std::declval<Args>()...))

H5Attribute

using fub::H5Attribute = typedef H5Handle<H5Adeleter>

H5Dataset

using fub::H5Dataset = typedef H5Handle<H5Ddeleter>

H5File

using fub::H5File = typedef H5Handle<H5Fdeleter>

H5Properties

using fub::H5Properties = typedef H5Handle<H5Pdeleter>

H5Space

using fub::H5Space = typedef H5Handle<H5Sdeleter>

HasComputeNumericFlux

template<typename FM , typename... Args>

using fub::HasComputeNumericFlux = typedef is_detected<HasComputeNumericFluxType, FM, Args...>

HasComputeNumericFluxType

template<typename FM , typename... Args>

using fub::HasComputeNumericFluxType = typedef decltype(std::declval<FM>().ComputeNumericFlux(std::declval<Args>()...))

IdealGasConservativeShape

template<int Rank>

using fub::IdealGasConservativeShape = typedef IdealGasMixConservative<ScalarDepth, VectorDepth<Rank>, ScalarDepth, VectorDepth<-1> >

IdealGasMixCompleteShape

template<int Rank>

using fub::IdealGasMixCompleteShape = typedef IdealGasMixComplete<ScalarDepth, VectorDepth<Rank>, ScalarDepth, VectorDepth<-1>, ScalarDepth, ScalarDepth, ScalarDepth, ScalarDepth, ScalarDepth>

index

using fub::index = typedef std::ptrdiff_t

Index

template<int Rank>

using fub::Index = typedef std::array<std::ptrdiff_t, static_cast<std::size_t>(Rank)>

index_constant

template<index I>

using fub::index_constant = typedef std::integral_constant<index, I>

index_sequence

template<std::size_t... Is>

using fub::index_sequence = typedef integer_sequence<std::size_t, Is...>

IndexMappingBase

template<typename Equation >

using fub::IndexMappingBase = typedef boost::mp11::mp_transform<detail::DepthToIndexMappingType, typename Equation::CompleteDepths>

int_constant

template<int I>

using fub::int_constant = typedef std::integral_constant<int, I>

invoke_result_t

template<typename F , typename... Args>

using fub::invoke_result_t = typedef typename invoke_result<F, Args...>::type

IsInvocableT_

template<typename F , typename... Args>

using fub::IsInvocableT_ = typedef decltype(std::declval<F>()(std::declval<Args>()...))

IsProjection

template<typename Proj , typename State >

using fub::IsProjection = typedef is_detected<Projection_t, Proj, State>

Local

template<typename Tag , typename T >

using fub::Local = typedef typename detail::LocalType<Tag, T>::type

make_index_sequence

template<std::size_t N>

using fub::make_index_sequence = typedef make_integer_sequence<std::size_t, N>

make_integer_sequence

template<typename T , T N>

using fub::make_integer_sequence = typedef typename MakeIntegerSequence_<T, N, T{0}>::type

MaskArray

using fub::MaskArray = typedef Array<bool, 1>

mdarray

template<typename ValueType , typename... Is>

using fub::mdarray = typedef basic_mdarray<ValueType, extents<Is...>, layout_left, std_vector_policy>

mdspan_subspan_t

template<class ElementType , class Extents , class LayoutPolicy , class AccessorPolicy , class... SliceSpecifiers>

using fub::mdspan_subspan_t = typedef typename mdspan_subspan<ElementType, Extents, LayoutPolicy, AccessorPolicy, SliceSpecifiers...>::type

negation

template<class Bool >

using fub::negation = typedef std::integral_constant<bool, !bool(Bool::value)>

nodeduce_t

template<typename T >

using fub::nodeduce_t = typedef typename nodeduce<T>::type

PerfectGasCharShape

template<int Rank>

using fub::PerfectGasCharShape = typedef PerfectGasCharacteristics<ScalarDepth, VectorDepth<Rank>, ScalarDepth>

PerfectGasCompleteShape

template<int Rank>

using fub::PerfectGasCompleteShape = typedef PerfectGasComplete<ScalarDepth, VectorDepth<Rank>, ScalarDepth, ScalarDepth, ScalarDepth>

PerfectGasConsShape

template<int Rank>

using fub::PerfectGasConsShape = typedef PerfectGasConservative<ScalarDepth, VectorDepth<Rank>, ScalarDepth>

PerfectGasMixCharShape

template<int Rank>

using fub::PerfectGasMixCharShape = typedef PerfectGasMixCharacteristics<ScalarDepth, VectorDepth<Rank>, ScalarDepth, VectorDepth<-1> >

PerfectGasMixCompleteShape

template<int Rank>

using fub::PerfectGasMixCompleteShape = typedef PerfectGasMixComplete<ScalarDepth, VectorDepth<Rank>, ScalarDepth, VectorDepth<-1>, ScalarDepth, ScalarDepth>

PerfectGasMixConsShape

template<int Rank>

using fub::PerfectGasMixConsShape = typedef PerfectGasMixConservative<ScalarDepth, VectorDepth<Rank>, ScalarDepth, VectorDepth<-1> >

PerfectGasMixKineticStateShape

using fub::PerfectGasMixKineticStateShape = typedef PerfectGasMixKineticState<ScalarDepth, ScalarDepth, VectorDepth<-1> >

PerfectGasMixPrimShape

template<int Rank>

using fub::PerfectGasMixPrimShape = typedef PerfectGasMixPrimitive<ScalarDepth, VectorDepth<Rank>, ScalarDepth, VectorDepth<-1> >

PerfectGasPrimShape

template<int Rank>

using fub::PerfectGasPrimShape = typedef PerfectGasPrimitive<ScalarDepth, VectorDepth<Rank>, ScalarDepth>

ProgramOptions

using fub::ProgramOptions = typedef std::map<std::string, pybind11::object>

Projection_t

template<typename Proj , typename State >

using fub::Projection_t = typedef decltype(std::invoke(std::declval<Proj>(), std::declval<State>()))

remove_cvref_t

template<typename T >

using fub::remove_cvref_t = typedef typename remove_cvref<T>::type

Result

template<typename T , typename E >

using fub::Result = typedef boost::outcome_v2::result<T, E>

RowBase

template<typename State >

using fub::RowBase = typedef typename RowBaseImpl<State>::type

ScalarFluxT

template<typename Eq >

using fub::ScalarFluxT = typedef decltype(std::declval<const Eq&>().Flux(std::declval<Conservative<Eq>&>(), std::declval<const Complete<Eq>&>(), Direction::X))

ScalarReconstructT

template<typename Eq >

using fub::ScalarReconstructT = typedef decltype(std::declval<const Eq&>().Reconstruct( std::declval<Complete<Eq>&>(), std::declval<const Conservative<Eq>&>()))

ScalarStateBase

template<typename Depths >

using fub::ScalarStateBase = typedef boost::mp11::mp_transform<detail::DepthToStateValueType, Depths>

SeverityLogger

using fub::SeverityLogger = typedef boost::log::sources::severity_logger<boost::log::trivial::severity_level>

size_constant

template<std::size_t I>

using fub::size_constant = typedef std::integral_constant<std::size_t, I>

StridedDataView

template<typename T , int Rank>

using fub::StridedDataView = typedef PatchDataView<T, Rank, layout_stride>

tag_invoke_result

template<typename _Tag , typename... _Args>

using fub::tag_invoke_result = typedef invoke_result<decltype(fub::meta::tag_invoke), _Tag, _Args...>

tag_invoke_result_t

template<typename _Tag , typename... _Args>

using fub::tag_invoke_result_t = typedef invoke_result_t<decltype(fub::meta::tag_invoke), _Tag, _Args...>

tag_t

template<auto & T>

using fub::tag_t = typedef std::decay_t<decltype(T)>

ToConcreteDepth

template<typename Depth >

using fub::ToConcreteDepth = typedef typename ToConcreteDepthImpl<Depth>::type

ToConcreteDepths

template<typename Depths >

using fub::ToConcreteDepths = typedef boost::mp11::mp_transform<ToConcreteDepth, Depths>

value_type_t

template<typename Var >

using fub::value_type_t = typedef typename value_type<Var>::type

VectorizedFluxT

template<typename Eq , typename N = int_constant<kDefaultChunkSize>>

using fub::VectorizedFluxT = typedef decltype(std::declval<const Eq&>().Flux( std::declval<ConservativeArray<Eq, N::value>&>(), std::declval<const CompleteArray<Eq, N::value>&>(), Direction::X))

VectorizedReconstructT

template<typename Eq , typename N = int_constant<kDefaultChunkSize>>

using fub::VectorizedReconstructT = typedef decltype(std::declval<const Eq&>().Reconstruct( std::declval<CompleteArray<Eq, N::value>&>(), std::declval<const ConservativeArray<Eq, N::value>&>()))

View

template<typename State , int Rank = State::Equation::Rank()>

using fub::View = typedef BasicView<State, layout_stride, Rank>

ViewBase

template<typename State , typename Layout , int Rank>

using fub::ViewBase = typedef typename detail::ViewBaseImpl<State, Layout, Rank>::type

ViewPointerBase

template<typename State >

using fub::ViewPointerBase = typedef typename detail::ViewPointerBaseImpl<State>::type

void_t

template<class... >

using fub::void_t = typedef void

Enumeration Type Documentation

Direction

enum fub::Direction : std::size_t

strong

This is a type safe type to denote a dimensional split direction.

Enumerator
X
Y
Z

Side

enum fub::Side : int

strong

This is a type safe type to denote a side.

Enumerator
Lower
Upper

TimeStepErrc

enum fub::TimeStepErrc

strong

Enumerator
success
time_step_too_large

Function Documentation

Advance() [1/2]

template<typename T >

void fub::Advance	(	T *&	pointer,
		std::ptrdiff_t	n
	)

Advance() [2/2]

template<typename State >

void fub::Advance ( ViewPointer< State > &  pointer, std::ptrdiff_t  n  )

noexcept

AnyNaN()

template<typename Equation >

bool fub::AnyNaN

(

const Complete< Equation > &

state

)

ApplyGradient()

template<typename State , std::ptrdiff_t Rank>

void fub::ApplyGradient ( State &  u, span< const State, Rank >  grad, nodeduce_t< const Eigen::Matrix< double, Rank, 1 > & >  x  )

noexcept

AsArray() [1/3]

template<typename T , typename... Ts>

constexpr auto fub::AsArray ( const std::tuple< T, Ts... > &  t )

constexpr

AsArray() [2/3]

template<typename Extents >

constexpr std::array<std::ptrdiff_t, Extents::rank()> fub::AsArray ( Extents  e )

constexprnoexcept

AsArray() [3/3]

template<std::size_t... Is, typename T , typename... Ts>

constexpr auto fub::AsArray ( std::index_sequence< Is... >  , const std::tuple< T, Ts... > &  t  )

constexpr

AsCons() [1/9]

template<typename Eq >

ConservativeBase<Eq>& fub::AsCons

(

Complete< Eq > &

x

)

AsCons() [2/9]

template<typename Eq , int N>

ConservativeArrayBase<Eq, N>& fub::AsCons

(

CompleteArray< Eq, N > &

x

)

AsCons() [3/9]

template<typename Eq >

Conservative<Eq>& fub::AsCons

(

Conservative< Eq > &

x

)

AsCons() [4/9]

template<typename Eq , int N>

ConservativeArray<Eq, N>& fub::AsCons

(

ConservativeArray< Eq, N > &

x

)

AsCons() [5/9]

template<typename State , typename L , int R>

auto fub::AsCons

(

const BasicView< State, L, R > &

view

)

AsCons() [6/9]

template<typename Eq >

const ConservativeBase<Eq>& fub::AsCons

(

const Complete< Eq > &

x

)

AsCons() [7/9]

template<typename Eq , int N>

const ConservativeArrayBase<Eq, N>& fub::AsCons

(

const CompleteArray< Eq, N > &

x

)

AsCons() [8/9]

template<typename Eq >

const Conservative<Eq>& fub::AsCons

(

const Conservative< Eq > &

x

)

AsCons() [9/9]

template<typename Eq , int N>

const ConservativeArray<Eq, N>& fub::AsCons

(

const ConservativeArray< Eq, N > &

x

)

AsConst() [1/2]

template<typename State , typename Layout , int Rank>

BasicView<const State, Layout, Rank> fub::AsConst

(

const BasicView< State, Layout, Rank > &

v

)

AsConst() [2/2]

template<typename State >

ViewPointer<std::add_const_t<State> > fub::AsConst ( const ViewPointer< State > &  p )

noexcept

AsEigenVector()

template<std::size_t N>

Eigen::Matrix<double, static_cast<int>N), 1> fub::AsEigenVector

(

const std::array< double, N > &

x

)

AsTuple()

template<typename TupleLike >

constexpr auto fub::AsTuple ( const TupleLike &  t )

constexpr

Ball()

template<std::size_t Rank>

fub::Ball	(	const std::array< double, Rank > &	,
		double
	)		-> Ball< Rank >

BasicView()

template<typename S , typename L , int R>

fub::BasicView

(

const BasicView< S, L, R > &

)

-> BasicView< S, L, R >

Begin() [1/3]

template<typename State , typename Layout , int Rank>

ViewPointer<State> fub::Begin

(

const BasicView< State, Layout, Rank > &

view

)

Begin() [2/3]

template<typename T , int R, typename L >

T* fub::Begin

(

const PatchDataView< T, R, L > &

pdv

)

Begin() [3/3]

template<typename State >

ViewPointer<State> fub::Begin

(

const Row< State > &

row

)

Box()

template<int N, typename State , typename Layout , int Rank>

IndexBox<Rank> fub::Box

(

const BasicView< State, Layout, Rank > &

view

)

clamp() [1/2]

template<class T >

constexpr const T& fub::clamp ( const T &  v, const T &  lo, const T &  hi  )

constexpr

clamp() [2/2]

template<class T , class Compare >

constexpr const T& fub::clamp ( const T &  v, const T &  lo, const T &  hi, Compare  comp  )

constexpr

CompleteFromPrim() [1/4]

template<int Rank>

void fub::CompleteFromPrim	(	const PerfectGas< Rank > &	equation,
		Complete< PerfectGas< Rank >> &	complete,
		const Primitive< PerfectGas< Rank >> &	prim
	)

CompleteFromPrim() [2/4]

template<int Rank>

void fub::CompleteFromPrim	(	const PerfectGas< Rank > &	equation,
		CompleteArray< PerfectGas< Rank >> &	complete,
		const PrimitiveArray< PerfectGas< Rank >> &	prim
	)

CompleteFromPrim() [3/4]

template<int Rank>

void fub::CompleteFromPrim	(	const PerfectGasMix< Rank > &	equation,
		Complete< PerfectGasMix< Rank >> &	complete,
		const Primitive< PerfectGasMix< Rank >> &	prim
	)

CompleteFromPrim() [4/4]

template<int Rank>

void fub::CompleteFromPrim	(	const PerfectGasMix< Rank > &	equation,
		CompleteArray< PerfectGasMix< Rank >> &	complete,
		const PrimitiveArray< PerfectGasMix< Rank >> &	prim
	)

ComputeAmplitudes() [1/2]

template<typename Equation >

void fub::ComputeAmplitudes	(	Characteristics< Equation > &	amplitudes,
		const Primitive< Equation > &	left,
		const Primitive< Equation > &	right,
		double	rhoc,
		double	ooc2,
		double	dx,
		int	ix
	)

ComputeAmplitudes() [2/2]

template<typename Equation >

void fub::ComputeAmplitudes	(	CharacteristicsArray< Equation > &	amplitudes,
		const PrimitiveArray< Equation > &	left,
		const PrimitiveArray< Equation > &	right,
		Array1d	rhoc,
		Array1d	ooc2,
		double	dx,
		int	ix
	)

ComputeReflectedCoordinates()

Coordinates<2> fub::ComputeReflectedCoordinates ( const Coordinates< 2 > &  offset, const Coordinates< 2 > &  boundary_normal  )

inline

ComputeStableFluxComponents() [1/2]

void fub::ComputeStableFluxComponents	(	const PatchDataView< double, 2, layout_stride > &	stabilised_fluxes,
		const PatchDataView< double, 2, layout_stride > &	shielded_left_fluxes,
		const PatchDataView< double, 2, layout_stride > &	shielded_right_fluxes,
		const PatchDataView< const double, 2, layout_stride > &	regular_fluxes,
		const PatchDataView< const double, 2, layout_stride > &	boundary_fluxes,
		const CutCellData< 2 > &	geom,
		Duration	dt,
		double	dx,
		Direction	dir
	)

ComputeStableFluxComponents() [2/2]

void fub::ComputeStableFluxComponents	(	const PatchDataView< double, 3, layout_stride > &	stabilised_fluxes,
		const PatchDataView< double, 3, layout_stride > &	shielded_left_fluxes,
		const PatchDataView< double, 3, layout_stride > &	shielded_right_fluxes,
		const PatchDataView< const double, 3, layout_stride > &	regular_fluxes,
		const PatchDataView< const double, 3, layout_stride > &	boundary_fluxes,
		const CutCellData< 3 > &	geom,
		Duration	dt,
		double	dx,
		Direction	dir
	)

Contains() [1/2]

template<int Rank>

bool fub::Contains	(	const IndexBox< Rank > &	b1,
		const IndexBox< Rank > &	b2
	)

Contains() [2/2]

template<int Rank>

bool fub::Contains	(	const IndexBox< Rank > &	box,
		const Index< Rank > &	index
	)

CopyFromBuffer() [1/2]

template<typename Equation >

void fub::CopyFromBuffer	(	Complete< Equation > &	state,
		span< const double >	buffer
	)

CopyFromBuffer() [2/2]

template<typename Equation >

void fub::CopyFromBuffer	(	Conservative< Equation > &	state,
		span< const double >	buffer
	)

CopyToBuffer()

template<typename Equation >

void fub::CopyToBuffer	(	span< double >	buffer,
		const Conservative< Equation > &	state
	)

count_dynamic_extents()

template<typename... IndexType>

constexpr std::size_t fub::count_dynamic_extents ( IndexType...  extent )

constexprnoexcept

Drop() [1/2]

template<std::size_t N, typename... Ts>

constexpr auto fub::Drop ( const std::tuple< Ts... > &  t )

constexpr

Drop() [2/2]

template<std::size_t N, std::size_t... Is, typename... Ts>

constexpr auto fub::Drop ( std::index_sequence< Is... >  , const std::tuple< Ts... > &  t  )

constexpr

Embed()

template<int Rank>

IndexBox<Rank> fub::Embed	(	const IndexBox< Rank - 1 > &	box,
		const std::array< std::ptrdiff_t, 2 > &	limits
	)

EmbedIndex()

template<int Rank>

Index<Rank + 1> fub::EmbedIndex	(	const Index< Rank > &	index,
		Direction	dir
	)

EmbedInSpace()

template<std::size_t DestRank, std::size_t SrcRank>

std::array<std::ptrdiff_t, DestRank> fub::EmbedInSpace

(

const std::array< std::ptrdiff_t, SrcRank > &

index

)

End() [1/3]

template<typename State , typename Layout , int Rank>

ViewPointer<State> fub::End

(

const BasicView< State, Layout, Rank > &

view

)

End() [2/3]

template<typename T , int R, typename L >

T* fub::End

(

const PatchDataView< T, R, L > &

pdv

)

End() [3/3]

template<typename State >

ViewPointer<State> fub::End

(

const Row< State > &

row

)

Extent() [1/2]

template<Direction Dir, typename T , typename L , int R>

std::ptrdiff_t fub::Extent

(

const BasicView< T, L, R > &

view

)

Extent() [2/2]

template<Direction Dir, typename T , int R, typename L >

std::ptrdiff_t fub::Extent

(

const PatchDataView< T, R, L > &

pdv

)

Extents()

template<int N, typename State , typename Layout , int Rank>

dynamic_extents<static_cast<std::size_t>Rank)> fub::Extents

(

const BasicView< State, Layout, Rank > &

view

)

Flux() [1/3]

template<typename Eq , typename Equation = std::decay_t<Eq>>

void fub::Flux	(	Eq &&	equation,
		Conservative< Equation > &	flux,
		const Complete< Equation > &	state,
		Direction	dir,
		[[maybe_unused] ] double	x = 0.0
	)

Flux() [2/3]

template<typename Eq , typename Equation = std::decay_t<Eq>>

void fub::Flux	(	Eq &&	equation,
		ConservativeArray< Equation > &	flux,
		const CompleteArray< Equation > &	state,
		Direction	dir,
		[[maybe_unused] ] double	x = 0.0
	)

Flux() [3/3]

template<typename Eq , typename Equation = std::decay_t<Eq>>

void fub::Flux	(	Eq &&	equation,
		ConservativeArray< Equation > &	flux,
		const CompleteArray< Equation > &	state,
		MaskArray	mask,
		Direction	dir,
		[[maybe_unused] ] double	x = 0.0
	)

ForEachComponent()

template<typename F , typename... Ts>

void fub::ForEachComponent	(	F	function,
		Ts &&...	states
	)

ForEachIndex()

template<int Rank, typename Function >

Function fub::ForEachIndex	(	const IndexBox< Rank > &	box,
		Function	function
	)

ForEachRow()

template<typename Tuple , typename Function >

void fub::ForEachRow	(	const Tuple &	views,
		Function	f
	)

ForEachVariable()

template<typename F , typename... Ts>

void fub::ForEachVariable	(	F	function,
		Ts &&...	states
	)

FormatTimeStepLine()

std::string fub::FormatTimeStepLine	(	std::ptrdiff_t	cycle,
		std::chrono::duration< double >	time_point,
		std::chrono::duration< double >	time_step_size,
		std::chrono::duration< double >	final_time,
		std::chrono::steady_clock::duration	wall_time,
		std::chrono::steady_clock::duration	wall_time_difference
	)

get()

template<std::size_t I, typename State >

constexpr decltype(auto) fub::get ( State &&  x )

constexpr

GetAbsoluteBoundaryCentroid()

template<int Rank>

Eigen::Matrix<double, Rank, 1> fub::GetAbsoluteBoundaryCentroid	(	const CutCellData< Rank > &	geom,
		const Index< Rank > &	index,
		const Eigen::Matrix< double, Rank, 1 > &	dx
	)

GetAbsoluteVolumeCentroid()

template<int Rank>

Eigen::Matrix<double, Rank, 1> fub::GetAbsoluteVolumeCentroid	(	const CutCellData< Rank > &	geom,
		const Index< Rank > &	index,
		const Eigen::Matrix< double, Rank, 1 > &	dx
	)

GetBoundaryCentroid() [1/2]

Eigen::Vector2d fub::GetBoundaryCentroid	(	const CutCellData< 2 > &	ccdata,
		const std::array< std::ptrdiff_t, 2 > &	index
	)

GetBoundaryCentroid() [2/2]

Eigen::Vector3d fub::GetBoundaryCentroid	(	const CutCellData< 3 > &	ccdata,
		const std::array< std::ptrdiff_t, 3 > &	index
	)

GetBoundaryNormal() [1/2]

Eigen::Vector2d fub::GetBoundaryNormal	(	const CutCellData< 2 > &	ccdata,
		const std::array< std::ptrdiff_t, 2 > &	index
	)

GetBoundaryNormal() [2/2]

Eigen::Vector3d fub::GetBoundaryNormal	(	const CutCellData< 3 > &	ccdata,
		const std::array< std::ptrdiff_t, 3 > &	index
	)

GetInfoLogger()

SeverityLogger fub::GetInfoLogger ( )

inline

GetLogger()

SeverityLogger fub::GetLogger ( boost::log::trivial::severity_level  level )

inline

GetOffset()

template<std::size_t Rank>

Eigen::Matrix<double, Rank, 1> fub::GetOffset

(

const std::array< std::ptrdiff_t, Rank > &

index

)

GetOptionOr() [1/5]

template<>

::amrex::Box fub::GetOptionOr	(	const ProgramOptions &	map,
		const std::string &	name,
		const ::amrex::Box &	value
	)

GetOptionOr() [2/5]

template<>

::amrex::IntVect fub::GetOptionOr	(	const ProgramOptions &	map,
		const std::string &	name,
		const ::amrex::IntVect &	value
	)

GetOptionOr() [3/5]

template<>

::amrex::RealBox fub::GetOptionOr	(	const ProgramOptions &	map,
		const std::string &	name,
		const ::amrex::RealBox &	value
	)

GetOptionOr() [4/5]

template<>

Direction fub::GetOptionOr	(	const ProgramOptions &	map,
		const std::string &	name,
		const Direction &	value
	)

GetOptionOr() [5/5]

template<typename T >

T fub::GetOptionOr	(	const ProgramOptions &	map,
		const std::string &	name,
		const T &	value
	)

GetOptions()

ProgramOptions fub::GetOptions	(	const ProgramOptions &	options,
		const std::string &	name
	)

GetOrForward() [1/2]

template<int N, typename T >

constexpr decltype(auto) fub::GetOrForward ( const ViewPointer< T > &  pointer )

constexprnoexcept

GetOrForward() [2/2]

template<int N, typename T >

constexpr T* fub::GetOrForward ( T *  pointer )

constexprnoexcept

GetSign()

int fub::GetSign ( int  side )

inline

GetUnshieldedCentroid()

Eigen::Vector2d fub::GetUnshieldedCentroid	(	const CutCellData< 2 > &	geom,
		const Index< 2 > &	face,
		const Eigen::Vector2d &	dx,
		Direction	dir
	)

GetVolumeCentroid() [1/2]

Eigen::Vector2d fub::GetVolumeCentroid	(	const CutCellData< 2 > &	ccdata,
		const std::array< std::ptrdiff_t, 2 > &	index
	)

GetVolumeCentroid() [2/2]

Eigen::Vector3d fub::GetVolumeCentroid	(	const CutCellData< 3 > &	ccdata,
		const std::array< std::ptrdiff_t, 3 > &	index
	)

GodunovMethod()

template<typename Equation >

fub::GodunovMethod

(

const Equation &

eq

)

-> GodunovMethod< Equation >

GradientDetector()

template<typename Eq , typename... Ps>

fub::GradientDetector	(	const Eq &	,
		const std::pair< Ps, double > &	...
	)		-> GradientDetector< Eq, Ps... >

Grow()

template<int Rank>

IndexBox<Rank> fub::Grow	(	const IndexBox< Rank > &	box,
		Direction	dir,
		const std::array< std::ptrdiff_t, 2 > &	shifts
	)

Head()

template<typename T , typename... Ts>

T fub::Head	(	T &&	head,
		Ts &&	...
	)

Hll()

template<typename Equation , typename Signals >

fub::Hll	(	const Equation &	eq,
		const Signals &	signals
	)		-> Hll< Equation, Signals >

HllMethod()

template<typename Equation , typename Signals >

fub::HllMethod	(	const Equation &	eq,
		const Signals &	signals
	)		-> HllMethod< Equation, Signals >

InitializeLogging()

void fub::InitializeLogging	(	MPI_Comm	comm,
		const LogOptions &	log = {}
	)

Intersect() [1/2]

template<int Rank>

IndexBox<Rank> fub::Intersect	(	const IndexBox< Rank > &	b1,
		const IndexBox< Rank > &	b2
	)

Intersect() [2/2]

std::array<double, 2> fub::Intersect ( const std::array< double, 2 > &  i1, const std::array< double, 2 > &  i2  )

inline

ipow()

constexpr std::ptrdiff_t fub::ipow ( int  base, int  exponent  )

constexpr

IsCutCell() [1/2]

bool fub::IsCutCell	(	const CutCellData< 2 > &	geom,
		const std::array< std::ptrdiff_t, 2 > &	index
	)

IsCutCell() [2/2]

bool fub::IsCutCell	(	const CutCellData< 3 > &	geom,
		const std::array< std::ptrdiff_t, 3 > &	index
	)

KineticEnergy() [1/3]

template<int Dim>

Array1d fub::KineticEnergy ( Array1d  density, const Eigen::Array< double, Dim, kDefaultChunkSize, Eigen::RowMajor > &  momentum  )

noexcept

KineticEnergy() [2/3]

template<int Dim>

Array1d fub::KineticEnergy ( Array1d  density, const Eigen::Array< double, Dim, kDefaultChunkSize, Eigen::RowMajor > &  momentum, MaskArray  mask  )

noexcept

KineticEnergy() [3/3]

template<int Dim>

double fub::KineticEnergy ( double  density, const Eigen::Array< double, Dim, 1 > &  momentum  )

noexcept

LeftTo()

template<std::size_t N>

std::array<std::ptrdiff_t, N> fub::LeftTo	(	const std::array< std::ptrdiff_t, N > &	idx,
		Direction	dir,
		std::ptrdiff_t	shift = 1
	)

Load() [1/13]

template<typename Eq , int N>

void fub::Load	(	Complete< Eq > &	q,
		const CompleteArray< Eq, N > &	qs,
		int	i
	)

Load() [2/13]

template<typename Eq >

void fub::Load	(	Complete< Eq > &	state,
		nodeduce_t< ViewPointer< const Complete< Eq >>>	pointer
	)

Load() [3/13]

template<typename Eq >

void fub::Load	(	CompleteArray< Eq > &	state,
		nodeduce_t< ViewPointer< const Complete< Eq >>>	pointer
	)

Load() [4/13]

template<typename Eq , int N, typename Layout , int Rank>

void fub::Load	(	CompleteArray< Eq, N > &	state,
		const BasicView< const Complete< Eq >, Layout, Rank > &	view,
		nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & >	index
	)

Load() [5/13]

template<typename Eq , int N>

void fub::Load	(	Conservative< Eq > &	q,
		const ConservativeArray< Eq, N > &	qs,
		int	i
	)

Load() [6/13]

template<typename Eq >

void fub::Load	(	Conservative< Eq > &	state,
		nodeduce_t< ViewPointer< const Conservative< Eq >>>	pointer
	)

Load() [7/13]

template<typename Eq >

void fub::Load	(	ConservativeArray< Eq > &	state,
		nodeduce_t< ViewPointer< const Conservative< Eq >>>	pointer
	)

Load() [8/13]

template<typename Eq , int N, typename Layout , int Rank>

void fub::Load	(	ConservativeArray< Eq, N > &	state,
		const BasicView< const Conservative< Eq >, Layout, Rank > &	view,
		nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & >	index
	)

Load() [9/13]

template<typename Eq , int N, typename Layout , std::size_t Rank>

void fub::Load	(	ConservativeArray< Eq, N > &	state,
		nodeduce_t< const BasicView< const Conservative< Eq >, Layout, static_cast< int >(Rank)> & >	view,
		std::array< std::ptrdiff_t, Rank >	index
	)

Load() [10/13]

template<typename T , int Rank, typename Layout , typename... Indices>

auto fub::Load	(	const PatchDataView< T, Rank, Layout > &	pdv,
		Indices...	indices
	)

Load() [11/13]

template<int N, typename T , int Rank, typename Layout , typename... Indices>

Eigen::Array<std::remove_cv_t<T>, N, 1> fub::Load	(	int_constant< N >	n,
		const PatchDataView< T, Rank, Layout > &	pdv,
		Indices...	indices
	)

Load() [12/13]

template<typename State , typename Layout , int Rank>

void fub::Load	(	State &	state,
		const BasicView< const State, Layout, Rank > &	view,
		const std::array< std::ptrdiff_t, State::Equation::Rank()> &	index
	)

Load() [13/13]

template<typename State , typename Layout , int Rank>

void fub::Load	(	State &	state,
		const BasicView< State, Layout, Rank > &	view,
		const std::array< std::ptrdiff_t, State::Equation::Rank()> &	index
	)

LoadN() [1/7]

void fub::LoadN ( Array< char, 1 > &  array, const char *  pointer, int  n  )

inline

LoadN() [2/7]

template<typename Eq >

void fub::LoadN	(	CompleteArray< Eq > &	state,
		nodeduce_t< ViewPointer< const Complete< Eq >>>	pointer,
		int	n
	)

LoadN() [3/7]

template<typename Eq , int N, typename Layout , int Rank>

void fub::LoadN	(	CompleteArray< Eq, N > &	state,
		const BasicView< const Complete< Eq >, Layout, Rank > &	view,
		int	size,
		nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & >	pos
	)

LoadN() [4/7]

template<typename Eq >

void fub::LoadN	(	ConservativeArray< Eq > &	state,
		nodeduce_t< ViewPointer< const Conservative< Eq >>>	pointer,
		int	n
	)

LoadN() [5/7]

template<typename Eq , int N, typename Layout , int Rank>

void fub::LoadN	(	ConservativeArray< Eq, N > &	state,
		const BasicView< const Conservative< Eq >, Layout, Rank > &	view,
		int	size,
		nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & >	pos
	)

LoadN() [6/7]

template<int N, typename T , int Rank, typename Layout , typename... Indices>

Eigen::Array<std::remove_cv_t<T>, N, 1> fub::LoadN	(	int_constant< N >	,
		const PatchDataView< T, Rank, Layout > &	pdv,
		int	size,
		nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & >	index
	)

LoadN() [7/7]

template<int N, typename T , int Rank, typename Layout , typename... Indices>

std::enable_if_t<boost::mp11::mp_all<std::is_integral<Indices>...>::value, Eigen::Array<std::remove_cv_t<T>, N, 1> > fub::LoadN	(	int_constant< N >	,
		const PatchDataView< T, Rank, Layout > &	pdv,
		int	size,
		std::ptrdiff_t	i0,
		Indices...	indices
	)

Log()

void fub::Log	(	std::string	message,
		Duration	timepoint,
		boost::log::trivial::severity_level	level = boost::log::trivial::severity_level::info
	)

make_error_code() [1/2]

std::error_code fub::make_error_code ( const TimeStepTooLarge &  )

inline

make_error_code() [2/2]

std::error_code fub::make_error_code ( TimeStepErrc  error )

inline

make_span() [1/5]

template<class Container >

auto fub::make_span

(

const Container &

array

)

-> span<const typename Container::value_type>

make_span() [2/5]

template<class T , size_t N>

auto fub::make_span

(

const std::array< T, N > &

array

)

-> span<const T, static_cast<std::ptrdiff_t>(N)>

make_span() [3/5]

template<class Container >

auto fub::make_span

(

Container &

array

)

-> span<typename Container::value_type>

make_span() [4/5]

template<class T , size_t N>

auto fub::make_span

(

std::array< T, N > &

array

)

-> span<T, static_cast<std::ptrdiff_t>(N)>

make_span() [5/5]

template<class T , size_t N>

auto fub::make_span

(

T(&)

array[N]

)

-> span<T, static_cast<std::ptrdiff_t>(N)>

MakeBackup()

template<typename DestGrid , typename SrcGrid >

void fub::MakeBackup	(	std::shared_ptr< DestGrid > &	dest,
		const std::shared_ptr< SrcGrid > &	src,
		CounterRegistry &	counter_database
	)

MakeOutput()

template<typename Grid , typename Fn >

std::unique_ptr<AsOutput<Grid, Fn> > fub::MakeOutput	(	std::vector< std::ptrdiff_t >	frequencies,
		std::vector< Duration >	intervals,
		Fn	fn
	)

MakeRotation() [1/2]

Eigen::Matrix<double, 2, 2> fub::MakeRotation ( const Eigen::Matrix< double, 2, 1 > &  a, const Eigen::Matrix< double, 2, 1 > &  b  )

inline

MakeRotation() [2/2]

Eigen::Matrix<double, 3, 3> fub::MakeRotation ( const Eigen::Matrix< double, 3, 1 > &  a, const Eigen::Matrix< double, 3, 1 > &  b  )

inline

MakeUniqueName()

std::string fub::MakeUniqueName ( )

inline

Mapping()

template<int N, typename State , typename Layout , int Rank>

Layout::template mapping< dynamic_extents<static_cast<std::size_t>Rank)> > fub::Mapping

(

const BasicView< State, Layout, Rank > &

view

)

mask_load()

template<typename Abi >

Vc::Vector<double, Abi> fub::mask_load	(	const double *	p,
		Vc::Mask< double, Abi >	mask
	)

Min() [1/2]

template<typename T >

const T& fub::Min

(

const OmpLocal< T > &

x

)

Min() [2/2]

template<typename T >

const T& fub::Min

(

const std::optional< T > &

x

)

MinAll()

Duration fub::MinAll	(	MPI_Comm	comm,
		Duration	local_duration
	)

MusclHancockMethod() [1/2]

template<typename Equation >

fub::MusclHancockMethod

(

const Equation &

)

-> MusclHancockMethod< Equation >

MusclHancockMethod() [2/2]

template<typename Equation , typename Method >

fub::MusclHancockMethod	(	const Equation &	,
		const Method &
	)		-> MusclHancockMethod< Equation, Method >

MyCutCellMethod()

template<typename Equation , typename FluxMethod >

fub::MyCutCellMethod	(	const Equation &	,
		const FluxMethod &
	)		-> MyCutCellMethod< Equation, FluxMethod >

MyStab_ComputeStableFluxComponents() [1/2]

void fub::MyStab_ComputeStableFluxComponents	(	const PatchDataView< double, 2, layout_stride > &	stabilised_fluxes,
		const PatchDataView< double, 2, layout_stride > &	shielded_left_fluxes,
		const PatchDataView< double, 2, layout_stride > &	shielded_right_fluxes,
		const PatchDataView< const double, 2, layout_stride > &	regular_fluxes,
		const PatchDataView< const double, 2, layout_stride > &	boundary_fluxes,
		const CutCellData< 2 > &	geom,
		Duration	dt,
		double	dx,
		Direction	dir
	)

MyStab_ComputeStableFluxComponents() [2/2]

void fub::MyStab_ComputeStableFluxComponents	(	const PatchDataView< double, 3, layout_stride > &	stabilised_fluxes,
		const PatchDataView< double, 3, layout_stride > &	shielded_left_fluxes,
		const PatchDataView< double, 3, layout_stride > &	shielded_right_fluxes,
		const PatchDataView< const double, 3, layout_stride > &	regular_fluxes,
		const PatchDataView< const double, 3, layout_stride > &	boundary_fluxes,
		const CutCellData< 3 > &	geom,
		Duration	dt,
		double	dx,
		Direction	dir
	)

NewtonIteration()

template<typename Function , typename Derivative >

double fub::NewtonIteration	(	Function &&	f,
		Derivative &&	Df,
		double	x0,
		double	tolerance = 1e-7,
		int	max_iterations = 5000
	)

operator!=() [1/2]

template<std::ptrdiff_t... StaticExtentsL, std::ptrdiff_t... StaticExtentsR>

constexpr bool fub::operator!= ( const extents< StaticExtentsL... > &  left, const extents< StaticExtentsR... > &  right  )

constexprnoexcept

operator!=() [2/2]

template<int Rank>

bool fub::operator!=	(	const IndexBox< Rank > &	b1,
		const IndexBox< Rank > &	b2
	)

operator==() [1/2]

template<std::ptrdiff_t... StaticExtentsL, std::ptrdiff_t... StaticExtentsR>

constexpr bool fub::operator== ( const extents< StaticExtentsL... > &  lhs, const extents< StaticExtentsR... > &  rhs  )

constexprnoexcept

Returns: true if lhs.rank() == rhs.rank() and lhs.extents(r) == rhs.extents(r) for all r in the range [0, lhs.rank()), or false otherwise.

operator==() [2/2]

template<int Rank>

bool fub::operator==	(	const IndexBox< Rank > &	b1,
		const IndexBox< Rank > &	b2
	)

overloaded()

template<class... Ts>

fub::overloaded

(

Ts...

)

-> overloaded< Ts... >

ParseCommandLine()

std::optional<ProgramOptions> fub::ParseCommandLine	(	int	argc,
		char **	argv
	)

ParsePythonScript()

ProgramOptions fub::ParsePythonScript	(	const boost::filesystem::path &	path,
		MPI_Comm	comm
	)

PrimFromComplete() [1/4]

template<int Rank>

void fub::PrimFromComplete	(	const PerfectGas< Rank > &	,
		Primitive< PerfectGas< Rank >> &	prim,
		const Complete< PerfectGas< Rank >> &	complete
	)

PrimFromComplete() [2/4]

template<int Rank>

void fub::PrimFromComplete	(	const PerfectGas< Rank > &	,
		PrimitiveArray< PerfectGas< Rank >> &	prim,
		const CompleteArray< PerfectGas< Rank >> &	complete
	)

PrimFromComplete() [3/4]

template<int Rank>

void fub::PrimFromComplete	(	const PerfectGasMix< Rank > &	equation,
		Primitive< PerfectGasMix< Rank >> &	prim,
		const Complete< PerfectGasMix< Rank >> &	complete
	)

PrimFromComplete() [4/4]

template<int Rank>

void fub::PrimFromComplete	(	const PerfectGasMix< Rank > &	equation,
		PrimitiveArray< PerfectGasMix< Rank >> &	prim,
		const CompleteArray< PerfectGasMix< Rank >> &	complete
	)

Project()

template<int Rank, int OtherRank>

IndexBox<Rank> fub::Project

(

const IndexBox< OtherRank > &

box

)

ReadAndBroadcastFile()

std::string fub::ReadAndBroadcastFile	(	std::string	filepath,
		MPI_Comm	comm
	)

ReadPointsFromFile()

Eigen::Matrix<double, 3, Eigen::Dynamic> fub::ReadPointsFromFile

(

const std::string &

filename

)

Reduceall()

Result<void, TimeStepTooLarge> fub::Reduceall	(	MPI_Comm	comm,
		Result< void, TimeStepTooLarge >	result
	)

Reflect() [1/15]

void fub::Reflect	(	Complete< IdealGasMix< 1 >> &	reflected,
		const Complete< IdealGasMix< 1 >> &	state,
		const Eigen::Matrix< double, 1, 1 > &	normal,
		const IdealGasMix< 1 > &	gas
	)

Reflect() [2/15]

void fub::Reflect	(	Complete< IdealGasMix< 2 >> &	reflected,
		const Complete< IdealGasMix< 2 >> &	state,
		const Eigen::Vector2d &	normal,
		const IdealGasMix< 2 > &	gas
	)

Reflect() [3/15]

void fub::Reflect	(	Complete< IdealGasMix< 3 >> &	reflected,
		const Complete< IdealGasMix< 3 >> &	state,
		const Eigen::Vector3d &	normal,
		const IdealGasMix< 3 > &	gas
	)

Reflect() [4/15]

void fub::Reflect	(	Complete< PerfectGas< 1 >> &	reflected,
		const Complete< PerfectGas< 1 >> &	state,
		const Eigen::Matrix< double, 1, 1 > &	normal,
		const PerfectGas< 1 > &	gas
	)

Reflect() [5/15]

void fub::Reflect	(	Complete< PerfectGas< 2 >> &	reflected,
		const Complete< PerfectGas< 2 >> &	state,
		const Eigen::Vector2d &	normal,
		const PerfectGas< 2 > &	gas
	)

Reflect() [6/15]

void fub::Reflect	(	Complete< PerfectGas< 3 >> &	reflected,
		const Complete< PerfectGas< 3 >> &	state,
		const Eigen::Vector3d &	normal,
		const PerfectGas< 3 > &	gas
	)

Reflect() [7/15]

void fub::Reflect	(	Complete< PerfectGasMix< 1 >> &	reflected,
		const Complete< PerfectGasMix< 1 >> &	state,
		const Eigen::Matrix< double, 1, 1 > &	normal,
		const PerfectGasMix< 1 > &	gas
	)

Reflect() [8/15]

void fub::Reflect	(	Complete< PerfectGasMix< 2 >> &	reflected,
		const Complete< PerfectGasMix< 2 >> &	state,
		const Eigen::Vector2d &	normal,
		const PerfectGasMix< 2 > &	gas
	)

Reflect() [9/15]

void fub::Reflect	(	Complete< PerfectGasMix< 3 >> &	reflected,
		const Complete< PerfectGasMix< 3 >> &	state,
		const Eigen::Vector3d &	normal,
		const PerfectGasMix< 3 > &	gas
	)

Reflect() [10/15]

void fub::Reflect	(	Conservative< PerfectGas< 1 >> &	reflected,
		const Conservative< PerfectGas< 1 >> &	state,
		const Eigen::Matrix< double, 1, 1 > &	normal,
		const PerfectGas< 1 > &	gas
	)

Reflect() [11/15]

void fub::Reflect	(	Conservative< PerfectGas< 2 >> &	reflected,
		const Conservative< PerfectGas< 2 >> &	state,
		const Eigen::Vector2d &	normal,
		const PerfectGas< 2 > &	gas
	)

Reflect() [12/15]

void fub::Reflect	(	Conservative< PerfectGas< 3 >> &	reflected,
		const Conservative< PerfectGas< 3 >> &	state,
		const Eigen::Vector3d &	normal,
		const PerfectGas< 3 > &	gas
	)

Reflect() [13/15]

void fub::Reflect	(	Conservative< PerfectGasMix< 1 >> &	reflected,
		const Conservative< PerfectGasMix< 1 >> &	state,
		const Eigen::Matrix< double, 1, 1 > &	normal,
		const PerfectGasMix< 1 > &	gas
	)

Reflect() [14/15]

void fub::Reflect	(	Conservative< PerfectGasMix< 2 >> &	reflected,
		const Conservative< PerfectGasMix< 2 >> &	state,
		const Eigen::Vector2d &	normal,
		const PerfectGasMix< 2 > &	gas
	)

Reflect() [15/15]

void fub::Reflect	(	Conservative< PerfectGasMix< 3 >> &	reflected,
		const Conservative< PerfectGasMix< 3 >> &	state,
		const Eigen::Vector3d &	normal,
		const PerfectGasMix< 3 > &	gas
	)

ReflectIndex() [1/3]

Index<1> fub::ReflectIndex	(	Index< 1 >	i,
		const IndexBox< 1 > &	domain,
		Direction	dir,
		int	side
	)

ReflectIndex() [2/3]

Index<2> fub::ReflectIndex	(	Index< 2 >	i,
		const IndexBox< 2 > &	domain,
		Direction	dir,
		int	side
	)

ReflectIndex() [3/3]

Index<3> fub::ReflectIndex	(	Index< 3 >	i,
		const IndexBox< 3 > &	domain,
		Direction	dir,
		int	side
	)

RelativeCellIndex()

template<int Rank>

Index<Rank> fub::RelativeCellIndex	(	const Coordinates< Rank > &	x,
		const Coordinates< Rank > &	dx
	)

ResetHierarchyConfigurationIfDetected()

template<typename T , typename Grid >

void fub::ResetHierarchyConfigurationIfDetected	(	T &&	obj,
		Grid &&	grid
	)

Invokes member function obj.ResetHierarchyConfiguration(grid)

This is a helper function which invokes ResetHierarchyConfiguration if the specified object obj has such a member function. If obj does not have such a member function the function body will be empty.

This functionality is used by generic algorithms in include/fub/solver/*

RightTo()

template<std::size_t N>

std::array<std::ptrdiff_t, N> fub::RightTo	(	const std::array< std::ptrdiff_t, N > &	idx,
		Direction	dir,
		std::ptrdiff_t	shift = 1
	)

Rotate() [1/12]

void fub::Rotate	(	Complete< IdealGasMix< 2 >> &	rotated,
		const Complete< IdealGasMix< 2 >> &	state,
		const Eigen::Matrix< double, 2, 2 > &	rotation,
		const IdealGasMix< 2 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [2/12]

void fub::Rotate	(	Complete< IdealGasMix< 3 >> &	rotated,
		const Complete< IdealGasMix< 3 >> &	state,
		const Eigen::Matrix< double, 3, 3 > &	rotation,
		const IdealGasMix< 3 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [3/12]

void fub::Rotate	(	Complete< PerfectGas< 2 >> &	rotated,
		const Complete< PerfectGas< 2 >> &	state,
		const Eigen::Matrix< double, 2, 2 > &	rotation,
		const PerfectGas< 2 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [4/12]

void fub::Rotate	(	Complete< PerfectGas< 3 >> &	rotated,
		const Complete< PerfectGas< 3 >> &	state,
		const Eigen::Matrix< double, 3, 3 > &	rotation,
		const PerfectGas< 3 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [5/12]

void fub::Rotate	(	Complete< PerfectGasMix< 2 >> &	rotated,
		const Complete< PerfectGasMix< 2 >> &	state,
		const Eigen::Matrix< double, 2, 2 > &	rotation,
		const PerfectGasMix< 2 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [6/12]

void fub::Rotate	(	Complete< PerfectGasMix< 3 >> &	rotated,
		const Complete< PerfectGasMix< 3 >> &	state,
		const Eigen::Matrix< double, 3, 3 > &	rotation,
		const PerfectGasMix< 3 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [7/12]

void fub::Rotate	(	Conservative< IdealGasMix< 2 >> &	rotated,
		const Conservative< IdealGasMix< 2 >> &	state,
		const Eigen::Matrix< double, 2, 2 > &	rotation,
		const IdealGasMix< 2 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [8/12]

void fub::Rotate	(	Conservative< IdealGasMix< 3 >> &	rotated,
		const Conservative< IdealGasMix< 3 >> &	state,
		const Eigen::Matrix< double, 3, 3 > &	rotation,
		const IdealGasMix< 3 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [9/12]

void fub::Rotate	(	Conservative< PerfectGas< 2 >> &	rotated,
		const Conservative< PerfectGas< 2 >> &	state,
		const Eigen::Matrix< double, 2, 2 > &	rotation,
		const PerfectGas< 2 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [10/12]

void fub::Rotate	(	Conservative< PerfectGas< 3 >> &	rotated,
		const Conservative< PerfectGas< 3 >> &	state,
		const Eigen::Matrix< double, 3, 3 > &	rotation,
		const PerfectGas< 3 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [11/12]

void fub::Rotate	(	Conservative< PerfectGasMix< 2 >> &	rotated,
		const Conservative< PerfectGasMix< 2 >> &	state,
		const Eigen::Matrix< double, 2, 2 > &	rotation,
		const PerfectGasMix< 2 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

Rotate() [12/12]

void fub::Rotate	(	Conservative< PerfectGasMix< 3 >> &	rotated,
		const Conservative< PerfectGasMix< 3 >> &	state,
		const Eigen::Matrix< double, 3, 3 > &	rotation,
		const PerfectGasMix< 3 > &
	)

Defines how to rotate a given state of the euler equations.

This function is needed when computing the reference state in the boundary flux of the cut-cell stabilizations.

RunSimulation()

template<typename Solver , typename Grid = std::decay_t< decltype(*std::declval<Solver&>().GetGriddingAlgorithm())>>

void fub::RunSimulation	(	Solver &	solver,
		RunOptions	options,
		std::chrono::steady_clock::time_point	wall_time_reference,
		BasicOutput< Grid > &	output
	)

Shift() [1/2]

template<int Rank>

Eigen::Matrix<double, Rank, 1> fub::Shift	(	const Eigen::Matrix< double, Rank, 1 > &	v,
		Direction	dir,
		double	shift
	)

Shift() [2/2]

template<std::size_t N>

std::array<std::ptrdiff_t, N> fub::Shift	(	const std::array< std::ptrdiff_t, N > &	idx,
		Direction	dir,
		std::ptrdiff_t	shift
	)

Shrink() [1/3]

template<typename State , int Rank, typename Layout >

View<State, Rank> fub::Shrink	(	const BasicView< State, Layout, Rank > &	view,
		Direction	dir,
		std::array< std::ptrdiff_t, 2 >	offsets
	)

Shrink() [2/3]

template<int Rank>

IndexBox<Rank> fub::Shrink	(	const IndexBox< Rank > &	box,
		Direction	dir,
		const std::array< std::ptrdiff_t, 2 > &	shifts
	)

Shrink() [3/3]

template<typename Extent >

auto fub::Shrink	(	const layout_left::mapping< Extent > &	layout,
		Direction	dir,
		std::ptrdiff_t	n = 1
	)

Size_()

template<std::ptrdiff_t... StaticExtents>

constexpr std::ptrdiff_t fub::Size_ ( const extents< StaticExtents... >  e )

constexprnoexcept

Slice()

template<Direction dir, typename T , typename L , int Rank, typename SliceSpecifier >

auto fub::Slice	(	const BasicView< T, L, Rank > &	view,
		SliceSpecifier	slice
	)

SliceExtent_()

constexpr std::ptrdiff_t fub::SliceExtent_ ( const std::pair< std::ptrdiff_t, std::ptrdiff_t > &  p )

constexpr

SliceLast()

template<typename T , int Rank, typename Layout >

PatchDataView<T, Rank - 1, Layout> fub::SliceLast	(	const PatchDataView< T, Rank, Layout > &	pdv,
		int	component = 0
	)

span() [1/6]

template<class Container >

fub::span

(

const Container &

)

-> span< const typename Container::value_type >

span() [2/6]

template<class T , size_t N>

fub::span

(

const std::array< T, N > &

)

-> span< const T, static_cast< std::ptrdiff_t >(N)>

span() [3/6]

template<class Container >

fub::span

(

Container &

)

-> span< typename Container::value_type >

span() [4/6]

template<class T , size_t N>

fub::span

(

std::array< T, N > &

)

-> span< T, static_cast< std::ptrdiff_t >(N)>

span() [5/6]

template<class T , typename I >

fub::span	(	T *	,
		I
	)		-> span< T >

span() [6/6]

template<class T , size_t N>

fub::span

(

T(&)

[N]

)

-> span< T, static_cast< std::ptrdiff_t >(N)>

StateToTuple()

template<typename State >

auto fub::StateToTuple

(

const State &

x

)

Store() [1/9]

template<typename Eq , typename Layout >

void fub::Store	(	const BasicView< Complete< Eq >, Layout, Eq::Rank()> &	view,
		const Complete< Eq > &	state,
		const std::array< std::ptrdiff_t, Eq::Rank()> &	index
	)

Store() [2/9]

template<typename Eq , int N, typename Layout , int Rank>

void fub::Store	(	const BasicView< Complete< Eq >, Layout, Rank > &	view,
		const CompleteArray< Eq, N > &	state,
		nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & >	index
	)

Store() [3/9]

template<typename Eq , typename Layout >

void fub::Store	(	const BasicView< Conservative< Eq >, Layout, Eq::Rank()> &	view,
		const Conservative< Eq > &	state,
		const std::array< std::ptrdiff_t, Eq::Rank()> &	index
	)

Store() [4/9]

template<typename Eq , int N, typename Layout , int Rank>

void fub::Store	(	const BasicView< Conservative< Eq >, Layout, Rank > &	view,
		const ConservativeArray< Eq, N > &	state,
		nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & >	index
	)

Store() [5/9]

template<typename T , int Rank, typename L >

void fub::Store	(	const PatchDataView< T, Rank, L > &	view,
		nodeduce_t< const T & >	value,
		const nodeduce_t< std::array< std::ptrdiff_t, static_cast< std::size_t >(Rank)>> &	index
	)

Store() [6/9]

template<typename T , int Rank, typename Layout , int N, int Options, typename... Indices>

void fub::Store	(	const PatchDataView< T, Rank, Layout > &	view,
		const Eigen::Array< T, 1, N, Options > &	chunk,
		const nodeduce_t< std::array< std::ptrdiff_t, static_cast< std::size_t >(Rank)>> &	index
	)

Store() [7/9]

template<typename T , typename Base , int Rank, typename Layout , int N, bool Options, typename... Indices>

void fub::Store	(	const PatchDataView< T, Rank, Layout > &	view,
		const Eigen::Block< Base, 1, N, Options > &	chunk,
		const nodeduce_t< std::array< std::ptrdiff_t, static_cast< std::size_t >(Rank)>> &	index
	)

Store() [8/9]

template<typename Eq >

void fub::Store	(	nodeduce_t< ViewPointer< Complete< Eq >>>	pointer,
		const CompleteArray< Eq > &	state
	)

Store() [9/9]

template<typename Eq >

void fub::Store	(	nodeduce_t< ViewPointer< Conservative< Eq >>>	pointer,
		const ConservativeArray< Eq > &	state
	)

StoreN() [1/6]

void fub::StoreN ( char *  pointer, const Array< char, 1 > &  array, int  n  )

inline

StoreN() [2/6]

template<typename Eq , int N, typename Layout , int Rank>

void fub::StoreN	(	const BasicView< Complete< Eq >, Layout, Rank > &	view,
		const CompleteArray< Eq, N > &	state,
		int	size,
		nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & >	pos
	)

StoreN() [3/6]

template<typename Eq , int N, typename Layout , int Rank>

void fub::StoreN	(	const BasicView< Conservative< Eq >, Layout, Rank > &	view,
		const ConservativeArray< Eq, N > &	state,
		int	size,
		nodeduce_t< const std::array< std::ptrdiff_t, std::size_t(Rank)> & >	pos
	)

StoreN() [4/6]

template<typename T , typename A , int N, bool B, typename Layout >

void fub::StoreN	(	const PatchDataView< T, 1, Layout > &	pdv,
		int	n,
		const Eigen::Block< A, 1, N, B > &	chunk,
		std::ptrdiff_t	offset
	)

StoreN() [5/6]

template<typename Eq >

void fub::StoreN	(	nodeduce_t< ViewPointer< Complete< Eq >>>	pointer,
		const CompleteArray< Eq > &	state,
		int	n
	)

StoreN() [6/6]

template<typename Eq >

void fub::StoreN	(	nodeduce_t< ViewPointer< Conservative< Eq >>>	pointer,
		const ConservativeArray< Eq > &	state,
		int	n
	)

subspan()

template<class ElementType , class Extents , class LayoutPolicy , class AccessorPolicy , class... SliceSpecifiers>

mdspan_subspan_t<ElementType, Extents, LayoutPolicy, AccessorPolicy, SliceSpecifiers...> fub::subspan ( const basic_mdspan< ElementType, Extents, LayoutPolicy, AccessorPolicy > &  src, SliceSpecifiers...  slices  )

noexcept

Subview()

template<typename State , typename Layout , int Rank>

View<State> fub::Subview	(	const BasicView< State, Layout, Rank > &	state,
		const IndexBox< Rank > &	box
	)

tag_invoke() [1/23]

template<int Rank, typename State >

constexpr auto fub::tag_invoke ( tag_t< Depths >  , const PerfectGasMix< Rank > &  eq, Type< State >    )

constexprnoexcept

tag_invoke() [2/23]

constexpr void fub::tag_invoke ( tag_t< euler::CompleteFromKineticState >  , const PerfectGasMix &  eq, Complete &  q, const KineticState &  kin, const Array< double, N, 1 > &  u  )

constexprnoexcept

tag_invoke() [3/23]

template<int Rank>

void fub::tag_invoke ( tag_t< euler::CompleteFromKineticState >  , const PerfectGasMix< Rank > &  eq, Complete< PerfectGasMix< Rank >> &  q, const KineticState< PerfectGasMix< Rank >> &  kin  )

noexcept

tag_invoke() [4/23]

template<int Rank>

void fub::tag_invoke ( tag_t< euler::CompleteFromKineticState >  , const PerfectGasMix< Rank > &  eq, CompleteArray< PerfectGasMix< Rank >> &  q, const KineticStateArray< PerfectGasMix< Rank >> &  kin, const Array< double, Rank > &  u  )

noexcept

tag_invoke() [5/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr const Density& fub::tag_invoke ( tag_t< euler::Density >  , const PerfectGasMix &  , const PerfectGasMixConservative< Density, Momentum, Energy, Species > &  q  )

constexprnoexcept

tag_invoke() [6/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr const Energy& fub::tag_invoke ( tag_t< euler::Energy >  , const PerfectGasMix &  , const PerfectGasMixConservative< Density, Momentum, Energy, Species > &  q  )

constexprnoexcept

tag_invoke() [7/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr auto fub::tag_invoke ( tag_t< euler::Gamma >  , const PerfectGasMix &  eq, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &    )

constexprnoexcept

tag_invoke() [8/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr auto fub::tag_invoke ( tag_t< euler::InternalEnergy >  , const PerfectGasMix &  eq, const PerfectGasMixConservative< Density, Momentum, Energy, Species > &  q  )

constexprnoexcept

tag_invoke() [9/23]

template<typename Density , typename Temperature , typename MoleFractions >

constexpr auto fub::tag_invoke ( tag_t< euler::InternalEnergy >  , const PerfectGasMix &  eq, const PerfectGasMixKineticState< Density, Temperature, MoleFractions > &  q  )

constexprnoexcept

tag_invoke() [10/23]

constexpr void fub::tag_invoke ( tag_t< euler::KineticStateFromComplete >  , const PerfectGasMix &  eq, KineticState &  kin, const Complete &  q  )

constexprnoexcept

tag_invoke() [11/23]

template<int Rank>

void fub::tag_invoke ( tag_t< euler::KineticStateFromComplete >  , const PerfectGasMix< Rank > &  eq, KineticStateArray< PerfectGasMix< Rank >> &  kin, const CompleteArray< PerfectGasMix< Rank >> &  q  )

noexcept

tag_invoke() [12/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr const Momentum& fub::tag_invoke ( tag_t< euler::Momentum >  , const PerfectGasMix &  , const PerfectGasMixConservative< Density, Momentum, Energy, Species > &  q  )

constexprnoexcept

tag_invoke() [13/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr decltype(auto) fub::tag_invoke ( tag_t< euler::Momentum >  , const PerfectGasMix &  , const PerfectGasMixConservative< Density, Momentum, Energy, Species > &  q, int  d  )

constexprnoexcept

tag_invoke() [14/23]

template<typename Density , typename Momentum , typename Energy , typename Species , typename Pressure , typename SpeedOfSound >

constexpr const Pressure& fub::tag_invoke ( tag_t< euler::Pressure >  , const PerfectGasMix &  , const PerfectGasMixComplete< Density, Momentum, Energy, Species, Pressure, SpeedOfSound > &  q  )

constexprnoexcept

tag_invoke() [15/23]

template<typename Density , typename Momentum , typename Energy , typename Species , typename Pressure , typename SpeedOfSound >

constexpr auto fub::tag_invoke ( tag_t< euler::SetIsentropicPressure >  , const PerfectGasMix &  eq, PerfectGasMixComplete< Density, Momentum, Energy, Species, Pressure, SpeedOfSound > &  q, const PerfectGasMixComplete< Density, Momentum, Energy, Species, Pressure, SpeedOfSound > &  q0, Pressure  p_new  )

constexprnoexcept

tag_invoke() [16/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr const Species& fub::tag_invoke ( tag_t< euler::Species >  , const PerfectGasMix &  , const PerfectGasMixConservative< Density, Momentum, Energy, Species > &  q  )

constexprnoexcept

tag_invoke() [17/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr decltype(auto) fub::tag_invoke ( tag_t< euler::Species >  , const PerfectGasMix &  , const PerfectGasMixConservative< Density, Momentum, Energy, Species > &  q, int  d  )

constexprnoexcept

tag_invoke() [18/23]

template<typename Density , typename Velocity , typename Pressure , typename Species >

constexpr const Species& fub::tag_invoke ( tag_t< euler::Species >  , const PerfectGasMix &  , const PerfectGasMixPrimitive< Density, Velocity, Pressure, Species > &  q  )

constexprnoexcept

tag_invoke() [19/23]

template<typename Density , typename Momentum , typename Energy , typename Species , typename Pressure , typename SpeedOfSound >

constexpr const SpeedOfSound& fub::tag_invoke ( tag_t< euler::SpeedOfSound >  , const PerfectGasMix &  , const PerfectGasMixComplete< Density, Momentum, Energy, Species, Pressure, SpeedOfSound > &  q  )

constexprnoexcept

tag_invoke() [20/23]

template<int Rank>

double fub::tag_invoke ( tag_t< euler::Temperature >  , const PerfectGasMix< Rank > &  eq, const Complete< PerfectGasMix< Rank >> &  q  )

noexcept

tag_invoke() [21/23]

template<int Rank>

Array1d fub::tag_invoke ( tag_t< euler::Temperature >  , const PerfectGasMix< Rank > &  eq, const CompleteArray< PerfectGasMix< Rank >> &  q  )

noexcept

tag_invoke() [22/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr Momentum fub::tag_invoke ( tag_t< euler::Velocity >  , const PerfectGasMix &  , const PerfectGasMixConservative< Density, Momentum, Energy, Species > &  q  )

constexprnoexcept

tag_invoke() [23/23]

template<typename Density , typename Momentum , typename Energy , typename Species >

constexpr auto fub::tag_invoke ( tag_t< euler::Velocity >  , const PerfectGasMix &  , const PerfectGasMixConservative< Density, Momentum, Energy, Species > &  q, int  d  )

constexprnoexcept

Take() [1/2]

template<std::size_t N, typename... Ts>

constexpr auto fub::Take ( const std::tuple< Ts... > &  t )

constexpr

Take() [2/2]

template<std::size_t... Is, typename... Ts>

constexpr auto fub::Take ( std::index_sequence< Is... >  , const std::tuple< Ts... > &  t  )

constexpr

TimeStepErrc_category()

const TimeStepErrcCategory& fub::TimeStepErrc_category ( )

inline

ToMap()

ProgramOptions fub::ToMap

(

const pybind11::dict &

dict

)

Transform()

template<typename Tuple , typename Function >

constexpr auto fub::Transform ( Tuple &&  tuple, Function  f  )

constexpr

UnitVector()

template<int Rank>

Eigen::Matrix<double, Rank, 1> fub::UnitVector ( Direction  dir )

noexcept

Unzip()

template<typename... Ts>

constexpr auto fub::Unzip ( const std::tuple< Ts... > &  zipped )

constexpr

VarNames()

template<typename State , typename ReturnType , typename Equation >

ReturnType fub::VarNames

(

const Equation &

equation

)

ViewPointer()

template<typename State >

fub::ViewPointer

(

const ViewPointer< State > &

)

-> ViewPointer< State >

Zip()

template<typename... Ts>

constexpr auto fub::Zip ( Ts &&...  ts )

constexpr

Variable Documentation

all

constexpr all_type fub::all

staticconstexpr

bool_c

template<bool B>

constexpr bool_constant<B> fub::bool_c

staticconstexpr

Depths

constexpr struct fub::DepthsFn fub::Depths

dynamic_extent

constexpr std::ptrdiff_t fub::dynamic_extent

staticconstexpr

This is a magic value to denote runtime-known extents.

index_c

template<index I>

constexpr index_constant<I> fub::index_c

staticconstexpr

int_c

template<int I>

constexpr int_constant<I> fub::int_c

staticconstexpr

is_extents_v

template<typename E >

constexpr bool fub::is_extents_v

staticconstexpr

is_mdspan_v

template<typename T >

constexpr bool fub::is_mdspan_v

staticconstexpr

is_span_v

template<typename T >

constexpr bool fub::is_span_v

staticconstexpr

Returns true if the specified T is a span<S, N> for some type S and integer N.

kDefaultChunkSize

constexpr const int fub::kDefaultChunkSize

constexpr

size_c

template<std::size_t I>

constexpr size_constant<I> fub::size_c

staticconstexpr