Namespaces
	detail

	DSL

	HYPRE

	NavierStokesSolutions

	Tests

	XRotRotDetail

Classes
struct	KirchhoffLove
	Assemble a Kirchhoff-Love plate problem. More...

struct	QuadRot

struct	RMParameters
	Structure to store model data. More...

struct	RMNorms
	Structure to store component norms (for rotation, displacement, Kirchoff term and total energy) More...

struct	ReissnerMindlin
	Assemble a RM problem. More...

class	HHO_Diffusion
	The HHO_Diffusion class provides tools to implement the HHO method for the diffusion problem. More...

struct	FullGradientDiffusion
	Assemble a diffusion problem. More...

class	ScalarHybridSpace

class	VectorHybridSpace
	Class definition: polynomial bases and operators. More...

class	HHO_LocVarDiff
	The HHO_LocVarDiff class provides tools to implement the HHO method for the diffusion problem. More...

struct	NavierStokes
	Class for the Navier-Stokes model. More...

struct	Stokes
	Class for Stokes model. More...

class	HMM_StefanPME_Transient
	The vector Xh manipulated in the resolution has mixed components, corresponding either to the unknown u or to \(\zeta(u)\), depending on the choice of weight of mass-lumping for the cell/edge unknowns. If no weight is put on the edges (resp. the cells), then the edge (resp. cell) unknowns represent \(\zeta(u)\). Otherwise, they represent u. More...

class	StochStefanPME
	The vector Xh manipulated in the resolution has mixed components, corresponding either to the unknown \(u\) or to \(\zeta(e^W u)\), depending on the choice of weight of mass-lumping for the cell/edge unknowns. If no weight is put on the edges (resp. the cells), then the edge (resp. cell) unknowns represent \(\zeta(e^W u)\). Otherwise, they represent u. More...

class	LEPNC_diffusion
	The LEPNC_diffusion class provides an implementation of the LEPNC method for the stationnary diffusion problem \(-div(K\nabla u)=f\). More...

class	LEPNC_StefanPME
	LEPNC scheme for diffusion equation \(u - \div(K \nabla(\zeta(u))) = f\). More...

class	LEPNC_StefanPME_Transient
	LEPNC scheme for diffusion equation \(\partial_t u - \div(K \nabla(\zeta(u))) = f\). More...

class	LEPNCCore

struct	MonomialPowers
	Compute vectors listing the powers of monomial basis functions (for a cell, only this specialization is relevant) up to a certain degree. More...

struct	MonomialPowers< Cell >

struct	MatrixGradient
	Structure to store the gradient of a matrix-valued function. More...

class	MonomialScalarBasisCell
	Scalar monomial basis on a cell. More...

class	MonomialScalarBasisEdge
	Scalar monomial basis on an edge. More...

class	Family

class	TensorizedVectorFamily
	Vector family obtained by tensorization of a scalar family. More...

class	MatrixFamily
	Matrix family obtained from a scalar family. More...

class	TangentFamily
	Vector family for polynomial functions that are tangent to an edge (determined by the generator) More...

class	ShiftedBasis
	Generate a basis where the function indices are shifted. More...

class	RestrictedBasis
	Generate a basis restricted to the first "dimension" functions. More...

class	GradientBasis
	Basis for the space of gradients of polynomials. More...

class	CurlBasis
	Basis for the space of curls (vectorial rot) of polynomials. More...

class	DivergenceBasis
	Basis (or rather family) of divergence of an existing basis. More...

class	RotorBasis
	Basis (or rather family) of scalar rotor of an existing basis. More...

class	HessianBasis
	Basis for the space of Hessians of polynomials. More...

class	RolyComplBasisCell
	Basis for the complement R^{c,k}(T) in P^k(T)^2 of the range of the vectorial rotational on a face. More...

class	GolyComplBasisCell
	Basis for the complement G^{c,k}(T) in P^k(F)^2 of the range of the gradient on a face. More...

class	HolyComplBasisCell
	Basis for the complement H^{c,k}(T) in P^k(T)^{2x2} of the range of the Hessian on a face. More...

struct	evaluate_quad
	Evaluate a basis at quadrature nodes. 'BasisFunction' (=Function, Gradient, Curl, Divergence, or Rotor) determines what kind of value we want to evaluate. More...

struct	DecomposePoly
	Structure to decompose a set of polynomials on a basis on an edge or a cell. More...

class	GlobalDOFSpace
	Base class for global DOF spaces. Provides functions to manipulate global DOFs (the local version being provided by LocalDOFSpace). More...

struct	IntegralWeight
	Structure for weights (scalar, at the moment) in integral. More...

class	LinearSolver
	This structure is a wrapper to allow a given code to select various linear solvers. More...

struct	LocalStaticCondensation
	Structure to store information for, and perform, local static condensation. More...

class	LocalDOFSpace
	Base class for local DOF spaces: functions to access local DOFs (organised from the smallest dimension to the largest) associated with each geometric entity. More...

struct	PolynomialSpaceDimension
	Basis dimensions for various polynomial spaces on edges/faces/elements (when relevant): Pk, Gk, Rk and complements. More...

struct	PolynomialSpaceDimension< Cell >

struct	PolynomialSpaceDimension< Edge >

class	DDRCore
	Construct all polynomial spaces for the DDR sequence. More...

class	EXCurl
	Extended XCurl space, with vector-valued polynomials on the edges. More...

class	PlatesCore
	Construct all polynomial spaces for the plates sequence. More...

class	XCurl
	Discrete Hcurl space: local operators, L2 product and global interpolator. More...

class	XDivDiv
	Discrete Hdivdiv space. More...

class	XGrad
	Discrete H1 space: local operators, L2 product and global interpolator. More...

class	XRot
	Discrete H1 space: local operators, L2 product and global interpolator. More...

class	XRotRot
	Discrete HRotRot space: local operators, L2 product and global interpolator. More...

class	HHOSpace
	Class definition: polynomial bases and operators. More...

class	VHHOSpace
	Class definition: polynomial bases and operators. More...

class	ElementQuad

class	UVector

class	HybridCore

class	VtuWriter

struct	VecHash
	Hash function for VectorZd type. More...

class	QuadRuleEdge

class	LegendreGauss

class	QuadRuleTriangle
	Wrapper for dunavant quadrature rules. More...

struct	QuadratureNode
	Description of one node and one weight from a quadrature rule. More...

Typedefs
template<typename T >
using	SpatialFunctionType = std::function< T(const VectorRd &)>
	Generic type for function that only depends on spatial coordinate. More...

template<typename T >
using	PiecewiseSpatialFunctionType = std::function< T(const VectorRd &, const Cell *)>
	Generic type for function that depends on space, with formula changing from one cell to the next. More...

template<typename T >
using	TemporalSpatialFunctionType = std::function< T(const double &, const VectorRd &)>
	Generic type for function that depends on space and time. More...

template<typename T >
using	PiecewiseTemporalSpatialFunctionType = std::function< T(const double &, const VectorRd &, const Cell *)>
	Generic type for function that depends on space and time, with formula changing from one cell to the next. More...

template<typename T >
using	EigFunctionType = std::function< T(const size_t &, const size_t &, const VectorRd &)>
	Type for "eigenfunctions" e_i, depending on two indices k,l. More...

template<typename T >
using	DoubleVector = std::vector< std::vector< T > >

typedef Eigen::Matrix2d	MatrixRd

typedef Eigen::Vector2d	VectorRd

typedef Eigen::Vector2i	VectorZd

template<typename T >
using	BasisQuad = boost::multi_array< T, 2 >
	type for a family of basis functions evaluated on quadrature nodes More...

template<typename T >
using	FType = std::function< T(const VectorRd &)>
	type for function of point. T is the type of value of the function More...

template<typename MatrixType >
using	EigenLUType = Eigen::SparseLU< MatrixType >

template<typename MatrixType >
using	EigenBiCGStabType = Eigen::BiCGSTAB< MatrixType, Eigen::IncompleteLUT< double > >

