Common classes, functions, properties and concepts. More...

Description

Common classes, functions, properties and concepts.

Modules
	Properties
	Basic properties of all models in DuMu^x

	Typetraits
	Basic Type traits in DuMu^x

Files
file	common/balanceequationopts.hh
	Traits class to set options used by the local residual when when evaluating the balance equations.

file	boundaryflag.hh
	Boundary flag to store e.g. in sub control volume faces.

file	boundaryflag.hh
	Boundary flag to store e.g. in sub control volume faces.

file	common/boundarytypes.hh
	Class to specify the type of a boundary.

file	cubicspline.hh
	A simple implementation of a cubic spline.

file	cubicsplinehermitebasis.hh
	The cubic hermite spline basis.

file	defaultmappertraits.hh
	Defines the default element and vertex mapper types.

file	defaultusagemessage.hh
	Function printing a default usage message.

file	deprecated.hh
	Helpers for deprecation.

file	dimensionlessnumbers.hh
	Collection of functions, calculating dimensionless numbers.

file	doubleexpintegrationconstants.hh
	Exponential integration abcissas.

file	doubleexpintegrator.hh
	A double exponential integrator.

file	dumuxmessage.hh
	Provides the class creating the famous DuMu^x start and end messages.

file	entitymap.hh
	A map from indices to entities using grid entity seeds.

file	enumerate.hh
	A Python-like enumerate function.

file	exceptions.hh
	Some exceptions thrown in DuMu^x

file	fvporousmediumspatialparams.hh
	The base class for spatial parameters in porous medium problems.

file	common/fvproblem.hh
	Base class for all finite volume problems.

file	fvproblemwithspatialparams.hh
	Base class for all finite volume problems that are parameterized.

file	common/fvspatialparams.hh
	Basic spatial parameters to be used with finite-volume schemes.

file	gridcapabilities.hh
	dune-grid capabilities compatibility layer

file	indextraits.hh
	Defines the index types used for grid and local indices.

file	initialize.hh
	The initialize function to be called before using Dumux.

file	integrate.hh
	Define helper functions for integration.

file	intersectionmapper.hh
	defines intersection mappers.

file	loggingparametertree.hh
	A parameter tree that logs which parameters have been used.

file	math.hh
	Define some often used mathematical functions.

file	monotonecubicspline.hh
	A monotone cubic spline.

file	numeqvector.hh
	A helper to deduce a vector with the same size as numbers of equations.

file	numericdifferentiation.hh
	A class for numeric differentiation.

file	optionalscalar.hh
	A wrapper that can either contain a valid Scalar or NaN.

file	parameters.cc
	The infrastructure to retrieve run-time parameters from Dune::ParameterTrees.

file	parameters.hh
	The infrastructure to retrieve run-time parameters from Dune::ParameterTrees.

file	partial.hh
	Get only parts of a container or tuple.

file	common/pdesolver.hh
	Defines a high-level interface for a PDESolver.

file	pointsource.hh
	A point source class, i.e. sources located at a single point in space.

file	common/properties.hh
	Declares all properties used in Dumux.

file	random.hh
	Some tools for random number generation.

file	reorderingdofmapper.hh
	An SCSG element mapper that sorts the indices in order to optimize the matrix sparsity pattern.

file	reservedblockvector.hh
	A arithmetic block vector type based on DUNE's reserved vector.

file	spline.hh
	Provides 3rd order polynomial splines.

file	staggeredfvproblem.hh
	Base class for all staggered fv problems.

file	stringutilities.hh
	Helpers for working with strings.

file	tabulated2dfunction.hh
	Implements tabulation for a two-dimensional function.

file	tag.hh
	Helper class to create (named and comparable) tagged types.

file	common/timeloop.hh
	Manages the handling of time dependent problems.

file	variables.hh

file	variablesbackend.hh
	Backends for operations on different solution vector types or more generic variable classes to be used in places where several different types/layouts should be supported.

file	variablesbackend.hh
	Backends for operations on different solution vector types or more generic variable classes to be used in places where several different types/layouts should be supported.

file	python/common/fvspatialparams.hh
	Basic spatial parameters to be used with finite-volume schemes.

Namespaces
namespace	Dumux::InterpolationPolicy
	forward declaration of the linear interpolation policy (default)

Classes
class	Dumux::BalanceEquationOptions< TypeTag >
	Traits class to set options used by the local residual when when evaluating the balance equations. More...

