www.mooseframework.org
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
libMesh Namespace Reference

The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings. More...

Namespaces

 boostcopy
 
 DenseMatrices
 
 DofMap
 
 Elem
 
 ElemInternal
 
 ExodusII_IO_Helper
 
 FiniteElements
 
 GmshIO
 
 JacobiPolynomials
 
 libMeshPrivateData
 
 MacroFunctions
 
 mapvector
 
 MeshBase
 
 MeshRefinement
 
 MeshTools
 
 Nemesis
 
 NonlinearImplicitSystem
 
 OptimizationSystem
 
 Parallel
 
 Parameters
 
 PatchRecoveryErrorEstimator
 
 PetscNonlinearSolver
 
 Predicates
 
 QoISet
 
 Quality
 
 RBDataDeserialization
 
 RBDataSerialization
 
 RBParameters
 
 ReferenceElem
 
 SensitivityData
 
 Singleton
 
 SparsityPattern
 
 System
 
 SystemSubsetBySubdomain
 
 TensorTools
 
 TensorValue
 
 Threads
 
 Trees
 
 TriangleWrapper
 
 TriangulatorInterface
 
 Utility
 
 VariationalMeshSmoother
 
 vectormap
 
 VectorValue
 
 VTKIO
 
 WeightedPatchRecoveryErrorEstimator
 

Classes

class  AbaqusIO
 
class  AdaptiveTimeSolver
 
class  AdjointDofConstraintValues
 
class  AdjointRefinementEstimator
 
class  AdjointResidualErrorEstimator
 
class  AnalyticFunction
 
class  AztecLinearSolver
 
class  BasicOStreamProxy
 
class  BoundaryInfo
 
class  BoundaryMesh
 
class  BoundaryProjectSolution
 
class  BoundaryVolumeSolutionTransfer
 
class  BoundingBox
 
class  BuildProjectionList
 
struct  casting_compare
 
class  Cell
 
class  CentroidPartitioner
 
class  CheckpointIO
 
class  chunked_mapvector
 
struct  CompareDofObjectsByID
 
struct  CompareDofObjectsByPIDAndThenID
 
struct  CompareElemIdsByLevel
 
struct  CompareTypes
 
struct  CompareTypes< MetaPhysicL::DualNumber< T, D, asd >, MetaPhysicL::DualNumber< T, D, asd > >
 
struct  CompareTypes< MetaPhysicL::DualNumber< T, D, asd >, MetaPhysicL::DualNumber< T2, D2, asd > >
 
struct  CompareTypes< MetaPhysicL::DualNumber< T, D, asd >, T2 >
 
struct  CompareTypes< MetaPhysicL::DualNumber< T, T, asd >, MetaPhysicL::DualNumber< T2, T2, asd > >
 
struct  CompareTypes< MetaPhysicL::DualNumber< T, T, asd >, T2 >
 
struct  CompareTypes< MetaPhysicL::DynamicSparseNumberArray< T, IndexType >, T2 >
 
struct  CompareTypes< std::complex< T >, T >
 
struct  CompareTypes< T, MetaPhysicL::DualNumber< T2, D, asd > >
 
struct  CompareTypes< T, MetaPhysicL::DualNumber< T2, T2, asd > >
 
struct  CompareTypes< T, std::complex< T > >
 
struct  CompareTypes< T, T >
 
struct  CompareTypes< TypeVector< T >, TypeVector< T > >
 
struct  CompareTypes< TypeVector< T >, TypeVector< T2 > >
 
struct  CompareTypes< TypeVector< T >, VectorValue< T2 > >
 
struct  CompareTypes< VectorValue< T >, TypeVector< T2 > >
 
struct  CompareTypes< VectorValue< T >, VectorValue< T > >
 
struct  CompareTypes< VectorValue< T >, VectorValue< T2 > >
 
class  CompositeFEMFunction
 
class  CompositeFunction
 
class  CondensedEigenSystem
 
class  ConstCouplingAccessor
 
class  ConstCouplingRow
 
class  ConstCouplingRowConstIterator
 
class  ConstFEMFunction
 
class  ConstFunction
 
class  ConstParameterProxy
 
class  ConstTypeTensorColumn
 
class  ContinuationSystem
 
class  ConvergenceFailure
 
class  CouplingAccessor
 
class  CouplingMatrix
 
class  DefaultCoupling
 
class  DenseMatrix
 
class  DenseMatrixBase
 
class  DenseSubMatrix
 
class  DenseSubVector
 
class  DenseVector
 
class  DenseVectorBase
 
class  DGFEMContext
 
class  DiagonalMatrix
 
class  DiffContext
 
class  DifferentiablePhysics
 
class  DifferentiableQoI
 
class  DifferentiableSystem
 
class  DiffSolver
 
class  DirectSolutionTransfer
 
class  DirichletBoundaries
 
class  DirichletBoundary
 
class  DiscontinuityMeasure
 
class  DistributedMesh
 
class  DistributedVector
 
class  DofConstraints
 
class  DofConstraintValueMap
 
class  DofMap
 
class  DofObject
 
class  DSNAOutput
 
class  DSNAOutput< VectorValue< InnerOutput > >
 
class  DTKAdapter
 
class  DTKEvaluator
 
class  DTKSolutionTransfer
 
class  DynaIO
 
class  DynamicCastFailure
 
class  Edge
 
class  Edge2
 
class  Edge3
 
class  Edge4
 
class  EigenPreconditioner
 
class  EigenSolver
 
class  EigenSparseLinearSolver
 
class  EigenSparseMatrix
 
class  EigenSparseVector
 
class  EigenSystem
 
class  EigenTimeSolver
 
struct  EimPointData
 
class  Elem
 
class  ElemAssembly
 
class  ElemCutter
 
struct  ElemHashUtils
 
class  ElemSideBuilder
 
class  EnsightIO
 
class  EpetraMatrix
 
class  EpetraVector
 
class  EquationSystems
 
class  ErrorEstimator
 
class  ErrorVector
 
class  Euler2Solver
 
class  EulerSolver
 
class  ExactErrorEstimator
 
class  ExactSolution
 
class  ExodusHeaderInfo
 
class  ExodusII_IO
 
class  ExodusII_IO_Helper
 
class  ExplicitSystem
 
class  Face
 
class  Factory
 
class  FactoryImp
 
class  FastPoolAllocator
 
class  FE
 
class  FEAbstract
 
class  FEClough
 
class  FEComputeData
 
class  FEGenericBase
 
class  FEHermite
 
class  FEHierarchic
 
class  FEHierarchicVec
 
class  FEInterface
 
class  FEL2Hierarchic
 
class  FEL2HierarchicVec
 
class  FEL2Lagrange
 
class  FEL2LagrangeVec
 
class  FEL2RaviartThomas
 
class  FELagrange
 
class  FELagrangeVec
 
class  FEMap
 
class  FEMContext
 
class  FEMFunctionBase
 
class  FEMFunctionWrapper
 
class  FEMonomial
 
class  FEMonomialVec
 
class  FEMPhysics
 
class  FEMSystem
 
class  FENedelecOne
 
struct  FEOutputType
 
struct  FEOutputType< HIERARCHIC_VEC >
 
struct  FEOutputType< L2_HIERARCHIC_VEC >
 
struct  FEOutputType< L2_LAGRANGE_VEC >
 
struct  FEOutputType< L2_RAVIART_THOMAS >
 
struct  FEOutputType< LAGRANGE_VEC >
 
struct  FEOutputType< MONOMIAL_VEC >
 
struct  FEOutputType< NEDELEC_ONE >
 
struct  FEOutputType< RAVIART_THOMAS >
 
class  FERaviartThomas
 
class  FEScalar
 
class  FESubdivision
 
class  FETransformationBase
 
class  FEType
 
class  FEXYZ
 
class  FEXYZMap
 
class  FileError
 
class  FileHistoryData
 
class  FileSolutionHistory
 
class  FirstOrderUnsteadySolver
 
class  FloatingPointException
 
class  FrequencySystem
 
class  FroIO
 
class  FunctionBase
 
class  GenericProjector
 
class  GhostingFunctor
 
class  GhostPointNeighbors
 
class  GmshIO
 
class  GMVIO
 
class  GnuPlotIO
 
class  GradientMeshFunction
 
class  H1FETransformation
 
struct  hash
 
class  HCurlFETransformation
 
class  HDivFETransformation
 
class  Hex
 
class  Hex20
 
class  Hex27
 
class  Hex8
 