template<typename MatrixType >
using	PardisoLUType = bool

template<typename MatrixType >
using	UMFPACKType = bool

using	PastixLUType = bool

using	PastixLLTType = bool

template<typename MatrixType >
using	ListSolvers = std::tuple< std::unique_ptr< EigenLUType< MatrixType > >, std::unique_ptr< EigenBiCGStabType< MatrixType > >, std::unique_ptr< PardisoLUType< MatrixType > >, std::unique_ptr< UMFPACKType< MatrixType > >, std::unique_ptr< PastixLUType >, std::unique_ptr< PastixLLTType > >

typedef std::function< bool(const Cell &)>	CellSelection

typedef std::unordered_map< VectorZd, double, VecHash >	MonomialCellIntegralsType
	Type for list of integrals of monomials. More...

typedef std::vector< double >	MonomialEdgeIntegralsType
	Type for list of edge integrals of monomials. More...

typedef std::vector< QuadratureNode >	QuadratureRule

Enumerations
enum	TensorRankE { Scalar = 0 , Vector = 1 , Matrix = 2 }

enum	BasisFunctionE { Function , Gradient , SymmetricGradient , SkewsymmetricGradient , Curl , Divergence , Rotor , Hessian }

enum	SolverName { EigenLU , EigenBiCGStab , PardisoLU , UMFPACK , PaStiXLU , PaStiXLLT }
	Enumeration of all available solvers. More...

Functions
static double	StDev (const Eigen::VectorXd &v)

double	scalar_product (const double &x, const double &y)
	Scalar product between two reals. More...

double	scalar_product (const VectorRd &x, const VectorRd &y)
	Scalar product between two vectors. More...

boost::multi_array< VectorRd, 2 >	matrix_vector_product (const boost::multi_array< MatrixRd, 2 > &basis_quad, const std::vector< VectorRd > &v_quad)
	Take the product of a matrix-valued basis with a vector. More...

boost::multi_array< VectorRd, 2 >	matrix_vector_product (const std::vector< MatrixRd > &m_quad, const boost::multi_array< VectorRd, 2 > &basis_quad)
	Take the product of a matrix with a vector-valued basis. More...

boost::multi_array< VectorRd, 2 >	vector_matrix_product (const std::vector< VectorRd > &v_quad, const boost::multi_array< MatrixRd, 2 > &basis_quad)
	Take the product of (the transposed of) a vector with a matrix-valued basis. More...

Eigen::MatrixXd	compute_gram_matrix (const boost::multi_array< VectorRd, 2 > &B1, const boost::multi_array< double, 2 > &B2, const QuadratureRule &qr)
	Compute the Gram-like matrix given a family of vector-valued and one of scalar-valued functions by tensorizing the latter. More...

Eigen::MatrixXd	compute_gram_matrix (const boost::multi_array< double, 2 > &B1, const boost::multi_array< double, 2 > &B2, const QuadratureRule &qr, const size_t nrows, const size_t ncols, const std::string sym="nonsym")
	Compute the Gram-like matrix given the evaluation of two families of functions at quadrature nodes. This version is an overload for double-valued families, more efficient than the generic templated version. More...

Eigen::MatrixXd	compute_gram_matrix (const boost::multi_array< double, 2 > &B1, const boost::multi_array< double, 2 > &B2, const QuadratureRule &qr, const std::string sym="nonsym")
	Compute the Gram-like matrix given the evaluation of two families of functions at quadrature nodes. Consists in calling the double-valued version with nrows = nb of elements in B1, ncols = nb of elements in B2. More...

Eigen::MatrixXd	compute_gram_matrix (const boost::multi_array< VectorRd, 2 > &B1, const boost::multi_array< VectorRd, 2 > &B2, const QuadratureRule &qr, const size_t nrows, const size_t ncols, const std::string sym="nonsym")
	Compute the Gram-like matrix given the evaluation of two families of functions at quadrature nodes. This version is an overload for Vector2d-valued families, more efficient than the generic templated version. More...

Eigen::MatrixXd	compute_gram_matrix (const boost::multi_array< VectorRd, 2 > &B1, const boost::multi_array< VectorRd, 2 > &B2, const QuadratureRule &qr, const std::string sym="nonsym")
	Compute the Gram-like matrix given the evaluation of two families of functions at quadrature nodes. Consists in calling the Vector2d-valued version with nrows = nb of elements in B1, ncols = nb of elements in B2. More...

Eigen::MatrixXd	compute_weighted_gram_matrix (const FType< VectorRd > &f, const BasisQuad< VectorRd > &B1, const BasisQuad< double > &B2, const QuadratureRule &qr, size_t n_rows=0, size_t n_cols=0)
	Computes the Gram-like matrix of integrals (f dot phi_i, phi_j) More...

Eigen::MatrixXd	compute_weighted_gram_matrix (const FType< VectorRd > &f, const BasisQuad< double > &B1, const BasisQuad< VectorRd > &B2, const QuadratureRule &qr, size_t n_rows=0, size_t n_cols=0)
	Computes the Gram-like matrix of integrals (phi_i, f dot phi_j) More...

template<size_t N>
MatrixGradient< N >	operator* (double scalar, MatrixGradient< N > const &G)
	Multiplication of a MatrixGradient from the left (non-member function to be able to multiply from the left) More...

template<typename outValue , typename inValue , typename FunctionType >
boost::multi_array< outValue, 2 >	transform_values_quad (const boost::multi_array< inValue, 2 > &B_quad, const FunctionType &F)
	Takes an array B_quad of values at quadrature nodes and applies the function F to all of them. F must take inValue and return outValue. The function must be called with outValue as template argument: transform_values_quad<outValue>(...) More...

template<typename ScalarBasisType , size_t N>
Family< TensorizedVectorFamily< ScalarBasisType, N > >	GenericTensorization (const ScalarBasisType &B, const std::vector< Eigen::VectorXd > &v)
	From a scalar family B=(B_1..B_r) and vectors (v_1..v_k) in R^N, constructs a "Family" of "TensorizedVectorFamily" (built on B, of size N) that represents the family (B_1v_1..B_rv_1 B_1v_2...B_rv_2... B_1v_k..B_rv_k). More...

template<typename ScalarBasisType , size_t N>
Family< MatrixFamily< ScalarBasisType, N > >	IsotropicMatrixFamily (const ScalarBasisType &B)
	From a scalar family B, constructs a "Family" of "MatrixFamily" (built on B, of size NxN) that represents the family B Id on the MatrixFamily. More...

template<typename T >
Eigen::MatrixXd	gram_schmidt (boost::multi_array< T, 2 > &basis_eval, const std::function< double(size_t, size_t)> &inner_product)

template<int N>
double	scalar_product (const Eigen::Matrix< double, N, N > &x, const Eigen::Matrix< double, N, N > &y)
	Scalar product between two matrices. More...

template<typename Value >
boost::multi_array< double, 2 >	scalar_product (const boost::multi_array< Value, 2 > &basis_quad, const Value &v)
	This overloading of the scalar_product function computes the scalar product between an evaluation of a basis and a constant value; both basis values and constant value must be of type Value. More...

template<typename Value >
boost::multi_array< double, 2 >	scalar_product (const boost::multi_array< Value, 2 > &basis_quad, const std::vector< Value > &v)
	This overloading of the scalar_product function computes the scalar product between an evaluation of a basis and a field that varies on the quadrature nodes; both basis values and constant value must be of type Value. More...

template<typename BasisType >
Family< BasisType >	l2_orthonormalize (const BasisType &basis, const QuadratureRule &qr, boost::multi_array< typename BasisType::FunctionValue, 2 > &basis_quad)
	\(L^2\)-orthonormalization: simply consists in using gram_schmidt() with the specific l2 inner product More...

template<typename BasisType >
Family< BasisType >	l2_orthonormalize (const BasisType &basis, const Eigen::MatrixXd &GM)
	\(L^2\)-orthonormalization: when the Gram Matrix is passed, we use Cholesky. More...

