libMesh Namespace Reference

Namespaces

 boostcopy
 
 DenseMatrices
 
 ElementTypes
 
 exII
 
 FiniteElements
 
 libMeshPrivateData
 
 MacroFunctions
 
 MeshTools
 
 Nemesis
 
 Parallel
 
 Predicates
 
 QuadratureRules
 
 Quality
 
 ReferenceElem
 
 SparsityPattern
 
 TensorTools
 
 Threads
 
 Trees
 
 TriangleWrapper
 
 Utility
 

Classes

class  Problem_Interface
 
class  ProjectVector
 
class  BuildProjectionList
 
class  ProjectSolution
 
class  ProjectFEMSolution
 
class  BoundaryProjectSolution
 
class  AbaqusIO
 
class  AdaptiveTimeSolver
 
class  AdjointRefinementEstimator
 
class  AdjointResidualErrorEstimator
 
class  DenseVector
 
class  AnalyticFunction
 
struct  AutoPtrRef
 
class  AutoPtr
 A simple smart pointer providing strict ownership semantics. More...
 
class  BoundaryInfo
 
class  BoundaryMesh
 
class  Cell
 
class  Hex
 
class  Hex20
 
class  Hex27
 
class  Hex8
 
class  InfCell
 
class  InfHex
 
class  InfHex16
 
class  InfHex18
 
class  InfHex8
 
class  InfPrism
 
class  InfPrism12
 
class  InfPrism6
 
class  Prism
 
class  Prism15
 
class  Prism18
 
class  Prism6
 
class  Pyramid
 
class  Pyramid14
 
class  Pyramid5
 
class  Tet
 
class  Tet10
 
class  Tet4
 
class  CentroidPartitioner
 
class  CheckpointIO
 
struct  ScalarTraits
 
struct  ScalarTraits< std::complex< T > >
 
struct  CompareTypes
 
struct  CompareTypes< T, T >
 
struct  CompareTypes< T, std::complex< T > >
 
struct  CompareTypes< std::complex< T >, T >
 
class  CondensedEigenSystem
 
class  ConstFEMFunction
 
class  ConstFunction
 
class  LinearSolver
 
class  ContinuationSystem
 
class  CouplingMatrix
 
class  DenseMatrix
 
class  DenseVectorBase
 
class  DenseMatrixBase
 
class  DenseSubMatrix
 
class  DenseSubVector
 
class  DerivedRBConstruction
 
class  DerivedRBEvaluation
 
class  DGFEMContext
 
class  NumericVector
 
class  DiffContext
 
class  DifferentiablePhysics
 
class  DifferentiableQoI
 
class  LinearSolutionMonitor
 
class  DiffSolver
 
class  DifferentiableSystem
 
class  DirectSolutionTransfer
 
class  DirichletBoundary
 
class  DirichletBoundaries
 
class  DiscontinuityMeasure
 
class  DistributedVector
 
class  DivaIO
 
class  SparseMatrix
 
class  DofConstraints
 
class  DofConstraintValueMap
 
class  AdjointDofConstraintValues
 
class  NodeConstraints
 
class  DofMap
 
class  DofObject
 
class  DTKAdapter
 
class  DTKEvaluator
 
class  DTKSolutionTransfer
 
class  Edge
 
class  Edge2
 
class  Edge3
 
class  Edge4
 
class  InfEdge2
 
class  ShellMatrix
 
class  EigenPreconditioner
 
class  EigenSolver
 
class  EigenSparseLinearSolver
 
class  EigenSparseVector
 
class  EigenSparseMatrix
 
class  EigenSystem
 
class  EigenTimeSolver
 
class  Elem
 
class  ElemAssembly
 
class  EnsightIO
 
class  EquationSystems
 
class  ErrorEstimator
 
class  ErrorVector
 
class  Euler2Solver
 
class  EulerSolver
 
class  FEGenericBase
 
class  TensorValue
 
class  VectorValue
 
class  ExactErrorEstimator
 
class  FunctionBase
 
class  ExactSolution
 
class  ExodusII_IO
 
class  ExodusII_IO_Helper
 
class  ExplicitSystem
 
class  Face
 
class  InfQuad
 
class  InfQuad4
 
class  InfQuad6
 
class  Quad
 
class  Quad4
 
class  Quad8
 
class  Quad9
 
class  Tri
 
class  Tri3
 
class  Tri6
 
class  Factory
 
class  FactoryImp
 
class  InfFE
 
struct  FEOutputType
 
struct  FEOutputType< LAGRANGE_VEC >
 
struct  FEOutputType< NEDELEC_ONE >
 
class  FE
 
class  FEClough
 
class  FEHermite
 
class  FEHierarchic
 
class  FEL2Hierarchic
 
class  FELagrange
 
class  FEL2Lagrange
 
class  FEMonomial
 
class  FEScalar
 
class  FEXYZ
 
class  FELagrangeVec
 
class  FENedelecOne
 
class  FEAbstract
 
class  FETransformationBase
 
struct  TypesEqual
 
struct  TypesEqual< T, T >
 
class  FEComputeData
 
class  FEInterface
 
class  FEMap
 
class  H1FETransformation
 
class  HCurlFETransformation
 
class  FEType
 
class  FEXYZMap
 
class  FEMContext
 
class  FEMFunctionBase
 
class  FEMPhysics
 
class  FEMSystem
 
class  LaplacianErrorEstimator
 
class  FrequencySystem
 
class  FroIO
 
class  GmshIO
 
class  GMVIO
 
class  GnuPlotIO
 
class  HilbertSFCPartitioner
 
class  HPCoarsenTest
 
class  HPSelector
 
class  HPSingularity
 
class  TestClass
 
class  ImplicitSystem
 
class  InfElemBuilder
 
class  JumpErrorEstimator
 
class  KellyErrorEstimator
 
class  LaspackLinearSolver
 
class  LaspackVector
 
class  LaspackMatrix
 
class  LegacyXdrIO
 
class  LibMeshInit
 
class  LogicError
 
class  NotImplemented
 
class  FileError
 
class  ConvergenceFailure
 
class  DynamicCastFailure
 
class  FloatingPointException
 
class  Singleton
 
class  Linear
 
class  LinearImplicitSystem
 
class  LinearPartitioner
 
class  Preconditioner
 
class  LocationMap
 
class  mapvector
 
class  MatlabIO
 
class  MEDITIO
 
class  MemorySolutionHistory
 
class  Mesh
 
class  MeshBase
 
class  MeshCommunication
 
class  MeshData
 
class  MeshDataUnvHeader
 
class  MeshFunction
 
class  MeshInput
 
struct  mesh_inserter_iterator
 
class  MeshOutput
 
class  MeshRefinement
 
class  MeshSerializer
 
class  MeshSmoother
 
class  LaplaceMeshSmoother
 
class  VariationalMeshSmoother
 
class  TetGenMeshInterface
 
class  TetGenWrapper
 
class  TriangleInterface
 
class  MeshfreeInterpolation
 
class  InverseDistanceInterpolation
 
class  MeshfreeSolutionTransfer
 
class  MeshFunctionSolutionTransfer
 
class  METIS_CSR_Graph
 
class  MetisPartitioner
 
class  MortonSFCPartitioner
 
class  Nemesis_IO
 
class  Nemesis_IO_Helper
 
class  NewmarkSystem
 
class  NewtonSolver
 
class  NoSolutionHistory
 
class  Node
 
class  NodeElem
 
class  NonlinearSolver
 
class  NonlinearImplicitSystem
 
struct  null_output_iterator
 
class  OFFIO
 
class  BasicOStreamProxy
 
struct  SyncNodalPositions
 
class  ParallelMesh
 
class  ParallelObject
 
class  ParameterVector
 
class  Parameters
 
class  ParmetisPartitioner
 
class  ParsedFunction
 
class  Partitioner
 
class  Patch
 
class  PatchRecoveryErrorEstimator
 
class  PerfData
 
class  PerfLog
 
class  PerfMon
 
class  PeriodicBoundaries
 
class  PeriodicBoundary
 
class  PeriodicBoundaryBase
 
class  PetscDiffSolver
 
class  PetscDMNonlinearSolver
 
class  PetscMatrix
 
class  PetscLinearSolver
 
class  PetscNonlinearSolver
 
class  PetscPreconditioner
 
class  PetscVector
 
class  Plane
 
class  PltLoader
 
class  Point
 
class  PointLocatorBase
 
class  PointLocatorList
 
class  PointLocatorTree
 
class  PoolAllocator
 
class  FastPoolAllocator
 
class  PostscriptIO
 
class  QoISet
 
class  QBase
 
class  QClough
 
class  QConical
 
class  QGauss
 
class  QGrundmann_Moller
 
class  QGrid
 
class  QJacobi
 
class  QMonomial
 
class  QSimpson
 
class  QTrap
 
class  WendlandRBF
 
class  RadialBasisInterpolation
 
struct  RawFieldType
 
struct  RawFieldType< Number >
 
struct  RawFieldType< Gradient >
 
struct  RawFieldType< Tensor >
 
struct  RawFieldType< TypeNTensor< 3, Number > >
 
struct  RawFieldType< Real >
 
struct  RawFieldType< RealGradient >
 
struct  RawFieldType< RealTensor >
 
struct  RawFieldType< TypeNTensor< 3, Real > >
 
class  RawAccessor
 
class  RawAccessor< TypeNTensor< N, ScalarType > >
 
class  RBAssemblyExpansion
 
class  RBConstruction
 
class  RBConstructionBase
 
class  RBEIMAssembly
 
class  RBEIMConstruction
 
class  RBEIMEvaluation
 
class  RBEIMTheta
 
class  RBEvaluation
 
class  RBParameters
 
class  RBParametrized
 
class  RBParametrizedFunction
 
class  RBSCMConstruction
 
class  RBSCMEvaluation
 
class  RBTemporalDiscretization
 
class  RBTheta
 
class  RBThetaExpansion
 
class  ReferenceCountedObject
 
class  ReferenceCounter
 
class  RefinementSelector
 
class  RemoteElem
 
class  SensitivityData
 
class  SerialMesh
 
class  SFCPartitioner
 
class  Side
 
class  SideEdge
 
class  SlepcEigenSolver
 
class  SolutionHistory
 
class  SolutionTransfer
 
class  Solver
 
class  SparseShellMatrix
 
class  Sphere
 
class  StatisticsVector
 
class  SteadySolver
 
class  StoredRange
 
class  SumShellMatrix
 
class  Surface
 
class  System
 
class  SystemNorm
 
class  SystemSubset
 
class  SystemSubsetBySubdomain
 
class  TecplotIO
 
class  TensorShellMatrix
 
class  TypeVector
 
class  TypeTensor
 
class  TypeNTensor
 
class  TetGenIO
 
class  TimeSolver
 
class  TransientRBAssemblyExpansion
 
class  TransientRBConstruction
 
class  TransientRBEvaluation
 
class  TransientRBThetaExpansion
 
class  TransientSystem
 
class  Tree
 
class  TreeBase
 
class  TreeNode
 
class  AztecLinearSolver
 
class  EpetraMatrix
 
class  EpetraVector
 
class  NoxNonlinearSolver
 
class  TrilinosPreconditioner
 
class  TwostepTimeSolver
 
class  TypeTensorColumn
 
class  ConstTypeTensorColumn
 
class  UCDIO
 
class  UniformRefinementEstimator
 
class  UnsteadySolver
 
class  UnstructuredMesh
 
class  UNVIO
 
class  Variable
 
class  VariableGroup
 
class  vectormap
 
class  VTKIO
 
class  WeightedPatchRecoveryErrorEstimator
 
class  WrappedFunction
 
class  Xdr
 
class  XdrHEAD
 
class  XdrIO
 
class  XdrMESH
 
class  XdrMGF
 
class  XdrMHEAD
 
class  XdrSHEAD
 
class  XdrSOLN
 
class  ZeroFunction
 

Typedefs

typedef int PetscErrorCode
 
typedef int PetscInt
 
typedef std::vector< Point >
::const_iterator 
const_list_iterator
 
typedef DerivedRBConstruction
< RBConstruction
SteadyDerivedRBConstruction
 
typedef DerivedRBEvaluation
< RBEvaluation
SteadyDerivedRBEvaluation
 
typedef std::map< dof_id_type,
Real, std::less< dof_id_type >
, Threads::scalable_allocator
< std::pair< const dof_id_type,
Real > > > 
DofConstraintRow
 
typedef std::map< const Node
*, Real, std::less< const Node * >
, Threads::scalable_allocator
< std::pair< const Node *const,
Real > > > 
NodeConstraintRow
 
typedef int32_t eigen_idx_type
 
typedef Eigen::SparseMatrix
< Number, Eigen::RowMajor,
eigen_idx_type
EigenSM
 
typedef Eigen::Matrix< Number,
Eigen::Dynamic, 1 > 
EigenSV
 
typedef StoredRange
< MeshBase::element_iterator,
Elem * > 
ElemRange
 
typedef StoredRange
< MeshBase::const_element_iterator,
const Elem * > 
ConstElemRange
 
typedef FEGenericBase< RealFEBase
 
typedef TensorValue< NumberNumberTensorValue
 
typedef NumberTensorValue Tensor
 
typedef VectorValue< NumberNumberVectorValue
 
typedef NumberVectorValue Gradient
 
typedef FEGenericBase
< RealGradient
FEVectorBase
 
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 ParallelMesh DefaultMesh
 
typedef double * LPDOUBLE
 
typedef LPDOUBLELPLPDOUBLE
 
typedef LPLPDOUBLELPLPLPDOUBLE
 
typedef void * LPVOID
 
typedef LPVOIDLPLPVOID
 
typedef int * LPINT
 
typedef LPINTLPLPINT
 
typedef unsigned int uint
 
typedef Real REAL
 
typedef StoredRange
< MeshBase::node_iterator,
Node * > 
NodeRange
 
typedef StoredRange
< MeshBase::const_node_iterator,
const Node * > 
ConstNodeRange
 
typedef BasicOStreamProxy OStreamProxy
 
typedef LinearImplicitSystem SteadyLinearSystem
 
typedef TransientSystem
< LinearImplicitSystem
TransientImplicitSystem
 
typedef TransientSystem
< LinearImplicitSystem
TransientLinearImplicitSystem
 
typedef TransientSystem
< NonlinearImplicitSystem
TransientNonlinearImplicitSystem
 
typedef TransientSystem
< ExplicitSystem
TransientExplicitSystem
 
typedef TransientSystem< SystemTransientBaseSystem
 

Functions

const Number imaginary (0., 1.)
 
bool initialized ()
 
bool closed ()
 
void libmesh_terminate_handler ()
 
 omp_set_num_threads (libMesh::libMeshPrivateData::_n_threads)
 
