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_typeDSNAN
 
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_typeEigenSM
 
typedef Eigen::Matrix< Number, Eigen::Dynamic, 1 > EigenSV
 
typedef std::unordered_multiset< Elem *, ElemHashUtils, ElemHashUtilsunordered_multiset_elem
 
typedef StoredRange< MeshBase::element_iterator, Elem * > ElemRange
 
typedef StoredRange< MeshBase::const_element_iterator, const Elem * > ConstElemRange
 
typedef FEGenericBase< RealFEBase
 
typedef TensorValue< NumberNumberTensorValue
 
typedef NumberTensorValue Tensor
 
typedef VectorValue< NumberNumberVectorValue
 
typedef NumberVectorValue Gradient
 
typedef FEGenericBase< RealGradientFEVectorBase
 
typedef VectorValue< RealRealVectorValue
 
typedef TensorValue< RealRealTensorValue
 
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< RealComplex
 
typedef std::complex< RealCOMPLEX
 
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< LinearImplicitSystemTransientImplicitSystem
 
typedef TransientSystem< LinearImplicitSystemTransientLinearImplicitSystem
 
typedef TransientSystem< NonlinearImplicitSystemTransientNonlinearImplicitSystem
 
typedef TransientSystem< ExplicitSystemTransientExplicitSystem
 
typedef TransientSystem< SystemTransientBaseSystem
 
typedef TransientSystem< EigenSystemTransientEigenSystem
 
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 >
command_line_value (const std::string &name, T value)
 
template<typename T >
command_line_value (const std::vector< std::string > &name, T value)
 
template<typename 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< CheckpointIOsplit_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 >
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_typeindex_range (const NumericVector< T > &vec)
 
processor_id_type global_n_processors ()
 
processor_id_type global_processor_id ()
 
unsigned int n_threads ()
 
template<typename T >
libmesh_real (T a)
 
template<typename T >
libmesh_conj (T a)
 
template<typename 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 >
triple_product (const TypeVector< T > &a, const TypeVector< T > &b, const TypeVector< T > &c)
 
template<typename T >
cross_norm_sq (const TypeVector< T > &b, const TypeVector< T > &c)
 
template<typename 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 RemoteElemremote_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

◆ ConstNodeRange

◆ 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

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

◆ FEBase

Definition at line 39 of file exact_error_estimator.h.

◆ FEVectorBase

Definition at line 667 of file fe_base.h.

◆ 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

Definition at line 31 of file node_range.h.

◆ Number

Definition at line 191 of file libmesh_common.h.

◆ NumberTensorValue

Definition at line 53 of file exact_solution.h.

◆ NumberVectorValue

Definition at line 56 of file exact_solution.h.

◆ numeric_index_type

Definition at line 92 of file id_types.h.

◆ 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

Definition at line 44 of file mesh_triangle_wrapper.h.

◆ RealGradient

Definition at line 50 of file hp_coarsentest.h.

◆ RealTensor

Definition at line 51 of file hp_coarsentest.h.

◆ RealTensorValue

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

Definition at line 49 of file hp_coarsentest.h.

◆ RealVectorValue

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

Definition at line 47 of file hp_coarsentest.h.

◆ SteadyLinearSystem

◆ 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

Definition at line 55 of file exact_solution.h.

◆ TransientBaseSystem

◆ TransientEigenSystem

◆ TransientExplicitSystem

◆ TransientImplicitSystem

◆ TransientLinearImplicitSystem

◆ TransientNonlinearImplicitSystem

◆ 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

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.

◆ EigenSolverType

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.

◆ ElemQuality

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.

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

33  : int {
34  // 1D
35  EDGE2 = 0,
36  EDGE3 = 1,
37  EDGE4 = 2,
38  // 2D
39  TRI3 = 3,
40  TRI6 = 4,
41  QUAD4 = 5,
42  QUAD8 = 6,
43  QUAD9 = 7,
44  // 3D
45  TET4 = 8,
46  TET10 = 9,
47  HEX8 = 10,
48  HEX20 = 11,
49  HEX27 = 12,
50  PRISM6 = 13,
51  PRISM15 = 14,
52  PRISM18 = 15,
53  PYRAMID5 = 16,
54  PYRAMID13 = 17,
55  PYRAMID14 = 18,
56  // Infinite Elems
57  INFEDGE2 = 19,
58  INFQUAD4 = 20,
59  INFQUAD6 = 21,
60  INFHEX8 = 22,
61  INFHEX16 = 23,
62  INFHEX18 = 24,
63  INFPRISM6 = 25,
64  INFPRISM12 = 26,
65  // 0D
66  NODEELEM = 27,
67  // Miscellaneous Elems
68  REMOTEELEM = 28,
69  TRI3SUBDIVISION = 29,
70  // Shell Elems
71  TRISHELL3 = 30,
72  QUADSHELL4 = 31,
73  QUADSHELL8 = 32,
74  // Invalid
75  INVALID_ELEM}; // should always be last

◆ ErrorEstimatorType

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.

◆ FEContinuity

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.

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

34  : int {
35  // C0
36  LAGRANGE = 0,
37  HIERARCHIC = 1,
38  // discontinuous, in local coordinates
39  MONOMIAL = 2,
40  L2_HIERARCHIC = 6,
41  L2_LAGRANGE = 7,
42  // higher-order
43  BERNSTEIN = 3,
44  SZABAB = 4,
45  // discontinuous, in global coordinates
46  XYZ = 5,
47  // infinite element stuff
48  INFINITE_MAP = 11, // for 1/r-map
49  JACOBI_20_00 = 12, // i_max = 19
50  JACOBI_30_00 = 13, // i_max = 19
51  LEGENDRE = 14, // i_max = 19
52  // C1 elements
53  CLOUGH = 21,
54  HERMITE = 22,
55  SUBDIVISION = 23,
56  // A scalar variable that couples to
57  // all other DOFs in the system
58  SCALAR = 31,
59  // Vector-valued elements
60  LAGRANGE_VEC = 41,
61  NEDELEC_ONE = 42,
62  // Invalid
63  INVALID_FE = 99};

◆ FEFieldType

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.

◆ FEMNormType

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.

