libMesh Namespace Reference

Namespaces
namespace	boostcopy
namespace	DenseMatrices
namespace	ElementTypes
namespace	exII
namespace	FiniteElements
namespace	libMeshPrivateData
namespace	MacroFunctions
namespace	MeshTools
namespace	Nemesis
namespace	Parallel
namespace	Predicates
namespace	QuadratureRules
namespace	Quality
namespace	ReferenceElem
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	Pyramid13
class	Pyramid14
class	Pyramid5
class	Tet
class	Tet10
class	Tet4
class	CentroidPartitioner
class	CheckpointIO
struct	TypesEqual
struct	TypesEqual< T, T >
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	CompositeFEMFunction
class	CompositeFunction
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	DGFEMContext
class	DiffContext
class	DifferentiablePhysics
class	DifferentiableQoI
class	LinearSolutionMonitor
class	DiffSolver
class	DifferentiableSystem
class	DirectSolutionTransfer
class	DirichletBoundary
class	DirichletBoundaries
class	DiscontinuityMeasure
class	DistributedVector
class	DivaIO
class	DofConstraints
class	DofConstraintValueMap
class	AdjointDofConstraintValues
class	NodeConstraints
class	DofMap
class	DofObject
class	DTKAdapter
class	DTKEvaluator
class	DTKSolutionTransfer
class	Edge
class	Edge2
class	Edge3
class	Edge4
class	InfEdge2
class	EigenPreconditioner
class	EigenSolver
class	EigenSparseLinearSolver
class	EigenSparseMatrix
class	EigenSparseVector
class	EigenSystem
class	EigenTimeSolver
class	Elem
class	ElemAssembly
class	ElemCutter
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	Tri3Subdivision
class	Tri6
class	Factory
class	FactoryImp
struct	FEOutputType
struct	FEOutputType< LAGRANGE_VEC >
struct	FEOutputType< NEDELEC_ONE >
class	FE
class	FEClough
class	FEHermite
class	FESubdivision
class	FEHierarchic
class	FEL2Hierarchic
class	FELagrange
class	FEL2Lagrange
class	FEMonomial
class	FEScalar
class	FEXYZ
class	FELagrangeVec
class	FENedelecOne
class	FEAbstract
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	Singleton
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	METIS_CSR_Graph
class	MetisPartitioner
class	MortonSFCPartitioner
class	NameBasedIO
class	Nemesis_IO
class	Nemesis_IO_Helper
class	NewmarkSystem
class	NewtonSolver
class	NoSolutionHistory
class	Node
class	NodeElem
class	NonlinearImplicitSystem
class	NonlinearSolver
struct	null_output_iterator
class	NumericVector
class	OFFIO
class	BasicOStreamProxy
struct	SyncNodalPositions
class	ParallelMesh
class	ParallelObject
class	ParameterAccessor
class	ParameterProxy
class	ConstParameterProxy
class	ParameterPointer
class	ParameterVector
class	Parameters
class	ParmetisPartitioner
class	ParsedFEMFunction
class	ParsedFunction
class	Partitioner
class	Patch
class	PatchRecoveryErrorEstimator
class	PerfData
class	PerfLog
class	PerfMon
class	PeriodicBoundaries
class	PeriodicBoundary
class	PeriodicBoundaryBase
class	PetscDiffSolver
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	QComposite
class	QConical
class	QGauss
class	QGaussLobatto
class	QGrundmann_Moller
class	QGrid
class	QJacobi
class	QMonomial
class	QSimpson
class	QTrap
class	WendlandRBF
class	RadialBasisInterpolation
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	vectormap
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 int32_t	eigen_idx_type
typedef Eigen::SparseMatrix < Number, Eigen::RowMajor, eigen_idx_type >	EigenSM
typedef Eigen::Matrix< Number, Eigen::Dynamic, 1 >	EigenSV
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 uint8_t	unique_id_type
typedef dof_id_type	numeric_index_type
typedef uint8_t	processor_id_type
typedef uint64_t	largest_id_type
typedef std::complex< Real >	Complex
typedef std::complex< Real >	COMPLEX
typedef Real	Number
typedef ParallelMesh	DefaultMesh
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
Enumerations
enum	LinearConvergenceReason {   CONVERGED_RTOL_NORMAL = 1, CONVERGED_ATOL_NORMAL = 9, CONVERGED_RTOL = 2, CONVERGED_ATOL = 3,   CONVERGED_ITS = 4, CONVERGED_CG_NEG_CURVE = 5, CONVERGED_CG_CONSTRAINED = 6, CONVERGED_STEP_LENGTH = 7,   CONVERGED_HAPPY_BREAKDOWN = 8, DIVERGED_NULL = -2, DIVERGED_ITS = -3, DIVERGED_DTOL = -4,   DIVERGED_BREAKDOWN = -5, DIVERGED_BREAKDOWN_BICG = -6, DIVERGED_NONSYMMETRIC = -7, DIVERGED_INDEFINITE_PC = -8,   DIVERGED_NAN = -9, DIVERGED_INDEFINITE_MAT = -10, CONVERGED_ITERATING = 0, UNKNOWN_FLAG = -128 }
enum	EigenSolverType {   POWER = 0, LAPACK, SUBSPACE, ARNOLDI,   LANCZOS, KRYLOVSCHUR, INVALID_EIGENSOLVER }
enum	EigenProblemType {   NHEP = 0, HEP, GNHEP, GHEP,   GHIEP, INVALID_EIGENPROBLEMTYPE }
enum	PositionOfSpectrum {   LARGEST_MAGNITUDE = 0, SMALLEST_MAGNITUDE, LARGEST_REAL, SMALLEST_REAL,   LARGEST_IMAGINARY, SMALLEST_IMAGINARY, INVALID_Postion_of_Spectrum }
enum	ElemQuality {   ASPECT_RATIO = 0, SKEW, SHEAR, SHAPE,   MAX_ANGLE, MIN_ANGLE, CONDITION, DISTORTION,   TAPER, WARP, STRETCH, DIAGONAL,   ASPECT_RATIO_BETA, ASPECT_RATIO_GAMMA, SIZE, JACOBIAN }
enum	ElemType {   EDGE2 = 0, EDGE3, EDGE4, TRI3,   TRI6, QUAD4, QUAD8, QUAD9,   TET4, TET10, HEX8, HEX20,   HEX27, PRISM6, PRISM15, PRISM18,   PYRAMID5, PYRAMID13, PYRAMID14, INFEDGE2,   INFQUAD4, INFQUAD6, INFHEX8, INFHEX16,   INFHEX18, INFPRISM6, INFPRISM12, NODEELEM,   REMOTEELEM, TRI3SUBDIVISION, INVALID_ELEM }
enum	FEFamily {   LAGRANGE = 0, HIERARCHIC = 1, MONOMIAL = 2, L2_HIERARCHIC = 6,   L2_LAGRANGE = 7, BERNSTEIN = 3, SZABAB = 4, XYZ = 5,   INFINITE_MAP = 11, JACOBI_20_00 = 12, JACOBI_30_00 = 13, LEGENDRE = 14,   CLOUGH = 21, HERMITE = 22, SUBDIVISION = 23, SCALAR = 31,   LAGRANGE_VEC = 41, NEDELEC_ONE = 42, INVALID_FE = 99 }
enum	FEContinuity { DISCONTINUOUS, C_ZERO, C_ONE, H_CURL }
enum	FEFieldType { TYPE_SCALAR = 0, TYPE_VECTOR }
enum	InfMapType { CARTESIAN = 0, SPHERICAL, ELLIPSOIDAL, INVALID_INF_MAP }
enum	IOPackage {   TECPLOT, GMV, GMSH, VTK,   DIVA, TETGEN, UCD, LIBMESH,   INVALID_IO_PACKAGE }
enum	FEMNormType {   L2 = 0, H1 = 1, H2 = 2, HCURL = 3,   HDIV = 4, L1 = 5, L_INF = 6, H1_SEMINORM = 10,   H2_SEMINORM = 11, HCURL_SEMINORM = 12, HDIV_SEMINORM = 13, W1_INF_SEMINORM = 15,   W2_INF_SEMINORM = 16, DISCRETE_L1 = 20, DISCRETE_L2 = 21, DISCRETE_L_INF = 22,   H1_X_SEMINORM = 31, H1_Y_SEMINORM = 32, H1_Z_SEMINORM = 33, INVALID_NORM = 42 }
enum	Order {   CONSTANT = 0, FIRST = 1, SECOND = 2, THIRD = 3,   FOURTH = 4, FIFTH = 5, SIXTH = 6, SEVENTH = 7,   EIGHTH = 8, NINTH = 9, TENTH = 10, ELEVENTH = 11,   TWELFTH = 12, THIRTEENTH = 13, FOURTEENTH = 14, FIFTEENTH = 15,   SIXTEENTH = 16, SEVENTEENTH = 17, EIGHTTEENTH = 18, NINTEENTH = 19,   NINETEENTH = 19, TWENTIETH = 20, TWENTYFIRST = 21, TWENTYSECOND = 22,   TWENTYTHIRD = 23, TWENTYFOURTH = 24, TWENTYFIFTH = 25, TWENTYSIXTH = 26,   TWENTYSEVENTH = 27, TWENTYEIGHTH = 28, TWENTYNINTH = 29, THIRTIETH = 30,   THIRTYFIRST = 31, THIRTYSECOND = 32, THIRTYTHIRD = 33, THIRTYFOURTH = 34,   THIRTYFIFTH = 35, THIRTYSIXTH = 36, THIRTYSEVENTH = 37, THIRTYEIGHTH = 38,   THIRTYNINTH = 39, FORTIETH = 40, FORTYFIRST = 41, FORTYSECOND = 42,   FORTYTHIRD = 43, INVALID_ORDER }
enum	ParallelType {   AUTOMATIC = 0, SERIAL, PARALLEL, GHOSTED,   INVALID_PARALLELIZATION }
enum	PointLocatorType {   TREE = 0, TREE_ELEMENTS, TREE_LOCAL_ELEMENTS, LIST,   INVALID_LOCATOR }
enum	PreconditionerType {   IDENTITY_PRECOND = 0, JACOBI_PRECOND, BLOCK_JACOBI_PRECOND, SOR_PRECOND,   SSOR_PRECOND, EISENSTAT_PRECOND, ASM_PRECOND, CHOLESKY_PRECOND,   ICC_PRECOND, ILU_PRECOND, LU_PRECOND, USER_PRECOND,   SHELL_PRECOND, AMG_PRECOND, INVALID_PRECONDITIONER }
enum	QuadratureType {   QGAUSS = 0, QJACOBI_1_0 = 1, QJACOBI_2_0 = 2, QSIMPSON = 3,   QTRAP = 4, QGRID = 5, QGRUNDMANN_MOLLER = 6, QMONOMIAL = 7,   QCONICAL = 8, QGAUSS_LOBATTO = 9, QCLOUGH = 21, QCOMPOSITE = 31,   INVALID_Q_RULE = 127 }
enum	SolverPackage { PETSC_SOLVERS = 0, SLEPC_SOLVERS }
enum	SolverType {   CG = 0, CGN, CGS, CR,   QMR, TCQMR, TFQMR, BICG,   BICGSTAB, MINRES, GMRES, LSQR,   JACOBI, SOR_FORWARD, SOR_BACKWARD, SSOR,   RICHARDSON, CHEBYSHEV, INVALID_SOLVER }
enum	SubsetSolveMode { SUBSET_ZERO = 0, SUBSET_COPY_RHS, SUBSET_DONT_TOUCH }
enum	XdrMODE {   UNKNOWN = -1, ENCODE = 0, DECODE, WRITE,   READ }
Functions
bool	warned_about_auto_ptr (false)
const Number	imaginary (0., 1.)
bool	initialized ()
bool	closed ()
void	libmesh_terminate_handler ()
void	enableFPE (bool on)
void	enableSEGV (bool on)
bool	on_command_line (const std::string &arg)
template<typename T >
T	command_line_value (const std::string &name, T value)
template<typename T >
T	command_line_value (const std::vector< std::string > &name, T value)
template<typename T >
T	command_line_next (const std::string &name, T value)
template<typename T >
void	command_line_vector (const std::string &name, std::vector< T > &vec)
SolverPackage	default_solver_package ()
template int	command_line_value< int > (const std::string &, int)
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 int	command_line_next< int > (const std::string &, int)
template float	command_line_next< float > (const std::string &, float)
template double	command_line_next< double > (const std::string &, double)
template long double	command_line_next< long double > (const std::string &, long double)
template std::string	command_line_next< 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 > &)
void	print_trace (std::ostream &out_stream)
void	write_traceout ()
std::string	demangle (const char *name)
	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 Parallel::Communicator &, 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 Parallel::Communicator &, 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 Parallel::Communicator &, 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 Parallel::Communicator &, 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)
	LIBMESH_VMA_INSTANTIATE (Real, int, Real)
	LIBMESH_VMA_INSTANTIATE (Real, float, Real)
	LIBMESH_VMA_INSTANTIATE (Real, double, Real)
	LIBMESH_VMA_INSTANTIATE (Real, int, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, int, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, int, Real)
	LIBMESH_VMA_INSTANTIATE (Real, float, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, float, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, float, Real)
	LIBMESH_VMA_INSTANTIATE (Real, std::complex< float >, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, std::complex< float >, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, std::complex< float >, Real)
	LIBMESH_VMA_INSTANTIATE (Real, double, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, double, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, double, Real)
	LIBMESH_VMA_INSTANTIATE (Real, std::complex< double >, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, std::complex< double >, Complex)
	LIBMESH_VMA_INSTANTIATE (Complex, std::complex< double >, Real)
std::ostream &	operator<< (std::ostream &os, const QBase &q)
template<typename T >
T	SIGN (T a, T b)
void	petsc_auto_fieldsplit (PC my_pc, const System &sys)
PetscErrorCode	__libmesh_petsc_diff_solver_monitor (SNES 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) PetscErrorCode __libmesh_petsc_diff_solver_jacobian(SNES
PetscErrorCode Vec Mat	libmesh_dbg_var (j)
PetscErrorCode Vec Mat Mat void *ctx	libmesh_assert (x)
	libmesh_assert (j)
	libmesh_assert (ctx)
PetscVector< Number >	X_input (x, sys.comm())
PetscMatrix< Number > J_input *	pc ()
PetscMatrix< Number >	J_input (pc, sys.comm())
X_input	swap (X_system)
J_input	swap (J_system)
sys	get_dof_map ()
DiffSolver::SolveResult	convert_solve_result (SNESConvergedReason r)
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) PetscErrorCode __libmesh_petsc_snes_jacobian(SNES snes
PetscErrorCode Vec Mat Mat void *ctx	START_LOG ("jacobian()","PetscNonlinearSolver")
PetscMatrix< Number > Jac *	jac ()
PetscMatrix< Number >	PC (pc, sys.comm())
PetscMatrix< Number >	Jac (jac, sys.comm())
PetscVector< Number >	X_global (x, sys.comm())
PC	attach_dof_map (sys.get_dof_map())
X_global	swap (X_sys)
Jac	swap (Jac_sys)
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< unsigned long long > > (std::vector< unsigned long long > &, 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 *)
template void	Xdr::data< std::vector< std::string > > (std::vector< std::string > &, 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)
processor_id_type	n_processors ()
processor_id_type	processor_id ()
processor_id_type	global_n_processors ()
processor_id_type	global_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<class T >
void	libmesh_ignore (const T &)
template<typename Tnew , typename Told >
Tnew	cast_ref (Told &oldvar)
template<typename Tnew , typename Told >
Tnew	libmesh_cast_ref (Told &oldvar)
template<typename Tnew , typename Told >
Tnew	cast_ptr (Told *oldvar)
template<typename Tnew , typename Told >
Tnew	libmesh_cast_ptr (Told *oldvar)
template<typename Tnew , typename Told >
Tnew	cast_int (Told oldvar)
template<typename Tnew , typename Told >
Tnew	libmesh_cast_int (Told oldvar)
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)
PetscErrorCode	__libmesh_petsc_snes_jacobian (SNES, Vec x, Mat jac, Mat pc, void *ctx)
	static_assert (sizeof(PetscInt)==sizeof(numeric_index_type),"PETSc and libMesh integer sizes must match!")
PetscInt *	numeric_petsc_cast (const numeric_index_type *p)
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
MPI_Comm	GLOBAL_COMM_WORLD = MPI_COMM_NULL
Parallel::FakeCommunicator	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
	EIGEN_SOLVERS
	LASPACK_SOLVERS
	INVALID_SOLVER_PACKAGE
std::terminate_handler	old_terminate_handler
	INSTANTIATE_SUBDIVISION_FE
	INSTANTIATE_SUBDIVISION_MAPS
const RemoteElem *	remote_elem
const unsigned int	MIN_ELEM_PER_PROC = 4
PetscErrorCode Vec	x
PetscErrorCode Vec Mat Mat	pc
PetscDiffSolver &	solver
ImplicitSystem &	sys = solver.system()
if(solver.verbose) libMesh PetscVector< Number > &	X_system
PetscMatrix< Number > &	J_system
PetscErrorCode Vec Mat	jac
PetscErrorCode	ierr = 0
PetscVector< Number > &	X_sys = *cast_ptr<PetscVector<Number>*>(sys.solution.get())
PetscMatrix< Number > &	Jac_sys = *cast_ptr<PetscMatrix<Number>*>(sys.matrix)
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
bool	warned_about_auto_ptr

---

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 51 of file id_types.h.

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

Definition at line 152 of file libmesh_common.h.

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

Definition at line 153 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 64 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 87 of file dof_map.h.

typedef int32_t libMesh::eigen_idx_type

Definition at line 59 of file eigen_core_support.h.

typedef Eigen::SparseMatrix<Number, Eigen::RowMajor, eigen_idx_type> libMesh::EigenSM

Definition at line 71 of file eigen_core_support.h.

typedef Eigen::Matrix<Number, Eigen::Dynamic, 1> libMesh::EigenSV

Definition at line 72 of file eigen_core_support.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 37 of file exact_error_estimator.h.

typedef FEGenericBase<RealGradient> libMesh::FEVectorBase

Definition at line 664 of file fe_base.h.

typedef NumberVectorValue libMesh::Gradient

Definition at line 52 of file exact_error_estimator.h.

typedef uint8_t libMesh::largest_id_type

Definition at line 138 of file id_types.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 135 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 181 of file libmesh_common.h.

typedef TensorValue< Number > libMesh::NumberTensorValue

Definition at line 48 of file exact_error_estimator.h.

typedef VectorValue< Number > libMesh::NumberVectorValue

Definition at line 51 of file exact_error_estimator.h.

typedef dof_id_type libMesh::numeric_index_type

Definition at line 92 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 44 of file petsc_diff_solver.C.

typedef int libMesh::PetscInt

Definition at line 45 of file petsc_diff_solver.C.

typedef uint16_t libMesh::processor_id_type

Definition at line 99 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 174 of file derived_rb_construction.h.

typedef DerivedRBEvaluation<RBEvaluation> libMesh::SteadyDerivedRBEvaluation

Definition at line 118 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 50 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 uint64_t libMesh::unique_id_type

Definition at line 79 of file id_types.h.

---

Enumeration Type Documentation

enum libMesh::EigenProblemType

Defines an enum for eigenproblem types. This can be Hermitian (HEP), generalized Hermitian (GHEP), non-Hermitian (NHEP), generalized non-Hermitian (GNHEP), or generalized indefinite Hermitian (GHIEP).

Enumerator:

NHEP
HEP
GNHEP
GHEP
GHIEP
INVALID_EIGENPROBLEMTYPE

Definition at line 51 of file enum_eigen_solver_type.h.

                      {NHEP=0,
                       HEP,
                       GNHEP,
                       GHEP,
                       GHIEP,

                       INVALID_EIGENPROBLEMTYPE};

enum libMesh::EigenSolverType

Defines an enum for iterative eigenproblem solver types

Enumerator:

POWER
LAPACK
SUBSPACE
ARNOLDI
LANCZOS
KRYLOVSCHUR
INVALID_EIGENSOLVER

Definition at line 30 of file enum_eigen_solver_type.h.

                     {POWER=0,
                      LAPACK,
                      SUBSPACE,
                      ARNOLDI,
                      LANCZOS,
                      KRYLOVSCHUR,
                      // SLEPc optional packages
                      // EPSARPACK,
                      // EPSLAPACK,
                      // EPSBLZPACK,
                      // EPSPLANSO,
                      // EPSTRLAN,

                      INVALID_EIGENSOLVER};

enum libMesh::ElemQuality

Defines an enum for element quality metrics.

Enumerator:

ASPECT_RATIO
SKEW
SHEAR
SHAPE
MAX_ANGLE
MIN_ANGLE
CONDITION
DISTORTION
TAPER
WARP
STRETCH
DIAGONAL
ASPECT_RATIO_BETA
ASPECT_RATIO_GAMMA
SIZE
JACOBIAN

Definition at line 30 of file enum_elem_quality.h.

                 {ASPECT_RATIO=0,
                  SKEW,
                  SHEAR,
                  SHAPE,
                  MAX_ANGLE,
                  MIN_ANGLE,
                  CONDITION,
                  DISTORTION,
                  TAPER,
                  WARP,
                  STRETCH,
                  DIAGONAL,
                  ASPECT_RATIO_BETA,
                  ASPECT_RATIO_GAMMA,
                  SIZE,
                  JACOBIAN};