class	Dumux::BoundarySegmentIndexFlag
	Class for accessing boundary flags. More...

class	Dumux::BoundaryTypes< numEq >
	Class to specify the type of a boundary. More...

class	Dumux::CubicSpline< Scalar >
	A simple implementation of a natural cubic spline. More...

struct	Dumux::CubicSplineHermiteBasis< Scalar >
	The cubic spline hermite basis. More...

class	Dumux::DimensionlessNumbers< Scalar >
	Collection of functions which calculate dimensionless numbers. Each number has it's own function. All the parameters for the calculation have to be handed over. Rendering this collection generic in the sense that it can be used by any model. More...

class	Dumux::DumuxMessage
	DuMu^x start and end message. More...

class	Dumux::EntityMap< GridView, codim >
	A map from indices to entities using grid entity seeds. More...

class	Dumux::NumericalProblem
	Exception thrown if a fixable numerical problem occurs. More...

class	Dumux::ParameterException
	Exception thrown if a run-time parameter is not specified correctly. More...

class	Dumux::FVPorousMediumSpatialParams< GridGeometry, Scalar, Implementation >
	The base class for spatial parameters of porous-medium problems. More...

class	Dumux::FVProblem< TypeTag >
	Base class for all finite-volume problems. More...

class	Dumux::FVProblemWithSpatialParams< TypeTag >
	Base class for all finite-volume problems using spatial parameters. More...

class	Dumux::FVSpatialParams< GridGeometry, Scalar, Implementation >
	The base class for spatial parameters used with finite-volume schemes. More...

struct	Dumux::IndexTraits< GridView >
	Struture to define the index types used for grid and local indices. More...

class	Dumux::ConformingGridIntersectionMapper< GridView >
	defines a standard intersection mapper for mapping of global DOFs assigned to faces. It only works for conforming grids, without hanging nodes. More...

class	Dumux::NonConformingGridIntersectionMapper< GridView >
	defines an intersection mapper for mapping of global DOFs assigned to faces which also works for non-conforming grids and corner-point grids. More...

class	Dumux::IntersectionMapper< GridView >
	defines an intersection mapper for mapping of global DOFs assigned to faces which also works for adaptive grids. More...

class	Dumux::LoggingParameterTree
	A parameter tree that logs which parameters have been used. More...

struct	Dumux::InterpolationPolicy::Linear
	interpolate linearly between two given values More...

struct	Dumux::InterpolationPolicy::LinearTable
	interpolate linearly in a piecewise linear function (tabularized function) More...

class	Dumux::MonotoneCubicSpline< Scalar >
	A monotone cubic spline. More...

class	Dumux::NumericDifferentiation
	A class for numeric differentiation with respect to a scalar parameter. More...

struct	Dumux::OptionalScalar< T >
	A type for an optional scalar (contains either a valid number or NaN) More...

class	Dumux::Parameters
	Parameter class managing runtime input parameters. More...

class	Dumux::PDESolver< A, LS >
	A high-level interface for a PDESolver. More...

class	Dumux::PointSource< PositionType, ValueType >
	A point source base class. More...

class	Dumux::IdPointSource< GlobalPosition, SourceValues, I >
	A point source class with an identifier to attach data. More...

class	Dumux::SolDependentPointSource< TypeTag >
	A point source class for time dependent point sources. More...

class	Dumux::BoundingBoxTreePointSourceHelper
	A helper class calculating a sub control volume to point source map This class uses the bounding box tree implementation to indentify in which sub control volume(s) a point source falls. More...

class	Dumux::ReservedBlockVector< BlockType, capacity >
	A arithmetic block vector type based on DUNE's reserved vector. More...

class	Dumux::Spline< Scalar, numSamples >
	A 3rd order polynomial spline. More...

class	Dumux::Spline< Scalar, -1 >
	Specialization of a spline with the number of sampling points only known at run time. More...

class	Dumux::Spline< Scalar, 2 >
	Spline for two sampling points. More...

class	Dumux::StaggeredFVProblem< TypeTag >
	Base class for all staggered finite-volume problems. More...

class	Dumux::Tabulated2DFunction< Scalar >
	Implements tabulation for a two-dimensional function. More...

struct	Dumux::Utility::Tag< T >
	Helper class to create (named and comparable) tagged types Tags any given type. The tagged type is equality comparable and can be written to streams. A custom name can be provided by implementing the `name()` member function. More...

class	Dumux::TimeLoopBase< Scalar >
	Manages the handling of time dependent problems. More...

