libMesh Namespace Reference

Namespaces
namespace	boostcopy
namespace	DenseMatrices
namespace	ElementTypes
namespace	exII
namespace	FiniteElements
namespace	libMeshPrivateData
namespace	MeshTools
namespace	Nemesis
namespace	Parallel
namespace	Predicates
namespace	QuadratureRules
namespace	Quality
namespace	SparsityPattern
namespace	TensorTools
namespace	Threads
namespace	Trees
namespace	TriangleWrapper
namespace	Utility
Classes
class	Problem_Interface
class	ProjectVector
class	BuildProjectionList
class	ProjectSolution
class	ProjectFEMSolution
class	BoundaryProjectSolution
class	AbaqusIO
class	AdaptiveTimeSolver
class	AdjointRefinementEstimator
class	AdjointResidualErrorEstimator
class	AnalyticFunction
struct	AutoPtrRef
class	AutoPtr
	A simple smart pointer providing strict ownership semantics. More...
class	BoundaryInfo
class	BoundaryMesh
class	Cell
class	Hex
class	Hex20
class	Hex27
class	Hex8
class	InfCell
class	InfHex
class	InfHex16
class	InfHex18
class	InfHex8
class	InfPrism
class	InfPrism12
class	InfPrism6
class	Prism
class	Prism15
class	Prism18
class	Prism6
class	Pyramid
class	Pyramid5
class	Tet
class	Tet10
class	Tet4
class	CentroidPartitioner
struct	ScalarTraits
struct	ScalarTraits< std::complex< T > >
struct	CompareTypes
struct	CompareTypes< T, T >
struct	CompareTypes< T, std::complex< T > >
struct	CompareTypes< std::complex< T >, T >
class	CondensedEigenSystem
class	ConstFEMFunction
class	ConstFunction
class	ContinuationSystem
class	CouplingMatrix
class	DenseMatrix
class	DenseMatrixBase
class	DenseSubMatrix
class	DenseSubVector
class	DenseVector
class	DenseVectorBase
class	DerivedRBConstruction
class	DerivedRBEvaluation
class	DiffContext
class	DifferentiablePhysics
class	DifferentiableQoI
class	DiffSolver
class	DifferentiableSystem
class	DirectSolutionTransfer
class	DirichletBoundary
class	DirichletBoundaries
class	DiscontinuityMeasure
class	DistributedVector
class	DivaIO
class	DofConstraints
class	NodeConstraints
class	DofMap
class	DofObject
class	DTKAdapter
class	DTKEvaluator
class	DTKSolutionTransfer
class	Edge
class	Edge2
class	Edge3
class	Edge4
class	InfEdge2
class	EigenSolver
class	EigenSystem
class	EigenTimeSolver
class	Elem
class	ElemAssembly
class	EnsightIO
class	EquationSystems
class	ErrorEstimator
class	ErrorVector
class	Euler2Solver
class	EulerSolver
class	ExactErrorEstimator
class	ExactSolution
class	ExodusII_IO
class	ExodusII_IO_Helper
class	ExplicitSystem
class	Face
class	InfQuad
class	InfQuad4
class	InfQuad6
class	Quad
class	Quad4
class	Quad8
class	Quad9
class	Tri
class	Tri3
class	Tri6
class	Factory
class	FactoryImp
struct	FEOutputType
struct	FEOutputType< LAGRANGE_VEC >
struct	FEOutputType< NEDELEC_ONE >
class	FE
class	FEClough
class	FEHermite
class	FEHierarchic
class	FEL2Hierarchic
class	FELagrange
class	FEL2Lagrange
class	FEMonomial
class	FEScalar
class	FEXYZ
class	FELagrangeVec
class	FENedelecOne
class	FEAbstract
struct	TypesEqual
struct	TypesEqual< T, T >
class	FEGenericBase
class	FEComputeData
class	FEInterface
class	FEMap
class	FETransformationBase
class	FEType
class	FEXYZMap
class	FEMContext
class	FEMFunctionBase
class	FEMPhysics
class	FEMSystem
class	LaplacianErrorEstimator
class	FrequencySystem
class	FroIO
class	FunctionBase
class	GmshIO
class	GMVIO
class	GnuPlotIO
class	H1FETransformation
class	HCurlFETransformation
class	HilbertSFCPartitioner
class	HPCoarsenTest
class	HPSelector
class	HPSingularity
class	TestClass
class	ImplicitSystem
class	InfElemBuilder
class	InfFE
class	JumpErrorEstimator
class	KellyErrorEstimator
class	LaspackLinearSolver
class	LaspackMatrix
class	LaspackVector
class	LegacyXdrIO
class	LibMeshInit
class	LogicError
class	NotImplemented
class	FileError
class	ConvergenceFailure
class	DynamicCastFailure
class	FloatingPointException
class	Linear
class	LinearImplicitSystem
class	LinearPartitioner
class	LinearSolver
class	LocationMap
class	mapvector
class	MatlabIO
class	MEDITIO
class	MemorySolutionHistory
class	Mesh
class	MeshBase
class	MeshCommunication
class	MeshData
class	MeshDataUnvHeader
class	MeshFunction
class	MeshInput
struct	mesh_inserter_iterator
class	MeshOutput
class	MeshRefinement
class	MeshSerializer
class	MeshSmoother
class	LaplaceMeshSmoother
class	VariationalMeshSmoother
class	TetGenMeshInterface
class	TetGenWrapper
class	TriangleInterface
class	MeshfreeInterpolation
class	InverseDistanceInterpolation
class	MeshfreeSolutionTransfer
class	MeshFunctionSolutionTransfer
class	MetisPartitioner
class	MortonSFCPartitioner
class	Nemesis_IO
class	Nemesis_IO_Helper
class	NewmarkSystem
class	LinearSolutionMonitor
class	NewtonSolver
class	NoSolutionHistory
class	Node
class	NodeElem
class	NonlinearImplicitSystem
class	NonlinearSolver
struct	null_output_iterator
class	NumericVector
class	OFStream
class	OStringStream
class	OFFIO
class	BasicOStreamProxy
struct	SyncNodalPositions
class	ParallelMesh
class	ParameterVector
class	Parameters
class	ParmetisPartitioner
class	ParsedFunction
class	Partitioner
class	Patch
class	PatchRecoveryErrorEstimator
class	PerfData
class	PerfLog
class	PerfMon
class	PeriodicBoundaries
class	PeriodicBoundary
class	PeriodicBoundaryBase
class	PetscDiffSolver
class	PetscDMNonlinearSolver
class	PetscLinearSolver
class	PetscMatrix
class	PetscNonlinearSolver
class	PetscPreconditioner
class	PetscVector
class	Plane
class	PltLoader
class	Point
class	PointLocatorBase
class	PointLocatorList
class	PointLocatorTree
class	PoolAllocator
class	FastPoolAllocator
class	PostscriptIO
class	Preconditioner
class	QoISet
class	QBase
class	QClough
class	QConical
class	QGauss
class	QGrundmann_Moller
class	QGrid
class	QJacobi
class	QMonomial
class	QSimpson
class	QTrap
struct	RawFieldType
struct	RawFieldType< Number >
struct	RawFieldType< Gradient >
struct	RawFieldType< Tensor >
struct	RawFieldType< TypeNTensor< 3, Number > >
struct	RawFieldType< Real >
struct	RawFieldType< RealGradient >
struct	RawFieldType< RealTensor >
struct	RawFieldType< TypeNTensor< 3, Real > >
class	RawAccessor
class	RawAccessor< TypeNTensor< N, ScalarType > >
class	RBAssemblyExpansion
class	RBConstruction
class	RBConstructionBase
class	RBEIMAssembly
class	RBEIMConstruction
class	RBEIMEvaluation
class	RBEIMTheta
class	RBEvaluation
class	RBParameters
class	RBParametrized
class	RBParametrizedFunction
class	RBSCMConstruction
class	RBSCMEvaluation
class	RBTemporalDiscretization
class	RBTheta
class	RBThetaExpansion
class	ReferenceCountedObject
class	ReferenceCounter
class	RefinementSelector
class	RemoteElem
class	SensitivityData
class	SerialMesh
class	SFCPartitioner
class	ShellMatrix
class	Side
class	SideEdge
class	SlepcEigenSolver
class	SolutionHistory
class	SolutionTransfer
class	Solver
class	SparseMatrix
class	SparseShellMatrix
class	Sphere
class	StatisticsVector
class	SteadySolver
class	StoredRange
class	SumShellMatrix
class	Surface
class	System
class	SystemNorm
class	SystemSubset
class	SystemSubsetBySubdomain
class	TecplotIO
class	TensorShellMatrix
class	TensorValue
class	TetGenIO
class	TimeSolver
class	TransientRBAssemblyExpansion
class	TransientRBConstruction
class	TransientRBEvaluation
class	TransientRBThetaExpansion
class	TransientSystem
class	Tree
class	TreeBase
class	TreeNode
class	AztecLinearSolver
class	EpetraMatrix
class	EpetraVector
class	NoxNonlinearSolver
class	TrilinosPreconditioner
class	TwostepTimeSolver
class	TypeNTensor
class	TypeTensor
class	TypeTensorColumn
class	ConstTypeTensorColumn
class	TypeVector
class	UCDIO
class	UniformRefinementEstimator
class	UnsteadySolver
class	UnstructuredMesh
class	UNVIO
class	Variable
class	VariableGroup
class	VectorValue
class	VTKIO
class	WeightedPatchRecoveryErrorEstimator
class	WrappedFunction
class	Xdr
class	XdrHEAD
class	XdrIO
class	XdrMESH
class	XdrMGF
class	XdrMHEAD
class	XdrSHEAD
class	XdrSOLN
class	ZeroFunction
Typedefs
typedef int	PetscErrorCode
typedef int	PetscInt
typedef std::vector< Point > ::const_iterator	const_list_iterator
typedef DerivedRBConstruction < RBConstruction >	SteadyDerivedRBConstruction
typedef DerivedRBEvaluation < RBEvaluation >	SteadyDerivedRBEvaluation
typedef std::map< dof_id_type, Real, std::less< dof_id_type > , Threads::scalable_allocator < std::pair< const dof_id_type, Real > > >	DofConstraintRow
typedef std::map< const Node , Real, std::less< const Node > , Threads::scalable_allocator < std::pair< const Node *const, Real > > >	NodeConstraintRow
typedef StoredRange < MeshBase::element_iterator, Elem * >	ElemRange
typedef StoredRange < MeshBase::const_element_iterator, const Elem * >	ConstElemRange
typedef FEGenericBase< Real >	FEBase
typedef TensorValue< Number >	NumberTensorValue
typedef NumberTensorValue	Tensor
typedef VectorValue< Number >	NumberVectorValue
typedef NumberVectorValue	Gradient
typedef FEGenericBase < RealGradient >	FEVectorBase
typedef VectorValue< Real >	RealVectorValue
typedef TensorValue< Real >	RealTensorValue
typedef RealVectorValue	RealGradient
typedef RealTensorValue	RealTensor
typedef TestClass	subdomain_id_type
typedef int8_t	boundary_id_type
typedef uint8_t	dof_id_type
typedef dof_id_type	numeric_index_type
typedef uint8_t	processor_id_type
typedef std::complex< Real >	Complex
typedef std::complex< Real >	COMPLEX
typedef Real	Number
typedef ParallelMesh	DefaultMesh
typedef double *	LPDOUBLE
typedef LPDOUBLE *	LPLPDOUBLE
typedef LPLPDOUBLE *	LPLPLPDOUBLE
typedef void *	LPVOID
typedef LPVOID *	LPLPVOID
typedef int *	LPINT
typedef LPINT *	LPLPINT
typedef unsigned int	uint
typedef Real	REAL
typedef StoredRange < MeshBase::node_iterator, Node * >	NodeRange
typedef StoredRange < MeshBase::const_node_iterator, const Node * >	ConstNodeRange
typedef BasicOStreamProxy	OStreamProxy
typedef LinearImplicitSystem	SteadyLinearSystem
typedef TransientSystem < LinearImplicitSystem >	TransientImplicitSystem
typedef TransientSystem < LinearImplicitSystem >	TransientLinearImplicitSystem
typedef TransientSystem < NonlinearImplicitSystem >	TransientNonlinearImplicitSystem
typedef TransientSystem < ExplicitSystem >	TransientExplicitSystem
typedef TransientSystem< System >	TransientBaseSystem
Functions
const Number	imaginary (0., 1.)
bool	initialized ()
bool	closed ()
void	libmesh_terminate_handler ()
void	_init (int &argc, char **&argv) void _init(int &argc
template float	command_line_value< float > (const std::string &, float)
template double	command_line_value< double > (const std::string &, double)
template long double	command_line_value< long double > (const std::string &, long double)
template std::string	command_line_value< std::string > (const std::string &, std::string)
template void	command_line_vector< int > (const std::string &, std::vector< int > &)
template void	command_line_vector< float > (const std::string &, std::vector< float > &)
template void	command_line_vector< double > (const std::string &, std::vector< double > &)
template void	command_line_vector< long double > (const std::string &, std::vector< long double > &)
std::string	process_trace (const char *name)
std::string	demangle (const char *name)
void	print_trace (std::ostream &out)
	INSTANTIATE_FE (0)
	INSTANTIATE_FE (1)
	INSTANTIATE_FE (2)
	INSTANTIATE_FE (3)
std::ostream &	operator<< (std::ostream &os, const FEAbstract &fe)
	REINIT_ERROR (REINIT_ERROR(0, REINIT_ERROR(CLOUGH, reinit)
	INSTANTIATE_ALL_MAPS (0)
	INSTANTIATE_ALL_MAPS (1)
	INSTANTIATE_ALL_MAPS (2)
	INSTANTIATE_ALL_MAPS (3)
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Elem , Base::build_elem(const Elem ))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Elem , Base::build_elem(const Elem ))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Elem , Base::build_elem(const Elem ))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, ElemType, Base::get_elem_type(const ElemType type))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, ElemType, Base::get_elem_type(const ElemType type))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, ElemType, Base::get_elem_type(const ElemType type))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, Base::n_base_mapping_sf(const ElemType, const Order))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, Base::n_base_mapping_sf(const ElemType, const Order))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, Base::n_base_mapping_sf(const ElemType, const Order))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, Radial::n_dofs_at_node(const Order, const unsigned int))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, Radial::n_dofs_at_node(const Order, const unsigned int))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, Radial::n_dofs_at_node(const Order, const unsigned int))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, edge_reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, edge_reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, edge_reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, init_face_shape_functions(const std::vector< Point > &, const Elem *))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, init_face_shape_functions(const std::vector< Point > &, const Elem *))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, init_face_shape_functions(const std::vector< Point > &, const Elem *))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Point, inverse_map(const Elem *, const Point &, const Real, const bool, const bool))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Point, inverse_map(const Elem *, const Point &, const Real, const bool, const bool))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Point, inverse_map(const Elem *, const Point &, const Real, const bool, const bool))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, n_dofs(const FEType &, const ElemType))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, n_dofs(const FEType &, const ElemType))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, n_dofs(const FEType &, const ElemType))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, n_dofs_per_elem(const FEType &, const ElemType))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, n_dofs_per_elem(const FEType &, const ElemType))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, n_dofs_per_elem(const FEType &, const ElemType))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, n_dofs_at_node(const FEType &, const ElemType, const unsigned int))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, n_dofs_at_node(const FEType &, const ElemType, const unsigned int))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, n_dofs_at_node(const FEType &, const ElemType, const unsigned int))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Real, shape(const FEType &, const Elem *, const unsigned int, const Point &p))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Real, shape(const FEType &, const Elem *, const unsigned int, const Point &p))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Real, shape(const FEType &, const Elem *, const unsigned int, const Point &p))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Real, shape(const FEType &, const ElemType, const unsigned int, const Point &))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Real, shape(const FEType &, const ElemType, const unsigned int, const Point &))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Real, shape(const FEType &, const ElemType, const unsigned int, const Point &))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, compute_data(const FEType &, const Elem *, FEComputeData &))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, compute_data(const FEType &, const Elem *, FEComputeData &))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, compute_data(const FEType &, const Elem *, FEComputeData &))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &))
std::ostream &	operator<< (std::ostream &os, const MeshBase &m)
template void	MeshCommunication::find_global_indices< MeshBase::const_node_iterator > (const MeshTools::BoundingBox &, const MeshBase::const_node_iterator &, const MeshBase::const_node_iterator &, std::vector< dof_id_type > &) const
template void	MeshCommunication::find_global_indices< MeshBase::const_element_iterator > (const MeshTools::BoundingBox &, const MeshBase::const_element_iterator &, const MeshBase::const_element_iterator &, std::vector< dof_id_type > &) const
template void	MeshCommunication::find_global_indices< MeshBase::node_iterator > (const MeshTools::BoundingBox &, const MeshBase::node_iterator &, const MeshBase::node_iterator &, std::vector< dof_id_type > &) const
template void	MeshCommunication::find_global_indices< MeshBase::element_iterator > (const MeshTools::BoundingBox &, const MeshBase::element_iterator &, const MeshBase::element_iterator &, std::vector< dof_id_type > &) const
std::ostream &	operator<< (std::ostream &os, const MeshData &m)
bool	is_between (Real min, Real check, Real max)
std::ostream &	operator<< (std::ostream &os, const QBase &q)
template<typename T >
T	SIGN (T a, T b)
PetscErrorCode	__libmesh_petsc_diff_solver_monitor (SNES, PetscInt its, PetscReal fnorm, void *ctx)
PetscErrorCode	__libmesh_petsc_diff_solver_residual (SNES, Vec x, Vec r, void *ctx)
PetscErrorCode	__libmesh_petsc_diff_solver_jacobian (SNES, Vec x, Mat libmesh_dbg_var(j), Mat pc, MatStructure msflag, void ctx)
void	PetscDMRegister ()
PetscErrorCode	__libmesh_petsc_preconditioner_setup (void *ctx)
PetscErrorCode	__libmesh_petsc_preconditioner_apply (void *ctx, Vec x, Vec y)
PetscErrorCode	__libmesh_petsc_preconditioner_setup (PC pc)
PetscErrorCode	__libmesh_petsc_preconditioner_apply (PC pc, Vec x, Vec y)
PetscErrorCode	__libmesh_petsc_snes_monitor (SNES, PetscInt its, PetscReal fnorm, void *)
PetscErrorCode	__libmesh_petsc_snes_residual (SNES snes, Vec x, Vec r, void *ctx)
PetscErrorCode	__libmesh_petsc_snes_jacobian (SNES snes, Vec x, Mat jac, Mat pc, MatStructure msflag, void ctx)
std::ostream &	operator<< (std::ostream &os, const EquationSystems &es)
template void	Xdr::data< std::complex< float > > (std::complex< float > &, const char *)
template void	Xdr::data< std::complex< double > > (std::complex< double > &, const char *)
template void	Xdr::data< std::complex< long double > > (std::complex< long double > &, const char *)
template void	Xdr::data< std::string > (std::string &, const char *)
template void	Xdr::data< std::vector< int > > (std::vector< int > &, const char *)
template void	Xdr::data< std::vector< unsigned int > > (std::vector< unsigned int > &, const char *)
template void	Xdr::data< std::vector< short int > > (std::vector< short int > &, const char *)
template void	Xdr::data< std::vector< unsigned short int > > (std::vector< unsigned short int > &, const char *)
template void	Xdr::data< std::vector< long int > > (std::vector< long int > &, const char *)
template void	Xdr::data< std::vector< unsigned long int > > (std::vector< unsigned long int > &, const char *)
template void	Xdr::data< std::vector< char > > (std::vector< char > &, const char *)
template void	Xdr::data< std::vector< signed char > > (std::vector< signed char > &, const char *)
template void	Xdr::data< std::vector< unsigned char > > (std::vector< unsigned char > &, const char *)
template void	Xdr::data< std::vector< float > > (std::vector< float > &, const char *)
template void	Xdr::data< std::vector< double > > (std::vector< double > &, const char *)
template void	Xdr::data< std::vector< long double > > (std::vector< long double > &, const char *)
template void	Xdr::data< std::vector< std::complex< float > > > (std::vector< std::complex< float > > &, const char *)
template void	Xdr::data< std::vector< std::complex< double > > > (std::vector< std::complex< double > > &, const char *)
template void	Xdr::data< std::vector< std::complex< long double > > > (std::vector< std::complex< long double > > &, const char *)
	ScalarTraits_true (char)
	ScalarTraits_true (short)
	ScalarTraits_true (int)
	ScalarTraits_true (long)
	ScalarTraits_true (unsigned char)
	ScalarTraits_true (float)
	ScalarTraits_true (double)
	SUPERTYPE (unsigned char, short)
	SUPERTYPE (unsigned char, int)
	SUPERTYPE (unsigned char, float)
	SUPERTYPE (unsigned char, double)
	SUPERTYPE (unsigned char, long double)
	SUPERTYPE (char, short)
	SUPERTYPE (char, int)
	SUPERTYPE (char, float)
	SUPERTYPE (char, double)
	SUPERTYPE (char, long double)
	SUPERTYPE (short, int)
	SUPERTYPE (short, float)
	SUPERTYPE (short, double)
	SUPERTYPE (short, long double)
	SUPERTYPE (int, float)
	SUPERTYPE (int, double)
	SUPERTYPE (int, long double)
	SUPERTYPE (float, double)
	SUPERTYPE (float, long double)
	SUPERTYPE (double, long double)
