Common

Various general functions and classes. More...

Namespaces
namespace	Eigen::internal

Classes
class	HArDCore2D::DSL::GlobalDOFTable
	Base class for global DOF spaces. Provides functions to manipulate global DOFs (the local version being provided by LocalDOFTable). More...
class	HArDCore2D::GlobalDOFSpace
	Base class for global DOF spaces. Provides functions to manipulate global DOFs (the local version being provided by LocalDOFSpace). More...
struct	HArDCore2D::IntegralWeight
	Structure for weights (scalar, at the moment) in integral. More...
class	HArDCore2D::LinearSolver< MatrixType >
	This structure is a wrapper to allow a given code to select various linear solvers. More...
struct	HArDCore2D::LocalStaticCondensation
	Structure to store information for, and perform, local static condensation. More...
class	HArDCore2D::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...
class	Eigen::PastixLU< _MatrixType, IsStrSym >
	Class to invoke the Pastix LU solver. More...
class	Eigen::PastixLLT< _MatrixType, _UpLo >
	Class to invoke the Pastix LLT solver. More...
class	Eigen::PastixLDLT< _MatrixType, _UpLo >
	Class to invoke the Pastix LDLT solver. More...
struct	Eigen::internal::pastix_traits< Pastix >
struct	Eigen::internal::pastix_traits< PastixLU< _MatrixType > >
struct	Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >
struct	Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >
class	Eigen::PastixBase< Derived >
struct	HArDCore2D::PolynomialSpaceDimension< GeometricSupport >
	Basis dimensions for various polynomial spaces on edges/faces/elements (when relevant): Pk, Gk, Rk and complements. More...
struct	HArDCore2D::PolynomialSpaceDimension< Cell >
struct	HArDCore2D::PolynomialSpaceDimension< Edge >

Macros
#define	PASTIX_COMPLEX   std::complex<float>
#define	PASTIX_DCOMPLEX   std::complex<double>

Typedefs
template<typename MatrixType >
using	HArDCore2D::EigenLUType = Eigen::SparseLU< MatrixType >
template<typename MatrixType >
using	HArDCore2D::EigenBiCGStabType = Eigen::BiCGSTAB< MatrixType, Eigen::IncompleteLUT< double > >
template<typename MatrixType >
using	HArDCore2D::PardisoLUType = bool
template<typename MatrixType >
using	HArDCore2D::UMFPACKType = bool
using	HArDCore2D::PastixLUType = bool
using	HArDCore2D::PastixLLTType = bool
using	HArDCore2D::SuperLUType = bool
template<typename MatrixType >
using	HArDCore2D::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 >, std::unique_ptr< SuperLUType > >
typedef _MatrixType	Eigen::internal::pastix_traits< PastixLU< _MatrixType > >::MatrixType
typedef _MatrixType::Scalar	Eigen::internal::pastix_traits< PastixLU< _MatrixType > >::Scalar
typedef _MatrixType::RealScalar	Eigen::internal::pastix_traits< PastixLU< _MatrixType > >::RealScalar
typedef _MatrixType::StorageIndex	Eigen::internal::pastix_traits< PastixLU< _MatrixType > >::StorageIndex
typedef _MatrixType	Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >::MatrixType
typedef _MatrixType::Scalar	Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >::Scalar
typedef _MatrixType::RealScalar	Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >::RealScalar
typedef _MatrixType::StorageIndex	Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >::StorageIndex
typedef _MatrixType	Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >::MatrixType
typedef _MatrixType::Scalar	Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >::Scalar
typedef _MatrixType::RealScalar	Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >::RealScalar
typedef _MatrixType::StorageIndex	Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >::StorageIndex
typedef SparseSolverBase< Derived >	Eigen::PastixBase< Derived >::Base
typedef internal::pastix_traits< Derived >::MatrixType	Eigen::PastixBase< Derived >::_MatrixType
typedef _MatrixType	Eigen::PastixBase< Derived >::MatrixType
typedef MatrixType::Scalar	Eigen::PastixBase< Derived >::Scalar
typedef MatrixType::RealScalar	Eigen::PastixBase< Derived >::RealScalar
typedef MatrixType::StorageIndex	Eigen::PastixBase< Derived >::StorageIndex
typedef Matrix< Scalar, Dynamic, 1 >	Eigen::PastixBase< Derived >::Vector
typedef SparseMatrix< Scalar, ColMajor >	Eigen::PastixBase< Derived >::ColSpMatrix
typedef _MatrixType	Eigen::PastixLU< _MatrixType, IsStrSym >::MatrixType
typedef PastixBase< PastixLU< MatrixType > >	Eigen::PastixLU< _MatrixType, IsStrSym >::Base
typedef Base::ColSpMatrix	Eigen::PastixLU< _MatrixType, IsStrSym >::ColSpMatrix
typedef MatrixType::StorageIndex	Eigen::PastixLU< _MatrixType, IsStrSym >::StorageIndex
typedef _MatrixType	Eigen::PastixLLT< _MatrixType, _UpLo >::MatrixType
typedef PastixBase< PastixLLT< MatrixType, _UpLo > >	Eigen::PastixLLT< _MatrixType, _UpLo >::Base
typedef Base::ColSpMatrix	Eigen::PastixLLT< _MatrixType, _UpLo >::ColSpMatrix
typedef _MatrixType	Eigen::PastixLDLT< _MatrixType, _UpLo >::MatrixType
typedef PastixBase< PastixLDLT< MatrixType, _UpLo > >	Eigen::PastixLDLT< _MatrixType, _UpLo >::Base
typedef Base::ColSpMatrix	Eigen::PastixLDLT< _MatrixType, _UpLo >::ColSpMatrix

Enumerations
enum	HArDCore2D::SolverName {   HArDCore2D::EigenLU , HArDCore2D::EigenBiCGStab , HArDCore2D::PardisoLU , HArDCore2D::UMFPACK ,   HArDCore2D::PaStiXLU , HArDCore2D::PaStiXLLT , HArDCore2D::SuperLU }
	Enumeration of all available solvers. More...
enum	{ Eigen::PastixBase< Derived >::ColsAtCompileTime = MatrixType::ColsAtCompileTime , Eigen::PastixBase< Derived >::MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime }
enum	{ Eigen::PastixLLT< _MatrixType, _UpLo >::UpLo = _UpLo }
enum	{ Eigen::PastixLDLT< _MatrixType, _UpLo >::UpLo = _UpLo }

Functions
	HArDCore2D::DSL::GlobalDOFTable::GlobalDOFTable (const DiscreteSpaceDescriptor &descriptor)
	Constructor.
size_t	HArDCore2D::DSL::GlobalDOFTable::globalOffset (const Vertex &V) const
	Return the global offset for the unknowns on the vertex V.
size_t	HArDCore2D::DSL::GlobalDOFTable::globalOffset (const Edge &E) const
	Return the global offset for the unknowns on the edge E.
size_t	HArDCore2D::DSL::GlobalDOFTable::globalOffset (const Cell &T) const
	Return the global offset for the unknowns on the cell T.
Eigen::VectorXd	HArDCore2D::DSL::GlobalDOFTable::restrictEdge (size_t iE, const Eigen::VectorXd &vh) const
	Restrict to the edge (including its vertices) of index iE.
Eigen::VectorXd	HArDCore2D::DSL::GlobalDOFTable::restrictCell (size_t iT, const Eigen::VectorXd &vh) const
	Restrict to the cell (including vertices and edges) of index iT.
Eigen::VectorXd	HArDCore2D::DSL::GlobalDOFTable::restrict (const Edge &E, const Eigen::VectorXd vh) const
	Restrict to an edge.
Eigen::VectorXd	HArDCore2D::DSL::GlobalDOFTable::restrict (const Cell &T, const Eigen::VectorXd vh) const
	Restrict to a cell.
