Distance implementation details. More...

Description

Distance implementation details.

Namespaces
namespace	Staggered
namespace	Multithreading

Classes
struct	NoOpFunctor
struct	LocalAssemblerChooser
struct	LocalAssemblerChooser< DiscretizationMethods::Box >
struct	LocalAssemblerChooser< DiscretizationMethods::CCMpfa >
struct	LocalAssemblerChooser< DiscretizationMethods::CCTpfa >
struct	LocalAssemblerChooser< DiscretizationMethods::FCStaggered >
struct	VariablesChooser
struct	VariablesChooser< A, true >
struct	VariablesChooser< A, false >
struct	ValidityTestFunctor
struct	ProblemTraits
struct	hasState
	helper struct detecting if a PrimaryVariables object has a state() function More...
struct	ConcatSeq
struct	ConcatSeq< std::index_sequence< Is1... >, offset, std::index_sequence< Is2... > >
class	VariablesBackend
class	VariablesBackend< Vars, false >
	Class providing operations for primary variable vector/scalar types. More...
class	VariablesBackend< Vars, true >
struct	ProblemTraits< Problem, DiscretizationMethods::Box >
struct	ProblemTraits< Problem, DiscretizationMethods::CCMpfa >
struct	ProblemTraits< Problem, DiscretizationMethods::CCTpfa >
class	FaceCenteredStaggeredLocalIntersectionIndexMapper
class	FaceCenteredStaggeredLocalIntersectionIndexMapper< GridView, false >
	Provides a mapping of local intersecton indices (indexInInside) such that the local indices always follow the order of a reference element, regardless of how the element is oriented. More...
class	FaceCenteredStaggeredLocalIntersectionIndexMapper< GridView, true >
	Provides a mapping of local intersecton indices (indexInInside) such that the local indices always follow the order of a reference element, regardless of how the element in oriented. More...
struct	ProblemTraits< Problem, DiscretizationMethods::FCStaggered >
struct	ProblemTraits< Problem, DiscretizationMethods::Staggered >
struct	InAxisVelocities
struct	InAxisVelocities< Scalar, 1 >
struct	PairData
	Parallel Data stored per sub face. More...
struct	AxisData
	In Axis Data stored per sub face. More...
struct	AxisData< GridView, 1 >
	In Axis Data stored per sub face for first-order scheme. More...
struct	EmptyFreeFlowHeatCondType
struct	FreeFlowHeatCondType
struct	FreeFlowHeatCondType< true, Traits >
struct	SupportsPeriodicity
struct	SupportsPeriodicity< Dune::SPGrid< ct, dim, Ref, Comm > >
struct	PointsToGeometryWrapper
struct	GeometrySquaredDistance
struct	GeometrySquaredDistance< Geo1, Geo2, dimWorld, 0, 0 >
struct	GeometrySquaredDistance< Geo1, Geo2, dimWorld, 1, 0 >
struct	GeometrySquaredDistance< Geo1, Geo2, dimWorld, 0, 1 >
struct	GeometrySquaredDistance< Geo1, Geo2, dimWorld, 0, 2 >
struct	GeometrySquaredDistance< Geo1, Geo2, dimWorld, 2, 0 >
struct	isUG
class	GridIntersectionIterator
	Iterate over the GridViews boundary intersections This will visit all intersections for which boundary() is true and neighbor() is false. More...
class	NonConformingIntersectionIteratorFactory
	Non conforming intersection iterator factory. More...
class	SkeletonFunction
	Skeleton function for intersection writer. More...
class	SegmentNetwork
	Segment representation of a 1d network grid. More...
class	NetworkIndicatorFunction
	Get the closest segment for a given surface point. More...
class	DebugIntersectionVTKOutput
	Simple legacy VTK writer for outputting debug data on the coupling interface. More...
struct	HasIndex
struct	HasIndex< i, std::tuple< Indices... > >
class	createMultiTypeBlockMatrixType
	a helper class to create a multitype matrix given the diagonal matrix blocks More...