std::ostream &	operator<< (std::ostream &os, const Elem &e)
	INSTANTIATE_INF_FE (1, CARTESIAN)
	INSTANTIATE_INF_FE (2, CARTESIAN)
	INSTANTIATE_INF_FE (3, CARTESIAN)
void	init (int &argc, char **&argv)
void	init (int &argc, char **&argv, MPI_Comm COMM_WORLD_IN=MPI_COMM_WORLD)
int	close ()
bool	on_command_line (const std::string &arg)
template<typename T >
T	command_line_value (const std::string &, T)
template<typename T >
T	command_line_value (const std::vector< std::string > &, T)
template<typename T >
void	command_line_vector (const std::string &, std::vector< T > &)
SolverPackage	default_solver_package ()
processor_id_type	n_processors ()
processor_id_type	processor_id ()
unsigned int	n_threads ()
template<typename T >
T	libmesh_real (T a)
template<typename T >
T	libmesh_conj (T a)
template<typename T >
T	libmesh_real (std::complex< T > a)
template<typename T >
std::complex< T >	libmesh_conj (std::complex< T > a)
bool	libmesh_isnan (float a)
bool	libmesh_isnan (double a)
bool	libmesh_isnan (long double a)
template<typename T >
bool	libmesh_isnan (std::complex< T > a)
template<typename Tnew , typename Told >
Tnew	libmesh_cast_ref (Told &oldvar)
template<typename Tnew , typename Told >
Tnew	libmesh_cast_ptr (Told *oldvar)
template<typename Tnew , typename Told >
Tnew	libmesh_cast_int (Told oldvar)
template<class T >
void	libmesh_ignore (const T &)
void	libmesh_version_stdout ()
int	get_libmesh_version ()
std::string	get_io_compatibility_version ()
std::ostream &	operator<< (std::ostream &os, const Node &n)
template<typename P >
void	print_helper (std::ostream &os, const P *param)
template<typename P >
void	print_helper (std::ostream &os, const std::vector< P > *param)
std::ostream &	operator<< (std::ostream &os, const Parameters &p)
void	PetscDMSetSystem (DM, NonlinearImplicitSystem &)
void	PetscDMGetSystem (DM, NonlinearImplicitSystem *&)
template<typename T >
std::ostream &	operator<< (std::ostream &os, const SparseMatrix< T > &m)
template<typename T , typename Scalar >
boostcopy::enable_if_c < ScalarTraits< Scalar > ::value, TypeTensor< typename CompareTypes< T, Scalar > ::supertype > >::type	operator* (const Scalar factor, const TypeTensor< T > &t)
template<typename T , typename Scalar >
boostcopy::enable_if_c < ScalarTraits< Scalar > ::value, TypeVector< typename CompareTypes< T, Scalar > ::supertype > >::type	operator* (const Scalar factor, const TypeVector< T > &v)
Variables
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE	Real
DIE A HORRIBLE DEATH HERE typedef float	ErrorVectorReal
MPI_Comm	COMM_WORLD = MPI_COMM_NULL
Parallel::Communicator	CommWorld
OStreamProxy	out (std::cout)
OStreamProxy	err (std::cerr)
PerfLog	perflog ("libMesh",#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING true#else false#endif)
MPI_Errhandler	libmesh_errhandler
	TRILINOS_SOLVERS
	LASPACK_SOLVERS
	INVALID_SOLVER_PACKAGE
std::terminate_handler	old_terminate_handler
void char **&	argv
const RemoteElem *	remote_elem
const unsigned int	MIN_ELEM_PER_PROC = 4
PetscBool	PetscDMRegistered = PETSC_FALSE
const unsigned char	triangular_number_row []
const unsigned char	triangular_number_column []
const unsigned char	square_number_column []
const unsigned char	square_number_row []
const unsigned char	cube_number_column []
const unsigned char	cube_number_row []
const unsigned char	cube_number_page []
const Number	imaginary
const Real	pi
const Number	zero = 0.
const unsigned int	invalid_uint = static_cast<unsigned int>(-1)
static const Real	TOLERANCE = 1.e-8

Detailed Description

Sanity check, _without_ prior inclusion of libmesh_config.h.

This file is no typical header file. It is only to be included at the _end_ of an implementation file, so that the proper variations of the InfFE class are instantiated.

The libMesh namespace provides an interface to certain functionality in the library. It provides a uniform init() method that initializes any other dependent libraries (e.g. MPI or PETSC), and a close() method for closing those libraries. It also provides a centralized place for performance logging and other functionality.

Petsc include files.

SLEPc include files.

Trilinos include files.

Typedef Documentation

typedef int16_t libMesh::boundary_id_type

Definition at line 47 of file id_types.h.

typedef std::complex<Real> libMesh::COMPLEX

Definition at line 131 of file libmesh_common.h.

typedef std::complex<Real> libMesh::Complex

Definition at line 130 of file libmesh_common.h.

typedef std::vector<Point>::const_iterator libMesh::const_list_iterator

Definition at line 33 of file point_locator_list.C.

typedef StoredRange<MeshBase::const_element_iterator, const Elem*> libMesh::ConstElemRange

Definition at line 32 of file elem_range.h.

typedef StoredRange<MeshBase::const_node_iterator, const Node*> libMesh::ConstNodeRange

Definition at line 34 of file node_range.h.

typedef SerialMesh libMesh::DefaultMesh

Definition at line 27 of file mesh.h.

typedef uint32_t libMesh::dof_id_type

Definition at line 58 of file id_types.h.

typedef std::map<dof_id_type, Real, std::less<dof_id_type>, Threads::scalable_allocator<std::pair<const dof_id_type, Real> > > libMesh::DofConstraintRow

A row of the Dof constraint matrix.

Definition at line 86 of file dof_map.h.

typedef StoredRange<MeshBase::element_iterator, Elem*> libMesh::ElemRange

Definition at line 31 of file elem_range.h.

typedef FEGenericBase< Real > libMesh::FEBase

Definition at line 36 of file exact_error_estimator.h.

typedef FEGenericBase<RealGradient> libMesh::FEVectorBase

Definition at line 676 of file fe_base.h.

typedef NumberVectorValue libMesh::Gradient

Definition at line 51 of file exact_error_estimator.h.

typedef double* libMesh::LPDOUBLE

Definition at line 39 of file mesh_smoother_vsmoother.h.

typedef int* libMesh::LPINT

Definition at line 44 of file mesh_smoother_vsmoother.h.

typedef LPDOUBLE* libMesh::LPLPDOUBLE

Definition at line 40 of file mesh_smoother_vsmoother.h.

typedef LPINT* libMesh::LPLPINT

Definition at line 45 of file mesh_smoother_vsmoother.h.

typedef LPLPDOUBLE* libMesh::LPLPLPDOUBLE

Definition at line 41 of file mesh_smoother_vsmoother.h.

typedef LPVOID* libMesh::LPLPVOID

Definition at line 43 of file mesh_smoother_vsmoother.h.

typedef void* libMesh::LPVOID

Definition at line 42 of file mesh_smoother_vsmoother.h.

typedef std::map<const Node *, Real, std::less<const Node *>, Threads::scalable_allocator<std::pair<const Node * const, Real> > > libMesh::NodeConstraintRow

A row of the Node constraint mapping. Currently this just stores the topology of the constrained Nodes, but for forward compatibility we also include coefficients, so we could add Lagrange-positioned-node constraints later.

Definition at line 110 of file dof_map.h.

typedef StoredRange<MeshBase::node_iterator, Node*> libMesh::NodeRange

Definition at line 33 of file node_range.h.

typedef Complex libMesh::Number

Definition at line 159 of file libmesh_common.h.

typedef TensorValue< Number > libMesh::NumberTensorValue

Definition at line 47 of file exact_error_estimator.h.

typedef VectorValue< Number > libMesh::NumberVectorValue

Definition at line 50 of file exact_error_estimator.h.

typedef dof_id_type libMesh::numeric_index_type

Definition at line 70 of file id_types.h.

typedef BasicOStreamProxy libMesh::OStreamProxy

Definition at line 239 of file ostream_proxy.h.

typedef int libMesh::PetscErrorCode

Definition at line 43 of file petsc_diff_solver.C.

typedef int libMesh::PetscInt

Definition at line 44 of file petsc_diff_solver.C.

typedef uint16_t libMesh::processor_id_type

Definition at line 77 of file id_types.h.

typedef Real libMesh::REAL

Definition at line 36 of file mesh_triangle_wrapper.h.

typedef RealVectorValue libMesh::RealGradient

Definition at line 50 of file hp_coarsentest.h.

typedef RealTensorValue libMesh::RealTensor

Definition at line 51 of file hp_coarsentest.h.

typedef TensorValue< Real > libMesh::RealTensorValue

Useful typedefs to allow transparent switching between Real and Complex data types.

Definition at line 49 of file hp_coarsentest.h.

typedef VectorValue< Real > libMesh::RealVectorValue

Useful typedefs to allow transparent switching between Real and Complex data types.

Definition at line 47 of file hp_coarsentest.h.

typedef DerivedRBConstruction<RBConstruction> libMesh::SteadyDerivedRBConstruction

Definition at line 173 of file derived_rb_construction.h.

typedef DerivedRBEvaluation<RBEvaluation> libMesh::SteadyDerivedRBEvaluation

Definition at line 117 of file derived_rb_evaluation.h.

typedef LinearImplicitSystem libMesh::SteadyLinearSystem

Definition at line 34 of file steady_system.h.

typedef uint16_t libMesh::subdomain_id_type

Note: subdomain_id_types are positive integers - however limitation in the exodusII API force us to use a signed integer here to represent subdomains. This gives us 2^31 possible unique blocks

Based on the 4-byte comment warning above, this probably doesn't work with exodusII *at all*...

Definition at line 43 of file id_types.h.

typedef NumberTensorValue libMesh::Tensor

Definition at line 49 of file exact_error_estimator.h.

typedef TransientSystem<System> libMesh::TransientBaseSystem

Definition at line 152 of file transient_system.h.

typedef TransientSystem<ExplicitSystem> libMesh::TransientExplicitSystem

Definition at line 151 of file transient_system.h.

typedef TransientSystem<LinearImplicitSystem> libMesh::TransientImplicitSystem

Definition at line 148 of file transient_system.h.

typedef TransientSystem<LinearImplicitSystem> libMesh::TransientLinearImplicitSystem

Definition at line 149 of file transient_system.h.

typedef TransientSystem<NonlinearImplicitSystem> libMesh::TransientNonlinearImplicitSystem

Definition at line 150 of file transient_system.h.

typedef unsigned int libMesh::uint

Definition at line 46 of file mesh_smoother_vsmoother.h.

Function Documentation

PetscErrorCode libMesh::__libmesh_petsc_diff_solver_jacobian	(	SNES	,
		Vec	x,
		Mat *	libmesh_dbg_varj,
		Mat *	pc,
		MatStructure *	msflag,
		void *	ctx
	)

Definition at line 112 of file petsc_diff_solver.C.

References libMesh::ImplicitSystem::assembly(), libMesh::PetscMatrix< T >::close(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::AutoPtr< Tp >::get(), libMesh::System::get_dof_map(), libMesh::ImplicitSystem::matrix, out, libMesh::System::solution, libMesh::PetscMatrix< T >::swap(), libMesh::DiffSolver::system(), libMesh::System::update(), and libMesh::DiffSolver::verbose.

Referenced by libMesh::PetscDiffSolver::solve().

00114 {
00115   libmesh_assert(x);
00116   libmesh_assert(j);
00117 //  libmesh_assert_equal_to (pc, j);  // We don't use separate preconditioners yet
00118   libmesh_assert(ctx);
00119 
00120   PetscDiffSolver& solver =
00121     *(static_cast<PetscDiffSolver*> (ctx));
00122   ImplicitSystem &sys = solver.system();
00123 
00124   if (solver.verbose)
00125     libMesh::out << "Assembling the Jacobian" << std::endl;
00126 
00127   PetscVector<Number>& X_system =
00128     *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
00129   PetscVector<Number> X_input(x);
00130 
00131   PetscMatrix<Number> J_input(*pc);
00132   PetscMatrix<Number>& J_system =
00133     *libmesh_cast_ptr<PetscMatrix<Number>*>(sys.matrix);
00134 
00135   // DiffSystem assembles from the solution and into the jacobian, so
00136   // swap those with our input vectors before assembling.  They'll
00137   // probably already be references to the same vectors, but PETSc
00138   // might do something tricky.
00139   X_input.swap(X_system);
00140   J_input.swap(J_system);
00141 
00142   // We may need to correct a non-conforming solution
00143   sys.get_dof_map().enforce_constraints_exactly(sys);
00144 
00145   // We may need to localize a parallel solution
00146   sys.update();
00147 
00148   // Do DiffSystem assembly
00149   sys.assembly(false, true);
00150   J_system.close();
00151 
00152   // Swap back
00153   X_input.swap(X_system);
00154   J_input.swap(J_system);
00155 
00156   *msflag = SAME_NONZERO_PATTERN;
00157 
00158   // No errors, we hope
00159   return 0;
00160 }

PetscErrorCode libMesh::__libmesh_petsc_diff_solver_monitor	(	SNES	,
		PetscInt	its,
		PetscReal	fnorm,
		void *	ctx
	)

Definition at line 50 of file petsc_diff_solver.C.

References out, and libMesh::DiffSolver::verbose.

Referenced by libMesh::PetscDiffSolver::init().

00052 {
00053   PetscDiffSolver& solver =
00054     *(static_cast<PetscDiffSolver*> (ctx));
00055 
00056   if (solver.verbose)
00057     libMesh::out << "  PetscDiffSolver step " << its
00058                  << ", |residual|_2 = " << fnorm << std::endl;
00059 
00060   return 0;
00061 }

PetscErrorCode libMesh::__libmesh_petsc_diff_solver_residual	(	SNES	,
		Vec	x,
		Vec	r,
		void *	ctx
	)

Definition at line 66 of file petsc_diff_solver.C.

References libMesh::ImplicitSystem::assembly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::AutoPtr< Tp >::get(), libMesh::System::get_dof_map(), out, libMesh::ExplicitSystem::rhs, libMesh::System::solution, libMesh::DiffSolver::system(), libMesh::System::update(), and libMesh::DiffSolver::verbose.

Referenced by libMesh::PetscDiffSolver::solve().

00067 {
00068   libmesh_assert(x);
00069   libmesh_assert(r);
00070   libmesh_assert(ctx);
00071 
00072   PetscDiffSolver& solver =
00073     *(static_cast<PetscDiffSolver*> (ctx));
00074   ImplicitSystem &sys = solver.system();
00075 
00076   if (solver.verbose)
00077     libMesh::out << "Assembling the residual" << std::endl;
00078 
00079   PetscVector<Number>& X_system =
00080     *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
00081   PetscVector<Number>& R_system =
00082     *libmesh_cast_ptr<PetscVector<Number>*>(sys.rhs);
00083   PetscVector<Number> X_input(x), R_input(r);
00084 
00085   // DiffSystem assembles from the solution and into the rhs, so swap
00086   // those with our input vectors before assembling.  They'll probably
00087   // already be references to the same vectors, but PETSc might do
00088   // something tricky.
00089   X_input.swap(X_system);
00090   R_input.swap(R_system);
00091 
00092   // We may need to correct a non-conforming solution
00093   sys.get_dof_map().enforce_constraints_exactly(sys);
00094 
00095   // We may need to localize a parallel solution
00096   sys.update();
00097 
00098   // Do DiffSystem assembly
00099   sys.assembly(true, false);
00100   R_system.close();
00101 
00102   // Swap back
00103   X_input.swap(X_system);
00104   R_input.swap(R_system);
00105 
00106   // No errors, we hope
00107   return 0;
00108 }

PetscErrorCode libMesh::__libmesh_petsc_preconditioner_apply	(	PC	pc,
		Vec	x,
		Vec	y
	)

Definition at line 91 of file petsc_linear_solver.C.

00092   {
00093     void *ctx;
00094     PetscErrorCode ierr = PCShellGetContext(pc,&ctx);CHKERRQ(ierr);
00095     Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);
00096 
00097     PetscVector<Number> x_vec(x);
00098     PetscVector<Number> y_vec(y);
00099 
00100     preconditioner->apply(x_vec,y_vec);
00101 
00102     return 0;
00103   }

PetscErrorCode libMesh::__libmesh_petsc_preconditioner_apply	(	void *	ctx,
		Vec	x,
		Vec	y
	)

This function is called by PETSc to acctually apply the preconditioner. ctx will hold the Preconditioner.

Definition at line 62 of file petsc_linear_solver.C.

Referenced by libMesh::PetscNonlinearSolver< T >::init(), and libMesh::PetscLinearSolver< T >::init().

00063   {
00064     Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);
00065 
00066     PetscVector<Number> x_vec(x);
00067     PetscVector<Number> y_vec(y);
00068 
00069     preconditioner->apply(x_vec,y_vec);
00070 
00071     return 0;
00072   }

