▶NBatchMaterialUtils | |
▶NCompileTimeDerivatives | |
▶NCompileTimeDerivativesMaterialInternal | |
▶NEigen | |
▶NGeneralFieldTransfer | |
▶NlibMesh | The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings |
▶NMemoryUtils | |
▶NMetaPhysicL | We need to instantiate the following CompareTypes to tell the compiler that ADReal is a subtype of ChainedADReal |
▶Nmoose | |
▶NMoose | MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to address this in their environment if C++17 compatibility isn't found |
▶NMooseMeshElementConversionUtils | |
▶NMooseUtils | |
▶NNestedSolveInternal | Internal use namespace that contains template helpers to map each residual type to its corresponding Jacobian type |
▶Nnlohmann | |
▶Nstd | |
▶NTIMPI | |
CAB2PredictorCorrector | A TimeStepper based on the AB2 method |
CAccumulatedValue | |
CAccumulatedValueBase | |
CAccumulateReporter | |
CAction | Base class for actions |
▶CActionFactory | Specialized factory for generic Action System objects |
CActionWarehouse | Storage for action instances |
CActivateElementsByPath | |
CActivateElementsCoupled | |
CActivateElementsUserObjectBase | |
CActuallyExplicitEuler | Implements a truly explicit (no nonlinear solve) first-order, forward Euler time integration scheme |
CAdamsPredictor | Implements an explicit Adams predictor based on two old solution vectors |
CAdaptivity | Takes care of everything related to mesh adaptivity |
CAdaptivityAction | |
CADConservativeAdvection | A conservative formulation of advection, e.g |
CADConservativeAdvectionBC | A boundary condition for when the advection term is integrated by parts |
CADCoupledTimeDerivative | This calculates the time derivative for a coupled variable |
CAddAuxKernelAction | Action to add AuxKernel nested within an AuxVariable |
CAddAuxVariableAction | Action for creating Auxiliary variables |
CAddBCAction | |
CAddBoundAction | Action to add Bounds objects within a Bounds block |
CAddBoundsVectorsAction | |
CAddConstraintAction | |
CAddControlAction | Action for creating Control objects |
CAddDamperAction | |
CAddDGKernelAction | |
CAddDiracKernelAction | |
CAddDistributionAction | This class adds a distribution object |
CAddElementalFieldAction | |
CAddExecutorAction | |
CAddExternalAuxVariableAction | Action for creating Auxiliary variables |
CAddFieldSplitAction | |
CAddFunctionAction | This class parses functions in the [Functions] block and creates them |
CAddFunctorMaterialAction | |
CAddFVBCAction | |
CAddFVICAction | |
CAddFVInitialConditionAction | |
CAddFVInterfaceKernelAction | |
CAddFVKernelAction | |
CADDGAdvection | Adds residual/Jacobian contributions for a convection term from internal faces for a discontinuous Galerkin formulation |
CADDGDiffusion | DG kernel for diffusion |
CADDGKernel | |
CAddICAction | |
CADDiffusion | |
CAddIndicatorAction | |
CAddInitialConditionAction | |
CAddInterfaceKernelAction | |
CADDirichletBC | Boundary condition of a Dirichlet type |
CADDirichletBCBase | Base class for automatic differentiation Dirichlet BCs |
CADDirichletBCBaseTempl | Base class for automatic differentiation Dirichlet BCs |
CAddKernelAction | |
CAddMarkerAction | |
CAddMaterialAction | |
CAddMeshDivisionAction | This class parses MeshDivisions in the [MeshDivisions] block and creates them |
CAddMeshGeneratorAction | |
CAddMetaDataGenerator | This mesh generator assigns external mesh metadata to the input mesh |
CAddMultiAppAction | |
CAddNodalKernelAction | |
CAddNodalNormalsAction | Action to setup computation of nodal normals |
CAddOutputAction | Action for creating output objects |
CAddPeriodicBCAction | This Action adds a periodic boundary to the problem |
CAddPositionsAction | Build Positions objects within the [Positions] input file block |
CAddPostprocessorAction | |
CAddRelationshipManager | This Action retrieves all of the Actions from the MooseAction Warehouse and triggers the addRelationshipManagers() call on each of them |
CAddReporterAction | Build Reporter objects within the [Reporters] input file block |
CAddSamplerAction | This class adds a Sampler object |
CAddScalarKernelAction | |
CAddTimesAction | Build Times objects within the [Times] input file block |
CAddTimeStepperAction | Add all timestepper(s) info from input |
CAddTransferAction | |
CAddUserObjectAction | |
CAddVariableAction | Adds nonlinear variable |
CAddVectorPostprocessorAction | |
CADFParser | |
CADFunctionDirichletBC | Boundary condition of a Dirichlet type |
CADFunctionNeumannBC | Boundary condition of a Neumann style whose value is computed by a user-defined function |
CADFunctionPenaltyDirichletBC | A different approach to applying Dirichlet BCs |
CADFunctorInterface | An interface for accessing Moose::Functors for systems that care about automatic differentiation, e.g |
CADIntegratedBCTempl | Base class for deriving any boundary condition of a integrated type |
CADInterfaceKernelTempl | ADInterfaceKernel and ADVectorInterfaceKernel is responsible for interfacing physics across subdomains |
CADKernelGradTempl | |
CADKernelScalarBase | This ADKernel adds standardized methods for assembling to a primary scalar variable associated with the primary variable of the ADKernel object |
CADKernelStabilizedTempl | |
CADKernelSUPGTempl | |
CADKernelTempl | |
CADKernelValueTempl | |
CADMatCoupledForce | Kernel representing the contribution of the PDE term $mv$, where $m$ is a material property coefficient, $v$ is a coupled scalar variable, and Jacobian derivatives are calculated using automatic differentiation |
CADMatDiffusion | Isotropic diffusion kernel that takes a diffusion coefficient of type Real |
CADMatDiffusionBase | This class template implements a diffusion kernel with a mobility that can vary spatially and can depend on variables in the simulation |
CADMaterialProperty | |
CADMatReaction | Kernel representing the contribution of the PDE term $-L*v$, where $L$ is a reaction rate coefficient material property, $v$ is a scalar variable (nonlinear or coupled auxvariable), and whose Jacobian contribution is calculated using automatic differentiation |
CADMortarConstraint | |
CADMortarScalarBase | This Constraint adds standardized methods for assembling to a primary scalar variable associated with the major variables of the Mortar Constraint object |
CADNodalBCTempl | Base class for deriving any automatic differentiation boundary condition of a integrated type |
CADNodalKernel | Base class for creating nodal kernels with AD-computed Jacobians |
CADPenaltyDirichletBC | Weakly enforce a Dirichlet BC using a penalty term |
CADPenaltyPeriodicSegmentalConstraint | This class enforces a periodic boundary condition between a microscale and macroscale field |
CADPeriodicSegmentalConstraint | This class enforces a periodic boundary condition between a microscale and macroscale field |
CADPiecewiseLinearInterpolationMaterial | This material uses a LinearInterpolation object to define the dependence of the material's value on a variable |
CADRobinBC | |
CADScalarKernel | Base class for AD scalar kernels |
CADScalarTimeDerivative | |
CADScalarTimeKernel | |
CADTimeDerivative | |
CADTimeKernelGradTempl | AD time kernels should inherit from this class when the time portion of the weak residual is multiplied by the gradient of the test function |
CADTimeKernelTempl | All AD time kernels should inherit from this class |
CADTimeKernelValueTempl | AD time kernels should inherit from this class when the time portion of the weak residual is multiplied by the test function |
CAdvancedExtruderGenerator | Extrudes a mesh to another dimension |
CAdvancedOutput | Based class for output objects |
CAdvectiveFluxAux | Auxiliary kernel responsible for computing a component of the advection flux vector |
CADVectorDiffusion | |
CADVectorFunctionDirichletBC | Boundary condition of a Dirichlet type |
CADVectorFunctionNeumannBC | Boundary condition of a Neumann style whose value is computed by a user-defined function for vector variables and whose Jacobian is computed by the automatic differentiation system |
CADVectorMatchedValueBC | Implements a simple coupled boundary condition where u=v on the boundary |
CADVectorRobinBC | |
CADVectorTimeDerivative | |
CAllLocalDofIndicesThread | Grab all the (possibly semi)local dof indices for the variables passed in, in the system passed in |
CAllNodesSendListThread | |
CAllSideSetsByNormalsGenerator | This class will add sidesets to the entire mesh based on unique normals |
CAnalyticalIndicator | |
CAnisotropicDiffusion | This kernel implements the Laplacian operator multiplied by a 2nd order tensor giving anisotropic (direction specific) diffusion: $ K u $ |
CAnnularMesh | Mesh generated from parameters |
CAnnularMeshGenerator | Generates an annular mesh given all the parameters |
CAppFactory | Generic AppFactory class for building Application objects |
CAppFactoryBuildInfo | |
CAppFactoryBuildInfoBase | Polymorphic data structure with parameter and object build access |
CArbitraryQuadrature | Implements a fake quadrature rule where you can specify the locations (in the reference domain) of the quadrature points |
CAreaPostprocessor | This postprocessor computes the area of a specified block |
CArrayBodyForce | |
CArrayConstantIC | |
CArrayCoupledTimeDerivative | This calculates the time derivative for a coupled variable |
CArrayDGDiffusion | Array version of DGDiffusion |
CArrayDGKernel | The DGKernel class is responsible for calculating the residuals for various physics on internal sides (edges/faces) |
CArrayDGLowerDKernel | The DGKernel class is responsible for calculating the residuals for various physics on internal sides (edges/faces) along with its associated lower-d elements |
CArrayDiffusion | |
CArrayDirichletBC | Boundary condition of a Dirichlet type |
CArrayFunctionIC | |
CArrayHFEMDiffusion | |
CArrayHFEMDirichletBC | |
CArrayIntegratedBC | Base class for deriving any boundary condition of a integrated type |
CArrayKernel | |
CArrayLowerDIntegratedBC | Base class for deriving any boundary condition of a integrated type |
CArrayNeumannBC | |
CArrayNodalBC | Base class for deriving any boundary condition that works at nodes on vector variables |
CArrayParsedAux | AuxKernel that evaluates a parsed function expression for each component of an array variable |
CArrayPenaltyDirichletBC | |
CArrayReaction | |
CArrayTimeDerivative | |
CArrayTimeKernel | All array time kernels should inherit from this class |
CArrayVacuumBC | |
CArrayVariableComponent | |
CArrayVarReductionAux | |
▶CAssembly | Keeps track of stuff related to assembling |
CAStableDirk4 | Fourth-order diagonally implicit Runge Kutta method (Dirk) with three stages plus an update |
CAttribBoundaries | AttribBoundaries tracks all boundary IDs associated with an object |
CAttribDisplaced | Tracks whether the object is on the displaced mesh |
CAttribExecOns | |
CAttribExecutionOrderGroup | |
CAttribInterfaces | |
CAttribMatrixTags | |
CAttribName | |
CAttribPostAux | TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies |
CAttribPreAux | TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies |
CAttribPreIC | TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies |
CAttribResidualObject | Residual objects have this attribute |
CAttribSorted | This attribute describes sorting state |
CAttribSubdomains | |
CAttribSysNum | Tracks the libmesh system number that a MooseObject is associated with |
CAttribSystem | |
CAttribTagBase | AttribTagBase tracks all (vector or matrix) tags associated with an object |
CAttribThread | |
CAttribute | Attribute is an abstract class that can be implemented in order to track custom metadata about MooseObject instances - enabling warehouse queries over the attribute |
CAttribVar | |
CAttribVectorTags | |
CAutoCheckpointAction | |
CAutomaticMortarGeneration | This class is a container/interface for the objects involved in automatic generation of mortar spaces |
CAuxiliarySystem | A system that holds auxiliary variables |
CAuxKernelTempl | Base class for creating new auxiliary kernels and auxiliary boundary conditions |
CAuxNodalScalarKernel | |
CAuxScalarKernel | Base class for making kernels that work on auxiliary scalar variables |
CAverageElementSize | This postprocessor computes an average element size (h) for the whole domain |
CAverageNodalVariableValue | |
CAverageValueConstraint | This Kernel implements part of the equation that enforces the constraint of |
CAxisymmetric2D3DSolutionFunction | Function for reading a 2D axisymmetric solution from file and mapping it to a 3D Cartesian system |
CAxisymmetricCenterlineAverageValue | This postprocessor computes a line integral of the specified variable along the centerline of an axisymmetric domain |
CBackup | Helper class to hold streams for Backup and Restore operations |
CBadActiveWalker | |
CBatchMaterial | |
CBDF2 | BDF2 time integrator |
CBicubicInterpolation | This class interpolates tabulated data with a bicubic function |
CBicubicSplineFunction | Function that uses spline interpolation |
CBicubicSplineInterpolation | This class interpolates tabulated functions with a bi-cubic spline |
CBidimensionalInterpolation | This class interpolates tabulated data with a Bidimension function (either bicubic or bilinear) |
CBilinearInterpolation | This class applies the Least Squares algorithm to a set of points to provide a smooth curve for sampling values |
CBlockDeletionGenerator | MeshGenerator for removing blocks from the mesh |
CBlockRestrictable | An interface that restricts an object to subdomains via the 'blocks' input parameter |
CBlockToMeshConverterGenerator | Creates a new mesh out of one or more subdomains/blocks from another mesh |
CBlockWeightedPartitioner | Partition a mesh by weighting blocks |
CBndElement | |
CBndNode | |
CBndNodeCompare | Helper class for sorting Boundary Nodes so that we always get the same order of application for boundary conditions |
CBodyForceTempl | This kernel implements a generic functional body force term: $ - c f $ |
CBoolFunctionControl | A basic control for changing a boolean-valued input parameter using a Function |
CBoundaryCondition | Base class for creating new types of boundary conditions |
CBoundaryDeletionGenerator | |
CBoundaryElemIntegrityCheckThread | |
CBoundaryMarker | Marks all elements near a given boundary for refinement/coarsening |
CBoundaryNodeIntegrityCheckThread | |
CBoundaryPreservedMarker | |
CBoundaryRestrictable | /class BoundaryRestrictable /brief Provides functionality for limiting the object to certain boundary ids The is class the inheriting class with methods useful for limiting an object to certain boundaries |
CBoundaryRestrictableRequired | A class for requiring an object to be boundary restricted |
CBoundingBoxIC | BoundingBoxIC allows setting the initial condition of a value inside and outside of a specified box |
CBoundingBoxNodeSetGenerator | Selects a set of nodes and assigns a nodeset name to them based on the bounding box specified |
CBoundingValueElementDamper | This class implements a damper that limits the value of a variable to be within user-specified bounds |
CBoundingValueNodalDamper | This class implements a damper that limits the value of a variable to be within user-specified bounds |
CBoundsBase | This is a base class used to set an upper and/or lower bound of a variable for the PETSc's variational inequalities solver |
CBoxMarker | |
CBreakBoundaryOnSubdomainGenerator | MeshGenerator for breaking all boundaries based on which block they are attached to |
CBreakMeshByBlockGenerator | |
CBreakMeshByBlockGeneratorBase | |
CBreakMeshByElementGenerator | |
CBuildArrayVariableAux | |
CCacheChangedListsThread | |
CCartesianGridDivision | Divides the mesh based on a Cartesian grid |
CCartesianMeshGenerator | |
CCentralDifference | Implements a truly explicit (no nonlinear solve) Central Difference time integration scheme |
CCentroidMultiApp | Automatically generates Sub-App positions from centroids of elements in the master mesh |
CChangeOverFixedPointPostprocessor | Computes the change in a post-processor value, or the magnitude of its relative change, over a time step or over the entire transient |
CChangeOverTimePostprocessor | Computes the change in a post-processor value, or the magnitude of its relative change, over a time step or over the entire transient |
CChangeOverTimestepPostprocessor | Computes the change in a post-processor value, or the magnitude of its relative change, over a time step or over the entire transient |
CCheckFVBCAction | |
CCheckIntegrityAction | |
CCheckOutputAction | Action for checking that "outputs" is properly populated for Materials |
CCheckpoint | Writes out three things: |
CCheckpointFileNames | A structure for storing the various output files associated with checkpoint output |
CCircularBoundaryCorrectionGenerator | This CircularBoundaryCorrectionGenerator object is designed to correct full or partial circular boundaries in a 2D mesh to preserve areas |
CCoarsenBlockGenerator | MeshGenerator for coarsening one or more blocks |
CCoarsenedPiecewiseLinear | Function class that reads in a list of (x,y) value pairs representing a point-wise defined function similar to PiecewiseLinear |
CCoefReactionTempl | |
CCoefTimeDerivative | Time derivative term multiplied by a coefficient |
CColumnMajorMatrixTempl | This class defines a Tensor that can change its shape |
CCombinerGenerator | Collects multiple meshes into a single (unconnected) mesh |
CComboMarker | Combines multiple marker fields |
▶CCommandLine | This class wraps provides and tracks access to command line parameters |
CCommonOutputAction | Meta-action for creating common output object parameters This action serves two purpose, first it adds common output object parameters |
CComparisonPostprocessor | Base class for comparing quantities and producing a boolean value |
CCompileParamWalker | |
CCompileTimeDerivativesMaterial | Material class to set up an expression and its derivatives built at compile time using the CompileTimeDerivatives framework |
CComposeTimeStepperAction | Add the composition time stepper as final time stepper |
CCompositeFunction | Base class for function objects |
CCompositeTensorBase | CompositeTensorBase computes a simple T type MaterialProperty \( \bar T\) that is summed up from a list of other T objects (tensors) \( T_i \) with associated weights \( w_i \) |
▶CCompositionDT | A TimeStepper that takes time steppers as inputs and computes the minimum time step size among all time steppers as output |
CComputeBoundaryInitialConditionThread | |
CComputeDiracThread | |
CComputeElemAuxBcsThread | |
CComputeElemAuxVarsThread | |
CComputeElemDampingThread | |
CComputeFDResidualFunctor | |
CComputeFullJacobianThread | |
CComputeFVFluxJacobianThread | |
CComputeFVFluxResidualThread | |
CComputeFVFluxRJThread | |
CComputeFVFluxThread | Base class for assembly-like calculations |
CComputeFVInitialConditionThread | |
CComputeIndicatorThread | |
CComputeInitialConditionThread | |
CComputeJacobianBlocksThread | Specialization for filling multiple "small" preconditioning matrices simulatenously |
CComputeJacobianForScalingThread | |
CComputeJacobianThread | |
CComputeLineSearchObjectWrapper | Wrapper of the libmesh ComputeLineSearchObject |
CComputeMarkerThread | |
CComputeMaterialsObjectThread | |
CComputeMortarFunctor | |
CComputeMortarNodalAuxBndThread | This class evaluates a single mortar nodal aux kernel |
CComputeNodalAuxBcsThread | |
CComputeNodalAuxVarsThread | |
CComputeNodalDampingThread | |
CComputeNodalKernelBCJacobiansThread | |
CComputeNodalKernelBcsThread | |
CComputeNodalKernelJacobiansThread | |
CComputeNodalKernelsThread | |
CComputeNodalUserObjectsThread | |
CComputeResidualAndJacobian | |
CComputeResidualAndJacobianThread | |
CComputeResidualFunctor | |
CComputeResidualThread | |
CComputeThreadedGeneralUserObjectsThread | Thread to compute threaded general user objects |
CComputeUserObjectsThread | Class for threaded computation of UserObjects |
CConcentricCircleMesh | Mesh generated from parameters |
CConcentricCircleMeshGenerator | Generates a mesh based on concentric circles, given all the parameters |
CConditionalEnableControl | Base class for controls that enable/disable object(s) based on some condition |
CConditionalFunctionEnableControl | Control for enabling/disabling objects when a function value is true |
CConservativeAdvection | Advection of the variable by the velocity provided by the user |
CConsole | An output object for writing to the console (screen) |
CConsoleStream | A helper class for re-directing output streams to Console output objects form MooseObjects |
CConsoleStreamInterface | An inteface for the _console for outputting to the Console object |
CConstantAux | Constant auxiliary value |
CConstantBounds | Provides constant bound of a variable for the PETSc's variational inequalities solver |
CConstantDamper | Simple constant damper |
CConstantDT | |
CConstantFunction | Class that represents constant function |
CConstantIC | ConstantIC just returns a constant value |
CConstantPointSource | TOOD |
CConstantPostprocessor | A class for storing a constant value |
CConstantRate | Represents the rate in a simple ODE of du/dt = rate |
CConstantReporter | |
CConstantScalarAux | Sets a constant value on a scalar variable |
CConstantVectorPostprocessor | |
CConstBndElement | |
CConstraint | Base class for all Constraint types |
CConstraintWarehouse | Warehouse for storing constraints |
CContainsPointAux | Computes a binary field where the field is 1 in the elements that contain the point (we say elements because the point may lie on a boundary between elements) and 0 everywhere else |
CControl | Base class for Control objects |
CControllableAlias | Allows for aliases to be defined via InputParameterWarehouse::addControllableParameterAlias |
CControllableItem | An intermediate object for building a "controllable item", where an "item" can refer to multiple input parameters with different names |
CControllableParameter | Simply a set of ControllableItem objects |
CControlOutput | Class for output information regarding Controls to the screen |
CConvectiveFluxBC | |
CCopyNodalVarsAction | |
CCopyValueAux | Copies one variable onto an auxiliary variable |
CCoupleable | Interface for objects that needs coupling capabilities |
CCoupleableMooseVariableDependencyIntermediateInterface | Intermediate base class that ties together all the interfaces for getting MooseVariableFEBases with the MooseVariableDependencyInterface |
CCoupledForceNodalKernel | Adds a force proportional to the value of the coupled variable |
CCoupledForceTempl | Implements a source term proportional to the value of a coupled variable |
CCoupledODETimeDerivative | |
CCoupledTiedValueConstraint | A CoupledTiedValueConstraint forces the value of a variable to be the same on both sides of an interface |
CCoupledTimeDerivative | This calculates the time derivative for a coupled variable |
CCoupledValueFunctionMaterialTempl | Compute a function value from coupled variables |
CCoupledVarNeumannBC | |
CCoupledVarNeumannBCTempl | Implements a Neumann BC where grad(u)=_coupled_var on the boundary |
CCoupledVarThresholdElementSubdomainModifier | |
CCouplingFunctorCheckAction | Checks whether there are any Kernels or BoundaryConditions in the warehouses and if so adds a default coupling functor to ensure correct sparsity |
CCrankNicolson | Crank-Nicolson time integrator |
CCreateAddedMeshGenerators | Action that calls MeshGeneratorSystem::createAddedMeshGenerators() |
CCreateApplicationBlockAction | Action that create Application Block |
CCreateDisplacedProblemAction | |
CCreateExecutionerAction | |
CCreateProblemAction | |
CCreateProblemDefaultAction | |
CCSV | Based class for adding basic filename support to output base class |
CCSVFileTimes | Times from a file |
CCSVReaderVectorPostprocessor | |
CCSVTimeSequenceStepper | Solves the PDEs at a sequence of time points given as a column in a text table file (such as a *.csv file) |
CCumulativeValuePostprocessor | Creates a cumulative sum of a post-processor value over a transient |
CCutMeshByPlaneGenerator | This CutMeshByPlaneGenerator object is designed to trim the input mesh by removing all the elements on one side of a given plane with special processing on the elements crossed by the cutting line to ensure a smooth cross-section |
CCyclicDependencyException | |
CCylindricalAverage | Compute a cylindrical average of a variableas a function of radius throughout the simulation domain |
CCylindricalGridDivision | Divides the mesh based on a cylindrical grid |
CDamper | Base class for deriving dampers |
CDataFileInterface | Interface for objects that need to resolve data file paths (MooseObject and Action) |
CDebugResidualAux | Auxiliary kernel for debugging convergence |
CDeclareLateReportersAction | |
CDependencyResolver | Class that represents the dependecy as a graph |
CDependencyResolverInterface | Interface for sorting dependent vectors of objects |
CDeprecatedBlockAction | Used for marking that some block are deprecated and not be used |
CDerivativeFunctionMaterialBaseTempl | Material base class to compute a function and its derivatives |
CDerivativeKernelInterface | Interface class ("Veneer") to provide generator methods for derivative material property names, and guarded getMaterialPropertyPointer calls |
CDerivativeMaterialInterface | Interface class ("Veneer") to provide generator methods for derivative material property names |
CDerivativeMaterialPropertyNameInterface | |
▶CDerivativeParsedMaterialHelperTempl | Helper class to perform the auto derivative taking |
CDerivativeParsedMaterialTempl | Class to evaluate a parsed function (for example a free energy) and automatically provide all derivatives |
CDerivativeSumMaterialTempl | |
CDGConvection | |
CDGDiffusion | DG kernel for diffusion |
CDGFunctionDiffusionDirichletBC | Implements a simple BC for DG |
CDGKernel | Responsible for calculating the residuals for various physics on internal sides (edges/faces) |
CDGKernelBase | Serves as a base class for DGKernel and ADDGKernel |
CDGLowerDKernel | The DGKernel class is responsible for calculating the residuals for various physics on internal sides (edges/faces) along with its associated lower-d elements |
CDifferencePostprocessor | Computes the difference between two postprocessors |
CDiffusion | This kernel implements the Laplacian operator: $ u $ |
CDiffusionCG | Creates all the objects needed to solve a diffusion equation with a continuous Galerkin finite element discretization |
CDiffusionFluxAux | Auxiliary kernel responsible for computing the components of the flux vector in diffusion problems |
CDiffusionFluxBC | A FluxBC which is consistent with the boundary terms arising from the Diffusion Kernel |
CDiffusionFV | Creates all the objects needed to solve a diffusion equation with a cell-centered finite volume discretization |
CDiffusionPhysicsBase | Base class to host all common parameters and attributes of Physics actions to solve the diffusion equation |
CDiracKernelBase | DiracKernelBase is the base class for all DiracKernel type classes |
CDiracKernelInfo | The DiracKernelInfo object is a place where all the Dirac points added by different DiracKernels are collected |
CDiracKernelTempl | A DiracKernel is used when you need to add contributions to the residual by means of multiplying some number by the shape functions on an element and adding the value into the residual vector at the places associated with that shape function |
CDirichletBC | Boundary condition of a Dirichlet type |
CDirichletBCBase | Base boundary condition of a Dirichlet type |
CDiscreteElementUserObject | |
CDisplacedProblem | |
CDisplacedSystem | |
CDisplayGhostingAction | Class to setup multiple AuxVariables and AuxKernels to display the ghosting when running in parallel |
CDistributedPositions | Positions created by distributing Positions objects onto one another |
CDistributedRectilinearMeshGenerator | This class works by first creating a "distributed dual graph" of the element connectivity based on a linear partition of mesh before ever building an elements |
CDistribution | All Distributions should inherit from this class |
CDistributionInterface | Interface for objects that need to use distributions |
CDivergenceAuxTempl | Computes the divergence of a vector of variables |
CDivField | Weak form contribution corresponding to k*div(u) |
▶CDM_Moose | |
CDOFMapOutput | An output object for writing the DOF map of the system in a machine parsable format |
CDomainUserObject | This user object allows related evaluations on elements, boundaries, internal sides, interfaces in one single place |
CDumpObjectsNonlinearSystem | Nonlinear system for dumping objects |
CDumpObjectsProblem | Specialization of SubProblem for dumping generated objects as input file syntax |
CDupParamWalker | |
CDynamicObjectRegistrationAction | |
CEigenArrayDirichletBC | Boundary condition of a Dirichlet type for the eigen side |
CEigenDirichletBC | Set Dirichlet boundary condition for eigenvalue problems |
▶CEigenExecutionerBase | This class provides reusable routines for eigenvalue executioners |
CEigenKernel | The behavior of this kernel is controlled by one problem-wise global parameter eigen_on_current - bool, to indicate if this kernel is operating on the current solution or old solution This kernel also obtain the postprocessor for eigenvalue by one problem-wise global parameter eigen_postprocessor - string, the name of the postprocessor to obtain the eigenvalue |
CEigenProblem | Problem for solving eigenvalue problems |
CEigenvalue | Eigenvalue executioner is used to drive the eigenvalue calculations |
CEigenvalues | |
CElemElemConstraint | |
CElementalVariableValue | |
CElementArrayL2Norm | |
CElementAverageMaterialPropertyTempl | Computes the average of a material property over a volume |
CElementAverageSecondTimeDerivative | This postprocessor computes a volume integral of the second time derivative of a given variable |
CElementAverageTimeDerivative | This postprocessor computes a volume integral of the time derivative of a given variable |
CElementAverageValue | This postprocessor computes a volume integral of the specified variable |
CElementCentroidPositions | Positions from centroids of elements in the mesh |
CElementDamper | Base class for deriving element dampers |
CElementDeletionGeneratorBase | This class deletes elements from the mesh data structure after it has been generated or read but before any FEM data structures are initialized |
CElementExtremeFunctorValueTempl | A postprocessor for collecting an extreme value for a functor with an element argument |
CElementExtremeMaterialPropertyTempl | Determines the minimum or maximum of a material property over a volume |
CElementExtremeValue | A postprocessor for collecting the elemental min or max value |
CElementGenerator | Generates individual elements given a list of nodal positions |
CElementGroupCentroidPositions | Positions from centroids of groups of elements (subdomains, extra element ids) in the mesh |
CElementH1Error | This postprocessor will print out the H^1-norm of the difference between the computed solution and the passed function, where the norm is defined as: |
CElementH1ErrorFunctionAux | A class for computing the element-wise H1 error (actually W^{1,p} error, if you set the value of p to something other than 2.0) of the difference between an exact solution (typically represented by a ParsedFunction) and the specified solution variable |
CElementH1SemiError | This postprocessor will print out the h1 seminorm between the computed solution and the passed function |
CElementHCurlError | This postprocessor will print out the H(curl)-norm of the difference between the computed solution and the passed function by summing the squares of the L2-norm and the H(curl)-seminorm of the same difference |
CElementHCurlSemiError | This postprocessor will print out the H(curl)-seminorm of the difference between the computed solution and the passed function |
CElementHDivError | This postprocessor will print out the H(div)-norm of the difference between the computed solution and the passed function by summing the squares of the L2-norm and the H(div)-seminorm of the same difference |
CElementHDivSemiError | This postprocessor will print out the H(div)-seminorm of the difference between the computed solution and the passed function |
CElementIDInterface | |
CElementIDOutputAction | |
CElementIndicator | |
CElementIntegerAux | |
CElementIntegralArrayVariablePostprocessor | This postprocessor computes a volume integral of the specified variable |
CElementIntegralFunctorPostprocessorTempl | This postprocessor computes an element integral of the specified functor |
CElementIntegralIndicator | |
CElementIntegralMaterialPropertyTempl | |
CElementIntegralPostprocessor | This postprocessor computes a volume integral of the specified variable |
CElementIntegralUserObject | This postprocessor computes a volume integral of the specified variable |
CElementIntegralVariablePostprocessor | This postprocessor computes a volume integral of the specified variable |
CElementIntegralVariableUserObject | This postprocessor computes a volume integral of the specified variable |
CElementL1Error | Computes L1 error between an elemental field variable and an analytical function |
CElementL2Difference | Computes the L2-Norm difference between two solution fields |
CElementL2Error | |
CElementL2ErrorFunctionAux | A class for computing the element-wise L^2 error (actually L^p error, if you set the value of p to something other than 2) of the difference between an exact solution (typically represented by a ParsedFunction) and the coupled solution variable |
CElementL2FunctorErrorTempl | Computes L2 error between an 'approximate' functor and an 'exact' functor |
CElementL2Norm | |
CElementLengthAux | Computes the min or max of element length |
CElementLpNormAux | Compute an elemental field variable (single value per element) equal to the Lp-norm of a coupled Variable |
CElementPairInfo | This is the ElementPairInfo class |
CElementPairLocator | This is the ElementPairLocator class |
CElementPointNeighborLayers | ElementPointNeighborLayers is used to increase the halo or stencil depth of each processor's partition |
CElementPostprocessor | |
CElementQualityAux | Calculates element quality for each element |
CElementQualityChecker | |
CElementReporter | |
CElementsAlongLine | Get all of the elements that are intersected by a line |
CElementsAlongPlane | Get all of the elements that are intersected by a plane |
CElementSideNeighborLayers | ElementSideNeighborLayers is used to increase the halo or stencil depth of each processor's partition |
CElementSidesL2Norm | This postprocessor computes the L2 norm of a variable over element sides |
CElementStatistics | |
CElementsToTetrahedronsConverter | This ElementsToTetrahedronsConverter object is designed to convert all the elements in a 3D mesh consisting of only linear elements into TET4 elements |
CElementSubdomainModifier | |
CElementUOAux | This AuxKernel retrieves values from a ElementUOProvider derived class and returns the reported spatial values |
CElementUOProvider | User object intermediate base class that declares an interface for providing generic fields by name |
CElementUserObject | |
CElementValueSampler | Samples values of elemental variable(s) |
CElementVariablePostprocessor | |
CElementVariablesDifferenceMax | Finds the largest difference between two variable fields |
CElementVariableStatistics | |
CElementVariableVectorPostprocessor | Base class VectorPostprocessors operating on elemental variables |
CElementVectorL2Error | This postprocessor will print out the L2-seminorm of the difference between the computed solution and the passed function |
CElementVectorPostprocessor | |
CElementW1pError | This postprocessor computes the Sobolev norm W^{1,p} of the difference between the computed solution and the passed in function |
CElemInfo | Class used for caching additional information for elements such as the volume and centroid |
CElemSideDouble | |
CElemSideNeighborLayersGeomTester | User object to show information about the ElemSideNeighborLayer object's "ghosting" behaviors |
CElemSideNeighborLayersTester | User object to show information about the ElemSideNeighborLayer object's "ghosting" behaviors |
CEmptyAction | Do nothing action |
CEmptyPostprocessor | |
Cenable_bitmask_operators< Interfaces > | |
Cenable_bitmask_operators< Moose::RelationshipManagerType > | |
CEqualGradientConstraint | Constrain a specified component of the gradient of a variable to be the same on both sides of an interface |
CEqualValueBoundaryConstraint | |
CEqualValueConstraint | Constrain the value of a variable to be the same on both sides of an interface |
CEqualValueEmbeddedConstraint | A EqualValueEmbeddedConstraint forces the value of a variable to be the same on overlapping portion of two blocks |
CErrorFractionMarker | |
CErrorToleranceMarker | |
CExecFlagEnum | A MultiMooseEnum object to hold "execute_on" flags |
CExecuteMeshGenerators | |
CExecuteMooseObjectWarehouse | A class for storing MooseObjects based on execution flag |
CExecutioner | Executioners are objects that do the actual work of solving your problem |
▶CExecutor | Directs the execution flow of simulations |
CExecutorInterface | Interface class for classes which interact with Postprocessors |
CExodus | Class for output data to the ExodusII format |
CExodusFileTimes | Times from one or more Exodus files |
CExodusFormatter | |
CExodusTimeSequenceStepper | Solves the PDEs at a sequence of time points given as a vector in the input file |
CExplicitEuler | Explicit Euler time integrator |
CExplicitMidpoint | The explicit midpoint time integration method |
CExplicitRK2 | Base class for three different explicit second-order Runge-Kutta time integration methods: |
CExplicitSSPRungeKutta | Explicit strong stability preserving Runge-Kutta methods |
CExplicitTimeIntegrator | Base class for explicit time integrators that are implemented without using a nonlinear solver |
CExplicitTVDRK2 | Explicit TVD (total-variation-diminishing) second-order Runge-Kutta time integration methods: |
CExternalProblem | |
CExtraElementIDAux | |
CExtraElementIntegerDivision | Divides the mesh based on the extra element IDs |
▶CExtraIDIntegralReporter | |
CExtraIDIntegralVectorPostprocessor | This ExtraIDIntegralVectorPostprocessor source code is to integrate variables based on parsed extra IDs |
CExtraNodesetGenerator | |
CExtremeValueBase | |
CFaceArgInterface | A base class interface for both producers and consumers of functor face arguments, e.g |
CFaceArgProducerInterface | An interface for producers of functor face arguments, e.g |
CFaceFaceConstraint | This is a deprecated object! Use MortarConstraint instead! |
CFaceInfo | This data structure is used to store geometric and variable related metadata about each cell face in the mesh |
CFactorizedRankTwoTensorTempl | FactorizedRankTwoTensorTempl is designed to perform the spectral decomposition of an underlying symmetric second order tensor and reuse its bases for future operations if possible |
CFactory | Generic factory class for build all sorts of objects |
CFEProblem | Specialization of SubProblem for solving nonlinear equations plus auxiliary equations |
▶CFEProblemBase | Specialization of SubProblem for solving nonlinear equations plus auxiliary equations |
CFEProblemSolve | |
CFieldSplitPreconditioner | Implements a preconditioner designed to map onto PETSc's PCFieldSplit |
CFileInputStream | Helper class that hands out input streams to a file |
CFileLineInfo | Holds file and line information |
CFileLineInfoMap | A mapping between a series of keys to a FileLineInfo |
CFileMesh | |
CFileMeshGenerator | Generates a mesh by reading it from an file |
CFileOutput | An outputter with filename support |
CFilePositions | Positions from a file |
CFileRangeBuilder | To be called in the validParams functions of classes that need to operate on ranges of files |
CFillBetweenCurvesGenerator | This FillBetweenCurvesGenerator object is designed to generate a transition layer to connect two curves |
CFillBetweenPointVectorsGenerator | This FillBetweenPointVectorsGenerator object is designed to generate a transition layer with two sides containing different node numbers |
CFillBetweenSidesetsGenerator | This FillBetweenSidesetsGenerator object is designed to generate a transition layer to connect two boundaries of two input meshes |
CFindAppWalker | |
CFindValueOnLine | Find a specific target value along a sampling line |
CFiniteDifferencePreconditioner | Finite difference preconditioner |
CFixedPointSolve | |
CFlagElementsThread | |
CFlipSidesetGenerator | MeshGenerator for flipping a sideset |
CFloatingPointExceptionGuard | Scope guard for starting and stopping Floating Point Exception Trapping |
CFluxBC | Boundary condition of a flux type \( <\vec q * \vec n, v> \) |
CForcingFunctionAux | Add a forcing function to the previous time step value of an AuxVariable |
CFormattedTable | This class is used for building, formatting, and outputting tables of numbers |
CFullSolveMultiApp | This type of MultiApp will do a full solve when it is asked to take a step |
CFuncParseEvaler | |
CFunction | Base class for function objects |
CFunctionArrayAux | |
CFunctionAux | Function auxiliary value |
CFunctionDiffusion | The Laplacian operator with a function coefficient |
CFunctionDiracSource | |
CFunctionDirichletBC | Defines a boundary condition that forces the value to be a user specified function at the boundary |
CFunctionDT | |
CFunctionElementAverage | Computes the average of a function over a volume |
CFunctionElementIntegral | Integrates a function over elements |
CFunctionElementIntegralUserObject | This user object computes a volume integral of a specified function |
CFunctionGradientNeumannBC | Boundary condition of a Neumann style whose value is computed by a user-defined function |
CFunctionIC | Defines a boundary condition that forces the value to be a user specified function at the boundary |
CFunctionInterface | Interface for objects that need to use functions |
CFunctionLayeredIntegral | This UserObject computes volume integrals of a function storing partial sums for the specified number of intervals in a direction (x,y,z) |
CFunctionMaterialBase | Material base class, central to all Materials that provide a Function as a material property value |
CFunctionMaterialPropertyDescriptor | Material properties get fully described using this structure, including their dependent variables and derivation state |
CFunctionNeumannBC | Boundary condition of a Neumann style whose value is computed by a user-defined function |
CFunctionParserBase | |
CFunctionParserUtils | |
CFunctionPenaltyDirichletBC | A different approach to applying Dirichlet BCs |
CFunctionPeriodicBoundary | Periodic boundary for calculation periodic BC on domains where the translation is given by functions |
CFunctionScalarAux | Sets a value of a scalar variable based on the function |
CFunctionScalarIC | |
CFunctionSideAverage | Computes the average of a function over a boundary |
CFunctionSideIntegral | This postprocessor computes the integral of a function over a specified boundary |
CFunctionValuePostprocessor | This postprocessor displays a single value which is supplied by a MooseFunction |
CFunctorADConverterTempl | This material converts regular functors to AD functors and AD functors to regular functors |
CFunctorAux | Evaluate a functor (functor material property, function or variable) with either a cell-center, quadrature point, or node as the functor argument |
CFunctorBinnedValuesDivision | Divides the mesh based on the binned values of a functor |
CFunctorDirichletBC | Dirichlet boundary condition with functor inputs |
CFunctorElementalGradientAuxTempl | Evaluate a functor (functor material property, function or variable) with either the cell-center or quadrature point as the functor argument |
CFunctorInterface | An interface for accessing Moose::Functors |
CFunctorMaterial | FunctorMaterials compute functor material properties |
CFunctorNeumannBC | Neumann boundary condition with functor inputs |
CFunctorPositions | Positions from groups of three functors |
CFunctorRelationshipManager | Intermediate base class for RelationshipManagers that are simply built using ghosting functors |
CFunctorSmootherTempl | This functor material smooths a functor material property |
CFunctorTimes | Times created by evaluating a functor |
CFunctorVectorElementalAuxTempl | Evaluate a functor vector (material property usually) with the element as the functor argument and save one component to an auxiliary variable |
CFVAdvection | |
CFVAnisotropicDiffusion | FVAnisotropicDiffusion implements a standard diffusion term but with a diagonal tensor diffusion coefficient (provided as a vector) |
CFVBodyForce | This kernel implements a generic functional body force term: $ - c f$ |
CFVBoundaryCondition | Base class for creating new types of boundary conditions |
CFVBoundaryIntegralValueConstraint | This boundary object implements the residuals that enforce the constraint on the boundary |
CFVBoundaryScalarLagrangeMultiplierConstraint | Base class for implementing constraints on boundaries for finite volume variables using scalar Lagrange multipliers |
CFVBoundedValueConstraint | This Kernel implements the residuals that enforce the constraint |
CFVConstantIC | FVConstantIC just returns a constant value for a finite volume variable |
CFVConstantScalarOutflowBC | Constant velocity scalar advection boundary conditions |
CFVCoupledForce | Simple class to demonstrate off diagonal Jacobian contributions |
CFVDiffusion | FVDiffusion implements a standard diffusion term: |
CFVDiffusionInterface | |
CFVDirichletBC | Base class for finite volume Dirichlet boundary conditions |
CFVDirichletBCBase | Base class for finite volume Dirichlet boundaray conditions |
CFVDivergence | FVDivergence implements a standard divergence term: |
CFVElementalKernel | FVElemental is used for calculating residual contributions from volume integral terms of a PDE where the divergence theorem is not applied (e.g |
CFVFaceResidualObject | Interface class for a finite volume residual object whose residuals are based on faces |
CFVFluxBC | Provides an interface for computing residual contributions from finite volume numerical fluxes computed on faces to neighboring elements |
CFVFluxKernel | FVFluxKernel is used for calculating residual contributions from numerical fluxes from surface integral terms in a finite volume discretization of a PDE (i.e |
CFVFunctionDirichletBC | Applies a Dirichlet boundary condition with a value prescribed by a function |
CFVFunctionIC | Defines a boundary condition that forces the value to be a user specified function at the boundary |
CFVFunctionNeumannBC | Neumann boundary (== fixed inflow) condition for finite volume scheme |
CFVFunctorDirichletBCTempl | |
CFVFunctorNeumannBC | Neumann boundary (== inflow) condition for finite volume scheme where the inflow is given as a functor |
CFVFunctorTimeKernel | |
CFVInitialConditionBase | Description |
CFVInitialConditionTempl | This is a template class that implements the workhorse compute and computeNodal methods |
CFVInitialConditionWarehouse | Warehouse for storing finite volume initial conditions |
CFVIntegralValueConstraint | This Kernel implements the residuals that enforce the constraint |
CFVInterfaceKernel | Base class for creating kernels that interface physics between subdomains |
CFVKernel | FVKernel is a base class for all finite volume method kernels |
CFVMassMatrix | Computes a 'mass matrix', which will just be a diagonal matrix for the finite volume method, meant for use in preconditioning schemes which require one |
CFVMatAdvection | |
CFVNeumannBC | Neumann boundary (== fixed inflow) condition for finite volume scheme |
CFVOneVarDiffusionInterface | |
CFVOrthogonalBoundaryDiffusion | This class computes a boundary diffusion flux by taking the difference between a provided boundary value and the boundary cell centroid value |
CFVOrthogonalDiffusion | This class computes the intercell diffusion flux by taking the difference between neighboring cell centroid values |
CFVPointValueConstraint | This Kernel implements the residuals that enforce the constraint |
CFVPostprocessorDirichletBC | |
CFVReaction | |
CFVScalarLagrangeMultiplierConstraint | Base class for implementing constraints on finite volume variable elemental values using scalar Lagrange multipliers |
CFVScalarLagrangeMultiplierInterface | |
CFVTimeKernel | |
CFVTwoVarContinuityConstraint | |
CGapValueAux | |
CGeneralDamper | Base class for deriving general dampers |
CGeneralPostprocessor | This class is here to combine the Postprocessor interface and the base class Postprocessor object along with adding MooseObject to the inheritance tree |
CGeneralRegistry | |
CGeneralReporter | Reporter object that has a single execution of the "execute" method for for each execute flag |
CGeneralUserObject | |
CGeneralVectorPostprocessor | This class is here to combine the VectorPostprocessor interface and the base class VectorPostprocessor object along with adding MooseObject to the inheritance tree |
CGeneratedMesh | Mesh generated from parameters |
CGeneratedMeshGenerator | Generates a line, square, or cube mesh with uniformly spaced or biased elements |
CGenericConstant2DArray | |
CGenericConstantArray | |
CGenericConstantMaterialTempl | This material automatically declares as material properties whatever is passed to it through the parameters 'prop_names' and uses the values from 'prop_values' as the values for those properties |
CGenericConstantRankTwoTensorTempl | Declares a constant material property of type RankTwoTensor |
CGenericConstantVectorMaterialTempl | |
CGenericFunctionMaterialTempl | This material automatically declares as material properties whatever is passed to it through the parameters 'prop_names' and uses the Functions from 'prop_values' as the values for those properties |
CGenericFunctionRankTwoTensorTempl | Declares a function material property of type RankTwoTensor |
CGenericFunctionVectorMaterialTempl | This material automatically declares as material properties whatever is passed to it through the parameters 'prop_names' and uses the Functions from 'prop_values' as the values for those properties |
CGenericFunctorGradientMaterialTempl | This material automatically declares as functor material properties whatever is passed to it through the parameters 'prop_names' and uses the gradients of the functors from 'prop_values' as the values for those properties |
CGenericFunctorMaterialTempl | This material automatically declares as functor material properties whatever is passed to it through the parameters 'prop_names' and uses the functors from 'prop_values' as the values for those properties |
CGenericIntegratedBC | |
CGenericIntegratedBC< true > | |
CGenericInterfaceKernelTempl | |
CGenericInterfaceKernelTempl< T, true > | |
CGenericKernel | |
CGenericKernel< true > | |
CGenericKernelScalar | |
CGenericKernelScalar< true > | |
CGenericMaterialPropertyStruct | |
CGenericMaterialPropertyStruct< T, true > | |
CGenericNodalBC | |
CGenericNodalBC< true > | |
CGenericOptionalMaterialProperty | Wrapper around a material property pointer |
CGenericOptionalMaterialPropertyBase | Base class to facilitate storage using unique pointers |
CGenericSymFunctionTempl | |
CGenericSymFunctionTempl< true > | |
CGenericVectorFunctorMaterialTempl | This material automatically declares as functor material properties whatever is passed to it through the parameters 'prop_names' and uses the Functors from 'prop_values' as the values for the components of those vector properties |
CGeometricSearchData | |
CGeometricSearchInterface | |
CGeometryBase | Base class for userobjects that snap nodes to a defined geometry when adaptivity happens |
CGeometrySphere | Snaps the selected nodes to the surface of a sphere (or circular disk in 2D) |
CGhostEverything | |
CGhostHigherDLowerDPointNeighbors | |
CGhostingAux | |
CGhostingUserObject | This object loops over all of the underlying ghosting functors added by libMesh or MOOSE through RelationshipManagers to display the effective ghosting for a particular simulation |
CGhostLowerDElems | |
CGlobalParamsAction | |
CGMVOutput | Class for output data to the GMVOutputII format |
CGnuplot | Based class for adding basic filename support to output base class |
CGradField | Weak form contribution corresponding to -k*grad(p) |
CGradientJumpIndicator | |
CGreaterThanLessThanPostprocessor | |
CGriddedData | Container for holding a function defined on a grid of arbitrary dimension |
CGridPartitioner | Partitions a mesh using a regular grid |
CHardwareIDAux | "Paints" the ID of of the physical "node" in the cluster the element is located on |
CHashMap | HashMap is an abstraction for dictionary data type, we make it thread-safe by locking inserts |
CHeun | Heun's (aka improved Euler) time integration method |
CHFEMDiffusion | |
CHFEMDirichletBC | |
CHFEMTestJump | Computes an L2 product (lambda, [u*])_Gamma, where Gamma is the set of internal sides, lambda is a variable (generally a SIDE_DISCONTINUOUS FEType like SIDE_HIERARCIC) which is uniquely defined on those sides (although not necessarily their boundaries), and [u*] is the jump across a side of a test function u* corresponding to variation in a DISCONTINUOUS variable u (e.g |
CHFEMTrialJump | Computes an L2 product (lambda*, [u])_Gamma, where Gamma is the set of internal sides, lambda* is a test function corresponding to variation in a variable lambda (in typical use cases, a SIDE_DISCONTINUOUS FEType like SIDE_HIERARCIC) which is uniquely defined on those sides (although not necessarily their boundaries), and [u] is the jump across a side of a DISCONTINUOUS variable u (e.g |
CHierarchicalGridPartitioner | Partitions a mesh into sub-partitions for each computational node then into partitions within that node |
▶CHistogramVectorPostprocessor | Computes a histogram for each column in a given VectorPostprocessor |
CImageFunction | A function for extracting data from an image or stack of images |
CImageMesh | A 2D GeneratedMesh where xmin, xmax, etc |
CImageMeshGenerator | A 2D GeneratedMesh where xmin, xmax, etc |
CImageSampler | A helper class for reading and sampling images using VTK |
CImageSubdomainGenerator | MeshGenerator for defining a subdomain based on image data |
CImplicitEuler | Implicit Euler's method |
CImplicitMidpoint | Second-order Runge-Kutta (implicit midpoint) time integration |
CIndexableProperty | IndexableProperty is a helper (proxy) object to obtain a scalar component from a material property |
CIndicator | |
CIndicatorMarker | |
CInitialConditionBase | InitialConditionBase serves as the abstract base class for InitialConditions and VectorInitialConditions |
CInitialConditionTempl | This is a template class that implements the workhorse compute and computeNodal methods |
CInitialConditionWarehouse | Warehouse for storing initial conditions |
CInitProblemAction | |
CInputFileFormatter | This class produces produces a dump of the InputParameters that appears like the normal input file syntax |
▶CInputParameters | The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system |
CInputParameterWarehouse | Storage container for all InputParamter objects |
CInputPositions | Simple positions from an input parameter |
CInputStream | Helper class that hands out input streams to an underlying, managed stream of arbitrary type |
CInputTimes | Simple times from an input parameter |
CIntegralPreservingFunctionIC | Initial conditions specifying an initial condition as a general function while preserving a total integral magnitude |
CIntegratedBC | Base class for deriving any boundary condition of a integrated type |
CIntegratedBCBase | Base class for deriving any boundary condition of a integrated type |
CInterfaceAverageVariableValuePostprocessor | This postprocessor computes a spatial average value of the specified variable value on the interface |
CInterfaceDiffusion | DG kernel for interfacing diffusion between two variables on adjacent blocks |
CInterfaceDiffusiveFluxAverageTempl | |
CInterfaceDiffusiveFluxIntegralTempl | This postprocessor computes an integral of the diffusive flux over an interface |
CInterfaceIntegralPostprocessor | This postprocessor add generel capabilities to the InterfacePostprocessor to compute an integral over an interface |
CInterfaceIntegralVariableValuePostprocessor | This postprocessor computes a weighted (by area) integral of the specified variable |
CInterfaceKernelBase | InterfaceKernelBase is the base class for all InterfaceKernel type classes |
CInterfaceKernelTempl | InterfaceKernel and VectorInterfaceKernel is responsible for interfacing physics across subdomains |
CInterfaceMaterial | Interface materials compute MaterialProperties |
CInterfacePostprocessor | BASE CLASS FOR IMPLEMENTING INTERFACE POSTRPOCESSOR ALL INTERFACE POSTPROCESOR SHOULD DERIVE FROM THIS CLASS THIS ALSO COMPUTES THE INTERFACE AREA |
CInterfaceQpMaterialPropertyBaseUserObject | Specialization of InterfaceQpUserObjectBase for material properties |
CInterfaceQpMaterialPropertyRealUO | Specialization of InterfaceQpMaterialPropertyBaseUserObject for Real material properties |
CInterfaceQpUserObjectBase | This is a base class for userobjects collecting values of variables or material properites across an interface at each QP |
CInterfaceQpValueUserObject | Specialization of InterfaceQpUserObjectBase for scalar variables |
CInterfaceReaction | Implements a reaction to establish ReactionRate=k_f*u-k_b*v at interface |
CInterfaceTimeKernel | InterfaceTimeKernel is responsible for adding time derivative contributions for physics across interfaces |
CInterfaceUserObject | Base class for implementing interface user objects |
CInterfaceUserObjectBase | Base class for implementing interface user objects |
CInterfaceValueUserObject | A special InterfaceUserObject computing average values across an interface given the average type (see InterfaceValueTools for details) |
CInterfaceValueUserObjectAux | AuxKernel creating an AuxVariable from values stored in an InterfaceQpUserObjectBase |
CInterfaceVectorPostprocessor | |
CInternalSideIndicator | Responsible for calculating the residuals for various physics on internal sides (edges/faces) |
CInternalSideIntegralPostprocessor | This postprocessor computes a surface integral of the specified variable on internal sides of the mesh |
CInternalSideIntegralVariablePostprocessor | This postprocessor computes an integral on internal mesh sides of the specified variable |
CInternalSidePostprocessor | |
CInternalSideUserObject | Base class for user objects executed on all element sides internal to one or more blocks, by default to the whole mesh |
CInternalSideVectorPostprocessor | |
CInterpolatedStatefulMaterialTempl | Reconstitute a materal property from the old and older states of projected AuxVariables |
CIntersectionPointsAlongLine | Get the intersection points for all of the elements that are intersected by a line |
CInversePowerMethod | |
CIterationAdaptiveDT | Adjust the timestep based on the number of iterations |
CIterationInfo | Report the time and iteration information for the simulation |
CJacobianBlock | Helper class for holding the preconditioning blocks to fill |
CJSONFileReader | User object that reads a JSON file and makes its data available to other objects |
CJsonInputFileFormatter | This class produces produces a dump of the InputParameters that appears like the normal input file syntax |
CJSONOutput | |
CJsonSyntaxTree | Holds the syntax in a Json::Value tree |
CJvarMapIntegratedBCInterface | Interface class ("Veneer") for IntegratedBC to provide a mapping from 'jvar' in computeJacobianBlock into the _coupled_moose_vars array |
CJvarMapInterfaceBase | Base class ("Veneer") that implements the actual mapping from 'jvar' in into the _coupled_moose_vars array |
CJvarMapKernelInterface | Interface class ("Veneer") for Kernel to provide a mapping from 'jvar' in computeQpOffDiagJacobian into the _coupled_moose_vars array |
CKDTree | |
CKernel | |
CKernelBase | This is the common base class for the three main kernel types implemented in MOOSE, Kernel, VectorKernel and ArrayKernel |
CKernelGrad | Responsible for calculating the residuals in form: |
CKernelScalarBase | This Kernel adds standardized methods for assembling to a primary scalar variable associated with the primary variable of the Kernel object |
CKernelValue | Responsible for calculating the residuals in form: |
CLaplacianJumpIndicator | |
CLayeredAverage | This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CLayeredBase | This base class computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CLayeredExtremumMaterialProperty | This UserObject computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CLayeredIntegral | This UserObject computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CLayeredSideAverage | This UserObject computes side averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CLayeredSideAverageBase | Base class for computing layered side averages |
CLayeredSideAverageFunctor | Computes layered side averages of a functor |
CLayeredSideDiffusiveFluxAverage | This UserObject computes side averages of a flux storing partial sums for the specified number of intervals in a direction (x,y,z) |
CLayeredSideIntegral | This UserObject computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CLayeredSideIntegralBase | Base class for computing layered side integrals |
CLayeredSideIntegralFunctor | Computes layered side integrals of a functor |
CLazyCoupleable | Interface for objects that need coupling capabilities |
CLeastSquaresFit | LeastSquaresFit is a VectorPostprocessor that performs a least squares fit on data calculated in another VectorPostprocessor |
CLeastSquaresFitBase | Base class for linear least squares fit method |
CLeastSquaresFitHistory | LeastSquaresFitHistory is a VectorPostprocessor that performs a least squares fit on data calculated in another VectorPostprocessor and stores the full history of the coefficients |
CLibmeshPartitioner | |
CLibtorchArtificialNeuralNetParameters | A Reporter which can print the parameter values of a LibtorchArtificialNeuralNetwork from within a Controller object |
CLibtorchControlValuePostprocessor | A class for querying output signals from LibtorchNeuralNetControl and derived objects |
CLibtorchNeuralNetControl | A time-dependent, neural network-based control of multiple input parameters |
CLinearCombinationFunction | Sum_over_i (w_i * functions_i) |
CLinearCombinationPostprocessor | Computes a linear combination between an arbitrary number of post-processors |
CLinearInterpolation | This class interpolates values given a set of data pairs and an abscissa |
CLinearInterpolationTempl | |
CLinearNodalConstraint | The secondary node variable is programmed as a linear combination of the primary node variables (i.e, secondary_var = a_1*primary_var_1+ a_2*primary_var_2+.. |
CLineFunctionSampler | |
CLineMaterialRealSampler | This class samples Real material properties for the integration points in all elements that are intersected by a user-defined line |
CLineMaterialSamplerBase | This is a base class for sampling material properties for the integration points in all elements that are intersected by a user-defined line |
CLineSearch | |
CLineSegment | Used by the LineMaterialSamplerBase class and for some ray tracing stuff |
CLineValueSampler | |
CLocalRankConfig | Holds app partitioning information relevant to the a particular rank for a multiapp scenario |
CLockFile | Gets an exclusive lock on a file |
CLogConstantDT | Simple time-stepper which imposes a time step constant in the logarithmic space |
CLowerBoundNodalKernel | Class used to enforce a lower bound on a coupled variable |
CLowerDBlockFromSidesetGenerator | Creates lower-dimensional elements on the specified sidesets |
CLowerDIntegratedBC | |
CLStableDirk2 | Second order diagonally implicit Runge Kutta method (Dirk) with two stages |
CLStableDirk3 | Third order diagonally implicit Runge Kutta method (Dirk) with three stages |
CLStableDirk4 | Fourth-order diagonally implicit Runge Kutta method (Dirk) with five stages |
CLumpedPreconditioner | Class to that applies the lumped mass matrix preconditioner in the ExplicitTimeIntegrator |
CMarker | |
CMassEigenKernel | |
CMassLumpedTimeDerivative | |
CMassMatrix | Computes a finite element mass matrix meant for use in preconditioning schemes which require one |
CMatchedValueBCTempl | Implements a simple coupled boundary condition where u=v on the boundary |
CMatCoupledForce | Represents a right hand side force term of the form Sum_j c_j * m_j * v_j, where c is a vector of real numbers, m_j is a vector of material properties, and v_j is a vector of variables |
CMatDiffusion | Isotropic diffusion kernel that takes a diffusion coefficient of type Real |
CMatDiffusionBase | This class template implements a diffusion kernel with a mobility that can vary spatially and can depend on variables in the simulation |
CMaterial | Materials compute MaterialProperties |
CMaterialADConverterTempl | This material converts regular material properties to AD properties and AD properties to regular properties |
CMaterialAuxBaseTempl | A base class for the various Material related AuxKernal objects |
CMaterialBase | MaterialBases compute MaterialProperties |
▶CMaterialData | Proxy for accessing MaterialPropertyStorage |
CMaterialDerivativeRankFourTestKernel | This kernel is used for testing derivatives of a material property |
CMaterialDerivativeRankTwoTestKernel | This kernel is used for testing derivatives of a material property |
CMaterialDerivativeTestAction | Sets up variables and Kernels to test the derivatives of material properties via the Jacobian checker |
CMaterialDerivativeTestKernel | This kernel is used for testing derivatives of a material property |
CMaterialDerivativeTestKernelBase | This kernel is used for testing derivatives of a material property |
CMaterialFunctorConverterTempl | This material converts functor to regular (AD or not) material properties |
CMaterialOutputAction | Creates AuxVariables and AuxKernels for automatic output of material properties |
▶CMaterialProperties | |
CMaterialProperty | |
CMaterialPropertyBase | Concrete definition of a parameter value for a specified type |
CMaterialPropertyDebugOutput | A class for producing various debug related outputs |
CMaterialPropertyInterface | An interface for accessing Materials |
▶CMaterialPropertyRegistry | Registry class for material property IDs and names |
▶CMaterialPropertyStorage | Stores the stateful material properties computed by materials |
CMaterialPropertyValueTempl | |
CMaterialRankFourTensorAux | MaterialRankFourTensorAux is designed to take the data in the RankFourTensor material property, for example stiffness, and output the value for the supplied indices |
CMaterialRankTwoTensorAuxTempl | MaterialRankTwoTensorAux is designed to take the data in the RankTwoTensor material property, for example stress or strain, and output the value for the supplied indices |
CMaterialRateAuxBaseTempl | A base class for the various Material related AuxKernal objects |
CMaterialRateRealAuxTempl | Object for passing a scalar, REAL material property to an AuxVariable |
CMaterialRealAuxTempl | Object for passing a scalar, REAL material property to an AuxVariable |
CMaterialRealDenseMatrixAux | AuxKernel for outputting a DenseMatrix<Real> material property component to an AuxVariable |
CMaterialRealTensorValueAux | AuxKernel for outputting a RealTensorValue material property component to an AuxVariable |
CMaterialRealVectorValueAuxTempl | AuxKernel for outputting a RealVectorValue material property component to an AuxVariable |
CMaterialStdVectorAuxBaseTempl | A base class for the various Material related AuxKernal objects |
CMaterialStdVectorAuxTempl | AuxKernel for outputting a std::vector material-property component to an AuxVariable |
CMaterialStdVectorRealGradientAux | AuxKernel for outputting a std::vector material-property component to an AuxVariable |
CMaterialVectorPostprocessor | This postprocessor records all scalar material properties of the specified material object on specified elements at the indicated execution points (e.g |
CMaterialWarehouse | MaterialBase objects are special in that they have additional objects created automatically (see FEProblemBase::addMaterial) |
CMatNeumannBCTempl | Implements a Neumann BC where D grad(u) = value * M on the boundary, where value is a constant and M is a material property |
CMatReaction | This kernel adds to the residual a contribution of \( -L*v \) where \( L \) is a material property and \( v \) is a variable (nonlinear or coupled) |
CMaxIncrement | TODO |
CMaxQpsThread | This class determines the maximum number of Quadrature Points and Shape Functions used for a given simulation based on the variable discretizations, and quadrature rules used for all variables in the system |
CMaxVarNDofsPerElem | |
CMaxVarNDofsPerNode | |
CMemoryUsage | Output maximum, average, or total process memory usage |
CMemoryUsageReporter | Mix-in class for querying memory metrics used by MemoryUsage and VectorMemoryUsage |
CMeshBaseImageSampler | A helper class for reading and sampling images using VTK, but with a Meshbase object |
CMeshChangedInterface | Interface for notifications that the mesh has changed |
CMeshCollectionGenerator | Collects multiple meshes into a single (unconnected) mesh |
CMeshDiagnosticsGenerator | |
CMeshDivision | Base class for MeshDivision objects |
CMeshDivisionAux | Returns the index of the mesh division for each element / node |
CMeshDivisionFunctorReductionVectorPostprocessor | This MeshDivisionFunctorReductionVectorPostprocessor serves to integrate functors based on the index of the elements in the mesh division |
▶CMeshExtruderGenerator | Extrude a 1D or 2D mesh to a 2D or 3D mesh respectively |
▶CMeshGenerator | MeshGenerators are objects that can modify or add to an existing mesh |
CMeshGeneratorMesh | Mesh generated from parameters |
CMeshGeneratorSystem | System that manages MeshGenerators |
▶CMeshInfo | Report mesh information, such as the number of elements, nodes, and degrees of freedom |
CMeshMetaDataInterface | The Interface used to retrieve mesh meta data (attributes) set by the MeshGenerator system |
CMeshMetaDataReporter | Reports the mesh meta data |
CMeshOnlyAction | |
CMeshRepairGenerator | Mesh generator to perform various improvement / fixing operations on an input mesh |
CMessageFromInput | User object that get a message from an input file and print it out during the simulation |
CMonotoneCubicInterpolation | This class interpolates values given a set of data pairs and an abscissa |
CMooseADWrapperStruct | |
CMooseADWrapperStruct< ChainedReal, true > | |
CMooseADWrapperStruct< MooseUtils::SemidynamicVector< T, N, zero_initialize >, is_ad > | |
CMooseADWrapperStruct< Point, true > | |
CMooseADWrapperStruct< Real, true > | |
CMooseADWrapperStruct< std::array< T, N >, is_ad > | |
CMooseADWrapperStruct< std::vector< T >, is_ad > | |
CMooseADWrapperStruct< W< T >, is_ad > | |
▶CMooseApp | Base class for MOOSE-based applications |
CMooseAppCoordTransform | |
CMooseArray | Forward declarations |
CMooseBase | Base class for everything in MOOSE with a name and a type |
CMooseBaseErrorInterface | Interface that provides APIs to output errors/warnings/info messages |
CMooseBaseParameterInterface | Every object that can be built by the factory should be derived from this class |
CMooseEigenSystem | |
CMooseEnum | This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It should be initialized with a space-delimited list of strings which become the enum values |
CMooseEnumBase | The base class for both the MooseEnum and MultiMooseEnum classes |
CMooseEnumItem | Class for containing MooseEnum item information |
CMooseException | Provides a way for users to bail out of the current solve |
CMooseInit | Initialization object for any MOOSE-based application |
CMooseIsADType | |
CMooseIsADType< ADPoint > | |
CMooseIsADType< ADReal > | |
CMooseIsADType< std::vector< T > > | |
CMooseIsADType< W< T > > | |
CMooseIsADType< W< T, N > > | |
▶CMooseMesh | MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and storing more state |
CMooseObject | Every object that can be built by the factory should be derived from this class |
CMooseObjectAction | |
CMooseObjectName | A class for storing the names of MooseObject by tag and object name |
CMooseObjectParameterName | A class for storing an input parameter name |
CMooseObjectTagWarehouse | A storage container for MooseObjects that inherit from SetupInterface |
CMooseObjectUnitTest | Base class for building basic unit tests for MOOSE objects that can live alone (like user objects, etc.) |
CMooseObjectWarehouse | A storage container for MooseObjects that inherit from SetupInterface |
CMooseObjectWarehouseBase | A base storage container for MooseObjects |
CMooseParsedFunction | This class is used to evaluate symbolic equations passed in to Moose through the input file |
CMooseParsedFunctionBase | Creates the 'vars' and 'vals' parameters used by all ParsedFunctions, the parameters provided from this function should be appended to the parameters for the class using the += operator |
CMooseParsedFunctionWrapper | A wrapper class for creating and evaluating parsed functions via the libMesh::ParsedFunction interface for fparser |
CMooseParsedGradFunction | This class is similar to ParsedFunction except it also supports returning the gradient of the function |
CMooseParsedVectorFunction | This class is similar to ParsedFunction except it returns a vector function |
CMoosePartitioner | Base class for MOOSE partitioner |
CMoosePreconditioner | Base class for MOOSE preconditioners |
CMooseRandom | This class encapsulates a useful, consistent, cross-platform random number generator with multiple utilities |
CMooseServer | |
CMooseUnits | Physical unit management class with runtime unit string parsing, unit checking, unit conversion, and output |
CMooseVariableBase | |
CMooseVariableConstMonomial | |
CMooseVariableData | |
CMooseVariableDataBase | |
CMooseVariableDataFV | |
CMooseVariableDependencyInterface | |
CMooseVariableFE | Class for stuff related to variables |
CMooseVariableField | Class for stuff related to variables |
CMooseVariableFieldBase | This class provides an interface for common operations on field variables of both FE and FV types with all their scalar, vector, eigenvector permutations |
CMooseVariableFV | This class provides variable solution values for other classes/objects to bind to when looping over faces or elements |
CMooseVariableInterface | Interface for objects that need to get values of MooseVariables |
CMooseVariableScalar | Class for scalar variables (they are different) |
CMortarConstraint | |
CMortarConstraintBase | User for mortar methods |
CMortarConsumerInterface | An interface for accessing mortar mesh data |
CMortarData | |
CMortarExecutorInterface | Interface for notifications that the mortar mesh has been setup |
CMortarNodalAuxKernelTempl | Base class for creating new nodally-based mortar auxiliary kernels |
CMortarNodalGeometryOutput | |
CMortarScalarBase | This Constraint adds standardized methods for assembling to a primary scalar variable associated with the major variables of the Mortar Constraint object |
CMortarSegmentHelper | This class supports defining mortar segment mesh elements in 3D by projecting secondary and primary elements onto a linearized plane, computing the overlapping polygon formed by their projections, and triangulating the resulting nodes |
CMortarSegmentInfo | Holds xi^(1), xi^(2), and other data for a given mortar segment |
CMortarUserObject | Base class for creating new nodally-based mortar user objects |
CMortarUserObjectThread | |
CMoveNodeGenerator | Modifies the position of one or more node(s) |
CMultiApp | A MultiApp represents one or more MOOSE applications that are running simultaneously |
CMultiAppCloneReporterTransfer | Transfer for migrating reporter values between the main and sub-application(s) |
CMultiAppConservativeTransfer | Transfers variables on possibly different meshes while conserving a user defined property (Postprocessor) for each variable |
CMultiAppCoordTransform | This class contains transformation information that only exists in a context in which there are multiple applications |
CMultiAppCopyTransfer | Copy variables directly from one application to another, based on degree-of-freedom indexing TODO: Rename to MultiAppVariableCopy or MultiAppFieldCopy |
CMultiAppDofCopyTransfer | Copy the fields directly from one application to another, based on degree-of-freedom indexing |
CMultiAppFieldTransfer | Intermediary class that allows variable names as inputs |
CMultiAppGeneralFieldNearestLocationTransfer | Performs a geometric interpolation based on the values at the nearest nodes to a target location in the origin mesh |
CMultiAppGeneralFieldShapeEvaluationTransfer | Evaluates origin shape functions to compute the target variables |
▶CMultiAppGeneralFieldTransfer | It is a general field transfer |
CMultiAppGeneralFieldUserObjectTransfer | Transfers values computed in the origin mesh by the source user object spatialValue() routine at locations in the target mesh |
CMultiAppGeometricInterpolationTransfer | Interpolate variable values using geometry/mesh-based coefficients |
CMultiAppNearestNodeTransfer | Copy the value to the target domain from the nearest node in the source domain |
CMultiAppPositions | Positions from all the MultiApps |
CMultiAppPostprocessorInterpolationTransfer | Transfers from postprocessors in child apps of a MultiApp in different locations in parent app mesh, interpolates the values between the app locations then fills a field variable in the parent app system |
CMultiAppPostprocessorToAuxScalarTransfer | Copies the value of a Postprocessor from one app to a scalar AuxVariable in another |
CMultiAppPostprocessorTransfer | Copies the value of a Postprocessor either: |
CMultiAppProjectionTransfer | Project values from one domain to another |
CMultiAppReporterTransfer | Transfer for migrating reporter values between the main and sub-application(s) |
CMultiAppScalarToAuxScalarTransfer | Copies the value of a SCALAR variable from one App to another |
CMultiAppShapeEvaluationTransfer | Transfers a vector of variables |
CMultiAppSolveFailure | Utility class for catching solve failure errors so that MOOSE can recover state before continuing |
CMultiAppTransfer | Base class for all MultiAppTransfer objects |
CMultiAppUserObjectTransfer | Loops over a target mesh and uses either node or element centroid location (based on the target variable type) for sampling a user object (i.e |
CMultiAppVariableValueSamplePostprocessorTransfer | Samples a variable's value in the parent application domain at the point where the MultiApp (for each child app) is |
CMultiAppVariableValueSampleTransfer | Samples a variable's value in the parent application domain at the point where the MultiApp (for each child app) is |
CMultiAppVectorPostprocessorTransfer | Copies the values of a VectorPostprocessor from the parent application to postprocessors on each subapp of a MultiApp or collects the postprocessors on each subapp of a MultiApp into a VectorPostprocessor on the parent app |
CMultiDimensionalInterpolationTempl | This class interpolates multi-dimensional data sets |
▶CMultiIndex | Implements a container class for multi-indexed objects with an arbitrary number of indices |
CMultiMooseEnum | This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It should be initialized with a comma-separated list of strings which become the enum values |
CNanoflannMeshAdaptor | This allows us to adapt the MeshBase class for use with nanoflann |
CNanoflannMeshSubdomainAdaptor | Special adaptor that works with subdomains of the Mesh |
CNearestNodeDistanceAux | Computes the distance from a block or boundary to another boundary |
▶CNearestNodeLocator | Finds the nearest node to each node in boundary1 to each node in boundary2 and the other way around |
CNearestNodeNumber | Given a NearestNodeNumberUO, outputs the nearest node number to a given point |
CNearestNodeNumberUO | Finds the nearest node to a given point |
CNearestNodeThread | |
CNearestNodeValueAux | Finds the closest node on a paired boundary to the current node or element and stores a corresponding field value |
CNearestPointAverage | Given a list of points this object computes the average of a variable over the points closest to each provided point |
CNearestPointBase | This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CNearestPointIntegralVariablePostprocessor | Given a list of points this object computes the variable integral closest to each one of those points |
CNearestPointLayeredAverage | This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CNearestPointLayeredIntegral | This UserObject computes integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CNearestPointLayeredSideAverage | This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CNearestPointLayeredSideAverageFunctor | Computes layered side averages of a functor nearest to a set of points |
CNearestPointLayeredSideDiffusiveFluxAverage | This UserObject computes averages of a variable's flux storing partial sums for the specified number of intervals in a direction (x,y,z) |
CNearestPointLayeredSideIntegral | This UserObject computes integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CNearestPointLayeredSideIntegralFunctor | Computes layered side integrals of a functor nearest to a set of points |
CNearestPositionsDivision | Divides the mesh based on a nearest-neighbor algorithm applied to the positions from a Positions object |
CNearestRadiusLayeredAverage | This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) |
CNeighborCoupleable | Enhances Coupleable interface to also couple the values from neighbor elements |
CNeighborCoupleableMooseVariableDependencyIntermediateInterface | Intermediate base class that ties together all the interfaces for getting MooseVariables with the MooseVariableDependencyInterface |
CNeighborMooseVariableInterface | Enhances MooseVariableInterface interface provide values from neighbor elements |
CNeighborResidualObject | This is a base class for objects that can provide residual contributions for both local and neighbor elements |
CNemesis | Class for output data to the Nemesis format |
CNestedDivision | Divides the mesh based on nested divisions |
▶CNestedSolveTempl | NestedSolveTempl<is_ad> and its instantiations NestedSolve and ADNestedSolve are utility classes that implement a non-linear solver |
CNeumannBCTempl | Implements a simple constant Neumann BC where grad(u)=value on the boundary |
CNewmarkBeta | Newmark-Beta time integration method |
CNodalBC | Base class for deriving any boundary condition that works at nodes |
CNodalBCBase | Base class for deriving any boundary condition that works at nodes |
CNodalConstraint | |
CNodalDamper | Base class for deriving nodal dampers |
CNodalEqualValueConstraint | Constraint to enforce equal values (in 1D) |
CNodalExtremeValue | A postprocessor for collecting the nodal min or max value |
CNodalKernel | Base class for creating nodal kernels with hand-coded Jacobians |
CNodalKernelBase | Base class for creating new types of nodal kernels |
CNodalL2Error | |
CNodalL2Norm | Computes the "nodal" L2-norm of the coupled variable, which is defined by summing the square of its value at every node and taking the square root |
CNodalMaxValue | This class computes a maximum (over all the nodal values) of the coupled variable |
CNodalMaxValueId | Computes the id of the node with the maximum value across all processes |
CNodalNormalBC | This is a base class to enforce strong boundary condition with a normal defined at a node |
CNodalNormalsCorner | |
CNodalNormalsEvaluator | Works on top of NodalNormalsPreprocessor |
CNodalNormalsPreprocessor | An ElementUserObject that prepares MOOSE for computing nodal normals |
CNodalPatchRecovery | This class uses patch recovery technique to recover material properties to smooth nodal fields |
CNodalPatchRecoveryAux | |
CNodalPatchRecoveryAuxBase | |
CNodalPatchRecoveryBase | |
CNodalPatchRecoveryMaterialProperty | Prepare patches for use in nodal patch recovery based on a material property |
CNodalPostprocessor | |
CNodalReporter | |
CNodalScalarKernel | |
CNodalStatistics | |
CNodalSum | Computes a sum of the nodal values of the coupled variable |
CNodalUserObject | A user object that runs over all the nodes and does an aggregation step to compute a single value |
CNodalValueSampler | Samples values of nodal variable(s) |
CNodalVariablePostprocessor | This is a base class for other classes which compute post-processed values based on nodal solution values of _u |
CNodalVariableStatistics | |
CNodalVariableValue | Sums a nodal value across all processors and multiplies the result by a scale factor |
CNodalVariableVectorPostprocessor | Base class VectorPostprocessors operating on nodal variables |
CNodalVectorPostprocessor | |
CNodeElemConstraint | A NodeElemConstraint is used when you need to create constraints between a secondary node and a primary element |
CNodeFaceConstraint | A NodeFaceConstraint is used when you need to create constraints between two surfaces in a mesh |
CNodeSetsFromSideSetsGenerator | MeshGenerator for constructing node sets from side sets |
CNonADFunctorInterface | An interface for accessing Moose::Functors for systems that do not care about automatic differentiation, e.g |
CNonlinearEigen | |
CNonlinearEigenSystem | Nonlinear eigenvalue system to be solved |
CNonlinearSolveObject | A solve object for use with a nonlinear system solver |
CNonlinearSystem | Nonlinear system to be solved |
CNonlinearSystemBase | Nonlinear system to be solved |
CNonlinearThread | |
CNonlocalIntegratedBC | NonlocalIntegratedBC is used for solving integral terms in integro-differential equations |
CNonlocalKernel | NonlocalKernel is used for solving integral terms in integro-differential equations |
CNormalizationAux | This auxiliary kernel normalizes a variable based on a postprocessor |
CNullExecutor | |
CNullKernel | |
CNullScalarKernel | Scalar kernel that sets a zero residual, to avoid error from system missing this variable |
CNumDOFs | |
CNumElems | |
CNumFailedTimeSteps | This postprocessor outputs the amount of failed time steps |
CNumFixedPointIterations | Returns the number of fixed point iterations taken by the Executioner as a Postprocessor |
CNumLinearIterations | |
CNumMeshDivisions | Counts the number of divisions/regions from a MeshDivision object |
CNumNodes | |
CNumNonlinearIterations | NumNonlinearIterations is a postprocessor that reports the number of nonlinear iterations |
CNumPositions | Counts the number of positions from a Positions object |
CNumRelationshipManagers | |
CNumResidualEvaluations | Just returns the total number of Residual Evaluations performed |
CNumVars | |
CODEKernel | |
CODETimeDerivative | |
CODETimeKernel | Base class for ODEKernels that contribute to the time residual vector |
COldEqualValueConstraint | Constrain the value of a variable to be the same on both sides of an interface |
COneDEqualValueConstraintBC | This is the \( \int \lambda dg\) term from the mortar method |
COnScopeExit | This works like the Sentinel helper classes in MOOSE, except it is more flexible and concise to use |
COptionalMaterialPropertyProxy | |
COptionalMaterialPropertyProxyBase | Helper class for deferred getting of material properties after the construction phase for materials |
COrientedBoxInterface | |
COrientedBoxMarker | Creates a box of specified width, length and height, with its center at specified position, and with the direction along the width direction specified, and with the direction along the length direction specified |
COrientedSubdomainBoundingBoxGenerator | MeshGenerator for defining a Subdomain inside or outside of a bounding box with arbitrary orientation |
COutput | Based class for output objects |
COutputData | A structure for storing the various lists that contain the names of the items to be exported |
COutputDataWarehouse | A helper warehouse for storing OutputData objects for the various output types |
COutputInterface | A class to provide an common interface to objects requiring "outputs" option |
COutputMapWrapper | In newer versions of Clang calling operator[] on a map with a component that has a default constructor is an error, thus utilizing a map directly to store a ExecFlagEnum is not possible |
COutputOnWarehouse | A helper warehouse class for storing the "execute_on" settings for the various output types |
COutputTools | |
COutputWarehouse | Class for storing and utilizing output objects |
COverlayMeshGenerator | |
COverrideParamWalker | |
COversampleOutput | Based class for providing re-positioning and oversampling support to output objects |
CParallelUniqueId | |
CParsedAux | AuxKernel that evaluates a parsed function expression |
CParsedCurveGenerator | His ParsedCurveGenerator object is designed to generate a mesh of a curve that consists of EDGE2 elements |
CParsedElementDeletionGenerator | Deletes elements based on the evaluation of a parsed expression, involving the coordinates of their vertex average and their volume |
CParsedFunctorMaterialTempl | Computes a functor material from a parsed expression of other functors |
CParsedGenerateSideset | MeshGenerator for defining a Sideset by a parsed expression and optionally by looking at the subdomain a side's element belongs to and the side's normal vector |
CParsedMaterialBase | Helper class for ParsedMaterial and DerivativeParsedMaterial to declare and read the input parameters |
CParsedMaterialHelper | Helper class to perform the parsing and optimization of the function expression |
CParsedMaterialTempl | FunctionMaterialBase child class to evaluate a parsed function |
CParsedNodeTransformGenerator | |
CParsedODEKernel | Parsed ODE function kernel |
CParsedPostprocessor | Postprocessor that evaluates a parsed function expression |
CParsedSubdomainMeshGenerator | MeshGenerator for defining a Subdomain inside or outside of combinatorial geometry |
CParsedVectorAux | AuxKernel that evaluates a parsed function expression for every component |
CParser | Class for parsing input files |
CPartitionerAction | |
CPatchMeshGenerator | |
CPatternedMesh | Reads one or more 2D mesh files and stitches them together based on a provided two-dimensional pattern array |
CPatternedMeshGenerator | Reads one or more 2D mesh files and stitches them together based on a provided two-dimensional pattern array |
CPenaltyDirichletBC | Weakly enforce a Dirichlet BC using a penalty term |
CPenaltyDirichletNodalKernel | |
CPenaltyEqualValueConstraintTempl | Constrain the value of a variable to be the same on both sides of an interface using a generalized force stemming from a penalty-based enforcement |
CPenaltyInterfaceDiffusionTempl | Interface kernel for interfacing diffusion between two variables on adjacent blocks |
CPenaltyPeriodicSegmentalConstraint | This class enforces a periodic boundary condition between a microscale and macroscale field |
CPenetrationAux | |
CPenetrationInfo | Data structure used to hold penetration information |
CPenetrationLocator | |
▶CPenetrationThread | |
CPercentChangePostprocessor | This postprocessor displays the change in the postprocessor between adjacent timesteps |
▶CPerfGraph | The PerfGraph will hold the master list of all registered performance segments and the head PerfNode |
CPerfGraphData | |
CPerfGraphInterface | Interface for objects interacting with the PerfGraph |
CPerfGraphLivePrint | This is effectively a functor that runs on a separate thread and watches the state of the call stack to see if things need to be printed about what the application is doing |
CPerfGraphOutput | Class for output information regarding Controls to the screen |
CPerfGraphReporter | Reports the full graph from the PerfGraph |
CPerfGuard | Scope guard for starting and stopping timing for a node |
CPerfNode | A node in the PerfGraph |
CPeriodicFunction | |
CPeriodicSegmentalConstraint | This class enforces a periodic boundary condition between a microscale and macroscale field |
CPetscExternalPartitioner | Partitions a mesh using external petsc partitioners such as parmetis, ptscotch, chaco, party, etc |
CPetscOutput | Adds the ability to output on every nonlinear and/or linear residual |
CPetscOutputInterface | |
CPhysicsBase | Base class to help creates an entire physics |
CPhysicsBasedPreconditioner | Implements a segregated solve preconditioner |
CPicardSolve | |
CPIDTransientControl | A time-dependent control of an input parameter or a postprocessor, which aims at making a postprocessor match a desired value |
CPiecewiseBase | Function base which provides a piecewise approximation to a specified (x,y) point data set |
CPiecewiseBilinear | PiecewiseBilinear reads from a file the information necessary to build the vectors x and y and the ColumnMajorMatrix z, and then sends those (along with a sample point) to BilinearInterpolation |
CPiecewiseByBlockFunctorMaterialTempl | Defines a functor material property by another functor (possibly constant) on each block, discontinuous at interfaces |
CPiecewiseByBlockLambdaFunctor | A material property that is evaluated on-the-fly via calls to various overloads of operator() |
CPiecewiseConstant | Function which provides a piecewise constant interpolation of a provided (x,y) point data set |
CPiecewiseConstantByBlockMaterialTempl | |
CPiecewiseConstantFromCSV | Function which provides a piecewise constant, in space, field from a CSV file |
CPiecewiseLinear | Function which provides a piecewise continuous linear interpolation of a provided (x,y) point data set |
CPiecewiseLinearBase | Base class for functions which provides a piecewise continuous linear interpolation of an (x,y) point data set |
CPiecewiseLinearFromVectorPostprocessor | Function which provides a piecewise continuous linear interpolation of a data set provided as two columns of a VectorPostprocessor |
CPiecewiseLinearInterpolationMaterial | This material uses a LinearInterpolation object to define the dependence of the material's value on a variable |
CPiecewiseMulticonstant | Uses GriddedData to define data on a grid, and does linear interpolation on that data to provide function values |
CPiecewiseMultiInterpolation | Uses GriddedData to define data on a grid, and does linear interpolation on that data to provide function values |
CPiecewiseMultilinear | Uses GriddedData to define data on a grid, and does linear interpolation on that data to provide function values |
CPiecewiseTabularBase | Function base which provides a piecewise approximation to a provided (x,y) point data set via input parameter specifications |
CPlaneDeletionGenerator | Deletes elements lying above a plane |
CPlaneIDMeshGenerator | Assigns plane extra ID for existing 3D meshes |
CPNGOutput | |
▶CPointIndexedMap | An unordered map indexed by Point, eg 3 floating point numbers Because floating point rounding errors can affect the hashing, eg the binning of values, we may need to look near a Point/key for where the initial value was stored |
CPointListAdaptor | |
CPointSamplerBase | Base class for sampling objects (variables, functors etc) at points |
CPointValue | Compute the value of a variable at a specified location |
CPointValueSampler | |
CPointVariableSamplerBase | Base class for sampling variable(s) at points |
CPointwiseRenormalizeVector | Renormalization of a vector variable (i.e |
CPolyLineMeshGenerator | Generates a polyline (open ended or looped) of Edge elements through a series of nodal locations and other input parameters |
CPolynomialFit | Least squares polynomial fit |
CPositions | Positions objects are under the hood Reporters |
CPositionsFunctorValueSampler | Samples one or more functor(s) at points given by a Positions object |
CPostprocessor | Base class for all Postprocessors |
CPostprocessorComparison | Compares two post-processors and produces a boolean value |
CPostprocessorDirichletBC | Boundary condition of a Dirichlet type |
CPostprocessorDT | Computes the value of dt based on a postprocessor value |
CPostprocessorInterface | Interface class for classes which interact with Postprocessors |
CPostprocessorNeumannBC | Implements a constant Neumann BC where grad(u) is a equal to a postprocessor on the boundary |
CPostprocessorReporterName | A ReporterName that represents a Postprocessor |
CPostprocessorSpatialUserObject | User object that holds a postprocessor value |
CPredictor | Base class for predictors |
CProblem | Class that hold the whole problem being solved |
CProcessorIDAux | |
CProgressOutput | Output a simulation time progress bar on the console |
CProjectedMaterialPropertyNodalPatchRecoveryAux | |
CProjectedStatefulMaterialAuxTempl | |
CProjectedStatefulMaterialNodalPatchRecoveryBase | |
CProjectedStatefulMaterialNodalPatchRecoveryTempl | |
▶CProjectedStatefulMaterialStorageAction | Set up AuxKernels and AuxVariables for projected material property storage (PoMPS) |
CProjectionAux | Projects from one variable to another |
CProjectMaterialProperties | |
CPropertyReadFile | Read properties from file - grain, element, node or block Input file syntax: prop1 prop2 etc |
CPropertyValue | Abstract definition of a property value |
CProxyRelationshipManager | Intermediate base class for RelationshipManagers that are simply built using ghosting functors |
CPseudoTimestep | Computes a time step size based on pseudo-timestep continuation |
CQpMap | Helper object for holding qp mapping info |
CQuadraturePointMarker | |
CQuadraturePointMultiApp | Automatically generates sub-App positions with elemental quadrature points of the parent mesh |
CQuotientAux | This auxiliary kernel computes its value by dividing "numerator" by "denominator |
CQuotientScalarAux | This auxiliary kernel computes its value by dividing "numerator" by "denominator |
▶CRadialAverage | Gather and communicate a full list of all quadrature points and the values of a selected material property at each point |
CRalston | Ralston's time integration method |
CRandomData | |
CRandomIC | RandomIC just returns a Random value |
CRandomICBase | Base class for randomly generated initial conditions |
CRandomInterface | Interface for objects that need parallel consistent random numbers without patterns over the course of multiple runs |
CRandomPartitioner | Partitions a mesh randomly using element ids as the seed for the generator |
▶CRankFourTensorTempl | RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C |
CRankMap | Builds lists and maps that help in knowing which physical hardware nodes each rank is on |
CRankThreeTensorTempl | RankThreeTensor is designed to handle any N-dimensional third order tensor, r |
CRankTwoTensorTempl | RankTwoTensorTempl is designed to handle the Stress or Strain Tensor for a fully anisotropic material |
CReactionNodalKernel | Represents a nodal reaction term equivalent to $a * u$ |
CReactionTempl | Implements a simple consuming reaction term with weak form $(\psi_i, \lambda u_h)$ |
CReadExecutorParamsAction | |
CRealFunctionControl | A basic control for changing an input parameter using a Function |
CReceiver | A class for storing data, it allows the user to change the value of the postprocessor by altering the _my_value reference |
CRedistributeProperties | RedistributeProperties is used for its redistribute() callback, which ensures that any stateful properties are restributed to the same properties to which elements they are associated with are redistributed |
▶CReferenceResidualProblem | FEProblemBase derived class to enable convergence checking relative to a user-specified postprocessor |
CRefineBlockGenerator | MeshGenerator for refining one or more blocks |
CRefineSidesetGenerator | MeshGenerator for refining one or more sidesets |
CRegistry | The registry is used as a global singleton to collect information on all available MooseObject and Action classes for use in a moose app/simulation |
CRegistryEntry | |
CRegistryEntryBase | |
CRegistryEntryData | Holds details and meta-data info for a particular MooseObject or Action for use in the use in the registry |
CRelationshipManager | RelationshipManagers are used for describing what kinds of non-local resources are needed for an object's calculations |
CRelativeDifferencePostprocessor | Computes the absolute value of the relative difference between 2 post-processor values |
CRelativeSolutionDifferenceNorm | Gets the relative solution norm from the transient executioner |
CRenameBlockGenerator | MeshGenerator for re-numbering or re-naming blocks |
CRenameBoundaryGenerator | MeshGenerator for re-numbering or re-naming boundaries |
▶CReporter | Reporter objects allow for the declaration of arbitrary data types that are aggregate values for a simulation |
CReporterBroadcastContext | A context that broadcasts the Reporter value from the root processor |
CReporterContext | General context that is called by all Reporter values to manage the old values |
CReporterContextBase | This is a helper class to aid with parallel communication of compute Reporter values as well as provides a link to the stored Reporter value state object |
▶CReporterData | This is a helper class for managing the storage of declared Reporter object values |
CReporterDebugOutput | Produces debug output for displaying Reporter information |
CReporterGatherContext | A context that gathers the Reporter value to the root processor |
CReporterGeneralContext | |
CReporterInterface | Interface to allow object to consume Reporter values |
CReporterMode | MooseEnumItem that automatically creates the ID and doesn't allow the ID to be assigned |
CReporterName | The Reporter system is comprised of objects that can contain any number of data values |
CReporterPointMarker | Marks all elements as inside/empty if they do/don't contain a point |
CReporterPointSource | A ReporterPointSource DiracKernel is used to create variable valued point sources |
CReporterPositions | Positions from a Reporter |
CReporterProducerEnum | MooseEnum designed for the ReporterContext objects to define how a ReporterValue can and is being produced |
CReporterScatterContext | A context that scatters the Reporter value from the root processor |
CReporterState | A special version of RestartableData to aid in storing Reporter values |
CReporterStateBase | The base class for storing a Repoter's state |
CReporterTimes | Times from a Reporter |
CReporterTransferInterface | |
CReporterVectorContext | This context is specific for vector types of reporters, mainly for declaring a vector of the type from another context |
CResetDisplacedMeshThread | |
CResidual | |
CResidualObject | This is the common base class for objects that give residual contributions |
CResolveOptionalMaterialPropertiesAction | This action acts right after all material objects have been constructed |
▶CRestartable | A class for creating restricted objects |
CRestartableData | Concrete definition of a parameter value for a specified type |
CRestartableDataIO | Class for doing restart |
▶CRestartableDataMap | Storage for restartable data that is ordered based on insertion order |
▶CRestartableDataReader | Reader for restartable data written by the RestartableDataWriter |
▶CRestartableDataReporter | Reports restartable data and restartable meta data |
▶CRestartableDataValue | Abstract definition of a RestartableData value |
CRestartableDataWriter | Writer for restartable data, to be read by the RestartableDataReader |
▶CRestartableEquationSystems | Wrapper class that owns a libMesh EquationSystem and adds advanced restart capability to it |
CRinglebMesh | Mesh generated from parameters |
CRinglebMeshGenerator | Generates a mesh given all the parameters |
CSampler | This is the base class for Samplers as used within the Stochastic Tools module |
CSamplerBase | Base class for VectorPostprocessors that need to do "sampling" of values in the domain |
CSamplerInterface | Interface for objects that need to use samplers |
CScalarComponentIC | Initial condition to set different values on each component of scalar variable |
CScalarConstantIC | ScalarConstantIC just returns a constant value |
CScalarCoupleable | Interface for objects that needs scalar coupling capabilities |
CScalarInitialCondition | InitialConditions are objects that set the initial value of variables |
CScalarInitialConditionWarehouse | Warehouse for storing scalar initial conditions |
CScalarKernel | |
CScalarKernelBase | Base class shared by AD and non-AD scalar kernels |
CScalarL2Error | Postprocessor for computing the error in a scalar value relative to a known Function's value |
CScalarLagrangeMultiplier | This Kernel implements part of the equation that enforces the constraint of |
CScalarLMKernelTempl | This Kernel implements part of the equation that enforces the constraint of |
CScalarSolutionIC | Class for reading an initial condition from a solution user object |
CScalarTagMatrixAux | The value of a tagged matrix for a given node and a given variable is coupled to the current AuxVariable |
CScalarTagVectorAux | The value of a tagged vector for a given node and a given variable is coupled to the current AuxVariable |
CScalarVariable | |
CScalePostprocessor | Scale a postprocessor |
CSecantSolve | |
CSecondaryNeighborhoodThread | |
CSecondTimeDerivativeAux | Second time derivative of a variable |
CSerializerGuard | A scope guard that guarantees that whatever happens between when it gets created and when it is destroyed is done "serially" (each MPI rank will run in turn starting from 0) |
CSetAdaptivityOptionsAction | |
CSetupDampersAction | |
CSetupDebugAction | |
CSetupInterface | |
CSetupMeshAction | |
CSetupMeshCompleteAction | |
CSetupPreconditionerAction | Set the preconditioner up |
CSetupPredictorAction | Sets the predictor |
CSetupQuadratureAction | Sets the quadrature |
CSetupRecoverFileBaseAction | |
CSetupResidualDebugAction | |
CSetupTimeIntegratorAction | |
CSetupTimeStepperAction | Set up the final time stepper for the simulation |
CShapeElementUserObject | ElementUserObject class in which the _phi and _grad_phi shape function data is available and correctly initialized on EXEC_NONLINEAR (the Jacobian calculation) |
CShapeSideUserObject | SideUserObject class in which the _phi and _grad_phi shape function data is available and correctly initialized on EXEC_NONLINEAR (the Jacobian calculation) |
CShapeUserObject | UserObject template class in which the _phi and _grad_phi shape function data is available and correctly initialized on EXEC_NONLINEAR (the Jacobian calculation) |
CSideAdvectiveFluxIntegralTempl | This postprocessor computes a side integral of the mass flux |
CSideAverageMaterialPropertyTempl | Computes the average of a material property over a side set |
CSideAverageValue | This postprocessor computes a volume integral of the specified variable |
CSideDiffusiveFluxAverageTempl | |
CSideDiffusiveFluxIntegralTempl | This postprocessor computes a side integral of the mass flux |
CSideExtremeValue | A postprocessor for collecting the side min or max value |
CSideIntegralFunctorPostprocessorTempl | This postprocessor computes a surface integral of the specified functor |
CSideIntegralFunctorUserObject | Computes a side integral of the specified functor |
CSideIntegralMaterialPropertyTempl | Computes the integral of a material property over a side set |
CSideIntegralPostprocessor | This postprocessor computes a surface integral of the specified variable on a sideset on the boundary of the mesh |
CSideIntegralUserObject | This postprocessor computes a side integral of the specified variable over a given boundary |
CSideIntegralVariablePostprocessor | This postprocessor computes a surface integral of the specified variable |
CSideIntegralVariableUserObject | This postprocessor computes a volume integral of the specified variable |
CSidePostprocessor | Base class for postprocessors executed on one or more sidesets |
CSideSetExtruderGenerator | Extrude a sideset from a mesh in a given direction |
▶CSidesetInfoVectorPostprocessor | Computes and outputs information (area, centroid, bounding box) about sidesets |
CSideSetsAroundSubdomainGenerator | Adds the faces on the boundary of given block to the sidesets specified by "boundary" Optionally, only adds faces that have a normal equal to specified normal up to a tolerance |
CSideSetsBetweenSubdomainsGenerator | MeshGenerator that creates a sideset composed of the nodes located between two or more subdomains |
CSideSetsFromBoundingBoxGenerator | MeshGenerator for defining sidesets inside or outside of a bounding box |
CSideSetsFromNodeSetsGenerator | MeshGenerator for constructing side Sets from node sets |
CSideSetsFromNormalsGenerator | A mesh generator to generate new sidesets from all faces matching the normal |
CSideSetsFromPointsGenerator | A mesh generator to generate new sidesets from all faces connected to points with the same normal as the face the point is part of |
CSideSetsGeneratorBase | |
CSideUserObject | Base class for user objects executed one or more sidesets, which may be on the outer boundary of the mesh, or be internal to mesh, blocks etc |
CSideValueSampler | |
CSideVariablePostprocessor | |
CSideVectorPostprocessor | |
CSimplePredictor | A SimplePredictor uses an algorithm that will predict the next solution based on previous solutions |
CSimulationTimes | Times simulated, obtained from the problem |
CSinDirichletBC | A spatially-constant, time-varying NodalBC whose imposed value g(t) varies sinusoidally with time according to the formula: |
CSingleMatrixPreconditioner | Single matrix preconditioner |
CSingleRankPartitioner | Partitions a mesh to one MPI rank |
CSinNeumannBC | Implements a spatially-constant, time-varying flux boundary condition grad(u).n = g(t), where |
CSlepcEigenSolverConfiguration | |
CSmoothMeshGenerator | MeshGenerator for doing mesh smoothing |
CSolutionAux | AuxKernel for reading a solution from file |
CSolutionHistory | Based class for adding basic filename support to output base class |
CSolutionIC | Class for reading an initial condition from a solution user object |
CSolutionInvalidInterface | An interface that allows the marking of invalid solutions during a solve |
▶CSolutionInvalidity | The SolutionInvalidity will contain all the information about the occurrence(s) of solution invalidity |
CSolutionInvalidityReporter | Reports the summary table of solution invalid warnings |
CSolutionScalarAux | AuxScalarKernel for reading a solution from file |
CSolutionTimeAdaptiveDT | |
CSolutionUserObject | User object that reads an existing solution from an input file and uses it in the current simulation |
CSolveObject | |
CSolverParams | |
CSONDefinitionFormatter | This class produces a dump of the InputFileParameters in the Standard Object Notation (SON) format for use by the Hierarchical Input Validation Engine (HIVE) in the NEAMS Workbench |
CSpatialAverageBase | Base clase for computing spatial average of a variable over simple spatial regions of the computation domain |
CSpatialUserObjectAux | Function auxiliary value |
CSpatialUserObjectVectorPostprocessor | SpatialUserObjectVectorPostprocessor is a type of VectorPostprocessor that outputs the values of a spatial user object as a vector in the order of the provided points |
CSphereMeshGenerator | Create a sphere volume mesh |
CSphericalAverage | Compute a spherical average of a variable as a function of radius throughout the simulation domain |
CSphericalGridDivision | Divides the mesh based on a spherical grid |
CSpiralAnnularMesh | Mesh generated from parameters |
CSpiralAnnularMeshGenerator | Generates a spiral annular mesh given all the parameters |
CSplineFunction | Function that uses spline interpolation |
CSplineInterpolation | This class interpolates tabulated functions with cubic splines |
CSplineInterpolationBase | |
CSplit | Base class for split-based preconditioners |
CSplitMeshAction | |
CStackGenerator | Take several 3D meshes and stitch them on top of each other like a stack |
CSteady | Steady executioners usually only call "solve()" on the NonlinearSystem once |
CSteffensenSolve | |
CStitchBoundaryMeshGenerator | Allows a pair of boundaries to be "stitched" together |
CStitchedMesh | Reads an arbitrary set of meshes and attempts to "stitch" (join) them along boundaries |
CStitchedMeshGenerator | Allows multiple mesh files to be "stitched" together to form a single mesh |
CStorage | |
CStringInputStream | Helper class that hands out input streams to a stringstream |
CSubAppBackups | Helper class for holding Sub-app backups |
CSubdomainBoundingBoxGenerator | MeshGenerator for defining a Subdomain inside or outside of a bounding box |
CSubdomainIDGenerator | MeshGenerator for assigning a subdomain ID to all elements |
CSubdomainPerElementGenerator | MeshGenerator for assigning subdomain IDs of all elements |
CSubdomainsDivision | Divides the mesh based on the subdomains |
CSubProblem | Generic class for solving transient nonlinear problems |
CSwapBackSentinel | The "SwapBackSentinel" class's destructor guarantees that FEProblemBase::swapBackMaterials{Face,Neighbor}() is called even when an exception is thrown from FEProblemBase::reinitMaterials{Face,Neighbor} |
▶CSymmetricRankFourTensorTempl | SymmetricRankFourTensorTempl is designed to handle an N-dimensional fourth order tensor with minor symmetry, C |
CSymmetricRankTwoTensorTempl | SymmetricRankTwoTensorTempl is designed to handle the Stress or Strain Tensor for an anisotropic material |
CSymmetryTransformGenerator | |
▶CSyntax | Holding syntax for parsing input files |
CSyntaxFormatterInterface | This interface is for classes that want to be called to format InputParameters |
▶CSyntaxTree | |
CSystemBase | Base class for a system (of equations) |
CSystemInfo | |
CTableOutput | Base class for scalar variables and postprocessors output objects |
CTableValue | |
CTableValueBase | |
CTagAuxBase | The value of a tagged vector for a given node and a given variable is coupled to the current AuxVariable |
▶CTaggingInterface | |
CTagMatrixAux | For visualization or other purposes, the diagnal of the matrix of a tag is extracted, and nodal values are assigned by using the matrix diagnal values |
CTagVectorArrayVariableAux | Couple a tagged vector, and return its evaluations at degree of freedom indices corresponding to the coupled array variable |
CTagVectorArrayVariableValueAux | Couple a tagged vector, and return its array value |
CTagVectorAux | The value of a tagged vector for a given node and a given variable is coupled to the current AuxVariable |
CTagVectorSum | Computes the sum of components of the requested tagged vector |
CTecplot | Class for output data to the TecplotII format |
CTerminator | This Userobject requests termination of the current solve based on the values of Postprocessors (and a logical expression testing them) |
CTestSourceStepper | |
▶CTheWarehouse | TheWarehouse is a container for MooseObjects that allows querying/filtering over various customizeable attributes |
CThreadedElementLoop | Base class for assembly-like calculations |
CThreadedElementLoopBase | Base class for assembly-like calculations |
CThreadedFaceLoop | This loops over a set of mesh faces (i.e |
CThreadedGeneralUserObject | An instance of this object type has one copy per thread that runs on each thread |
CThreadedNodeLoop | |
CThreadedRadialAverageLoop | RadialAverage threaded loop |
CThreeMaterialPropertyInterface | This interface is designed currently for DomainUserObject where material properties on element, face and neighboring face may all required |
CThresholdElementSubdomainModifier | |
CTiedValueConstraint | A TiedValueConstraint forces the value of a variable to be the same on both sides of an interface |
CTiledMesh | |
CTiledMeshGenerator | Take an input mesh and repeat it in the x,y and z directions |
CTimeDerivative | |
CTimeDerivativeAux | Time derivative of a functor, which can be a variable, function, functor material property |
CTimeDerivativeNodalKernel | Represents du/dt |
CTimedPrint | Dummy TimedPrint Class - use TIME_SECTION instead |
CTimeExtremeValue | A postprocessor for reporting the max/min value of another postprocessor over time |
CTimeIntegratedPostprocessor | Integrate a post-processor value over time using trapezoidal rule |
CTimeIntegrator | Base class for time integrators |
CTimeIntervalTimes | Times between a start time and end time with a fixed time interval |
CTimeKernel | All time kernels should inherit from this class |
CTimeNodalKernel | Represents a simple ODE of du/dt - rate = 0 |
CTimePeriod | A basic control for disabling objects for a portion of the simulation |
CTimePeriodBase | Base class for basic control for disabling objects for a portion of the simulation |
CTimePostprocessor | Postprocessor that returns the current time |
CTimes | Times objects are under the hood Reporters, but limited to a vector of Real |
CTimeSequenceFromTimes | Time sequence stepper that gets its sequence of times to hit from a times object |
CTimeSequenceStepper | Solves the PDEs at a sequence of time points given as a vector in the input file |
CTimeSequenceStepperBase | Solves the PDEs at a sequence of given time points |
CTimeStepper | Base class for time stepping |
CTimestepSize | |
CTopResidualDebugOutput | A class for producing various debug related outputs |
CTopResidualDebugOutputTopResidualData | A structure for storing data related to top residuals |
CTransfer | Base class for all Transfer objects |
CTransfiniteMeshGenerator | Generates an quadrilateral given all the parameters |
CTransformedPositions | Positions transformed using a simple operation (translation, rotation, scaling) |
CTransformGenerator | |
CTransient | Transient executioners usually loop through a number of timesteps.. |
CTransientInterface | Interface for objects that needs transient capabilities |
CTransientMultiApp | MultiApp Implementation for Transient Apps |
CTrilinearInterpolation | This class interpolates a function of three values (f(x,y,z)) |
CTwoMaterialPropertyInterface | This interface is designed for DGKernel, InternalSideUserObject, InterfaceUserObject, where material properties on a side of both its primary side (face) and its secondary side (neighbor) all required |
CUniformMarker | |
CUniqueExtraIDMeshGenerator | Add a new extra ID by finding unique combinations of existing extra ID values |
▶CUniqueStorage | Storage container that stores a vector of unique pointers of T, but represents most of the public facing accessors (iterators, operator[]) as a vector of T |
CUnitsConversionEvaler | |
CUpdateDisplacedMeshThread | |
CUpdateErrorVectorsThread | |
CUpperBoundNodalKernel | Class used to enforce a upper bound on a coupled variable |
CUserForcingFunction | Deprecated, use BodyForce |
CUserForcingFunctionNodalKernel | Represents the rate in a simple ODE of du/dt = f |
CUserObject | Base class for user-specific data |
CUserObjectInterface | Interface for objects that need to use UserObjects |
CVacuumBC | Implements a simple Vacuum BC for neutron diffusion on the boundary |
CValueCache | ValueCache is a generic helper template to implement an unstructured data cache, where arbitrary result types can be placed in an n-dimensional space of real numbers |
CValueJumpIndicator | |
CValueRangeMarker | |
CValueThresholdMarker | |
CVarCopyInfo | Information about variables that will be copied |
CVariableCondensationPreconditioner | Interface for condensing out LMs for the dual mortar approach |
CVariableGradientComponent | Extract a component from the gradient of a variable |
CVariableInnerProduct | |
CVariableOldValueBounds | Provides a bound of a variable using its old value |
CVariableResidual | |
CVariableResidualNormsDebugOutput | A class for producing various debug related outputs |
CVariableTimeIntegrationAux | An AuxKernel that can be used to integrate a field variable in time using a variety of different integration methods |
CVariableValueVolumeHistogram | Compute a histogram of volume fractions binned according to variable values |
CVariableWarehouse | Holds variables and provides some services |
CVariadicTable | A class for "pretty printing" a table of data |
CVecStore | |
CVectorBodyForce | This kernel implements a generic functional body force term: $ - c {f} {} $ |
CVectorConstantIC | VectorConstantIC just returns a constant value |
CVectorConstantPointSource | A VectorConstantPointSource DiracKernel is used to add a constant source term at a point |
CVectorCoupledTimeDerivative | This calculates the time derivative for a coupled vector variable |
CVectorCurlPenaltyDirichletBC | Enforces a Dirichlet boundary condition for the curl of vector nonlinear variables in a weak sense by applying a penalty to the difference in the current solution and the Dirichlet data |
CVectorDiffusion | This kernel implements the Laplacian operator: $ {u} {}$ |
CVectorDirichletBC | Boundary condition of a Dirichlet type |
CVectorDivPenaltyDirichletBC | Enforces a Dirichlet boundary condition for the divergence of vector nonlinear variables in a weak sense by applying a penalty to the difference between the current solution and the Dirichlet data |
CVectorFromComponentVariablesMaterialTempl | Computes a vector material property from coupled variables |
CVectorFunctionAux | Function auxiliary value |
CVectorFunctionDirichletBC | Boundary condition of a Dirichlet type |
CVectorFunctionIC | IC that calls vectorValue method of a Function object |
CVectorFunctionReaction | Kernel representing the contribution of the PDE term $fu$, where $f$ is a function coefficient and $u$ is a vector variable |
CVectorIntegratedBC | Base class for deriving any boundary condition of a integrated type |
CVectorKernel | |
CVectorMagnitudeAux | Computes the magnitude of a vector whose components are given by up to three coupled variables |
CVectorMagnitudeFunctorMaterialTempl | This class takes up to three functors corresponding to vector components and computes the Euclidean norm from them |
CVectorMaterialRealVectorValueAuxTempl | AuxKernel for outputting a RealVectorValue material property component to a vector AuxVariable |
CVectorMemoryUsage | Generate a table of various memory metrics indexed by MPI rank |
CVectorNeumannBC | Implements a flux boundary condition grad(u).n = V.n, where the vector V is specifed by the user |
CVectorNodalBC | Base class for deriving any boundary condition that works at nodes on vector variables |
CVectorOfPostprocessors | VectorOfPostprocessors is a type of VectorPostprocessor that outputs the values of an arbitrary user-specified set of postprocessors as a vector in the order specified by the user |
CVectorPenaltyDirichletBC | Enforces a Dirichlet boundary condition for vector nonlinear variables in a weak sense by applying a penalty to the difference in the current solution and the Dirichlet data |
CVectorPostprocessor | Base class for Postprocessors that produce a vector of values |
CVectorPostprocessorComparison | Compares two vector post-processors of equal size and produces a boolean value |
CVectorPostprocessorComponent | |
CVectorPostprocessorContext | |
CVectorPostprocessorInterface | |
CVectorPostprocessorReductionValue | |
CVectorPostprocessorReporterName | A ReporterName that represents a VectorPostprocessor |
CVectorPostprocessorVisualizationAux | Read values from a VectorPostprocessor that is producing vectors that are "number of processors" in length |
CVectorTag | Storage for all of the information pretaining to a vector tag |
CVectorTimeDerivative | |
CVectorTimeKernel | All vector time kernels should inherit from this class |
CVectorVariableComponentAux | Extract a component from a vector variable |
CVectorVariableMagnitudeAux | Compute the magnitude of a vector variable |
CVerifyElementUniqueID | |
CVerifyNodalUniqueID | |
CVolumeAux | AuxKernel that samples element volumes |
CVolumePostprocessor | This postprocessor computes the volume of a specified block |
CVTKOutput | |
CWeakGradientBC | A FluxBC which is consistent with the boundary terms arising from the Diffusion Kernel |
CWeightedGapAux | Compute a weighted gap based on a mortar discretization |
CWorkBalance | Compute several metrics for each MPI process |
CXDA | Class for output data to the XDAII format |
CXFEMInterface | This is the XFEMInterface class |
CXMLOutput | |
CXYDelaunayGenerator | Generates a triangulation in the XY plane, based on an input mesh defining the outer boundary (as well as explicitly required interior Steiner points) and an optional set of input meshes defining inner hole boundaries |
CXYMeshLineCutter | This XYMeshLineCutter object is designed to trim the input mesh by removing all the elements on one side of a given straight line with special processing on the elements crossed by the cutting line to ensure a smooth cross-section |
CYAMLFormatter | This class produces produces a yaml dump of the InputParameters that is machine parsable by any YAML formatter |