struct	MultiDomainTupleSharedPtr
	helper alias to create a tuple of shared_ptr<...> from an indexed type More...
struct	MultiDomainTupleSharedPtrConst
	helper alias to create a tuple of shared_ptr<const ...> from an indexed type More...
struct	MultiDomainMatrixType
	helper alias to create the JacobianMatrix type More...
struct	PriVarSwitchVariablesType
struct	PriVarSwitchVariablesType< Assembler, false >
struct	supportsPartialReassembly
	helper struct detecting if an assembler supports partial reassembly More...
struct	BlockTypeHelper
struct	BlockTypeHelper< S, true >
struct	SetEqual
struct	Sum
struct	Max
struct	Min
struct	VolVarsWithPVSwitch
	Helper structs to conditionally use a primary variable switch or not. More...
struct	VolVarsWithOutPVSwitch

Typedefs
template<class T, class Default>
using	NonVoidOrDefault_t = std::conditional_t<!std::is_same_v<T, void>, T, Default>
template<class TypeTag, class Impl, DiffMethod diffMethod, bool isImplicit>
using	LocalAssemblerChooser_t
template<class Assembler>
using	AssemblerVariablesType = typename Assembler::Variables
template<class Assembler>
using	AssemblerVariables = typename VariablesChooser<Assembler>::Type
template<class Vars>
using	SolutionVectorType = typename Vars::SolutionVector
template<class Problem, class SubControlVolumeFace>
using	HasVelocityInSpatialParams = decltype(std::declval<Problem>().spatialParams().velocity(std::declval<SubControlVolumeFace>()))
template<class Assembler, class Index>
using	DetectPVSwitchMultiDomain = typename Assembler::template GridVariables<Index::value>::VolumeVariables::PrimaryVariableSwitch
template<class Assembler, std::size_t i>
using	GetPVSwitchMultiDomain = Dune::Std::detected_or<int, DetectPVSwitchMultiDomain, Assembler, Dune::index_constant<i>>
template<class Assembler>
using	AssemblerGridVariablesType = typename Assembler::GridVariables
template<class Assembler>
using	PriVarSwitchVariables = typename PriVarSwitchVariablesType<Assembler, assemblerExportsGridVariables<Assembler>>::Type
template<class LinearSolver, class Residual>
using	NormDetector = decltype(std::declval<LinearSolver>().norm(std::declval<Residual>()))
template<class C>
using	dynamicIndexAccess = decltype(std::declval<C>()[0])
template<class C>
using	staticIndexAccess = decltype(std::declval<C>()[Dune::Indices::_0])
template<class SolutionVector>
using	BlockType = typename BlockTypeHelper<SolutionVector, Dune::IsNumber<SolutionVector>::value>::type
template<class Variables>
using	DetectPVSwitch = typename Variables::VolumeVariables::PrimaryVariableSwitch
	helper aliases to extract a primary variable switch from the VolumeVariables (if defined, yields int otherwise)
template<class Variables>
using	GetPVSwitch = Dune::Std::detected_or<int, DetectPVSwitch, Variables>
template<class Variables>
using	PrimaryVariableSwitch = typename GetPVSwitch<Variables>::type
template<class FluidMatrixInteraction>
using	AdsorptionModelDetector = decltype(std::declval<FluidMatrixInteraction>().adsorptionModel())
template<typename T, typename ... Ts>
using	RobinDerivDetector = decltype(std::declval<T>().addRobinFluxDerivatives(std::declval<Ts>()...))
template<typename T, typename ... Ts>
using	SaturationDetector = decltype(std::declval<T>().spatialParams().saturation(std::declval<Ts>()...))

Functions
template<class ElementSolution>
bool	allStatesEqual (const ElementSolution &elemSol, std::true_type hasState)
	returns true if all states in an element solution are the same
template<class ElementSolution>
bool	allStatesEqual (const ElementSolution &elemSol, std::false_type hasState)
	overload if the solution is stateless