Eigen::MatrixXd	HArDCore2D::DSL::GlobalDOFTable::extendOperator (const Cell &T, const Edge &E, const Eigen::MatrixXd &opE) const
	Extend an edge operator to a cell.
std::vector< size_t >	HArDCore2D::DSL::GlobalDOFTable::globalDOFIndices (const Cell &T) const
void	HArDCore2D::DSL::GlobalDOFTable::setLabelDOF (const size_t i, const int label)
	Set a label to the DOF number i (default label is -1)
int	HArDCore2D::DSL::GlobalDOFTable::getLabelDOF (const size_t i)
	Get label of DOF number i.
std::pair< double, double >	HArDCore2D::store_times (boost::timer::cpu_timer &timer, std::string message="")
	Function to store and display wall/proc timers from boost::timer::cpu_timer.
	HArDCore2D::GlobalDOFSpace::GlobalDOFSpace (const Mesh &mesh, size_t n_local_vertex_dofs, size_t n_local_edge_dofs, size_t n_local_cell_dofs)
	Constructor.
size_t	HArDCore2D::GlobalDOFSpace::globalOffset (const Vertex &V) const
	Return the global offset for the unknowns on the vertex V.
size_t	HArDCore2D::GlobalDOFSpace::globalOffset (const Edge &E) const
	Return the global offset for the unknowns on the edge E.
size_t	HArDCore2D::GlobalDOFSpace::globalOffset (const Cell &T) const
	Return the global offset for the unknowns on the cell T.
Eigen::VectorXd	HArDCore2D::GlobalDOFSpace::restrictEdge (size_t iE, const Eigen::VectorXd &vh) const
	Restrict to the edge (including its vertices) of index iE.
Eigen::VectorXd	HArDCore2D::GlobalDOFSpace::restrictCell (size_t iT, const Eigen::VectorXd &vh) const
	Restrict to the cell (including vertices and edges) of index iT.
Eigen::VectorXd	HArDCore2D::GlobalDOFSpace::restrict (const Edge &E, const Eigen::VectorXd vh) const
	Restrict to an edge.
Eigen::VectorXd	HArDCore2D::GlobalDOFSpace::restrict (const Cell &T, const Eigen::VectorXd vh) const
	Restrict to a cell.
Eigen::MatrixXd	HArDCore2D::GlobalDOFSpace::extendOperator (const Cell &T, const Edge &E, const Eigen::MatrixXd &opE) const
	Extend an edge operator to a cell.
std::vector< size_t >	HArDCore2D::GlobalDOFSpace::globalDOFIndices (const Cell &T) const
void	HArDCore2D::GlobalDOFSpace::setLabelDOF (const size_t i, const int label)
	Set a label to the DOF number i (default label is -1)
int	HArDCore2D::GlobalDOFSpace::getLabelDOF (const size_t i)
	Get label of DOF number i.
	HArDCore2D::IntegralWeight::IntegralWeight (const std::function< double(const Cell &T, const Eigen::Vector2d &x)> _value, std::function< size_t(const Cell &T)> _deg)
	HArDCore2D::IntegralWeight::IntegralWeight (double val)
	HArDCore2D::LinearSolver< MatrixType >::LinearSolver (const std::string &namesolver)
	Constructor.
std::string	HArDCore2D::LinearSolver< MatrixType >::name () const
	Returns the name of the solver.
Eigen::ComputationInfo	HArDCore2D::LinearSolver< MatrixType >::info_factorize () const
	Returns the information message after the "factorize" step.
Eigen::ComputationInfo	HArDCore2D::LinearSolver< MatrixType >::info_solve () const
	Returns the information message after the "solve" step.
void	HArDCore2D::LinearSolver< MatrixType >::analyzePattern (MatrixType &A)
	Analyze the pattern of the matrix.
void	HArDCore2D::LinearSolver< MatrixType >::factorize (MatrixType &A)
	Factorize the matrix.
void	HArDCore2D::LinearSolver< MatrixType >::compute (MatrixType &A)
	Analyze and factorize the matrix.
template<typename VectorType >
VectorType	HArDCore2D::LinearSolver< MatrixType >::solve (VectorType &b)
	Solve the system Ax=b using the selected solver (after analysis of pattern and computation of matrix)
template<typename VectorType >
VectorType	HArDCore2D::LinearSolver< MatrixType >::compute_and_solve (MatrixType &A, VectorType &b)
	Perform all operators to solve Ax=b.
template<typename VectorType >
double	HArDCore2D::LinearSolver< MatrixType >::residual (MatrixType &A, VectorType &b, VectorType &x)
	Check relative infinity norm of residual: ||Ax-b||/||b||.
	HArDCore2D::LocalStaticCondensation::LocalStaticCondensation (const Eigen::MatrixXd &Perm, const std::vector< size_t > &globalDOFs_gl, const std::vector< size_t > &globalDOFs_sc)
	Constructor.
std::tuple< Eigen::MatrixXd, Eigen::VectorXd, Eigen::MatrixXd, Eigen::VectorXd >	HArDCore2D::LocalStaticCondensation::compute (const std::pair< Eigen::MatrixXd, Eigen::VectorXd > &lsT)
	Compute the local static condensation.
std::vector< size_t >	HArDCore2D::LocalStaticCondensation::globalDOFs_gl ()
	Returns global DOFs that are not statically condensend.
size_t	HArDCore2D::LocalStaticCondensation::dim_gl ()
	Returns the number of DOFs that are not statically condensed.
std::vector< size_t >	HArDCore2D::LocalStaticCondensation::globalDOFs_sc ()
	Returns global DOFs that are statically condensend.
size_t	HArDCore2D::LocalStaticCondensation::dim_sc ()
	Returns the number of DOFs that are statically condensed.
	HArDCore2D::LocalDOFSpace::LocalDOFSpace (const Mesh &mesh, size_t n_local_vertex_dofs, size_t n_local_edge_dofs, size_t n_local_cell_dofs)
	Constructor.
const Mesh &	HArDCore2D::LocalDOFSpace::mesh () const
	Returns the mesh.
size_t	HArDCore2D::LocalDOFSpace::numLocalDofsVertex () const
	Returns the number of local vertex DOFs.
size_t	HArDCore2D::LocalDOFSpace::numLocalDofsEdge () const
	Returns the number of local edge DOFs.
size_t	HArDCore2D::LocalDOFSpace::numLocalDofsCell () const
	Returns the number of local cell DOFs.
size_t	HArDCore2D::LocalDOFSpace::dimension () const
	Returns the dimension of the global space (all DOFs for all geometric entities)
size_t	HArDCore2D::LocalDOFSpace::numTotalDofsVertices () const
	Returns the total number of vertex DOFs.
size_t	HArDCore2D::LocalDOFSpace::numTotalDofsEdges () const
	Returns the total number of vertex DOFs.
size_t	HArDCore2D::LocalDOFSpace::numTotalDofsCells () const
	Returns the total number of vertex DOFs.
size_t	HArDCore2D::LocalDOFSpace::dimensionVertex (const Vertex &V) const
	Returns the dimension of the local space on the vertex V.
size_t	HArDCore2D::LocalDOFSpace::dimensionVertex (size_t iV) const
	Returns the dimension of the local space on the vertex of index iV.
size_t	HArDCore2D::LocalDOFSpace::dimensionEdge (const Edge &E) const
	Returns the dimension of the local space on the edge E (including vertices)
size_t	HArDCore2D::LocalDOFSpace::dimensionEdge (size_t iE) const
	Returns the dimension of the local space on the edge of index iE (including vertices)
size_t	HArDCore2D::LocalDOFSpace::dimensionCell (const Cell &T) const
	Returns the dimension of the local space on the cell T (including faces, edges and vertices)
size_t	HArDCore2D::LocalDOFSpace::dimensionCellBoundary (const Cell &T) const
	Returns the dimension of the local space on the boundary of T.
