Dumux::Detail Namespace Reference

Namespaces
namespace	PDESolver
namespace	DofBackend
namespace	Box
namespace	Tpfa
namespace	CVFE
namespace	FCDiamond
namespace	PQ1Bubble
namespace	Intersections
namespace	VtkData
namespace	RasterImageData
namespace	VTKReader
namespace	DuneVectors
namespace	HelmholtzOperator
namespace	IstlSolvers
namespace	LATraits
namespace	LinearSolverParameters
namespace	LinearPDESolver
namespace	Preconditioners
namespace	Newton
namespace	Multithreading

Classes
struct	NoOpFunctor
struct	LocalAssemblerChooser
struct	LocalAssemblerChooser< DiscretizationMethods::CVFE< DM > >
struct	LocalAssemblerChooser< DiscretizationMethods::CCMpfa >
struct	LocalAssemblerChooser< DiscretizationMethods::CCTpfa >
struct	LocalAssemblerChooser< DiscretizationMethods::FCStaggered >
class	MultiMapperView
struct	ValidityTestFunctor
struct	ProblemTraits
struct	ProblemGridGeometryHelper
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 >
	Class providing operations for generic variable classes, containing primary and possibly also secondary variables. More...
struct	ProblemTraits< Problem, DiscretizationMethods::Box >
struct	DiscretizationDefaultLocalOperator< TypeTag >
struct	ProblemTraits< Problem, DiscretizationMethods::CCMpfa >
struct	ProblemTraits< Problem, DiscretizationMethods::CCTpfa >
struct	DiscretizationDefaultLocalOperator
class	FaceCenteredStaggeredLocalIntersectionIndexMapper
class	FaceCenteredStaggeredLocalIntersectionIndexMapper< GridView, false >
	Provides a mapping of local intersection 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 intersection 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::FCDiamond >
struct	ProblemTraits< Problem, DiscretizationMethods::FCStaggered >
struct	ProblemTraits< Problem, DiscretizationMethods::PQ1Bubble >
class	PQ1BubbleLocalBasis
	P1/Q1 + Bubble functions on the reference element. More...
class	PQ1BubbleLocalCoefficients
	Associations of the P1/Q1 + Bubble degrees of freedom to the facets of the reference element. More...
class	PQ1BubbleLocalInterpolation
	Evaluate the degrees of freedom of a P1 + Bubble basis. More...
struct	ProblemTraits< Problem, DiscretizationMethods::PQ2 >
struct	ProblemTraits< Problem, DiscretizationMethods::PQ3 >
struct	EmptyFreeFlowHeatCondType
struct	FreeFlowHeatCondType
struct	FreeFlowHeatCondType< true, Traits >
struct	PointsToGeometryWrapper
struct	isUG
struct	isUG< Dune::UGGrid< dim > >
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...
struct	NativeDuneVectorTypeImpl
struct	NativeDuneVectorTypeImpl< V, true >
struct	NativeDuneVectorType
struct	NativeDuneVectorType< Dune::MultiTypeBlockVector< Args... > >
struct	IstlSolverResult
class	IstlIterativeLinearSolver
	Standard dune-istl iterative linear solvers. More...
class	DirectIstlSolver
	Direct dune-istl linear solvers. More...
class	ParallelISTLHelperImpl
class	ParallelISTLHelperImpl< LinearSolverTraits, true >
class	StokesPreconditioner
	A Stokes preconditioner (saddle-point problem) for the problem \(\begin{pmatrix} A & B \\ C & 0 \end{pmatrix} \begin{pmatrix} u \\ p \end{pmatrix} = \begin{pmatrix} f \\ g \end{pmatrix}, \). 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	CouplingManagerSupportsMultithreadedAssemblySelector
struct	CouplingManagerSupportsMultithreadedAssemblySelector< Traits, DiscretizationMethods::CVFE< D > >
struct	MomentumDiscretizationMethod
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	SetEqual
struct	Sum
struct	Max
struct	Min