template<class Geometry, class ElementSolution>
auto	minDistVertexSol (const Geometry &geometry, const typename Geometry::GlobalCoordinate &globalPos, const ElementSolution &elemSol)
	return the solution at the closest dof
template<class Matrix>
void	setupReducedMatrices (const Matrix &massMatrix, const Matrix &projMatrix, const std::vector< bool > &dofIsVoid, Matrix &reducedM, Matrix &reducedP, std::vector< std::size_t > &expansionMap)
	Reduces a mass matrix and projection matrix such that they are composed of only those dofs that actually take part in the projection. Simultaneously, a container with the index map into the complete target space is filled so that the entries after projection can be assigned to the corresponding dof in the overall target space.
template<bool doBidirectional, class FEBasisDomain, class FEBasisTarget, class GlueType>
auto	createProjectionMatrices (const FEBasisDomain &feBasisDomain, const FEBasisTarget &feBasisTarget, const GlueType &glue, bool treatDiagonalZeroes=true)
	Creates the matrices underlying l2-projections.
template<bool doBidirectional, class FEBasisDomain, class FEBasisTarget, class GlueType>
auto	makeProjectorPair (const FEBasisDomain &feBasisDomain, const FEBasisTarget &feBasisTarget, const GlueType &glue)
	Creates a projector class between two function space bases.
template<class ElemVolVars, class SubControlVolumeFace, class UpwindTermFunction, class Scalar>
Scalar	upwindSchemeMultiplier (const ElemVolVars &elemVolVars, const SubControlVolumeFace &scvf, const UpwindTermFunction &upwindTerm, Scalar flux, int phaseIdx)
	returns the upwind factor which is multiplied to the advective flux across the given scvf
template<class EntitySet, class ctype, int dimworld, typename std::enable_if_t<(EntitySet::Entity::Geometry::mydimension > 0), int > = 0>
void	closestEntity (const Dune::FieldVector< ctype, dimworld > &point, const BoundingBoxTree< EntitySet > &tree, std::size_t node, ctype &minSquaredDistance, std::size_t &eIdx)
	Compute the closest entity in an AABB tree (index and shortest squared distance) recursively.
template<class Geo1, class Geo2, class ctype, class GetFacetCornerIndices, class ComputeNormalFunction>
bool	computeSegmentIntersection (const Geo1 &geo1, const Geo2 &geo2, ctype baseEps, ctype &tfirst, ctype &tlast, const GetFacetCornerIndices &getFacetCornerIndices, const ComputeNormalFunction &computeNormal)
	Algorithm to find segment-like intersections of a polygon/polyhedron with a segment. The result is stored in the form of the local coordinates tfirst and tlast on the segment geo1.
template<class Function, class Range>
Range	evalFunctionForRange (const Function &f, const Range &range)
template<class S, class V>
void	addDataSetToGnuplot (GnuplotInterface< S > &gnuplot, const V &x, const V &y, const std::string &curveName, const std::string &curveOptions, const std::string &xLabel, const std::string &yLabel)
template<class Problem, class SubControlVolumeFace>
static constexpr bool	hasVelocityInSpatialParams ()
template<class... Args, std::size_t ... Is>
auto	toRef (const std::tuple< Args... > &v, std::index_sequence< Is... > indices)
template<class LinearSolver, class Residual>
static constexpr bool	hasNorm ()
template<class V, class Scalar, class Reduce, class Transform>
auto	hybridInnerProduct (const V &v1, const V &v2, Scalar init, Reduce &&r, Transform &&t) -> std::enable_if_t< hasDynamicIndexAccess< V >(), Scalar >
template<class V, class Scalar, class Reduce, class Transform>
auto	hybridInnerProduct (const V &v1, const V &v2, Scalar init, Reduce &&r, Transform &&t) -> std::enable_if_t< hasStaticIndexAccess< V >() &&!hasDynamicIndexAccess< V >(), Scalar >
template<class Scalar, class V>
auto	maxRelativeShift (const V &v1, const V &v2) -> std::enable_if_t< Dune::IsNumber< V >::value, Scalar >
template<class Scalar, class V>
auto	maxRelativeShift (const V &v1, const V &v2) -> std::enable_if_t<!Dune::IsNumber< V >::value, Scalar >
template<class To, class From>
void	assign (To &to, const From &from)
template<class T, std::enable_if_t< Dune::IsNumber< std::decay_t< T > >::value, int > = 0>
constexpr std::size_t	blockSize ()
template<class T, std::enable_if_t<!Dune::IsNumber< std::decay_t< T > >::value, int > = 0>
constexpr std::size_t	blockSize ()
template<class FluidMatrixInteraction>
static constexpr bool	hasAdsorptionModel ()
template<class FluidMatrixInteraction>
static constexpr bool	hasAdsorptionModel ()
template<class T, typename ... Args>
static constexpr bool	hasAddRobinFluxDerivatives ()
template<class T, typename ... Args>
static constexpr bool	hasSaturation ()