enum libMesh::ElemType

Defines an enum for geometric element types.

Enumerator:

EDGE2
EDGE3
EDGE4
TRI3
TRI6
QUAD4
QUAD8
QUAD9
TET4
TET10
HEX8
HEX20
HEX27
PRISM6
PRISM15
PRISM18
PYRAMID5
PYRAMID13
PYRAMID14
INFEDGE2
INFQUAD4
INFQUAD6
INFHEX8
INFHEX16
INFHEX18
INFPRISM6
INFPRISM12
NODEELEM
REMOTEELEM
TRI3SUBDIVISION
INVALID_ELEM

Definition at line 30 of file enum_elem_type.h.

              {EDGE2=0,         // 0
               EDGE3,           // 1
               EDGE4,           // 2

               TRI3,            // 3
               TRI6,            // 4

               QUAD4,           // 5
               QUAD8,           // 6
               QUAD9,           // 7

               TET4,            // 8
               TET10,           // 9

               HEX8,            // 10
               HEX20,           // 11
               HEX27,           // 12

               PRISM6,          // 13
               PRISM15,         // 14
               PRISM18,         // 15

               PYRAMID5,        // 16
               PYRAMID13,       // 17
               PYRAMID14,       // 18

               INFEDGE2,        // 19

               INFQUAD4,        // 20
               INFQUAD6,        // 21

               INFHEX8,         // 22
               INFHEX16,        // 23
               INFHEX18,        // 24

               INFPRISM6,       // 25
               INFPRISM12,      // 26

               NODEELEM,        // 27

               REMOTEELEM,      // 28

               TRI3SUBDIVISION, // 29

               INVALID_ELEM};   // 30 - should always be last

enum libMesh::FEContinuity

defines an enum for finite element types to libmesh_assert a certain level (or type? Hcurl?) of continuity.

Enumerator:

DISCONTINUOUS
C_ZERO
C_ONE
H_CURL

Definition at line 72 of file enum_fe_family.h.

                  {DISCONTINUOUS,
                   C_ZERO,
                   C_ONE,
                   H_CURL};

enum libMesh::FEFamily

defines an enum for finite element families.

Enumerator:

LAGRANGE
HIERARCHIC
MONOMIAL
L2_HIERARCHIC
L2_LAGRANGE
BERNSTEIN
SZABAB
XYZ
INFINITE_MAP
JACOBI_20_00
JACOBI_30_00
LEGENDRE
CLOUGH
HERMITE
SUBDIVISION
SCALAR
LAGRANGE_VEC
NEDELEC_ONE
INVALID_FE

Definition at line 32 of file enum_fe_family.h.

              {LAGRANGE     = 0,
               HIERARCHIC   = 1,

               // discontinuous, in local coordinates
               MONOMIAL      = 2,
               L2_HIERARCHIC = 6,
               L2_LAGRANGE   = 7,

               // higher-order
               BERNSTEIN    = 3,
               SZABAB       = 4,

               // discontinuous, in global coordinates
               XYZ          = 5,

               // infinite element stuff
               INFINITE_MAP = 11,     //   for 1/r-map
               JACOBI_20_00 = 12,     //   i_max = 19
               JACOBI_30_00 = 13,     //   i_max = 19
               LEGENDRE     = 14,     //   i_max = 19

               // C1 elements
               CLOUGH       = 21,
               HERMITE      = 22,
               SUBDIVISION  = 23,

               // A scalar variable that couples to
               // all other DOFs in the system
               SCALAR       = 31,

               // Vector-valued elements
               LAGRANGE_VEC = 41,
               NEDELEC_ONE  = 42,

               INVALID_FE   = 99};

enum libMesh::FEFieldType

defines an enum for finite element field types - i.e. is it a scalar element, vector, tensor, etc.

Enumerator:

TYPE_SCALAR
TYPE_VECTOR

Definition at line 81 of file enum_fe_family.h.

                 {TYPE_SCALAR = 0,
                  TYPE_VECTOR};

enum libMesh::FEMNormType

defines an enum for norms defined on vectors of finite element coefficients

Enumerator:

L2
H1
H2
HCURL
HDIV
L1
L_INF
H1_SEMINORM
H2_SEMINORM
HCURL_SEMINORM
HDIV_SEMINORM
W1_INF_SEMINORM
W2_INF_SEMINORM
DISCRETE_L1
DISCRETE_L2
DISCRETE_L_INF
H1_X_SEMINORM
H1_Y_SEMINORM
H1_Z_SEMINORM
INVALID_NORM

Definition at line 32 of file enum_norm_type.h.

                 {L2              = 0,
                  H1              = 1,
                  H2              = 2,
                  HCURL           = 3,
                  HDIV            = 4,

                  L1              = 5,
                  L_INF           = 6,

                  H1_SEMINORM     = 10,

                  H2_SEMINORM     = 11,

                  HCURL_SEMINORM  = 12,

                  HDIV_SEMINORM   = 13,

                  W1_INF_SEMINORM = 15,
                  W2_INF_SEMINORM = 16,

                  // discrete norms on coefficient vectors
                  DISCRETE_L1     = 20,
                  DISCRETE_L2     = 21,
                  DISCRETE_L_INF  = 22,

                  // Seminorms based on only individual gradient
                  // directional components
                  H1_X_SEMINORM    = 31,
                  H1_Y_SEMINORM    = 32,
                  H1_Z_SEMINORM    = 33,

                  INVALID_NORM    = 42};

enum libMesh::InfMapType

defines an enum for the types of coordinate mappings available in infinite elements.

Enumerator:

CARTESIAN
SPHERICAL
ELLIPSOIDAL
INVALID_INF_MAP

Definition at line 31 of file enum_inf_map_type.h.

                {CARTESIAN=0,
                 SPHERICAL,
                 ELLIPSOIDAL,
                 INVALID_INF_MAP};

enum libMesh::IOPackage

libMesh interfaces with several different software packages for the purposes of creating, reading, and writing mesh files. These enumerations give an easy way of selecting one or the other.

Enumerator:

TECPLOT
GMV
GMSH
VTK
DIVA
TETGEN
UCD
LIBMESH
INVALID_IO_PACKAGE

Definition at line 34 of file enum_io_package.h.

  {
    TECPLOT,
    GMV,
    GMSH,
    VTK,
    DIVA,
    TETGEN,
    UCD,
    LIBMESH,
    INVALID_IO_PACKAGE
  };

enum libMesh::LinearConvergenceReason

Linear solver convergence flags (taken from the PETSc flags)

Enumerator:

CONVERGED_RTOL_NORMAL
CONVERGED_ATOL_NORMAL
CONVERGED_RTOL
CONVERGED_ATOL
CONVERGED_ITS
CONVERGED_CG_NEG_CURVE
CONVERGED_CG_CONSTRAINED
CONVERGED_STEP_LENGTH
CONVERGED_HAPPY_BREAKDOWN
DIVERGED_NULL
DIVERGED_ITS
DIVERGED_DTOL
DIVERGED_BREAKDOWN
DIVERGED_BREAKDOWN_BICG
DIVERGED_NONSYMMETRIC
DIVERGED_INDEFINITE_PC
DIVERGED_NAN
DIVERGED_INDEFINITE_MAT
CONVERGED_ITERATING
UNKNOWN_FLAG

Definition at line 30 of file enum_convergence_flags.h.

                             {
  /* converged */
  CONVERGED_RTOL_NORMAL        =  1,
  CONVERGED_ATOL_NORMAL        =  9,
  CONVERGED_RTOL               =  2,
  CONVERGED_ATOL               =  3,
  CONVERGED_ITS                =  4,
  CONVERGED_CG_NEG_CURVE       =  5,
  CONVERGED_CG_CONSTRAINED     =  6,
  CONVERGED_STEP_LENGTH        =  7,
  CONVERGED_HAPPY_BREAKDOWN    =  8,
  /* diverged */
  DIVERGED_NULL                = -2,
  DIVERGED_ITS                 = -3,
  DIVERGED_DTOL                = -4,
  DIVERGED_BREAKDOWN           = -5,
  DIVERGED_BREAKDOWN_BICG      = -6,
  DIVERGED_NONSYMMETRIC        = -7,
  DIVERGED_INDEFINITE_PC       = -8,
  DIVERGED_NAN                 = -9,
  DIVERGED_INDEFINITE_MAT      = -10,

  CONVERGED_ITERATING          =  0,

  UNKNOWN_FLAG                 = -128};

enum libMesh::Order

defines an enum for polynomial orders. Fixing each label to a specific int, since InfFE and p refinement may cast between them

Enumerator:

CONSTANT
FIRST
SECOND
THIRD
FOURTH
FIFTH
SIXTH
SEVENTH
EIGHTH
NINTH
TENTH
ELEVENTH
TWELFTH
THIRTEENTH
FOURTEENTH
FIFTEENTH
SIXTEENTH
SEVENTEENTH
EIGHTTEENTH
NINTEENTH
NINETEENTH
TWENTIETH
TWENTYFIRST
TWENTYSECOND
TWENTYTHIRD
TWENTYFOURTH
TWENTYFIFTH
TWENTYSIXTH
TWENTYSEVENTH
TWENTYEIGHTH
TWENTYNINTH
THIRTIETH
THIRTYFIRST
THIRTYSECOND
THIRTYTHIRD
THIRTYFOURTH
THIRTYFIFTH
THIRTYSIXTH
THIRTYSEVENTH
THIRTYEIGHTH
THIRTYNINTH
FORTIETH
FORTYFIRST
FORTYSECOND
FORTYTHIRD
INVALID_ORDER

Definition at line 32 of file enum_order.h.

           {CONSTANT     =  0,
            FIRST        =  1,
            SECOND       =  2,
            THIRD        =  3,
            FOURTH       =  4,
            FIFTH        =  5,
            SIXTH        =  6,
            SEVENTH      =  7,
            EIGHTH       =  8,
            NINTH        =  9,
            TENTH        = 10,

            ELEVENTH     = 11,
            TWELFTH      = 12,
            THIRTEENTH   = 13,
            FOURTEENTH   = 14,
            FIFTEENTH    = 15,
            SIXTEENTH    = 16,
            SEVENTEENTH  = 17,
            EIGHTTEENTH  = 18,
            NINTEENTH    = 19, // deprecated
            NINETEENTH   = 19,
            TWENTIETH    = 20,

            TWENTYFIRST   = 21,
            TWENTYSECOND  = 22,
            TWENTYTHIRD   = 23,
            TWENTYFOURTH  = 24,
            TWENTYFIFTH   = 25,
            TWENTYSIXTH   = 26,
            TWENTYSEVENTH = 27,
            TWENTYEIGHTH  = 28,
            TWENTYNINTH   = 29,
            THIRTIETH     = 30,

            THIRTYFIRST   = 31,
            THIRTYSECOND  = 32,
            THIRTYTHIRD   = 33,
            THIRTYFOURTH  = 34,
            THIRTYFIFTH   = 35,
            THIRTYSIXTH   = 36,
            THIRTYSEVENTH = 37,
            THIRTYEIGHTH  = 38,
            THIRTYNINTH   = 39,
            FORTIETH     = 40,

            FORTYFIRST   = 41,
            FORTYSECOND  = 42,
            FORTYTHIRD   = 43,

            INVALID_ORDER};

enum libMesh::ParallelType

Defines an enum for parallel data structure types

Enumerator:

AUTOMATIC
SERIAL
PARALLEL
GHOSTED
INVALID_PARALLELIZATION

Definition at line 30 of file enum_parallel_type.h.

                  {AUTOMATIC=0,
                   SERIAL,
                   PARALLEL,
                   GHOSTED,

                   INVALID_PARALLELIZATION};

enum libMesh::PointLocatorType

defines an enum for the types of point locators (given a point with global coordinates, locate the corresponding element in space) available in libMesh.

Enumerator:

TREE
TREE_ELEMENTS
TREE_LOCAL_ELEMENTS
LIST
INVALID_LOCATOR

Definition at line 32 of file enum_point_locator_type.h.

                      {TREE = 0,
                       TREE_ELEMENTS,
                       TREE_LOCAL_ELEMENTS,
                       LIST,
                       INVALID_LOCATOR};

enum libMesh::PositionOfSpectrum

Defines an enum for the position of the spectrum, i.e. the eigenvalues to be computed.

Enumerator:

LARGEST_MAGNITUDE
SMALLEST_MAGNITUDE
LARGEST_REAL
SMALLEST_REAL
LARGEST_IMAGINARY
SMALLEST_IMAGINARY
INVALID_Postion_of_Spectrum

Definition at line 65 of file enum_eigen_solver_type.h.

                        {LARGEST_MAGNITUDE=0,
                         SMALLEST_MAGNITUDE,
                         LARGEST_REAL,
                         SMALLEST_REAL,
                         LARGEST_IMAGINARY,
                         SMALLEST_IMAGINARY,

                         INVALID_Postion_of_Spectrum};

enum libMesh::PreconditionerType

Defines an enum for preconditioner types

Enumerator:

IDENTITY_PRECOND
JACOBI_PRECOND
BLOCK_JACOBI_PRECOND
SOR_PRECOND
SSOR_PRECOND
EISENSTAT_PRECOND
ASM_PRECOND
CHOLESKY_PRECOND
ICC_PRECOND
ILU_PRECOND
LU_PRECOND
USER_PRECOND
SHELL_PRECOND
AMG_PRECOND
INVALID_PRECONDITIONER

Definition at line 30 of file enum_preconditioner_type.h.

                        {IDENTITY_PRECOND =0,
                         JACOBI_PRECOND,
                         BLOCK_JACOBI_PRECOND,
                         SOR_PRECOND,
                         SSOR_PRECOND,
                         EISENSTAT_PRECOND,
                         ASM_PRECOND,
                         CHOLESKY_PRECOND,
                         ICC_PRECOND,
                         ILU_PRECOND,
                         LU_PRECOND,
                         USER_PRECOND,
                         SHELL_PRECOND,
                         AMG_PRECOND,

                         INVALID_PRECONDITIONER};

enum libMesh::QuadratureType

Defines an enum for currently available quadrature rules.

Enumerator:

QGAUSS
QJACOBI_1_0
QJACOBI_2_0
QSIMPSON
QTRAP
QGRID
QGRUNDMANN_MOLLER
QMONOMIAL
QCONICAL
QGAUSS_LOBATTO
QCLOUGH
QCOMPOSITE
INVALID_Q_RULE

Definition at line 30 of file enum_quadrature_type.h.

                    {QGAUSS            = 0,

                     QJACOBI_1_0       = 1,
                     QJACOBI_2_0       = 2,

                     QSIMPSON          = 3,
                     QTRAP             = 4,
                     QGRID             = 5,
                     QGRUNDMANN_MOLLER = 6,
                     QMONOMIAL         = 7,
                     QCONICAL          = 8,
                     QGAUSS_LOBATTO    = 9,

                     QCLOUGH           = 21,

                     QCOMPOSITE        = 31,

                     INVALID_Q_RULE    = 127};

enum libMesh::SolverPackage

Defines an enum for various linear solver packages. This allows for run-time switching between solver packages

Enumerator:

PETSC_SOLVERS
SLEPC_SOLVERS

Definition at line 32 of file enum_solver_package.h.

  {
    PETSC_SOLVERS=0,
    TRILINOS_SOLVERS,
    LASPACK_SOLVERS,
    SLEPC_SOLVERS,
    EIGEN_SOLVERS,

    INVALID_SOLVER_PACKAGE
  };

enum libMesh::SolverType

Defines an enum for iterative solver types

Enumerator:

CG
CGN
CGS
CR
QMR
TCQMR
TFQMR
BICG
BICGSTAB
MINRES
GMRES
LSQR
JACOBI
SOR_FORWARD
SOR_BACKWARD
SSOR
RICHARDSON
CHEBYSHEV
INVALID_SOLVER

Definition at line 30 of file enum_solver_type.h.

                {CG=0,
                 CGN,
                 CGS,
                 CR,
                 QMR,
                 TCQMR,
                 TFQMR,
                 BICG,
                 BICGSTAB,
                 MINRES,
                 GMRES,
                 LSQR,
                 JACOBI,
                 SOR_FORWARD,
                 SOR_BACKWARD,
                 SSOR,
                 RICHARDSON,
                 CHEBYSHEV,

                 INVALID_SOLVER};

enum libMesh::SubsetSolveMode

defines an enum for the question what happens to the dofs outside the given subset when a system is solved on a subset.

Enumerator:

SUBSET_ZERO	Set dofs outside the subset to zero.
SUBSET_COPY_RHS	Set dofs outside the subset to the value of the corresponding dofs of the right hand side.
SUBSET_DONT_TOUCH	Leaves dofs outside the subset unchanged. This is fastest, but also most confusing because it abandons the property that the solution vector is (theoretically) independent of the initial guess.

Definition at line 32 of file enum_subset_solve_mode.h.

                     {
  SUBSET_ZERO = 0, 
  SUBSET_COPY_RHS, 
  SUBSET_DONT_TOUCH 
};

enum libMesh::XdrMODE

Defines an enum for read/write mode in Xdr format. READ, WRITE perform reading and writing in ASCII format, and DECODE, ENCODE do the same in binary format.

Enumerator:

UNKNOWN
ENCODE
DECODE
WRITE
READ

Definition at line 32 of file enum_xdr_mode.h.

  {
    UNKNOWN = -1, ENCODE=0, DECODE, WRITE, READ
  };

---

Function Documentation

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

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

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

Definition at line 51 of file petsc_diff_solver.C.

References libMesh::PetscVector< T >::close(), libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::get(), ierr, libMesh::DiffSolver::linear_solution_monitor, out, solver, and libMesh::DiffSolver::verbose.

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

  {
    PetscDiffSolver& solver =
      *(static_cast<PetscDiffSolver*> (ctx));

    if (solver.verbose)
      libMesh::out << "  PetscDiffSolver step " << its
                   << ", |residual|_2 = " << fnorm << std::endl;
    if (solver.linear_solution_monitor.get()) {
      int ierr = 0;

      Vec petsc_delta_u;
      ierr = SNESGetSolutionUpdate(snes, &petsc_delta_u);
      CHKERRABORT(solver.comm().get(), ierr);
      PetscVector<Number> delta_u(petsc_delta_u, solver.comm());
      delta_u.close();

      Vec petsc_u;
      ierr = SNESGetSolution(snes, &petsc_u);
      CHKERRABORT(solver.comm().get(), ierr);
      PetscVector<Number> u(petsc_u, solver.comm());
      u.close();

      Vec petsc_res;
      ierr = SNESGetFunction(snes, &petsc_res, NULL, NULL);
      CHKERRABORT(solver.comm().get(), ierr);
      PetscVector<Number> res(petsc_res, solver.comm());
      res.close();

      (*solver.linear_solution_monitor)(
                                        delta_u, delta_u.l2_norm(),
                                        u, u.l2_norm(),
                                        res, res.l2_norm(), its);
    }
    return 0;
  }

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

Definition at line 92 of file petsc_diff_solver.C.

References libMesh::ImplicitSystem::assembly(), libMesh::ParallelObject::comm(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::System::get_dof_map(), libmesh_assert(), out, libMesh::ExplicitSystem::rhs, libMesh::System::solution, solver, sys, libMesh::DiffSolver::system(), libMesh::System::update(), libMesh::DiffSolver::verbose, X_input(), and X_system.

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

  {
    libmesh_assert(x);
    libmesh_assert(r);
    libmesh_assert(ctx);

    PetscDiffSolver& solver =
      *(static_cast<PetscDiffSolver*> (ctx));
    ImplicitSystem &sys = solver.system();

    if (solver.verbose)
      libMesh::out << "Assembling the residual" << std::endl;

    PetscVector<Number>& X_system =
      *cast_ptr<PetscVector<Number>*>(sys.solution.get());
    PetscVector<Number>& R_system =
      *cast_ptr<PetscVector<Number>*>(sys.rhs);
    PetscVector<Number> X_input(x, sys.comm()), R_input(r, sys.comm());

    // DiffSystem assembles from the solution and into the rhs, so swap
    // those with our input vectors before assembling.  They'll probably
    // already be references to the same vectors, but PETSc might do
    // something tricky.
    X_input.swap(X_system);
    R_input.swap(R_system);

    // We may need to correct a non-conforming solution
    sys.get_dof_map().enforce_constraints_exactly(sys);

    // We may need to localize a parallel solution
    sys.update();

    // Do DiffSystem assembly
    sys.assembly(true, false);
    R_system.close();

    // Swap back
    X_input.swap(X_system);
    R_input.swap(R_system);

    // No errors, we hope
    return 0;
  }

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 63 of file petsc_linear_solver.C.

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

  {
    Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);

    PetscVector<Number> x_vec(x, preconditioner->comm());
    PetscVector<Number> y_vec(y, preconditioner->comm());

    preconditioner->apply(x_vec,y_vec);

    return 0;
  }

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

Definition at line 89 of file petsc_linear_solver.C.

References ierr.

  {
    void *ctx;
    PetscErrorCode ierr = PCShellGetContext(pc,&ctx);CHKERRQ(ierr);
    Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);

    PetscVector<Number> x_vec(x, preconditioner->comm());
    PetscVector<Number> y_vec(y, preconditioner->comm());

    preconditioner->apply(x_vec,y_vec);

    return 0;
  }

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 50 of file petsc_linear_solver.C.

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

  {
    Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);

    if (!preconditioner->initialized())
      libmesh_error_msg("Preconditioner not initialized!  Make sure you call init() before solve!");

    preconditioner->setup();

    return 0;
  }