size_t	HArDCore2D::LocalDOFSpace::dimensionCell (size_t iT) const
	Returns the dimension of the local space on the cell of index iT (including faces, edges and vertices)
size_t	HArDCore2D::LocalDOFSpace::dimensionCellBoundary (size_t iT) const
	Returns the dimension of the local space on the boundary of T.
size_t	HArDCore2D::LocalDOFSpace::localOffset (const Edge &E, const Vertex &V) const
	Returns the local offset of the vertex V with respect to the edge E.
size_t	HArDCore2D::LocalDOFSpace::localOffset (const Edge &E) const
	Returns the local offset of the unknowns attached to the edge E.
size_t	HArDCore2D::LocalDOFSpace::localOffset (const Cell &T, const Vertex &V) const
	Returns the local offset of the vertex V with respect to the cell T.
size_t	HArDCore2D::LocalDOFSpace::localOffset (const Cell &T, const Edge &E) const
	Returns the local offset of the edge E with respect to the cell T.
size_t	HArDCore2D::LocalDOFSpace::localOffset (const Cell &T) const
	Returns the local offset of the unknowns attached to the element T.
static std::pair< std::vector< int >, std::vector< int > >	HArDCore2D::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	HArDCore2D::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 >	HArDCore2D::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 > >	HArDCore2D::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 >	HArDCore2D::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.
int	Eigen::internal::eigen_pastix (pastix_data_t **pastix_data, PASTIX_Comm pastix_comm, int n, int *ptr, int *idx, float *vals, int *perm, int *invp, float *x, int nbrhs, int *iparm, double *dparm)
int	Eigen::internal::eigen_pastix (pastix_data_t **pastix_data, PASTIX_Comm pastix_comm, int n, int *ptr, int *idx, double *vals, int *perm, int *invp, double *x, int nbrhs, int *iparm, double *dparm)
int	Eigen::internal::eigen_pastix (pastix_data_t **pastix_data, PASTIX_Comm pastix_comm, int n, int *ptr, int *idx, std::complex< float > *vals, int *perm, int *invp, std::complex< float > *x, int nbrhs, int *iparm, double *dparm)
int	Eigen::internal::eigen_pastix (pastix_data_t **pastix_data, PASTIX_Comm pastix_comm, int n, int *ptr, int *idx, std::complex< double > *vals, int *perm, int *invp, std::complex< double > *x, int nbrhs, int *iparm, double *dparm)
template<typename MatrixType >
void	Eigen::internal::c_to_fortran_numbering (MatrixType &mat)
template<typename MatrixType >
void	Eigen::internal::fortran_to_c_numbering (MatrixType &mat)
	Eigen::PastixBase< Derived >::PastixBase ()
	Eigen::PastixBase< Derived >::~PastixBase ()
template<typename Rhs , typename Dest >
bool	Eigen::PastixBase< Derived >::_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &x) const
Array< StorageIndex, IPARM_SIZE, 1 > &	Eigen::PastixBase< Derived >::iparm ()
int &	Eigen::PastixBase< Derived >::iparm (int idxparam)
Array< double, DPARM_SIZE, 1 > &	Eigen::PastixBase< Derived >::dparm ()
double &	Eigen::PastixBase< Derived >::dparm (int idxparam)
Index	Eigen::PastixBase< Derived >::cols () const
Index	Eigen::PastixBase< Derived >::rows () const
ComputationInfo	Eigen::PastixBase< Derived >::info () const
	Reports whether previous computation was successful.
void	Eigen::PastixBase< Derived >::init (double eps_refinement=-1.0, double eps_ctrl=-1.0)
void	Eigen::PastixBase< Derived >::analyzePattern (ColSpMatrix &mat)
void	Eigen::PastixBase< Derived >::factorize (ColSpMatrix &mat)
void	Eigen::PastixBase< Derived >::clean ()
void	Eigen::PastixBase< Derived >::compute (ColSpMatrix &mat)
	Eigen::PastixLU< _MatrixType, IsStrSym >::PastixLU ()
	Eigen::PastixLU< _MatrixType, IsStrSym >::PastixLU (const MatrixType &matrix)
void	Eigen::PastixLU< _MatrixType, IsStrSym >::compute (const MatrixType &matrix)
void	Eigen::PastixLU< _MatrixType, IsStrSym >::analyzePattern (const MatrixType &matrix)
void	Eigen::PastixLU< _MatrixType, IsStrSym >::factorize (const MatrixType &matrix)
void	Eigen::PastixLU< _MatrixType, IsStrSym >::init (double eps_refinement=-1.0, double eps_ctrl=-1.0)
void	Eigen::PastixLU< _MatrixType, IsStrSym >::grabMatrix (const MatrixType &matrix, ColSpMatrix &out)
	Eigen::PastixLLT< _MatrixType, _UpLo >::PastixLLT ()
	Eigen::PastixLLT< _MatrixType, _UpLo >::PastixLLT (const MatrixType &matrix)
void	Eigen::PastixLLT< _MatrixType, _UpLo >::compute (const MatrixType &matrix)
void	Eigen::PastixLLT< _MatrixType, _UpLo >::analyzePattern (const MatrixType &matrix)
void	Eigen::PastixLLT< _MatrixType, _UpLo >::factorize (const MatrixType &matrix)
void	Eigen::PastixLLT< _MatrixType, _UpLo >::init ()
void	Eigen::PastixLLT< _MatrixType, _UpLo >::grabMatrix (const MatrixType &matrix, ColSpMatrix &out)
	Eigen::PastixLDLT< _MatrixType, _UpLo >::PastixLDLT ()
	Eigen::PastixLDLT< _MatrixType, _UpLo >::PastixLDLT (const MatrixType &matrix)
void	Eigen::PastixLDLT< _MatrixType, _UpLo >::compute (const MatrixType &matrix)
void	Eigen::PastixLDLT< _MatrixType, _UpLo >::analyzePattern (const MatrixType &matrix)
void	Eigen::PastixLDLT< _MatrixType, _UpLo >::factorize (const MatrixType &matrix)
void	Eigen::PastixLDLT< _MatrixType, _UpLo >::init ()
void	Eigen::PastixLDLT< _MatrixType, _UpLo >::grabMatrix (const MatrixType &matrix, ColSpMatrix &out)
static size_t	HArDCore2D::PolynomialSpaceDimension< Cell >::Poly (int k)
	Dimension of Pk(T)
static size_t	HArDCore2D::PolynomialSpaceDimension< Cell >::Goly (int k)
	Dimension of Gk(T)
static size_t	HArDCore2D::PolynomialSpaceDimension< Cell >::GolyCompl (int k)
	Dimension of Gck(T)
static size_t	HArDCore2D::PolynomialSpaceDimension< Cell >::Roly (int k)
	Dimension of Rk(T)
static size_t	HArDCore2D::PolynomialSpaceDimension< Cell >::RolyCompl (int k)
	Dimension of Rck(T)
static size_t	HArDCore2D::PolynomialSpaceDimension< Cell >::Holy (int k)
	Dimension of Hk(T)
static size_t	HArDCore2D::PolynomialSpaceDimension< Cell >::HolyCompl (int k)
	Dimension of Hck(T)
static size_t	HArDCore2D::PolynomialSpaceDimension< Edge >::Poly (int k)
	Dimension of Pk(E)

Variables
std::function< double(const Cell &T, const Eigen::Vector2d &x)>	HArDCore2D::IntegralWeight::value
std::function< size_t(const Cell &T)>	HArDCore2D::IntegralWeight::deg
std::map< std::string, int >	HArDCore2D::ParamName
	To parse optional Solver parameter from command line.
std::vector< double >	HArDCore2D::SolverParam
	Create space and stores default values of optional solver parameters.
const char *	HArDCore2D::SolverParamHelper
	Create a solver specific description in boost::desc.options.