Typedefs
template<class Imp, class P, class G, class S, class V>
using	TimeInfoInterfaceCVFEDetector
template<class Imp>
using	SCVFIsOverlappingDetector
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 P>
using	ProblemConstraintsDetector = decltype(std::declval<P>().constraints())
	helper struct detecting if problem has a constraints() function
template<class GG>
using	GGPeriodicMapDetector = decltype(std::declval<GG>().periodicDofMap())
	helper struct detecting if a gridGeometry object has a periodicDofMap() function
template<class Problem>
using	ProblemGridGeometry = typename ProblemGridGeometryHelper<Problem>::type
template<class P>
using	DetectPriVarsHaveState = decltype(std::declval<P>().state())
template<class Vars>
using	SolutionVectorType = typename Vars::SolutionVector
template<class T>
using	SpecifiesBaseGridGeometry = typename T::BasicGridGeometry
template<class T>
using	SpecifiesGeometryHelper = typename T::GeometryHelper
template<class GV, class T>
using	BoxGeometryHelper_t
template<class FluxVariablesCache>
using	DefinesScvfQuadratureRule = typename FluxVariablesCache::ScvfQuadratureRule
template<class FluxVariablesCache>
using	ScvfQuadratureRuleOrDefault_t
template<class ElementVariables>
using	PrimaryVariables_t = typename decltype(primaryVariablesType<ElementVariables>())::type
template<class GV, class T>
using	FaceCenteredDiamondGeometryHelper_t
template<class T>
using	EnableHybridCVFE = typename T::EnableHybridCVFE
template<class GV, class T>
using	PQ1BubbleGeometryHelper_t
template<class GV, class T>
using	PQ2GeometryHelper_t
template<class GV, class T>
using	PQ3GeometryHelper_t
template<class P, class FVG, class EV, class IPD>
using	SourceWithIpDataInterface
	helper struct detecting if a problem has new source interface
template<class Problem, class SubControlVolumeFace>
using	HasVelocityInSpatialParams = decltype(std::declval<Problem>().spatialParams().velocity(std::declval<SubControlVolumeFace>()))
template<class GV, class T>
using	BoxFacetCouplingGeometryHelper_t
template<class P>
using	SubProblemConstraintsDetector = decltype(std::declval<P>().constraints())
	helper struct detecting if sub-problem has a constraints() function
template<class Assembler, class Index>
using	DetectPVSwitchMultiDomain = typename Assembler::template GridVariables<Index::value>::VolumeVariables::PrimaryVariableSwitch
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	PrimaryVariableSwitch = Dune::Std::detected_or_t<int, DetectPVSwitch, Variables>
template<class FluidMatrixInteraction>
using	AdsorptionModelDetector = decltype(std::declval<FluidMatrixInteraction>().adsorptionModel())
template<class GV, class T>
using	BoxDfmGeometryHelper_t
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 Imp, class P, class G, class S, class V>
constexpr bool	hasTimeInfoInterfaceCVFE ()
template<class Imp>
constexpr bool	hasScvfIsOverlapping ()
template<class P>
constexpr bool	hasGlobalConstraints ()
template<class GG>
constexpr bool	hasPeriodicDofMap ()
template<class P>
constexpr bool	priVarsHaveState ()
template<class ElementVariables>
constexpr auto	primaryVariablesType ()
template<class Element, class GridGeometry, class CVFEElemSol>
auto	evalCVFEGradientsAtLocalPos (const Element &element, const typename Element::Geometry &geometry, const GridGeometry &gridGeometry, const CVFEElemSol &elemSol, const typename Element::Geometry::LocalCoordinate &localPos, bool ignoreState=false)
	Evaluates the gradient of a control-volume finite element solution to a given global position.
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 vertex dof
template<class Element, class GridGeometry, class ElementSolution>
auto	minDistDofSol (const Element &element, const GridGeometry &gridGeometry, const typename Element::Geometry::LocalCoordinate &localPos, const ElementSolution &elemSol)
	return the solution at the closest dof