PetscErrorCode libMesh::__libmesh_petsc_preconditioner_setup

(

PC

pc

)

Definition at line 75 of file petsc_linear_solver.C.

References ierr.

  {
    void *ctx;
    PetscErrorCode ierr = PCShellGetContext(pc,&ctx);CHKERRQ(ierr);
    Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);

    if (!preconditioner->initialized())
      libmesh_error_msg("Preconditioner not initialized!  Make sure you call init() before solve!");

    preconditioner->setup();

    return 0;
  }

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

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 *
	)

Definition at line 61 of file petsc_nonlinear_solver.C.

References out.

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

  {
    //PetscErrorCode ierr=0;

    //if (its > 0)
    libMesh::out << "  NL step "
                 << std::setw(2) << its
                 << std::scientific
                 << ", |residual|_2 = " << fnorm
                 << std::endl;

    //return ierr;
    return 0;
  }

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

Definition at line 81 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::_current_nonlinear_iteration_number, libMesh::PetscNonlinearSolver< T >::_zero_out_residual, libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::DofMap::enforce_constraints_exactly(), libMesh::Parallel::Communicator::get(), libMesh::System::get_dof_map(), ierr, libmesh_assert(), libMesh::NonlinearSolver< T >::matvec, libMesh::NonlinearImplicitSystem::ComputeResidual::residual(), libMesh::NonlinearSolver< T >::residual, libMesh::NonlinearImplicitSystem::ComputeResidualandJacobian::residual_and_jacobian(), libMesh::NonlinearSolver< T >::residual_and_jacobian_object, libMesh::NonlinearSolver< T >::residual_object, libMesh::ExplicitSystem::rhs, libMesh::System::solution, solver, START_LOG(), sys, libMesh::NonlinearSolver< T >::system(), libMesh::System::update(), X_global(), and X_sys.

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

  {
    START_LOG("residual()", "PetscNonlinearSolver");

    PetscErrorCode ierr=0;

    libmesh_assert(x);
    libmesh_assert(r);
    libmesh_assert(ctx);

    // No way to safety-check this cast, since we got a void*...
    PetscNonlinearSolver<Number>* solver =
      static_cast<PetscNonlinearSolver<Number>*> (ctx);

    // Get the current iteration number from the snes object,
    // store it in the PetscNonlinearSolver object for possible use
    // by the user's residual function.
    {
      PetscInt n_iterations = 0;
      ierr = SNESGetIterationNumber(snes, &n_iterations);
      CHKERRABORT(solver->comm().get(),ierr);
      solver->_current_nonlinear_iteration_number = cast_int<unsigned>(n_iterations);
    }

    NonlinearImplicitSystem &sys = solver->system();

    PetscVector<Number>& X_sys = *cast_ptr<PetscVector<Number>*>(sys.solution.get());
    PetscVector<Number>& R_sys = *cast_ptr<PetscVector<Number>*>(sys.rhs);
    PetscVector<Number> X_global(x, sys.comm()), R(r, sys.comm());

    // Use the systems update() to get a good local version of the parallel solution
    X_global.swap(X_sys);
    R.swap(R_sys);

    sys.get_dof_map().enforce_constraints_exactly(sys);

    sys.update();

    //Swap back
    X_global.swap(X_sys);
    R.swap(R_sys);

    if (solver->_zero_out_residual)
      R.zero();

    //-----------------------------------------------------------------------------
    // if the user has provided both function pointers and objects only the pointer
    // will be used, so catch that as an error
    if (solver->residual && solver->residual_object)
      libmesh_error_msg("ERROR: cannot specifiy both a function and object to compute the Residual!");

    if (solver->matvec && solver->residual_and_jacobian_object)
      libmesh_error_msg("ERROR: cannot specifiy both a function and object to compute the combined Residual & Jacobian!");

    if (solver->residual != NULL)
      solver->residual(*sys.current_local_solution.get(), R, sys);

    else if (solver->residual_object != NULL)
      solver->residual_object->residual(*sys.current_local_solution.get(), R, sys);

    else if (solver->matvec != NULL)
      solver->matvec (*sys.current_local_solution.get(), &R, NULL, sys);

    else if (solver->residual_and_jacobian_object != NULL)
      solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), &R, NULL, sys);

    else
      libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");

    R.close();
    X_global.close();

    STOP_LOG("residual()", "PetscNonlinearSolver");

    return ierr;
  }

Jac libMesh::attach_dof_map

(

sys.

get_dof_map()

)

template<typename Tnew , typename Told >

Tnew libMesh::cast_int

(

Told

oldvar

)

[inline]

Definition at line 546 of file libmesh_common.h.

{
  libmesh_assert_equal_to
    (oldvar, static_cast<Told>(static_cast<Tnew>(oldvar)));

  return(static_cast<Tnew>(oldvar));
}

template<typename Tnew , typename Told >

Tnew libMesh::cast_ptr

(

Told *

oldvar

)

[inline]

Definition at line 509 of file libmesh_common.h.

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

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

{
#if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI)
  Tnew newvar = dynamic_cast<Tnew>(oldvar);
  if (!newvar)
    {
      libMesh::err << "Failed to convert " << typeid(Told).name()
                   << " pointer to " << typeid(Tnew).name()
                   << std::endl;
      libMesh::err << "The " << typeid(Told).name()
                   << " appears to be a "
                   << typeid(*oldvar).name() << std::endl;
      libmesh_error();
    }
  return newvar;
#else
  return(static_cast<Tnew>(oldvar));
#endif
}

template<typename Tnew , typename Told >

Tnew libMesh::cast_ref

(

Told &

oldvar

)

[inline]

Definition at line 475 of file libmesh_common.h.

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

{
#if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI) && defined(LIBMESH_ENABLE_EXCEPTIONS)
  try
    {
      Tnew newvar = dynamic_cast<Tnew>(oldvar);
      return newvar;
    }
  catch (std::bad_cast)
    {
      libMesh::err << "Failed to convert " << typeid(Told).name()
                   << " reference to " << typeid(Tnew).name()
                   << std::endl;
      libMesh::err << "The " << typeid(Told).name()
                   << " appears to be a "
                   << typeid(*(&oldvar)).name() << std::endl;
      libmesh_error();
    }
#else
  return(static_cast<Tnew>(oldvar));
#endif
}

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.

Definition at line 272 of file libmesh.C.

References libMesh::libMeshPrivateData::_is_initialized.

Referenced by libMesh::LaspackVector< T >::l1_norm(), libMesh::EigenSparseVector< T >::l1_norm(), libMesh::EpetraVector< T >::l1_norm(), libMesh::PetscVector< T >::l1_norm(), libMesh::PetscMatrix< T >::l1_norm(), libMesh::LaspackVector< T >::l2_norm(), libMesh::EigenSparseVector< T >::l2_norm(), libMesh::EpetraVector< T >::l2_norm(), libMesh::PetscVector< T >::l2_norm(), libMesh::LibMeshInit::LibMeshInit(), libMesh::LaspackVector< T >::linfty_norm(), libMesh::EigenSparseVector< T >::linfty_norm(), libMesh::EpetraVector< T >::linfty_norm(), libMesh::PetscVector< T >::linfty_norm(), libMesh::PetscMatrix< T >::linfty_norm(), libMesh::PetscMatrix< T >::operator()(), libMesh::DistributedVector< T >::operator+=(), libMesh::LaspackVector< T >::operator+=(), libMesh::EigenSparseVector< T >::operator+=(), libMesh::EpetraVector< T >::operator+=(), libMesh::PetscVector< T >::operator+=(), libMesh::DistributedVector< T >::operator-=(), libMesh::LaspackVector< T >::operator-=(), libMesh::EigenSparseVector< T >::operator-=(), libMesh::EpetraVector< T >::operator-=(), libMesh::PetscVector< T >::operator-=(), libMesh::EigenSparseVector< T >::operator/=(), libMesh::EpetraVector< T >::operator/=(), libMesh::LaspackVector< T >::operator=(), libMesh::EigenSparseVector< T >::operator=(), libMesh::PetscVector< T >::operator=(), libMesh::PetscVector< T >::print_matlab(), libMesh::LaspackVector< T >::sum(), libMesh::EigenSparseVector< T >::sum(), libMesh::EpetraVector< T >::sum(), libMesh::PetscVector< T >::sum(), libMesh::LaspackVector< T >::zero(), libMesh::EigenSparseVector< T >::zero(), libMesh::EpetraVector< T >::zero(), libMesh::PetscVector< T >::zero(), libMesh::LibMeshInit::~LibMeshInit(), libMesh::MeshBase::~MeshBase(), libMesh::System::~System(), and libMesh::UnstructuredMesh::~UnstructuredMesh().

{
  return !libMeshPrivateData::_is_initialized;
}

template<typename T >

T libMesh::command_line_next	(	const std::string &	,
		T
	)

Use GetPot's search()/next() functions to get following arguments from the command line.

Definition at line 859 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::command_line, and libmesh_assert().

Referenced by libMesh::DofMap::use_coupled_neighbor_dofs().

{
  // Make sure the command line parser is ready for use
  libmesh_assert(command_line.get());

  if (command_line->search(1, name.c_str()))
    value = command_line->next(value);

  return value;
}

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

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

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

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

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

template<typename T >

T libMesh::command_line_value	(	const std::string &	,
		T
	)

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

Definition at line 827 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::command_line, and libmesh_assert().

Referenced by libMesh::LibMeshInit::LibMeshInit(), and petsc_auto_fieldsplit().

{
  // Make sure the command line parser is ready for use
  libmesh_assert(command_line.get());

  // only if the variable exists in the file
  if (command_line->have_variable(name.c_str()))
    value = (*command_line)(name.c_str(), value);

  return value;
}

template<typename T >

T libMesh::command_line_value	(	const std::vector< std::string > &	name,
		T	value
	)

Definition at line 840 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::command_line, and libmesh_assert().

{
  // Make sure the command line parser is ready for use
  libmesh_assert(command_line.get());

  // Check for multiple options (return the first that matches)
  for (std::vector<std::string>::const_iterator i=name.begin(); i != name.end(); ++i)
    if (command_line->have_variable(i->c_str()))
      {
        value = (*command_line)(i->c_str(), value);
        break;
      }

  return value;
}

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

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

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

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 > &
	)

Returns:

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

Definition at line 873 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::command_line, and libmesh_assert().

{
  // Make sure the command line parser is ready for use
  libmesh_assert(command_line.get());

  // only if the variable exists on the command line
  if (command_line->have_variable(name.c_str()))
    {
      unsigned size = command_line->vector_variable_size(name.c_str());
      vec.resize(size);

      for (unsigned i=0; i<size; ++i)
        vec[i] = (*command_line)(name.c_str(), vec[i], i);
    }
}

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 > &
	)

DiffSolver::SolveResult libMesh::convert_solve_result

(

SNESConvergedReason

r

)

Definition at line 297 of file petsc_diff_solver.C.

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

{
  switch (r)
    {
    case SNES_CONVERGED_FNORM_ABS:
      return DiffSolver::CONVERGED_ABSOLUTE_RESIDUAL;
    case SNES_CONVERGED_FNORM_RELATIVE:
      return DiffSolver::CONVERGED_RELATIVE_RESIDUAL;
#if PETSC_VERSION_LESS_THAN(3,2,1)
    case SNES_CONVERGED_PNORM_RELATIVE:
#else
    case SNES_CONVERGED_SNORM_RELATIVE:
#endif
      return DiffSolver::CONVERGED_RELATIVE_STEP;
#if !PETSC_VERSION_LESS_THAN(2,3,3)
    case SNES_CONVERGED_ITS:
#endif
    case SNES_CONVERGED_TR_DELTA:
      return DiffSolver::CONVERGED_NO_REASON;
    case SNES_DIVERGED_FUNCTION_DOMAIN:
    case SNES_DIVERGED_FUNCTION_COUNT:
    case SNES_DIVERGED_FNORM_NAN:
#if !PETSC_VERSION_LESS_THAN(3,3,0)
    case SNES_DIVERGED_INNER:
#endif
#if !PETSC_VERSION_LESS_THAN(2,3,2)
    case SNES_DIVERGED_LINEAR_SOLVE:
#endif
    case SNES_DIVERGED_LOCAL_MIN:
      return DiffSolver::DIVERGED_NO_REASON;
    case SNES_DIVERGED_MAX_IT:
      return DiffSolver::DIVERGED_MAX_NONLINEAR_ITERATIONS;
#if PETSC_VERSION_LESS_THAN(3,2,0)
    case SNES_DIVERGED_LS_FAILURE:
#else
    case SNES_DIVERGED_LINE_SEARCH:
#endif
      return DiffSolver::DIVERGED_BACKTRACKING_FAILURE;
      // In PETSc, SNES_CONVERGED_ITERATING means
      // the solve is still iterating, but by the
      // time we get here, we must have either
      // converged or diverged, so
      // SNES_CONVERGED_ITERATING is invalid.
    case SNES_CONVERGED_ITERATING:
      return DiffSolver::INVALID_SOLVE_RESULT;
    default:
      break;
    }
  return DiffSolver::INVALID_SOLVE_RESULT;
}

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.

Definition at line 890 of file libmesh.C.

References libMesh::libMeshPrivateData::_solver_package, EIGEN_SOLVERS, initialized(), INVALID_SOLVER_PACKAGE, LASPACK_SOLVERS, libmesh_assert(), on_command_line(), PETSC_SOLVERS, and TRILINOS_SOLVERS.

{
  libmesh_assert (libMesh::initialized());

  static bool called = false;

  // Check the command line.  Since the command line is
  // unchanging it is sufficient to do this only once.
  if (!called)
    {
      called = true;

#ifdef LIBMESH_HAVE_PETSC
      if (libMesh::on_command_line ("--use-petsc"))
        libMeshPrivateData::_solver_package = PETSC_SOLVERS;
#endif

#ifdef LIBMESH_HAVE_TRILINOS
      if (libMesh::on_command_line ("--use-trilinos") ||
          libMesh::on_command_line ("--disable-petsc"))
        libMeshPrivateData::_solver_package = TRILINOS_SOLVERS;
#endif

#ifdef LIBMESH_HAVE_EIGEN
      if (libMesh::on_command_line ("--use-eigen"  ) ||
#if defined(LIBMESH_HAVE_MPI)
          // If the user bypassed MPI, we disable PETSc and Trilinos
          // too
          libMesh::on_command_line ("--disable-mpi") ||
#endif
          libMesh::on_command_line ("--disable-petsc"))
        libMeshPrivateData::_solver_package = EIGEN_SOLVERS;
#endif

#ifdef LIBMESH_HAVE_LASPACK
      if (libMesh::on_command_line ("--use-laspack"  ) ||
#if defined(LIBMESH_HAVE_MPI)
          // If the user bypassed MPI, we disable PETSc and Trilinos
          // too
          libMesh::on_command_line ("--disable-mpi") ||
#endif
          libMesh::on_command_line ("--disable-petsc"))
        libMeshPrivateData::_solver_package = LASPACK_SOLVERS;
#endif

      if (libMesh::on_command_line ("--disable-laspack") &&
          libMesh::on_command_line ("--disable-trilinos") &&
          libMesh::on_command_line ("--disable-eigen") &&
          (
#if defined(LIBMESH_HAVE_MPI)
           // If the user bypassed MPI, we disable PETSc too
           libMesh::on_command_line ("--disable-mpi") ||
#endif
           libMesh::on_command_line ("--disable-petsc")))
        libMeshPrivateData::_solver_package = INVALID_SOLVER_PACKAGE;
    }


  return libMeshPrivateData::_solver_package;
}

std::string libMesh::demangle

(

const char *

name

)

Mostly system independent demangler

Definition at line 223 of file print_trace.C.

References libMesh::Quality::name().

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

{
  int status = 0;
  std::string ret = name;

  // Actually do the demangling
  char *demangled_name = abi::__cxa_demangle(name, 0, 0, &status);

  // If demangling returns non-NULL, save the result in a string.
  if (demangled_name)
    ret = demangled_name;

  // According to cxxabi.h docs, the caller is responsible for
  // deallocating memory.
  std::free(demangled_name);

  return ret;
}

void libMesh::enableFPE

(

bool

on

)

Toggle floating point exceptions -- courtesy of Cody Permann & MOOSE team

Toggle hardware trap floating point exceptions

Definition at line 745 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::libmesh_handleFPE().

Referenced by libMesh::LibMeshInit::LibMeshInit(), and libMesh::LibMeshInit::~LibMeshInit().

{
#if !defined(LIBMESH_HAVE_FEENABLEEXCEPT) && defined(LIBMESH_HAVE_XMMINTRIN_H) && !defined(__SUNPRO_CC)
  static int flags = 0;
#endif

  if (on)
    {
      struct sigaction new_action, old_action;

#ifdef LIBMESH_HAVE_FEENABLEEXCEPT
      feenableexcept(FE_DIVBYZERO | FE_INVALID);
#elif  LIBMESH_HAVE_XMMINTRIN_H
#  ifndef __SUNPRO_CC
      flags = _MM_GET_EXCEPTION_MASK();           // store the flags
      _MM_SET_EXCEPTION_MASK(flags & ~_MM_MASK_INVALID);
#  endif
#endif


      // Set up the structure to specify the new action.
      new_action.sa_sigaction = libmesh_handleFPE;
      sigemptyset (&new_action.sa_mask);
      new_action.sa_flags = SA_SIGINFO;

      sigaction (SIGFPE, NULL, &old_action);
      if (old_action.sa_handler != SIG_IGN)
        sigaction (SIGFPE, &new_action, NULL);
    }
  else
    {
#ifdef LIBMESH_HAVE_FEDISABLEEXCEPT
      fedisableexcept(FE_DIVBYZERO | FE_INVALID);
#elif  LIBMESH_HAVE_XMMINTRIN_H
#  ifndef __SUNPRO_CC
      _MM_SET_EXCEPTION_MASK(flags);
#  endif
#endif
      signal(SIGFPE, SIG_DFL);
    }
}

void libMesh::enableSEGV

(

bool

on

)

Toggle libMesh reporting of segmentation faults

Definition at line 790 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::libmesh_handleSEGV().

Referenced by libMesh::LibMeshInit::LibMeshInit().

{
  static struct sigaction old_action;
  static bool was_on = false;

  if (on)
    {
      struct sigaction new_action;
      was_on = true;

      // Set up the structure to specify the new action.
      new_action.sa_sigaction = libmesh_handleSEGV;
      sigemptyset (&new_action.sa_mask);
      new_action.sa_flags = SA_SIGINFO;

      sigaction (SIGSEGV, &new_action, &old_action);
    }
  else if (was_on)
    {
      was_on = false;
      sigaction (SIGSEGV, &old_action, NULL);
    }
}

sys libMesh::get_dof_map

(

)

Definition at line 179 of file petsc_diff_solver.C.

Referenced by libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), libMesh::System::boundary_project_vector(), libMesh::TransientSystem< Base >::init_data(), libMesh::TransientSystem< Base >::old_solution(), libMesh::TransientSystem< Base >::older_solution(), and libMesh::TransientSystem< Base >::re_update().

  : Parent(s)
{
}

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().

{
  std::string retval(LIBMESH_IO_COMPATIBILITY_VERSION);
  return retval;
}

int libMesh::get_libmesh_version

(

)

Definition at line 43 of file libmesh_version.C.

Referenced by libmesh_version_stdout().

{
  /* Note: return format follows the versioning convention xx.yy.zz where

     xx = major version number
     yy = minor version number
     zz = micro version number

     For example:
     v.   0.23  -> 002300 = 2300
     v   0.23.1 -> 002301 = 2301
     v. 10.23.2 -> 102302         */

  int major_version = 0;
  int minor_version = 0;
  int micro_version = 0;

#ifdef LIBMESH_MAJOR_VERSION
  major_version = LIBMESH_MAJOR_VERSION;
#endif

#ifdef LIBMESH_MINOR_VERSION
  minor_version = LIBMESH_MINOR_VERSION;
#endif

#ifdef LIBMESH_MICRO_VERSION
  micro_version = LIBMESH_MICRO_VERSION;
#endif

  return major_version*10000 + minor_version*100 + micro_version;
}

libMesh::processor_id_type libMesh::global_n_processors

(

)

[inline]

Returns:

the number of processors libMesh was initialized with.

Definition at line 104 of file libmesh_base.h.

References libMesh::libMeshPrivateData::_n_processors.

Referenced by libMesh::PerfLog::get_info_header(), n_processors(), libMesh::MacroFunctions::report_error(), and libMesh::MacroFunctions::stop().

{
#ifdef LIBMESH_HAVE_MPI
  return libMeshPrivateData::_n_processors;
#else
  return 1;
#endif
}

libMesh::processor_id_type libMesh::global_processor_id

(

)

[inline]

Returns:

the index of the local processor with respect to the original MPI pool libMesh was initialized with.

Definition at line 114 of file libmesh_base.h.

References libMesh::libMeshPrivateData::_processor_id.

Referenced by libMesh::PerfLog::get_info_header(), libMesh::MacroFunctions::here(), libMesh::LibMeshInit::LibMeshInit(), processor_id(), and write_traceout().

{
#ifdef LIBMESH_HAVE_MPI
  return libMeshPrivateData::_processor_id;
#else
  return 0;
#endif
}

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

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.