std::map< std::string, SolverName >	HArDCore2D::map_solver
	Map to associate to each lowercase name a solver.
std::map< SolverName, std::string >	HArDCore2D::map_realname
	Map to associate to each solver its proper name.
std::map< SolverName, size_t >	HArDCore2D::map_id
Eigen::MatrixXd	HArDCore2D::LocalStaticCondensation::m_Perm
std::vector< size_t >	HArDCore2D::LocalStaticCondensation::m_globalDOFs_gl
std::vector< size_t >	HArDCore2D::LocalStaticCondensation::m_globalDOFs_sc
size_t	HArDCore2D::LocalStaticCondensation::m_dim_gl
size_t	HArDCore2D::LocalStaticCondensation::m_dim_sc
const Mesh &	HArDCore2D::LocalDOFSpace::m_mesh
size_t	HArDCore2D::LocalDOFSpace::m_n_local_vertex_dofs
size_t	HArDCore2D::LocalDOFSpace::m_n_local_edge_dofs
size_t	HArDCore2D::LocalDOFSpace::m_n_local_cell_dofs
int	Eigen::PastixBase< Derived >::m_initisOk
int	Eigen::PastixBase< Derived >::m_analysisIsOk
int	Eigen::PastixBase< Derived >::m_factorizationIsOk
ComputationInfo	Eigen::PastixBase< Derived >::m_info
pastix_data_t *	Eigen::PastixBase< Derived >::m_pastixdata
int	Eigen::PastixBase< Derived >::m_comm
Array< int, IPARM_SIZE, 1 >	Eigen::PastixBase< Derived >::m_iparm
Array< double, DPARM_SIZE, 1 >	Eigen::PastixBase< Derived >::m_dparm
Matrix< StorageIndex, Dynamic, 1 >	Eigen::PastixBase< Derived >::m_perm
Matrix< StorageIndex, Dynamic, 1 >	Eigen::PastixBase< Derived >::m_invp
int	Eigen::PastixBase< Derived >::m_size
ColSpMatrix	Eigen::PastixLU< _MatrixType, IsStrSym >::m_transposedStructure
bool	Eigen::PastixLU< _MatrixType, IsStrSym >::m_structureIsUptodate

Detailed Description

Various general functions and classes.

Macro Definition Documentation

PASTIX_COMPLEX

#define PASTIX_COMPLEX   std::complex<float>

PASTIX_DCOMPLEX

#define PASTIX_DCOMPLEX   std::complex<double>

Typedef Documentation

_MatrixType

template<class Derived >

typedef internal::pastix_traits<Derived>::MatrixType Eigen::PastixBase< Derived >::_MatrixType

Base [1/4]

template<class Derived >

typedef SparseSolverBase<Derived> Eigen::PastixBase< Derived >::Base

protected

Base [2/4]

template<typename _MatrixType , bool IsStrSym>

typedef PastixBase<PastixLU<MatrixType> > Eigen::PastixLU< _MatrixType, IsStrSym >::Base

Base [3/4]

template<typename _MatrixType , int _UpLo>

typedef PastixBase<PastixLLT<MatrixType, _UpLo> > Eigen::PastixLLT< _MatrixType, _UpLo >::Base

Base [4/4]

template<typename _MatrixType , int _UpLo>

typedef PastixBase<PastixLDLT<MatrixType, _UpLo> > Eigen::PastixLDLT< _MatrixType, _UpLo >::Base

ColSpMatrix [1/4]

template<class Derived >

typedef SparseMatrix<Scalar, ColMajor> Eigen::PastixBase< Derived >::ColSpMatrix

ColSpMatrix [2/4]

template<typename _MatrixType , bool IsStrSym>

typedef Base::ColSpMatrix Eigen::PastixLU< _MatrixType, IsStrSym >::ColSpMatrix

ColSpMatrix [3/4]

template<typename _MatrixType , int _UpLo>

typedef Base::ColSpMatrix Eigen::PastixLLT< _MatrixType, _UpLo >::ColSpMatrix

ColSpMatrix [4/4]

template<typename _MatrixType , int _UpLo>

typedef Base::ColSpMatrix Eigen::PastixLDLT< _MatrixType, _UpLo >::ColSpMatrix

EigenBiCGStabType

template<typename MatrixType >

using HArDCore2D::EigenBiCGStabType = typedef Eigen::BiCGSTAB<MatrixType, Eigen::IncompleteLUT<double> >

EigenLUType

template<typename MatrixType >

using HArDCore2D::EigenLUType = typedef Eigen::SparseLU<MatrixType>

ListSolvers

template<typename MatrixType >

using HArDCore2D::ListSolvers = typedef 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>, std::unique_ptr<SuperLUType> >

MatrixType [1/7]

template<typename _MatrixType >

typedef _MatrixType Eigen::internal::pastix_traits< PastixLU< _MatrixType > >::MatrixType

MatrixType [2/7]

template<typename _MatrixType , int Options>

typedef _MatrixType Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >::MatrixType

MatrixType [3/7]

template<typename _MatrixType , int Options>

typedef _MatrixType Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >::MatrixType

MatrixType [4/7]

template<class Derived >

typedef _MatrixType Eigen::PastixBase< Derived >::MatrixType

MatrixType [5/7]

template<typename _MatrixType , bool IsStrSym>

typedef _MatrixType Eigen::PastixLU< _MatrixType, IsStrSym >::MatrixType

MatrixType [6/7]

template<typename _MatrixType , int _UpLo>

typedef _MatrixType Eigen::PastixLLT< _MatrixType, _UpLo >::MatrixType

MatrixType [7/7]

template<typename _MatrixType , int _UpLo>

typedef _MatrixType Eigen::PastixLDLT< _MatrixType, _UpLo >::MatrixType

PardisoLUType

template<typename MatrixType >

using HArDCore2D::PardisoLUType = typedef bool

PastixLLTType

using HArDCore2D::PastixLLTType = typedef bool

PastixLUType

using HArDCore2D::PastixLUType = typedef bool

RealScalar [1/4]

template<typename _MatrixType >

typedef _MatrixType::RealScalar Eigen::internal::pastix_traits< PastixLU< _MatrixType > >::RealScalar

RealScalar [2/4]

template<typename _MatrixType , int Options>

typedef _MatrixType::RealScalar Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >::RealScalar

RealScalar [3/4]

template<typename _MatrixType , int Options>

typedef _MatrixType::RealScalar Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >::RealScalar

RealScalar [4/4]

template<class Derived >

typedef MatrixType::RealScalar Eigen::PastixBase< Derived >::RealScalar

Scalar [1/4]

template<typename _MatrixType >

typedef _MatrixType::Scalar Eigen::internal::pastix_traits< PastixLU< _MatrixType > >::Scalar

Scalar [2/4]

template<typename _MatrixType , int Options>

typedef _MatrixType::Scalar Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >::Scalar

Scalar [3/4]

template<typename _MatrixType , int Options>

typedef _MatrixType::Scalar Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >::Scalar

Scalar [4/4]

template<class Derived >

typedef MatrixType::Scalar Eigen::PastixBase< Derived >::Scalar

StorageIndex [1/5]

template<typename _MatrixType >

typedef _MatrixType::StorageIndex Eigen::internal::pastix_traits< PastixLU< _MatrixType > >::StorageIndex

StorageIndex [2/5]

template<typename _MatrixType , int Options>

typedef _MatrixType::StorageIndex Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > >::StorageIndex

StorageIndex [3/5]

template<typename _MatrixType , int Options>

typedef _MatrixType::StorageIndex Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > >::StorageIndex

StorageIndex [4/5]

template<class Derived >

typedef MatrixType::StorageIndex Eigen::PastixBase< Derived >::StorageIndex

StorageIndex [5/5]

template<typename _MatrixType , bool IsStrSym>

typedef MatrixType::StorageIndex Eigen::PastixLU< _MatrixType, IsStrSym >::StorageIndex