class	Dumux::TimeLoop< Scalar >
	The default time loop for instationary simulations. More...

class	Dumux::CheckPointTimeLoop< Scalar >
	A time loop with a check point mechanism. More...

class	Dumux::Experimental::Variables< X >
	Class that represents the variables of a model. We assume that models are formulated on the basis of primary and possibly secondary variables, where the latter may non-linearly depend on the former. Variables in Dumux represent the state of a numerical solution of a model, consisting of all primary/secondary variables and, if a transient problem is modeled, time information. More...

class	Dumux::DofBackend< DofVector, isScalar >
	Class providing operations with primary variable vectors. More...

class	Dumux::DofBackend< Scalar, true >
	Specialization providing operations for scalar/number types. More...

class	Dumux::DofBackend< Vector, false >
	Specialization providing operations for block vectors. More...

class	Dumux::DofBackend< Dune::MultiTypeBlockVector< Blocks... >, false >
	Specialization providing operations for multitype block vectors. More...

class	Dumux::Detail::VariablesBackend< Vars, false >
	Class providing operations for primary variable vector/scalar types. More...

class	Dumux::Python::FVProblem< GridGeometry_, SpatialParams_, PrimaryVariables, enableInternalDirichletConstraints_ >
	A C++ wrapper for a Python problem. More...

class	Dumux::Python::FVSpatialParams< GridGeometry_ >
	The base class for spatial parameters used with finite-volume schemes. More...

Typedefs
template<class PrimaryVariables >
using	Dumux::NumEqVector = typename NumEqVectorTraits< PrimaryVariables >::type
	A vector with the same size as numbers of equations This is the default implementation and has to be specialized for all custom primary variable vector types. More...

template<class Vars >
using	Dumux::VariablesBackend = Detail::VariablesBackend< Vars, Dune::Std::is_detected_v< Detail::SolutionVectorType, Vars > >
	Class providing operations for generic variable classes that represent the state of a numerical solution, possibly consisting of primary/secondary variables and information on the time level. More...

Functions
std::string	Dumux::defaultUsageMessage (const std::string &programName)
	Provides a general text block, that is part of error/ help messages. More...

template<class Scalar >
constexpr Scalar	Dumux::arithmeticMean (Scalar x, Scalar y, Scalar wx=1.0, Scalar wy=1.0) noexcept
	Calculate the (weighted) arithmetic mean of two scalar values. More...

template<class Scalar >
constexpr Scalar	Dumux::harmonicMean (Scalar x, Scalar y, Scalar wx=1.0, Scalar wy=1.0) noexcept
	Calculate the (weighted) harmonic mean of two scalar values. More...

template<class Scalar >
Scalar	Dumux::geometricMean (Scalar x, Scalar y) noexcept
	Calculate the geometric mean of two scalar values. More...

template<class Scalar , int m, int n>
void	Dumux::harmonicMeanMatrix (Dune::FieldMatrix< Scalar, m, n > &K, const Dune::FieldMatrix< Scalar, m, n > &Ki, const Dune::FieldMatrix< Scalar, m, n > &Kj)
	Calculate the harmonic mean of a fixed-size matrix. More...

template<class Scalar , class SolContainer >
int	Dumux::invertLinearPolynomial (SolContainer &sol, Scalar a, Scalar b)
	Invert a linear polynomial analytically. More...

template<class Scalar , class SolContainer >
int	Dumux::invertQuadraticPolynomial (SolContainer &sol, Scalar a, Scalar b, Scalar c)
	Invert a quadratic polynomial analytically. More...

template<class Scalar , class SolContainer >
int	Dumux::invertCubicPolynomial (SolContainer *sol, Scalar a, Scalar b, Scalar c, Scalar d, std::size_t numPostProcessIterations=1)
	Invert a cubic polynomial analytically. More...

template<class Scalar , int dim>
bool	Dumux::isLarger (const Dune::FieldVector< Scalar, dim > &pos, const Dune::FieldVector< Scalar, dim > &smallerVec)
	Comparison of two position vectors. More...

template<class Scalar , int dim>
bool	Dumux::isSmaller (const Dune::FieldVector< Scalar, dim > &pos, const Dune::FieldVector< Scalar, dim > &largerVec)
	Comparison of two position vectors. More...

template<class Scalar , int dim>
bool	Dumux::isBetween (const Dune::FieldVector< Scalar, dim > &pos, const Dune::FieldVector< Scalar, dim > &smallerVec, const Dune::FieldVector< Scalar, dim > &largerVec)
	Comparison of three position vectors. More...

