Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
 ►NlibMesh The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings ►Nmoose ►NMoose ►NMooseUtils CAB2PredictorCorrector A TimeStepper based on the AB2 method CAction Base class for actions ►CActionFactory Specialized factory for generic Action System objects CActionWarehouse Storage for action instances CAdamsPredictor Implements an explicit Adams predictor based on two old solution vectors CAdaptivity Takes care of everything related to mesh adaptivity CAdaptivityAction CAddAllSideSetsByNormals This class will add sidesets to the entire mesh based on unique normals CAddAuxVariableAction Action for creating Auxiliary variables CAddBCAction CAddBoundsVectorsAction CAddConstraintAction CAddControlAction Action for creating Control objects CAddDamperAction CAddDGKernelAction CAddDiracKernelAction CAddDistributionAction This class adds a distribution object CAddElementalFieldAction CAddExtraNodeset CAddFieldSplitAction CAddFunctionAction This class parses functions in the [Functions] block and creates them CAddICAction CAddIndicatorAction CAddInitialConditionAction CAddInterfaceKernelAction CAddKernelAction CAddMarkerAction CAddMaterialAction CAddMeshModifierAction CAddMortarInterfaceAction 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 CAddPostprocessorAction CAddSamplerAction This class adds a Sampler object CAddScalarKernelAction CAddSideSetsBase CAddSideSetsFromBoundingBox MeshModifier for defining a Subdomain inside or outside of a bounding box CAddTransferAction CAddUserObjectAction CAddVariableAction Adds nonlinear variable CAddVectorPostprocessorAction CAdvancedOutput Based class for output objects CAllLocalDofIndicesThread Grab all the local dof indices for the variables passed in, in the system passed in CAllNodesSendListThread 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 CAppFactory Generic AppFactory class for building Application objects 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 ►CAssembly Keeps track of stuff related to assembling CAssignElementSubdomainID MeshModifier for assigning subdomain IDs of all elements CAssignSubdomainID MeshModifier for assigning a subdomain ID to all elements CAStableDirk4 Fourth-order diagonally implicit Runge Kutta method (Dirk) with three stages plus an update CAutoPositionsMultiApp Automatically generates Sub-App positions from positions in the master app's mesh CAuxGroupExecuteMooseObjectWarehouse General warehouse for storing MooseObjects based on relation to IC and AuxKernel execution CAuxiliarySystem A system that holds auxiliary variables CAuxKernel 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 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 CBDF2 BDF2 time integrator CBicubicSplineFunction Function that uses spline interpolation CBicubicSplineInterpolation This class interpolates tabulated functions with a bi-cubic spline CBilinearInterpolation This class applies the Least Squares algorithm to a set of points to provide a smooth curve for sampling values CBlockDeleter CBlockRestrictable An interface that restricts an object to subdomains via the 'blocks' input parameter CBndElement CBndNode CBndNodeCompare Helper class for sorting Boundary Nodes so that we always get the same order of application for boundary conditions CBodyForce This kernel implements a generic functional body force term: $- c f$ CBoundaryCondition Base 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 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 CBoundingBoxNodeSet 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 CBoundsAux Fills in the "bounds vectors" to provide an upper and lower bound for the variable that is coupled in CBoxMarker CBreakBoundaryOnSubdomain CCacheChangedListsThread CChangeOverTimestepPostprocessor Computes the change in a post-processor value, or the magnitude of its relative change, over a time step CCheckIntegrityAction CCheckOutputAction Action for checking that "outputs" is properly populated for Materials CCheckpoint CCheckpointFileNames A structure for storing the various output files associated with checkpoint output CColumnMajorMatrix This class defines a Tensor that can change its shape CComboMarker ►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 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$$ CComputeBoundaryInitialConditionThread CComputeDiracThread CComputeElemAuxBcsThread CComputeElemAuxVarsThread CComputeElemDampingThread CComputeFullJacobianThread CComputeIndicatorThread CComputeInitialConditionThread CComputeJacobianBlocksThread Specialization for filling multiple "small" preconditioning matrices simulatenously CComputeJacobianThread CComputeMarkerThread CComputeMaterialsObjectThread CComputeNodalAuxBcsThread CComputeNodalAuxVarsThread CComputeNodalDampingThread CComputeNodalKernelBCJacobiansThread CComputeNodalKernelBcsThread CComputeNodalKernelJacobiansThread CComputeNodalKernelsThread CComputeNodalUserObjectsThread CComputeResidualThread CComputeUserObjectsThread Class for threaded computation of UserObjects CConservativeAdvection 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 CConstantDamper Simple constant damper CConstantDT CConstantFunction Class that represents constant function CConstantIC ConstantIC just returns a constant value CConstantPointSource TOOD CConstantRate Represents the rate in a simple ODE of du/dt = rate CConstantScalarAux Sets a constant value on a scalar variable CConstantVectorPostprocessor CConstraint Base class for all Constraint types CConstraintWarehouse Warehouse for storing constraints CControl Base class for Control objects CControllableParameter A class for accessing controllable InputParameters CControlOutput Class for output information regarding Controls to the screen CConvectiveFluxBC CCopyNodalVarsAction CCoupleable Interface for objects that needs coupling capabilities CCoupleableMooseVariableDependencyIntermediateInterface Intermediate base class that ties together all the interfaces for getting MooseVariables with the MooseVariableDependencyInterface CCoupledForce Simple class to demonstrate off diagonal Jacobian contributions 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 CCrankNicolson Crank-Nicolson time integrator CCreateDisplacedProblemAction CCreateExecutionerAction CCreateProblemAction CCSV Based class for adding basic filename support to output base class CCSVReader 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 CCyclicDependencyException CDamper Base class for deriving dampers CDebugResidualAux Auxiliary kernel for debugging convergence ►CDependencyResolver CDependencyResolverComparator CDependencyResolverInterface Interface for sorting dependent vectors of objects CDeprecatedBlockAction Used for marking that some block are deprecated and not be used CDerivativeMaterialInterface Interface class ("Veneer") to provide generator methods for derivative material property names CDerivativeMaterialPropertyNameInterface CDetermineSystemType 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) CDifferencePostprocessor Computes the difference between two postprocessors CDiffusion This kernel implements the Laplacian operator: $u$ 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 CDiracKernel 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 CDiracKernelInfo The DiracKernelInfo object is a place where all the Dirac points added by different DiracKernels are collected CDirichletBC Boundary condition of a Dirichlet type CDiscreteElementUserObject CDisplacedProblem CDisplacedSystem CDistribution All Distributions should inherit from this class CDistributionInterface Interface for objects that need to use distributions ►CDM_Moose CDOFMapOutput An output object for writing the DOF map of the system in a machine parsable format CDT2 An 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 ►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 Specialization of SubProblem for solving nonlinear equations plus auxiliary equations CEigenvalue CEigenvalues CElemElemConstraint CElementalVariableValue 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 CElementDamper Base class for deriving element dampers CElementDeleterBase This class deletes elements from the mesh data structure after it has been generated or read but before any FEM data structures are initialized CElementExtremeValue A postprocessor for collecting the nodal min or max value 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 CElementIndicator CElementIntegralIndicator CElementIntegralMaterialProperty 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 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 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 CElementPostprocessor CElementsAlongLine Get all of the elements that are intersected by a line CElementsAlongPlane Get all of the elements that are intersected by a plane CElementUserObject CElementVariablePostprocessor CElementVariablesDifferenceMax Finds the largest difference between two variable fields CElementVectorL2Error CElementVectorPostprocessor CElementW1pError This postprocessor computes the Sobolev norm W^{1,p} of the difference between the computed solution and the passed in function CEmptyAction Do nothing action CEmptyPostprocessor 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 CErrorFractionMarker CErrorToleranceMarker CExecStore The class for storing warehouses that holds objects that are being evaluated at different times CExecuteMooseObjectWarehouse A class for storing MooseObjects based on execution flag CExecutioner Executioners are objects that do the actual work of solving your problem CExecutionerAttributeReporter A class to report class attributes value from Executioners CExodus Class for output data to the ExodusII format CExodusFormatter CExodusTimeSequenceStepper Solves the PDEs at a sequence of time points given as a vector in the input file CExpandWalker 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: CExplicitTVDRK2 Explicit TVD (total-variation-diminishing) second-order Runge-Kutta time integration methods: CFaceFaceConstraint User for mortar methods CFactory Generic factory class for build all sorts of objects CFDKernel CFEProblem Specialization of SubProblem for solving nonlinear equations plus auxiliary equations CFEProblemBase Specialization of SubProblem for solving nonlinear equations plus auxiliary equations CFieldSplitPreconditioner Implements a preconditioner designed to map onto PETSc's PCFieldSplit CFileLineInfo Holds file and line information CFileLineInfoMap A mapping between a series of keys to a FileLineInfo CFileMesh CFileOutput An outputter with filename support CFileRangeBuilder Augments an InputParameters object with file range information CFindValueOnLine Find a specific target value along a sampling line CFiniteDifferencePreconditioner Finite difference preconditioner CFlagElementsThread CFluxBC Boundary condition of a flux type $$<\vec q * \vec n, v>$$ CFormattedTable This class is used for building, formatting, and outputting tables of numbers CFullSolveMultiApp This type of MultiApp will completely solve itself the first time it is asked to take a step CFunction Base class for function objects CFunctionAux Function auxiliary value CFunctionDiracSource CFunctionDirichletBC Defines a boundary condition that forces the value to be a user specified function at the boundary CFunctionDT 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 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 CFunctionPresetBC Defines a boundary condition that forces the value to be a user specified function at the boundary CFunctionScalarAux Sets a value of a scalar variable based on the function CFunctionScalarIC 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 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 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 CGenericConstantMaterial 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 CGenericConstantRankTwoTensor Declares a constant material property of type RankTwoTensor CGenericFunctionMaterial 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 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) CGlobalParamsAction CGMVOutput Class for output data to the GMVOutputII format CGnuplot Based class for adding basic filename support to output base class CGradientJumpIndicator CGriddedData Container for holding a function defined on a grid of arbitrary dimension 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 CImageFunction A function for extracting data from an image or stack of images CImageMesh A 2D GeneratedMesh where xmin, xmax, etc CImageSampler A helper class for reading and sampling images using VTK CImageSubdomain MeshModifier for defining a Subdomains based on Image data CImplicitEuler Implicit Euler's method CImplicitMidpoint Second-order Runge-Kutta (implicit midpoint) time integration CIndicator CIndicatorMarker Cinfix_ostream_iterator CInitialCondition InitialConditions are objects that set the initial value of variables CInitialConditionWarehouse Warehouse for storing initial conditions CInitProblemAction CInputFileFormatter This class produces produces a dump of the InputFileParameters 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 CIntegratedBC Base class for deriving any boundary condition of a integrated type CInterfaceKernel InterfaceKernel is responsible for interfacing physics across subdomains CInternalSideIndicator Responsible for calculating the residuals for various physics on internal sides (edges/faces) CInternalSidePostprocessor CInternalSideUserObject CInternalSideVectorPostprocessor 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 CJacobianBlock Helper class for holding the preconditioning blocks to fill CJsonInputFileFormatter This class produces produces a dump of the InputFileParameters that appears like the normal input file syntax 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 two main kernel types implemented in MOOSE, EigenKernel and Kernel CKernelGrad Responsible for calculating the residuals in form: CKernelValue Responsible for calculating the residuals in form: CKernelWarehouse Holds kernels and provides some services 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 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).c CLayeredSideAverage This UserObject computes side averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z).c CLayeredSideFluxAverage 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) CLeastSquaresFit LeastSquaresFit is a VectorPostprocessor that performs a least squares fit on data calculated in another VectorPostprocessor CLibmeshPartitioner 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 CLinearNodalConstraint The 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 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 CLineSegment Used by the LineMaterialSamplerBase class and for some ray tracing stuff CLineValueSampler CLockFile Gets an exclusive lock on a file CLogConstantDT Simple time-stepper which imposes a time step constant in the logarithmic space 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 CMarker CMassEigenKernel CMassLumpedTimeDerivative CMatchedValueBC Implements a simple coupled boundary condition where u=v on the boundary CMaterial Materials compute MaterialProperties CMaterialAuxBase A base class for the various Material related AuxKernal objects 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 CMaterialOutputAction Creates AuxVariables and AuxKernels for automatic output of material properties CMaterialProperties Container for storing material properties CMaterialProperty 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 CMaterialPropertyStorage Stores the stateful material properties computed by materials CMaterialRealAux Object for passing a scalar, REAL material property to an AuxVariable CMaterialRealDenseMatrixAux AuxKernel for outputting a DenseMatrix material property component to an AuxVariable CMaterialRealTensorValueAux AuxKernel for outputting a RealTensorValue material property component to an AuxVariable CMaterialRealVectorValueAux AuxKernel for outputting a RealVectorValue material property component to an AuxVariable CMaterialStdVectorAux AuxKernel for outputting a std::vector material-property component to an AuxVariable CMaterialStdVectorAuxBase A base class for the various Material related AuxKernal objects 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 Material objects are special in that they have additional objects created automatically (see FEProblemBase::addMaterial) 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 CMemoryUsage Output maximum, average, or total process memory usage CMeshChangedInterface Interface for notifications that the mesh has changed ►CMeshExtruder CMeshModifier MeshModifiers are objects that can modify or add to an existing mesh CMeshSideSet Add lower dimensional elements along the faces contained in a side set CMonotoneCubicInterpolation This class interpolates values given a set of data pairs and an abscissa CMooseApp Base class for MOOSE-based applications CMooseArray 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 ►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 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 Adds user facing parameters for parsed function 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 CMooseVariable Class for stuff related to variables CMooseVariableBase CMooseVariableConstMonomial CMooseVariableDependencyInterface CMooseVariableInterface Interface for objects that need to get values of MooseVariables CMooseVariableScalar Class for scalar variables (they are different) CMultiApp A MultiApp represents one or more MOOSE applications that are running simultaneously CMultiAppCopyTransfer Copy the value to the target domain from the nearest node in the source domain CMultiAppDTKInterpolationTransfer Transfers from spatially varying Interpolations in a MultiApp to the "master" system CMultiAppDTKUserObjectEvaluator Evaluates the specified UserObject and returns the result in a DTK FieldContainer CMultiAppDTKUserObjectTransfer Transfers from spatially varying UserObjects in a MultiApp to the "master" system CMultiAppInterpolationTransfer Copy the value to the target domain from the nearest node in the source domain CMultiAppMeshFunctionTransfer Transfers a vector of variables CMultiAppNearestNodeTransfer Copy the value to the target domain from the nearest node in the source domain CMultiAppPostprocessorInterpolationTransfer Transfers from spatially varying PostprocessorInterpolations in a MultiApp to the "master" system CMultiAppPostprocessorToAuxScalarTransfer Copies the value of a Postprocessor from one app to a scalar AuxVariable in another CMultiAppPostprocessorTransfer Copies the value of a Postprocessor from the Master to a MultiApp CMultiAppProjectionTransfer Project values from one domain to another CMultiAppScalarToAuxScalarTransfer Copies the value of a SCALAR variable from one App to another CMultiAppSolveFailure Utility class for catching solve failure errors so that MOOSE can recover state before continuing CMultiAppTransfer Base class for all MultiAppTransfer objects CMultiAppUserObjectTransfer Samples a variable's value in the Master domain at the point where the MultiApp is CMultiAppVariableValueSamplePostprocessorTransfer Samples a variable's value in the Master domain at the point where the MultiApp is CMultiAppVariableValueSampleTransfer Samples a variable's value in the Master domain at the point where the MultiApp is 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 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 CNearestNodeThread CNearestNodeValueAux Finds the closest node on a paired boundary to the current node or element and stores a corresponding field value CNearestPointBase This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z) CNearestPointLayeredAverage 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 CNemesis Class for output data to the Nemesis format CNeumannBC Implements a simple constant Neumann BC where grad(u)=value on the boundary CNodalBC 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 new types of boundary conditions 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 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 CNodalPostprocessor CNodalProxyMaxValue Computes the max value at a node and broadcasts it to all processors CNodalScalarKernel 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 CNodalVariablePostprocessor This is a base class for other classes which compute post-processed values based on nodal solution values of _u 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 CNodeFaceConstraint A NodeFaceConstraint is used when you need to create constraints between two surfaces in a mesh CNonlinearEigen CNonlinearEigenSystem Nonlinear eigenvalue system to be solved CNonlinearSystem Nonlinear system to be solved CNonlinearSystemBase Nonlinear system to be solved 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 CNullKernel CNumDOFs CNumElems CNumLinearIterations CNumNodes CNumNonlinearIterations NumNonlinearIterations is a postprocessor that reports the number of nonlinear iterations CNumPicardIterations Returns the number of Picard iterations taken by the underlying Transient Executioner as a Postprocessor 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 COneDEqualValueConstraintBC This is the $$\int \lambda dg$$ term from the mortar method 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 COrientedSubdomainBoundingBox MeshModifier 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 MultiMooseEnum is not possible COutputOnWarehouse A helper warehouse class for storing the "execute_on" settings for the various output types COutputWarehouse Class for storing and utilizing output objects COversampleOutput Based class for providing re-positioning and oversampling support to output objects CParallelUniqueId CParsedAddSideset MeshModifier 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 CParsedAux AuxKernel that evaluates a parsed function expression CParsedODEKernel CParsedSubdomainMeshModifier MeshModifier for defining a Subdomain inside or outside of combinatorial geometry CParser Class for parsing input files CPartitionerAction CPatternedMesh 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 CPenetrationAux CPenetrationInfo Data structure used to hold penetration information CPenetrationLocator ►CPenetrationThread CPercentChangePostprocessor This postprocessor displays the change in the postprocessor between adjacent timesteps CPerflogDumper Records all post processor data in a CSV file CPerformanceData CPetscOutput Adds the ability to output on every nonlinear and/or linear residual CPhysicsBasedPreconditioner Implements a segregated solve preconditioner CPiecewise Function which provides a piecewise approximation to a provided (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 CPiecewiseConstant Function which provides a piecewise continuous constant interpolation of a provided (x,y) point data set CPiecewiseLinear Function which provides a piecewise continuous linear interpolation of a provided (x,y) point data set CPiecewiseLinearInterpolationMaterial This material uses a LinearInterpolation object to define the dependence of the material's value on a variable CPiecewiseMultilinear CPointSamplerBase CPointValue Compute the value of a variable at a specified location CPointValueSampler CPolynomialFit This class applies the Least Squares algorithm to a set of points to provide a smooth curve for sampling values CPostprocessor Base class for all Postprocessors CPostprocessorData 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 CPredictor Base class for predictors CPresetBC TODO: CPresetNodalBC TODO CProblem Class that hold the whole problem being solved CProcessorIDAux CProjectMaterialProperties CPropertyValue Abstract definition of a property value CQpMap Helper object for holding qp mapping info CQuadraturePointMarker CQuotientAux This auxiliary kernel computes its value by dividing "numerator" by "denominator CQuotientScalarAux This auxiliary kernel computes its value by dividing "numerator" by "denominator CRalston Ralston's time integration method CRandomData CRandomIC RandomIC just returns a Random value CRandomInterface Interface for objects that need parallel consistent random numbers without patterns over the course of multiple runs CRankFourTensor RankFourTensor is designed to handle any N-dimensional fourth order tensor, C CRankThreeTensor RankThreeTensor is designed to handle any N-dimensional third order tensor, r CRankTwoTensor RankTwoTensor is designed to handle the Stress or Strain Tensor for a fully anisotropic material CReaction 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 CRelativeDifferencePostprocessor Computes the absolute value of the relative difference between 2 post-processor values CRelativeSolutionDifferenceNorm Gets the relative solution norm from the transient executioner CRenameBlock MeshModifier for re-numbering or re-naming blocks CResetDisplacedMeshThread CResidual CRestartable A class for creating restricted objects CRestartableData Concrete definition of a parameter value for a specified type CRestartableDataIO Class for doing restart CRestartableDatas Container for storing material properties CRestartableDataValue Abstract definition of a RestartableData value CResurrector Class for doing restart ►CSampler This is the base class for Samplers 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 CScalarKernel CScalarL2Error Postprocessor for computing the error in a scalar value relative to a known Function's value CScalarVariable CScalePostprocessor Scale a postprocessor CSelfAux Self auxiliary value CSetAdaptivityOptionsAction CSetupDampersAction CSetupDebugAction CSetupInterface CSetupMeshAction CSetupMeshCompleteAction CSetupPostprocessorDataAction The PostprocessorInterface::hasPostprocessor method utilizes the PostprocessorData to determine if a postprocessor exists CSetupPreconditionerAction Set the preconditioner up CSetupPredictorAction Sets the predictor CSetupQuadratureAction Sets the quadrature CSetupRecoverFileBaseAction CSetupResidualDebugAction CSetupTimeIntegratorAction CSetupTimeStepperAction 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) CSideAverageValue This postprocessor computes a volume integral of the specified variable CSideFluxAverage CSideFluxIntegral This postprocessor computes a side integral of the mass flux CSideIntegralPostprocessor This postprocessor computes a volume integral of the specified variable CSideIntegralUserObject This postprocessor computes a side integral of the specified variable over a given boundary CSideIntegralVariablePostprocessor This postprocessor computes a volume integral of the specified variable CSideIntegralVariableUserObject This postprocessor computes a volume integral of the specified variable CSidePostprocessor CSideSetsAroundSubdomain 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 CSideSetsBetweenSubdomains CSideSetsFromNormals CSideSetsFromPoints CSideUserObject CSideValueSampler CSideVectorPostprocessor CSimplePredictor A SimplePredictor uses an algorithm that will predict the next solution based on previous solutions CSinDirichletBC A spatially-constant, time-varying NodalBC whose imposed value g(t) varies sinusoidally with time according to the formula: CSingleMatrixPreconditioner Single matrix preconditioner CSinNeumannBC Implements a spatially-constant, time-varying flux boundary condition grad(u).n = g(t), where CSlaveNeighborhoodThread CSolutionAux AuxKernel for reading a solution from file CSolutionFunction Function for reading a solution from file Creates a function that extracts values from a solution read from a file, via a SolutionUserObject CSolutionHistory Based class for adding basic filename support to output base class CSolutionTimeAdaptiveDT CSolutionUserObject User object that reads an existing solution from an input file and uses it in the current simulation 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 CSpatialUserObjectAux Function auxiliary value CSphericalAverage Compute a spherical average of a variableas a function of radius throughout the simulation domain CSplineFunction Function that uses spline interpolation CSplineInterpolation This class interpolates tabulated functions with cubic splines CSplineInterpolationBase CSplit Base class for split-based preconditioners CSteady Steady executioners usually only call "solve()" on the NonlinearSystem once CStitchedMesh Reads an arbitrary set of meshes and attempts to "stitch" (join) them along boundaries CSubAppBackups Helper class for holding Sub-app backups CSubdomainBoundingBox MeshModifier for defining a Subdomain inside or outside of a bounding box 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} ►CSyntax Holding syntax for parsing input files CSyntaxFormatterInterface This interface is for classes that want to be called to format InputFileParameters ►CSyntaxTree CSystemBase Base class for a system (of equations) CSystemInfo CTableOutput Base class for scalar variables and postprocessors output objects 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) CTestSetupPostprocessorDataActionFunction A class for testing SetupPostprocessorDataAction CThreadedElementLoop Base class for assembly-like calculations CThreadedElementLoopBase Base class for assembly-like calculations CThreadedNodeLoop CTiedValueConstraint A TiedValueConstraint forces the value of a variable to be the same on both sides of an interface CTiledMesh CTimeDerivative CTimeDerivativeNodalKernel Represents du/dt CTimeExtremeValue A postprocessor for reporting the max/min value of another postprocessor over time CTimeIntegrator Base class for time integrators 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 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 CTotalVariableValue Integrate a post-processor value over time using trapezoidal rule CTransfer Base class for all Transfer objects CTransform 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 CUniformMarker CUnusedWalker CUpdateDisplacedMeshThread CUpdateErrorVectorsThread 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 CValueRangeMarker CValueThresholdMarker CVarCopyInfo Information about variables that will be copied CVariableGradientComponent Extract a component from the gradient of a variable CVariableInnerProduct 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 CVariableWarehouse Holds variables and provides some services CVectorMagnitudeAux Computes the magnitude of a vector whose components are given by up to three coupled variables CVectorNeumannBC Implements a flux boundary condition grad(u).n = V.n, where the vector V is specifed by the user 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 CVectorPostprocessor Base class for Postprocessors that produce a vector of values ►CVectorPostprocessorData CVectorPostprocessorFunction Function which provides a piecewise continuous linear interpolation of a data set provided as two columns of a VectorPostprocessor CVectorPostprocessorInterface CVerifyElementUniqueID CVerifyNodalUniqueID CVolumeHistogram Compute a histogram of volume fractions binned according to variable values 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 CXDA Class for output data to the XDAII format CXFEMInterface This is the XFEMInterface class CYAMLFormatter This class produces produces a yaml dump of the InputFileParameters that is machine parsable by any YAML formatter CZeroInterface Interface to bring zero values inside objects