PetscErrorCode libMesh::__libmesh_petsc_preconditioner_setup ( PC pc )

Definition at line 74 of file petsc_linear_solver.C.

References err.

00075   {
00076     void *ctx;
00077     PetscErrorCode ierr = PCShellGetContext(pc,&ctx);CHKERRQ(ierr);
00078     Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);
00079 
00080     if(!preconditioner->initialized())
00081     {
00082       err<<"Preconditioner not initialized!  Make sure you call init() before solve!"<<std::endl;
00083       libmesh_error();
00084     }
00085 
00086     preconditioner->setup();
00087 
00088     return 0;
00089   }

PetscErrorCode libMesh::__libmesh_petsc_preconditioner_setup ( void * ctx )

This function is called by PETSc to initialize the preconditioner. ctx will hold the Preconditioner.

Definition at line 46 of file petsc_linear_solver.C.

References err.

Referenced by libMesh::PetscNonlinearSolver< T >::init(), and libMesh::PetscLinearSolver< T >::init().

00047   {
00048     Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);
00049 
00050     if(!preconditioner->initialized())
00051     {
00052       err<<"Preconditioner not initialized!  Make sure you call init() before solve!"<<std::endl;
00053       libmesh_error();
00054     }
00055 
00056     preconditioner->setup();
00057 
00058     return 0;
00059   }

