libMesh Namespace Reference

Namespaces
	boostcopy
	DenseMatrices
	FiniteElements
	libMeshPrivateData
	MacroFunctions
	MeshTools
	Nemesis
	Parallel
	Predicates
	Quality
	Utility functions for computing element quality indicators.
	RBDataDeserialization
	RBDataSerialization
	ReferenceElem
	Namespace providing access to reference geometric element types.
	SparsityPattern
	Defines the sparsity pattern of a sparse matrix.
	TensorTools
	Threads
	Trees
	TriangleWrapper
	Namespace that wraps the Triangle mesh generator's API.
	Utility

Classes
class	AbaqusIO
class	AdaptiveTimeSolver
class	AdjointDofConstraintValues
class	AdjointRefinementEstimator
class	AdjointResidualErrorEstimator
class	AnalyticFunction
	Wraps a function pointer into a FunctionBase object. More...
class	AztecLinearSolver
class	BasicOStreamProxy
class	BoundaryInfo
	Used by the Mesh to keep track of boundary nodes and elements. More...
class	BoundaryMesh
	Specialized mesh used for keeping track of boundary elements. More...
class	BoundaryProjectSolution
class	BoundaryVolumeSolutionTransfer
class	BoundingBox
class	BuildProjectionList
class	Cell
	The base class for all 3D geometric element types. More...
class	CentroidPartitioner
class	CheckpointIO
struct	CompareElemIdsByLevel
struct	CompareTypes
struct	CompareTypes< MetaPhysicL::DynamicSparseNumberArray< T, I >, T2 >
struct	CompareTypes< std::complex< T >, T >
struct	CompareTypes< T, std::complex< T > >
struct	CompareTypes< T, T >
class	CompositeFEMFunction
	FEMFunction which is a function of another function. More...
class	CompositeFunction
	A function that returns a vector whose components are defined by multiple functions. More...
class	CondensedEigenSystem
	Extends EigenSystem to allow certain DOFs to be condensed out. More...
class	ConstCouplingAccessor
class	ConstCouplingRow
class	ConstCouplingRowConstIterator
class	ConstFEMFunction
	FEMFunction that returns a single value. More...
class	ConstFunction
	Function that returns a single value that never changes. More...
class	ConstParameterProxy
class	ConstTypeTensorColumn
class	ContinuationSystem
class	ConvergenceFailure
class	CouplingAccessor
class	CouplingMatrix
	Defines the coupling between variables of a System. More...
class	DefaultCoupling
class	DenseMatrix
	A matrix object used for finite element assembly and numerics. More...
class	DenseMatrixBase
class	DenseSubMatrix
class	DenseSubVector
class	DenseVector
class	DenseVectorBase
class	DGFEMContext
	Extends FEMContext to work for DG problems. More...
class	DiffContext
class	DifferentiablePhysics
class	DifferentiableQoI
class	DifferentiableSystem
class	DiffSolver
class	DirectSolutionTransfer
	Implements solution transfers for matched variable/mesh case. More...
class	DirichletBoundaries
class	DirichletBoundary
	Class for specifying Dirichlet boundary conditions as constraints. More...
class	DiscontinuityMeasure
class	DistributedMesh
	Mesh data structure which is distributed across all processors. More...
class	DistributedVector
class	DofConstraints
class	DofConstraintValueMap
class	DofMap
	Manages the degrees of freedom (DOFs) in a simulation. More...
class	DofObject
class	DSNAOutput
class	DSNAOutput< VectorValue< InnerOutput > >
class	DTKAdapter
class	DTKEvaluator
class	DTKSolutionTransfer
class	DynamicCastFailure
class	Edge
	The base class for all 1D geometric element types. More...
class	Edge2
	A 1D geometric element with 2 nodes. More...
class	Edge3
	A 1D geometric element with 3 nodes. More...
class	Edge4
	A 1D geometric element with 4 nodes. More...
class	EigenPreconditioner
class	EigenSolver
	Base class which defines the interface for solving eigenproblems. More...
class	EigenSparseLinearSolver
class	EigenSparseMatrix
class	EigenSparseVector
class	EigenSystem
	Manages consistently variables, degrees of freedom, and coefficient vectors for eigenvalue problems. More...
class	EigenTimeSolver
class	Elem
	The base class for all geometric element types. More...
class	ElemAssembly
class	ElemCutter
	Subdivides a single element using a mesh generator. More...
struct	ElemHashUtils
	A struct providing convenience functions for hashing elements. More...
class	EnsightIO
class	EpetraMatrix
class	EpetraVector
class	EquationSystems
	Manages multiples systems of equations. More...
class	ErrorEstimator
class	ErrorVector
class	Euler2Solver
class	EulerSolver
class	ExactErrorEstimator
class	ExactSolution
class	ExodusII_IO
	Handles reading and writing of Exodus binary files. More...
class	ExodusII_IO_Helper
class	ExplicitSystem
	Manages consistently variables, degrees of freedom, and coefficient vectors for explicit systems. More...
class	Face
	The base class for all 2D geometric element types. More...
class	Factory
	Handles name-based creation of objects. More...
class	FactoryImp
class	FastPoolAllocator
	Boost-derived allocator that can be used with std::containers. More...
class	FE
	Template class which generates the different FE families and orders. More...
class	FEAbstract
class	FEClough
class	FEComputeData
	Helper class used with FEInterface::compute_data(). More...
class	FEGenericBase
class	FEHermite
class	FEHierarchic
class	FEInterface
	Interface class which provides access to FE functions. More...
class	FEL2Hierarchic
class	FEL2Lagrange
class	FELagrange
class	FELagrangeVec
class	FEMap
	Computes finite element mapping function values, gradients, etc. More...
class	FEMContext
class	FEMFunctionBase
class	FEMFunctionWrapper
class	FEMonomial
class	FEMPhysics
class	FEMSystem
class	FENedelecOne
struct	FEOutputType
struct	FEOutputType< LAGRANGE_VEC >
struct	FEOutputType< NEDELEC_ONE >
class	FEScalar
class	FESubdivision
class	FETransformationBase
class	FEType
	Manages the family, order, etc. parameters for a given FE. More...
class	FEXYZ
class	FEXYZMap
	An implementation of FEMap for "XYZ" elements. More...
class	FileError
class	FirstOrderUnsteadySolver
class	FloatingPointException
class	FrequencySystem
class	FroIO
class	FunctionBase
	Base class for functors that can be evaluated at a point and (optionally) time. More...
class	GenericProjector
class	GhostingFunctor
class	GhostPointNeighbors
class	GmshIO
class	GMVIO
class	GnuPlotIO
class	H1FETransformation
class	HCurlFETransformation
class	Hex
	The base class for all hexahedral element types. More...
class	Hex20
	A 3D hexahedral element with 20 nodes. More...
class	Hex27
	A 3D hexahedral element with 27 nodes. More...
class	Hex8
	A 3D hexahedral element with 8 nodes. More...
class	HilbertSFCPartitioner
	Partitioner based on Hilbert's space filling curve algorithm. More...
class	HPCoarsenTest
class	HPSelector
class	HPSingularity
class	ImplicitSystem
	Manages consistently variables, degrees of freedom, coefficient vectors, and matrices for implicit systems. More...
class	InfCell
	The base class for all 3D infinite geometric element types. More...
class	InfEdge2
	A 1D infinite element with 2 nodes. More...
class	InfElemBuilder
class	InfFE
	Base class for all the infinite geometric element types. More...
class	InfHex
	The base class for all 3D infinite hexahedral element types. More...
class	InfHex16
	A 3D infinite hexahedral element with 16 nodes. More...
class	InfHex18
	A 3D infinite hexahedral element with 18 nodes. More...
class	InfHex8
	A 3D infinite hexahedral element with 8 nodes. More...
class	InfPrism
	The base class for all 3D infinite prismatic element types. More...
class	InfPrism12
	A 3D infinite prismatic element with 12 nodes. More...
class	InfPrism6
	A 3D infinite prismatic element with 6 nodes. More...
class	InfQuad
	The base class for all 2D infinite quadrilateral element types. More...
class	InfQuad4
	A 2D infinite quadrilateral element with 4 nodes. More...
class	InfQuad6
	A 2D infinite quadrilateral element with 6 nodes. More...
class	IntRange
class	InverseDistanceInterpolation
class	JumpErrorEstimator
class	KellyErrorEstimator
class	LaplaceMeshSmoother
class	LaplacianErrorEstimator
class	LaspackLinearSolver
class	LaspackMatrix
class	LaspackVector
class	LibMeshInit
class	LinearImplicitSystem
	Manages consistently variables, degrees of freedom, coefficient vectors, matrices and linear solvers for implicit systems. More...
class	LinearPartitioner
	Partitions the elements based solely on their ids. More...
class	LinearSolutionMonitor
class	LinearSolver
class	LocationMap
	std::map-like data structure using hashed Points for keys. More...
class	LogicError
class	MappedSubdomainPartitioner
	Partitions elements based on user-defined mapping from subdomain ids -> processor ids. More...
class	mapvector
class	MatlabIO
class	MatrixFillAction
class	MEDITIO
class	MemorySolutionHistory
	Stores past solutions in memory. More...
class	Mesh
	Manages a collection of Nodes and Elems. More...
struct	mesh_inserter_iterator
	An output iterator for use with packed_range functions. More...
class	MeshBase
	Base class for Mesh. More...
class	MeshCommunication
class	MeshfreeInterpolation
	Base class which defines the mesh-free interpolation interface. More...
class	MeshfreeSolutionTransfer
	A SolutionTransfer object that does "mesh free" interpolation. More...
class	MeshFunction
class	MeshFunctionSolutionTransfer
	SolutionTransfer object which uses a MeshFunction. More...
class	MeshInput
class	MeshOutput
class	MeshRefinement
	Responsible for mesh refinement algorithms and data. More...
class	MeshSerializer
	Temporarily serializes a DistributedMesh for output. More...
class	MeshSmoother
class	METIS_CSR_Graph
	Compressed graph data structure used by MetisPartitioner. More...
class	MetisPartitioner
	Partitioner which interfaces with the METIS library. More...
class	MortonSFCPartitioner
	Partitioner based on Morton's space filling curve algorithm. More...
struct	myhash
class	NameBasedIO
class	Nemesis_IO
class	Nemesis_IO_Helper
class	NewmarkSolver
class	NewmarkSystem
	Implements the Newmark time integration scheme. More...
class	NewtonSolver
class	NloptOptimizationSolver
class	Node
	A geometric point in (x,y,z) space associated with a DOF. More...
class	NodeConstraints
class	NodeElem
	A zero-dimensional geometric entity implementing the Elem interface. More...
class	NonlinearImplicitSystem
	Manages consistently variables, degrees of freedom, coefficient vectors, matrices and non-linear solvers for implicit systems. More...
class	NonlinearSolver
class	NoSolutionHistory
	For storing and retrieving timestep data. More...
class	NotImplemented
class	NoxNonlinearSolver
struct	null_output_iterator
	A do-nothing output iterator implementation. More...
class	NumericVector
	Provides a uniform interface to vector storage schemes for different linear algebra libraries. More...
class	OFFIO
	Reads OOF OOGL triangulated surface files. More...
class	OldSolutionBase
class	OldSolutionCoefs
class	OldSolutionValue
class	OptimizationSolver
class	OptimizationSystem
class	OrderWrapper
class	ParallelMesh
class	ParallelObject
	An object whose state is distributed along a set of processors. More...
class	ParameterAccessor
	Base class for reading/writing sensitivity parameters. More...
class	ParameterMultiAccessor
	Stores a user-provided pointer to a parameter. More...
class	ParameterMultiPointer
	Stores multiple user-provided pointers. More...
class	ParameterPointer
	Stores/modifies a user-provided pointer to a parameter. More...
class	ParameterProxy
class	Parameters
class	ParameterVector
	Specifies parameters for parameter sensitivity calculations. More...
class	ParmetisHelper
	Pointer-to-implementation class used by ParmetisPartitioner. More...
class	ParmetisPartitioner
	Partitioner which provides an interface to ParMETIS. More...
class	ParsedFEMFunction
	Support for using parsed functions in FEMSystem. More...
class	ParsedFEMFunctionParameter
	Stores a pointer to a ParsedFEMFunction and a string for the parameter. More...
class	ParsedFunction
	A Function defined by a std::string. More...
class	ParsedFunctionParameter
	Stores a pointer to a parsed function and a string for the parameter. More...
class	Partitioner
	Base class for all concrete Partitioner instantiations. More...
class	Patch
class	PatchRecoveryErrorEstimator
class	PerfData
	Data object managed by PerfLog. More...
struct	PerfItem
class	PerfLog
	Responsible for timing and summarizing events. More...
class	PerfMon
	A class for interfacing with hardware timers. More...
class	PeriodicBoundaries
	Maps between boundary ids and PeriodicBoundaryBase objects. More...
class	PeriodicBoundary
	Used for implementing periodic BCs via constraints. More...
class	PeriodicBoundaryBase
	Base class for all PeriodicBoundary implementations. More...
class	PetscDiffSolver
class	PetscDMWrapper
class	PetscLinearSolver
class	PetscMatrix
	SparseMatrix interface to PETSc Mat. More...
class	PetscNonlinearSolver
class	PetscPreconditioner
class	PetscSolverException
class	PetscVector
	NumericVector interface to PETSc Vec. More...
class	Plane
	A geometric object representing a planar surface. More...
class	PltLoader
class	Point
	A geometric point in (x,y,z) space. More...
class	PointerToPointerIter
class	PointLocatorBase
class	PointLocatorTree
class	PointNeighborCoupling
class	PoolAllocator
	Boost-derived allocator that can be used with std::containers. More...
class	PostscriptIO
class	Preconditioner
class	Prism
	The base class for all prismatic element types. More...
class	Prism15
	A 3D prismatic element with 15 nodes. More...
class	Prism18
	A 3D prismatic element with 18 nodes. More...
class	Prism6
	A 3D prismatic element with 6 nodes. More...
class	Problem_Interface
class	Pyramid
	The base class for all pyramid element types. More...
class	Pyramid13
	A 3D pyramid element with 13 nodes. More...
class	Pyramid14
	A 3D pyramid element with 14 nodes. More...
class	Pyramid5
	A 3D pyramid element with 5 nodes. More...
class	QBase
	Base class for all quadrature families and orders. More...
class	QClough
	Implements quadrature rules for Clough-Tocher macroelements. More...
class	QComposite
	A quadrature rule for subdivided elements. More...
class	QConical
	Conical product quadrature rules for Tri and Tet elements. More...
class	QGauss
	Implements 1, 2, and 3D "Gaussian" quadrature rules. More...
class	QGaussLobatto
	Implements 1D and 2/3D tensor product Gauss-Lobatto quadrature rules. More...
class	QGrid
	Implements grid-based quadrature rules suitable for non-smooth functions. More...
class	QGrundmann_Moller
	Implements the quadrature rules of Grundmann and Moller in 2D and 3D. More...
class	QJacobi
	Implements 1D Gauss-Jacobi quadrature rules of various orders. More...
class	QMonomial
	Implements quadrature rules for non-tensor polynomials. More...
class	QoISet
	Used to specify quantities of interest in a simulation. More...
class	QSimpson
	Implements Simpson's rule, i.e. nodal quadrature for quadratic elements. More...
class	QTrap
	Implements trapezoidal rule, i.e. nodal quadrature for linear elements. More...
class	Quad
	The base class for all quadrilateral element types. More...
class	Quad4
	A 2D quadrilateral element with 4 nodes. More...
class	Quad8
	A 2D quadrilateral element with 8 nodes. More...
class	Quad9
	A 2D quadrilateral element with 9 nodes. More...
class	QuadShell4
	A 2D quadrilateral shell element with 4 nodes. More...
class	QuadShell8
	A 2D quadrilateral shell element with 8 nodes. More...
class	RadialBasisInterpolation
	Does radial basis function interpolation using Nanoflann. More...
class	RawAccessor
class	RawAccessor< TypeNTensor< N, ScalarType > >
struct	RawFieldType
struct	RawFieldType< Gradient >
struct	RawFieldType< Number >
struct	RawFieldType< Real >
struct	RawFieldType< RealGradient >
struct	RawFieldType< RealTensor >
struct	RawFieldType< Tensor >
struct	RawFieldType< TypeNTensor< 3, Number > >
struct	RawFieldType< TypeNTensor< 3, Real > >
class	RBAssemblyExpansion
class	RBConstruction
class	RBConstructionBase
class	RBEIMAssembly
class	RBEIMConstruction
class	RBEIMEvaluation
class	RBEIMTheta
class	RBEvaluation
class	RBParameters
class	RBParametrized
class	RBParametrizedFunction
	Provides a reduced basis parameterized function. More...
class	RBSCMConstruction
class	RBSCMEvaluation
class	RBTemporalDiscretization
	Encapsulates the details of the generalized Euler discretization. More...
class	RBTheta
class	RBThetaExpansion
class	ReferenceCountedObject
class	ReferenceCounter
	Common base for all objects whose creations/destructions are counted. More...
class	RefinementSelector
class	RemoteElem
	Used by ParallelMesh to represent an Elem owned by another processor. More...
class	ReplicatedMesh
	Mesh data structure replicated on all processors. More...
class	ResidualContext
struct	ScalarTraits
struct	ScalarTraits< MetaPhysicL::DynamicSparseNumberArray< T, I > >
struct	ScalarTraits< std::complex< T > >
class	SecondOrderUnsteadySolver
class	SensitivityData
	Holds completed parameter sensitivity calculations. More...
class	SerialMesh
class	SFCPartitioner
	Partitioner based on different types of space filling curves. More...
class	ShellMatrix
class	SiblingCoupling
class	Side
	Proxy class for efficiently representing an Elem's side. More...
class	SideEdge
class	SimpleRange
class	Singleton
	Base class for all library singleton objects. More...
class	SlepcEigenSolver
	EigenSolver implementation based on SLEPc. More...
class	SolutionHistory
	For storing and retrieving timestep data. More...
class	SolutionTransfer
	Base class for all SolutionTransfer implementations. More...
class	SolverConfiguration
class	SolverException
class	SparseMatrix
class	SparseShellMatrix
class	Sphere
	A geometric object representing a sphere. More...
class	StatisticsVector
	A std::vector derived class for implementing simple statistical algorithms. More...
class	SteadySolver
class	StoredRange
	Utility class for defining generic ranges for threading. More...
class	SubdomainPartitioner
	Independently partitions chunks of subdomains and combines the results. More...
class	SumShellMatrix
class	Surface
	Base class for Plane and Sphere classes. More...
struct	SyncLocalIDs
struct	SyncNodalPositions
struct	SyncRefinementFlags
class	System
	Manages consistently variables, degrees of freedom, and coefficient vectors. More...
class	SystemNorm
class	SystemSubset
class	SystemSubsetBySubdomain
class	TaoOptimizationSolver
class	TecplotIO
class	TensorShellMatrix
class	TensorValue
class	TestClass
class	Tet
	The base class for all tetrahedral element types. More...
class	Tet10
	A 3D tetrahedral element with 10 nodes. More...
class	Tet4
	A 3D tetrahedral element with 4 nodes. More...
class	TetGenIO
class	TetGenMeshInterface
class	TetGenWrapper
class	TimeSolver
class	TopologyMap
	Enables topology-based lookups of nodes. More...
class	TransientRBAssemblyExpansion
class	TransientRBConstruction
class	TransientRBEvaluation
class	TransientRBThetaExpansion
class	TransientSystem
	Manages storage and variables for transient systems. More...
class	Tree
	Tree class templated on the number of leaves on each node. More...
class	TreeBase
class	TreeNode
	Base class for different Tree types. More...
class	Tri
	The base class for all triangular element types. More...
class	Tri3
	A 2D triangular element with 3 nodes. More...
class	Tri3Subdivision
	A surface shell element used in mechanics calculations. More...
class	Tri6
	A 2D triangular element with 6 nodes. More...
class	TriangleInterface
class	TrilinosPreconditioner
class	TriShell3
struct	tuple_n
struct	tuple_n< 0, T >
class	TwostepTimeSolver
class	TypeNTensor
struct	TypesEqual
struct	TypesEqual< T, T >
class	TypeTensor
class	TypeTensorColumn
class	TypeVector
class	UCDIO
class	UniformRefinementEstimator
class	UnsteadySolver
class	UnstructuredMesh
	Base class for Replicated and Distributed meshes. More...
class	UNVIO
class	Variable
	A variable which is solved for in a System of equations. More...
class	VariableGroup
class	VariationalMeshSmoother
class	vectormap
class	VectorSetAction
class	VectorValue
class	VTKIO
class	WeightedPatchRecoveryErrorEstimator
class	WendlandRBF
	Interface for evaluating Wendland's radial basis functions. More...
class	WrappedFunction
	Wrap a libMesh-style function pointer into a FunctionBase object. More...
class	WrappedFunctor
class	Xdr
	C++ interface for the XDR (eXternal Data Representation) format. More...
class	XdrIO
class	ZeroFunction
	ConstFunction that simply returns 0. More...

Typedefs
typedef DynamicSparseNumberArray< Real, dof_id_type >	DSNAN
template<typename T >
using	UniquePtr = std::unique_ptr< T >
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 std::unordered_multiset< Elem *, ElemHashUtils, ElemHashUtils >	unordered_multiset_elem
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 DistributedMesh	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
typedef TransientSystem< EigenSystem >	TransientEigenSystem
template<size_t I, typename T >
using	tuple_of = typename tuple_n< I, T >::template type<>