template<typename FunctionValue >
Eigen::MatrixXd	compute_gram_matrix (const boost::multi_array< FunctionValue, 2 > &B1, const boost::multi_array< FunctionValue, 2 > &B2, const QuadratureRule &qr, const size_t nrows, const size_t ncols, const std::string sym="nonsym")
	Compute the Gram-like matrix given the evaluation of two families of functions at quadrature nodes. This templated function is very generic, and thus not the most efficient. More efficient overloads are provided for double- or Vector2d-valued families. More...

template<typename FunctionValue >
Eigen::MatrixXd	compute_gram_matrix (const boost::multi_array< FunctionValue, 2 > &B1, const boost::multi_array< FunctionValue, 2 > &B2, const QuadratureRule &qr, const std::string sym="nonsym")
	Compute the Gram-like matrix given the evaluation of two families of functions at quadrature nodes. This version calls the generic one with nrows = nb of elements in family B1 and ncols = nb of elements in family B2. More...

template<typename FunctionValue >
Eigen::MatrixXd	compute_gram_matrix (const boost::multi_array< FunctionValue, 2 > &B, const QuadratureRule &qr)
	Compute the Gram matrix given the evaluation of one family of functions at quadrature nodes. Consists in calling the generic templated version with B1=B2. More...

template<typename ScalarFamilyType , size_t N>
Eigen::MatrixXd	compute_gram_matrix (const MatrixFamily< ScalarFamilyType, N > &MatFam, const boost::multi_array< double, 2 > &scalar_family_quad, const QuadratureRule &qr)
	Compute the Gram-like matrix for a MatrixFamily. This overload is more efficient than the generic function as it only computes the gram matrix of the underlying scalar family, and then creates the bloc-diagonal gram matrix of the MatrixFamily (which is indeed bloc diagonal given the choice of m_E elements in this class). More...

template<typename T >
Eigen::VectorXd	integrate (const FType< T > &f, const BasisQuad< T > &B, const QuadratureRule &qr, size_t n_rows=0)
	Compute the integral of a given function against all functions from a family. More...

template<typename T , typename U >
Eigen::MatrixXd	compute_weighted_gram_matrix (const FType< U > &f, const BasisQuad< T > &B1, const BasisQuad< T > &B2, const QuadratureRule &qr, size_t n_rows=0, size_t n_cols=0, const std::string sym="nonsym")
	Computes the Gram-like matrix of integrals (f phi_i, phi_j) More...

template<typename T , typename U >
Eigen::MatrixXd	compute_weighted_gram_matrix (const FType< U > &f, const BasisQuad< T > &B1, const BasisQuad< T > &B2, const QuadratureRule &qr, const std::string sym)
	Computes the Gram-like matrix of integrals (f phi_i, phi_j) More...

template<typename Value >
Eigen::MatrixXd	compute_closure_matrix (const boost::multi_array< Value, 2 > &f_quad, const boost::multi_array< Value, 2 > &g_quad, const QuadratureRule &qr_f, const QuadratureRule &qr_g)
	Computes closure equation matrices, from evaluations at quadrature nodes. For two families of functions \((f_i)\) and \((g_j)\) with values in some space E, this routine computes the matrix \((\int f_i)\cdot(\int g_j)\) where \(\cdot\) is the dot product in E. More...

template<typename Value >
Eigen::MatrixXd	compute_closure_matrix (const boost::multi_array< Value, 2 > &f_quad, const boost::multi_array< Value, 2 > &g_quad, const QuadratureRule &qr)
	Computes closure equation matrices. Overload of the previous one when qr_f=qr_g. More...

template<typename Value >
Eigen::MatrixXd	compute_closure_matrix (const boost::multi_array< Value, 2 > &f_quad, const QuadratureRule &qr)
	Computes closure equation matrices. Overload of the previous one when f=g. More...

template<typename BasisType >
Eigen::VectorXd	l2_projection (const std::function< typename BasisType::FunctionValue(const VectorRd &)> &f, const BasisType &basis, QuadratureRule &quad, const boost::multi_array< typename BasisType::FunctionValue, 2 > &basis_quad, const Eigen::MatrixXd &mass_basis=Eigen::MatrixXd::Zero(1, 1))
	Compute the L2-projection of a function. More...

std::pair< double, double >	store_times (boost::timer::cpu_timer &timer, std::string message="")
	Function to store and display wall/proc timers from boost::timer::cpu_timer. More...

static std::pair< std::vector< int >, std::vector< int > >	distributeLoad (size_t nb_elements, unsigned nb_threads)
	Function to distribute elements (considered as jobs) over threads. It returns a pair of vectors indicating the start and end element of each thread. More...

static void	parallel_for (unsigned nb_elements, std::function< void(size_t start, size_t end)> functor, bool use_threads=true, unsigned nb_threads_max=1e9)
	Generic function to execute threaded processes. More...

static std::pair< Eigen::SparseMatrix< double >, Eigen::VectorXd >	parallel_assembly_system (size_t nb_elements, size_t size_system, std::function< void(size_t start, size_t end, std::list< Eigen::Triplet< double >> triplets, Eigen::VectorXd rhs)> batch_local_assembly, bool use_threads=true)
	Function to assemble global matrix and right-hand side from a procedure that computes local triplets and rhs contributions. More...

static std::tuple< Eigen::SparseMatrix< double >, Eigen::VectorXd, Eigen::SparseMatrix< double > >	parallel_assembly_system (size_t nb_elements, size_t size_system1, std::pair< size_t, size_t > size_Mat2, std::function< void(size_t start, size_t end, std::list< Eigen::Triplet< double >> triplets1, Eigen::VectorXd vec1, std::list< Eigen::Triplet< double >> *triplets2)> batch_local_assembly, bool use_threads=true)
	Function to assemble two global matrices and one vector (such as: system matrix+vector and matrix for BC) from a procedure that computes local triplets and rhs contributions. More...

static std::tuple< Eigen::SparseMatrix< double >, Eigen::VectorXd, Eigen::SparseMatrix< double >, Eigen::VectorXd >	parallel_assembly_system (size_t nb_elements, size_t size_system1, std::pair< size_t, size_t > size_Mat2, size_t size_b2, std::function< void(size_t start, size_t end, std::list< Eigen::Triplet< double >> triplets1, Eigen::VectorXd vec1, std::list< Eigen::Triplet< double >> triplets2, Eigen::VectorXd vec2)> batch_local_assembly, bool use_threads=true)
	Function to assemble two global matrices and vectors (such as: system and static condensation operator) from a procedure that computes local triplets and rhs contributions. More...

double	compute_squared_rotrot_norm (size_t iT, const Eigen::VectorXd &vT, const XRot &x_rot, const XRotRot &x_rotrot)
	Compute the squared rotrot norm on the element of index iT. More...

double	compute_rotrot_norm (const Eigen::VectorXd &v, const XRot &x_rot, const XRotRot &x_rotrot)
	Compute rotrot norm. More...

template<typename GeometricSupport >
size_t const	DimPoly (int m)

template<>
const size_t	DimPoly< Cell > (const int m)
	Compute the size of the basis of 2-variate polynomials up to degree m. More...

template<>
const size_t	DimPoly< Edge > (const int m)
	Compute the size of the basis of 1-variate polynomials up to degree m. More...

MonomialCellIntegralsType	IntegrateCellMonomials (const Cell &T, const size_t maxdeg)
	Compute all integrals on a cell of monomials up to a total degree, using vertex values. More...

MonomialCellIntegralsType	CheckIntegralsDegree (const Cell &T, const size_t degree, const MonomialCellIntegralsType &mono_int_map={})
	Checks if the degree of an existing list of monomial integrals is sufficient, other re-compute and return a proper list. More...

template<typename BasisType >
Eigen::MatrixXd	transformGM (const Family< BasisType > &family_basis, const char RC, const Eigen::MatrixXd &anc_GM)
	Transforms a Gram Matrix from an ancestor to a family basis. More...

