|
| static double | StDev (const Eigen::VectorXd &v) |
| |
| double | scalar_product (const double &x, const double &y) |
| | Scalar product between two reals.
|
| |
| double | scalar_product (const VectorRd &x, const VectorRd &y) |
| | Scalar product between two vectors.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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)
|
| |
| 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)
|
| |
| 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)
|
| |
| 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>(...)
|
| |
| 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).
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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).
|
| |
| 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.
|
| |
| 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)
|
| |
| 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)
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| double | compute_rotrot_norm (const Eigen::VectorXd &v, const XRot &x_rot, const XRotRot &x_rotrot) |
| | Compute rotrot norm.
|
| |
| 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.
|
| |
| template<> |
| const size_t | DimPoly< Edge > (const int m) |
| | Compute the size of the basis of 1-variate polynomials up to degree m.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| Eigen::MatrixXd | GramMatrix (const Cell &T, const GolyComplBasisCell &basis1, const GolyComplBasisCell &basis2, MonomialCellIntegralsType mono_int_map={}) |
| | Gram Matrix of a pair of GolyCompl bases.
|
| |
| 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.
|
| |
| 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.
|
| |
| template<typename BasisType > |
| constexpr bool | useAncestor () |
| | Determines if the ancestor of a basis will be used to compute a Gram matrix for this basis.
|
| |
| 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.
|
| |
| 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)
|
| |
| 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)
|
| |
| 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)
|
| |
| 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)
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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={}) |
| | Gram Matrix of the divergence of a MatrixFamily and a tensorized basis.
|
| |
| 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).
|
| |
| 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.
|
| |
| 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.
|
| |
| MonomialEdgeIntegralsType | IntegrateEdgeMonomials (const Edge &E, const size_t maxdeg) |
| | Compute all integrals of edge monomials up to a total degree.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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={}) |
| | GramMatrix of two tensorized families on the edge.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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)
|
| |
| QuadratureRule | generate_quadrature_rule (const Cell &T, const int doe, const bool force_split=false) |
| | Generate quadrature rule on mesh element.
|
| |
| QuadratureRule | generate_quadrature_rule (const Edge &E, const int doe) |
| | Generate quadrature rule on mesh face.
|
| |
| 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) |
| |