template<class Policy = InterpolationPolicy::Linear, class Scalar , class ... Parameter>
Scalar	Dumux::interpolate (Scalar ip, Parameter &&... params)
	a generic function to interpolate given a set of parameters and an interpolation point More...

template<class Scalar >
std::vector< Scalar >	Dumux::linspace (const Scalar begin, const Scalar end, std::size_t samples, bool endPoint=true)
	Generates linearly spaced vectors. More...

template<class Scalar >
Scalar	Dumux::antoine (Scalar temperature, Scalar A, Scalar B, Scalar C)
	Evaluates the Antoine equation used to calculate the vapour pressure of various liquids. More...

template<class ValueType >
constexpr int	Dumux::sign (const ValueType &value) noexcept
	Sign or signum function. More...

template<class Scalar >
Dune::FieldVector< Scalar, 3 >	Dumux::crossProduct (const Dune::FieldVector< Scalar, 3 > &vec1, const Dune::FieldVector< Scalar, 3 > &vec2)
	Cross product of two vectors in three-dimensional Euclidean space. More...

template<class Scalar >
Scalar	Dumux::crossProduct (const Dune::FieldVector< Scalar, 2 > &vec1, const Dune::FieldVector< Scalar, 2 > &vec2)
	Cross product of two vectors in two-dimensional Euclidean space retuning scalar. More...

template<class Scalar >
Scalar	Dumux::tripleProduct (const Dune::FieldVector< Scalar, 3 > &vec1, const Dune::FieldVector< Scalar, 3 > &vec2, const Dune::FieldVector< Scalar, 3 > &vec3)
	Triple product of three vectors in three-dimensional Euclidean space retuning scalar. More...

template<class Scalar , int m, int n>
Dune::FieldMatrix< Scalar, n, m >	Dumux::getTransposed (const Dune::FieldMatrix< Scalar, m, n > &M)
	Transpose a FieldMatrix. More...

template<class Scalar >
Dune::DynamicMatrix< Scalar >	Dumux::getTransposed (const Dune::DynamicMatrix< Scalar > &M)
	Transpose a DynamicMatrix. More...

template<class Scalar >
Dune::DynamicMatrix< Scalar >	Dumux::multiplyMatrices (const Dune::DynamicMatrix< Scalar > &M1, const Dune::DynamicMatrix< Scalar > &M2)
	Multiply two dynamic matrices. More...

template<class Scalar , int rows1, int cols1, int cols2>
Dune::FieldMatrix< Scalar, rows1, cols2 >	Dumux::multiplyMatrices (const Dune::FieldMatrix< Scalar, rows1, cols1 > &M1, const Dune::FieldMatrix< Scalar, cols1, cols2 > &M2)
	Multiply two field matrices. More...

template<class MatrixType >
Dune::DenseMatrix< MatrixType >::field_type	Dumux::trace (const Dune::DenseMatrix< MatrixType > &M)
	Trace of a dense matrix. More...

template<class MAT , class V >
Dune::DenseVector< V >::derived_type	Dumux::mv (const Dune::DenseMatrix< MAT > &M, const Dune::DenseVector< V > &v)
	Returns the result of the projection of a vector v with a Matrix M. More...

template<class FieldScalar , class V >
std::enable_if_t< Dune::IsNumber< FieldScalar >::value, typename Dune::DenseVector< V >::derived_type >	Dumux::mv (const FieldScalar m, const Dune::DenseVector< V > &v)
	Returns the result of a vector v multiplied by a scalar m. More...

template<class V1 , class MAT , class V2 >
Dune::DenseMatrix< MAT >::value_type	Dumux::vtmv (const Dune::DenseVector< V1 > &v1, const Dune::DenseMatrix< MAT > &M, const Dune::DenseVector< V2 > &v2)
	Evaluates the scalar product of a vector v2, projected by a matrix M, with a vector v1. More...

template<class V1 , class FieldScalar , class V2 >
std::enable_if_t< Dune::IsNumber< FieldScalar >::value, FieldScalar >	Dumux::vtmv (const Dune::DenseVector< V1 > &v1, const FieldScalar m, const Dune::DenseVector< V2 > &v2)
	Evaluates the scalar product of a vector v2, scaled by a scalar m, with a vector v1. More...

template<class Scalar >
std::array< Scalar, 2 >	Dumux::linearRegression (const std::vector< Scalar > &x, const std::vector< Scalar > &y)
	Returns the [intercept, slope] of the regression line fitted to a set of (x, y) data points. More...