template<typename BasisType >
Eigen::MatrixXd	transformGM (const RestrictedBasis< BasisType > &restr_basis, const char RC, const Eigen::MatrixXd &anc_GM)
	Transforms a Gram Matrix from an ancestor to a restricted basis. More...

template<typename BasisType >
Eigen::MatrixXd	transformGM (const ShiftedBasis< BasisType > &shifted_basis, const char RC, const Eigen::MatrixXd &anc_GM)
	Transforms a Gram Matrix from an ancestor to a shifted basis. More...

Eigen::MatrixXd	GramMatrix (const Cell &T, const MonomialScalarBasisCell &basis1, const MonomialScalarBasisCell &basis2, MonomialCellIntegralsType mono_int_map={})
	Computes the Gram Matrix of a pair of local scalar monomial bases. More...

template<typename BasisType >
Eigen::MatrixXd	GramMatrix (const Cell &T, const BasisType &basis, MonomialCellIntegralsType mono_int_map={})
	This overload to simplify the call to GramMatrix in case the two bases are the same. More...

template<typename BasisType1 , typename BasisType2 , size_t N>
Eigen::MatrixXd	GramMatrix (const Cell &T, const TensorizedVectorFamily< BasisType1, N > &basis1, const TensorizedVectorFamily< BasisType2, N > &basis2, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of any pair of tensorized scalar bases. More...

Eigen::MatrixXd	GramMatrix (const Cell &T, const RolyComplBasisCell &basis1, const RolyComplBasisCell &basis2, MonomialCellIntegralsType mono_int_map={})
	Computes the Gram Matrix of a pair of RolyCompl bases. More...

template<typename BasisType1 , size_t N>
Eigen::MatrixXd	GramMatrix (const Cell &T, const RolyComplBasisCell &rolycompl_basis, const TensorizedVectorFamily< BasisType1, N > &tens_family, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of a RolyCompl basis and a tensorized scalar basis. More...

template<typename BasisType1 , size_t N>
Eigen::MatrixXd	GramMatrix (const Cell &T, const TensorizedVectorFamily< BasisType1, N > &tens_family, const RolyComplBasisCell &rolycompl_basis, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of a tensorized scalar basis and a RolyCompl basis. More...

Eigen::MatrixXd	GramMatrix (const Cell &T, const GolyComplBasisCell &basis1, const GolyComplBasisCell &basis2, MonomialCellIntegralsType mono_int_map={})
	Gram Matrix of a pair of GolyCompl bases. More...

Eigen::MatrixXd	GMRolyComplScalar (const Cell &T, const RolyComplBasisCell &rolycompl_basis, const MonomialScalarBasisCell &mono_basis, const size_t m, MonomialCellIntegralsType mono_int_map)
	Computes the Gram Matrix of the mth component of a RolyCompl Basis and a monomial basis. More...

template<typename BasisType >
Eigen::MatrixXd	GMRolyComplScalar (const Cell &T, const RolyComplBasisCell &basis1, const BasisType &basis2, const size_t m, MonomialCellIntegralsType mono_int_map)
	Generic template to compute the Gram Matrix of the mth component of a RolyCompl Basis and any basis. More...

template<typename BasisType >
constexpr bool	useAncestor ()
	Determines if the ancestor of a basis will be used to compute a Gram matrix for this basis. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Cell &T, const BasisType1 &basis1, const BasisType2 &basis2, MonomialCellIntegralsType mono_int_map={})
	Generic template to compute the Gram Matrix of any pair of bases. More...

Eigen::MatrixXd	GMScalarDerivative (const Cell &T, const MonomialScalarBasisCell &basis1, const MonomialScalarBasisCell &basis2, const size_t m, MonomialCellIntegralsType mono_int_map={})
	Computes the Gram Matrix of a pair of local scalar monomial bases, taking a partial derivative of the first (w.r.t. the homogeneous coordinates, without scaling) More...

Eigen::MatrixXd	GMScalarDerivative (const Cell &T, const MonomialScalarBasisCell &basis1, const MonomialScalarBasisCell &basis2, const size_t m, const size_t l, MonomialCellIntegralsType mono_int_map={})
	Computes the Gram Matrix of a pair of local scalar monomial bases, taking partial derivatives of each of them (w.r.t. the homogeneous coordinates, without scaling) More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GMScalarDerivative (const Cell &T, const BasisType1 &basis1, const BasisType2 &basis2, const size_t m, MonomialCellIntegralsType mono_int_map={})
	Generic template to compute the Gram Matrix of any pair of scalar bases, taking a partial derivative of the first (w.r.t. the homogeneous coordinates, without scaling) More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GMScalarDerivative (const Cell &T, const BasisType1 &basis1, const BasisType2 &basis2, const size_t m, const size_t l, MonomialCellIntegralsType mono_int_map={})
	Generic template to compute the Gram Matrix of any pair of scalar bases, taking partial derivatives of each of them (w.r.t. the homogeneous coordinates, without scaling) More...

template<typename BasisType1 , typename BasisType2 , size_t N>
Eigen::MatrixXd	GramMatrix (const Cell &T, const GradientBasis< BasisType1 > &grad_basis, const TensorizedVectorFamily< BasisType2, N > &tens_family, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of a gradient basis and a tensorized scalar basis. More...

template<typename BasisType1 , typename BasisType2 , size_t N>
Eigen::MatrixXd	GramMatrix (const Cell &T, const TensorizedVectorFamily< BasisType1, N > &tens_family, const GradientBasis< BasisType2 > &grad_basis, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of a tensorized scalar basis and a gradient basis. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Cell &T, const GradientBasis< BasisType1 > &grad_basis1, const GradientBasis< BasisType2 > &grad_basis2, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of a gradient basis and another gradient basis. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Cell &T, const CurlBasis< BasisType1 > &basis1, const CurlBasis< BasisType2 > &basis2, MonomialCellIntegralsType mono_int_map={})
	Generic template to compute the Gram Matrix of a pair of Curl bases. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Cell &T, const CurlBasis< BasisType1 > &curl_basis, const TensorizedVectorFamily< BasisType2, 2 > &tens_family, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of a curl basis and a tensorized scalar basis. More...

template<typename BasisType1 , typename BasisType2 , size_t N>
Eigen::MatrixXd	GramMatrix (const Cell &T, const TensorizedVectorFamily< BasisType1, N > &tens_family, const CurlBasis< BasisType2 > &curl_basis, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of a tensorized scalar basis and a gradient basis. More...

template<typename BasisType1 , typename BasisType2 >
boost::disable_if< boost::is_same< BasisType2, MonomialCellIntegralsType >, Eigen::MatrixXd >::type	GramMatrix (const Cell &T, const DivergenceBasis< BasisType1 > &basis1, const BasisType2 &basis2, MonomialCellIntegralsType mono_int_map={})
	Generic template to compute the Gram Matrix of a Divergence basis and any other basis. More...

template<typename BasisType1 , typename Basis2 >
Eigen::MatrixXd	GramMatrix (const Cell &T, const BasisType1 &basis1, const DivergenceBasis< Basis2 > &basis2, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of any basis and a Divergence basis. More...

template<typename BasisType1 >
Eigen::MatrixXd	GramMatrixDiv (const Cell &T, const TensorizedVectorFamily< BasisType1, 2 > &basis1, const MonomialScalarBasisCell &basis2, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of a Divergence<Tensorized> basis and a monomial scalar basis. More...

Eigen::MatrixXd	GramMatrixDiv (const Cell &T, const RolyComplBasisCell &basis1, const MonomialScalarBasisCell &basis2, MonomialCellIntegralsType mono_int_map={})
	Computes the Gram Matrix of a Divergence<RolyCompl> basis and a monomial scalar basis. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrixDiv (const Cell &T, const BasisType1 &basis1, const BasisType2 &basis2, MonomialCellIntegralsType mono_int_map={})
	Template to compute the Gram Matrix of the divergence of any basis and any other basis. More...

template<typename BasisType1 , typename BasisType2 , size_t N>
Eigen::MatrixXd	GramMatrix (const Cell &T, const MatrixFamily< BasisType1, N > &basis1, const MatrixFamily< BasisType2, N > &basis2, MonomialCellIntegralsType mono_int_map={})
	Gram Matrix of any pair of MatrixFamily bases. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Cell &T, const DivergenceBasis< MatrixFamily< BasisType1, dimspace >> &basis1, const TensorizedVectorFamily< BasisType2, dimspace > &basis2, MonomialCellIntegralsType mono_int_map={})

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Cell &T, const GradientBasis< TensorizedVectorFamily< BasisType1, dimspace >> &basis1, const MatrixFamily< BasisType2, dimspace > &basis2, MonomialCellIntegralsType mono_int_map={})
	Gram Matrix of the gradient basis of a tensorized family and a matrix family (only valid if N=dimspace in Tensorized and MatrixFamily). More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Cell &T, const MatrixFamily< BasisType1, dimspace > &basis1, const GradientBasis< TensorizedVectorFamily< BasisType2, dimspace >> &basis2, MonomialCellIntegralsType mono_int_map={})
	Gram Matrix of a Matrix family and the gradient of a tensorized family. More...

template<typename BasisType1 , typename BasisType2 , size_t N>
Eigen::MatrixXd	GramMatrix (const Cell &T, const GradientBasis< TensorizedVectorFamily< BasisType1, N >> &basis1, const GradientBasis< TensorizedVectorFamily< BasisType2, N >> &basis2, MonomialCellIntegralsType mono_int_map={})
	Gram Matrix of two gradient bases of tensorized families. More...

MonomialEdgeIntegralsType	IntegrateEdgeMonomials (const Edge &E, const size_t maxdeg)
	Compute all integrals of edge monomials up to a total degree. More...

MonomialEdgeIntegralsType	CheckIntegralsDegree (const Edge &E, const size_t degree, const MonomialEdgeIntegralsType &mono_int_map={})
	Checks if the degree of an existing list of monomial integrals is sufficient, other re-compute and return a proper list. More...

Eigen::MatrixXd	GramMatrix (const Edge &E, const MonomialScalarBasisEdge &basis1, const MonomialScalarBasisEdge &basis2, MonomialEdgeIntegralsType mono_int_map={})
	Computes the Gram Matrix of a pair of local scalar monomial bases. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Edge &E, const BasisType1 &basis1, const BasisType2 &basis2, MonomialEdgeIntegralsType mono_int_map={})
	Generic template to compute the Gram Matrix of any pair of bases. More...

template<typename BasisType1 , typename BasisType2 , size_t N>
Eigen::MatrixXd	GramMatrix (const Edge &E, const TensorizedVectorFamily< BasisType1, N > &basis1, const TensorizedVectorFamily< BasisType2, N > &basis2, MonomialEdgeIntegralsType mono_int_map={})

template<typename BasisType >
Eigen::MatrixXd	GramMatrix (const Edge &E, const BasisType &basis, MonomialEdgeIntegralsType mono_int_map={})
	This overload to simplify the call to GramMatrix in case the two bases are the same. More...

Eigen::MatrixXd	GMDer (const Edge &E, const MonomialScalarBasisEdge &basis1, const MonomialScalarBasisEdge &basis2, MonomialEdgeIntegralsType mono_int_map={})
	Computes the Gram Matrix of the derivative of a monomial basis with another monomial basis. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GMDer (const Edge &E, const BasisType1 &basis1, const BasisType2 &basis2, MonomialEdgeIntegralsType mono_int_map={})
	Generic template for GMDer with derived bases. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Edge &E, const GradientBasis< BasisType1 > &basis1, const BasisType2 &basis2, MonomialEdgeIntegralsType mono_int_map={})
	Computes the Gram Matrix of a gradient basis (considering the tangential gradient as a scalar) and a scalar basis. More...

template<typename BasisType1 , typename BasisType2 >
Eigen::MatrixXd	GramMatrix (const Edge &E, const BasisType1 &basis1, const GradientBasis< BasisType2 > &basis2, MonomialEdgeIntegralsType mono_int_map={})
	Computes the Gram Matrix of a scalar basis and a gradient basis (considering the tangential gradient as a scalar) More...

QuadratureRule	generate_quadrature_rule (const Cell &T, const int doe, const bool force_split=false)
	Generate quadrature rule on mesh element. More...

QuadratureRule	generate_quadrature_rule (const Edge &E, const int doe)
	Generate quadrature rule on mesh face. More...

template<typename T >
double	squared_l2_error (const std::function< T(const Eigen::Vector2d &)> &f, const Eigen::VectorXd &fX, const boost::multi_array< T, 2 > &fX_basis_quad, const QuadratureRule &quad_X)

Variables
static const double	PI = boost::math::constants::pi<double>()

static KirchhoffLove::DeflectionType	trigonometric_u

static KirchhoffLove::GradientDeflectionType	trigonometric_grad_u

static KirchhoffLove::MomentTensorType	trigonometric_hess_u

static KirchhoffLove::MomentTensorType	trigonometric_dx_hess_u

static KirchhoffLove::MomentTensorType	trigonometric_dy_hess_u

static KirchhoffLove::GradientDeflectionType	trigonometric_grad_Delta_u

static KirchhoffLove::MomentTensorEdgeDerivativeType	trigonometric_hess_u_DE

static KirchhoffLove::ForcingTermType	trigonometric_divdiv_hess_u

static KirchhoffLove::DeflectionType	quartic_u

static KirchhoffLove::GradientDeflectionType	quartic_grad_u

static KirchhoffLove::MomentTensorType	quartic_hess_u

static KirchhoffLove::MomentTensorType	quartic_dx_hess_u

static KirchhoffLove::MomentTensorType	quartic_dy_hess_u

static KirchhoffLove::GradientDeflectionType	quartic_grad_Delta_u

static KirchhoffLove::MomentTensorEdgeDerivativeType	quartic_hess_u_DE

static KirchhoffLove::ForcingTermType	quartic_divdiv_hess_u

static KirchhoffLove::DeflectionType	biquartic_u

static KirchhoffLove::GradientDeflectionType	biquartic_grad_u

static KirchhoffLove::MomentTensorType	biquartic_hess_u

static KirchhoffLove::MomentTensorType	biquartic_dx_hess_u

static KirchhoffLove::MomentTensorType	biquartic_dy_hess_u

static KirchhoffLove::GradientDeflectionType	biquartic_grad_Delta_u

static KirchhoffLove::MomentTensorEdgeDerivativeType	biquartic_hess_u_DE

static KirchhoffLove::ForcingTermType	biquartic_divdiv_hess_u

static const double	PI = boost::math::constants::pi<double>()

static QuadRot::PotentialType	linear_u

static QuadRot::RotorType	linear_rot_u

static QuadRot::RotRotType	linear_rotrot_u

static QuadRot::LagrangeMultiplierType	linear_p

static QuadRot::ForcingTermType	linear_f

static QuadRot::PotentialType	quadratic_u

static QuadRot::RotorType	quadratic_rot_u

static QuadRot::RotRotType	quadratic_rotrot_u

static QuadRot::LagrangeMultiplierType	quadratic_p

static QuadRot::ForcingTermType	quadratic_f

static QuadRot::PotentialType	cubic_u

static QuadRot::RotorType	cubic_rot_u

static QuadRot::RotRotType	cubic_rotrot_u

static QuadRot::LagrangeMultiplierType	cubic_p

static QuadRot::ForcingTermType	cubic_f

static QuadRot::PotentialType	quartic_u

static QuadRot::RotorType	quartic_rot_u

static QuadRot::RotRotType	quartic_rotrot_u

static QuadRot::LagrangeMultiplierType	quartic_p

static QuadRot::ForcingTermType	quartic_f

static QuadRot::PotentialType	trigonometric_u

static QuadRot::RotorType	trigonometric_rot_u

static QuadRot::RotRotType	trigonometric_rotrot_u

static QuadRot::RotorType	trigonometric_rotrotrot_u

static QuadRot::LagrangeMultiplierType	trigonometric_p

static QuadRot::ForcingTermType	trigonometric_f

static const double	PI = boost::math::constants::pi<double>()

static ReissnerMindlin::SolutionRotationType	constant_theta

static ReissnerMindlin::GradientRotationType	constant_grad_theta

static ReissnerMindlin::SolutionDisplacementType	constant_u

static ReissnerMindlin::ForcingTermType	constant_f

static ReissnerMindlin::SolutionRotationType	polynomial_theta

static ReissnerMindlin::GradientRotationType	polynomial_grad_theta

static ReissnerMindlin::SolutionDisplacementType	polynomial_u

static ReissnerMindlin::ForcingTermType	polynomial_f

static std::function< double(const VectorRd &)>	an_g = [](const VectorRd &x)->double { return sin(PIx(0))sin(PI*x(1)); }

static std::function< VectorRd(const VectorRd &)>	an_GRAD_g

static std::function< MatrixRd(const VectorRd &)>	an_HESS_g

static std::function< double(const VectorRd &)>	an_LAPL_g = [](const VectorRd &x)->double { return -2pow(PI,2)sin(PIx(0))sin(PI*x(1)); }

static std::function< double(const VectorRd &)>	an_V = [](const VectorRd &x)->double { return x(0) * exp(-x(0))*cos(x(1)); }

static std::function< VectorRd(const VectorRd &)>	an_GRAD_V

static std::function< MatrixRd(const VectorRd &)>	an_HESS_V

static std::function< double(const VectorRd &)>	an_LAPL_V = [](const VectorRd &x)->double { return -2.* exp(-x(0))*cos(x(1)); }

static ReissnerMindlin::SolutionDisplacementType	an_v

static ReissnerMindlin::SolutionRotationType	an_GRAD_v

static ReissnerMindlin::GradientRotationType	an_HESS_v

static ReissnerMindlin::SolutionDisplacementType	an_LAPL_v

static ReissnerMindlin::SolutionRotationType	analytical_theta = an_GRAD_v

static ReissnerMindlin::GradientRotationType	analytical_grad_theta = an_HESS_v

static ReissnerMindlin::SolutionDisplacementType	analytical_u

static ReissnerMindlin::ForcingTermType	analytical_f

static ReissnerMindlin::SolutionRotationType	ukn_theta

static ReissnerMindlin::GradientRotationType	ukn_grad_theta

static ReissnerMindlin::SolutionDisplacementType	ukn_u

static ReissnerMindlin::ForcingTermType	ukn_f

static ReissnerMindlin::SolutionRotationType	kir_theta

static ReissnerMindlin::GradientRotationType	kir_grad_theta

static ReissnerMindlin::SolutionDisplacementType	kir_u

static ReissnerMindlin::ForcingTermType	kir_f

static const double	PI = boost::math::constants::pi<double>()

static const VectorRd	vec_a = VectorRd(1.,2.)

static FullGradientDiffusion::SolutionType	linear_u

static FullGradientDiffusion::SolutionGradientType	linear_gradu

static FullGradientDiffusion::ForcingTermType	linear_f

static FullGradientDiffusion::PermeabilityType	linear_kappa = FullGradientDiffusion::PermeabilityType(1.)

static FullGradientDiffusion::SolutionType	trigonometric_u

static FullGradientDiffusion::SolutionGradientType	trigonometric_gradu

static FullGradientDiffusion::ForcingTermType	trigonometric_f

static FullGradientDiffusion::PermeabilityType	trigonometric_kappa = FullGradientDiffusion::PermeabilityType(1.)

static const double	PI = boost::math::constants::pi<double>()

double	pressure_scaling = 1.

static Stokes::VelocityType	linear_u

static Stokes::VelocityGradientType	linear_gradu

static Stokes::PressureType	linear_p

static Stokes::PressureGradientType	linear_gradp

static Stokes::MomentumForcingTermType	linear_f

static Stokes::CompressibilityForcingTermType	linear_g = [](const VectorRd & x)->double { return linear_gradu(x).trace();}

static Stokes::ViscosityType	linear_mu = Stokes::ViscosityType(1.)

static Stokes::VelocityType	trigonometric_u

static Stokes::VelocityGradientType	trigonometric_gradu

static Stokes::PressureType	trigonometric_p

static Stokes::PressureGradientType	trigonometric_gradp

static Stokes::MomentumForcingTermType	trigonometric_f

static Stokes::CompressibilityForcingTermType	trigonometric_g = [](const VectorRd & x)->double { return trigonometric_gradu(x).trace();}

static Stokes::ViscosityType	trigonometric_mu = Stokes::ViscosityType(1.)

static SpatialFunctionType< double >	zero_scalar_function = [](const VectorRd & x)->double { return 0.;}
	Zero spatial function. More...

static const double	PI = boost::math::constants::pi<double>()
	Type for vector of vector. More...

static std::function< double(const size_t &, const size_t &)>	mui

static EigFunctionType< double >	mui_ei

static EigFunctionType< VectorRd >	grad_mui_ei

static EigFunctionType< double >	Delta_mui_ei

constexpr int	dimspace = 2
	Dimension, and generic types for vector in correct dimension (makes it easier to translate a code between 2D and 3D) More...

static std::function< Eigen::MatrixXd(const Eigen::MatrixXd &)>	symmetrise_matrix = [](const Eigen::MatrixXd & x)->Eigen::MatrixXd { return 0.5*(x+x.transpose());}
	Function to symmetrise a matrix (useful together with transform_values_quad) More...

static std::function< Eigen::MatrixXd(const Eigen::MatrixXd &)>	skew_symmetrise_matrix = [](const Eigen::MatrixXd & x)->Eigen::MatrixXd { return 0.5*(x-x.transpose());}
	Function to skew-symmetrise a matrix (useful together with transform_values_quad) More...

std::map< std::string, int >	ParamName
	To parse optional Solver parameter from command line. More...

std::vector< double >	SolverParam
	Create space and stores default values of optional solver parameters. More...

const char *	SolverParamHelper
	Create a solver specific description in boost::desc.options. More...

std::map< std::string, SolverName >	map_solver
	Map to associate to each lowercase name a solver. More...

std::map< SolverName, std::string >	map_realname
	Map to associate to each solver its proper name. More...

std::map< SolverName, size_t >	map_id

static const CellSelection	allcells = [](const Cell &)->bool {return true;}

static const double	PI = boost::math::constants::pi<double>()

static auto	q

static auto	grad_q

static auto	rot_q

static auto	v

static const double	PI = boost::math::constants::pi<double>()

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	constant_vector

static std::function< double(const Eigen::Vector2d &)>	rot_constant_vector

static std::function< MatrixRd(const Eigen::Vector2d &)>	grad_constant_vector

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	linear_vector

static std::function< double(const Eigen::Vector2d &)>	rot_linear_vector

static std::function< MatrixRd(const Eigen::Vector2d &)>	grad_linear_vector

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	quadratic_vector

static std::function< double(const Eigen::Vector2d &)>	rot_quadratic_vector

static std::function< MatrixRd(const Eigen::Vector2d &)>	grad_quadratic_vector

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	cubic_vector

static std::function< double(const Eigen::Vector2d &)>	rot_cubic_vector

static std::function< MatrixRd(const Eigen::Vector2d &)>	grad_cubic_vector

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	trigonometric_vector

static std::function< double(const Eigen::Vector2d &)>	rot_trigonometric_vector

static std::function< MatrixRd(const Eigen::Vector2d &)>	grad_trigonometric_vector

static std::function< double(const Eigen::Vector2d &)>	trigonometric_q

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	grad_trigonometric_q

static const double	PI = boost::math::constants::pi<double>()

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	constant_vector

static std::function< double(const Eigen::Vector2d &)>	rot_constant_vector

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	linear_vector

static std::function< double(const Eigen::Vector2d &)>	rot_linear_vector

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	trigonometric_vector

static std::function< double(const Eigen::Vector2d &)>	rot_trigonometric_vector

static const double	PI = boost::math::constants::pi<double>()

static KirchhoffLove::DeflectionType	trigonometric_u

static KirchhoffLove::ForcingTermType	trigonometric_f

static KirchhoffLove::MomentTensorType	trigonometric_sigma

static KirchhoffLove::MomentTensorEdgeDerivativeType	trigonometric_sigma_DE

static KirchhoffLove::DeflectionType	simple_u

static KirchhoffLove::ForcingTermType	simple_f

static KirchhoffLove::MomentTensorType	simple_sigma

static KirchhoffLove::MomentTensorEdgeDerivativeType	simple_sigma_DE

static KirchhoffLove::DeflectionType	quartic_u

static KirchhoffLove::ForcingTermType	quartic_f

static KirchhoffLove::MomentTensorType	quartic_sigma

static KirchhoffLove::MomentTensorEdgeDerivativeType	quartic_sigma_DE

static KirchhoffLove::DeflectionType	biquartic_u

static KirchhoffLove::ForcingTermType	biquartic_f

static KirchhoffLove::MomentTensorType	biquartic_sigma

static KirchhoffLove::MomentTensorEdgeDerivativeType	biquartic_sigma_DE

static const double	PI = boost::math::constants::pi<double>()

static std::function< double(const Eigen::Vector2d &)>	trigonometric_scalar

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	grad_trigonometric_scalar

static std::function< double(const Eigen::Vector2d &)>	constant_scalar

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	grad_constant_scalar

static std::function< double(const Eigen::Vector2d &)>	linear_scalar

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	grad_linear_scalar

static std::function< double(const Eigen::Vector2d &)>	quadratic_scalar

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	grad_quadratic_scalar

static const double	PI = boost::math::constants::pi<double>()

static std::function< double(const Eigen::Vector2d &)>	trigonometric_scalar

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	grad_trigonometric_scalar

static std::function< double(const Eigen::Vector2d &)>	constant_scalar

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	grad_constant_scalar

static std::function< double(const Eigen::Vector2d &)>	linear_scalar

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	grad_linear_scalar

static std::function< double(const Eigen::Vector2d &)>	quadratic_scalar

static std::function< Eigen::Vector2d(const Eigen::Vector2d &)>	grad_quadratic_scalar

Function Documentation

◆ compute_rotrot_norm()

double HArDCore2D::compute_rotrot_norm	(	const Eigen::VectorXd &	v,
		const XRot &	x_rot,
		const XRotRot &	x_rotrot
	)

Compute rotrot norm.

◆ compute_squared_rotrot_norm()

double HArDCore2D::compute_squared_rotrot_norm	(	size_t	iT,
		const Eigen::VectorXd &	vT,
		const XRot &	x_rot,
		const XRotRot &	x_rotrot
	)

Compute the squared rotrot norm on the element of index iT.

◆ squared_l2_error()

template<typename T >

double HArDCore2D::squared_l2_error	(	const std::function< T(const Eigen::Vector2d &)> &	f,
		const Eigen::VectorXd &	fX,
		const boost::multi_array< T, 2 > &	fX_basis_quad,
		const QuadratureRule &	quad_X
	)

Variable Documentation

◆ biquartic_f

KirchhoffLove::ForcingTermType HArDCore2D::biquartic_f

static

Initial value:

= [](const VectorRd & x) -> double {
    return 24*pow(x(0), 2)*pow(x(0) - 1, 2) + 32*x(0)*x(1)*(x(0) - 1)*(x(1) - 1) + 8*x(0)*x(1)*(x(0) - 1)*(4*x(1) - 2) + 8*x(0)*x(1)*(4*x(0) - 2)*(x(1) - 1) + 8*x(0)*x(1)*(x(0)*x(1) + x(0)*(x(1) - 1) + x(1)*(x(0) - 1) + (x(0) - 1)*(x(1) - 1)) + 8*x(0)*(x(0) - 1)*(x(1) - 1)*(4*x(1) - 2) + 8*x(0)*(x(1) - 1)*(x(0)*x(1) + x(0)*(x(1) - 1) + x(1)*(x(0) - 1) + (x(0) - 1)*(x(1) - 1)) + 24*pow(x(1), 2)*pow(x(1) - 1, 2) + 8*x(1)*(x(0) - 1)*(4*x(0) - 2)*(x(1) - 1) + 8*x(1)*(x(0) - 1)*(x(0)*x(1) + x(0)*(x(1) - 1) + x(1)*(x(0) - 1) + (x(0) - 1)*(x(1) - 1)) + 2*(4*x(0) - 4)*(x(1) - 1)*(x(0)*x(1) + x(0)*(x(1) - 1) + x(1)*(x(0) - 1) + (x(0) - 1)*(x(1) - 1));
  }

◆ biquartic_sigma

KirchhoffLove::MomentTensorType HArDCore2D::biquartic_sigma

static

Initial value:

= [](const VectorRd & x) -> Eigen::Matrix2d {
    Eigen::Matrix2d M;
      M.row(0) << 2*pow(x(1), 2)*pow(x(1) - 1, 2)*(pow(x(0), 2) + 4*x(0)*(x(0) - 1) + pow(x(0) - 1, 2)), 4*x(0)*x(1)*(x(0) - 1)*(x(1) - 1)*(x(0)*x(1) + x(0)*(x(1) - 1) + x(1)*(x(0) - 1) + (x(0) - 1)*(x(1) - 1));      
      M.row(1) << 4*x(0)*x(1)*(x(0) - 1)*(x(1) - 1)*(x(0)*x(1) + x(0)*(x(1) - 1) + x(1)*(x(0) - 1) + (x(0) - 1)*(x(1) - 1)), 2*pow(x(0), 2)*pow(x(0) - 1, 2)*(pow(x(1), 2) + 4*x(1)*(x(1) - 1) + pow(x(1) - 1, 2));
    return -M;
  }

◆ biquartic_sigma_DE

KirchhoffLove::MomentTensorEdgeDerivativeType HArDCore2D::biquartic_sigma_DE

static

◆ biquartic_u

KirchhoffLove::DeflectionType HArDCore2D::biquartic_u

static

Initial value:

= [](const VectorRd & x) -> double {
    return pow(x(0),2)*pow(1.-x(0),2)*pow(x(1),2)*pow(1.-x(1),2);
  }

◆ constant_scalar [1/2]

std::function<double(const Eigen::Vector2d&)> HArDCore2D::constant_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> double {
              return 1.;
            }

◆ constant_scalar [2/2]

std::function<double(const Eigen::Vector2d&)> HArDCore2D::constant_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> double {
              return 1.;
            }

◆ constant_vector [1/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::constant_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
              return Eigen::Vector2d(1., 2.);
            }

◆ constant_vector [2/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::constant_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
              return Eigen::Vector2d(1., 2.);
            }

◆ cubic_f

QuadRot::ForcingTermType HArDCore2D::cubic_f

static

Initial value:

= [](const VectorRd & x) -> VectorRd {
    VectorRd f_x;
    f_x << 0., 0.;
    return f_x;
  }

◆ cubic_p

QuadRot::LagrangeMultiplierType HArDCore2D::cubic_p

static

Initial value:

= [](const VectorRd & x) -> double {
    return 0.;
  }

◆ cubic_rot_u

QuadRot::RotorType HArDCore2D::cubic_rot_u

static

Initial value:

= [](const VectorRd & x) -> double {
    return 3. * ( pow(x(0) - 0.5, 2) + pow(x(1) - 0.5, 2) );
  }

◆ cubic_rotrot_u

QuadRot::RotRotType HArDCore2D::cubic_rotrot_u

static

Initial value:

= [](const VectorRd & x)->VectorRd {
    VectorRd rotrot_u_x;
    rotrot_u_x << 6. * (x(1) - 0.5), -6. * (x(0) - 0.5);
    return rotrot_u_x;
  }

◆ cubic_u

QuadRot::PotentialType HArDCore2D::cubic_u

static

Initial value:

= [](const VectorRd & x) -> VectorRd {
    VectorRd u_x;
    u_x << -pow(x(1) - 0.5, 3), pow(x(0) - 0.5, 3);
    return u_x;
  }

◆ cubic_vector

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::cubic_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
            return Eigen::Vector2d(
                       1. + std::pow(x(0),3) - x(1)*std::pow(x(0),2),
                       2. + 2. * std::pow(x(1), 3) + std::pow(x(1),2)*x(0)
                       );
          }