Variables
template<class Grid, int dofCodim>
static constexpr bool	canCommunicate
template<class Assembler>
constexpr bool	exportsVariables = Dune::Std::is_detected_v<AssemblerVariablesType, Assembler>
template<class Assembler>
constexpr bool	assemblerExportsGridVariables = Dune::Std::is_detected_v<AssemblerGridVariablesType, Assembler>
template<class C>
static constexpr auto	hasDynamicIndexAccess = Dune::Std::is_detected<dynamicIndexAccess, C>{}
template<class C>
static constexpr auto	hasStaticIndexAccess = Dune::Std::is_detected<staticIndexAccess, C>{}

Typedef Documentation

◆ AdsorptionModelDetector

template<class FluidMatrixInteraction>

using Dumux::Detail::AdsorptionModelDetector = decltype(std::declval<FluidMatrixInteraction>().adsorptionModel())

◆ AssemblerGridVariablesType

template<class Assembler>

using Dumux::Detail::AssemblerGridVariablesType = typename Assembler::GridVariables

◆ AssemblerVariables

template<class Assembler>

using Dumux::Detail::AssemblerVariables = typename VariablesChooser<Assembler>::Type

◆ AssemblerVariablesType

template<class Assembler>

using Dumux::Detail::AssemblerVariablesType = typename Assembler::Variables

◆ BlockType

template<class SolutionVector>

using Dumux::Detail::BlockType = typename BlockTypeHelper<SolutionVector, Dune::IsNumber<SolutionVector>::value>::type

◆ DetectPVSwitch

template<class Variables>

using Dumux::Detail::DetectPVSwitch = typename Variables::VolumeVariables::PrimaryVariableSwitch

helper aliases to extract a primary variable switch from the VolumeVariables (if defined, yields int otherwise)

◆ DetectPVSwitchMultiDomain

template<class Assembler, class Index>

using Dumux::Detail::DetectPVSwitchMultiDomain = typename Assembler::template GridVariables<Index::value>::VolumeVariables::PrimaryVariableSwitch

◆ dynamicIndexAccess

template<class C>

using Dumux::Detail::dynamicIndexAccess = decltype(std::declval<C>()[0])

◆ GetPVSwitch

template<class Variables>

using Dumux::Detail::GetPVSwitch = Dune::Std::detected_or<int, DetectPVSwitch, Variables>

◆ GetPVSwitchMultiDomain

template<class Assembler, std::size_t i>

using Dumux::Detail::GetPVSwitchMultiDomain = Dune::Std::detected_or<int, DetectPVSwitchMultiDomain, Assembler, Dune::index_constant<i>>

◆ HasVelocityInSpatialParams

template<class Problem, class SubControlVolumeFace>

using Dumux::Detail::HasVelocityInSpatialParams = decltype(std::declval<Problem>().spatialParams().velocity(std::declval<SubControlVolumeFace>()))