Enumerations
enum	VariableIndexing { SYSTEM_VARIABLE_ORDER = 0, LOCAL_VARIABLE_ORDER }
enum	LinearConvergenceReason : int {   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, DIVERGED_PCSETUP_FAILED = -11, CONVERGED_ITERATING = 0,   UNKNOWN_FLAG = -128 }
enum	EigenSolverType : int {   POWER =0, LAPACK, SUBSPACE, ARNOLDI,   LANCZOS, KRYLOVSCHUR, INVALID_EIGENSOLVER }
enum	EigenProblemType : int {   NHEP =0, HEP, GNHEP, GHEP,   GHIEP, INVALID_EIGENPROBLEMTYPE }
enum	PositionOfSpectrum : int {   LARGEST_MAGNITUDE =0, SMALLEST_MAGNITUDE, TARGET_MAGNITUDE, LARGEST_REAL,   SMALLEST_REAL, TARGET_REAL, LARGEST_IMAGINARY, SMALLEST_IMAGINARY,   TARGET_IMAGINARY, INVALID_Postion_of_Spectrum, INVALID_POSITION_OF_SPECTRUM }
enum	ElemQuality : int {   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 : int {   EDGE2 = 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, TRISHELL3 = 30, QUADSHELL4 = 31,   QUADSHELL8 = 32, INVALID_ELEM }
enum	ErrorEstimatorType : int {   INVALID = -1, ADJOINT_REFINEMENT = 0, ADJOINT_RESIDUAL = 1, DISCONTINUITY_MEASURE = 2,   EXACT = 3, KELLY = 4, LAPLACIAN = 5, PATCH_RECOVERY = 6,   WEIGHTED_PATCH_RECOVERY = 7, UNIFORM_REFINEMENT = 8 }
enum	FEFamily : int {   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 : int { DISCONTINUOUS, C_ZERO, C_ONE, H_CURL }
enum	FEFieldType : int { TYPE_SCALAR = 0, TYPE_VECTOR }
enum	InfMapType : int { CARTESIAN =0, SPHERICAL, ELLIPSOIDAL, INVALID_INF_MAP }
enum	IOPackage : int {   TECPLOT, GMV, GMSH, VTK,   DIVA, TETGEN, UCD, LIBMESH,   INVALID_IO_PACKAGE }
enum	FEMNormType : int {   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 : int {   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, 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 : int {   AUTOMATIC =0, SERIAL, PARALLEL, GHOSTED,   INVALID_PARALLELIZATION }
enum	PointLocatorType : int { TREE = 0, TREE_ELEMENTS, TREE_LOCAL_ELEMENTS, INVALID_LOCATOR }
enum	PreconditionerType : int {   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 : int {   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 : int { PETSC_SOLVERS =0, SLEPC_SOLVERS, NLOPT_SOLVERS }
enum	SolverType : int {   CG =0, CGN, CGS, CR,   QMR, TCQMR, TFQMR, BICG,   BICGSTAB, MINRES, GMRES, LSQR,   JACOBI, SOR_FORWARD, SOR_BACKWARD, SSOR,   RICHARDSON, CHEBYSHEV, SPARSELU, INVALID_SOLVER }
enum	SubsetSolveMode : int { SUBSET_ZERO = 0, SUBSET_COPY_RHS, SUBSET_DONT_TOUCH }
enum	XdrMODE : int {   UNKNOWN = -1, ENCODE =0, DECODE, WRITE,   READ }
enum	PetscMatrixType : int { AIJ =0, HYPRE }

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 (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 (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 unsigned short	command_line_value< unsigned short > (const std::string &, unsigned short)
template unsigned int	command_line_value< unsigned int > (const std::string &, unsigned int)
template short	command_line_value< short > (const std::string &, short)
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 unsigned short	command_line_value< unsigned short > (const std::vector< std::string > &, unsigned short)
template unsigned int	command_line_value< unsigned int > (const std::vector< std::string > &, unsigned int)
template short	command_line_value< short > (const std::vector< std::string > &, short)
template int	command_line_value< int > (const std::vector< std::string > &, int)
template float	command_line_value< float > (const std::vector< std::string > &, float)
template double	command_line_value< double > (const std::vector< std::string > &, double)
template long double	command_line_value< long double > (const std::vector< std::string > &, long double)
template std::string	command_line_value< std::string > (const std::vector< std::string > &, std::string)
template unsigned short	command_line_next< unsigned short > (std::string, unsigned short)
template unsigned int	command_line_next< unsigned int > (std::string, unsigned int)
template short	command_line_next< short > (std::string, short)
template int	command_line_next< int > (std::string, int)
template float	command_line_next< float > (std::string, float)
template double	command_line_next< double > (std::string, double)
template long double	command_line_next< long double > (std::string, long double)
template std::string	command_line_next< std::string > (std::string, std::string)
template void	command_line_vector< unsigned short > (const std::string &, std::vector< unsigned short > &)
template void	command_line_vector< unsigned int > (const std::string &, std::vector< unsigned int > &)
template void	command_line_vector< short > (const std::string &, std::vector< short > &)
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 (0, CLOUGH, reinit)
	REINIT_ERROR (0, CLOUGH, edge_reinit)
	SIDEMAP_ERROR (0, CLOUGH, side_map)
	REINIT_ERROR (0, HERMITE, reinit)
	REINIT_ERROR (0, HERMITE, edge_reinit)
	SIDEMAP_ERROR (0, HERMITE, side_map)
	REINIT_ERROR (0, HIERARCHIC, reinit)
	REINIT_ERROR (0, HIERARCHIC, edge_reinit)
	SIDEMAP_ERROR (0, HIERARCHIC, side_map)
	REINIT_ERROR (0, L2_HIERARCHIC, reinit)
	REINIT_ERROR (0, L2_HIERARCHIC, edge_reinit)
	SIDEMAP_ERROR (0, L2_HIERARCHIC, side_map)
	REINIT_ERROR (0, LAGRANGE, reinit)
	REINIT_ERROR (0, LAGRANGE, edge_reinit)
	SIDEMAP_ERROR (0, LAGRANGE, side_map)
	REINIT_ERROR (0, LAGRANGE_VEC, reinit)
	REINIT_ERROR (0, LAGRANGE_VEC, edge_reinit)
	SIDEMAP_ERROR (0, LAGRANGE_VEC, side_map)
	REINIT_ERROR (0, L2_LAGRANGE, reinit)
	REINIT_ERROR (0, L2_LAGRANGE, edge_reinit)
	SIDEMAP_ERROR (0, L2_LAGRANGE, side_map)
	REINIT_ERROR (0, MONOMIAL, reinit)
	REINIT_ERROR (0, MONOMIAL, edge_reinit)
	SIDEMAP_ERROR (0, MONOMIAL, side_map)
	REINIT_ERROR (0, SCALAR, reinit)
	REINIT_ERROR (0, SCALAR, edge_reinit)
	SIDEMAP_ERROR (0, SCALAR, side_map)
	REINIT_ERROR (0, XYZ, reinit)
	REINIT_ERROR (0, XYZ, edge_reinit)
	SIDEMAP_ERROR (0, XYZ, side_map)
	REINIT_ERROR (0, NEDELEC_ONE, reinit)
	REINIT_ERROR (0, NEDELEC_ONE, edge_reinit)
	SIDEMAP_ERROR (0, NEDELEC_ONE, side_map)
	REINIT_ERROR (0, BERNSTEIN, reinit)
	REINIT_ERROR (0, BERNSTEIN, edge_reinit)
	SIDEMAP_ERROR (0, BERNSTEIN, side_map)
	REINIT_ERROR (0, SZABAB, reinit)
	REINIT_ERROR (0, SZABAB, edge_reinit)
	SIDEMAP_ERROR (0, SZABAB, side_map)
	REINIT_ERROR (1, CLOUGH, edge_reinit)
	REINIT_ERROR (1, HERMITE, edge_reinit)
	REINIT_ERROR (1, HIERARCHIC, edge_reinit)
	REINIT_ERROR (1, L2_HIERARCHIC, edge_reinit)
	REINIT_ERROR (1, LAGRANGE, edge_reinit)
	REINIT_ERROR (1, LAGRANGE_VEC, edge_reinit)
	REINIT_ERROR (1, L2_LAGRANGE, edge_reinit)
	REINIT_ERROR (1, XYZ, edge_reinit)
	REINIT_ERROR (1, MONOMIAL, edge_reinit)
	REINIT_ERROR (1, SCALAR, edge_reinit)
	REINIT_ERROR (1, NEDELEC_ONE, reinit)
	REINIT_ERROR (1, NEDELEC_ONE, edge_reinit)
	SIDEMAP_ERROR (1, NEDELEC_ONE, side_map)
	REINIT_ERROR (1, BERNSTEIN, edge_reinit)
	REINIT_ERROR (1, SZABAB, edge_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, map(const Elem *, const Point &))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Point, map(const Elem *, const Point &))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Point, map(const Elem *, const Point &))
	INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Point, inverse_map(const Elem *, const Point &, const Real, const bool))
	INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Point, inverse_map(const Elem *, const Point &, const Real, const bool))
	INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Point, inverse_map(const Elem *, const Point &, const Real, 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 > &))
bool	is_between (Real min, Real check, Real max)
std::unique_ptr< CheckpointIO >	split_mesh (MeshBase &mesh, processor_id_type nsplits)
std::ostream &	operator<< (std::ostream &os, const MeshBase &m)
void	query_ghosting_functors (const MeshBase &mesh, processor_id_type pid, MeshBase::const_element_iterator elem_it, MeshBase::const_element_iterator elem_end, std::set< const Elem *, CompareElemIdsByLevel > &connected_elements)
void	connect_children (const MeshBase &mesh, MeshBase::const_element_iterator elem_it, MeshBase::const_element_iterator elem_end, std::set< const Elem *, CompareElemIdsByLevel > &connected_elements)
void	connect_families (std::set< const Elem *, CompareElemIdsByLevel > &connected_elements)
void	reconnect_nodes (const std::set< const Elem *, CompareElemIdsByLevel > &connected_elements, std::set< const Node *> &connected_nodes)
template void	MeshCommunication::find_global_indices< MeshBase::const_node_iterator > (const Parallel::Communicator &, const libMesh::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 libMesh::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 libMesh::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 libMesh::BoundingBox &, const MeshBase::element_iterator &, const MeshBase::element_iterator &, std::vector< dof_id_type > &) const
template void	MeshCommunication::find_local_indices< MeshBase::const_element_iterator > (const libMesh::BoundingBox &, const MeshBase::const_element_iterator &, const MeshBase::const_element_iterator &, std::unordered_map< dof_id_type, dof_id_type > &) const
	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)
double	__libmesh_nlopt_objective (unsigned n, const double *x, double *gradient, void *data)
void	__libmesh_nlopt_equality_constraints (unsigned m, double *result, unsigned n, const double *x, double *gradient, void *data)
void	__libmesh_nlopt_inequality_constraints (unsigned m, double *result, unsigned n, const double *x, double *gradient, void *data)
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, #if PETSC_RELEASE_LESS_THAN(3, 5, 0) Mat *libmesh_dbg_var(j), Mat *pc, MatStructure *msflag, #else Mat libmesh_dbg_var(j), Mat pc, #endif void *ctx)
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_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)
ResidualContext	libmesh_petsc_snes_residual_helper (SNES snes, Vec x, void *ctx)
PetscErrorCode	libmesh_petsc_snes_monitor (SNES, PetscInt its, PetscReal fnorm, void *)
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_residual (SNES snes, Vec x, Vec r, void *ctx)
PetscErrorCode	libmesh_petsc_snes_fd_residual (SNES snes, Vec x, Vec r, void *ctx)
PetscErrorCode	__libmesh_petsc_snes_fd_residual (SNES snes, Vec x, Vec r, void *ctx)
PetscErrorCode	libmesh_petsc_snes_mffd_residual (SNES snes, Vec x, Vec r, void *ctx)
PetscErrorCode	libmesh_petsc_snes_mffd_interface (void *ctx, Vec x, Vec r)
PetscErrorCode	__libmesh_petsc_snes_mffd_interface (void *ctx, Vec x, Vec r)
PetscErrorCode	libmesh_petsc_snes_jacobian (#if PETSC_RELEASE_LESS_THAN(3, 5, 0) SNES snes, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx #else SNES snes, Vec x, Mat jac, Mat pc, void *ctx #endif)
PetscErrorCode	libmesh_petsc_linesearch_shellfunc (SNESLineSearch linesearch, void *ctx)
PetscErrorCode	__libmesh_petsc_snes_jacobian (#if PETSC_RELEASE_LESS_THAN(3, 5, 0) SNES snes, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx #else SNES snes, Vec x, Mat jac, Mat pc, void *ctx #endif)
PetscErrorCode	libmesh_petsc_snes_postcheck (#if PETSC_VERSION_LESS_THAN(3, 3, 0) SNES, Vec x, Vec y, Vec w, void *context, PetscBool *changed_y, PetscBool *changed_w #else SNESLineSearch, Vec x, Vec y, Vec w, PetscBool *changed_y, PetscBool *changed_w, void *context #endif)
PetscErrorCode	__libmesh_petsc_snes_postcheck (#if PETSC_VERSION_LESS_THAN(3, 3, 0) SNES, Vec x, Vec y, Vec w, void *context, PetscBool *changed_y, PetscBool *changed_w #else SNESLineSearch, Vec x, Vec y, Vec w, PetscBool *changed_y, PetscBool *changed_w, void *context #endif)
PetscErrorCode	__libmesh_tao_objective (Tao, Vec x, PetscReal *objective, void *ctx)
PetscErrorCode	__libmesh_tao_gradient (Tao, Vec x, Vec g, void *ctx)
PetscErrorCode	__libmesh_tao_hessian (Tao, Vec x, Mat h, Mat pc, void *ctx)
PetscErrorCode	__libmesh_tao_equality_constraints (Tao, Vec x, Vec ce, void *ctx)
PetscErrorCode	__libmesh_tao_equality_constraints_jacobian (Tao, Vec x, Mat J, Mat Jpre, void *ctx)
PetscErrorCode	__libmesh_tao_inequality_constraints (Tao, Vec x, Vec cineq, void *ctx)
PetscErrorCode	__libmesh_tao_inequality_constraints_jacobian (Tao, Vec x, Mat J, Mat Jpre, void *ctx)
std::ostream &	operator<< (std::ostream &os, const EquationSystems &es)
template void	Xdr::data< std::complex< float > > (std::complex< float > &, const char *)
template void	Xdr::data< std::complex< double > > (std::complex< double > &, const char *)
template void	Xdr::data< std::complex< long double > > (std::complex< long double > &, const char *)
template void	Xdr::data< std::string > (std::string &, const char *)
template void	Xdr::data< std::vector< int > > (std::vector< int > &, const char *)
template void	Xdr::data< std::vector< unsigned int > > (std::vector< unsigned int > &, const char *)
template void	Xdr::data< std::vector< short int > > (std::vector< short int > &, const char *)
template void	Xdr::data< std::vector< unsigned short int > > (std::vector< unsigned short int > &, const char *)
template void	Xdr::data< std::vector< long int > > (std::vector< long int > &, const char *)
template void	Xdr::data< std::vector< long long > > (std::vector< long long > &, 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 *)
template<typename T , typename... Args>
std::unique_ptr< T >	make_unique (Args &&... args)
	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)
bool	operator== (const OrderWrapper &lhs, const OrderWrapper &rhs)
bool	operator!= (const OrderWrapper &lhs, const OrderWrapper &rhs)
bool	operator< (const OrderWrapper &lhs, const OrderWrapper &rhs)
bool	operator> (const OrderWrapper &lhs, const OrderWrapper &rhs)
bool	operator<= (const OrderWrapper &lhs, const OrderWrapper &rhs)
bool	operator>= (const OrderWrapper &lhs, const OrderWrapper &rhs)
	OrderWrapperOperators (int) OrderWrapperOperators(unsigned int) OrderWrapperOperators(std
bool	operator== (const OrderWrapper &lhs, int rhs)
bool	operator== (Order lhs, const OrderWrapper &rhs)
bool	operator== (const OrderWrapper &lhs, Order rhs)
bool	operator!= (int lhs, const OrderWrapper &rhs)
bool	operator!= (const OrderWrapper &lhs, int rhs)
bool	operator!= (Order lhs, const OrderWrapper &rhs)
bool	operator!= (const OrderWrapper &lhs, Order rhs)
bool	operator< (int lhs, const OrderWrapper &rhs)
bool	operator< (const OrderWrapper &lhs, int rhs)
bool	operator< (Order lhs, const OrderWrapper &rhs)
bool	operator< (const OrderWrapper &lhs, Order rhs)
bool	operator> (int lhs, const OrderWrapper &rhs)
bool	operator> (const OrderWrapper &lhs, int rhs)
bool	operator> (Order lhs, const OrderWrapper &rhs)
bool	operator> (const OrderWrapper &lhs, Order rhs)
bool	operator<= (int lhs, const OrderWrapper &rhs)
bool	operator<= (const OrderWrapper &lhs, int rhs)
bool	operator<= (Order lhs, const OrderWrapper &rhs)
bool	operator<= (const OrderWrapper &lhs, Order rhs)
bool	operator>= (int lhs, const OrderWrapper &rhs)
bool	operator>= (const OrderWrapper &lhs, int rhs)
bool	operator>= (Order lhs, const OrderWrapper &rhs)
bool	operator>= (const OrderWrapper &lhs, Order rhs)
std::ostream &	operator<< (std::ostream &os, const OrderWrapper &order)
	INSTANTIATE_INF_FE (1, CARTESIAN)
	INSTANTIATE_INF_FE (2, CARTESIAN)
	INSTANTIATE_INF_FE (3, CARTESIAN)
template<typename T >
IntRange< std::size_t >	index_range (const std::vector< T > &vec)
template<typename T >
IntRange< numeric_index_type >	index_range (const NumericVector< T > &vec)
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<typename T >
bool	libmesh_isinf (T x)
template<typename T >
bool	libmesh_isinf (std::complex< T > a)
template<class ... Args>
void	libmesh_ignore (const Args &...)
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)
template<typename P >
void	print_helper (std::ostream &os, const std::vector< std::vector< P >> *param)
std::ostream &	operator<< (std::ostream &os, const Parameters &p)
template<>
void	print_helper (std::ostream &os, const char *param)
template<>
void	print_helper (std::ostream &os, const unsigned char *param)
PetscErrorCode	libmesh_petsc_snes_jacobian (SNES, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx)
PetscErrorCode	libmesh_petsc_snes_jacobian (SNES, Vec x, Mat jac, Mat pc, void *ctx)
PetscErrorCode	__libmesh_petsc_snes_jacobian (SNES, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx)
PetscErrorCode	__libmesh_petsc_snes_jacobian (SNES, Vec x, Mat jac, Mat pc, void *ctx)
PetscInt *	numeric_petsc_cast (const numeric_index_type *p)
template<typename I >
SimpleRange< I >	as_range (const std::pair< I, I > &p)
template<typename I >
SimpleRange< I >	as_range (const I &first, const I &second)
template<typename T >
std::ostream &	operator<< (std::ostream &os, const SparseMatrix< T > &m)
int *	numeric_trilinos_cast (const numeric_index_type *p)
template<unsigned int N, typename T , typename Scalar >
boostcopy::enable_if_c< ScalarTraits< Scalar >::value, TypeNTensor< N, typename CompareTypes< Scalar, T >::supertype > >::type	operator* (const Scalar &, const TypeNTensor< N, T > &)
template<unsigned int N, typename T , typename Scalar >
boostcopy::enable_if_c< ScalarTraits< Scalar >::value, TypeNTensor< N, typename CompareTypes< Scalar, T >::supertype > >::type	operator/ (const Scalar &, const TypeNTensor< N, T > &)
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)
template<typename T >
T	triple_product (const TypeVector< T > &a, const TypeVector< T > &b, const TypeVector< T > &c)
template<typename T >
T	cross_norm_sq (const TypeVector< T > &b, const TypeVector< T > &c)
template<typename T >
T	cross_norm (const TypeVector< T > &b, const TypeVector< T > &c)

Variables
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE	Real
DIE A HORRIBLE DEATH HERE typedef float	ErrorVectorReal
MPI_Comm	GLOBAL_COMM_WORLD = MPI_COMM_NULL
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
Threads::spin_mutex	parent_indices_mutex
Threads::spin_mutex	parent_bracketing_nodes_mutex
const RemoteElem *	remote_elem
const unsigned int	MIN_ELEM_PER_PROC = 4
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. Here, it provides a LibMeshInit class which uses the RAII (Resource Acquisition Is Initialization) idiom to ensure initialization of any other dependent libraries (e.g. MPI or PETSC), and to close those libraries when it goes out of scope. It also provides a centralized place for performance logging and other functionality.

Typedef Documentation

boundary_id_type

typedef int16_t libMesh::boundary_id_type

Definition at line 51 of file id_types.h.

Complex

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

Definition at line 155 of file libmesh_common.h.

COMPLEX

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

Definition at line 156 of file libmesh_common.h.

ConstElemRange

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

Definition at line 34 of file elem_range.h.

ConstNodeRange

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

Definition at line 34 of file node_range.h.

DefaultMesh

typedef ReplicatedMesh libMesh::DefaultMesh

Definition at line 28 of file mesh.h.

dof_id_type

typedef uint32_t libMesh::dof_id_type

Definition at line 64 of file id_types.h.

DofConstraintRow

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 97 of file dof_map.h.

DSNAN

typedef DynamicSparseNumberArray<Real, dof_id_type> libMesh::DSNAN

Definition at line 96 of file system_projection.C.

eigen_idx_type

typedef int32_t libMesh::eigen_idx_type

Definition at line 66 of file eigen_core_support.h.

EigenSM

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

Definition at line 78 of file eigen_core_support.h.

EigenSV

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

Definition at line 79 of file eigen_core_support.h.

ElemRange

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

Definition at line 31 of file elem_range.h.

FEBase

typedef FEGenericBase< Real > libMesh::FEBase

Definition at line 39 of file exact_error_estimator.h.

FEVectorBase

typedef FEGenericBase<RealGradient> libMesh::FEVectorBase

Definition at line 667 of file fe_base.h.

Gradient

typedef NumberVectorValue libMesh::Gradient

Definition at line 57 of file exact_solution.h.

largest_id_type

typedef uint8_t libMesh::largest_id_type

Definition at line 139 of file id_types.h.

NodeConstraintRow

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 145 of file dof_map.h.

NodeRange

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

Definition at line 31 of file node_range.h.

Number

typedef Complex libMesh::Number

Definition at line 191 of file libmesh_common.h.

NumberTensorValue

typedef TensorValue< Number > libMesh::NumberTensorValue

Definition at line 53 of file exact_solution.h.

NumberVectorValue

typedef VectorValue< Number > libMesh::NumberVectorValue

Definition at line 56 of file exact_solution.h.

numeric_index_type

typedef dof_id_type libMesh::numeric_index_type

Definition at line 92 of file id_types.h.

OStreamProxy

typedef BasicOStreamProxy libMesh::OStreamProxy

Definition at line 232 of file ostream_proxy.h.

processor_id_type

typedef uint16_t libMesh::processor_id_type

Definition at line 99 of file id_types.h.

REAL

typedef Real libMesh::REAL

Definition at line 44 of file mesh_triangle_wrapper.h.

RealGradient

typedef RealVectorValue libMesh::RealGradient

Definition at line 50 of file hp_coarsentest.h.

RealTensor

typedef RealTensorValue libMesh::RealTensor

Definition at line 51 of file hp_coarsentest.h.

RealTensorValue

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.

RealVectorValue

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.

SteadyLinearSystem

typedef LinearImplicitSystem libMesh::SteadyLinearSystem

Definition at line 34 of file steady_system.h.

subdomain_id_type

typedef uint16_t libMesh::subdomain_id_type

Note

subdomain_id_type should be a positive integer, but due to a limitation in the exodusII API, we are forced 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.

Tensor

typedef NumberTensorValue libMesh::Tensor

Definition at line 55 of file exact_solution.h.

TransientBaseSystem

typedef TransientSystem<System> libMesh::TransientBaseSystem

Definition at line 155 of file transient_system.h.

TransientEigenSystem

typedef TransientSystem<EigenSystem> libMesh::TransientEigenSystem

Definition at line 157 of file transient_system.h.

TransientExplicitSystem

typedef TransientSystem<ExplicitSystem> libMesh::TransientExplicitSystem

Definition at line 154 of file transient_system.h.

TransientImplicitSystem

typedef TransientSystem<LinearImplicitSystem> libMesh::TransientImplicitSystem

Definition at line 151 of file transient_system.h.

TransientLinearImplicitSystem

typedef TransientSystem<LinearImplicitSystem> libMesh::TransientLinearImplicitSystem

Definition at line 152 of file transient_system.h.

TransientNonlinearImplicitSystem

typedef TransientSystem<NonlinearImplicitSystem> libMesh::TransientNonlinearImplicitSystem

Definition at line 153 of file transient_system.h.

tuple_of

template<size_t I, typename T >

using libMesh::tuple_of = typedef typename tuple_n<I,T>::template type<>

Definition at line 21 of file tuple_of.h.

unique_id_type

typedef uint64_t libMesh::unique_id_type

Definition at line 79 of file id_types.h.

UniquePtr

template<typename T >

using libMesh::UniquePtr = typedef std::unique_ptr<T>

Definition at line 33 of file auto_ptr.h.

unordered_multiset_elem

typedef std::unordered_multiset<Elem *, ElemHashUtils, ElemHashUtils> libMesh::unordered_multiset_elem

Definition at line 77 of file elem_hash.h.

Enumeration Type Documentation

EigenProblemType

enum libMesh::EigenProblemType : int

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

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum EigenProblemType : int; reducing header file dependencies.

Enumerator
NHEP
HEP
GNHEP
GHEP
GHIEP
INVALID_EIGENPROBLEMTYPE

Definition at line 54 of file enum_eigen_solver_type.h.

                      : int {
                       NHEP=0,
                       HEP,
                       GNHEP,
                       GHEP,
                       GHIEP,
                       // Invalid
                       INVALID_EIGENPROBLEMTYPE};

EigenSolverType

enum libMesh::EigenSolverType : int

Defines an enum for iterative eigenproblem solver types

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum EigenSolverType : int; reducing header file dependencies.

Enumerator
POWER
LAPACK
SUBSPACE
ARNOLDI
LANCZOS
KRYLOVSCHUR
INVALID_EIGENSOLVER

Definition at line 33 of file enum_eigen_solver_type.h.

                     : int {
                      POWER=0,
                      LAPACK,
                      SUBSPACE,
                      ARNOLDI,
                      LANCZOS,
                      KRYLOVSCHUR,
                      // Invalid
                      INVALID_EIGENSOLVER};

ElemQuality

enum libMesh::ElemQuality : int

Defines an enum for element quality metrics.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum ElemQuality : int; reducing header file dependencies.

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 34 of file enum_elem_quality.h.

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

ElemType

enum libMesh::ElemType : int

Defines an enum for geometric element types.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum ElemType : int; reducing header file dependencies.

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
TRISHELL3
QUADSHELL4
QUADSHELL8
INVALID_ELEM

Definition at line 33 of file enum_elem_type.h.

              : int {
               // 1D
               EDGE2 = 0,
               EDGE3 = 1,
               EDGE4 = 2,
               // 2D
               TRI3 = 3,
               TRI6 = 4,
               QUAD4 = 5,
               QUAD8 = 6,
               QUAD9 = 7,
               // 3D
               TET4 = 8,
               TET10 = 9,
               HEX8 = 10,
               HEX20 = 11,
               HEX27 = 12,
               PRISM6 = 13,
               PRISM15 = 14,
               PRISM18 = 15,
               PYRAMID5 = 16,
               PYRAMID13 = 17,
               PYRAMID14 = 18,
               // Infinite Elems
               INFEDGE2 = 19,
               INFQUAD4 = 20,
               INFQUAD6 = 21,
               INFHEX8 = 22,
               INFHEX16 = 23,
               INFHEX18 = 24,
               INFPRISM6 = 25,
               INFPRISM12 = 26,
               // 0D
               NODEELEM = 27,
               // Miscellaneous Elems
               REMOTEELEM = 28,
               TRI3SUBDIVISION = 29,
               // Shell Elems
               TRISHELL3 = 30,
               QUADSHELL4 = 31,
               QUADSHELL8 = 32,
               // Invalid
               INVALID_ELEM};   // should always be last

ErrorEstimatorType

enum libMesh::ErrorEstimatorType : int

Defines an enum for the different types of error estimators which are available.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum ErrorEstimatorType : int; reducing header file dependencies.

Enumerator
INVALID
ADJOINT_REFINEMENT
ADJOINT_RESIDUAL
DISCONTINUITY_MEASURE
EXACT
KELLY
LAPLACIAN
PATCH_RECOVERY
WEIGHTED_PATCH_RECOVERY
UNIFORM_REFINEMENT

Definition at line 33 of file enum_error_estimator_type.h.

                        : int {
                         INVALID                 = -1,
                         ADJOINT_REFINEMENT      =  0,
                         ADJOINT_RESIDUAL        =  1,
                         DISCONTINUITY_MEASURE   =  2,
                         EXACT                   =  3,
                         KELLY                   =  4,
                         LAPLACIAN               =  5,
                         PATCH_RECOVERY          =  6,
                         WEIGHTED_PATCH_RECOVERY =  7,
                         UNIFORM_REFINEMENT      =  8};

FEContinuity

enum libMesh::FEContinuity : int

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

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum FEContinuity : int; reducing header file dependencies.

Enumerator
DISCONTINUOUS
C_ZERO
C_ONE
H_CURL

Definition at line 74 of file enum_fe_family.h.

                  : int {
                   DISCONTINUOUS,
                   C_ZERO,
                   C_ONE,
                   H_CURL};

FEFamily

enum libMesh::FEFamily : int

defines an enum for finite element families.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum FEFamily : int; reducing header file dependencies.

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 34 of file enum_fe_family.h.

              : int {
               // C0
               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
               INVALID_FE   = 99};

FEFieldType

enum libMesh::FEFieldType : int

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

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum FEFieldType : int; reducing header file dependencies.

Enumerator
TYPE_SCALAR
TYPE_VECTOR

Definition at line 89 of file enum_fe_family.h.

                 : int {
                  TYPE_SCALAR = 0,
                  TYPE_VECTOR};

FEMNormType

enum libMesh::FEMNormType : int

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

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum FEMNormType : int; reducing header file dependencies.

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 34 of file enum_norm_type.h.

                 : int {
                  // Hilbert norms and seminorms in FE space
                  L2              = 0,
                  H1              = 1,
                  H2              = 2,
                  HCURL           = 3,
                  HDIV            = 4,
                  L1              = 5,
                  L_INF           = 6,
                  H1_SEMINORM     = 10,
                  H2_SEMINORM     = 11,
                  // Vector FE norms
                  HCURL_SEMINORM  = 12,
                  HDIV_SEMINORM   = 13,
                  // Sobolev infinity seminorms
                  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
                  INVALID_NORM    = 42};

InfMapType

enum libMesh::InfMapType : int

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

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum InfMapType : int; reducing header file dependencies.

Enumerator
CARTESIAN
SPHERICAL
ELLIPSOIDAL
INVALID_INF_MAP

Definition at line 34 of file enum_inf_map_type.h.

                : int {
                 CARTESIAN=0,
                 SPHERICAL,
                 ELLIPSOIDAL,
                 // Invalid
                 INVALID_INF_MAP};

IOPackage

enum libMesh::IOPackage : int

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.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum IOPackage : int; reducing header file dependencies.

Enumerator
TECPLOT
GMV
GMSH
VTK
DIVA
TETGEN
UCD
LIBMESH
INVALID_IO_PACKAGE

Definition at line 37 of file enum_io_package.h.

               : int
  {
    TECPLOT,
    GMV,
    GMSH,
    VTK,
    DIVA,
    TETGEN,
    UCD,
    LIBMESH,
    // Invalid
    INVALID_IO_PACKAGE
  };

LinearConvergenceReason

enum libMesh::LinearConvergenceReason : int

Linear solver convergence flags (taken from the PETSc flags).

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum LinearConvergenceReason : int; reducing header file dependencies.

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
DIVERGED_PCSETUP_FAILED
CONVERGED_ITERATING
UNKNOWN_FLAG

Definition at line 33 of file enum_convergence_flags.h.

                             : int {
  // 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,
  DIVERGED_PCSETUP_FAILED      = -11,
  // still running
  CONVERGED_ITERATING          =  0,
  // Invalid
  UNKNOWN_FLAG                 = -128};

Order

enum libMesh::Order : int

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

Note

It is possible to safely cast integral values larger than 43 to Order, provided that the cast value fits in the range of int. A potential use case for such a cast is when employing the QGrid class at extremely high order.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum Order : int; reducing header file dependencies.

Enumerator
CONSTANT
FIRST
SECOND
THIRD
FOURTH
FIFTH
SIXTH
SEVENTH
EIGHTH
NINTH
TENTH
ELEVENTH
TWELFTH
THIRTEENTH
FOURTEENTH
FIFTEENTH
SIXTEENTH
SEVENTEENTH
EIGHTTEENTH
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 40 of file enum_order.h.

           : int {
            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,
            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
            INVALID_ORDER};

ParallelType

enum libMesh::ParallelType : int

Defines an enum for parallel data structure types.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum ParallelType : int; reducing header file dependencies.

Enumerator
AUTOMATIC
SERIAL
PARALLEL
GHOSTED
INVALID_PARALLELIZATION

Definition at line 33 of file enum_parallel_type.h.

                  : int {
                   AUTOMATIC=0,
                   SERIAL,
                   PARALLEL,
                   GHOSTED,
                   // Invalid
                   INVALID_PARALLELIZATION};

PetscMatrixType

enum libMesh::PetscMatrixType : int

Enumerator
AIJ
HYPRE

Definition at line 63 of file petsc_matrix.h.

                     : int {
                 AIJ=0,
                 HYPRE};

PointLocatorType

enum libMesh::PointLocatorType : int

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

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum PointLocatorType : int; reducing header file dependencies.

Enumerator
TREE
TREE_ELEMENTS
TREE_LOCAL_ELEMENTS
INVALID_LOCATOR

Definition at line 35 of file enum_point_locator_type.h.

                      : int {
                       TREE = 0,
                       TREE_ELEMENTS,
                       TREE_LOCAL_ELEMENTS,
                       // Invalid
                       INVALID_LOCATOR};

PositionOfSpectrum

enum libMesh::PositionOfSpectrum : int

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

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum PositionOfSpectrum : int; reducing header file dependencies.

Enumerator
LARGEST_MAGNITUDE
SMALLEST_MAGNITUDE
TARGET_MAGNITUDE
LARGEST_REAL
SMALLEST_REAL
TARGET_REAL
LARGEST_IMAGINARY
SMALLEST_IMAGINARY
TARGET_IMAGINARY
INVALID_Postion_of_Spectrum
INVALID_POSITION_OF_SPECTRUM

Definition at line 74 of file enum_eigen_solver_type.h.

                        : int {
                         LARGEST_MAGNITUDE=0,
                         SMALLEST_MAGNITUDE,
                         TARGET_MAGNITUDE,
                         LARGEST_REAL,
                         SMALLEST_REAL,
                         TARGET_REAL,
                         LARGEST_IMAGINARY,
                         SMALLEST_IMAGINARY,
                         TARGET_IMAGINARY,
                         // Invalid
                         INVALID_Postion_of_Spectrum,
                         INVALID_POSITION_OF_SPECTRUM};

PreconditionerType

enum libMesh::PreconditionerType : int

Defines an enum for preconditioner types.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum PreconditionerType : int; reducing header file dependencies.

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 33 of file enum_preconditioner_type.h.

                        : int {
                         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
                         INVALID_PRECONDITIONER};

QuadratureType

enum libMesh::QuadratureType : int

Defines an enum for currently available quadrature rules.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum QuadratureType : int; reducing header file dependencies.

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 33 of file enum_quadrature_type.h.

                    : int {
                     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
                     INVALID_Q_RULE    = 127};

SolverPackage

enum libMesh::SolverPackage : int

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

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum SolverPackage : int; reducing header file dependencies.

Enumerator
PETSC_SOLVERS
SLEPC_SOLVERS
NLOPT_SOLVERS

Definition at line 34 of file enum_solver_package.h.

                   : int
  {
    PETSC_SOLVERS=0,
    TRILINOS_SOLVERS,
    LASPACK_SOLVERS,
    SLEPC_SOLVERS,
    EIGEN_SOLVERS,
    NLOPT_SOLVERS,
    // Invalid
    INVALID_SOLVER_PACKAGE
  };

SolverType

enum libMesh::SolverType : int

Defines an enum for iterative solver types.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum SolverType : int; reducing header file dependencies.

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

Definition at line 33 of file enum_solver_type.h.

                : int {
                 CG=0,
                 CGN,
                 CGS,
                 CR,
                 QMR,
                 TCQMR,
                 TFQMR,
                 BICG,
                 BICGSTAB,
                 MINRES,
                 GMRES,
                 LSQR,
                 JACOBI,
                 SOR_FORWARD,
                 SOR_BACKWARD,
                 SSOR,
                 RICHARDSON,
                 CHEBYSHEV,
                 SPARSELU,
                 // Invalid
                 INVALID_SOLVER};

SubsetSolveMode

enum libMesh::SubsetSolveMode : int

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

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum SubsetSolveMode : int; reducing header file dependencies.

Enumerator
SUBSET_ZERO
SUBSET_COPY_RHS
SUBSET_DONT_TOUCH

Definition at line 35 of file enum_subset_solve_mode.h.

                     : int {
  // Set dofs outside the subset to zero.
  SUBSET_ZERO = 0,
  // Set dofs outside the subset to the value of the corresponding
  // dofs of the right hand side.
  SUBSET_COPY_RHS,
  // 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.
  SUBSET_DONT_TOUCH
};

VariableIndexing

enum libMesh::VariableIndexing

Dirichlet functions may be indexed either by "system variable order" or "local variable order", depending on how the DirichletBoundary object is constructed. For example, suppose a system has variables {a, b, c, d}, and a DirichletBoundary is set for variables {b, d} (i.e. variables_in is {1, 3}). If the boundary is constructed to use "system variable order", input function(s) will be queried for components 1 and 3; this is useful for reusing input functions as both exact solutions and Dirichlet boundaries in benchmark problems. If the boundary is constructed to use "local variable order", input function(s) will be queried for components 0 and 1; this is useful for flexibly constructing Dirichlet boundaries in multiphysics codes or from user input files.

Enumerator
SYSTEM_VARIABLE_ORDER
LOCAL_VARIABLE_ORDER

Definition at line 62 of file dirichlet_boundaries.h.

                      { SYSTEM_VARIABLE_ORDER = 0,
                        LOCAL_VARIABLE_ORDER };

XdrMODE

enum libMesh::XdrMODE : int

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.

The fixed type, i.e. ": int", enumeration syntax used here allows this enum to be forward declared as enum XdrMODE : int; reducing header file dependencies.

Enumerator
UNKNOWN
ENCODE
DECODE
WRITE
READ

Definition at line 35 of file enum_xdr_mode.h.

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

Function Documentation

__libmesh_nlopt_equality_constraints()

void libMesh::__libmesh_nlopt_equality_constraints	(	unsigned	m,
		double *	result,
		unsigned	n,
		const double *	x,
		double *	gradient,
		void *	data
	)

Definition at line 107 of file nlopt_optimization_solver.C.

References data, libMesh::OptimizationSystem::ComputeEqualityConstraints::equality_constraints(), libMesh::OptimizationSystem::ComputeEqualityConstraintsJacobian::equality_constraints_jacobian(), libMesh::OptimizationSolver< T >::equality_constraints_jacobian_object, libMesh::OptimizationSolver< T >::equality_constraints_object, index_range(), and libMesh::OptimizationSolver< T >::system().

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

{
  LOG_SCOPE("equality_constraints()", "NloptOptimizationSolver");

  libmesh_assert(data);

  // data should be a pointer to the solver (it was passed in as void *)
  NloptOptimizationSolver<Number> * solver =
    static_cast<NloptOptimizationSolver<Number> *> (data);

  OptimizationSystem & sys = solver->system();

  // We'll use current_local_solution below, so let's ensure that it's consistent
  // with the vector x that was passed in.
  if (sys.solution->size() != n)
    libmesh_error_msg("Error: Input vector x has different length than sys.solution!");

  for (auto i : index_range(*sys.solution))
    sys.solution->set(i, x[i]);
  sys.solution->close();

  // Impose constraints on the solution vector
  sys.get_dof_map().enforce_constraints_exactly(sys);

  // Update sys.current_local_solution based on the solution vector
  sys.update();

  // Call the user's equality constraints function if there is one.
  OptimizationSystem::ComputeEqualityConstraints * eco = solver->equality_constraints_object;
  if (eco)
    {
      eco->equality_constraints(*sys.current_local_solution,
                                *sys.C_eq,
                                sys);

      sys.C_eq->close();

      // Copy the values out of eq_constraints into 'result'.
      // TODO: Even better would be if we could use 'result' directly
      // as the storage of eq_constraints.  Perhaps a serial-only
      // NumericVector variant which supports this option?
      for (unsigned int i = 0; i < m; ++i)
        result[i] = (*sys.C_eq)(i);

      // If gradient != nullptr, then the Jacobian matrix of the equality
      // constraints has been requested.  The incoming 'gradient'
      // array is of length m*n and d(c_i)/d(x_j) = gradient[n*i+j].
      if (gradient)
        {
          OptimizationSystem::ComputeEqualityConstraintsJacobian * eco_jac =
            solver->equality_constraints_jacobian_object;

          if (eco_jac)
            {
              eco_jac->equality_constraints_jacobian(*sys.current_local_solution,
                                                     *sys.C_eq_jac,
                                                     sys);

              sys.C_eq_jac->close();

              // copy the Jacobian data to the gradient array
              for (numeric_index_type i=0; i<m; i++)
                for (const auto & dof_index : sys.eq_constraint_jac_sparsity[i])
                  gradient[n*i+dof_index] = (*sys.C_eq_jac)(i,dof_index);
            }
          else
            libmesh_error_msg("Jacobian function not defined in __libmesh_nlopt_equality_constraints");
        }

    }
  else
    libmesh_error_msg("Constraints function not defined in __libmesh_nlopt_equality_constraints");
}

__libmesh_nlopt_inequality_constraints()

void libMesh::__libmesh_nlopt_inequality_constraints	(	unsigned	m,
		double *	result,
		unsigned	n,
		const double *	x,
		double *	gradient,
		void *	data
	)

Definition at line 187 of file nlopt_optimization_solver.C.

References data, index_range(), libMesh::OptimizationSystem::ComputeInequalityConstraints::inequality_constraints(), libMesh::OptimizationSystem::ComputeInequalityConstraintsJacobian::inequality_constraints_jacobian(), libMesh::OptimizationSolver< T >::inequality_constraints_jacobian_object, libMesh::OptimizationSolver< T >::inequality_constraints_object, and libMesh::OptimizationSolver< T >::system().

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

{
  LOG_SCOPE("inequality_constraints()", "NloptOptimizationSolver");

  libmesh_assert(data);

  // data should be a pointer to the solver (it was passed in as void *)
  NloptOptimizationSolver<Number> * solver =
    static_cast<NloptOptimizationSolver<Number> *> (data);

  OptimizationSystem & sys = solver->system();

  // We'll use current_local_solution below, so let's ensure that it's consistent
  // with the vector x that was passed in.
  if (sys.solution->size() != n)
    libmesh_error_msg("Error: Input vector x has different length than sys.solution!");

  for (auto i : index_range(*sys.solution))
    sys.solution->set(i, x[i]);
  sys.solution->close();

  // Impose constraints on the solution vector
  sys.get_dof_map().enforce_constraints_exactly(sys);

  // Update sys.current_local_solution based on the solution vector
  sys.update();

  // Call the user's inequality constraints function if there is one.
  OptimizationSystem::ComputeInequalityConstraints * ineco = solver->inequality_constraints_object;
  if (ineco)
    {
      ineco->inequality_constraints(*sys.current_local_solution,
                                    *sys.C_ineq,
                                    sys);

      sys.C_ineq->close();

      // Copy the values out of ineq_constraints into 'result'.
      // TODO: Even better would be if we could use 'result' directly
      // as the storage of ineq_constraints.  Perhaps a serial-only
      // NumericVector variant which supports this option?
      for (unsigned int i = 0; i < m; ++i)
        result[i] = (*sys.C_ineq)(i);

      // If gradient != nullptr, then the Jacobian matrix of the equality
      // constraints has been requested.  The incoming 'gradient'
      // array is of length m*n and d(c_i)/d(x_j) = gradient[n*i+j].
      if (gradient)
        {
          OptimizationSystem::ComputeInequalityConstraintsJacobian * ineco_jac =
            solver->inequality_constraints_jacobian_object;

          if (ineco_jac)
            {
              ineco_jac->inequality_constraints_jacobian(*sys.current_local_solution,
                                                         *sys.C_ineq_jac,
                                                         sys);

              sys.C_ineq_jac->close();

              // copy the Jacobian data to the gradient array
              for (numeric_index_type i=0; i<m; i++)
                for (const auto & dof_index : sys.ineq_constraint_jac_sparsity[i])
                  gradient[n*i+dof_index] = (*sys.C_ineq_jac)(i,dof_index);
            }
          else
            libmesh_error_msg("Jacobian function not defined in __libmesh_nlopt_inequality_constraints");
        }

    }
  else
    libmesh_error_msg("Constraints function not defined in __libmesh_nlopt_inequality_constraints");
}

__libmesh_nlopt_objective()

double libMesh::__libmesh_nlopt_objective	(	unsigned	n,
		const double *	x,
		double *	gradient,
		void *	data
	)

Definition at line 37 of file nlopt_optimization_solver.C.

References data, libMesh::NloptOptimizationSolver< T >::get_iteration_count(), libMesh::OptimizationSystem::ComputeGradient::gradient(), libMesh::OptimizationSolver< T >::gradient_object, index_range(), libMesh::OptimizationSystem::ComputeObjective::objective(), libMesh::OptimizationSolver< T >::objective_object, out, Real, libMesh::OptimizationSolver< T >::system(), and libMesh::OptimizationSolver< T >::verbose.

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

{
  LOG_SCOPE("objective()", "NloptOptimizationSolver");

  // ctx should be a pointer to the solver (it was passed in as void *)
  NloptOptimizationSolver<Number> * solver =
    static_cast<NloptOptimizationSolver<Number> *> (data);

  OptimizationSystem & sys = solver->system();

  // We'll use current_local_solution below, so let's ensure that it's consistent
  // with the vector x that was passed in.
  for (auto i : index_range(*sys.solution))
    sys.solution->set(i, x[i]);

  // Make sure the solution vector is parallel-consistent
  sys.solution->close();

  // Impose constraints on X
  sys.get_dof_map().enforce_constraints_exactly(sys);

  // Update sys.current_local_solution based on X
  sys.update();

  Real objective;
  if (solver->objective_object != nullptr)
    {
      objective =
        solver->objective_object->objective(*(sys.current_local_solution), sys);
    }
  else
    {
      libmesh_error_msg("Objective function not defined in __libmesh_nlopt_objective");
    }

  // If the gradient has been requested, fill it in
  if (gradient)
    {
      if (solver->gradient_object != nullptr)
        {
          solver->gradient_object->gradient(*(sys.current_local_solution), *(sys.rhs), sys);

          // we've filled up sys.rhs with the gradient data, now copy it
          // to the nlopt data structure
          libmesh_assert(sys.rhs->size() == n);

          std::vector<double> grad;
          sys.rhs->localize_to_one(grad);
          for (unsigned int i = 0; i < n; ++i)
            gradient[i] = grad[i];
        }
      else
        libmesh_error_msg("Gradient function not defined in __libmesh_nlopt_objective");
    }

  // Increment the iteration count.
  solver->get_iteration_count()++;

  // Possibly print the current value of the objective function
  if (solver->verbose)
    libMesh::out << objective << std::endl;

  return objective;
}

__libmesh_petsc_diff_solver_jacobian()

PetscErrorCode libMesh::__libmesh_petsc_diff_solver_jacobian	(	SNES	,
		Vec	x,
		#if	PETSC_RELEASE_LESS_THAN3, 5, 0) Mat *libmesh_dbg_var(j,
		Mat *	pc,
		MatStructure *	msflag,
		#else Mat	libmesh_dbg_varj,
		Mat	pc,
		#endif void *	ctx
	)

Definition at line 132 of file petsc_diff_solver.C.

References libMesh::ImplicitSystem::assembly(), libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::DofMap::enforce_constraints_exactly(), libMesh::System::get_dof_map(), libMesh::ImplicitSystem::matrix, out, libMesh::System::solution, libMesh::PetscMatrix< T >::swap(), libMesh::DiffSolver::system(), libMesh::System::update(), and libMesh::DiffSolver::verbose.

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

  {
    libmesh_assert(x);
    libmesh_assert(j);
    //  libmesh_assert_equal_to (pc, j);  // We don't use separate preconditioners yet
    libmesh_assert(ctx);

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

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

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

#if PETSC_RELEASE_LESS_THAN(3,5,0)
    PetscMatrix<Number> J_input(*pc, sys.comm());
#else
    PetscMatrix<Number> J_input(pc, sys.comm());
#endif
    PetscMatrix<Number> & J_system =
      *cast_ptr<PetscMatrix<Number> *>(sys.matrix);

    // DiffSystem assembles from the solution and into the jacobian, 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);
    J_input.swap(J_system);

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

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

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

    // Swap back
    X_input.swap(X_system);
    J_input.swap(J_system);

#if PETSC_RELEASE_LESS_THAN(3,5,0)
    *msflag = SAME_NONZERO_PATTERN;
#endif
    // No errors, we hope
    return 0;
  }

__libmesh_petsc_diff_solver_monitor()

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

Definition at line 43 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, and libMesh::DiffSolver::verbose.

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

  {
    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, nullptr, nullptr);
      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;
  }

__libmesh_petsc_diff_solver_residual()

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

Definition at line 86 of file petsc_diff_solver.C.

References libMesh::ImplicitSystem::assembly(), libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::DofMap::enforce_constraints_exactly(), libMesh::System::get_dof_map(), out, libMesh::ExplicitSystem::rhs, libMesh::System::solution, libMesh::PetscVector< T >::swap(), libMesh::DiffSolver::system(), libMesh::System::update(), and libMesh::DiffSolver::verbose.

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 localize a parallel solution
    sys.update();

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

    // 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;
  }

__libmesh_petsc_preconditioner_apply() [1/2]

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

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

Definition at line 110 of file petsc_linear_solver.C.

References libmesh_petsc_preconditioner_apply().