◆ grad_constant_scalar [1/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::grad_constant_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
               return Eigen::Vector2d::Zero();
             }

◆ grad_constant_scalar [2/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::grad_constant_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
               return Eigen::Vector2d::Zero();
             }

◆ grad_constant_vector

std::function<MatrixRd(const Eigen::Vector2d&)> HArDCore2D::grad_constant_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> MatrixRd {
               return MatrixRd::Zero();
             }

◆ grad_cubic_vector

std::function<MatrixRd(const Eigen::Vector2d&)> HArDCore2D::grad_cubic_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> MatrixRd {
         MatrixRd G = MatrixRd::Zero();
         G.row(0) << 3*x(0)*x(0)-2*x(1)*x(0), -x(0)*x(0);
         G.row(1) << x(1)*x(1), 6*x(1)*x(1)+2*x(1)*x(0);         
               return G;
             }

◆ grad_linear_scalar [1/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::grad_linear_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
             return Eigen::Vector2d(1., 2.);
               }

◆ grad_linear_scalar [2/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::grad_linear_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
             return Eigen::Vector2d(1., 2.);
               }

◆ grad_linear_vector

std::function<MatrixRd(const Eigen::Vector2d&)> HArDCore2D::grad_linear_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> MatrixRd {
         MatrixRd G = MatrixRd::Zero();
         G.row(0) << 1, -1;
         G.row(1) << 1, 2;         
               return G;
             }