SuperLUType

using HArDCore2D::SuperLUType = typedef bool

UMFPACKType

template<typename MatrixType >

using HArDCore2D::UMFPACKType = typedef bool

Vector

template<class Derived >

typedef Matrix<Scalar,Dynamic,1> Eigen::PastixBase< Derived >::Vector

Enumeration Type Documentation

anonymous enum

template<class Derived >

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

anonymous enum

template<typename _MatrixType , int _UpLo>

anonymous enum

Enumerator
UpLo

anonymous enum

template<typename _MatrixType , int _UpLo>

anonymous enum

Enumerator
UpLo

SolverName

enum HArDCore2D::SolverName

Enumeration of all available solvers.

Enumerator
EigenLU
EigenBiCGStab
PardisoLU
UMFPACK
PaStiXLU
PaStiXLLT
SuperLU

Function Documentation

_solve_impl()

template<typename Base >

template<typename Rhs , typename Dest >

bool Eigen::PastixBase< Base >::_solve_impl	(	const MatrixBase< Rhs > &	b,
		MatrixBase< Dest > &	x
	)		const

analyzePattern() [1/5]

template<class Derived >

void Eigen::PastixBase< Derived >::analyzePattern ( ColSpMatrix &  mat )

protected

analyzePattern() [2/5]

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::analyzePattern ( const MatrixType &  matrix )

inline

Compute the LU symbolic factorization of matrix using its sparsity pattern. Several ordering methods can be used at this step. See the PaStiX user's manual. The result of this operation can be used with successive matrices having the same pattern as matrix

See also

factorize()

analyzePattern() [3/5]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::analyzePattern ( const MatrixType &  matrix )

inline

Compute the LL^T symbolic factorization of matrix using its sparsity pattern The result of this operation can be used with successive matrices having the same pattern as matrix

See also

factorize()

analyzePattern() [4/5]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLDLT< _MatrixType, _UpLo >::analyzePattern ( const MatrixType &  matrix )

inline

Compute the LDL^T symbolic factorization of matrix using its sparsity pattern The result of this operation can be used with successive matrices having the same pattern as matrix

See also

factorize()

analyzePattern() [5/5]

template<typename MatrixType >

void HArDCore2D::LinearSolver< MatrixType >::analyzePattern ( MatrixType &  A )

inline

Analyze the pattern of the matrix.

Parameters

A	Matrix of the system to solve

c_to_fortran_numbering()

template<typename MatrixType >

void Eigen::internal::c_to_fortran_numbering

(

MatrixType &

mat

)

clean()

template<class Derived >

void Eigen::PastixBase< Derived >::clean ( )

inlineprotected

cols()

template<class Derived >

Index Eigen::PastixBase< Derived >::cols ( ) const

inline

compute() [1/6]

template<class Derived >

void Eigen::PastixBase< Derived >::compute ( ColSpMatrix &  mat )

protected

compute() [2/6]

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::compute ( const MatrixType &  matrix )

inline

Compute the LU supernodal factorization of matrix. iparm and dparm can be used to tune the PaStiX parameters. see the PaStiX user's manual

See also

analyzePattern() factorize()

compute() [3/6]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::compute ( const MatrixType &  matrix )

inline

Compute the L factor of the LL^T supernodal factorization of matrix

See also

analyzePattern() factorize()

compute() [4/6]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLDLT< _MatrixType, _UpLo >::compute ( const MatrixType &  matrix )

inline

Compute the L and D factors of the LDL^T factorization of matrix

See also

analyzePattern() factorize()

compute() [5/6]

std::tuple< Eigen::MatrixXd, Eigen::VectorXd, Eigen::MatrixXd, Eigen::VectorXd > HArDCore2D::LocalStaticCondensation::compute ( const std::pair< Eigen::MatrixXd, Eigen::VectorXd > &  lsT )

inline

Compute the local static condensation.

From a local pair of Matrix-Vector product, constructed with all the DOFs, returns a 4-tuple; the first two elements are the matrix-vector of the locally statically condensed system, the last two elements are the matrix-vector of the local recovery operator

compute() [6/6]

template<typename MatrixType >

void HArDCore2D::LinearSolver< MatrixType >::compute ( MatrixType &  A )

inline

Analyze and factorize the matrix.

Parameters

A	Matrix of the system to solve

compute_and_solve()

template<typename MatrixType >

template<typename VectorType >

VectorType HArDCore2D::LinearSolver< MatrixType >::compute_and_solve ( MatrixType &  A, VectorType &  b  )

inline

Perform all operators to solve Ax=b.

Parameters

A	Matrix of the system to solve
b	Right-hand side of the system

dim_gl()

size_t HArDCore2D::LocalStaticCondensation::dim_gl ( )

inline

Returns the number of DOFs that are not statically condensed.

dim_sc()

size_t HArDCore2D::LocalStaticCondensation::dim_sc ( )

inline

Returns the number of DOFs that are statically condensed.

dimension()

size_t HArDCore2D::LocalDOFSpace::dimension ( ) const

inline

Returns the dimension of the global space (all DOFs for all geometric entities)

dimensionCell() [1/2]

size_t HArDCore2D::LocalDOFSpace::dimensionCell ( const Cell &  T ) const

inline

Returns the dimension of the local space on the cell T (including faces, edges and vertices)

dimensionCell() [2/2]

size_t HArDCore2D::LocalDOFSpace::dimensionCell ( size_t  iT ) const

inline

Returns the dimension of the local space on the cell of index iT (including faces, edges and vertices)

dimensionCellBoundary() [1/2]

size_t HArDCore2D::LocalDOFSpace::dimensionCellBoundary ( const Cell &  T ) const

inline

Returns the dimension of the local space on the boundary of T.

dimensionCellBoundary() [2/2]

size_t HArDCore2D::LocalDOFSpace::dimensionCellBoundary ( size_t  iT ) const

inline

Returns the dimension of the local space on the boundary of T.

dimensionEdge() [1/2]

size_t HArDCore2D::LocalDOFSpace::dimensionEdge ( const Edge &  E ) const

inline

Returns the dimension of the local space on the edge E (including vertices)

dimensionEdge() [2/2]

size_t HArDCore2D::LocalDOFSpace::dimensionEdge ( size_t  iE ) const

inline

Returns the dimension of the local space on the edge of index iE (including vertices)

dimensionVertex() [1/2]

size_t HArDCore2D::LocalDOFSpace::dimensionVertex ( const Vertex &  V ) const

inline

Returns the dimension of the local space on the vertex V.

dimensionVertex() [2/2]

size_t HArDCore2D::LocalDOFSpace::dimensionVertex ( size_t  iV ) const

inline

Returns the dimension of the local space on the vertex of index iV.

distributeLoad()

static std::pair< std::vector< int >, std::vector< int > > HArDCore2D::distributeLoad ( size_t  nb_elements, unsigned  nb_threads  )

static

Function to distribute elements (considered as jobs) over threads. It returns a pair of vectors indicating the start and end element of each thread.

dparm() [1/2]

template<class Derived >

Array< double, DPARM_SIZE, 1 > & Eigen::PastixBase< Derived >::dparm ( )

inline

Returns a reference to the double vector DPARM of PaStiX parameters The statistics related to the different phases of factorization and solve are saved here as well

See also

analyzePattern() factorize()

dparm() [2/2]

template<class Derived >

double & Eigen::PastixBase< Derived >::dparm ( int  idxparam )

inline

Return a reference to a particular index parameter of the DPARM vector

See also

dparm()

eigen_pastix() [1/4]

int Eigen::internal::eigen_pastix ( pastix_data_t **  pastix_data, PASTIX_Comm  pastix_comm, int  n, int *  ptr, int *  idx, double *  vals, int *  perm, int *  invp, double *  x, int  nbrhs, int *  iparm, double *  dparm  )

inline