◆ LocalAssemblerChooser_t

template<class TypeTag, class Impl, DiffMethod diffMethod, bool isImplicit>

using Dumux::Detail::LocalAssemblerChooser_t

Initial value:

 typename LocalAssemblerChooser<
    typename GetPropType<TypeTag, Properties::GridGeometry>::DiscretizationMethod
>::template type<TypeTag, Impl, diffMethod, isImplicit>

◆ NonVoidOrDefault_t

template<class T, class Default>

using Dumux::Detail::NonVoidOrDefault_t = std::conditional_t<!std::is_same_v<T, void>, T, Default>

◆ NormDetector

template<class LinearSolver, class Residual>

using Dumux::Detail::NormDetector = decltype(std::declval<LinearSolver>().norm(std::declval<Residual>()))

◆ PrimaryVariableSwitch

template<class Variables>

using Dumux::Detail::PrimaryVariableSwitch = typename GetPVSwitch<Variables>::type

◆ PriVarSwitchVariables

template<class Assembler>

using Dumux::Detail::PriVarSwitchVariables = typename PriVarSwitchVariablesType<Assembler, assemblerExportsGridVariables<Assembler>>::Type

◆ RobinDerivDetector

template<typename T, typename ... Ts>

using Dumux::Detail::RobinDerivDetector = decltype(std::declval<T>().addRobinFluxDerivatives(std::declval<Ts>()...))

◆ SaturationDetector

template<typename T, typename ... Ts>

using Dumux::Detail::SaturationDetector = decltype(std::declval<T>().spatialParams().saturation(std::declval<Ts>()...))

◆ SolutionVectorType

template<class Vars>

using Dumux::Detail::SolutionVectorType = typename Vars::SolutionVector

◆ staticIndexAccess

template<class C>

using Dumux::Detail::staticIndexAccess = decltype(std::declval<C>()[Dune::Indices::_0])

Function Documentation

◆ addDataSetToGnuplot()

template<class S, class V>

void Dumux::Detail::addDataSetToGnuplot	(	GnuplotInterface< S > &	gnuplot,
		const V &	x,
		const V &	y,
		const std::string &	curveName,
		const std::string &	curveOptions,
		const std::string &	xLabel,
		const std::string &	yLabel )

◆ allStatesEqual() [1/2]

template<class ElementSolution>

bool Dumux::Detail::allStatesEqual	(	const ElementSolution &	elemSol,
		std::false_type	hasState )

overload if the solution is stateless

◆ allStatesEqual() [2/2]

template<class ElementSolution>

bool Dumux::Detail::allStatesEqual	(	const ElementSolution &	elemSol,
		std::true_type	hasState )

returns true if all states in an element solution are the same

◆ assign()

template<class To, class From>

void Dumux::Detail::assign	(	To &	to,
		const From &	from )

◆ blockSize() [1/2]

template<class T, std::enable_if_t<!Dune::IsNumber< std::decay_t< T > >::value, int > = 0>

std::size_t Dumux::Detail::blockSize ( )

constexpr

◆ blockSize() [2/2]

template<class T, std::enable_if_t< Dune::IsNumber< std::decay_t< T > >::value, int > = 0>

std::size_t Dumux::Detail::blockSize ( )

constexpr

◆ createProjectionMatrices()

template<bool doBidirectional, class FEBasisDomain, class FEBasisTarget, class GlueType>

auto Dumux::Detail::createProjectionMatrices	(	const FEBasisDomain &	feBasisDomain,
		const FEBasisTarget &	feBasisTarget,
		const GlueType &	glue,
		bool	treatDiagonalZeroes = true )

Creates the matrices underlying l2-projections.

Template Parameters

doBidirectional If false, the backward projection matrix is not assembled

Parameters

feBasisDomain	The basis to the domain finite element space
feBasisTarget	The basis to the target finite element space
glue	The glue object containing the intersections between the two grids
treatDiagonalZeroes	If true, zero entries on the diagonal of the matrices that appear if the two domains occupy different geometric regions (and some dofs to not take part in the projection as a result) are substituted by ones. This substitution will lead to those dofs being mapped to zeroes in the target space.