class  HilbertSFCPartitioner
 
class  HistoryData
 
class  HPCoarsenTest
 
class  HPSelector
 
class  HPSingularity
 
class  ImplicitSystem
 
class  InfCell
 
class  InfEdge2
 
class  InfElemBuilder
 
class  InfFE
 
class  InfFEBase
 
class  InfFEMap
 
class  InfFERadial
 
class  InfHex
 
class  InfHex16
 
class  InfHex18
 
class  InfHex8
 
class  InfPrism
 
class  InfPrism12
 
class  InfPrism6
 
class  InfQuad
 
class  InfQuad4
 
class  InfQuad6
 
class  InterMeshProjection
 
class  IntRange
 
class  InverseDistanceInterpolation
 
class  JumpErrorEstimator
 
class  KellyErrorEstimator
 
class  LaplaceMeshSmoother
 
class  LaplacianErrorEstimator
 
class  LaspackLinearSolver
 
class  LaspackMatrix
 
class  LaspackVector
 
class  LibMeshInit
 
class  LinearImplicitSystem
 
class  LinearPartitioner
 
class  LinearSolutionMonitor
 
class  LinearSolver
 
class  LocationMap
 
class  LogicError
 
class  LumpedMassMatrix
 
class  MappedSubdomainPartitioner
 
class  mapvector
 
class  MatlabIO
 
class  MatrixFillAction
 
class  MEDITIO
 
class  MemoryHistoryData
 
class  MemorySolutionHistory
 
class  Mesh
 
struct  mesh_inserter_iterator
 
class  MeshBase
 
class  MeshCommunication
 
class  MeshfreeInterpolation
 
class  MeshfreeSolutionTransfer
 
class  MeshFunction
 
class  MeshFunctionSolutionTransfer
 
class  MeshInput
 
class  MeshlessInterpolationFunction
 
class  MeshOutput
 
class  MeshRefinement
 
class  MeshSerializer
 
class  MeshSmoother
 
class  METIS_CSR_Graph
 
class  MetisPartitioner
 
class  MortonSFCPartitioner
 
class  NameBasedIO
 
class  Nemesis_IO
 
class  Nemesis_IO_Helper
 
class  NewmarkSolver
 
class  NewmarkSystem
 
class  NewtonSolver
 
class  NloptOptimizationSolver
 
class  Node
 
class  NodeConstraints
 
class  NodeElem
 
class  NonlinearImplicitSystem
 
class  NonlinearSolver
 
class  NoSolutionHistory
 
class  NotImplemented
 
class  NoxNonlinearSolver
 
struct  null_output_iterator
 
class  NumericVector
 
class  OFFIO
 
class  OldSolutionBase
 
class  OldSolutionCoefs
 
class  OldSolutionValue
 
class  OptimizationSolver
 
class  OptimizationSystem
 
class  OrderWrapper
 
class  ParallelMesh
 
class  ParallelObject
 
class  ParameterAccessor
 
class  ParameterMultiAccessor
 
class  ParameterMultiPointer
 
class  ParameterPointer
 
class  ParameterProxy
 
class  Parameters
 
class  ParameterVector
 
class  ParmetisHelper
 
class  ParmetisPartitioner
 
class  ParsedFEMFunction
 
class  ParsedFEMFunctionParameter
 
class  ParsedFunction
 
class  ParsedFunctionParameter
 
class  Partitioner
 
class  Patch
 
class  PatchRecoveryErrorEstimator
 
class  PerfData
 
struct  PerfItem
 
class  PerfLog
 
class  PerfMon
 
class  PeriodicBoundaries
 
class  PeriodicBoundary
 
class  PeriodicBoundaryBase
 
class  PetscDiffSolver
 
struct  PetscDMContext
 
class  PetscDMWrapper
 
class  PetscLinearSolver
 
class  PetscMatrix
 
class  PetscNonlinearSolver
 
class  PetscPreconditioner
 
class  PetscShellMatrix
 
class  PetscSolverException
 
class  PetscVector
 
class  Plane
 
class  PltLoader
 
class  Point
 
class  PointerToPointerIter
 
class  PointLocatorBase
 
class  PointLocatorNanoflann
 
class  PointLocatorTree
 
class  PointNeighborCoupling
 
class  Poly2TriTriangulator
 
class  PoolAllocator
 
class  PostscriptIO
 
class  Preconditioner
 
class  Prism
 
class  Prism15
 
class  Prism18
 
class  Prism20
 
class  Prism21
 
class  Prism6
 
class  Problem_Interface
 
class  Pyramid
 
class  Pyramid13
 
class  Pyramid14
 
class  Pyramid18
 
class  Pyramid5
 
class  QBase
 
class  QClough
 
class  QComposite
 
class  QConical
 
class  QGauss
 
class  QGaussLobatto
 
class  QGrid
 
class  QGrundmann_Moller
 
class  QJacobi
 
class  QMonomial
 
class  QNodal
 
class  QoISet
 
class  QSimpson
 
class  QTrap
 
class  Quad
 
class  Quad4
 
class  Quad8
 
class  Quad9
 
class  QuadShell4
 
class  QuadShell8
 
class  RadialBasisInterpolation
 
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
 
class  RBSCMConstruction
 
class  RBSCMEvaluation
 
class  RBTemporalDiscretization
 
class  RBTheta
 
class  RBThetaExpansion
 
struct  RealTraits
 
class  ReferenceCountedObject
 
class  ReferenceCounter
 
class  RefinementSelector
 
class  RemoteElem
 
class  ReplicatedMesh
 
class  ResidualContext
 
struct  ScalarTraits
 
struct  ScalarTraits< MetaPhysicL::DualNumber< T, D, asd > >
 
struct  ScalarTraits< MetaPhysicL::DynamicSparseNumberArray< T, IndexType > >
 
struct  ScalarTraits< std::complex< T > >
 
class  SecondOrderUnsteadySolver
 
class  SensitivityData
 
class  SerialMesh
 
class  SFCPartitioner
 
class  ShellMatrix
 
class  SiblingCoupling
 
class  Side
 
class  SideEdge
 
class  SimpleRange
 
class  Singleton
 
class  SlepcEigenSolver
 
class  SolutionHistory
 
class  SolutionTransfer
 
class  SolverConfiguration
 
class  SolverException
 
class  SparseMatrix
 
class  SparseShellMatrix
 
class  Sphere
 
class  StatisticsVector
 
class  SteadySolver
 
class  StoredRange
 
class  SubdomainPartitioner
 
class  SumShellMatrix
 
class  Surface
 
struct  SyncElementIntegers
 
struct  SyncLocalIDs
 
struct  SyncNodalPositions
 
struct  SyncRefinementFlags
 
struct  SyncSubdomainIds
 
class  System
 
class  SystemNorm
 
class  SystemSubset
 
class  SystemSubsetBySubdomain
 
class  TaoOptimizationSolver
 
class  TecplotIO
 
class  TensorShellMatrix
 
class  TensorValue
 
class  TestClass
 
class  Tet
 
class  Tet10
 
class  Tet14
 
class  Tet4
 
class  TetGenIO
 
class  TetGenMeshInterface
 
class  TetGenWrapper
 
class  TimeSolver
 
class  TopologyMap
 
class  TransientRBAssemblyExpansion
 
class  TransientRBConstruction
 
class  TransientRBEvaluation
 
class  TransientRBThetaExpansion
 
class  TransientSystem
 
class  Tree
 
class  TreeBase
 
class  TreeNode
 
class  Tri
 
class  Tri3
 
class  Tri3Subdivision
 
class  Tri6
 
class  Tri7
 
class  TriangleInterface
 
class  TriangulatorInterface
 
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
 
struct  TypeToSend
 
struct  TypeToSend< MetaPhysicL::DynamicSparseNumberArray< T, IndexType > >
 
class  TypeVector
 
struct  TypeVectorAttributes
 
class  TypeVectorOpFunction
 
class  UCDIO
 
class  UniformRefinementEstimator
 
class  UnsteadySolver
 
class  UnstructuredMesh
 
class  UNVIO
 
class  Variable
 
class  VariableGroup
 
class  VariationalMeshSmoother
 
struct  VectorizedEvalInput
 
class  vectormap
 
class  VectorOfNodesAdaptor
 
class  VectorSetAction
 
class  VectorValue
 
class  VTKIO
 
class  WeightedPatchRecoveryErrorEstimator
 
class  WendlandRBF
 
class  WrappedFunction
 
class  WrappedFunctor
 