eigen_pastix() [2/4]

int Eigen::internal::eigen_pastix ( pastix_data_t **  pastix_data, PASTIX_Comm  pastix_comm, int  n, int *  ptr, int *  idx, float *  vals, int *  perm, int *  invp, float *  x, int  nbrhs, int *  iparm, double *  dparm  )

inline

eigen_pastix() [3/4]

int Eigen::internal::eigen_pastix ( pastix_data_t **  pastix_data, PASTIX_Comm  pastix_comm, int  n, int *  ptr, int *  idx, std::complex< double > *  vals, int *  perm, int *  invp, std::complex< double > *  x, int  nbrhs, int *  iparm, double *  dparm  )

inline

eigen_pastix() [4/4]

int Eigen::internal::eigen_pastix ( pastix_data_t **  pastix_data, PASTIX_Comm  pastix_comm, int  n, int *  ptr, int *  idx, std::complex< float > *  vals, int *  perm, int *  invp, std::complex< float > *  x, int  nbrhs, int *  iparm, double *  dparm  )

inline

extendOperator() [1/2]

Eigen::MatrixXd GlobalDOFTable::extendOperator	(	const Cell &	T,
		const Edge &	E,
		const Eigen::MatrixXd &	opE
	)		const

Extend an edge operator to a cell.

extendOperator() [2/2]

Eigen::MatrixXd GlobalDOFSpace::extendOperator	(	const Cell &	T,
		const Edge &	E,
		const Eigen::MatrixXd &	opE
	)		const

Extend an edge operator to a cell.

factorize() [1/5]

template<class Derived >

void Eigen::PastixBase< Derived >::factorize ( ColSpMatrix &  mat )

protected

factorize() [2/5]

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::factorize ( const MatrixType &  matrix )

inline

Compute the LU supernodal factorization of matrix WARNING The matrix matrix should have the same structural pattern as the same used in the analysis phase.

See also

analyzePattern()

factorize() [3/5]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::factorize ( const MatrixType &  matrix )

inline

Compute the LL^T supernodal numerical factorization of matrix

See also

analyzePattern()

factorize() [4/5]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLDLT< _MatrixType, _UpLo >::factorize ( const MatrixType &  matrix )

inline

Compute the LDL^T supernodal numerical factorization of matrix

factorize() [5/5]

template<typename MatrixType >

void HArDCore2D::LinearSolver< MatrixType >::factorize ( MatrixType &  A )

inline

Factorize the matrix.

Parameters

A	Matrix of the system to solve

fortran_to_c_numbering()

template<typename MatrixType >

void Eigen::internal::fortran_to_c_numbering

(

MatrixType &

mat

)

getLabelDOF() [1/2]

int HArDCore2D::DSL::GlobalDOFTable::getLabelDOF ( const size_t  i )

inline

Get label of DOF number i.

getLabelDOF() [2/2]

int HArDCore2D::GlobalDOFSpace::getLabelDOF ( const size_t  i )

inline

Get label of DOF number i.

globalDOFIndices() [1/2]

std::vector< size_t > GlobalDOFTable::globalDOFIndices

(

const Cell &

T

)

const

globalDOFIndices() [2/2]

std::vector< size_t > GlobalDOFSpace::globalDOFIndices

(

const Cell &

T

)

const

globalDOFs_gl()

std::vector< size_t > HArDCore2D::LocalStaticCondensation::globalDOFs_gl ( )

inline

Returns global DOFs that are not statically condensend.

globalDOFs_sc()

std::vector< size_t > HArDCore2D::LocalStaticCondensation::globalDOFs_sc ( )

inline

Returns global DOFs that are statically condensend.

GlobalDOFSpace()

GlobalDOFSpace::GlobalDOFSpace	(	const Mesh &	mesh,
		size_t	n_local_vertex_dofs,
		size_t	n_local_edge_dofs,
		size_t	n_local_cell_dofs
	)

Constructor.

GlobalDOFTable()

GlobalDOFTable::GlobalDOFTable

(

const DiscreteSpaceDescriptor &

descriptor

)

Constructor.

globalOffset() [1/6]

size_t HArDCore2D::DSL::GlobalDOFTable::globalOffset ( const Cell &  T ) const

inline

Return the global offset for the unknowns on the cell T.

globalOffset() [2/6]

size_t HArDCore2D::GlobalDOFSpace::globalOffset ( const Cell &  T ) const

inline

Return the global offset for the unknowns on the cell T.

globalOffset() [3/6]

size_t HArDCore2D::DSL::GlobalDOFTable::globalOffset ( const Edge &  E ) const

inline

Return the global offset for the unknowns on the edge E.

globalOffset() [4/6]

size_t HArDCore2D::GlobalDOFSpace::globalOffset ( const Edge &  E ) const

inline

Return the global offset for the unknowns on the edge E.

globalOffset() [5/6]

size_t HArDCore2D::DSL::GlobalDOFTable::globalOffset ( const Vertex &  V ) const

inline

Return the global offset for the unknowns on the vertex V.

globalOffset() [6/6]

size_t HArDCore2D::GlobalDOFSpace::globalOffset ( const Vertex &  V ) const

inline

Return the global offset for the unknowns on the vertex V.

Goly()

static size_t HArDCore2D::PolynomialSpaceDimension< Cell >::Goly ( int  k )

inlinestatic

Dimension of Gk(T)

GolyCompl()

static size_t HArDCore2D::PolynomialSpaceDimension< Cell >::GolyCompl ( int  k )

inlinestatic

Dimension of Gck(T)

grabMatrix() [1/3]

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::grabMatrix ( const MatrixType &  matrix, ColSpMatrix &  out  )

inlineprotected

grabMatrix() [2/3]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::grabMatrix ( const MatrixType &  matrix, ColSpMatrix &  out  )

inlineprotected

grabMatrix() [3/3]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLDLT< _MatrixType, _UpLo >::grabMatrix ( const MatrixType &  matrix, ColSpMatrix &  out  )

inlineprotected

Holy()

static size_t HArDCore2D::PolynomialSpaceDimension< Cell >::Holy ( int  k )

inlinestatic

Dimension of Hk(T)

HolyCompl()

static size_t HArDCore2D::PolynomialSpaceDimension< Cell >::HolyCompl ( int  k )

inlinestatic

Dimension of Hck(T)

info()

template<class Derived >

ComputationInfo Eigen::PastixBase< Derived >::info ( ) const

inline

Reports whether previous computation was successful.

Returns

Success if computation was successful, NumericalIssue if the PaStiX reports a problem InvalidInput if the input matrix is invalid

See also

iparm()

info_factorize()

template<typename MatrixType >

Eigen::ComputationInfo HArDCore2D::LinearSolver< MatrixType >::info_factorize ( ) const

inline

Returns the information message after the "factorize" step.

info_solve()

template<typename MatrixType >

Eigen::ComputationInfo HArDCore2D::LinearSolver< MatrixType >::info_solve ( ) const

inline

Returns the information message after the "solve" step.

init() [1/4]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLLT< _MatrixType, _UpLo >::init ( )

inlineprotected

init() [2/4]

template<typename _MatrixType , int _UpLo>

void Eigen::PastixLDLT< _MatrixType, _UpLo >::init ( )

inlineprotected

init() [3/4]

template<class Derived >

void Eigen::PastixBase< Derived >::init	(	double	eps_refinement = -1.0,
		double	eps_ctrl = -1.0
	)

Initialize the PaStiX data structure. A first call to this function fills iparm and dparm with the default PaStiX parameters

See also

iparm() dparm()

init() [4/4]

template<typename _MatrixType , bool IsStrSym>

void Eigen::PastixLU< _MatrixType, IsStrSym >::init ( double  eps_refinement = -1.0, double  eps_ctrl = -1.0  )

inline

IntegralWeight() [1/2]

