 |
MFEM v4.9.0
Finite element discretization library
|
|
MFEM v4.9.0
Finite element discretization library
|
| ►NGecko | |
| CArc | |
| CFunctional | |
| CFunctionalArithmetic | |
| CFunctionalGeometric | |
| CFunctionalHarmonic | |
| CFunctionalMaximum | |
| CFunctionalQuasiconvex | |
| CFunctionalRMS | |
| CFunctionalSMR | |
| CGraph | |
| ►CNode | |
| CComparator | |
| CProgress | |
| CWeightedSum | |
| CWeightedValue | |
| ►Nmfem | |
| ►Nblocksolvers | |
| CBBTSolver | |
| CBDPMinresSolver | Wrapper for the block-diagonal-preconditioned MINRES employed in ex5p.cpp |
| CBPCGSolver | Bramble-Pasciak Conjugate Gradient |
| CBPSParameters | Parameters for the BramblePasciakSolver method |
| CBramblePasciakSolver | Bramble-Pasciak Solver for Darcy equation |
| CDarcySolver | Abstract solver class for Darcy's flow |
| CDFSData | Data for the divergence free solver |
| CDFSParameters | Parameters for the divergence free solver |
| CDFSSpaces | |
| CDivFreeSolver | Divergence free solver |
| CIterSolveParameters | |
| CLocalSolver | Solver for local problems in SaddleSchwarzSmoother |
| CSaddleSchwarzSmoother | |
| CSymDirectSubBlockSolver | Block diagonal solver for symmetric A, each block is inverted by direct solver |
| ►Nceed | |
| CAlgebraicCoarseSpace | A way to use algebraic levels in a Multigrid object |
| CAlgebraicInterpolation | Multigrid interpolation operator in Ceed framework |
| CAlgebraicMultigrid | Extension of Multigrid object to algebraically generated coarse spaces |
| CAlgebraicSolver | Wrapper for AlgebraicMultigrid object |
| CAlgebraicSpaceHierarchy | Hierarchy of AlgebraicCoarseSpace objects for use in Multigrid object |
| CBasisHash | |
| CCoefficient | |
| CGridCoefficient | |
| CMFConvectionIntegrator | Represent a ConvectionIntegrator with AssemblyLevel::None using libCEED |
| CMFDiffusionIntegrator | Represent a DiffusionIntegrator with AssemblyLevel::None using libCEED |
| CMFIntegrator | |
| CMFMassIntegrator | Represent a MassIntegrator with AssemblyLevel::None using libCEED |
| CMFVectorConvectionNLFIntegrator | |
| CMixedIntegrator | This class wraps a ceed::PAIntegrator or ceed::MFIntegrator to support mixed finite element spaces |
| CMixedMFConvectionIntegrator | |
| CMixedMFDiffusionIntegrator | |
| CMixedMFMassIntegrator | |
| CMixedMFVectorConvectionNLIntegrator | |
| CMixedPAConvectionIntegrator | |
| CMixedPADiffusionIntegrator | |
| CMixedPAMassIntegrator | |
| CMixedPAVectorConvectionNLIntegrator | |
| COperator | |
| COperatorInfo | |
| CPAConvectionIntegrator | Represent a ConvectionIntegrator with AssemblyLevel::Partial using libCEED |
| CPADiffusionIntegrator | Represent a DiffusionIntegrator with AssemblyLevel::Partial using libCEED |
| CPAIntegrator | |
| CPAMassIntegrator | Represent a MassIntegrator with AssemblyLevel::Partial using libCEED |
| CParAlgebraicCoarseSpace | Parallel version of AlgebraicCoarseSpace |
| CPAVectorConvectionNLFIntegrator | |
| CQuadCoefficient | |
| CRestrHash | |
| CVariableCoefficient | |
| ►Ncommon | |
| CAffineTransformation | |
| CDistanceSolver | |
| CDivergenceFreeProjector | |
| CElementMeshStream | |
| CH1_FESpace | |
| CH1_ParFESpace | |
| CHeatDistanceSolver | |
| CIrrotationalProjector | |
| CKershawTransformation | |
| CL2_ParFESpace | |
| CND_FESpace | |
| CND_ParFESpace | |
| CNormalizationDistanceSolver | |
| CNormalizedGradCoefficient | |
| CParDiscreteCurlOperator | |
| CParDiscreteDivOperator | |
| CParDiscreteGradOperator | |
| CParDiscreteInterpolationOperator | |
| CParticleTrajectories | Helper class for easily visualizing particle trajectories using GLVis |
| CPDEFilter | |
| CPLapDistanceSolver | |
| CPProductCoefficient | |
| CPUMPLaplacian | |
| CRT_FESpace | |
| CRT_ParFESpace | |
| CScreenedPoisson | |
| CSpiralTransformation | |
| ►Nelectromagnetics | |
| CJouleHeatingCoefficient | |
| CMagneticDiffusionEOperator | |
| CMaxwellSolver | |
| CMeshDependentCoefficient | |
| CScaledGFCoefficient | |
| CSurfaceCurrent | |
| CTeslaSolver | |
| CVoltaSolver | |
| ►Neltrans | |
| CGeometryUtils | Various utilities for working with different element geometries |
| CGeometryUtils< Geometry::CUBE > | |
| CGeometryUtils< Geometry::SEGMENT > | |
| CGeometryUtils< Geometry::SQUARE > | |
| CLagrange | 1D Lagrange basis from [0, 1] |
| ►Nfuture | |
| Calways_false | |
| Ccreate_function_signature | |
| Ccreate_function_signature< output_t(*)(input_ts...)> | |
| Ccreate_function_signature< output_t(T::*)(input_ts...) const > | |
| CDerivativeOperator | |
| CDifferentiableOperator | |
| CDofToQuadMap | DofToQuadMap struct |
| Cdual | Dual number struct (value plus gradient) |
| CFDJacobian | |
| CFieldDescriptor | FieldDescriptor struct |
| CFieldOperator | Base class for FieldOperators |
| CFunctionSignature | |
| CFunctionSignature< output_t(input_ts...)> | |
| CGradient | Gradient FieldOperator |
| CIdentity | Identity FieldOperator |
| Cis_dual_number | Class for checking if a type is a dual number or not |
| Cis_dual_number< dual< value_type, gradient_type > > | Class for checking if a type is a dual number or not |
| Cis_gradient_fop | |
| Cis_gradient_fop< Gradient< FIELD_ID > > | |
| Cis_identity_fop | |
| Cis_identity_fop< Identity< FIELD_ID > > | |
| Cis_sum_fop | |
| Cis_sum_fop< Sum< FIELD_ID > > | |
| Cis_tuple | Trait for checking if a type is a mfem::tuple |
| Cis_tuple< tuple< T... > > | This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts |
| Cis_tuple_of_tuples | Trait for checking if a type if a mfem::tuple containing only mfem::tuple |
| Cis_tuple_of_tuples< tuple< T... > > | Trait for checking if a type if a mfem::tuple containing only mfem::tuple |
| Cis_value_fop | |
| Cis_value_fop< Value< FIELD_ID > > | |
| Cis_weight_fop | |
| Cis_weight_fop< Weight > | |
| Cis_zero | Checks if a type is zero |
| Cis_zero< zero > | |
| Cisotropic_tensor | |
| Cisotropic_tensor< T, 3, 3, 3 > | |
| Cisotropic_tensor< T, m, m > | |
| Cisotropic_tensor< T, m, m, m, m > | |
| Cisotropic_tensor< T, n > | |
| CParameterFunction | |
| CParameterSpace | Base class for parametric spaces |
| CSharedMemory | |
| CSharedMemoryInfo | |
| CSum | Sum FieldOperator |
| Ctensor | |
| Ctensor< T > | |
| Ctensor< T, 0 > | |
| Ctensor< T, 0, n1 > | |
| Ctensor< T, n0 > | |
| Ctensor< T, n0, n1 > | |
| Ctensor< T, n0, n1, n2 > | |
| Ctensor< T, n0, n1, n2, n3 > | |
| Ctensor< T, n0, n1, n2, n3, n4 > | |
| CThreadBlocks | ThreadBlocks struct |
| Ctuple | This is a class that mimics most of std::tuple's interface, except that it is usable in CUDA kernels and admits some arithmetic operator overloads |
| Ctuple< T0 > | Type that mimics std::tuple |
| Ctuple< T0, T1 > | Type that mimics std::tuple |
| Ctuple< T0, T1, T2 > | Type that mimics std::tuple |
| Ctuple< T0, T1, T2, T3 > | Type that mimics std::tuple |
| Ctuple< T0, T1, T2, T3, T4 > | Type that mimics std::tuple |
| Ctuple< T0, T1, T2, T3, T4, T5 > | Type that mimics std::tuple |
| Ctuple< T0, T1, T2, T3, T4, T5, T6 > | Type that mimics std::tuple |
| Ctuple< T0, T1, T2, T3, T4, T5, T6, T7 > | Type that mimics std::tuple |
| Ctuple< T0, T1, T2, T3, T4, T5, T6, T7, T8 > | |
| Ctuple_element | Struct used to determine the type at index I of a tuple |
| Ctuple_element< 0, tuple< Head, Tail... > > | This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts |
| Ctuple_element< I, tuple< Head, Tail... > > | This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts |
| Ctuple_size | |
| Ctuple_size< tuple< Types... > > | |
| CUniformParameterSpace | Uniform parameter space |
| CValue | Value FieldOperator |
| CWeight | Weight FieldOperator |
| Czero | A sentinel struct for eliding no-op tensor operations |
| ►NGinkgo | |
| CBICGSTABSolver | |
| CCBGMRESSolver | |
| CCGSolver | |
| CCGSSolver | |
| CEnableGinkgoSolver | |
| CFCGSolver | |
| CGinkgoExecutor | |
| CGinkgoIterativeSolver | |
| CGinkgoPreconditioner | |
| Cgko_mfem_destroy | |
| CGMRESSolver | |
| CIcIsaiPreconditioner | |
| CIcPreconditioner | |
| CIluIsaiPreconditioner | |
| CIluPreconditioner | |
| CIRSolver | |
| CJacobiPreconditioner | |
| CMFEMPreconditioner | |
| COperatorWrapper | |
| CResidualLogger | |
| CVectorWrapper | |
| ►NKDTreeNorms | |
| CNorm_l1 | Evaluates l1 norm of a vector |
| CNorm_l2 | Evaluates l2 norm of a vector |
| CNorm_li | Finds the max absolute value of a vector |
| ►Nkernels | |
| ►CInvariantsEvaluator2D | |
| CBuffers | |
| ►CInvariantsEvaluator3D | |
| CBuffers | |
| ►Nnavier | |
| CAccelTerm_T | Container for an acceleration term |
| ►CNavierParticles | Transient Navier-Stokes fluid-particles solver |
| ►CFluidParticleIndices | |
| CFieldIndices | |
| CTagIndices | |
| CRecirculationBC_2D | 2D recirculation boundary condition struct |
| CReflectionBC_2D | 2D wall reflection boundary condition struct |
| CNavierSolver | Transient incompressible Navier Stokes solver in a split scheme formulation |
| CPresDirichletBC_T | Container for a Dirichlet boundary condition of the pressure field |
| CVelDirichletBC_T | Container for a Dirichlet boundary condition of the velocity field |
| ►Nspde | |
| CBoundary | |
| CGFTransformer | Base class to transform a grid function |
| CLevelSetTransformer | Level Set Transformer, 1 for u(x) >= threshold, 0 otherwise |
| COffsetTransformer | Adds an constant offset to a grid function, i.e. u(x) = u(x) + offset |
| CScaleTransformer | Transforms a grid function by scaling it by a constant factor |
| CSPDESolver | |
| CUniformGRFTransformer | |
| CVisualizer | |
| ►NSubMeshUtils | |
| CUniqueIndexGenerator | Convenience object to create unique indices |
| CAB1Solver | |
| CAB2Solver | |
| CAB3Solver | |
| CAB4Solver | |
| CAB5Solver | |
| CAbstractErrorEstimator | Base class for all error estimators |
| CAbstractSparseMatrix | Abstract data type for sparse matrices |
| CAdamsBashforthSolver | |
| CAdamsMoultonSolver | |
| CAdaptivityEvaluator | |
| CADIOS2DataCollection | |
| Cadios2stream | |
| CAdvectionFlux | Advection flux |
| CAdvectionOper | |
| CAdvectorCG | |
| CAlgoimIntegrationRules | |
| CAM1Solver | |
| CAM2Solver | |
| CAM3Solver | |
| CAM4Solver | |
| CAMGFSolver | AMG with Filtering: specialization of FilteredSolver |
| CAmgXSolver | MFEM wrapper for Nvidia's multigrid library, AmgX (github.com/NVIDIA/AMGX) |
| CAnalyticAdaptTC | |
| CAnisotropicErrorEstimator | Base class for all error estimators that compute one non-negative real (double) number and an anisotropic flag for every element in the Mesh |
| CArgMaxReducer | I = argmax(a[i], a[j]) |
| CArgMaxReducer< double, I > | |
| CArgMaxReducer< float, I > | |
| CArgMinMaxReducer | |
| CArgMinMaxReducer< double, I > | |
| CArgMinMaxReducer< float, I > | |
| CArgMinReducer | I = argmin(a[i], a[j]) |
| CArgMinReducer< double, I > | |
| CArgMinReducer< float, I > | |
| CARKStepSolver | Interface to ARKode's ARKStep module – additive Runge-Kutta methods |
| CArray | |
| CArray2D | Dynamic 2D array using row-major layout |
| CArray3D | |
| CArrayHasher | Helper class for hashing std::array. Usable in place of std::hash<std::array<T,N>> |
| CArraysByName | |
| CAssignOp | |
| CAttributeSets | |
| CAutoSIMD | |
| CAutoSIMD< double, 2, 16 > | |
| CAutoSIMD< double, 4, 32 > | |
| CAutoSIMD< double, 8, 64 > | |
| CAutoSIMDTraits | |
| CAuxSpaceSmoother | |
| CAverageAccelerationSolver | The classical midpoint method |
| CBackend | MFEM backends |
| CBackwardEulerSolver | Backward Euler ODE solver. L-stable |
| CBAndReducer | &= b |
| CBaseKDTreeNodalProjection | Base class for KDTreeNodalProjection |
| CBasisType | Possible basis types. Note that not all elements can use all BasisType(s) |
| CBatchedDirectSolver | Solve block-diagonal systems using batched LU or inverses |
| CBatchedLinAlg | Class for performing batched linear algebra operations, potentially using accelerated algorithms (GPU BLAS or MAGMA). Accessed using static member functions |
| CBatchedLinAlgBase | Abstract base clase for batched linear algebra operations |
| CBatchedLOR_ADS | |
| CBatchedLOR_AMS | |
| CBatchedLOR_DG | |
| CBatchedLOR_H1 | |
| CBatchedLOR_ND | |
| CBatchedLOR_RT | |
| CBatchedLORAssembly | Efficient batched assembly of LOR discretizations on device |
| CBatchedLORKernel | Abstract base class for the batched LOR assembly kernels |
| ►CBatchInverseElementTransformation | Performs batch inverse element transforms. Currently only supports non-mixed meshes with SEGMENT, SQUARE, or CUBE geometries. Mixed element order meshes are projected onto an equivalent uniform order mesh |
| CKernels | |
| CBdrHyperbolicDirichletIntegrator | Abstract boundary hyperbolic form integrator, assembling <F̂(u⁻,u_b,x) n, [v]> term for scalar finite elements at the boundary |
| CBellSpacingFunction | Bell spacing function, which produces spacing resembling a Bell curve |
| CBiCGSTABSolver | BiCGSTAB method |
| CBiCubic2DFiniteElement | A 2D bi-cubic element on a square with uniformly spaces nodes |
| CBiCubic3DFiniteElement | Class for cubic FE on wedge |
| CBiLinear2DFiniteElement | A 2D bi-linear element on a square with nodes at the vertices of the square |
| CBiLinear3DFiniteElement | Class for linear FE on wedge |
| CBilinearForm | A "square matrix" operator for the associated FE space and BLFIntegrators The sum of all the BLFIntegrators can be used form the matrix M. This class also supports other assembly levels specified via the SetAssemblyLevel() function |
| CBilinearFormExtension | Class extending the BilinearForm class to support different AssemblyLevels |
| CBilinearFormIntegrator | Abstract base class BilinearFormIntegrator |
| CBiQuad2DFiniteElement | A 2D bi-quadratic element on a square with uniformly spaced nodes |
| CBiQuadPos2DFiniteElement | |
| CBiQuadratic3DFiniteElement | Class for quadratic FE on wedge |
| ►CBlockArray | |
| Cconst_iterator | |
| Citerator | |
| Citerator_base | |
| CBlockDiagonalPreconditioner | A class to handle Block diagonal preconditioners in a matrix-free implementation |
| CBlockFESpaceOperator | Operator for block systems arising from different arbitrarily many finite element spaces |
| CBlockILU | |
| CBlockLowerTriangularPreconditioner | A class to handle Block lower triangular preconditioners in a matrix-free implementation |
| CBlockMatrix | |
| CBlockNonlinearForm | A class representing a general block nonlinear operator defined on the Cartesian product of multiple FiniteElementSpaces |
| CBlockNonlinearFormIntegrator | |
| CBlockOperator | A class to handle Block systems in a matrix-free implementation |
| CBlockStaticCondensation | Class that performs static condensation of interior dofs for multiple FE spaces. This class is used in class DPGWeakFrom. It is suitable for systems resulting from the discretization of multiple FE spaces. It eliminates the dofs associated with the interior of the elements and returns the reduced system which contains only the interfacial dofs. The ordering of the dofs in the matrix is implied by the ordering given by the FE spaces, but there is no assumption on the ordering of the FE spaces. This class handles both serial and parallel FE spaces |
| CBlockVector | A class to handle Vectors in a block fashion |
| CBOrReducer | |= b |
| CBoundaryFlowIntegrator | |
| CBoundaryHyperbolicFlowIntegrator | Abstract boundary hyperbolic linear form integrator, assembling <ɑ/2 F(u,x) n - β |F(u,x) n|, v> terms for scalar finite elements |
| CBoundaryLFIntegrator | Class for boundary integration \( L(v) := (g, v) \) |
| CBoundaryMassIntegrator | |
| CBoundaryNormalLFIntegrator | Class for boundary integration \( L(v) = (g \cdot n, v) \) |
| CBoundaryTangentialLFIntegrator | Class for boundary integration \( L(v) = (g \cdot \tau, v) \) in 2D |
| CBurgersFlux | Burgers flux |
| CCartesianCoefficient | |
| CCartesianPML | Class for setting up a simple Cartesian PML region |
| CCartesianXCoefficient | Scalar coefficient which returns the x-component of the evaluation point |
| CCartesianYCoefficient | Scalar coefficient which returns the y-component of the evaluation point |
| CCartesianZCoefficient | Scalar coefficient which returns the z-component of the evaluation point |
| CCentralDifferenceSolver | |
| CCGSolver | Conjugate gradient method |
| CChangeOfBasis_L2 | Change of basis operator between L2 spaces |
| CChangeOfBasis_RT | |
| CCholeskyFactors | |
| CCoarseFineTransformations | Defines the coarse-fine transformations of all fine elements |
| CCoefficient | Base class Coefficients that optionally depend on space and time. These are used by the BilinearFormIntegrator, LinearFormIntegrator, and NonlinearFormIntegrator classes to represent the physical coefficients in the PDEs that are being discretized. This class can also be used in a more general way to represent functions that don't necessarily belong to a FE space, e.g., to project onto GridFunctions to use as initial conditions, exact solutions, etc. See, e.g., ex4 or ex22 for these uses |
| CCoefficientRefiner | Refinement operator to control data oscillation |
| CCoefficientVector | Class to represent a coefficient evaluated at quadrature points |
| CColumnMajorLayout2D | |
| CColumnMajorLayout3D | |
| CColumnMajorLayout4D | |
| CComplexBlockStaticCondensation | Class that performs static condensation of interior dofs for multiple FE spaces for complex systems (see BlockStaticCondensation). It's used by the class ComplexDPGWeakForm |
| CComplexCholeskyFactors | |
| CComplexDenseMatrix | Specialization of the ComplexOperator built from a pair of Dense Matrices. The purpose of this specialization is to support the inverse of a ComplexDenseMatrix and various MatMat operations See ComplexOperator documentation for more information |
| CComplexDPGWeakForm | Class representing the DPG weak formulation for complex valued systems (see the class DPGWeakForm) |
| CComplexFactors | |
| CComplexGridFunction | |
| CComplexHypreParMatrix | Specialization of the ComplexOperator built from a pair of HypreParMatrices |
| CComplexLinearForm | |
| CComplexLUFactors | |
| CComplexOperator | Mimic the action of a complex operator using two real operators |
| CComplexSparseMatrix | Specialization of the ComplexOperator built from a pair of Sparse Matrices |
| CComplexUMFPackSolver | Interface with UMFPack solver specialized for ComplexSparseMatrix This approach avoids forming a monolithic SparseMatrix which leads to increased memory and flops |
| CComponentwiseUpwindFlux | Component-wise upwinded flux |
| CConduitDataCollection | Data collection that uses the Conduit Mesh Blueprint specification |
| CConformingFaceRestriction | Operator that extracts face degrees of freedom for H1, ND, or RT FiniteElementSpaces |
| CConformingProlongationOperator | Auxiliary class used by ParFiniteElementSpace |
| CConnection | Helper struct for defining a connectivity table, see Table::MakeFromList |
| CConservativeConvectionIntegrator | \(-\alpha (u, q \cdot \nabla v)\), negative transpose of ConvectionIntegrator |
| CConst2DFECollection | Piecewise-constant discontinuous finite elements in 2D. This class is kept only for backward compatibility, consider using L2_FECollection instead |
| CConst3DFECollection | Piecewise-constant discontinuous finite elements in 3D. This class is kept only for backward compatibility, consider using L2_FECollection instead |
| CConstantCoefficient | A coefficient that is constant across space and time |
| CConstrainedInnerProduct | Inner product operator constrained to a list of indices/dofs. The method Eval() computes the inner product of two vectors only on the constrained entries specified in the constraint list |
| CConstrainedOperator | Square Operator for imposing essential boundary conditions using only the action, Mult(), of a given unconstrained Operator |
| CConstrainedSolver | An abstract class to solve the constrained system \( Ax = f \) subject to the constraint \( B x = r \) |
| ►CConvectionIntegrator | \(\alpha (Q \cdot \nabla u, v)\) |
| CKernels | |
| CConvectiveVectorConvectionNLFIntegrator | |
| CConvergenceStudy | Class to compute error and convergence rates. It supports H1, H(curl) (ND elements), H(div) (RT elements) and L2 (DG) |
| CCPardisoSolver | MKL Parallel Direct Sparse Solver for Clusters |
| CCrankNicolsonTimeBaseSolver | Crank-Nicolson time solver for the Schrodinger equation |
| CCrossCrossCoefficient | Matrix coefficient defined as -a k x k x, for a vector k and scalar a |
| CCrouzeixRaviartFECollection | Crouzeix-Raviart nonconforming elements in 2D |
| CCrouzeixRaviartFiniteElement | A 2D Crouzeix-Raviart element on triangle |
| CCrouzeixRaviartQuadFiniteElement | A 2D Crouzeix-Raviart finite element on square |
| CCubic1DFiniteElement | A 1D cubic element with uniformly spaced nodes |
| CCubic2DFiniteElement | A 2D cubic element on a triangle with uniformly spaced nodes |
| CCubic3DFiniteElement | |
| CCubicDiscont2DFECollection | Piecewise-cubic discontinuous finite elements in 2D. This class is kept only for backward compatibility, consider using L2_FECollection instead |
| CCubicFECollection | Piecewise-(bi)cubic continuous finite elements |
| ►CCurlCurlIntegrator | Integrator for \((\mathrm{curl}(u), \mathrm{curl}(v))\) for Nedelec elements |
| CKernels | |
| CCurlGridFunctionCoefficient | Vector coefficient defined as the Curl of a vector GridFunction |
| CCurlInterpolator | |
| CCut | All subclasses of Cut will implement intersection routines and quadrature point generation within the cut in the intersection of two elements. Although, this class is designed to support MortarAssembler and ParMortarAssembler, it can be used for any problem requiring to perform Petrov-Galerkin formulations on non-matching elements |
| CCutIntegrationRules | Abstract class for construction of IntegrationRules in cut elements |
| CCuWrap | |
| CCuWrap< 1 > | |
| CCuWrap< 2 > | |
| CCuWrap< 3 > | |
| CCVODESolver | Interface to the CVODE library – linear multi-step methods |
| CCVODESSolver | |
| CCylindricalAzimuthalCoefficient | |
| CCylindricalRadialCoefficient | |
| CDataCollection | |
| CDeltaCoefficient | Delta function coefficient optionally multiplied by a weight coefficient and a scaled time dependent C-function |
| CDeltaLFIntegrator | Abstract class for integrators that support delta coefficients |
| CDenseMatrix | Data type dense matrix using column-major storage |
| CDenseMatrixEigensystem | |
| CDenseMatrixGeneralizedEigensystem | |
| CDenseMatrixInverse | |
| CDenseMatrixSVD | Class for Singular Value Decomposition of a DenseMatrix |
| CDenseSymmetricMatrix | |
| CDenseTensor | Rank 3 tensor (array of matrices) |
| CDerivativeIntegrator | Class for integrating \( (Q \partial_i(u), v) \) where \(u\) and \(v\) are scalars |
| CDeterminantCoefficient | Scalar coefficient defined as the determinant of a matrix coefficient |
| CDevice | The MFEM Device class abstracts hardware devices such as GPUs, as well as programming models such as CUDA, OCCA, RAJA and OpenMP |
| CDeviceConformingProlongationOperator | Auxiliary device class used by ParFiniteElementSpace |
| CDeviceDofQuadLimits | Maximum number of 1D DOFs or quadrature points for the current runtime configuration of the Device (used in fallback kernels) |
| CDevicePair | Pair of values which can be used in device code |
| CDeviceTensor | A basic generic Tensor class, appropriate for use on the GPU |
| CDG_Interface_FECollection | |
| CDGDiffusionBR2Integrator | |
| ►CDGDiffusionIntegrator | |
| CKernels | |
| CDGDirichletLFIntegrator | |
| CDGElasticityDirichletLFIntegrator | |
| CDGElasticityIntegrator | |
| CDGHyperbolicConservationLaws | Time dependent DG operator for hyperbolic conservation laws |
| CDGIndexer | |
| CDGMassInverse | Solver for the discontinuous Galerkin mass matrix |
| ►CDGTraceIntegrator | |
| CKernels | |
| CDiffMappedGridFunctionCoefficient | Returns f(u(x)) - f(v(x)) where u, v are scalar GridFunctions and f:R → R |
| ►CDiffusionIntegrator | |
| CKernels | |
| CDiffusionSolver | Class for solving Poisson's equation: |
| CDirectSubBlockSolver | Block diagonal solver for A, each block is inverted by direct solver |
| CDiscreteAdaptTC | |
| CDiscreteInterpolator | |
| CDiscreteLinearOperator | |
| CDiscreteUpwindLOSolver | |
| CDivDivIntegrator | \((Q \nabla \cdot u, \nabla \cdot v)\) for Raviart-Thomas elements |
| CDivergenceGridFunctionCoefficient | Scalar coefficient defined as the Divergence of a vector GridFunction |
| CDivergenceInterpolator | |
| CDofToQuad | Structure representing the matrices/tensors needed to evaluate (in reference space) the values, gradients, divergences, or curls of a FiniteElement at the quadrature points of a given IntegrationRule |
| CDofTransformation | |
| CDomainLFGradIntegrator | Class for domain integrator \( L(v) := (f, \nabla v) \) |
| ►CDomainLFIntegrator | Class for domain integration \( L(v) := (f, v) \) |
| CKernels | |
| CDPGWeakForm | Class representing the DPG weak formulation. Given the variational formulation a(u,v) = b(v), (or A u = b, where <Au,v> = a(u,v)) this class forms the DPG linear system A^T G^-1 A u = A^T G^-1 b This system results from the minimum residual formulation u = argmin_w ||G^-1(b - Aw)||. Here G is a symmetric positive definite matrix resulting from the discretization of the Riesz operator on the test space. Since the test space is broken (discontinuous), G is defined and inverted element-wise and the assembly of the global system is performed in the same manner as the standard FEM method. Note that DPGWeakForm can handle multiple Finite Element spaces |
| CDSmoother | Data type for scaled Jacobi-type smoother of sparse matrix |
| ►CDSTable | |
| CRowIterator | |
| CDynamicVectorLayout | |
| CEABilinearFormExtension | Data and methods for element-assembled bilinear forms |
| CEdge | Class that implements an edge defined by a start and end point |
| CElasticityComponentIntegrator | Integrator that computes the PA action of one of the blocks in an ElasticityIntegrator, considering the elasticity operator as a dim x dim block operator |
| CElasticityDiagonalPreconditioner | ElasticityDiagonalPreconditioner acts as a matrix-free preconditioner for ElasticityOperator |
| CElasticityGradientOperator | ElasticityGradientOperator is a wrapper class to pass ElasticityOperator::AssembleGradientDiagonal and ElasticityOperator::GradientMult as a separate object through NewtonSolver |
| CElasticityIntegrator | |
| CElasticityOperator | Parallel finite element operator for linear and nonlinear elasticity |
| CElement | Abstract data type element |
| CElementDofIndexer | |
| CElementRestriction | Operator that converts FiniteElementSpace L-vectors to E-vectors |
| CElementRestrictionOperator | Abstract base class that defines an interface for element restrictions |
| CElementTransformation | |
| CEliminationCGSolver | |
| CEliminationGMRESSolver | |
| CEliminationProjection | |
| CEliminationSolver | Solve constrained system by eliminating the constraint; see ConstrainedSolver |
| CEliminator | Perform elimination of a single constraint |
| CEmbedding | Defines the position of a fine element within a coarse element |
| CErrorEstimator | Base class for all element based error estimators |
| CErrorException | Exception class thrown when MFEM encounters an error and the current ErrorAction is set to MFEM_ERROR_THROW |
| CESDIRK32Solver | |
| CESDIRK33Solver | |
| CEulerFlux | Euler flux |
| CExplicitRKSolver | |
| CExponentialMatrixCoefficient | Matrix coefficient defined as the exponential of a matrix coefficient |
| CExtrapolator | |
| CExtrudeCoefficient | Class used for extruding scalar GridFunctions |
| CFABilinearFormExtension | Data and methods for fully-assembled bilinear forms |
| CFaceElementTransformations | A specialized ElementTransformation class representing a face and its two neighboring elements |
| CFaceGeometricFactors | Structure for storing face geometric factors: coordinates, Jacobians, determinants of the Jacobians, and normal vectors |
| CFaceNeighborGeometricFactors | Class for accessing the geometric factors of face neighbor elements (i.e. across boundaries of MPI mesh partitions) |
| CFaceQuadratureInterpolator | A class that performs interpolation from a face E-vector to quadrature point values and/or derivatives (Q-vectors) on the faces |
| CFaceQuadratureSpace | Class representing the storage layout of a FaceQuadratureFunction |
| CFaceRestriction | Base class for operators that extracts Face degrees of freedom |
| CFactors | |
| CFGMRESSolver | FGMRES method |
| ►CFieldEvaluator | Complex_t - dof/qpt data type, real_t - ShapeEvaluator (FE basis) data type |
| CAction | This struct implements the input (Eval, EvalSerialized) and output (Assemble, AssembleSerialized) operations for the given Ops. Ops is "bitwise or" of constants from the enum InOutData |
| CAction< 0, dummy > | |
| CAction< 1, dummy > | |
| CAction< 2, dummy > | |
| CAction< 3, dummy > | |
| CAData | Auxiliary templated struct AData, used by the Eval() and Assemble() methods |
| CAData< 0, it_t > | |
| CAData< 1, it_t > | |
| CAData< 2, it_t > | |
| CAData< 3, it_t > | |
| CBData | This struct is similar to struct AData, adding separate static data members for the input (InData) and output (OutData) data types |
| CSpec | |
| CTElementMatrix | This struct implements element matrix computation for some combinations of input (InOps) and output (OutOps) operations |
| CTElementMatrix< 1, 1, it_t > | |
| CTElementMatrix< 2, 2, it_t > | |
| CFieldEvaluator_base | Field evaluators – values of a given global FE grid function This is roughly speaking a templated version of GridFunction |
| CFilteredSolver | Base class for solvers with filtering (subspace correction) |
| CFindPointsGSLIB | FindPointsGSLIB can robustly evaluate a GridFunction on an arbitrary collection of points. See Mittal et al., "General Field Evaluation in High-Order Meshes on GPUs". (2025). Computers & Fluids. for technical details |
| CFiniteElement | Abstract class for all finite elements |
| CFiniteElementCollection | Collection of finite elements from the same family in multiple dimensions. This class is used to match the degrees of freedom of a FiniteElementSpace between elements, and to provide the finite element restriction from an element to its boundary |
| ►CFiniteElementSpace | Class FiniteElementSpace - responsible for providing FEM view of the mesh, mainly managing the set of degrees of freedom |
| CDerefinementOperator | Derefinement operator, used by the friend class InterpolationGridTransfer |
| Ckey_hash | |
| CRefinementOperator | GridFunction interpolation operator applicable after mesh refinement |
| CFiniteElementSpaceHierarchy | |
| CFluxFunction | Abstract class for hyperbolic flux for a system of hyperbolic conservation laws |
| CFMSDataCollection | Data collection that uses FMS |
| CForwardEulerSolver | The classical forward Euler method |
| CFoxGoodwinSolver | |
| CFuentesPyramid | |
| CFunctionCoefficient | A general function coefficient |
| CFunctionSpace | Describes the function space on each element |
| CGaussBiLinear2DFiniteElement | A 2D bi-linear element on a square with nodes at the "Gaussian" points |
| CGaussBiQuad2DFiniteElement | A 2D bi-quadratic element on a square with nodes at the 9 "Gaussian" points |
| CGaussianSpacingFunction | Gaussian spacing function of the general form g(x) = a exp(-(x-m)^2 / c^2) for some scalar parameters a, m, c |
| CGaussIntegrationRule | |
| CGaussLinear2DFiniteElement | A linear element on a triangle with nodes at the 3 "Gaussian" points |
| CGaussLinearDiscont2DFECollection | Version of LinearDiscont2DFECollection with dofs in the Gaussian points |
| CGaussQuad2DFiniteElement | A quadratic element on triangle with nodes at the "Gaussian" points |
| CGaussQuadraticDiscont2DFECollection | Version of QuadraticDiscont2DFECollection with dofs in the Gaussian points |
| CGeneralAMS | Perform AMS cycle with generic Operator objects |
| CGeneralizedAlpha2Solver | |
| CGeneralizedAlphaSolver | |
| CGenericIntegrationRule | |
| CGeometricFactors | Structure for storing mesh geometric factors: coordinates, Jacobians, and determinants of the Jacobians |
| CGeometricMultigrid | Geometric multigrid associated with a hierarchy of finite element spaces |
| CGeometricSpacingFunction | Geometric spacing function |
| ►CGeometry | |
| CConstants | |
| ►CConstants< Geometry::CUBE > | |
| CVertToVert | |
| CConstants< Geometry::POINT > | |
| ►CConstants< Geometry::PRISM > | |
| CVertToVert | |
| ►CConstants< Geometry::PYRAMID > | |
| CVertToVert | |
| CConstants< Geometry::SEGMENT > | |
| ►CConstants< Geometry::SQUARE > | |
| CVertToVert | |
| ►CConstants< Geometry::TETRAHEDRON > | |
| CVertToVert | |
| ►CConstants< Geometry::TRIANGLE > | |
| CVertToVert | |
| CGeometryRefiner | |
| CGMRESSolver | GMRES method |
| CGnuTLS_global_state | |
| CGnuTLS_session_params | |
| CGnuTLS_socketbuf | |
| CGnuTLS_status | |
| CGPUBlas | Singleton class represented a cuBLAS or hipBLAS handle |
| CGPUBlasBatchedLinAlg | |
| CGradComponentCoeff | |
| CGradientGridFunctionCoefficient | Vector coefficient defined as the Gradient of a scalar GridFunction |
| CGradientIntegrator | |
| CGradientInterpolator | |
| CGridFunction | Class for grid function - Vector with associated FE space |
| CGridFunctionCoefficient | Coefficient defined by a GridFunction. This coefficient is mesh dependent |
| CGridFunctionPumi | Class for PUMI grid functions |
| CGridTransfer | Base class for transfer algorithms that construct transfer Operators between two finite element (FE) spaces |
| ►CGroupCommunicator | Communicator performing operations within groups defined by a GroupTopology with arbitrary-size data associated with each group |
| COpData | Data structure on which we define reduce operations. The data is associated with (and the operation is performed on) one group at a time |
| CGroupConvectionIntegrator | \(\alpha (Q \cdot \nabla u, v)\) using the "group" FE discretization |
| CGroupTopology | |
| CGSOPGSLIB | Class for gather-scatter (gs) operations on Vectors based on corresponding global identifiers |
| CGSSmoother | Data type for Gauss-Seidel smoother of sparse matrix |
| CH1_BergotPyramidElement | |
| CH1_FECollection | Arbitrary order H1-conforming (continuous) finite elements |
| CH1_FiniteElement | |
| CH1_FiniteElement< Geometry::CUBE, P > | |
| CH1_FiniteElement< Geometry::SEGMENT, P > | |
| CH1_FiniteElement< Geometry::SQUARE, P > | |
| CH1_FiniteElement< Geometry::TETRAHEDRON, P > | |
| CH1_FiniteElement< Geometry::TRIANGLE, P > | |
| CH1_FiniteElementSpace | |
| CH1_FuentesPyramidElement | |
| CH1_HexahedronElement | Arbitrary order H1 elements in 3D on a cube |
| CH1_QuadrilateralElement | Arbitrary order H1 elements in 2D on a square |
| CH1_SegmentElement | Arbitrary order H1 elements in 1D |
| CH1_TetrahedronElement | Arbitrary order H1 elements in 3D on a tetrahedron |
| CH1_Trace_FECollection | Arbitrary order "H^{1/2}-conforming" trace finite elements defined on the interface between mesh elements (faces,edges,vertices); these are the trace FEs of the H1-conforming FEs |
| CH1_TriangleElement | Arbitrary order H1 elements in 2D on a triangle |
| CH1_WedgeElement | Arbitrary order H1 elements in 3D on a wedge |
| CH1Pos_FECollection | Arbitrary order H1-conforming (continuous) finite elements with positive basis functions |
| CH1Pos_HexahedronElement | Arbitrary order H1 elements in 3D utilizing the Bernstein basis on a cube |
| ►CH1Pos_PyramidElement | |
| CIndex | |
| CH1Pos_QuadrilateralElement | Arbitrary order H1 elements in 2D utilizing the Bernstein basis on a square |
| CH1Pos_SegmentElement | Arbitrary order H1 elements in 1D utilizing the Bernstein basis |
| CH1Pos_TetrahedronElement | |
| CH1Pos_TriangleElement | Arbitrary order H1 elements in 2D utilizing the Bernstein basis on a triangle |
| CH1Pos_WedgeElement | Arbitrary order H1 elements in 3D utilizing the Bernstein basis on a wedge |
| CH1Ser_FECollection | |
| CH1Ser_QuadrilateralElement | Arbitrary order H1 serendipity elements in 2D on a quad |
| CHashed2 | |
| CHashed4 | |
| CHasher | Streaming implementation for murmurhash3 128 (x64). Constructs the hash in 3 stages: init, append, finalize |
| CHashFunction | Hash function for data sequences |
| ►CHashTable | |
| Cconst_iterator | |
| Citerator | |
| CHdivSaddlePointSolver | Solve the H(div) saddle-point system using MINRES with matrix-free block-diagonal preconditioning |
| CHexahedron | Data type hexahedron element |
| CHHTAlphaSolver | |
| CHiopNlpOptimizer | Adapts the HiOp functionality to the MFEM OptimizationSolver interface |
| CHiopOptimizationProblem | Internal class - adapts the OptimizationProblem class to HiOp's interface |
| CHiOpProblem | Users can inherit this class to access to HiOp-specific functionality |
| CHipWrap | |
| CHipWrap< 1 > | |
| CHipWrap< 2 > | |
| CHipWrap< 3 > | |
| CHybridization | Auxiliary class Hybridization, used to implement BilinearForm hybridization |
| CHybridizationExtension | Extension class supporting Hybridization on device (GPU) |
| CHyperbolicFormIntegrator | Abstract hyperbolic form integrator, assembling (F(u, x), ∇v) and <F̂(u⁻,u⁺,x) n, [v]> terms for scalar finite elements |
| CHyperelasticModel | Abstract class for hyperelastic models |
| CHyperelasticNLFIntegrator | |
| CHypre | A simple singleton class for hypre's global settings, that 1) calls HYPRE_Init() and sets some GPU-relevant options at construction and 2) calls HYPRE_Finalize() at destruction |
| CHypreADS | The Auxiliary-space Divergence Solver in hypre |
| CHypreAME | |
| CHypreAMS | The Auxiliary-space Maxwell Solver in hypre |
| CHypreBoomerAMG | The BoomerAMG solver in hypre |
| CHypreDiagScale | Jacobi preconditioner in hypre |
| CHypreEuclid | |
| CHypreFGMRES | Flexible GMRES solver in hypre |
| CHypreGMRES | GMRES solver in hypre |
| CHypreIdentity | The identity operator as a hypre solver |
| CHypreILU | Wrapper for Hypre's native parallel ILU preconditioner |
| CHypreLOBPCG | |
| CHypreParaSails | The ParaSails preconditioner in hypre |
| CHypreParMatrix | Wrapper for hypre's ParCSR matrix class |
| CHypreParVector | Wrapper for hypre's parallel vector class |
| CHyprePCG | PCG solver in hypre |
| CHypreSmoother | Parallel smoothers in hypre |
| CHypreSolver | Abstract class for hypre's solvers and preconditioners |
| CHypreTriSolve | |
| CIdentityInterpolator | |
| CIdentityMatrixCoefficient | Constant matrix coefficient defined as the identity of dimension d |
| CIdentityOperator | Identity Operator I: x -> x |
| Cifgzstream | |
| CIMEX_DIRK_RK3 | Third order, 3/4-stage implicit-explicit (IMEX) Runge-Kutta (RK) method |
| CIMEXExpImplEuler | Forward-backward Euler method |
| CIMEXRK2 | Second order, two-stage implicit-explicit (IMEX) Runge-Kutta (RK) method |
| CIMEXRK2_3StageExplicit | Second order, 2/3-stage implicit-explicit (IMEX) Runge-Kutta (RK) method |
| CImplicitMidpointSolver | Implicit midpoint method. A-stable, not L-stable |
| CIncompressibleBaseFlow | Class for simulating incompressible Schrodinger flow |
| CIncompressibleNeoHookeanIntegrator | |
| CInit | A class to initialize the size of a Tensor |
| CInit< Dim, Dim, T, Args... > | |
| CInnerProductCoefficient | Scalar coefficient defined as the inner product of two vector coefficients |
| CInnerProductOperator | Abstract class for defining inner products. The method Eval() must be implemented in derived classes to compute the inner product of two vectors according to a specific inner product definition |
| CIntegerSet | A set of integers |
| CIntegrationPoint | Class for integration point with weight |
| CIntegrationPointTransformation | |
| CIntegrationRule | Class for an integration rule - an Array of IntegrationPoint |
| CIntegrationRules | Container class for integration rules |
| CIntegrator | This base class implements some shared functionality between linear and nonlinear form integrators |
| CInterpConfig | |
| CInterpolationGridTransfer | Transfer data between a coarse mesh and an embedded refined mesh using interpolation |
| CInterpolationManager | This class manages the storage and computation of the interpolations from master (coarse) face to slave (fine) face |
| CInterpolatorFP | |
| ►CIntRuleCoefficient | |
| CAux | |
| CAux< false, dummy > | |
| ►CAux< true, dummy > | |
| Cresult_t | |
| CInvariantsEvaluator2D | Auxiliary class for evaluating the 2x2 matrix invariants and their first and second derivatives |
| CInvariantsEvaluator3D | Auxiliary class for evaluating the 3x3 matrix invariants and their first and second derivatives |
| CInverseElementTransformation | The inverse transformation of a given ElementTransformation |
| CInverseHarmonicModel | |
| CInverseIntegrator | Integrator that inverts the matrix assembled by another integrator |
| CInverseMatrixCoefficient | Matrix coefficient defined as the inverse of a matrix coefficient |
| CIPSolver | Class for interior-point solvers of contact-problems described by a OptContactProblem |
| Cisockstream | |
| CIsoparametricTransformation | A standard isoparametric element transformation |
| ►CIterativeSolver | Abstract base class for iterative solver |
| CPrintLevel | Settings for the output behavior of the IterativeSolver |
| CIterativeSolverController | Abstract base class for an iterative solver controller |
| CJumpScaling | |
| ►CKDTree | |
| CNodeND | Structure defining a node in the KDTree |
| CPointND | |
| CKDTreeBase | Abstract base class for KDTree. Can be used when the dimension of the space is known dynamically |
| CKDTreeNodalProjection | |
| CKellyErrorEstimator | Fast error indication strategy for smooth scalar parallel problems |
| CKernelDispatchKeyHash | Hashes variadic packs for which each type contained in the variadic pack has a specialization of std::hash available |
| CKernelDispatchTable | |
| ►CKernelDispatchTable< Kernels, Signature, internal::KernelTypeList< Params... >, internal::KernelTypeList< OptParams... > > | |
| ►CSpecialization | Register a specialized kernel for dispatch |
| COpt | |
| CKernelReporter | Singleton class to report fallback kernels |
| CKINSolver | Interface to the KINSOL library – nonlinear solver methods |
| CKLUSolver | Direct sparse solver using KLU |
| CKnotVector | A vector of knots in one dimension, with B-spline basis functions of a prescribed order |
| CL2_BergotPyramidElement | Arbitrary order L2 elements in 3D on a pyramid |
| CL2_FECollection | Arbitrary order "L2-conforming" discontinuous finite elements |
| CL2_FiniteElement | |
| CL2_FiniteElement< Geometry::CUBE, P > | |
| CL2_FiniteElement< Geometry::SEGMENT, P > | |
| CL2_FiniteElement< Geometry::SQUARE, P > | |
| CL2_FiniteElement< Geometry::TETRAHEDRON, P > | |
| CL2_FiniteElement< Geometry::TRIANGLE, P > | |
| CL2_FiniteElement_base | |
| CL2_FiniteElementSpace | |
| CL2_FuentesPyramidElement | |
| CL2_HexahedronElement | Arbitrary order L2 elements in 3D on a cube |
| CL2_QuadrilateralElement | Arbitrary order L2 elements in 2D on a square |
| CL2_SegmentElement | Arbitrary order L2 elements in 1D on a segment |
| CL2_TetrahedronElement | Arbitrary order L2 elements in 3D on a tetrahedron |
| CL2_TriangleElement | Arbitrary order L2 elements in 2D on a triangle |
| CL2_WedgeElement | Arbitrary order L2 elements in 3D on a wedge |
| CL2ElementRestriction | Operator that converts L2 FiniteElementSpace L-vectors to E-vectors |
| CL2FaceRestriction | Operator that extracts Face degrees of freedom for L2 spaces |
| CL2InterfaceFaceRestriction | Operator that extracts face degrees of freedom for L2 interface spaces |
| CL2MortarIntegrator | Integrator for scalar finite elements |
| CL2NormalDerivativeFaceRestriction | Class to compute face normal derivatives (in reference coordinate) of an L2 grid function (used internally by L2FaceRestriction) |
| CL2Pos_HexahedronElement | Arbitrary order L2 elements in 3D utilizing the Bernstein basis on a cube |
| ►CL2Pos_PyramidElement | Arbitrary order L2 elements in 3D utilizing the Bernstein basis on a pyramid |
| CIndex | |
| CL2Pos_QuadrilateralElement | Arbitrary order L2 elements in 2D utilizing the Bernstein basis on a square |
| CL2Pos_SegmentElement | Arbitrary order L2 elements in 1D utilizing the Bernstein basis on a segment |
| CL2Pos_TetrahedronElement | |
| CL2Pos_TriangleElement | Arbitrary order L2 elements in 2D utilizing the Bernstein basis on a triangle |
| CL2Pos_WedgeElement | Arbitrary order L2 elements in 3D utilizing the Bernstein basis on a wedge |
| ►CL2ProjectionGridTransfer | Transfer data in L2 and H1 finite element spaces between a coarse mesh and an embedded refined mesh using L2 projection |
| CH1SpaceLumpedMassOperator | |
| CH1SpaceMixedMassOperator | |
| CL2Projection | |
| CL2ProjectionH1Space | Class below must be public as we now have device code |
| CL2ProjectionL2Space | |
| CL2Prolongation | |
| CL2ZienkiewiczZhuEstimator | Implements the Zienkiewicz-Zhu error estimation procedure where the flux averaging is replaced by a global L2 projection (requiring a mass matrix solve) |
| CLagrange1DFiniteElement | A 1D element with uniform nodes |
| CLagrangeHexFiniteElement | Tensor products of 1D Lagrange1DFiniteElement (only degree 2 is functional) |
| CLagrangeVectorL2MortarIntegrator | Integrator for Lagrange vector finite elements. Experimental |
| CLBFGSSolver | |
| CLevelSetNormalGradCoeff | |
| CLinear1DFiniteElement | A 1D linear element with nodes on the endpoints |
| CLinear2DFiniteElement | A 2D linear element on triangle with nodes at the vertices of the triangle |
| CLinear3DFiniteElement | A 3D linear element on a tetrahedron with nodes at the vertices of the tetrahedron |
| CLinearAccelerationSolver | |
| CLinearDiscont2DFECollection | Piecewise-linear discontinuous finite elements in 2D. This class is kept only for backward compatibility, consider using L2_FECollection instead |
| CLinearDiscont3DFECollection | Piecewise-linear discontinuous finite elements in 3D. This class is kept only for backward compatibility, consider using L2_FECollection instead |
| CLinearElasticitySolver | Class for solving linear elasticity: |
| CLinearFECollection | Piecewise-(bi/tri)linear continuous finite elements |
| CLinearForm | Vector with associated FE space and LinearFormIntegrators |
| CLinearFormExtension | Class extending the LinearForm class to support assembly on devices |
| CLinearFormIntegrator | Abstract base class LinearFormIntegrator |
| CLinearNonConf3DFECollection | Piecewise-linear nonconforming finite elements in 3D |
| CLinearPyramidFiniteElement | A linear element defined on a square pyramid |
| CLinearSpacingFunction | Linear spacing function, defining the width of interval i as s + i * d |
| CLinearWedgeFiniteElement | A linear element defined on a triangular prism |
| CListOfIntegerSets | List of integer sets |
| CLocal_FECollection | Discontinuous collection defined locally by a given finite element |
| CLogarithmicSpacingFunction | Logarithmic spacing function, uniform in log base 10 by default |
| CLORBase | Abstract base class for LORDiscretization and ParLORDiscretization classes, which construct low-order refined versions of bilinear forms |
| CLORDiscretization | Create and assemble a low-order refined version of a BilinearForm |
| CLORSolver | Represents a solver of type SolverType created using the low-order refined version of the given BilinearForm or ParBilinearForm |
| CLORSolver< HypreADS > | |
| CLORSolver< HypreAMS > | |
| CLpErrorEstimator | Compares the solution to a known coefficient |
| CLSZienkiewiczZhuEstimator | Implements the Zienkiewicz-Zhu error estimation procedure [1,2] using face-based patches [3] |
| CLUFactors | |
| CLumpedIntegrator | |
| CMagma | Singleton class for interfacing with the MAGMA library |
| CMagmaBatchedLinAlg | |
| CMappedGridFunctionCoefficient | Returns f(u(x)) where u is a scalar GridFunction and f:R → R |
| ►CMassIntegrator | |
| CKernels | |
| CMaterialTopology | Virtual class to define the interface for defining the material topology |
| CMatrix | Abstract data type matrix |
| CMatrixArrayCoefficient | Matrix coefficient defined by a matrix of scalar coefficients. Coefficients that are not set will evaluate to zero in the vector. The coefficient is stored as a flat Array with indexing (i,j) -> i*width+j |
| CMatrixArrayVectorCoefficient | Matrix coefficient defined row-wise by an array of vector coefficients. Rows that are not set will evaluate to zero. The matrix coefficient is stored as an array indexing the rows of the matrix |
| CMatrixCoefficient | Base class for Matrix Coefficients that optionally depend on time and space |
| CMatrixConstantCoefficient | A matrix coefficient that is constant in space and time |
| CMatrixFreeAMS | An auxiliary Maxwell solver for a high-order curl-curl system without high-order assembly |
| CMatrixFreeAuxiliarySpace | Auxiliary space solvers for MatrixFreeAMS preconditioner |
| CMatrixFunctionCoefficient | A matrix coefficient with an optional scalar coefficient multiplier q. The matrix function can either be represented by a std function or a constant matrix provided when constructing this object. |
| CMatrixInverse | Abstract data type for matrix inverse |
| CMatrixProductCoefficient | Matrix coefficient defined as the product of two matrices |
| CMatrixRestrictedCoefficient | Derived matrix coefficient that has the value of the parent matrix coefficient where it is active and is zero otherwise |
| CMatrixSumCoefficient | Matrix coefficient defined as the linear combination of two matrices |
| CMatrixVectorProductCoefficient | Vector coefficient defined as a product of a matrix coefficient and a vector coefficient |
| CMaxReducer | = max(a,b) |
| CMaxReducer< double > | |
| CMaxReducer< float > | |
| CMemAlloc | |
| CMemAllocNode | |
| CMemory | Class used by MFEM to store pointers to host and/or device memory |
| CMemoryIJData | |
| CMemoryManager | |
| ►CMesh | Mesh data type |
| CFaceInfo | This structure stores the low level information necessary to interpret the configuration of elements on a specific face. This information can be accessed using methods like GetFaceElements(), GetFaceInfos(), FaceIsInterior(), etc |
| CFaceInformation | This structure is used as a human readable output format that deciphers the information contained in Mesh::FaceInfo when using the Mesh::GetFaceInformation() method |
| CGeometryList | List of mesh geometries stored as Array<Geometry::Type> |
| CNCFaceInfo | |
| CMeshOperator | Serves as base for mesh manipulation classes |
| CMeshOperatorSequence | |
| ►CMeshPart | Class containing a minimal description of a part (a subset of the elements) of a Mesh and its connectivity to other parts |
| CEntity | |
| CEntityHelper | |
| CMeshPartitioner | Class that allows serial meshes to be partitioned into MeshPart objects, typically one MeshPart at a time, which can then be used to write the local mesh in parallel MFEM mesh format |
| CMFBilinearFormExtension | Data and methods for matrix-free bilinear forms |
| CMFNonlinearFormExtension | Data and methods for unassembled nonlinear forms |
| CMinMaxLocScalar | Two pairs for the min/max values and their location indices |
| CMinMaxReducer | = minmax(a,b) |
| CMinMaxReducer< double > | |
| CMinMaxReducer< float > | |
| CMinReducer | = min(a,b) |
| CMinReducer< double > | |
| CMinReducer< float > | |
| CMINRESSolver | MINRES method |
| CMixedBilinearForm | |
| CMixedBilinearFormExtension | Class extending the MixedBilinearForm class to support different AssemblyLevels |
| CMixedCrossCurlCurlIntegrator | |
| CMixedCrossCurlGradIntegrator | |
| CMixedCrossCurlIntegrator | |
| CMixedCrossGradCurlIntegrator | |
| CMixedCrossGradGradIntegrator | |
| CMixedCrossGradIntegrator | |
| CMixedCrossProductIntegrator | |
| CMixedCurlCurlIntegrator | |
| CMixedCurlIntegrator | |
| CMixedDirectionalDerivativeIntegrator | |
| CMixedDivGradIntegrator | |
| CMixedDotProductIntegrator | |
| CMixedGradDivIntegrator | |
| CMixedGradGradIntegrator | |
| CMixedScalarCrossCurlIntegrator | |
| CMixedScalarCrossGradIntegrator | |
| CMixedScalarCrossProductIntegrator | |
| CMixedScalarCurlIntegrator | |
| CMixedScalarDerivativeIntegrator | |
| CMixedScalarDivergenceIntegrator | |
| CMixedScalarIntegrator | |
| CMixedScalarMassIntegrator | |
| CMixedScalarVectorIntegrator | |
| CMixedScalarWeakCrossProductIntegrator | |
| CMixedScalarWeakCurlCrossIntegrator | |
| CMixedScalarWeakCurlIntegrator | |
| CMixedScalarWeakDerivativeIntegrator | |
| CMixedScalarWeakDivergenceIntegrator | |
| CMixedScalarWeakGradientIntegrator | |
| CMixedVectorCurlIntegrator | |
| CMixedVectorDivergenceIntegrator | |
| CMixedVectorGradientIntegrator | |
| CMixedVectorIntegrator | |
| CMixedVectorMassIntegrator | |
| CMixedVectorProductIntegrator | |
| CMixedVectorWeakCurlIntegrator | |
| CMixedVectorWeakDivergenceIntegrator | |
| CMixedWeakCurlCrossIntegrator | |
| CMixedWeakDivCrossIntegrator | |
| CMixedWeakGradDotIntegrator | |
| CMMA | MMA (Method of Moving Asymptotes) solves a nonlinear optimization problem involving an objective function, inequality constraints, and variable bounds |
| CMomentFittingIntRules | Class for subdomain IntegrationRules by means of moment-fitting |
| CMortarAssembler | This class implements the serial variational transfer between finite element spaces. Variational transfer has been shown to have better approximation properties than standard interpolation. This facilities can be used for supporting applications which require the handling of non matching meshes. For instance: General multi-physics problems, fluid structure interaction, or even visualization of average quantities within subvolumes This algorithm allows to perform quadrature in the intersection of elements of two separate and unrelated meshes. It generates quadrature rules in the intersection which allows us to integrate-with to machine precision using the mfem::MortarIntegrator interface. See https://doi.org/10.1137/15M1008361 for and in-depth explanation. At this time curved elements are not supported |
| CMortarIntegrator | Interface for mortar element assembly. The MortarIntegrator interface is used for performing Petrov-Galerkin finite element assembly on intersections between elements. The quadrature rules are to be generated by a cut algorithm (e.g., mfem::Cut). The quadrature rules are defined in the respective trial and test reference frames. Trial and test spaces can be associated with different element shapes (e.g., triangles and quadrilaterals) and different polynomial orders (e.g., 1 and 4). This class is designed to work in conjunction with the MFEM/moonolith module but it can be used also for other applications |
| CMpi | A simple singleton class that calls MPI_Init() at construction and MPI_Finalize() at destruction. It also provides easy access to MPI_COMM_WORLD's rank and size |
| CMPI_Session | A simple convenience class based on the Mpi singleton class above. Preserved for backward compatibility. New code should use Mpi::Init() and other Mpi methods instead |
| CMPITypeMap | Helper struct to convert a C++ type to an MPI type |
| CMPITypeMap< bool > | |
| CMPITypeMap< char > | |
| CMPITypeMap< double > | |
| CMPITypeMap< float > | |
| CMPITypeMap< int > | |
| CMPITypeMap< long > | |
| CMPITypeMap< long long > | |
| CMPITypeMap< short > | |
| CMPITypeMap< unsigned char > | |
| CMPITypeMap< unsigned int > | |
| CMPITypeMap< unsigned long > | |
| CMPITypeMap< unsigned long long > | |
| CMPITypeMap< unsigned short > | |
| CMultigrid | Multigrid solver class |
| CMultigridBase | Abstract base class for Multigrid solvers |
| CMultReducer | *= b |
| CMUMPSSolver | MUMPS: A Parallel Sparse Direct Solver |
| CMyEnergyFunctor | |
| CMyResidualFunctor | |
| Cnamed_ifgzstream | |
| CNamedFieldsMap | Lightweight adaptor over an std::map from strings to pointer to T |
| CNativeBatchedLinAlg | |
| CNCInterpConfig | |
| CNCL2FaceRestriction | Operator that extracts face degrees of freedom for L2 nonconforming spaces |
| ►CNCMesh | A class for non-conforming AMR. The class is not used directly by the user, rather it is an extension of the Mesh class |
| CElement | |
| CFace | |
| CGeomInfo | This holds in one place the constants about the geometries we support |
| CMaster | |
| CMeshId | Identifies a vertex/edge/face in both Mesh and NCMesh |
| ►CNCList | Lists all edges/faces in the nonconforming mesh |
| CMeshIdAndType | |
| CNode | |
| CPoint | |
| CPointMatrix | The PointMatrix stores the coordinates of the slave face using the master face coordinate as reference |
| CSlave | Nonconforming edge/face within a bigger edge/face |
| CTmpVertex | |
| CTriFaceTraverseResults | |
| CNCNURBSExtension | NCNURBSExtension extends NURBSExtension to support NC-patch NURBS meshes |
| CNCSubMesh | Class representing a Nonconformal SubMesh. This is only used by SubMesh |
| CND1_3DFECollection | Lowest order Nedelec finite elements in 3D. This class is kept only for backward compatibility, consider using the new ND_FECollection instead |
| CND_DofTransformation | |
| CND_FECollection | Arbitrary order H(curl)-conforming Nedelec finite elements |
| CND_FuentesPyramidElement | |
| CND_HexahedronElement | Arbitrary order Nedelec elements in 3D on a cube |
| CND_PyramidDofTransformation | DoF transformation implementation for the Nedelec basis on pyramid elements |
| CND_QuadrilateralElement | Arbitrary order Nedelec elements in 2D on a square |
| CND_R1D_FECollection | Arbitrary order 3D H(curl)-conforming Nedelec finite elements in 1D |
| CND_R1D_PointElement | A 0D Nedelec finite element for the boundary of a 1D domain |
| CND_R1D_SegmentElement | Arbitrary order, three component, Nedelec elements in 1D on a segment |
| CND_R2D_FECollection | Arbitrary order 3D H(curl)-conforming Nedelec finite elements in 2D |
| CND_R2D_FiniteElement | |
| CND_R2D_QuadrilateralElement | Arbitrary order Nedelec 3D elements in 2D on a square |
| CND_R2D_SegmentElement | |
| CND_R2D_Trace_FECollection | Arbitrary order 3D H(curl)-trace finite elements in 2D defined on the interface between mesh elements (edges); these are the tangential trace FEs of the H(curl)-conforming FEs |
| CND_R2D_TriangleElement | Arbitrary order Nedelec 3D elements in 2D on a triangle |
| CND_SegmentElement | Arbitrary order Nedelec elements in 1D on a segment |
| CND_TetDofTransformation | DoF transformation implementation for the Nedelec basis on tetrahedra |
| CND_TetrahedronElement | Arbitrary order Nedelec elements in 3D on a tetrahedron |
| CND_Trace_FECollection | Arbitrary order H(curl)-trace finite elements defined on the interface between mesh elements (faces,edges); these are the tangential trace FEs of the H(curl)-conforming FEs |
| CND_TriangleElement | Arbitrary order Nedelec elements in 2D on a triangle |
| CND_TriDofTransformation | |
| CND_WedgeDofTransformation | DoF transformation implementation for the Nedelec basis on wedge elements |
| CND_WedgeElement | |
| CNedelec1HexFiniteElement | A 3D 1st order Nedelec element on a cube |
| CNedelec1PyrFiniteElement | A 3D 1st order Nedelec element on a pyramid |
| CNedelec1TetFiniteElement | A 3D 1st order Nedelec element on a tetrahedron |
| CNedelec1WdgFiniteElement | A 3D 1st order Nedelec element on a wedge |
| CNedelec2PyrFiniteElement | A 3D 2nd order Nedelec element on a pyramid |
| CNeoHookeanModel | |
| CNewmarkSolver | |
| CNewtonSolver | Newton's method for solving F(x)=b for a given operator F |
| CNNLSSolver | |
| CNodalFiniteElement | Class for standard nodal finite elements |
| CNodalTensorFiniteElement | |
| CNodeExtrudeCoefficient | Class used to extrude the nodes of a mesh |
| CNonconservativeDGTraceIntegrator | |
| CNonlinearForm | |
| CNonlinearFormExtension | Class extending the NonlinearForm class to support the different AssemblyLevels |
| CNonlinearFormIntegrator | This class is used to express the local action of a general nonlinear finite element operator. In addition it may provide the capability to assemble the local gradient operator and to compute the local energy |
| CNormalGradCoeff | |
| CNormalGradComponentCoeff | |
| CNormalInterpolator | |
| CNormalizedVectorCoefficient | Vector coefficient defined as a normalized vector field (returns v/|v|) |
| CNormalTraceIntegrator | |
| CNormalTraceJumpIntegrator | |
| CNoSIMDTraits | |
| CNumericalFlux | Abstract class for numerical flux for a system of hyperbolic conservation laws on a face with states, fluxes and characteristic speed |
| CNURBS1DFiniteElement | An arbitrary order 1D NURBS element on a segment |
| CNURBS2DFiniteElement | An arbitrary order 2D NURBS element on a square |
| CNURBS3DFiniteElement | An arbitrary order 3D NURBS element on a cube |
| CNURBS_HCurl2DFiniteElement | |
| CNURBS_HCurl3DFiniteElement | |
| CNURBS_HCurlFECollection | Arbitrary order H(curl) NURBS finite elements |
| CNURBS_HDiv2DFiniteElement | |
| CNURBS_HDiv3DFiniteElement | |
| CNURBS_HDivFECollection | Arbitrary order H(div) NURBS finite elements |
| CNURBSExtension | NURBSExtension generally contains multiple NURBSPatch objects spanning an entire Mesh. It also defines and manages DOFs in NURBS finite element spaces |
| CNURBSFECollection | Arbitrary order non-uniform rational B-splines (NURBS) finite elements |
| CNURBSFiniteElement | An arbitrary order and dimension NURBS element |
| CNURBSMeshRules | Class for defining different integration rules on each NURBS patch |
| CNURBSPatch | A NURBS patch can be 1D, 2D, or 3D, and is defined as a tensor product of KnotVectors |
| CNURBSPatchMap | Mapping for mesh vertices and NURBS space DOFs on a patch |
| COctetTrussTopology | |
| CODESolver | Abstract class for solving systems of ODEs: dx/dt = f(x,t) |
| CODESolverWithStates | Abstract class for an ODESolver that has state history implemented as ODEStateData |
| CODEStateData | An interface for storing state of previous timesteps |
| CODEStateDataVector | An implementation of ODEStateData that stores states in an std::vector<Vector> |
| COffsetStridedLayout1D | |
| COffsetStridedLayout2D | |
| COffsetStridedLayout3D | |
| COffsetStridedLayout4D | |
| Cofgzstream | |
| COperator | Abstract operator |
| COperatorChebyshevSmoother | Chebyshev accelerated smoothing with given vector, no matrix necessary |
| COperatorHandle | Pointer to an Operator of a specified type |
| COperatorJacobiSmoother | Jacobi smoothing for a given bilinear form (no matrix necessary) |
| COptContactProblem | Contact optimization problem with mortar and non-mortar interfaces |
| COptimizationProblem | |
| COptimizationSolver | Abstract solver for OptimizationProblems |
| COptions | Options for the Incompressible Schrödinger Flow solver |
| COptionsParser | |
| COrdering | The ordering method used when the number of unknowns per mesh node (vector dimension) is bigger than 1 |
| COrthoSolver | Solver wrapper which orthogonalizes the input and output vector |
| Cosockstream | |
| COuterProductCoefficient | Matrix coefficient defined as the outer product of two vector coefficients |
| COutStream | Simple extension of std::ostream |
| COversetFindPointsGSLIB | OversetFindPointsGSLIB enables use of findpts for arbitrary number of overlapping grids |
| CP0HexFiniteElement | A 3D constant element on a cube |
| CP0PyrFiniteElement | A 3D constant element on a pyramid |
| CP0QuadFiniteElement | A 2D constant element on a square |
| CP0SegmentFiniteElement | A 1D constant element on a segment |
| CP0TetFiniteElement | A 3D constant element on a tetrahedron |
| CP0TriangleFiniteElement | A 2D constant element on a triangle |
| CP0WdgFiniteElement | A 3D constant element on a wedge |
| CP0WedgeFiniteElement | A 0th order L2 element on a Wedge |
| CP1OnQuadFECollection | Linear (P1) finite elements on quadrilaterals |
| CP1OnQuadFiniteElement | A 2D linear element on a square with 3 nodes at the vertices of the lower left triangle |
| CP1SegmentFiniteElement | A 1D linear element with nodes at 1/3 and 2/3 (trace of RT1) |
| CP1TetNonConfFiniteElement | A 3D Crouzeix-Raviart element on the tetrahedron |
| CP2SegmentFiniteElement | A 1D quadratic element with nodes at the Gaussian points (trace of RT2) |
| CPABilinearFormExtension | Data and methods for partially-assembled bilinear forms |
| CPADiscreteLinearOperatorExtension | Partial assembly extension for DiscreteLinearOperator |
| CPair | A pair of objects |
| CPairHasher | Helper class for hashing std::pair. Usable in place of std::hash<std::pair<T,U>> |
| CPAMixedBilinearFormExtension | Data and methods for partially-assembled mixed bilinear forms |
| CPANonlinearFormExtension | Data and methods for partially-assembled nonlinear forms |
| CParAdvectorCGOper | Performs a single remap advection step in parallel |
| CParallelDirectSolver | Wrapper around parallel sparse direct solvers (MUMPS, SuperLU_DIST, STRUMPACK, CPARDISO) |
| CParaViewDataCollection | Writer for ParaView visualization (PVD and VTU format) |
| CParaViewDataCollectionBase | Abstract base class for ParaViewDataCollection and ParaViewHDFDataCollection |
| CParaViewHDFDataCollection | Writer for ParaView visualization (VTKHDF format) |
| CParBilinearForm | Class for parallel bilinear form |
| CParBlockNonlinearForm | A class representing a general parallel block nonlinear operator defined on the Cartesian product of multiple ParFiniteElementSpaces |
| CParComplexDPGWeakForm | Class representing the parallel weak formulation. (Convenient for DPG Equations) |
| CParComplexGridFunction | |
| CParComplexLinearForm | |
| CParDiscreteLinearOperator | |
| CPardisoSolver | MKL Parallel Direct Sparse Solver PARDISO |
| CParDPGWeakForm | Class representing the parallel weak formulation. (Convenient for DPG Equations) |
| CParFiniteElementSpace | Abstract parallel finite element space |
| CParFiniteElementSpaceHierarchy | |
| CParGridFunction | Class for parallel grid function |
| CParL2FaceRestriction | Operator that extracts Face degrees of freedom in parallel |
| CParLinearForm | Class for parallel linear form |
| CParLORDiscretization | Create and assemble a low-order refined version of a ParBilinearForm |
| ►CParMesh | Class for parallel meshes |
| CVert3 | |
| CVert4 | |
| CParMixedBilinearForm | Class for parallel bilinear form using different test and trial FE spaces |
| CParMortarAssembler | This class implements the parallel variational transfer between finite element spaces. Variational transfer has been shown to have better approximation properties than standard interpolation. This facilities can be used for supporting applications which require the handling of non matching meshes. For instance: General multi-physics problems, fluid structure interaction, or even visualization of average quantities within subvolumes. This particular code is also used with LLNL for large scale multilevel Monte Carlo simulations. This algorithm allows to perform quadrature in the intersection of elements of two separate, unrelated, and arbitrarily distributed meshes. It generates quadrature rules in the intersection which allows us to integrate with to machine precision using the mfem::MortarIntegrator interface. See https://doi.org/10.1137/15M1008361 for and in-depth explanation. At this time curved elements are not supported. Convex non-affine elements are partially supported, however, high order (>3) finite element discretizations or nonlinear geometric transformations might generate undesired oscillations. Discontinuous fields in general can only be mapped to order 0 destination fields. For such cases localized versions of the projection will have to be developed |
| CParNCH1FaceRestriction | Operator that extracts Face degrees of freedom for NCMesh in parallel |
| CParNCL2FaceRestriction | Operator that extracts Face degrees of freedom for NCMesh in parallel |
| ►CParNCMesh | A parallel extension of the NCMesh class |
| CElementSet | |
| CElementValueMessage | |
| CNeighborDerefinementMessage | |
| CNeighborElementRankMessage | |
| CNeighborPRefinementMessage | |
| CNeighborRefinementMessage | |
| CRebalanceDofMessage | |
| CRebalanceMessage | |
| CVarOrderElemInfo | |
| CParNCSubMesh | Class representing a Parallel Nonconformal SubMesh. This is only used by ParSubMesh |
| CParNonlinearForm | Parallel non-linear operator on the true dofs |
| CParNURBSExtension | Parallel version of NURBSExtension |
| CParPumiMesh | Class for PUMI parallel meshes |
| CParSesquilinearForm | |
| CParSubMesh | Subdomain representation of a topological parent in another ParMesh |
| CPartialSpacingFunction | Partial spacing function, defined as part of an existing spacing function |
| CParticle | Container for data associated with a single particle |
| CParticleSet | ParticleSet initializes and manages data associated with particles |
| CParticleTopology | Class that implements the particle topology |
| CParticleVector | ParticleVector carries vector data (of a given vector dimension) for an arbitrary number of particles. Data is stored contiguously in memory in an either byNODES (x0,x1,x2,...,xN,y0,y1,y2...yN,z0.....zN) or byVDIM (x0,y0,z0,...,xN,yN,zN) ordering, where N+1 is the number of particles. ParticleVector provides convenient methods for accessing and manipulating data for individual particles (e.g., GetValues) or components across all particles (e.g., GetComponents) |
| CParTransferMap | ParTransferMap represents a mapping of degrees of freedom from a source ParGridFunction to a destination ParGridFunction |
| CPenaltyConstrainedSolver | Solve constrained system with penalty method; see ConstrainedSolver |
| CPenaltyGMRESSolver | |
| CPenaltyPCGSolver | |
| CPetscBCHandler | Helper class for handling essential boundary conditions |
| CPetscBDDCSolver | |
| CPetscBDDCSolverParams | Auxiliary class for BDDC customization |
| CPetscFieldSplitSolver | |
| CPetscH2Solver | |
| CPetscLinearSolver | Abstract class for PETSc's linear solvers |
| CPetscMemory | Wrapper for syncing PETSc's vector memory |
| CPetscNonlinearSolver | Abstract class for PETSc's nonlinear solvers |
| CPetscODESolver | Abstract class for PETSc's ODE solvers |
| CPetscParMatrix | Wrapper for PETSc's matrix class |
| CPetscParVector | |
| CPetscPCGSolver | |
| CPetscPreconditioner | Abstract class for PETSc's preconditioners |
| CPetscPreconditionerFactory | |
| CPetscSolver | Abstract class for PETSc's solvers |
| CPetscSolverMonitor | Abstract class for monitoring PETSc's solvers |
| CPiecewiseSpacingFunction | Piecewise spacing function, with spacing functions defining spacing within arbitarily many fixed subintervals of the unit interval |
| CpLaplace | |
| CpLaplaceAD | |
| CpLaplaceSL | |
| CPLBound | |
| CPmlCoefficient | |
| CPmlMatrixCoefficient | |
| CPoint | Data type point element |
| CPointFiniteElement | A 0D point finite element |
| ►CPoly_1D | Class for computing 1D special polynomials and their associated basis functions |
| CBasis | Class for evaluating 1D nodal, positive (Bernstein), or integrated (Gerritsma) bases |
| CPositionVectorCoefficient | |
| CPositiveFiniteElement | Class for finite elements utilizing the always positive Bernstein basis |
| CPositiveTensorFiniteElement | |
| CPowerCoefficient | Scalar coefficient defined as a scalar raised to a power |
| CPowerMethod | PowerMethod helper class to estimate the largest eigenvalue of an operator using the iterative power method |
| CpRefinement | |
| CPRefinementTransferOperator | Matrix-free transfer operator between finite element spaces on the same mesh |
| CProductCoefficient | Scalar coefficient defined as the product of two scalar coefficients or a scalar and a scalar coefficient |
| CProductOperator | General product operator: x -> (A*B)(x) = A(B(x)) |
| CProductSolver | |
| CPumiMesh | Base class for PUMI meshes |
| CPWCoefficient | A piecewise coefficient with the pieces keyed off the element attribute numbers |
| CPWConstCoefficient | A piecewise constant coefficient with the constants keyed off the element attribute numbers |
| CPWMatrixCoefficient | A piecewise matrix-valued coefficient with the pieces keyed off the element attribute numbers |
| CPWVectorCoefficient | A piecewise vector-valued coefficient with the pieces keyed off the element attribute numbers |
| CPyramid | Data type Pyramid element |
| CQFunctionAutoDiff | |
| CQuad1DFiniteElement | A 1D quadratic finite element with uniformly spaced nodes |
| CQuad2DFiniteElement | A 2D quadratic element on triangle with nodes at the vertices and midpoints of the triangle |
| CQuadPos1DFiniteElement | A 1D quadratic positive element utilizing the 2nd order Bernstein basis |
| CQuadratic3DFiniteElement | A 3D quadratic element on a tetrahedron with uniformly spaced nodes |
| CQuadraticDiscont2DFECollection | Piecewise-quadratic discontinuous finite elements in 2D. This class is kept only for backward compatibility, consider using L2_FECollection instead |
| CQuadraticDiscont3DFECollection | Piecewise-quadratic discontinuous finite elements in 3D. This class is kept only for backward compatibility, consider using L2_FECollection instead |
| CQuadraticFECollection | Piecewise-(bi)quadratic continuous finite elements |
| CQuadraticPosDiscont2DFECollection | Version of QuadraticDiscont2DFECollection with positive basis functions |
| CQuadraticPosFECollection | Version of QuadraticFECollection with positive basis functions |
| CQuadrature1D | A class container for 1D quadrature type constants |
| CQuadratureFunction | Represents values or vectors of values at quadrature points on a mesh |
| CQuadratureFunctionCoefficient | Quadrature function coefficient which requires that the quadrature rules used for this coefficient be the same as those that live within the supplied QuadratureFunction |
| CQuadratureFunctions1D | A Class that defines 1-D numerical quadrature rules on [0,1] |
| CQuadratureInterpolator | A class that performs interpolation from an E-vector to quadrature point values and/or derivatives (Q-vectors) |
| CQuadratureLFIntegrator | |
| CQuadratureSpace | Class representing the storage layout of a QuadratureFunction |
| CQuadratureSpaceBase | Abstract base class for QuadratureSpace and FaceQuadratureSpace |
| CQuadrilateral | Data type quadrilateral element |
| CQVectorFuncAutoDiff | |
| CRajaCuWrap | |
| CRajaCuWrap< 1 > | |
| CRajaCuWrap< 2 > | |
| CRajaCuWrap< 3 > | |
| CRajaHipWrap | |
| CRajaHipWrap< 1 > | |
| CRajaHipWrap< 2 > | |
| CRajaHipWrap< 3 > | |
| CRAPOperator | The operator x -> R*A*P*x constructed through the actions of R^T, A and P |
| CRatioCoefficient | Scalar coefficient defined as the ratio of two scalars where one or both scalars are scalar coefficients |
| CRebalancer | ParMesh rebalancing operator |
| CRectangularConstrainedOperator | Rectangular Operator for imposing essential boundary conditions on the input space using only the action, Mult(), of a given unconstrained Operator |
| CRefinedBiLinear2DFiniteElement | A 2D refined bi-linear FE on a square |
| CRefinedGeometry | |
| CRefinedLinear1DFiniteElement | A 1D refined linear element |
| CRefinedLinear2DFiniteElement | A 2D refined linear element on a triangle |
| CRefinedLinear3DFiniteElement | A 2D refined linear element on a tetrahedron |
| CRefinedLinearFECollection | Finite element collection on a macro-element |
| CRefinedTriLinear3DFiniteElement | A 3D refined tri-linear element on a cube |
| CRefinement | |
| CRefTrf | |
| CResidualBCMonitor | Monitor that checks whether the residual is zero at a given set of dofs |
| CRestrictedCoefficient | Derived coefficient that takes the value of the parent coefficient for the active attributes and is zero otherwise |
| CRK2Solver | |
| CRK3SSPSolver | Third-order, strong stability preserving (SSP) Runge-Kutta method |
| CRK4Solver | The classical explicit forth-order Runge-Kutta method, RK4 |
| CRK6Solver | |
| CRK8Solver | |
| CRotTriLinearHexFiniteElement | |
| CRowNode | |
| CRT0_2DFECollection | First order Raviart-Thomas finite elements in 2D. This class is kept only for backward compatibility, consider using RT_FECollection instead |
| CRT0_3DFECollection | First order Raviart-Thomas finite elements in 3D. This class is kept only for backward compatibility, consider using RT_FECollection instead |
| CRT0HexFiniteElement | A 3D 0th order Raviert-Thomas element on a cube |
| CRT0PyrFiniteElement | A 3D 0th order Raviert-Thomas element on a pyramid |
| CRT0QuadFiniteElement | A 2D 1st order Raviart-Thomas vector element on a square |
| CRT0TetFiniteElement | A 3D 0th order Raviert-Thomas element on a tetrahedron |
| CRT0TriangleFiniteElement | A 2D 1st order Raviart-Thomas vector element on a triangle |
| CRT0WdgFiniteElement | A 3D 0th order Raviert-Thomas element on a wedge |
| CRT1_2DFECollection | Second order Raviart-Thomas finite elements in 2D. This class is kept only for backward compatibility, consider using RT_FECollection instead |
| CRT1_3DFECollection | Second order Raviart-Thomas finite elements in 3D. This class is kept only for backward compatibility, consider using RT_FECollection instead |
| CRT1HexFiniteElement | A 3D 1st order Raviert-Thomas element on a cube |
| CRT1QuadFiniteElement | A 2D 2nd order Raviart-Thomas vector element on a square |
| CRT1TriangleFiniteElement | A 2D 2nd order Raviart-Thomas vector element on a triangle |
| CRT2_2DFECollection | Third order Raviart-Thomas finite elements in 2D. This class is kept only for backward compatibility, consider using RT_FECollection instead |
| CRT2QuadFiniteElement | A 2D 3rd order Raviart-Thomas vector element on a square |
| CRT2TriangleFiniteElement | A 2D 3rd order Raviart-Thomas vector element on a triangle |
| CRT_FECollection | Arbitrary order H(div)-conforming Raviart-Thomas finite elements |
| CRT_FuentesPyramidElement | |
| CRT_HexahedronElement | Arbitrary order Raviart-Thomas elements in 3D on a cube |
| CRT_QuadrilateralElement | Arbitrary order Raviart-Thomas elements in 2D on a square |
| CRT_R1D_FECollection | Arbitrary order 3D H(div)-conforming Raviart-Thomas finite elements in 1D |
| CRT_R1D_SegmentElement | Arbitrary order, three component, Raviart-Thomas elements in 1D on a segment |
| CRT_R2D_FECollection | Arbitrary order 3D H(div)-conforming Raviart-Thomas finite elements in 2D |
| CRT_R2D_FiniteElement | |
| CRT_R2D_QuadrilateralElement | Arbitrary order Raviart-Thomas 3D elements in 2D on a square |
| CRT_R2D_SegmentElement | |
| CRT_R2D_Trace_FECollection | Arbitrary order 3D "H^{-1/2}-conforming" face finite elements defined on the interface between mesh elements (faces); these are the normal trace FEs of the H(div)-conforming FEs |
| CRT_R2D_TriangleElement | Arbitrary order Raviart-Thomas 3D elements in 2D on a triangle |
| CRT_TetrahedronElement | Arbitrary order Raviart-Thomas elements in 3D on a tetrahedron |
| CRT_Trace_FECollection | Arbitrary order "H^{-1/2}-conforming" face finite elements defined on the interface between mesh elements (faces); these are the normal trace FEs of the H(div)-conforming FEs |
| CRT_TriangleElement | Arbitrary order Raviart-Thomas elements in 2D on a triangle |
| CRT_WedgeElement | |
| CRusanovFlux | Rusanov flux, also known as local Lax-Friedrichs, F̂ n = ½(F(u⁺,x)n + F(u⁻,x)n) - ½λ(u⁺ - u⁻) where λ is the maximum characteristic speed |
| CSBM2DirichletIntegrator | |
| CSBM2DirichletLFIntegrator | |
| CSBM2NeumannIntegrator | |
| CSBM2NeumannLFIntegrator | |
| CScalarCrossProductInterpolator | |
| CScalarFiniteElement | Class for finite elements with basis functions that return scalar values |
| CScalarLayout | |
| CScalarMatrixProductCoefficient | Matrix coefficient defined as a product of a scalar coefficient and a matrix coefficient |
| CScalarOps | Auxiliary class used as the default for the second template parameter in the classes InvariantsEvaluator2D and InvariantsEvaluator3D |
| CScalarProductInterpolator | |
| CScalarVectorProductCoefficient | Vector coefficient defined as a product of scalar and vector coefficients |
| CScalarVectorProductInterpolator | |
| CScaledOperator | Scaled Operator B: x -> a A(x) |
| CSchrodingerBaseKernels | Base class for Schrodinger solver kernels |
| CSchurConstrainedHypreSolver | Basic saddle-point solver with assembled blocks (ie, the operators are assembled HypreParMatrix objects.) |
| CSchurConstrainedSolver | Solve constrained system by solving original mixed system; see ConstrainedSolver |
| CSDIRK23Solver | |
| CSDIRK33Solver | |
| CSDIRK34Solver | |
| CSecondOrderODESolver | Abstract class for solving systems of ODEs: d2x/dt2 = f(x,dx/dt,t) |
| CSecondOrderTimeDependentOperator | Base abstract class for second order time dependent operators |
| CSegment | Data type line segment element |
| CSerialAdvectorCGOper | Performs a single remap advection step in serial |
| CSesquilinearForm | |
| CShallowWaterFlux | Shallow water flux |
| CShapeEvaluator | General ShapeEvaluator for any scalar FE type (L2 or H1) |
| CShapeEvaluator_base | Shape evaluators – values of basis functions on the reference element |
| CShapeEvaluator_base< FE, IR, false, real_t > | ShapeEvaluator without tensor-product structure |
| CShapeEvaluator_base< FE, IR, true, real_t > | ShapeEvaluator with tensor-product structure in any dimension |
| CShiftedFaceMarker | |
| CShiftedFunctionCoefficient | |
| CShiftedVectorFunctionCoefficient | |
| CSIA1Solver | First Order Symplectic Integration Algorithm |
| CSIA2Solver | Second Order Symplectic Integration Algorithm |
| CSIASolver | |
| CSIAVSolver | Variable order Symplectic Integration Algorithm (orders 1-4) |
| CSidreDataCollection | Data collection with Sidre routines following the Conduit mesh blueprint specification |
| CSIMPInterpolationCoefficient | Solid isotropic material penalization (SIMP) coefficient |
| CSkewSymmetricVectorConvectionNLFIntegrator | |
| CSLBQPOptimizer | |
| CSlepcEigenSolver | |
| CSLISolver | Stationary linear iteration: x <- x + B (b - A x) |
| Csocketbuf | |
| Csocketserver | |
| Csocketstream | |
| CSolver | Base class for solvers |
| CSpacingFunction | |
| CSparseMatrix | Data type sparse matrix |
| CSparseSmoother | |
| CSphericalAzimuthalCoefficient | |
| CSphericalPolarCoefficient | |
| CSphericalRadialCoefficient | |
| CSTable | |
| CSTable3D | Symmetric 3D Table stored as an array of rows each of which has a stack of column, floor, number nodes. The number of the node is assigned by counting the nodes from zero as they are pushed into the table. Diagonals of any kind are not allowed so the row, column and floor must all be different for each node. Only one node is stored for all 6 symmetric entries that are indexable by unique triplets of row, column, and floor |
| CSTable3DNode | |
| CStack | |
| CStackPart | |
| CStatelessDofTransformation | |
| CStaticCondensation | |
| CStopWatch | Timing object |
| CStrainEnergyDensityCoefficient | Strain energy density coefficient |
| CStridedLayout1D | |
| CStridedLayout2D | |
| CStridedLayout3D | |
| CStridedLayout4D | |
| CSTRUMPACKMixedPrecisionSolver | |
| CSTRUMPACKRowLocMatrix | |
| CSTRUMPACKSolver | |
| CSTRUMPACKSolverBase | |
| CSubMesh | Subdomain representation of a topological parent in another Mesh |
| CSumCoefficient | Scalar coefficient defined as the linear combination of two scalar coefficients or a scalar and a scalar coefficient |
| CSumIntegrator | Integrator defining a sum of multiple Integrators |
| CSumOperator | General linear combination operator: x -> a A(x) + b B(x) |
| CSumReducer | += b |
| CSundials | Singleton class for SUNContext and SundialsMemHelper objects |
| CSundialsMemHelper | |
| CSundialsNVector | Vector interface for SUNDIALS N_Vectors |
| CSundialsSolver | Base class for interfacing with SUNDIALS packages |
| CSuperLURowLocMatrix | |
| CSuperLUSolver | |
| CSymmetricMatrixCoefficient | Base class for symmetric matrix coefficients that optionally depend on time and space |
| CSymmetricMatrixConstantCoefficient | A matrix coefficient that is constant in space and time |
| CSymmetricMatrixFunctionCoefficient | A matrix coefficient with an optional scalar coefficient multiplier q. The matrix function can either be represented by a std function or a constant matrix provided when constructing this object. |
| CTable | Table stores the connectivity of elements of TYPE I to elements of TYPE II. For example, it may be the element-to-face connectivity table |
| CTangentTraceIntegrator | |
| CTargetConstructor | Base class representing target-matrix construction algorithms for mesh optimization via the target-matrix optimization paradigm (TMOP) |
| CTAutoDiffDenseMatrix | Templated dense matrix data type |
| CTAutoDiffVector | Templated vector data type |
| ►CTBilinearForm | Templated bilinear form class, cf. bilinearform.?pp |
| CS_spec | Contains matrix sizes, type of kernel (ElementMatrix is templated on a kernel, e.g. ElementMatrix::Compute may be AssembleGradGrad()) |
| CT_result | |
| CTCoefficient | Templated coefficient classes, cf. coefficient.?pp |
| CTConstantCoefficient | |
| CTDiffusionKernel | Diffusion kernel |
| ►CTDiffusionKernel< 1, 1, complex_t > | Diffusion kernel in 1D |
| CCoefficientEval | |
| Cf_asm_data | Partially assembled data type for one element with the given number of quadrature points. This type is used in full element matrix assembly |
| Cp_asm_data | Partially assembled data type for one element with the given number of quadrature points. This type is used in partial assembly, and partially assembled action |
| ►CTDiffusionKernel< 2, 2, complex_t > | Diffusion kernel in 2D |
| CCoefficientEval | |
| Cf_asm_data | Partially assembled data type for one element with the given number of quadrature points. This type is used in full element matrix assembly. Stores one general (non-symmetric) 2 x 2 matrix per point |
| Cp_asm_data | Partially assembled data type for one element with the given number of quadrature points. This type is used in partial assembly, and partially assembled action. Stores one symmetric 2 x 2 matrix per point |
| ►CTDiffusionKernel< 3, 3, complex_t > | Diffusion kernel in 3D |
| CCoefficientEval | |
| Cf_asm_data | Partially assembled data type for one element with the given number of quadrature points. This type is used in full element matrix assembly. Stores one general (non-symmetric) 3 x 3 matrix per point |
| Cp_asm_data | Partially assembled data type for one element with the given number of quadrature points. This type is used in partial assembly, and partially assembled action. Stores one symmetric 3 x 3 matrix per point |
| ►CTElementTransformation | Element transformation class, templated on a mesh type and an integration rule. It is constructed from a mesh (e.g. class TMesh) and shape evaluator (e.g. class ShapeEvaluator) objects. Allows computation of physical coordinates and Jacobian matrices corresponding to the reference integration points. The desired result is specified through the template subclass Result and stored in an object of the same type |
| CGet | |
| CResult | Templated struct Result, used to specify the type result that is computed by the TElementTransformation::Eval() method and stored in this structure |
| CResult< 0, it_t > | |
| CResult< 1, it_t > | |
| CResult< 10, it_t > | |
| CResult< 2, it_t > | |
| CResult< 3, it_t > | |
| CResult< 6, it_t > | |
| CTensorBasisElement | |
| CTensorInd | A Class to compute the real index from the multi-indices of a tensor |
| CTensorInd< Dim, Dim, T, Args... > | |
| CTensorProductPRefinementTransferOperator | Matrix-free transfer operator between finite element spaces on the same mesh exploiting the tensor product structure of the finite elements |
| CTetrahedron | Data type tetrahedron element |
| CTFiniteElementSpace_simple | |
| ►CTFunctionCoefficient | Function coefficient |
| CDim | |
| CDim< 1, dummy > | |
| CDim< 2, dummy > | |
| CDim< 3, dummy > | |
| CTGridFunctionCoefficient | GridFunction coefficient class |
| CThresholdDerefiner | De-refinement operator using an error threshold |
| CThresholdRefiner | Mesh refinement operator using an error threshold |
| CTimeDependentAdjointOperator | |
| CTimeDependentOperator | Base abstract class for first order time dependent operators |
| CTIntegrationRule | |
| CTIntegrationRule< Geometry::CUBE, Order, real_t > | |
| CTIntegrationRule< Geometry::SEGMENT, Order, real_t > | |
| CTIntegrationRule< Geometry::SQUARE, Order, real_t > | |
| CTIntegrationRule< Geometry::TETRAHEDRON, 0, real_t > | |
| CTIntegrationRule< Geometry::TETRAHEDRON, 1, real_t > | |
| CTIntegrationRule< Geometry::TETRAHEDRON, 2, real_t > | |
| CTIntegrationRule< Geometry::TETRAHEDRON, 3, real_t > | |
| CTIntegrationRule< Geometry::TETRAHEDRON, 4, real_t > | |
| CTIntegrationRule< Geometry::TETRAHEDRON, 5, real_t > | |
| CTIntegrationRule< Geometry::TETRAHEDRON, 6, real_t > | |
| CTIntegrationRule< Geometry::TETRAHEDRON, 7, real_t > | |
| CTIntegrationRule< Geometry::TRIANGLE, 0, real_t > | |
| CTIntegrationRule< Geometry::TRIANGLE, 1, real_t > | |
| CTIntegrationRule< Geometry::TRIANGLE, 2, real_t > | |
| CTIntegrationRule< Geometry::TRIANGLE, 3, real_t > | |
| CTIntegrationRule< Geometry::TRIANGLE, 4, real_t > | |
| CTIntegrationRule< Geometry::TRIANGLE, 5, real_t > | |
| CTIntegrationRule< Geometry::TRIANGLE, 6, real_t > | |
| CTIntegrationRule< Geometry::TRIANGLE, 7, real_t > | |
| ►CTIntegrator | The Integrator class combines a kernel and a coefficient |
| Ckernel | |
| ►CTMassKernel | Mass kernel |
| CCoefficientEval | |
| Cf_asm_data | Partially assembled data type for one element with the given number of quadrature points. This type is used in full element matrix assembly |
| Cp_asm_data | Partially assembled data type for one element with the given number of quadrature points. This type is used in partial assembly, and partially assembled action |
| CTMatrix | |
| CTMesh | |
| CTMOP_AMetric_011 | |
| CTMOP_AMetric_014 | 2D barrier Size (V) metric (polyconvex) |
| CTMOP_AMetric_036 | 2D barrier Shape+Size+Orientation (VOS) metric (polyconvex) |
| CTMOP_AMetric_049 | |
| CTMOP_AMetric_050 | 2D barrier Skew (Q) metric |
| CTMOP_AMetric_051 | 2D barrier Size+Skew (VQ) metric |
| CTMOP_AMetric_107 | 2D barrier Shape+Orientation (OS) metric (polyconvex) |
| CTMOP_AMetric_126 | 2D barrier Shape+Size (VS) metric (polyconvex) |
| CTMOP_Combo_QualityMetric | |
| CTMOP_ExponentialLimiter | Exponential limiter function in TMOP_Integrator |
| CTMOP_Integrator | A TMOP integrator class based on any given TMOP_QualityMetric and TargetConstructor |
| CTMOP_LimiterFunction | Base class for limiting functions to be used in class TMOP_Integrator |
| CTMOP_Metric_000 | 0 metric |
| CTMOP_Metric_001 | 2D non-barrier metric without a type |
| CTMOP_Metric_002 | |
| CTMOP_Metric_004 | |
| CTMOP_Metric_007 | 2D barrier Shape+Size (VS) metric (not polyconvex) |
| CTMOP_Metric_009 | 2D barrier Shape+Size (VS) metric (not polyconvex) |
| CTMOP_Metric_014 | 2D non-barrier Shape+Size+Orientation (VOS) metric (polyconvex) |
| CTMOP_Metric_022 | 2D Shifted barrier form of shape metric (mu_2) |
| CTMOP_Metric_050 | |
| CTMOP_Metric_055 | |
| CTMOP_Metric_056 | |
| CTMOP_Metric_058 | 2D barrier shape (S) metric (not polyconvex) |
| CTMOP_Metric_066 | |
| CTMOP_Metric_077 | |
| CTMOP_Metric_080 | |
| CTMOP_Metric_085 | 2D barrier Shape+Orientation (OS) metric (polyconvex) |
| CTMOP_Metric_090 | 2D compound barrier Shape+Size (VS) metric (balanced) |
| CTMOP_Metric_094 | 2D compound barrier Shape+Size (VS) metric (balanced) |
| CTMOP_Metric_098 | 2D barrier Shape+Size+Orientation (VOS) metric (polyconvex) |
| CTMOP_Metric_211 | 2D untangling metric |
| CTMOP_Metric_252 | Shifted barrier form of metric 56 (area, ideal barrier metric), 2D |
| CTMOP_Metric_301 | 3D barrier Shape (S) metric, well-posed (polyconvex & invex) |
| CTMOP_Metric_302 | 3D barrier Shape (S) metric, well-posed (polyconvex & invex) |
| CTMOP_Metric_303 | 3D barrier Shape (S) metric, well-posed (polyconvex & invex) |
| CTMOP_Metric_304 | 3D barrier Shape (S) metric, well-posed (polyconvex & invex) |
| CTMOP_Metric_311 | 3D Size (V) untangling metric |
| CTMOP_Metric_313 | 3D Shape (S) metric, untangling version of 303 |
| CTMOP_Metric_315 | 3D Size (V) metric |
| CTMOP_Metric_316 | 3D Size (V) metric |
| CTMOP_Metric_318 | 3D Size (V) metric |
| CTMOP_Metric_321 | 3D barrier Shape+Size (VS) metric, well-posed (invex) |
| CTMOP_Metric_322 | 3D barrier Shape+Size (VS) metric, well-posed (invex) |
| CTMOP_Metric_323 | 3D barrier Shape+Size (VS) metric, well-posed (invex) |
| CTMOP_Metric_328 | 3D compound barrier Shape+Size (VS) metric (polyconvex, balanced) |
| CTMOP_Metric_332 | 3D compound barrier Shape+Size (VS) metric (polyconvex) |
| CTMOP_Metric_333 | 3D barrier Shape+Size (VS) metric, well-posed (polyconvex) |
| CTMOP_Metric_334 | 3D barrier Shape+Size (VS) metric, well-posed (polyconvex) |
| CTMOP_Metric_338 | 3D compound barrier Shape+Size (VS) metric (polyconvex, balanced) |
| CTMOP_Metric_342 | 3D barrier Shape+Size+Orientation (VOS) metric (polyconvex) |
| CTMOP_Metric_347 | 3D barrier Shape+Size (VS) metric, well-posed (polyconvex) |
| CTMOP_Metric_352 | 3D shifted barrier form of metric 316 (not typed) |
| CTMOP_Metric_360 | 3D non-barrier Shape (S) metric |
| CTMOP_Metric_aspratio2D | 2D non-barrier Aspect ratio metric |
| CTMOP_Metric_aspratio3D | 3D non-barrier Aspect ratio metric |
| CTMOP_Metric_skew2D | |
| CTMOP_Metric_skew3D | 3D non-barrier Skew metric |
| CTMOP_PA_Metric_2D | Abstract base class for the 2D metric TMOP PA kernels |
| CTMOP_PA_Metric_3D | Abstract base class for the 3D metric TMOP PA kernels |
| CTMOP_QuadraticLimiter | Default limiter function in TMOP_Integrator |
| CTMOP_QualityMetric | Abstract class for local mesh quality metrics in the target-matrix optimization paradigm (TMOP) by P. Knupp et al |
| CTMOP_WorstCaseUntangleOptimizer_Metric | |
| CTMOPComboIntegrator | |
| CTMOPDeRefinerEstimator | |
| CTMOPHRSolver | |
| CTMOPMatrixCoefficient | |
| CTMOPNewtonSolver | |
| CTMOPRefinerEstimator | |
| CTPiecewiseConstCoefficient | |
| CTProductIntegrationRule | |
| CTProductIntegrationRule_base | |
| CTProductIntegrationRule_base< 1, Q, real_t > | |
| CTProductIntegrationRule_base< 2, Q, real_t > | |
| CTProductIntegrationRule_base< 3, Q, real_t > | |
| CTProductShapeEvaluator | |
| CTProductShapeEvaluator< 1, DOF, NIP, real_t > | ShapeEvaluator with 1D tensor-product structure |
| CTProductShapeEvaluator< 2, DOF, NIP, real_t > | ShapeEvaluator with 2D tensor-product structure |
| CTProductShapeEvaluator< 3, DOF, NIP, real_t > | ShapeEvaluator with 3D tensor-product structure |
| CTraceCoefficient | Scalar coefficient defined as the trace of a matrix coefficient |
| CTraceIntegrator | |
| CTraceJumpIntegrator | |
| CTransferMap | TransferMap represents a mapping of degrees of freedom from a source GridFunction to a destination GridFunction |
| CTransferOperator | Matrix-free transfer operator between finite element spaces |
| CTransformedCoefficient | A coefficient that depends on 1 or 2 parent coefficients and a transformation rule represented by a C-function |
| CTransposeIntegrator | |
| CTransposeMatrixCoefficient | Matrix coefficient defined as the transpose of a matrix coefficient |
| CTransposeOperator | The transpose of a given operator. Switches the roles of the methods Mult() and MultTranspose() |
| CTrapezoidalRuleSolver | |
| CTriangle | Data type triangle element |
| CTriLinear3DFiniteElement | A 3D tri-linear element on a cube with nodes at the vertices of the cube |
| CTriple | A triple of objects |
| CTripleProductOperator | General triple product operator x -> A*B*C*x, with ownership of the factors |
| CTrueTransferOperator | Matrix-free transfer operator between finite element spaces working on true degrees of freedom |
| CTTensor3 | |
| CTTensor4 | |
| CTVector | |
| CUMFPackSolver | Direct sparse solver using UMFPACK |
| CUniformSpacingFunction | Uniform spacing function, dividing the unit interval into Size() equally spaced intervals (elements) |
| CVarMessage | Variable-length MPI message containing unspecific binary data |
| CVector | Vector data type |
| CVectorArrayCoefficient | Vector coefficient defined by an array of scalar coefficients. Coefficients that are not set will evaluate to zero in the vector. This object takes ownership of the array of coefficients inside it and deletes them at object destruction |
| CVectorBoundaryFluxLFIntegrator | |
| CVectorBoundaryLFIntegrator | |
| CVectorCoefficient | Base class for vector Coefficients that optionally depend on time and space |
| CVectorConstantCoefficient | Vector coefficient that is constant in space and time |
| CVectorConvectionNLFIntegrator | |
| CVectorCrossProductCoefficient | Vector coefficient defined as a cross product of two vectors |
| CVectorCrossProductInterpolator | |
| CVectorCurlCurlIntegrator | |
| CVectorDeltaCoefficient | Vector coefficient defined by a scalar DeltaCoefficient and a constant vector direction |
| CVectorDiffusionIntegrator | |
| CVectorDivergenceIntegrator | |
| CVectorDomainLFGradIntegrator | |
| CVectorDomainLFIntegrator | |
| CVectorFEBoundaryFluxIntegrator | Integrator for (Q u.n, v.n) for RT elements |
| CVectorFEBoundaryFluxLFIntegrator | |
| CVectorFEBoundaryNormalLFIntegrator | |
| CVectorFEBoundaryTangentLFIntegrator | Class for boundary integration \( L(v) = (n \times f, v) \) |
| CVectorFECurlIntegrator | |
| CVectorFEDivergenceIntegrator | |
| CVectorFEDomainLFCurlIntegrator | \( (Q, \mathrm{curl}(v))_{\Omega} \) for Nedelec Elements |
| CVectorFEDomainLFDivIntegrator | \( (Q, \mathrm{div}(v))_{\Omega} \) for RT Elements |
| CVectorFEDomainLFIntegrator | \( (f, v)_{\Omega} \) for VectorFiniteElements (Nedelec, Raviart-Thomas) |
| CVectorFEMassIntegrator | |
| CVectorFEWeakDivergenceIntegrator | |
| CVectorFiniteElement | Intermediate class for finite elements whose basis functions return vector values |
| CVectorFuncAutoDiff | |
| CVectorFunctionCoefficient | A general vector function coefficient |
| CVectorGridFunctionCoefficient | Vector coefficient defined by a vector GridFunction |
| CVectorIdentityInterpolator | Class identical to IdentityInterpolator with the exception that it requires the vector dimension (number of components) to be specified during construction |
| CVectorInnerProductInterpolator | |
| CVectorL2MortarIntegrator | Integrator for vector finite elements. Experimental |
| CVectorLayout | |
| CVectorMassIntegrator | |
| CVectorQuadratureFunctionCoefficient | Vector quadrature function coefficient which requires that the quadrature rules used for this vector coefficient be the same as those that live within the supplied QuadratureFunction |
| CVectorQuadratureLFIntegrator | |
| CVectorRestrictedCoefficient | Derived vector coefficient that has the value of the parent vector where it is active and is zero otherwise |
| CVectorRotProductCoefficient | Scalar coefficient defined as a cross product of two vectors in the xy-plane |
| CVectorScalarProductInterpolator | |
| CVectorSumCoefficient | Vector coefficient defined as the linear combination of two vectors |
| CVectorTensorFiniteElement | |
| CVertex | Data type for vertex |
| CVertexToKnotSpan | For a NURBS mesh with nonconforming patch topology, this struct provides a map from hanging vertices in the patch topology to the knotvector of a neighboring patch. This facilitates ensuring mesh conformity |
| CVisItDataCollection | Data collection with VisIt I/O routines |
| CVisItFieldInfo | Helper class for VisIt visualization data |
| CVisualizerBase | Base class for visualization |
| CVolumeForceCoefficient | Volumetric force for linear elasticity |
| CVTKGeometry | Helper class for converting between MFEM and VTK geometry types |
| ►CVTKHDF | Low-level class for writing VTKHDF data (for use in ParaView) |
| CRestart | Helper used in VTKHDF::VTKHDF for enabling/disabling restart mode |
| CWBZAlphaSolver | |
| CWedge | Data type Wedge element |
| CWeightedInnerProduct | Inner product weighted by operators, X and Y. The method Eval() computes the inner product of two vectors, x and y, weighted by the operators, X and Y, as (Y(y),X(x)) |
| CWhiteGaussianNoiseDomainLFIntegrator | |
| CZienkiewiczZhuEstimator | Implements the Zienkiewicz-Zhu error estimation procedure |
| ►Nstrict_fstream | |
| ►Ndetail | |
| Cstatic_method_holder | |
| CException | Exception class thrown by failed operations |
| Cfstream | |
| Cifstream | |
| Cofstream | |
| ►Nzstr | |
| ►Ndetail | |
| Cstrict_fstream_holder | |
| Cz_stream_wrapper | |
| CException | Exception class thrown by failed zlib operations |
| Cifstream | |
| Cistream | |
| Cistreambuf | |
| Cofstream | |
| Costream | |
| Costreambuf | |
| CCombo_Level_Set_Coefficient | Combination of level sets: +1 inside the true domain, -1 outside |
| CComplex | |
| CDist_Level_Set_Coefficient | Level set coefficient: +1 inside the true domain, -1 outside |
| CDist_Vector_Coefficient | Distance vector to the zero level-set |
| CHessianCoefficient | |
| CHRHessianCoefficient | |
| CIsoElasticyLambdaCoeff | Converts E modulus of elasticity and Poisson's ratio to Lame's lambda coefficient |
| CIsoElasticySchearCoeff | Converts E modulus of elasticity and Poisson's ratio to Shear coefficient |
| ►CIsoLinElasticSolver | Solver for linear isotropic elasticity. The solver provides options for partial assembly, dFEM based integrators, and full assembly. The preconditioners are based on block LOR approximations |
| CNqptUniformParameterSpace | |
| CLinearElasticMaterial | Linear elastic material |
| CNeoHookeanMaterial | Neo-Hookean material |
1.11.0