struct  WrappedPetsc
 
class  Xdr
 
class  XdrIO
 
class  ZeroFunction
 

Typedefs

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 TestClass subdomain_id_type
 
typedef int8_t boundary_id_type
 
typedef uint8_t dof_id_type
 
typedef int8_t dof_id_signed_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 subdomain_id_type elemset_id_type
 
typedef std::complex< RealComplex
 
typedef std::complex< RealCOMPLEX
 
typedef Real Number
 
typedef FEGenericBase< RealFEBase
 
typedef TensorValue< NumberNumberTensorValue
 
typedef NumberTensorValue Tensor
 
typedef VectorValue< NumberNumberVectorValue
 
typedef NumberVectorValue Gradient
 
typedef VectorValue< RealRealVectorValue
 
typedef TensorValue< RealRealTensorValue
 
typedef RealVectorValue RealGradient
 
typedef RealTensorValue RealTensor
 
typedef FEGenericBase< RealGradientFEVectorBase
 
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 StoredRange< MeshBase::node_iterator, Node *> NodeRange
 
typedef StoredRange< MeshBase::const_node_iterator, const Node *> ConstNodeRange
 
typedef DistributedMesh DefaultMesh
 
typedef std::set< const Node *> connected_node_set_type
 
typedef int32_t eigen_idx_type
 
typedef Eigen::SparseMatrix< Number, Eigen::RowMajor, eigen_idx_typeEigenSM
 
typedef Eigen::Matrix< Number, Eigen::Dynamic, 1 > EigenSV
 
typedef typename tuple_n< Index, T >::template type<> tuple_of
 
typedef std::vector< RealRBParameter
 
typedef LinearImplicitSystem SteadyLinearSystem
 
typedef TransientSystem< LinearImplicitSystemTransientImplicitSystem
 
typedef TransientSystem< LinearImplicitSystemTransientLinearImplicitSystem
 
typedef TransientSystem< NonlinearImplicitSystemTransientNonlinearImplicitSystem
 
typedef TransientSystem< ExplicitSystemTransientExplicitSystem
 
typedef TransientSystem< SystemTransientBaseSystem
 
typedef TransientSystem< EigenSystemTransientEigenSystem
 
typedef BasicOStreamProxy OStreamProxy
 
typedef DynamicSparseNumberArray< Real, dof_id_typeDSNAN
 
typedef VectorValue< RealRealVectorValue
 
typedef FEGenericBase< RealFEBase
 
typedef FEGenericBase< VectorValue< Real > > FEVectorBase
 
template<typename T >
using UniquePtr = std::unique_ptr< T >
 
typedef TransientSystem< ExplicitSystemTransientExplicitSystem
 
typedef Eigen::Matrix< Real, Moose::dim, 1 > RealDIMValue
 
typedef Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
 
typedef Eigen::Matrix< Real, Eigen::Dynamic, Moose::dimRealVectorArrayValue
 
typedef Eigen::Matrix< Real, Eigen::Dynamic, Moose::dim *Moose::dimRealTensorArrayValue
 
typedef Eigen::Matrix< Real, Eigen::Dynamic, Eigen::Dynamic > RealEigenMatrix
 
typedef TensorValue< RealRealTensorValue
 

Enumerations

enum  VariableIndexing
 
enum  LinearConvergenceReason
 
enum  EigenSolverType
 
enum  EigenProblemType
 
enum  PositionOfSpectrum
 
enum  ElemQuality
 
enum  ElemType
 
enum  ElemMappingType
 
enum  ErrorEstimatorType
 
enum  FEFamily
 
enum  FEContinuity
 
enum  FEFieldType
 
enum  InfMapType
 
enum  IOPackage
 
enum  MatrixBuildType { MatrixBuildType::AUTOMATIC, MatrixBuildType::DIAGONAL }
 
enum  FEMNormType
 
enum  Order
 
enum  ParallelType
 
enum  PartitionerType
 
enum  PointLocatorType
 
enum  PreconditionerType
 
enum  QuadratureType
 
enum  SolverPackage
 
enum  SolverType
 
enum  SubsetSolveMode
 
enum  XdrMODE
 
enum  PetscMatrixType
 

Functions

bool initialized ()
 
bool closed ()
 
void enableFPE (bool on)
 
void enableSEGV (bool on)
 
bool on_command_line (std::string arg)
 
command_line_value (const std::string &, T)
 
command_line_value (const std::vector< std::string > &, T)
 
command_line_next (std::string name, T default_value)
 
void command_line_vector (const std::string &, std::vector< T > &)
 
std::vector< std::string > command_line_names ()
 
void add_command_line_name (const std::string &name)
 
void add_command_line_names (const GetPot &getpot)
 
SolverPackage default_solver_package ()
 
processor_id_type global_n_processors ()
 
processor_id_type global_processor_id ()
 
unsigned int n_threads ()
 
libmesh_real (T a)
 
libmesh_conj (T a)
 
libmesh_real (std::complex< T > a)
 
std::complex< T > libmesh_conj (std::complex< T > a)
 
bool libmesh_isnan (T x)
 
bool libmesh_isnan (std::complex< T > a)
 
bool libmesh_isinf (T x)
 
bool libmesh_isinf (std::complex< T > a)
 
void libmesh_ignore (const Args &...)
 
void libmesh_merge_move (T &target, T &source)
 
Tnew cast_ref (Told &oldvar)
 
Tnew cast_ptr (Told *oldvar)
 
Tnew libmesh_cast_ptr (Told *oldvar)
 
Tnew cast_int (Told oldvar)
 
Tnew libmesh_cast_int (Told oldvar)
 
void libmesh_version_stdout ()
 
int get_libmesh_version ()
 
std::string get_io_compatibility_version ()
 
void print_trace (std::ostream &out_stream=std::cerr)
 
std::string demangle (const char *name)
 
void write_traceout ()
 
OutputShape fe_fdm_deriv (const Elem *elem, const Order order, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level, OutputShape(*shape_func)(const Elem *, const Order, const unsigned int, const Point &, const bool))
 
OutputShape fe_fdm_deriv (const ElemType type, const Order order, const unsigned int i, const unsigned int j, const Point &p, OutputShape(*shape_func)(const ElemType, const Order, const unsigned int, const Point &))
 
OutputShape fe_fdm_second_deriv (const Elem *elem, const Order order, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level, OutputShape(*deriv_func)(const Elem *, const Order, const unsigned int, const unsigned int, const Point &, const bool))
 
OutputShape fe_fdm_second_deriv (const ElemType type, const Order order, const unsigned int i, const unsigned int j, const Point &p, OutputShape(*deriv_func)(const ElemType, const Order, const unsigned int, const unsigned int, const Point &))
 
void lagrange_nodal_soln (const Elem *elem, const Order order, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln, bool add_p_level=true)
 
unsigned int monomial_n_dofs (const ElemType t, const Order o)
 
void rational_fe_weighted_shapes (const Elem *elem, const FEType underlying_fe_type, std::vector< std::vector< Real >> &shapes, const std::vector< Point > &p, const bool add_p_level)
 
void rational_fe_weighted_shapes_derivs (const Elem *elem, const FEType fe_type, std::vector< std::vector< Real >> &shapes, std::vector< std::vector< std::vector< Real >>> &derivs, const std::vector< Point > &p, const bool add_p_level)
 
Real rational_fe_shape (const Elem &elem, const FEType underlying_fe_type, const unsigned int i, const Point &p, const bool add_p_level)
 
Real rational_fe_shape_deriv (const Elem &elem, const FEType underlying_fe_type, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level)
 
Real rational_fe_shape_second_deriv (const Elem &elem, const FEType underlying_fe_type, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level)
 
void rational_all_shapes (const Elem &elem, const FEType underlying_fe_type, const std::vector< Point > &p, std::vector< std::vector< Real >> &v, const bool add_p_level)
 
void rational_all_shape_derivs (const Elem &elem, const FEType underlying_fe_type, const std::vector< Point > &p, std::vector< std::vector< OutputShape >> *comps[3], const bool add_p_level)
 
Real fe_lagrange_1D_linear_shape (const unsigned int i, const Real xi)
 
Real fe_lagrange_1D_quadratic_shape (const unsigned int i, const Real xi)
 
Real fe_lagrange_1D_cubic_shape (const unsigned int i, const Real xi)
 
Real fe_lagrange_1D_shape (const Order order, const unsigned int i, const Real xi)
 