  {
    libmesh_deprecated();
    return libmesh_petsc_preconditioner_apply(ctx, x, y);
  }

__libmesh_petsc_preconditioner_apply() [2/2]

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

Definition at line 123 of file petsc_linear_solver.C.

References libmesh_petsc_preconditioner_apply().

  {
    libmesh_deprecated();
    return libmesh_petsc_preconditioner_apply(pc, x, y);
  }

__libmesh_petsc_preconditioner_setup() [1/2]

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

References libmesh_petsc_preconditioner_setup().

  {
    libmesh_deprecated();
    return libmesh_petsc_preconditioner_setup(ctx);
  }

__libmesh_petsc_preconditioner_setup() [2/2]

PetscErrorCode libMesh::__libmesh_petsc_preconditioner_setup

(

PC

pc

)

Definition at line 117 of file petsc_linear_solver.C.

References libmesh_petsc_preconditioner_setup().

  {
    libmesh_deprecated();
    return libmesh_petsc_preconditioner_setup(pc);
  }

__libmesh_petsc_snes_fd_residual()

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

Definition at line 227 of file petsc_nonlinear_solver.C.

References libmesh_petsc_snes_fd_residual().

  {
    libmesh_deprecated();
    return libmesh_petsc_snes_fd_residual(snes, x, r, ctx);
  }

__libmesh_petsc_snes_jacobian() [1/3]

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

__libmesh_petsc_snes_jacobian() [2/3]

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

__libmesh_petsc_snes_jacobian() [3/3]

PetscErrorCode libMesh::__libmesh_petsc_snes_jacobian	(	#if PETSC_RELEASE_LESS_THAN(3, 5, 0) SNES	snes,
		Vec	x,
		Mat *	jac,
		Mat *	pc,
		MatStructure *	msflag,
		void *ctx #else SNES	snes,
		Vec	x,
		Mat	jac,
		Mat	pc,
		void *ctx #	endif
	)

Definition at line 396 of file petsc_nonlinear_solver.C.

References libmesh_petsc_snes_jacobian().