task_scheduler reset (new Threads::task_scheduler_init(libMesh::n_threads()))
 
 libmesh_assert (remote_elem)
 
 if (!libMesh::on_command_line("--disable-mpi"))
 
 libmesh_assert_greater (libMeshPrivateData::_n_processors, 0)
 
 libmesh_parallel_only (this->comm())
 
 if (!libMesh::on_command_line("--disable-petsc")#if defined(LIBMESH_HAVE_MPI)&&!libMesh::on_command_line("--disable-mpi")#endif)
 
command_line parse_command_line (argc, argv)
 
if(!libMesh::on_command_line("--sync-with-stdio"))
std 
if (libMesh::on_command_line("--separate-libmeshout"))
 
 if (libMesh::on_command_line("--redirect-stdout"))
 
 if (libMesh::processor_id()!=0)
 
void enableFPE (bool on)
 
bool on_command_line (const 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 >
void command_line_vector (const std::string &name, std::vector< T > &vec)
 
SolverPackage default_solver_package ()
 
template int command_line_value< int > (const std::string &, int)
 
template float command_line_value< float > (const std::string &, float)
 
template double command_line_value< double > (const std::string &, double)
 
template long double command_line_value< long double > (const std::string &, long double)
 
template std::string command_line_value< std::string > (const std::string &, std::string)
 
template void command_line_vector< int > (const std::string &, std::vector< int > &)
 
template void command_line_vector< float > (const std::string &, std::vector< float > &)
 
template void command_line_vector< double > (const std::string &, std::vector< double > &)
 
template void command_line_vector< long double > (const std::string &, std::vector< long double > &)
 
std::string process_trace (const char *name)
 
std::string demangle (const char *name)
 
void print_trace (std::ostream &out)
 
void write_traceout ()
 
error_per_cell resize (mesh.max_elem_id())
 
 if (solution_vector &&solution_vector!=system.solution.get())
 
 for (unsigned int var=0;var< n_vars;var++)
 
this reduce_error (error_per_cell, system.comm())
 
 START_LOG ("std::sqrt()","ExactErrorEstimator")
 
 STOP_LOG ("std::sqrt()","ExactErrorEstimator")
 
 INSTANTIATE_FE (0)
 
 INSTANTIATE_FE (1)
 
 INSTANTIATE_FE (2)
 
 INSTANTIATE_FE (3)
 
std::ostream & operator<< (std::ostream &os, const FEAbstract &fe)
 
 REINIT_ERROR (REINIT_ERROR(0, REINIT_ERROR(CLOUGH, reinit)
 
 INSTANTIATE_ALL_MAPS (0)
 
 INSTANTIATE_ALL_MAPS (1)
 
 INSTANTIATE_ALL_MAPS (2)
 
 INSTANTIATE_ALL_MAPS (3)
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Elem *, Base::build_elem(const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Elem *, Base::build_elem(const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Elem *, Base::build_elem(const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, ElemType, Base::get_elem_type(const ElemType type))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, ElemType, Base::get_elem_type(const ElemType type))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, ElemType, Base::get_elem_type(const ElemType type))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, Base::n_base_mapping_sf(const ElemType, const Order))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, Base::n_base_mapping_sf(const ElemType, const Order))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, Base::n_base_mapping_sf(const ElemType, const Order))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, Radial::n_dofs_at_node(const Order, const unsigned int))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, Radial::n_dofs_at_node(const Order, const unsigned int))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, Radial::n_dofs_at_node(const Order, const unsigned int))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, reinit(const Elem *, const unsigned int, const Real, const std::vector< Point > *const, const std::vector< Real > *const))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, reinit(const Elem *, const unsigned int, const Real, const std::vector< Point > *const, const std::vector< Real > *const))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, reinit(const Elem *, const unsigned int, const Real, const std::vector< Point > *const, const std::vector< Real > *const))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, edge_reinit(const Elem *, const unsigned int, const Real, const std::vector< Point > *const, const std::vector< Real > *const))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, edge_reinit(const Elem *, const unsigned int, const Real, const std::vector< Point > *const, const std::vector< Real > *const))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, edge_reinit(const Elem *, const unsigned int, const Real, const std::vector< Point > *const, const std::vector< Real > *const))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, init_face_shape_functions(const std::vector< Point > &, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, init_face_shape_functions(const std::vector< Point > &, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, init_face_shape_functions(const std::vector< Point > &, const Elem *))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Point, inverse_map(const Elem *, const Point &, const Real, const bool, const bool))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Point, inverse_map(const Elem *, const Point &, const Real, const bool, const bool))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Point, inverse_map(const Elem *, const Point &, const Real, const bool, const bool))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, n_dofs(const FEType &, const ElemType))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, n_dofs(const FEType &, const ElemType))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, n_dofs(const FEType &, const ElemType))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, n_dofs_per_elem(const FEType &, const ElemType))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, n_dofs_per_elem(const FEType &, const ElemType))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, n_dofs_per_elem(const FEType &, const ElemType))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, unsigned int, n_dofs_at_node(const FEType &, const ElemType, const unsigned int))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, unsigned int, n_dofs_at_node(const FEType &, const ElemType, const unsigned int))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, unsigned int, n_dofs_at_node(const FEType &, const ElemType, const unsigned int))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Real, shape(const FEType &, const Elem *, const unsigned int, const Point &p))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Real, shape(const FEType &, const Elem *, const unsigned int, const Point &p))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Real, shape(const FEType &, const Elem *, const unsigned int, const Point &p))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, Real, shape(const FEType &, const ElemType, const unsigned int, const Point &))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, Real, shape(const FEType &, const ElemType, const unsigned int, const Point &))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, Real, shape(const FEType &, const ElemType, const unsigned int, const Point &))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, compute_data(const FEType &, const Elem *, FEComputeData &))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, compute_data(const FEType &, const Elem *, FEComputeData &))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, compute_data(const FEType &, const Elem *, FEComputeData &))
 
 INSTANTIATE_INF_FE_MBRF (1, CARTESIAN, void, nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &))
 
 INSTANTIATE_INF_FE_MBRF (2, CARTESIAN, void, nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &))
 
 INSTANTIATE_INF_FE_MBRF (3, CARTESIAN, void, nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &))
 
std::ostream & operator<< (std::ostream &os, const MeshBase &m)
 
template void MeshCommunication::find_global_indices< MeshBase::const_node_iterator > (const Parallel::Communicator &, const MeshTools::BoundingBox &, const MeshBase::const_node_iterator &, const MeshBase::const_node_iterator &, std::vector< dof_id_type > &) const
 
template void MeshCommunication::find_global_indices< MeshBase::const_element_iterator > (const Parallel::Communicator &, const MeshTools::BoundingBox &, const MeshBase::const_element_iterator &, const MeshBase::const_element_iterator &, std::vector< dof_id_type > &) const
 
template void MeshCommunication::find_global_indices< MeshBase::node_iterator > (const Parallel::Communicator &, const MeshTools::BoundingBox &, const MeshBase::node_iterator &, const MeshBase::node_iterator &, std::vector< dof_id_type > &) const
 
template void MeshCommunication::find_global_indices< MeshBase::element_iterator > (const Parallel::Communicator &, const MeshTools::BoundingBox &, const MeshBase::element_iterator &, const MeshBase::element_iterator &, std::vector< dof_id_type > &) const
 
std::ostream & operator<< (std::ostream &os, const MeshData &m)
 
bool is_between (Real min, Real check, Real max)
 
 PetscObjectGetComm ((PetscObject) pc,&comm)
 
 CHKERRABORT (comm, ierr)
 
std::ostream & operator<< (std::ostream &os, const QBase &q)
 
template<typename T >
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, MatStructure *msflag, void *ctx)
 
DiffSolver::SolveResult convert_solve_result (SNESConvergedReason r)
 
void PetscDMRegister ()
 
PetscErrorCode __libmesh_petsc_preconditioner_setup (void *ctx)
 
PetscErrorCode __libmesh_petsc_preconditioner_apply (void *ctx, Vec x, Vec y)
 
PetscErrorCode __libmesh_petsc_preconditioner_setup (PC pc)
 
PetscErrorCode __libmesh_petsc_preconditioner_apply (PC pc, Vec x, Vec y)
 
PetscErrorCode __libmesh_petsc_snes_monitor (SNES, PetscInt its, PetscReal fnorm, void *)
 
PetscErrorCode __libmesh_petsc_snes_residual (SNES snes, Vec x, Vec r, void *ctx)
 
PetscErrorCode __libmesh_petsc_snes_jacobian (SNES snes, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx)
 
std::ostream & operator<< (std::ostream &os, const EquationSystems &es)
 
template void Xdr::data< std::complex< float > > (std::complex< float > &, const char *)
 
template void Xdr::data< std::complex< double > > (std::complex< double > &, const char *)
 
template void Xdr::data< std::complex< long double > > (std::complex< long double > &, const char *)
 
template void Xdr::data< std::string > (std::string &, const char *)
 
template void Xdr::data< std::vector< int > > (std::vector< int > &, const char *)
 
template void Xdr::data< std::vector< unsigned int > > (std::vector< unsigned int > &, const char *)
 
template void Xdr::data< std::vector< short int > > (std::vector< short int > &, const char *)
 
template void Xdr::data< std::vector< unsigned short int > > (std::vector< unsigned short int > &, const char *)
 
template void Xdr::data< std::vector< long int > > (std::vector< long int > &, const char *)
 
template void Xdr::data< std::vector< unsigned long int > > (std::vector< unsigned long int > &, const char *)
 
template void Xdr::data< std::vector< unsigned long long > > (std::vector< unsigned long long > &, const char *)
 
template void Xdr::data< std::vector< char > > (std::vector< char > &, const char *)
 
template void Xdr::data< std::vector< signed char > > (std::vector< signed char > &, const char *)
 
template void Xdr::data< std::vector< unsigned char > > (std::vector< unsigned char > &, const char *)
 
template void Xdr::data< std::vector< float > > (std::vector< float > &, const char *)
 
template void Xdr::data< std::vector< double > > (std::vector< double > &, const char *)
 
template void Xdr::data< std::vector< long double > > (std::vector< long double > &, const char *)
 
template void Xdr::data< std::vector< std::complex< float > > > (std::vector< std::complex< float > > &, const char *)
 
template void Xdr::data< std::vector< std::complex< double > > > (std::vector< std::complex< double > > &, const char *)
 
template void Xdr::data< std::vector< std::complex< long double > > > (std::vector< std::complex< long double > > &, const char *)
 
template void Xdr::data< std::vector< std::string > > (std::vector< std::string > &, const char *)
 
 ScalarTraits_true (char)
 
 ScalarTraits_true (short)
 
 ScalarTraits_true (int)
 
 ScalarTraits_true (long)
 
 ScalarTraits_true (unsigned char)
 
 ScalarTraits_true (float)
 
 ScalarTraits_true (double)
 
 SUPERTYPE (unsigned char, short)
 
 SUPERTYPE (unsigned char, int)
 
 SUPERTYPE (unsigned char, float)
 
 SUPERTYPE (unsigned char, double)
 
 SUPERTYPE (unsigned char, long double)
 
 SUPERTYPE (char, short)
 
 SUPERTYPE (char, int)
 
 SUPERTYPE (char, float)
 
 SUPERTYPE (char, double)
 
 SUPERTYPE (char, long double)
 
 SUPERTYPE (short, int)
 
 SUPERTYPE (short, float)
 
 SUPERTYPE (short, double)
 
 SUPERTYPE (short, long double)
 
 SUPERTYPE (int, float)
 
 SUPERTYPE (int, double)
 
 SUPERTYPE (int, long double)
 
 SUPERTYPE (float, double)
 
 SUPERTYPE (float, long double)
 
 SUPERTYPE (double, long double)
 
std::ostream & operator<< (std::ostream &os, const Elem &e)
 
 INSTANTIATE_INF_FE (1, CARTESIAN)
 
 INSTANTIATE_INF_FE (2, CARTESIAN)
 
 INSTANTIATE_INF_FE (3, CARTESIAN)
 
processor_id_type n_processors ()
 
processor_id_type processor_id ()
 
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 Tnew , typename Told >
Tnew libmesh_cast_ref (Told &oldvar)
 
template<typename Tnew , typename Told >
Tnew libmesh_cast_ptr (Told *oldvar)
 
template<typename Tnew , typename Told >
Tnew libmesh_cast_int (Told oldvar)
 
template<class T >
void libmesh_ignore (const T &)
 
void libmesh_version_stdout ()
 
int get_libmesh_version ()
 
std::string get_io_compatibility_version ()
 
std::ostream & operator<< (std::ostream &os, const Node &n)
 
template<typename P >
void print_helper (std::ostream &os, const P *param)
 
template<typename P >
void print_helper (std::ostream &os, const std::vector< P > *param)
 
std::ostream & operator<< (std::ostream &os, const Parameters &p)
 
void PetscDMSetSystem (DM, NonlinearImplicitSystem &)
 
void PetscDMGetSystem (DM, NonlinearImplicitSystem *&)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const SparseMatrix< T > &m)
 
template<typename T , typename Scalar >
boostcopy::enable_if_c
< ScalarTraits< Scalar >
::value, TypeTensor< typename
CompareTypes< T, Scalar >
::supertype > >::type 
operator* (const Scalar factor, const TypeTensor< T > &t)
 
template<typename T , typename Scalar >
boostcopy::enable_if_c
< ScalarTraits< Scalar >
::value, TypeVector< typename
CompareTypes< T, Scalar >
::supertype > >::type 
operator* (const Scalar factor, const TypeVector< T > &v)
 

Variables

DIE A HORRIBLE DEATH HERE
typedef
LIBMESH_DEFAULT_SCALAR_TYPE 
Real
 
DIE A HORRIBLE DEATH HERE
typedef float 
ErrorVectorReal
 
MPI_Comm COMM_WORLD = MPI_COMM_NULL
 
Parallel::FakeCommunicator CommWorld
 
OStreamProxy out (std::cout)
 
OStreamProxy err (std::cerr)
 
PerfLog perflog ("libMesh",#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING true#else false#endif)
 
MPI_Errhandler libmesh_errhandler
 
 TRILINOS_SOLVERS
 
 LASPACK_SOLVERS
 
 EIGEN_SOLVERS
 
 INVALID_SOLVER_PACKAGE
 
std::terminate_handler old_terminate_handler
 
LibMeshInit::LibMeshInit(int
argc, const char *const *argv)
LibMeshInit command_lin 
reset )(new GetPot(argc, argv))
 
 n_threads [0] = "--n_threads"
 
void
ExactErrorEstimator::estimate_error(const
System &system, ErrorVector
&error_per_cell, const
NumericVector< Number >
*solution_vector, bool
estimate_parent_error) void
ExactErrorEstimator const
unsigned in 
dim ) = mesh.mesh_dimension()
 
const unsigned int n_vars = system.n_vars()
 
const DofMapdof_map = system.get_dof_map()
 
const RemoteElemremote_elem
 
template<typename T >
void PetscPreconditioner< T >
::set_petsc_subpreconditioner_type(PCType
type, PC &pc) void
PetscPreconditioner< T >
Parallel::communicator 
comm
 
Parallel::Communicator communicator (comm)
 
 ierr = PCSetUp(pc)
 
KSP * subksps
 
PetscInt n_local
 
const unsigned int MIN_ELEM_PER_PROC = 4
 
PetscBool PetscDMRegistered = PETSC_FALSE
 
const unsigned char triangular_number_row []
 
const unsigned char triangular_number_column []
 
const unsigned char square_number_column []
 
const unsigned char square_number_row []
 
const unsigned char cube_number_column []
 
const unsigned char cube_number_row []
 
const unsigned char cube_number_page []
 
const Number imaginary
 
const Real pi
 
const Number zero = 0.
 
const unsigned int invalid_uint = static_cast<unsigned int>(-1)
 
static const Real TOLERANCE = 1.e-8
 

Detailed Description

Sanity check, without prior inclusion of libmesh_config.h.

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

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

Petsc include files.

SLEPc include files.

Trilinos include files.

Typedef Documentation

typedef int16_t libMesh::boundary_id_type

Definition at line 47 of file id_types.h.

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

Definition at line 136 of file libmesh_common.h.

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

Definition at line 137 of file libmesh_common.h.

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

Definition at line 33 of file point_locator_list.C.

Definition at line 27 of file mesh.h.

typedef uint32_t libMesh::dof_id_type

Definition at line 58 of file id_types.h.

A row of the Dof constraint matrix.

Definition at line 87 of file dof_map.h.

typedef int32_t libMesh::eigen_idx_type

Definition at line 59 of file eigen_core_support.h.

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

Definition at line 71 of file eigen_core_support.h.

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

Definition at line 72 of file eigen_core_support.h.

Definition at line 36 of file exact_error_estimator.h.

Definition at line 676 of file fe_base.h.

Definition at line 51 of file exact_error_estimator.h.

typedef uint8_t libMesh::largest_id_type

Definition at line 121 of file id_types.h.

typedef double* libMesh::LPDOUBLE

Definition at line 39 of file mesh_smoother_vsmoother.h.

typedef int* libMesh::LPINT

Definition at line 44 of file mesh_smoother_vsmoother.h.

Definition at line 40 of file mesh_smoother_vsmoother.h.

Definition at line 45 of file mesh_smoother_vsmoother.h.

Definition at line 41 of file mesh_smoother_vsmoother.h.

