libMesh
|
▶Nboost | |
▶Nmultiprecision | |
▶Ndetail | |
Cis_lossy_conversion< libMesh::NumericVector< T >, To > | |
▶NGETPOT_NAMESPACE | |
▶CGetPot | GetPot - A class for parsing command line arguments and configuration files |
Cltstr | Helper functor for creating sets of C-style strings |
Cvariable | Variable to be specified on the command line or in input files |
▶NlibMesh | The libMesh namespace provides an interface to certain functionality in the library |
▶Nboostcopy | |
Cenable_if_c | |
Cenable_if_c< false, T > | |
▶NMeshTools | Utility functions for operations on a Mesh object |
▶NGeneration | Tools for Mesh generation |
▶NPrivate | |
CGaussLobattoRedistributionFunction | This object is passed to MeshTools::Modification::redistribute() to redistribute the points on a uniform grid into the Gauss-Lobatto points on the actual grid |
CQueryElemSubdomainIDBase | Class for receiving the callback during extrusion generation and providing user-defined subdomains based on the old (existing) element id and the current layer |
▶NParallel | |
▶NUtils | |
CConvert | A utility to convert a double to some sort of KeyType , for interpreting how histogram bounds relate to KeyType positions |
CConvert< Hilbert::HilbertIndices > | |
CConvert< std::pair< FirstKeyType, SecondKeyType > > | A pseudoinverse for converting bounds back to pairs of key types |
CBinSorter | Perform a parallel sort using a bin-sort method |
CHistogram | Defines a histogram to be used in parallel in conjunction with a BinSorter |
CPacking< const Elem * > | |
CPacking< const Elem *const > | |
CPacking< const Node * > | |
CPacking< const Node *const > | |
CPacking< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > > | |
CPacking< Elem * > | |
CPacking< Elem *const > | |
CPacking< Node * > | |
CPacking< Node *const > | |
CSort | The parallel sorting method is templated on the type of data which is to be sorted |
CSyncEverything | |
▶NPredicates | This namespace defines several multi_predicates which are used by the element and node iterators |
Cabstract_multi_predicate | |
Cactive | |
CActive | Used to iterate over non-nullptr, active entries in a container |
CActiveLocal | Used to iterate over non-nullptr, active, local elements owned by a given processor |
CActiveLocalSubdomain | Used to iterate over non-nullptr, active elements with a given PID on a given subdomain |
CActiveLocalSubdomainSet | Used to iterate over non-nullptr, active elements with a given PID whose subdomains are in a user-specified set |
CActiveNotLocal | Used to iterate over non-nullptr, active, non-local entries in a container |
CActiveOnBoundary | Used to iterate over non-nullptr, active elements which are on the boundary |
CActivePID | Used to iterate over non-nullptr, active elements owned by a given processor |
CActiveSemiLocal | Used to iterate over non-nullptr, semi-local entries (i.e |
CActiveSubdomain | Used to iterate over non-nullptr, active elements on a given subdomain |
CActiveSubdomainSet | Used to iterate over non-nullptr, active elements whose subdomains are in a user-specified set |
CActiveType | Used to iterate over non-nullptr, active elements of a given geometric type |
CAncestor | Used to iterate over non-nullptr, entries that have children (i.e |
Cancestor | |
CBID | Used to iterate over non-nullptr elements on the boundary with a given ID |
Cbid | |
CBND | Used to iterate over non-nullptr elements on the boundary |
Cbnd | |
Cboundary_side | |
CBoundarySide | Used to iterate over the sides of an element which are on the boundary of the Mesh |
Celem_type | |
CEvaluable | Used to iterate over elements where solutions indexed by a given DofMap are evaluable for a given variable var_num |
Cevaluable | |
CFaceLocal | Used to iterate over non-nullptr, face-local entries (i.e |
Cfacelocal_pid | |
CFlagged | Used to iterate over non-nullptr, elements with a given refinement flag |
Cflagged | |
CFlaggedPID | Used to iterate over non-nullptr, elements with a given refinement flag belonging to a given processor |
CGhost | Used to iterate over non-nullptr elements not owned by a given processor but semi-local to that processor, i.e |
Cis_null | |
CIsNull | Used to iterate over nullptr entries in a container |
CLevel | Used to iterate over non-nullptr elements of a specified (refinement) level |
Clevel | |
CLocal | Used to iterate over non-nullptr, local entries (i.e |
CLocalLevel | Used to iterate over non-nullptr local elements with a specified (refinement) level |
CLocalNotLevel | Used to iterate over non-nullptr local elements not of a specified (refinement) level |
Cmovable_il | Helper object for creating a std::vector from a std::initializer_list https://stackoverflow.com/questions/46737054/vectorunique-ptra-using-initialization-list |
Cmulti_evaluable | |
Cmulti_predicate | |
CMultiEvaluable | Used to iterate over elements where solutions indexed by a given vector of DofMaps are evaluable for all variables |
Cnot_active | |
Cnot_ancestor | |
Cnot_level | |
Cnot_null | |
Cnot_pid | |
Cnot_subactive | |
CNotActive | Used to iterate over non-nullptr, inactive entries in a container |
CNotAncestor | Used to iterate over non-nullptr, entries that have no children (i.e |
CNotLevel | Used to iterate over non-nullptr elements not of a specified (refinement) level |
CNotLocal | Used to iterate over non-nullptr, non-local entries in a container |
CNotNull | Used to iterate over non-nullptr entries in a container |
CNotPID | Used to iterate over non-nullptr elements not owned by a given processor |
CNotSubActive | Used to iterate over non-nullptr, non-subactive entries (i.e |
Cnull_neighbor | |
Cpid | |
CPID | Used to iterate over non-nullptr elements owned by a given processor |
Cpredicate | |
Csemilocal_pid | |
CSubActive | Used to iterate over non-nullptr, subactive entries (i.e |
Csubactive | |
Csubdomain | |
Csubdomain_set | |
CType | Used to iterate over non-nullptr, elements of a given geometric type |
▶NRBDataDeserialization | |
CRBEIMEvaluationDeserialization | This class de-serializes a RBEIMEvaluation object using the Cap'n Proto library |
CRBEvaluationDeserialization | This class de-serializes an RBEvaluation object using the Cap'n Proto library |
CRBSCMEvaluationDeserialization | This class de-serializes a RBSCMEvaluation object using the Cap'n Proto library |
CTransientRBEvaluationDeserialization | This class de-serializes a TransientRBEvaluation object using the Cap'n Proto library |
▶NRBDataSerialization | |
CRBEIMEvaluationSerialization | This class serializes an RBEIMEvaluation object using the Cap'n Proto library |
CRBEvaluationSerialization | This class serializes an RBEvaluation object using the Cap'n Proto library |
CRBSCMEvaluationSerialization | This class serializes an RBSCMEvaluation object using the Cap'n Proto library |
CTransientRBEvaluationSerialization | This class serializes a TransientRBEvaluation object using the Cap'n Proto library |
▶NSparsityPattern | This defines the sparsity pattern, or graph, of a sparse matrix |
CAugmentSparsityPattern | Abstract base class to be used to add user-defined implicit degree of freedom couplings |
CBuild | This helper class can be called on multiple threads to compute the sparsity pattern (or graph) of the sparse matrix resulting from the discretization |
CGraph | |
CNonlocalGraph | |
▶NTensorTools | |
CDecrementRank | |
CDecrementRank< TensorValue< T > > | |
CDecrementRank< TypeNTensor< N, T > > | |
CDecrementRank< TypeTensor< T > > | |
CDecrementRank< TypeVector< T > > | |
CDecrementRank< VectorValue< T > > | |
CIncrementRank | |
CIncrementRank< TensorValue< T > > | |
CIncrementRank< TypeNTensor< N, T > > | |
CIncrementRank< TypeTensor< T > > | |
CIncrementRank< TypeVector< T > > | |
CIncrementRank< VectorValue< T > > | |
CMakeBaseNumber | |
CMakeBaseNumber< T, typename std::enable_if< ScalarTraits< T >::value >::type > | |
CMakeBaseNumber< Wrapper< T >, typename std::enable_if< MathWrapperTraits< Wrapper< T > >::value >::type > | |
CMakeNumber | |
CMakeNumber< std::complex< T > > | |
CMakeNumber< TensorValue< T > > | |
CMakeNumber< TypeNTensor< N, T > > | |
CMakeNumber< TypeTensor< T > > | |
CMakeNumber< TypeVector< T > > | |
CMakeNumber< VectorValue< T > > | |
CMakeReal | |
CMakeReal< std::complex< T > > | |
CMakeReal< TensorValue< T > > | |
CMakeReal< TypeNTensor< N, T > > | |
CMakeReal< TypeTensor< T > > | |
CMakeReal< TypeVector< T > > | |
CMakeReal< VectorValue< T > > | |
CMathWrapperTraits | This helper structure is used to determine whether a template class is one of our mathematical structures, like TypeVector, TypeTensor and their descendents |
CMathWrapperTraits< TensorValue< T > > | |
CMathWrapperTraits< TypeNTensor< N, T > > | |
CMathWrapperTraits< TypeTensor< T > > | |
CMathWrapperTraits< TypeVector< T > > | |
CMathWrapperTraits< VectorValue< T > > | |
CTensorTraits | |
CTensorTraits< T, typename std::enable_if< ScalarTraits< T >::value >::type > | |
CTensorTraits< TensorValue< T > > | |
CTensorTraits< TypeNTensor< N, T > > | |
CTensorTraits< TypeTensor< T > > | |
CTensorTraits< TypeVector< T > > | |
CTensorTraits< VectorValue< T > > | |
▶NThreads | The Threads namespace is for wrapper functions for common general multithreading algorithms and tasks |
Catomic | Defines atomic operations which can only be executed on a single thread at a time |
CBlockedRange | Blocked range which can be subdivided and executed in parallel |
CBoolAcquire | We use a class to turn Threads::in_threads on and off, to be exception-safe |
CDisablePerfLogInScope | We use a class to turn perf logging off and on within threads, to be exception-safe and to avoid forcing indirect inclusion of libmesh_logging.h everywhere |
CNonConcurrentThread | Simple compatibility class for std::thread 'concurrent' execution |
CRangeBody | |
▶Crecursive_mutex | Recursive mutex |
Cscoped_lock | |
▶Cscalable_allocator | Scalable allocator to be used in multithreaded code chunks which allocate a lot of dynamic memory |
Crebind | |
▶Cspin_mutex | Spin mutex |
Cscoped_lock | |
Csplit | Dummy "splitting object" used to distinguish splitting constructors from copy constructors |
Ctask_scheduler_init | Scheduler to manage threads |
▶NUtility | |
CCompareUnderlying | Struct which defines a custom comparison object that can be used with std::sets of std::unique_ptrs |
Cdo_pow | An efficient template instantiation for raising to an arbitrary integer power |
Cdo_pow< 0, T > | |
Cdo_pow< 1, T > | |
Cdo_pow< 6, T > | |
Cis_streamable | Helper struct for enabling template metaprogramming/SFINAE |
CReverseBytes | This Functor simply takes an object and reverses its byte representation |
CAbaqusIO | Preliminary implementation for reading Abaqus mesh files in ASCII format |
CAdaptiveTimeSolver | This class wraps another UnsteadySolver derived class, and compares the results of timestepping with deltat and timestepping with 2*deltat to adjust future timestep lengths |
CAdjointDofConstraintValues | Storage for DofConstraint right hand sides for all adjoint problems |
CAdjointRefinementEstimator | This class implements a "brute force" goal-oriented error estimator which computes an estimate of error in a quantity of interest based on the residual of the current coarse grid primal solution as weighted against an adjoint solution on a uniformly refined (in h and/or p, for an arbitrary number of levels) grid |
CAdjointResidualErrorEstimator | This class implements a goal oriented error indicator, by weighting residual-based estimates from the primal problem against estimates from the adjoint problem |
CAnalyticFunction | Wraps a function pointer into a FunctionBase object |
CAztecLinearSolver | This class provides an interface to AztecOO iterative solvers that is compatible with the libMesh LinearSolver<> |
CBasicOStreamProxy | This class is intended to be reseatable like a pointer-to-ostream for flexibility, but to look like a reference when used to produce less awkward user code |
CBoundaryInfo | The BoundaryInfo class contains information relevant to boundary conditions including storing faces, edges, and nodes on the boundary, along with ids that can be used to identify the type of boundary each entity is part of |
CBoundaryMesh | The BoundaryMesh is a Mesh in its own right, but it contains a description of the boundary of some other mesh |
CBoundaryProjectSolution | This class implements projecting an arbitrary boundary function to the current mesh |
CBoundaryVolumeSolutionTransfer | SolutionTransfer derived class which is specifically for transferring solutions back and forth between a VolumeMesh and its associated BoundaryMesh |
CBoundingBox | Defines a Cartesian bounding box by the two corner extremum |
CBuildProjectionList | This class builds the send_list of old dof indices whose coefficients are needed to perform a projection |
Ccasting_compare | |
CCell | The Cell is an abstract element type that lives in three dimensions |
CCentroidPartitioner | Partitions the Mesh based on the locations of element vertex averages |
CCheckpointIO | Can be used to write simplified restart files that can be used to restart simulations that have crashed |
▶Cchunked_mapvector | This chunked_mapvector templated class is intended to provide the asymptotic performance characteristics of a std::map with an interface more closely resembling that of a std::vector, for use with DistributedMesh |
Cconst_reverse_veclike_iterator | |
Cconst_veclike_iterator | |
Cveclike_iterator | |
Cveclike_iterator_base | |
CCompareDofObjectsByID | Comparison object to use with DofObject pointers |
CCompareDofObjectsByPIDAndThenID | |
CCompareElemIdsByLevel | Specific weak ordering for Elem *'s to be used in a set |
CCompareTypes | |
CCompareTypes< MetaPhysicL::DualNumber< T, D, asd >, MetaPhysicL::DualNumber< T, D, asd > > | |
CCompareTypes< MetaPhysicL::DualNumber< T, D, asd >, MetaPhysicL::DualNumber< T2, D2, asd > > | |
CCompareTypes< MetaPhysicL::DualNumber< T, D, asd >, T2 > | |
CCompareTypes< MetaPhysicL::DualNumber< T, T, asd >, MetaPhysicL::DualNumber< T2, T2, asd > > | |
CCompareTypes< MetaPhysicL::DualNumber< T, T, asd >, T2 > | |
CCompareTypes< MetaPhysicL::DynamicSparseNumberArray< T, IndexType >, T2 > | |
CCompareTypes< std::complex< T >, T > | |
CCompareTypes< T, MetaPhysicL::DualNumber< T2, D, asd > > | |
CCompareTypes< T, MetaPhysicL::DualNumber< T2, T2, asd > > | |
CCompareTypes< T, std::complex< T > > | |
CCompareTypes< T, T > | |
CCompareTypes< TypeVector< T >, TypeVector< T > > | |
CCompareTypes< TypeVector< T >, TypeVector< T2 > > | |
CCompareTypes< TypeVector< T >, VectorValue< T2 > > | |
CCompareTypes< VectorValue< T >, TypeVector< T2 > > | |
CCompareTypes< VectorValue< T >, VectorValue< T > > | |
CCompareTypes< VectorValue< T >, VectorValue< T2 > > | |
CCompositeFEMFunction | FEMFunction which is a function of another function |
CCompositeFunction | A function that returns a vector whose components are defined by multiple functions |
CCondensedEigenSystem | This class extends EigenSystem to allow a simple way of solving (standard or generalized) eigenvalue problems in the case where we want to remove certain degrees of freedom from the system |
CConstCouplingAccessor | This accessor class allows simple access to CouplingMatrix values |
CConstCouplingRow | This proxy class acts like a container of indices from a single coupling row |
CConstCouplingRowConstIterator | |
CConstFEMFunction | FEMFunction that returns a single value, regardless of the time and location inputs |
CConstFunction | Function that returns a single value that never changes |
CConstParameterProxy | |
CConstTypeTensorColumn | |
CContinuationSystem | This class inherits from the FEMSystem |
CConvergenceFailure | A class representing a solver's failure to converge, to be thrown by "libmesh_convergence_failure();" This should be a last resort; more often, a solve which has failed should be reattempted after switching to a smaller timestep, adding underrelaxation, taking a smaller continuation step, etc |
CCouplingAccessor | This accessor class allows simple setting of CouplingMatrix values |
CCouplingMatrix | This class defines a coupling matrix |
CDefaultCoupling | This class implements the default algebraic coupling in libMesh: elements couple to themselves, but may also couple to neighbors both locally and across periodic boundary conditions |
▶CDenseMatrix | Defines a dense matrix for use in Finite Element-type computations |
CUseBlasLapack | Helper structure for determining whether to use blas_lapack |
CDenseMatrixBase | Defines an abstract dense matrix base class for use in Finite Element-type computations |
CDenseSubMatrix | Defines a dense submatrix for use in Finite Element-type computations |
CDenseSubVector | Defines a dense subvector for use in finite element computations |
CDenseVector | Defines a dense vector for use in Finite Element-type computations |
CDenseVectorBase | Defines an abstract dense vector base class for use in Finite Element-type computations |
CDGFEMContext | This class extends FEMContext in order to provide extra data required to perform local element residual and Jacobian assembly in the case of a discontinuous Galerkin (DG) discretization |
CDiagonalMatrix | Diagonal matrix class whose underlying storage is a vector |
CDiffContext | This class provides all data required for a physics package (e.g |
CDifferentiablePhysics | This class provides a specific system class |
CDifferentiableQoI | This class provides a specific system class |
CDifferentiableSystem | This class provides a specific system class |
CDiffSolver | This is a generic class that defines a solver to handle ImplicitSystem classes, including NonlinearImplicitSystem and DifferentiableSystem A user can define a solver by deriving from this class and implementing certain functions |
CDirectSolutionTransfer | Implementation of a SolutionTransfer object that only works for transferring the solution but only in the case of: |
CDirichletBoundaries | We're using a class instead of a typedef to allow forward declarations and future flexibility |
CDirichletBoundary | This class allows one to associate Dirichlet boundary values with a given set of mesh boundary ids and system variable ids |
CDiscontinuityMeasure | This class measures discontinuities between elements for debugging purposes |
CDistributedMesh | The DistributedMesh class is derived from the MeshBase class, and is intended to provide identical functionality to the user but be distributed rather than replicated across distributed-memory systems |
CDistributedVector | This class provides a simple parallel, distributed vector datatype which is specific to libmesh |
CDofConstraints | The constraint matrix storage format |
CDofConstraintValueMap | Storage for DofConstraint right hand sides for a particular problem |
▶CDofMap | This class handles the numbering of degrees of freedom on a mesh |
CAugmentSendList | Abstract base class to be used to add user-defined parallel degree of freedom couplings |
CAugmentSparsityPattern | Backwards compatibility for prior AugmentSparsityPattern users |
CDofObject | The DofObject defines an abstract base class for objects that have degrees of freedom associated with them |
CDSNAOutput | |
CDSNAOutput< VectorValue< InnerOutput > > | |
CDTKAdapter | The DTKAdapter is used with the DTKSolutionTransfer object to adapt libmesh data to the DTK interface |
CDTKEvaluator | Implements the evaluate() function to compute FE solution values at points requested by DTK |
CDTKSolutionTransfer | Implementation of a SolutionTransfer object that uses the DataTransferKit (https://github.com/CNERG/DataTransferKit) to transfer variables back and forth between systems |
▶CDynaIO | Reading and writing meshes in (a subset of) LS-DYNA format |
CElementDefinition | Defines mapping from libMesh element types to LS-DYNA element types or vice-versa |
CElementMaps | Struct which holds a map from LS-DYNA to libMesh element numberings and vice-versa |
CDynamicCastFailure | A class representing that a dynamic cast failed to produce expected output |
CEdge | The Edge is an element in 1D |
CEdge2 | The Edge2 is an element in 1D composed of 2 nodes |
CEdge3 | The Edge3 is an element in 1D composed of 3 nodes |
CEdge4 | The Edge4 is an element in 1D composed of 4 nodes |
CEigenPreconditioner | This class provides an interface to the suite of preconditioners available from Eigen |
CEigenSolver | This class provides an interface to solvers for eigenvalue problems |
CEigenSparseLinearSolver | This class provides an interface to Eigen iterative solvers that is compatible with the libMesh LinearSolver<> |
CEigenSparseMatrix | The EigenSparseMatrix class wraps a sparse matrix object from the Eigen library |
CEigenSparseVector | This class provides a nice interface to the Eigen C++-based data structures for serial vectors |
CEigenSystem | Manages consistently variables, degrees of freedom, and coefficient vectors for eigenvalue problems |
CEigenTimeSolver | The name of this class is confusing...it's meant to refer to the base class (TimeSolver) while still telling one that it's for solving (generalized) EigenValue problems that arise from finite element discretizations |
CEimPointData | This struct is used to encapsulate the arguments required to specify an EIM point that we may add to our list of interpolation points |
▶CElem | This is the base class from which all geometric element types are derived |
CChildRefIter | |
CConstChildRefIter | |
CConstNodeRefIter | |
CNodeRefIter | |
Cside_iterator | The definition of the struct used for iterating over sides |
CSideIter | The definition of the protected nested SideIter class |
CElemAssembly | ElemAssembly provides a per-element (interior and boundary) assembly functionality |
CElemCutter | This class implements cutting a single element into a collection of subelements |
CElemHashUtils | The ElemHashUtils struct defines functions used for the "Hash" and "Pred" template arguments of the various "unordered" containers, e.g |
CElemSideBuilder | Helper for building element sides that minimizes the construction of new elements |
▶CEnsightIO | This class implements writing meshes and solutions in Ensight's Gold format |
CScalars | |
CSystemVars | |
CVectors | |
CEpetraMatrix | This class provides a nice interface to the Epetra data structures for parallel, sparse matrices |
CEpetraVector | This class provides a nice interface to the Trilinos Epetra_Vector object |
CEquationSystems | This is the EquationSystems class |
CErrorEstimator | This class holds functions that will estimate the error in a finite element solution on a given mesh |
CErrorVector | The ErrorVector is a specialization of the StatisticsVector for error data computed on a finite element mesh |
CEuler2Solver | This class defines a theta-method (defaulting to Backward Euler with theta = 1.0) solver to handle time integration of DifferentiableSystems |
CEulerSolver | This class defines a theta-method Euler (defaulting to Backward Euler with theta = 1.0) solver to handle time integration of DifferentiableSystems |
CExactErrorEstimator | This class implements an "error estimator" based on the difference between the approximate and exact solution |
CExactSolution | This class handles the computation of the L2 and/or H1 error for the Systems in the EquationSystems object which is passed to it |
CExodusHeaderInfo | This class is used as both an external data structure for passing around Exodus file header information, and for storing information internally in ExodusII_IO_Helper |
CExodusII_IO | The ExodusII_IO class implements reading meshes in the ExodusII file format from Sandia National Labs |
▶CExodusII_IO_Helper | This is the ExodusII_IO_Helper class |
CConversion | |
CMappedInputVector | This class facilitates reading in vectors from Exodus file that may be of a different floating point type than Real |
CMappedOutputVector | This class facilitates inline conversion of an input data vector to a different precision level, depending on the underlying type of Real and whether or not the single_precision flag is set |
CNamesData | This class is useful for managing anything that requires a char ** input/output in ExodusII file |
CExplicitSystem | Manages consistently variables, degrees of freedom, and coefficient vectors for explicit systems |
CFace | The Face is an abstract element type that lives in two dimensions |
CFactory | Factory class definition |
CFactoryImp | Factory implementation class |
▶CFastPoolAllocator | An allocator which can be used in standard containers |
Crebind | Methods required for copy construction of containers using this allocator |
CFE | A specific instantiation of the FEBase class |
CFEAbstract | This class forms the foundation from which generic finite elements may be derived |
CFEClough | Clough-Tocher finite elements |
CFEComputeData | Class FEComputeData hides arbitrary data to be passed to and from children of FEBase through the FEInterface::compute_data() method |
CFEGenericBase | This class forms the foundation from which generic finite elements may be derived |
CFEHermite | Hermite finite elements |
CFEHierarchic | Hierarchic finite elements |
CFEHierarchicVec | FEHierarchicVec objects are used for working with vector-valued high-order finite elements |
CFEInterface | This class provides an encapsulated access to all static public member functions of finite element classes |
CFEL2Hierarchic | Discontinuous Hierarchic finite elements |
CFEL2HierarchicVec | FEHierarchicVec objects are used for working with vector-valued high-order piecewise-continuous finite elements |
CFEL2Lagrange | Discontinuous Lagrange finite elements |
CFEL2LagrangeVec | FEL2LagrangeVec objects are used for working with vector-valued finite elements |
CFEL2RaviartThomas | FEL2RaviartThomas objects are used for working with vector-valued discontinuous Raviart-Thomas finite elements, e.g |
CFELagrange | Lagrange finite elements |
CFELagrangeVec | FELagrangeVec objects are used for working with vector-valued finite elements |
CFEMap | Class contained in FE that encapsulates mapping (i.e |
▶CFEMContext | This class provides all data required for a physics package (e.g |
CFENeeded | Helper nested class for C++03-compatible "template typedef" |
CFEMFunctionBase | FEMFunctionBase is a base class from which users can derive in order to define "function-like" objects that can be used within FEMSystem |
CFEMFunctionWrapper | The FEMFunctionWrapper input functor class can be used with a GenericProjector to read values from an FEMFunction |
CFEMonomial | Monomial finite elements |
CFEMonomialVec | FEMonomialVec objects are used for working with vector-valued discontinuous finite elements |
CFEMPhysics | This class provides a specific system class |
CFEMSystem | This class provides a specific system class |
CFENedelecOne | FENedelecOne objects are used for working with vector-valued Nedelec finite elements of the first kind |
CFEOutputType | Most finite element types in libMesh are scalar-valued |
CFEOutputType< HIERARCHIC_VEC > | |
CFEOutputType< L2_HIERARCHIC_VEC > | |
CFEOutputType< L2_LAGRANGE_VEC > | |
CFEOutputType< L2_RAVIART_THOMAS > | |
CFEOutputType< LAGRANGE_VEC > | Specialize for non-scalar-valued elements |
CFEOutputType< MONOMIAL_VEC > | |
CFEOutputType< NEDELEC_ONE > | |
CFEOutputType< RAVIART_THOMAS > | |
CFERaviartThomas | FERaviartThomas objects are used for working with vector-valued Raviart-Thomas finite elements |
CFEScalar | The FEScalar class is used for working with SCALAR variables |
CFESubdivision | |
CFETransformationBase | This class handles the computation of the shape functions in the physical domain |
CFEType | Class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialized finite element families |
CFEXYZ | XYZ finite elements |
CFEXYZMap | An implementation of FEMap for "XYZ" elements |
CFileError | A class representing a failed attempt by the library to open a file (or construct an fstream, etc), to be thrown by "libmesh_file_error(filename);" For ease of debugging, "filename" should include any (absolute or relative or implicit) pathname that was part of the failed open |
CFileHistoryData | HistoryData subclass that provides a struct to store history data such as timestamps, mesh, primal and adjoint filenames and timestep sizes |
CFileSolutionHistory | Subclass of Solution History that stores the solutions and other important vectors onto disk |
CFirstOrderUnsteadySolver | Generic class from which first order UnsteadySolvers should subclass |
CFloatingPointException | A class representing a floating point exception |
CFrequencySystem | FrequencySystem provides a specific system class for frequency-dependent (linear) systems |
CFroIO | This class implements writing meshes in the .fro format used by the MIT ACDL |
CFunctionBase | Base class for functors that can be evaluated at a point and (optionally) time |
▶CGenericProjector | The GenericProjector class implements the core of other projection operations, using two input functors to read values to be projected and an output functor to set degrees of freedom in the result |
CProjectEdges | |
CProjectInteriors | |
CProjectSides | |
CProjectVertices | |
CSortAndCopy | |
CSubFunctor | |
CSubProjector | |
CGhostingFunctor | This abstract base class defines the interface by which library code and user code can report associations between elements |
CGhostPointNeighbors | This class implements the original default geometry ghosting requirements in libMesh: point neighbors on the same manifold, and interior_parent elements |
▶CGmshIO | Reading and writing meshes in the Gmsh format |
CElementDefinition | Defines mapping from libMesh element types to Gmsh element types or vice-versa |
CElementMaps | Struct which holds a map from Gmsh to libMesh element numberings and vice-versa |
CGMVIO | This class implements writing meshes in the GMV format |
CGnuPlotIO | This class implements writing meshes using GNUplot, designed for use only with 1D meshes |
CGradientMeshFunction | |
CH1FETransformation | This class handles the computation of the shape functions in the physical domain for H1 conforming elements |
Chash | |
CHCurlFETransformation | This class handles the computation of the shape functions in the physical domain for HCurl conforming elements |
CHDivFETransformation | This class handles the computation of the shape functions in the physical domain for HDiv conforming elements |
CHex | The Hex is an element in 3D with 6 sides |
CHex20 | The Hex20 is an element in 3D composed of 20 nodes |
CHex27 | The Hex27 is an element in 3D composed of 27 nodes |
CHex8 | The Hex8 is an element in 3D composed of 8 nodes |
CHilbertSFCPartitioner | The HilbertSFCPartitioner uses a Hilbert space filling curve to partition the elements |
CHistoryData | The History Data classes are companion classes to SolutionHistory and MeshHistory classes |
CHPCoarsenTest | This class uses the error estimate given by different types of derefinement (h coarsening or p reduction) to choose between h refining and p elevation |
CHPSelector | Subclasses of this abstract base class choose between h refining and p elevation |
CHPSingularity | This class uses a user-provided list of singularity locations to choose between h refining and p elevation |
CImplicitSystem | Manages consistently variables, degrees of freedom, coefficient vectors, and matrices for implicit systems |
CInfCell | The InfCell is an abstract element type that lives in three dimensions |
CInfEdge2 | The InfEdge2 is an infinite element in 1D composed of 2 nodes |
CInfElemBuilder | This class is used to build infinite elements on top of an existing mesh |
CInfFE | A specific instantiation of the FEBase class |
CInfFEBase | This nested class contains most of the static methods related to the base part of an infinite element |
CInfFEMap | Class that encapsulates mapping (i.e |
CInfFERadial | Infinite elements are in some sense directional, compared to conventional finite elements |
CInfHex | The InfHex is an element in 3D with 5 sides |
CInfHex16 | The InfHex16 is an infinite element in 3D composed of 16 nodes |
CInfHex18 | The InfHex18 is an infinite element in 3D composed of 18 nodes |
CInfHex8 | The InfHex8 is an infinite element in 3D composed of 8 nodes |
CInfPrism | The InfPrism is an element in 3D with 4 sides |
CInfPrism12 | The InfPrism12 is an infinite element in 3D composed of 12 nodes |
CInfPrism6 | The InfPrism6 is an infinite element in 3D composed of 6 nodes |
CInfQuad | The InfQuad is an abstract element type that lives in two dimensions |
CInfQuad4 | The INFQUAD4 is an infinite element in 2D composed of 4 nodes |
CInfQuad6 | The INFQUAD6 is an infinite element in 2D composed of 6 nodes |
CInterMeshProjection | This class implements inter mesh projection, i.e |
▶CIntRange | The IntRange templated class is intended to make it easy to loop over integers which are indices of a container |
Citerator | |
▶CInverseDistanceInterpolation | Inverse distance interpolation |
CPointListAdaptor | This class adapts list of libMesh Point types for use in a nanoflann KD-Tree |
CJumpErrorEstimator | This abstract base class implements utility functions for error estimators which are based on integrated jumps between elements |
CKellyErrorEstimator | This class implements the Kelly error indicator which is based on the flux jumps between elements |
CLaplaceMeshSmoother | This class defines the data structures necessary for Laplace smoothing |
CLaplacianErrorEstimator | This class is an error indicator based on laplacian jumps between elements |
CLaspackLinearSolver | This class provides an interface to Laspack iterative solvers that is compatible with the libMesh LinearSolver<> |
CLaspackMatrix | The LaspackMatrix class wraps a QMatrix object from the Laspack library |
CLaspackVector | This class provides a nice interface to the Laspack C-based data structures for serial vectors |
CLibMeshInit | The LibMeshInit class, when constructed, initializes the dependent libraries (e.g |
CLinearImplicitSystem | Manages consistently variables, degrees of freedom, coefficient vectors, matrices and linear solvers for implicit systems |
CLinearPartitioner | The LinearPartitioner simply takes the element list and splits it into equal-sized chunks assigned to each processor |
CLinearSolutionMonitor | Functor for use as callback in solve of nonlinear solver |
CLinearSolver | This base class can be inherited from to provide interfaces to linear solvers from different packages like PETSc and LASPACK |
CLocationMap | Data structures that enable location-based lookups The key is a hash of the Point location |
CLogicError | A class to represent the internal "this should never happen" errors, to be thrown by "libmesh_error();" |
CLumpedMassMatrix | Template class used to construct a lumped mass matrix |
CMappedSubdomainPartitioner | The MappedSubdomainPartitioner partitions the elements based on their subdomain ids |
▶Cmapvector | This mapvector templated class is intended to provide the performance characteristics of a std::map with an interface more closely resembling that of a std::vector, for use with DistributedMesh |
Cconst_reverse_veclike_iterator | |
Cconst_veclike_iterator | |
Cveclike_iterator | |
CMatlabIO | This class implements reading meshes in the Matlab PDE toolkit in a proprietary format |
CMatrixFillAction | The MatrixFillAction output functor class can be used with GenericProjector to write solution transfer coefficients into a sparse matrix |
CMEDITIO | This class implements writing meshes in the mesh format used by the MEdit visualization tool developed in the Gamma Project at INRIA Roquencourt |
CMemoryHistoryData | MemoryHistoryData provides a data structure to store memory history data |
CMemorySolutionHistory | Subclass of Solution History that stores the solutions and other important vectors in memory |
CMesh | The Mesh class is a thin wrapper, around the ReplicatedMesh class by default |
Cmesh_inserter_iterator | A class for templated methods that expect output iterator arguments, which adds objects to the Mesh |
▶CMeshBase | This is the MeshBase class |
Cconst_element_iterator | The definition of the const_element_iterator struct |
Cconst_node_iterator | The definition of the const_node_iterator struct |
Celement_iterator | The definition of the element_iterator struct |
Cnode_iterator | The definition of the node_iterator struct |
CMeshCommunication | This is the MeshCommunication class |
CMeshfreeInterpolation | Base class to support various mesh-free interpolation methods |
CMeshfreeSolutionTransfer | Implementation of a SolutionTransfer object that utilizes the MeshfreeInterpolation system to interpolate one solution to another |
CMeshFunction | This class provides function-like objects for data distributed over a mesh |
CMeshFunctionSolutionTransfer | Implementation of a SolutionTransfer object that only works for transferring the solution using a MeshFunction |
CMeshInput | This class defines an abstract interface for Mesh input |
CMeshlessInterpolationFunction | |
CMeshOutput | This class defines an abstract interface for Mesh output |
▶CMeshRefinement | Implements (adaptive) mesh refinement algorithms for a MeshBase |
CElementFlagging | Abstract base class to be used for user-specified element flagging |
CMeshSerializer | Temporarily serialize a DistributedMesh for non-distributed-mesh capable code paths |
CMeshSmoother | This class provides the necessary interface for mesh smoothing |
CMETIS_CSR_Graph | This utility class provides a convenient implementation for building the compressed-row-storage graph required for the METIS/ParMETIS graph partitioning schemes |
CMetisPartitioner | The MetisPartitioner uses the Metis graph partitioner to partition the elements |
CMortonSFCPartitioner | The MortonSFCPartitioner uses a Morton space filling curve to partition the elements |
CNameBasedIO | This class supports simple reads and writes in any libMesh-supported format, by dispatching to one of the other I/O classes based on filename |
CNemesis_IO | The Nemesis_IO class implements reading parallel meshes in the Nemesis file format from Sandia National Labs |
CNemesis_IO_Helper | This is the Nemesis_IO_Helper class |
CNewmarkSolver | This class defines a Newmark time integrator for second order (in time) DifferentiableSystems |
CNewmarkSystem | This class contains a specific system class |
CNewtonSolver | This class defines a solver which uses the default libMesh linear solver in a quasiNewton method to handle a DifferentiableSystem |
CNloptOptimizationSolver | This class provides an interface to the NLopt optimization solvers |
CNode | A Node is like a Point , but with more information |
CNodeConstraints | The Node constraint storage format |
CNodeElem | The NodeElem is a point element, generally used as a side of a 1D element |
▶CNonlinearImplicitSystem | Manages consistently variables, degrees of freedom, coefficient vectors, matrices and non-linear solvers for implicit systems |
CComputeBounds | Abstract base class to be used to calculate the bounds on the degrees of freedom of a nonlinear system |
CComputeJacobian | Abstract base class to be used to calculate the Jacobian of a nonlinear system |
CComputePostCheck | Abstract base class to be used for applying user modifications to the solution vector and/or Newton update step after each nonlinear step |
CComputePreCheck | Abstract base class to be used for applying user modifications to the Newton search direction before the solver's line search is called |
CComputeResidual | Abstract base class to be used to calculate the residual of a nonlinear system |
CComputeResidualandJacobian | Abstract base class to be used to calculate the residual and Jacobian simultaneously of a nonlinear system |
CComputeVectorSubspace | Callable abstract base class to be used as a callback to provide the solver with a basis for the system's Jacobian's nullspace (the kernel or the "zero energy modes") or near-nullspace (the "low energy modes") |
CNonlinearSolver | This base class can be inherited from to provide interfaces to nonlinear solvers from different packages like PETSc and Trilinos |
CNoSolutionHistory | 'Save nothing' subclass of Solution History, this is the default |
CNotImplemented | A class to stub for features that should be in libMesh, but haven't been written yet, to be thrown by "libmesh_not_implemented();" |
CNoxNonlinearSolver | This class provides an interface to nox iterative solvers that is compatible with the libMesh NonlinearSolver<> |
Cnull_output_iterator | A do-nothing class for templated methods that expect output iterator arguments |
CNumericVector | Provides a uniform interface to vector storage schemes for different linear algebra libraries |
COFFIO | This class is responsible for reading an unstructured, triangulated surface in the standard OFF OOGL format |
COldSolutionBase | The OldSolutionBase input functor abstract base class is the root of the OldSolutionValue and OldSolutionCoefs classes which allow a GenericProjector to read old solution values or solution interpolation coefficients for a just-refined-and-coarsened mesh |
COldSolutionCoefs | The OldSolutionCoefs input functor class can be used with GenericProjector to read solution transfer coefficients on a just-refined-and-coarsened mesh |
COldSolutionValue | The OldSolutionValue input functor class can be used with GenericProjector to read values from a solution on a just-refined-and-coarsened mesh |
COptimizationSolver | This base class can be inherited from to provide interfaces to optimization solvers from different packages like PETSc/TAO and nlopt |
▶COptimizationSystem | This System subclass enables us to assemble an objective function, gradient, Hessian and bounds for optimization problems |
CComputeEqualityConstraints | Abstract base class to be used to calculate the equality constraints |
CComputeEqualityConstraintsJacobian | Abstract base class to be used to calculate the Jacobian of the equality constraints |
CComputeGradient | Abstract base class to be used to calculate the gradient of an objective function |
CComputeHessian | Abstract base class to be used to calculate the Hessian of an objective function |
CComputeInequalityConstraints | Abstract base class to be used to calculate the inequality constraints |
CComputeInequalityConstraintsJacobian | Abstract base class to be used to calculate the Jacobian of the inequality constraints |
CComputeLowerAndUpperBounds | Abstract base class to be used to calculate the lower and upper bounds for all dofs in the system |
CComputeObjective | Abstract base class to be used to calculate the objective function for optimization |
COrderWrapper | This provides a shim class that wraps the Order enum |
CParallelMesh | |
CParallelObject | An object whose state is distributed along a set of processors |
CParameterAccessor | Accessor object allowing reading and modification of the independent variables in a parameter sensitivity calculation |
CParameterMultiAccessor | Accessor object allowing reading and modification of the independent variables in a parameter sensitivity calculation |
CParameterMultiPointer | Accessor object allowing reading and modification of the independent variables in a parameter sensitivity calculation |
CParameterPointer | Accessor object allowing reading and modification of the independent variables in a parameter sensitivity calculation |
CParameterProxy | |
▶CParameters | This class provides the ability to map between arbitrary, user-defined strings and several data types |
CParameter | Concrete definition of a parameter value for a specified type |
CValue | Abstract definition of a parameter value |
CParameterVector | Data structure for specifying which Parameters should be independent variables in a parameter sensitivity calculation |
CParmetisHelper | The ParmetisHelper class allows us to use a 'pimpl' strategy in the ParmetisPartitioner class |
CParmetisPartitioner | The ParmetisPartitioner uses the Parmetis graph partitioner to partition the elements |
CParsedFEMFunction | ParsedFEMFunction provides support for FParser-based parsed functions in FEMSystem |
CParsedFEMFunctionParameter | Accessor object allowing reading and modification of the independent variables in a parameter sensitivity calculation |
CParsedFunction | A Function generated (via FParser) by parsing a mathematical expression |
CParsedFunctionParameter | Accessor object allowing reading and modification of the independent variables in a parameter sensitivity calculation |
CPartitioner | The Partitioner class provides a uniform interface for partitioning algorithms |
CPatch | This class implements useful utility functions for a patch of elements |
▶CPatchRecoveryErrorEstimator | This class implements the Patch Recovery error indicator |
CEstimateError | Class to compute the error contribution for a range of elements |
CPerfData | The PerfData class simply contains the performance data that is recorded for individual events |
CPerfItem | Used for logging something that naturally lasts as long as some enclosing scope, such as the current function |
CPerfLog | The PerfLog class allows monitoring of specific events |
CPerfMon | PAPI stands for Performance Application Programming Interface |
CPeriodicBoundaries | We're using a class instead of a typedef to allow forward declarations and future flexibility |
CPeriodicBoundary | The definition of a periodic boundary |
CPeriodicBoundaryBase | The base class for defining periodic boundaries |
CPetscDiffSolver | This class defines a solver which uses a PETSc SNES context to handle a DifferentiableSystem |
CPetscDMContext | Struct to house data regarding where in the mesh hierarchy we are located |
CPetscDMWrapper | This class defines a wrapper around the PETSc DM infrastructure |
CPetscLinearSolver | This class provides an interface to PETSc iterative solvers that is compatible with the libMesh LinearSolver<> |
CPetscMatrix | This class provides a nice interface to the PETSc C-based data structures for parallel, sparse matrices |
▶CPetscNonlinearSolver | This class provides an interface to PETSc iterative solvers that is compatible with the libMesh NonlinearSolver<> |
CComputeLineSearchObject | Abstract base class to be used to implement a custom line-search algorithm |
CPetscPreconditioner | This class provides an interface to the suite of preconditioners available from PETSc |
CPetscShellMatrix | This class allows to use a PETSc shell matrix |
CPetscSolverException | A specialization of the SolverException class for PETSc |
CPetscVector | This class provides a nice interface to PETSc's Vec object |
CPlane | This class defines a plane |
CPltLoader | This class will read a binary .plt file |
CPoint | A Point defines a location in LIBMESH_DIM dimensional Real space |
CPointerToPointerIter | The PointerToPointerIter templated class is intended to wrap pointer-to-pointer iterators in an interface which works more like a standard iterator, by returning a value rather than a pointer |
CPointLocatorBase | This is the base class for point locators |
CPointLocatorNanoflann | This is a PointLocator that uses Nanoflann for its implementation |
CPointLocatorTree | This is a point locator |
CPointNeighborCoupling | This class implements the default algebraic coupling in libMesh: elements couple to themselves, but may also couple to neighbors both locally and across periodic boundary conditions |
CPoly2TriTriangulator | A C++ interface between LibMesh and the poly2tri library, with custom code for Steiner point insertion |
▶CPoolAllocator | An allocator which can be used in standard containers |
Crebind | Methods required for copy construction of containers using this allocator |
CPostscriptIO | This class implements writing 2D meshes in Postscript |
CPreconditioner | This class provides a uniform interface for preconditioners |
CPrism | The Prism is an element in 3D with 5 sides |
CPrism15 | The Prism15 is an element in 3D composed of 15 nodes |
CPrism18 | The Prism18 is an element in 3D composed of 18 nodes |
CPrism20 | The Prism20 is an element in 3D composed of 20 nodes |
CPrism21 | The Prism21 is an element in 3D composed of 21 nodes |
CPrism6 | The Prism6 is an element in 3D composed of 6 nodes |
CProblem_Interface | |
CPyramid | The Pyramid is an element in 3D with 5 sides |
CPyramid13 | The Pyramid13 is an element in 3D composed of 13 nodes, designed to interface with a QUAD8 element on the base and a TRI6 element on each of the triangular faces |
CPyramid14 | The Pyramid14 is an element in 3D composed of 14 nodes, designed to interface with a QUAD9 element on the base and a TRI6 element on each of the triangular faces |
CPyramid18 | The Pyramid18 is an element in 3D composed of 18 nodes, designed to interface with a QUAD9 element on the base and a TRI7 element on each of the triangular faces |
CPyramid5 | The Pyramid5 is an element in 3D composed of 5 nodes |
CQBase | The QBase class provides the basic functionality from which various quadrature rules can be derived |
CQClough | This class creates a Gaussian quadrature rule duplicated for each subelement of a Clough-Tocher divided macroelement |
CQComposite | This class implements generic composite quadrature rules |
CQConical | This class implements the so-called conical product quadrature rules for Tri and Tet elements |
CQGauss | This class implements specific orders of Gauss quadrature |
CQGaussLobatto | This class implements Gauss-Lobatto quadrature for 1D elements and 2D/3D tensor product elements |
CQGrid | This class creates quadrature points on a uniform grid, with order+1 points on an edge |
CQGrundmann_Moller | This class implements the Grundmann-Moller quadrature rules for tetrahedra |
CQJacobi | This class implements two (for now) Jacobi-Gauss quadrature rules |
CQMonomial | This class defines alternate quadrature rules on "tensor-product" elements (quadrilaterals and hexahedra) which can be useful when integrating monomial finite element bases |
CQNodal | This class implements nodal quadrature rules for various element types |
▶CQoISet | Data structure for specifying which Quantities of Interest should be calculated in an adjoint or a parameter sensitivity calculation |
Citerator | |
CQSimpson | This class implements Simpson quadrature |
CQTrap | This class implements trapezoidal quadrature |
CQuad | The QUAD is an element in 2D composed of 4 sides |
CQuad4 | The QUAD4 is an element in 2D composed of 4 nodes |
CQuad8 | The QUAD8 is an element in 2D composed of 8 nodes |
CQuad9 | The QUAD9 is an element in 2D composed of 9 nodes |
CQuadShell4 | QuadShell4 is almost identical to Quad4 |
CQuadShell8 | QuadShell8 is almost identical to Quad8 |
CRadialBasisInterpolation | Radial Basis Function interpolation |
CRawAccessor | This class provides single index access to FieldType (i.e |
CRawAccessor< TypeNTensor< N, ScalarType > > | Stub implementations for stub TypeNTensor object |
CRawFieldType | What underlying data type would we need to access in each field? |
CRawFieldType< Gradient > | |
CRawFieldType< Number > | |
CRawFieldType< Real > | |
CRawFieldType< RealGradient > | |
CRawFieldType< RealTensor > | |
CRawFieldType< Tensor > | |
CRawFieldType< TypeNTensor< 3, Number > > | |
CRawFieldType< TypeNTensor< 3, Real > > | |
CRBAssemblyExpansion | This class stores the set of ElemAssembly functor objects that define the "parameter-independent expansion" of a PDE |
CRBConstruction | This class is part of the rbOOmit framework |
CRBConstructionBase | This class is part of the rbOOmit framework |
CRBEIMAssembly | This class provides functionality required to define an assembly object that arises from an "Empirical Interpolation Method" (EIM) approximation |
CRBEIMConstruction | This class is part of the rbOOmit framework |
CRBEIMEvaluation | This class enables evaluation of an Empirical Interpolation Method (EIM) approximation |
CRBEIMTheta | This class provides functionality required to define an RBTheta object that arises from an "Empirical Interpolation Method" (EIM) approximation |
CRBEvaluation | This class is part of the rbOOmit framework |
▶CRBParameters | This class is part of the rbOOmit framework |
Cconst_iterator | Define a constant iterator for iterating over the map of parameters |
CRBParametrized | This class is part of the rbOOmit framework |
CRBParametrizedFunction | A simple functor class that provides a RBParameter-dependent function |
CRBSCMConstruction | This class is part of the rbOOmit framework |
CRBSCMEvaluation | This class is part of the rbOOmit framework |
CRBTemporalDiscretization | Define a class that encapsulates the details of a "generalized Euler" temporal discretization to be used in the rbOOmit framework |
CRBTheta | This class is part of the rbOOmit framework |
CRBThetaExpansion | This class stores the set of RBTheta functor objects that define the "parameter-dependent expansion" of a PDE |
CRealTraits | |
CReferenceCountedObject | This class implements reference counting |
CReferenceCounter | This is the base class for enabling reference counting |
CRefinementSelector | This abstract class provides an interface to methods for selecting the type of refinement to be used on each element in a given mesh |
CRemoteElem | In parallel meshes where a ghost element has neighbors which do not exist on the local processor, the ghost element's neighbors are set to point to the singleton RemoteElement instead |
CReplicatedMesh | The ReplicatedMesh class is derived from the MeshBase class, and is used to store identical copies of a full mesh data structure on each processor |
CResidualContext | |
CScalarTraits | |
CScalarTraits< MetaPhysicL::DualNumber< T, D, asd > > | |
CScalarTraits< MetaPhysicL::DynamicSparseNumberArray< T, IndexType > > | |
CScalarTraits< std::complex< T > > | |
CSecondOrderUnsteadySolver | Generic class from which second order UnsteadySolvers should subclass |
▶CSensitivityData | Data structure for holding completed parameter sensitivity calculations |
CConstRow | |
CRow | |
CSerialMesh | |
CSFCPartitioner | The SFCPartitioner uses a Hilbert or Morton-ordered space filling curve to partition the elements |
CShellMatrix | Generic shell matrix, i.e |
CSiblingCoupling | This class adds coupling (for use in send_list construction) between active elements and all descendants of their parent |
CSide | This defines the Side class |
CSideEdge | This defines the SideEdge class |
CSimpleRange | The SimpleRange templated class is intended to make it easy to construct ranges from pairs of iterators |
▶CSingleton | Base class for all library singleton objects |
CSetup | Abstract base class for runtime singleton setup |
CSlepcEigenSolver | This class provides an interface to the SLEPc eigenvalue solver library from http://slepc.upv.es/ |
CSolutionHistory | A SolutionHistory class that enables the storage and retrieval of timesteps and (in the future) adaptive steps |
CSolutionTransfer | Base class for objects that allow transferring variable values between different systems with different meshes |
CSolverConfiguration | This class stores solver configuration data, e.g |
CSolverException | A class representing an exception during a solve |
CSparseMatrix | Generic sparse matrix |
CSparseShellMatrix | This class allows to use any SparseMatrix object as a shell matrix |
CSphere | This class defines a sphere |
CStatisticsVector | The StatisticsVector class is derived from the std::vector<> and therefore has all of its useful features |
CSteadySolver | This class implements a TimeSolver which does a single solve of the steady state problem |
CStoredRange | The StoredRange class defines a contiguous, divisible set of objects |
CSubdomainPartitioner | The SubdomainPartitioner partitions the elements in "chunks" of user-specified subdomain ids |
CSumShellMatrix | This class combines any number of shell matrices to a single shell matrix by summing them together |
CSurface | The base class for all "surface" related geometric objects |
CSyncElementIntegers | |
CSyncLocalIDs | |
CSyncNodalPositions | |
CSyncRefinementFlags | |
CSyncSubdomainIds | |
▶CSystem | Manages consistently variables, degrees of freedom, and coefficient vectors |
CAssembly | Abstract base class to be used for system assembly |
CConstraint | Abstract base class to be used for system constraints |
CInitialization | Abstract base class to be used for system initialization |
CQOI | Abstract base class to be used for quantities of interest |
CQOIDerivative | Abstract base class to be used for derivatives of quantities of interest |
CSystemNorm | This class defines a norm/seminorm to be applied to a NumericVector which contains coefficients in a finite element space |
CSystemSubset | This is a base class for classes which represent subsets of the dofs of a System |
▶CSystemSubsetBySubdomain | This class represents a subset of the dofs of a System , selected by the subdomain_id and possible the variable numbers |
CSubdomainSelection | Subclass for user-specified selection of subdomain ids to be included in a SystemSubset |
CSubdomainSelectionByList | Selection of subdomain ids by a list |
CTaoOptimizationSolver | This class provides an interface to the Tao optimization solvers |
CTecplotIO | This class implements writing meshes in the Tecplot format |
CTensorShellMatrix | Shell matrix that is given by a tensor product of two vectors, i.e |
▶CTensorValue | This class defines a tensor in LIBMESH_DIM dimensional Real or Complex space |
Crebind | |
CTestClass | |
CTet | The Tet is an element in 3D composed of 4 sides |
CTet10 | The Tet10 is an element in 3D composed of 10 nodes |
CTet14 | The Tet14 is an element in 3D composed of 14 nodes |
CTet4 | The Tet4 is an element in 3D composed of 4 nodes |
CTetGenIO | This class implements reading and writing meshes in the TetGen format |
CTetGenMeshInterface | Class TetGenMeshInterface provides an interface for tetrahedralization of meshes using the TetGen library |
CTetGenWrapper | The TetGenWrapper provides an interface for basic access to TetGen data structures and methods |
CTimeSolver | This is a generic class that defines a solver to handle time integration of DifferentiableSystems |
CTopologyMap | Data structures that enable topology-based lookups of nodes created by mesh refinement |
CTransientRBAssemblyExpansion | This extends RBAssemblyExpansion to provide an assembly expansion for the case of time-dependent PDEs |
CTransientRBConstruction | This class is part of the rbOOmit framework |
CTransientRBEvaluation | This class is part of the rbOOmit framework |
CTransientRBThetaExpansion | This class stores the set of RBTheta functor objects that define the "parameter-dependent expansion" of a PDE |
CTransientSystem | Manages storage and variables for transient systems |
CTree | This class defines a tree that may be used for fast point location in space |
CTreeBase | This is the base class for trees, it allows pointer usage of trees |
CTreeNode | This class defines a node on a tree |
CTri | The Tri is an element in 2D composed of 3 sides |
CTri3 | The Tri3 is an element in 2D composed of 3 nodes |
CTri3Subdivision | The Tri3Subdivision element is a three-noded subdivision surface shell element used in mechanics calculations |
CTri6 | The Tri6 is an element in 2D composed of 6 nodes |
CTri7 | The Tri7 is an element in 2D composed of 7 nodes |
CTriangleInterface | A C++ interface between LibMesh and the Triangle library written by J.R |
▶CTriangulatorInterface | |
CAffineHole | A way to translate and/or rotate an existing hole; perhaps to tile it in many places or to put it at an angle that the underlying hole doesn't support |
CArbitraryHole | Another concrete instantiation of the hole, this one should be sufficiently general for most non-polygonal purposes |
CHole | An abstract class for defining a 2-dimensional hole |
CMeshedHole | Another concrete instantiation of the hole, as general as ArbitraryHole, but based on an existing 1D or 2D mesh |
CPolygonHole | A concrete instantiation of the Hole class that describes polygonal (triangular, square, pentagonal, ...) holes |
CRegion | A class for defining a 2-dimensional region for Triangle |
CTrilinosPreconditioner | This class provides an interface to the suite of preconditioners available from Trilinos |
CTriShell3 | TriShell3 is almost identical to Tri3 |
Ctuple_n | |
Ctuple_n< 0, T > | |
CTwostepTimeSolver | This class wraps another UnsteadySolver derived class, and compares the results of timestepping with deltat and timestepping with 2*deltat to adjust future timestep lengths |
CTypeNTensor | This class will eventually define a rank-N tensor in LIBMESH_DIM dimensional space of type T |
CTypesEqual | |
CTypesEqual< T, T > | |
CTypeTensor | This class defines a tensor in LIBMESH_DIM dimensional space of type T |
CTypeTensorColumn | |
CTypeToSend | For ease of communication, we allow users to translate their own value types to a more easily computable (typically a vector of some fixed-size type) output, by specializing these calls using different types |
CTypeToSend< MetaPhysicL::DynamicSparseNumberArray< T, IndexType > > | |
CTypeVector | This class defines a vector in LIBMESH_DIM dimensional space of type T |
CTypeVectorAttributes | |
CTypeVectorOpFunction | |
CUCDIO | This class implements reading & writing meshes in the AVS's UCD format |
CUniformRefinementEstimator | This class implements a `‘brute force’' error estimator which integrates differences between the current solution and the solution on a uniformly refined (in h and/or p, for an arbitrary number of levels) grid |
CUnsteadySolver | This is a generic class that defines a solver to handle time integration of DifferentiableSystems |
CUnstructuredMesh | The UnstructuredMesh class is derived from the MeshBase class |
CUNVIO | The UNVIO class implements the Ideas UNV universal file format |
CVariable | This class defines the notion of a variable in the system |
CVariableGroup | This class defines a logically grouped set of variables in the system |
▶CVariationalMeshSmoother | This is an implementation of Larisa Branets' smoothing algorithms |
CArray2D | 2D array type for interfacing with C APIs |
CArray3D | 3D array type for interfacing with C APIs |
CVectorizedEvalInput | Define a struct for the input to the "vectorized evaluate" functions below |
▶Cvectormap | This vectormap templated class is intended to provide the performance characteristics of a sorted std::vector with an interface more closely resembling that of a std::map, for use in particular when memory is tight |
CFirstCompare | Equality comparison, based solely on first element in a pair |
CFirstOrder | Strict weak ordering, based solely on first element in a pair |
CVectorOfNodesAdaptor | |
CVectorSetAction | The VectorSetAction output functor class can be used with a GenericProjector to set projection values (which must be of type Val) as coefficients of the given NumericVector |
▶CVectorValue | This class defines a vector in LIBMESH_DIM dimensional Real or Complex space |
Crebind | |
▶CVTKIO | This class implements reading and writing meshes in the VTK format |
CElementMaps | Helper object that holds a map from VTK to libMesh element types and vice-versa |
▶CWeightedPatchRecoveryErrorEstimator | This class implements the Patch Recovery error indicator |
CEstimateError | Class to compute the error contribution for a range of elements |
CWendlandRBF | Simple radial basis function |
CWrappedFunction | Wrap a libMesh-style function pointer into a FunctionBase object |
CWrappedFunctor | This class provides a wrapper with which to evaluate a (libMesh-style) function pointer in a FunctionBase-compatible interface |
CWrappedPetsc | |
CXdr | This class implements a C++ interface to the XDR (eXternal Data Representation) format |
CXdrIO | MeshIO class used for writing XDR (eXternal Data Representation) and XDA mesh files |
CZeroFunction | ConstFunction that simply returns 0 |
▶NMetaPhysicL | |
CRawType< libMesh::DenseMatrix< T > > | |
CRawType< libMesh::DenseVector< T > > | |
CRawType< libMesh::TensorValue< T > > | |
CRawType< libMesh::TypeTensor< T > > | |
CRawType< libMesh::TypeVector< T > > | |
CRawType< libMesh::VectorValue< T > > | |
CReplaceAlgebraicType< libMesh::TensorValue< T >, U > | |
CReplaceAlgebraicType< libMesh::TypeTensor< T >, U > | |
CReplaceAlgebraicType< libMesh::TypeVector< T >, U > | |
CReplaceAlgebraicType< libMesh::VectorValue< T >, U > | |
▶Nstd | |
Chash< libMesh::FEType > | |
Chash< libMesh::Point > | |
Cmultiplies< boost::multiprecision::float128 > | |
Cplus< boost::multiprecision::float128 > | |
▶NTIMPI | |
CAttributes< libMesh::FEType > | |
CAttributes< libMesh::Point > | |
CAttributes< libMesh::TypeVector< T > > | |
CAttributes< libMesh::VectorValue< T > > | |
COpFunction< libMesh::FEType > | |
COpFunction< libMesh::Point > | |
COpFunction< libMesh::TypeVector< T > > | |
COpFunction< libMesh::VectorValue< T > > | |
CStandardType< Hilbert::HilbertIndices > | |
CStandardType< libMesh::FEType > | |
CStandardType< libMesh::Point > | |
CStandardType< libMesh::TensorValue< T >, typename std::enable_if< StandardType< T >::is_fixed_type >::type > | |
CStandardType< libMesh::TypeTensor< T >, typename std::enable_if< StandardType< T >::is_fixed_type >::type > | |
CStandardType< libMesh::TypeVector< T >, typename std::enable_if< StandardType< T >::is_fixed_type >::type > | |
CStandardType< libMesh::VectorValue< T >, typename std::enable_if< StandardType< T >::is_fixed_type >::type > | |
CA0 | |
CA1 | |
CA2 | |
CA3 | |
CAcousticsInnerProduct | |
CAcousticsRBAssemblyExpansion | |
CAcousticsRBThetaExpansion | |
CAllSecondOrderTest | |
CAllTriTest | |
CAssembleOptimization | This class encapsulate all functionality required for assembling the objective function, gradient, and hessian |
CAssemblyA0 | |
CAssemblyA1 | |
CAssemblyA2 | |
CAssemblyEIM | |
CAssemblyF0 | |
CAssemblyF1 | |
CAssemblyF2 | |
CAssemblyPointLoadX | |
CAssemblyPointLoadY | |
CAssemblyPointLoadZ | |
CAugmentSparsityOnInterface | |
CAugmentSparsityOnNodes | |
CAzimuthalPeriodicBoundary | |
CB | |
CBBoxTest | |
CBdyFunction | |
▶CBiharmonic | Encapsulates most of the data structures necessary to calculate the biharmonic residual and Jacobian, auxiliary quantities, to take a timestep, and to output the state – biharmonic solution and vectors of auxiliary quantities |
CJR | Biharmonic's friend class definition |
CBoundaryInfoTest | |
CBoundaryMeshTest | |
CBoundaryRefinedMeshTest | |
CCDRBAssemblyExpansion | |
CCDRBThetaExpansion | |
CCheckpointIOTest | |
CComplexVectorValueTest | |
CCompositeFunctionTest | |
CConstantFirstOrderODE | Implements ODE: 2.1 |
CConstantSecondOrderODE | Implements ODE: 3.14{u} = 2.71, u(0) = 0, |
CConstraintOperatorTest | |
CContainsPointTest | |
CContrivedPartitioner | |
CCopyNodesAndElementsTest | |
CCoupledFEMFunctionsx | |
CCoupledFEMFunctionsy | |
CCoupledSystem | |
CCoupledSystemQoI | |
CCouplingMatrixTest | |
CCurlCurlExactSolution | |
CCurlCurlSystem | FEMSystem, TimeSolver and NewtonSolver will handle most tasks, but we must specify element residuals |
CDefaultCouplingTest | |
CDenseMatrixTest | |
CDiagonalMatrixTest | |
CDistortTest | |
CDistributedMeshTest | |
CDistributedVectorTest | |
CDivGradExactSolution | |
CDM_libMesh | |
CDMVec_libMesh | |
CDofMapTest | |
CDofObjectTest | |
CDualShapeTest | This class is for unit testing dual coefficient and shape function values |
CEdgeTest | |
CEigenSparseMatrixTest | |
CEigenSparseVectorTest | |
CEIM_F | |
CEIM_IP_assembly | |
CEimTestRBAssemblyExpansion | |
CEimTestRBThetaExpansion | |
CElasticityAssembly | |
CElasticityAssemblyExpansion | |
CElasticityRBConstruction | |
CElasticityRBEvaluation | |
CElasticitySystem | |
CElasticityThetaExpansion | |
CElemTest | |
CEpetraVectorTest | |
CEquationSystemsTest | |
CEuler2SolverSecondOrderTest | |
CEuler2SolverTest | |
CEulerSolverSecondOrderTest | |
CEulerSolverTest | |
CEx02RBAssemblyExpansion | |
CEx02RBThetaExpansion | |
CEx6AssemblyExpansion | |
CEx6InnerProduct | |
CEx6ThetaExpansion | |
CExactSoln | |
CExampleOneFunction | |
CExodusTest | |
CExtraIntegersTest | |
CF0 | |
CFEMParameters | |
CFESideTest | |
CFETest | |
CFETestBase | |
CFirstOrderScalarSystemBase | FEMSystem-based class for testing of TimeSolvers using first order SCALARs |
▶CFParserAutodiffTest | |
CADTest | |
CGetBoundaryPointsSecondTest | |
CGetBoundaryPointsTest | |
CGetPotTest | |
CGxyz | |
CHDGProblem | |
CHeatSystem | |
▶CInfFERadialTest | This class is for unit testing the "radial" basis function aspects of the InfFE |
CTabulatedGrad | |
CTabulatedVal | |
CInnerProductAssembly | |
CIntegrate | |
CL2System | |
CLaplaceExactGradient | |
CLaplaceExactSolution | |
CLaplaceQoI | |
CLaplaceSystem | |
CLaplaceYoung | A class which provides the residual and jacobian assembly functions for the Laplace-Young system of equations |
CLargeDeformationElasticity | |
CLaspackMatrixTest | |
CLaspackVectorTest | |
CLibMeshPoly2TriTest | |
CLinearElasticity | |
CLinearElasticityWithContact | This class encapsulate all functionality required for assembling and solving a linear elastic model with contact |
CLinearTimeFirstOrderODE | Implements ODE: 5.0 |
CLinearTimeSecondOrderODE | Implements ODE: 1.0{u} = 6.0*t+2.0, u(0) = 0, |
CLumpedMassMatrixTest | |
CM0 | |
CMappedSubdomainPartitionerTest | |
CMeshAssignTest | |
CMeshBaseTest | |
CMeshDeletionsTest | |
▶CMeshExtruderTest | |
CQueryElemSubdomainID | |
CMeshfunctionDFEM | |
CMeshFunctionTest | |
CMeshGenerationTest | |
CMeshInputTest | |
CMeshSpatialDimensionTest | |
CMeshStitchTest | |
CMeshSubdomainIDTest | |
CMeshTriangulationTest | |
CMessageTagTest | |
CMixedDimensionMeshTest | |
CMixedDimensionNonUniformRefinement | |
CMixedDimensionNonUniformRefinement3D | |
CMixedDimensionNonUniformRefinementTriangle | |
CMixedDimensionRefinedMeshTest | |
CMixedExactSolution | |
CMixedOrderTest | |
CMultiEvaluablePredTest | |
CMyConstraint | |
CNavierSystem | |
CNewmarkSolverTest | |
CNewmarkSolverTestBase | |
CNodalNeighborsTest | |
CNodeTest | |
CNonlinearNeoHookeCurrentConfig | This class implements a constitutive formulation for an Neo-Hookean elastic solid in terms of the current configuration |
CNumberVectorValueTest | |
CNumericVectorTest | |
COutput0 | |
COutputAssembly | Output assembly object which computes the average value of the solution variable inside a user-provided BoundingBox |
COverlappingAlgebraicGhostingTest | |
COverlappingCouplingFunctor | |
COverlappingCouplingGhostingTest | |
COverlappingFunctorTest | |
COverlappingTestBase | |
COverlappingTestPartitioner | |
CPackedRangeTest | |
CPackingTypesTest | |
CParallelGhostSyncTest | |
CParallelPointTest | |
CParallelSortTest | |
CParallelSyncTest | |
CParallelTest | |
CParametersTest | |
CParsedFEMFunctionTest | |
CParsedFunctionTest | |
CPartitionerTest | |
CPerElemTest | |
CPeriodicBCTest | |
CPeriodicQuadFunction | |
CPetscMatrixTest | |
CPetscSolverConfiguration | |
CPetscVectorTest | |
CPointLocatorTest | |
CPointNeighborCouplingTest | |
CPointTest | |
CPointTestBase | |
CPoissonSystem | |
CPSoln | |
CQuadratureTest | |
CRationalMapTest | |
CRBParametersTest | |
CRealVectorValueTest | |
CSecondOrderScalarSystemFirstOrderTimeSolverBase | FEMSystem-based class for testing of TimeSolvers using second order SCALARs |
CSecondOrderScalarSystemSecondOrderTimeSolverBase | FEMSystem-based class for testing of TimeSolvers using second order SCALARs |
CShiftedGaussian | |
CSideTest | |
CSigmaPhysics | |
CSimpleEIMConstruction | |
CSimpleEIMEvaluation | |
CSimpleRBConstruction | |
CSimpleRBEvaluation | |
CSkewFunc | |
CSlepcSolverConfiguration | A class that interfaces the SolverConfiguration to add the SLEPC option SetST |
CSlitFunc | |
CSlitMeshRefinedMeshTest | |
CSlitMeshRefinedSystemTest | |
CSlitMeshTest | |
CSolidSystem | |
CSolutionFunction | |
CSolutionGradient | |
CSparseMatrixTest | |
CStreamRedirector | This class uses RAII to control redirecting the libMesh::err stream to NULL and restoring it around some operation where we do not want to see output to the screen |
CSystemsTest | |
CTensorTraitsTest | |
CThetaA0 | |
CThetaA1 | |
CThetaA2 | |
CThetaA3 | |
CThetaConstant | |
CThetaEIM | |
CThetaF0 | |
CThetaF1 | |
CThetaF2 | |
CThetaOutput0 | |
CThetaPointLoadX | |
CThetaPointLoadY | |
CThetaPointLoadZ | |
CThetaSolverTestBase | |
CTimeSolverTestImplementation | |
Ctimeval | |
Ctoken | |
CTransparentComparatorTest | |
CTripleFunction | |
CTypeTensorTest | |
CTypeVectorTestBase | |
CUnitPerfItem | |
CUSoln | |
▶Cvariant_filter_iterator | Original Authors: Corwin Joy * Michael Gradman cjoy@.nosp@m.hous.nosp@m.ton.r.nosp@m.r.co.nosp@m.m * Micha.nosp@m.el.G.nosp@m.radma.nosp@m.n@ca.nosp@m.minus.nosp@m..com Caminus, Suite 1150, Two Allen Center, 1200 Smith Street, Houston, TX 77002 This class is an extension of variant_bidirectional_iterator to a filter_iterator similar to boost's |
CIter | The actual iterator object is held as a template parameter here |
CIterBase | Abstract base class for the iterator type |
CPred | The actual predicate is held as a template parameter here |
CPredBase | Abstract base class for the predicate |
CVectorCompareTypesTest | |
CVectormapTest | |
CVolumeTest | |
CVSoln | |
CWhichNodeAmITest | |
CWriteEdgesetData | |
CWriteElemsetData | |
CWriteNodesetData | |
CWriteSidesetData | |
CWriteVecAndScalar | |
CXdrTest |