www.mooseframework.org
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
 NlibMeshThe following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings
 Nmoose
 NMoose
 NMooseUtils
 CAB2PredictorCorrectorA TimeStepper based on the AB2 method
 CActionBase class for actions
 CActionFactorySpecialized factory for generic Action System objects
 CActionWarehouseStorage for action instances
 CAdamsPredictorImplements an explicit Adams predictor based on two old solution vectors
 CAdaptivityTakes care of everything related to mesh adaptivity
 CAdaptivityAction
 CAddAllSideSetsByNormalsThis class will add sidesets to the entire mesh based on unique normals
 CAddAuxVariableActionAction for creating Auxiliary variables
 CAddBCAction
 CAddBoundsVectorsAction
 CAddConstraintAction
 CAddControlActionAction for creating Control objects
 CAddDamperAction
 CAddDGKernelAction
 CAddDiracKernelAction
 CAddDistributionActionThis class adds a distribution object
 CAddElementalFieldAction
 CAddExtraNodeset
 CAddFieldSplitAction
 CAddFunctionActionThis class parses functions in the [Functions] block and creates them
 CAddICAction
 CAddIndicatorAction
 CAddInitialConditionAction
 CAddInterfaceKernelAction
 CAddKernelAction
 CAddMarkerAction
 CAddMaterialAction
 CAddMeshModifierAction
 CAddMortarInterfaceAction
 CAddMultiAppAction
 CAddNodalKernelAction
 CAddNodalNormalsActionAction to setup computation of nodal normals
 CAddOutputActionAction for creating output objects
 CAddPeriodicBCActionThis Action adds a periodic boundary to the problem
 CAddPostprocessorAction
 CAddSamplerActionThis class adds a Sampler object
 CAddScalarKernelAction
 CAddSideSetsBase
 CAddSideSetsFromBoundingBoxMeshModifier for defining a Subdomain inside or outside of a bounding box
 CAddTransferAction
 CAddUserObjectAction
 CAddVariableActionAdds nonlinear variable
 CAddVectorPostprocessorAction
 CAdvancedOutputBased class for output objects
 CAllLocalDofIndicesThreadGrab all the local dof indices for the variables passed in, in the system passed in
 CAllNodesSendListThread
 CAnalyticalIndicator
 CAnisotropicDiffusionThis kernel implements the Laplacian operator multiplied by a 2nd order tensor giving anisotropic (direction specific) diffusion: $ K u $
 CAnnularMeshMesh generated from parameters
 CAppFactoryGeneric AppFactory class for building Application objects
 CArbitraryQuadratureImplements a fake quadrature rule where you can specify the locations (in the reference domain) of the quadrature points
 CAreaPostprocessorThis postprocessor computes the area of a specified block
 CAssemblyKeeps track of stuff related to assembling
 CAssignElementSubdomainIDMeshModifier for assigning subdomain IDs of all elements
 CAssignSubdomainIDMeshModifier for assigning a subdomain ID to all elements
 CAStableDirk4Fourth-order diagonally implicit Runge Kutta method (Dirk) with three stages plus an update
 CAutoPositionsMultiAppAutomatically generates Sub-App positions from positions in the master app's mesh
 CAuxGroupExecuteMooseObjectWarehouseGeneral warehouse for storing MooseObjects based on relation to IC and AuxKernel execution
 CAuxiliarySystemA system that holds auxiliary variables
 CAuxKernelBase class for creating new auxiliary kernels and auxiliary boundary conditions
 CAuxNodalScalarKernel
 CAuxScalarKernelBase class for making kernels that work on auxiliary scalar variables
 CAverageElementSizeThis postprocessor computes an average element size (h) for the whole domain
 CAverageNodalVariableValue
 CAxisymmetric2D3DSolutionFunctionFunction for reading a 2D axisymmetric solution from file and mapping it to a 3D Cartesian system
 CAxisymmetricCenterlineAverageValueThis postprocessor computes a line integral of the specified variable along the centerline of an axisymmetric domain
 CBackupHelper class to hold streams for Backup and Restore operations
 CBadActiveWalker
 CBDF2BDF2 time integrator
 CBicubicSplineFunctionFunction that uses spline interpolation
 CBicubicSplineInterpolationThis class interpolates tabulated functions with a bi-cubic spline
 CBilinearInterpolationThis class applies the Least Squares algorithm to a set of points to provide a smooth curve for sampling values
 CBlockDeleter
 CBlockRestrictableAn interface that restricts an object to subdomains via the 'blocks' input parameter
 CBndElement
 CBndNode
 CBndNodeCompareHelper class for sorting Boundary Nodes so that we always get the same order of application for boundary conditions
 CBodyForceThis kernel implements a generic functional body force term: $ - c f $
 CBoundaryConditionBase class for creating new types of boundary conditions
 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
 CBoundaryRestrictableRequiredA class for requiring an object to be boundary restricted
 CBoundingBoxICBoundingBoxIC allows setting the initial condition of a value inside and outside of a specified box
 CBoundingBoxNodeSetSelects a set of nodes and assigns a nodeset name to them based on the bounding box specified
 CBoundingValueElementDamperThis class implements a damper that limits the value of a variable to be within user-specified bounds
 CBoundingValueNodalDamperThis class implements a damper that limits the value of a variable to be within user-specified bounds
 CBoundsAuxFills in the "bounds vectors" to provide an upper and lower bound for the variable that is coupled in
 CBoxMarker
 CBreakBoundaryOnSubdomain
 CCacheChangedListsThread
 CChangeOverTimestepPostprocessorComputes the change in a post-processor value, or the magnitude of its relative change, over a time step
 CCheckIntegrityAction
 CCheckOutputActionAction for checking that "outputs" is properly populated for Materials
 CCheckpoint
 CCheckpointFileNamesA structure for storing the various output files associated with checkpoint output
 CColumnMajorMatrixThis class defines a Tensor that can change its shape
 CComboMarker
 CCommandLineThis class wraps provides and tracks access to command line parameters
 CCommonOutputActionMeta-action for creating common output object parameters This action serves two purpose, first it adds common output object parameters
 CCompositeFunctionBase class for function objects
 CCompositeTensorBaseCompositeTensorBase 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 \)
 CComputeBoundaryInitialConditionThread
 CComputeDiracThread
 CComputeElemAuxBcsThread
 CComputeElemAuxVarsThread
 CComputeElemDampingThread
 CComputeFullJacobianThread
 CComputeIndicatorThread
 CComputeInitialConditionThread
 CComputeJacobianBlocksThreadSpecialization for filling multiple "small" preconditioning matrices simulatenously
 CComputeJacobianThread
 CComputeMarkerThread
 CComputeMaterialsObjectThread
 CComputeNodalAuxBcsThread
 CComputeNodalAuxVarsThread
 CComputeNodalDampingThread
 CComputeNodalKernelBCJacobiansThread
 CComputeNodalKernelBcsThread
 CComputeNodalKernelJacobiansThread
 CComputeNodalKernelsThread
 CComputeNodalUserObjectsThread
 CComputeResidualThread
 CComputeUserObjectsThreadClass for threaded computation of UserObjects
 CConservativeAdvection
 CConsoleAn output object for writing to the console (screen)
 CConsoleStreamA helper class for re-directing output streams to Console output objects form MooseObjects
 CConsoleStreamInterfaceAn inteface for the _console for outputting to the Console object
 CConstantAuxConstant auxiliary value
 CConstantDamperSimple constant damper
 CConstantDT
 CConstantFunctionClass that represents constant function
 CConstantICConstantIC just returns a constant value
 CConstantPointSourceTOOD
 CConstantRateRepresents the rate in a simple ODE of du/dt = rate
 CConstantScalarAuxSets a constant value on a scalar variable
 CConstantVectorPostprocessor
 CConstraintBase class for all Constraint types
 CConstraintWarehouseWarehouse for storing constraints
 CControlBase class for Control objects
 CControllableParameterA class for accessing controllable InputParameters
 CControlOutputClass for output information regarding Controls to the screen
 CConvectiveFluxBC
 CCopyNodalVarsAction
 CCoupleableInterface for objects that needs coupling capabilities
 CCoupleableMooseVariableDependencyIntermediateInterfaceIntermediate base class that ties together all the interfaces for getting MooseVariables with the MooseVariableDependencyInterface
 CCoupledForceSimple class to demonstrate off diagonal Jacobian contributions
 CCoupledODETimeDerivative
 CCoupledTiedValueConstraintA CoupledTiedValueConstraint forces the value of a variable to be the same on both sides of an interface
 CCoupledTimeDerivativeThis calculates the time derivative for a coupled variable
 CCrankNicolsonCrank-Nicolson time integrator
 CCreateDisplacedProblemAction
 CCreateExecutionerAction
 CCreateProblemAction
 CCSVBased class for adding basic filename support to output base class
 CCSVReader
 CCSVTimeSequenceStepperSolves the PDEs at a sequence of time points given as a column in a text table file (such as a *.csv file)
 CCumulativeValuePostprocessorCreates a cumulative sum of a post-processor value over a transient
 CCyclicDependencyException
 CDamperBase class for deriving dampers
 CDebugResidualAuxAuxiliary kernel for debugging convergence
 CDependencyResolver
 CDependencyResolverComparator
 CDependencyResolverInterfaceInterface for sorting dependent vectors of objects
 CDeprecatedBlockActionUsed for marking that some block are deprecated and not be used
 CDerivativeMaterialInterfaceInterface class ("Veneer") to provide generator methods for derivative material property names
 CDerivativeMaterialPropertyNameInterface
 CDetermineSystemType
 CDGConvection
 CDGDiffusionDG kernel for diffusion
 CDGFunctionDiffusionDirichletBCImplements a simple BC for DG
 CDGKernelResponsible for calculating the residuals for various physics on internal sides (edges/faces)
 CDifferencePostprocessorComputes the difference between two postprocessors
 CDiffusionThis kernel implements the Laplacian operator: $ u $
 CDiffusionFluxAuxAuxiliary kernel responsible for computing the components of the flux vector in diffusion problems
 CDiffusionFluxBCA FluxBC which is consistent with the boundary terms arising from the Diffusion Kernel
 CDiracKernelA 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
 CDiracKernelInfoThe DiracKernelInfo object is a place where all the Dirac points added by different DiracKernels are collected
 CDirichletBCBoundary condition of a Dirichlet type
 CDiscreteElementUserObject
 CDisplacedProblem
 CDisplacedSystem
 CDistributionAll Distributions should inherit from this class
 CDistributionInterfaceInterface for objects that need to use distributions
 CDM_Moose
 CDOFMapOutputAn output object for writing the DOF map of the system in a machine parsable format
 CDT2An adaptive timestepper that compares the solution obtained from a single step of size dt with two steps of size dt/2 and adjusts the next timestep accordingly
 CDTKInterpolationAdapter
 CDupParamWalker
 CDynamicObjectRegistrationAction
 CEigenExecutionerBaseThis class provides reusable routines for eigenvalue executioners
 CEigenKernelThe 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
 CEigenProblemSpecialization of SubProblem for solving nonlinear equations plus auxiliary equations
 CEigenvalue
 CEigenvalues
 CElemElemConstraint
 CElementalVariableValue
 CElementAverageTimeDerivativeThis postprocessor computes a volume integral of the time derivative of a given variable
 CElementAverageValueThis postprocessor computes a volume integral of the specified variable
 CElementDamperBase class for deriving element dampers
 CElementDeleterBaseThis class deletes elements from the mesh data structure after it has been generated or read but before any FEM data structures are initialized
 CElementExtremeValueA postprocessor for collecting the nodal min or max value
 CElementH1ErrorThis 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:
 CElementH1ErrorFunctionAuxA 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
 CElementH1SemiErrorThis postprocessor will print out the h1 seminorm between the computed solution and the passed function
 CElementIndicator
 CElementIntegralIndicator
 CElementIntegralMaterialProperty
 CElementIntegralPostprocessorThis postprocessor computes a volume integral of the specified variable
 CElementIntegralUserObjectThis postprocessor computes a volume integral of the specified variable
 CElementIntegralVariablePostprocessorThis postprocessor computes a volume integral of the specified variable
 CElementIntegralVariableUserObjectThis postprocessor computes a volume integral of the specified variable
 CElementL2DifferenceComputes the L2-Norm difference between two solution fields
 CElementL2Error
 CElementL2ErrorFunctionAuxA 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
 CElementL2Norm
 CElementLengthAuxComputes the min or max of element length
 CElementLpNormAuxCompute an elemental field variable (single value per element) equal to the Lp-norm of a coupled Variable
 CElementPairInfoThis is the ElementPairInfo class
 CElementPairLocatorThis is the ElementPairLocator class
 CElementPostprocessor
 CElementsAlongLineGet all of the elements that are intersected by a line
 CElementsAlongPlaneGet all of the elements that are intersected by a plane
 CElementUserObject
 CElementVariablePostprocessor
 CElementVariablesDifferenceMaxFinds the largest difference between two variable fields
 CElementVectorL2Error
 CElementVectorPostprocessor
 CElementW1pErrorThis postprocessor computes the Sobolev norm W^{1,p} of the difference between the computed solution and the passed in function
 CEmptyActionDo nothing action
 CEmptyPostprocessor
 CEqualGradientConstraintConstrain a specified component of the gradient of a variable to be the same on both sides of an interface
 CEqualValueBoundaryConstraint
 CEqualValueConstraintConstrain the value of a variable to be the same on both sides of an interface
 CErrorFractionMarker
 CErrorToleranceMarker
 CExecStoreThe class for storing warehouses that holds objects that are being evaluated at different times
 CExecuteMooseObjectWarehouseA class for storing MooseObjects based on execution flag
 CExecutionerExecutioners are objects that do the actual work of solving your problem
 CExecutionerAttributeReporterA class to report class attributes value from Executioners
 CExodusClass for output data to the ExodusII format
 CExodusFormatter
 CExodusTimeSequenceStepperSolves the PDEs at a sequence of time points given as a vector in the input file
 CExpandWalker
 CExplicitEulerExplicit Euler time integrator
 CExplicitMidpointThe explicit midpoint time integration method
 CExplicitRK2Base class for three different explicit second-order Runge-Kutta time integration methods:
 CExplicitTVDRK2Explicit TVD (total-variation-diminishing) second-order Runge-Kutta time integration methods:
 CFaceFaceConstraintUser for mortar methods
 CFactoryGeneric factory class for build all sorts of objects
 CFDKernel
 CFEProblemSpecialization of SubProblem for solving nonlinear equations plus auxiliary equations
 CFEProblemBaseSpecialization of SubProblem for solving nonlinear equations plus auxiliary equations
 CFieldSplitPreconditionerImplements a preconditioner designed to map onto PETSc's PCFieldSplit
 CFileLineInfoHolds file and line information
 CFileLineInfoMapA mapping between a series of keys to a FileLineInfo
 CFileMesh
 CFileOutputAn outputter with filename support
 CFileRangeBuilderAugments an InputParameters object with file range information
 CFindValueOnLineFind a specific target value along a sampling line
 CFiniteDifferencePreconditionerFinite difference preconditioner
 CFlagElementsThread
 CFluxBCBoundary condition of a flux type \( <\vec q * \vec n, v> \)
 CFormattedTableThis class is used for building, formatting, and outputting tables of numbers
 CFullSolveMultiAppThis type of MultiApp will completely solve itself the first time it is asked to take a step
 CFunctionBase class for function objects
 CFunctionAuxFunction auxiliary value
 CFunctionDiracSource
 CFunctionDirichletBCDefines a boundary condition that forces the value to be a user specified function at the boundary
 CFunctionDT
 CFunctionICDefines a boundary condition that forces the value to be a user specified function at the boundary
 CFunctionInterfaceInterface for objects that need to use functions
 CFunctionNeumannBCBoundary condition of a Neumann style whose value is computed by a user-defined function
 CFunctionParserBase
 CFunctionParserUtils
 CFunctionPenaltyDirichletBCA different approach to applying Dirichlet BCs
 CFunctionPeriodicBoundaryPeriodic boundary for calculation periodic BC on domains where the translation is given by functions
 CFunctionPresetBCDefines a boundary condition that forces the value to be a user specified function at the boundary
 CFunctionScalarAuxSets a value of a scalar variable based on the function
 CFunctionScalarIC
 CFunctionSideIntegralThis postprocessor computes the integral of a function over a specified boundary
 CFunctionValuePostprocessorThis postprocessor displays a single value which is supplied by a MooseFunction
 CGapValueAux
 CGeneralDamperBase class for deriving general dampers
 CGeneralPostprocessorThis class is here to combine the Postprocessor interface and the base class Postprocessor object along with adding MooseObject to the inheritance tree
 CGeneralUserObject
 CGeneralVectorPostprocessorThis class is here to combine the VectorPostprocessor interface and the base class VectorPostprocessor object along with adding MooseObject to the inheritance tree
 CGeneratedMeshMesh generated from parameters
 CGenericConstantMaterialThis 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
 CGenericConstantRankTwoTensorDeclares a constant material property of type RankTwoTensor
 CGenericFunctionMaterialThis 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
 CGeometricSearchData
 CGeometricSearchInterface
 CGeometryBaseBase class for userobjects that snap nodes to a defined geometry when adaptivity happens
 CGeometrySphereSnaps the selected nodes to the surface of a sphere (or circular disk in 2D)
 CGlobalParamsAction
 CGMVOutputClass for output data to the GMVOutputII format
 CGnuplotBased class for adding basic filename support to output base class
 CGradientJumpIndicator
 CGriddedDataContainer for holding a function defined on a grid of arbitrary dimension
 CHashMapHashMap is an abstraction for dictionary data type, we make it thread-safe by locking inserts
 CHeunHeun's (aka improved Euler) time integration method
 CImageFunctionA function for extracting data from an image or stack of images
 CImageMeshA 2D GeneratedMesh where xmin, xmax, etc
 CImageSamplerA helper class for reading and sampling images using VTK
 CImageSubdomainMeshModifier for defining a Subdomains based on Image data
 CImplicitEulerImplicit Euler's method
 CImplicitMidpointSecond-order Runge-Kutta (implicit midpoint) time integration
 CIndicator
 CIndicatorMarker
 Cinfix_ostream_iterator
 CInitialConditionInitialConditions are objects that set the initial value of variables
 CInitialConditionWarehouseWarehouse for storing initial conditions
 CInitProblemAction
 CInputFileFormatterThis class produces produces a dump of the InputFileParameters that appears like the normal input file syntax
 CInputParametersThe main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system
 CInputParameterWarehouseStorage container for all InputParamter objects
 CIntegratedBCBase class for deriving any boundary condition of a integrated type
 CInterfaceKernelInterfaceKernel is responsible for interfacing physics across subdomains
 CInternalSideIndicatorResponsible for calculating the residuals for various physics on internal sides (edges/faces)
 CInternalSidePostprocessor
 CInternalSideUserObject
 CInternalSideVectorPostprocessor
 CIntersectionPointsAlongLineGet the intersection points for all of the elements that are intersected by a line
 CInversePowerMethod
 CIterationAdaptiveDTAdjust the timestep based on the number of iterations
 CJacobianBlockHelper class for holding the preconditioning blocks to fill
 CJsonInputFileFormatterThis class produces produces a dump of the InputFileParameters that appears like the normal input file syntax
 CJsonSyntaxTreeHolds the syntax in a Json::Value tree
 CJvarMapIntegratedBCInterfaceInterface class ("Veneer") for IntegratedBC to provide a mapping from 'jvar' in computeJacobianBlock into the _coupled_moose_vars array
 CJvarMapInterfaceBaseBase class ("Veneer") that implements the actual mapping from 'jvar' in into the _coupled_moose_vars array
 CJvarMapKernelInterfaceInterface class ("Veneer") for Kernel to provide a mapping from 'jvar' in computeQpOffDiagJacobian into the _coupled_moose_vars array
 CKDTree
 CKernel
 CKernelBaseThis is the common base class for the two main kernel types implemented in MOOSE, EigenKernel and Kernel
 CKernelGradResponsible for calculating the residuals in form:
 CKernelValueResponsible for calculating the residuals in form:
 CKernelWarehouseHolds kernels and provides some services
 CLaplacianJumpIndicator
 CLayeredAverageThis UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z)
 CLayeredBaseThis UserObject computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z)
 CLayeredIntegralThis UserObject computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z).c
 CLayeredSideAverageThis UserObject computes side averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z).c
 CLayeredSideFluxAverageThis UserObject computes side averages of a flux storing partial sums for the specified number of intervals in a direction (x,y,z)
 CLayeredSideIntegralThis UserObject computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z)
 CLeastSquaresFitLeastSquaresFit is a VectorPostprocessor that performs a least squares fit on data calculated in another VectorPostprocessor
 CLibmeshPartitioner
 CLinearCombinationFunctionSum_over_i (w_i * functions_i)
 CLinearCombinationPostprocessorComputes a linear combination between an arbitrary number of post-processors
 CLinearInterpolationThis class interpolates values given a set of data pairs and an abscissa
 CLinearNodalConstraintThe slave node variable is programmed as a linear combination of the master node variables (i.e, slave_var = a_1*master_var_1+ a_2*master_var_2+..
 CLineFunctionSampler
 CLineMaterialRealSamplerThis class samples Real material properties for the integration points in all elements that are intersected by a user-defined line
 CLineMaterialSamplerBaseThis is a base class for sampling material properties for the integration points in all elements that are intersected by a user-defined line
 CLineSegmentUsed by the LineMaterialSamplerBase class and for some ray tracing stuff
 CLineValueSampler
 CLockFileGets an exclusive lock on a file
 CLogConstantDTSimple time-stepper which imposes a time step constant in the logarithmic space
 CLStableDirk2Second order diagonally implicit Runge Kutta method (Dirk) with two stages
 CLStableDirk3Third order diagonally implicit Runge Kutta method (Dirk) with three stages
 CLStableDirk4Fourth-order diagonally implicit Runge Kutta method (Dirk) with five stages
 CMarker
 CMassEigenKernel
 CMassLumpedTimeDerivative
 CMatchedValueBCImplements a simple coupled boundary condition where u=v on the boundary
 CMaterialMaterials compute MaterialProperties
 CMaterialAuxBaseA base class for the various Material related AuxKernal objects
 CMaterialDataProxy for accessing MaterialPropertyStorage
 CMaterialDerivativeRankFourTestKernelThis kernel is used for testing derivatives of a material property
 CMaterialDerivativeRankTwoTestKernelThis kernel is used for testing derivatives of a material property
 CMaterialDerivativeTestActionSets up variables and Kernels to test the derivatives of material properties via the Jacobian checker
 CMaterialDerivativeTestKernelThis kernel is used for testing derivatives of a material property
 CMaterialDerivativeTestKernelBaseThis kernel is used for testing derivatives of a material property
 CMaterialOutputActionCreates AuxVariables and AuxKernels for automatic output of material properties
 CMaterialPropertiesContainer for storing material properties
 CMaterialPropertyConcrete definition of a parameter value for a specified type
 CMaterialPropertyDebugOutputA class for producing various debug related outputs
 CMaterialPropertyInterfaceAn interface for accessing Materials
 CMaterialPropertyStorageStores the stateful material properties computed by materials
 CMaterialRealAuxObject for passing a scalar, REAL material property to an AuxVariable
 CMaterialRealDenseMatrixAuxAuxKernel for outputting a DenseMatrix<Real> material property component to an AuxVariable
 CMaterialRealTensorValueAuxAuxKernel for outputting a RealTensorValue material property component to an AuxVariable
 CMaterialRealVectorValueAuxAuxKernel for outputting a RealVectorValue material property component to an AuxVariable
 CMaterialStdVectorAuxAuxKernel for outputting a std::vector material-property component to an AuxVariable
 CMaterialStdVectorAuxBaseA base class for the various Material related AuxKernal objects
 CMaterialStdVectorRealGradientAuxAuxKernel for outputting a std::vector material-property component to an AuxVariable
 CMaterialVectorPostprocessorThis postprocessor records all scalar material properties of the specified material object on specified elements at the indicated execution points (e.g
 CMaterialWarehouseMaterial objects are special in that they have additional objects created automatically (see FEProblemBase::addMaterial)
 CMaxIncrementTODO
 CMaxQpsThreadThis 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
 CMemoryUsageOutput maximum, average, or total process memory usage
 CMeshChangedInterfaceInterface for notifications that the mesh has changed
 CMeshExtruder
 CMeshModifierMeshModifiers are objects that can modify or add to an existing mesh
 CMeshSideSetAdd lower dimensional elements along the faces contained in a side set
 CMonotoneCubicInterpolationThis class interpolates values given a set of data pairs and an abscissa
 CMooseAppBase class for MOOSE-based applications
 CMooseArray
 CMooseEigenSystem
 CMooseEnumThis 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
 CMooseEnumBaseThe base class for both the MooseEnum and MultiMooseEnum classes
 CMooseEnumItemClass for containing MooseEnum item information
 CMooseExceptionProvides a way for users to bail out of the current solve
 CMooseInitInitialization object for any MOOSE-based application
 CMooseMeshMooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and storing more state
 CMooseObjectEvery object that can be built by the factory should be derived from this class
 CMooseObjectAction
 CMooseObjectNameA class for storing the names of MooseObject by tag and object name
 CMooseObjectParameterNameA class for storing an input parameter name
 CMooseObjectWarehouseA storage container for MooseObjects that inherit from SetupInterface
 CMooseObjectWarehouseBaseA base storage container for MooseObjects
 CMooseParsedFunctionThis class is used to evaluate symbolic equations passed in to Moose through the input file
 CMooseParsedFunctionBaseAdds user facing parameters for parsed function
 CMooseParsedFunctionWrapperA wrapper class for creating and evaluating parsed functions via the libMesh::ParsedFunction interface for fparser
 CMooseParsedGradFunctionThis class is similar to ParsedFunction except it also supports returning the gradient of the function
 CMooseParsedVectorFunctionThis class is similar to ParsedFunction except it returns a vector function
 CMoosePartitionerBase class for MOOSE partitioner
 CMoosePreconditionerBase class for MOOSE preconditioners
 CMooseRandomThis class encapsulates a useful, consistent, cross-platform random number generator with multiple utilities
 CMooseVariableClass for stuff related to variables
 CMooseVariableBase
 CMooseVariableConstMonomial
 CMooseVariableDependencyInterface
 CMooseVariableInterfaceInterface for objects that need to get values of MooseVariables
 CMooseVariableScalarClass for scalar variables (they are different)
 CMultiAppA MultiApp represents one or more MOOSE applications that are running simultaneously
 CMultiAppCopyTransferCopy the value to the target domain from the nearest node in the source domain
 CMultiAppDTKInterpolationTransferTransfers from spatially varying Interpolations in a MultiApp to the "master" system
 CMultiAppDTKUserObjectEvaluatorEvaluates the specified UserObject and returns the result in a DTK FieldContainer
 CMultiAppDTKUserObjectTransferTransfers from spatially varying UserObjects in a MultiApp to the "master" system
 CMultiAppInterpolationTransferCopy the value to the target domain from the nearest node in the source domain
 CMultiAppMeshFunctionTransferTransfers a vector of variables
 CMultiAppNearestNodeTransferCopy the value to the target domain from the nearest node in the source domain
 CMultiAppPostprocessorInterpolationTransferTransfers from spatially varying PostprocessorInterpolations in a MultiApp to the "master" system
 CMultiAppPostprocessorToAuxScalarTransferCopies the value of a Postprocessor from one app to a scalar AuxVariable in another
 CMultiAppPostprocessorTransferCopies the value of a Postprocessor from the Master to a MultiApp
 CMultiAppProjectionTransferProject values from one domain to another
 CMultiAppScalarToAuxScalarTransferCopies the value of a SCALAR variable from one App to another
 CMultiAppSolveFailureUtility class for catching solve failure errors so that MOOSE can recover state before continuing
 CMultiAppTransferBase class for all MultiAppTransfer objects
 CMultiAppUserObjectTransferSamples a variable's value in the Master domain at the point where the MultiApp is
 CMultiAppVariableValueSamplePostprocessorTransferSamples a variable's value in the Master domain at the point where the MultiApp is
 CMultiAppVariableValueSampleTransferSamples a variable's value in the Master domain at the point where the MultiApp is
 CMultiMooseEnumThis 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
 CNearestNodeDistanceAuxComputes the distance from a block or boundary to another boundary
 CNearestNodeLocatorFinds the nearest node to each node in boundary1 to each node in boundary2 and the other way around
 CNearestNodeThread
 CNearestNodeValueAuxFinds the closest node on a paired boundary to the current node or element and stores a corresponding field value
 CNearestPointBaseThis UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z)
 CNearestPointLayeredAverageThis UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z)
 CNeighborCoupleableEnhances Coupleable interface to also couple the values from neighbor elements
 CNeighborCoupleableMooseVariableDependencyIntermediateInterfaceIntermediate base class that ties together all the interfaces for getting MooseVariables with the MooseVariableDependencyInterface
 CNeighborMooseVariableInterfaceEnhances MooseVariableInterface interface provide values from neighbor elements
 CNemesisClass for output data to the Nemesis format
 CNeumannBCImplements a simple constant Neumann BC where grad(u)=value on the boundary
 CNodalBCBase class for deriving any boundary condition that works at nodes
 CNodalConstraint
 CNodalDamperBase class for deriving nodal dampers
 CNodalEqualValueConstraintConstraint to enforce equal values (in 1D)
 CNodalExtremeValueA postprocessor for collecting the nodal min or max value
 CNodalKernelBase class for creating new types of boundary conditions
 CNodalL2Error
 CNodalL2NormComputes 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
 CNodalMaxValueThis class computes a maximum (over all the nodal values) of the coupled variable
 CNodalNormalBCThis is a base class to enforce strong boundary condition with a normal defined at a node
 CNodalNormalsCorner
 CNodalNormalsEvaluatorWorks on top of NodalNormalsPreprocessor
 CNodalNormalsPreprocessorAn ElementUserObject that prepares MOOSE for computing nodal normals
 CNodalPostprocessor
 CNodalProxyMaxValueComputes the max value at a node and broadcasts it to all processors
 CNodalScalarKernel
 CNodalSumComputes a sum of the nodal values of the coupled variable
 CNodalUserObjectA user object that runs over all the nodes and does an aggregation step to compute a single value
 CNodalValueSampler
 CNodalVariablePostprocessorThis is a base class for other classes which compute post-processed values based on nodal solution values of _u
 CNodalVariableValueSums a nodal value across all processors and multiplies the result by a scale factor
 CNodalVariableVectorPostprocessorBase class VectorPostprocessors operating on nodal variables
 CNodalVectorPostprocessor
 CNodeFaceConstraintA NodeFaceConstraint is used when you need to create constraints between two surfaces in a mesh
 CNonlinearEigen
 CNonlinearEigenSystemNonlinear eigenvalue system to be solved
 CNonlinearSystemNonlinear system to be solved
 CNonlinearSystemBaseNonlinear system to be solved
 CNonlocalIntegratedBCNonlocalIntegratedBC is used for solving integral terms in integro-differential equations
 CNonlocalKernelNonlocalKernel is used for solving integral terms in integro-differential equations
 CNormalizationAuxThis auxiliary kernel normalizes a variable based on a postprocessor
 CNullKernel
 CNumDOFs
 CNumElems
 CNumLinearIterations
 CNumNodes
 CNumNonlinearIterationsNumNonlinearIterations is a postprocessor that reports the number of nonlinear iterations
 CNumPicardIterationsReturns the number of Picard iterations taken by the underlying Transient Executioner as a Postprocessor
 CNumResidualEvaluationsJust returns the total number of Residual Evaluations performed
 CNumVars
 CODEKernel
 CODETimeDerivative
 CODETimeKernelBase class for ODEKernels that contribute to the time residual vector
 COneDEqualValueConstraintBCThis is the \( \int \lambda dg\) term from the mortar method
 COrientedBoxInterface
 COrientedBoxMarkerCreates 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
 COrientedSubdomainBoundingBoxMeshModifier for defining a Subdomain inside or outside of a bounding box with arbitrary orientation
 COutputBased class for output objects
 COutputDataA structure for storing the various lists that contain the names of the items to be exported
 COutputDataWarehouseA helper warehouse for storing OutputData objects for the various output types
 COutputInterfaceA class to provide an common interface to objects requiring "outputs" option
 COutputMapWrapperIn 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 MultiMooseEnum is not possible
 COutputOnWarehouseA helper warehouse class for storing the "execute_on" settings for the various output types
 COutputWarehouseClass for storing and utilizing output objects
 COversampleOutputBased class for providing re-positioning and oversampling support to output objects
 CParallelUniqueId
 CParsedAddSidesetMeshModifier 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
 CParsedAuxAuxKernel that evaluates a parsed function expression
 CParsedODEKernel
 CParsedSubdomainMeshModifierMeshModifier for defining a Subdomain inside or outside of combinatorial geometry
 CParserClass for parsing input files
 CPartitionerAction
 CPatternedMeshReads one or more 2D mesh files and stitches them together based on a provided two-dimensional pattern array
 CPenaltyDirichletBCWeakly enforce a Dirichlet BC using a penalty term
 CPenetrationAux
 CPenetrationInfoData structure used to hold penetration information
 CPenetrationLocator
 CPenetrationThread
 CPercentChangePostprocessorThis postprocessor displays the change in the postprocessor between adjacent timesteps
 CPerflogDumperRecords all post processor data in a CSV file
 CPerformanceData
 CPetscOutputAdds the ability to output on every nonlinear and/or linear residual
 CPhysicsBasedPreconditionerImplements a segregated solve preconditioner
 CPiecewiseFunction which provides a piecewise approximation to a provided (x,y) point data set
 CPiecewiseBilinearPiecewiseBilinear 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
 CPiecewiseConstantFunction which provides a piecewise continuous constant interpolation of a provided (x,y) point data set
 CPiecewiseLinearFunction which provides a piecewise continuous linear interpolation of a provided (x,y) point data set
 CPiecewiseLinearInterpolationMaterialThis material uses a LinearInterpolation object to define the dependence of the material's value on a variable
 CPiecewiseMultilinear
 CPointSamplerBase
 CPointValueCompute the value of a variable at a specified location
 CPointValueSampler
 CPolynomialFitThis class applies the Least Squares algorithm to a set of points to provide a smooth curve for sampling values
 CPostprocessorBase class for all Postprocessors
 CPostprocessorData
 CPostprocessorDirichletBCBoundary condition of a Dirichlet type
 CPostprocessorDTComputes the value of dt based on a postprocessor value
 CPostprocessorInterfaceInterface class for classes which interact with Postprocessors
 CPostprocessorNeumannBCImplements a constant Neumann BC where grad(u) is a equal to a postprocessor on the boundary
 CPredictorBase class for predictors
 CPresetBCTODO:
 CPresetNodalBCTODO
 CProblemClass that hold the whole problem being solved
 CProcessorIDAux
 CProjectMaterialProperties
 CPropertyValueAbstract definition of a property value
 CQpMapHelper object for holding qp mapping info
 CQuadraturePointMarker
 CQuotientAuxThis auxiliary kernel computes its value by dividing "numerator" by "denominator
 CQuotientScalarAuxThis auxiliary kernel computes its value by dividing "numerator" by "denominator
 CRalstonRalston's time integration method
 CRandomData
 CRandomICRandomIC just returns a Random value
 CRandomInterfaceInterface for objects that need parallel consistent random numbers without patterns over the course of multiple runs
 CRankFourTensorRankFourTensor is designed to handle any N-dimensional fourth order tensor, C
 CRankThreeTensorRankThreeTensor is designed to handle any N-dimensional third order tensor, r
 CRankTwoTensorRankTwoTensor is designed to handle the Stress or Strain Tensor for a fully anisotropic material
 CReaction
 CRealFunctionControlA basic control for changing an input parameter using a Function
 CReceiverA class for storing data, it allows the user to change the value of the postprocessor by altering the _my_value reference
 CRelativeDifferencePostprocessorComputes the absolute value of the relative difference between 2 post-processor values
 CRelativeSolutionDifferenceNormGets the relative solution norm from the transient executioner
 CRenameBlockMeshModifier for re-numbering or re-naming blocks
 CResetDisplacedMeshThread
 CResidual
 CRestartableA class for creating restricted objects
 CRestartableDataConcrete definition of a parameter value for a specified type
 CRestartableDataIOClass for doing restart
 CRestartableDatasContainer for storing material properties
 CRestartableDataValueAbstract definition of a RestartableData value
 CResurrectorClass for doing restart
 CSamplerThis is the base class for Samplers
 CSamplerBaseBase class for VectorPostprocessors that need to do "sampling" of values in the domain
 CSamplerInterfaceInterface for objects that need to use samplers
 CScalarComponentICInitial condition to set different values on each component of scalar variable
 CScalarConstantICScalarConstantIC just returns a constant value
 CScalarCoupleableInterface for objects that needs scalar coupling capabilities
 CScalarInitialConditionInitialConditions are objects that set the initial value of variables
 CScalarKernel
 CScalarL2ErrorPostprocessor for computing the error in a scalar value relative to a known Function's value
 CScalarVariable
 CScalePostprocessorScale a postprocessor
 CSelfAuxSelf auxiliary value
 CSetAdaptivityOptionsAction
 CSetupDampersAction
 CSetupDebugAction
 CSetupInterface
 CSetupMeshAction
 CSetupMeshCompleteAction
 CSetupPostprocessorDataActionThe PostprocessorInterface::hasPostprocessor method utilizes the PostprocessorData to determine if a postprocessor exists
 CSetupPreconditionerActionSet the preconditioner up
 CSetupPredictorActionSets the predictor
 CSetupQuadratureActionSets the quadrature
 CSetupRecoverFileBaseAction
 CSetupResidualDebugAction
 CSetupTimeIntegratorAction
 CSetupTimeStepperAction
 CShapeElementUserObjectElementUserObject class in which the _phi and _grad_phi shape function data is available and correctly initialized on EXEC_NONLINEAR (the Jacobian calculation)
 CShapeSideUserObjectSideUserObject class in which the _phi and _grad_phi shape function data is available and correctly initialized on EXEC_NONLINEAR (the Jacobian calculation)
 CShapeUserObjectUserObject template class in which the _phi and _grad_phi shape function data is available and correctly initialized on EXEC_NONLINEAR (the Jacobian calculation)
 CSideAverageValueThis postprocessor computes a volume integral of the specified variable
 CSideFluxAverage
 CSideFluxIntegralThis postprocessor computes a side integral of the mass flux
 CSideIntegralPostprocessorThis postprocessor computes a volume integral of the specified variable
 CSideIntegralUserObjectThis postprocessor computes a side integral of the specified variable over a given boundary
 CSideIntegralVariablePostprocessorThis postprocessor computes a volume integral of the specified variable
 CSideIntegralVariableUserObjectThis postprocessor computes a volume integral of the specified variable
 CSidePostprocessor
 CSideSetsAroundSubdomainAdds 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
 CSideSetsBetweenSubdomains
 CSideSetsFromNormals
 CSideSetsFromPoints
 CSideUserObject
 CSideValueSampler
 CSideVectorPostprocessor
 CSimplePredictorA SimplePredictor uses an algorithm that will predict the next solution based on previous solutions
 CSinDirichletBCA spatially-constant, time-varying NodalBC whose imposed value g(t) varies sinusoidally with time according to the formula:
 CSingleMatrixPreconditionerSingle matrix preconditioner
 CSinNeumannBCImplements a spatially-constant, time-varying flux boundary condition grad(u).n = g(t), where
 CSlaveNeighborhoodThread
 CSolutionAuxAuxKernel for reading a solution from file
 CSolutionFunctionFunction for reading a solution from file Creates a function that extracts values from a solution read from a file, via a SolutionUserObject
 CSolutionHistoryBased class for adding basic filename support to output base class
 CSolutionTimeAdaptiveDT
 CSolutionUserObjectUser object that reads an existing solution from an input file and uses it in the current simulation
 CSolverParams
 CSONDefinitionFormatterThis 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
 CSpatialUserObjectAuxFunction auxiliary value
 CSphericalAverageCompute a spherical average of a variableas a function of radius throughout the simulation domain
 CSplineFunctionFunction that uses spline interpolation
 CSplineInterpolationThis class interpolates tabulated functions with cubic splines
 CSplineInterpolationBase
 CSplitBase class for split-based preconditioners
 CSteadySteady executioners usually only call "solve()" on the NonlinearSystem once
 CStitchedMeshReads an arbitrary set of meshes and attempts to "stitch" (join) them along boundaries
 CSubAppBackupsHelper class for holding Sub-app backups
 CSubdomainBoundingBoxMeshModifier for defining a Subdomain inside or outside of a bounding box
 CSubProblemGeneric class for solving transient nonlinear problems
 CSwapBackSentinelThe "SwapBackSentinel" class's destructor guarantees that FEProblemBase::swapBackMaterials{Face,Neighbor}() is called even when an exception is thrown from FEProblemBase::reinitMaterials{Face,Neighbor}
 CSyntaxHolding syntax for parsing input files
 CSyntaxFormatterInterfaceThis interface is for classes that want to be called to format InputFileParameters
 CSyntaxTree
 CSystemBaseBase class for a system (of equations)
 CSystemInfo
 CTableOutputBase class for scalar variables and postprocessors output objects
 CTecplotClass for output data to the TecplotII format
 CTerminatorThis Userobject requests termination of the current solve based on the values of Postprocessors (and a logical expression testing them)
 CTestSetupPostprocessorDataActionFunctionA class for testing SetupPostprocessorDataAction
 CThreadedElementLoopBase class for assembly-like calculations
 CThreadedElementLoopBaseBase class for assembly-like calculations
 CThreadedNodeLoop
 CTiedValueConstraintA TiedValueConstraint forces the value of a variable to be the same on both sides of an interface
 CTiledMesh
 CTimeDerivative
 CTimeDerivativeNodalKernelRepresents du/dt
 CTimeExtremeValueA postprocessor for reporting the max/min value of another postprocessor over time
 CTimeIntegratorBase class for time integrators
 CTimeKernelAll time kernels should inherit from this class
 CTimeNodalKernelRepresents a simple ODE of du/dt - rate = 0
 CTimePeriodA basic control for disabling objects for a portion of the simulation
 CTimeSequenceStepperSolves the PDEs at a sequence of time points given as a vector in the input file
 CTimeSequenceStepperBaseSolves the PDEs at a sequence of given time points
 CTimeStepperBase class for time stepping
 CTimestepSize
 CTopResidualDebugOutputA class for producing various debug related outputs
 CTopResidualDebugOutputTopResidualDataA structure for storing data related to top residuals
 CTotalVariableValueIntegrate a post-processor value over time using trapezoidal rule
 CTransferBase class for all Transfer objects
 CTransform
 CTransientTransient executioners usually loop through a number of timesteps..
 CTransientInterfaceInterface for objects that needs transient capabilities
 CTransientMultiAppMultiApp Implementation for Transient Apps
 CTrilinearInterpolationThis class interpolates a function of three values (f(x,y,z))
 CTwoMaterialPropertyInterface
 CUniformMarker
 CUnusedWalker
 CUpdateDisplacedMeshThread
 CUpdateErrorVectorsThread
 CUserForcingFunctionDeprecated, use BodyForce
 CUserForcingFunctionNodalKernelRepresents the rate in a simple ODE of du/dt = f
 CUserObjectBase class for user-specific data
 CUserObjectInterfaceInterface for objects that need to use UserObjects
 CVacuumBCImplements a simple Vacuum BC for neutron diffusion on the boundary
 CValueRangeMarker
 CValueThresholdMarker
 CVarCopyInfoInformation about variables that will be copied
 CVariableGradientComponentExtract a component from the gradient of a variable
 CVariableInnerProduct
 CVariableResidual
 CVariableResidualNormsDebugOutputA class for producing various debug related outputs
 CVariableTimeIntegrationAuxAn AuxKernel that can be used to integrate a field variable in time using a variety of different integration methods
 CVariableWarehouseHolds variables and provides some services
 CVectorMagnitudeAuxComputes the magnitude of a vector whose components are given by up to three coupled variables
 CVectorNeumannBCImplements a flux boundary condition grad(u).n = V.n, where the vector V is specifed by the user
 CVectorOfPostprocessorsVectorOfPostprocessors 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
 CVectorPostprocessorBase class for Postprocessors that produce a vector of values
 CVectorPostprocessorData
 CVectorPostprocessorFunctionFunction which provides a piecewise continuous linear interpolation of a data set provided as two columns of a VectorPostprocessor
 CVectorPostprocessorInterface
 CVerifyElementUniqueID
 CVerifyNodalUniqueID
 CVolumeHistogramCompute a histogram of volume fractions binned according to variable values
 CVolumePostprocessorThis postprocessor computes the volume of a specified block
 CVTKOutput
 CWeakGradientBCA FluxBC which is consistent with the boundary terms arising from the Diffusion Kernel
 CXDAClass for output data to the XDAII format
 CXFEMInterfaceThis is the XFEMInterface class
 CYAMLFormatterThis class produces produces a yaml dump of the InputFileParameters that is machine parsable by any YAML formatter
 CZeroInterfaceInterface to bring zero values inside objects