Real fe_lagrange_1D_linear_shape_deriv (const unsigned int i, const unsigned int libmesh_dbg_var(j), const Real)
 
Real fe_lagrange_1D_quadratic_shape_deriv (const unsigned int i, const unsigned int libmesh_dbg_var(j), const Real xi)
 
Real fe_lagrange_1D_cubic_shape_deriv (const unsigned int i, const unsigned int libmesh_dbg_var(j), const Real xi)
 
Real fe_lagrange_1D_shape_deriv (const Order order, const unsigned int i, const unsigned int j, const Real xi)
 
Real fe_lagrange_1D_quadratic_shape_second_deriv (const unsigned int i, const unsigned int libmesh_dbg_var(j), const Real)
 
Real fe_lagrange_1D_cubic_shape_second_deriv (const unsigned int i, const unsigned int libmesh_dbg_var(j), const Real xi)
 
Real fe_lagrange_1D_shape_second_deriv (const Order order, const unsigned int i, const unsigned int j, const Real xi)
 
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)
 
std::ostream & operator<< (std::ostream &os, const Elem &e)
 
std::ostream & operator<< (std::ostream &os, const Node &n)
 
std::unique_ptr< CheckpointIOsplit_mesh (MeshBase &mesh, processor_id_type nsplits)
 
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, const MeshBase *mesh=nullptr)
 
void reconnect_nodes (const std::set< const Elem *, CompareElemIdsByLevel > &connected_elements, connected_node_set_type &connected_nodes)
 
PetscScalar PS (T val)
 
PetscScalar * pPS (T *ptr)
 
const PetscScalar * pPS (const T *ptr)
 
PetscReal * pPR (T *ptr)
 
const PetscReal * pPR (const T *ptr)
 
PetscInt * numeric_petsc_cast (const numeric_index_type *p)
 
std::ostream & operator<< (std::ostream &os, const SparseMatrix< T > &m)
 
intnumeric_trilinos_cast (const numeric_index_type *p)
 
boostcopy::enable_if_c< ScalarTraits< Scalar >::value, TypeNTensor< N, typename CompareTypes< Scalar, T >::supertype > >::type operator* (const Scalar &, const TypeNTensor< N, T > &)
 
boostcopy::enable_if_c< ScalarTraits< Scalar >::value, TypeNTensor< N, typename CompareTypes< Scalar, T >::supertype > >::type operator/ (const Scalar &, const TypeNTensor< N, T > &)
 
boostcopy::enable_if_c< ScalarTraits< Scalar >::value, TypeTensor< typename CompareTypes< T, Scalar >::supertype > >::type operator* (const Scalar &factor, const TypeTensor< T > &t)
 
TypeVector< typename CompareTypes< T, T2 >::supertype > operator* (const TypeVector< T > &a, const TypeTensor< T2 > &b)
 
TypeTensor< typename CompareTypes< T, T2 >::supertype > outer_product (const TypeVector< T > &a, const TypeVector< T2 > &b)
 
boostcopy::enable_if_c< ScalarTraits< Scalar >::value, TypeVector< typename CompareTypes< T, Scalar >::supertype > >::type operator* (const Scalar &factor, const TypeVector< T > &v)
 
triple_product (const TypeVector< T > &a, const TypeVector< T > &b, const TypeVector< T > &c)
 
cross_norm_sq (const TypeVector< T > &b, const TypeVector< T > &c)
 
cross_norm (const TypeVector< T > &b, const TypeVector< T > &c)
 
TypeVector< typename CompareTypes< T, T2 >::supertype > outer_product (const T &a, const TypeVector< T2 > &b)
 