34  : int {
35  // Hilbert norms and seminorms in FE space
36  L2 = 0,
37  H1 = 1,
38  H2 = 2,
39  HCURL = 3,
40  HDIV = 4,
41  L1 = 5,
42  L_INF = 6,
43  H1_SEMINORM = 10,
44  H2_SEMINORM = 11,
45  // Vector FE norms
46  HCURL_SEMINORM = 12,
47  HDIV_SEMINORM = 13,
48  // Sobolev infinity seminorms
49  W1_INF_SEMINORM = 15,
50  W2_INF_SEMINORM = 16,
51  // discrete norms on coefficient vectors
52  DISCRETE_L1 = 20,
53  DISCRETE_L2 = 21,
54  DISCRETE_L_INF = 22,
55  // Seminorms based on only individual gradient
56  // directional components
57  H1_X_SEMINORM = 31,
58  H1_Y_SEMINORM = 32,
59  H1_Z_SEMINORM = 33,
60  // Invalid
61  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.

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

◆ LinearConvergenceReason

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.

33  : int {
34  // converged
37  CONVERGED_RTOL = 2,
38  CONVERGED_ATOL = 3,
39  CONVERGED_ITS = 4,
44  // diverged
45  DIVERGED_NULL = -2,
46  DIVERGED_ITS = -3,
47  DIVERGED_DTOL = -4,
48  DIVERGED_BREAKDOWN = -5,
52  DIVERGED_NAN = -9,
55  // still running
57  // Invalid
58  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.

40  : int {
41  CONSTANT = 0,
42  FIRST = 1,
43  SECOND = 2,
44  THIRD = 3,
45  FOURTH = 4,
46  FIFTH = 5,
47  SIXTH = 6,
48  SEVENTH = 7,
49  EIGHTH = 8,
50  NINTH = 9,
51  TENTH = 10,
52  ELEVENTH = 11,
53  TWELFTH = 12,
54  THIRTEENTH = 13,
55  FOURTEENTH = 14,
56  FIFTEENTH = 15,
57  SIXTEENTH = 16,
58  SEVENTEENTH = 17,
59  EIGHTTEENTH = 18,
60  NINETEENTH = 19,
61  TWENTIETH = 20,
62  TWENTYFIRST = 21,
63  TWENTYSECOND = 22,
64  TWENTYTHIRD = 23,
65  TWENTYFOURTH = 24,
66  TWENTYFIFTH = 25,
67  TWENTYSIXTH = 26,
68  TWENTYSEVENTH = 27,
69  TWENTYEIGHTH = 28,
70  TWENTYNINTH = 29,
71  THIRTIETH = 30,
72  THIRTYFIRST = 31,
73  THIRTYSECOND = 32,
74  THIRTYTHIRD = 33,
75  THIRTYFOURTH = 34,
76  THIRTYFIFTH = 35,
77  THIRTYSIXTH = 36,
78  THIRTYSEVENTH = 37,
79  THIRTYEIGHTH = 38,
80  THIRTYNINTH = 39,
81  FORTIETH = 40,
82  FORTYFIRST = 41,
83  FORTYSECOND = 42,
84  FORTYTHIRD = 43,
85  // Invalid

◆ ParallelType

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.

◆ PetscMatrixType

Enumerator
AIJ 
HYPRE 

Definition at line 63 of file petsc_matrix.h.

63  : int {
64  AIJ=0,
65  HYPRE};

◆ PointLocatorType

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

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.

◆ PositionOfSpectrum

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.

◆ PreconditionerType

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.

◆ QuadratureType

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.

◆ SolverPackage

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.

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

◆ SubsetSolveMode

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.

35  : int {
36  // Set dofs outside the subset to zero.
37  SUBSET_ZERO = 0,
38  // Set dofs outside the subset to the value of the corresponding
39  // dofs of the right hand side.
41  // Leaves dofs outside the subset unchanged. This is fastest, but
42  // also most confusing because it abandons the property that the
43  // solution vector is (theoretically) independent of the initial
44  // guess.
46 };

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

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

35  : int
36  {
37  UNKNOWN = -1,
38  ENCODE=0,
39  DECODE,
40  WRITE,
41  READ
42  };

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

113 {
114  LOG_SCOPE("equality_constraints()", "NloptOptimizationSolver");
115 
116  libmesh_assert(data);
117 
118  // data should be a pointer to the solver (it was passed in as void *)
119  NloptOptimizationSolver<Number> * solver =
120  static_cast<NloptOptimizationSolver<Number> *> (data);
121 
122  OptimizationSystem & sys = solver->system();
123 
124  // We'll use current_local_solution below, so let's ensure that it's consistent
125  // with the vector x that was passed in.
126  if (sys.solution->size() != n)
127  libmesh_error_msg("Error: Input vector x has different length than sys.solution!");
128 
129  for (auto i : index_range(*sys.solution))
130  sys.solution->set(i, x[i]);
131  sys.solution->close();
132 
133  // Impose constraints on the solution vector
134  sys.get_dof_map().enforce_constraints_exactly(sys);
135 
136  // Update sys.current_local_solution based on the solution vector
137  sys.update();
138 
139  // Call the user's equality constraints function if there is one.
140  OptimizationSystem::ComputeEqualityConstraints * eco = solver->equality_constraints_object;
141  if (eco)
142  {
143  eco->equality_constraints(*sys.current_local_solution,
144  *sys.C_eq,
145  sys);
146 
147  sys.C_eq->close();
148 
149  // Copy the values out of eq_constraints into 'result'.
150  // TODO: Even better would be if we could use 'result' directly
151  // as the storage of eq_constraints. Perhaps a serial-only
152  // NumericVector variant which supports this option?
153  for (unsigned int i = 0; i < m; ++i)
154  result[i] = (*sys.C_eq)(i);
155 
156  // If gradient != nullptr, then the Jacobian matrix of the equality
157  // constraints has been requested. The incoming 'gradient'
158  // array is of length m*n and d(c_i)/d(x_j) = gradient[n*i+j].
159  if (gradient)
160  {
161  OptimizationSystem::ComputeEqualityConstraintsJacobian * eco_jac =
162  solver->equality_constraints_jacobian_object;
163 
164  if (eco_jac)
165  {
166  eco_jac->equality_constraints_jacobian(*sys.current_local_solution,
167  *sys.C_eq_jac,
168  sys);
169 
170  sys.C_eq_jac->close();
171 
172  // copy the Jacobian data to the gradient array
173  for (numeric_index_type i=0; i<m; i++)
174  for (const auto & dof_index : sys.eq_constraint_jac_sparsity[i])
175  gradient[n*i+dof_index] = (*sys.C_eq_jac)(i,dof_index);
176  }
177  else
178  libmesh_error_msg("Jacobian function not defined in __libmesh_nlopt_equality_constraints");
179  }
180 
181  }
182  else
183  libmesh_error_msg("Constraints function not defined in __libmesh_nlopt_equality_constraints");
184 }
IntRange< std::size_t > index_range(const std::vector< T > &vec)
Definition: int_range.h:104
dof_id_type numeric_index_type
Definition: id_types.h:92
IterBase * data

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

193 {
194  LOG_SCOPE("inequality_constraints()", "NloptOptimizationSolver");
195 
196  libmesh_assert(data);
197 
198  // data should be a pointer to the solver (it was passed in as void *)
199  NloptOptimizationSolver<Number> * solver =
200  static_cast<NloptOptimizationSolver<Number> *> (data);
201 
202  OptimizationSystem & sys = solver->system();
203 
204  // We'll use current_local_solution below, so let's ensure that it's consistent
205  // with the vector x that was passed in.
206  if (sys.solution->size() != n)
207  libmesh_error_msg("Error: Input vector x has different length than sys.solution!");
208 
209  for (auto i : index_range(*sys.solution))
210  sys.solution->set(i, x[i]);
211  sys.solution->close();
212 
213  // Impose constraints on the solution vector
214  sys.get_dof_map().enforce_constraints_exactly(sys);
215 
216  // Update sys.current_local_solution based on the solution vector
217  sys.update();
218 
219  // Call the user's inequality constraints function if there is one.
220  OptimizationSystem::ComputeInequalityConstraints * ineco = solver->inequality_constraints_object;
221  if (ineco)
222  {
223  ineco->inequality_constraints(*sys.current_local_solution,
224  *sys.C_ineq,
225  sys);
226 
227  sys.C_ineq->close();
228 
229  // Copy the values out of ineq_constraints into 'result'.
230  // TODO: Even better would be if we could use 'result' directly
231  // as the storage of ineq_constraints. Perhaps a serial-only
232  // NumericVector variant which supports this option?
233  for (unsigned int i = 0; i < m; ++i)
234  result[i] = (*sys.C_ineq)(i);
235 
236  // If gradient != nullptr, then the Jacobian matrix of the equality
237  // constraints has been requested. The incoming 'gradient'
238  // array is of length m*n and d(c_i)/d(x_j) = gradient[n*i+j].
239  if (gradient)
240  {
241  OptimizationSystem::ComputeInequalityConstraintsJacobian * ineco_jac =
242  solver->inequality_constraints_jacobian_object;
243 
244  if (ineco_jac)
245  {
246  ineco_jac->inequality_constraints_jacobian(*sys.current_local_solution,
247  *sys.C_ineq_jac,
248  sys);
249 
250  sys.C_ineq_jac->close();
251 
252  // copy the Jacobian data to the gradient array
253  for (numeric_index_type i=0; i<m; i++)
254  for (const auto & dof_index : sys.ineq_constraint_jac_sparsity[i])
255  gradient[n*i+dof_index] = (*sys.C_ineq_jac)(i,dof_index);
256  }
257  else
258  libmesh_error_msg("Jacobian function not defined in __libmesh_nlopt_inequality_constraints");
259  }
260 
261  }
262  else
263  libmesh_error_msg("Constraints function not defined in __libmesh_nlopt_inequality_constraints");
264 }
IntRange< std::size_t > index_range(const std::vector< T > &vec)
Definition: int_range.h:104
dof_id_type numeric_index_type
Definition: id_types.h:92
IterBase * data

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

41 {
42  LOG_SCOPE("objective()", "NloptOptimizationSolver");
43 
44  // ctx should be a pointer to the solver (it was passed in as void *)
45  NloptOptimizationSolver<Number> * solver =
46  static_cast<NloptOptimizationSolver<Number> *> (data);
47 
48  OptimizationSystem & sys = solver->system();
49 
50  // We'll use current_local_solution below, so let's ensure that it's consistent
51  // with the vector x that was passed in.
52  for (auto i : index_range(*sys.solution))
53  sys.solution->set(i, x[i]);
54 
55  // Make sure the solution vector is parallel-consistent
56  sys.solution->close();
57 
58  // Impose constraints on X
59  sys.get_dof_map().enforce_constraints_exactly(sys);
60 
61  // Update sys.current_local_solution based on X
62  sys.update();
63 
64  Real objective;
65  if (solver->objective_object != nullptr)
66  {
67  objective =
68  solver->objective_object->objective(*(sys.current_local_solution), sys);
69  }
70  else
71  {
72  libmesh_error_msg("Objective function not defined in __libmesh_nlopt_objective");
73  }
74 
75  // If the gradient has been requested, fill it in
76  if (gradient)
77  {
78  if (solver->gradient_object != nullptr)
79  {
80  solver->gradient_object->gradient(*(sys.current_local_solution), *(sys.rhs), sys);
81 
82  // we've filled up sys.rhs with the gradient data, now copy it
83  // to the nlopt data structure
84  libmesh_assert(sys.rhs->size() == n);
85 
86  std::vector<double> grad;
87  sys.rhs->localize_to_one(grad);
88  for (unsigned int i = 0; i < n; ++i)
89  gradient[i] = grad[i];
90  }
91  else
92  libmesh_error_msg("Gradient function not defined in __libmesh_nlopt_objective");
93  }
94 
95  // Increment the iteration count.
96  solver->get_iteration_count()++;
97 
98  // Possibly print the current value of the objective function
99  if (solver->verbose)
100  libMesh::out << objective << std::endl;
101 
102  return objective;
103 }
IntRange< std::size_t > index_range(const std::vector< T > &vec)
Definition: int_range.h:104
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
IterBase * data
OStreamProxy out(std::cout)

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

143  {
144  libmesh_assert(x);
145  libmesh_assert(j);
146  // libmesh_assert_equal_to (pc, j); // We don't use separate preconditioners yet
147  libmesh_assert(ctx);
148 
149  PetscDiffSolver & solver =
150  *(static_cast<PetscDiffSolver*> (ctx));
151  ImplicitSystem & sys = solver.system();
152 
153  if (solver.verbose)
154  libMesh::out << "Assembling the Jacobian" << std::endl;
155 
156  PetscVector<Number> & X_system =
157  *cast_ptr<PetscVector<Number> *>(sys.solution.get());
158  PetscVector<Number> X_input(x, sys.comm());
159 
160 #if PETSC_RELEASE_LESS_THAN(3,5,0)
161  PetscMatrix<Number> J_input(*pc, sys.comm());
162 #else
163  PetscMatrix<Number> J_input(pc, sys.comm());
164 #endif
165  PetscMatrix<Number> & J_system =
166  *cast_ptr<PetscMatrix<Number> *>(sys.matrix);
167 
168  // DiffSystem assembles from the solution and into the jacobian, so
169  // swap those with our input vectors before assembling. They'll
170  // probably already be references to the same vectors, but PETSc
171  // might do something tricky.
172  X_input.swap(X_system);
173  J_input.swap(J_system);
174 
175  // We may need to localize a parallel solution
176  sys.update();
177 
178  // We may need to correct a non-conforming solution
179  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
180 
181  // Do DiffSystem assembly
182  sys.assembly(false, true);
183  J_system.close();
184 
185  // Swap back
186  X_input.swap(X_system);
187  J_input.swap(J_system);
188 
189 #if PETSC_RELEASE_LESS_THAN(3,5,0)
190  *msflag = SAME_NONZERO_PATTERN;
191 #endif
192  // No errors, we hope
193  return 0;
194  }
OStreamProxy out(std::cout)

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

47  {
48  PetscDiffSolver & solver =
49  *(static_cast<PetscDiffSolver *> (ctx));
50 
51  if (solver.verbose)
52  libMesh::out << " PetscDiffSolver step " << its
53  << ", |residual|_2 = " << fnorm << std::endl;
54  if (solver.linear_solution_monitor.get()) {
55  int ierr = 0;
56 
57  Vec petsc_delta_u;
58  ierr = SNESGetSolutionUpdate(snes, &petsc_delta_u);
59  CHKERRABORT(solver.comm().get(), ierr);
60  PetscVector<Number> delta_u(petsc_delta_u, solver.comm());
61  delta_u.close();
62 
63  Vec petsc_u;
64  ierr = SNESGetSolution(snes, &petsc_u);
65  CHKERRABORT(solver.comm().get(), ierr);
66  PetscVector<Number> u(petsc_u, solver.comm());
67  u.close();
68 
69  Vec petsc_res;
70  ierr = SNESGetFunction(snes, &petsc_res, nullptr, nullptr);
71  CHKERRABORT(solver.comm().get(), ierr);
72  PetscVector<Number> res(petsc_res, solver.comm());
73  res.close();
74 
75  (*solver.linear_solution_monitor)(
76  delta_u, delta_u.l2_norm(),
77  u, u.l2_norm(),
78  res, res.l2_norm(), its);
79  }
80  return 0;
81  }
PetscErrorCode ierr
OStreamProxy out(std::cout)

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

87  {
88  libmesh_assert(x);
89  libmesh_assert(r);
90  libmesh_assert(ctx);
91 
92  PetscDiffSolver & solver =
93  *(static_cast<PetscDiffSolver*> (ctx));
94  ImplicitSystem & sys = solver.system();
95 
96  if (solver.verbose)
97  libMesh::out << "Assembling the residual" << std::endl;
98 
99  PetscVector<Number> & X_system =
100  *cast_ptr<PetscVector<Number> *>(sys.solution.get());
101  PetscVector<Number> & R_system =
102  *cast_ptr<PetscVector<Number> *>(sys.rhs);
103  PetscVector<Number> X_input(x, sys.comm()), R_input(r, sys.comm());
104 
105  // DiffSystem assembles from the solution and into the rhs, so swap
106  // those with our input vectors before assembling. They'll probably
107  // already be references to the same vectors, but PETSc might do
108  // something tricky.
109  X_input.swap(X_system);
110  R_input.swap(R_system);
111 
112  // We may need to localize a parallel solution
113  sys.update();
114 
115  // We may need to correct a non-conforming solution
116  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
117 
118  // Do DiffSystem assembly
119  sys.assembly(true, false);
120  R_system.close();
121 
122  // Swap back
123  X_input.swap(X_system);
124  R_input.swap(R_system);
125 
126  // No errors, we hope
127  return 0;
128  }
OStreamProxy out(std::cout)

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

111  {
112  libmesh_deprecated();
113  return libmesh_petsc_preconditioner_apply(ctx, x, y);
114  }
PetscErrorCode libmesh_petsc_preconditioner_apply(PC pc, Vec x, Vec 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().

124  {
125  libmesh_deprecated();
126  return libmesh_petsc_preconditioner_apply(pc, x, y);
127  }
PetscErrorCode libmesh_petsc_preconditioner_apply(PC pc, Vec x, Vec 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().

105  {
106  libmesh_deprecated();
108  }
PetscErrorCode libmesh_petsc_preconditioner_setup(PC pc)

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

118  {
119  libmesh_deprecated();
121  }
PetscErrorCode libmesh_petsc_preconditioner_setup(PC 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().

228  {
229  libmesh_deprecated();
230  return libmesh_petsc_snes_fd_residual(snes, x, r, ctx);
231  }
PetscErrorCode libmesh_petsc_snes_fd_residual(SNES snes, Vec x, Vec r, void *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().

403  {
404  libmesh_deprecated();
406 #if PETSC_RELEASE_LESS_THAN(3,5,0)
407  snes, x, jac, pc, msflag, ctx
408 #else
409  snes, x, jac, pc, ctx
410 #endif
411  );
412  }
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)

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

279  {
280  libmesh_deprecated();
281  return libmesh_petsc_snes_mffd_interface(ctx, x, r);
282  }
PetscErrorCode libmesh_petsc_snes_mffd_interface(void *ctx, Vec x, Vec 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().

140  {
141  libmesh_deprecated();
142  return libmesh_petsc_snes_monitor(nullptr, its, fnorm, nullptr);
143  }
PetscErrorCode libmesh_petsc_snes_monitor(SNES, PetscInt its, PetscReal fnorm, void *)

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

529  {
530  libmesh_deprecated();
532 #if PETSC_VERSION_LESS_THAN(3,3,0)
533  nullptr, x, y, w, context, changed_y, changed_w
534 #else
535  nullptr, x, y, w, changed_y, changed_w, context
536 #endif
537  );
538  }
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)

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

192  {
193  libmesh_deprecated();
194  return libmesh_petsc_snes_residual(snes, x, r, ctx);
195  }
PetscErrorCode libmesh_petsc_snes_residual(SNES snes, Vec x, Vec r, void *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().

206  {
207  LOG_SCOPE("equality_constraints()", "TaoOptimizationSolver");
208 
209  PetscErrorCode ierr = 0;
210 
211  libmesh_assert(x);
212  libmesh_assert(ce);
213  libmesh_assert(ctx);
214 
215  // ctx should be a pointer to the solver (it was passed in as void *)
216  TaoOptimizationSolver<Number> * solver =
217  static_cast<TaoOptimizationSolver<Number> *> (ctx);
218 
219  OptimizationSystem & sys = solver->system();
220 
221  // We'll use current_local_solution below, so let's ensure that it's consistent
222  // with the vector x that was passed in.
223  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
224  PetscVector<Number> X(x, sys.comm());
225 
226  // Perform a swap so that sys.solution points to the input vector
227  // "x", update sys.current_local_solution based on "x", then swap
228  // back.
229  X.swap(X_sys);
230  sys.update();
231  X.swap(X_sys);
232 
233  // We'll also pass the constraints vector ce into the assembly routine
234  // so let's make a PETSc vector for that too.
235  PetscVector<Number> eq_constraints(ce, sys.comm());
236 
237  // Clear the gradient prior to assembly
238  eq_constraints.zero();
239 
240  // Enforce constraints exactly on the current_local_solution.
241  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
242 
243  if (solver->equality_constraints_object != nullptr)
244  solver->equality_constraints_object->equality_constraints(*(sys.current_local_solution), eq_constraints, sys);
245  else
246  libmesh_error_msg("Constraints function not defined in __libmesh_tao_equality_constraints");
247 
248  eq_constraints.close();
249 
250  return ierr;
251  }
PetscErrorCode 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().

258  {
259  LOG_SCOPE("equality_constraints_jacobian()", "TaoOptimizationSolver");
260 
261  PetscErrorCode ierr = 0;
262 
263  libmesh_assert(x);
264  libmesh_assert(J);
265  libmesh_assert(Jpre);
266 
267  // ctx should be a pointer to the solver (it was passed in as void *)
268  TaoOptimizationSolver<Number> * solver =
269  static_cast<TaoOptimizationSolver<Number> *> (ctx);
270 
271  OptimizationSystem & sys = solver->system();
272 
273  // We'll use current_local_solution below, so let's ensure that it's consistent
274  // with the vector x that was passed in.
275  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
276  PetscVector<Number> X(x, sys.comm());
277 
278  // Perform a swap so that sys.solution points to the input vector
279  // "x", update sys.current_local_solution based on "x", then swap
280  // back.
281  X.swap(X_sys);
282  sys.update();
283  X.swap(X_sys);
284 
285  // Let's also wrap J and Jpre in PetscMatrix objects for convenience
286  PetscMatrix<Number> J_petsc(J, sys.comm());
287  PetscMatrix<Number> Jpre_petsc(Jpre, sys.comm());
288 
289  // Enforce constraints exactly on the current_local_solution.
290  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
291 
292  if (solver->equality_constraints_jacobian_object != nullptr)
293  solver->equality_constraints_jacobian_object->equality_constraints_jacobian(*(sys.current_local_solution), J_petsc, sys);
294  else
295  libmesh_error_msg("Constraints function not defined in __libmesh_tao_equality_constraints_jacobian");
296 
297  J_petsc.close();
298  Jpre_petsc.close();
299 
300  return ierr;
301  }
PetscErrorCode 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().

98  {
99  LOG_SCOPE("gradient()", "TaoOptimizationSolver");
100 
101  PetscErrorCode ierr = 0;
102 
103  libmesh_assert(x);
104  libmesh_assert(g);
105  libmesh_assert(ctx);
106 
107  // ctx should be a pointer to the solver (it was passed in as void *)
108  TaoOptimizationSolver<Number> * solver =
109  static_cast<TaoOptimizationSolver<Number> *> (ctx);
110 
111  OptimizationSystem & sys = solver->system();
112 
113  // We'll use current_local_solution below, so let's ensure that it's consistent
114  // with the vector x that was passed in.
115  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
116  PetscVector<Number> X(x, sys.comm());
117 
118  // Perform a swap so that sys.solution points to the input vector
119  // "x", update sys.current_local_solution based on "x", then swap
120  // back.
121  X.swap(X_sys);
122  sys.update();
123  X.swap(X_sys);
124 
125  // We'll also pass the gradient in to the assembly routine
126  // so let's make a PETSc vector for that too.
127  PetscVector<Number> gradient(g, sys.comm());
128 
129  // Clear the gradient prior to assembly
130  gradient.zero();
131 
132  // Enforce constraints exactly on the current_local_solution.
133  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
134 
135  if (solver->gradient_object != nullptr)
136  solver->gradient_object->gradient(*(sys.current_local_solution), gradient, sys);
137  else
138  libmesh_error_msg("Gradient function not defined in __libmesh_tao_gradient");
139 
140  gradient.close();
141 
142  return ierr;
143  }
PetscErrorCode 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().

149  {
150  LOG_SCOPE("hessian()", "TaoOptimizationSolver");
151 
152  PetscErrorCode ierr = 0;
153 
154  libmesh_assert(x);
155  libmesh_assert(h);
156  libmesh_assert(pc);
157  libmesh_assert(ctx);
158 
159  // ctx should be a pointer to the solver (it was passed in as void *)
160  TaoOptimizationSolver<Number> * solver =
161  static_cast<TaoOptimizationSolver<Number> *> (ctx);
162 
163  OptimizationSystem & sys = solver->system();
164 
165  // We'll use current_local_solution below, so let's ensure that it's consistent
166  // with the vector x that was passed in.
167  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
168  PetscVector<Number> X(x, sys.comm());
169 
170  // Perform a swap so that sys.solution points to the input vector
171  // "x", update sys.current_local_solution based on "x", then swap
172  // back.
173  X.swap(X_sys);
174  sys.update();
175  X.swap(X_sys);
176 
177  // Let's also wrap pc and h in PetscMatrix objects for convenience
178  PetscMatrix<Number> PC(pc, sys.comm());
179  PetscMatrix<Number> hessian(h, sys.comm());
180  PC.attach_dof_map(sys.get_dof_map());
181  hessian.attach_dof_map(sys.get_dof_map());
182 
183  // Enforce constraints exactly on the current_local_solution.
184  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
185 
186  if (solver->hessian_object != nullptr)
187  {
188  // Following PetscNonlinearSolver by passing in PC. It's not clear
189  // why we pass in PC and not hessian though?
190  solver->hessian_object->hessian(*(sys.current_local_solution), PC, sys);
191  }
192  else
193  libmesh_error_msg("Hessian function not defined in __libmesh_tao_hessian");
194 
195  PC.close();
196  hessian.close();
197 
198  return ierr;
199  }
PetscErrorCode 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().

307  {
308  LOG_SCOPE("inequality_constraints()", "TaoOptimizationSolver");
309 
310  PetscErrorCode ierr = 0;
311 
312  libmesh_assert(x);
313  libmesh_assert(cineq);
314  libmesh_assert(ctx);
315 
316  // ctx should be a pointer to the solver (it was passed in as void *)
317  TaoOptimizationSolver<Number> * solver =
318  static_cast<TaoOptimizationSolver<Number> *> (ctx);
319 
320  OptimizationSystem & sys = solver->system();
321 
322  // We'll use current_local_solution below, so let's ensure that it's consistent
323  // with the vector x that was passed in.
324  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
325  PetscVector<Number> X(x, sys.comm());
326 
327  // Perform a swap so that sys.solution points to the input vector
328  // "x", update sys.current_local_solution based on "x", then swap
329  // back.
330  X.swap(X_sys);
331  sys.update();
332  X.swap(X_sys);
333 
334  // We'll also pass the constraints vector ce into the assembly routine
335  // so let's make a PETSc vector for that too.
336  PetscVector<Number> ineq_constraints(cineq, sys.comm());
337 
338  // Clear the gradient prior to assembly
339  ineq_constraints.zero();
340 
341  // Enforce constraints exactly on the current_local_solution.
342  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
343 
344  if (solver->inequality_constraints_object != nullptr)
345  solver->inequality_constraints_object->inequality_constraints(*(sys.current_local_solution), ineq_constraints, sys);
346  else
347  libmesh_error_msg("Constraints function not defined in __libmesh_tao_inequality_constraints");
348 
349  ineq_constraints.close();
350 
351  return ierr;
352  }
PetscErrorCode 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().

359  {
360  LOG_SCOPE("inequality_constraints_jacobian()", "TaoOptimizationSolver");
361 
362  PetscErrorCode ierr = 0;
363 
364  libmesh_assert(x);
365  libmesh_assert(J);
366  libmesh_assert(Jpre);
367 
368  // ctx should be a pointer to the solver (it was passed in as void *)
369  TaoOptimizationSolver<Number> * solver =
370  static_cast<TaoOptimizationSolver<Number> *> (ctx);
371 
372  OptimizationSystem & sys = solver->system();
373 
374  // We'll use current_local_solution below, so let's ensure that it's consistent
375  // with the vector x that was passed in.
376  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
377  PetscVector<Number> X(x, sys.comm());
378 
379  // Perform a swap so that sys.solution points to the input vector
380  // "x", update sys.current_local_solution based on "x", then swap
381  // back.
382  X.swap(X_sys);
383  sys.update();
384  X.swap(X_sys);
385 
386  // Let's also wrap J and Jpre in PetscMatrix objects for convenience
387  PetscMatrix<Number> J_petsc(J, sys.comm());
388  PetscMatrix<Number> Jpre_petsc(Jpre, sys.comm());
389 
390  // Enforce constraints exactly on the current_local_solution.
391  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
392 
393  if (solver->inequality_constraints_jacobian_object != nullptr)
394  solver->inequality_constraints_jacobian_object->inequality_constraints_jacobian(*(sys.current_local_solution), J_petsc, sys);
395  else
396  libmesh_error_msg("Constraints function not defined in __libmesh_tao_inequality_constraints_jacobian");
397 
398  J_petsc.close();
399  Jpre_petsc.close();
400 
401  return ierr;
402  }
PetscErrorCode 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().

50  {
51  LOG_SCOPE("objective()", "TaoOptimizationSolver");
52 
53  PetscErrorCode ierr = 0;
54 
55  libmesh_assert(x);
56  libmesh_assert(objective);
57  libmesh_assert(ctx);
58 
59  // ctx should be a pointer to the solver (it was passed in as void *)
60  TaoOptimizationSolver<Number> * solver =
61  static_cast<TaoOptimizationSolver<Number> *> (ctx);
62 
63  OptimizationSystem & sys = solver->system();
64 
65  // We'll use current_local_solution below, so let's ensure that it's consistent
66  // with the vector x that was passed in.
67  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
68  PetscVector<Number> X(x, sys.comm());
69 
70  // Perform a swap so that sys.solution points to the input vector
71  // "x", update sys.current_local_solution based on "x", then swap
72  // back.
73  X.swap(X_sys);
74  sys.update();
75  X.swap(X_sys);
76 
77  // Enforce constraints (if any) exactly on the
78  // current_local_solution. This is the solution vector that is
79  // actually used in the computation of the objective function
80  // below, and is not locked by debug-enabled PETSc the way that
81  // the solution vector is.
82  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
83 
84  if (solver->objective_object != nullptr)
85  (*objective) = solver->objective_object->objective(*(sys.current_local_solution), sys);
86  else
87  libmesh_error_msg("Objective function not defined in __libmesh_tao_objective");
88 
89  return ierr;
90  }
PetscErrorCode 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().

58 {
59  return {p.first, p.second};
60 }

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

71 {
72  return {first, second};
73 }

◆ cast_int()

template<typename Tnew , typename Told >
Tnew libMesh::cast_int ( Told  oldvar)
inline

Definition at line 545 of file libmesh_common.h.

546 {
547  libmesh_assert_equal_to
548  (oldvar, static_cast<Told>(static_cast<Tnew>(oldvar)));
549 
550  return(static_cast<Tnew>(oldvar));
551 }

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

509 {
510 #if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI)
511  Tnew newvar = dynamic_cast<Tnew>(oldvar);
512  if (!newvar)
513  {
514  libMesh::err << "Failed to convert " << typeid(Told).name()
515  << " pointer to " << typeid(Tnew).name()
516  << std::endl;
517  libMesh::err << "The " << typeid(Told).name()
518  << " appears to be a "
519  << typeid(*oldvar).name() << std::endl;
520  libmesh_error();
521  }
522  return newvar;
523 #else
524  return(static_cast<Tnew>(oldvar));
525 #endif
526 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
OStreamProxy err(std::cerr)

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

473 {
474 #if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI) && defined(LIBMESH_ENABLE_EXCEPTIONS)
475  try
476  {
477  Tnew newvar = dynamic_cast<Tnew>(oldvar);
478  return newvar;
479  }
480  catch (std::bad_cast &)
481  {
482  libMesh::err << "Failed to convert " << typeid(Told).name()
483  << " reference to " << typeid(Tnew).name()
484  << std::endl;
485  libMesh::err << "The " << typeid(Told).name()
486  << " appears to be a "
487  << typeid(*(&oldvar)).name() << std::endl;
488  libmesh_error();
489  }
490 #else
491  return(static_cast<Tnew>(oldvar));
492 #endif
493 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
OStreamProxy err(std::cerr)

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

266 {
268 }

◆ command_line_next()

template<typename T >
T libMesh::command_line_next ( std::string  name,
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().

942 {
943  // on_command_line also puts the command_line cursor in the spot we
944  // need
945  if (on_command_line(name))
946  return command_line->next(value);
947 
948  return value;
949 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
static const bool value
Definition: xdr_io.C:109
bool on_command_line(std::string arg)
Definition: libmesh.C:876

◆ 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 &  ,
 
)
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().

910 {
911  // Make sure the command line parser is ready for use
912  libmesh_assert(command_line.get());
913 
914  // only if the variable exists in the file
915  if (command_line->have_variable(name.c_str()))
916  value = (*command_line)(name.c_str(), value);
917 
918  return value;
919 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
static const bool value
Definition: xdr_io.C:109

◆ command_line_value() [2/2]

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

Definition at line 922 of file libmesh.C.

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

923 {
924  // Make sure the command line parser is ready for use
925  libmesh_assert(command_line.get());
926 
927  // Check for multiple options (return the first that matches)
928  for (const auto & entry : name)
929  if (command_line->have_variable(entry.c_str()))
930  {
931  value = (*command_line)(entry.c_str(), value);
932  break;
933  }
934 
935  return value;
936 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
static const bool value
Definition: xdr_io.C:109

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

955 {
956  // Make sure the command line parser is ready for use
957  libmesh_assert(command_line.get());
958 
959  // only if the variable exists on the command line
960  if (command_line->have_variable(name.c_str()))
961  {
962  unsigned size = command_line->vector_variable_size(name.c_str());
963  vec.resize(size);
964 
965  for (unsigned i=0; i<size; ++i)
966  vec[i] = (*command_line)(name.c_str(), vec[i], i);
967  }
968 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42

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

172 {
173  // None of these parameters are used when !LIBMESH_ENABLE_AMR.
174  libmesh_ignore(mesh, elem_it, elem_end, connected_elements);
175 
176 #ifdef LIBMESH_ENABLE_AMR
177  // Our XdrIO output needs inactive local elements to not have any
178  // remote_elem children. Let's make sure that doesn't happen.
179  //
180  for (const auto & elem : as_range(elem_it, elem_end))
181  {
182  if (elem->has_children())
183  for (auto & child : elem->child_ref_range())
184  if (&child != remote_elem)
185  connected_elements.insert(&child);
186  }
187 #endif // LIBMESH_ENABLE_AMR
188 }
MeshBase & mesh
void libmesh_ignore(const Args &...)
SimpleRange< I > as_range(const std::pair< I, I > &p)
Definition: simple_range.h:57
const RemoteElem * remote_elem
Definition: remote_elem.C:57

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

192 {
193  // This parameter is not used when !LIBMESH_ENABLE_AMR.
194  libmesh_ignore(connected_elements);
195 
196 #ifdef LIBMESH_ENABLE_AMR
197 
198  // Because our set is sorted by ascending level, we can traverse it
199  // in reverse order, adding parents as we go, and end up with all
200  // ancestors added. This is safe for std::set where insert doesn't
201  // invalidate iterators.
202  //
203  // This only works because we do *not* cache
204  // connected_elements.rend(), whose value can change when we insert
205  // elements which are sorted before the original rend.
206  //
207  // We're also going to get subactive descendents here, when any
208  // exist. We're iterating in the wrong direction to do that
209  // non-recursively, so we'll cop out and rely on total_family_tree.
210  // Iterating backwards does mean that we won't be querying the newly
211  // inserted subactive elements redundantly.
212 
213  std::set<const Elem *, CompareElemIdsByLevel>::reverse_iterator
214  elem_rit = connected_elements.rbegin();
215 
216  for (; elem_rit != connected_elements.rend(); ++elem_rit)
217  {
218  const Elem * elem = *elem_rit;
219  libmesh_assert(elem);
220  const Elem * parent = elem->parent();
221 
222  // We let ghosting functors worry about only active elements,
223  // but the remote processor needs all its semilocal elements'
224  // ancestors and active semilocal elements' descendants too.
225  if (parent)
226  connected_elements.insert (parent);
227 
228  if (elem->active() && elem->has_children())
229  {
230  std::vector<const Elem *> subactive_family;
231  elem->total_family_tree(subactive_family);
232  for (std::size_t i=0; i != subactive_family.size(); ++i)
233  {
234  libmesh_assert(subactive_family[i] != remote_elem);
235  connected_elements.insert(subactive_family[i]);
236  }
237  }
238  }
239 
240 # ifdef DEBUG
241  // Let's be paranoid and make sure that all our ancestors
242  // really did get inserted. I screwed this up the first time
243  // by caching rend, and I can easily imagine screwing it up in
244  // the future by changing containers.
245  for (const auto & elem : connected_elements)
246  {
247  libmesh_assert(elem);
248  const Elem * parent = elem->parent();
249  if (parent)
250  libmesh_assert(connected_elements.count(parent));
251  }
252 # endif // DEBUG
253 
254 #endif // LIBMESH_ENABLE_AMR
255 }
const Elem * parent() const
Definition: elem.h:2479
The base class for all geometric element types.
Definition: elem.h:100
void total_family_tree(std::vector< const Elem *> &active_family, const bool reset=true) const
Definition: elem.C:1557
void libmesh_ignore(const Args &...)
bool active() const
Definition: elem.h:2390
bool has_children() const
Definition: elem.h:2428
const RemoteElem * remote_elem
Definition: remote_elem.C:57

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

252 {
253  switch (r)
254  {
255  case SNES_CONVERGED_FNORM_ABS:
256  return DiffSolver::CONVERGED_ABSOLUTE_RESIDUAL;
257  case SNES_CONVERGED_FNORM_RELATIVE:
258  return DiffSolver::CONVERGED_RELATIVE_RESIDUAL;
259 #if PETSC_VERSION_LESS_THAN(3,2,1)
260  case SNES_CONVERGED_PNORM_RELATIVE:
261 #else
262  case SNES_CONVERGED_SNORM_RELATIVE:
263 #endif
264  return DiffSolver::CONVERGED_RELATIVE_STEP;
265  case SNES_CONVERGED_ITS:
266  case SNES_CONVERGED_TR_DELTA:
267  return DiffSolver::CONVERGED_NO_REASON;
268  case SNES_DIVERGED_FUNCTION_DOMAIN:
269  case SNES_DIVERGED_FUNCTION_COUNT:
270  case SNES_DIVERGED_FNORM_NAN:
271 #if !PETSC_VERSION_LESS_THAN(3,3,0)
272  case SNES_DIVERGED_INNER:
273 #endif
274  case SNES_DIVERGED_LINEAR_SOLVE:
275  case SNES_DIVERGED_LOCAL_MIN:
276  return DiffSolver::DIVERGED_NO_REASON;
277  case SNES_DIVERGED_MAX_IT:
278  return DiffSolver::DIVERGED_MAX_NONLINEAR_ITERATIONS;
279 #if PETSC_VERSION_LESS_THAN(3,2,0)
280  case SNES_DIVERGED_LS_FAILURE:
281 #else
282  case SNES_DIVERGED_LINE_SEARCH:
283 #endif
284  return DiffSolver::DIVERGED_BACKTRACKING_FAILURE;
285  // In PETSc, SNES_CONVERGED_ITERATING means
286  // the solve is still iterating, but by the
287  // time we get here, we must have either
288  // converged or diverged, so
289  // SNES_CONVERGED_ITERATING is invalid.
290  case SNES_CONVERGED_ITERATING:
291  return DiffSolver::INVALID_SOLVE_RESULT;
292  default:
293  break;
294  }
295  return DiffSolver::INVALID_SOLVE_RESULT;
296 }

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

1099 {
1100  return std::sqrt(cross_norm_sq(b,c));
1101 }
T cross_norm_sq(const TypeVector< T > &b, const TypeVector< T > &c)
Definition: type_vector.h:1076

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

1078 {
1079  T z = b(0)*c(1) - b(1)*c(0);
1080 
1081 #if LIBMESH_DIM == 3
1082  T x = b(1)*c(2) - b(2)*c(1),
1083  y = b(0)*c(2) - b(2)*c(0);
1084  return x*x + y*y + z*z;
1085 #else
1086  return z*z;
1087 #endif
1088 }

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

972 {
973  libmesh_assert (libMesh::initialized());
974 
975  static bool called = false;
976 
977  // Check the command line. Since the command line is
978  // unchanging it is sufficient to do this only once.
979  if (!called)
980  {
981  called = true;
982 
983 #ifdef LIBMESH_HAVE_PETSC
984  if (libMesh::on_command_line ("--use-petsc"))
986 #endif
987 
988 #ifdef LIBMESH_TRILINOS_HAVE_AZTECOO
989  if (libMesh::on_command_line ("--use-trilinos") ||
990  libMesh::on_command_line ("--disable-petsc"))
992 #endif
993 
994 #ifdef LIBMESH_HAVE_EIGEN
995  if (libMesh::on_command_line ("--use-eigen" ) ||
996 #if defined(LIBMESH_HAVE_MPI)
997  // If the user bypassed MPI, we disable PETSc and Trilinos
998  // too
999  libMesh::on_command_line ("--disable-mpi") ||
1000 #endif
1001  libMesh::on_command_line ("--disable-petsc"))
1003 #endif
1004 
1005 #ifdef LIBMESH_HAVE_LASPACK
1006  if (libMesh::on_command_line ("--use-laspack" ) ||
1007 #if defined(LIBMESH_HAVE_MPI)
1008  // If the user bypassed MPI, we disable PETSc and Trilinos
1009  // too
1010  libMesh::on_command_line ("--disable-mpi") ||
1011 #endif
1012  libMesh::on_command_line ("--disable-petsc"))
1014 #endif
1015 
1016  if (libMesh::on_command_line ("--disable-laspack") &&
1017  libMesh::on_command_line ("--disable-trilinos") &&
1018  libMesh::on_command_line ("--disable-eigen") &&
1019  (
1020 #if defined(LIBMESH_HAVE_MPI)
1021  // If the user bypassed MPI, we disable PETSc too
1022  libMesh::on_command_line ("--disable-mpi") ||
1023 #endif
1024  libMesh::on_command_line ("--disable-petsc")))
1026  }
1027 
1028 
1030 }
EIGEN_SOLVERS
Definition: libmesh.C:246
TRILINOS_SOLVERS
Definition: libmesh.C:244
LASPACK_SOLVERS
Definition: libmesh.C:248
bool initialized()
Definition: libmesh.C:258
INVALID_SOLVER_PACKAGE
Definition: libmesh.C:250
bool on_command_line(std::string arg)
Definition: libmesh.C:876
SolverPackage _solver_package
Definition: libmesh.C:240

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

251 {
252  int status = 0;
253  std::string ret = name;
254 
255  // Actually do the demangling
256  char * demangled_name = abi::__cxa_demangle(name, 0, 0, &status);
257 
258  // If demangling returns non-nullptr, save the result in a string.
259  if (demangled_name)
260  ret = demangled_name;
261 
262  // According to cxxabi.h docs, the caller is responsible for
263  // deallocating memory.
264  std::free(demangled_name);
265 
266  return ret;
267 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:42
MPI_Status status
Definition: status.h:41

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

801 {
802 #if !defined(LIBMESH_HAVE_FEENABLEEXCEPT) && defined(LIBMESH_HAVE_XMMINTRIN_H) && !defined(__SUNPRO_CC)
803  static int flags = 0;
804 #endif
805 
806  if (on)
807  {
808 #ifdef LIBMESH_HAVE_FEENABLEEXCEPT
809  feenableexcept(FE_DIVBYZERO | FE_INVALID);
810 #elif LIBMESH_HAVE_XMMINTRIN_H
811 # ifndef __SUNPRO_CC
812  flags = _MM_GET_EXCEPTION_MASK(); // store the flags
813  _MM_SET_EXCEPTION_MASK(flags & ~_MM_MASK_INVALID);
814 # endif
815 #endif
816 
817 #if LIBMESH_HAVE_DECL_SIGACTION
818  struct sigaction new_action, old_action;
819 
820  // Set up the structure to specify the new action.
821  new_action.sa_sigaction = libmesh_handleFPE;
822  sigemptyset (&new_action.sa_mask);
823  new_action.sa_flags = SA_SIGINFO;
824 
825  sigaction (SIGFPE, nullptr, &old_action);
826  if (old_action.sa_handler != SIG_IGN)
827  sigaction (SIGFPE, &new_action, nullptr);
828 #endif
829  }
830  else
831  {
832 #ifdef LIBMESH_HAVE_FEDISABLEEXCEPT
833  fedisableexcept(FE_DIVBYZERO | FE_INVALID);
834 #elif LIBMESH_HAVE_XMMINTRIN_H
835 # ifndef __SUNPRO_CC
836  _MM_SET_EXCEPTION_MASK(flags);
837 # endif
838 #endif
839  signal(SIGFPE, SIG_DFL);
840  }
841 }

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

847 {
848 #if LIBMESH_HAVE_DECL_SIGACTION
849  static struct sigaction old_action;
850  static bool was_on = false;
851 
852  if (on)
853  {
854  struct sigaction new_action;
855  was_on = true;
856 
857  // Set up the structure to specify the new action.
858  new_action.sa_sigaction = libmesh_handleSEGV;
859  sigemptyset (&new_action.sa_mask);
860  new_action.sa_flags = SA_SIGINFO;
861 
862  sigaction (SIGSEGV, &new_action, &old_action);
863  }
864  else if (was_on)
865  {
866  was_on = false;
867  sigaction (SIGSEGV, &old_action, nullptr);
868  }
869 #else
870  libmesh_error_msg("System call sigaction not supported.");
871 #endif
872 }

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

81 {
82  std::string retval(LIBMESH_IO_COMPATIBILITY_VERSION);
83  return retval;
84 }

◆ get_libmesh_version()

int libMesh::get_libmesh_version ( )

Definition at line 46 of file libmesh_version.C.

Referenced by libmesh_version_stdout().

47 {
48  /* Note: return format follows the versioning convention xx.yy.zz where
49 
50  xx = major version number
51  yy = minor version number
52  zz = micro version number
53 
54  For example:
55  v. 0.23 -> 002300 = 2300
56  v 0.23.1 -> 002301 = 2301
57  v. 10.23.2 -> 102302 */
58 
59  int major_version = 0;
60  int minor_version = 0;
61  int micro_version = 0;
62 
63 #ifdef LIBMESH_MAJOR_VERSION
64  major_version = LIBMESH_MAJOR_VERSION;
65 #endif
66 
67 #ifdef LIBMESH_MINOR_VERSION
68  minor_version = LIBMESH_MINOR_VERSION;
69 #endif
70 
71 #ifdef LIBMESH_MICRO_VERSION
72  micro_version = LIBMESH_MICRO_VERSION;
73 #endif
74 
75  return major_version*10000 + minor_version*100 + micro_version;
76 }

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

76 {
77 #ifdef LIBMESH_HAVE_MPI
79 #else
80  return 1;
81 #endif
82 }
processor_id_type _n_processors
Definition: libmesh.C:235

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

86 {
87 #ifdef LIBMESH_HAVE_MPI
89 #else
90  return 0;
91 #endif
92 }
processor_id_type _processor_id
Definition: libmesh.C:236

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

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

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

116 {
117  return {vec.first_local_index(), vec.last_local_index()};
118 }

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

259 {
261 }

◆ INSTANTIATE_ALL_MAPS() [1/4]

libMesh::INSTANTIATE_ALL_MAPS ( )

◆ INSTANTIATE_ALL_MAPS() [2/4]

libMesh::INSTANTIATE_ALL_MAPS ( )

◆ INSTANTIATE_ALL_MAPS() [3/4]

libMesh::INSTANTIATE_ALL_MAPS ( )

◆ INSTANTIATE_ALL_MAPS() [4/4]

libMesh::INSTANTIATE_ALL_MAPS ( )

◆ INSTANTIATE_FE() [1/4]

libMesh::INSTANTIATE_FE ( )

◆ INSTANTIATE_FE() [2/4]

libMesh::INSTANTIATE_FE ( )

◆ INSTANTIATE_FE() [3/4]

libMesh::INSTANTIATE_FE ( )

◆ INSTANTIATE_FE() [4/4]

libMesh::INSTANTIATE_FE ( )

◆ INSTANTIATE_INF_FE() [1/3]

libMesh::INSTANTIATE_INF_FE ( ,
CARTESIAN   
)

Collect all 2D explicit instantiations for class InfFE

◆ INSTANTIATE_INF_FE() [2/3]

libMesh::INSTANTIATE_INF_FE ( ,
CARTESIAN   
)

Collect all 3D explicit instantiations for class InfFE

◆ INSTANTIATE_INF_FE() [3/3]

libMesh::INSTANTIATE_INF_FE ( ,
CARTESIAN   
)

Collect all 1D explicit instantiations for class InfFE

◆ INSTANTIATE_INF_FE_MBRF() [1/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [2/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [3/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [4/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [5/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [6/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [7/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [8/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [9/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [10/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [11/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [12/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [13/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [20/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [21/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [22/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [23/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [24/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [25/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [26/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [27/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [28/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [32/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [33/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [34/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [35/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [36/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [37/57]

libMesh::INSTANTIATE_INF_FE_MBRF ( ,
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 ( ,
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 ( ,
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 ( ,
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 ( ,
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 ( ,
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 ( ,
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 ( ,
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 ( ,
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 ( ,
CARTESIAN  ,
Real  ,
shape(const FEType &, const Elem *, const unsigned int, const Point &p)   
)

◆ INSTANTIATE_INF_FE_MBRF() [47/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [48/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [49/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [50/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [51/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [52/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [53/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [54/57]

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

◆ INSTANTIATE_INF_FE_MBRF() [55/57]

libMesh::INSTANTIATE_INF_FE_MBRF ( ,
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 ( ,
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 ( ,
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().

31 {
32  return min <= check && check <= max;
33 }
long double max(long double a, double b)
long double min(long double a, double b)

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

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

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

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

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

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

◆ libmesh_conj() [1/2]

template<typename T >
T libMesh::libmesh_conj ( a)
inline

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

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

◆ libmesh_ignore()

◆ libmesh_isinf() [1/2]

template<typename T >
bool libMesh::libmesh_isinf ( 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().

182 { return !libmesh_isnan(x) && libmesh_isnan(x - x); }
bool libmesh_isnan(std::complex< T > a)

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

185 { return (libmesh_isinf(std::real(a)) || libmesh_isinf(std::imag(a))); }
bool libmesh_isinf(std::complex< T > a)

◆ libmesh_isnan() [1/4]

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

173 { return libmesh_C_isnan_double(a); }
int libmesh_C_isnan_double(double a)
Definition: libmesh_isnan.c:26

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

174 { return libmesh_C_isnan_longdouble(a); }
int libmesh_C_isnan_longdouble(long double a)
Definition: libmesh_isnan.c:27

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

177 { return (libmesh_isnan(std::real(a)) || libmesh_isnan(std::imag(a))); }
bool libmesh_isnan(std::complex< T > 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().

385  {
386  // No way to safety-check this cast, since we got a void *...
387  PetscNonlinearSolver<Number> * solver =
388  static_cast<PetscNonlinearSolver<Number> *> (ctx);
389 
390  solver->linesearch_object->linesearch(linesearch);
391  return 0;
392  }

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

62  {
63  Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number> *>(ctx);
64 
65  PetscVector<Number> x_vec(x, preconditioner->comm());
66  PetscVector<Number> y_vec(y, preconditioner->comm());
67 
68  preconditioner->apply(x_vec,y_vec);
69 
70  return 0;
71  }

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

88  {
89  void * ctx;
90  PetscErrorCode ierr = PCShellGetContext(pc,&ctx);CHKERRQ(ierr);
91  Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number> *>(ctx);
92 
93  PetscVector<Number> x_vec(x, preconditioner->comm());
94  PetscVector<Number> y_vec(y, preconditioner->comm());
95 
96  preconditioner->apply(x_vec,y_vec);
97 
98  return 0;
99  }
PetscErrorCode ierr
CHKERRQ(ierr)

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

49  {
50  Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number> *>(ctx);
51 
52  if (!preconditioner->initialized())
53  libmesh_error_msg("Preconditioner not initialized! Make sure you call init() before solve!");
54 
55  preconditioner->setup();
56 
57  return 0;
58  }

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

74  {
75  void * ctx;
76  PetscErrorCode ierr = PCShellGetContext(pc,&ctx);CHKERRQ(ierr);
77  Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number> *>(ctx);
78 
79  if (!preconditioner->initialized())
80  libmesh_error_msg("Preconditioner not initialized! Make sure you call init() before solve!");
81 
82  preconditioner->setup();
83 
84  return 0;
85  }
PetscErrorCode ierr
CHKERRQ(ierr)

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

202  {
203  ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);
204 
205  libmesh_assert(r);
206  PetscVector<Number> R(r, rc.sys.comm());
207 
208  if (rc.solver->_zero_out_residual)
209  R.zero();
210 
211  if (rc.solver->fd_residual_object != nullptr)
212  rc.solver->fd_residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
213 
214  else if (rc.solver->residual_object != nullptr)
215  rc.solver->residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
216 
217  else
218  libmesh_error_msg("Error! Unable to compute residual for forming finite difference Jacobian!");
219 
220  R.close();
221 
222  return rc.ierr;
223  }
ResidualContext libmesh_petsc_snes_residual_helper(SNES snes, Vec x, void *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 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().

295  {
296  LOG_SCOPE("jacobian()", "PetscNonlinearSolver");
297 
298  PetscErrorCode ierr=0;
299 
300  libmesh_assert(ctx);
301 
302  // No way to safety-check this cast, since we got a void *...
303  PetscNonlinearSolver<Number> * solver =
304  static_cast<PetscNonlinearSolver<Number> *> (ctx);
305 
306  // Get the current iteration number from the snes object,
307  // store it in the PetscNonlinearSolver object for possible use
308  // by the user's Jacobian function.
309  {
310  PetscInt n_iterations = 0;
311  ierr = SNESGetIterationNumber(snes, &n_iterations);
312  CHKERRABORT(solver->comm().get(),ierr);
313  solver->_current_nonlinear_iteration_number = cast_int<unsigned>(n_iterations);
314  }
315 
316  NonlinearImplicitSystem & sys = solver->system();
317 #if PETSC_RELEASE_LESS_THAN(3,5,0)
318  PetscMatrix<Number> PC(*pc, sys.comm());
319  PetscMatrix<Number> Jac(*jac, sys.comm());
320 #else
321  PetscMatrix<Number> PC(pc, sys.comm());
322  PetscMatrix<Number> Jac(jac, sys.comm());
323 #endif
324  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
325  PetscVector<Number> X_global(x, sys.comm());
326 
327  // Set the dof maps
328  PC.attach_dof_map(sys.get_dof_map());
329  Jac.attach_dof_map(sys.get_dof_map());
330 
331  // Use the systems update() to get a good local version of the parallel solution
332  X_global.swap(X_sys);
333  sys.update();
334  X_global.swap(X_sys);
335 
336  // Enforce constraints (if any) exactly on the
337  // current_local_solution. This is the solution vector that is
338  // actually used in the computation of the residual below, and is
339  // not locked by debug-enabled PETSc the way that "x" is.
340  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
341 
342  if (solver->_zero_out_jacobian)
343  PC.zero();
344 
345  //-----------------------------------------------------------------------------
346  // if the user has provided both function pointers and objects only the pointer
347  // will be used, so catch that as an error
348  if (solver->jacobian && solver->jacobian_object)
349  libmesh_error_msg("ERROR: cannot specify both a function and object to compute the Jacobian!");
350 
351  if (solver->matvec && solver->residual_and_jacobian_object)
352  libmesh_error_msg("ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!");
353 
354  if (solver->jacobian != nullptr)
355  solver->jacobian(*sys.current_local_solution.get(), PC, sys);
356 
357  else if (solver->jacobian_object != nullptr)
358  solver->jacobian_object->jacobian(*sys.current_local_solution.get(), PC, sys);
359 
360  else if (solver->matvec != nullptr)
361  solver->matvec(*sys.current_local_solution.get(), nullptr, &PC, sys);
362 
363  else if (solver->residual_and_jacobian_object != nullptr)
364  solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), nullptr, &PC, sys);
365 
366  else
367  libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
368 
369  PC.close();
370  Jac.close();
371 #if PETSC_RELEASE_LESS_THAN(3,5,0)
372  *msflag = SAME_NONZERO_PATTERN;
373 #endif
374 
375  return ierr;
376  }
PetscErrorCode 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().

268  {
269  // No way to safety-check this cast, since we got a void *...
270  PetscNonlinearSolver<Number> * solver =
271  static_cast<PetscNonlinearSolver<Number> *> (ctx);
272 
273  return libmesh_petsc_snes_mffd_residual(solver->snes(), x, r, ctx);
274  }
PetscErrorCode libmesh_petsc_snes_mffd_residual(SNES snes, Vec x, Vec r, void *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().

239  {
240  ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);
241 
242  libmesh_assert(r);
243  PetscVector<Number> R(r, rc.sys.comm());
244 
245  if (rc.solver->_zero_out_residual)
246  R.zero();
247 
248  if (rc.solver->mffd_residual_object != nullptr)
249  rc.solver->mffd_residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
250 
251  else if (rc.solver->residual_object != nullptr)
252  rc.solver->residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
253 
254  else
255  libmesh_error_msg("Error! Unable to compute residual for forming finite differenced"
256  "Jacobian-vector products!");
257 
258  R.close();
259 
260  return rc.ierr;
261  }
ResidualContext libmesh_petsc_snes_residual_helper(SNES snes, Vec x, void *ctx)

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

123  {
124  //PetscErrorCode ierr=0;
125 
126  //if (its > 0)
127  libMesh::out << " NL step "
128  << std::setw(2) << its
129  << std::scientific
130  << ", |residual|_2 = " << fnorm
131  << std::endl;
132 
133  //return ierr;
134  return 0;
135  }
OStreamProxy out(std::cout)

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

432  {
433  LOG_SCOPE("postcheck()", "PetscNonlinearSolver");
434 
435  PetscErrorCode ierr = 0;
436 
437  // PETSc almost certainly initializes these to false already, but
438  // it doesn't hurt to be explicit.
439  *changed_w = PETSC_FALSE;
440  *changed_y = PETSC_FALSE;
441 
442  libmesh_assert(context);
443 
444  // Cast the context to a NonlinearSolver object.
445  PetscNonlinearSolver<Number> * solver =
446  static_cast<PetscNonlinearSolver<Number> *> (context);
447 
448  // If the user has provided both postcheck function pointer and
449  // object, this is ambiguous, so throw an error.
450  if (solver->postcheck && solver->postcheck_object)
451  libmesh_error_msg("ERROR: cannot specify both a function and object for performing the solve postcheck!");
452 
453  // It's also possible that we don't need to do anything at all, in
454  // that case return early...
455  NonlinearImplicitSystem & sys = solver->system();
456  DofMap & dof_map = sys.get_dof_map();
457 
458  if (!dof_map.n_constrained_dofs() && !solver->postcheck && !solver->postcheck_object)
459  return ierr;
460 
461  // We definitely need to wrap at least "w"
462  PetscVector<Number> petsc_w(w, sys.comm());
463 
464  // The user sets these flags in his/her postcheck function to
465  // indicate whether they changed something.
466  bool
467  changed_search_direction = false,
468  changed_new_soln = false;
469 
470  if (solver->postcheck || solver->postcheck_object)
471  {
472  PetscVector<Number> petsc_x(x, sys.comm());
473  PetscVector<Number> petsc_y(y, sys.comm());
474 
475  if (solver->postcheck)
476  solver->postcheck(petsc_x,
477  petsc_y,
478  petsc_w,
479  changed_search_direction,
480  changed_new_soln,
481  sys);
482 
483  else if (solver->postcheck_object)
484  solver->postcheck_object->postcheck(petsc_x,
485  petsc_y,
486  petsc_w,
487  changed_search_direction,
488  changed_new_soln,
489  sys);
490  }
491 
492  // Record whether the user changed the solution or the search direction.
493  if (changed_search_direction)
494  *changed_y = PETSC_TRUE;
495 
496  if (changed_new_soln)
497  *changed_w = PETSC_TRUE;
498 
499  if (dof_map.n_constrained_dofs())
500  {
501  PetscVector<Number> & system_soln = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
502 
503  // ... and swap it in before enforcing the constraints.
504  petsc_w.swap(system_soln);
505 
506  dof_map.enforce_constraints_exactly(sys);
507 
508  // If we have constraints, we'll assume that we did change the
509  // solution w (hopefully slightly). Enforcing constraints
510  // does not change the search direction, y, but the user may
511  // have, so we leave it alone.
512  *changed_w = PETSC_TRUE;
513 
514  // Swap back
515  petsc_w.swap(system_soln);
516  }
517 
518  return ierr;
519  }
PetscErrorCode 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().

151  {
152  ResidualContext rc = libmesh_petsc_snes_residual_helper(snes, x, ctx);
153 
154  libmesh_assert(r);
155  PetscVector<Number> R(r, rc.sys.comm());
156 
157  if (rc.solver->_zero_out_residual)
158  R.zero();
159 
160  //-----------------------------------------------------------------------------
161  // if the user has provided both function pointers and objects only the pointer
162  // will be used, so catch that as an error
163  if (rc.solver->residual && rc.solver->residual_object)
164  libmesh_error_msg("ERROR: cannot specify both a function and object to compute the Residual!");
165 
166  if (rc.solver->matvec && rc.solver->residual_and_jacobian_object)
167  libmesh_error_msg("ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!");
168 
169  if (rc.solver->residual != nullptr)
170  rc.solver->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
171 
172  else if (rc.solver->residual_object != nullptr)
173  rc.solver->residual_object->residual(*rc.sys.current_local_solution.get(), R, rc.sys);
174 
175  else if (rc.solver->matvec != nullptr)
176  rc.solver->matvec (*rc.sys.current_local_solution.get(), &R, nullptr, rc.sys);
177 
178  else if (rc.solver->residual_and_jacobian_object != nullptr)
179  rc.solver->residual_and_jacobian_object->residual_and_jacobian (*rc.sys.current_local_solution.get(), &R, nullptr, rc.sys);
180 
181  else
182  libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
183 
184  R.close();
185 
186  return rc.ierr;
187  }
ResidualContext libmesh_petsc_snes_residual_helper(SNES snes, Vec x, void *ctx)

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

65 {
66  LOG_SCOPE("residual()", "PetscNonlinearSolver");
67 
68  PetscErrorCode ierr = 0;
69 
70  libmesh_assert(x);
71  libmesh_assert(ctx);
72 
73  // No way to safety-check this cast, since we got a void *...
74  PetscNonlinearSolver<Number> * solver =
75  static_cast<PetscNonlinearSolver<Number> *> (ctx);
76 
77  // Get the current iteration number from the snes object,
78  // store it in the PetscNonlinearSolver object for possible use
79  // by the user's residual function.
80  {
81  PetscInt n_iterations = 0;
82  ierr = SNESGetIterationNumber(snes, &n_iterations);
83  CHKERRABORT(solver->comm().get(),ierr);
84  solver->_current_nonlinear_iteration_number = cast_int<unsigned>(n_iterations);
85  }
86 
87  NonlinearImplicitSystem & sys = solver->system();
88 
89  PetscVector<Number> & X_sys = *cast_ptr<PetscVector<Number> *>(sys.solution.get());
90 
91  PetscVector<Number> X_global(x, sys.comm());
92 
93  // Use the system's update() to get a good local version of the
94  // parallel solution. This operation does not modify the incoming
95  // "x" vector, it only localizes information from "x" into
96  // sys.current_local_solution.
97  X_global.swap(X_sys);
98  sys.update();
99  X_global.swap(X_sys);
100 
101  // Enforce constraints (if any) exactly on the
102  // current_local_solution. This is the solution vector that is
103  // actually used in the computation of the residual below, and is
104  // not locked by debug-enabled PETSc the way that "x" is.
105  sys.get_dof_map().enforce_constraints_exactly(sys, sys.current_local_solution.get());
106 
107  return ResidualContext(solver, sys, ierr);
108 }
PetscErrorCode ierr

◆ libmesh_real() [1/2]

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

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

275 {
276  // If this got called then we're probably crashing; let's print a
277  // stack trace. The trace files that are ultimately written depend on:
278  // 1.) Who throws the exception.
279  // 2.) Whether the C++ runtime unwinds the stack before the
280  // terminate_handler is called (this is implementation defined).
281  //
282  // The various cases are summarized in the table below:
283  //
284  // | libmesh exception | other exception
285  // -------------------------------------
286  // stack unwinds | A | B
287  // stack does not unwind | C | D
288  //
289  // Case A: There will be two stack traces in the file: one "useful"
290  // one, and one nearly empty one due to stack unwinding.
291  // Case B: You will get one nearly empty stack trace (not great, Bob!)
292  // Case C: You will get two nearly identical stack traces, ignore one of them.
293  // Case D: You will get one useful stack trace.
294  //
295  // Cases A and B (where the stack unwinds when an exception leaves
296  // main) appear to be non-existent in practice. I don't have a
297  // definitive list, but the stack does not unwind for GCC on either
298  // Mac or Linux. I think there's good reasons for this behavior too:
299  // it's much easier to get a stack trace when the stack doesn't
300  // unwind, for example.
302 
303  // We may care about performance data pre-crash; it would be sad to
304  // throw that away.
307 
308  // If we have MPI and it has been initialized, we need to be sure
309  // and call MPI_Abort instead of std::abort, so that the parallel
310  // job can die nicely.
311 #if defined(LIBMESH_HAVE_MPI)
312  int mpi_initialized;
313  MPI_Initialized (&mpi_initialized);
314 
315  if (mpi_initialized)
316  MPI_Abort(libMesh::GLOBAL_COMM_WORLD, 1);
317  else
318 #endif
319  // The system terminate_handler may do useful things like printing
320  // uncaught exception information, or the user may have created
321  // their own terminate handler that we want to call.
323 }
MPI_Comm GLOBAL_COMM_WORLD
Definition: libmesh.C:195
void write_traceout()
Definition: print_trace.C:233
PerfLog perflog("libMesh", #ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING true #else false #endif)
std::terminate_handler old_terminate_handler
Definition: libmesh.C:272
void clear()
Definition: perf_log.C:77
void print_log() const
Definition: perf_log.C:684

◆ libmesh_version_stdout()

void libMesh::libmesh_version_stdout ( )

Definition at line 23 of file libmesh_version.C.

References get_libmesh_version().

24 {
25  std::cout << "--------------------------------------------------------" << std::endl;
26  std::cout << "libMesh Library: Version = " << LIBMESH_LIB_VERSION;
27  std::cout << " (" << get_libmesh_version() << ")" << std::endl << std::endl;
28 
29  std::cout << LIBMESH_LIB_RELEASE << std::endl << std::endl;
30 
31  std::cout << "Build Date = " << LIBMESH_BUILD_DATE << std::endl;
32  std::cout << "Build Host = " << LIBMESH_BUILD_HOST << std::endl;
33  std::cout << "Build User = " << LIBMESH_BUILD_USER << std::endl;
34  std::cout << "Build Arch = " << LIBMESH_BUILD_ARCH << std::endl;
35  std::cout << "Build Rev = " << LIBMESH_BUILD_VERSION << std::endl << std::endl;
36 
37  // CXXFLAGS is ambiguous wth multiple methods - could add all three but why not libmesh-config?
38  //std::cout << "C++ Config = " << LIBMESH_CXX << " " << LIBMESH_CXXFLAGS << std::endl;
39  std::cout << "--------------------------------------------------------" << std::endl;
40 
41  return;
42 }
int get_libmesh_version()

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

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

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

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

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

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

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

◆ n_threads()

unsigned int libMesh::n_threads ( )
inline

◆ numeric_petsc_cast()

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

832 {
833  return reinterpret_cast<int *>(const_cast<numeric_index_type *>(p));
834 }
dof_id_type numeric_index_type
Definition: id_types.h:92

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

877 {
878  // Make sure the command line parser is ready for use
879  libmesh_assert(command_line.get());
880 
881  // Users had better not be asking about an empty string
882  libmesh_assert(!arg.empty());
883 
884  bool found_it = command_line->search(arg);
885 
886  if (!found_it)
887  {
888  // Try with all dashes instead of underscores
889  std::replace(arg.begin(), arg.end(), '_', '-');
890  found_it = command_line->search(arg);
891  }
892 
893  if (!found_it)
894  {
895  // OK, try with all underscores instead of dashes
896  auto name_begin = arg.begin();
897  while (*name_begin == '-')
898  ++name_begin;
899  std::replace(name_begin, arg.end(), '-', '_');
900  found_it = command_line->search(arg);
901  }
902 
903  return found_it;
904 }

◆ operator!=() [1/5]

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

Definition at line 96 of file fe_type.h.

96 { return !(lhs == rhs); }

◆ operator!=() [2/5]

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

Definition at line 141 of file fe_type.h.

141 { return !(lhs == rhs); }

◆ operator!=() [3/5]

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

Definition at line 142 of file fe_type.h.

142 { return !(lhs == rhs); }

◆ operator!=() [4/5]

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

Definition at line 143 of file fe_type.h.

143 { return !(lhs == rhs); }

◆ operator!=() [5/5]

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

Definition at line 144 of file fe_type.h.

144 { 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.

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

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

768 {
769  return v * factor;
770 }

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

962 {
963  return t * factor;
964 }

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

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

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

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

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

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

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

148 { 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.

445 {
446  m.print(os);
447  return os;
448 }

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

166 {
167  os << order.get_order();
168  return os;
169 }

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

209 {
210  q.print_info(os);
211  return os;
212 }

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

218 {
219  n.print_info(os);
220  return os;
221 }

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

397 {
398  p.print(os);
399  return os;
400 }

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

420 {
421  m.print_info(os);
422  return os;
423 }

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

810 {
811  fe.print_info(os);
812  return os;
813 }

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

1289 {
1290  es.print_info(os);
1291  return os;
1292 }

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

1802 {
1803  e.print_info(os);
1804  return os;
1805 }

◆ operator<=() [1/5]

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

Definition at line 99 of file fe_type.h.

99 { return !(lhs > rhs); }

◆ operator<=() [2/5]

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

Definition at line 153 of file fe_type.h.

153 { return !(lhs > rhs); }

◆ operator<=() [3/5]

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

Definition at line 154 of file fe_type.h.

154 { return !(lhs > rhs); }

◆ operator<=() [4/5]

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

Definition at line 155 of file fe_type.h.

155 { return !(lhs > rhs); }

◆ operator<=() [5/5]

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

Definition at line 156 of file fe_type.h.

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

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

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

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

140 { 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.

98 { return rhs < lhs; }

◆ operator>() [2/5]

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

Definition at line 149 of file fe_type.h.

149 { return rhs < lhs; }

◆ operator>() [3/5]

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

Definition at line 150 of file fe_type.h.

150 { return rhs < lhs; }

◆ operator>() [4/5]

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

Definition at line 151 of file fe_type.h.

151 { return rhs < lhs; }

◆ operator>() [5/5]

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

Definition at line 152 of file fe_type.h.

152 { 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.

100 { return !(lhs < rhs); }

◆ operator>=() [2/5]

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

Definition at line 157 of file fe_type.h.

157 { return !(lhs < rhs); }

◆ operator>=() [3/5]

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

Definition at line 158 of file fe_type.h.

158 { return !(lhs < rhs); }

◆ operator>=() [4/5]

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

Definition at line 159 of file fe_type.h.

159 { return !(lhs < rhs); }

◆ operator>=() [5/5]

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

Definition at line 160 of file fe_type.h.

160 { return !(lhs < rhs); }

◆ OrderWrapperOperators()

libMesh::OrderWrapperOperators ( int  )

Definition at line 130 of file fe_type.h.

References libMesh::OrderWrapper::get_order().

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

60 {
61  std::string sys_prefix = "--solver_group_";
62 
63  if (libMesh::on_command_line("--solver-system-names"))
64  {
65  sys_prefix = sys_prefix + sys.name() + "_";
66  }
67 
68  std::map<std::string, std::vector<dof_id_type>> group_indices;
69 
70  if (libMesh::on_command_line("--solver-variable-names"))
71  {
72  for (unsigned int v = 0; v != sys.n_vars(); ++v)
73  {
74  const std::string & var_name = sys.variable_name(v);
75 
76  std::vector<dof_id_type> var_idx;
78  (var_idx, sys.get_mesh(), v);
79 
80  std::string group_command = sys_prefix + var_name;
81 
82  const std::string empty_string;
83 
84  std::string group_name = libMesh::command_line_value
85  (group_command, empty_string);
86 
87  if (group_name != empty_string)
88  {
89  std::vector<dof_id_type> & indices =
90  group_indices[group_name];
91  const bool prior_indices = !indices.empty();
92  indices.insert(indices.end(), var_idx.begin(),
93  var_idx.end());
94  if (prior_indices)
95  std::sort(indices.begin(), indices.end());
96  }
97  else
98  {
99  indices_to_fieldsplit (sys.comm(), var_idx, my_pc, var_name);
100  }
101  }
102  }
103 
104  for (const auto & pr : group_indices)
105  indices_to_fieldsplit(sys.comm(), pr.second, my_pc, pr.first);
106 }
void local_variable_indices(std::vector< dof_id_type > &idx, const MeshBase &mesh, unsigned int var_num) const
Definition: dof_map.C:1076
const Parallel::Communicator & comm() const
const MeshBase & get_mesh() const
Definition: system.h:2033
const std::string & variable_name(const unsigned int i) const
Definition: system.h:2153
bool on_command_line(std::string arg)
Definition: libmesh.C:876
const std::string & name() const
Definition: system.h:2017
T command_line_value(const std::string &name, T value)
Definition: libmesh.C:909
unsigned int n_vars() const
Definition: system.h:2105
const DofMap & get_dof_map() const
Definition: system.h:2049

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

535 {
536  os << *param;
537 }

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

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

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

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

◆ print_helper() [4/5]

template<>
void libMesh::print_helper ( std::ostream &  os,
const char *  param 
)
inline

Definition at line 541 of file parameters.h.

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

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

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

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

197 {
198  // First try a GDB backtrace. They are better than what you get
199  // from calling backtrace() because you don't have to do any
200  // demangling, and they include line numbers! If the GDB backtrace
201  // fails, for example if your system does not have GDB, fall back to
202  // calling backtrace().
203  bool gdb_worked = false;
204 
205  // Let the user disable GDB backtraces by configuring with
206  // --without-gdb-command or with a command line option.
207  if (std::string(LIBMESH_GDB_COMMAND) != std::string("no") &&
208  !libMesh::on_command_line("--no-gdb-backtrace"))
209  gdb_worked = gdb_backtrace(out_stream);
210 
211  // This part requires that your compiler at least supports
212  // backtraces. Demangling is also nice, but it will still run
213  // without it.
214 #if defined(LIBMESH_HAVE_GLIBC_BACKTRACE)
215  if (!gdb_worked)
216  {
217  void * addresses[40];
218  char ** strings;
219 
220  int size = backtrace(addresses, 40);
221  strings = backtrace_symbols(addresses, size);
222  out_stream << "Stack frames: " << size << std::endl;
223  for (int i = 0; i < size; i++)
224  out_stream << i << ": " << process_trace(strings[i]) << std::endl;
225  std::free(strings);
226  }
227 #endif
228 }
bool on_command_line(std::string arg)
Definition: libmesh.C:876

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

142 {
143  for (auto & gf :
146  {
147  GhostingFunctor::map_type elements_to_ghost;
148  libmesh_assert(gf);
149  (*gf)(elem_it, elem_end, pid, elements_to_ghost);
150 
151  // We can ignore the CouplingMatrix in ->second, but we
152  // need to ghost all the elements in ->first.
153  for (auto & pr : elements_to_ghost)
154  {
155  const Elem * elem = pr.first;
156  libmesh_assert(elem != remote_elem);
157  connected_elements.insert(elem);
158  }
159  }
160 
161  // The GhostingFunctors won't be telling us about the elements from
162  // pid; we need to add those ourselves.
163  for (; elem_it != elem_end; ++elem_it)
164  connected_elements.insert(*elem_it);
165 }
The base class for all geometric element types.
Definition: elem.h:100
MeshBase & mesh
SimpleRange< I > as_range(const std::pair< I, I > &p)
Definition: simple_range.h:57
std::unordered_map< const Elem *, const CouplingMatrix * > map_type
std::set< GhostingFunctor * >::const_iterator ghosting_functors_begin() const
Definition: mesh_base.h:835
std::set< GhostingFunctor * >::const_iterator ghosting_functors_end() const
Definition: mesh_base.h:841
const RemoteElem * remote_elem
Definition: remote_elem.C:57

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

260 {
261  // We're done using the nodes list for element decisions; now
262  // let's reuse it for nodes of the elements we've decided on.
263  connected_nodes.clear();
264 
265  for (const auto & elem : connected_elements)
266  for (auto & n : elem->node_ref_range())
267  connected_nodes.insert(&n);
268 }

◆ REINIT_ERROR() [1/40]

libMesh::REINIT_ERROR ( ,
CLOUGH  ,
reinit   
)

Definition at line 65 of file fe_boundary.C.

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

◆ REINIT_ERROR() [2/40]

libMesh::REINIT_ERROR ( ,
CLOUGH  ,
edge_reinit   
)

Definition at line 66 of file fe_boundary.C.

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

◆ REINIT_ERROR() [3/40]

libMesh::REINIT_ERROR ( ,
HERMITE  ,
reinit   
)

Definition at line 69 of file fe_boundary.C.

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

◆ REINIT_ERROR() [4/40]

libMesh::REINIT_ERROR ( ,
HERMITE  ,
edge_reinit   
)

Definition at line 70 of file fe_boundary.C.

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

◆ REINIT_ERROR() [5/40]

libMesh::REINIT_ERROR ( ,
HIERARCHIC  ,
reinit   
)

Definition at line 73 of file fe_boundary.C.

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

◆ REINIT_ERROR() [6/40]

libMesh::REINIT_ERROR ( ,
HIERARCHIC  ,
edge_reinit   
)

Definition at line 74 of file fe_boundary.C.

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

◆ REINIT_ERROR() [7/40]

libMesh::REINIT_ERROR ( ,
L2_HIERARCHIC  ,
reinit   
)

Definition at line 77 of file fe_boundary.C.

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

◆ REINIT_ERROR() [8/40]

libMesh::REINIT_ERROR ( ,
L2_HIERARCHIC  ,
edge_reinit   
)

Definition at line 78 of file fe_boundary.C.

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

◆ REINIT_ERROR() [9/40]

libMesh::REINIT_ERROR ( ,
LAGRANGE  ,
reinit   
)

Definition at line 81 of file fe_boundary.C.

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

◆ REINIT_ERROR() [10/40]

libMesh::REINIT_ERROR ( ,
LAGRANGE  ,
edge_reinit   
)

Definition at line 82 of file fe_boundary.C.

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

◆ REINIT_ERROR() [11/40]

libMesh::REINIT_ERROR ( ,
LAGRANGE_VEC  ,
reinit   
)

Definition at line 85 of file fe_boundary.C.

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

◆ REINIT_ERROR() [12/40]

libMesh::REINIT_ERROR ( ,
LAGRANGE_VEC  ,
edge_reinit   
)

Definition at line 86 of file fe_boundary.C.

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

◆ REINIT_ERROR() [13/40]

libMesh::REINIT_ERROR ( ,
L2_LAGRANGE  ,
reinit   
)

Definition at line 89 of file fe_boundary.C.

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

◆ REINIT_ERROR() [14/40]

libMesh::REINIT_ERROR ( ,
L2_LAGRANGE  ,
edge_reinit   
)

Definition at line 90 of file fe_boundary.C.

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

◆ REINIT_ERROR() [15/40]

libMesh::REINIT_ERROR ( ,
MONOMIAL  ,
reinit   
)

Definition at line 93 of file fe_boundary.C.

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

◆ REINIT_ERROR() [16/40]

libMesh::REINIT_ERROR ( ,
MONOMIAL  ,
edge_reinit   
)

Definition at line 94 of file fe_boundary.C.

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

◆ REINIT_ERROR() [17/40]

libMesh::REINIT_ERROR ( ,
SCALAR  ,
reinit   
)

Definition at line 97 of file fe_boundary.C.

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

◆ REINIT_ERROR() [18/40]

libMesh::REINIT_ERROR ( ,
SCALAR  ,
edge_reinit   
)

Definition at line 98 of file fe_boundary.C.

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

◆ REINIT_ERROR() [19/40]

libMesh::REINIT_ERROR ( ,
XYZ  ,
reinit   
)

Definition at line 101 of file fe_boundary.C.

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

◆ REINIT_ERROR() [20/40]

libMesh::REINIT_ERROR ( ,
XYZ  ,
edge_reinit   
)

Definition at line 102 of file fe_boundary.C.

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

◆ REINIT_ERROR() [21/40]

libMesh::REINIT_ERROR ( ,
NEDELEC_ONE  ,
reinit   
)

Definition at line 105 of file fe_boundary.C.

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

◆ REINIT_ERROR() [22/40]

libMesh::REINIT_ERROR ( ,
NEDELEC_ONE  ,
edge_reinit   
)

Definition at line 106 of file fe_boundary.C.

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

◆ REINIT_ERROR() [23/40]

libMesh::REINIT_ERROR ( ,
BERNSTEIN  ,
reinit   
)

Definition at line 110 of file fe_boundary.C.

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

◆ REINIT_ERROR() [24/40]

libMesh::REINIT_ERROR ( ,
BERNSTEIN  ,
edge_reinit   
)

Definition at line 111 of file fe_boundary.C.

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

◆ REINIT_ERROR() [25/40]

libMesh::REINIT_ERROR ( ,
SZABAB  ,
reinit   
)

Definition at line 114 of file fe_boundary.C.

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

◆ REINIT_ERROR() [26/40]

libMesh::REINIT_ERROR ( ,
SZABAB  ,
edge_reinit   
)

Definition at line 115 of file fe_boundary.C.

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

◆ REINIT_ERROR() [27/40]

libMesh::REINIT_ERROR ( ,
CLOUGH  ,
edge_reinit   
)

Definition at line 120 of file fe_boundary.C.

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

◆ REINIT_ERROR() [28/40]

libMesh::REINIT_ERROR ( ,
HERMITE  ,
edge_reinit   
)

Definition at line 121 of file fe_boundary.C.

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

◆ REINIT_ERROR() [29/40]

libMesh::REINIT_ERROR ( ,
HIERARCHIC  ,
edge_reinit   
)

Definition at line 122 of file fe_boundary.C.

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

◆ REINIT_ERROR() [30/40]

libMesh::REINIT_ERROR ( ,
L2_HIERARCHIC  ,
edge_reinit   
)

Definition at line 123 of file fe_boundary.C.

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

◆ REINIT_ERROR() [31/40]

libMesh::REINIT_ERROR ( ,
LAGRANGE  ,
edge_reinit   
)

Definition at line 124 of file fe_boundary.C.

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

◆ REINIT_ERROR() [32/40]

libMesh::REINIT_ERROR ( ,
LAGRANGE_VEC  ,
edge_reinit   
)

Definition at line 125 of file fe_boundary.C.

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

◆ REINIT_ERROR() [33/40]

libMesh::REINIT_ERROR ( ,
L2_LAGRANGE  ,
edge_reinit   
)

Definition at line 126 of file fe_boundary.C.

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

◆ REINIT_ERROR() [34/40]

libMesh::REINIT_ERROR ( ,
XYZ  ,
edge_reinit   
)

Definition at line 127 of file fe_boundary.C.

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

◆ REINIT_ERROR() [35/40]

libMesh::REINIT_ERROR ( ,
MONOMIAL  ,
edge_reinit   
)

Definition at line 128 of file fe_boundary.C.

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

◆ REINIT_ERROR() [36/40]

libMesh::REINIT_ERROR ( ,
SCALAR  ,
edge_reinit   
)

Definition at line 129 of file fe_boundary.C.

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

◆ REINIT_ERROR() [37/40]

libMesh::REINIT_ERROR ( ,
NEDELEC_ONE  ,
reinit   
)

Definition at line 130 of file fe_boundary.C.

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

◆ REINIT_ERROR() [38/40]

libMesh::REINIT_ERROR ( ,
NEDELEC_ONE  ,
edge_reinit   
)

Definition at line 131 of file fe_boundary.C.

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

◆ REINIT_ERROR() [39/40]

libMesh::REINIT_ERROR ( ,
BERNSTEIN  ,
edge_reinit   
)

Definition at line 134 of file fe_boundary.C.

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

◆ REINIT_ERROR() [40/40]

libMesh::REINIT_ERROR ( ,
SZABAB  ,
edge_reinit   
)

Definition at line 135 of file fe_boundary.C.

135 { 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 ( ,
CLOUGH  ,
side_map   
)

Definition at line 67 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [2/14]

libMesh::SIDEMAP_ERROR ( ,
HERMITE  ,
side_map   
)

Definition at line 71 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [3/14]

libMesh::SIDEMAP_ERROR ( ,
HIERARCHIC  ,
side_map   
)

Definition at line 75 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [4/14]

libMesh::SIDEMAP_ERROR ( ,
L2_HIERARCHIC  ,
side_map   
)

Definition at line 79 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [5/14]

libMesh::SIDEMAP_ERROR ( ,
LAGRANGE  ,
side_map   
)

Definition at line 83 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [6/14]

libMesh::SIDEMAP_ERROR ( ,
LAGRANGE_VEC  ,
side_map   
)

Definition at line 87 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [7/14]

libMesh::SIDEMAP_ERROR ( ,
L2_LAGRANGE  ,
side_map   
)

Definition at line 91 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [8/14]

libMesh::SIDEMAP_ERROR ( ,
MONOMIAL  ,
side_map   
)

Definition at line 95 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [9/14]

libMesh::SIDEMAP_ERROR ( ,
SCALAR  ,
side_map   
)

Definition at line 99 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [10/14]

libMesh::SIDEMAP_ERROR ( ,
XYZ  ,
side_map   
)

Definition at line 103 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [11/14]

libMesh::SIDEMAP_ERROR ( ,
NEDELEC_ONE  ,
side_map   
)

Definition at line 107 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [12/14]

libMesh::SIDEMAP_ERROR ( ,
BERNSTEIN  ,
side_map   
)

Definition at line 112 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [13/14]

libMesh::SIDEMAP_ERROR ( ,
SZABAB  ,
side_map   
)

Definition at line 116 of file fe_boundary.C.

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

◆ SIDEMAP_ERROR() [14/14]

libMesh::SIDEMAP_ERROR ( ,
NEDELEC_ONE  ,
side_map   
)

Definition at line 132 of file fe_boundary.C.

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

◆ SIGN()

template<typename T >
T libMesh::SIGN ( a,
b 
)
inline

Definition at line 33 of file newton_solver.C.

References std::abs().

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

34 {
35  return b >= 0 ? std::abs(a) : -std::abs(a);
36 }
double abs(double 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().

135 {
136  // There is currently an issue with DofObjects not being properly
137  // reset if the mesh is not first repartitioned onto 1 processor
138  // *before* being repartitioned onto the desired number of
139  // processors. So, this is a workaround, but not a particularly
140  // onerous one.
141  mesh.partition(1);
142  mesh.partition(nsplits);
143 
144  processor_id_type my_num_chunks = 0;
145  processor_id_type my_first_chunk = 0;
146  chunking(mesh.comm().size(), mesh.comm().rank(), nsplits, my_num_chunks, my_first_chunk);
147 
148  auto cpr = libmesh_make_unique<CheckpointIO>(mesh);
149  cpr->current_processor_ids().clear();
150  for (processor_id_type i = my_first_chunk; i < my_first_chunk + my_num_chunks; i++)
151  cpr->current_processor_ids().push_back(i);
152  cpr->current_n_processors() = nsplits;
153  cpr->parallel() = true;
154  return cpr;
155 }
MeshBase & mesh
uint8_t processor_id_type
Definition: id_types.h:99

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

1057 {
1058 #if LIBMESH_DIM == 3
1059  return
1060  a(0)*(b(1)*c(2) - b(2)*c(1)) -
1061  a(1)*(b(0)*c(2) - b(2)*c(0)) +
1062  a(2)*(b(0)*c(1) - b(1)*c(0));
1063 #else
1064  return 0;
1065 #endif
1066 }

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

234 {
235 #ifdef LIBMESH_ENABLE_TRACEFILES
236  std::stringstream outname;
237  outname << "traceout_" << static_cast<std::size_t>(libMesh::global_processor_id()) << '_' << getpid() << ".txt";
238  std::ofstream traceout(outname.str().c_str(), std::ofstream::app);
239  libMesh::print_trace(traceout);
240 #endif
241 }
void print_trace(std::ostream &out_stream)
Definition: print_trace.C:196
processor_id_type global_processor_id()
Definition: libmesh_base.h:85

◆ 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

◆ 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

◆ 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, $ \sqrt{-1} $.

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

◆ 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

◆ 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

◆ warned_about_auto_ptr

bool libMesh::warned_about_auto_ptr

◆ zero