HArDCore2D::IntegralWeight::IntegralWeight ( const std::function< double(const Cell &T, const Eigen::Vector2d &x)>  _value, std::function< size_t(const Cell &T)>  _deg  )

inline

Parameters

_value	Value of weight
_deg	Local degree of weight

IntegralWeight() [2/2]

HArDCore2D::IntegralWeight::IntegralWeight ( double  val )

inline

iparm() [1/2]

template<class Derived >

Array< StorageIndex, IPARM_SIZE, 1 > & Eigen::PastixBase< Derived >::iparm ( )

inline

Returns a reference to the integer vector IPARM of PaStiX parameters to modify the default parameters. The statistics related to the different phases of factorization and solve are saved here as well

See also

analyzePattern() factorize()

iparm() [2/2]

template<class Derived >

int & Eigen::PastixBase< Derived >::iparm ( int  idxparam )

inline

Return a reference to a particular index parameter of the IPARM vector

See also

iparm()

LinearSolver()

template<typename MatrixType >

HArDCore2D::LinearSolver< MatrixType >::LinearSolver ( const std::string &  namesolver )

inline

Constructor.

The name of the solver is not caps-dependent

LocalDOFSpace()

LocalDOFSpace::LocalDOFSpace	(	const Mesh &	mesh,
		size_t	n_local_vertex_dofs,
		size_t	n_local_edge_dofs,
		size_t	n_local_cell_dofs
	)

Constructor.

localOffset() [1/5]

size_t HArDCore2D::LocalDOFSpace::localOffset ( const Cell &  T ) const

inline

Returns the local offset of the unknowns attached to the element T.

localOffset() [2/5]

size_t HArDCore2D::LocalDOFSpace::localOffset ( const Cell &  T, const Edge &  E  ) const

inline

Returns the local offset of the edge E with respect to the cell T.

localOffset() [3/5]

size_t HArDCore2D::LocalDOFSpace::localOffset ( const Cell &  T, const Vertex &  V  ) const

inline

Returns the local offset of the vertex V with respect to the cell T.

localOffset() [4/5]

size_t HArDCore2D::LocalDOFSpace::localOffset ( const Edge &  E ) const

inline

Returns the local offset of the unknowns attached to the edge E.

localOffset() [5/5]

size_t HArDCore2D::LocalDOFSpace::localOffset ( const Edge &  E, const Vertex &  V  ) const

inline

Returns the local offset of the vertex V with respect to the edge E.

LocalStaticCondensation()

HArDCore2D::LocalStaticCondensation::LocalStaticCondensation ( const Eigen::MatrixXd &  Perm, const std::vector< size_t > &  globalDOFs_gl, const std::vector< size_t > &  globalDOFs_sc  )

inline

Constructor.

Parameters

Perm	Permutation that moves the DOFs to condense at the end
globalDOFs_gl	List of global DOFs that are globally coupled (not statically condensed)
globalDOFs_sc	List of global DOFs that are statically condensed

mesh()

const Mesh & HArDCore2D::LocalDOFSpace::mesh ( ) const

inline

Returns the mesh.

name()

template<typename MatrixType >

std::string HArDCore2D::LinearSolver< MatrixType >::name ( ) const

inline

Returns the name of the solver.

numLocalDofsCell()

size_t HArDCore2D::LocalDOFSpace::numLocalDofsCell ( ) const

inline

Returns the number of local cell DOFs.

numLocalDofsEdge()

size_t HArDCore2D::LocalDOFSpace::numLocalDofsEdge ( ) const

inline

Returns the number of local edge DOFs.

numLocalDofsVertex()

size_t HArDCore2D::LocalDOFSpace::numLocalDofsVertex ( ) const

inline

Returns the number of local vertex DOFs.

numTotalDofsCells()

size_t HArDCore2D::LocalDOFSpace::numTotalDofsCells ( ) const

inline

Returns the total number of vertex DOFs.

numTotalDofsEdges()

size_t HArDCore2D::LocalDOFSpace::numTotalDofsEdges ( ) const

inline

Returns the total number of vertex DOFs.

numTotalDofsVertices()

size_t HArDCore2D::LocalDOFSpace::numTotalDofsVertices ( ) const

inline

Returns the total number of vertex DOFs.

parallel_assembly_system() [1/3]

static std::pair< Eigen::SparseMatrix< double >, Eigen::VectorXd > HArDCore2D::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  )

inlinestatic

Function to assemble global matrix and right-hand side from a procedure that computes local triplets and rhs contributions.

parallel_assembly_system() [2/3]

static std::tuple< Eigen::SparseMatrix< double >, Eigen::VectorXd, Eigen::SparseMatrix< double >, Eigen::VectorXd > HArDCore2D::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  )

inlinestatic

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.

parallel_assembly_system() [3/3]

static std::tuple< Eigen::SparseMatrix< double >, Eigen::VectorXd, Eigen::SparseMatrix< double > > HArDCore2D::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  )

inlinestatic

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.

parallel_for()

static void HArDCore2D::parallel_for ( unsigned  nb_elements, std::function< void(size_t start, size_t end)>  functor, bool  use_threads = true, unsigned  nb_threads_max = 1e9  )

inlinestatic

Generic function to execute threaded processes.

Parameters

nb_elements	Number of jobs for the functor function
functor	Function that splits the jobs between two indices of "elements"
use_threads	Do we multithread or not
nb_threads_max	To limit the number of cores used by the process

PastixBase()

template<class Derived >

Eigen::PastixBase< Derived >::PastixBase ( )

inline

PastixLDLT() [1/2]

template<typename _MatrixType , int _UpLo>

Eigen::PastixLDLT< _MatrixType, _UpLo >::PastixLDLT ( )

inline

PastixLDLT() [2/2]

template<typename _MatrixType , int _UpLo>

Eigen::PastixLDLT< _MatrixType, _UpLo >::PastixLDLT ( const MatrixType &  matrix )

inlineexplicit

PastixLLT() [1/2]

template<typename _MatrixType , int _UpLo>

Eigen::PastixLLT< _MatrixType, _UpLo >::PastixLLT ( )

inline

PastixLLT() [2/2]

template<typename _MatrixType , int _UpLo>

Eigen::PastixLLT< _MatrixType, _UpLo >::PastixLLT ( const MatrixType &  matrix )

inlineexplicit

PastixLU() [1/2]

template<typename _MatrixType , bool IsStrSym>

Eigen::PastixLU< _MatrixType, IsStrSym >::PastixLU ( )

inline

PastixLU() [2/2]

template<typename _MatrixType , bool IsStrSym>

Eigen::PastixLU< _MatrixType, IsStrSym >::PastixLU ( const MatrixType &  matrix )

inlineexplicit

Poly() [1/2]

static size_t HArDCore2D::PolynomialSpaceDimension< Cell >::Poly ( int  k )

inlinestatic

Dimension of Pk(T)

Poly() [2/2]

static size_t HArDCore2D::PolynomialSpaceDimension< Edge >::Poly ( int  k )

inlinestatic

Dimension of Pk(E)

residual()

template<typename MatrixType >

template<typename VectorType >

double HArDCore2D::LinearSolver< MatrixType >::residual ( MatrixType &  A, VectorType &  b, VectorType &  x  )

inline

Check relative infinity norm of residual: ||Ax-b||/||b||.

restrict() [1/4]

Eigen::VectorXd HArDCore2D::DSL::GlobalDOFTable::restrict ( const Cell &  T, const Eigen::VectorXd  vh  ) const

inline

Restrict to a cell.

restrict() [2/4]

Eigen::VectorXd HArDCore2D::GlobalDOFSpace::restrict ( const Cell &  T, const Eigen::VectorXd  vh  ) const

inline

Restrict to a cell.

restrict() [3/4]

Eigen::VectorXd HArDCore2D::DSL::GlobalDOFTable::restrict ( const Edge &  E, const Eigen::VectorXd  vh  ) const