Returns: An std::pair of projection matrices, where the first entry stores the matrices of the forward projection and the second entry stores those of the backward projection. The entries of the returned pair are itself std::pairs which store the mass matrix in the first and the projection matrix in the second entry.

◆ evalFunctionForRange()

template<class Function, class Range>

Range Dumux::Detail::evalFunctionForRange	(	const Function &	f,
		const Range &	range )

◆ hasAddRobinFluxDerivatives()

template<class T, typename ... Args>

constexpr bool Dumux::Detail::hasAddRobinFluxDerivatives ( )

staticconstexpr

◆ hasAdsorptionModel() [1/2]

template<class FluidMatrixInteraction>

constexpr bool Dumux::Detail::hasAdsorptionModel ( )

staticconstexpr

◆ hasAdsorptionModel() [2/2]

template<class FluidMatrixInteraction>

constexpr bool Dumux::Detail::hasAdsorptionModel ( )

staticconstexpr

◆ hasNorm()

template<class LinearSolver, class Residual>

constexpr bool Dumux::Detail::hasNorm ( )

staticconstexpr

◆ hasSaturation()

template<class T, typename ... Args>

constexpr bool Dumux::Detail::hasSaturation ( )

staticconstexpr

◆ hasVelocityInSpatialParams()

template<class Problem, class SubControlVolumeFace>

constexpr bool Dumux::Detail::hasVelocityInSpatialParams ( )

staticconstexpr

◆ hybridInnerProduct() [1/2]

template<class V, class Scalar, class Reduce, class Transform>

auto Dumux::Detail::hybridInnerProduct	(	const V &	v1,
		const V &	v2,
		Scalar	init,
		Reduce &&	r,
		Transform &&	t ) -> std::enable_if_t< hasDynamicIndexAccess< V >(), Scalar >

◆ hybridInnerProduct() [2/2]

template<class V, class Scalar, class Reduce, class Transform>

auto Dumux::Detail::hybridInnerProduct	(	const V &	v1,
		const V &	v2,
		Scalar	init,
		Reduce &&	r,
		Transform &&	t ) -> std::enable_if_t< hasStaticIndexAccess< V >() &&!hasDynamicIndexAccess< V >(), Scalar >

◆ makeProjectorPair()

template<bool doBidirectional, class FEBasisDomain, class FEBasisTarget, class GlueType>

auto Dumux::Detail::makeProjectorPair	(	const FEBasisDomain &	feBasisDomain,
		const FEBasisTarget &	feBasisTarget,
		const GlueType &	glue )

Creates a projector class between two function space bases.

Template Parameters

doBidirectional If false, the backward projection matrix is not assembled

Returns: an std::pair with the forward and backward projector

◆ maxRelativeShift() [1/2]

template<class Scalar, class V>

auto Dumux::Detail::maxRelativeShift	(	const V &	v1,
		const V &	v2 ) -> std::enable_if_t< Dune::IsNumber< V >::value, Scalar >

◆ maxRelativeShift() [2/2]

template<class Scalar, class V>

auto Dumux::Detail::maxRelativeShift	(	const V &	v1,
		const V &	v2 ) -> std::enable_if_t<!Dune::IsNumber< V >::value, Scalar >

◆ minDistVertexSol()

template<class Geometry, class ElementSolution>

auto Dumux::Detail::minDistVertexSol	(	const Geometry &	geometry,
		const typename Geometry::GlobalCoordinate &	globalPos,
		const ElementSolution &	elemSol )

return the solution at the closest dof

◆ setupReducedMatrices()

template<class Matrix>

void Dumux::Detail::setupReducedMatrices	(	const Matrix &	massMatrix,
		const Matrix &	projMatrix,
		const std::vector< bool > &	dofIsVoid,
		Matrix &	reducedM,
		Matrix &	reducedP,
		std::vector< std::size_t > &	expansionMap )