  {
    libmesh_deprecated();
    return libmesh_petsc_snes_jacobian(
#if PETSC_RELEASE_LESS_THAN(3,5,0)
                                       snes, x, jac, pc, msflag, ctx
#else
                                       snes, x, jac, pc, ctx
#endif
                                       );
  }

__libmesh_petsc_snes_mffd_interface()

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

Definition at line 278 of file petsc_nonlinear_solver.C.

References libmesh_petsc_snes_mffd_interface().

  {
    libmesh_deprecated();
    return libmesh_petsc_snes_mffd_interface(ctx, x, r);
  }

__libmesh_petsc_snes_monitor()

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

Definition at line 139 of file petsc_nonlinear_solver.C.

References libmesh_petsc_snes_monitor().

  {
    libmesh_deprecated();
    return libmesh_petsc_snes_monitor(nullptr, its, fnorm, nullptr);
  }

__libmesh_petsc_snes_postcheck()

PetscErrorCode libMesh::__libmesh_petsc_snes_postcheck	(	#if PETSC_VERSION_LESS_THAN(3, 3, 0)	SNES,
		Vec	x,
		Vec	y,
		Vec	w,
		void *	context,
		PetscBool *	changed_y,
		PetscBool *changed_w #else	SNESLineSearch,
		Vec	x,
		Vec	y,
		Vec	w,
		PetscBool *	changed_y,
		PetscBool *	changed_w,
		void *context #	endif
	)

Definition at line 522 of file petsc_nonlinear_solver.C.

References libmesh_petsc_snes_postcheck().

  {
    libmesh_deprecated();
    return libmesh_petsc_snes_postcheck(
#if PETSC_VERSION_LESS_THAN(3,3,0)
                                        nullptr, x, y, w, context, changed_y, changed_w
#else
                                        nullptr, x, y, w, changed_y, changed_w, context
#endif
                                        );
  }

__libmesh_petsc_snes_residual()

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

Definition at line 191 of file petsc_nonlinear_solver.C.

References libmesh_petsc_snes_residual().

  {
    libmesh_deprecated();
    return libmesh_petsc_snes_residual(snes, x, r, ctx);
  }

__libmesh_tao_equality_constraints()

PetscErrorCode libMesh::__libmesh_tao_equality_constraints	(	Tao	,
		Vec	x,
		Vec	ce,
		void *	ctx
	)

Definition at line 205 of file tao_optimization_solver.C.

References libMesh::ParallelObject::comm(), libMesh::OptimizationSystem::ComputeEqualityConstraints::equality_constraints(), libMesh::OptimizationSolver< T >::equality_constraints_object, ierr, libMesh::PetscVector< T >::swap(), libMesh::OptimizationSolver< T >::system(), and libMesh::PetscVector< T >::zero().

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

  {
    LOG_SCOPE("equality_constraints()", "TaoOptimizationSolver");

    PetscErrorCode ierr = 0;

    libmesh_assert(x);
    libmesh_assert(ce);
    libmesh_assert(ctx);

    // ctx should be a pointer to the solver (it was passed in as void *)
    TaoOptimizationSolver<Number> * solver =
      static_cast<TaoOptimizationSolver<Number> *> (ctx);

    OptimizationSystem & sys = solver->system();

    // We'll use current_local_solution below, so let's ensure that it's consistent
    // with the vector x that was passed in.
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> X(x, sys.comm());

    // Perform a swap so that sys.solution points to the input vector
    // "x", update sys.current_local_solution based on "x", then swap
    // back.
    X.swap(X_sys);
    sys.update();
    X.swap(X_sys);

    // We'll also pass the constraints vector ce into the assembly routine
    // so let's make a PETSc vector for that too.
    PetscVector<Number> eq_constraints(ce, sys.comm());

    // Clear the gradient prior to assembly
    eq_constraints.zero();

    // Enforce constraints exactly on the current_local_solution.
    sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());

    if (solver->equality_constraints_object != nullptr)
      solver->equality_constraints_object->equality_constraints(*(sys.current_local_solution), eq_constraints, sys);
    else
      libmesh_error_msg("Constraints function not defined in __libmesh_tao_equality_constraints");

    eq_constraints.close();

    return ierr;
  }

__libmesh_tao_equality_constraints_jacobian()

PetscErrorCode libMesh::__libmesh_tao_equality_constraints_jacobian	(	Tao	,
		Vec	x,
		Mat	J,
		Mat	Jpre,
		void *	ctx
	)

Definition at line 257 of file tao_optimization_solver.C.

References libMesh::ParallelObject::comm(), libMesh::OptimizationSystem::ComputeEqualityConstraintsJacobian::equality_constraints_jacobian(), libMesh::OptimizationSolver< T >::equality_constraints_jacobian_object, ierr, libMesh::PetscVector< T >::swap(), and libMesh::OptimizationSolver< T >::system().

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

  {
    LOG_SCOPE("equality_constraints_jacobian()", "TaoOptimizationSolver");

    PetscErrorCode ierr = 0;

    libmesh_assert(x);
    libmesh_assert(J);
    libmesh_assert(Jpre);

    // ctx should be a pointer to the solver (it was passed in as void *)
    TaoOptimizationSolver<Number> * solver =
      static_cast<TaoOptimizationSolver<Number> *> (ctx);

    OptimizationSystem & sys = solver->system();

    // We'll use current_local_solution below, so let's ensure that it's consistent
    // with the vector x that was passed in.
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> X(x, sys.comm());

    // Perform a swap so that sys.solution points to the input vector
    // "x", update sys.current_local_solution based on "x", then swap
    // back.
    X.swap(X_sys);
    sys.update();
    X.swap(X_sys);

    // Let's also wrap J and Jpre in PetscMatrix objects for convenience
    PetscMatrix<Number> J_petsc(J, sys.comm());
    PetscMatrix<Number> Jpre_petsc(Jpre, sys.comm());

    // Enforce constraints exactly on the current_local_solution.
    sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());

    if (solver->equality_constraints_jacobian_object != nullptr)
      solver->equality_constraints_jacobian_object->equality_constraints_jacobian(*(sys.current_local_solution), J_petsc, sys);
    else
      libmesh_error_msg("Constraints function not defined in __libmesh_tao_equality_constraints_jacobian");

    J_petsc.close();
    Jpre_petsc.close();

    return ierr;
  }

__libmesh_tao_gradient()

PetscErrorCode libMesh::__libmesh_tao_gradient	(	Tao	,
		Vec	x,
		Vec	g,
		void *	ctx
	)

Definition at line 97 of file tao_optimization_solver.C.

References libMesh::ParallelObject::comm(), libMesh::OptimizationSystem::ComputeGradient::gradient(), libMesh::OptimizationSolver< T >::gradient_object, ierr, libMesh::PetscVector< T >::swap(), libMesh::OptimizationSolver< T >::system(), and libMesh::PetscVector< T >::zero().

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

  {
    LOG_SCOPE("gradient()", "TaoOptimizationSolver");

    PetscErrorCode ierr = 0;

    libmesh_assert(x);
    libmesh_assert(g);
    libmesh_assert(ctx);

    // ctx should be a pointer to the solver (it was passed in as void *)
    TaoOptimizationSolver<Number> * solver =
      static_cast<TaoOptimizationSolver<Number> *> (ctx);

    OptimizationSystem & sys = solver->system();

    // We'll use current_local_solution below, so let's ensure that it's consistent
    // with the vector x that was passed in.
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> X(x, sys.comm());

    // Perform a swap so that sys.solution points to the input vector
    // "x", update sys.current_local_solution based on "x", then swap
    // back.
    X.swap(X_sys);
    sys.update();
    X.swap(X_sys);

    // We'll also pass the gradient in to the assembly routine
    // so let's make a PETSc vector for that too.
    PetscVector<Number> gradient(g, sys.comm());

    // Clear the gradient prior to assembly
    gradient.zero();

    // Enforce constraints exactly on the current_local_solution.
    sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());

    if (solver->gradient_object != nullptr)
      solver->gradient_object->gradient(*(sys.current_local_solution), gradient, sys);
    else
      libmesh_error_msg("Gradient function not defined in __libmesh_tao_gradient");

    gradient.close();

    return ierr;
  }

__libmesh_tao_hessian()

PetscErrorCode libMesh::__libmesh_tao_hessian	(	Tao	,
		Vec	x,
		Mat	h,
		Mat	pc,
		void *	ctx
	)

Definition at line 148 of file tao_optimization_solver.C.

References libMesh::SparseMatrix< T >::attach_dof_map(), libMesh::ParallelObject::comm(), libMesh::OptimizationSystem::ComputeHessian::hessian(), libMesh::OptimizationSolver< T >::hessian_object, ierr, libMesh::PetscVector< T >::swap(), and libMesh::OptimizationSolver< T >::system().

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

  {
    LOG_SCOPE("hessian()", "TaoOptimizationSolver");

    PetscErrorCode ierr = 0;

    libmesh_assert(x);
    libmesh_assert(h);
    libmesh_assert(pc);
    libmesh_assert(ctx);

    // ctx should be a pointer to the solver (it was passed in as void *)
    TaoOptimizationSolver<Number> * solver =
      static_cast<TaoOptimizationSolver<Number> *> (ctx);

    OptimizationSystem & sys = solver->system();

    // We'll use current_local_solution below, so let's ensure that it's consistent
    // with the vector x that was passed in.
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> X(x, sys.comm());

    // Perform a swap so that sys.solution points to the input vector
    // "x", update sys.current_local_solution based on "x", then swap
    // back.
    X.swap(X_sys);
    sys.update();
    X.swap(X_sys);

    // Let's also wrap pc and h in PetscMatrix objects for convenience
    PetscMatrix<Number> PC(pc, sys.comm());
    PetscMatrix<Number> hessian(h, sys.comm());
    PC.attach_dof_map(sys.get_dof_map());
    hessian.attach_dof_map(sys.get_dof_map());

    // Enforce constraints exactly on the current_local_solution.
    sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());

    if (solver->hessian_object != nullptr)
      {
        // Following PetscNonlinearSolver by passing in PC. It's not clear
        // why we pass in PC and not hessian though?
        solver->hessian_object->hessian(*(sys.current_local_solution), PC, sys);
      }
    else
      libmesh_error_msg("Hessian function not defined in __libmesh_tao_hessian");

    PC.close();
    hessian.close();

    return ierr;
  }

__libmesh_tao_inequality_constraints()

PetscErrorCode libMesh::__libmesh_tao_inequality_constraints	(	Tao	,
		Vec	x,
		Vec	cineq,
		void *	ctx
	)

Definition at line 306 of file tao_optimization_solver.C.

References libMesh::ParallelObject::comm(), ierr, libMesh::OptimizationSystem::ComputeInequalityConstraints::inequality_constraints(), libMesh::OptimizationSolver< T >::inequality_constraints_object, libMesh::PetscVector< T >::swap(), libMesh::OptimizationSolver< T >::system(), and libMesh::PetscVector< T >::zero().

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

  {
    LOG_SCOPE("inequality_constraints()", "TaoOptimizationSolver");

    PetscErrorCode ierr = 0;

    libmesh_assert(x);
    libmesh_assert(cineq);
    libmesh_assert(ctx);

    // ctx should be a pointer to the solver (it was passed in as void *)
    TaoOptimizationSolver<Number> * solver =
      static_cast<TaoOptimizationSolver<Number> *> (ctx);

    OptimizationSystem & sys = solver->system();

    // We'll use current_local_solution below, so let's ensure that it's consistent
    // with the vector x that was passed in.
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> X(x, sys.comm());

    // Perform a swap so that sys.solution points to the input vector
    // "x", update sys.current_local_solution based on "x", then swap
    // back.
    X.swap(X_sys);
    sys.update();
    X.swap(X_sys);

    // We'll also pass the constraints vector ce into the assembly routine
    // so let's make a PETSc vector for that too.
    PetscVector<Number> ineq_constraints(cineq, sys.comm());

    // Clear the gradient prior to assembly
    ineq_constraints.zero();

    // Enforce constraints exactly on the current_local_solution.
    sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());

    if (solver->inequality_constraints_object != nullptr)
      solver->inequality_constraints_object->inequality_constraints(*(sys.current_local_solution), ineq_constraints, sys);
    else
      libmesh_error_msg("Constraints function not defined in __libmesh_tao_inequality_constraints");

    ineq_constraints.close();

    return ierr;
  }

__libmesh_tao_inequality_constraints_jacobian()

PetscErrorCode libMesh::__libmesh_tao_inequality_constraints_jacobian	(	Tao	,
		Vec	x,
		Mat	J,
		Mat	Jpre,
		void *	ctx
	)

Definition at line 358 of file tao_optimization_solver.C.

References libMesh::ParallelObject::comm(), ierr, libMesh::OptimizationSystem::ComputeInequalityConstraintsJacobian::inequality_constraints_jacobian(), libMesh::OptimizationSolver< T >::inequality_constraints_jacobian_object, libMesh::PetscVector< T >::swap(), and libMesh::OptimizationSolver< T >::system().

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

  {
    LOG_SCOPE("inequality_constraints_jacobian()", "TaoOptimizationSolver");

    PetscErrorCode ierr = 0;

    libmesh_assert(x);
    libmesh_assert(J);
    libmesh_assert(Jpre);

    // ctx should be a pointer to the solver (it was passed in as void *)
    TaoOptimizationSolver<Number> * solver =
      static_cast<TaoOptimizationSolver<Number> *> (ctx);

    OptimizationSystem & sys = solver->system();

    // We'll use current_local_solution below, so let's ensure that it's consistent
    // with the vector x that was passed in.
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> X(x, sys.comm());

    // Perform a swap so that sys.solution points to the input vector
    // "x", update sys.current_local_solution based on "x", then swap
    // back.
    X.swap(X_sys);
    sys.update();
    X.swap(X_sys);

    // Let's also wrap J and Jpre in PetscMatrix objects for convenience
    PetscMatrix<Number> J_petsc(J, sys.comm());
    PetscMatrix<Number> Jpre_petsc(Jpre, sys.comm());

    // Enforce constraints exactly on the current_local_solution.
    sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());

    if (solver->inequality_constraints_jacobian_object != nullptr)
      solver->inequality_constraints_jacobian_object->inequality_constraints_jacobian(*(sys.current_local_solution), J_petsc, sys);
    else
      libmesh_error_msg("Constraints function not defined in __libmesh_tao_inequality_constraints_jacobian");

    J_petsc.close();
    Jpre_petsc.close();

    return ierr;
  }

__libmesh_tao_objective()

PetscErrorCode libMesh::__libmesh_tao_objective	(	Tao	,
		Vec	x,
		PetscReal *	objective,
		void *	ctx
	)

Definition at line 49 of file tao_optimization_solver.C.

References libMesh::ParallelObject::comm(), ierr, libMesh::OptimizationSystem::ComputeObjective::objective(), libMesh::OptimizationSolver< T >::objective_object, libMesh::PetscVector< T >::swap(), and libMesh::OptimizationSolver< T >::system().

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

  {
    LOG_SCOPE("objective()", "TaoOptimizationSolver");

    PetscErrorCode ierr = 0;

    libmesh_assert(x);
    libmesh_assert(objective);
    libmesh_assert(ctx);

    // ctx should be a pointer to the solver (it was passed in as void *)
    TaoOptimizationSolver<Number> * solver =
      static_cast<TaoOptimizationSolver<Number> *> (ctx);

    OptimizationSystem & sys = solver->system();

    // We'll use current_local_solution below, so let's ensure that it's consistent
    // with the vector x that was passed in.
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> X(x, sys.comm());

    // Perform a swap so that sys.solution points to the input vector
    // "x", update sys.current_local_solution based on "x", then swap
    // back.
    X.swap(X_sys);
    sys.update();
    X.swap(X_sys);

    // Enforce constraints (if any) exactly on the
    // current_local_solution.  This is the solution vector that is
    // actually used in the computation of the objective function
    // below, and is not locked by debug-enabled PETSc the way that
    // the solution vector is.
    sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());

    if (solver->objective_object != nullptr)
      (*objective) = solver->objective_object->objective(*(sys.current_local_solution), sys);
    else
      libmesh_error_msg("Objective function not defined in __libmesh_tao_objective");

    return ierr;
  }

as_range() [1/2]

template<typename I >

SimpleRange<I> libMesh::as_range

(

const std::pair< I, I > &

p

)

Helper function that allows us to treat a homogenous pair as a range. Useful for writing range-based for loops over the pair returned by std::equal_range() and std::map::equal_range().