PetscErrorCode libMesh::__libmesh_petsc_snes_jacobian	(	SNES	snes,
		Vec	x,
		Mat *	jac,
		Mat *	pc,
		MatStructure *	msflag,
		void *	ctx
	)

Referenced by libMesh::PetscNonlinearSolver< T >::solve().

PetscErrorCode libMesh::__libmesh_petsc_snes_monitor	(	SNES	,
		PetscInt	its,
		PetscReal	fnorm,
		void *
	)

Referenced by libMesh::PetscNonlinearSolver< T >::init().

PetscErrorCode libMesh::__libmesh_petsc_snes_residual	(	SNES	snes,
		Vec	x,
		Vec	r,
		void *	ctx
	)

Referenced by libMesh::PetscNonlinearSolver< T >::solve().

void libMesh::_init	(	int &	argc,
		char **&	argv
	)

int libMesh::close ( )

Stop using the mesh library. This will call PetscFinalize() if PETSC is available. This method should be called after all other library objects have gone out of scope, as it interrogates the ReferenceCounter object to look for memory leaks.

libMesh::init() and libMesh::close() are a deprecated method of library initialization. Create a LibMeshInit object to begin using the library; when the LibMeshInit object is destroyed the library will be closed.

bool libMesh::closed ( )

Checks that the library has been closed. This should always return false when called from a library object. It is useful to libmesh_assert(!libMeshclosed()) in library object destructors.