Definition at line 265 of file libmesh.C.

References libMesh::libMeshPrivateData::_is_initialized.

Referenced by libMesh::PetscVector< T >::_get_array(), libMesh::PetscVector< T >::_restore_array(), libMesh::LaspackVector< T >::abs(), libMesh::DistributedVector< T >::abs(), libMesh::EigenSparseVector< T >::abs(), libMesh::EigenSparseMatrix< T >::add(), libMesh::LaspackMatrix< T >::add(), libMesh::EpetraMatrix< T >::add(), libMesh::PetscMatrix< T >::add(), libMesh::LaspackVector< T >::add(), libMesh::DistributedVector< T >::add(), libMesh::EigenSparseVector< T >::add(), libMesh::PetscMatrix< T >::add_block_matrix(), libMesh::EigenSparseMatrix< T >::add_matrix(), libMesh::LaspackMatrix< T >::add_matrix(), libMesh::EpetraMatrix< T >::add_matrix(), libMesh::PetscMatrix< T >::add_matrix(), libMesh::EigenSparseLinearSolver< T >::clear(), libMesh::AztecLinearSolver< T >::clear(), libMesh::LaspackLinearSolver< T >::clear(), libMesh::SlepcEigenSolver< T >::clear(), libMesh::PetscNonlinearSolver< T >::clear(), libMesh::LaspackVector< T >::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::EpetraVector< T >::clear(), libMesh::PetscVector< T >::clear(), libMesh::LaspackMatrix< T >::clear(), libMesh::EpetraMatrix< T >::clear(), libMesh::PetscMatrix< T >::clear(), libMesh::DistributedVector< T >::close(), libMesh::LaspackVector< T >::close(), libMesh::EigenSparseVector< T >::close(), libMesh::EpetraVector< T >::close(), libMesh::EpetraMatrix< T >::closed(), libMesh::PetscMatrix< T >::closed(), libMesh::NumericVector< T >::compare(), default_solver_package(), libMesh::LaspackVector< T >::dot(), libMesh::EigenSparseVector< T >::dot(), libMesh::DistributedVector< T >::first_local_index(), libMesh::LaspackVector< T >::first_local_index(), libMesh::EigenSparseVector< T >::first_local_index(), libMesh::EpetraVector< T >::first_local_index(), libMesh::PetscVector< T >::first_local_index(), libMesh::PetscNonlinearSolver< T >::get_converged_reason(), libMesh::NumericVector< T >::global_relative_compare(), libMesh::EigenSparseLinearSolver< T >::init(), libMesh::AztecLinearSolver< T >::init(), libMesh::LaspackLinearSolver< T >::init(), libMesh::SlepcEigenSolver< T >::init(), libMesh::NoxNonlinearSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::EigenSparseMatrix< T >::init(), libMesh::PetscLinearSolver< T >::init(), libMesh::LaspackMatrix< T >::init(), libMesh::EpetraMatrix< T >::init(), libMesh::PetscMatrix< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::DistributedVector< T >::l1_norm(), libMesh::EigenSparseVector< T >::l1_norm(), libMesh::EpetraMatrix< T >::l1_norm(), libMesh::PetscMatrix< T >::l1_norm(), libMesh::DistributedVector< T >::l2_norm(), libMesh::EigenSparseVector< T >::l2_norm(), libMesh::DistributedVector< T >::last_local_index(), libMesh::LaspackVector< T >::last_local_index(), libMesh::EigenSparseVector< T >::last_local_index(), libMesh::EpetraVector< T >::last_local_index(), libMesh::PetscVector< T >::last_local_index(), libMesh::LibMeshInit::LibMeshInit(), libMesh::DistributedVector< T >::linfty_norm(), libMesh::EigenSparseVector< T >::linfty_norm(), libMesh::EpetraMatrix< T >::linfty_norm(), libMesh::PetscMatrix< T >::linfty_norm(), libMesh::NumericVector< T >::local_relative_compare(), libMesh::DistributedVector< T >::local_size(), libMesh::LaspackVector< T >::local_size(), libMesh::EigenSparseVector< T >::local_size(), libMesh::EpetraVector< T >::local_size(), libMesh::PetscVector< T >::local_size(), libMesh::DistributedVector< T >::localize(), libMesh::DistributedVector< T >::localize_to_one(), libMesh::EigenSparseMatrix< T >::m(), libMesh::LaspackMatrix< T >::m(), libMesh::EpetraMatrix< T >::m(), libMesh::PetscMatrix< T >::m(), libMesh::PetscVector< T >::map_global_to_local_index(), libMesh::DistributedVector< T >::max(), libMesh::LaspackVector< T >::max(), libMesh::EigenSparseVector< T >::max(), libMesh::EpetraVector< T >::max(), libMesh::MeshBase::MeshBase(), libMesh::DistributedVector< T >::min(), libMesh::LaspackVector< T >::min(), libMesh::EigenSparseVector< T >::min(), libMesh::EpetraVector< T >::min(), libMesh::EigenSparseMatrix< T >::n(), libMesh::LaspackMatrix< T >::n(), libMesh::EpetraMatrix< T >::n(), libMesh::PetscMatrix< T >::n(), libMesh::AnalyticFunction< Output >::operator()(), libMesh::EigenSparseMatrix< T >::operator()(), libMesh::LaspackMatrix< T >::operator()(), libMesh::EpetraMatrix< T >::operator()(), libMesh::DistributedVector< T >::operator()(), libMesh::LaspackVector< T >::operator()(), libMesh::EigenSparseVector< T >::operator()(), libMesh::EpetraVector< T >::operator()(), libMesh::PetscMatrix< T >::operator()(), libMesh::DistributedVector< T >::operator+=(), libMesh::DistributedVector< T >::operator-=(), libMesh::DistributedVector< T >::operator=(), libMesh::LaspackVector< T >::operator=(), libMesh::EigenSparseVector< T >::operator=(), libMesh::SparseMatrix< T >::print(), libMesh::NumericVector< T >::print(), libMesh::NumericVector< T >::print_global(), libMesh::PetscMatrix< T >::print_matlab(), libMesh::EpetraMatrix< T >::print_personal(), libMesh::PetscMatrix< T >::print_personal(), libMesh::EpetraMatrix< T >::row_start(), libMesh::PetscMatrix< T >::row_start(), libMesh::EpetraMatrix< T >::row_stop(), libMesh::PetscMatrix< T >::row_stop(), libMesh::DistributedVector< T >::scale(), libMesh::LaspackVector< T >::scale(), libMesh::EigenSparseVector< T >::scale(), libMesh::EigenSparseMatrix< T >::set(), libMesh::LaspackMatrix< T >::set(), libMesh::EpetraMatrix< T >::set(), libMesh::PetscMatrix< T >::set(), libMesh::DistributedVector< T >::set(), libMesh::LaspackVector< T >::set(), libMesh::EigenSparseVector< T >::set(), libMesh::DistributedVector< T >::size(), libMesh::LaspackVector< T >::size(), libMesh::EigenSparseVector< T >::size(), libMesh::EpetraVector< T >::size(), libMesh::PetscVector< T >::size(), libMesh::DistributedVector< T >::sum(), libMesh::EigenSparseVector< T >::sum(), libMesh::UnstructuredMesh::UnstructuredMesh(), libMesh::LaspackMatrix< T >::update_sparsity_pattern(), libMesh::EpetraMatrix< T >::update_sparsity_pattern(), libMesh::DistributedVector< T >::zero(), libMesh::LaspackVector< T >::zero(), libMesh::EigenSparseVector< T >::zero(), libMesh::EpetraVector< T >::zero(), libMesh::EpetraMatrix< T >::zero(), libMesh::PetscMatrix< T >::zero(), and libMesh::PetscMatrix< T >::zero_rows().

{
  return libMeshPrivateData::_is_initialized;
}

libMesh::INSTANTIATE_ALL_MAPS

(

0

)

libMesh::INSTANTIATE_ALL_MAPS

(

1

)

libMesh::INSTANTIATE_ALL_MAPS

(

2

)

libMesh::INSTANTIATE_ALL_MAPS

(

3

)

libMesh::INSTANTIATE_FE

(

0

)

libMesh::INSTANTIATE_FE

(

1

)

libMesh::INSTANTIATE_FE

(

2

)

libMesh::INSTANTIATE_FE

(

3

)

libMesh::INSTANTIATE_INF_FE	(	1	,
		CARTESIAN
	)

Collect all 1D explicit instantiations for class InfFE

libMesh::INSTANTIATE_INF_FE	(	2	,
		CARTESIAN
	)

Collect all 2D explicit instantiations for class InfFE

libMesh::INSTANTIATE_INF_FE	(	3	,
		CARTESIAN
	)