Reduces a mass matrix and projection matrix such that they are composed of only those dofs that actually take part in the projection. Simultaneously, a container with the index map into the complete target space is filled so that the entries after projection can be assigned to the corresponding dof in the overall target space.

◆ toRef()

template<class... Args, std::size_t ... Is>

auto Dumux::Detail::toRef	(	const std::tuple< Args... > &	v,
		std::index_sequence< Is... >	indices )

◆ upwindSchemeMultiplier()

template<class ElemVolVars, class SubControlVolumeFace, class UpwindTermFunction, class Scalar>

Scalar Dumux::Detail::upwindSchemeMultiplier	(	const ElemVolVars &	elemVolVars,
		const SubControlVolumeFace &	scvf,
		const UpwindTermFunction &	upwindTerm,
		Scalar	flux,
		int	phaseIdx )

returns the upwind factor which is multiplied to the advective flux across the given scvf

Variable Documentation

◆ assemblerExportsGridVariables

template<class Assembler>

bool Dumux::Detail::assemblerExportsGridVariables = Dune::Std::is_detected_v<AssemblerGridVariablesType, Assembler>

inlineconstexpr

◆ canCommunicate

template<class Grid, int dofCodim>

bool Dumux::Detail::canCommunicate

staticconstexpr

Initial value:

                                 =
Dune::Capabilities::canCommunicate<Grid, dofCodim>::v
|| Dumux::Temp::Capabilities::canCommunicate<Grid, dofCodim>::v

◆ exportsVariables

template<class Assembler>

bool Dumux::Detail::exportsVariables = Dune::Std::is_detected_v<AssemblerVariablesType, Assembler>

inlineconstexpr

◆ hasDynamicIndexAccess

template<class C>

auto Dumux::Detail::hasDynamicIndexAccess = Dune::Std::is_detected<dynamicIndexAccess, C>{}

staticconstexpr

◆ hasStaticIndexAccess

template<class C>

auto Dumux::Detail::hasStaticIndexAccess = Dune::Std::is_detected<staticIndexAccess, C>{}

staticconstexpr

Description

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ AdsorptionModelDetector

◆ AssemblerGridVariablesType

◆ AssemblerVariables

◆ AssemblerVariablesType

◆ BlockType

◆ DetectPVSwitch

◆ DetectPVSwitchMultiDomain

◆ dynamicIndexAccess

◆ GetPVSwitch

◆ GetPVSwitchMultiDomain

◆ HasVelocityInSpatialParams

◆ LocalAssemblerChooser_t

◆ NonVoidOrDefault_t

◆ NormDetector

◆ PrimaryVariableSwitch

◆ PriVarSwitchVariables

◆ RobinDerivDetector

◆ SaturationDetector

◆ SolutionVectorType

◆ staticIndexAccess

Function Documentation

◆ addDataSetToGnuplot()

◆ allStatesEqual() [1/2]

◆ allStatesEqual() [2/2]

◆ assign()

◆ blockSize() [1/2]

◆ blockSize() [2/2]

◆ createProjectionMatrices()

◆ evalFunctionForRange()

◆ hasAddRobinFluxDerivatives()

◆ hasAdsorptionModel() [1/2]

◆ hasAdsorptionModel() [2/2]

◆ hasNorm()

◆ hasSaturation()

◆ hasVelocityInSpatialParams()

◆ hybridInnerProduct() [1/2]

◆ hybridInnerProduct() [2/2]

◆ makeProjectorPair()

◆ maxRelativeShift() [1/2]

◆ maxRelativeShift() [2/2]

◆ minDistVertexSol()

◆ setupReducedMatrices()

◆ toRef()

◆ upwindSchemeMultiplier()

Variable Documentation

◆ assemblerExportsGridVariables

◆ canCommunicate

◆ exportsVariables

◆ hasDynamicIndexAccess

◆ hasStaticIndexAccess