template<typename T , typename... Args>
T	Dumux::getParam (Args &&... args)
	A free function to get a parameter from the parameter tree singleton. More...

template<typename T , typename... Args>
T	Dumux::getParamFromGroup (Args &&... args)
	A free function to get a parameter from the parameter tree singleton with a model group. More...

bool	Dumux::hasParam (const std::string &param)
	Check whether a key exists in the parameter tree. More...

bool	Dumux::hasParamInGroup (const std::string &paramGroup, const std::string &param)
	Check whether a key exists in the parameter tree with a model group prefix. More...

std::vector< std::string >	Dumux::getParamSubGroups (const std::string &subGroupName, const std::string &paramGroup)
	Get a list of sub groups from the parameter tree sorted by relevance. More...

Typedef Documentation

◆ NumEqVector

template<class PrimaryVariables >

using Dumux::NumEqVector = typedef typename NumEqVectorTraits<PrimaryVariables>::type

A vector with the same size as numbers of equations This is the default implementation and has to be specialized for all custom primary variable vector types.

Note: This is based on the primary variables concept

◆ VariablesBackend

template<class Vars >

using Dumux::VariablesBackend = typedef Detail::VariablesBackend<Vars, Dune::Std::is_detected_v<Detail::SolutionVectorType, Vars> >

Class providing operations for generic variable classes that represent the state of a numerical solution, possibly consisting of primary/secondary variables and information on the time level.

Function Documentation

◆ antoine()

template<class Scalar >

Scalar Dumux::antoine	(	Scalar	temperature,
		Scalar	A,
		Scalar	B,
		Scalar	C
	)

Evaluates the Antoine equation used to calculate the vapour pressure of various liquids.

See http://en.wikipedia.org/wiki/Antoine_equation

Parameters

temperature	The temperature [K] of the fluid
A	The first coefficient for the Antoine equation
B	The first coefficient for the Antoine equation
C	The first coefficient for the Antoine equation

◆ arithmeticMean()

template<class Scalar >

constexpr Scalar Dumux::arithmeticMean	(	Scalar	x,
		Scalar	y,
		Scalar	wx = `1.0`,
		Scalar	wy = `1.0`
	)

constexprnoexcept

Calculate the (weighted) arithmetic mean of two scalar values.

Parameters

x	The first input value
y	The second input value
wx	The first weight
wy	The second weight

◆ crossProduct() [1/2]

template<class Scalar >

Scalar Dumux::crossProduct	(	const Dune::FieldVector< Scalar, 2 > &	vec1,
		const Dune::FieldVector< Scalar, 2 > &	vec2
	)

Cross product of two vectors in two-dimensional Euclidean space retuning scalar.

Parameters

vec1	The first vector
vec2	The second vector

◆ crossProduct() [2/2]

template<class Scalar >

Dune::FieldVector< Scalar, 3 > Dumux::crossProduct	(	const Dune::FieldVector< Scalar, 3 > &	vec1,
		const Dune::FieldVector< Scalar, 3 > &	vec2
	)

Cross product of two vectors in three-dimensional Euclidean space.

Parameters

vec1	The first vector
vec2	The second vector

◆ defaultUsageMessage()

std::string Dumux::defaultUsageMessage ( const std::string & programName )

inline

Provides a general text block, that is part of error/ help messages.

Returns: The string that is the help / error message.

◆ geometricMean()

template<class Scalar >

Scalar Dumux::geometricMean	(	Scalar	x,
		Scalar	y
	)

noexcept

Calculate the geometric mean of two scalar values.

Parameters

x	The first input value
y	The second input value

Note: as std::sqrt is not constexpr this function is not constexpr

◆ getParam()

template<typename T , typename... Args>

T Dumux::getParam ( Args &&... args )

A free function to get a parameter from the parameter tree singleton.

Note: auto endTime = getParam<double>("TimeManager.TEnd");; Once this has been called the first time, you cannot modify the parameter tree anymore

◆ getParamFromGroup()

template<typename T , typename... Args>

T Dumux::getParamFromGroup ( Args &&... args )

A free function to get a parameter from the parameter tree singleton with a model group.

Note: auto endTime = getParamFromGroup<double>("FreeFlow", "TimeManager.TEnd");; Once this has been called the first time, you cannot modify the parameter tree anymore

◆ getParamSubGroups()