Referenced by libMesh::MeshBase::~MeshBase(), libMesh::System::~System(), and libMesh::UnstructuredMesh::~UnstructuredMesh().

template<typename T >

T libMesh::command_line_value	(	const std::vector< std::string > &	,
		T
	)			`[inline]`

template<typename T >

T libMesh::command_line_value	(	const std::string &	,
		T
	)			`[inline]`

Returns:: the value associated with name on the command line if it is specified, otherwise return the default, provided value. A second template function is provided to support recognizing multiple variations of a given option

template double libMesh::command_line_value< double >	(	const std::string &	,
		double
	)

template float libMesh::command_line_value< float >	(	const std::string &	,
		float
	)

Type Constraints

template long double libMesh::command_line_value< long double >	(	const std::string &	,
		long	double
	)

template std::string libMesh::command_line_value< std::string >	(	const std::string &	,
		std::string
	)

template<typename T >

void libMesh::command_line_vector	(	const std::string &	,
		std::vector< T > &
	)			`[inline]`

Returns:: the array of values associated with name on the command line if it is specified, otherwise return the default, provided array.

template void libMesh::command_line_vector< double >	(	const std::string &	,
		std::vector< double > &
	)

template void libMesh::command_line_vector< float >	(	const std::string &	,
		std::vector< float > &
	)

template void libMesh::command_line_vector< int >	(	const std::string &	,
		std::vector< int > &
	)

template void libMesh::command_line_vector< long double >	(	const std::string &	,
		std::vector< long double > &
	)

SolverPackage libMesh::default_solver_package ( )

Returns:: the default solver interface to use. The value depends on which solver packages were available when the library was configured. The command-line is also checked, allowing the user to override the compiled default. For example, --use-petsc will force the use of PETSc solvers, and --use-laspack will force the use of LASPACK solvers.

std::string libMesh::demangle ( const char * name )

Definition at line 124 of file print_trace.C.

Referenced by libMesh::Parameters::get(), process_trace(), and libMesh::Parameters::Parameter< T >::type().

00124 { return std::string(name); }

std::string libMesh::get_io_compatibility_version ( )

Specifier for I/O file compatibility features. This only needs to be changed when new restart file functionality is added.

Definition at line 77 of file libmesh_version.C.

Referenced by libMesh::EquationSystems::write().

00078 {
00079   std::string retval(LIBMESH_IO_COMPATIBILITY_VERSION);
00080   return retval;
00081 }

int libMesh::get_libmesh_version ( )

Definition at line 43 of file libmesh_version.C.

Referenced by libmesh_version_stdout().

00044 {
00045   /* Note: return format follows the versioning convention xx.yy.zz where
00046    
00047      xx = major version number
00048      yy = minor version number
00049      zz = micro version number
00050      
00051      For example:
00052      v.   0.23  -> 002300 = 2300
00053      v   0.23.1 -> 002301 = 2301
00054      v. 10.23.2 -> 102302         */
00055 
00056     int major_version = 0;
00057     int minor_version = 0;
00058     int micro_version = 0;
00059 
00060 #ifdef LIBMESH_MAJOR_VERSION
00061     major_version = LIBMESH_MAJOR_VERSION;
00062 #endif
00063 
00064 #ifdef LIBMESH_MINOR_VERSION
00065     minor_version = LIBMESH_MINOR_VERSION;
00066 #endif
00067 
00068 #ifdef LIBMESH_MICRO_VERSION
00069     micro_version = LIBMESH_MICRO_VERSION;
00070 #endif
00071 
00072     return major_version*10000 + minor_version*100 + micro_version;
00073 }

const Number libMesh::imaginary	(	0.	,
		1.
	)

void libMesh::init	(	int &	argc,
		char **&	argv,
		MPI_Comm	COMM_WORLD_IN = `MPI_COMM_WORLD`
	)

Initialize the library for use. This will call PetscInitialize if PETSC is available. This method takes an optional parameter

You must perform an initialization before using any of the library functionality, but libMesh::init() is a deprecated way to do so. Create a LibMeshInit object instead.

void libMesh::init	(	int &	argc,
		char **&	argv
	)

Initialize the library for use. This will call PetscInitialize if PETSC is available.

You must perform an initialization before using any of the library functionality, but libMesh::init() is a deprecated way to do so. Create a LibMeshInit object instead.

Referenced by libMesh::TriangleInterface::triangulate().

bool libMesh::initialized ( )

Checks that library initialization has been done. If it hasn't an error message is printed and the code aborts. It is useful to libmesh_assert(libMesh::initialized()) in library object constructors.

Referenced by libMesh::MeshBase::MeshBase(), and libMesh::UnstructuredMesh::UnstructuredMesh().

libMesh::INSTANTIATE_ALL_MAPS ( 3 )

libMesh::INSTANTIATE_ALL_MAPS ( 2 )

libMesh::INSTANTIATE_ALL_MAPS ( 1 )

libMesh::INSTANTIATE_ALL_MAPS ( 0 )

libMesh::INSTANTIATE_FE ( 3 )

libMesh::INSTANTIATE_FE ( 2 )

libMesh::INSTANTIATE_FE ( 1 )

libMesh::INSTANTIATE_FE ( 0 )

libMesh::INSTANTIATE_INF_FE	(	3	,
		CARTESIAN
	)

Collect all 3D explicit instantiations for class InfFE

libMesh::INSTANTIATE_INF_FE	(	2	,
		CARTESIAN
	)

Collect all 2D explicit instantiations for class InfFE

libMesh::INSTANTIATE_INF_FE	(	1	,
		CARTESIAN
	)