◆ grad_q

auto HArDCore2D::grad_q

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
             return PI * Eigen::Vector2d(
                             cos(PI * x(0)) * sin(PI * x(1)),
                             sin(PI * x(0)) * cos(PI * x(1)) 
                             );
               }

◆ grad_quadratic_scalar [1/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::grad_quadratic_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
                return grad_linear_scalar(x) + Eigen::Vector2d(2. * x(0), 4. * x(1));
              }

◆ grad_quadratic_scalar [2/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::grad_quadratic_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
                return grad_linear_scalar(x) + Eigen::Vector2d(2. * x(0), 4. * x(1));
              }

◆ grad_quadratic_vector

std::function<MatrixRd(const Eigen::Vector2d&)> HArDCore2D::grad_quadratic_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> MatrixRd {
         MatrixRd G = MatrixRd::Zero();
         G.row(0) << 2.*x(0)-x(1), -x(0);
         G.row(1) << x(1), 4.*x(1)+x(0);         
               return G;
             }

◆ grad_trigonometric_q

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::grad_trigonometric_q

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
      return Eigen::Vector2d(PI*cos(PI*x(0))*sin(PI*x(1)), PI*sin(PI*x(0))*cos(PI*x(1)));
    }

◆ grad_trigonometric_scalar [1/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::grad_trigonometric_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
                return PI * Eigen::Vector2d(
                                cos(PI * x(0)) * sin(PI * x(1)),
                                sin(PI * x(0)) * cos(PI * x(1))
                                );
                  }