Definition at line 57 of file simple_range.h.

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshRefinement::_refine_elements(), libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::add_elements(), libMesh::BoundaryInfo::add_node(), libMesh::BoundaryInfo::add_shellface(), libMesh::BoundaryInfo::add_side(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::BoundaryInfo::boundary_ids(), libMesh::Partitioner::build_graph(), libMesh::BoundaryInfo::build_side_list_from_node_list(), libMesh::Singleton::cleanup(), libMesh::CentroidPartitioner::compute_centroids(), connect_children(), libMesh::UnstructuredMesh::contract(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshCommunication::delete_remote_elements(), DMCreateFieldDecomposition_libMesh(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::LocationMap< T >::find(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::UNVIO::groups_in(), libMesh::BoundaryInfo::has_boundary_id(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::DofMap::merge_ghost_functor_outputs(), libMesh::MeshTools::n_active_levels(), libMesh::CheckpointIO::n_active_levels_in(), libMesh::MeshTools::n_levels(), libMesh::MeshTools::n_local_levels(), libMesh::MeshTools::n_non_subactive_elem_of_type_at_level(), libMesh::MeshTools::n_p_levels(), libMesh::GhostPointNeighbors::operator()(), libMesh::SiblingCoupling::operator()(), libMesh::DefaultCoupling::operator()(), libMesh::PointNeighborCoupling::operator()(), libMesh::MetisPartitioner::partition_range(), libMesh::LinearPartitioner::partition_range(), libMesh::MappedSubdomainPartitioner::partition_range(), libMesh::SFCPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), query_ghosting_functors(), libMesh::BoundaryInfo::raw_boundary_ids(), libMesh::BoundaryInfo::raw_edge_boundary_ids(), libMesh::BoundaryInfo::raw_shellface_boundary_ids(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::BoundaryInfo::shellface_boundary_ids(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::Partitioner::single_partition_range(), libMesh::MeshTools::Modification::smooth(), libMesh::Parallel::sync_node_data_by_element_id_once(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TecplotIO::write_binary(), libMesh::XdrIO::write_serialized_bcs_helper(), and libMesh::XdrIO::write_serialized_connectivity().

{
  return {p.first, p.second};
}

as_range() [2/2]

template<typename I >

SimpleRange<I> libMesh::as_range	(	const I &	first,
		const I &	second
	)

As above, but can be used in cases where a std::pair is not otherwise involved.

Definition at line 69 of file simple_range.h.

{
  return {first, second};
}

cast_int()

template<typename Tnew , typename Told >

Tnew libMesh::cast_int ( Told  oldvar )

inline

Definition at line 545 of file libmesh_common.h.

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

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

cast_ptr()

template<typename Tnew , typename Told >

Tnew libMesh::cast_ptr ( Told *  oldvar )

inline

Definition at line 508 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
}

cast_ref()

template<typename Tnew , typename Told >

Tnew libMesh::cast_ref ( Told &  oldvar )

inline

Definition at line 472 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
}

closed()

bool libMesh::closed

(

)

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

Definition at line 265 of file libmesh.C.

References libMesh::libMeshPrivateData::_is_initialized.

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

{
  return !libMeshPrivateData::_is_initialized;
}

command_line_next()

template<typename T >

T libMesh::command_line_next	(	std::string	name,
		T	default_value
	)

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

For backwards compatibility with past option naming conventions, libMesh searches for the given argument first in its original form, then with all underscores changed to dashes, then with all dashes (except any leading dashes) changed to underscores, and returns true if any of the above finds a match.

This routine manipulates the command_line cursor and should not be called concurrently with similar utilities in multiple threads.

Definition at line 941 of file libmesh.C.

References libMesh::Quality::name(), on_command_line(), and value.

Referenced by libMesh::NloptOptimizationSolver< T >::init(), and libMesh::DofMap::use_coupled_neighbor_dofs().

{
  // on_command_line also puts the command_line cursor in the spot we
  // need
  if (on_command_line(name))
    return command_line->next(value);

  return value;
}

command_line_next< double >()

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

command_line_next< float >()

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

command_line_next< int >()

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

command_line_next< long double >()

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

command_line_next< short >()

template short libMesh::command_line_next< short >	(	std::string	,
		short
	)

command_line_next< std::string >()

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

command_line_next< unsigned int >()

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

command_line_next< unsigned short >()

template unsigned short libMesh::command_line_next< unsigned short >	(	std::string	,
		unsigned	short
	)

command_line_value() [1/2]

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

This routine manipulates the command_line cursor and should not be called concurrently with similar utilities in multiple threads.

Definition at line 909 of file libmesh.C.

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

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;
}

command_line_value() [2/2]

template<typename T >

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

Definition at line 922 of file libmesh.C.

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

{
  // 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 (const auto & entry : name)
    if (command_line->have_variable(entry.c_str()))
      {
        value = (*command_line)(entry.c_str(), value);
        break;
      }

  return value;
}

command_line_value< double >() [1/2]

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

command_line_value< double >() [2/2]

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

command_line_value< float >() [1/2]

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

command_line_value< float >() [2/2]

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

command_line_value< int >() [1/2]

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

command_line_value< int >() [2/2]

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

command_line_value< long double >() [1/2]

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

command_line_value< long double >() [2/2]

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

command_line_value< short >() [1/2]

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

command_line_value< short >() [2/2]

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

command_line_value< std::string >() [1/2]

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

command_line_value< std::string >() [2/2]

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

command_line_value< unsigned int >() [1/2]

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

command_line_value< unsigned int >() [2/2]

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

command_line_value< unsigned short >() [1/2]

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

command_line_value< unsigned short >() [2/2]

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

command_line_vector()

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.

This routine manipulates the command_line cursor and should not be called concurrently with similar utilities in multiple threads.

Definition at line 954 of file libmesh.C.

References libMesh::Quality::name().

{
  // 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);
    }
}

command_line_vector< double >()

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

command_line_vector< float >()

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

command_line_vector< int >()

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

command_line_vector< long double >()

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

command_line_vector< short >()

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

command_line_vector< unsigned int >()

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

command_line_vector< unsigned short >()

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

connect_children()

void libMesh::connect_children	(	const MeshBase &	mesh,
		MeshBase::const_element_iterator	elem_it,
		MeshBase::const_element_iterator	elem_end,
		std::set< const Elem *, CompareElemIdsByLevel > &	connected_elements
	)

Definition at line 168 of file mesh_communication.C.

References as_range(), libMesh::Elem::child_ref_range(), libMesh::Elem::has_children(), libmesh_ignore(), mesh, and remote_elem.

Referenced by libMesh::MeshCommunication::delete_remote_elements(), and libMesh::CheckpointIO::write().

{
  // None of these parameters are used when !LIBMESH_ENABLE_AMR.
  libmesh_ignore(mesh, elem_it, elem_end, connected_elements);

#ifdef LIBMESH_ENABLE_AMR
  // Our XdrIO output needs inactive local elements to not have any
  // remote_elem children.  Let's make sure that doesn't happen.
  //
  for (const auto & elem : as_range(elem_it, elem_end))
    {
      if (elem->has_children())
        for (auto & child : elem->child_ref_range())
          if (&child != remote_elem)
            connected_elements.insert(&child);
    }
#endif // LIBMESH_ENABLE_AMR
}

connect_families()

void libMesh::connect_families

(

std::set< const Elem *, CompareElemIdsByLevel > &

connected_elements

)

Definition at line 191 of file mesh_communication.C.

References libMesh::Elem::active(), libMesh::Elem::has_children(), libmesh_ignore(), libMesh::Elem::parent(), remote_elem, and libMesh::Elem::total_family_tree().

Referenced by libMesh::MeshCommunication::delete_remote_elements(), and libMesh::CheckpointIO::write().

{
  // This parameter is not used when !LIBMESH_ENABLE_AMR.
  libmesh_ignore(connected_elements);

#ifdef LIBMESH_ENABLE_AMR

  // Because our set is sorted by ascending level, we can traverse it
  // in reverse order, adding parents as we go, and end up with all
  // ancestors added.  This is safe for std::set where insert doesn't
  // invalidate iterators.
  //
  // This only works because we do *not* cache
  // connected_elements.rend(), whose value can change when we insert
  // elements which are sorted before the original rend.
  //
  // We're also going to get subactive descendents here, when any
  // exist.  We're iterating in the wrong direction to do that
  // non-recursively, so we'll cop out and rely on total_family_tree.
  // Iterating backwards does mean that we won't be querying the newly
  // inserted subactive elements redundantly.

  std::set<const Elem *, CompareElemIdsByLevel>::reverse_iterator
    elem_rit  = connected_elements.rbegin();

  for (; elem_rit != connected_elements.rend(); ++elem_rit)
    {
      const Elem * elem = *elem_rit;
      libmesh_assert(elem);
      const Elem * parent = elem->parent();

      // We let ghosting functors worry about only active elements,
      // but the remote processor needs all its semilocal elements'
      // ancestors and active semilocal elements' descendants too.
      if (parent)
        connected_elements.insert (parent);

      if (elem->active() && elem->has_children())
        {
          std::vector<const Elem *> subactive_family;
          elem->total_family_tree(subactive_family);
          for (std::size_t i=0; i != subactive_family.size(); ++i)
            {
              libmesh_assert(subactive_family[i] != remote_elem);
              connected_elements.insert(subactive_family[i]);
            }
        }
    }

#  ifdef DEBUG
  // Let's be paranoid and make sure that all our ancestors
  // really did get inserted.  I screwed this up the first time
  // by caching rend, and I can easily imagine screwing it up in
  // the future by changing containers.
  for (const auto & elem : connected_elements)
    {
      libmesh_assert(elem);
      const Elem * parent = elem->parent();
      if (parent)
        libmesh_assert(connected_elements.count(parent));
    }
#  endif // DEBUG

#endif // LIBMESH_ENABLE_AMR
}

convert_solve_result()

DiffSolver::SolveResult libMesh::convert_solve_result

(

SNESConvergedReason

r

)

Definition at line 251 of file petsc_diff_solver.C.

References libMesh::DiffSolver::CONVERGED_ABSOLUTE_RESIDUAL, libMesh::DiffSolver::CONVERGED_NO_REASON, libMesh::DiffSolver::CONVERGED_RELATIVE_RESIDUAL, libMesh::DiffSolver::CONVERGED_RELATIVE_STEP, libMesh::DiffSolver::DIVERGED_BACKTRACKING_FAILURE, libMesh::DiffSolver::DIVERGED_MAX_NONLINEAR_ITERATIONS, libMesh::DiffSolver::DIVERGED_NO_REASON, and libMesh::DiffSolver::INVALID_SOLVE_RESULT.

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;
    case SNES_CONVERGED_ITS:
    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
    case SNES_DIVERGED_LINEAR_SOLVE:
    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;
}

cross_norm()

template<typename T >

T libMesh::cross_norm ( const TypeVector< T > &  b, const TypeVector< T > &  c  )

inline

Calls cross_norm_sq() and takes the square root of the result.

Definition at line 1097 of file type_vector.h.

References cross_norm_sq().

Referenced by libMesh::Quad4::volume(), libMesh::Tri3::volume(), libMesh::Quad8::volume(), libMesh::Tri6::volume(), and libMesh::Quad9::volume().

{
  return std::sqrt(cross_norm_sq(b,c));
}

cross_norm_sq()

template<typename T >

T libMesh::cross_norm_sq ( const TypeVector< T > &  b, const TypeVector< T > &  c  )

inline

Compute |b x c|^2 without creating the extra temporary produced by calling b.cross(c).norm_sq().

Definition at line 1076 of file type_vector.h.

Referenced by cross_norm().

{
  T z = b(0)*c(1) - b(1)*c(0);

#if LIBMESH_DIM == 3
  T x = b(1)*c(2) - b(2)*c(1),
    y = b(0)*c(2) - b(2)*c(0);
  return x*x + y*y + z*z;
#else
  return z*z;
#endif
}

default_solver_package()

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

References libMesh::libMeshPrivateData::_solver_package, EIGEN_SOLVERS, initialized(), INVALID_SOLVER_PACKAGE, LASPACK_SOLVERS, 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_TRILINOS_HAVE_AZTECOO
      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;
}

demangle()

std::string libMesh::demangle

(

const char *

name

)

Mostly system independent demangler

Definition at line 250 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-nullptr, 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;
}

enableFPE()

void libMesh::enableFPE

(

bool

on

)

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

Toggle hardware trap floating point exceptions

Definition at line 800 of file libmesh.C.

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

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

  if (on)
    {
#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

#if LIBMESH_HAVE_DECL_SIGACTION
      struct sigaction new_action, old_action;

      // 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, nullptr, &old_action);
      if (old_action.sa_handler != SIG_IGN)
        sigaction (SIGFPE, &new_action, nullptr);
#endif
    }
  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);
    }
}

enableSEGV()

void libMesh::enableSEGV

(

bool

on

)

Toggle libMesh reporting of segmentation faults

Definition at line 846 of file libmesh.C.

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

{
#if LIBMESH_HAVE_DECL_SIGACTION
  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, nullptr);
    }
#else
  libmesh_error_msg("System call sigaction not supported.");
#endif
}

get_io_compatibility_version()

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 80 of file libmesh_version.C.

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

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

get_libmesh_version()

int libMesh::get_libmesh_version

(

)

Definition at line 46 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;
}

global_n_processors()

libMesh::processor_id_type libMesh::global_n_processors ( )

inline

Returns

The number of processors libMesh was initialized with.

Definition at line 75 of file libmesh_base.h.

References libMesh::libMeshPrivateData::_n_processors.

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

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

global_processor_id()

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 85 of file libmesh_base.h.

References libMesh::libMeshPrivateData::_processor_id.

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

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

imaginary()

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

index_range() [1/2]

template<typename T >

IntRange<std::size_t> libMesh::index_range

(

const std::vector< T > &

vec

)

Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in vector.

Definition at line 104 of file int_range.h.

Referenced by __libmesh_nlopt_equality_constraints(), __libmesh_nlopt_inequality_constraints(), __libmesh_nlopt_objective(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::FEMap::compute_affine_map(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEMap::compute_single_point_map(), libMesh::Prism18::connectivity(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::ErrorEstimator::estimate_errors(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_point(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), libMesh::HCurlFETransformation< OutputShape >::map_phi(), libMesh::H1FETransformation< OutputShape >::map_phi(), libMesh::BoundaryProjectSolution::operator()(), libMesh::FEGenericBase< FEOutputType< T >::type >::print_d2phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::print_dphi(), libMesh::FEMap::print_JxW(), libMesh::FEGenericBase< FEOutputType< T >::type >::print_phi(), libMesh::FEMap::print_xyz(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_bc_names(), libMesh::CheckpointIO::read_bcs(), libMesh::CheckpointIO::read_nodesets(), libMesh::CheckpointIO::read_remote_elem(), libMesh::CheckpointIO::read_subdomain_names(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::FEMap::resize_quadrature_map_vectors(), libMesh::DofMap::scatter_constraints(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::FE< Dim, LAGRANGE_VEC >::side_map(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::EnsightIO::write_geometry_ascii(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::ExodusII_IO_Helper::write_sidesets(), and libMesh::EnsightIO::write_vector_ascii().

{
  return IntRange<std::size_t>(0, vec.size());
}

index_range() [2/2]

template<typename T >

IntRange<numeric_index_type> libMesh::index_range

(

const NumericVector< T > &

vec

)

Same thing but for NumericVector. Returns a range (first_local_index, last_local_index).

Definition at line 115 of file int_range.h.

References libMesh::NumericVector< T >::first_local_index(), and libMesh::NumericVector< T >::last_local_index().

{
  return {vec.first_local_index(), vec.last_local_index()};
}

initialized()

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

References libMesh::libMeshPrivateData::_is_initialized.

Referenced by libMesh::PetscVector< T >::_get_array(), libMesh::PetscVector< T >::_restore_array(), libMesh::EigenSparseVector< T >::abs(), libMesh::DistributedVector< T >::abs(), libMesh::LaspackVector< T >::abs(), libMesh::EigenSparseMatrix< T >::add(), libMesh::LaspackMatrix< T >::add(), libMesh::EpetraMatrix< T >::add(), libMesh::PetscMatrix< T >::add(), libMesh::DistributedVector< T >::add(), libMesh::LaspackVector< 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::LaspackLinearSolver< T >::clear(), libMesh::AztecLinearSolver< T >::clear(), libMesh::SlepcEigenSolver< T >::clear(), libMesh::TaoOptimizationSolver< T >::clear(), libMesh::NloptOptimizationSolver< T >::clear(), libMesh::LaspackMatrix< T >::clear(), libMesh::LaspackVector< T >::clear(), libMesh::PetscNonlinearSolver< Number >::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::EpetraMatrix< T >::clear(), libMesh::EpetraVector< T >::clear(), libMesh::PetscVector< T >::clear(), libMesh::PetscMatrix< T >::clear(), libMesh::DistributedVector< T >::close(), libMesh::LaspackMatrix< T >::close(), libMesh::EigenSparseVector< T >::close(), libMesh::LaspackVector< T >::close(), libMesh::EpetraVector< T >::close(), libMesh::EpetraMatrix< T >::closed(), libMesh::PetscMatrix< T >::closed(), libMesh::NumericVector< Number >::compare(), default_solver_package(), libMesh::EigenSparseVector< T >::dot(), libMesh::LaspackVector< T >::dot(), libMesh::DistributedVector< T >::first_local_index(), libMesh::EigenSparseVector< T >::first_local_index(), libMesh::LaspackVector< T >::first_local_index(), libMesh::EpetraVector< T >::first_local_index(), libMesh::PetscVector< T >::first_local_index(), libMesh::TaoOptimizationSolver< T >::get_converged_reason(), libMesh::PetscNonlinearSolver< Number >::get_converged_reason(), libMesh::NumericVector< Number >::global_relative_compare(), libMesh::EigenSparseLinearSolver< T >::init(), libMesh::LaspackLinearSolver< T >::init(), libMesh::AztecLinearSolver< T >::init(), libMesh::SlepcEigenSolver< T >::init(), libMesh::TaoOptimizationSolver< T >::init(), libMesh::NoxNonlinearSolver< Number >::init(), libMesh::EigenSparseMatrix< T >::init(), libMesh::NloptOptimizationSolver< T >::init(), libMesh::LaspackMatrix< T >::init(), libMesh::PetscMatrix< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::EpetraMatrix< T >::init(), libMesh::EigenSparseVector< T >::init(), libMesh::PetscNonlinearSolver< Number >::init(), libMesh::PetscLinearSolver< 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::EigenSparseVector< T >::last_local_index(), libMesh::LaspackVector< 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< Number >::local_relative_compare(), libMesh::DistributedVector< T >::local_size(), libMesh::EigenSparseVector< T >::local_size(), libMesh::LaspackVector< 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::EigenSparseVector< T >::max(), libMesh::LaspackVector< T >::max(), libMesh::EpetraVector< T >::max(), libMesh::MeshBase::MeshBase(), libMesh::DistributedVector< T >::min(), libMesh::EigenSparseVector< T >::min(), libMesh::LaspackVector< 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::DistributedVector< T >::operator()(), libMesh::EpetraMatrix< T >::operator()(), libMesh::EigenSparseVector< T >::operator()(), libMesh::LaspackVector< T >::operator()(), libMesh::EpetraVector< T >::operator()(), libMesh::PetscMatrix< T >::operator()(), libMesh::DistributedVector< T >::operator+=(), libMesh::DistributedVector< T >::operator-=(), libMesh::DistributedVector< T >::operator=(), libMesh::EigenSparseVector< T >::operator=(), libMesh::LaspackVector< T >::operator=(), libMesh::SparseMatrix< ValOut >::print(), libMesh::NumericVector< Number >::print(), libMesh::NumericVector< Number >::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::EigenSparseVector< T >::scale(), libMesh::DistributedVector< T >::scale(), libMesh::LaspackVector< T >::scale(), libMesh::EigenSparseMatrix< T >::set(), libMesh::LaspackMatrix< T >::set(), libMesh::EpetraMatrix< T >::set(), libMesh::PetscMatrix< T >::set(), libMesh::DistributedVector< T >::set(), libMesh::EigenSparseVector< T >::set(), libMesh::LaspackVector< T >::set(), libMesh::DistributedVector< T >::size(), libMesh::EigenSparseVector< T >::size(), libMesh::LaspackVector< 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::EigenSparseVector< T >::zero(), libMesh::LaspackVector< T >::zero(), libMesh::EpetraMatrix< T >::zero(), libMesh::EpetraVector< T >::zero(), libMesh::PetscMatrix< T >::zero(), and libMesh::PetscMatrix< T >::zero_rows().

{
  return libMeshPrivateData::_is_initialized;
}

INSTANTIATE_ALL_MAPS() [1/4]

libMesh::INSTANTIATE_ALL_MAPS

(

0

)

INSTANTIATE_ALL_MAPS() [2/4]

libMesh::INSTANTIATE_ALL_MAPS

(

1

)

INSTANTIATE_ALL_MAPS() [3/4]

libMesh::INSTANTIATE_ALL_MAPS

(

2

)

INSTANTIATE_ALL_MAPS() [4/4]

libMesh::INSTANTIATE_ALL_MAPS

(

3

)

INSTANTIATE_FE() [1/4]

libMesh::INSTANTIATE_FE

(

0

)

INSTANTIATE_FE() [2/4]

libMesh::INSTANTIATE_FE

(

1

)

INSTANTIATE_FE() [3/4]

libMesh::INSTANTIATE_FE

(

2

)

INSTANTIATE_FE() [4/4]

libMesh::INSTANTIATE_FE

(

3

)

INSTANTIATE_INF_FE() [1/3]

libMesh::INSTANTIATE_INF_FE	(	2	,
		CARTESIAN
	)

Collect all 2D explicit instantiations for class InfFE

INSTANTIATE_INF_FE() [2/3]

libMesh::INSTANTIATE_INF_FE	(	3	,
		CARTESIAN
	)

Collect all 3D explicit instantiations for class InfFE

INSTANTIATE_INF_FE() [3/3]

libMesh::INSTANTIATE_INF_FE	(	1	,
		CARTESIAN
	)

Collect all 1D explicit instantiations for class InfFE

INSTANTIATE_INF_FE_MBRF() [1/57]

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		Elem *	,
		Base::build_elem(const Elem *)
	)

INSTANTIATE_INF_FE_MBRF() [2/57]

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		Elem *	,
		Base::build_elem(const Elem *)
	)

INSTANTIATE_INF_FE_MBRF() [3/57]

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		Elem *	,
		Base::build_elem(const Elem *)
	)

INSTANTIATE_INF_FE_MBRF() [4/57]

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		ElemType	,
		Base::get_elem_type(const ElemType type)
	)

INSTANTIATE_INF_FE_MBRF() [5/57]

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		ElemType	,
		Base::get_elem_type(const ElemType type)
	)

INSTANTIATE_INF_FE_MBRF() [6/57]

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		ElemType	,
		Base::get_elem_type(const ElemType type)
	)

INSTANTIATE_INF_FE_MBRF() [7/57]

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

INSTANTIATE_INF_FE_MBRF() [8/57]

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

INSTANTIATE_INF_FE_MBRF() [9/57]

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

INSTANTIATE_INF_FE_MBRF() [10/57]

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

INSTANTIATE_INF_FE_MBRF() [11/57]

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

INSTANTIATE_INF_FE_MBRF() [12/57]

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

INSTANTIATE_INF_FE_MBRF() [13/57]

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

INSTANTIATE_INF_FE_MBRF() [14/57]

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

INSTANTIATE_INF_FE_MBRF() [15/57]

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

INSTANTIATE_INF_FE_MBRF() [16/57]

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

INSTANTIATE_INF_FE_MBRF() [17/57]

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

INSTANTIATE_INF_FE_MBRF() [18/57]

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

INSTANTIATE_INF_FE_MBRF() [19/57]

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

INSTANTIATE_INF_FE_MBRF() [20/57]

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

INSTANTIATE_INF_FE_MBRF() [21/57]

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

INSTANTIATE_INF_FE_MBRF() [22/57]

libMesh::INSTANTIATE_INF_FE_MBRF	(	1	,
		CARTESIAN	,
		Point	,
		map(const Elem *, const Point &)
	)

INSTANTIATE_INF_FE_MBRF() [23/57]

libMesh::INSTANTIATE_INF_FE_MBRF	(	2	,
		CARTESIAN	,
		Point	,
		map(const Elem *, const Point &)
	)

INSTANTIATE_INF_FE_MBRF() [24/57]

libMesh::INSTANTIATE_INF_FE_MBRF	(	3	,
		CARTESIAN	,
		Point	,
		map(const Elem *, const Point &)
	)

INSTANTIATE_INF_FE_MBRF() [25/57]

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

INSTANTIATE_INF_FE_MBRF() [26/57]

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

INSTANTIATE_INF_FE_MBRF() [27/57]

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

INSTANTIATE_INF_FE_MBRF() [28/57]

libMesh::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() [29/57]

libMesh::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() [30/57]

libMesh::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() [31/57]

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

INSTANTIATE_INF_FE_MBRF() [32/57]

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

INSTANTIATE_INF_FE_MBRF() [33/57]

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

INSTANTIATE_INF_FE_MBRF() [34/57]

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

INSTANTIATE_INF_FE_MBRF() [35/57]

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

INSTANTIATE_INF_FE_MBRF() [36/57]

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

INSTANTIATE_INF_FE_MBRF() [37/57]

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

INSTANTIATE_INF_FE_MBRF() [38/57]

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

INSTANTIATE_INF_FE_MBRF() [39/57]

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

INSTANTIATE_INF_FE_MBRF() [40/57]

libMesh::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() [41/57]

libMesh::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() [42/57]

libMesh::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() [43/57]

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

INSTANTIATE_INF_FE_MBRF() [44/57]

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

INSTANTIATE_INF_FE_MBRF() [45/57]

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

INSTANTIATE_INF_FE_MBRF() [46/57]

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

INSTANTIATE_INF_FE_MBRF() [47/57]

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

INSTANTIATE_INF_FE_MBRF() [48/57]

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

INSTANTIATE_INF_FE_MBRF() [49/57]

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

INSTANTIATE_INF_FE_MBRF() [50/57]

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

INSTANTIATE_INF_FE_MBRF() [51/57]

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

INSTANTIATE_INF_FE_MBRF() [52/57]

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

INSTANTIATE_INF_FE_MBRF() [53/57]

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

INSTANTIATE_INF_FE_MBRF() [54/57]

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

INSTANTIATE_INF_FE_MBRF() [55/57]

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

INSTANTIATE_INF_FE_MBRF() [56/57]

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

INSTANTIATE_INF_FE_MBRF() [57/57]

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

is_between()

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

Definition at line 30 of file bounding_box.C.

References std::max(), and std::min().

Referenced by libMesh::BoundingBox::contains_point(), and libMesh::BoundingBox::intersects().

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

libmesh_cast_int()

template<typename Tnew , typename Told >

Tnew libMesh::libmesh_cast_int ( Told  oldvar )

inline

Definition at line 555 of file libmesh_common.h.

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

libmesh_cast_ptr()

template<typename Tnew , typename Told >

Tnew libMesh::libmesh_cast_ptr ( Told *  oldvar )

inline

Definition at line 530 of file libmesh_common.h.

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

libmesh_cast_ref()

template<typename Tnew , typename Told >

Tnew libMesh::libmesh_cast_ref ( Told &  oldvar )

inline

Definition at line 497 of file libmesh_common.h.

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

libmesh_conj() [1/2]

template<typename T >

T libMesh::libmesh_conj ( T  a )

inline

Definition at line 162 of file libmesh_common.h.

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

{ return a; }

libmesh_conj() [2/2]

template<typename T >

std::complex<T> libMesh::libmesh_conj ( std::complex< T >  a )

inline

Definition at line 168 of file libmesh_common.h.

{ return std::conj(a); }

libmesh_ignore()

template<class ... Args>

void libMesh::libmesh_ignore ( const Args &  ... )

inline

Definition at line 461 of file libmesh_common.h.

Referenced by libMesh::Parallel::Communicator::alltoall(), libMesh::Parallel::Communicator::broadcast(), libMesh::OptimizationSolver< T >::build(), libMesh::LinearSolver< Number >::build(), libMesh::SparseMatrix< ValOut >::build(), libMesh::Preconditioner< Number >::build_preconditioner(), libMesh::FEMap::compute_inverse_map_second_derivs(), connect_children(), connect_families(), libMesh::ExodusII_IO_Helper::Conversion::Conversion(), libMesh::Parallel::DataType::DataType(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshCommunication::find_global_indices(), libMesh::MeshTools::Modification::flatten(), libMesh::PetscMatrix< T >::init(), libMesh::Elem::is_vertex_on_parent(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::Parallel::Communicator::maxloc(), libMesh::Parallel::Communicator::minloc(), libMesh::Parallel::Communicator::scatter(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::Parallel::Status::size(), and libMesh::Parallel::StandardType< Point >::StandardType().

{ }

libmesh_isinf() [1/2]

template<typename T >

bool libMesh::libmesh_isinf ( T  x )

inline

Definition at line 182 of file libmesh_common.h.

References libmesh_isnan().

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::inverse_map(), and libmesh_isinf().

{ return !libmesh_isnan(x) && libmesh_isnan(x - x); }

libmesh_isinf() [2/2]

template<typename T >

bool libMesh::libmesh_isinf ( std::complex< T >  a )

inline

Definition at line 185 of file libmesh_common.h.

References libmesh_isinf().

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

libmesh_isnan() [1/4]

bool libMesh::libmesh_isnan ( float  a )

inline

Definition at line 172 of file libmesh_common.h.

References libmesh_C_isnan_float().

Referenced by libMesh::DofMap::allgather_recursive_constraints(), libmesh_isinf(), libmesh_isnan(), libMesh::NewtonSolver::line_search(), libMesh::XdrIO::read_serialized_nodes(), libMesh::NewtonSolver::solve(), and libMesh::Edge3::volume().

{ return libmesh_C_isnan_float(a); }

libmesh_isnan() [2/4]

bool libMesh::libmesh_isnan ( double  a )

inline

Definition at line 173 of file libmesh_common.h.

References libmesh_C_isnan_double().

{ return libmesh_C_isnan_double(a); }

libmesh_isnan() [3/4]

bool libMesh::libmesh_isnan ( long double  a )

inline

Definition at line 174 of file libmesh_common.h.

References libmesh_C_isnan_longdouble().

{ return libmesh_C_isnan_longdouble(a); }

libmesh_isnan() [4/4]

template<typename T >

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

inline

Definition at line 177 of file libmesh_common.h.

References libmesh_isnan().

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

libmesh_petsc_linesearch_shellfunc()

PetscErrorCode libMesh::libmesh_petsc_linesearch_shellfunc	(	SNESLineSearch	linesearch,
		void *	ctx
	)

Definition at line 384 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::linesearch_object.

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

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

    solver->linesearch_object->linesearch(linesearch);
    return 0;
  }

libmesh_petsc_preconditioner_apply() [1/2]

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

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

Definition at line 61 of file petsc_linear_solver.C.

Referenced by __libmesh_petsc_preconditioner_apply(), libMesh::PetscNonlinearSolver< Number >::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;
  }

libmesh_petsc_preconditioner_apply() [2/2]

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

Definition at line 87 of file petsc_linear_solver.C.

References CHKERRQ(), and 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;
  }

libmesh_petsc_preconditioner_setup() [1/2]

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

Referenced by __libmesh_petsc_preconditioner_setup(), libMesh::PetscNonlinearSolver< Number >::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;
  }

libmesh_petsc_preconditioner_setup() [2/2]

PetscErrorCode libMesh::libmesh_petsc_preconditioner_setup

(

PC

pc

)

Definition at line 73 of file petsc_linear_solver.C.

References CHKERRQ(), and 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;
  }

libmesh_petsc_snes_fd_residual()

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

Definition at line 201 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::_zero_out_residual, libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::NonlinearSolver< T >::fd_residual_object, libMesh::ResidualContext::ierr, libmesh_petsc_snes_residual_helper(), libMesh::NonlinearImplicitSystem::ComputeResidual::residual(), libMesh::NonlinearSolver< T >::residual_object, libMesh::ResidualContext::solver, libMesh::ResidualContext::sys, and libMesh::PetscVector< T >::zero().

Referenced by __libmesh_petsc_snes_fd_residual().

  {
    ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);

    libmesh_assert(r);
    PetscVector<Number> R(r, rc.sys.comm());

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

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

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

    else
      libmesh_error_msg("Error! Unable to compute residual for forming finite difference Jacobian!");

    R.close();

    return rc.ierr;
  }