inline

Restrict to an edge.

restrict() [4/4]

Eigen::VectorXd HArDCore2D::GlobalDOFSpace::restrict ( const Edge &  E, const Eigen::VectorXd  vh  ) const

inline

Restrict to an edge.

restrictCell() [1/2]

Eigen::VectorXd GlobalDOFTable::restrictCell	(	size_t	iT,
		const Eigen::VectorXd &	vh
	)		const

Restrict to the cell (including vertices and edges) of index iT.

restrictCell() [2/2]

Eigen::VectorXd GlobalDOFSpace::restrictCell	(	size_t	iT,
		const Eigen::VectorXd &	vh
	)		const

Restrict to the cell (including vertices and edges) of index iT.

restrictEdge() [1/2]

Eigen::VectorXd GlobalDOFTable::restrictEdge	(	size_t	iE,
		const Eigen::VectorXd &	vh
	)		const

Restrict to the edge (including its vertices) of index iE.

restrictEdge() [2/2]

Eigen::VectorXd GlobalDOFSpace::restrictEdge	(	size_t	iE,
		const Eigen::VectorXd &	vh
	)		const

Restrict to the edge (including its vertices) of index iE.

Roly()

static size_t HArDCore2D::PolynomialSpaceDimension< Cell >::Roly ( int  k )

inlinestatic

Dimension of Rk(T)

RolyCompl()

static size_t HArDCore2D::PolynomialSpaceDimension< Cell >::RolyCompl ( int  k )

inlinestatic

Dimension of Rck(T)

rows()

template<class Derived >

Index Eigen::PastixBase< Derived >::rows ( ) const

inline

setLabelDOF() [1/2]

void HArDCore2D::DSL::GlobalDOFTable::setLabelDOF ( const size_t  i, const int  label  )

inline

Set a label to the DOF number i (default label is -1)

setLabelDOF() [2/2]

void HArDCore2D::GlobalDOFSpace::setLabelDOF ( const size_t  i, const int  label  )

inline

Set a label to the DOF number i (default label is -1)

solve()

template<typename MatrixType >

template<typename VectorType >

VectorType HArDCore2D::LinearSolver< MatrixType >::solve ( VectorType &  b )

inline

Solve the system Ax=b using the selected solver (after analysis of pattern and computation of matrix)

Parameters

b	Right-hand side of the system to solve

store_times()

std::pair< double, double > HArDCore2D::store_times ( boost::timer::cpu_timer &  timer, std::string  message = ""  )

inline

Function to store and display wall/proc timers from boost::timer::cpu_timer.

Wall time is in the first element of the pair, proc time in the second

Parameters

timer	The timer
message	Optional message to display with time (if not message is passed, times are not displayed)

~PastixBase()

template<class Derived >

Eigen::PastixBase< Derived >::~PastixBase ( )

inline

Variable Documentation

deg

std::function<size_t (const Cell & T)> HArDCore2D::IntegralWeight::deg

m_analysisIsOk

template<class Derived >

int Eigen::PastixBase< Derived >::m_analysisIsOk

protected

m_comm

template<class Derived >

int Eigen::PastixBase< Derived >::m_comm

mutableprotected

m_dim_gl

size_t HArDCore2D::LocalStaticCondensation::m_dim_gl

m_dim_sc

size_t HArDCore2D::LocalStaticCondensation::m_dim_sc

m_dparm

template<class Derived >

Array<double,DPARM_SIZE,1> Eigen::PastixBase< Derived >::m_dparm

mutableprotected

m_factorizationIsOk

template<class Derived >

int Eigen::PastixBase< Derived >::m_factorizationIsOk

protected

m_globalDOFs_gl

std::vector<size_t> HArDCore2D::LocalStaticCondensation::m_globalDOFs_gl

m_globalDOFs_sc

std::vector<size_t> HArDCore2D::LocalStaticCondensation::m_globalDOFs_sc

m_info

template<class Derived >

ComputationInfo Eigen::PastixBase< Derived >::m_info

mutableprotected

m_initisOk

template<class Derived >

int Eigen::PastixBase< Derived >::m_initisOk

protected

m_invp

template<class Derived >

Matrix<StorageIndex,Dynamic,1> Eigen::PastixBase< Derived >::m_invp

mutableprotected

m_iparm

template<class Derived >

Array<int,IPARM_SIZE,1> Eigen::PastixBase< Derived >::m_iparm

mutableprotected

m_mesh

const Mesh& HArDCore2D::LocalDOFSpace::m_mesh

protected

m_n_local_cell_dofs

size_t HArDCore2D::LocalDOFSpace::m_n_local_cell_dofs

protected

m_n_local_edge_dofs

size_t HArDCore2D::LocalDOFSpace::m_n_local_edge_dofs

protected

m_n_local_vertex_dofs

size_t HArDCore2D::LocalDOFSpace::m_n_local_vertex_dofs

protected

m_pastixdata

template<class Derived >

pastix_data_t* Eigen::PastixBase< Derived >::m_pastixdata

mutableprotected

m_Perm

Eigen::MatrixXd HArDCore2D::LocalStaticCondensation::m_Perm

m_perm

template<class Derived >

Matrix<StorageIndex,Dynamic,1> Eigen::PastixBase< Derived >::m_perm

mutableprotected

m_size

template<class Derived >

int Eigen::PastixBase< Derived >::m_size

mutableprotected

m_structureIsUptodate

template<typename _MatrixType , bool IsStrSym>

bool Eigen::PastixLU< _MatrixType, IsStrSym >::m_structureIsUptodate

protected

m_transposedStructure

template<typename _MatrixType , bool IsStrSym>

ColSpMatrix Eigen::PastixLU< _MatrixType, IsStrSym >::m_transposedStructure

protected

map_id

std::map<SolverName, size_t> HArDCore2D::map_id

Initial value:

= {{EigenLU,0},
                                            {EigenBiCGStab,1},
                                            {PardisoLU,2},
                                            {UMFPACK,3},
                                            {PaStiXLU,4},
                                            {PaStiXLLT,5},
                                            {SuperLU,6}}

map_realname

std::map<SolverName, std::string> HArDCore2D::map_realname

Initial value:

= {{EigenLU,"Eigen LU"},
                                            {EigenBiCGStab,"Eigen BiCGStab"},
                                            {PardisoLU,"Pardiso LU"},
                                            {UMFPACK,"UMFPACK"},
                                            {PaStiXLU,"PaStiX LU"},
                                            {PaStiXLLT,"PaStiX LLT"},
                                            {SuperLU,"SuperLU"}}

Map to associate to each solver its proper name.

map_solver

std::map<std::string, SolverName> HArDCore2D::map_solver

Initial value:

= {{"eigenlu",EigenLU},
                                            {"eigenbicgstab",EigenBiCGStab},
                                            {"pardisolu",PardisoLU},
                                            {"umfpack",UMFPACK},
                                            {"pastixlu",PaStiXLU},
                                            {"pastixllt",PaStiXLLT},
                                            {"superlu",SuperLU}}

Map to associate to each lowercase name a solver.

The user passes a string and this map identifies the solver (this is case-independent)

ParamName

std::map<std::string, int> HArDCore2D::ParamName

Initial value:

{
 
 
 
  }

To parse optional Solver parameter from command line.

SolverParam

std::vector<double> HArDCore2D::SolverParam

Initial value:

{
 
 
 
  }

Create space and stores default values of optional solver parameters.

SolverParamHelper

const char* HArDCore2D::SolverParamHelper

Initial value:

{
 
 
 
 
 
 
 
  "Set the solver parameters, not implemented with this solver, see src/Common/linearsolver.hpp for modifications\n"
 
  }

Create a solver specific description in boost::desc.options.

value

std::function<double (const Cell & T, const Eigen::Vector2d & x)> HArDCore2D::IntegralWeight::value