version 3.8
Common

Common functionality. More...

Description

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  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 DuMux 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 DuMux
 
file  functionfromstringexpression.hh
 Evaluating string math expressions containing named variables.
 
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  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  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  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  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  common/volumevariables.hh
 Basic volume variables for finite volume methods.
 
file  variables.hh
 
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::BoundaryFlag< Grid >
 Boundary flag to store e.g. in sub control volume faces. 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
 DuMux 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::FunctionFromStringExpression< numVars, Scalar >
 Evaluating string math expressions containing named variables. 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 >
 Structure 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...
 
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::MetaData::Collector
 Class to collect metadata. 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::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 identify 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< S >
 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::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::Detail::VariablesBackend< Vars, true >
 Class providing operations for generic variable classes, containing primary and possibly also secondary variables. 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::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...
 

Typedef Documentation

◆ NumEqVector

template<class PrimaryVariables >
using Dumux::NumEqVector = typedef typename NumEqVectorTraits<PrimaryVariables>::type
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> >

Function Documentation

◆ antoine()

template<class Scalar >
Scalar Dumux::antoine ( Scalar  temperature,
Scalar  A,
Scalar  B,
Scalar  C 
)

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

Parameters
temperatureThe temperature [K] of the fluid
AThe first coefficient for the Antoine equation
BThe first coefficient for the Antoine equation
CThe 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
Parameters
xThe first input value
yThe second input value
wxThe first weight
wyThe second weight

◆ crossProduct() [1/2]

template<class Scalar >
Scalar Dumux::crossProduct ( const Dune::FieldVector< Scalar, 2 > &  vec1,
const Dune::FieldVector< Scalar, 2 > &  vec2 
)
Parameters
vec1The first vector
vec2The 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 
)
Parameters
vec1The first vector
vec2The second vector

◆ defaultUsageMessage()

std::string Dumux::defaultUsageMessage ( const std::string &  programName)
inline
Returns
The string that is the help / error message.

◆ geometricMean()

template<class Scalar >
Scalar Dumux::geometricMean ( Scalar  x,
Scalar  y 
)
noexcept
Parameters
xThe first input value
yThe second input value
Note
as std::sqrt is not constexpr this function is not constexpr

◆ getTransposed() [1/2]

template<class Scalar >
Dune::DynamicMatrix< Scalar > Dumux::getTransposed ( const Dune::DynamicMatrix< Scalar > &  M)
Parameters
MThe 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)
Parameters
MThe 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
Parameters
xThe first input value
yThe second input value
wxThe first weight
wyThe 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 
)

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

Parameters
KThe matrix for storing the result
KiThe first input matrix
KjThe second input matrix

◆ interpolate()

template<class Policy = InterpolationPolicy::Linear, class Scalar , class ... Parameter>
Scalar Dumux::interpolate ( Scalar  ip,
Parameter &&...  params 
)
Parameters
paramsthe parameters used for interpolation (depends on the policy used)
ipthe 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 
)

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
solContainer into which the solutions are written
aThe coefficient for the cubic term
bThe coefficient for the quadratic term
cThe coefficient for the linear term
dThe coefficient for the constant term
numPostProcessIterationsThe 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 
)

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
solContainer into which the solutions are written
aThe coefficiont for the linear term
bThe coefficiont for the constant term

◆ invertQuadraticPolynomial()

template<class Scalar , class SolContainer >
int Dumux::invertQuadraticPolynomial ( SolContainer &  sol,
Scalar  a,
Scalar  b,
Scalar  c 
)

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
solContainer into which the solutions are written
aThe coefficiont for the quadratic term
bThe coefficiont for the linear term
cThe 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 
)

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 compared 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
posVector holding the current Position that is to be checked
smallerVecReference vector, holding the minimum values for comparison.
largerVecReference 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 
)

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
posVector holding the current Position that is to be checked
smallerVecReference 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 
)

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
posVector holding the current Position that is to be checked
largerVecReference 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 
)

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

Parameters
xx-values of the data set
yy-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 
)
Parameters
beginThe first value in the vector
endThe last value in the vector
samplesThe size of the vector
endPointif 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 
)
Parameters
M1The first dynamic matrix
M2The 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 
)
Parameters
M1The first field matrix
M2The 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 
)

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
MThe matrix
vThe 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 
)
   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
mThe scale factor
vThe vector

◆ sign()

template<class ValueType >
constexpr int Dumux::sign ( const ValueType &  value)
constexprnoexcept

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)
Parameters
MThe 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 
)
Parameters
vec1The first vector
vec2The second vector
vec3The 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 
)

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
v1The first vector
MThe matrix
v2The 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 
)

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
v1The first vector
mThe scale factor
v2The second vector