Collect all 1D explicit instantiations for class InfFE

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		void	,
		nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		void	,
		nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		void	,
		nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		void	,
		compute_data(const FEType &, const Elem *, FEComputeData &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		void	,
		compute_data(const FEType &, const Elem *, FEComputeData &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		void	,
		compute_data(const FEType &, const Elem *, FEComputeData &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		Real	,
		shape(const FEType &, const ElemType, const unsigned int, const Point &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		Real	,
		shape(const FEType &, const ElemType, const unsigned int, const Point &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		Real	,
		shape(const FEType &, const ElemType, const unsigned int, const Point &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		Real	,
		shape(const FEType &, const Elem *, const unsigned int, const Point &p)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		Real	,
		shape(const FEType &, const Elem *, const unsigned int, const Point &p)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		Real	,
		shape(const FEType &, const Elem *, const unsigned int, const Point &p)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		void	,
		compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		void	,
		compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		void	,
		compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		void	,
		compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		void	,
		compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		void	,
		compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		unsigned	int,
		n_dofs_at_node(const FEType &, const ElemType, const unsigned int)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		unsigned	int,
		n_dofs_at_node(const FEType &, const ElemType, const unsigned int)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		unsigned	int,
		n_dofs_at_node(const FEType &, const ElemType, const unsigned int)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		unsigned	int,
		n_dofs_per_elem(const FEType &, const ElemType)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		unsigned	int,
		n_dofs_per_elem(const FEType &, const ElemType)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		unsigned	int,
		n_dofs_per_elem(const FEType &, const ElemType)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		unsigned	int,
		n_dofs(const FEType &, const ElemType)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		unsigned	int,
		n_dofs(const FEType &, const ElemType)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		unsigned	int,
		n_dofs(const FEType &, const ElemType)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		void	,
		inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		void	,
		inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		void	,
		inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		Point	,
		inverse_map(const Elem *, const Point &, const Real, const bool, const bool)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		Point	,
		inverse_map(const Elem *, const Point &, const Real, const bool, const bool)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		Point	,
		inverse_map(const Elem *, const Point &, const Real, const bool, const bool)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		void	,
		init_face_shape_functions(const std::vector< Point > &, const Elem *)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		void	,
		init_face_shape_functions(const std::vector< Point > &, const Elem *)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		void	,
		init_face_shape_functions(const std::vector< Point > &, const Elem *)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		void	,
		edge_reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		void	,
		edge_reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		void	,
		edge_reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		void	,
		reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		void	,
		reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		void	,
		reinit(const Elem , const unsigned int, const Real, const std::vector< Point > const, const std::vector< Real > *const)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		unsigned	int,
		Radial::	n_dofs_at_nodeconst Order, const unsigned int
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		unsigned	int,
		Radial::	n_dofs_at_nodeconst Order, const unsigned int
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		unsigned	int,
		Radial::	n_dofs_at_nodeconst Order, const unsigned int
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		unsigned	int,
		Base::	n_base_mapping_sfconst ElemType, const Order
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		unsigned	int,
		Base::	n_base_mapping_sfconst ElemType, const Order
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		unsigned	int,
		Base::	n_base_mapping_sfconst ElemType, const Order
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		ElemType	,
		Base::	get_elem_typeconst ElemType type
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		ElemType	,
		Base::	get_elem_typeconst ElemType type
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		ElemType	,
		Base::	get_elem_typeconst ElemType type
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		Elem *	,
		Base::	build_elemconst Elem *
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		Elem *	,
		Base::	build_elemconst Elem *
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		Elem *	,
		Base::	build_elemconst Elem *
	)

bool libMesh::is_between	(	Real	min,
		Real	check,
		Real	max
	)

Definition at line 237 of file mesh_tools.C.

Referenced by libMesh::MeshTools::BoundingBox::contains_point(), and libMesh::MeshTools::BoundingBox::intersect().

00238 {
00239   return min <= check && check <= max;
00240 }

template<typename Tnew , typename Told >

Tnew libMesh::libmesh_cast_int ( Told oldvar ) [inline]

Definition at line 359 of file libmesh_common.h.

00360 {
00361   libmesh_assert_equal_to
00362     (oldvar, static_cast<Told>(static_cast<Tnew>(oldvar)));
00363 
00364   return(static_cast<Tnew>(oldvar));
00365 }

template<typename Tnew , typename Told >

Tnew libMesh::libmesh_cast_ptr ( Told * oldvar ) [inline]

Definition at line 330 of file libmesh_common.h.

References err, and libMesh::Quality::name().

Referenced by libMesh::Parameters::have_parameter().

00331 {
00332 #if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI)
00333   Tnew newvar = dynamic_cast<Tnew>(oldvar);
00334   if (!newvar)
00335     {
00336       libMesh::err << "Failed to convert " << typeid(Told).name()
00337                    << " pointer to " << typeid(Tnew).name()
00338                    << std::endl;
00339       libMesh::err << "The " << typeid(Told).name()
00340                    << " appears to be a "
00341                    << typeid(*oldvar).name() << std::endl;
00342       libmesh_error();
00343     }
00344   return newvar;
00345 #else
00346   return(static_cast<Tnew>(oldvar));
00347 #endif
00348 }

template<typename Tnew , typename Told >

Tnew libMesh::libmesh_cast_ref ( Told & oldvar ) [inline]

Definition at line 304 of file libmesh_common.h.

References err, and libMesh::Quality::name().

00305 {
00306 #if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI)
00307   try
00308     {
00309       Tnew newvar = dynamic_cast<Tnew>(oldvar);
00310       return newvar;
00311     }
00312   catch (std::bad_cast)
00313     {
00314       libMesh::err << "Failed to convert " << typeid(Told).name()
00315                    << " reference to " << typeid(Tnew).name()
00316                    << std::endl;
00317       libMesh::err << "The " << typeid(Told).name()
00318                    << " appears to be a "
00319                    << typeid(*(&oldvar)).name() << std::endl;
00320       libmesh_error();
00321     }
00322 #else
00323   return(static_cast<Tnew>(oldvar));
00324 #endif
00325 }

template<typename T >

std::complex<T> libMesh::libmesh_conj ( std::complex< T > a ) [inline]

Definition at line 143 of file libmesh_common.h.

00143 { return std::conj(a); }

template<typename T >

T libMesh::libmesh_conj ( T a ) [inline]

Definition at line 137 of file libmesh_common.h.

Referenced by libMesh::DenseVector< T >::dot().

00137 { return a; }

template<class T >

void libMesh::libmesh_ignore ( const T & ) [inline]

Definition at line 396 of file libmesh_common.h.

00396 { }

template<typename T >

bool libMesh::libmesh_isnan ( std::complex< T > a ) [inline]

Definition at line 152 of file libmesh_common.h.

References libmesh_isnan().

00152 { return (libmesh_isnan(std::real(a)) || libmesh_isnan(std::imag(a))); }

bool libMesh::libmesh_isnan ( long double a ) [inline]

Definition at line 149 of file libmesh_common.h.

References libmesh_C_isnan_longdouble().

00149 { return libmesh_C_isnan_longdouble(a); }

bool libMesh::libmesh_isnan ( double a ) [inline]

Definition at line 148 of file libmesh_common.h.

References libmesh_C_isnan_double().

00148 { return libmesh_C_isnan_double(a); }

bool libMesh::libmesh_isnan ( float a ) [inline]

Definition at line 147 of file libmesh_common.h.

References libmesh_C_isnan_float().

Referenced by libmesh_isnan(), libMesh::NewtonSolver::line_search(), and libMesh::NewtonSolver::solve().

00147 { return libmesh_C_isnan_float(a); }

template<typename T >

T libMesh::libmesh_real ( std::complex< T > a ) [inline]

Definition at line 140 of file libmesh_common.h.

00140 { return std::real(a); }

template<typename T >

T libMesh::libmesh_real ( T a ) [inline]

Definition at line 136 of file libmesh_common.h.

Referenced by libMesh::FEMContext::_do_elem_position_set(), libMesh::ContinuationSystem::continuation_solve(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::LaspackVector< T >::max(), libMesh::DistributedVector< T >::max(), libMesh::DenseVector< T >::max(), libMesh::DenseMatrix< T >::max(), libMesh::LaspackVector< T >::min(), libMesh::DistributedVector< T >::min(), libMesh::DenseVector< T >::min(), libMesh::DenseMatrix< T >::min(), libMesh::FEMSystem::numerical_jacobian(), libMesh::ContinuationSystem::solve_tangent(), libMesh::GmshIO::write_post(), libMesh::EnsightIO::write_scalar_ascii(), and libMesh::EnsightIO::write_vector_ascii().

00136 { return a; }

void libMesh::libmesh_terminate_handler ( )

Definition at line 294 of file libmesh.C.

References old_terminate_handler.

00295 {
00296   // If this got called then we're probably crashing; let's print a
00297   // stack trace.
00298   libmesh_write_traceout();
00299 
00300   // The system terminate_handler may do useful things like printing
00301   // uncaught exception information, or the user may have created
00302   // their own terminate handler that we want to call.
00303   old_terminate_handler();
00304 }

void libMesh::libmesh_version_stdout ( )

Definition at line 20 of file libmesh_version.C.

References get_libmesh_version().

00021 {
00022   std::cout << "--------------------------------------------------------" << std::endl;
00023   std::cout << "libMesh Library: Version = " << LIBMESH_LIB_VERSION;
00024   std::cout << " (" << get_libmesh_version() << ")" << std::endl << std::endl;
00025 
00026   std::cout << LIBMESH_LIB_RELEASE << std::endl << std::endl;
00027 
00028   std::cout << "Build Date   = " << LIBMESH_BUILD_DATE     << std::endl;
00029   std::cout << "Build Host   = " << LIBMESH_BUILD_HOST     << std::endl;
00030   std::cout << "Build User   = " << LIBMESH_BUILD_USER     << std::endl;
00031   std::cout << "Build Arch   = " << LIBMESH_BUILD_ARCH     << std::endl;
00032   std::cout << "Build Rev    = " << LIBMESH_BUILD_VERSION  << std::endl << std::endl;
00033 
00034   // CXXFLAGS is ambiguous wth multiple methods - could add all three but why not libmesh-config?
00035   //std::cout << "C++ Config   = " << LIBMESH_CXX << " " << LIBMESH_CXXFLAGS << std::endl;
00036   std::cout << "--------------------------------------------------------" << std::endl;
00037 
00038   return;
00039 }

template void libMesh::MeshCommunication::find_global_indices< MeshBase::const_element_iterator >	(	const MeshTools::BoundingBox &	,
		const MeshBase::const_element_iterator &	,
		const MeshBase::const_element_iterator &	,
		std::vector< dof_id_type > &
	)			const

template void libMesh::MeshCommunication::find_global_indices< MeshBase::const_node_iterator >	(	const MeshTools::BoundingBox &	,
		const MeshBase::const_node_iterator &	,
		const MeshBase::const_node_iterator &	,
		std::vector< dof_id_type > &
	)			const

template void libMesh::MeshCommunication::find_global_indices< MeshBase::element_iterator >	(	const MeshTools::BoundingBox &	,
		const MeshBase::element_iterator &	,
		const MeshBase::element_iterator &	,
		std::vector< dof_id_type > &
	)			const

template void libMesh::MeshCommunication::find_global_indices< MeshBase::node_iterator >	(	const MeshTools::BoundingBox &	,
		const MeshBase::node_iterator &	,
		const MeshBase::node_iterator &	,
		std::vector< dof_id_type > &
	)			const

libMesh::processor_id_type libMesh::n_processors ( ) [inline]

Returns:: the number of processors used in the current simulation.

Definition at line 74 of file libmesh_base.h.

References libMesh::libMeshPrivateData::_n_processors.

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::ParallelMesh::add_elem(), libMesh::ParallelMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Parallel::Communicator::barrier(), libMesh::AztecLinearSolver< T >::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshCommunication::find_global_indices(), libMesh::PerfLog::get_info_header(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EquationSystems::init(), libMesh::DistributedVector< T >::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::PetscVector< T >::localize(), libMesh::EpetraVector< T >::localize_to_one(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::DofMap::print_dof_constraints(), libMesh::MeshTools::processor_bounding_box(), libMesh::Elem::PackedElem::processor_id(), libMesh::System::project_vector(), libMesh::Nemesis_IO::read(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::ParallelMesh::renumber_dof_objects(), libMesh::DofMap::scatter_constraints(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscPreconditioner< T >::set_petsc_preconditioner_type(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_dofobject_data_by_xyz(), libMesh::Parallel::unpack(), libMesh::Node::PackedNode::unpack(), libMesh::ParallelMesh::update_parallel_id_counts(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), and libMesh::XdrIO::write_serialized_nodes().

00075 {
00076 #ifdef LIBMESH_HAVE_MPI
00077   return libMeshPrivateData::_n_processors;
00078 #else
00079   return 1;
00080 #endif
00081 }

unsigned int libMesh::n_threads ( ) [inline]

Returns:: the maximum number of threads used in the simulation.

Definition at line 99 of file libmesh_base.h.

References libMesh::libMeshPrivateData::_n_threads.

Referenced by libMesh::FEMContext::_do_elem_position_set(), libMesh::FEMContext::elem_position_get(), libMesh::FEMContext::elem_reinit(), libMesh::MeshBase::get_info(), libMesh::FE< Dim, T >::shape(), libMesh::FE< Dim, T >::shape_deriv(), and libMesh::FE< Dim, T >::shape_second_deriv().

00100 {
00101   return static_cast<unsigned int>(libMeshPrivateData::_n_threads);
00102 }

bool libMesh::on_command_line ( const std::string & arg )

Returns:: true if the argument arg was specified on the command line, false otherwise.

Referenced by libMesh::NonlinearSolver< T >::build(), libMesh::DofMap::distribute_dofs(), libMesh::System::read_header(), and libMesh::DofMap::use_coupled_neighbor_dofs().

template<typename T , typename Scalar >

boostcopy::enable_if_c< ScalarTraits<Scalar>::value, TypeVector<typename CompareTypes<T, Scalar>::supertype> >::type libMesh::operator*	(	const Scalar	factor,
		const TypeVector< T > &	v
	)			`[inline]`

Definition at line 679 of file type_vector.h.

00681 {
00682   return v * factor;
00683 }

template<typename T , typename Scalar >

boostcopy::enable_if_c< ScalarTraits<Scalar>::value, TypeTensor<typename CompareTypes<T, Scalar>::supertype> >::type libMesh::operator*	(	const Scalar	factor,
		const TypeTensor< T > &	t
	)			`[inline]`

Definition at line 869 of file type_tensor.h.

00871 {
00872   return t * factor;
00873 }

template<typename T >

std::ostream & libMesh::operator<<	(	std::ostream &	os,
		const SparseMatrix< T > &	m
	)			`[inline]`

Definition at line 431 of file sparse_matrix.h.

00432 {
00433   m.print(os);
00434   return os;
00435 }

std::ostream& libMesh::operator<<	(	std::ostream &	os,
		const Parameters &	p
	)			`[inline]`

Definition at line 403 of file parameters.h.

References libMesh::Parameters::print().

00404 {
00405   p.print(os);
00406   return os;
00407 }

std::ostream& libMesh::operator<<	(	std::ostream &	os,
		const Node &	n
	)			`[inline]`

Definition at line 237 of file node.h.

References libMesh::Node::print_info().

00238 {
00239   n.print_info(os);
00240   return os;
00241 }

std::ostream& libMesh::operator<<	(	std::ostream &	os,
		const Elem &	e
	)			`[inline]`

Definition at line 1251 of file elem.h.

References libMesh::Elem::print_info().

01252 {
01253   e.print_info(os);
01254   return os;
01255 }

std::ostream& libMesh::operator<<	(	std::ostream &	os,
		const EquationSystems &	es
	)

Definition at line 1179 of file equation_systems.C.

References libMesh::EquationSystems::print_info().

01180 {
01181   es.print_info(os);
01182   return os;
01183 }

std::ostream& libMesh::operator<<	(	std::ostream &	os,
		const QBase &	q
	)

Definition at line 197 of file quadrature.C.

References libMesh::QBase::print_info().

00198 {
00199   q.print_info(os);
00200   return os;
00201 }

std::ostream& libMesh::operator<<	(	std::ostream &	os,
		const MeshData &	m
	)

Definition at line 377 of file mesh_data.C.

References libMesh::MeshData::print_info().

00378 {
00379   m.print_info(os);
00380   return os;
00381 }

std::ostream& libMesh::operator<<	(	std::ostream &	os,
		const MeshBase &	m
	)

Definition at line 301 of file mesh_base.C.

References libMesh::MeshBase::print_info().

00302 {
00303   m.print_info(os);
00304   return os;
00305 }

std::ostream& libMesh::operator<<	(	std::ostream &	os,
		const FEAbstract &	fe
	)

Definition at line 867 of file fe_abstract.C.

References libMesh::FEAbstract::print_info().

00868 {
00869   fe.print_info(os);
00870   return os;
00871 }

void libMesh::PetscDMGetSystem	(	DM	,
		NonlinearImplicitSystem *&
	)

void libMesh::PetscDMRegister ( )

Referenced by libMesh::PetscDMNonlinearSolver< T >::PetscDMNonlinearSolver().

void libMesh::PetscDMSetSystem	(	DM	,
		NonlinearImplicitSystem &
	)

template<typename P >

void libMesh::print_helper	(	std::ostream &	os,
		const std::vector< P > *	param
	)			`[inline]`

Definition at line 545 of file parameters.h.

00546 {
00547   for (unsigned int i=0; i<param->size(); ++i)
00548     os << (*param)[i] << " ";
00549 }

template<typename P >

void libMesh::print_helper	(	std::ostream &	os,
		const P *	param
	)			`[inline]`

Helper functions for printing scalar and vector types. Called from Parameters::Parameter<T>::print(...).

Definition at line 538 of file parameters.h.

Referenced by libMesh::Parameters::Parameter< T >::print().

00539 {
00540   os << *param;
00541 }

void libMesh::print_trace ( std::ostream & out )

Definition at line 122 of file print_trace.C.

00122 {}

std::string libMesh::process_trace ( const char * name )

The Apple backtrace function returns more information than the Linux version. We need to pass only the function name to the demangler or it won't decode it for us.

lineno: stackframeno address functionname + offset

Definition at line 42 of file print_trace.C.

References demangle().

00043 {
00044   std::string fullname = name;
00045   std::string saved_begin, saved_end;
00046   size_t namestart, nameend;
00047 
00055 #ifdef __APPLE__
00056   namestart = fullname.find("0x");
00057   if (namestart != std::string::npos)
00058   {
00059     namestart = fullname.find(' ', namestart) + 1;
00060     saved_begin = fullname.substr(0, namestart);
00061   }
00062   else
00063     namestart = 0;
00064   nameend = fullname.find('+');
00065   if (nameend == std::string::npos ||
00066       nameend <= namestart)
00067     nameend = fullname.size();
00068   else
00069   {
00070     nameend -= 1;
00071     saved_end = fullname.substr(nameend, fullname.length());
00072   }
00073 #else
00074   namestart = fullname.find('(');
00075   if (namestart == std::string::npos)
00076     return fullname;
00077   else
00078     namestart++;
00079   nameend = fullname.find('+');
00080   if (nameend == std::string::npos ||
00081       nameend <= namestart)
00082     return fullname;
00083 #endif
00084 
00085   std::string type_name = fullname.substr(namestart, nameend - namestart);
00086 
00087   // Try to demangle now
00088   return saved_begin + demangle(type_name.c_str()) + saved_end;
00089 }

libMesh::processor_id_type libMesh::processor_id ( ) [inline]

Returns:: the index of the local processor.

Definition at line 86 of file libmesh_base.h.

References libMesh::libMeshPrivateData::_processor_id.

00087 {
00088 #ifdef LIBMESH_HAVE_MPI
00089   return libMeshPrivateData::_processor_id;
00090 #else
00091   return 0;
00092 #endif
00093 }

libMesh::REINIT_ERROR	(	REINIT_ERROR(	0,
		REINIT_ERROR(	CLOUGH,
		reinit
	)

Definition at line 74 of file fe_boundary.C.

References libMesh::Elem::build_side(), std::max(), libMesh::Elem::neighbor(), libMesh::Elem::p_level(), side, and libMesh::Elem::type().

00143 {
00144   libmesh_assert(elem);
00145   libmesh_assert (this->qrule != NULL || pts != NULL);
00146   // We now do this for 1D elements!
00147   // libmesh_assert_not_equal_to (Dim, 1);
00148 
00149   // Build the side of interest
00150   const AutoPtr<Elem> side(elem->build_side(s));
00151 
00152   // Find the max p_level to select
00153   // the right quadrature rule for side integration
00154   unsigned int side_p_level = elem->p_level();
00155   if (elem->neighbor(s) != NULL)
00156     side_p_level = std::max(side_p_level, elem->neighbor(s)->p_level());
00157 
00158   // Initialize the shape functions at the user-specified
00159   // points
00160   if (pts != NULL)
00161     {
00162       // The shape functions do not correspond to the qrule
00163       this->shapes_on_quadrature = false;
00164 
00165       // Initialize the face shape functions
00166       this->_fe_map->template init_face_shape_functions<Dim>(*pts, side.get());
00167 
00168       // Compute the Jacobian*Weight on the face for integration
00169       if (weights != NULL)
00170         {
00171           this->_fe_map->compute_face_map (Dim, *weights, side.get());
00172         }
00173       else
00174         {
00175           std::vector<Real> dummy_weights (pts->size(), 1.);
00176           this->_fe_map->compute_face_map (Dim, dummy_weights, side.get());
00177         }
00178     }
00179   // If there are no user specified points, we use the
00180   // quadrature rule
00181   else
00182     {
00183       // initialize quadrature rule
00184       this->qrule->init(side->type(), side_p_level);
00185 
00186       if(this->qrule->shapes_need_reinit())
00187         this->shapes_on_quadrature = false;
00188 
00189       // FIXME - could this break if the same FE object was used
00190       // for both volume and face integrals? - RHS
00191       // We might not need to reinitialize the shape functions
00192       if ((this->get_type() != elem->type())    ||
00193           (side->type() != last_side)           ||
00194           (this->get_p_level() != side_p_level) ||
00195           this->shapes_need_reinit()            ||
00196           !this->shapes_on_quadrature)
00197         {
00198           // Set the element type and p_level
00199           this->elem_type = elem->type();
00200 
00201           // Set the last_side
00202           last_side = side->type();
00203 
00204           // Set the last p level
00205           this->_p_level = side_p_level;
00206 
00207           // Initialize the face shape functions
00208           this->_fe_map->template init_face_shape_functions<Dim>(this->qrule->get_points(),  side.get());
00209         }
00210 
00211       // Compute the Jacobian*Weight on the face for integration
00212       this->_fe_map->compute_face_map (Dim, this->qrule->get_weights(), side.get());
00213 
00214       // The shape functions correspond to the qrule
00215       this->shapes_on_quadrature = true;
00216     }
00217 
00218   // make a copy of the Jacobian for integration
00219   const std::vector<Real> JxW_int(this->_fe_map->get_JxW());
00220 
00221   // make a copy of shape on quadrature info
00222   bool shapes_on_quadrature_side = this->shapes_on_quadrature;
00223 
00224   // Find where the integration points are located on the
00225   // full element.
00226   const std::vector<Point>* ref_qp;
00227   if (pts != NULL)
00228     ref_qp = pts;
00229   else
00230     ref_qp = &this->qrule->get_points();
00231 
00232   std::vector<Point> qp;
00233   this->side_map(elem, side.get(), s, *ref_qp, qp);
00234 
00235   // compute the shape function and derivative values
00236   // at the points qp
00237   this->reinit  (elem, &qp);
00238 
00239   this->shapes_on_quadrature = shapes_on_quadrature_side;
00240 
00241   // copy back old data
00242   this->_fe_map->get_JxW() = JxW_int;
00243 }

libMesh::ScalarTraits_true ( double )

libMesh::ScalarTraits_true ( float )

libMesh::ScalarTraits_true ( unsigned char )

libMesh::ScalarTraits_true ( long )

libMesh::ScalarTraits_true ( int )

libMesh::ScalarTraits_true ( short )

libMesh::ScalarTraits_true ( char )

template<typename T >

T libMesh::SIGN	(	T	a,
		T	b
	)			`[inline]`

Definition at line 33 of file newton_solver.C.

References std::abs().

Referenced by libMesh::NewtonSolver::line_search().

00034 {
00035   return b >= 0 ? std::abs(a) : -std::abs(a);
00036 }

libMesh::SUPERTYPE	(	double	,
		long	double
	)

libMesh::SUPERTYPE	(	float	,
		long	double
	)

libMesh::SUPERTYPE	(	float	,
		double
	)

libMesh::SUPERTYPE	(	int	,
		long	double
	)

libMesh::SUPERTYPE	(	int	,
		double
	)

libMesh::SUPERTYPE	(	int	,
		float
	)

libMesh::SUPERTYPE	(	short	,
		long	double
	)

libMesh::SUPERTYPE	(	short	,
		double
	)

libMesh::SUPERTYPE	(	short	,
		float
	)

libMesh::SUPERTYPE	(	short	,
		int
	)

libMesh::SUPERTYPE	(	char	,
		long	double
	)

libMesh::SUPERTYPE	(	char	,
		double
	)

libMesh::SUPERTYPE	(	char	,
		float
	)

libMesh::SUPERTYPE	(	char	,
		int
	)

libMesh::SUPERTYPE	(	char	,
		short
	)

libMesh::SUPERTYPE	(	unsigned	char,
		long	double
	)

libMesh::SUPERTYPE	(	unsigned	char,
		double
	)

libMesh::SUPERTYPE	(	unsigned	char,
		float
	)

libMesh::SUPERTYPE	(	unsigned	char,
		int
	)

libMesh::SUPERTYPE	(	unsigned	char,
		short
	)

template void libMesh::Xdr::data< std::complex< double > >	(	std::complex< double > &	,
		const char *
	)

template void libMesh::Xdr::data< std::complex< float > >	(	std::complex< float > &	,
		const char *
	)

template void libMesh::Xdr::data< std::complex< long double > >	(	std::complex< long double > &	,
		const char *
	)

template void libMesh::Xdr::data< std::string >	(	std::string &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< char > >	(	std::vector< char > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< double > >	(	std::vector< double > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< float > >	(	std::vector< float > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< int > >	(	std::vector< int > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< long double > >	(	std::vector< long double > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< long int > >	(	std::vector< long int > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< short int > >	(	std::vector< short int > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< signed char > >	(	std::vector< signed char > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< std::complex< double > > >	(	std::vector< std::complex< double > > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< std::complex< float > > >	(	std::vector< std::complex< float > > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< std::complex< long double > > >	(	std::vector< std::complex< long double > > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< unsigned char > >	(	std::vector< unsigned char > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< unsigned int > >	(	std::vector< unsigned int > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< unsigned long int > >	(	std::vector< unsigned long int > &	,
		const char *
	)

template void libMesh::Xdr::data< std::vector< unsigned short int > >	(	std::vector< unsigned short int > &	,
		const char *
	)

Variable Documentation

void char** & libMesh::argv

Definition at line 312 of file libmesh.C.

int libMesh::COMM_WORLD = MPI_COMM_NULL

MPI Communicator to be used in the library.

Something to use with CHKERRABORT if we're just using PETSc's MPI "uni" stub.

Definition at line 214 of file libmesh.C.

Parallel::Communicator libMesh::CommWorld

The default libMesh communicator

Definition at line 219 of file libmesh.C.

const unsigned char libMesh::cube_number_column

Definition at line 85 of file number_lookups.C.

const unsigned char libMesh::cube_number_page

Definition at line 309 of file number_lookups.C.

const unsigned char libMesh::cube_number_row

Definition at line 197 of file number_lookups.C.

OStreamProxy libMesh::err

Definition at line 195 of file libmesh_common.h.

DIE A HORRIBLE DEATH HERE typedef float libMesh::ErrorVectorReal

Definition at line 170 of file libmesh_common.h.

Referenced by libMesh::JumpErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::ErrorVector::minimum(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), and libMesh::HPCoarsenTest::select_refinement().

const Number libMesh::imaginary

The imaginary unit, $\sqrt{-1}$ .

libMesh::INVALID_SOLVER_PACKAGE

Definition at line 270 of file libmesh.C.

const unsigned int libMesh::invalid_uint = static_cast<unsigned int>(-1)

A number which is used quite often to represent an invalid or uninitialized value.

Definition at line 190 of file libmesh.h.

Referenced by libMesh::FEMContext::_do_elem_position_set(), libMesh::SFCPartitioner::_do_partition(), libMesh::InfFE< Dim, T_radial, T_map >::compute_node_indices_fast(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_indices(), libMesh::UnstructuredMesh::create_submesh(), libMesh::Xdr::data_stream(), libMesh::DofMap::dof_indices(), libMesh::FEMContext::elem_position_get(), libMesh::TreeNode< N >::find_element_in_children(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::Elem::get_node_index(), libMesh::DofObject::has_dofs(), libMesh::MeshTools::Generation::Private::idx(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_flags(), libMesh::Elem::local_node(), libMesh::FEMSystem::mesh_position_get(), libMesh::DofObject::n_dofs(), libMesh::Quad9::n_second_order_adjacent_vertices(), libMesh::InfHex18::n_second_order_adjacent_vertices(), libMesh::Hex27::n_second_order_adjacent_vertices(), libMesh::FEMSystem::numerical_jacobian(), libMesh::DofMap::old_dof_indices(), libMesh::XdrIO::pack_element(), libMesh::MeshDataUnvHeader::read(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::Elem::which_child_am_i(), libMesh::Elem::which_neighbor_am_i(), libMesh::Elem::which_side_am_i(), and libMesh::System::write_serialized_blocked_dof_objects().

libMesh::LASPACK_SOLVERS

Definition at line 268 of file libmesh.C.

Referenced by libMesh::SparseMatrix< T >::build(), libMesh::NumericVector< T >::build(), and libMesh::LinearSolver< T >::build().

MPI_Errhandler libMesh::libmesh_errhandler

Definition at line 255 of file libmesh.C.

const unsigned int libMesh::MIN_ELEM_PER_PROC = 4

Definition at line 52 of file parmetis_partitioner.C.

Referenced by libMesh::ParmetisPartitioner::_do_repartition().

std::terminate_handler libMesh::old_terminate_handler

Definition at line 292 of file libmesh.C.

Referenced by libmesh_terminate_handler().

OStreamProxy libMesh::out

Definition at line 194 of file libmesh_common.h.

PerfLog libMesh::perflog

A PerfLog object to log performance. If the library is configured with --enable-perflog then it will log key functions.

Definition at line 39 of file libmesh_logging.h.

PetscBool libMesh::PetscDMRegistered = PETSC_FALSE

Definition at line 42 of file petsc_dm_nonlinear_solver.C.

const Real libMesh::pi

Initial value:

    static_cast<Real>(3.1415926535897932384626433832795029L)

$\pi=3.14159...$ .

Definition at line 178 of file libmesh.h.

Referenced by libMesh::MeshTools::Generation::build_cube(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::Tri3::min_and_max_angle(), libMesh::TriangleInterface::PolygonHole::point(), libMesh::VariationalMeshSmoother::readgr(), libMesh::MeshTools::Modification::rotate(), and libMesh::Sphere::surface_coords().

DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE libMesh::Real

Definition at line 106 of file libmesh_common.h.

const RemoteElem * libMesh::remote_elem

Definition at line 28 of file remote_elem.C.

Referenced by libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::add_child(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::Elem::coarsen(), libMesh::FEAbstract::compute_node_constraints(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::Elem::family_tree_by_neighbor(), libMesh::Elem::family_tree_by_subneighbor(), libMesh::Elem::find_edge_neighbors(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::find_point_neighbors(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_node_pointers(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::nullify_neighbors(), libMesh::Parallel::unpack(), and libMesh::Elem::PackedElem::unpack().

const unsigned char libMesh::square_number_column

Initial value:

 {
0,
0, 1, 1,
0, 1, 2, 2, 2,
0, 1, 2, 3, 3, 3, 3,
0, 1, 2, 3, 4, 4, 4, 4, 4,
0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5,
0, 1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 6, 6,
0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7,
0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9
}

Definition at line 57 of file number_lookups.C.

Referenced by libMesh::FE< Dim, T >::shape(), and libMesh::FE< Dim, T >::shape_deriv().

const unsigned char libMesh::square_number_row

Initial value:

 {
 0,
 1, 1, 0,
 2, 2, 2, 1, 0,
 3, 3, 3, 3, 2, 1, 0,
 4, 4, 4, 4, 4, 3, 2, 1, 0,
 5, 5, 5, 5, 5, 5, 4, 3, 2, 1, 0,
 6, 6, 6, 6, 6, 6, 6, 5, 4, 3, 2, 1, 0,
 7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0,
 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 6, 5, 4, 3, 2, 1, 0,
 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
}

Definition at line 70 of file number_lookups.C.

Referenced by libMesh::FE< Dim, T >::shape(), and libMesh::FE< Dim, T >::shape_deriv().

static const Real libMesh::TOLERANCE = 1.e-8 [static]

Definition at line 114 of file libmesh_common.h.

Referenced by libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), libMesh::ImplicitSystem::assemble_residual_derivatives(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::Elem::contains_point(), libMesh::EquationSystems::EquationSystems(), libMesh::MemorySolutionHistory::find_stored_entry(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::LocationMap< T >::key(), libMesh::BoundaryProjectSolution::operator()(), libMesh::ProjectFEMSolution::operator()(), libMesh::ProjectSolution::operator()(), libMesh::TypeTensor< T >::operator==(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::Elem::refine(), libMesh::MemorySolutionHistory::retrieve(), libMesh::NewtonSolver::solve(), libMesh::MemorySolutionHistory::store(), libMesh::Edge3::volume(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

const unsigned char libMesh::triangular_number_column

Initial value:

 {
 0,
 0, 1,
 0, 1, 2,
 0, 1, 2, 3,
 0, 1, 2, 3, 4,
 0, 1, 2, 3, 4, 5,
 0, 1, 2, 3, 4, 5, 6,
 0, 1, 2, 3, 4, 5, 6, 7,
 0, 1, 2, 3, 4, 5, 6, 7, 8,
 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
}

Definition at line 42 of file number_lookups.C.

Referenced by libMesh::FE< Dim, T >::shape().

const unsigned char libMesh::triangular_number_row

Initial value:

 {
 0,
 1, 1,
 2, 2, 2,
 3, 3, 3, 3,
 4, 4, 4, 4, 4,
 5, 5, 5, 5, 5, 5,
 6, 6, 6, 6, 6, 6, 6,
 7, 7, 7, 7, 7, 7, 7, 7,
 8, 8, 8, 8, 8, 8, 8, 8, 8,
 9, 9, 9, 9, 9, 9, 9, 9, 9, 9
}

Definition at line 29 of file number_lookups.C.

Referenced by libMesh::FE< Dim, T >::shape().

libMesh::TRILINOS_SOLVERS

Definition at line 266 of file libmesh.C.

Referenced by libMesh::SparseMatrix< T >::build(), libMesh::Preconditioner< T >::build(), libMesh::NumericVector< T >::build(), libMesh::NonlinearSolver< T >::build(), and libMesh::LinearSolver< T >::build().