std::vector< std::string > Dumux::getParamSubGroups	(	const std::string &	subGroupName,
		const std::string &	paramGroup
	)

inline

Get a list of sub groups from the parameter tree sorted by relevance.

Returns: A vector of fully qualified subGroup names sorted by descending relevance.

◆ getTransposed() [1/2]

template<class Scalar >

Dune::DynamicMatrix< Scalar > Dumux::getTransposed ( const Dune::DynamicMatrix< Scalar > & M )

Transpose a DynamicMatrix.

Parameters

M	The matrix to be transposed

◆ getTransposed() [2/2]

template<class Scalar , int m, int n>

Dune::FieldMatrix< Scalar, n, m > Dumux::getTransposed ( const Dune::FieldMatrix< Scalar, m, n > & M )

Transpose a FieldMatrix.

Parameters

M	The matrix to be transposed

◆ harmonicMean()

template<class Scalar >

constexpr Scalar Dumux::harmonicMean	(	Scalar	x,
		Scalar	y,
		Scalar	wx = `1.0`,
		Scalar	wy = `1.0`
	)

constexprnoexcept

Calculate the (weighted) harmonic mean of two scalar values.

Parameters

x	The first input value
y	The second input value
wx	The first weight
wy	The second weight

◆ harmonicMeanMatrix()

template<class Scalar , int m, int n>

void Dumux::harmonicMeanMatrix	(	Dune::FieldMatrix< Scalar, m, n > &	K,
		const Dune::FieldMatrix< Scalar, m, n > &	Ki,
		const Dune::FieldMatrix< Scalar, m, n > &	Kj
	)

Calculate the harmonic mean of a fixed-size matrix.

This is done by calculating the harmonic mean for each entry individually. The result is stored the first argument.

Parameters

K	The matrix for storing the result
Ki	The first input matrix
Kj	The second input matrix

◆ hasParam()

bool Dumux::hasParam ( const std::string & param )

inline

Check whether a key exists in the parameter tree.

Note: Once this has been called the first time, you cannot modify the parameter tree anymore

◆ hasParamInGroup()

bool Dumux::hasParamInGroup	(	const std::string &	paramGroup,
		const std::string &	param
	)

inline

Check whether a key exists in the parameter tree with a model group prefix.

Note: Once this has been called the first time, you cannot modify the parameter tree anymore

◆ interpolate()

template<class Policy = InterpolationPolicy::Linear, class Scalar , class ... Parameter>

Scalar Dumux::interpolate	(	Scalar	ip,
		Parameter &&...	params
	)

a generic function to interpolate given a set of parameters and an interpolation point

Parameters

params	the parameters used for interpolation (depends on the policy used)
ip	the interpolation point

◆ invertCubicPolynomial()

template<class Scalar , class SolContainer >

int Dumux::invertCubicPolynomial	(	SolContainer *	sol,
		Scalar	a,
		Scalar	b,
		Scalar	c,
		Scalar	d,
		std::size_t	numPostProcessIterations = `1`
	)

Invert a cubic polynomial analytically.

The polynomial is defined as

\[ p(x) = a\; x^3 + + b\;x^3 + c\;x + d \]

This method returns the number of solutions which are in the real numbers. The "sol" argument contains the real roots of the cubic polynomial in order with the smallest root first.

Note: The closer the roots are to each other the less precise the inversion becomes. Increase number of post-processing iterations for improved results.

Parameters

sol	Container into which the solutions are written
a	The coefficient for the cubic term
b	The coefficient for the quadratic term
c	The coefficient for the linear term
d	The coefficient for the constant term
numPostProcessIterations	The number of iterations to increase precision of the analytical result

◆ invertLinearPolynomial()

template<class Scalar , class SolContainer >

int Dumux::invertLinearPolynomial	(	SolContainer &	sol,
		Scalar	a,
		Scalar	b
	)

Invert a linear polynomial analytically.

The polynomial is defined as

\[ p(x) = a\; x + b \]

This method Returns the number of solutions which are in the real numbers, i.e. 1 except if the slope of the line is 0.

Parameters

sol	Container into which the solutions are written
a	The coefficiont for the linear term
b	The coefficiont for the constant term

◆ invertQuadraticPolynomial()

template<class Scalar , class SolContainer >

int Dumux::invertQuadraticPolynomial	(	SolContainer &	sol,
		Scalar	a,
		Scalar	b,
		Scalar	c
	)

Invert a quadratic polynomial analytically.

The polynomial is defined as