TypeVector< typename CompareTypes< T, T2 >::supertype > outer_product (const TypeVector< T > &a, const T2 &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_recalculate_monitor (SNES snes, PetscInt it, PetscReal norm, void *mctx)
 
PetscErrorCode libmesh_petsc_snes_monitor (SNES, PetscInt its, PetscReal fnorm, void *)
 
PetscErrorCode libmesh_petsc_snes_residual (SNES, Vec x, Vec r, void *ctx)
 
PetscErrorCode libmesh_petsc_snes_fd_residual (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_jacobian (SNES, Vec x, Mat jac, Mat pc, void *ctx)
 
PetscErrorCode libmesh_petsc_snes_precheck (SNESLineSearch, Vec X, Vec Y, PetscBool *changed, void *context)
 
PetscErrorCode libmesh_petsc_snes_postcheck (SNESLineSearch, Vec x, Vec y, Vec w, PetscBool *changed_y, PetscBool *changed_w, void *context)
 
PetscErrorCode libmesh_petsc_linesearch_shellfunc (SNESLineSearch linesearch, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_monitor (SNES, PetscInt its, PetscReal fnorm, void *)
 
PetscErrorCode __libmesh_petsc_snes_residual (SNES, Vec x, Vec r, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_fd_residual (SNES, Vec x, Vec r, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_mffd_interface (void *ctx, Vec x, Vec r)
 
PetscErrorCode __libmesh_petsc_snes_jacobian (SNES, Vec x, Mat jac, Mat pc, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_postcheck (SNESLineSearch, Vec x, Vec y, Vec w, PetscBool *changed_y, PetscBool *changed_w, void *context)
 
PetscErrorCode __libmesh_tao_objective (Tao tao, Vec x, PetscReal *objective, void *ctx)
 
PetscErrorCode __libmesh_tao_gradient (Tao tao, Vec x, Vec g, void *ctx)
 
PetscErrorCode __libmesh_tao_hessian (Tao tao, Vec x, Mat h, Mat pc, void *ctx)
 
PetscErrorCode __libmesh_tao_equality_constraints (Tao tao, Vec x, Vec ce, void *ctx)
 
PetscErrorCode __libmesh_tao_equality_constraints_jacobian (Tao tao, Vec x, Mat J, Mat Jpre, void *ctx)
 
PetscErrorCode __libmesh_tao_inequality_constraints (Tao tao, Vec x, Vec cineq, void *ctx)
 
PetscErrorCode __libmesh_tao_inequality_constraints_jacobian (Tao tao, Vec x, Mat J, Mat Jpre, void *ctx)
 
const TypeToSend< T >::type convert_to_send (const T &in)
 
void convert_from_receive (SendT &received, T &converted)
 
 ScalarTraits_true (char)
 
 ScalarTraits_true (short)
 
 ScalarTraits_true (int)
 
 ScalarTraits_true (long)
 
 ScalarTraits_true (unsigned char)
 
 ScalarTraits_true (float)
 
 ScalarTraits_true (double)
 
 ScalarTraits_true (Real)
 
 RealTraits_true (float)
 
 RealTraits_true (double)
 
 RealTraits_true (long 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)
 
 SUPERTYPE (unsigned char, Real)
 
 SUPERTYPE (char, Real)
 
 SUPERTYPE (short, Real)
 
 SUPERTYPE (int, Real)
 
 SUPERTYPE (float, Real)
 
 SUPERTYPE (double, Real)
 
 SUPERTYPE (long double, Real)
 
auto index_range (const T &sizable)
 
IntRange< numeric_index_typeindex_range (const NumericVector< T > &vec)
 
IntRange< T > make_range (T beg, T end)
 
IntRange< T > make_range (T end)
 
void print_helper (std::ostream &os, const P *param)
 
void print_helper (std::ostream &os, const std::vector< P > *param)
 
void print_helper (std::ostream &os, const std::vector< std::vector< P >> *param)
 
void print_helper (std::ostream &os, const std::vector< std::vector< std::vector< P >>> *param)
 
void print_helper (std::ostream &os, const std::map< P1, P2, C, A > *param)
 
std::ostream & operator<< (std::ostream &os, const Parameters &p)
 
void print_helper (std::ostream &os, const char *param)
 
void print_helper (std::ostream &os, const unsigned char *param)
 
SimpleRange< IndexType > as_range (const std::pair< IndexType, IndexType > &p)
 
SimpleRange< IndexType > as_range (const IndexType &first, const IndexType &second)
 
bool warned_about_auto_ptr (false)
 
const Number imaginary (0., 1.)
 
void libmesh_terminate_handler ()
 
template LIBMESH_EXPORT unsigned char command_line_value< unsigned char > (const std::string &, unsigned char)
 
template LIBMESH_EXPORT unsigned short command_line_value< unsigned short > (const std::string &, unsigned short)
 
template LIBMESH_EXPORT unsigned int command_line_value< unsigned int > (const std::string &, unsigned int)
 
template LIBMESH_EXPORT char command_line_value< char > (const std::string &, char)
 
template LIBMESH_EXPORT short command_line_value< short > (const std::string &, short)
 
template LIBMESH_EXPORT int command_line_value< int > (const std::string &, int)
 
template LIBMESH_EXPORT float command_line_value< float > (const std::string &, float)
 
template LIBMESH_EXPORT double command_line_value< double > (const std::string &, double)
 
template LIBMESH_EXPORT long double command_line_value< long double > (const std::string &, long double)
 
template LIBMESH_EXPORT std::string command_line_value< std::string > (const std::string &, std::string)
 
template LIBMESH_EXPORT unsigned char command_line_value< unsigned char > (const std::vector< std::string > &, unsigned char)
 
template LIBMESH_EXPORT unsigned short command_line_value< unsigned short > (const std::vector< std::string > &, unsigned short)
 
template LIBMESH_EXPORT unsigned int command_line_value< unsigned int > (const std::vector< std::string > &, unsigned int)
 
template LIBMESH_EXPORT char command_line_value< char > (const std::vector< std::string > &, char)
 
template LIBMESH_EXPORT short command_line_value< short > (const std::vector< std::string > &, short)
 
template LIBMESH_EXPORT int command_line_value< int > (const std::vector< std::string > &, int)
 
template LIBMESH_EXPORT float command_line_value< float > (const std::vector< std::string > &, float)
 
template LIBMESH_EXPORT double command_line_value< double > (const std::vector< std::string > &, double)
 
template LIBMESH_EXPORT long double command_line_value< long double > (const std::vector< std::string > &, long double)
 
template LIBMESH_EXPORT std::string command_line_value< std::string > (const std::vector< std::string > &, std::string)
 
template LIBMESH_EXPORT unsigned char command_line_next< unsigned char > (std::string, unsigned char)
 
template LIBMESH_EXPORT unsigned short command_line_next< unsigned short > (std::string, unsigned short)
 
template LIBMESH_EXPORT unsigned int command_line_next< unsigned int > (std::string, unsigned int)
 
template LIBMESH_EXPORT char command_line_next< char > (std::string, char)
 
template LIBMESH_EXPORT short command_line_next< short > (std::string, short)
 
template LIBMESH_EXPORT int command_line_next< int > (std::string, int)
 
template LIBMESH_EXPORT float command_line_next< float > (std::string, float)
 
template LIBMESH_EXPORT double command_line_next< double > (std::string, double)
 
template LIBMESH_EXPORT long double command_line_next< long double > (std::string, long double)
 
template LIBMESH_EXPORT std::string command_line_next< std::string > (std::string, std::string)
 
template LIBMESH_EXPORT void command_line_vector< unsigned char > (const std::string &, std::vector< unsigned char > &)
 
template LIBMESH_EXPORT void command_line_vector< unsigned short > (const std::string &, std::vector< unsigned short > &)
 
template LIBMESH_EXPORT void command_line_vector< unsigned int > (const std::string &, std::vector< unsigned int > &)
 
template LIBMESH_EXPORT void command_line_vector< char > (const std::string &, std::vector< char > &)
 
template LIBMESH_EXPORT void command_line_vector< short > (const std::string &, std::vector< short > &)
 
template LIBMESH_EXPORT void command_line_vector< int > (const std::string &, std::vector< int > &)
 
template LIBMESH_EXPORT void command_line_vector< float > (const std::string &, std::vector< float > &)
 
template LIBMESH_EXPORT void command_line_vector< double > (const std::string &, std::vector< double > &)
 
template LIBMESH_EXPORT void command_line_vector< long double > (const std::string &, std::vector< long double > &)
 
template LIBMESH_EXPORT Real command_line_value< Real > (const std::string &, Real)
 
template LIBMESH_EXPORT Real command_line_value< Real > (const std::vector< std::string > &, Real)
 
template LIBMESH_EXPORT Real command_line_next< Real > (std::string, Real)
 
template LIBMESH_EXPORT void command_line_vector< Real > (const std::string &, std::vector< Real > &)
 
template Real fe_fdm_deriv< Real > (const Elem *, const Order, const unsigned int, const unsigned int, const Point &, const bool, Real(*shape_func)(const Elem *, const Order, const unsigned int, const Point &, const bool))
 
template Real fe_fdm_deriv< Real > (const ElemType, const Order, const unsigned int, const unsigned int, const Point &, Real(*shape_func)(const ElemType, const Order, const unsigned int, const Point &))
 
template RealGradient fe_fdm_deriv< RealGradient > (const Elem *, const Order, const unsigned int, const unsigned int, const Point &, const bool, RealGradient(*shape_func)(const Elem *, const Order, const unsigned int, const Point &, const bool))
 
template Real fe_fdm_second_deriv< Real > (const ElemType, const Order, const unsigned int, const unsigned int, const Point &, Real(*shape_func)(const ElemType, const Order, const unsigned int, const unsigned int, const Point &))
 
template Real fe_fdm_second_deriv< Real > (const Elem *, const Order, const unsigned int, const unsigned int, const Point &, const bool, Real(*shape_func)(const Elem *, const Order, const unsigned int, const unsigned int, const Point &, const bool))
 
template RealGradient fe_fdm_second_deriv< RealGradient > (const Elem *, const Order, const unsigned int, const unsigned int, const Point &, const bool, RealGradient(*shape_func)(const Elem *, const Order, const unsigned int, const unsigned int, const Point &, const bool))
 
 INSTANTIATE_FE (0)
 
 INSTANTIATE_FE (1)
 
 INSTANTIATE_FE (2)
 
 INSTANTIATE_FE (3)
 
template LIBMESH_EXPORT void rational_all_shape_derivs< double > (const Elem &elem, const FEType underlying_fe_type, const std::vector< Point > &p, std::vector< std::vector< Real >> *comps[3], const bool add_p_level)
 
std::ostream & operator<< (std::ostream &os, const FEAbstract &fe)
 
 LIBMESH_FE_NODAL_SOLN (BERNSTEIN, bernstein_nodal_soln)
 
 LIBMESH_DEFAULT_VECTORIZED_FE (template<>Real FE< 0, BERNSTEIN)
 
 LIBMESH_ERRORS_IN_LOW_D (CLOUGH)
 
 SIDEMAP_ERROR (1, NEDELEC_ONE, side_map)
 
 REINIT_ERROR (1, RAVIART_THOMAS, reinit)
 
 SIDEMAP_ERROR (1, RAVIART_THOMAS, side_map)
 
 REINIT_ERROR (1, L2_RAVIART_THOMAS, reinit)
 
 SIDEMAP_ERROR (1, L2_RAVIART_THOMAS, side_map)
 
 LIBMESH_FE_NODAL_SOLN (CLOUGH, clough_nodal_soln)
 
 LIBMESH_FE_NODAL_SOLN (HERMITE, hermite_nodal_soln)
 
 LIBMESH_DEFAULT_VECTORIZED_FE (1, HERMITE)
 
 LIBMESH_FE_NODAL_SOLN (HIERARCHIC, hierarchic_nodal_soln)
 
 LIBMESH_DEFAULT_VECTORIZED_FE (0, HIERARCHIC_VEC)
 
 LIBMESH_FE_SIDE_NODAL_SOLN (HIERARCHIC_VEC)
 
 LIBMESH_FE_SIDE_NODAL_SOLN (L2_HIERARCHIC_VEC)
 
 LIBMESH_FE_NODAL_SOLN (L2_HIERARCHIC, l2_hierarchic_nodal_soln)
 
 LIBMESH_FE_NODAL_SOLN (L2_LAGRANGE, lagrange_nodal_soln)
 
 LIBMESH_FE_NODAL_SOLN (LAGRANGE, lagrange_nodal_soln)
 
 LIBMESH_DEFAULT_VECTORIZED_FE (0, LAGRANGE_VEC)
 
 LIBMESH_FE_SIDE_NODAL_SOLN (LAGRANGE_VEC)
 
 LIBMESH_FE_SIDE_NODAL_SOLN (L2_LAGRANGE_VEC)
 
 LIBMESH_FE_NODAL_SOLN (MONOMIAL, monomial_nodal_soln)
 
 LIBMESH_DEFAULT_VECTORIZED_FE (0, MONOMIAL_VEC)
 
 LIBMESH_FE_SIDE_NODAL_SOLN (MONOMIAL_VEC)
 
 LIBMESH_DEFAULT_VECTORIZED_FE (0, NEDELEC_ONE)
 
 LIBMESH_FE_SIDE_NODAL_SOLN (NEDELEC_ONE)
 
 LIBMESH_FE_NODAL_SOLN (RATIONAL_BERNSTEIN, rational_nodal_soln)
 
 LIBMESH_DEFAULT_VECTORIZED_FE (0, RAVIART_THOMAS)
 
 LIBMESH_FE_SIDE_NODAL_SOLN (RAVIART_THOMAS)
 
bool orientation (std::array< Point, N > &arr)
 
 LIBMESH_FE_NODAL_SOLN (SCALAR, scalar_nodal_soln)
 
 LIBMESH_FE_NODAL_SOLN (SIDE_HIERARCHIC, side_hierarchic_nodal_soln)
 
 LIBMESH_DEFAULT_VECTORIZED_FE (2, SUBDIVISION)
 
 LIBMESH_FE_NODAL_SOLN (SZABAB, szabab_nodal_soln)
 
 LIBMESH_FE_NODAL_SOLN (XYZ, xyz_nodal_soln)
 
 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, void, compute_face_functions())
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, compute_face_functions())
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, compute_face_functions())
 
 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(const FEType &, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, n_dofs(const FEType &, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, n_dofs(const FEType &, const Elem *))
 
 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_per_elem(const FEType &, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, n_dofs_per_elem(const FEType &, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, n_dofs_per_elem(const FEType &, const Elem *))
 
 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, unsigned int, n_dofs_at_node(const FEType &, const Elem *, const unsigned int))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, n_dofs_at_node(const FEType &, const Elem *, const unsigned int))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, n_dofs_at_node(const FEType &, const Elem *, 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_shape_indices(const FEType &, const Elem *, const unsigned int, unsigned int &, unsigned int &))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, compute_shape_indices(const FEType &, const Elem *, const unsigned int, unsigned int &, unsigned int &))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, compute_shape_indices(const FEType &, const Elem *, 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 Elem *, const unsigned int, const Point &, const bool))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Real, shape(const FEType, const Elem *, const unsigned int, const Point &, const bool))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Real, shape(const FEType, const Elem *, const unsigned int, const Point &, const bool))
 
 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, Real, shape_deriv(const FEType &, const Elem *, const unsigned int, const unsigned int, const Point &))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Real, shape_deriv(const FEType &, const Elem *, const unsigned int, const unsigned int, const Point &))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Real, shape_deriv(const FEType &, const Elem *, const unsigned int, const unsigned int, const Point &))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Real, shape_deriv(const FEType &, const ElemType, const unsigned int, const unsigned int, const Point &))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Real, shape_deriv(const FEType &, const ElemType, const unsigned int, const unsigned int, const Point &))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Real, shape_deriv(const FEType &, const ElemType, const unsigned int, const unsigned int, const Point &))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Real, shape_deriv(const FEType, const Elem *, const unsigned int, const unsigned int, const Point &, const bool))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Real, shape_deriv(const FEType, const Elem *, const unsigned int, const unsigned int, const Point &, const bool))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Real, shape_deriv(const FEType, const Elem *, const unsigned int, const unsigned int, const Point &, const bool))
 
 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 > &))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, inf_compute_constraints(DofConstraints &, DofMap &, const unsigned int, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, inf_compute_constraints(DofConstraints &, DofMap &, const unsigned int, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, inf_compute_constraints(DofConstraints &, DofMap &, const unsigned int, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, inf_compute_node_constraints(NodeConstraints &constraints, const Elem *elem))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, inf_compute_node_constraints(NodeConstraints &constraints, const Elem *elem))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, inf_compute_node_constraints(NodeConstraints &constraints, const Elem *elem))
 