◆ grad_trigonometric_scalar [2/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::grad_trigonometric_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
                return PI * Eigen::Vector2d(
                                cos(PI * x(0)) * sin(PI * x(1)),
                                sin(PI * x(0)) * cos(PI * x(1))
                                );
                  }

◆ grad_trigonometric_vector

std::function<MatrixRd(const Eigen::Vector2d&)> HArDCore2D::grad_trigonometric_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> MatrixRd {
         MatrixRd G = MatrixRd::Zero();
         G.row(0) << PI*cos(PI*x(0))*sin(PI*x(1)), PI*sin(PI*x(0))*cos(PI*x(1));
         G.row(1) << PI*cos(PI*x(0))*sin(PI*x(1)), PI*sin(PI*x(0))*cos(PI*x(1));         
               return G;
             }

◆ linear_f [1/2]

QuadRot::ForcingTermType HArDCore2D::linear_f

static

Initial value:

= [](const VectorRd & x) -> VectorRd {
    VectorRd f_x;
    f_x << 0, 0;
    return f_x;
  }

◆ linear_f [2/2]

Stokes::MomentumForcingTermType HArDCore2D::linear_f

static

Initial value:

= [](const VectorRd & x) -> VectorRd {
    return VectorRd::Zero();
  }

◆ linear_g