libmesh_petsc_snes_jacobian() [1/3]

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

libmesh_petsc_snes_jacobian() [2/3]

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

libmesh_petsc_snes_jacobian() [3/3]

PetscErrorCode libMesh::libmesh_petsc_snes_jacobian	(	#if PETSC_RELEASE_LESS_THAN(3, 5, 0) SNES	snes,
		Vec	x,
		Mat *	jac,
		Mat *	pc,
		MatStructure *	msflag,
		void *ctx #else SNES	snes,
		Vec	x,
		Mat	jac,
		Mat	pc,
		void *ctx #	endif
	)

Definition at line 288 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::_current_nonlinear_iteration_number, libMesh::PetscNonlinearSolver< T >::_zero_out_jacobian, libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::DofMap::enforce_constraints_exactly(), libMesh::Parallel::Communicator::get(), libMesh::System::get_dof_map(), ierr, libMesh::NonlinearImplicitSystem::ComputeJacobian::jacobian(), libMesh::NonlinearSolver< T >::jacobian, libMesh::NonlinearSolver< T >::jacobian_object, libMesh::NonlinearSolver< T >::matvec, libMesh::NonlinearImplicitSystem::ComputeResidualandJacobian::residual_and_jacobian(), libMesh::NonlinearSolver< T >::residual_and_jacobian_object, libMesh::System::solution, libMesh::PetscVector< T >::swap(), libMesh::NonlinearSolver< T >::system(), and libMesh::System::update().

Referenced by __libmesh_petsc_snes_jacobian(), and libMesh::PetscNonlinearSolver< Number >::solve().

  {
    LOG_SCOPE("jacobian()", "PetscNonlinearSolver");

    PetscErrorCode ierr=0;

    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 Jacobian 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();
#if PETSC_RELEASE_LESS_THAN(3,5,0)
    PetscMatrix<Number> PC(*pc, sys.comm());
    PetscMatrix<Number> Jac(*jac, sys.comm());
#else
    PetscMatrix<Number> PC(pc, sys.comm());
    PetscMatrix<Number> Jac(jac, sys.comm());
#endif
    PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
    PetscVector<Number> X_global(x, sys.comm());

    // Set the dof maps
    PC.attach_dof_map(sys.get_dof_map());
    Jac.attach_dof_map(sys.get_dof_map());

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

    // Enforce constraints (if any) exactly on the
    // current_local_solution.  This is the solution vector that is
    // actually used in the computation of the residual below, and is
    // not locked by debug-enabled PETSc the way that "x" is.
    sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());

    if (solver->_zero_out_jacobian)
      PC.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->jacobian && solver->jacobian_object)
      libmesh_error_msg("ERROR: cannot specify both a function and object to compute the Jacobian!");

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

    if (solver->jacobian != nullptr)
      solver->jacobian(*sys.current_local_solution.get(), PC, sys);

    else if (solver->jacobian_object != nullptr)
      solver->jacobian_object->jacobian(*sys.current_local_solution.get(), PC, sys);

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

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

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

    PC.close();
    Jac.close();
#if PETSC_RELEASE_LESS_THAN(3,5,0)
    *msflag = SAME_NONZERO_PATTERN;
#endif

    return ierr;
  }

libmesh_petsc_snes_mffd_interface()

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

Definition at line 267 of file petsc_nonlinear_solver.C.

References libmesh_petsc_snes_mffd_residual(), and libMesh::PetscNonlinearSolver< T >::snes().

Referenced by __libmesh_petsc_snes_mffd_interface(), and libMesh::PetscNonlinearSolver< Number >::solve().

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

    return libmesh_petsc_snes_mffd_residual(solver->snes(), x, r, ctx);
  }

libmesh_petsc_snes_mffd_residual()

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

Definition at line 238 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::_zero_out_residual, libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::ResidualContext::ierr, libmesh_petsc_snes_residual_helper(), libMesh::NonlinearSolver< T >::mffd_residual_object, libMesh::NonlinearImplicitSystem::ComputeResidual::residual(), libMesh::NonlinearSolver< T >::residual_object, libMesh::ResidualContext::solver, libMesh::ResidualContext::sys, and libMesh::PetscVector< T >::zero().

Referenced by libmesh_petsc_snes_mffd_interface().

  {
    ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);

    libmesh_assert(r);
    PetscVector<Number> R(r, rc.sys.comm());

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

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

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

    else
      libmesh_error_msg("Error! Unable to compute residual for forming finite differenced"
                        "Jacobian-vector products!");

    R.close();

    return rc.ierr;
  }

libmesh_petsc_snes_monitor()

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

Definition at line 122 of file petsc_nonlinear_solver.C.

References out.

Referenced by __libmesh_petsc_snes_monitor(), and libMesh::PetscNonlinearSolver< Number >::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;
  }

libmesh_petsc_snes_postcheck()

PetscErrorCode libMesh::libmesh_petsc_snes_postcheck	(	#if PETSC_VERSION_LESS_THAN(3, 3, 0)	SNES,
		Vec	x,
		Vec	y,
		Vec	w,
		void *	context,
		PetscBool *	changed_y,
		PetscBool *changed_w #else	SNESLineSearch,
		Vec	x,
		Vec	y,
		Vec	w,
		PetscBool *	changed_y,
		PetscBool *	changed_w,
		void *context #	endif
	)

Definition at line 425 of file petsc_nonlinear_solver.C.

References libMesh::ParallelObject::comm(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::System::get_dof_map(), ierr, libMesh::DofMap::n_constrained_dofs(), libMesh::NonlinearImplicitSystem::ComputePostCheck::postcheck(), libMesh::NonlinearSolver< T >::postcheck, libMesh::NonlinearSolver< T >::postcheck_object, libMesh::System::solution, libMesh::PetscVector< T >::swap(), and libMesh::NonlinearSolver< T >::system().

Referenced by __libmesh_petsc_snes_postcheck(), and libMesh::PetscNonlinearSolver< Number >::init().

  {
    LOG_SCOPE("postcheck()", "PetscNonlinearSolver");

    PetscErrorCode ierr = 0;

    // PETSc almost certainly initializes these to false already, but
    // it doesn't hurt to be explicit.
    *changed_w = PETSC_FALSE;
    *changed_y = PETSC_FALSE;

    libmesh_assert(context);

    // Cast the context to a NonlinearSolver object.
    PetscNonlinearSolver<Number> * solver =
      static_cast<PetscNonlinearSolver<Number> *> (context);

    // If the user has provided both postcheck function pointer and
    // object, this is ambiguous, so throw an error.
    if (solver->postcheck && solver->postcheck_object)
      libmesh_error_msg("ERROR: cannot specify both a function and object for performing the solve postcheck!");

    // It's also possible that we don't need to do anything at all, in
    // that case return early...
    NonlinearImplicitSystem & sys = solver->system();
    DofMap & dof_map = sys.get_dof_map();

    if (!dof_map.n_constrained_dofs() && !solver->postcheck && !solver->postcheck_object)
      return ierr;

    // We definitely need to wrap at least "w"
    PetscVector<Number> petsc_w(w, sys.comm());

    // The user sets these flags in his/her postcheck function to
    // indicate whether they changed something.
    bool
      changed_search_direction = false,
      changed_new_soln = false;

    if (solver->postcheck || solver->postcheck_object)
      {
        PetscVector<Number> petsc_x(x, sys.comm());
        PetscVector<Number> petsc_y(y, sys.comm());

        if (solver->postcheck)
          solver->postcheck(petsc_x,
                            petsc_y,
                            petsc_w,
                            changed_search_direction,
                            changed_new_soln,
                            sys);

        else if (solver->postcheck_object)
          solver->postcheck_object->postcheck(petsc_x,
                                              petsc_y,
                                              petsc_w,
                                              changed_search_direction,
                                              changed_new_soln,
                                              sys);
      }

    // Record whether the user changed the solution or the search direction.
    if (changed_search_direction)
      *changed_y = PETSC_TRUE;

    if (changed_new_soln)
      *changed_w = PETSC_TRUE;

    if (dof_map.n_constrained_dofs())
      {
        PetscVector<Number> & system_soln = *cast_ptr<PetscVector<Number> *>(sys.solution.get());

        // ... and swap it in before enforcing the constraints.
        petsc_w.swap(system_soln);

        dof_map.enforce_constraints_exactly(sys);

        // If we have constraints, we'll assume that we did change the
        // solution w (hopefully slightly).  Enforcing constraints
        // does not change the search direction, y, but the user may
        // have, so we leave it alone.
        *changed_w = PETSC_TRUE;

        // Swap back
        petsc_w.swap(system_soln);
      }

    return ierr;
  }

libmesh_petsc_snes_residual()

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

Definition at line 150 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::_zero_out_residual, libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::ResidualContext::ierr, libmesh_petsc_snes_residual_helper(), 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::ResidualContext::solver, libMesh::ResidualContext::sys, and libMesh::PetscVector< T >::zero().

Referenced by __libmesh_petsc_snes_residual(), and libMesh::PetscNonlinearSolver< Number >::solve().

  {
    ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);

    libmesh_assert(r);
    PetscVector<Number> R(r, rc.sys.comm());

    if (rc.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 (rc.solver->residual && rc.solver->residual_object)
      libmesh_error_msg("ERROR: cannot specify both a function and object to compute the Residual!");

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

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

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

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

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

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

    R.close();

    return rc.ierr;
  }

libmesh_petsc_snes_residual_helper()

ResidualContext libMesh::libmesh_petsc_snes_residual_helper	(	SNES	snes,
		Vec	x,
		void *	ctx
	)

Definition at line 64 of file petsc_nonlinear_solver.C.

References libMesh::PetscNonlinearSolver< T >::_current_nonlinear_iteration_number, libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::DofMap::enforce_constraints_exactly(), libMesh::Parallel::Communicator::get(), libMesh::System::get_dof_map(), ierr, libMesh::System::solution, libMesh::PetscVector< T >::swap(), libMesh::NonlinearSolver< T >::system(), and libMesh::System::update().

Referenced by libmesh_petsc_snes_fd_residual(), libmesh_petsc_snes_mffd_residual(), and libmesh_petsc_snes_residual().

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

  PetscErrorCode ierr = 0;

  libmesh_assert(x);
  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> X_global(x, sys.comm());

  // Use the system's update() to get a good local version of the
  // parallel solution.  This operation does not modify the incoming
  // "x" vector, it only localizes information from "x" into
  // sys.current_local_solution.
  X_global.swap(X_sys);
  sys.update();
  X_global.swap(X_sys);

  // Enforce constraints (if any) exactly on the
  // current_local_solution.  This is the solution vector that is
  // actually used in the computation of the residual below, and is
  // not locked by debug-enabled PETSc the way that "x" is.
  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());

  return ResidualContext(solver, sys, ierr);
}

libmesh_real() [1/2]

template<typename T >

T libMesh::libmesh_real ( T  a )

inline

Definition at line 161 of file libmesh_common.h.

Referenced by libMesh::FEMContext::_do_elem_position_set(), libMesh::ContinuationSystem::continuation_solve(), libMesh::DenseSubVector< T >::max(), libMesh::DistributedVector< T >::max(), libMesh::EigenSparseVector< T >::max(), libMesh::LaspackVector< T >::max(), libMesh::DenseVector< Output >::max(), libMesh::DenseMatrix< Number >::max(), libMesh::DenseSubVector< T >::min(), libMesh::DistributedVector< T >::min(), libMesh::EigenSparseVector< T >::min(), libMesh::LaspackVector< T >::min(), libMesh::DenseVector< Output >::min(), libMesh::DenseMatrix< Number >::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; }

libmesh_real() [2/2]

template<typename T >

T libMesh::libmesh_real ( std::complex< T >  a )

inline

Definition at line 165 of file libmesh_common.h.

{ return std::real(a); }

libmesh_terminate_handler()

void libMesh::libmesh_terminate_handler

(

)

Definition at line 274 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();
}

libmesh_version_stdout()

void libMesh::libmesh_version_stdout

(

)

Definition at line 23 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_VMA_INSTANTIATE() [1/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		int	,
		Real
	)

LIBMESH_VMA_INSTANTIATE() [2/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		float	,
		Real
	)

LIBMESH_VMA_INSTANTIATE() [3/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		double	,
		Real
	)

LIBMESH_VMA_INSTANTIATE() [4/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		int	,
		Complex
	)

LIBMESH_VMA_INSTANTIATE() [5/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		int	,
		Complex
	)

LIBMESH_VMA_INSTANTIATE() [6/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		int	,
		Real
	)

LIBMESH_VMA_INSTANTIATE() [7/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		float	,
		Complex
	)

LIBMESH_VMA_INSTANTIATE() [8/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		float	,
		Complex
	)

LIBMESH_VMA_INSTANTIATE() [9/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		float	,
		Real
	)

LIBMESH_VMA_INSTANTIATE() [10/18]

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

LIBMESH_VMA_INSTANTIATE() [11/18]

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

LIBMESH_VMA_INSTANTIATE() [12/18]

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

LIBMESH_VMA_INSTANTIATE() [13/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Real	,
		double	,
		Complex
	)

LIBMESH_VMA_INSTANTIATE() [14/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		double	,
		Complex
	)

LIBMESH_VMA_INSTANTIATE() [15/18]

libMesh::LIBMESH_VMA_INSTANTIATE	(	Complex	,
		double	,
		Real
	)

LIBMESH_VMA_INSTANTIATE() [16/18]

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

LIBMESH_VMA_INSTANTIATE() [17/18]

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

LIBMESH_VMA_INSTANTIATE() [18/18]

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

make_unique()

template<typename T , typename... Args>

std::unique_ptr<T> libMesh::make_unique

(

Args &&...

args

)

Definition at line 45 of file auto_ptr.h.