template<class Element, class GridGeometry, class CVFEElemSol>
CVFEElemSol::PrimaryVariables	evalCVFESolutionAtLocalPos (const Element &element, const typename Element::Geometry &geometry, const GridGeometry &gridGeometry, const CVFEElemSol &elemSol, const typename Element::Geometry::LocalCoordinate &localPos, bool ignoreState=false)
	Interpolates a given control-volume finite element solution at a given global position. Uses the finite element cache of the grid geometry.
template<class Function, class GridView>
auto	makeLocalFunction (Function &&f, const GridView &gridView)
	Create a local function from a given function.
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 P, class FVG, class EV, class IPD>
constexpr bool	hasProblemSourceWithIpDataInterface ()
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 LinearSolverTraits, class GridView>
Dune::SolverCategory::Category	solverCategory (const GridView &gridView)
template<class K, int rows, int cols, class VectorRow, class VectorCol>
void	symmetrizeConstraintsImpl (Dune::FieldMatrix< K, rows, cols > &A, VectorRow &bRow, const VectorCol &bCol, const VectorCol &constrainedRows, bool isDiagonal)
template<class MBlock, class VectorRow, class VectorCol>
void	symmetrizeConstraintsImpl (Dune::BCRSMatrix< MBlock > &A, VectorRow &bRow, const VectorCol &bCol, const VectorCol &constrainedRows, bool isDiagonal)
template<class... MBlock, class VectorRow, class VectorCol>
void	symmetrizeConstraintsImpl (Dune::MultiTypeBlockMatrix< MBlock... > &A, VectorRow &bRow, const VectorCol &bCol, const VectorCol &constrainedRows, bool isDiagonal)
template<class Problem, class SubControlVolumeFace>
static constexpr bool	hasVelocityInSpatialParams ()
template<class P>
constexpr bool	hasSubProblemGlobalConstraints ()
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 T>
static constexpr bool	enablesHybridCVFE = Dune::Std::detected_or_t<std::false_type, EnableHybridCVFE, T>{}

Typedef Documentation

AdsorptionModelDetector

template<class FluidMatrixInteraction>

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

BoxDfmGeometryHelper_t

template<class GV, class T>

using Dumux::Detail::BoxDfmGeometryHelper_t

Initial value:

 Dune::Std::detected_or_t<
    Dumux::BoxDfmGeometryHelper<GV, GV::dimension, typename T::SubControlVolume, typename T::SubControlVolumeFace>,
    SpecifiesGeometryHelper,
    T
>

BoxFacetCouplingGeometryHelper_t

template<class GV, class T>

using Dumux::Detail::BoxFacetCouplingGeometryHelper_t

Initial value:

 Dune::Std::detected_or_t<
    Dumux::BoxGeometryHelper<GV, GV::dimension, typename T::SubControlVolume, typename T::SubControlVolumeFace>,
    SpecifiesGeometryHelper,
    T
>

BoxGeometryHelper_t

template<class GV, class T>

using Dumux::Detail::BoxGeometryHelper_t

Initial value:

 Dune::Std::detected_or_t<
    Dumux::BoxGeometryHelper<GV, GV::dimension, typename T::SubControlVolume, typename T::SubControlVolumeFace>,
    SpecifiesGeometryHelper,
    T
>

DefinesScvfQuadratureRule

template<class FluxVariablesCache>

using Dumux::Detail::DefinesScvfQuadratureRule = typename FluxVariablesCache::ScvfQuadratureRule

DetectPriVarsHaveState

template<class P>

using Dumux::Detail::DetectPriVarsHaveState = decltype(std::declval<P>().state())

DetectPVSwitch

template<class Variables>

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

DetectPVSwitchMultiDomain

template<class Assembler, class Index>

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

EnableHybridCVFE

template<class T>

using Dumux::Detail::EnableHybridCVFE = typename T::EnableHybridCVFE

FaceCenteredDiamondGeometryHelper_t

template<class GV, class T>

using Dumux::Detail::FaceCenteredDiamondGeometryHelper_t

Initial value:

 Dune::Std::detected_or_t<
    Dumux::DiamondGeometryHelper<GV, typename T::SubControlVolume, typename T::SubControlVolumeFace>,
    SpecifiesGeometryHelper,
    T