\[ p(x) = a\; x^2 + + b\;x + c \]

This method returns the number of solutions which are in the real numbers. The "sol" argument contains the real roots of the parabola in order with the smallest root first.

Parameters

sol	Container into which the solutions are written
a	The coefficiont for the quadratic term
b	The coefficiont for the linear term
c	The coefficiont for the constant term

◆ isBetween()

template<class Scalar , int dim>

bool Dumux::isBetween	(	const Dune::FieldVector< Scalar, dim > &	pos,
		const Dune::FieldVector< Scalar, dim > &	smallerVec,
		const Dune::FieldVector< Scalar, dim > &	largerVec
	)

Comparison of three position vectors.

Compares an current position vector with two reference vector, and returns true if the position vector lies in between them. "Between" in this case means that all the entries of each spatial dimension are smaller in comparison with the larger reference vector as well as larger campared to the smaller reference. This is comfortable to cheack weather the current position is located inside or outside of a lense with different properties.

Parameters

pos	Vektor holding the current Position that is to be checked
smallerVec	Reference vector, holding the minimum values for comparison.
largerVec	Reference vector, holding the maximum values for comparison.

◆ isLarger()

template<class Scalar , int dim>

bool Dumux::isLarger	(	const Dune::FieldVector< Scalar, dim > &	pos,
		const Dune::FieldVector< Scalar, dim > &	smallerVec
	)

Comparison of two position vectors.

Compares an current position vector with a reference vector, and returns true if the position vector is larger. "Larger" in this case means that all the entries of each spatial dimension are larger compared to the reference vector.

Parameters

pos	Vektor holding the current Position that is to be checked
smallerVec	Reference vector, holding the minimum values for comparison.

◆ isSmaller()

template<class Scalar , int dim>

bool Dumux::isSmaller	(	const Dune::FieldVector< Scalar, dim > &	pos,
		const Dune::FieldVector< Scalar, dim > &	largerVec
	)

Comparison of two position vectors.

Compares an current position vector with a reference vector, and returns true if the position vector is smaller. "Smaller" in this case means that all the entries of each spatial dimension are smaller in comparison with the reference vector.

Parameters

pos	Vektor holding the current Position that is to be checked
largerVec	Reference vector, holding the maximum values for comparison.

◆ linearRegression()

template<class Scalar >

std::array< Scalar, 2 > Dumux::linearRegression	(	const std::vector< Scalar > &	x,
		const std::vector< Scalar > &	y
	)

Returns the [intercept, slope] of the regression line fitted to a set of (x, y) data points.

Note: We use least-square regression method to find the regression line.

Parameters

x	x-values of the data set
y	y-values of the data set

◆ linspace()

template<class Scalar >

std::vector< Scalar > Dumux::linspace	(	const Scalar	begin,
		const Scalar	end,
		std::size_t	samples,
		bool	endPoint = `true`
	)

Generates linearly spaced vectors.

Parameters

begin	The first value in the vector
end	The last value in the vector
samples	The size of the vector
endPoint	if the range is including the interval's end point or not

◆ multiplyMatrices() [1/2]

template<class Scalar >

Dune::DynamicMatrix< Scalar > Dumux::multiplyMatrices	(	const Dune::DynamicMatrix< Scalar > &	M1,
		const Dune::DynamicMatrix< Scalar > &	M2
	)

Multiply two dynamic matrices.

Parameters

M1	The first dynamic matrix
M2	The second dynamic matrix (to be multiplied to M1 from the right side)

◆ multiplyMatrices() [2/2]

template<class Scalar , int rows1, int cols1, int cols2>

Dune::FieldMatrix< Scalar, rows1, cols2 > Dumux::multiplyMatrices	(	const Dune::FieldMatrix< Scalar, rows1, cols1 > &	M1,
		const Dune::FieldMatrix< Scalar, cols1, cols2 > &	M2
	)

Multiply two field matrices.

Parameters

M1	The first field matrix
M2	The second field matrix (to be multiplied to M1 from the right side)

◆ mv() [1/2]

template<class MAT , class V >

Dune::DenseVector< V >::derived_type Dumux::mv	(	const Dune::DenseMatrix< MAT > &	M,
		const Dune::DenseVector< V > &	v
	)

Returns the result of the projection of a vector v with a Matrix M.

Note: We use DenseVector and DenseMatrix here so that it can be used with the statically and dynamically allocated Dune Vectors/Matrices. Size mismatch assertions are done in the respective Dune classes.