{
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

MeshCommunication::find_global_indices< MeshBase::const_element_iterator >()

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

MeshCommunication::find_global_indices< MeshBase::const_node_iterator >()

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

MeshCommunication::find_global_indices< MeshBase::element_iterator >()

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

MeshCommunication::find_global_indices< MeshBase::node_iterator >()

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

MeshCommunication::find_local_indices< MeshBase::const_element_iterator >()

template void libMesh::MeshCommunication::find_local_indices< MeshBase::const_element_iterator >	(	const libMesh::BoundingBox &	,
		const MeshBase::const_element_iterator &	,
		const MeshBase::const_element_iterator &	,
		std::unordered_map< dof_id_type, dof_id_type > &
	)		const

n_threads()

unsigned int libMesh::n_threads ( )

inline

Returns

The maximum number of threads used in the simulation.

Definition at line 96 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(), and libMesh::Threads::num_pthreads().

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

numeric_petsc_cast()

PetscInt* libMesh::numeric_petsc_cast ( const numeric_index_type *  p )

inline

Definition at line 1217 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(), libMesh::PetscVector< T >::localize(), and libMesh::PetscMatrix< T >::zero_rows().

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

numeric_trilinos_cast()

int* libMesh::numeric_trilinos_cast ( const numeric_index_type *  p )

inline

Definition at line 831 of file trilinos_epetra_vector.h.

Referenced by libMesh::EpetraMatrix< T >::add_matrix(), libMesh::EpetraVector< T >::add_vector(), and libMesh::EpetraVector< T >::insert().

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

on_command_line()

bool libMesh::on_command_line

(

std::string

arg

)

Returns

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

For backwards compatibility with past option naming conventions, libMesh searches for the given argument first in its original form, then with all underscores changed to dashes, then with all dashes (except any leading dashes) changed to underscores, and returns true if any of the above finds a match.

This routine manipulates the command_line cursor and should not be called concurrently with similar utilities in multiple threads.

Definition at line 876 of file libmesh.C.

Referenced by libMesh::PetscDMWrapper::build_section(), libMesh::Node::choose_processor_id(), command_line_next(), libMesh::ContinuationSystem::ContinuationSystem(), default_solver_package(), libMesh::DofMap::distribute_dofs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::NewtonSolver::init(), libMesh::NloptOptimizationSolver< T >::init(), libMesh::TimeSolver::init_data(), libMesh::LibMeshInit::LibMeshInit(), petsc_auto_fieldsplit(), print_trace(), libMesh::System::read_header(), libMesh::TimeSolver::reinit(), libMesh::MacroFunctions::report_error(), libMesh::Partitioner::set_node_processor_ids(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LinearImplicitSystem::solve(), libMesh::NonlinearImplicitSystem::solve(), and libMesh::DofMap::use_coupled_neighbor_dofs().

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

  // Users had better not be asking about an empty string
  libmesh_assert(!arg.empty());

  bool found_it = command_line->search(arg);

  if (!found_it)
    {
      // Try with all dashes instead of underscores
      std::replace(arg.begin(), arg.end(), '_', '-');
      found_it = command_line->search(arg);
    }

  if (!found_it)
    {
      // OK, try with all underscores instead of dashes
      auto name_begin = arg.begin();
      while (*name_begin == '-')
        ++name_begin;
      std::replace(name_begin, arg.end(), '-', '_');
      found_it = command_line->search(arg);
    }

  return found_it;
}

operator!=() [1/5]

bool libMesh::operator!= ( const OrderWrapper &  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 96 of file fe_type.h.

{ return !(lhs == rhs); }

operator!=() [2/5]

bool libMesh::operator!= ( int  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 141 of file fe_type.h.

{ return !(lhs == rhs); }

operator!=() [3/5]

bool libMesh::operator!= ( const OrderWrapper &  lhs, int  rhs  )

inline

Definition at line 142 of file fe_type.h.

{ return !(lhs == rhs); }

operator!=() [4/5]

bool libMesh::operator!= ( Order  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 143 of file fe_type.h.

{ return !(lhs == rhs); }

operator!=() [5/5]

bool libMesh::operator!= ( const OrderWrapper &  lhs, Order  rhs  )

inline

Definition at line 144 of file fe_type.h.

{ return !(lhs == rhs); }

operator*() [1/3]

template<unsigned int N, typename T , typename Scalar >

boostcopy::enable_if_c< ScalarTraits<Scalar>::value, TypeNTensor<N,typename CompareTypes<Scalar, T>::supertype> >::type libMesh::operator*	(	const Scalar &	,
		const TypeNTensor< N, T > &
	)

Definition at line 254 of file type_n_tensor.h.

{
  libmesh_not_implemented();
  return TypeNTensor<N,typename CompareTypes<Scalar, T>::supertype>();
}

operator*() [2/3]

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 766 of file type_vector.h.

{
  return v * factor;
}

operator*() [3/3]

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 960 of file type_tensor.h.

{
  return t * factor;
}

operator/()

template<unsigned int N, typename T , typename Scalar >

boostcopy::enable_if_c< ScalarTraits<Scalar>::value, TypeNTensor<N,typename CompareTypes<Scalar, T>::supertype> >::type libMesh::operator/	(	const Scalar &	,
		const TypeNTensor< N, T > &
	)

Definition at line 264 of file type_n_tensor.h.

{
  libmesh_not_implemented();
  return TypeNTensor<N,typename CompareTypes<Scalar, T>::supertype>();
}

operator<() [1/5]

bool libMesh::operator< ( const OrderWrapper &  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 97 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{ return lhs.get_order() < rhs.get_order(); }

operator<() [2/5]

bool libMesh::operator< ( int  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 145 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{ return lhs < rhs.get_order(); }

operator<() [3/5]

bool libMesh::operator< ( const OrderWrapper &  lhs, int  rhs  )

inline

Definition at line 146 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{ return lhs.get_order() < rhs; }

operator<() [4/5]

bool libMesh::operator< ( Order  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 147 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{ return lhs < rhs.get_order(); }

operator<() [5/5]

bool libMesh::operator< ( const OrderWrapper &  lhs, Order  rhs  )

inline

Definition at line 148 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{ return lhs.get_order() < rhs; }

operator<<() [1/9]

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

Note

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

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 444 of file sparse_matrix.h.

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

operator<<() [2/9]

std::ostream& libMesh::operator<< ( std::ostream &  os, const OrderWrapper &  order  )

inline

Overload stream operators.

Definition at line 165 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{
  os << order.get_order();
  return os;
}

operator<<() [3/9]

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;
}

operator<<() [4/9]

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

inline

Definition at line 217 of file node.h.

References libMesh::Node::print_info().

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

operator<<() [5/9]

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

inline

Definition at line 396 of file parameters.h.

References libMesh::Parameters::print().

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

operator<<() [6/9]

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 419 of file mesh_base.C.

References libMesh::MeshBase::print_info().

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

operator<<() [7/9]

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

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

Definition at line 809 of file fe_abstract.C.

References libMesh::FEAbstract::print_info().

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

operator<<() [8/9]

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

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

Definition at line 1287 of file equation_systems.C.

References libMesh::EquationSystems::print_info().

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

operator<<() [9/9]

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

inline

Definition at line 1801 of file elem.h.

References libMesh::Elem::print_info().

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

operator<=() [1/5]

bool libMesh::operator<= ( const OrderWrapper &  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 99 of file fe_type.h.

{ return !(lhs > rhs); }

operator<=() [2/5]

bool libMesh::operator<= ( int  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 153 of file fe_type.h.

{ return !(lhs > rhs); }

operator<=() [3/5]

bool libMesh::operator<= ( const OrderWrapper &  lhs, int  rhs  )

inline

Definition at line 154 of file fe_type.h.

{ return !(lhs > rhs); }

operator<=() [4/5]

bool libMesh::operator<= ( Order  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 155 of file fe_type.h.

{ return !(lhs > rhs); }

operator<=() [5/5]

bool libMesh::operator<= ( const OrderWrapper &  lhs, Order  rhs  )

inline

Definition at line 156 of file fe_type.h.

{ return !(lhs > rhs); }

operator==() [1/4]

bool libMesh::operator== ( const OrderWrapper &  lhs, const OrderWrapper &  rhs  )

inline

Overload comparison operators for OrderWrapper.

Definition at line 95 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{ return lhs.get_order() == rhs.get_order(); }

operator==() [2/4]

bool libMesh::operator== ( const OrderWrapper &  lhs, int  rhs  )

inline

Definition at line 138 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{ return lhs.get_order() == rhs; }

operator==() [3/4]

bool libMesh::operator== ( Order  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 139 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{ return lhs == rhs.get_order(); }

operator==() [4/4]

bool libMesh::operator== ( const OrderWrapper &  lhs, Order  rhs  )

inline

Definition at line 140 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

{ return lhs.get_order() == rhs; }

operator>() [1/5]

bool libMesh::operator> ( const OrderWrapper &  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 98 of file fe_type.h.

{ return rhs < lhs; }

operator>() [2/5]

bool libMesh::operator> ( int  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 149 of file fe_type.h.

{ return rhs < lhs; }

operator>() [3/5]

bool libMesh::operator> ( const OrderWrapper &  lhs, int  rhs  )

inline

Definition at line 150 of file fe_type.h.

{ return rhs < lhs; }

operator>() [4/5]

bool libMesh::operator> ( Order  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 151 of file fe_type.h.

{ return rhs < lhs; }

operator>() [5/5]

bool libMesh::operator> ( const OrderWrapper &  lhs, Order  rhs  )

inline

Definition at line 152 of file fe_type.h.

{ return rhs < lhs; }

operator>=() [1/5]

bool libMesh::operator>= ( const OrderWrapper &  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 100 of file fe_type.h.

{ return !(lhs < rhs); }

operator>=() [2/5]

bool libMesh::operator>= ( int  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 157 of file fe_type.h.

{ return !(lhs < rhs); }

operator>=() [3/5]

bool libMesh::operator>= ( const OrderWrapper &  lhs, int  rhs  )

inline

Definition at line 158 of file fe_type.h.

{ return !(lhs < rhs); }

operator>=() [4/5]

bool libMesh::operator>= ( Order  lhs, const OrderWrapper &  rhs  )

inline

Definition at line 159 of file fe_type.h.

{ return !(lhs < rhs); }

operator>=() [5/5]

bool libMesh::operator>= ( const OrderWrapper &  lhs, Order  rhs  )

inline

Definition at line 160 of file fe_type.h.

{ return !(lhs < rhs); }

OrderWrapperOperators()

libMesh::OrderWrapperOperators

(

int

)

Definition at line 130 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

                                                         { return lhs == rhs.get_order(); }

petsc_auto_fieldsplit()

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

Definition at line 58 of file petsc_auto_fieldsplit.C.

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

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

{
  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 (const auto & pr : group_indices)
    indices_to_fieldsplit(sys.comm(), pr.second, my_pc, pr.first);
}

print_helper() [1/5]

template<typename P >

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

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

Definition at line 534 of file parameters.h.

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

{
  os << *param;
}

print_helper() [2/5]

template<typename P >

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

Definition at line 557 of file parameters.h.

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

print_helper() [3/5]

template<typename P >

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

Definition at line 565 of file parameters.h.

{
  for (std::size_t i=0; i<param->size(); ++i)
    for (std::size_t j=0; j<(*param)[i].size(); ++j)
      os << (*param)[i][j] << " ";
}

print_helper() [4/5]

template<>

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

inline

Definition at line 541 of file parameters.h.

{
  // Specialization so that we don't print out unprintable characters
  os << static_cast<int>(*param);
}

print_helper() [5/5]

template<>

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

inline

Definition at line 549 of file parameters.h.

{
  // Specialization so that we don't print out unprintable characters
  os << static_cast<int>(*param);
}

print_trace()

void libMesh::print_trace

(

std::ostream &

out_stream = std::cerr

)

Print a stack trace (for code compiled with gcc)

Definition at line 196 of file print_trace.C.

References on_command_line().

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 = false;

  // Let the user disable GDB backtraces by configuring with
  // --without-gdb-command or with a command line option.
  if (std::string(LIBMESH_GDB_COMMAND) != std::string("no") &&
      !libMesh::on_command_line("--no-gdb-backtrace"))
    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
}

query_ghosting_functors()

void libMesh::query_ghosting_functors	(	const MeshBase &	mesh,
		processor_id_type	pid,
		MeshBase::const_element_iterator	elem_it,
		MeshBase::const_element_iterator	elem_end,
		std::set< const Elem *, CompareElemIdsByLevel > &	connected_elements
	)

Definition at line 137 of file mesh_communication.C.

References as_range(), libMesh::MeshBase::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), mesh, and remote_elem.

Referenced by libMesh::MeshCommunication::delete_remote_elements(), and libMesh::CheckpointIO::write().

{
  for (auto & gf :
         as_range(mesh.ghosting_functors_begin(),
                  mesh.ghosting_functors_end()))
    {
      GhostingFunctor::map_type elements_to_ghost;
      libmesh_assert(gf);
      (*gf)(elem_it, elem_end, pid, elements_to_ghost);

      // We can ignore the CouplingMatrix in ->second, but we
      // need to ghost all the elements in ->first.
      for (auto & pr : elements_to_ghost)
        {
          const Elem * elem = pr.first;
          libmesh_assert(elem != remote_elem);
          connected_elements.insert(elem);
        }
    }

  // The GhostingFunctors won't be telling us about the elements from
  // pid; we need to add those ourselves.
  for (; elem_it != elem_end; ++elem_it)
    connected_elements.insert(*elem_it);
}

reconnect_nodes()

void libMesh::reconnect_nodes	(	const std::set< const Elem *, CompareElemIdsByLevel > &	connected_elements,
		std::set< const Node *> &	connected_nodes
	)

Definition at line 258 of file mesh_communication.C.

References libMesh::Elem::node_ref_range().

Referenced by libMesh::MeshCommunication::delete_remote_elements(), and libMesh::CheckpointIO::write().

{
  // We're done using the nodes list for element decisions; now
  // let's reuse it for nodes of the elements we've decided on.
  connected_nodes.clear();

  for (const auto & elem : connected_elements)
    for (auto & n : elem->node_ref_range())
      connected_nodes.insert(&n);
}

REINIT_ERROR() [1/40]

libMesh::REINIT_ERROR	(	0	,
		CLOUGH	,
		reinit
	)

Definition at line 65 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D CLOUGH elements!");      }

REINIT_ERROR() [2/40]

libMesh::REINIT_ERROR	(	0	,
		CLOUGH	,
		edge_reinit
	)

Definition at line 66 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D CLOUGH elements!"); }

REINIT_ERROR() [3/40]

libMesh::REINIT_ERROR	(	0	,
		HERMITE	,
		reinit
	)

Definition at line 69 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D HERMITE elements!"); }

REINIT_ERROR() [4/40]

libMesh::REINIT_ERROR	(	0	,
		HERMITE	,
		edge_reinit
	)

Definition at line 70 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D HERMITE elements!"); }

REINIT_ERROR() [5/40]

libMesh::REINIT_ERROR	(	0	,
		HIERARCHIC	,
		reinit
	)

Definition at line 73 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D HIERARCHIC elements!"); }

REINIT_ERROR() [6/40]

libMesh::REINIT_ERROR	(	0	,
		HIERARCHIC	,
		edge_reinit
	)

Definition at line 74 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D HIERARCHIC elements!"); }

REINIT_ERROR() [7/40]

libMesh::REINIT_ERROR	(	0	,
		L2_HIERARCHIC	,
		reinit
	)

Definition at line 77 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D L2_HIERARCHIC elements!"); }

REINIT_ERROR() [8/40]

libMesh::REINIT_ERROR	(	0	,
		L2_HIERARCHIC	,
		edge_reinit
	)

Definition at line 78 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D L2_HIERARCHIC elements!"); }

REINIT_ERROR() [9/40]

libMesh::REINIT_ERROR	(	0	,
		LAGRANGE	,
		reinit
	)

Definition at line 81 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D LAGRANGE elements!"); }

REINIT_ERROR() [10/40]

libMesh::REINIT_ERROR	(	0	,
		LAGRANGE	,
		edge_reinit
	)

Definition at line 82 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D LAGRANGE elements!"); }

REINIT_ERROR() [11/40]

libMesh::REINIT_ERROR	(	0	,
		LAGRANGE_VEC	,
		reinit
	)

Definition at line 85 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D LAGRANGE_VEC elements!"); }

REINIT_ERROR() [12/40]

libMesh::REINIT_ERROR	(	0	,
		LAGRANGE_VEC	,
		edge_reinit
	)

Definition at line 86 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D LAGRANGE_VEC elements!"); }

REINIT_ERROR() [13/40]

libMesh::REINIT_ERROR	(	0	,
		L2_LAGRANGE	,
		reinit
	)

Definition at line 89 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D L2_LAGRANGE elements!"); }

REINIT_ERROR() [14/40]

libMesh::REINIT_ERROR	(	0	,
		L2_LAGRANGE	,
		edge_reinit
	)

Definition at line 90 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D L2_LAGRANGE elements!"); }

REINIT_ERROR() [15/40]

libMesh::REINIT_ERROR	(	0	,
		MONOMIAL	,
		reinit
	)

Definition at line 93 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D MONOMIAL elements!"); }

REINIT_ERROR() [16/40]

libMesh::REINIT_ERROR	(	0	,
		MONOMIAL	,
		edge_reinit
	)

Definition at line 94 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D MONOMIAL elements!"); }

REINIT_ERROR() [17/40]

libMesh::REINIT_ERROR	(	0	,
		SCALAR	,
		reinit
	)

Definition at line 97 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D SCALAR elements!"); }

REINIT_ERROR() [18/40]

libMesh::REINIT_ERROR	(	0	,
		SCALAR	,
		edge_reinit
	)

Definition at line 98 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D SCALAR elements!"); }

REINIT_ERROR() [19/40]

libMesh::REINIT_ERROR	(	0	,
		XYZ	,
		reinit
	)

Definition at line 101 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D XYZ elements!"); }

REINIT_ERROR() [20/40]

libMesh::REINIT_ERROR	(	0	,
		XYZ	,
		edge_reinit
	)

Definition at line 102 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D XYZ elements!"); }

REINIT_ERROR() [21/40]

libMesh::REINIT_ERROR	(	0	,
		NEDELEC_ONE	,
		reinit
	)

Definition at line 105 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D NEDELEC_ONE elements!"); }

REINIT_ERROR() [22/40]

libMesh::REINIT_ERROR	(	0	,
		NEDELEC_ONE	,
		edge_reinit
	)

Definition at line 106 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D NEDELEC_ONE elements!"); }

REINIT_ERROR() [23/40]

libMesh::REINIT_ERROR	(	0	,
		BERNSTEIN	,
		reinit
	)

Definition at line 110 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D BERNSTEIN elements!"); }

REINIT_ERROR() [24/40]

libMesh::REINIT_ERROR	(	0	,
		BERNSTEIN	,
		edge_reinit
	)

Definition at line 111 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D BERNSTEIN elements!"); }

REINIT_ERROR() [25/40]

libMesh::REINIT_ERROR	(	0	,
		SZABAB	,
		reinit
	)

Definition at line 114 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 0D SZABAB elements!"); }

REINIT_ERROR() [26/40]

libMesh::REINIT_ERROR	(	0	,
		SZABAB	,
		edge_reinit
	)

Definition at line 115 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 0D SZABAB elements!"); }

REINIT_ERROR() [27/40]

libMesh::REINIT_ERROR	(	1	,
		CLOUGH	,
		edge_reinit
	)

Definition at line 120 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D CLOUGH elements!"); }

REINIT_ERROR() [28/40]

libMesh::REINIT_ERROR	(	1	,
		HERMITE	,
		edge_reinit
	)

Definition at line 121 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D HERMITE elements!"); }

REINIT_ERROR() [29/40]

libMesh::REINIT_ERROR	(	1	,
		HIERARCHIC	,
		edge_reinit
	)

Definition at line 122 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D HIERARCHIC elements!"); }

REINIT_ERROR() [30/40]

libMesh::REINIT_ERROR	(	1	,
		L2_HIERARCHIC	,
		edge_reinit
	)

Definition at line 123 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D L2_HIERARCHIC elements!"); }

REINIT_ERROR() [31/40]

libMesh::REINIT_ERROR	(	1	,
		LAGRANGE	,
		edge_reinit
	)

Definition at line 124 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D LAGRANGE elements!"); }

REINIT_ERROR() [32/40]

libMesh::REINIT_ERROR	(	1	,
		LAGRANGE_VEC	,
		edge_reinit
	)

Definition at line 125 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D LAGRANGE_VEC elements!"); }

REINIT_ERROR() [33/40]

libMesh::REINIT_ERROR	(	1	,
		L2_LAGRANGE	,
		edge_reinit
	)

Definition at line 126 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D L2_LAGRANGE elements!"); }

REINIT_ERROR() [34/40]

libMesh::REINIT_ERROR	(	1	,
		XYZ	,
		edge_reinit
	)

Definition at line 127 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D XYZ elements!"); }

REINIT_ERROR() [35/40]

libMesh::REINIT_ERROR	(	1	,
		MONOMIAL	,
		edge_reinit
	)

Definition at line 128 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D MONOMIAL elements!"); }

REINIT_ERROR() [36/40]

libMesh::REINIT_ERROR	(	1	,
		SCALAR	,
		edge_reinit
	)

Definition at line 129 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D SCALAR elements!"); }

REINIT_ERROR() [37/40]

libMesh::REINIT_ERROR	(	1	,
		NEDELEC_ONE	,
		reinit
	)

Definition at line 130 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot reinit 1D NEDELEC_ONE elements!"); }

REINIT_ERROR() [38/40]

libMesh::REINIT_ERROR	(	1	,
		NEDELEC_ONE	,
		edge_reinit
	)

Definition at line 131 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D NEDELEC_ONE elements!"); }

REINIT_ERROR() [39/40]

libMesh::REINIT_ERROR	(	1	,
		BERNSTEIN	,
		edge_reinit
	)

Definition at line 134 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D BERNSTEIN elements!"); }

REINIT_ERROR() [40/40]

libMesh::REINIT_ERROR	(	1	,
		SZABAB	,
		edge_reinit
	)

Definition at line 135 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot edge_reinit 1D SZABAB elements!"); }

ScalarTraits_true() [1/7]

libMesh::ScalarTraits_true

(

char

)

ScalarTraits_true() [2/7]

libMesh::ScalarTraits_true

(

short

)

ScalarTraits_true() [3/7]

libMesh::ScalarTraits_true

(

int

)

ScalarTraits_true() [4/7]

libMesh::ScalarTraits_true

(

long

)

ScalarTraits_true() [5/7]

libMesh::ScalarTraits_true

(

unsigned

char

)

ScalarTraits_true() [6/7]

libMesh::ScalarTraits_true

(

float

)

ScalarTraits_true() [7/7]

libMesh::ScalarTraits_true

(

double

)

SIDEMAP_ERROR() [1/14]

libMesh::SIDEMAP_ERROR	(	0	,
		CLOUGH	,
		side_map
	)

Definition at line 67 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D CLOUGH elements!"); }

SIDEMAP_ERROR() [2/14]

libMesh::SIDEMAP_ERROR	(	0	,
		HERMITE	,
		side_map
	)

Definition at line 71 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D HERMITE elements!"); }

SIDEMAP_ERROR() [3/14]

libMesh::SIDEMAP_ERROR	(	0	,
		HIERARCHIC	,
		side_map
	)

Definition at line 75 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D HIERARCHIC elements!"); }

SIDEMAP_ERROR() [4/14]

libMesh::SIDEMAP_ERROR	(	0	,
		L2_HIERARCHIC	,
		side_map
	)

Definition at line 79 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D L2_HIERARCHIC elements!"); }

SIDEMAP_ERROR() [5/14]

libMesh::SIDEMAP_ERROR	(	0	,
		LAGRANGE	,
		side_map
	)

Definition at line 83 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map LAGRANGE elements!"); }

SIDEMAP_ERROR() [6/14]

libMesh::SIDEMAP_ERROR	(	0	,
		LAGRANGE_VEC	,
		side_map
	)

Definition at line 87 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D LAGRANGE_VEC elements!"); }

SIDEMAP_ERROR() [7/14]

libMesh::SIDEMAP_ERROR	(	0	,
		L2_LAGRANGE	,
		side_map
	)

Definition at line 91 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D L2_LAGRANGE elements!"); }

SIDEMAP_ERROR() [8/14]

libMesh::SIDEMAP_ERROR	(	0	,
		MONOMIAL	,
		side_map
	)

Definition at line 95 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D MONOMIAL elements!"); }

SIDEMAP_ERROR() [9/14]

libMesh::SIDEMAP_ERROR	(	0	,
		SCALAR	,
		side_map
	)

Definition at line 99 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D SCALAR elements!"); }

SIDEMAP_ERROR() [10/14]

libMesh::SIDEMAP_ERROR	(	0	,
		XYZ	,
		side_map
	)

Definition at line 103 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D XYZ elements!"); }

SIDEMAP_ERROR() [11/14]

libMesh::SIDEMAP_ERROR	(	0	,
		NEDELEC_ONE	,
		side_map
	)

Definition at line 107 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D NEDELEC_ONE elements!"); }

SIDEMAP_ERROR() [12/14]

libMesh::SIDEMAP_ERROR	(	0	,
		BERNSTEIN	,
		side_map
	)

Definition at line 112 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D BERNSTEIN elements!"); }

SIDEMAP_ERROR() [13/14]

libMesh::SIDEMAP_ERROR	(	0	,
		SZABAB	,
		side_map
	)

Definition at line 116 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 0D SZABAB elements!"); }

SIDEMAP_ERROR() [14/14]

libMesh::SIDEMAP_ERROR	(	1	,
		NEDELEC_ONE	,
		side_map
	)

Definition at line 132 of file fe_boundary.C.

{ libmesh_error_msg("ERROR: Cannot side_map 1D NEDELEC_ONE elements!"); }

SIGN()

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);
}

split_mesh()

std::unique_ptr< CheckpointIO > libMesh::split_mesh	(	MeshBase &	mesh,
		processor_id_type	nsplits
	)

split_mesh takes the given initialized/opened mesh and partitions it into nsplits pieces or chunks. It returns a CheckpointIO object that can be used to write the mesh chunks into individual files (e.g. by calling checkpoint_obj.write(out_file_name)) - the number of files is equal to the number of chunks. This function supports MPI parallelism and can be used with several MPI procs to speed up splitting.

Definition at line 134 of file checkpoint_io.C.

References libMesh::ParallelObject::comm(), mesh, libMesh::MeshBase::partition(), libMesh::Parallel::Communicator::rank(), and libMesh::Parallel::Communicator::size().

{
  // There is currently an issue with DofObjects not being properly
  // reset if the mesh is not first repartitioned onto 1 processor
  // *before* being repartitioned onto the desired number of
  // processors. So, this is a workaround, but not a particularly
  // onerous one.
  mesh.partition(1);
  mesh.partition(nsplits);

  processor_id_type my_num_chunks = 0;
  processor_id_type my_first_chunk = 0;
  chunking(mesh.comm().size(), mesh.comm().rank(), nsplits, my_num_chunks, my_first_chunk);

  auto cpr = libmesh_make_unique<CheckpointIO>(mesh);
  cpr->current_processor_ids().clear();
  for (processor_id_type i = my_first_chunk; i < my_first_chunk + my_num_chunks; i++)
    cpr->current_processor_ids().push_back(i);
  cpr->current_n_processors() = nsplits;
  cpr->parallel() = true;
  return cpr;
}

SUPERTYPE() [1/20]

libMesh::SUPERTYPE	(	unsigned	char,
		short
	)

SUPERTYPE() [2/20]

libMesh::SUPERTYPE	(	unsigned	char,
		int
	)

SUPERTYPE() [3/20]

libMesh::SUPERTYPE	(	unsigned	char,
		float
	)

SUPERTYPE() [4/20]

libMesh::SUPERTYPE	(	unsigned	char,
		double
	)

SUPERTYPE() [5/20]

libMesh::SUPERTYPE	(	unsigned	char,
		long	double
	)

SUPERTYPE() [6/20]

libMesh::SUPERTYPE	(	char	,
		short
	)

SUPERTYPE() [7/20]

libMesh::SUPERTYPE	(	char	,
		int
	)

SUPERTYPE() [8/20]

libMesh::SUPERTYPE	(	char	,
		float
	)

SUPERTYPE() [9/20]

libMesh::SUPERTYPE	(	char	,
		double
	)

SUPERTYPE() [10/20]

libMesh::SUPERTYPE	(	char	,
		long	double
	)

SUPERTYPE() [11/20]

libMesh::SUPERTYPE	(	short	,
		int
	)

SUPERTYPE() [12/20]

libMesh::SUPERTYPE	(	short	,
		float
	)

SUPERTYPE() [13/20]

libMesh::SUPERTYPE	(	short	,
		double
	)

SUPERTYPE() [14/20]

libMesh::SUPERTYPE	(	short	,
		long	double
	)

SUPERTYPE() [15/20]

libMesh::SUPERTYPE	(	int	,
		float
	)

SUPERTYPE() [16/20]

libMesh::SUPERTYPE	(	int	,
		double
	)

SUPERTYPE() [17/20]

libMesh::SUPERTYPE	(	int	,
		long	double
	)

SUPERTYPE() [18/20]

libMesh::SUPERTYPE	(	float	,
		double
	)

SUPERTYPE() [19/20]

libMesh::SUPERTYPE	(	float	,
		long	double
	)

SUPERTYPE() [20/20]

libMesh::SUPERTYPE	(	double	,
		long	double
	)

triple_product()

template<typename T >

T libMesh::triple_product ( const TypeVector< T > &  a, const TypeVector< T > &  b, const TypeVector< T > &  c  )

inline

Definition at line 1054 of file type_vector.h.

Referenced by libMesh::Tri3::contains_point(), libMesh::Pyramid5::volume(), libMesh::Prism6::volume(), libMesh::Hex8::volume(), libMesh::Tet4::volume(), libMesh::Pyramid13::volume(), libMesh::Tet10::volume(), libMesh::Prism15::volume(), libMesh::Hex20::volume(), libMesh::Pyramid14::volume(), libMesh::Hex27::volume(), and libMesh::Prism18::volume().

{
#if LIBMESH_DIM == 3
  return
    a(0)*(b(1)*c(2) - b(2)*c(1)) -
    a(1)*(b(0)*c(2) - b(2)*c(0)) +
    a(2)*(b(0)*c(1) - b(1)*c(0));
#else
  return 0;
#endif
}

warned_about_auto_ptr()

bool libMesh::warned_about_auto_ptr

(

false

)

write_traceout()

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

We append to the trace file rather than overwriting it. This allows multiple traces to be written to the same file.

Definition at line 233 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
}

Xdr::data< std::complex< double > >()

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

Xdr::data< std::complex< float > >()

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

Xdr::data< std::complex< long double > >()

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

Xdr::data< std::string >()

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

Xdr::data< std::vector< char > >()

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

Xdr::data< std::vector< double > >()

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

Xdr::data< std::vector< float > >()

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

Xdr::data< std::vector< int > >()

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

Xdr::data< std::vector< long double > >()

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

Xdr::data< std::vector< long int > >()

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

Xdr::data< std::vector< long long > >()

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

Xdr::data< std::vector< short int > >()

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

Xdr::data< std::vector< signed char > >()

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

Xdr::data< std::vector< std::complex< double > > >()

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

Xdr::data< std::vector< std::complex< float > > >()

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

Xdr::data< std::vector< std::complex< long double > > >()

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

Xdr::data< std::vector< std::string > >()

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

Xdr::data< std::vector< unsigned char > >()

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

Xdr::data< std::vector< unsigned int > >()

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

Xdr::data< std::vector< unsigned long int > >()

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

Xdr::data< std::vector< unsigned long long > >()

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

Xdr::data< std::vector< unsigned short int > >()

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

Variable Documentation

cube_number_column

const unsigned char libMesh::cube_number_column

Definition at line 84 of file number_lookups.C.

cube_number_page

const unsigned char libMesh::cube_number_page

Definition at line 308 of file number_lookups.C.

cube_number_row

const unsigned char libMesh::cube_number_row

Definition at line 196 of file number_lookups.C.

EIGEN_SOLVERS

libMesh::EIGEN_SOLVERS

Definition at line 246 of file libmesh.C.

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

err

OStreamProxy libMesh::err

Definition at line 229 of file libmesh_common.h.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::QComposite< QSubCell >::add_subelem_values(), libMesh::LaspackLinearSolver< T >::adjoint_solve(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::Factory< Base >::build(), libMesh::Patch::build_around_element(), cast_ptr(), cast_ref(), libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::MeshCommunication::check_for_duplicate_global_indices(), libMesh::FEMap::compute_single_point_map(), libMesh::Elem::contains_point(), libMesh::GMVIO::copy_nodal_solution(), libMesh::ElemCutter::cut_2D(), libMesh::ElemCutter::cut_3D(), libMesh::ParsedFEMFunction< T >::eval(), libMesh::ParsedFunction< T >::eval(), libMesh::PerfLog::fast_pop(), 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::QJacobi::init_1D(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::EpetraVector< T >::inputNonlocalValues(), libMesh::FEInterface::inverse_map(), libMesh::FE< Dim, LAGRANGE_VEC >::inverse_map(), libMesh::LibMeshInit::LibMeshInit(), libMesh::InfFE< Dim, T_radial, T_map >::nodal_soln(), libMesh::ErrorVector::plot_error(), libMesh::TetGenMeshInterface::process_hull_integrity_result(), libMesh::Elem::quality(), libMesh::Nemesis_IO::read(), libMesh::GMVIO::read(), 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::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, LAGRANGE_VEC >::shape_second_deriv(), libMesh::EigenSparseLinearSolver< T >::solve(), libMesh::LaspackLinearSolver< T >::solve(), libMesh::NameBasedIO::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::VTKIO::write_nodal_data(), libMesh::NameBasedIO::write_nodal_data(), and libMesh::GmshIO::write_post().

ErrorVectorReal

DIE A HORRIBLE DEATH HERE typedef float libMesh::ErrorVectorReal

Definition at line 202 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().

GLOBAL_COMM_WORLD

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

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

imaginary

const Number libMesh::imaginary

The imaginary unit, .

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::compute_data().

INSTANTIATE_SUBDIVISION_FE

libMesh::INSTANTIATE_SUBDIVISION_FE

Definition at line 573 of file fe.C.

INSTANTIATE_SUBDIVISION_MAPS

libMesh::INSTANTIATE_SUBDIVISION_MAPS

Definition at line 2109 of file fe_map.C.

INVALID_SOLVER_PACKAGE

libMesh::INVALID_SOLVER_PACKAGE

Definition at line 250 of file libmesh.C.

Referenced by default_solver_package().

invalid_uint

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

Referenced by libMesh::FEMContext::_do_elem_position_set(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::MeshRefinement::add_node(), libMesh::Elem::as_parent_node(), libMesh::CompositeFEMFunction< Output >::attach_subfunction(), libMesh::CompositeFunction< Output >::attach_subfunction(), libMesh::CompositeFEMFunction< Output >::component(), libMesh::CompositeFunction< Output >::component(), libMesh::InfFE< Dim, T_radial, T_map >::compute_node_indices_fast(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_indices(), libMesh::Xdr::data_stream(), libMesh::MeshFunction::discontinuous_gradient(), libMesh::MeshFunction::discontinuous_value(), libMesh::DofMap::dof_indices(), 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::MeshFunction::gradient(), libMesh::DofObject::has_dofs(), libMesh::MeshFunction::hessian(), libMesh::MeshTools::Generation::Private::idx(), libMesh::DofMap::is_evaluable(), libMesh::MeshTools::libmesh_assert_equal_n_systems(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::Elem::local_node(), libMesh::FEMSystem::mesh_position_get(), libMesh::DofObject::n_dofs(), libMesh::PeriodicBoundaries::neighbor(), libMesh::FEMSystem::numerical_jacobian(), libMesh::DofMap::old_dof_indices(), libMesh::MeshFunction::operator()(), libMesh::Elem::parent_bracketing_nodes(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::ReplicatedMesh::stitching_helper(), 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().

LASPACK_SOLVERS

libMesh::LASPACK_SOLVERS

Definition at line 248 of file libmesh.C.

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

libmesh_errhandler

MPI_Errhandler libMesh::libmesh_errhandler

Definition at line 233 of file libmesh.C.

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

MIN_ELEM_PER_PROC

const unsigned int libMesh::MIN_ELEM_PER_PROC = 4

Definition at line 58 of file parmetis_partitioner.C.

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

old_terminate_handler

std::terminate_handler libMesh::old_terminate_handler

Definition at line 272 of file libmesh.C.

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

out

OStreamProxy libMesh::out

Definition at line 228 of file libmesh_common.h.

Referenced by __libmesh_nlopt_objective(), __libmesh_petsc_diff_solver_jacobian(), __libmesh_petsc_diff_solver_monitor(), __libmesh_petsc_diff_solver_residual(), libMesh::ParmetisPartitioner::_do_repartition(), 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< ErrorVectorReal >::histogram(), libMesh::ContinuationSystem::initialize_tangent(), libmesh_petsc_snes_monitor(), libMesh::LibMeshInit::LibMeshInit(), libMesh::NewtonSolver::line_search(), libMesh::MeshInput< MeshBase >::MeshInput(), libMesh::MeshOutput< MeshBase >::MeshOutput(), libMesh::ExodusII_IO_Helper::message(), libMesh::UNVIO::nodes_in(), libMesh::UNVIO::nodes_out(), libMesh::Parallel::Communicator::nonblocking_receive_packed_range(), libMesh::Xdr::open(), libMesh::ExodusII_IO_Helper::open(), libMesh::PointLocatorTree::operator()(), libMesh::MetisPartitioner::partition_range(), libMesh::SFCPartitioner::partition_range(), libMesh::DofMap::prepare_send_list(), libMesh::TaoOptimizationSolver< T >::print_converged_reason(), libMesh::NloptOptimizationSolver< T >::print_converged_reason(), libMesh::LaspackLinearSolver< T >::print_converged_reason(), libMesh::PetscNonlinearSolver< Number >::print_converged_reason(), libMesh::AztecLinearSolver< T >::print_converged_reason(), libMesh::LinearSolver< Number >::print_converged_reason(), libMesh::NewtonSolver::print_convergence(), libMesh::DofObject::print_dof_info(), 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::TetGenIO::read(), libMesh::Nemesis_IO::read(), libMesh::PltLoader::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_qa_records(), libMesh::ExodusII_IO_Helper::read_var_names_impl(), libMesh::VariationalMeshSmoother::readgr(), libMesh::MeshRefinement::refine_elements(), libMesh::TetGenWrapper::set_switches(), libMesh::ContinuationSystem::set_Theta(), libMesh::ContinuationSystem::set_Theta_LOCA(), libMesh::TwostepTimeSolver::solve(), libMesh::EigenSparseLinearSolver< T >::solve(), libMesh::NewtonSolver::solve(), libMesh::UnsteadySolver::solve(), libMesh::EigenTimeSolver::solve(), libMesh::NloptOptimizationSolver< T >::solve(), libMesh::ContinuationSystem::solve_tangent(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::MacroFunctions::stop(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::ContinuationSystem::update_solution(), libMesh::XdrIO::write(), libMesh::TecplotIO::write_ascii(), libMesh::MeshOutput< MeshBase >::write_discontinuous_equation_systems(), libMesh::Nemesis_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::MeshOutput< MeshBase >::write_equation_systems(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::GmshIO::write_post(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_var_names_impl(), and libMesh::VariationalMeshSmoother::writegr().

parent_bracketing_nodes_mutex

Threads::spin_mutex libMesh::parent_bracketing_nodes_mutex

Definition at line 86 of file elem.C.

Referenced by libMesh::Elem::parent_bracketing_nodes().

parent_indices_mutex

Threads::spin_mutex libMesh::parent_indices_mutex

Definition at line 85 of file elem.C.

Referenced by libMesh::Elem::as_parent_node().

perflog

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 44 of file libmesh_logging.h.

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

pi

const Real libMesh::pi

Initial value:

=
  static_cast<Real>(3.1415926535897932384626433832795029L)

.

Definition at line 233 of file libmesh.h.

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::MeshTools::Generation::Private::GaussLobattoRedistributionFunction::GaussLobattoRedistributionFunction(), 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().

Real

DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE libMesh::Real

Definition at line 131 of file libmesh_common.h.

Referenced by __libmesh_nlopt_objective(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::NewmarkSolver::_general_residual(), libMesh::DenseMatrix< Number >::_lu_decompose(), libMesh::DenseMatrix< Number >::_svd_solve_lapack(), 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::DofMap::allgather_recursive_constraints(), 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_delaunay_square(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::SystemNorm::calculate_norm(), libMesh::System::calculate_norm(), libMesh::DofMap::check_for_cyclic_constraints(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), 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< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::FEMap::compute_single_point_map(), libMesh::QConical::conical_product_pyramid(), libMesh::BoundingBox::contains_point(), libMesh::InfQuad4::contains_point(), libMesh::InfPrism::contains_point(), libMesh::Tri3::contains_point(), libMesh::InfHex::contains_point(), libMesh::ContinuationSystem::continuation_solve(), libMesh::ExodusII_IO_Helper::create(), libMesh::Nemesis_IO_Helper::create(), libMesh::TreeNode< N >::create_bounding_box(), libMesh::DenseMatrix< Number >::det(), libMesh::Sphere::distance(), libMesh::QGauss::dunavant_rule2(), libMesh::EquationSystems::EquationSystems(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::AdjointResidualErrorEstimator::estimate_error(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_point(), libMesh::MeshCommunication::find_global_indices(), libMesh::ElemCutter::find_intersection_points(), libMesh::UnstructuredMesh::find_neighbors(), 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::DofMap::gather_constraints(), libMesh::MeshTools::Generation::Private::GaussLobattoRedistributionFunction::GaussLobattoRedistributionFunction(), libMesh::ParsedFEMFunction< T >::get_inline_value(), libMesh::ParsedFunction< T >::get_inline_value(), libMesh::ImplicitSystem::get_linear_solve_parameters(), libMesh::PerfLog::get_perf_info(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::NumericVector< Number >::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< ErrorVectorReal >::histogram(), libMesh::Elem::hmax(), libMesh::Elem::hmin(), libMesh::PointLocatorTree::init(), libMesh::FEComputeData::init(), libMesh::QGaussLobatto::init_1D(), libMesh::QGrid::init_1D(), libMesh::QGauss::init_1D(), libMesh::QSimpson::init_1D(), libMesh::QJacobi::init_1D(), libMesh::QGrid::init_2D(), libMesh::QGauss::init_2D(), libMesh::QSimpson::init_2D(), libMesh::QMonomial::init_2D(), libMesh::QGrid::init_3D(), libMesh::QGauss::init_3D(), libMesh::QSimpson::init_3D(), libMesh::QMonomial::init_3D(), libMesh::QGrundmann_Moller::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::BoundingBox::intersects(), libMesh::FE< Dim, LAGRANGE_VEC >::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::DenseSubVector< T >::l1_norm(), libMesh::LaspackVector< T >::l1_norm(), libMesh::EpetraVector< T >::l1_norm(), libMesh::EpetraMatrix< T >::l1_norm(), libMesh::PetscVector< T >::l1_norm(), libMesh::PetscMatrix< T >::l1_norm(), libMesh::DenseVector< Output >::l1_norm(), libMesh::DenseMatrix< Number >::l1_norm(), libMesh::StatisticsVector< ErrorVectorReal >::l2_norm(), libMesh::DenseSubVector< T >::l2_norm(), libMesh::LaspackVector< T >::l2_norm(), libMesh::EpetraVector< T >::l2_norm(), libMesh::PetscVector< T >::l2_norm(), libMesh::DenseVector< Output >::l2_norm(), libMesh::NewtonSolver::line_search(), libMesh::EigenSparseMatrix< T >::linfty_norm(), libMesh::DenseSubVector< T >::linfty_norm(), libMesh::DistributedVector< T >::linfty_norm(), libMesh::LaspackVector< T >::linfty_norm(), libMesh::EpetraVector< T >::linfty_norm(), libMesh::EpetraMatrix< T >::linfty_norm(), libMesh::PetscVector< T >::linfty_norm(), libMesh::PetscMatrix< T >::linfty_norm(), libMesh::DenseVector< Output >::linfty_norm(), libMesh::DenseMatrix< Number >::linfty_norm(), libMesh::PointLocatorBase::locate_node(), libMesh::FESubdivision::loop_subdivision_mask(), libMesh::Edge4::loose_bounding_box(), libMesh::Edge3::loose_bounding_box(), libMesh::Quad8::loose_bounding_box(), libMesh::Tri6::loose_bounding_box(), libMesh::Quad9::loose_bounding_box(), libMesh::InfFE< Dim, T_radial, T_map >::map(), libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::Edge2::master_point(), libMesh::Edge3::master_point(), libMesh::Edge4::master_point(), libMesh::DenseSubVector< T >::max(), libMesh::DistributedVector< T >::max(), libMesh::EigenSparseVector< T >::max(), libMesh::LaspackVector< T >::max(), libMesh::PetscVector< T >::max(), libMesh::DenseVector< Output >::max(), libMesh::DenseMatrix< Number >::max(), libMesh::DofMap::max_constraint_error(), libMesh::ErrorVector::mean(), libMesh::StatisticsVector< ErrorVectorReal >::mean(), libMesh::StatisticsVector< ErrorVectorReal >::median(), libMesh::VariationalMeshSmoother::metr_data_gen(), libMesh::DenseSubVector< T >::min(), libMesh::DistributedVector< T >::min(), libMesh::EigenSparseVector< T >::min(), libMesh::LaspackVector< T >::min(), libMesh::PetscVector< T >::min(), libMesh::DenseVector< Output >::min(), libMesh::DenseMatrix< Number >::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::TypeTensor< T >::norm_sq(), libMesh::StatisticsVector< ErrorVectorReal >::normalize(), libMesh::FEMSystem::numerical_jacobian(), libMesh::FEMSystem::numerical_jacobian_h_for_var(), libMesh::FEAbstract::on_reference_element(), libMesh::Plane::on_surface(), libMesh::ExodusII_IO_Helper::open(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshTools::Generation::Private::GaussLobattoRedistributionFunction::operator()(), libMesh::Parallel::Packing< T >::pack(), libMesh::Node::packed_size(), libMesh::ParsedFEMFunction< T >::partial_reparse(), libMesh::ParsedFunction< T >::partial_reparse(), libMesh::StatisticsVector< ErrorVectorReal >::plot_histogram(), 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::UNVIO::read_dataset(), libMesh::GmshIO::read_mesh(), libMesh::AbaqusIO::read_nodes(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::VariationalMeshSmoother::readgr(), libMesh::FESubdivision::regular_shape(), libMesh::FESubdivision::regular_shape_deriv(), libMesh::FESubdivision::regular_shape_second_deriv(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::MemorySolutionHistory::retrieve(), libMesh::MeshTools::Modification::rotate(), libMesh::MeshTools::Modification::scale(), libMesh::QBase::scale(), libMesh::HPCoarsenTest::select_refinement(), libMesh::NewmarkSystem::set_newmark_parameters(), libMesh::FEMSystem::set_numerical_jacobian_h_for_var(), libMesh::NonlinearImplicitSystem::set_solver_parameters(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::InfFE< Dim, T_radial, T_map >::shape(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), libMesh::BoundingBox::signed_distance(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::Modification::smooth(), libMesh::TwostepTimeSolver::solve(), libMesh::NewtonSolver::solve(), libMesh::NoxNonlinearSolver< Number >::solve(), libMesh::CondensedEigenSystem::solve(), libMesh::EigenSystem::solve(), libMesh::NloptOptimizationSolver< T >::solve(), libMesh::FrequencySystem::solve(), libMesh::LinearImplicitSystem::solve(), libMesh::PetscNonlinearSolver< Number >::solve(), libMesh::ContinuationSystem::solve_tangent(), libMesh::PatchRecoveryErrorEstimator::specpoly(), libMesh::Sphere::Sphere(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::QMonomial::stroud_rule(), libMesh::MeshTools::subdomain_bounding_sphere(), libMesh::NumericVector< Number >::subset_l1_norm(), libMesh::NumericVector< Number >::subset_l2_norm(), libMesh::NumericVector< Number >::subset_linfty_norm(), libMesh::Sphere::surface_coords(), libMesh::TypeVector< Real >::unit(), libMesh::Parallel::Packing< T >::unpack(), libMesh::ContinuationSystem::update_solution(), libMesh::ErrorVector::variance(), libMesh::StatisticsVector< ErrorVectorReal >::variance(), libMesh::Quad4::volume(), libMesh::Edge3::volume(), libMesh::Prism6::volume(), libMesh::Edge4::volume(), libMesh::Quad8::volume(), libMesh::Tri6::volume(), libMesh::Quad9::volume(), libMesh::Pyramid13::volume(), libMesh::Tet10::volume(), libMesh::Hex20::volume(), libMesh::Prism15::volume(), libMesh::Pyramid14::volume(), libMesh::Prism18::volume(), libMesh::Hex27::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().

remote_elem

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::active_family_tree_by_side(), libMesh::Elem::active_family_tree_by_topological_neighbor(), libMesh::Elem::add_child(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::Elem::ancestor(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::Elem::coarsen(), libMesh::FEAbstract::compute_node_constraints(), connect_children(), connect_families(), 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::TopologyMap::fill(), 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::interior_parent(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_node_pointers(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), libMesh::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::GhostPointNeighbors::operator()(), libMesh::DefaultCoupling::operator()(), query_ghosting_functors(), libMesh::CheckpointIO::read_remote_elem(), libMesh::Elem::remove_links_to_me(), libMesh::Elem::set_interior_parent(), libMesh::MeshRefinement::test_level_one(), libMesh::Elem::total_family_tree_by_neighbor(), libMesh::Elem::total_family_tree_by_subneighbor(), libMesh::Parallel::Packing< T >::unpack(), libMesh::CheckpointIO::write_remote_elem(), and libMesh::RemoteElem::~RemoteElem().

square_number_column

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 56 of file number_lookups.C.

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

square_number_row

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 69 of file number_lookups.C.

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

TOLERANCE

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

static

Definition at line 139 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::EquationSystems::build_parallel_solution_vector(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::Elem::contains_point(), libMesh::EquationSystems::EquationSystems(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MemorySolutionHistory::find_stored_entry(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::LocationMap< T >::key(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), libMesh::BoundaryProjectSolution::operator()(), libMesh::MeshTools::Generation::Private::GaussLobattoRedistributionFunction::operator()(), libMesh::TypeTensor< T >::operator==(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::MemorySolutionHistory::retrieve(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), libMesh::NewtonSolver::solve(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::MemorySolutionHistory::store(), libMesh::TriangleInterface::triangulate(), libMesh::Parallel::Packing< T >::unpack(), libMesh::PointLocatorBase::unset_close_to_point_tol(), libMesh::Edge3::volume(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

triangular_number_column

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 41 of file number_lookups.C.

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

triangular_number_row

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 28 of file number_lookups.C.

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

TRILINOS_SOLVERS

libMesh::TRILINOS_SOLVERS

Definition at line 244 of file libmesh.C.

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

warned_about_auto_ptr

bool libMesh::warned_about_auto_ptr

zero

const Number libMesh::zero = 0.

.

Definition at line 239 of file libmesh.h.

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