>

GGPeriodicMapDetector

template<class GG>

using Dumux::Detail::GGPeriodicMapDetector = decltype(std::declval<GG>().periodicDofMap())

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>

PQ1BubbleGeometryHelper_t

template<class GV, class T>

using Dumux::Detail::PQ1BubbleGeometryHelper_t

Initial value:

 Dune::Std::detected_or_t<
    std::conditional_t<enablesHybridCVFE<T>,
        Dumux::HybridPQ1BubbleGeometryHelper<GV, typename T::SubControlVolume, typename T::SubControlVolumeFace, T::numCubeBubbleDofs>,
        Dumux::PQ1BubbleGeometryHelper<GV, typename T::SubControlVolume, typename T::SubControlVolumeFace>
    >,
    SpecifiesGeometryHelper,
    T
>

PQ2GeometryHelper_t

template<class GV, class T>

using Dumux::Detail::PQ2GeometryHelper_t

Initial value:

 Dune::Std::detected_or_t<
    std::conditional_t<enablesHybridCVFE<T>,
        Dumux::HybridPQ2GeometryHelper<GV, typename T::SubControlVolume, typename T::SubControlVolumeFace>,
        void 
    >,
    SpecifiesGeometryHelper,
    T
>

PQ3GeometryHelper_t

template<class GV, class T>

using Dumux::Detail::PQ3GeometryHelper_t

Initial value:

 Dune::Std::detected_or_t<
    std::conditional_t<enablesHybridCVFE<T>,
        Dumux::HybridPQ3GeometryHelper<GV, typename T::SubControlVolume, typename T::SubControlVolumeFace>,
        void
    >,
    SpecifiesGeometryHelper,
    T
>

PrimaryVariables_t

template<class ElementVariables>

using Dumux::Detail::PrimaryVariables_t = typename decltype(primaryVariablesType<ElementVariables>())::type

PrimaryVariableSwitch

template<class Variables>

using Dumux::Detail::PrimaryVariableSwitch = Dune::Std::detected_or_t<int, DetectPVSwitch, Variables>

ProblemConstraintsDetector

template<class P>

using Dumux::Detail::ProblemConstraintsDetector = decltype(std::declval<P>().constraints())

ProblemGridGeometry

template<class Problem>

using Dumux::Detail::ProblemGridGeometry = typename ProblemGridGeometryHelper<Problem>::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>()...))

SCVFIsOverlappingDetector

template<class Imp>

using Dumux::Detail::SCVFIsOverlappingDetector

Initial value:

 decltype(
    std::declval<Imp>().isOverlapping()
)

ScvfQuadratureRuleOrDefault_t

template<class FluxVariablesCache>

using Dumux::Detail::ScvfQuadratureRuleOrDefault_t

Initial value:

Dune::Std::detected_or_t<QuadratureRules::MidpointQuadrature,
                                                              DefinesScvfQuadratureRule,
                                                              FluxVariablesCache>

SolutionVectorType

template<class Vars>

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

SourceWithIpDataInterface

template<class P, class FVG, class EV, class IPD>

using Dumux::Detail::SourceWithIpDataInterface

Initial value:

 decltype(
    std::declval<P>().source(std::declval<FVG>(), std::declval<EV>(), std::declval<IPD>())
)

SpecifiesBaseGridGeometry

template<class T>

using Dumux::Detail::SpecifiesBaseGridGeometry = typename T::BasicGridGeometry

SpecifiesGeometryHelper

template<class T>

using Dumux::Detail::SpecifiesGeometryHelper = typename T::GeometryHelper

SubProblemConstraintsDetector

template<class P>

using Dumux::Detail::SubProblemConstraintsDetector = decltype(std::declval<P>().constraints())

TimeInfoInterfaceCVFEDetector

template<class Imp, class P, class G, class S, class V>

using Dumux::Detail::TimeInfoInterfaceCVFEDetector