Parameters

M	The matrix
v	The vector

◆ mv() [2/2]

template<class FieldScalar , class V >

std::enable_if_t< Dune::IsNumber< FieldScalar >::value, typename Dune::DenseVector< V >::derived_type > Dumux::mv	(	const FieldScalar	m,
		const Dune::DenseVector< V > &	v
	)

Returns the result of a vector v multiplied by a scalar m.

   Note: We use DenseVector and DenseMatrix here so that
   it can be used with the statically and dynamically
   allocated Dune Vectors/Matrices. Size mismatch
   assertions are done in the respective Dune classes.

Note: We need the enable_if to make sure that only Scalars fit here. Matrix types are forced to use the above mv(DenseMatrix, DenseVector) instead.

Parameters

m	The scale factor
v	The vector

◆ sign()

template<class ValueType >

constexpr int Dumux::sign ( const ValueType & value )

constexprnoexcept

Sign or signum function.

Returns 1 for a positive argument. Returns -1 for a negative argument. Returns 0 if the argument is zero.

◆ trace()

template<class MatrixType >

Dune::DenseMatrix< MatrixType >::field_type Dumux::trace ( const Dune::DenseMatrix< MatrixType > & M )

Trace of a dense matrix.

Parameters

M	The dense matrix

◆ tripleProduct()

template<class Scalar >

Scalar Dumux::tripleProduct	(	const Dune::FieldVector< Scalar, 3 > &	vec1,
		const Dune::FieldVector< Scalar, 3 > &	vec2,
		const Dune::FieldVector< Scalar, 3 > &	vec3
	)

Triple product of three vectors in three-dimensional Euclidean space retuning scalar.

Parameters

vec1	The first vector
vec2	The second vector
vec3	The third vector

◆ vtmv() [1/2]

template<class V1 , class MAT , class V2 >

Dune::DenseMatrix< MAT >::value_type Dumux::vtmv	(	const Dune::DenseVector< V1 > &	v1,
		const Dune::DenseMatrix< MAT > &	M,
		const Dune::DenseVector< V2 > &	v2
	)

Evaluates the scalar product of a vector v2, projected by a matrix M, with a vector v1.

Note: We use DenseVector and DenseMatrix here so that it can be used with the statically and dynamically allocated Dune Vectors/Matrices. Size mismatch assertions are done in the respective Dune classes.

Parameters

v1	The first vector
M	The matrix
v2	The second vector

◆ vtmv() [2/2]

template<class V1 , class FieldScalar , class V2 >

std::enable_if_t< Dune::IsNumber< FieldScalar >::value, FieldScalar > Dumux::vtmv	(	const Dune::DenseVector< V1 > &	v1,
		const FieldScalar	m,
		const Dune::DenseVector< V2 > &	v2
	)

Evaluates the scalar product of a vector v2, scaled by a scalar m, with a vector v1.

Note: We use DenseVector and DenseMatrix here so that it can be used with the statically and dynamically allocated Dune Vectors/Matrices. Size mismatch assertions are done in the respective Dune classes.

Note: We need the enable_if to make sure that only Scalars fit here. Matrix types are forced to use the above vtmv(DenseVector, DenseMatrix, DenseVector) instead.

Parameters

v1	The first vector
m	The scale factor
v2	The second vector

Description

Modules

Files

Namespaces

Classes

Typedefs

Functions

Typedef Documentation

◆ NumEqVector

◆ VariablesBackend

Function Documentation

◆ antoine()

◆ arithmeticMean()

◆ crossProduct() [1/2]

◆ crossProduct() [2/2]

◆ defaultUsageMessage()

◆ geometricMean()

◆ getParam()

◆ getParamFromGroup()

◆ getParamSubGroups()

◆ getTransposed() [1/2]

◆ getTransposed() [2/2]

◆ harmonicMean()

◆ harmonicMeanMatrix()

◆ hasParam()

◆ hasParamInGroup()

◆ interpolate()

◆ invertCubicPolynomial()

◆ invertLinearPolynomial()

◆ invertQuadraticPolynomial()

◆ isBetween()

◆ isLarger()

◆ isSmaller()

◆ linearRegression()

◆ linspace()

◆ multiplyMatrices() [1/2]

◆ multiplyMatrices() [2/2]

◆ mv() [1/2]

◆ mv() [2/2]

◆ sign()

◆ trace()

◆ tripleProduct()

◆ vtmv() [1/2]

◆ vtmv() [2/2]