Stokes::CompressibilityForcingTermType HArDCore2D::linear_g = [](const VectorRd & x)->double { return linear_gradu(x).trace();}

static

◆ linear_gradp

Stokes::PressureGradientType HArDCore2D::linear_gradp

static

Initial value:

= [](const VectorRd & x) -> VectorRd {
    return VectorRd::Zero();
  }

◆ linear_gradu

Stokes::VelocityGradientType HArDCore2D::linear_gradu

static

Initial value:

= [](const VectorRd & x) -> MatrixRd {
    MatrixRd M = MatrixRd::Zero();
    M << 1., 0., 0., -1.;      
    return M;
  }

◆ linear_mu

Stokes::ViscosityType HArDCore2D::linear_mu = Stokes::ViscosityType(1.)

static

◆ linear_p [1/2]

QuadRot::LagrangeMultiplierType HArDCore2D::linear_p

static

Initial value:

= [](const VectorRd & x) -> double {
    return 0.;
  }

◆ linear_p [2/2]

Stokes::PressureType HArDCore2D::linear_p

static

Initial value:

= [](const VectorRd & x) -> double {
    return 0.;
  }

◆ linear_rot_u

QuadRot::RotorType HArDCore2D::linear_rot_u

static

Initial value:

= [](const VectorRd & x) -> double {
    return 2.;
  }

◆ linear_rotrot_u

QuadRot::RotRotType HArDCore2D::linear_rotrot_u

static

Initial value:

= [](const VectorRd & x)->VectorRd {
    return VectorRd::Zero();
  }

◆ linear_scalar [1/2]

std::function<double(const Eigen::Vector2d&)> HArDCore2D::linear_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> double {
            return 1. + x(0) + 2. * x(1);
          }

◆ linear_scalar [2/2]

std::function<double(const Eigen::Vector2d&)> HArDCore2D::linear_scalar

static

Initial value:

= [](const Eigen::Vector2d & x) -> double {
            return 1. + x(0) + 2. * x(1);
          }

◆ linear_u [1/2]

QuadRot::PotentialType HArDCore2D::linear_u

static

Initial value:

= [](const VectorRd & x) -> VectorRd {
    VectorRd u_x;
    u_x << -(x(1) - 0.5), (x(0) - 0.5);
    return u_x;
  }

◆ linear_u [2/2]

Stokes::VelocityType HArDCore2D::linear_u

static

Initial value:

= [](const VectorRd & x) -> VectorRd {
    return VectorRd(x(0), -x(1));
  }

◆ linear_vector [1/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::linear_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
            return Eigen::Vector2d(
                       1. + x(0) - x(1),
                       2. + 2. * x(1) + x(0)
                       );
          }

◆ linear_vector [2/2]

std::function<Eigen::Vector2d(const Eigen::Vector2d&)> HArDCore2D::linear_vector

static

Initial value:

= [](const Eigen::Vector2d & x) -> Eigen::Vector2d {
            return Eigen::Vector2d(
                       1. + x(0) - x(1),
                       2. + 2. * x(1) + x(0)
                       );
          }