Definition at line 43 of file mesh_smoother_vsmoother.h.

typedef void* libMesh::LPVOID

Definition at line 42 of file mesh_smoother_vsmoother.h.

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

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

Definition at line 135 of file dof_map.h.

Definition at line 165 of file libmesh_common.h.

Definition at line 82 of file id_types.h.

Definition at line 239 of file ostream_proxy.h.

Definition at line 43 of file petsc_diff_solver.C.

typedef int libMesh::PetscInt

Definition at line 44 of file petsc_diff_solver.C.

typedef uint16_t libMesh::processor_id_type

Definition at line 89 of file id_types.h.

Definition at line 36 of file mesh_triangle_wrapper.h.

Definition at line 50 of file hp_coarsentest.h.

Definition at line 51 of file hp_coarsentest.h.

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

Definition at line 49 of file hp_coarsentest.h.

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

Definition at line 47 of file hp_coarsentest.h.

typedef uint16_t libMesh::subdomain_id_type

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

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

Definition at line 43 of file id_types.h.

Definition at line 49 of file exact_error_estimator.h.

typedef unsigned int libMesh::uint

Definition at line 46 of file mesh_smoother_vsmoother.h.

typedef uint64_t libMesh::unique_id_type

Definition at line 69 of file id_types.h.

Function Documentation

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

Definition at line 137 of file petsc_diff_solver.C.

References libMesh::ImplicitSystem::assembly(), libMesh::ParallelObject::comm(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::System::get_dof_map(), libmesh_assert(), 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().

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

Definition at line 50 of file petsc_diff_solver.C.

References CHKERRABORT(), libMesh::PetscVector< T >::close(), libMesh::ParallelObject::comm(), COMM_WORLD, ierr, libMesh::DiffSolver::linear_solution_monitor, out, and libMesh::DiffSolver::verbose.

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

52 {
53  PetscDiffSolver& solver =
54  *(static_cast<PetscDiffSolver*> (ctx));
55 
56  if (solver.verbose)
57  libMesh::out << " PetscDiffSolver step " << its
58  << ", |residual|_2 = " << fnorm << std::endl;
59  if (solver.linear_solution_monitor.get()) {
60  int ierr = 0;
61 
62  Vec petsc_delta_u;
63  ierr = SNESGetSolutionUpdate(snes, &petsc_delta_u);
65  PetscVector<Number> delta_u(petsc_delta_u, solver.comm());
66  delta_u.close();
67 
68  Vec petsc_u;
69  ierr = SNESGetSolution(snes, &petsc_u);
71  PetscVector<Number> u(petsc_u, solver.comm());
72  u.close();
73 
74  Vec petsc_res;
75  ierr = SNESGetFunction(snes, &petsc_res, NULL, NULL);
77  PetscVector<Number> res(petsc_res, solver.comm());
78  res.close();
79 
80  (*solver.linear_solution_monitor)(
81  delta_u, delta_u.l2_norm(),
82  u, u.l2_norm(),
83  res, res.l2_norm(), its);
84  }
85  return 0;
86 }
PetscErrorCode libMesh::__libmesh_petsc_diff_solver_residual ( SNES  ,
Vec  x,
Vec  r,
void *  ctx 
)

Definition at line 91 of file petsc_diff_solver.C.

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

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

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

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

Definition at line 63 of file petsc_linear_solver.C.

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

64  {
65  Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);
66 
67  PetscVector<Number> x_vec(x, preconditioner->comm());
68  PetscVector<Number> y_vec(y, preconditioner->comm());
69 
70  preconditioner->apply(x_vec,y_vec);
71 
72  return 0;
73  }
PetscErrorCode libMesh::__libmesh_petsc_preconditioner_apply ( PC  pc,
Vec  x,
Vec  y 
)

Definition at line 92 of file petsc_linear_solver.C.

References CHKERRQ(), and ierr.

93  {
94  void *ctx;
95  PetscErrorCode ierr = PCShellGetContext(pc,&ctx);CHKERRQ(ierr);
96  Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);
97 
98  PetscVector<Number> x_vec(x, preconditioner->comm());
99  PetscVector<Number> y_vec(y, preconditioner->comm());
100 
101  preconditioner->apply(x_vec,y_vec);
102 
103  return 0;
104  }
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 47 of file petsc_linear_solver.C.

References err.

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

48  {
49  Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);
50 
51  if(!preconditioner->initialized())
52  {
53  err<<"Preconditioner not initialized! Make sure you call init() before solve!"<<std::endl;
54  libmesh_error();
55  }
56 
57  preconditioner->setup();
58 
59  return 0;
60  }
PetscErrorCode libMesh::__libmesh_petsc_preconditioner_setup ( PC  pc)

Definition at line 75 of file petsc_linear_solver.C.

References CHKERRQ(), err, and ierr.

76  {
77  void *ctx;
78  PetscErrorCode ierr = PCShellGetContext(pc,&ctx);CHKERRQ(ierr);
79  Preconditioner<Number> * preconditioner = static_cast<Preconditioner<Number>*>(ctx);
80 
81  if(!preconditioner->initialized())
82  {
83  err<<"Preconditioner not initialized! Make sure you call init() before solve!"<<std::endl;
84  libmesh_error();
85  }
86 
87  preconditioner->setup();
88 
89  return 0;
90  }
PetscErrorCode libMesh::__libmesh_petsc_snes_jacobian ( SNES  snes,
Vec  x,
Mat *  jac,
Mat *  pc,
MatStructure *  msflag,
void *  ctx 
)

Definition at line 157 of file petsc_nonlinear_solver.C.

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

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

158  {
159  START_LOG("jacobian()", "PetscNonlinearSolver");
160 
162 
163  libmesh_assert(ctx);
164 
165  PetscNonlinearSolver<Number>* solver =
166  static_cast<PetscNonlinearSolver<Number>*> (ctx);
167 
168  // Get the current iteration number from the snes object,
169  // store it in the PetscNonlinearSolver object for possible use
170  // by the user's Jacobian function.
171  {
172  PetscInt n_iterations = 0;
173  ierr = SNESGetIterationNumber(snes, &n_iterations);
174  CHKERRABORT(solver->comm().get(),ierr);
175  solver->_current_nonlinear_iteration_number = static_cast<unsigned>(n_iterations);
176  }
177 
178  NonlinearImplicitSystem &sys = solver->system();
179 
180  PetscMatrix<Number> PC(*pc, sys.comm());
181  PetscMatrix<Number> Jac(*jac, sys.comm());
182  PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
183  PetscMatrix<Number>& Jac_sys = *libmesh_cast_ptr<PetscMatrix<Number>*>(sys.matrix);
184  PetscVector<Number> X_global(x, sys.comm());
185 
186  // Set the dof maps
187  PC.attach_dof_map(sys.get_dof_map());
188  Jac.attach_dof_map(sys.get_dof_map());
189 
190  // Use the systems update() to get a good local version of the parallel solution
191  X_global.swap(X_sys);
192  Jac.swap(Jac_sys);
193 
194  sys.get_dof_map().enforce_constraints_exactly(sys);
195  sys.update();
196 
197  X_global.swap(X_sys);
198  Jac.swap(Jac_sys);
199 
200  if (solver->_zero_out_jacobian)
201  PC.zero();
202 
203  //-----------------------------------------------------------------------------
204  // if the user has provided both function pointers and objects only the pointer
205  // will be used, so catch that as an error
206  if (solver->jacobian && solver->jacobian_object)
207  {
208  libMesh::err << "ERROR: cannot specify both a function and object to compute the Jacobian!" << std::endl;
209  libmesh_error();
210  }
211 
212  if (solver->matvec && solver->residual_and_jacobian_object)
213  {
214  libMesh::err << "ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!" << std::endl;
215  libmesh_error();
216  }
217  //-----------------------------------------------------------------------------
218 
219  if (solver->jacobian != NULL) solver->jacobian (*sys.current_local_solution.get(), PC, sys);
220  else if (solver->jacobian_object != NULL) solver->jacobian_object->jacobian (*sys.current_local_solution.get(), PC, sys);
221  else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), NULL, &PC, sys);
222  else if (solver->residual_and_jacobian_object != NULL) solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), NULL, &PC, sys);
223  else libmesh_error();
224 
225  PC.close();
226  Jac.close();
227  X_global.close();
228 
229  *msflag = SAME_NONZERO_PATTERN;
230 
231  STOP_LOG("jacobian()", "PetscNonlinearSolver");
232 
233  return ierr;
234  }
PetscErrorCode libMesh::__libmesh_petsc_snes_monitor ( SNES  ,
PetscInt  its,
PetscReal  fnorm,
void *   
)

Definition at line 58 of file petsc_nonlinear_solver.C.

References out.

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

59  {
60  //PetscErrorCode ierr=0;
61 
62  //if (its > 0)
63  libMesh::out << " NL step "
64  << std::setw(2) << its
65  << std::scientific
66  << ", |residual|_2 = " << fnorm
67  << std::endl;
68 
69  //return ierr;
70  return 0;
71  }
PetscErrorCode libMesh::__libmesh_petsc_snes_residual ( SNES  snes,
Vec  x,
Vec  r,
void *  ctx 
)

Definition at line 78 of file petsc_nonlinear_solver.C.

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

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

79  {
80  START_LOG("residual()", "PetscNonlinearSolver");
81 
83 
84  libmesh_assert(x);
85  libmesh_assert(r);
86  libmesh_assert(ctx);
87 
88  PetscNonlinearSolver<Number>* solver =
89  static_cast<PetscNonlinearSolver<Number>*> (ctx);
90 
91  // Get the current iteration number from the snes object,
92  // store it in the PetscNonlinearSolver object for possible use
93  // by the user's residual function.
94  {
95  PetscInt n_iterations = 0;
96  ierr = SNESGetIterationNumber(snes, &n_iterations);
97  CHKERRABORT(solver->comm().get(),ierr);
98  solver->_current_nonlinear_iteration_number = static_cast<unsigned>(n_iterations);
99  }
100 
101  NonlinearImplicitSystem &sys = solver->system();
102 
103  PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
104  PetscVector<Number>& R_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.rhs);
105  PetscVector<Number> X_global(x, sys.comm()), R(r, sys.comm());
106 
107  // Use the systems update() to get a good local version of the parallel solution
108  X_global.swap(X_sys);
109  R.swap(R_sys);
110 
111  sys.get_dof_map().enforce_constraints_exactly(sys);
112 
113  sys.update();
114 
115  //Swap back
116  X_global.swap(X_sys);
117  R.swap(R_sys);
118 
119  if (solver->_zero_out_residual)
120  R.zero();
121 
122  //-----------------------------------------------------------------------------
123  // if the user has provided both function pointers and objects only the pointer
124  // will be used, so catch that as an error
125  if (solver->residual && solver->residual_object)
126  {
127  libMesh::err << "ERROR: cannot specifiy both a function and object to compute the Residual!" << std::endl;
128  libmesh_error();
129  }
130 
131  if (solver->matvec && solver->residual_and_jacobian_object)
132  {
133  libMesh::err << "ERROR: cannot specifiy both a function and object to compute the combined Residual & Jacobian!" << std::endl;
134  libmesh_error();
135  }
136  //-----------------------------------------------------------------------------
137 
138  if (solver->residual != NULL) solver->residual (*sys.current_local_solution.get(), R, sys);
139  else if (solver->residual_object != NULL) solver->residual_object->residual (*sys.current_local_solution.get(), R, sys);
140  else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), &R, NULL, sys);
141  else if (solver->residual_and_jacobian_object != NULL) solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), &R, NULL, sys);
142  else libmesh_error();
143 
144  R.close();
145  X_global.close();
146 
147  STOP_LOG("residual()", "PetscNonlinearSolver");
148 
149  return ierr;
150  }
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 250 of file libmesh.C.

References libMesh::libMeshPrivateData::_is_initialized.

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

251 {
253 }
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

Definition at line 721 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::command_line, and libmesh_assert().

722 {
723  // Make sure the command line parser is ready for use
725 
726  // only if the variable exists in the file
727  if (command_line->have_variable(name.c_str()))
728  value = (*command_line)(name.c_str(), value);
729 
730  return value;
731 }
template<typename T >
T libMesh::command_line_value ( const std::vector< std::string > &  name,
value 
)

Definition at line 734 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::command_line, and libmesh_assert().

735 {
736  // Make sure the command line parser is ready for use
738 
739  // Check for multiple options (return the first that matches)
740  for (std::vector<std::string>::const_iterator i=name.begin(); i != name.end(); ++i)
741  if (command_line->have_variable(i->c_str()))
742  {
743  value = (*command_line)(i->c_str(), value);
744  break;
745  }
746 
747  return value;
748 }
template double libMesh::command_line_value< double > ( const std::string &  ,
double   
)
template float libMesh::command_line_value< float > ( const std::string &  ,
float   
)
template int libMesh::command_line_value< int > ( const std::string &  ,
int   
)
template long double libMesh::command_line_value< long double > ( const std::string &  ,
long  double 
)
template std::string libMesh::command_line_value< std::string > ( const std::string &  ,
std::string   
)
template<typename T >
void libMesh::command_line_vector ( const std::string &  ,
std::vector< T > &   
)
Returns
the array of values associated with name on the command line if it is specified, otherwise return the default, provided array.

Definition at line 754 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::command_line, and libmesh_assert().

755 {
756  // Make sure the command line parser is ready for use
758 
759  // only if the variable exists on the command line
760  if (command_line->have_variable(name.c_str()))
761  {
762  unsigned size = command_line->vector_variable_size(name.c_str());
763  vec.resize(size);
764 
765  for (unsigned i=0; i<size; ++i)
766  vec[i] = (*command_line)(name.c_str(), vec[i], i);
767  }
768 }
template void libMesh::command_line_vector< double > ( const std::string &  ,
std::vector< double > &   
)
template void libMesh::command_line_vector< float > ( const std::string &  ,
std::vector< float > &   
)
template void libMesh::command_line_vector< int > ( const std::string &  ,
std::vector< int > &   
)
template void libMesh::command_line_vector< long double > ( const std::string &  ,
std::vector< long double > &   
)
DiffSolver::SolveResult libMesh::convert_solve_result ( SNESConvergedReason  r)

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

262 {
263  switch (r)
264  {
265  case SNES_CONVERGED_FNORM_ABS:
266  return DiffSolver::CONVERGED_ABSOLUTE_RESIDUAL;
267  case SNES_CONVERGED_FNORM_RELATIVE:
268  return DiffSolver::CONVERGED_RELATIVE_RESIDUAL;
269 #if PETSC_VERSION_LESS_THAN(3,2,1)
270  case SNES_CONVERGED_PNORM_RELATIVE:
271 #else
272  case SNES_CONVERGED_SNORM_RELATIVE:
273 #endif
274  return DiffSolver::CONVERGED_RELATIVE_STEP;
275 #if !PETSC_VERSION_LESS_THAN(2,3,3)
276  case SNES_CONVERGED_ITS:
277 #endif
278  case SNES_CONVERGED_TR_DELTA:
279  return DiffSolver::CONVERGED_NO_REASON;
280  case SNES_DIVERGED_FUNCTION_DOMAIN:
281  case SNES_DIVERGED_FUNCTION_COUNT:
282  case SNES_DIVERGED_FNORM_NAN:
283 #if !PETSC_VERSION_LESS_THAN(3,3,0)
284  case SNES_DIVERGED_INNER:
285 #endif
286 #if !PETSC_VERSION_LESS_THAN(2,3,2)
287  case SNES_DIVERGED_LINEAR_SOLVE:
288 #endif
289  case SNES_DIVERGED_LOCAL_MIN:
290  return DiffSolver::DIVERGED_NO_REASON;
291  case SNES_DIVERGED_MAX_IT:
292  return DiffSolver::DIVERGED_MAX_NONLINEAR_ITERATIONS;
293 #if !PETSC_VERSION_LESS_THAN(3,2,0)
294  case SNES_DIVERGED_LINE_SEARCH:
295  return DiffSolver::DIVERGED_BACKTRACKING_FAILURE;
296 #endif
297  // In PETSc, SNES_CONVERGED_ITERATING means
298  // the solve is still iterating, but by the
299  // time we get here, we must have either
300  // converged or diverged, so
301  // SNES_CONVERGED_ITERATING is invalid.
302  case SNES_CONVERGED_ITERATING:
303  return DiffSolver::INVALID_SOLVE_RESULT;
304  }
305  return DiffSolver::INVALID_SOLVE_RESULT;
306 }
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 771 of file libmesh.C.

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