bool is_between (Real min, Real check, Real max)
 
std::ostream & operator<< (std::ostream &os, const MeshBase &m)
 
template LIBMESH_EXPORT 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 LIBMESH_EXPORT 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 LIBMESH_EXPORT 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 LIBMESH_EXPORT 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 LIBMESH_EXPORT 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)
 
std::ostream & operator<< (std::ostream &os, const MeshfreeInterpolation &mfi)
 
SIGN (T a, T b)
 
PetscErrorCode __libmesh_petsc_diff_solver_monitor (SNES snes, PetscInt its, PetscReal fnorm, void *ctx)
 
PetscErrorCode __libmesh_petsc_diff_solver_residual (SNES, Vec x, Vec r, void *ctx)
 
PetscErrorCode __libmesh_petsc_diff_solver_jacobian (SNES, Vec x, Mat libmesh_dbg_var(j), Mat pc, void *ctx)
 
DiffSolver::SolveResult convert_solve_result (SNESConvergedReason r)
 
PetscErrorCode libmesh_petsc_DMCreateSubDM (DM dm, PetscInt numFields, PetscInt fields[], IS *is, DM *subdm) PetscErrorCode libmesh_petsc_DMCreateSubDM(DM dm
 
 CHKERRQ (ierr)
 
 libmesh_assert (ctx)
 
 if (subdm)
 
PetscErrorCode libmesh_petsc_DMRefine (DM dmc, MPI_Comm, DM *dmf)
 
PetscErrorCode libmesh_petsc_DMCoarsen (DM dmf, MPI_Comm, DM *dmc)
 
PetscErrorCode libmesh_petsc_DMCreateInterpolation (DM dmc, DM dmf, Mat *mat, Vec *vec)
 
PetscErrorCode libmesh_petsc_DMCreateRestriction (DM dmc, DM dmf, Mat *mat)
 
PetscErrorCode libmesh_petsc_preconditioner_setup (PC pc)
 
PetscErrorCode libmesh_petsc_preconditioner_apply (PC pc, 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)
 
std::ostream & operator<< (std::ostream &os, const EquationSystems &es)
 
const std::vector< std::pair< IndexType, T > > convert_to_send (MetaPhysicL::DynamicSparseNumberArray< T, IndexType > &in)
 
void convert_from_receive (SendT &received, MetaPhysicL::DynamicSparseNumberArray< T, IndexType > &converted)
 
template LIBMESH_EXPORT void Xdr::data< std::complex< float > > (std::complex< float > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::complex< double > > (std::complex< double > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::complex< long double > > (std::complex< long double > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::string > (std::string &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< int > > (std::vector< int > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< unsigned int > > (std::vector< unsigned int > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< short int > > (std::vector< short int > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< unsigned short int > > (std::vector< unsigned short int > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< long int > > (std::vector< long int > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< long long > > (std::vector< long long > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< unsigned long int > > (std::vector< unsigned long int > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< unsigned long long > > (std::vector< unsigned long long > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< char > > (std::vector< char > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< signed char > > (std::vector< signed char > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< unsigned char > > (std::vector< unsigned char > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< float > > (std::vector< float > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< double > > (std::vector< double > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< long double > > (std::vector< long double > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< std::complex< float > > > (std::vector< std::complex< float >> &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< std::complex< double > > > (std::vector< std::complex< double >> &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< std::complex< long double > > > (std::vector< std::complex< long double >> &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< std::string > > (std::vector< std::string > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::complex< Real > > (std::complex< Real > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< Real > > (std::vector< Real > &, std::string_view)
 
template LIBMESH_EXPORT void Xdr::data< std::vector< std::complex< Real > > > (std::vector< std::complex< Real >> &, std::string_view)
 
void to_json (nlohmann::json &json, const Point &p)
 
void to_json (nlohmann::json &json, const DenseVector< Real > &vector)
 
void to_json (nlohmann::json &json, const DenseMatrix< Real > &matrix)
 
template<>
void print_helper (std::ostream &os, const Moose::RelationshipManagerType *param)
 

Variables

DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
 
DIE A HORRIBLE DEATH HERE typedef float ErrorVectorReal
 
 SYSTEM_VARIABLE_ORDER
 
 LOCAL_VARIABLE_ORDER
 
 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
 
 POWER
 
 LAPACK
 
 SUBSPACE
 
 ARNOLDI
 
 LANCZOS
 
 KRYLOVSCHUR
 
 INVALID_EIGENSOLVER
 
 NHEP
 
 HEP
 
 GNHEP
 
 GHEP
 
 GHIEP
 
 INVALID_EIGENPROBLEMTYPE
 
 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
 
 ASPECT_RATIO
 
 SKEW
 
 SHEAR
 
 SHAPE
 
 MAX_ANGLE
 
 MIN_ANGLE
 
 CONDITION
 
 DISTORTION
 
 TAPER
 
 WARP
 
 STRETCH
 
 DIAGONAL
 
 ASPECT_RATIO_BETA
 
 ASPECT_RATIO_GAMMA
 
 SIZE
 
 JACOBIAN
 
 TWIST
 
 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
 
 TRI7
 
 TET14
 
 PRISM20
 
 PRISM21
 
 PYRAMID18
 
 INVALID_ELEM
 
 LAGRANGE_MAP
 
 RATIONAL_BERNSTEIN_MAP
 
 INVALID_MAP
 
 INVALID
 
 ADJOINT_REFINEMENT
 
 ADJOINT_RESIDUAL
 
 DISCONTINUITY_MEASURE
 
 EXACT
 
 KELLY
 
 LAPLACIAN
 
 PATCH_RECOVERY
 
 WEIGHTED_PATCH_RECOVERY
 
 UNIFORM_REFINEMENT
 
 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
 
 MONOMIAL_VEC
 
 RAVIART_THOMAS
 
 L2_RAVIART_THOMAS
 
 L2_LAGRANGE_VEC
 
 HIERARCHIC_VEC
 
 L2_HIERARCHIC_VEC
 
 RATIONAL_BERNSTEIN
 
 SIDE_HIERARCHIC
 
 INVALID_FE
 
 DISCONTINUOUS
 
 C_ZERO
 
 C_ONE
 
 H_CURL
 
 H_DIV
 
 SIDE_DISCONTINUOUS
 
 TYPE_SCALAR
 
 TYPE_VECTOR
 
 CARTESIAN
 
 SPHERICAL
 
 ELLIPSOIDAL
 
 INVALID_INF_MAP
 
 TECPLOT
 
 GMV
 
 GMSH
 
 VTK
 
 DIVA
 
 TETGEN
 
 UCD
 
 LIBMESH
 
 INVALID_IO_PACKAGE
 
 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
 
 CONSTANT
 
 FIRST
 
 SECOND
 
 THIRD
 
 FOURTH
 
 FIFTH
 
 SIXTH
 
 SEVENTH
 
 EIGHTH
 
 NINTH
 
 TENTH
 
 ELEVENTH
 
 TWELFTH
 
 THIRTEENTH
 
 FOURTEENTH
 
 FIFTEENTH
 
 SIXTEENTH
 
 SEVENTEENTH
 
 EIGHTTEENTH
 
 EIGHTEENTH
 
 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
 
 AUTOMATIC
 
 AUTOMATIC
 
 SERIAL
 
 PARALLEL
 
 GHOSTED
 
 INVALID_PARALLELIZATION
 
 CENTROID_PARTITIONER
 
 LINEAR_PARTITIONER
 
 SFC_PARTITIONER
 
 HILBERT_SFC_PARTITIONER
 
 MORTON_SFC_PARTITIONER
 
 METIS_PARTITIONER
 
 PARMETIS_PARTITIONER
 
 SUBDOMAIN_PARTITIONER
 
 MAPPED_SUBDOMAIN_PARTITIONER
 
 INVALID_PARTITIONER
 
 TREE
 
 TREE_ELEMENTS
 
 TREE_LOCAL_ELEMENTS
 
 NANOFLANN
 
 INVALID_LOCATOR
 
 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
 
 SVD_PRECOND
 
 INVALID_PRECONDITIONER
 
 QGAUSS
 
 QJACOBI_1_0
 
 QJACOBI_2_0
 
 QSIMPSON
 
 QTRAP
 
 QGRID
 
 QGRUNDMANN_MOLLER
 
 QMONOMIAL
 
 QCONICAL
 
 QGAUSS_LOBATTO
 
 QCLOUGH
 
 QCOMPOSITE
 
 QNODAL
 
 INVALID_Q_RULE
 
 PETSC_SOLVERS
 
 TRILINOS_SOLVERS
 
 LASPACK_SOLVERS
 
 SLEPC_SOLVERS
 
 EIGEN_SOLVERS
 
 NLOPT_SOLVERS
 
 INVALID_SOLVER_PACKAGE
 
 CG
 
 CGN
 
 CGS
 
 CR
 
 QMR
 
 TCQMR
 
 TFQMR
 
 BICG
 
 BICGSTAB
 
 MINRES
 
 GMRES
 
 LSQR
 
 JACOBI
 
 SOR_FORWARD
 
 SOR_BACKWARD
 
 SSOR
 
 RICHARDSON
 
 CHEBYSHEV
 
 SPARSELU
 
 INVALID_SOLVER
 
 SUBSET_ZERO
 
 SUBSET_COPY_RHS
 
 SUBSET_DONT_TOUCH
 
 UNKNOWN
 
 ENCODE
 
 DECODE
 
 WRITE
 
 READ
 
 AIJ
 
 HYPRE
 
FactoryImp< ExampleOneFunction, FunctionBase< Number > > example_one_factory ("example_one")
 
OStreamProxy out (std::cout)
 
OStreamProxy err (std::cerr)
 
PerfLog perflog ("libMesh", #ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING true #else false #endif)
 
FactoryImp< ExampleOneFunction, FunctionBase< Number > > example_one_factory ("example_one")
 
const Number imaginary
 
const Real pi
 
const Number zero
 
const unsigned int invalid_uint
 
const int invalid_int
 
OStreamProxy out
 
OStreamProxy err
 
static constexpr Real TOLERANCE
 
MPI_Comm GLOBAL_COMM_WORLD
 
bool warned_about_auto_ptr
 
constexpr std::false_type always_false
 
PerfLog perflog
 
const RemoteElemremote_elem
 
const unsigned char triangular_number_row []
 
const unsigned char triangular_number_column []
 
const unsigned char square_number_row []
 
const unsigned char square_number_column []
 
const unsigned char cube_number_row []
 
const unsigned char cube_number_column []
 
const unsigned char cube_number_page []
 
const unsigned char tetrahedral_number_row []
 
const unsigned char tetrahedral_number_column []
 
const unsigned char tetrahedral_number_page []
 
const unsigned char prism_number_triangle []
 
const unsigned char prism_number_page []
 
MPI_Errhandler libmesh_errhandler
 
std::terminate_handler old_terminate_handler
 
 INSTANTIATE_SUBDIVISION_FE
 
template class LIBMESH_EXPORT FEGenericBase< Real >
 
template class LIBMESH_EXPORT FEGenericBase< RealGradient >
 
 INSTANTIATE_SUBDIVISION_MAPS
 
template class LIBMESH_EXPORT FETransformationBase< Real >
 
template class LIBMESH_EXPORT FETransformationBase< RealGradient >
 
template class LIBMESH_EXPORT FEXYZ< 2 >
 
template class LIBMESH_EXPORT FEXYZ< 3 >
 
template class LIBMESH_EXPORT H1FETransformation< Real >
 
template class LIBMESH_EXPORT H1FETransformation< RealGradient >
 
template class LIBMESH_EXPORT HCurlFETransformation< RealGradient >
 
template class LIBMESH_EXPORT HDivFETransformation< RealGradient >
 
Threads::spin_mutex parent_indices_mutex
 
Threads::spin_mutex parent_bracketing_nodes_mutex
 
template class LIBMESH_EXPORT MeshOutput< MeshBase >
 
template class LIBMESH_EXPORT MeshOutput< UnstructuredMesh >
 
template class LIBMESH_EXPORT MeshOutput< DistributedMesh >
 
template class LIBMESH_EXPORT DenseMatrix< Real >
 
template class LIBMESH_EXPORT DenseMatrix< Complex >
 
template class LIBMESH_EXPORT DenseMatrixBase< Real >
 
template class LIBMESH_EXPORT DenseMatrixBase< Complex >
 
template class LIBMESH_EXPORT DenseSubMatrix< Real >
 
template class LIBMESH_EXPORT DenseSubMatrix< Complex >
 
template class LIBMESH_EXPORT DenseSubVector< Real >
 
template class LIBMESH_EXPORT DenseSubVector< Complex >
 
template class LIBMESH_EXPORT DenseVector< Real >
 
template class LIBMESH_EXPORT DenseVector< Complex >
 
template class LIBMESH_EXPORT DenseVectorBase< Real >
 
template class LIBMESH_EXPORT DenseVectorBase< Complex >
 
template class LIBMESH_EXPORT DiagonalMatrix< Number >
 
template class LIBMESH_EXPORT DistributedVector< Number >
 
template class LIBMESH_EXPORT EigenPreconditioner< Number >
 
template class LIBMESH_EXPORT EigenSparseMatrix< Number >
 
template class LIBMESH_EXPORT EigenSparseVector< Number >
 
template class LIBMESH_EXPORT LaspackMatrix< Number >
 
template class LIBMESH_EXPORT LaspackVector< Number >
 
template class LIBMESH_EXPORT LumpedMassMatrix< Number >
 
template class LIBMESH_EXPORT NumericVector< Number >
 
template class LIBMESH_EXPORT PetscMatrix< Number >
 
template class LIBMESH_EXPORT PetscPreconditioner< Number >
 
template class LIBMESH_EXPORT PetscShellMatrix< Number >
 
template class LIBMESH_EXPORT PetscVector< Number >
 
template class LIBMESH_EXPORT Preconditioner< Number >
 
template class LIBMESH_EXPORT ShellMatrix< Number >
 
template class LIBMESH_EXPORT SparseMatrix< Number >
 
template class LIBMESH_EXPORT SparseShellMatrix< Number >
 
template class LIBMESH_EXPORT SumShellMatrix< Number >
 
template class LIBMESH_EXPORT TensorShellMatrix< Number >
 
template class LIBMESH_EXPORT EpetraMatrix< Number >
 
template class LIBMESH_EXPORT EpetraVector< Number >
 
template class LIBMESH_EXPORT TrilinosPreconditioner< Number >
 
template class LIBMESH_EXPORT TypeTensor< Real >
 
template class LIBMESH_EXPORT TypeTensor< Complex >
 
template class LIBMESH_EXPORT TypeVector< Real >
 
template class LIBMESH_EXPORT TypeVector< Complex >
 
const unsigned int MIN_ELEM_PER_PROC
 
template class LIBMESH_EXPORT QComposite< QGauss >
 
template class LIBMESH_EXPORT QComposite< QTrap >
 
template class LIBMESH_EXPORT QComposite< QSimpson >
 
template class LIBMESH_EXPORT RBConstructionBase< CondensedEigenSystem >
 
template class LIBMESH_EXPORT RBConstructionBase< LinearImplicitSystem >
 
template class LIBMESH_EXPORT RBConstructionBase< System >
 
template class LIBMESH_EXPORT InverseDistanceInterpolation< 1 >
 
template class LIBMESH_EXPORT InverseDistanceInterpolation< 2 >
 
template class LIBMESH_EXPORT InverseDistanceInterpolation< 3 >
 
template class LIBMESH_EXPORT RadialBasisInterpolation< 3, WendlandRBF< 3, 0 > >
 
template class LIBMESH_EXPORT RadialBasisInterpolation< 3, WendlandRBF< 3, 2 > >
 
template class LIBMESH_EXPORT RadialBasisInterpolation< 3, WendlandRBF< 3, 4 > >
 
template class LIBMESH_EXPORT RadialBasisInterpolation< 3, WendlandRBF< 3, 8 > >
 
template class LIBMESH_EXPORT EigenSolver< Number >
 
template class LIBMESH_EXPORT EigenSparseLinearSolver< Number >
 
template class LIBMESH_EXPORT LaspackLinearSolver< Number >
 
template class LIBMESH_EXPORT LinearSolver< Number >
 
template class LIBMESH_EXPORT NloptOptimizationSolver< Number >
 
template class LIBMESH_EXPORT NonlinearSolver< Number >
 
template class LIBMESH_EXPORT OptimizationSolver< Number >
 
PetscErrorCode PetscInt numFields
 
PetscErrorCode PetscInt const PetscInt fields []
 
PetscErrorCode PetscInt const PetscInt IS * is
 
PetscErrorCode PetscInt const PetscInt IS DM * subdm
 
voidctx
 
 ierr
 
PetscDMContextp_ctx
 
 return
 
template class LIBMESH_EXPORT PetscLinearSolver< Number >
 
template class LIBMESH_EXPORT PetscNonlinearSolver< Number >
 
template class LIBMESH_EXPORT SlepcEigenSolver< Number >
 
template class LIBMESH_EXPORT TaoOptimizationSolver< Number >
 
template class LIBMESH_EXPORT AztecLinearSolver< Number >
 
template class LIBMESH_EXPORT NoxNonlinearSolver< Number >
 
template class LIBMESH_EXPORT TransientSystem< LinearImplicitSystem >
 
template class LIBMESH_EXPORT TransientSystem< NonlinearImplicitSystem >
 
template class LIBMESH_EXPORT TransientSystem< ExplicitSystem >
 
template class LIBMESH_EXPORT TransientSystem< System >
 
template class LIBMESH_EXPORT TransientSystem< RBConstruction >
 
template class LIBMESH_EXPORT TransientSystem< EigenSystem >
 
template class LIBMESH_EXPORT LocationMap< Elem >
 
template class LIBMESH_EXPORT LocationMap< Node >
 
template class LIBMESH_EXPORT StatisticsVector< float >
 
template class LIBMESH_EXPORT StatisticsVector< double >
 
template class LIBMESH_EXPORT StatisticsVector< long double >
 
template class LIBMESH_EXPORT StatisticsVector< Real >
 
template class LIBMESH_EXPORT StatisticsVector< int >
 
template class LIBMESH_EXPORT StatisticsVector< unsigned int >
 
template class LIBMESH_EXPORT Tree< 2 >
 
template class LIBMESH_EXPORT Tree< 4 >
 
template class LIBMESH_EXPORT Tree< 8 >
 
template class LIBMESH_EXPORT TreeNode< 2 >
 
template class LIBMESH_EXPORT TreeNode< 4 >
 
template class LIBMESH_EXPORT TreeNode< 8 >
 

Detailed Description

The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings.

These are here because the dataLoad/dataStore routines create raw string buffers that can be communicated in a standard way using packed ranges.

Typedef Documentation

◆ FEBase

Definition at line 40 of file Assembly.h.

◆ FEVectorBase

Definition at line 42 of file Assembly.h.

◆ RealDIMValue

typedef Eigen::Matrix<Real, Moose::dim, 1> libMesh::RealDIMValue

Definition at line 137 of file MooseTypes.h.

◆ RealEigenMatrix

typedef Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic> libMesh::RealEigenMatrix

Definition at line 141 of file MooseTypes.h.

◆ RealEigenVector

typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> libMesh::RealEigenVector

Definition at line 138 of file MooseTypes.h.

◆ RealTensorArrayValue

typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim * Moose::dim> libMesh::RealTensorArrayValue

Definition at line 140 of file MooseTypes.h.

◆ RealTensorValue

Definition at line 145 of file MooseTypes.h.

◆ RealVectorArrayValue

typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim> libMesh::RealVectorArrayValue

Definition at line 139 of file MooseTypes.h.

◆ RealVectorValue

Definition at line 37 of file Assembly.h.

◆ TransientExplicitSystem

Definition at line 20 of file DisplacedSystem.h.

◆ UniquePtr

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

Definition at line 31 of file Moose.h.

Function Documentation

◆ print_helper()

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

Definition at line 912 of file MooseTypes.h.

913 {
914  // Specialization so that we don't print out unprintable characters
915  os << Moose::stringify(*param);
916 }
std::basic_ostream< charT, traits > * os
Definition: InfixIterator.h:33
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:62

◆ to_json() [1/3]

void libMesh::to_json ( nlohmann::json &  json,
const Point p 
)

Definition at line 50 of file JsonIO.C.

51 {
52  json["x"] = p(0);
53  json["y"] = p(1);
54  json["z"] = p(2);
55 }

◆ to_json() [2/3]

void libMesh::to_json ( nlohmann::json &  json,
const DenseVector< Real > &  vector 
)

Definition at line 58 of file JsonIO.C.

59 {
60  nlohmann::to_json(json, vector.get_values());
61 }
void to_json(nlohmann::json &json, const MooseApp &app)
Definition: JsonIO.C:22

◆ to_json() [3/3]

void libMesh::to_json ( nlohmann::json &  json,
const DenseMatrix< Real > &  matrix 
)

Definition at line 64 of file JsonIO.C.

65 {
66  std::vector<std::vector<Real>> values(matrix.m(), std::vector<Real>(matrix.n()));
67  for (const auto i : make_range(matrix.m()))
68  for (const auto j : make_range(matrix.n()))
69  values[i][j] = matrix(i, j);
70  nlohmann::to_json(json, values);
71 }
unsigned int m() const
IntRange< T > make_range(T beg, T end)
void to_json(nlohmann::json &json, const MooseApp &app)
Definition: JsonIO.C:22
unsigned int n() const