Initial value:

 decltype(
    std::declval<Imp>().computeStorage(
        std::declval<P>(), std::declval<G>(), std::declval<S>(), std::declval<V>(), true
    )
)

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 )

allStatesEqual() [2/2]

template<class ElementSolution>

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

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 )

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

hasGlobalConstraints()

template<class P>

bool Dumux::Detail::hasGlobalConstraints ( )

inlineconstexpr

hasPeriodicDofMap()

template<class GG>

bool Dumux::Detail::hasPeriodicDofMap ( )

inlineconstexpr

hasProblemSourceWithIpDataInterface()

template<class P, class FVG, class EV, class IPD>

bool Dumux::Detail::hasProblemSourceWithIpDataInterface ( )

inlineconstexpr

hasSaturation()

template<class T, typename ... Args>

constexpr bool Dumux::Detail::hasSaturation ( )

staticconstexpr

hasScvfIsOverlapping()

template<class Imp>

bool Dumux::Detail::hasScvfIsOverlapping ( )

inlineconstexpr

hasSubProblemGlobalConstraints()

template<class P>

bool Dumux::Detail::hasSubProblemGlobalConstraints ( )

inlineconstexpr

hasTimeInfoInterfaceCVFE()

template<class Imp, class P, class G, class S, class V>

bool Dumux::Detail::hasTimeInfoInterfaceCVFE ( )

inlineconstexpr

hasVelocityInSpatialParams()

template<class Problem, class SubControlVolumeFace>

constexpr bool Dumux::Detail::hasVelocityInSpatialParams ( )

staticconstexpr

makeLocalFunction()

template<class Function, class GridView>

auto Dumux::Detail::makeLocalFunction	(	Function &&	f,
		const GridView &	gridView )

makeProjectorPair()

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

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

Template Parameters

doBidirectional

If false, the backward projection matrix is not assembled

Returns

an std::pair with the forward and backward projector

minDistDofSol()

template<class Element, class GridGeometry, class ElementSolution>

auto Dumux::Detail::minDistDofSol	(	const Element &	element,
		const GridGeometry &	gridGeometry,
		const typename Element::Geometry::LocalCoordinate &	localPos,
		const ElementSolution &	elemSol )

minDistVertexSol()

template<class Geometry, class ElementSolution>

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

primaryVariablesType()

template<class ElementVariables>

auto Dumux::Detail::primaryVariablesType ( )

constexpr

priVarsHaveState()

template<class P>

bool Dumux::Detail::priVarsHaveState ( )

inlineconstexpr

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 )

solverCategory()

template<class LinearSolverTraits, class GridView>

Dune::SolverCategory::Category Dumux::Detail::solverCategory

(

const GridView &

gridView

)

symmetrizeConstraintsImpl() [1/3]

template<class MBlock, class VectorRow, class VectorCol>

void Dumux::Detail::symmetrizeConstraintsImpl	(	Dune::BCRSMatrix< MBlock > &	A,
		VectorRow &	bRow,
		const VectorCol &	bCol,
		const VectorCol &	constrainedRows,
		bool	isDiagonal )

symmetrizeConstraintsImpl() [2/3]

template<class K, int rows, int cols, class VectorRow, class VectorCol>

void Dumux::Detail::symmetrizeConstraintsImpl	(	Dune::FieldMatrix< K, rows, cols > &	A,
		VectorRow &	bRow,
		const VectorCol &	bCol,
		const VectorCol &	constrainedRows,
		bool	isDiagonal )

symmetrizeConstraintsImpl() [3/3]

template<class... MBlock, class VectorRow, class VectorCol>

void Dumux::Detail::symmetrizeConstraintsImpl	(	Dune::MultiTypeBlockMatrix< MBlock... > &	A,
		VectorRow &	bRow,
		const VectorCol &	bCol,
		const VectorCol &	constrainedRows,
		bool	isDiagonal )

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 )

Variable Documentation

enablesHybridCVFE

template<class T>

bool Dumux::Detail::enablesHybridCVFE = Dune::Std::detected_or_t<std::false_type, EnableHybridCVFE, T>{}

staticconstexpr