772 {
774 
775  static bool called = false;
776 
777  // Check the command line. Since the command line is
778  // unchanging it is sufficient to do this only once.
779  if (!called)
780  {
781  called = true;
782 
783 #ifdef LIBMESH_HAVE_PETSC
784  if (libMesh::on_command_line ("--use-petsc"))
786 #endif
787 
788 #ifdef LIBMESH_HAVE_TRILINOS
789  if (libMesh::on_command_line ("--use-trilinos") ||
790  libMesh::on_command_line ("--disable-petsc"))
792 #endif
793 
794 #ifdef LIBMESH_HAVE_EIGEN
795  if (libMesh::on_command_line ("--use-eigen" ) ||
796 #if defined(LIBMESH_HAVE_MPI)
797  // If the user bypassed MPI, we disable PETSc and Trilinos
798  // too
799  libMesh::on_command_line ("--disable-mpi") ||
800 #endif
801  libMesh::on_command_line ("--disable-petsc"))
803 #endif
804 
805 #ifdef LIBMESH_HAVE_LASPACK
806  if (libMesh::on_command_line ("--use-laspack" ) ||
807 #if defined(LIBMESH_HAVE_MPI)
808  // If the user bypassed MPI, we disable PETSc and Trilinos
809  // too
810  libMesh::on_command_line ("--disable-mpi") ||
811 #endif
812  libMesh::on_command_line ("--disable-petsc"))
814 #endif
815 
816  if (libMesh::on_command_line ("--disable-laspack") &&
817  libMesh::on_command_line ("--disable-trilinos") &&
818  libMesh::on_command_line ("--disable-eigen") &&
819  (
820 #if defined(LIBMESH_HAVE_MPI)
821  // If the user bypassed MPI, we disable PETSc too
822  libMesh::on_command_line ("--disable-mpi") ||
823 #endif
824  libMesh::on_command_line ("--disable-petsc")))
826  }
827 
828 
830 }
std::string libMesh::demangle ( const char *  name)

Definition at line 97 of file print_trace.C.

References libMesh::Quality::name().

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

98 {
99  int status = 0;
100  char *d = 0;
101  std::string ret = name;
102  try { if ( (d = abi::__cxa_demangle(name, 0, 0, &status)) ) ret = d; }
103  catch(...) { }
104  std::free(d);
105  return ret;
106 }
void libMesh::enableFPE ( bool  on)

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

Toggle hardware trap floating point exceptions

Definition at line 666 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::libmesh_handleFPE().

667 {
668 #if !defined(LIBMESH_HAVE_FEENABLEEXCEPT) && defined(LIBMESH_HAVE_XMMINTRIN_H)
669  static int flags = 0;
670 #endif
671 
672  if (on)
673  {
674  struct sigaction new_action, old_action;
675 
676 #ifdef LIBMESH_HAVE_FEENABLEEXCEPT
677  feenableexcept(FE_DIVBYZERO | FE_INVALID);
678 #elif LIBMESH_HAVE_XMMINTRIN_H
679 # ifndef __SUNPRO_CC
680  flags = _MM_GET_EXCEPTION_MASK(); // store the flags
681  _MM_SET_EXCEPTION_MASK(flags & ~_MM_MASK_INVALID);
682 # endif
683 #endif
684 
685 
686  // Set up the structure to specify the new action.
687  new_action.sa_sigaction = libmesh_handleFPE;
688  sigemptyset (&new_action.sa_mask);
689  new_action.sa_flags = SA_SIGINFO;
690 
691  sigaction (SIGFPE, NULL, &old_action);
692  if (old_action.sa_handler != SIG_IGN)
693  sigaction (SIGFPE, &new_action, NULL);
694  }
695  else
696  {
697 #ifdef LIBMESH_HAVE_FEDISABLEEXCEPT
698  fedisableexcept(FE_DIVBYZERO | FE_INVALID);
699 #elif LIBMESH_HAVE_XMMINTRIN_H
700 # ifndef __SUNPRO_CC
701  _MM_SET_EXCEPTION_MASK(flags);
702 # endif
703 #endif
704  signal(SIGFPE, 0);
705  }
706 }
libMesh::for ( )

Definition at line 241 of file exact_error_estimator.C.

References libMesh::Elem::active(), libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::NumericVector< T >::build(), libMesh::FEGenericBase< T >::build(), libMesh::Elem::child(), libMesh::FEGenericBase< T >::coarsened_dof_values(), libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::System::current_solution(), libMesh::FEType::default_quadrature_rule(), libMesh::DofMap::dof_indices(), ErrorVectorReal, libMesh::AutoPtr< Tp >::get(), libMesh::System::get_dof_map(), libMesh::DofObject::id(), libMesh::Elem::n_children(), libMesh::System::name(), libMesh::Elem::parent(), libMeshEnums::SERIAL, libMesh::System::update_global_solution(), libMesh::System::variable_name(), libMesh::System::variable_number(), and libMesh::DofMap::variable_type().

Referenced by libMesh::DofMap::get_local_constraints(), libMesh::DofMap::max_constraint_error(), and libMesh::DofMap::process_constraints().

242  {
243  // Possibly skip this variable
244  if (error_norm.weight(var) == 0.0) continue;
245 
246  // The (string) name of this variable
247  const std::string& var_name = system.variable_name(var);
248 
249  // The type of finite element to use for this variable
250  const FEType& fe_type = dof_map.variable_type (var);
251 
252  AutoPtr<FEBase> fe (FEBase::build (dim, fe_type));
253 
254  // Build an appropriate Gaussian quadrature rule
255  AutoPtr<QBase> qrule =
256  fe_type.default_quadrature_rule (dim,
257  _extra_order);
258 
259  fe->attach_quadrature_rule (qrule.get());
260 
261  // Prepare a global solution and a MeshFunction of the fine system if we need one
262  AutoPtr<MeshFunction> fine_values;
263  AutoPtr<NumericVector<Number> > fine_soln = NumericVector<Number>::build(system.comm());
264  if (_equation_systems_fine)
265  {
266  const System& fine_system = _equation_systems_fine->get_system(system.name());
267 
268  std::vector<Number> global_soln;
269  // FIXME - we're assuming that the fine system solution gets
270  // used even when a different vector is used for the coarse
271  // system
272  fine_system.update_global_solution(global_soln);
273  fine_soln->init (global_soln.size(), true, SERIAL);
274  (*fine_soln) = global_soln;
275 
276  fine_values = AutoPtr<MeshFunction>
277  (new MeshFunction(*_equation_systems_fine,
278  *fine_soln,
279  fine_system.get_dof_map(),
280  fine_system.variable_number(var_name)));
281  fine_values->init();
282  } else {
283  // Initialize functors if we're using them
284  for (unsigned int i=0; i != _exact_values.size(); ++i)
285  if (_exact_values[i])
286  _exact_values[i]->init();
287 
288  for (unsigned int i=0; i != _exact_derivs.size(); ++i)
289  if (_exact_derivs[i])
290  _exact_derivs[i]->init();
291 
292  for (unsigned int i=0; i != _exact_hessians.size(); ++i)
293  if (_exact_hessians[i])
294  _exact_hessians[i]->init();
295  }
296 
297  // Request the data we'll need to compute with
298  fe->get_JxW();
299  fe->get_phi();
300  fe->get_dphi();
301 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
302  fe->get_d2phi();
303 #endif
304  fe->get_xyz();
305 
306  // If we compute on parent elements, we'll want to do so only
307  // once on each, so we need to keep track of which we've done.
308  std::vector<bool> computed_var_on_parent;
309 
310 #ifdef LIBMESH_ENABLE_AMR
311  if (estimate_parent_error)
312  computed_var_on_parent.resize(error_per_cell.size(), false);
313 #endif
314 
315  // TODO: this ought to be threaded (and using subordinate
316  // MeshFunction objects in each thread rather than a single
317  // master)
318 
319  // Iterate over all the active elements in the mesh
320  // that live on this processor.
321  MeshBase::const_element_iterator
322  elem_it = mesh.active_local_elements_begin();
323  const MeshBase::const_element_iterator
324  elem_end = mesh.active_local_elements_end();
325 
326  for (;elem_it != elem_end; ++elem_it)
327  {
328  // e is necessarily an active element on the local processor
329  const Elem* elem = *elem_it;
330  const dof_id_type e_id = elem->id();
331 
332 #ifdef LIBMESH_ENABLE_AMR
333  // See if the parent of element e has been examined yet;
334  // if not, we may want to compute the estimator on it
335  const Elem* parent = elem->parent();
336 
337  // We only can compute and only need to compute on
338  // parents with all active children
339  bool compute_on_parent = true;
340  if (!parent || !estimate_parent_error)
341  compute_on_parent = false;
342  else
343  for (unsigned int c=0; c != parent->n_children(); ++c)
344  if (!parent->child(c)->active())
345  compute_on_parent = false;
346 
347  if (compute_on_parent &&
348  !computed_var_on_parent[parent->id()])
349  {
350  computed_var_on_parent[parent->id()] = true;
351 
352  // Compute a projection onto the parent
353  DenseVector<Number> Uparent;
354  FEBase::coarsened_dof_values(*(system.current_local_solution),
355  dof_map, parent, Uparent,
356  var, false);
357 
358  error_per_cell[parent->id()] +=
359  static_cast<ErrorVectorReal>
360  (find_squared_element_error(system, var_name,
361  parent, Uparent,
362  fe.get(),
363  fine_values.get()));
364  }
365 #endif
366 
367  // Get the local to global degree of freedom maps
368  std::vector<dof_id_type> dof_indices;
369  dof_map.dof_indices (elem, dof_indices, var);
370  const unsigned int n_dofs =
371  libmesh_cast_int<unsigned int>(dof_indices.size());
372  DenseVector<Number> Uelem(n_dofs);
373  for (unsigned int i=0; i != n_dofs; ++i)
374  Uelem(i) = system.current_solution(dof_indices[i]);
375 
376  error_per_cell[e_id] +=
377  static_cast<ErrorVectorReal>
378  (find_squared_element_error(system, var_name, elem,
379  Uelem, fe.get(),
380  fine_values.get()));
381 
382  } // End loop over active local elements
383  } // End loop over variables
std::string libMesh::get_io_compatibility_version ( )

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

Definition at line 77 of file libmesh_version.C.

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

78 {
79  std::string retval(LIBMESH_IO_COMPATIBILITY_VERSION);
80  return retval;
81 }
int libMesh::get_libmesh_version ( )

Definition at line 43 of file libmesh_version.C.

Referenced by libmesh_version_stdout().

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

Definition at line 231 of file exact_error_estimator.C.

References libMesh::NumericVector< T >::swap().

232  {
233  NumericVector<Number>* newsol =
234  const_cast<NumericVector<Number>*>(solution_vector);
235  System &sys = const_cast<System&>(system);
236  newsol->swap(*sys.solution);
237  sys.update();
238  }
libMesh::if ( !libMesh::  on_command_line"--disable-mpi")

Definition at line 357 of file libmesh.C.

References libMesh::libMeshPrivateData::_n_processors, libMesh::libMeshPrivateData::_processor_id, comm, COMM_WORLD, libMesh::Parallel::Communicator_World, libmesh_errhandler, EXTERN_C_FOR_PETSC_END::libmesh_initialized_mpi, libMesh_MPI_Handler(), and on_command_line().