Collect all 3D explicit instantiations for class InfFE

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

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

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

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		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	(	3	,
		CARTESIAN	,
		ElemType	,
		Base::	get_elem_typeconst ElemType type
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		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	(	3	,
		CARTESIAN	,
		unsigned	int,
		Base::	n_base_mapping_sfconst ElemType, const Order
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		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	(	3	,
		CARTESIAN	,
		unsigned	int,
		Radial::	n_dofs_at_nodeconst Order, const unsigned int
	)

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	(	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	(	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	(	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	(	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	(	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	(	1	,
		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	(	3	,
		CARTESIAN	,
		void	,
		init_face_shape_functions(const std::vector< Point > &, const Elem *)
	)

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	(	2	,
		CARTESIAN	,
		Point	,
		inverse_map(const Elem *, const Point &, const Real, const bool, 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	(	1	,
		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	(	3	,
		CARTESIAN	,
		void	,
		inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		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	(	3	,
		CARTESIAN	,
		unsigned	int,
		n_dofs(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	(	2	,
		CARTESIAN	,
		unsigned	int,
		n_dofs_per_elem(const FEType &, const ElemType)
	)

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

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	(	2	,
		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_at_node(const FEType &, const ElemType, const 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	(	2	,
		CARTESIAN	,
		void	,
		compute_shape_indices(const FEType &, 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	(	1	,
		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	(	3	,
		CARTESIAN	,
		void	,
		compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		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	(	3	,
		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 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	(	3	,
		CARTESIAN	,
		Real	,
		shape(const FEType &, const ElemType, const unsigned int, const Point &)
	)

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		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	(	3	,
		CARTESIAN	,
		void	,
		compute_data(const FEType &, const Elem *, FEComputeData &)
	)

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	(	2	,
		CARTESIAN	,
		void	,
		nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &)
	)

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

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

Definition at line 238 of file mesh_tools.C.

References std::max().

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

{
  return min <= check && check <= max;
}

PetscMatrix<Number> libMesh::J_input	(	pc	,
		sys.	comm()
	)

PetscMatrix<Number> Jac* libMesh::jac

(

)

PetscMatrix<Number> libMesh::Jac	(	jac	,
		sys.	comm()
	)

Referenced by libMesh::Problem_Interface::computeJacobian(), and libMesh::Problem_Interface::computePreconditioner().

PetscErrorCode Vec Mat Mat void* ctx libMesh::libmesh_assert

(

x

)

Referenced by __libmesh_petsc_diff_solver_residual(), __libmesh_petsc_snes_residual(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::PetscLinearSolver< T >::_create_complement_is(), libMesh::FEMContext::_do_elem_position_set(), libMesh::MetisPartitioner::_do_partition(), libMesh::DofMap::_dof_indices(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::DenseMatrix< T >::_evd_lapack(), libMesh::SteadySolver::_general_residual(), libMesh::PetscVector< T >::_get_array(), libMesh::EquationSystems::_read_impl(), libMesh::GMVIO::_read_one_cell(), libMesh::PetscVector< T >::_restore_array(), libMesh::PetscLinearSolver< T >::_restrict_solve_to_is_local_size(), libMesh::DistributedVector< T >::abs(), libMesh::LaspackVector< T >::abs(), libMesh::EigenSparseVector< T >::abs(), libMesh::Elem::active_family_tree(), libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::active_family_tree_by_side(), libMesh::EigenSparseMatrix< T >::add(), libMesh::LaspackMatrix< T >::add(), libMesh::EpetraMatrix< T >::add(), libMesh::PetscMatrix< T >::add(), libMesh::DistributedVector< T >::add(), libMesh::EigenSparseVector< T >::add(), libMesh::LaspackVector< T >::add(), libMesh::PetscMatrix< T >::add_block_matrix(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::GMVIO::add_cell_centered_data(), libMesh::Elem::add_child(), libMesh::BoundaryInfo::add_edge(), libMesh::SerialMesh::add_elem(), libMesh::ParallelMesh::add_elem(), libMesh::MeshRefinement::add_elem(), libMesh::MeshData::add_foreign_elem_id(), libMesh::MeshData::add_foreign_node_id(), libMesh::EigenSparseMatrix< T >::add_matrix(), libMesh::LaspackMatrix< T >::add_matrix(), libMesh::EpetraMatrix< T >::add_matrix(), libMesh::PetscMatrix< T >::add_matrix(), libMesh::BoundaryInfo::add_node(), libMesh::SerialMesh::add_node(), libMesh::ParallelMesh::add_node(), libMesh::DofMap::add_periodic_boundary(), libMesh::SerialMesh::add_point(), libMesh::ParallelMesh::add_point(), libMesh::MeshRefinement::add_point(), libMesh::Parallel::Request::add_prior_request(), libMesh::HPCoarsenTest::add_projection(), libMesh::EnsightIO::add_scalar(), libMesh::BoundaryInfo::add_side(), libMesh::ImplicitSystem::add_system_matrix(), libMesh::ExplicitSystem::add_system_rhs(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::EnsightIO::add_vector(), libMesh::LaspackVector< T >::add_vector(), libMesh::EigenSparseVector< T >::add_vector(), libMesh::NumericVector< T >::add_vector(), libMesh::EigenSparseVector< T >::add_vector_transpose(), libMesh::EquationSystems::adjoint_solve(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::Parallel::Communicator::allgather(), libMesh::Parallel::Communicator::allgather_packed_range(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::Parallel::Communicator::alltoall(), libMesh::AnalyticFunction< Output >::AnalyticFunction(), libMesh::Utility::do_pow< N, T >::apply(), libMesh::ImplicitSystem::assemble(), libMesh::FrequencySystem::assemble(), libMesh::FEMSystem::assembly(), libMesh::NonlinearImplicitSystem::assembly(), libMesh::MeshData::assign(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::System::attach_assemble_function(), libMesh::System::attach_constraint_function(), libMesh::ExactErrorEstimator::attach_exact_deriv(), libMesh::ExactSolution::attach_exact_deriv(), libMesh::ExactErrorEstimator::attach_exact_hessian(), libMesh::ExactSolution::attach_exact_hessian(), libMesh::System::attach_init_function(), libMesh::DofMap::attach_matrix(), libMesh::System::attach_QOI_derivative(), libMesh::System::attach_QOI_function(), libMesh::FE< Dim, T >::attach_quadrature_rule(), libMesh::InfFE< Dim, T_radial, T_map >::attach_quadrature_rule(), libMesh::FESubdivision::attach_quadrature_rule(), libMesh::ExactSolution::attach_reference_solution(), libMesh::ExactErrorEstimator::attach_reference_solution(), libMesh::FrequencySystem::attach_solve_function(), libMesh::Parallel::BinSorter< KeyType, IdxType >::BinSorter(), libMesh::Threads::BoolAcquire::BoolAcquire(), libMesh::BoundaryInfo::boundary_id(), libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryProjectSolution::BoundaryProjectSolution(), libMesh::TreeNode< N >::bounds_node(), libMesh::Parallel::Communicator::broadcast(), libMesh::Patch::build_around_element(), libMesh::DofMap::build_constraint_matrix(), libMesh::DofMap::build_constraint_matrix_and_vector(), libMesh::FEMSystem::build_context(), libMesh::MeshTools::Generation::build_cube(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::ParmetisPartitioner::build_graph(), libMesh::FEMContext::build_new_fe(), libMesh::EquationSystems::build_solution_vector(), libMesh::DofMap::build_sparsity(), libMesh::EquationSystems::build_variable_names(), libMesh::Elem::child(), libMesh::Singleton::cleanup(), libMesh::Parallel::Request::cleanup(), libMesh::EpetraMatrix< T >::clear(), libMesh::Parallel::Communicator::clear(), libMesh::DofObject::clear_dofs(), libMesh::DofMap::clear_sparsity(), libMesh::Parameters::Parameter< T >::clone(), libMesh::DistributedVector< T >::close(), libMesh::LaspackVector< T >::close(), libMesh::EigenSparseVector< T >::close(), libMesh::EpetraVector< T >::close(), libMesh::EpetraMatrix< T >::close(), libMesh::MeshData::close_foreign_id_maps(), libMesh::EpetraMatrix< T >::closed(), libMesh::PetscMatrix< T >::closed(), libMesh::Elem::coarsen(), libMesh::MeshRefinement::coarsen_elements(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::InfFE< Dim, T_radial, T_map >::combine_base_radial(), command_line_next(), command_line_value(), command_line_vector(), libMesh::Xdr::comment(), libMesh::System::compare(), libMesh::NumericVector< T >::compare(), libMesh::WrappedFunction< Output >::component(), libMesh::FEMap::compute_affine_map(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::FEInterface::compute_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::FEMap::compute_edge_map(), libMesh::ExactSolution::compute_error(), libMesh::FEXYZMap::compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::Elem::compute_key(), libMesh::FEMap::compute_map(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEMap::compute_single_point_map(), libMesh::Prism6::connectivity(), libMesh::Pyramid5::connectivity(), libMesh::InfHex8::connectivity(), libMesh::Hex8::connectivity(), libMesh::InfPrism6::connectivity(), libMesh::InfPrism12::connectivity(), libMesh::Tet4::connectivity(), libMesh::Tet10::connectivity(), libMesh::InfHex16::connectivity(), libMesh::Hex20::connectivity(), libMesh::Prism15::connectivity(), libMesh::Pyramid13::connectivity(), libMesh::Pyramid14::connectivity(), libMesh::InfHex18::connectivity(), libMesh::Hex27::connectivity(), libMesh::Prism18::connectivity(), libMesh::DofMap::constrain_element_dyad_matrix(), libMesh::DofMap::constrain_element_matrix(), libMesh::DofMap::constrain_element_matrix_and_vector(), libMesh::DofMap::constrain_element_vector(), libMesh::UnstructuredMesh::contract(), libMesh::Elem::contract(), libMesh::GMVIO::copy_nodal_solution(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::vectormap< dof_id_type, dof_id_type >::count(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::UnstructuredMesh::create_submesh(), libMesh::ElemCutter::cut_2D(), libMesh::ElemCutter::cut_3D(), libMesh::Xdr::data(), libMesh::Xdr::data_stream(), libMesh::XdrMGF::dataBlk(), libMesh::ParameterVector::deep_resize(), default_solver_package(), libMesh::SerialMesh::delete_elem(), libMesh::ParallelMesh::delete_elem(), libMesh::SerialMesh::delete_node(), libMesh::ParallelMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::Parallel::Communicator::dereference_unique_tag(), libMesh::DGFEMContext::DGFEMContext(), libMesh::DirichletBoundary::DirichletBoundary(), libMesh::MeshFunction::disable_out_of_mesh_mode(), libMesh::MeshTools::Modification::distort(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), DMlibMeshFunction(), libMesh::Xdr::do_read(), libMesh::Xdr::do_write(), libMesh::DofMap::dof_indices(), libMesh::FE< Dim, T >::dofs_on_edge(), libMesh::FE< Dim, T >::dofs_on_side(), libMesh::LaspackVector< T >::dot(), libMesh::EigenSparseVector< T >::dot(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::FE< Dim, T >::edge_reinit(), libMesh::SerialMesh::elem(), libMesh::ParallelMesh::elem(), libMesh::FEMContext::elem_fe_reinit(), libMesh::FEMContext::elem_position_get(), libMesh::MeshData::elem_to_foreign_id(), libMesh::TetGenIO::element_in(), libMesh::AdaptiveTimeSolver::element_residual(), libMesh::EigenTimeSolver::element_residual(), libMesh::UNVIO::elements_out(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::MeshFunction::enable_out_of_mesh_mode(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::ExactSolution::error_norm(), libMesh::AdaptiveTimeSolver::error_order(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::DofMap::extract_local_vector(), libMesh::Factory< Base >::Factory(), libMesh::Elem::family_tree(), libMesh::Elem::family_tree_by_neighbor(), libMesh::Elem::family_tree_by_side(), libMesh::Elem::family_tree_by_subneighbor(), libMesh::FEMContext::FEMContext(), libMesh::DofMap::find_connected_dofs(), libMesh::Elem::find_edge_neighbors(), libMesh::TreeNode< N >::find_element_in_children(), libMesh::MeshCommunication::find_global_indices(), libMesh::ElemCutter::find_intersection_points(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::find_nodal_neighbors(), libMesh::MeshTools::Subdivision::find_one_ring(), libMesh::Elem::find_point_neighbors(), libMesh::MemorySolutionHistory::find_stored_entry(), libMesh::DistributedVector< T >::first_local_index(), libMesh::LaspackVector< T >::first_local_index(), libMesh::EigenSparseVector< T >::first_local_index(), libMesh::EpetraVector< T >::first_local_index(), libMesh::PetscVector< T >::first_local_index(), libMesh::FEMContext::fixed_point_gradient(), libMesh::FEMContext::fixed_point_hessian(), libMesh::FEMContext::fixed_point_value(), libMesh::FEMContext::fixed_side_gradient(), libMesh::FEMContext::fixed_side_hessian(), libMesh::FEMContext::fixed_side_value(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::MeshData::foreign_id_to_elem(), libMesh::MeshData::foreign_id_to_node(), libMesh::Parallel::Communicator::gather(), libMesh::ParameterPointer< T >::get(), libMesh::Parameters::get(), libMesh::ReferenceElem::get(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_curl_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2(), libMesh::MeshData::get_data(), libMesh::DiffContext::get_deltat_value(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_div_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::FEMContext::get_elem(), libMesh::DiffContext::get_elem_fixed_solution(), libMesh::DiffContext::get_elem_jacobian(), libMesh::DiffContext::get_elem_residual(), libMesh::DiffContext::get_elem_solution(), libMesh::DiffContext::get_elem_solution_rate(), libMesh::TetGenWrapper::get_element_attribute(), libMesh::FEMContext::get_element_fe(), libMesh::FEMContext::get_element_qrule(), libMesh::DofMap::get_info(), libMesh::DifferentiableSystem::get_linear_solve_parameters(), libMesh::DifferentiableSystem::get_linear_solver(), libMesh::DiffContext::get_localized_subvector(), libMesh::DiffContext::get_localized_vector(), libMesh::EquationSystems::get_mesh_data(), libMesh::DofMap::get_n_nz(), libMesh::DofMap::get_n_oz(), libMesh::Elem::get_node(), libMesh::Tri3Subdivision::get_ordered_node(), libMesh::Tri3Subdivision::get_ordered_valence(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi(), libMesh::MeshFunction::get_point_locator(), libMesh::DenseMatrix< T >::get_principal_submatrix(), libMesh::DiffContext::get_qoi_derivatives(), libMesh::FEMContext::get_side_fe(), libMesh::FEMContext::get_side_qrule(), libMesh::EquationSystems::get_solution(), libMesh::DifferentiableSystem::get_time_solver(), libMesh::Parallel::Communicator::get_unique_tag(), libMesh::MeshData::get_unv_header(), libMesh::System::get_vector(), libMesh::NumericVector< T >::global_relative_compare(), libMesh::QGrundmann_Moller::gm_rule(), libMesh::MeshFunction::gradient(), libMesh::BoundaryInfo::has_boundary_id(), libMesh::MeshData::has_data(), libMesh::MeshRefinement::has_topological_neighbor(), libMesh::XdrSOLN::header(), libMesh::XdrMESH::header(), libMesh::MeshFunction::hessian(), libMesh::DofMap::heterogenously_constrain_element_matrix_and_vector(), libMesh::Parallel::Histogram< KeyType, IdxType >::Histogram(), libMesh::StatisticsVector< T >::histogram(), libMesh::DofObject::id(), libMesh::AdaptiveTimeSolver::init(), libMesh::QComposite< QSubCell >::init(), libMesh::AnalyticFunction< Output >::init(), libMesh::PointLocatorTree::init(), libMesh::PointLocatorList::init(), libMesh::MeshFunction::init(), libMesh::EigenSparseMatrix< T >::init(), libMesh::LaspackMatrix< T >::init(), libMesh::EpetraMatrix< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::PetscMatrix< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::DifferentiableSystem::init_data(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::InfFE< Dim, T_radial, T_map >::init_face_shape_functions(), libMesh::ImplicitSystem::init_matrices(), libMesh::InfFE< Dim, T_radial, T_map >::init_radial_shape_functions(), libMesh::InfFE< Dim, T_radial, T_map >::init_shape_functions(), libMesh::FESubdivision::init_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), libMesh::ParmetisPartitioner::initialize(), libMesh::ContinuationSystem::initialize_tangent(), libMesh::EpetraVector< T >::inputValues(), libMesh::TreeNode< N >::insert(), libMesh::NumericVector< T >::insert(), libMesh::MeshData::insert_elem_data(), libMesh::MeshData::insert_node_data(), libMesh::FEMContext::interior_curl(), libMesh::FEMContext::interior_div(), libMesh::Elem::interior_parent(), libMesh::FE< Dim, T >::inverse_map(), libMesh::InfFE< Dim, T_radial, T_map >::inverse_map(), libMesh::ErrorVector::is_active_elem(), libMesh::SystemNorm::is_discrete(), libMesh::SparsityPattern::Build::join(), libMesh::DistributedVector< T >::l1_norm(), libMesh::LaspackVector< T >::l1_norm(), libMesh::EigenSparseVector< T >::l1_norm(), libMesh::EpetraVector< T >::l1_norm(), libMesh::PetscVector< T >::l1_norm(), libMesh::EpetraMatrix< T >::l1_norm(), libMesh::DenseMatrix< T >::l1_norm(), libMesh::PetscMatrix< T >::l1_norm(), libMesh::DistributedVector< T >::l2_norm(), libMesh::LaspackVector< T >::l2_norm(), libMesh::EigenSparseVector< T >::l2_norm(), libMesh::EpetraVector< T >::l2_norm(), libMesh::PetscVector< T >::l2_norm(), libMesh::DistributedVector< T >::last_local_index(), libMesh::LaspackVector< T >::last_local_index(), libMesh::EigenSparseVector< T >::last_local_index(), libMesh::EpetraVector< T >::last_local_index(), libMesh::PetscVector< T >::last_local_index(), libMesh::MeshTools::libmesh_assert_connected_nodes(), libMesh::MeshTools::libmesh_assert_no_links_to_elem(), libMesh::MeshTools::libmesh_assert_old_dof_objects(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_node_pointers(), libMesh::Elem::libmesh_assert_valid_node_pointers(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_flags(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), libMesh::LibMeshInit::LibMeshInit(), libMesh::DistributedVector< T >::linfty_norm(), libMesh::LaspackVector< T >::linfty_norm(), libMesh::EigenSparseVector< T >::linfty_norm(), libMesh::EpetraVector< T >::linfty_norm(), libMesh::PetscVector< T >::linfty_norm(), libMesh::EpetraMatrix< T >::linfty_norm(), libMesh::DenseMatrix< T >::linfty_norm(), libMesh::PetscMatrix< T >::linfty_norm(), libMesh::NumericVector< T >::local_relative_compare(), libMesh::DistributedVector< T >::local_size(), libMesh::LaspackVector< T >::local_size(), libMesh::EigenSparseVector< T >::local_size(), libMesh::EpetraVector< T >::local_size(), libMesh::PetscVector< T >::local_size(), libMesh::DofMap::local_variable_indices(), libMesh::LaspackVector< T >::localize(), libMesh::DistributedVector< T >::localize(), libMesh::EigenSparseVector< T >::localize(), libMesh::EpetraVector< T >::localize(), libMesh::PetscVector< T >::localize(), libMesh::DistributedVector< T >::localize_to_one(), libMesh::EpetraVector< T >::localize_to_one(), libMesh::SumShellMatrix< T >::m(), libMesh::EigenSparseMatrix< T >::m(), libMesh::LaspackMatrix< T >::m(), libMesh::EpetraMatrix< T >::m(), libMesh::PetscMatrix< T >::m(), 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::FE< Dim, T >::map(), libMesh::InfFE< Dim, T_radial, T_map >::map(), libMesh::FE< Dim, T >::map_eta(), libMesh::PetscVector< T >::map_global_to_local_index(), libMesh::FE< Dim, T >::map_xi(), libMesh::FE< Dim, T >::map_zeta(), libMesh::EpetraMatrix< T >::mat(), libMesh::PetscMatrix< T >::mat(), libMesh::DistributedVector< T >::max(), libMesh::DenseVector< T >::max(), libMesh::LaspackVector< T >::max(), libMesh::EigenSparseVector< T >::max(), libMesh::EpetraVector< T >::max(), libMesh::DenseMatrix< T >::max(), libMesh::Parallel::Communicator::max(), libMesh::DofMap::max_constraint_error(), libMesh::Elem::max_descendant_p_level(), libMesh::Parallel::Communicator::maxloc(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshBase::MeshBase(), libMesh::DistributedVector< T >::min(), libMesh::DenseVector< T >::min(), libMesh::LaspackVector< T >::min(), libMesh::EigenSparseVector< T >::min(), libMesh::EpetraVector< T >::min(), libMesh::DenseMatrix< T >::min(), libMesh::Parallel::Communicator::min(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Parallel::Communicator::minloc(), libMesh::SumShellMatrix< T >::n(), libMesh::EigenSparseMatrix< T >::n(), libMesh::LaspackMatrix< T >::n(), libMesh::EpetraMatrix< T >::n(), libMesh::PetscMatrix< T >::n(), libMesh::BoundaryInfo::n_boundary_ids(), libMesh::BoundaryInfo::n_edge_boundary_ids(), libMesh::MeshData::n_elem_data(), libMesh::MeshBase::n_elem_on_proc(), libMesh::FrequencySystem::n_frequencies(), libMesh::MeshData::n_node_data(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::QBase::n_points(), libMesh::FE< Dim, T >::n_quadrature_points(), libMesh::InfFE< Dim, T_radial, T_map >::n_quadrature_points(), libMesh::MeshData::n_val_per_elem(), libMesh::MeshData::n_val_per_node(), libMesh::PeriodicBoundaries::neighbor(), libMesh::InfFE< Dim, T_radial, T_map >::nodal_soln(), libMesh::FE< Dim, T >::nodal_soln(), libMesh::Elem::node(), libMesh::SerialMesh::node(), libMesh::ParallelMesh::node(), libMesh::TetGenIO::node_in(), libMesh::SerialMesh::node_ptr(), libMesh::ParallelMesh::node_ptr(), libMesh::MeshData::node_to_foreign_id(), libMesh::UNVIO::nodes_out(), libMesh::AdaptiveTimeSolver::nonlocal_residual(), libMesh::EigenTimeSolver::nonlocal_residual(), libMesh::DofMap::old_dof_indices(), on_command_line(), libMesh::Xdr::open(), libMesh::Predicates::abstract_multi_predicate< T >::operator()(), libMesh::WrappedFunction< Output >::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PointLocatorList::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::ElemCutter::operator()(), libMesh::PointLocatorTree::operator()(), libMesh::AnalyticFunction< Output >::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshFunction::operator()(), libMesh::ProjectSolution::operator()(), libMesh::ProjectFEMSolution::operator()(), libMesh::MeshData::operator()(), libMesh::EigenSparseMatrix< T >::operator()(), libMesh::LaspackMatrix< T >::operator()(), libMesh::EpetraMatrix< T >::operator()(), libMesh::BoundaryProjectSolution::operator()(), libMesh::DistributedVector< T >::operator()(), libMesh::LaspackVector< T >::operator()(), libMesh::EigenSparseVector< T >::operator()(), Pred< IterType, PredType >::operator()(), libMesh::EpetraVector< T >::operator()(), libMesh::PetscMatrix< T >::operator()(), libMesh::DistributedVector< T >::operator+=(), libMesh::LaspackVector< T >::operator+=(), libMesh::EigenSparseVector< T >::operator+=(), libMesh::EpetraVector< T >::operator+=(), libMesh::PetscVector< T >::operator+=(), libMesh::DistributedVector< T >::operator-=(), libMesh::LaspackVector< T >::operator-=(), libMesh::EigenSparseVector< T >::operator-=(), libMesh::EpetraVector< T >::operator-=(), libMesh::PetscVector< T >::operator-=(), libMesh::EigenSparseVector< T >::operator/=(), libMesh::EpetraVector< T >::operator/=(), libMesh::Xdr::operator<<(), libMesh::DistributedVector< T >::operator=(), libMesh::LaspackVector< T >::operator=(), libMesh::EigenSparseVector< T >::operator=(), libMesh::PetscVector< T >::operator=(), libMesh::Xdr::operator>>(), libMesh::vectormap< dof_id_type, dof_id_type >::operator[](), libMesh::Hex::opposite_node(), libMesh::Quad::opposite_node(), libMesh::Edge::opposite_node(), libMesh::Parallel::pack(), libMesh::XdrIO::pack_element(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshBase::partition(), libMesh::Elem::point(), libMesh::SerialMesh::point(), libMesh::ParallelMesh::point(), libMesh::FEMContext::point_curl(), libMesh::FEMContext::point_gradient(), libMesh::System::point_gradient(), libMesh::FEMContext::point_hessian(), libMesh::System::point_hessian(), libMesh::MeshBase::point_locator(), libMesh::FEMContext::point_value(), libMesh::System::point_value(), libMesh::LaspackMatrix< T >::pos(), libMesh::METIS_CSR_Graph::prepare_for_use(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::SparseMatrix< T >::print(), libMesh::NumericVector< T >::print(), libMesh::NumericVector< T >::print_global(), libMesh::QBase::print_info(), libMesh::PetscMatrix< T >::print_matlab(), libMesh::PetscVector< T >::print_matlab(), libMesh::EpetraMatrix< T >::print_personal(), libMesh::PetscMatrix< T >::print_personal(), libMesh::DofMap::process_constraints(), libMesh::System::project_vector(), libMesh::ProjectFEMSolution::ProjectFEMSolution(), libMesh::ProjectSolution::ProjectSolution(), libMesh::QComposite< QSubCell >::QComposite(), libMesh::SerialMesh::query_elem(), libMesh::ParallelMesh::query_elem(), libMesh::SerialMesh::query_node_ptr(), libMesh::ParallelMesh::query_node_ptr(), libMesh::BoundaryInfo::raw_boundary_ids(), libMesh::BoundaryInfo::raw_edge_boundary_ids(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::MeshData::read(), libMesh::PltLoader::read_block_data(), libMesh::CheckpointIO::read_connectivity(), libMesh::PltLoader::read_data(), libMesh::PltLoader::read_feblock_data(), libMesh::PltLoader::read_fepoint_data(), libMesh::PltLoader::read_header(), libMesh::System::read_header(), libMesh::UCDIO::read_implementation(), libMesh::System::read_legacy_data(), libMesh::GmshIO::read_mesh(), libMesh::System::read_parallel_data(), libMesh::PltLoader::read_point_data(), libMesh::XdrIO::read_serialized_bcs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::MeshData::read_unv(), libMesh::MeshData::read_unv_implementation(), libMesh::MeshData::read_xdr(), libMesh::Parallel::Communicator::receive(), libMesh::MeshTools::Modification::redistribute(), libMesh::Parallel::Communicator::reference_unique_tag(), libMesh::TreeNode< N >::refine(), libMesh::Elem::refine(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::AdaptiveTimeSolver::reinit(), libMesh::DifferentiableSystem::reinit(), libMesh::TimeSolver::reinit(), libMesh::FE< Dim, T >::reinit(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::FEXYZ< Dim >::reinit(), libMesh::DofMap::reinit(), REINIT_ERROR(), libMesh::BoundaryInfo::remove(), libMesh::DofMap::remove_adjoint_dirichlet_boundary(), libMesh::DofMap::remove_dirichlet_boundary(), libMesh::BoundaryInfo::remove_edge(), libMesh::BoundaryInfo::remove_side(), libMesh::ParallelMesh::renumber_dof_objects(), libMesh::SerialMesh::renumber_elem(), libMesh::ParallelMesh::renumber_elem(), libMesh::SerialMesh::renumber_node(), libMesh::ParallelMesh::renumber_node(), libMesh::SerialMesh::renumber_nodes_and_elements(), libMesh::Elem::replace_child(), libMesh::ParameterVector::resize(), libMesh::EpetraMatrix< T >::row_start(), libMesh::PetscMatrix< T >::row_start(), libMesh::EpetraMatrix< T >::row_stop(), libMesh::PetscMatrix< T >::row_stop(), libMesh::DofMap::SCALAR_dof_indices(), libMesh::LaspackVector< T >::scale(), libMesh::DistributedVector< T >::scale(), libMesh::EigenSparseVector< T >::scale(), libMesh::DofMap::scatter_constraints(), libMesh::HPCoarsenTest::select_refinement(), libMesh::Parallel::Communicator::send(), libMesh::EquationSystems::sensitivity_solve(), libMesh::ParameterPointer< T >::set(), libMesh::EigenSparseMatrix< T >::set(), libMesh::LaspackMatrix< T >::set(), libMesh::EpetraMatrix< T >::set(), libMesh::PetscMatrix< T >::set(), libMesh::DistributedVector< T >::set(), libMesh::LaspackVector< T >::set(), libMesh::EigenSparseVector< T >::set(), libMesh::Elem::set_child(), libMesh::DofObject::set_dof_number(), libMesh::FrequencySystem::set_frequencies(), libMesh::Elem::set_interior_parent(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::SystemNorm::set_off_diagonal_weight(), libMesh::DofObject::set_old_dof_object(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::SFCPartitioner::set_sfc_type(), libMesh::SystemNorm::set_type(), libMesh::MeshData::set_unv_header(), libMesh::SystemNorm::set_weight(), libMesh::Singleton::setup(), libMesh::FE< Dim, T >::shape(), libMesh::InfFE< Dim, T_radial, T_map >::shape(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::Side< SideType, ParentType >::Side(), libMesh::FEMContext::side_fe_reinit(), libMesh::FEMContext::side_gradient(), libMesh::FEMContext::side_hessian(), libMesh::AdaptiveTimeSolver::side_residual(), libMesh::EigenTimeSolver::side_residual(), libMesh::FEMContext::side_value(), libMesh::SideEdge< EdgeType, ParentType >::SideEdge(), libMesh::DistributedVector< T >::size(), libMesh::LaspackVector< T >::size(), libMesh::EigenSparseVector< T >::size(), libMesh::EpetraVector< T >::size(), libMesh::PetscVector< T >::size(), libMesh::MeshData::slim(), libMesh::TwostepTimeSolver::solve(), libMesh::NewtonSolver::solve(), libMesh::CondensedEigenSystem::solve(), libMesh::EigenSystem::solve(), libMesh::TimeSolver::solve(), libMesh::FrequencySystem::solve(), libMesh::PetscLinearSolver< T >::solve(), libMesh::EquationSystems::solve(), libMesh::ContinuationSystem::solve_tangent(), libMesh::SparsityPattern::sort_row(), libMesh::Parallel::StandardType< std::pair< T1, T2 > >::StandardType(), libMesh::DofMap::stash_dof_constraints(), libMesh::MemorySolutionHistory::store(), libMesh::MeshBase::sub_point_locator(), libMesh::DistributedVector< T >::sum(), libMesh::LaspackVector< T >::sum(), libMesh::EigenSparseVector< T >::sum(), libMesh::EpetraVector< T >::sum(), libMesh::PetscVector< T >::sum(), libMesh::Parallel::Communicator::sum(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_dofobject_data_by_xyz(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::Parallel::Request::test(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::Elem::top_parent(), libMesh::MeshRefinement::topological_neighbor(), libMesh::MeshData::translate(), libMesh::Tree< N >::Tree(), libMesh::TreeNode< N >::TreeNode(), libMesh::SystemNorm::type(), libMesh::DofObject::unique_id(), libMesh::Parallel::unpack(), libMesh::DofObject::unpack_indexing(), libMesh::Parallel::unpack_range(), libMesh::DofMap::unstash_dof_constraints(), libMesh::UnstructuredMesh::UnstructuredMesh(), libMesh::System::update(), libMesh::ContinuationSystem::update_solution(), libMesh::LaspackMatrix< T >::update_sparsity_pattern(), libMesh::EpetraMatrix< T >::update_sparsity_pattern(), libMesh::EpetraVector< T >::vec(), libMesh::PetscVector< T >::vec(), libMesh::System::vector_is_adjoint(), libMesh::System::vector_name(), libMesh::Edge3::volume(), libMesh::Prism6::volume(), libMesh::Hex8::volume(), libMesh::Parallel::Request::wait(), libMesh::SystemNorm::weight(), libMesh::SystemNorm::weight_sq(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), libMesh::Elem::which_child_am_i(), libMesh::Elem::which_neighbor_am_i(), libMesh::Elem::which_side_am_i(), libMesh::FroIO::write(), libMesh::ExodusII_IO::write(), libMesh::XdrIO::write(), libMesh::MeshData::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::CheckpointIO::write_bcs(), libMesh::GMVIO::write_binary(), libMesh::CheckpointIO::write_connectivity(), libMesh::Elem::write_connectivity(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::MeshOutput< MT >::write_equation_systems(), libMesh::UCDIO::write_header(), libMesh::System::write_header(), libMesh::UCDIO::write_implementation(), libMesh::UCDIO::write_interior_elems(), libMesh::GmshIO::write_mesh(), libMesh::LegacyXdrIO::write_mesh(), libMesh::UCDIO::write_nodal_data(), libMesh::UCDIO::write_nodes(), libMesh::CheckpointIO::write_nodesets(), libMesh::XdrIO::write_parallel(), libMesh::System::write_parallel_data(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::UCDIO::write_soln(), libMesh::GnuPlotIO::write_solution(), libMesh::DivaIO::write_stream(), libMesh::TypeVector< T >::write_unformatted(), libMesh::TypeTensor< T >::write_unformatted(), libMesh::MeshData::write_unv(), libMesh::MeshData::write_unv_implementation(), libMesh::MeshData::write_xdr(), libMesh::DistributedVector< T >::zero(), libMesh::LaspackVector< T >::zero(), libMesh::EigenSparseVector< T >::zero(), libMesh::EpetraVector< T >::zero(), libMesh::PetscVector< T >::zero(), libMesh::EpetraMatrix< T >::zero(), libMesh::PetscMatrix< T >::zero(), and libMesh::PetscMatrix< T >::zero_rows().

libMesh::libmesh_assert

(

j

)

libMesh::libmesh_assert

(

ctx

)

template<typename Tnew , typename Told >

Tnew libMesh::libmesh_cast_int

(

Told

oldvar

)

[inline]

Definition at line 556 of file libmesh_common.h.

{
  // we use the less redundantly named libMesh::cast_int now
  return cast_int<Tnew>(oldvar);
}

template<typename Tnew , typename Told >

Tnew libMesh::libmesh_cast_ptr

(

Told *

oldvar

)

[inline]

Definition at line 531 of file libmesh_common.h.

{
  // we use the less redundantly named libMesh::cast_ptr now
  return cast_ptr<Tnew>(oldvar);
}

template<typename Tnew , typename Told >

Tnew libMesh::libmesh_cast_ref

(

Told &

oldvar

)

[inline]

Definition at line 499 of file libmesh_common.h.

{
  // we use the less redundantly named libMesh::cast_ref now
  libmesh_deprecated();
  return cast_ref<Tnew>(oldvar);
}

template<typename T >

T libMesh::libmesh_conj

(

T

a

)

[inline]

Definition at line 159 of file libmesh_common.h.

Referenced by libMesh::DistributedVector< T >::conjugate(), libMesh::LaspackVector< T >::conjugate(), and libMesh::DenseVector< T >::dot().

{ return a; }

template<typename T >

std::complex<T> libMesh::libmesh_conj

(

std::complex< T >

a

)

[inline]

Definition at line 165 of file libmesh_common.h.

{ return std::conj(a); }

PetscErrorCode Vec Mat libMesh::libmesh_dbg_var

(

j

)

template<class T >

void libMesh::libmesh_ignore

(

const T &

)

[inline]

Definition at line 464 of file libmesh_common.h.

Referenced by libMesh::PetscMatrix< T >::init(), and libMesh::Parallel::StandardType< Point >::StandardType().

{ }

bool libMesh::libmesh_isnan

(

float

a

)

[inline]

Definition at line 169 of file libmesh_common.h.

References libmesh_C_isnan_float().

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

{ return libmesh_C_isnan_float(a); }

bool libMesh::libmesh_isnan

(

double

a

)

[inline]

Definition at line 170 of file libmesh_common.h.

References libmesh_C_isnan_double().

{ return libmesh_C_isnan_double(a); }

bool libMesh::libmesh_isnan

(

long double

a

)

[inline]

Definition at line 171 of file libmesh_common.h.

References libmesh_C_isnan_longdouble().

{ return libmesh_C_isnan_longdouble(a); }

template<typename T >

bool libMesh::libmesh_isnan

(

std::complex< T >

a

)

[inline]

Definition at line 174 of file libmesh_common.h.

References libmesh_isnan().

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

template<typename T >

T libMesh::libmesh_real

(

T

a

)

[inline]

Definition at line 158 of file libmesh_common.h.

Referenced by libMesh::FEMContext::_do_elem_position_set(), libMesh::ContinuationSystem::continuation_solve(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::DistributedVector< T >::max(), libMesh::DenseVector< T >::max(), libMesh::LaspackVector< T >::max(), libMesh::EigenSparseVector< T >::max(), libMesh::DenseMatrix< T >::max(), libMesh::DistributedVector< T >::min(), libMesh::DenseVector< T >::min(), libMesh::LaspackVector< T >::min(), libMesh::EigenSparseVector< 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().

{ return a; }

template<typename T >

T libMesh::libmesh_real

(

std::complex< T >

a

)

[inline]

Definition at line 162 of file libmesh_common.h.

{ return std::real(a); }

void libMesh::libmesh_terminate_handler

(

)

Definition at line 281 of file libmesh.C.

References libMesh::PerfLog::clear(), GLOBAL_COMM_WORLD, old_terminate_handler, perflog, libMesh::PerfLog::print_log(), and write_traceout().

Referenced by libMesh::LibMeshInit::LibMeshInit().

{
  // If this got called then we're probably crashing; let's print a
  // stack trace.  The trace files that are ultimately written depend on:
  // 1.) Who throws the exception.
  // 2.) Whether the C++ runtime unwinds the stack before the
  //     terminate_handler is called (this is implementation defined).
  //
  // The various cases are summarized in the table below:
  //
  //                        | libmesh exception | other exception
  //                        -------------------------------------
  // stack unwinds          |        A          |       B
  // stack does not unwind  |        C          |       D
  //
  // Case A: There will be two stack traces in the file: one "useful"
  //         one, and one nearly empty one due to stack unwinding.
  // Case B: You will get one nearly empty stack trace (not great, Bob!)
  // Case C: You will get two nearly identical stack traces, ignore one of them.
  // Case D: You will get one useful stack trace.
  //
  // Cases A and B (where the stack unwinds when an exception leaves
  // main) appear to be non-existent in practice.  I don't have a
  // definitive list, but the stack does not unwind for GCC on either
  // Mac or Linux.  I think there's good reasons for this behavior too:
  // it's much easier to get a stack trace when the stack doesn't
  // unwind, for example.
  libMesh::write_traceout();

  // We may care about performance data pre-crash; it would be sad to
  // throw that away.
  libMesh::perflog.print_log();
  libMesh::perflog.clear();

  // If we have MPI and it has been initialized, we need to be sure
  // and call MPI_Abort instead of std::abort, so that the parallel
  // job can die nicely.
#if defined(LIBMESH_HAVE_MPI)
  int mpi_initialized;
  MPI_Initialized (&mpi_initialized);

  if (mpi_initialized)
    MPI_Abort(libMesh::GLOBAL_COMM_WORLD, 1);
  else
#endif
    // The system terminate_handler may do useful things like printing
    // uncaught exception information, or the user may have created
    // their own terminate handler that we want to call.
    old_terminate_handler();
}

void libMesh::libmesh_version_stdout

(

)

Definition at line 20 of file libmesh_version.C.

References get_libmesh_version().

{
  std::cout << "--------------------------------------------------------" << std::endl;
  std::cout << "libMesh Library: Version = " << LIBMESH_LIB_VERSION;
  std::cout << " (" << get_libmesh_version() << ")" << std::endl << std::endl;

  std::cout << LIBMESH_LIB_RELEASE << std::endl << std::endl;

  std::cout << "Build Date   = " << LIBMESH_BUILD_DATE     << std::endl;
  std::cout << "Build Host   = " << LIBMESH_BUILD_HOST     << std::endl;
  std::cout << "Build User   = " << LIBMESH_BUILD_USER     << std::endl;
  std::cout << "Build Arch   = " << LIBMESH_BUILD_ARCH     << std::endl;
  std::cout << "Build Rev    = " << LIBMESH_BUILD_VERSION  << std::endl << std::endl;

  // CXXFLAGS is ambiguous wth multiple methods - could add all three but why not libmesh-config?
  //std::cout << "C++ Config   = " << LIBMESH_CXX << " " << LIBMESH_CXXFLAGS << std::endl;
  std::cout << "--------------------------------------------------------" << std::endl;

  return;
}

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		int	,
		Real
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		float	,
		Real
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		double	,
		Real
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		int	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		int	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		int	,
		Real
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		float	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		float	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		float	,
		Real
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		std::complex< float >	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		std::complex< float >	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		std::complex< float >	,
		Real
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		double	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		double	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		double	,
		Real
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		std::complex< double >	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		std::complex< double >	,
		Complex
	)

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		std::complex< double >	,
		Real
	)

template void libMesh::MeshCommunication::find_global_indices< MeshBase::const_element_iterator >	(	const Parallel::Communicator &	,
		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 Parallel::Communicator &	,
		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 Parallel::Communicator &	,
		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 Parallel::Communicator &	,
		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 88 of file libmesh_base.h.

References global_n_processors().

Referenced by libMesh::DofMap::add_constraints_to_send_list(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::AztecLinearSolver< T >::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::DistributedVector< T >::init(), libMesh::PetscVector< T >::localize(), libMesh::EpetraVector< T >::localize_to_one(), libMesh::PetscVector< T >::localize_to_one(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::SparseMatrix< T >::print(), libMesh::DofMap::print_dof_constraints(), libMesh::ParallelMesh::renumber_dof_objects(), libMesh::DofMap::scatter_constraints(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::Parallel::unpack(), and libMesh::VTKIO::write_nodal_data().

{
  return libMesh::global_n_processors();
}

unsigned int libMesh::n_threads

(

)

[inline]

Returns:

the maximum number of threads used in the simulation.

Definition at line 125 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::LibMeshInit::LibMeshInit(), libMesh::Threads::num_pthreads(), libMesh::Threads::parallel_for(), libMesh::Threads::parallel_reduce(), libMesh::FE< Dim, T >::shape(), libMesh::FE< Dim, T >::shape_deriv(), and libMesh::FE< Dim, T >::shape_second_deriv().

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

PetscInt* libMesh::numeric_petsc_cast

(

const numeric_index_type *

p

)

[inline]

Definition at line 1388 of file petsc_vector.h.

Referenced by libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::PetscMatrix< T >::add_block_matrix(), libMesh::PetscMatrix< T >::add_matrix(), libMesh::PetscVector< T >::create_subvector(), libMesh::PetscMatrix< T >::init(), libMesh::PetscVector< T >::insert(), and libMesh::PetscMatrix< T >::zero_rows().

{
  return reinterpret_cast<PetscInt*>(const_cast<numeric_index_type*>(p));
}

bool libMesh::on_command_line

(

const std::string &

arg

)

Returns:

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

Definition at line 816 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::command_line, and libmesh_assert().

Referenced by libMesh::ContinuationSystem::ContinuationSystem(), default_solver_package(), libMesh::DofMap::distribute_dofs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::NewtonSolver::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init_data(), libMesh::LibMeshInit::LibMeshInit(), petsc_auto_fieldsplit(), libMesh::System::read_header(), libMesh::TimeSolver::reinit(), libMesh::MacroFunctions::report_error(), libMesh::LinearImplicitSystem::solve(), libMesh::NonlinearImplicitSystem::solve(), libMesh::DofMap::use_coupled_neighbor_dofs(), and libMesh::LibMeshInit::~LibMeshInit().

{
  // Make sure the command line parser is ready for use
  libmesh_assert(command_line.get());

  return command_line->search (arg);
}

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.

{
  return v * factor;
}

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.

{
  return t * factor;
}

template<typename T >

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

Same as the print method above, but allows you to print to a stream in the standard syntax.

template <typename u>=""> friend std::ostream& operator << (std::ostream& os, const SparseMatrix<U>& m);

Obscure C++ note 1: the above syntax, which does not require any prior declaration of operator<<, declares *any* instantiation of SparseMatrix<X> is friend to *any* instantiation of operator<<(ostream&, SparseMatrix<Y>&). It would not happen in practice, but in principle it means that SparseMatrix<Complex> would be friend to operator<<(ostream&, SparseMatrix<Real>).

Obscure C++ note 2: The form below, which requires a previous declaration of the operator<<(stream&, SparseMatrix<T>&) function (see top of this file), means that any instantiation of SparseMatrix<T> is friend to the specialization operator<<(ostream&, SparseMatrix<T>&), but e.g. SparseMatrix<U> is *not* friend to the same function. So this is slightly different to the form above...

This method seems to be the "preferred" technique, see http://www.parashift.com/c++-faq-lite/template-friends.html

Definition at line 454 of file sparse_matrix.h.

{
  m.print(os);
  return os;
}

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

Definition at line 202 of file node.h.

References libMesh::Node::print_info().

{
  n.print_info(os);
  return os;
}

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

Same as above, but allows you to use the stream syntax.

Definition at line 208 of file quadrature.C.

References libMesh::QBase::print_info().

{
  q.print_info(os);
  return os;
}

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

Equivalent to calling print_info() above, but now you can write: Mesh mesh; libMesh::out << mesh << std::endl;

Definition at line 354 of file mesh_base.C.

References libMesh::MeshBase::print_info().

{
  m.print_info(os);
  return os;
}

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

Same as above, but allows you to use the stream syntax.

Definition at line 365 of file mesh_data.C.

References libMesh::MeshData::print_info().

{
  m.print_info(os);
  return os;
}

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

Definition at line 405 of file parameters.h.

References libMesh::Parameters::print().

{
  p.print(os);
  return os;
}

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

Same as above, but allows you to print to a stream.

Definition at line 777 of file fe_abstract.C.

References libMesh::FEAbstract::print_info().

{
  fe.print_info(os);
  return os;
}

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

Same as above, but allows you to also use stream syntax.

Definition at line 1259 of file equation_systems.C.

References libMesh::EquationSystems::print_info().

{
  es.print_info(os);
  return os;
}

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

Definition at line 1262 of file elem.h.

References libMesh::Elem::print_info().

{
  e.print_info(os);
  return os;
}

PetscMatrix<Number> J_input* libMesh::pc

(

)

PetscMatrix<Number> libMesh::PC	(	pc	,
		sys.	comm()
	)

Referenced by libMesh::PetscDiffSolver::init(), libMesh::PetscDiffSolver::reinit(), and libMesh::PetscPreconditioner< T >::set_petsc_subpreconditioner_type().

void libMesh::petsc_auto_fieldsplit	(	PC	my_pc,
		const System &	sys
	)

Definition at line 60 of file petsc_auto_fieldsplit.C.

References libMesh::ParallelObject::comm(), command_line_value(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), EXTERN_C_FOR_PETSC_END::indices_to_fieldsplit(), libMesh::DofMap::local_variable_indices(), libMesh::System::n_vars(), libMesh::System::name(), on_command_line(), and libMesh::System::variable_name().

Referenced by libMesh::PetscDiffSolver::init(), libMesh::PetscLinearSolver< T >::init_names(), and libMesh::PetscDiffSolver::reinit().

{
  std::string sys_prefix = "--solver_group_";

  if (libMesh::on_command_line("--solver_system_names"))
    {
      sys_prefix = sys_prefix + sys.name() + "_";
    }

  std::map<std::string, std::vector<dof_id_type> > group_indices;

  if (libMesh::on_command_line("--solver_variable_names"))
    {
      for (unsigned int v = 0; v != sys.n_vars(); ++v)
        {
          const std::string& var_name = sys.variable_name(v);

          std::vector<dof_id_type> var_idx;
          sys.get_dof_map().local_variable_indices
            (var_idx, sys.get_mesh(), v);

          std::string group_command = sys_prefix + var_name;

          const std::string empty_string;

          std::string group_name = libMesh::command_line_value
            (group_command, empty_string);

          if (group_name != empty_string)
            {
              std::vector<dof_id_type> &indices =
                group_indices[group_name];
              const bool prior_indices = !indices.empty();
              indices.insert(indices.end(), var_idx.begin(),
                             var_idx.end());
              if (prior_indices)
                std::sort(indices.begin(), indices.end());
            }
          else
            {
              indices_to_fieldsplit (sys.comm(), var_idx, my_pc, var_name);
            }
        }
    }

  for (std::map<std::string, std::vector<dof_id_type> >::const_iterator
         i = group_indices.begin(); i != group_indices.end(); ++i)
    {
      indices_to_fieldsplit(sys.comm(), i->second, my_pc, i->first);
    }
}

template<typename P >

void libMesh::print_helper	(	std::ostream &	os,
		const P *	param
	)

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

Definition at line 542 of file parameters.h.

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

{
  os << *param;
}

template<typename P >

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

Definition at line 549 of file parameters.h.

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

void libMesh::print_trace

(

std::ostream &

out_stream = std::cerr

)

[static]

Print a stack trace (for code compiled with gcc)

Definition at line 175 of file print_trace.C.

Referenced by libMesh::MacroFunctions::report_error(), and write_traceout().

{
  // First try a GDB backtrace.  They are better than what you get
  // from calling backtrace() because you don't have to do any
  // demangling, and they include line numbers!  If the GDB backtrace
  // fails, for example if your system does not have GDB, fall back to
  // calling backtrace().
  bool gdb_worked = gdb_backtrace(out_stream);

  // This part requires that your compiler at least supports
  // backtraces.  Demangling is also nice, but it will still run
  // without it.
#if defined(LIBMESH_HAVE_GLIBC_BACKTRACE)
  if (!gdb_worked)
    {
      void *addresses[40];
      char **strings;

      int size = backtrace(addresses, 40);
      strings = backtrace_symbols(addresses, size);
      out_stream << "Stack frames: " << size << std::endl;
      for(int i = 0; i < size; i++)
        out_stream << i << ": " << process_trace(strings[i]) << std::endl;
      std::free(strings);
    }
#endif
}

libMesh::processor_id_type libMesh::processor_id

(

)

[inline]

Returns:

the index of the local processor.

Definition at line 96 of file libmesh_base.h.

References global_processor_id().

Referenced by libMesh::DofMap::allgather_recursive_constraints(), libMesh::DofMap::get_info(), libMesh::DofMap::get_local_constraints(), libMesh::DistributedVector< T >::init(), libMesh::PetscMatrix< T >::init(), libMesh::SparsityPattern::Build::join(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::PetscVector< T >::localize_to_one(), libMesh::MeshInput< MT >::MeshInput(), libMesh::MeshOutput< MT >::MeshOutput(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::SparseMatrix< T >::print(), libMesh::DofMap::print_dof_constraints(), libMesh::NumericVector< T >::print_global(), libMesh::PetscMatrix< T >::print_personal(), libMesh::TetGenIO::read(), libMesh::GMVIO::read(), libMesh::LegacyXdrIO::read(), libMesh::VTKIO::read(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::LegacyXdrIO::read_mesh(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::ParallelMesh::renumber_dof_objects(), libMesh::DofMap::scatter_constraints(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::VTKIO::system_vectors_to_vtk(), libMesh::Parallel::unpack(), libMesh::EpetraMatrix< T >::update_sparsity_pattern(), libMesh::FroIO::write(), libMesh::TecplotIO::write(), libMesh::PostscriptIO::write(), libMesh::MEDITIO::write(), libMesh::GmshIO::write(), libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::TecplotIO::write_nodal_data(), libMesh::MEDITIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::GmshIO::write_nodal_data(), libMesh::GmshIO::write_post(), and libMesh::GnuPlotIO::write_solution().

{
  return libMesh::global_processor_id();
}

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

Definition at line 70 of file fe_boundary.C.

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

{
  libmesh_assert(elem);
  libmesh_assert (this->qrule != NULL || pts != NULL);
  // We now do this for 1D elements!
  // libmesh_assert_not_equal_to (Dim, 1);

  // Build the side of interest
  const UniquePtr<Elem> side(elem->build_side(s));

  // Find the max p_level to select
  // the right quadrature rule for side integration
  unsigned int side_p_level = elem->p_level();
  if (elem->neighbor(s) != NULL)
    side_p_level = std::max(side_p_level, elem->neighbor(s)->p_level());

  // Initialize the shape functions at the user-specified
  // points
  if (pts != NULL)
    {
      // The shape functions do not correspond to the qrule
      this->shapes_on_quadrature = false;

      // Initialize the face shape functions
      this->_fe_map->template init_face_shape_functions<Dim>(*pts, side.get());

      // Compute the Jacobian*Weight on the face for integration
      if (weights != NULL)
        {
          this->_fe_map->compute_face_map (Dim, *weights, side.get());
        }
      else
        {
          std::vector<Real> dummy_weights (pts->size(), 1.);
          this->_fe_map->compute_face_map (Dim, dummy_weights, side.get());
        }
    }
  // If there are no user specified points, we use the
  // quadrature rule
  else
    {
      // initialize quadrature rule
      this->qrule->init(side->type(), side_p_level);

      if(this->qrule->shapes_need_reinit())
        this->shapes_on_quadrature = false;

      // FIXME - could this break if the same FE object was used
      // for both volume and face integrals? - RHS
      // We might not need to reinitialize the shape functions
      if ((this->get_type() != elem->type())    ||
          (side->type() != last_side)           ||
          (this->get_p_level() != side_p_level) ||
          this->shapes_need_reinit()            ||
          !this->shapes_on_quadrature)
        {
          // Set the element type and p_level
          this->elem_type = elem->type();

          // Set the last_side
          last_side = side->type();

          // Set the last p level
          this->_p_level = side_p_level;

          // Initialize the face shape functions
          this->_fe_map->template init_face_shape_functions<Dim>(this->qrule->get_points(),  side.get());
        }

      // Compute the Jacobian*Weight on the face for integration
      this->_fe_map->compute_face_map (Dim, this->qrule->get_weights(), side.get());

      // The shape functions correspond to the qrule
      this->shapes_on_quadrature = true;
    }

  // make a copy of the Jacobian for integration
  const std::vector<Real> JxW_int(this->_fe_map->get_JxW());

  // make a copy of shape on quadrature info
  bool shapes_on_quadrature_side = this->shapes_on_quadrature;

  // Find where the integration points are located on the
  // full element.
  const std::vector<Point>* ref_qp;
  if (pts != NULL)
    ref_qp = pts;
  else
    ref_qp = &this->qrule->get_points();

  std::vector<Point> qp;
  this->side_map(elem, side.get(), s, *ref_qp, qp);

  // compute the shape function and derivative values
  // at the points qp
  this->reinit  (elem, &qp);

  this->shapes_on_quadrature = shapes_on_quadrature_side;

  // copy back old data
  this->_fe_map->get_JxW() = JxW_int;
}

libMesh::ScalarTraits_true

(

char

)

libMesh::ScalarTraits_true

(

short

)

libMesh::ScalarTraits_true

(

int

)

libMesh::ScalarTraits_true

(

long

)

libMesh::ScalarTraits_true

(

unsigned

char

)

libMesh::ScalarTraits_true

(

float

)

libMesh::ScalarTraits_true

(

double

)

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().

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

PetscErrorCode Vec Mat Mat void* ctx libMesh::START_LOG	(	"jacobian()"	,
		"PetscNonlinearSolver"
	)

Referenced by __libmesh_petsc_snes_residual(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::LinearPartitioner::_do_partition(), libMesh::MetisPartitioner::_do_partition(), libMesh::SFCPartitioner::_do_partition(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::SlepcEigenSolver< T >::_solve_generalized_helper(), libMesh::SlepcEigenSolver< T >::_solve_standard_helper(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::MeshRefinement::add_point(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::LaspackLinearSolver< T >::adjoint_solve(), libMesh::LinearSolver< T >::adjoint_solve(), libMesh::PetscLinearSolver< T >::adjoint_solve(), libMesh::ImplicitSystem::adjoint_solve(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::Parallel::Communicator::allgather(), libMesh::Parallel::Communicator::alltoall(), libMesh::FrequencySystem::assemble(), libMesh::System::assemble(), libMesh::FEMSystem::assemble_qoi(), libMesh::System::assemble_qoi(), libMesh::FEMSystem::assemble_qoi_derivative(), libMesh::System::assemble_qoi_derivative(), libMesh::FEMSystem::assembly(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Parallel::Communicator::barrier(), libMesh::System::boundary_project_vector(), libMesh::Parallel::Communicator::broadcast(), libMesh::DofMap::build_constraint_matrix(), libMesh::DofMap::build_constraint_matrix_and_vector(), libMesh::MeshTools::Generation::build_cube(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::EquationSystems::build_solution_vector(), libMesh::DofMap::build_sparsity(), libMesh::System::calculate_norm(), libMesh::PetscDiffSolver::clear(), libMesh::InfFE< Dim, T_radial, T_map >::combine_base_radial(), libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_edge_map(), libMesh::FEXYZMap::compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FEMap::compute_map(), libMesh::FEMap::compute_null_map(), libMesh::FEGenericBase< OutputType >::compute_shape_functions(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::DofMap::constrain_element_dyad_matrix(), libMesh::DofMap::constrain_element_matrix(), libMesh::DofMap::constrain_element_matrix_and_vector(), libMesh::DofMap::constrain_element_vector(), libMesh::UnstructuredMesh::contract(), libMesh::DofMap::create_dof_constraints(), libMesh::ErrorVector::cut_above(), libMesh::StatisticsVector< T >::cut_above(), libMesh::ErrorVector::cut_below(), libMesh::StatisticsVector< T >::cut_below(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshTools::Modification::distort(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::dof_indices(), libMesh::UNVIO::elements_in(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::UniformRefinementEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::UniformRefinementEstimator::estimate_errors(), libMesh::LocationMap< T >::find(), libMesh::MeshCommunication::find_global_indices(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Parallel::Communicator::gather(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::heterogenously_constrain_element_matrix_and_vector(), libMesh::DofMap::heterogenously_constrain_element_vector(), libMesh::StatisticsVector< T >::histogram(), libMesh::LocationMap< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::PointLocatorTree::init(), libMesh::PointLocatorList::init(), libMesh::FrequencySystem::init_data(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::InfFE< Dim, T_radial, T_map >::init_radial_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), libMesh::FE< Dim, T >::init_shape_functions(), libMesh::InfFE< Dim, T_radial, T_map >::init_shape_functions(), libMesh::FESubdivision::init_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), libMesh::NewmarkSystem::initial_conditions(), libMesh::FE< Dim, T >::inverse_map(), libMesh::InfFE< Dim, T_radial, T_map >::inverse_map(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Parallel::Communicator::max(), libMesh::StatisticsVector< T >::maximum(), libMesh::Parallel::Communicator::maxloc(), libMesh::ErrorVector::mean(), libMesh::StatisticsVector< T >::mean(), libMesh::StatisticsVector< T >::median(), libMesh::Parallel::Communicator::min(), libMesh::ErrorVector::minimum(), libMesh::StatisticsVector< T >::minimum(), libMesh::Parallel::Communicator::minloc(), libMesh::UNVIO::nodes_in(), libMesh::FEMSystem::numerical_elem_jacobian(), libMesh::FEMSystem::numerical_nonlocal_jacobian(), libMesh::FEMSystem::numerical_side_jacobian(), libMesh::DofMap::old_dof_indices(), libMesh::PointLocatorList::operator()(), libMesh::PointLocatorTree::operator()(), libMesh::PointLocatorTree::perform_linear_search(), libMesh::FEMSystem::postprocess(), libMesh::DofMap::prepare_send_list(), libMesh::Parallel::Communicator::probe(), libMesh::System::project_vector(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::MeshData::read(), libMesh::LegacyXdrIO::read_mesh(), libMesh::Parallel::Communicator::receive(), libMesh::MeshTools::Modification::redistribute(), libMesh::DofMap::reinit(), libMesh::SerialMesh::renumber_nodes_and_elements(), libMesh::ParallelMesh::renumber_nodes_and_elements(), libMesh::DofMap::SCALAR_dof_indices(), libMesh::HPSingularity::select_refinement(), libMesh::HPCoarsenTest::select_refinement(), libMesh::Parallel::Communicator::send(), libMesh::Parallel::Communicator::send_receive(), libMesh::Parallel::Communicator::send_receive_packed_range(), libMesh::ImplicitSystem::sensitivity_solve(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::Partitioner::single_partition(), libMesh::EigenSparseLinearSolver< T >::solve(), libMesh::NewtonSolver::solve(), libMesh::LaspackLinearSolver< T >::solve(), libMesh::CondensedEigenSystem::solve(), libMesh::PetscDiffSolver::solve(), libMesh::AztecLinearSolver< T >::solve(), libMesh::PetscNonlinearSolver< T >::solve(), libMesh::FrequencySystem::solve(), libMesh::NonlinearImplicitSystem::solve(), libMesh::PetscLinearSolver< T >::solve(), libMesh::SerialMesh::stitch_meshes(), libMesh::Parallel::Communicator::sum(), libMesh::BoundaryInfo::sync(), libMesh::MeshData::translate(), libMesh::EquationSystems::update(), libMesh::NewmarkSystem::update_rhs(), libMesh::NewmarkSystem::update_u_v_a(), libMesh::ErrorVector::variance(), libMesh::StatisticsVector< T >::variance(), libMesh::Parallel::Request::wait(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), libMesh::ImplicitSystem::weighted_sensitivity_solve(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::UnstructuredMesh::write(), libMesh::MeshData::write(), libMesh::EquationSystems::write(), libMesh::MeshOutput< MT >::write_equation_systems(), libMesh::LegacyXdrIO::write_mesh(), libMesh::TecplotIO::write_nodal_data(), libMesh::GnuPlotIO::write_nodal_data(), libMesh::MEDITIO::write_nodal_data(), libMesh::GmshIO::write_nodal_data(), libMesh::Nemesis_IO::write_nodal_data(), libMesh::GMVIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), and libMesh::ExodusII_IO::write_nodal_data_discontinuous().

libMesh::static_assert	(	sizeof(PetscInt)	= =sizeof(numeric_index_type),
		"PETSc and libMesh integer sizes must match!"
	)

libMesh::SUPERTYPE	(	unsigned	char,
		short
	)

libMesh::SUPERTYPE	(	unsigned	char,
		int
	)

libMesh::SUPERTYPE	(	unsigned	char,
		float
	)

libMesh::SUPERTYPE	(	unsigned	char,
		double
	)

libMesh::SUPERTYPE	(	unsigned	char,
		long	double
	)

libMesh::SUPERTYPE	(	char	,
		short
	)

libMesh::SUPERTYPE	(	char	,
		int
	)

libMesh::SUPERTYPE	(	char	,
		float
	)

libMesh::SUPERTYPE	(	char	,
		double
	)

libMesh::SUPERTYPE	(	char	,
		long	double
	)

libMesh::SUPERTYPE	(	short	,
		int
	)

libMesh::SUPERTYPE	(	short	,
		float
	)

libMesh::SUPERTYPE	(	short	,
		double
	)

libMesh::SUPERTYPE	(	short	,
		long	double
	)

libMesh::SUPERTYPE	(	int	,
		float
	)

libMesh::SUPERTYPE	(	int	,
		double
	)

libMesh::SUPERTYPE	(	int	,
		long	double
	)

libMesh::SUPERTYPE	(	float	,
		double
	)

libMesh::SUPERTYPE	(	float	,
		long	double
	)

libMesh::SUPERTYPE	(	double	,
		long	double
	)

X_input libMesh::swap

(

X_system

)

Referenced by libMesh::DenseMatrix< T >::_lu_back_substitute(), libMesh::DenseMatrix< T >::_multiply_blas(), libMesh::Elem::compute_key(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::Utility::deallocate(), libMesh::SystemSubsetBySubdomain::init(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::Utility::ReverseBytes::operator()(), libMesh::PeriodicBoundary::PeriodicBoundary(), libMesh::DofMap::prepare_send_list(), libMesh::TreeNode< N >::refine(), libMesh::SerialMesh::renumber_nodes_and_elements(), libMesh::SparsityPattern::sort_row(), libMesh::DenseMatrix< T >::swap(), libMesh::EpetraMatrix< T >::swap(), libMesh::DistributedVector< T >::swap(), libMesh::LaspackVector< T >::swap(), libMesh::EigenSparseVector< T >::swap(), libMesh::EpetraVector< T >::swap(), libMesh::PetscVector< T >::swap(), libMesh::NumericVector< T >::swap(), libMesh::TreeNode< N >::transform_nodes_to_elements(), and libMesh::BuildProjectionList::unique().

J_input libMesh::swap

(

J_system

)

X_global libMesh::swap

(

X_sys

)

Jac libMesh::swap

(

Jac_sys

)

bool libMesh::warned_about_auto_ptr

(

false

)

void libMesh::write_traceout

(

)

Writes a stack trace to a uniquely named file if --enable-tracefiles has been set by configure, otherwise does nothing. Note that we append to the trace file rather than overwriting it. This allows multiple traces to be written to the same file.

Definition at line 206 of file print_trace.C.

References global_processor_id(), and print_trace().

Referenced by libmesh_terminate_handler(), and libMesh::MacroFunctions::report_error().

{
#ifdef LIBMESH_ENABLE_TRACEFILES
  std::stringstream outname;
  outname << "traceout_" << static_cast<std::size_t>(libMesh::global_processor_id()) << '_' << getpid() << ".txt";
  std::ofstream traceout(outname.str().c_str(), std::ofstream::app);
  libMesh::print_trace(traceout);
#endif
}

PetscVector<Number> libMesh::X_global	(	x	,
		sys.	comm()
	)

Referenced by __libmesh_petsc_snes_residual(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), and DMlibMeshFunction().

PetscVector<Number> libMesh::X_input	(	x	,
		sys.	comm()
	)

Referenced by __libmesh_petsc_diff_solver_residual().

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< std::string > >	(	std::vector< std::string > &	,
		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 long long > >	(	std::vector< unsigned long long > &	,
		const char *
	)

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

---

Variable Documentation

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 188 of file libmesh.C.

Referenced by libMesh::LibMeshInit::LibMeshInit().

Parallel::Communicator libMesh::CommWorld

The default libMesh communicator.

If this communicator is disabled, we also disable it as a default argument to functions which accept a default communicator argument. This should expose implicit uses of the default communicator as compile-time rather than run-time errors.

The macro LIBMESH_CAN_DEFAULT_TO_COMMWORLD effects this functionality; it is empty (and so leaves arguments with no default value) if the default is disabled, and it sets something equal to the default otherwise.

Definition at line 199 of file libmesh.C.

Referenced by libMesh::NumericVector< T >::build().

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.

libMesh::EIGEN_SOLVERS

Definition at line 253 of file libmesh.C.

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

OStreamProxy libMesh::err

Definition at line 232 of file libmesh_common.h.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::MetisPartitioner::_do_partition(), libMesh::SFCPartitioner::_do_partition(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::MeshData::activate(), libMesh::QComposite< QSubCell >::add_subelem_values(), libMesh::LaspackLinearSolver< T >::adjoint_solve(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Factory< Base >::build(), libMesh::Patch::build_around_element(), cast_ptr(), cast_ref(), libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::Elem::contains_point(), libMesh::GMVIO::copy_nodal_solution(), libMesh::ElemCutter::cut_2D(), libMesh::ElemCutter::cut_3D(), libMesh::MeshData::enable_compatibility_mode(), libMesh::ParsedFunction< Output, OutputGradient >::eval(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::PetscLinearSolver< T >::get_converged_reason(), libMesh::PetscLinearSolver< T >::get_initial_residual(), libMesh::UNVIO::groups_in(), libMesh::MacroFunctions::here(), libMesh::PointLocatorTree::init(), libMesh::PointLocatorList::init(), libMesh::QJacobi::init_1D(), libMesh::InfFE< Dim, T_radial, T_map >::init_shape_functions(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::EpetraVector< T >::inputNonlocalValues(), libMesh::FEInterface::inverse_map(), libMesh::FE< Dim, T >::inverse_map(), libMesh::InfFE< Dim, T_radial, T_map >::inverse_map(), EXTERN_C_FOR_PETSC_END::libmesh_handleFPE(), EXTERN_C_FOR_PETSC_END::libmesh_handleSEGV(), libMesh::LibMeshInit::LibMeshInit(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::HCurlFETransformation< OutputShape >::map_d2phi(), libMesh::HCurlFETransformation< OutputShape >::map_div(), libMesh::HCurlFETransformation< OutputShape >::map_dphi(), libMesh::InfFE< Dim, T_radial, T_map >::nodal_soln(), libMesh::MeshDataUnvHeader::operator=(), libMesh::ErrorVector::plot_error(), libMesh::TetGenMeshInterface::process_hull_integrity_result(), libMesh::Elem::quality(), libMesh::Nemesis_IO::read(), libMesh::GMVIO::read(), libMesh::MeshData::read(), libMesh::LegacyXdrIO::read_binary(), libMesh::ExodusII_IO_Helper::read_elemental_var_values(), libMesh::PltLoader::read_header(), libMesh::GmshIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_nodal_var_values(), libMesh::DofMap::reinit(), libMesh::MacroFunctions::report_error(), libMesh::LaspackLinearSolver< T >::set_laspack_preconditioner_type(), libMesh::PetscPreconditioner< T >::set_petsc_preconditioner_type(), libMesh::PetscLinearSolver< T >::set_petsc_solver_type(), libMesh::TrilinosPreconditioner< T >::set_preconditioner_type(), libMesh::SlepcEigenSolver< T >::set_slepc_problem_type(), libMesh::SlepcEigenSolver< T >::set_slepc_solver_type(), libMesh::AztecLinearSolver< T >::set_solver_type(), libMesh::InfFE< Dim, T_radial, T_map >::shape(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::MeshData::slim(), libMesh::EigenSparseLinearSolver< T >::solve(), libMesh::LaspackLinearSolver< T >::solve(), libMesh::VTKIO::system_vectors_to_vtk(), libMesh::NameBasedIO::write(), libMesh::MeshData::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::TecplotIO::write_binary(), libMesh::LegacyXdrIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::UNVIO::write_implementation(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::VTKIO::write_nodal_data(), libMesh::NameBasedIO::write_nodal_data(), libMesh::GmshIO::write_post(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::DivaIO::write_stream(), libMesh::MeshData::write_unv_implementation(), libMesh::EnsightIO::write_vector_ascii(), and libMesh::LibMeshInit::~LibMeshInit().

DIE A HORRIBLE DEATH HERE typedef float libMesh::ErrorVectorReal

Definition at line 192 of file libmesh_common.h.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::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().

int libMesh::GLOBAL_COMM_WORLD = MPI_COMM_NULL

MPI Communicator used to initialize libMesh.

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

Definition at line 190 of file libmesh.C.

Referenced by libmesh_terminate_handler(), and libMesh::LibMeshInit::LibMeshInit().

PetscErrorCode libMesh::ierr = 0

Definition at line 172 of file petsc_nonlinear_solver.C.

Referenced by __libmesh_petsc_diff_solver_monitor(), __libmesh_petsc_preconditioner_apply(), __libmesh_petsc_preconditioner_setup(), __libmesh_petsc_snes_residual(), libMesh::PetscLinearSolver< T >::_create_complement_is(), libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::PetscLinearSolver< T >::_restrict_solve_to_is_local_size(), libMesh::SlepcEigenSolver< T >::_solve_generalized_helper(), libMesh::SlepcEigenSolver< T >::_solve_standard_helper(), libMesh::PetscMatrix< T >::add(), libMesh::PetscVector< T >::add(), libMesh::PetscMatrix< T >::add_block_matrix(), libMesh::PetscMatrix< T >::add_matrix(), libMesh::PetscVector< T >::add_vector(), libMesh::PetscVector< T >::add_vector_transpose(), libMesh::PetscLinearSolver< T >::adjoint_solve(), libMesh::Parallel::Communicator::allgather(), libMesh::Parallel::Communicator::alltoall(), libMesh::PetscPreconditioner< T >::apply(), libMesh::SlepcEigenSolver< T >::attach_deflation_space(), libMesh::Parallel::Communicator::broadcast(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::SlepcEigenSolver< T >::clear(), libMesh::PetscPreconditioner< T >::clear(), libMesh::PetscDiffSolver::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::PetscMatrix< T >::clear(), libMesh::PetscMatrix< T >::close(), libMesh::PetscMatrix< T >::closed(), libMesh::PetscVector< T >::conjugate(), DMCreateDomainDecomposition_libMesh(), DMCreateDomainDecompositionDM_libMesh(), DMCreateFieldDecomposition_libMesh(), DMCreateFieldDecompositionDM_libMesh(), DMlibMeshCreateDomainDecompositionDM(), DMlibMeshCreateFieldDecompositionDM(), DMlibMeshFunction(), DMlibMeshGetBlocks(), DMlibMeshGetSystem(), DMlibMeshGetSystem_libMesh(), DMlibMeshGetVariables(), DMlibMeshParseDecompositionDescriptor_Private(), DMlibMeshSetSystem(), DMlibMeshSetSystem_libMesh(), DMlibMeshSetUpName_Private(), libMesh::Parallel::Communicator::gather(), libMesh::PetscMatrix< T >::get_diagonal(), libMesh::SlepcEigenSolver< T >::get_eigenpair(), libMesh::SlepcEigenSolver< T >::get_eigenvalue(), libMesh::PetscLinearSolver< T >::get_initial_residual(), libMesh::SlepcEigenSolver< T >::get_relative_error(), libMesh::PetscLinearSolver< T >::get_residual_history(), libMesh::PetscMatrix< T >::get_transpose(), EXTERN_C_FOR_PETSC_END::indices_to_fieldsplit(), libMesh::SlepcEigenSolver< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::PetscPreconditioner< T >::init(), libMesh::PetscLinearSolver< T >::init(), libMesh::PetscMatrix< T >::init(), libMesh::PetscVector< T >::l1_norm(), libMesh::PetscMatrix< T >::l1_norm(), libMesh::PetscVector< T >::l2_norm(), libMesh::LibMeshInit::LibMeshInit(), libMesh::PetscVector< T >::linfty_norm(), libMesh::PetscMatrix< T >::linfty_norm(), libMesh::PetscMatrix< T >::m(), libMesh::PetscMatrix< T >::n(), libMesh::PetscMatrix< T >::operator()(), libMesh::PetscMatrix< T >::print_matlab(), libMesh::PetscMatrix< T >::print_personal(), libMesh::GMVIO::read(), libMesh::Parallel::Communicator::receive(), libMesh::PetscVector< T >::reciprocal(), libMesh::PetscDiffSolver::reinit(), libMesh::PetscLinearSolver< T >::restrict_solve_to(), libMesh::PetscMatrix< T >::row_start(), libMesh::PetscMatrix< T >::row_stop(), libMesh::Parallel::Communicator::send(), libMesh::PetscMatrix< T >::set(), libMesh::PetscVector< T >::set(), libMesh::PetscPreconditioner< T >::set_petsc_preconditioner_type(), libMesh::PetscLinearSolver< T >::set_petsc_solver_type(), libMesh::PetscPreconditioner< T >::set_petsc_subpreconditioner_type(), libMesh::SlepcEigenSolver< T >::set_slepc_position_of_spectrum(), libMesh::SlepcEigenSolver< T >::set_slepc_problem_type(), libMesh::SlepcEigenSolver< T >::set_slepc_solver_type(), SNESFunction_DMlibMesh(), libMesh::PetscDiffSolver::solve(), libMesh::PetscLinearSolver< T >::solve(), libMesh::SlepcEigenSolver< T >::solve_generalized(), libMesh::SlepcEigenSolver< T >::solve_standard(), libMesh::PetscVector< T >::sum(), libMesh::TecplotIO::write_binary(), libMesh::PetscMatrix< T >::zero(), and libMesh::PetscMatrix< T >::zero_rows().

const Number libMesh::imaginary

The imaginary unit, .

libMesh::INSTANTIATE_SUBDIVISION_FE

Definition at line 596 of file fe.C.

libMesh::INSTANTIATE_SUBDIVISION_MAPS

Definition at line 1396 of file fe_map.C.

libMesh::INVALID_SOLVER_PACKAGE

Definition at line 257 of file libmesh.C.

Referenced by default_solver_package().

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 172 of file libmesh.h.

Referenced by libMesh::FEMContext::_do_elem_position_set(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::CompositeFunction< Output >::attach_subfunction(), libMesh::CompositeFEMFunction< Output >::attach_subfunction(), libMesh::CompositeFunction< Output >::component(), libMesh::CompositeFEMFunction< Output >::component(), 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::Xdr::data_stream(), libMesh::FEMContext::elem_position_get(), libMesh::MeshTools::find_nodal_neighbors(), 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::Pyramid13::n_second_order_adjacent_vertices(), libMesh::Pyramid14::n_second_order_adjacent_vertices(), libMesh::Hex27::n_second_order_adjacent_vertices(), libMesh::Prism18::n_second_order_adjacent_vertices(), libMesh::InfHex18::n_second_order_adjacent_vertices(), libMesh::FEMSystem::numerical_jacobian(), libMesh::DofMap::old_dof_indices(), libMesh::MeshDataUnvHeader::read(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::Node::valence(), 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().

PetscMatrix<Number>& libMesh::J_system

Initial value:

      *cast_ptr<PetscMatrix<Number>*>(sys.matrix)

Definition at line 168 of file petsc_diff_solver.C.

PetscErrorCode Vec Mat libMesh::jac

Definition at line 167 of file petsc_nonlinear_solver.C.

PetscMatrix<Number>& libMesh::Jac_sys = *cast_ptr<PetscMatrix<Number>*>(sys.matrix)

Definition at line 199 of file petsc_nonlinear_solver.C.

libMesh::LASPACK_SOLVERS

Definition at line 255 of file libmesh.C.

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

MPI_Errhandler libMesh::libmesh_errhandler

Definition at line 240 of file libmesh.C.

Referenced by libMesh::LibMeshInit::LibMeshInit().

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 279 of file libmesh.C.

Referenced by libmesh_terminate_handler(), libMesh::LibMeshInit::LibMeshInit(), and libMesh::LibMeshInit::~LibMeshInit().

OStreamProxy libMesh::out

Definition at line 231 of file libmesh_common.h.

Referenced by __libmesh_petsc_diff_solver_monitor(), __libmesh_petsc_diff_solver_residual(), __libmesh_petsc_snes_monitor(), libMesh::FEMSystem::assembly(), libMesh::System::attach_assemble_function(), libMesh::System::attach_assemble_object(), libMesh::System::attach_constraint_function(), libMesh::System::attach_constraint_object(), libMesh::System::attach_init_function(), libMesh::System::attach_init_object(), libMesh::System::attach_QOI_derivative(), libMesh::System::attach_QOI_derivative_object(), libMesh::System::attach_QOI_function(), libMesh::System::attach_QOI_object(), libMesh::Parallel::Sort< KeyType, IdxType >::bin(), libMesh::QBase::build(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_side_list_from_node_list(), libMesh::DofMap::build_sparsity(), libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::MeshRefinement::coarsen_elements(), libMesh::EquationSystems::compare(), libMesh::System::compare(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ContinuationSystem::continuation_solve(), libMesh::ExodusII_IO_Helper::create(), libMesh::Nemesis_IO_Helper::create(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::DofObject::debug_buffer(), libMesh::UNVIO::elements_in(), libMesh::UNVIO::elements_out(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::Utility::get_timestamp(), libMesh::StatisticsVector< T >::histogram(), libMesh::XdrMGF::init(), libMesh::ContinuationSystem::initialize_tangent(), libMesh::LibMeshInit::LibMeshInit(), libMesh::NewtonSolver::line_search(), libMesh::Parallel::Communicator::maxloc(), libMesh::MeshInput< MT >::MeshInput(), libMesh::MeshOutput< MT >::MeshOutput(), libMesh::ExodusII_IO_Helper::message(), libMesh::Parallel::Communicator::minloc(), libMesh::UNVIO::nodes_in(), libMesh::UNVIO::nodes_out(), libMesh::ExodusII_IO_Helper::open(), libMesh::PointLocatorTree::operator()(), libMesh::DofMap::prepare_send_list(), libMesh::PetscNonlinearSolver< T >::print_converged_reason(), libMesh::EigenSparseLinearSolver< T >::print_converged_reason(), libMesh::LaspackLinearSolver< T >::print_converged_reason(), libMesh::LinearSolver< T >::print_converged_reason(), libMesh::NewtonSolver::print_convergence(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::PerfLog::print_log(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Tet::qual_bounds(), libMesh::Hex::qual_bounds(), libMesh::Tri::qual_bounds(), libMesh::Quad::qual_bounds(), libMesh::InfQuad::qual_bounds(), libMesh::PltLoader::read(), libMesh::TetGenIO::read(), libMesh::Nemesis_IO::read(), libMesh::EquationSystems::read(), libMesh::PltLoader::read_data(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::PltLoader::read_header(), libMesh::System::read_header(), libMesh::UNVIO::read_implementation(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::ExodusII_IO_Helper::read_var_names_impl(), libMesh::VariationalMeshSmoother::readgr(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::TetGenWrapper::set_switches(), libMesh::ContinuationSystem::set_Theta(), libMesh::ContinuationSystem::set_Theta_LOCA(), libMesh::TwostepTimeSolver::solve(), libMesh::NewtonSolver::solve(), libMesh::EigenSparseLinearSolver< T >::solve(), libMesh::UnsteadySolver::solve(), libMesh::EigenTimeSolver::solve(), libMesh::ContinuationSystem::solve_tangent(), libMesh::SerialMesh::stitching_helper(), libMesh::MacroFunctions::stop(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::ContinuationSystem::update_solution(), libMesh::Nemesis_IO::write(), libMesh::ExodusII_IO::write(), libMesh::XdrIO::write(), libMesh::TecplotIO::write_ascii(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::MeshOutput< MT >::write_equation_systems(), libMesh::Nemesis_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::GmshIO::write_post(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_var_names_impl(), libMesh::VariationalMeshSmoother::writegr(), libMesh::AutoPtr< Tp >::~AutoPtr(), and libMesh::LibMeshInit::~LibMeshInit().

PetscMatrix< Number > PC * libMesh::pc

Definition at line 143 of file petsc_diff_solver.C.

Referenced by libMesh::PetscNonlinearSolver< T >::init(), libMesh::PetscLinearSolver< T >::init_names(), libMesh::ImplicitSystem::sensitivity_solve(), libMesh::TrilinosPreconditioner< T >::set_preconditioner_type(), and libMesh::NoxNonlinearSolver< T >::solve().

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.

Referenced by libmesh_terminate_handler(), libMesh::LibMeshInit::LibMeshInit(), libMesh::Threads::parallel_for(), libMesh::Threads::parallel_reduce(), and libMesh::LibMeshInit::~LibMeshInit().

const Real libMesh::pi

Initial value:

  static_cast<Real>(3.1415926535897932384626433832795029L)

.

Definition at line 160 of file libmesh.h.

Referenced by libMesh::MeshTools::Generation::build_cube(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::FESubdivision::loop_subdivision_mask(), 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 128 of file libmesh_common.h.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::DenseMatrix< T >::_lu_decompose(), libMesh::FEMContext::_update_time_from_system(), libMesh::Plane::above_surface(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), libMesh::UnstructuredMesh::all_second_order(), libMesh::ContinuationSystem::apply_predictor(), libMesh::ImplicitSystem::assemble_residual_derivatives(), libMesh::FEMSystem::assembly(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::MeshTools::bounding_sphere(), libMesh::TreeNode< N >::bounds_point(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::SystemNorm::calculate_norm(), libMesh::System::calculate_norm(), libMesh::VTKIO::cells_to_vtk(), libMesh::Tet::choose_diagonal(), libMesh::NewmarkSystem::clear(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::FEMap::compute_edge_map(), libMesh::FEXYZMap::compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::FEMap::compute_single_point_map(), libMesh::QConical::conical_product_pyramid(), libMesh::MeshTools::BoundingBox::contains_point(), libMesh::InfQuad4::contains_point(), libMesh::InfPrism6::contains_point(), libMesh::InfHex8::contains_point(), libMesh::ContinuationSystem::continuation_solve(), libMesh::ExodusII_IO_Helper::create(), libMesh::Nemesis_IO_Helper::create(), libMesh::TreeNode< N >::create_bounding_box(), libMesh::XdrMGF::dataBlk(), libMesh::DenseMatrix< T >::det(), libMesh::Sphere::distance(), libMesh::EquationSystems::EquationSystems(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::MeshCommunication::find_global_indices(), libMesh::ElemCutter::find_intersection_points(), libMesh::ExactErrorEstimator::find_squared_element_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::MeshRefinement::flag_elements_by_nelem_target(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::ImplicitSystem::get_linear_solve_parameters(), libMesh::PerfLog::get_perf_info(), libMesh::NumericVector< T >::global_relative_compare(), libMesh::QGrundmann_Moller::gm_rule(), libMesh::FEHermite< Dim >::hermite_raw_shape(), libMesh::FEHermite< Dim >::hermite_raw_shape_deriv(), libMesh::FEHermite< Dim >::hermite_raw_shape_second_deriv(), libMesh::StatisticsVector< T >::histogram(), libMesh::Elem::hmax(), libMesh::Elem::hmin(), libMesh::PointLocatorTree::init(), libMesh::FEComputeData::init(), libMesh::QGrid::init_1D(), libMesh::QGauss::init_2D(), libMesh::QGrid::init_2D(), libMesh::QMonomial::init_2D(), libMesh::QGauss::init_3D(), libMesh::QGrid::init_3D(), libMesh::QMonomial::init_3D(), libMesh::FESubdivision::init_shape_functions(), libMesh::ContinuationSystem::initialize_tangent(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), libMesh::MeshTools::BoundingBox::intersect(), libMesh::FE< Dim, T >::inverse_map(), libMesh::InfFE< Dim, T_radial, T_map >::inverse_map(), libMesh::Tet::is_child_on_side_helper(), libMesh::ElemCutter::is_cut(), libMesh::QGauss::keast_rule(), libMesh::LocationMap< T >::key(), libMesh::QMonomial::kim_rule(), libMesh::DenseVector< T >::l1_norm(), libMesh::LaspackVector< T >::l1_norm(), libMesh::EpetraVector< T >::l1_norm(), libMesh::PetscVector< T >::l1_norm(), libMesh::EpetraMatrix< T >::l1_norm(), libMesh::DenseMatrix< T >::l1_norm(), libMesh::PetscMatrix< T >::l1_norm(), libMesh::StatisticsVector< T >::l2_norm(), libMesh::DenseVector< T >::l2_norm(), libMesh::LaspackVector< T >::l2_norm(), libMesh::EpetraVector< T >::l2_norm(), libMesh::PetscVector< T >::l2_norm(), libMesh::NewtonSolver::line_search(), libMesh::DenseVector< T >::linfty_norm(), libMesh::DistributedVector< T >::linfty_norm(), libMesh::LaspackVector< T >::linfty_norm(), libMesh::EpetraVector< T >::linfty_norm(), libMesh::PetscVector< T >::linfty_norm(), libMesh::EpetraMatrix< T >::linfty_norm(), libMesh::DenseMatrix< T >::linfty_norm(), libMesh::PetscMatrix< T >::linfty_norm(), libMesh::FESubdivision::loop_subdivision_mask(), libMesh::InfFE< Dim, T_radial, T_map >::map(), libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::DistributedVector< T >::max(), libMesh::DenseVector< T >::max(), libMesh::LaspackVector< T >::max(), libMesh::EigenSparseVector< T >::max(), libMesh::PetscVector< T >::max(), libMesh::DenseMatrix< T >::max(), libMesh::DofMap::max_constraint_error(), libMesh::ErrorVector::mean(), libMesh::StatisticsVector< T >::mean(), libMesh::StatisticsVector< T >::median(), libMesh::VariationalMeshSmoother::metr_data_gen(), libMesh::DistributedVector< T >::min(), libMesh::DenseVector< T >::min(), libMesh::LaspackVector< T >::min(), libMesh::EigenSparseVector< T >::min(), libMesh::PetscVector< T >::min(), libMesh::DenseMatrix< T >::min(), libMesh::Tri3::min_and_max_angle(), libMesh::Tet4::min_and_max_angle(), libMesh::NewmarkSystem::NewmarkSystem(), libMesh::TetGenIO::node_in(), libMesh::UNVIO::nodes_out(), libMesh::NonlinearImplicitSystem::NonlinearImplicitSystem(), libMesh::StatisticsVector< T >::normalize(), libMesh::FEMSystem::numerical_jacobian(), libMesh::FEAbstract::on_reference_element(), libMesh::Plane::on_surface(), libMesh::ExodusII_IO_Helper::open(), LIBMESH_DEFINE_HASH_POINTERS::FuzzyPointCompare::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PointLocatorList::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::Parallel::pack(), libMesh::Node::packed_size(), libMesh::ParsedFEMFunction< Output >::ParsedFEMFunction(), libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction(), libMesh::TriangleInterface::PolygonHole::point(), libMesh::Elem::point_test(), libMesh::QBase::print_info(), libMesh::DofMap::process_constraints(), libMesh::MeshTools::processor_bounding_sphere(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::Hex::quality(), libMesh::Tri::quality(), libMesh::InfHex::quality(), libMesh::Quad::quality(), libMesh::GmshIO::read_mesh(), libMesh::AbaqusIO::read_nodes(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::MeshData::read_tetgen(), libMesh::MeshData::read_unv_implementation(), libMesh::VariationalMeshSmoother::readgr(), libMesh::Elem::refine(), libMesh::FESubdivision::regular_shape(), libMesh::FESubdivision::regular_shape_deriv(), libMesh::FESubdivision::regular_shape_second_deriv(), libMesh::MemorySolutionHistory::retrieve(), libMesh::MeshTools::Modification::rotate(), libMesh::MeshTools::Modification::scale(), libMesh::QBase::scale(), libMesh::HPCoarsenTest::select_refinement(), libMesh::FrequencySystem::set_current_frequency(), libMesh::FrequencySystem::set_frequencies(), libMesh::FrequencySystem::set_frequencies_by_range(), libMesh::FrequencySystem::set_frequencies_by_steps(), libMesh::NewmarkSystem::set_newmark_parameters(), libMesh::NonlinearImplicitSystem::set_solver_parameters(), libMesh::FE< Dim, T >::shape(), libMesh::InfFE< Dim, T_radial, T_map >::shape(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::TypeTensor< T >::size_sq(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::Modification::smooth(), libMesh::TwostepTimeSolver::solve(), libMesh::NewtonSolver::solve(), libMesh::CondensedEigenSystem::solve(), libMesh::NoxNonlinearSolver< T >::solve(), libMesh::EigenSystem::solve(), libMesh::PetscNonlinearSolver< T >::solve(), libMesh::LinearImplicitSystem::solve(), libMesh::FrequencySystem::solve(), libMesh::ContinuationSystem::solve_tangent(), libMesh::PatchRecoveryErrorEstimator::specpoly(), libMesh::Sphere::Sphere(), libMesh::SerialMesh::stitching_helper(), libMesh::QMonomial::stroud_rule(), libMesh::MeshTools::subdomain_bounding_sphere(), libMesh::NumericVector< T >::subset_l1_norm(), libMesh::NumericVector< T >::subset_l2_norm(), libMesh::NumericVector< T >::subset_linfty_norm(), libMesh::Sphere::surface_coords(), libMesh::TypeVector< T >::unit(), libMesh::Parallel::unpack(), libMesh::ContinuationSystem::update_solution(), libMesh::ErrorVector::variance(), libMesh::StatisticsVector< T >::variance(), libMesh::Quad4::volume(), libMesh::Edge3::volume(), libMesh::Prism6::volume(), libMesh::Hex8::volume(), libMesh::Elem::volume(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), libMesh::ImplicitSystem::weighted_sensitivity_solve(), libMesh::Sphere::world_coords(), libMesh::PostscriptIO::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::GmshIO::write_mesh(), and libMesh::GnuPlotIO::write_solution().

const RemoteElem * libMesh::remote_elem

Definition at line 57 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::RemoteElem::create(), 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_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), libMesh::LibMeshInit::LibMeshInit(), 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::MeshRefinement::test_level_one(), libMesh::Parallel::unpack(), and libMesh::RemoteElem::~RemoteElem().

PetscNonlinearSolver< Number > * libMesh::solver

Initial value:

      *(static_cast<PetscDiffSolver*> (ctx))

Definition at line 152 of file petsc_diff_solver.C.

Referenced by __libmesh_petsc_diff_solver_monitor(), __libmesh_petsc_diff_solver_residual(), __libmesh_petsc_snes_residual(), libMesh::EigenSparseLinearSolver< T >::solve(), and libMesh::NoxNonlinearSolver< T >::solve().

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().

ImplicitSystem& libMesh::sys = solver.system()

Definition at line 154 of file petsc_diff_solver.C.

Referenced by __libmesh_petsc_diff_solver_residual(), __libmesh_petsc_snes_residual(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::EquationSystems::_read_impl(), libMesh::EquationSystems::allgather(), libMesh::ExactSolution::attach_exact_deriv(), libMesh::ExactSolution::attach_exact_hessian(), libMesh::EquationSystems::clear(), libMesh::ExactSolution::compute_error(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::GMVIO::copy_nodal_solution(), DMCreateDomainDecomposition_libMesh(), DMCreateFieldDecomposition_libMesh(), DMlibMeshFunction(), DMlibMeshGetSystem(), DMlibMeshSetSystem(), DMlibMeshSetSystem_libMesh(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ExactSolution::ExactSolution(), libMesh::System::read_legacy_data(), libMesh::EquationSystems::reinit(), libMesh::DifferentiablePhysics::set_mesh_system(), libMesh::FEMContext::set_mesh_system(), libMesh::NoxNonlinearSolver< T >::solve(), libMesh::VTKIO::system_vectors_to_vtk(), libMesh::EnsightIO::write_case(), and libMesh::EnsightIO::write_solution_ascii().

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

Definition at line 136 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::ProjectSolution::operator()(), libMesh::ProjectFEMSolution::operator()(), libMesh::BoundaryProjectSolution::operator()(), libMesh::TypeTensor< T >::operator==(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::Elem::refine(), libMesh::MemorySolutionHistory::retrieve(), libMesh::FE< Dim, T >::shape(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::NewtonSolver::solve(), libMesh::SerialMesh::stitching_helper(), libMesh::MemorySolutionHistory::store(), libMesh::TriangleInterface::triangulate(), libMesh::PointLocatorBase::unset_close_to_point_tol(), 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 251 of file libmesh.C.

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

bool libMesh::warned_about_auto_ptr

Referenced by libMesh::AutoPtr< Tp >::~AutoPtr().

PetscErrorCode Vec libMesh::x

Definition at line 143 of file petsc_diff_solver.C.

Referenced by libMesh::DenseMatrix< T >::_cholesky_back_substitute(), libMesh::SFCPartitioner::_do_partition(), libMesh::DenseMatrix< T >::_lu_back_substitute(), libMesh::DenseMatrix< T >::_matvec_blas(), libMesh::VariationalMeshSmoother::adp_renew(), libMesh::PetscPreconditioner< T >::apply(), libMesh::Utility::do_pow< 6, T >::apply(), libMesh::Utility::do_pow< 1, T >::apply(), libMesh::MeshTools::Generation::build_cube(), libMesh::VariationalMeshSmoother::gener(), libMesh::QMonomial::kim_rule(), libMesh::NewtonSolver::line_search(), libMesh::UNVIO::nodes_out(), libMesh::VariationalMeshSmoother::pcg_ic0(), libMesh::GmshIO::read_mesh(), libMesh::AbaqusIO::read_nodes(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::VariationalMeshSmoother::readgr(), libMesh::MeshTools::Modification::rotate(), libMesh::TetGenWrapper::set_hole(), libMesh::TetGenWrapper::set_node(), libMesh::TetGenWrapper::set_region(), libMesh::FE< Dim, T >::shape(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::NoxNonlinearSolver< T >::solve(), libMesh::PatchRecoveryErrorEstimator::specpoly(), libMesh::QMonomial::stroud_rule(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), and libMesh::TypeVector< T >::TypeVector().

PetscVector<Number>& libMesh::X_sys = *cast_ptr<PetscVector<Number>*>(sys.solution.get())

Definition at line 198 of file petsc_nonlinear_solver.C.

Referenced by __libmesh_petsc_snes_residual(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), and DMlibMeshFunction().

if (solver.verbose) libMesh PetscVector<Number>& libMesh::X_system

Initial value:

      *cast_ptr<PetscVector<Number>*>(sys.solution.get())

Definition at line 159 of file petsc_diff_solver.C.

Referenced by __libmesh_petsc_diff_solver_residual().

const Number libMesh::zero = 0.

.

Definition at line 166 of file libmesh.h.

Referenced by libMesh::DenseMatrix< T >::_lu_decompose(), libMesh::HPCoarsenTest::add_projection(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::PetscMatrix< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshData::operator()(), libMesh::System::read_legacy_data(), libMesh::DenseVector< T >::resize(), libMesh::DenseMatrix< T >::resize(), libMesh::HPCoarsenTest::select_refinement(), and libMesh::FE< Dim, T >::side_map().