358  {
359  // Check whether the calling program has already initialized
360  // MPI, and avoid duplicate Init/Finalize
361  int flag;
362  MPI_Initialized (&flag);
363 
364  if (!flag)
365  {
366  MPI_Init (&argc, const_cast<char***>(&argv));
368  }
369 
370  // Duplicate the input communicator for internal use
371  // And get a Parallel::Communicator copy too, to use
372  // as a default for that API
373  this->_comm = COMM_WORLD_IN;
374 
375  libMesh::COMM_WORLD = COMM_WORLD_IN;
376 
377 #ifndef LIBMESH_DISABLE_COMMWORLD
378  Parallel::Communicator_World = COMM_WORLD_IN;
379 #endif
380 
381  //MPI_Comm_set_name not supported in at least SGI MPT's MPI implementation
382  //MPI_Comm_set_name (libMesh::COMM_WORLD, "libMesh::COMM_WORLD");
383 
385  libmesh_cast_int<processor_id_type>(this->comm().rank());
387  libmesh_cast_int<processor_id_type>(this->comm().size());
388 
389  // Set up an MPI error handler if requested. This helps us get
390  // into a debugger with a proper stack when an MPI error occurs.
391  if (libMesh::on_command_line ("--handle-mpi-errors"))
392  {
393 #if MPI_VERSION > 1
394  MPI_Comm_create_errhandler(libMesh_MPI_Handler, &libmesh_errhandler);
395  MPI_Comm_set_errhandler(libMesh::COMM_WORLD, libmesh_errhandler);
396  MPI_Comm_set_errhandler(MPI_COMM_WORLD, libmesh_errhandler);
397 #else
398  MPI_Errhandler_create(libMesh_MPI_Handler, &libmesh_errhandler);
399  MPI_Errhandler_set(libMesh::COMM_WORLD, libmesh_errhandler);
400  MPI_Errhandler_set(MPI_COMM_WORLD, libmesh_errhandler);
401 #endif // #if MPI_VERSION > 1
402  }
403  }
libMesh::if ( !libMesh::on_command_line("--disable-petsc")#if defined(LIBMESH_HAVE_MPI)&&!libMesh::on_command_line("--disable-mpi")#  endif)

Definition at line 419 of file libmesh.C.

References CHKERRABORT(), COMM_WORLD, ierr, EXTERN_C_FOR_PETSC_END::libmesh_initialized_petsc, EXTERN_C_FOR_PETSC_END::libmesh_initialized_slepc, and PetscBool.

428  {
429  int ierr=0;
430 
431  PETSC_COMM_WORLD = libMesh::COMM_WORLD;
432 
433  // Check whether the calling program has already initialized
434  // PETSc, and avoid duplicate Initialize/Finalize
435  PetscBool petsc_already_initialized;
436  ierr = PetscInitialized(&petsc_already_initialized);
438  if (petsc_already_initialized != PETSC_TRUE)
440 # if defined(LIBMESH_HAVE_SLEPC)
441 
442  // If SLEPc allows us to check whether the calling program
443  // has already initialized it, we do that, and avoid
444  // duplicate Initialize/Finalize.
445  // We assume that SLEPc will handle PETSc appropriately,
446  // which it does in the versions we've checked.
447 # if !SLEPC_VERSION_LESS_THAN(2,3,3)
448  if (!SlepcInitializeCalled)
449 # endif
450  {
451  ierr = SlepcInitialize (&argc, const_cast<char***>(&argv), NULL, NULL);
454  }
455 # else
457  {
458  ierr = PetscInitialize (&argc, const_cast<char***>(&argv), NULL, NULL);
460  }
461 # endif
462  }
if (!libMesh::on_command_line ("--sync-with-stdio")) std libMesh::if ( libMesh::  on_command_line"--separate-libmeshout")

Definition at line 483 of file libmesh.C.

References err, and out.

484  {
485  // Redirect. We'll share streambufs with cout/cerr for now, but
486  // presumably anyone using this option will want to replace the
487  // bufs later.
488  std::ostream* newout = new std::ostream(std::cout.rdbuf());
489  libMesh::out = *newout;
490  std::ostream* newerr = new std::ostream(std::cerr.rdbuf());
491  libMesh::err = *newerr;
492  }
libMesh::if ( libMesh::  on_command_line"--redirect-stdout")

Definition at line 498 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::_ofstream, err, EXTERN_C_FOR_PETSC_END::err_buf(), out, EXTERN_C_FOR_PETSC_END::out_buf(), processor_id(), and libMesh::BasicOStreamProxy< charT, traits >::rdbuf().

499  {
500  std::ostringstream filename;
501  filename << "stdout.processor." << libMesh::processor_id();
502  _ofstream.reset (new std::ofstream (filename.str().c_str()));
503  // Redirect, saving the original streambufs!
504  out_buf = libMesh::out.rdbuf (_ofstream->rdbuf());
505  err_buf = libMesh::err.rdbuf (_ofstream->rdbuf());
506  }
libMesh::if ( libMesh::processor_id()!  = 0)

Definition at line 511 of file libmesh.C.

544 {
545  // We can't delete, finalize, etc. more than once without
546  // reinitializing in between
548 
549  // Delete reference counted singleton(s)
550  Singleton::cleanup();
551 
552  // Clear the thread task manager we started
553  task_scheduler.reset();
554 
555  // Let's be sure we properly close on every processor at once:
556  libmesh_parallel_only(this->comm());
557 
558 
559  // Force the \p ReferenceCounter to print
560  // its reference count information. This allows
561  // us to find memory leaks. By default the
562  // \p ReferenceCounter only prints its information
563  // when the last created object has been destroyed.
564  // That does no good if we are leaking memory!
565  ReferenceCounter::print_info ();
566 
567 
568  // Print an informative message if we detect a memory leak
569  if (ReferenceCounter::n_objects() != 0)
570  {
571  libMesh::err << "Memory leak detected!"
572  << std::endl;
573 
574 #if !defined(LIBMESH_ENABLE_REFERENCE_COUNTING) || defined(NDEBUG)
575 
576  libMesh::err << "Compile in DEBUG mode with --enable-reference-counting"
577  << std::endl
578  << "for more information"
579  << std::endl;
580 #endif
581 
582  }
583 
584  // print the perflog to individual processor's file.
586 
587  // Now clear the logging object, we don't want it to print
588  // a second time during the PerfLog destructor.
590 
591  // Reconnect the output streams
592  // (don't do this, or we will get messages from objects
593  // that go out of scope after the following return)
594  //std::cout.rdbuf(std::cerr.rdbuf());
595 
596 
597  // Set the initialized() flag to false
599 
600  if (libMesh::on_command_line ("--redirect-stdout"))
601  {
602  // If stdout/stderr were redirected to files, reset them now.
605  }
606 
607  // If we built our own output streams, we want to clean them up.
608  if (libMesh::on_command_line ("--separate-libmeshout"))
609  {
610  delete libMesh::out.get();
611  delete libMesh::err.get();
612 
613  libMesh::out.reset(std::cout);
614  libMesh::err.reset(std::cerr);
615  }
616 
617 #ifdef LIBMESH_ENABLE_EXCEPTIONS
618  // Reset the old terminate handler; maybe the user code wants to
619  // keep doing C++ stuff after closing libMesh stuff.
620  std::set_terminate(old_terminate_handler);
621 #endif
622 
623 
624  if (libMesh::on_command_line("--enable-fpe"))
625  libMesh::enableFPE(false);
626 
627 #if defined(LIBMESH_HAVE_PETSC)
628  // Allow the user to bypass PETSc finalization
629  if (!libMesh::on_command_line ("--disable-petsc")
630 #if defined(LIBMESH_HAVE_MPI)
631  && !libMesh::on_command_line ("--disable-mpi")
632 #endif
633  )
634  {
635 # if defined(LIBMESH_HAVE_SLEPC)
637  SlepcFinalize();
638 # else
640  PetscFinalize();
641 # endif
642  }
643 #endif
644 
645 
646 #if defined(LIBMESH_HAVE_MPI)
647  // Allow the user to bypass MPI finalization
648  if (!libMesh::on_command_line ("--disable-mpi"))
649  {
650  this->_comm.clear();
651 #ifndef LIBMESH_DISABLE_COMMWORLD
653 #endif
654 
656  MPI_Finalize();
657  }
658 #endif
659 }
const Number libMesh::imaginary ( 0.  ,
1.   
)
bool libMesh::initialized ( )

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

Definition at line 243 of file libmesh.C.

References libMesh::libMeshPrivateData::_is_initialized.

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

244 {
246 }
libMesh::INSTANTIATE_ALL_MAPS ( )
libMesh::INSTANTIATE_ALL_MAPS ( )
libMesh::INSTANTIATE_ALL_MAPS ( )
libMesh::INSTANTIATE_ALL_MAPS ( )
libMesh::INSTANTIATE_FE ( )
libMesh::INSTANTIATE_FE ( )
libMesh::INSTANTIATE_FE ( )
libMesh::INSTANTIATE_FE ( )
libMesh::INSTANTIATE_INF_FE ( ,
CARTESIAN   
)

Collect all 1D explicit instantiations for class InfFE

libMesh::INSTANTIATE_INF_FE ( ,
CARTESIAN   
)

Collect all 2D explicit instantiations for class InfFE

libMesh::INSTANTIATE_INF_FE ( ,
CARTESIAN   
)

Collect all 3D explicit instantiations for class InfFE

libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Elem *  ,
Base::  build_elemconst Elem * 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Elem *  ,
Base::  build_elemconst Elem * 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Elem *  ,
Base::  build_elemconst Elem * 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
ElemType  ,
Base::  get_elem_typeconst ElemType type 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
ElemType  ,
Base::  get_elem_typeconst ElemType type 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
ElemType  ,
Base::  get_elem_typeconst ElemType type 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
Base::  n_base_mapping_sfconst ElemType, const Order 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
Base::  n_base_mapping_sfconst ElemType, const Order 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
Base::  n_base_mapping_sfconst ElemType, const Order 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
Radial::  n_dofs_at_nodeconst Order, const unsigned int 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
Radial::  n_dofs_at_nodeconst Order, const unsigned int 
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
Radial::  n_dofs_at_nodeconst Order, const unsigned int 
)
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)   
)
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)   
)
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)   
)
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)   
)
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)   
)
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)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
init_face_shape_functions(const std::vector< Point > &, const Elem *)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
init_face_shape_functions(const std::vector< Point > &, const Elem *)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
init_face_shape_functions(const std::vector< Point > &, const Elem *)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Point  ,
inverse_map(const Elem *, const Point &, const Real, const bool, const bool)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Point  ,
inverse_map(const Elem *, const Point &, const Real, const bool, const bool)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Point  ,
inverse_map(const Elem *, const Point &, const Real, const bool, const bool)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
inverse_map(const Elem *, const std::vector< Point > &, std::vector< Point > &, const Real, const bool)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
n_dofs(const FEType &, const ElemType)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
n_dofs(const FEType &, const ElemType)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
n_dofs(const FEType &, const ElemType)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
n_dofs_per_elem(const FEType &, const ElemType)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
n_dofs_per_elem(const FEType &, const ElemType)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
n_dofs_per_elem(const FEType &, const ElemType)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
n_dofs_at_node(const FEType &, const ElemType, const unsigned int)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
n_dofs_at_node(const FEType &, const ElemType, const unsigned int)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
unsigned  int,
n_dofs_at_node(const FEType &, const ElemType, const unsigned int)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
compute_shape_indices(const FEType &, const ElemType, const unsigned int, unsigned int &, unsigned int &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
compute_node_indices(const ElemType, const unsigned int, unsigned int &, unsigned int &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Real  ,
shape(const FEType &, const Elem *, const unsigned int, const Point &p)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Real  ,
shape(const FEType &, const Elem *, const unsigned int, const Point &p)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Real  ,
shape(const FEType &, const Elem *, const unsigned int, const Point &p)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Real  ,
shape(const FEType &, const ElemType, const unsigned int, const Point &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Real  ,
shape(const FEType &, const ElemType, const unsigned int, const Point &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
Real  ,
shape(const FEType &, const ElemType, const unsigned int, const Point &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
compute_data(const FEType &, const Elem *, FEComputeData &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
compute_data(const FEType &, const Elem *, FEComputeData &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
compute_data(const FEType &, const Elem *, FEComputeData &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &)   
)
libMesh::INSTANTIATE_INF_FE_MBRF ( ,
CARTESIAN  ,
void  ,
nodal_soln(const FEType &, const Elem *, const std::vector< Number > &, std::vector< Number > &)   
)
bool libMesh::is_between ( Real  min,
Real  check,
Real  max 
)

Definition at line 239 of file mesh_tools.C.

References std::max().

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

240 {
241  return min <= check && check <= max;
242 }
libMesh::libmesh_assert ( remote_elem  )

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

libMesh::libmesh_assert_greater ( libMeshPrivateData::_n_processors  ,
 
)

Referenced by libMesh::MetisPartitioner::_do_partition(), libMesh::LinearPartitioner::_do_partition(), libMesh::SFCPartitioner::_do_partition(), libMesh::CentroidPartitioner::_do_partition(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::Sphere::above_surface(), libMesh::MeshTools::Modification::all_tri(), libMesh::Sphere::below_surface(), libMesh::Sphere::closest_point(), libMesh::QGrundmann_Moller::compose_all(), libMesh::FEMap::compute_edge_map(), libMesh::FEXYZMap::compute_face_map(), libMesh::FEMap::compute_face_map(), libMesh::DofMap::constrain_p_dofs(), libMesh::Sphere::create_from_center_radius(), libMesh::Sphere::distance(), libMesh::PltLoader::elem_type(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::FEMContext::fixed_interior_hessian(), libMesh::FEMContext::fixed_interior_value(), libMesh::FEMContext::fixed_point_gradient(), libMesh::FEMContext::fixed_point_hessian(), libMesh::FEMContext::fixed_point_value(), libMesh::FEMContext::fixed_side_gradient(), libMesh::FEMContext::fixed_side_hessian(), libMesh::FEMContext::fixed_side_value(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::DofMap::get_adjoint_dirichlet_boundaries(), libMesh::PerfLog::get_info_header(), libMesh::EigenSparseMatrix< T >::init(), libMesh::MeshFunction::init(), libMesh::FrequencySystem::init_data(), libMesh::FEMContext::interior_curl(), libMesh::FEMContext::interior_div(), libMesh::FEMContext::interior_gradient(), libMesh::FEMContext::interior_gradients(), libMesh::FEMContext::interior_hessian(), libMesh::FEMContext::interior_hessians(), libMesh::FEMContext::interior_value(), libMesh::FEMContext::interior_values(), libMesh::FE< Dim, T >::inverse_map(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::inverse_map(), libMesh::DistributedVector< T >::localize(), libMesh::EpetraVector< T >::localize(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Tri3::min_and_max_angle(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::PltLoader::n_elem(), libMesh::PltLoader::n_nodes(), libMesh::DofMap::old_dof_indices(), libMesh::Sphere::on_surface(), libMesh::METIS_CSR_Graph::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::ParameterVector::operator[](), libMesh::FEMContext::point_curl(), libMesh::FEMContext::point_gradient(), libMesh::FEMContext::point_hessian(), libMesh::Elem::point_test(), libMesh::FEMContext::point_value(), libMesh::MatlabIO::read_stream(), libMesh::DofMap::remove_adjoint_dirichlet_boundary(), libMesh::QBase::scale(), libMesh::FrequencySystem::set_frequencies_by_range(), libMesh::FE< Dim, T >::shape(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FEMContext::side_gradient(), libMesh::FEMContext::side_gradients(), libMesh::FEMContext::side_hessian(), libMesh::FEMContext::side_hessians(), libMesh::FEMContext::side_value(), libMesh::FEMContext::side_values(), libMesh::VariationalMeshSmoother::smooth(), libMesh::FrequencySystem::solve(), libMesh::Sphere::Sphere(), libMesh::Sphere::unit_normal(), and libMesh::PostscriptIO::write().

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

Definition at line 448 of file libmesh_common.h.

449 {
450  libmesh_assert_equal_to
451  (oldvar, static_cast<Told>(static_cast<Tnew>(oldvar)));
452 
453  return(static_cast<Tnew>(oldvar));
454 }
template<typename Tnew , typename Told >
Tnew libMesh::libmesh_cast_ptr ( Told *  oldvar)
inline

Definition at line 419 of file libmesh_common.h.

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

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

420 {
421 #if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI)
422  Tnew newvar = dynamic_cast<Tnew>(oldvar);
423  if (!newvar)
424  {
425  libMesh::err << "Failed to convert " << typeid(Told).name()
426  << " pointer to " << typeid(Tnew).name()
427  << std::endl;
428  libMesh::err << "The " << typeid(Told).name()
429  << " appears to be a "
430  << typeid(*oldvar).name() << std::endl;
431  libmesh_error();
432  }
433  return newvar;
434 #else
435  return(static_cast<Tnew>(oldvar));
436 #endif
437 }
template<typename Tnew , typename Told >
Tnew libMesh::libmesh_cast_ref ( Told &  oldvar)
inline

Definition at line 393 of file libmesh_common.h.

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

394 {
395 #if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI)
396  try
397  {
398  Tnew newvar = dynamic_cast<Tnew>(oldvar);
399  return newvar;
400  }
401  catch (std::bad_cast)
402  {
403  libMesh::err << "Failed to convert " << typeid(Told).name()
404  << " reference to " << typeid(Tnew).name()
405  << std::endl;
406  libMesh::err << "The " << typeid(Told).name()
407  << " appears to be a "
408  << typeid(*(&oldvar)).name() << std::endl;
409  libmesh_error();
410  }
411 #else
412  return(static_cast<Tnew>(oldvar));
413 #endif
414 }
template<typename T >
T libMesh::libmesh_conj ( a)
inline
template<typename T >
std::complex<T> libMesh::libmesh_conj ( std::complex< T >  a)
inline

Definition at line 149 of file libmesh_common.h.

149 { return std::conj(a); }
template<class T >
void libMesh::libmesh_ignore ( const T &  )
inline

Definition at line 495 of file libmesh_common.h.

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

495 { }
bool libMesh::libmesh_isnan ( float  a)
inline
bool libMesh::libmesh_isnan ( double  a)
inline

Definition at line 154 of file libmesh_common.h.

References libmesh_C_isnan_double().

154 { return libmesh_C_isnan_double(a); }
bool libMesh::libmesh_isnan ( long double  a)
inline

Definition at line 155 of file libmesh_common.h.

References libmesh_C_isnan_longdouble().

155 { return libmesh_C_isnan_longdouble(a); }
template<typename T >
bool libMesh::libmesh_isnan ( std::complex< T >  a)
inline

Definition at line 158 of file libmesh_common.h.

References libmesh_isnan().

158 { return (libmesh_isnan(std::real(a)) || libmesh_isnan(std::imag(a))); }
template<typename T >
T libMesh::libmesh_real ( std::complex< T >  a)
inline

Definition at line 146 of file libmesh_common.h.

146 { return std::real(a); }
void libMesh::libmesh_terminate_handler ( )

Definition at line 259 of file libmesh.C.

References COMM_WORLD, old_terminate_handler, and write_traceout().

260 {
261  // If this got called then we're probably crashing; let's print a
262  // stack trace. The trace files that are ultimately written depend on:
263  // 1.) Who throws the exception.
264  // 2.) Whether the C++ runtime unwinds the stack before the
265  // terminate_handler is called (this is implementation defined).
266  //
267  // The various cases are summarized in the table below:
268  //
269  // | libmesh exception | other exception
270  // -------------------------------------
271  // stack unwinds | A | B
272  // stack does not unwind | C | D
273  //
274  // Case A: There will be two stack traces in the file: one "useful"
275  // one, and one nearly empty one due to stack unwinding.
276  // Case B: You will get one nearly empty stack trace (not great, Bob!)
277  // Case C: You will get two nearly identical stack traces, ignore one of them.
278  // Case D: You will get one useful stack trace.
279  //
280  // Cases A and B (where the stack unwinds when an exception leaves
281  // main) appear to be non-existent in practice. I don't have a
282  // definitive list, but the stack does not unwind for GCC on either
283  // Mac or Linux. I think there's good reasons for this behavior too:
284  // it's much easier to get a stack trace when the stack doesn't
285  // unwind, for example.
287 
288  // If we have MPI and it has been initialized, we need to be sure
289  // and call MPI_Abort instead of std::abort, so that the parallel
290  // job can die nicely.
291 #if defined(LIBMESH_HAVE_MPI)
292  int mpi_initialized;
293  MPI_Initialized (&mpi_initialized);
294 
295  if (mpi_initialized)
296  MPI_Abort(libMesh::COMM_WORLD, 1);
297  else
298 #endif
299  // The system terminate_handler may do useful things like printing
300  // uncaught exception information, or the user may have created
301  // their own terminate handler that we want to call.
303 }
void libMesh::libmesh_version_stdout ( )

Definition at line 20 of file libmesh_version.C.

References get_libmesh_version().

21 {
22  std::cout << "--------------------------------------------------------" << std::endl;
23  std::cout << "libMesh Library: Version = " << LIBMESH_LIB_VERSION;
24  std::cout << " (" << get_libmesh_version() << ")" << std::endl << std::endl;
25 
26  std::cout << LIBMESH_LIB_RELEASE << std::endl << std::endl;
27 
28  std::cout << "Build Date = " << LIBMESH_BUILD_DATE << std::endl;
29  std::cout << "Build Host = " << LIBMESH_BUILD_HOST << std::endl;
30  std::cout << "Build User = " << LIBMESH_BUILD_USER << std::endl;
31  std::cout << "Build Arch = " << LIBMESH_BUILD_ARCH << std::endl;
32  std::cout << "Build Rev = " << LIBMESH_BUILD_VERSION << std::endl << std::endl;
33 
34  // CXXFLAGS is ambiguous wth multiple methods - could add all three but why not libmesh-config?
35  //std::cout << "C++ Config = " << LIBMESH_CXX << " " << LIBMESH_CXXFLAGS << std::endl;
36  std::cout << "--------------------------------------------------------" << std::endl;
37 
38  return;
39 }
unsigned int libMesh::n_threads ( )
Returns
the maximum number of threads used in the simulation.
libMesh::omp_set_num_threads ( libMesh::libMeshPrivateData::_n_threads  )
bool libMesh::on_command_line ( const std::string &  arg)
Returns
true if the argument arg was specified on the command line, false otherwise.

Definition at line 710 of file libmesh.C.

References EXTERN_C_FOR_PETSC_END::command_line, and libmesh_assert().

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

711 {
712  // Make sure the command line parser is ready for use
714 
715  return command_line->search (arg);
716 }
template<typename T , typename Scalar >
boostcopy::enable_if_c< ScalarTraits<Scalar>::value, TypeVector<typename CompareTypes<T, Scalar>::supertype> >::type libMesh::operator* ( const Scalar  factor,
const TypeVector< T > &  v 
)
inline

Definition at line 679 of file type_vector.h.

681 {
682  return v * factor;
683 }
template<typename T , typename Scalar >
boostcopy::enable_if_c< ScalarTraits<Scalar>::value, TypeTensor<typename CompareTypes<T, Scalar>::supertype> >::type libMesh::operator* ( const Scalar  factor,
const TypeTensor< T > &  t 
)
inline

Definition at line 869 of file type_tensor.h.

871 {
872  return t * factor;
873 }
template<typename T >
std::ostream & libMesh::operator<< ( std::ostream &  os,
const SparseMatrix< T > &  m 
)

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

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

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

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

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

Definition at line 458 of file sparse_matrix.h.

459 {
460  m.print(os);
461  return os;
462 }
std::ostream& libMesh::operator<< ( std::ostream &  os,
const QBase &  q 
)

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

Definition at line 197 of file quadrature.C.

References libMesh::QBase::print_info().

198 {
199  q.print_info(os);
200  return os;
201 }
std::ostream& libMesh::operator<< ( std::ostream &  os,
const Node &  n 
)
inline

Definition at line 237 of file node.h.

References libMesh::Node::print_info().

238 {
239  n.print_info(os);
240  return os;
241 }
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 336 of file mesh_base.C.

References libMesh::MeshBase::print_info().

337 {
338  m.print_info(os);
339  return os;
340 }
std::ostream& libMesh::operator<< ( std::ostream &  os,
const MeshData &  m 
)

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

Definition at line 374 of file mesh_data.C.

References libMesh::MeshData::print_info().

375 {
376  m.print_info(os);
377  return os;
378 }
std::ostream& libMesh::operator<< ( std::ostream &  os,
const Parameters &  p 
)
inline

Definition at line 403 of file parameters.h.

References libMesh::Parameters::print().

404 {
405  p.print(os);
406  return os;
407 }
std::ostream& libMesh::operator<< ( std::ostream &  os,
const FEAbstract &  fe 
)

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

Definition at line 909 of file fe_abstract.C.

References libMesh::FEAbstract::print_info().

910 {
911  fe.print_info(os);
912  return os;
913 }
std::ostream& libMesh::operator<< ( std::ostream &  os,
const EquationSystems &  es 
)

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

Definition at line 1216 of file equation_systems.C.

References libMesh::EquationSystems::print_info().

1217 {
1218  es.print_info(os);
1219  return os;
1220 }
std::ostream& libMesh::operator<< ( std::ostream &  os,
const Elem &  e 
)
inline

Definition at line 1266 of file elem.h.

References libMesh::Elem::print_info().

1267 {
1268  e.print_info(os);
1269  return os;
1270 }
command_line libMesh::parse_command_line ( argc  ,
argv   
)
void libMesh::PetscDMGetSystem ( DM  ,
NonlinearImplicitSystem *&   
)
void libMesh::PetscDMRegister ( )

Definition at line 51 of file petsc_dm_nonlinear_solver.C.

References CHKERRABORT(), COMM_WORLD, DMCreate_libMesh(), ierr, and PetscDMRegistered.

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

52  {
54  return;
55 
57 #if PETSC_RELEASE_LESS_THAN(3,4,0)
58  ierr = DMRegister(DMLIBMESH, PETSC_NULL, "DMCreate_libMesh", DMCreate_libMesh); CHKERRABORT(libMesh::COMM_WORLD,ierr);
59 #else
60  ierr = DMRegister(DMLIBMESH, DMCreate_libMesh); CHKERRABORT(libMesh::COMM_WORLD,ierr);
61 #endif
62  PetscDMRegistered = PETSC_TRUE;
63  }
void libMesh::PetscDMSetSystem ( DM  ,
NonlinearImplicitSystem &   
)
template<typename P >
void libMesh::print_helper ( std::ostream &  os,
const P *  param 
)

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

Definition at line 538 of file parameters.h.

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

539 {
540  os << *param;
541 }
template<typename P >
void libMesh::print_helper ( std::ostream &  os,
const std::vector< P > *  param 
)

Definition at line 545 of file parameters.h.

546 {
547  for (unsigned int i=0; i<param->size(); ++i)
548  os << (*param)[i] << " ";
549 }
void libMesh::print_trace ( std::ostream &  out)

Definition at line 108 of file print_trace.C.

References process_trace().

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

109 {
110  void *addresses[40];
111  char **strings;
112 
113  int size = backtrace(addresses, 40);
114  strings = backtrace_symbols(addresses, size);
115  out << "Stack frames: " << size << std::endl;
116  for(int i = 0; i < size; i++)
117  out << i << ": " << process_trace(strings[i]) << std::endl;
118  std::free(strings);
119 }
std::string libMesh::process_trace ( const char *  name)

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

lineno: stackframeno address functionname + offset

Definition at line 47 of file print_trace.C.

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

Referenced by print_trace().

48 {
49  std::string fullname = name;
50  std::string saved_begin, saved_end;
51  size_t namestart, nameend;
52 
60 #ifdef __APPLE__
61  namestart = fullname.find("0x");
62  if (namestart != std::string::npos)
63  {
64  namestart = fullname.find(' ', namestart) + 1;
65  saved_begin = fullname.substr(0, namestart);
66  }
67  else
68  namestart = 0;
69  nameend = fullname.find('+');
70  if (nameend == std::string::npos ||
71  nameend <= namestart)
72  nameend = fullname.size();
73  else
74  {
75  nameend -= 1;
76  saved_end = fullname.substr(nameend, fullname.length());
77  }
78 #else
79  namestart = fullname.find('(');
80  if (namestart == std::string::npos)
81  return fullname;
82  else
83  namestart++;
84  nameend = fullname.find('+');
85  if (nameend == std::string::npos ||
86  nameend <= namestart)
87  return fullname;
88 #endif
89 
90  std::string type_name = fullname.substr(namestart, nameend - namestart);
91 
92  // Try to demangle now
93  return saved_begin + demangle(type_name.c_str()) + saved_end;
94 }
libMesh::processor_id_type libMesh::processor_id ( )
inline
Returns
the index of the local processor.

Definition at line 86 of file libmesh_base.h.

References libMesh::libMeshPrivateData::_processor_id.

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

87 {
88 #ifdef LIBMESH_HAVE_MPI
90 #else
91  return 0;
92 #endif
93 }
this libMesh::reduce_error ( error_per_cell  ,
system.  comm() 
)
libMesh::REINIT_ERROR ( REINIT_ERROR(  0,
REINIT_ERROR(  CLOUGH,
reinit   
)

Definition at line 76 of file fe_boundary.C.

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

145 {
146  libmesh_assert(elem);
147  libmesh_assert (this->qrule != NULL || pts != NULL);
148  // We now do this for 1D elements!
149  // libmesh_assert_not_equal_to (Dim, 1);
150 
151  // Build the side of interest
152  const AutoPtr<Elem> side(elem->build_side(s));
153 
154  // Find the max p_level to select
155  // the right quadrature rule for side integration
156  unsigned int side_p_level = elem->p_level();
157  if (elem->neighbor(s) != NULL)
158  side_p_level = std::max(side_p_level, elem->neighbor(s)->p_level());
159 
160  // Initialize the shape functions at the user-specified
161  // points
162  if (pts != NULL)
163  {
164  // The shape functions do not correspond to the qrule
165  this->shapes_on_quadrature = false;
166 
167  // Initialize the face shape functions
168  this->_fe_map->template init_face_shape_functions<Dim>(*pts, side.get());
169 
170  // Compute the Jacobian*Weight on the face for integration
171  if (weights != NULL)
172  {
173  this->_fe_map->compute_face_map (Dim, *weights, side.get());
174  }
175  else
176  {
177  std::vector<Real> dummy_weights (pts->size(), 1.);
178  this->_fe_map->compute_face_map (Dim, dummy_weights, side.get());
179  }
180  }
181  // If there are no user specified points, we use the
182  // quadrature rule
183  else
184  {
185  // initialize quadrature rule
186  this->qrule->init(side->type(), side_p_level);
187 
188  if(this->qrule->shapes_need_reinit())
189  this->shapes_on_quadrature = false;
190 
191  // FIXME - could this break if the same FE object was used
192  // for both volume and face integrals? - RHS
193  // We might not need to reinitialize the shape functions
194  if ((this->get_type() != elem->type()) ||
195  (side->type() != last_side) ||
196  (this->get_p_level() != side_p_level) ||
197  this->shapes_need_reinit() ||
198  !this->shapes_on_quadrature)
199  {
200  // Set the element type and p_level
201  this->elem_type = elem->type();
202 
203  // Set the last_side
204  last_side = side->type();
205 
206  // Set the last p level
207  this->_p_level = side_p_level;
208 
209  // Initialize the face shape functions
210  this->_fe_map->template init_face_shape_functions<Dim>(this->qrule->get_points(), side.get());
211  }
212 
213  // Compute the Jacobian*Weight on the face for integration
214  this->_fe_map->compute_face_map (Dim, this->qrule->get_weights(), side.get());
215 
216  // The shape functions correspond to the qrule
217  this->shapes_on_quadrature = true;
218  }
219 
220  // make a copy of the Jacobian for integration
221  const std::vector<Real> JxW_int(this->_fe_map->get_JxW());
222 
223  // make a copy of shape on quadrature info
224  bool shapes_on_quadrature_side = this->shapes_on_quadrature;
225 
226  // Find where the integration points are located on the
227  // full element.
228  const std::vector<Point>* ref_qp;
229  if (pts != NULL)
230  ref_qp = pts;
231  else
232  ref_qp = &this->qrule->get_points();
233 
234  std::vector<Point> qp;
235  this->side_map(elem, side.get(), s, *ref_qp, qp);
236 
237  // compute the shape function and derivative values
238  // at the points qp
239  this->reinit (elem, &qp);
240 
241  this->shapes_on_quadrature = shapes_on_quadrature_side;
242 
243  // copy back old data
244  this->_fe_map->get_JxW() = JxW_int;
245 }
task_scheduler libMesh::reset ( new Threads::  task_scheduler_initlibMesh::n_threads())
libMesh::ScalarTraits_true ( char  )
libMesh::ScalarTraits_true ( short  )
libMesh::ScalarTraits_true ( int  )
libMesh::ScalarTraits_true ( long  )
libMesh::ScalarTraits_true ( unsigned  char)
libMesh::ScalarTraits_true ( float  )
libMesh::ScalarTraits_true ( double  )
template<typename T >
T libMesh::SIGN ( 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 }
libMesh::START_LOG ( "std::sqrt()"  ,
"ExactErrorEstimator"   
)

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

libMesh::STOP_LOG ( "std::sqrt()"  ,
"ExactErrorEstimator"   
)

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

libMesh::SUPERTYPE ( unsigned  char,
short   
)
libMesh::SUPERTYPE ( unsigned  char,
int   
)
libMesh::SUPERTYPE ( unsigned  char,
float   
)
libMesh::SUPERTYPE ( unsigned  char,
double   
)
libMesh::SUPERTYPE ( unsigned  char,
long  double 
)
libMesh::SUPERTYPE ( char  ,
short   
)
libMesh::SUPERTYPE ( char  ,
int   
)
libMesh::SUPERTYPE ( char  ,
float   
)
libMesh::SUPERTYPE ( char  ,
double   
)
libMesh::SUPERTYPE ( char  ,
long  double 
)
libMesh::SUPERTYPE ( short  ,
int   
)
libMesh::SUPERTYPE ( short  ,
float   
)
libMesh::SUPERTYPE ( short  ,
double   
)
libMesh::SUPERTYPE ( short  ,
long  double 
)
libMesh::SUPERTYPE ( int  ,
float   
)
libMesh::SUPERTYPE ( int  ,
double   
)
libMesh::SUPERTYPE ( int  ,
long  double 
)
libMesh::SUPERTYPE ( float  ,
double   
)
libMesh::SUPERTYPE ( float  ,
long  double 
)
libMesh::SUPERTYPE ( double  ,
long  double 
)
void libMesh::write_traceout ( )

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

Definition at line 137 of file print_trace.C.

References print_trace(), and processor_id().

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

138  {
139 #ifdef LIBMESH_ENABLE_TRACEFILES
140  std::stringstream outname;
141  outname << "traceout_" << static_cast<std::size_t>(libMesh::processor_id()) << '_' << getpid() << ".txt";
142  std::ofstream traceout(outname.str().c_str(), std::ofstream::app);
143  libMesh::print_trace(traceout);
144 #endif
145  }
template void libMesh::Xdr::data< std::complex< double > > ( std::complex< double > &  ,
const char *   
)
template void libMesh::Xdr::data< std::complex< float > > ( std::complex< float > &  ,
const char *   
)
template void libMesh::Xdr::data< std::complex< long double > > ( std::complex< long double > &  ,
const char *   
)
template void libMesh::Xdr::data< std::string > ( std::string &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< char > > ( std::vector< char > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< double > > ( std::vector< double > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< float > > ( std::vector< float > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< int > > ( std::vector< int > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< long double > > ( std::vector< long double > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< long int > > ( std::vector< long int > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< short int > > ( std::vector< short int > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< signed char > > ( std::vector< signed char > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< std::complex< double > > > ( std::vector< std::complex< double > > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< std::complex< float > > > ( std::vector< std::complex< float > > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< std::complex< long double > > > ( std::vector< std::complex< long double > > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< std::string > > ( std::vector< std::string > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< unsigned char > > ( std::vector< unsigned char > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< unsigned int > > ( std::vector< unsigned int > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< unsigned long int > > ( std::vector< unsigned long int > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< unsigned long long > > ( std::vector< unsigned long long > &  ,
const char *   
)
template void libMesh::Xdr::data< std::vector< unsigned short int > > ( std::vector< unsigned short int > &  ,
const char *   
)

Variable Documentation

template<typename T >
void PetscPreconditioner<T>::set_petsc_subpreconditioner_type (PCType type, PC& pc) void PetscPreconditioner<T> Parallel::communicator libMesh::comm

Definition at line 244 of file petsc_preconditioner.C.

Referenced by libMesh::PetscMatrix< T >::_get_submatrix(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_solve_generalized_helper(), libMesh::SlepcEigenSolver< T >::_solve_standard_helper(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::PetscLinearSolver< T >::adjoint_solve(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::Parallel::Communicator::assign(), libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), libMesh::Parallel::Sort< KeyType, IdxType >::binsort(), libMesh::Preconditioner< T >::build(), libMesh::Parallel::Histogram< KeyType, IdxType >::build_histogram(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::DistributedVector< T >::clone(), libMesh::LaspackVector< T >::clone(), libMesh::EigenSparseVector< T >::clone(), libMesh::EpetraVector< T >::clone(), libMesh::PetscVector< T >::clone(), libMesh::EpetraVector< T >::close(), libMesh::Parallel::Sort< KeyType, IdxType >::communicate_bins(), libMesh::NumericVector< T >::compare(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::PetscVector< T >::create_subvector(), DMCreateDomainDecomposition_libMesh(), DMCreateDomainDecompositionDM_libMesh(), DMCreateFieldDecomposition_libMesh(), DMCreateFieldDecompositionDM_libMesh(), DMCreateGlobalVector_libMesh(), DMLibMeshCreateDomainDecompositionDM(), DMLibMeshCreateFieldDecompositionDM(), DMLibMeshGetBlocks(), DMLibMeshGetSystem(), DMLibMeshGetVariables(), DMLibMeshParseDecompositionDescriptor_Private(), DMLibMeshSetSystem(), DMSetUp_libMesh(), DMVariableBounds_libMesh(), DMView_libMesh(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::DofMap::get_info(), libMesh::NumericVector< T >::global_relative_compare(), if(), libMesh::SlepcEigenSolver< T >::init(), libMesh::PetscDMNonlinearSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::PetscPreconditioner< T >::init(), libMesh::EpetraMatrix< T >::init(), libMesh::PetscLinearSolver< T >::init(), libMesh::PetscMatrix< T >::init(), libMesh::DistributedVector< T >::init(), libMesh::EpetraVector< T >::init(), libMesh::PetscVector< T >::init(), libMesh::DistributedVector< T >::l1_norm(), libMesh::DistributedVector< T >::l2_norm(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedVector< T >::linfty_norm(), libMesh::NumericVector< T >::local_relative_compare(), libMesh::DistributedVector< T >::localize(), libMesh::EpetraVector< T >::localize(), libMesh::PetscVector< T >::localize(), libMesh::DistributedVector< T >::localize_to_one(), libMesh::EpetraVector< T >::localize_to_one(), libMesh::PetscVector< T >::localize_to_one(), libMesh::DistributedVector< T >::max(), libMesh::DistributedVector< T >::min(), libMesh::DofMap::n_constrained_dofs(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::SparseMatrix< T >::print(), libMesh::DofMap::print_dof_constraints(), libMesh::PetscMatrix< T >::print_matlab(), libMesh::PetscVector< T >::print_matlab(), libMesh::PetscMatrix< T >::print_personal(), libMesh::ParallelMesh::renumber_dof_objects(), libMesh::PetscLinearSolver< T >::restrict_solve_to(), libMesh::DofMap::scatter_constraints(), libMesh::PetscPreconditioner< T >::set_petsc_preconditioner_type(), libMesh::PetscLinearSolver< T >::solve(), libMesh::SlepcEigenSolver< T >::solve_generalized(), libMesh::SlepcEigenSolver< T >::solve_standard(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::NumericVector< T >::subset_l1_norm(), libMesh::NumericVector< T >::subset_l2_norm(), libMesh::NumericVector< T >::subset_linfty_norm(), libMesh::DistributedVector< T >::sum(), libMesh::EpetraVector< T >::sum(), libMesh::EpetraMatrix< T >::update_sparsity_pattern(), libMesh::DistributedVector< T >::zero_clone(), libMesh::LaspackVector< T >::zero_clone(), libMesh::EigenSparseVector< T >::zero_clone(), libMesh::EpetraVector< T >::zero_clone(), and libMesh::PetscVector< T >::zero_clone().

int libMesh::COMM_WORLD = MPI_COMM_NULL

MPI Communicator to be used in the library.

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

Definition at line 172 of file libmesh.C.

Referenced by __libmesh_petsc_diff_solver_monitor(), if(), libmesh_terminate_handler(), and PetscDMRegister().

Parallel::Communicator libMesh::CommWorld

The default libMesh communicator.

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

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

Definition at line 178 of file libmesh.C.

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

const unsigned char libMesh::cube_number_column

Definition at line 85 of file number_lookups.C.

const unsigned char libMesh::cube_number_page

Definition at line 309 of file number_lookups.C.

const unsigned char libMesh::cube_number_row

Definition at line 197 of file number_lookups.C.

void ExactErrorEstimator::estimate_error (const System& system, ErrorVector& error_per_cell, const NumericVector<Number>* solution_vector, bool estimate_parent_error) void ExactErrorEstimator const unsigned in libMesh::dim) = mesh.mesh_dimension()

Definition at line 216 of file exact_error_estimator.C.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::System::calculate_norm(), libMesh::JumpErrorEstimator::coarse_n_flux_faces_increment(), libMesh::FEGenericBase< T >::coarsened_dof_values(), libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FEGenericBase< T >::compute_shape_functions(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::compute_shape_functions(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::DofMap::dof_indices(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::QGrundmann_Moller::gm_rule(), libMesh::MeshFunction::gradient(), libMesh::MeshFunction::hessian(), libMesh::XdrMESH::init(), libMesh::TreeNode< N >::insert(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DofMap::old_dof_indices(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::ProjectSolution::operator()(), libMesh::MeshFunction::operator()(), libMesh::ProjectFEMSolution::operator()(), libMesh::BoundaryProjectSolution::operator()(), libMesh::MeshBase::prepare_for_use(), libMesh::GmshIO::read_mesh(), libMesh::FE< Dim, T >::reinit(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::reinit(), libMesh::DofMap::reinit(), libMesh::HPCoarsenTest::select_refinement(), libMesh::FEInterface::shape(), libMesh::Side< SideType, ParentType >::Side(), libMesh::SideEdge< EdgeType, ParentType >::SideEdge(), libMesh::EnsightIO::write_scalar_ascii(), and libMesh::EnsightIO::write_vector_ascii().

OStreamProxy libMesh::err

Definition at line 201 of file libmesh_common.h.

Referenced by __libmesh_petsc_preconditioner_setup(), __libmesh_petsc_snes_jacobian(), __libmesh_petsc_snes_residual(), libMesh::ExactSolution::_check_inputs(), libMesh::DenseMatrix< T >::_cholesky_decompose(), libMesh::ExactSolution::_compute_error(), libMesh::MetisPartitioner::_do_partition(), libMesh::SFCPartitioner::_do_partition(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::SparseMatrix< Number >::_get_submatrix(), libMesh::GMVIO::_gmv_elem_to_libmesh_elem(), libMesh::SyncNodalPositions::act_on_data(), libMesh::MeshData::activate(), libMesh::DofMap::add_adjoint_constraint_row(), libMesh::Elem::add_child(), libMesh::DofMap::add_constraint_row(), libMesh::BoundaryInfo::add_edge(), libMesh::ImplicitSystem::add_matrix(), libMesh::BoundaryInfo::add_node(), libMesh::BoundaryInfo::add_side(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::LaspackLinearSolver< T >::adjoint_solve(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::TetGenWrapper::allocate_facet_polygonlist(), libMesh::TetGenWrapper::allocate_facetlist(), libMesh::TetGenWrapper::allocate_pointlist(), libMesh::TetGenWrapper::allocate_polygon_vertexlist(), libMesh::TetGenWrapper::allocate_regionlist(), libMesh::FrequencySystem::assemble(), libMesh::FEMSystem::assembly(), libMesh::NonlinearImplicitSystem::assembly(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::ExodusII_IO_Helper::ElementMaps::assign_conversion(), libMesh::MeshCommunication::assign_global_indices(), libMesh::TetGenMeshInterface::assign_nodes_to_elem(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::LinearSolver< T >::attach_preconditioner(), libMesh::NonlinearSolver< T >::attach_preconditioner(), libMesh::Factory< Base >::build(), libMesh::EigenSolver< T >::build(), libMesh::LinearSolver< T >::build(), libMesh::NonlinearSolver< T >::build(), libMesh::Preconditioner< T >::build(), libMesh::PointLocatorBase::build(), libMesh::QBase::build(), libMesh::SparseMatrix< T >::build(), libMesh::Elem::build(), libMesh::Patch::build_around_element(), libMesh::MeshTools::Generation::build_cube(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::FEGenericBase< T >::build_InfFE(), libMesh::EquationSystems::build_variable_names(), libMesh::VTKIO::cells_to_vtk(), libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::DenseMatrix< T >::cholesky_solve(), libMesh::Xdr::close(), libMesh::WrappedFunction< Output >::component(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::compute_data(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::compute_node_indices(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::compute_node_indices_fast(), libMesh::FEGenericBase< T >::compute_periodic_constraints(), libMesh::FEMap::compute_single_point_map(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::Elem::contains_point(), libMesh::ContinuationSystem::continuation_solve(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::GMVIO::copy_nodal_solution(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UNVIO::count_elements(), libMesh::UNVIO::count_nodes(), libMesh::TreeNode< N >::create_bounding_box(), libMesh::NumericVector< Number >::create_subvector(), libMesh::TensorTools::curl_from_grad(), libMesh::Xdr::data(), libMesh::Xdr::data_stream(), libMesh::EquationSystems::delete_system(), libMesh::DenseMatrix< T >::det(), libMesh::TensorTools::div_from_grad(), DMlibMeshFunction(), DMlibMeshJacobian(), libMesh::QGauss::dunavant_rule(), libMesh::QGauss::dunavant_rule2(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::edge_reinit(), libMesh::MeshData::elem_to_foreign_id(), libMesh::TetGenIO::element_in(), libMesh::UNVIO::element_in(), libMesh::UNVIO::element_out(), libMesh::MeshData::enable_compatibility_mode(), libMesh::PointLocatorTree::enable_out_of_mesh_mode(), libMesh::DofMap::enforce_adjoint_constraints_exactly(), libMesh::DofMap::enforce_constraints_exactly(), libMesh::ExactSolution::error_norm(), libMesh::FEInterface::FEInterface(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshData::foreign_id_to_elem(), libMesh::MeshData::foreign_id_to_node(), libMesh::SyncNodalPositions::gather_data(), libMesh::Parameters::get(), libMesh::ExodusII_IO_Helper::NamesData::get_char_star(), libMesh::MeshData::get_data(), libMesh::VTKIO::get_elem_type(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::Base::get_elem_type(), libMesh::BoundaryInfo::get_id_by_name(), libMesh::MeshBase::get_id_by_name(), libMesh::PetscLinearSolver< T >::get_initial_residual(), libMesh::ImplicitSystem::get_matrix(), libMesh::ExodusII_IO::get_num_time_steps(), libMesh::TetGenWrapper::get_output_node(), libMesh::FEAbstract::get_refspace_nodes(), libMesh::EquationSystems::get_system(), libMesh::ExodusII_IO::get_time_steps(), libMesh::System::get_vector(), libMesh::ParsedFunction< Output >::getVarAddress(), libMesh::MeshFunction::gradient(), libMesh::XdrMESH::header(), libMesh::MacroFunctions::here(), libMesh::MeshFunction::hessian(), libMesh::MeshTools::Generation::Private::idx(), if(), libMesh::FEInterface::ifem_inverse_map(), libMesh::FEInterface::ifem_nodal_soln(), libMesh::LaplaceMeshSmoother::init(), libMesh::PetscPreconditioner< T >::init(), libMesh::TrilinosPreconditioner< T >::init(), libMesh::PointLocatorTree::init(), libMesh::PointLocatorList::init(), libMesh::MeshFunction::init(), libMesh::XdrMGF::init(), libMesh::DistributedVector< T >::init(), libMesh::QGauss::init_1D(), libMesh::QJacobi::init_1D(), libMesh::QTrap::init_2D(), libMesh::QClough::init_2D(), libMesh::QGrid::init_2D(), libMesh::QGauss::init_2D(), libMesh::QSimpson::init_2D(), libMesh::QConical::init_2D(), libMesh::QTrap::init_3D(), libMesh::QClough::init_3D(), libMesh::QGrid::init_3D(), libMesh::QGauss::init_3D(), libMesh::QSimpson::init_3D(), libMesh::QConical::init_3D(), libMesh::QGrundmann_Moller::init_3D(), libMesh::FrequencySystem::init_data(), libMesh::System::init_data(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::init_shape_functions(), libMesh::ParmetisPartitioner::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::EpetraVector< T >::inputNonlocalValues(), libMesh::MeshData::insert_elem_data(), libMesh::SerialMesh::insert_node(), libMesh::MeshData::insert_node_data(), libMesh::FEInterface::inverse_map(), libMesh::FE< Dim, T >::inverse_map(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::inverse_map(), libMesh::Xdr::is_open(), libMesh::InverseDistanceInterpolation< KDDim >::PointListAdaptor< KDDim >::kdtree_distance(), libMesh::QGauss::keast_rule(), libMesh::QMonomial::kim_rule(), libmesh_cast_ptr(), libmesh_cast_ref(), EXTERN_C_FOR_PETSC_END::libmesh_handleFPE(), libMesh::DenseMatrix< T >::lu_solve(), libMesh::HCurlFETransformation< T >::map_curl(), libMesh::H1FETransformation< T >::map_curl(), libMesh::H1FETransformation< T >::map_d2phi(), libMesh::HCurlFETransformation< T >::map_d2phi(), libMesh::HCurlFETransformation< T >::map_div(), libMesh::H1FETransformation< T >::map_div(), libMesh::HCurlFETransformation< T >::map_dphi(), libMesh::PetscVector< T >::map_global_to_local_index(), libMesh::HCurlFETransformation< T >::map_phi(), libMesh::ElementTypes::name(), libMesh::QuadratureRules::name(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::nodal_soln(), libMesh::UNVIO::node_in(), libMesh::MeshData::node_to_foreign_id(), libMesh::FEAbstract::on_reference_element(), libMesh::Xdr::open(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshFunction::operator()(), libMesh::MeshDataUnvHeader::operator=(), libMesh::ErrorVector::plot_error(), libMesh::PerfLog::pop(), libMesh::SparseMatrix< Number >::print_matlab(), libMesh::NumericVector< Number >::print_matlab(), libMesh::TetGenMeshInterface::process_hull_integrity_result(), libMesh::System::project_vector(), libMesh::Elem::quality(), libMesh::AbaqusIO::read(), libMesh::UCDIO::read(), libMesh::PltLoader::read(), libMesh::TetGenIO::read(), libMesh::UNVIO::read(), libMesh::ExodusII_IO::read(), libMesh::Nemesis_IO::read(), libMesh::GMVIO::read(), libMesh::CheckpointIO::read(), libMesh::UnstructuredMesh::read(), libMesh::VTKIO::read(), libMesh::MeshData::read(), libMesh::LegacyXdrIO::read_binary(), libMesh::PltLoader::read_block_data(), libMesh::PltLoader::read_data(), libMesh::ExodusII_IO_Helper::read_elemental_var_values(), libMesh::AbaqusIO::read_elements(), libMesh::PltLoader::read_feblock_data(), libMesh::PltLoader::read_fepoint_data(), libMesh::PltLoader::read_header(), libMesh::UCDIO::read_implementation(), libMesh::UNVIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::LegacyXdrIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_nodal_var_values(), libMesh::PltLoader::read_point_data(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::MeshData::read_tetgen(), libMesh::MeshData::read_unv(), libMesh::MeshData::read_unv_implementation(), libMesh::ExodusII_IO_Helper::read_var_names(), libMesh::MeshData::read_xdr(), libMesh::EpetraVector< T >::reciprocal(), libMesh::FEXYZ< Dim >::reinit(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::reinit(), libMesh::DofMap::reinit(), libMesh::System::restrict_vectors(), libMesh::DofMap::SCALAR_dof_indices(), libMesh::HPCoarsenTest::select_refinement(), libMesh::FrequencySystem::set_frequencies(), libMesh::FrequencySystem::set_frequencies_by_range(), libMesh::FrequencySystem::set_frequencies_by_steps(), libMesh::LaspackLinearSolver< T >::set_laspack_preconditioner_type(), libMesh::DofObject::set_n_comp_group(), libMesh::PetscPreconditioner< T >::set_petsc_preconditioner_type(), libMesh::PetscLinearSolver< T >::set_petsc_solver_type(), libMesh::TrilinosPreconditioner< T >::set_preconditioner_type(), libMesh::SlepcEigenSolver< T >::set_slepc_position_of_spectrum(), libMesh::SlepcEigenSolver< T >::set_slepc_problem_type(), libMesh::SlepcEigenSolver< T >::set_slepc_solver_type(), libMesh::AztecLinearSolver< T >::set_solver_type(), libMesh::TetGenWrapper::set_switches(), libMesh::FE< Dim, T >::shape(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::shape(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::MeshData::slim(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::EigenSparseLinearSolver< T >::solve(), libMesh::LaspackLinearSolver< T >::solve(), libMesh::QMonomial::stroud_rule(), libMesh::VTKIO::system_vectors_to_vtk(), libMesh::TriangleInterface::triangulate(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::System::variable_number(), libMesh::Elem::which_child_am_i(), libMesh::FroIO::write(), libMesh::UCDIO::write(), libMesh::TetGenIO::write(), libMesh::UNVIO::write(), libMesh::UnstructuredMesh::write(), libMesh::MeshData::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::TecplotIO::write_binary(), libMesh::LegacyXdrIO::write_binary(), libMesh::GMVIO::write_binary(), libMesh::PltLoader::write_dat(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::Nemesis_IO::write_global_data(), libMesh::ExodusII_IO::write_global_data(), libMesh::UCDIO::write_implementation(), libMesh::UNVIO::write_implementation(), libMesh::Nemesis_IO::write_information_records(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::UCDIO::write_interior_elems(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::GmshIO::write_post(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::GnuPlotIO::write_solution(), libMesh::DivaIO::write_stream(), libMesh::MeshData::write_unv(), libMesh::MeshData::write_unv_implementation(), libMesh::ExodusII_IO_Helper::write_var_names(), and libMesh::EnsightIO::write_vector_ascii().

libMesh::ierr = PCSetUp(pc)

Definition at line 264 of file petsc_preconditioner.C.

Referenced by __libmesh_petsc_diff_solver_monitor(), __libmesh_petsc_preconditioner_apply(), __libmesh_petsc_preconditioner_setup(), __libmesh_petsc_snes_jacobian(), __libmesh_petsc_snes_residual(), libMesh::PetscLinearSolver< T >::_create_complement_is(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::PetscLinearSolver< T >::_restrict_solve_to_is_local_size(), libMesh::SlepcEigenSolver< T >::_solve_generalized_helper(), libMesh::SlepcEigenSolver< T >::_solve_standard_helper(), libMesh::PetscVector< T >::add(), libMesh::PetscVector< T >::add_vector(), libMesh::PetscVector< T >::add_vector_transpose(), libMesh::PetscLinearSolver< T >::adjoint_solve(), libMesh::Parallel::Communicator::allgather(), libMesh::Parallel::Communicator::alltoall(), libMesh::PetscPreconditioner< T >::apply(), libMesh::SlepcEigenSolver< T >::attach_deflation_space(), libMesh::Parallel::Communicator::broadcast(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::SlepcEigenSolver< T >::clear(), libMesh::PetscNonlinearSolver< T >::clear(), libMesh::PetscPreconditioner< T >::clear(), libMesh::PetscDiffSolver::clear(), libMesh::PetscLinearSolver< T >::clear(), libMesh::PetscVector< T >::conjugate(), DMCreate_libMesh(), DMCreateDomainDecomposition_libMesh(), DMCreateDomainDecompositionDM_libMesh(), DMCreateFieldDecomposition_libMesh(), DMCreateFieldDecompositionDM_libMesh(), DMCreateGlobalVector_libMesh(), DMCreateLibMesh(), DMDestroy_libMesh(), DMLibMeshCreateDomainDecompositionDM(), DMLibMeshCreateFieldDecompositionDM(), DMlibMeshFunction(), DMLibMeshGetBlocks(), DMLibMeshGetSystem(), DMLibMeshGetVariables(), DMlibMeshJacobian(), DMLibMeshParseDecompositionDescriptor_Private(), DMLibMeshSetSystem(), DMLibMeshSetUpName_Private(), DMSetUp_libMesh(), DMVariableBounds_libMesh(), DMView_libMesh(), libMesh::Parallel::Communicator::gather(), libMesh::PetscNonlinearSolver< T >::get_converged_reason(), libMesh::SlepcEigenSolver< T >::get_eigenpair(), libMesh::SlepcEigenSolver< T >::get_eigenvalue(), libMesh::PetscLinearSolver< T >::get_initial_residual(), libMesh::SlepcEigenSolver< T >::get_relative_error(), libMesh::PetscLinearSolver< T >::get_residual_history(), if(), libMesh::SlepcEigenSolver< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::PetscDMNonlinearSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::PetscPreconditioner< T >::init(), libMesh::PetscLinearSolver< T >::init(), libMesh::PetscVector< T >::l1_norm(), libMesh::PetscVector< T >::l2_norm(), libMesh::PetscVector< T >::linfty_norm(), PetscDMRegister(), libMesh::GMVIO::read(), libMesh::Parallel::Communicator::receive(), libMesh::PetscVector< T >::reciprocal(), libMesh::PetscLinearSolver< T >::restrict_solve_to(), libMesh::Parallel::Communicator::send(), libMesh::PetscVector< T >::set(), libMesh::PetscPreconditioner< T >::set_petsc_preconditioner_type(), libMesh::PetscLinearSolver< T >::set_petsc_solver_type(), libMesh::SlepcEigenSolver< T >::set_slepc_position_of_spectrum(), libMesh::SlepcEigenSolver< T >::set_slepc_problem_type(), libMesh::SlepcEigenSolver< T >::set_slepc_solver_type(), SNESFunction_DMlibMesh(), SNESJacobian_DMlibMesh(), libMesh::PetscDMNonlinearSolver< T >::solve(), libMesh::PetscDiffSolver::solve(), libMesh::PetscNonlinearSolver< T >::solve(), libMesh::PetscLinearSolver< T >::solve(), libMesh::SlepcEigenSolver< T >::solve_generalized(), libMesh::SlepcEigenSolver< T >::solve_standard(), libMesh::PetscVector< T >::sum(), and libMesh::TecplotIO::write_binary().

const Number libMesh::imaginary

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

libMesh::INVALID_SOLVER_PACKAGE

Definition at line 235 of file libmesh.C.

Referenced by default_solver_package().

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

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

Definition at line 158 of file libmesh.h.

Referenced by libMesh::FEMContext::_do_elem_position_set(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::compute_node_indices_fast(), libMesh::FEGenericBase< T >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::InfFE< friend_Dim, friend_T_radial, friend_T_map >::compute_shape_indices(), libMesh::Xdr::data_stream(), libMesh::DofMap::dof_indices(), libMesh::FEMContext::elem_position_get(), libMesh::TreeNode< N >::find_element_in_children(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::Elem::get_node_index(), libMesh::DofObject::has_dofs(), libMesh::MeshTools::Generation::Private::idx(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_flags(), libMesh::Elem::local_node(), libMesh::FEMSystem::mesh_position_get(), libMesh::DofObject::n_dofs(), libMesh::Quad9::n_second_order_adjacent_vertices(), libMesh::Hex27::n_second_order_adjacent_vertices(), libMesh::InfHex18::n_second_order_adjacent_vertices(), libMesh::FEMSystem::numerical_jacobian(), libMesh::DofMap::old_dof_indices(), libMesh::MeshDataUnvHeader::read(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::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().

MPI_Errhandler libMesh::libmesh_errhandler

Definition at line 218 of file libmesh.C.

Referenced by if().

const unsigned int libMesh::MIN_ELEM_PER_PROC = 4
std::terminate_handler libMesh::old_terminate_handler

Definition at line 257 of file libmesh.C.

Referenced by libmesh_terminate_handler().

OStreamProxy libMesh::out

Definition at line 200 of file libmesh_common.h.

Referenced by __libmesh_petsc_diff_solver_jacobian(), __libmesh_petsc_diff_solver_monitor(), __libmesh_petsc_diff_solver_residual(), __libmesh_petsc_snes_monitor(), libMesh::DenseMatrix< T >::_lu_back_substitute_lapack(), libMesh::DenseMatrix< T >::_lu_decompose(), libMesh::DenseMatrix< T >::_lu_decompose_lapack(), libMesh::DenseMatrix< T >::_matvec_blas(), libMesh::DenseMatrix< T >::_multiply_blas(), libMesh::DenseMatrix< T >::_svd_helper(), libMesh::PetscVector< T >::add_vector_conjugate_transpose(), libMesh::FEMSystem::assembly(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::AbaqusIO::assign_sideset_ids(), 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::ElementTypes::basic_name(), libMesh::Parallel::Sort< KeyType, IdxType >::bin(), libMesh::QBase::build(), libMesh::FEAbstract::build(), libMesh::FEGenericBase< T >::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::MeshTools::Generation::build_sphere(), libMesh::ExodusII_IO_Helper::check_existing_vars(), libMesh::PerfLog::clear(), 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::UNVIO::count_elements(), libMesh::UNVIO::count_nodes(), libMesh::ExodusII_IO_Helper::create(), libMesh::Nemesis_IO_Helper::create(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::DofObject::debug_buffer(), libMesh::EnsightIO::elem_type_to_string(), libMesh::UNVIO::element_in(), libMesh::UNVIO::element_out(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::PetscMatrix< T >::get_diagonal(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::Utility::get_timestamp(), libMesh::StatisticsVector< T >::histogram(), if(), libMesh::XdrMGF::init(), libMesh::ContinuationSystem::initialize_tangent(), libMesh::NewtonSolver::line_search(), libMesh::Parallel::Communicator::maxloc(), libMesh::MeshInput< MT >::MeshInput(), libMesh::MeshOutput< MT >::MeshOutput(), libMesh::ExodusII_IO_Helper::message(), libMesh::Parallel::Communicator::minloc(), libMesh::SerialMesh::node(), libMesh::UNVIO::node_in(), libMesh::UNVIO::node_out(), libMesh::Xdr::open(), libMesh::ExodusII_IO_Helper::open(), libMesh::PetscVector< T >::pointwise_mult(), libMesh::DofMap::prepare_send_list(), libMesh::PetscNonlinearSolver< T >::print_converged_reason(), libMesh::EigenSparseLinearSolver< T >::print_converged_reason(), libMesh::LaspackLinearSolver< T >::print_converged_reason(), libMesh::PetscLinearSolver< T >::print_converged_reason(), libMesh::NewtonSolver::print_convergence(), libMesh::ExodusII_IO_Helper::print_header(), libMesh::PerfLog::print_log(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Tet::qual_bounds(), libMesh::Hex::qual_bounds(), libMesh::Tri::qual_bounds(), libMesh::Quad::qual_bounds(), libMesh::InfQuad::qual_bounds(), libMesh::AbaqusIO::read(), libMesh::TetGenIO::read(), libMesh::PltLoader::read(), libMesh::Nemesis_IO::read(), libMesh::EquationSystems::read(), libMesh::PltLoader::read_data(), libMesh::ExodusII_IO_Helper::read_elem_in_block(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::PltLoader::read_header(), libMesh::System::read_header(), libMesh::UNVIO::read_implementation(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::ExodusII_IO_Helper::read_var_names_impl(), libMesh::VariationalMeshSmoother::readgr(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::TetGenWrapper::set_switches(), libMesh::ContinuationSystem::set_Theta(), libMesh::ContinuationSystem::set_Theta_LOCA(), libMesh::TwostepTimeSolver::solve(), libMesh::NewtonSolver::solve(), libMesh::EigenSparseLinearSolver< T >::solve(), libMesh::UnsteadySolver::solve(), libMesh::EigenTimeSolver::solve(), libMesh::PetscLinearSolver< T >::solve(), libMesh::ContinuationSystem::solve_tangent(), libMesh::SerialMesh::stitching_helper(), libMesh::MacroFunctions::stop(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::ContinuationSystem::update_solution(), libMesh::Quality::valid(), libMesh::ExodusII_IO::write(), libMesh::Nemesis_IO::write(), libMesh::XdrIO::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements_discontinuous(), libMesh::MeshOutput< MT >::write_equation_systems(), libMesh::Nemesis_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::GmshIO::write_post(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_var_names_impl(), and libMesh::VariationalMeshSmoother::writegr().

PerfLog libMesh::perflog

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

Definition at line 39 of file libmesh_logging.h.

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

PetscBool libMesh::PetscDMRegistered = PETSC_FALSE

Definition at line 50 of file petsc_dm_nonlinear_solver.C.

Referenced by PetscDMRegister().

DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE libMesh::Real

Definition at line 112 of file libmesh_common.h.

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

const RemoteElem * libMesh::remote_elem

Definition at line 57 of file remote_elem.C.

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

LibMeshInit::LibMeshInit (int argc, const char* const* argv) LibMeshInit command_lin libMesh::reset)(new GetPot(argc, argv))

Definition at line 319 of file libmesh.C.

const unsigned char libMesh::square_number_column
Initial value:
= {
0,
0, 1, 1,
0, 1, 2, 2, 2,
0, 1, 2, 3, 3, 3, 3,
0, 1, 2, 3, 4, 4, 4, 4, 4,
0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5,
0, 1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 6, 6,
0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7,
0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9
}

Definition at line 57 of file number_lookups.C.

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

const unsigned char libMesh::square_number_row
Initial value:
= {
0,
1, 1, 0,
2, 2, 2, 1, 0,
3, 3, 3, 3, 2, 1, 0,
4, 4, 4, 4, 4, 3, 2, 1, 0,
5, 5, 5, 5, 5, 5, 4, 3, 2, 1, 0,
6, 6, 6, 6, 6, 6, 6, 5, 4, 3, 2, 1, 0,
7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0,
8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 6, 5, 4, 3, 2, 1, 0,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
}

Definition at line 70 of file number_lookups.C.

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

KSP* libMesh::subksps

Definition at line 268 of file petsc_preconditioner.C.

const unsigned char libMesh::triangular_number_column
Initial value:
= {
0,
0, 1,
0, 1, 2,
0, 1, 2, 3,
0, 1, 2, 3, 4,
0, 1, 2, 3, 4, 5,
0, 1, 2, 3, 4, 5, 6,
0, 1, 2, 3, 4, 5, 6, 7,
0, 1, 2, 3, 4, 5, 6, 7, 8,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
}

Definition at line 42 of file number_lookups.C.

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

const unsigned char libMesh::triangular_number_row
Initial value:
= {
0,
1, 1,
2, 2, 2,
3, 3, 3, 3,
4, 4, 4, 4, 4,
5, 5, 5, 5, 5, 5,
6, 6, 6, 6, 6, 6, 6,
7, 7, 7, 7, 7, 7, 7, 7,
8, 8, 8, 8, 8, 8, 8, 8, 8,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9
}

Definition at line 29 of file number_lookups.C.

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


Site Created By: libMesh Developers
Last modified: February 07 2014 16:57:08 UTC

Hosted By:
SourceForge.net Logo