# Complete Syntax

## Adaptivity

- Moose App
- SetAdaptivityOptionsActionAction for defining adaptivity parameters.
- Indicators
- Markers
- Phase Field App
- Markers

### Adaptivity/Indicators

- Moose App
- AddElementalFieldActionAdds elemental auxiliary variable for adaptivity system.
- AddIndicatorActionAction for adding Indicator object to a simulation.
- AnalyticalIndicatorCompute the square of the error as the difference between an unknown variable and an analytical solution.
- ArrayMooseVariableUsed for grouping standard field variables with the same finite element family and order
- GradientJumpIndicatorCompute the jump of the solution gradient across element boundaries.
- LaplacianJumpIndicatorCompute the jump of the solution laplacian across element bondaries.
- MooseVariableRepresents standard field variables, e.g. Lagrange, Hermite, or non-constant Monomials
- MooseVariableBaseBase class for Moose variables. This should never be the terminal object type
- MooseVariableConstMonomialSpecialization for constant monomials that avoids unnecessary loops
- MooseVariableFVRealBase class for Moose variables. This should never be the terminal object type
- MooseVariableScalarMoose wrapper class around scalar variables
- ValueJumpIndicatorCompute the jump of the solution across element bondaries.
- VectorMooseVariableRepresents vector field variables, e.g. Vector Lagrange or Nedelec

### Adaptivity/Markers

- Moose App
- AddElementalFieldActionAdds elemental auxiliary variable for adaptivity system.
- AddMarkerActionAction for adding Marker object to a simulation.
- ArrayMooseVariableUsed for grouping standard field variables with the same finite element family and order
- BoxMarkerMarks the region inside and outside of a 'box' domain for refinement or coarsening.
- ComboMarkerA marker that converts many markers into a single marker by considering the maximum value of the listed markers (i.e., refinement takes precedent).
- ErrorFractionMarkerMarks elements for refinement or coarsening based on the fraction of the min/max error from the supplied indicator.
- ErrorToleranceMarkerCoarsen or refine elements based on an absolute tolerance allowed from the supplied indicator.
- MooseVariableRepresents standard field variables, e.g. Lagrange, Hermite, or non-constant Monomials
- MooseVariableBaseBase class for Moose variables. This should never be the terminal object type
- MooseVariableConstMonomialSpecialization for constant monomials that avoids unnecessary loops
- MooseVariableFVRealBase class for Moose variables. This should never be the terminal object type
- MooseVariableScalarMoose wrapper class around scalar variables
- OrientedBoxMarkerMarks inside and outside a box that can have arbitrary orientation and center point.
- UniformMarkerUniformly mark all elements for refinement or coarsening.
- ValueRangeMarkerMark elements for adaptivity based on the supplied upper and lower bounds and the specified variable.
- ValueThresholdMarkerThe the refinement state based on a threshold value compared to the specified variable.
- VectorMooseVariableRepresents vector field variables, e.g. Vector Lagrange or Nedelec
- Phase Field App
- DiscreteNucleationMarkerMark new nucleation sites for refinement

## AuxKernels

- Moose App
- AddKernelAction
- ADMaterialRankTwoTensorAuxAccess a component of a RankTwoTensor for automatic material property output
- ADMaterialRealAuxOutputs element volume-averaged material properties
- ADMaterialRealVectorValueAux
- ADVectorMaterialRealVectorValueAuxConverts a vector-quantity material property into a vector auxiliary variable
- ArrayVariableComponentCopy a component of an array variable.
- ConstantAuxCreates a constant field in the domain.
- ConstantBoundsAuxProvides constant bound of a variable for the PETSc's variational inequalities solver
- DebugResidualAux
- DiffusionFluxAuxCompute components of flux vector for diffusion problems .
- ElemExtraIDAuxPuts element extra IDs into an aux variable.
- ElementH1ErrorFunctionAuxComputes the H1 or W^{1,p} error between an exact function and a coupled variable.
- ElementIntegerAuxCreates a field showing the element integer.
- ElementL2ErrorFunctionAuxA class for computing the element-wise L^2 (Euclidean) error between a function and a coupled variable.
- ElementLengthAuxCompute the element size using Elem::hmin() or Elem::hmax() from libMesh.
- ElementLpNormAuxCompute an elemental field variable (single value per element) equal to the Lp-norm of a coupled Variable.
- ElementQualityAuxGenerates a field containing the quality metric for each element. Useful for visualizing mesh quality.
- FunctionAuxAuxiliary Kernel that creates and updates a field variable by sampling a function through space and time.
- GapValueAux
- GhostingAuxColors the elements ghosted to the chosen PID.
- HardwareIDAuxCreates a field showing the assignment of partitions to physical nodes in the cluster.
- InterfaceValueUserObjectAuxGet stored value from the specified InterfaceQpUserObjectBase.
- JouleHeatingHeatGeneratedAuxCompute heat generated from Joule heating .
- LineSegmentLevelSetAuxAuxiliary Kernel that calcuates level set value using line segments' description.
- MaterialRankFourTensorAuxAccess a component of a RankFourTensor for automatic material property output
- MaterialRankTwoTensorAuxAccess a component of a RankTwoTensor for automatic material property output
- MaterialRealAuxOutputs element volume-averaged material properties
- MaterialRealDenseMatrixAux
- MaterialRealTensorValueAux
- MaterialRealVectorValueAux
- MaterialStdVectorAuxExtracts a component of a material type std::vector<Real> to an aux variable. If the std::vector is not of sufficient size then zero is returned
- MaterialStdVectorRealGradientAuxExtracts a component of a material's std::vector<RealGradient> to an aux variable. If the std::vector is not of sufficient size then zero is returned
- NearestNodeDistanceAuxStores the distance between a block and boundary or between two boundaries.
- NearestNodeValueAuxRetrieves a field value from the closest node on the paired boundary and stores it on this boundary or block.
- NormalizationAux
- ParsedAuxParsed function AuxKernel.
- PenetrationAuxAuxiliary Kernel for computing several geometry related quantities between two contacting bodies.
- ProcessorIDAuxCreates a field showing the processors and partitioning.
- QuotientAuxDivides two coupled variables.
- SelfAux
- SolutionAuxCreates fields by using information from a SolutionUserObject.
- SpatialUserObjectAux
- TagMatrixAuxCouple the diag of a tag matrix, and return its nodal value
- TagVectorAuxCouple a tag vector, and return its nodal value
- VariableGradientComponentCreates a field with consisting of one component of a coupled variable.
- VariableOldValueBoundsAuxProvides the upper and lower bound of the phase field fracture variable to PETSc's SNES variational inequalities solver.
- VariableTimeIntegrationAux
- VectorFunctionAuxAuxiliary Kernel that creates and updates a vector field variable by sampling a Function object, via the vectorValue method, through space and time.
- VectorMagnitudeAuxCreates a field representing the magnitude of three coupled variables using an Euclidean norm.
- VectorMaterialRealVectorValueAuxConverts a vector-quantity material property into a vector auxiliary variable
- VectorPostprocessorVisualizationAuxRead values from a VectorPostprocessor that is producing vectors that are 'number of processors' * in length. Puts the value for each processor into an elemental auxiliary field.
- VectorVariableComponentAuxCreates a field consisting of one component of a coupled vector variable.
- Fluid Properties App
- PressureAuxComputes pressure given specific volume and specific internal energy
- SaturationTemperatureAuxComputes saturation temperature from pressure and 2-phase fluid properties object
- SpecificEnthalpyAuxComputes specific enthalpy from pressure and temperature
- StagnationPressureAuxComputes stagnation pressure from specific volume, specific internal energy, and velocity
- StagnationTemperatureAuxComputes stagnation temperature from specific volume, specific internal energy, and velocity
- TemperatureAuxComputes temperature given specific volume and specific internal energy
- Porous Flow App
- PorousFlowDarcyVelocityComponentDarcy velocity (in m
^{3.s}-1.m^{-2, or m.s}-1) -(k_ij * krel /mu (nabla_j P - w_j)), where k_ij is the permeability tensor, krel is the relative permeability, mu is the fluid viscosity, P is the fluid pressure, and w_j is the fluid weight. - PorousFlowDarcyVelocityComponentLowerDimensionalDarcy velocity on a lower-dimensional element embedded in a higher-dimensional mesh. Units m
^{3.s}-1.m^{-2, or m.s}-1. Darcy velocity = -(k_ij * krel /(mu * a) (nabla_j P - w_j)), where k_ij is the permeability tensor, krel is the relative permeability, mu is the fluid viscosity, P is the fluid pressure, a is the fracture aperture and w_j is the fluid weight. The difference between this AuxKernel and PorousFlowDarcyVelocity is that this one projects gravity along the element's tangent direction. NOTE! For a meaningful answer, your permeability tensor must NOT contain terms that rotate tangential vectors to non-tangential vectors. - PorousFlowPropertyAuxAuxKernel to provide access to properties evaluated at quadpoints. Note that elemental AuxVariables must be used, so that these properties are integrated over each element.
- Tensor Mechanics App
- ADRankFourAuxAccess a component of a RankFourTensor
- ADRankTwoAuxAccess a component of a RankTwoTensor
- ADRankTwoScalarAuxCompute a scalar property of a RankTwoTensor
- AccumulateAux
- CylindricalRankTwoAuxTakes RankTwoTensor material and outputs component in cylindrical coordinates
- DomainIntegralQFunctionComputes the q-function for a segment along the crack front, used in the calculation of the J-integral
- DomainIntegralTopologicalQFunctionDetermines if a node is within the ring of the crack front defintion; this object is normally created by the DomainIntegralAction.
- ElasticEnergyAuxCompute the local elastic energy
- GlobalDisplacementAuxAuxKernel to visualize the displacements generated by the global strain tensor
- NewmarkAccelAuxComputes the current acceleration using the Newmark method.
- NewmarkVelAuxCalculates the current velocity using Newmark method.
- RadialDisplacementCylinderAuxCompute the radial component of the displacement vector for cylindrical models.
- RadialDisplacementSphereAuxCompute the radial component of the displacement vector for spherical models.
- RankFourAuxAccess a component of a RankFourTensor
- RankTwoAuxAccess a component of a RankTwoTensor
- RankTwoScalarAuxCompute a scalar property of a RankTwoTensor
- TestNewmarkTIAssigns the velocity/acceleration calculated by time integrator to the velocity/acceleration auxvariable.
- Phase Field App
- BndsCalcAuxCalculate location of grain boundaries in a polycrystalline sample
- CrossTermGradientFreeEnergyFree energy contribution from the cross terms in ACMultiInterface
- DiscreteNucleationAuxProject the DiscreteNucleationMap state onto an AuxVariable
- EBSDReaderAvgDataAux
- EBSDReaderPointDataAux
- EulerAngleProvider2RGBAuxOutput RGB representation of crystal orientation from user object to an AuxVariable. The entire domain must have the same crystal structure.
- EulerAngleVariables2RGBAux
- FeatureFloodCountAuxFeature detection by connectivity analysis
- GrainAdvectionAuxCalculates the advection velocity of grain due to rigid body translation and rotation
- GrainBoundaryVelocityCompute the velocity of grain boundaries.
- KKSGlobalFreeEnergyTotal free energy in KKS system, including chemical, barrier and gradient terms
- KKSMultiFreeEnergyTotal free energy in multi-phase KKS system, including chemical, barrier and gradient terms
- OutputEulerAnglesOutput Euler angles from user object to an AuxVariable.
- PFCEnergyDensity
- PFCRFFEnergyDensity
- TotalFreeEnergyTotal free energy (both the bulk and gradient parts), where the bulk free energy has been defined in a material
- MatVecRealGradAuxKernel
- MaterialVectorAuxKernel
- MaterialVectorGradAuxKernel
- Contact App
- ContactPressureAuxComputes the contact pressure from the contact force and nodal area
- Functional Expansion Tools App
- FunctionSeriesToAuxAuxKernel to convert a functional expansion (Functions object, type = FunctionSeries) to an AuxVariable
- Peridynamics App
- BoundaryOffsetPDClass for output offset of PD boundary nodes compared to initial FE mesh
- NodalRankTwoPDClass for computing and outputing components and scalar quantities of nodal rank two strain and stress tensors for bond-based and ordinary state-based peridynamic models
- NodalVolumePDClass for output nodal area(2D) or nodal volume(3D)
- RankTwoBasedFailureCriteriaNOSPDClass for rank two tensor based failure criteria in non-ordinary state-based model
- StretchBasedFailureCriterionPDClass for bond stretch failure criterion in bond-based model and ordinary state-based model
- Misc App
- CoupledDirectionalMeshHeightInterpolation
- Navier Stokes App
- EnthalpyAux
- INSCourantComputes h_min / |u|.
- INSDivergenceAuxComputes h_min / |u|.
- INSStressComponentAuxThis class computes the stress component based on pressure and velocity for incompressible Navier-Stokes
- InternalEnergyAux
- NSEnthalpyAuxNodal auxiliary variable, for computing enthalpy at the nodes.
- NSInternalEnergyAuxAuxiliary kernel for computing the internal energy of the fluid.
- NSMachAuxAuxiliary kernel for computing the Mach number assuming an ideal gas.
- NSPressureAuxNodal auxiliary variable, for computing pressure at the nodes.
- NSTemperatureAuxTemperature is an auxiliary value computed from the total energy based on the FluidProperties.
- NSVelocityAuxVelocity auxiliary value.
- SpecificInternalEnergyAux
- SpecificVolumeAux
- Chemical Reactions App
- AqueousEquilibriumRxnAuxConcentration of secondary equilibrium species
- EquilibriumConstantAuxEquilibrium constant for a given equilibrium species (in form log10(Keq))
- KineticDisPreConcAuxConcentration of secondary kinetic species
- KineticDisPreRateAuxKinetic rate of secondary kinetic species
- PHAuxpH of solution
- TotalConcentrationAuxTotal concentration of primary species (including stoichiometric contribution to secondary equilibrium species)
- XFEMApp
- XFEMCutPlaneAuxComputes the normal and origin of a cutting plane for each partial element.
- XFEMMarkerAuxIdentify the crack tip elements.
- XFEMVolFracAuxComputes the volume fraction of the physical material in each partial element.
- Geochemistry App
- GeochemistryQuantityAuxExtracts information from the Reactor and records it in the AuxVariable

### AuxKernels/MatVecRealGradAuxKernel

- Phase Field App
- MatVecRealGradAuxKernelAction

### AuxKernels/MaterialVectorAuxKernel

- Phase Field App
- MaterialVectorAuxKernelAction

### AuxKernels/MaterialVectorGradAuxKernel

- Phase Field App
- MaterialVectorGradAuxKernelAction

## AuxScalarKernels

- Moose App
- AddScalarKernelAction
- ConstantScalarAux
- FunctionScalarAux
- QuotientScalarAux
- ScalarTagMatrixAuxCouple a tag matrix, and return its nodal value
- ScalarTagVectorAuxCouple a tag vector, and return its value
- SolutionScalarAuxSets scalar variable by using information from a SolutionUserObject.
- Tensor Mechanics App
- GeneralizedPlaneStrainReferenceResidualGeneralized Plane Strain Reference Residual Scalar Kernel

## AuxVariables

- Moose App
- AddAuxVariableAction
- CopyNodalVarsAction
- ArrayMooseVariableUsed for grouping standard field variables with the same finite element family and order
- MooseVariableRepresents standard field variables, e.g. Lagrange, Hermite, or non-constant Monomials
- MooseVariableBaseBase class for Moose variables. This should never be the terminal object type
- MooseVariableConstMonomialSpecialization for constant monomials that avoids unnecessary loops
- MooseVariableFVRealBase class for Moose variables. This should never be the terminal object type
- MooseVariableScalarMoose wrapper class around scalar variables
- VectorMooseVariableRepresents vector field variables, e.g. Vector Lagrange or Nedelec
- MultiAuxVariables
- Phase Field App
- MultiAuxVariables

### AuxVariables/MultiAuxVariables

- Moose App
- MooseVariableRepresents standard field variables, e.g. Lagrange, Hermite, or non-constant Monomials
- MooseVariableBaseBase class for Moose variables. This should never be the terminal object type
- MooseVariableConstMonomialSpecialization for constant monomials that avoids unnecessary loops
- MooseVariableFVRealBase class for Moose variables. This should never be the terminal object type
- MooseVariableScalarMoose wrapper class around scalar variables
- VectorMooseVariableRepresents vector field variables, e.g. Vector Lagrange or Nedelec
- Phase Field App
- MultiAuxVariablesActionSet up auxvariables for components of MaterialProperty<std::vector<data_type> > for polycrystal sample.

## BCs

- Moose App
- AddBCAction
- ADDirichletBCImposes the essential boundary condition , where is a constant, controllable value.
- ADFunctionDirichletBCImposes the essential boundary condition , where is calculated by a function.
- ADFunctionNeumannBCImposes the integrated boundary condition , where is a (possibly) time and space-dependent MOOSE Function.
- ADFunctionPenaltyDirichletBCEnforces a (possibly) time and space-dependent MOOSE Function Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the Dirichlet data.
- ADFunctionPresetBCThe same as ADFunctionDirichletBC except the value is applied before the solve begins
- ADNeumannBCImposes the integrated boundary condition , where is a constant, controllable value.
- ADPenaltyDirichletBCEnforces a Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the Dirichlet data.
- ADPresetBCSimilar to ADDirichletBC except the value is applied before the solve begins. Deprecated: use ADDirichletBC with preset = true instead.
- ADVectorFunctionDirichletBCImposes the essential boundary condition , where components are calculated with functions.
- ADVectorMatchedValueBCImplements a ADVectorNodalBC which equates two different Variables' values on a specified boundary.
- ArrayDirichletBCImposes the essential boundary condition , where are constant, controllable values.
- ArrayPenaltyDirichletBCEnforces a Dirichlet boundary condition in a weak sense with , where is the constant scalar penalty; is the test functions and is the differences between the current solution and the Dirichlet data.
- ArrayVacuumBCImposes the Robin boundary condition .
- ConvectiveFluxBCDetermines boundary values via the initial and final values, flux, and exposure duration
- CoupledVarNeumannBCImposes the integrated boundary condition , where is a variable.
- DGFunctionDiffusionDirichletBC
- DiffusionFluxBCComputes a boundary residual contribution consistent with the Diffusion Kernel. Does not impose a boundary condition; instead computes the boundary contribution corresponding to the current value of grad(u) and accumulates it in the residual vector.
- DirichletBCImposes the essential boundary condition , where is a constant, controllable value.
- EigenArrayDirichletBCArray Dirichlet BC for eigenvalue solvers
- EigenDirichletBCDirichlet BC for eigenvalue solvers
- FunctionDirichletBCImposes the essential boundary condition , where is a (possibly) time and space-dependent MOOSE Function.
- FunctionGradientNeumannBCImposes the integrated boundary condition arising from integration by parts of a diffusion/heat conduction operator, and where the exact solution can be specified.
- FunctionNeumannBCImposes the integrated boundary condition , where is a (possibly) time and space-dependent MOOSE Function.
- FunctionPenaltyDirichletBCEnforces a (possibly) time and space-dependent MOOSE Function Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the Dirichlet data.
- FunctionPresetBCThe same as FunctionDirichletBC except the value is applied before the solve begins. Deprecated: use FunctionDirichletBC with preset = true instead.
- LagrangeVecDirichletBCImposes the essential boundary condition , where are constant, controllable values.
- LagrangeVecFunctionDirichletBCImposes the essential boundary condition , where components are calculated with functions.
- MatchedValueBCImplements a NodalBC which equates two different Variables' values on a specified boundary.
- NeumannBCImposes the integrated boundary condition , where is a constant, controllable value.
- OneDEqualValueConstraintBC
- PenaltyDirichletBCEnforces a Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the Dirichlet data.
- PostprocessorDirichletBC
- PostprocessorNeumannBC
- PresetBCSimilar to DirichletBC except the value is applied before the solve begins. Deprecated: use DirichletBC with preset = true instead.
- SinDirichletBCImposes a time-varying essential boundary condition , where varies from an given initial value at time to a given final value over a specified duration.
- SinNeumannBCImposes a time-varying flux boundary condition , where varies from an given initial value at time to a given final value over a specified duration.
- VacuumBC
- VectorDirichletBCImposes the essential boundary condition , where are constant, controllable values.
- VectorFunctionDirichletBCImposes the essential boundary condition , where components are calculated with functions.
- VectorNeumannBCImposes the integrated boundary condition , where is a user-defined, constant vector.
- VectorPenaltyDirichletBCEnforces a Dirichlet boundary condition for vector nonlinear variables in a weak sense by applying a penalty to the difference in the current solution and the Dirichlet data.
- WeakGradientBCComputes a boundary residual contribution consistent with the Diffusion Kernel. Does not impose a boundary condition; instead computes the boundary contribution corresponding to the current value of grad(u) and accumulates it in the residual vector.
- Periodic
- Rdg App
- AEFVBCA boundary condition kernel for the advection equation using a cell-centered finite volume method.
- Heat Conduction App
- ADConvectiveHeatFluxBCConvective heat transfer boundary condition with temperature and heat transfer coefficent given by material properties.
- ConvectiveFluxFunctionDetermines boundary value by fluid heat transfer coefficient and far-field temperature
- ConvectiveHeatFluxBCConvective heat transfer boundary condition with temperature and heat transfer coefficent given by material properties.
- CoupledConvectiveFlux
- CoupledConvectiveHeatFluxBCConvective heat transfer boundary condition with temperature and heat transfer coefficent given by auxiliary variables.
- GapHeatTransferTransfers heat across a gap between two surfaces dependent on the gap geometry specified.
- GrayLambertNeumannBCThis BC imposes a heat flux density that is computed from the GrayLambertSurfaceRadiationBase userobject.
- HeatConductionBC
- InfiniteCylinderRadiativeBCBoundary condition for radiative heat exchange with a cylinderwhere the boundary is approximated as a cylinder as well.
- Porous Flow App
- PorousFlowHalfCubicSinkApplies a flux sink to a boundary. The base flux defined by PorousFlowSink is multiplied by a cubic.
- PorousFlowHalfGaussianSinkApplies a flux sink to a boundary. The base flux defined by PorousFlowSink is multiplied by a Gaussian.
- PorousFlowPiecewiseLinearSinkApplies a flux sink to a boundary. The base flux defined by PorousFlowSink is multiplied by a piecewise linear function.
- PorousFlowSinkApplies a flux sink to a boundary.
- Tensor Mechanics App
- ADPressureApplies a pressure on a given boundary in a given direction
- CoupledPressureBCApplies a pressure from a variable on a given boundary in a given direction
- DashpotBC
- DisplacementAboutAxisImplements a boundary condition that enforces rotationaldisplacement around an axis on a boundary
- InteractionIntegralBenchmarkBCImplements a boundary condition that enforces a displacement field around a crack tip based on applied stress intensity factors.
- PenaltyInclinedNoDisplacementBCPenalty Enforcement of an inclined boundary condition
- PresetAccelerationPrescribe acceleration on a given boundary in a given direction
- PresetDisplacementPrescribe the displacement on a given boundary in a given direction.
- PresetVelocity
- PressureApplies a pressure on a given boundary in a given direction
- StickyBCImposes the boundary condition if exceeds the bounds provided
- CavityPressure
- CoupledPressure
- InclinedNoDisplacementBC
- Pressure
- Functional Expansion Tools App
- FXFluxBCSets a flux boundary condition, evaluated using a FunctionSeries instance. This does not fix the flux, but rather 'strongly encourages' flux agreement by penalizing the differences through contributions to the residual.
- FXValueBCImposes a fixed value boundary condition, evaluated using a FunctionSeries instance.
- FXValuePenaltyBCSets a value boundary condition, evaluated using a FunctionSeries instance. This does not fix the value, but rather 'strongly encourages' value agreement by penalizing the differences through contributions to the residual.
- Navier Stokes App
- AdvectionBCBoundary conditions for outflow/outflow of advected quantities: phi * velocity * normal, where phi is the advected quantitiy
- EnergyFreeBC
- INSADMomentumNoBCBCThis class implements the 'No BC' boundary condition based on the 'Laplace' form of the viscous stress tensor.
- INSMomentumNoBCBCLaplaceFormThis class implements the 'No BC' boundary condition based on the 'Laplace' form of the viscous stress tensor.
- INSMomentumNoBCBCTractionFormThis class implements the 'No BC' boundary condition based on the 'traction' form of the viscous stress tensor.
- INSTemperatureNoBCBCThis class implements the 'No BC' boundary condition discussed by Griffiths, Papanastiou, and others.
- ImplicitNeumannBCThis class implements a form of the Neumann boundary condition in which the boundary term is treated 'implicitly'.
- MassFreeBC
- MomentumFreeBC
- MomentumFreeSlipBC
- NSEnergyInviscidSpecifiedBCThis class corresponds to the inviscid part of the 'natural' boundary condition for the energy equation.
- NSEnergyInviscidSpecifiedDensityAndVelocityBCThis class corresponds to the inviscid part of the 'natural' boundary condition for the energy equation.
- NSEnergyInviscidSpecifiedNormalFlowBCThis class corresponds to the inviscid part of the 'natural' boundary condition for the energy equation.
- NSEnergyInviscidSpecifiedPressureBCThis class corresponds to the inviscid part of the 'natural' boundary condition for the energy equation.
- NSEnergyInviscidUnspecifiedBCThis class corresponds to the inviscid part of the 'natural' boundary condition for the energy equation.
- NSEnergyViscousBCThis class couples together all the variables for the compressible Navier-Stokes equations to allow them to be used in derived IntegratedBC classes.
- NSEnergyWeakStagnationBCThe inviscid energy BC term with specified normal flow.
- NSImposedVelocityBCImpose Velocity BC.
- NSImposedVelocityDirectionBCThis class imposes a velocity direction component as a Dirichlet condition on the appropriate momentum equation.
- NSInflowThermalBCThis class is used on a boundary where the incoming flow values (rho, u, v, T) are all completely specified.
- NSMassSpecifiedNormalFlowBCThis class implements the mass equation boundary term with a specified value of rho*(u.n) imposed weakly.
- NSMassUnspecifiedNormalFlowBCThis class implements the mass equation boundary term with the rho*(u.n) boundary integral computed implicitly.
- NSMassWeakStagnationBCThe inviscid energy BC term with specified normal flow.
- NSMomentumConvectiveWeakStagnationBCThe convective part (sans pressure term) of the momentum equation boundary integral evaluated at specified stagnation temperature, stagnation pressure, and flow direction values.
- NSMomentumInviscidNoPressureImplicitFlowBCMomentum equation boundary condition used when pressure
*is not*integrated by parts. - NSMomentumInviscidSpecifiedNormalFlowBCMomentum equation boundary condition in which pressure is specified (given) and the value of the convective part is allowed to vary (is computed implicitly).
- NSMomentumInviscidSpecifiedPressureBCMomentum equation boundary condition in which pressure is specified (given) and the value of the convective part is allowed to vary (is computed implicitly).
- NSMomentumPressureWeakStagnationBCThis class implements the pressure term of the momentum equation boundary integral for use in weak stagnation boundary conditions.
- NSMomentumViscousBCThis class corresponds to the viscous part of the 'natural' boundary condition for the momentum equations.
- NSPenalizedNormalFlowBCThis class penalizes the the value of u.n on the boundary so that it matches some desired value.
- NSPressureNeumannBCThis kernel is appropriate for use with a 'zero normal flow' boundary condition in the context of the Euler equations.
- NSStagnationPressureBCThis Dirichlet condition imposes the condition p_0 = p_0_desired.
- NSStagnationTemperatureBCThis Dirichlet condition imposes the condition T_0 = T_0_desired.
- NSThermalBCNS thermal BC.
- Peridynamics App
- RBMPresetOldValuePDClass to apply a preset BC to nodes with rigid body motion (RBM).
- Chemical Reactions App
- ChemicalOutFlowBCChemical flux boundary condition
- XFEMApp
- CrackTipEnrichmentCutOffBCImposes the essential boundary condition , where is a constant, controllable value.

### BCs/CavityPressure

- Tensor Mechanics App
- CavityPressureActionAction to setup cavity pressure boundary condition
- CavityPressurePPActionThis Action creates a CavityPressurePostprocessor.
- CavityPressureUOActionAction to add user objects for cavity pressure

### BCs/CoupledPressure

- Tensor Mechanics App
- CoupledPressureActionSet up Coupled Pressure boundary conditions

### BCs/InclinedNoDisplacementBC

- Tensor Mechanics App
- InclinedNoDisplacementBCActionSet up inclined no displacement boundary conditions

### BCs/Periodic

- Moose App
- AddPeriodicBCActionAction that adds periodic boundary conditions

### BCs/Pressure

- Tensor Mechanics App
- PressureActionSet up Pressure boundary conditions

## Constraints

- Moose App
- AddConstraintAction
- CoupledTiedValueConstraint
- EqualGradientConstraintEqualGradientConstraint enforces continuity of a gradient component between secondary and primary sides of a mortar interface using lagrange multipliers
- EqualValueBoundaryConstraint
- EqualValueConstraintEqualValueConstraint enforces solution continuity between secondary and primary sides of a mortar interface using lagrange multipliers
- EqualValueEmbeddedConstraintThis is a constraint enforcing overlapping portions of two blocks to have the same variable value
- LinearNodalConstraintConstrains secondary node to move as a linear combination of primary nodes.
- NodalFrictionalConstraintFrictional nodal constraint for contact
- NodalStickConstraintSticky nodal constraint for contact
- NormalMortarMechanicalContactThis class is used to apply normal contact forces using lagrange multipliers
- NormalNodalLMMechanicalContactImplements the KKT conditions for normal contact using an NCP function. Requires that either the gap distance or the normal contact pressure (represented by the value of
`variable`

) is zero. The LM variable must be of the same order as the mesh - OldEqualValueConstraintOldEqualValueConstraint enforces solution continuity between secondary and primary sides of a mortar interface using lagrange multipliers
- TangentialMortarLMMechanicalContactEnsures that the Karush-Kuhn-Tucker conditions of Coulomb frictional contact are satisfied
- TangentialMortarMechanicalContactUsed to apply tangential stresses from frictional contact using lagrange multipliers
- TiedValueConstraint
- Heat Conduction App
- GapConductanceConstraintComputes the residual and Jacobian contributions for the 'Lagrange Multiplier' implementation of the thermal contact problem. For more information, see the detailed description here: http://tinyurl.com/gmmhbe9
- Contact App
- MechanicalContactConstraintApply non-penetration constraints on the mechanical deformation using a node on face, primary/secondary algorithm, and multiple options for the physical behavior on the interface and the mathematical formulation for constraint enforcement
- NormalMortarLMMechanicalContactEnforces the normal contact complementarity conditions in a mortar discretization
- NormalNodalMechanicalContactApplies the normal contact force to displacement residuals through a Lagrange Multiplier
- RANFSNormalMechanicalContactApplies the Reduced Active Nonlinear Function Set scheme in which the secondary node's non-linear residual function is replaced by the zero penetration constraint equation when the constraint is active
- TangentialNodalLMMechanicalContactImplements the KKT conditions for frictional Coulomb contact using an NCP function. Requires that either the relative tangential velocity is zero or the tangential stress is equal to the friction coefficient times the normal contact pressure.
- XFEMApp
- XFEMEqualValueAtInterfaceEnforce that the solution have the same value on opposing sides of an XFEM interface.
- XFEMSingleVariableConstraintEnforce constraints on the value or flux associated with a variable at an XFEM interface.

## Contact

- Contact App
- ContactActionSets up all objects needed for mechanical contact enforcement

## Controls

- Moose App
- AddControlAction
- BoolFunctionControlSets the value of a 'bool' input parameters to the value of a provided function.
- ConditionalFunctionEnableControlControl for enabling/disabling objects when a function value is true
- RealFunctionControlSets the value of a 'Real' input parameters to the value of a provided function.
- TimePeriodControl the enabled/disabled state of objects with time.
- Stochastic Tools App
- MultiAppCommandLineControlControl for modifying the command line arguments of MultiApps.
- SamplerReceiverControl for receiving data from a Sampler via SamplerParameterTransfer.

## Covariance

- Stochastic Tools App
- AddCovarianceActionAdds Covariance objects contained within the
`[Trainers]`

and`[Surrogates]`

input blocks. - ExponentialCovarianceExponential covariance function.
- MaternHalfIntCovarianceMatern half-integer covariance function.
- SquaredExponentialCovarianceSquared Exponential covariance function.

## DGKernels

- Moose App
- AddDGKernelAction
- ADDGDiffusionDG kernel for diffusion operator
- ArrayDGDiffusionImplements interior penalty method for array diffusion equations.
- DGConvectionDG upwinding for the convection
- DGDiffusion
- Rdg App
- AEFVKernelA dgkernel for the advection equation using a cell-centered finite volume method.

## Dampers

- Moose App
- AddDamperAction
- BoundingValueElementDamper
- BoundingValueNodalDamper
- ConstantDamper
- MaxIncrementLimits a variable's update by some max fraction
- Tensor Mechanics App
- ElementJacobianDamperDamper that limits the change in element Jacobians
- Contact App
- ContactSlipDamperDamp the iterative solution to minimize oscillations in frictional contact constriants between nonlinear iterations

## Debug

- Moose App
- SetupDebugActionAdds various debugging type Output objects to the simulation system.
- SetupResidualDebugActionAdds the necessary objects for computing the residuals for individual variables.
- MaterialDerivativeTest

### Debug/MaterialDerivativeTest

- Moose App
- MaterialDerivativeTestActionAction for setting up the necessary objects for debugging material property derivatives.

## DeprecatedBlock

- Moose App
- DeprecatedBlockAction

## DiracKernels

- Moose App
- AddDiracKernelAction
- ConstantPointSource
- FunctionDiracSource
- Heat Conduction App
- GapHeatPointSourceMaster
- Porous Flow App
- PorousFlowPeacemanBoreholeApproximates a borehole in the mesh using the Peaceman approach, ie using a number of point sinks with given radii whose positions are read from a file. NOTE: if you are using PorousFlowPorosity that depends on volumetric strain, you should set strain_at_nearest_qp=true in your GlobalParams, to ensure the nodal Porosity Material uses the volumetric strain at the Dirac quadpoints, and can therefore be computed
- PorousFlowPointSourceFromPostprocessorPoint source (or sink) that adds (or removes) fluid at a mass flux rate specified by a postprocessor.
- PorousFlowPolyLineSinkApproximates a polyline sink by using a number of point sinks with given weighting whose positions are read from a file. NOTE: if you are using PorousFlowPorosity that depends on volumetric strain, you should set strain_at_nearest_qp=true in your GlobalParams, to ensure the nodal Porosity Material uses the volumetric strain at the Dirac quadpoints, and can therefore be computed
- PorousFlowSquarePulsePointSourcePoint source (or sink) that adds (removes) fluid at a constant mass flux rate for times between the specified start and end times.
- XFEMApp
- XFEMPressureApplies a pressure on an interface cut by XFEM.
- Contact App
- ContactPrimary
- SecondaryConstraint

## Distributions

- Moose App
- AddDistributionAction
- Stochastic Tools App
- BoostLognormalBoost Lognormal distribution.
- BoostNormalBoost Normal distribution.
- BoostWeibullBoost Weibull distribution.
- JohnsonSBJohnson Special Bounded (SB) distribution.
- LogisticLogistic distribution.
- LognormalLognormal distribution
- NormalNormal distribution
- TruncatedNormalTruncated normal distribution
- UniformContinuous uniform distribution.
- WeibullThree-parameter Weibull distribution.

## DomainIntegral

- Tensor Mechanics App
- DomainIntegralActionCreates the MOOSE objects needed to compute fraction domain integrals

## Executioner

- Moose App
- CreateExecutionerAction
- EigenvalueEigenvalue solves a standard/generalized eigenvaue problem
- InversePowerMethodInverse power method for Eigen value problems.
- NonlinearEigenExecutioner for Eigen value problems.
- SteadyExecutioner for steady-state simulations.
- TransientExecutioner for time varying simulations.
- Adaptivity
- Predictor
- Quadrature
- TimeIntegrator
- TimeStepper
- External Petsc Solver App
- TimeStepper

### Executioner/Adaptivity

- Moose App
- AdaptivityAction

### Executioner/Predictor

### Executioner/Quadrature

- Moose App
- SetupQuadratureAction

### Executioner/TimeIntegrator

- Moose App
- SetupTimeIntegratorAction
- AStableDirk4
- ActuallyExplicitEulerImplementation of Explicit/Forward Euler without invoking any of the nonlinear solver
- BDF2
- CentralDifferenceImplementation of explicit, Central Difference integration without invoking any of the nonlinear solver
- CrankNicolson
- ExplicitEuler
- ExplicitMidpoint
- ExplicitSSPRungeKuttaExplicit strong stability preserving Runge-Kutta methods
- ExplicitTVDRK2
- Heun
- ImplicitEuler
- ImplicitMidpoint
- LStableDirk2
- LStableDirk3
- LStableDirk4
- NewmarkBetaComputes the first and second time derivative of variable using Newmark-Beta method.
- Ralston

### Executioner/TimeStepper

- Moose App
- SetupTimeStepperAction
- AB2PredictorCorrector
- CSVTimeSequenceStepperSolves the Transient problem at a sequence of given time points read in a file.
- ConstantDTTimestepper that takes a constant time step size
- DT2
- ExodusTimeSequenceStepperSolves the Transient problem at a sequence of time points taken from a specified exodus file.
- FunctionDTTimestepper whose steps vary over time according to a user-defined function
- IterationAdaptiveDTAdjust the timestep based on the number of iterations
- LogConstantDTTimeStepper which imposes a time step constant in the logarithmic space
- PostprocessorDT
- SolutionTimeAdaptiveDT
- TimeSequenceStepperSolves the Transient problem at a sequence of given time points.
- External Petsc Solver App
- ExternalPetscTimeStepperTimestepper that queries the step size of the external petsc solver, and use that as the time step size.

## FVBCs

- Moose App
- CheckFVBCAction
- AddFVBCAction
- FVConstantScalarOutflowBC
- FVDirichletBC
- FVMatAdvectionOutflowBCOutflow boundary condition taking the advected quantity from a material property
- FVNeumannBC

## FVKernels

- Moose App
- AddFVKernelAction
- FVAdvection
- FVBodyForceDemonstrates the multiple ways that scalar values can be introduced into finite volume kernels, e.g. (controllable) constants, functions, and postprocessors.
- FVCoupledForceImplements a source term proportional to the value of a coupled variable.
- FVDiffusion
- FVMatAdvection
- FVReactionSimple consuming reaction term
- FVTimeKernel

## FluidPropertiesInterrogator

- Fluid Properties App
- AddFluidPropertiesInterrogatorActionAction that sets up the fluid properties interrogator

## Functions

- Moose App
- AddFunctionAction
- Axisymmetric2D3DSolutionFunctionFunction for reading a 2D axisymmetric solution from file and mapping it to a 3D Cartesian model
- BicubicSplineFunction
- CoarsenedPiecewiseLinearPerform a point reduction of the tabulated data upon initialization, then evaluate using a linear interpolation.
- CompositeFunctionMultiplies an arbitrary set of functions together
- ConstantFunction
- ImageFunctionFunction with values sampled from an image or image stack.
- LinearCombinationFunctionReturns the linear combination of the functions
- ParsedFunctionFunction created by parsing a string
- ParsedGradFunction
- ParsedVectorFunction
- PiecewiseBilinearInterpolates values from a csv file
- PiecewiseConstantDefines data using a set of x-y data pairs
- PiecewiseLinearLinearly interpolates between pairs of x-y data
- PiecewiseMulticonstantPiecewiseMulticonstant performs constant interpolation on 1D, 2D, 3D or 4D data. The data_file specifies the axes directions and the function values. If a point lies outside the data range, the appropriate end value is used.
- PiecewiseMultilinearPiecewiseMultilinear performs linear interpolation on 1D, 2D, 3D or 4D data. The data_file specifies the axes directions and the function values. If a point lies outside the data range, the appropriate end value is used.
- SolutionFunction
- SplineFunction
- TestSetupPostprocessorDataActionFunction
- VectorPostprocessorFunctionProvides piecewise linear interpolation of from two columns of a VectorPostprocessor
- Navier Stokes App
- WedgeFunctionFunction which computes the exact solution for Jeffery-Hamel flow in a wedge.
- Level Set App
- LevelSetOlssonBubbleImplementation of 'bubble' ranging from 0 to 1.
- LevelSetOlssonPlaneImplementation of a level set function to represent a plane.
- LevelSetOlssonVortexA function for creating vortex velocity fields for level set equation benchmark problems.
- Fluid Properties App
- SaturationPressureFunctionComputes saturation pressure from temperature function and 2-phase fluid properties object
- SaturationTemperatureFunctionComputes saturation temperature from pressure function and 2-phase fluid properties object
- Porous Flow App
- MovingPlanarFrontThis function defines the position of a moving front. The front is an infinite plane with normal pointing from start_posn to end_posn. The front's distance from start_posn is defined by 'distance', so if the 'distance' function is time dependent, the front's position will change with time. Roughly speaking, the function returns true_value for points lying in between start_posn and start_posn + distance. Precisely speaking, two planes are constructed, both with normal pointing from start_posn to end_posn. The first plane passes through start_posn; the second plane passes through end_posn. Given a point p and time t, this function returns false_value if ANY of the following are true: (a) t<activation_time; (b) t>=deactivation_time; (c) p is 'behind' start_posn (ie, p lies on one side of the start_posn plane and end_posn lies on the other side); (d) p is 'ahead' of the front (ie, p lies one one side of the front and start_posn lies on the other side); (e) the distance between p and the front is greater than active_length. Otherwise, the point is 'in the active zone' and the function returns true_value.
- Phase Field App
- FourierNoiseGenerate noise from a fourier series
- Functional Expansion Tools App
- FunctionSeriesThis function uses a convolution of functional series (functional expansion or FX) to create a 1D, 2D, or 3D function

## GeochemicalModelInterrogator

- Geochemistry App
- AddGeochemicalModelInterrogatorActionAction that sets up the geochemical model interrogator

## GlobalParams

- Moose App
- GlobalParamsAction

## GrayDiffuseRadiation

- Heat Conduction App
- RadiationTransferActionThis action sets up the net radiation calculation between specified sidesets.

## ICs

- Moose App
- AddInitialConditionAction
- ArrayConstantICSets constant component values for an array field variable.
- ArrayFunctionICAn initial condition that uses a normal function of x, y, z to produce values (and optionally gradients) for a field variable.
- BoundingBoxICBoundingBoxIC allows setting the initial condition of a value inside and outside of a specified box. The box is aligned with the x, y, z axes
- ConstantICSets a constant field value.
- FunctionICAn initial condition that uses a normal function of x, y, z to produce values (and optionally gradients) for a field variable.
- FunctionScalarIC
- RandomICInitialize a variable with randomly generated numbers following either a uniform distribution or a user-defined distribution
- ScalarComponentIC
- ScalarConstantIC
- VectorConstantICSets constant component values for a vector field variable.
- VectorFunctionICSets component values for a vector field variable based on a vector function.
- Navier Stokes App
- NSInitialConditionNSInitialCondition sets intial constant values for all variables.
- Fluid Properties App
- RhoFromPressureTemperatureICComputes the density from pressure and temperature.
- RhoVaporMixtureFromPressureTemperatureICComputes the density of a vapor mixture from pressure and temperature.
- SpecificEnthalpyFromPressureTemperatureICComputes the specific enthalpy from pressure and temperature.
- Porous Flow App
- PorousFlowFluidPropertyICAn initial condition to calculate one fluid property (such as enthalpy) from pressure and temperature
- PorousFlowFluidStateBrineCO2ICAn initial condition to calculate z from saturation for brine and CO2
- PorousFlowFluidStateICAn initial condition to calculate z from saturation
- PorousFlowFluidStateWaterNCGICAn initial condition to calculate z from saturation for water and non-condensable gas
- Tensor Mechanics App
- VolumeWeightedWeibullInitialize a variable with randomly generated numbers following a volume-weighted Weibull distribution
- Phase Field App
- BimodalInverseSuperellipsoidsICBimodal size distribution of large particles (specified in input file, value invalue) and small particles (placed randomly inside the larger particles, value outvalue)
- BimodalSuperellipsoidsICBimodal size distribution of large particles (specified in input file) and small particles (placed randomly outside the larger particles)
- BndsCalcICInitialize the location of grain boundaries in a polycrystalline sample
- ClosePackICClose packed arrangement of smooth circles
- CrossICCross-shaped initial condition
- IsolatedBoundingBoxICSpecify variable values inside and outside a list of isolated boxes shaped axis-aligned regions defined by pairs of opposing corners
- LatticeSmoothCircleICPerturbed square lattice of smooth circles
- MultiBoundingBoxICAllows setting the initial condition of a value of a field inside and outside multiple bounding boxes.
- MultiSmoothCircleICRandom distribution of smooth circles with given minimum spacing
- MultiSmoothSuperellipsoidICRandom distribution of smooth ellipse with given minimum spacing
- NestedBoundingBoxICSpecify variable values inside a list of nested boxes shaped axis-aligned regions defined by pairs of opposing corners
- PFCFreezingICBase class for generating a random field for a variable.
- PolycrystalColoringICRandom Voronoi tesselation polycrystal (used by PolycrystalVoronoiICAction)
- PolycrystalRandomICRandom initial condition for a polycrystalline material
- PolycrystalVoronoiVoidICRandom distribution of smooth circles with given minimum spacing
- RampICLinear ramp along the x-axis with given values at the left and right extreme points.
- ReconPhaseVarIC
- RndBoundingBoxICRandom noise with different min/max inside/outside of a bounding box
- RndSmoothCircleICRandom noise with different min/max inside/outside of a smooth circle
- SmoothCircleFromFileICMultiple smooth circles read from a text file
- SmoothCircleICCircle with a smooth interface
- SmoothSuperellipsoidICSuperellipsoid with a smooth interface
- SpecifiedSmoothCircleICMultiple smooth circles with manually specified radii and center points
- SpecifiedSmoothSuperellipsoidICMultiple smooth superellipsoids with manually specified center points; semiaxes a,b,c; and exponents n
- ThumbICThumb shaped bicrystal for grain boundary mobility tests
- Tricrystal2CircleGrainsICTricrystal with two circles/bubbles
- TricrystalTripleJunctionICTricrystal with a triple junction
- PolycrystalICs

### ICs/PolycrystalICs

- Phase Field App
- BicrystalBoundingBoxIC
- BicrystalCircleGrainIC
- PolycrystalColoringIC
- PolycrystalRandomIC
- PolycrystalVoronoiVoidIC
- Tricrystal2CircleGrainsIC

#### ICs/PolycrystalICs/BicrystalBoundingBoxIC

- Phase Field App
- BicrystalBoundingBoxICActionConstructs a bicrystal, where one grain is on the inside of the box and the other grain is the outside of the box

#### ICs/PolycrystalICs/BicrystalCircleGrainIC

- Phase Field App
- BicrystalCircleGrainICActionBicrystal with a circular grain and an embedding outer grain

#### ICs/PolycrystalICs/PolycrystalColoringIC

- Phase Field App
- PolycrystalColoringICActionRandom Voronoi tessellation polycrystal action

#### ICs/PolycrystalICs/PolycrystalRandomIC

- Phase Field App
- PolycrystalRandomICAction

#### ICs/PolycrystalICs/PolycrystalVoronoiVoidIC

- Phase Field App
- PolycrystalVoronoiVoidICAction

#### ICs/PolycrystalICs/Tricrystal2CircleGrainsIC

- Phase Field App
- Tricrystal2CircleGrainsICAction

## InterfaceKernels

- Moose App
- AddInterfaceKernelAction
- InterfaceReactionImplements a reaction to establish ReactionRate=k_f*u-k_b*v at interface.
- Heat Conduction App
- ConjugateHeatTransferThis InterfaceKernel models conjugate heat transfer. Fluid side must be primary side and solid side must be secondary side. T_fluid is provided in case that variable (
__fluid energy variable) is not temperature but e.g. internal energy.__ - SideSetHeatTransferKernelModeling conduction, convection, and radiation across internal side set.
- Tensor Mechanics App
- CZMInterfaceKernelInterface kernel for use with cohesive zone models (CZMs) that compute traction as a function of the displacement jump
- Phase Field App
- EqualGradientLagrangeInterfaceEnforce componentwise gradient continuity between two different variables across a subdomain boundary using a Lagrange multiplier
- EqualGradientLagrangeMultiplierLagrange multiplier kernel for EqualGradientLagrangeInterface.
- InterfaceDiffusionBoundaryTermAdd weak form surface terms of the Diffusion equation for two different variables across a subdomain boundary
- InterfaceDiffusionFluxMatchEnforce flux continuity between two different variables across a subdomain boundary

## Kernels

- Moose App
- AddKernelAction
- ADBodyForceDemonstrates the multiple ways that scalar values can be introduced into kernels, e.g. (controllable) constants, functions, and postprocessors. Implements the weak form .
- ADCoupledTimeDerivativeTime derivative Kernel that acts on a coupled variable. Weak form: .
- ADDiffusionSame as
`Diffusion`

in terms of physics/residual, but the Jacobian is computed using forward automatic differentiation - ADMatAnisoDiffusionDiffusion equation kernel that takes an anisotropic diffusivity from a material property
- ADMatDiffusionDiffusion equation kernel that takes an isotropic diffusivity from a material property
- ADTimeDerivativeThe time derivative operator with the weak form of .
- ADVectorDiffusionThe Laplacian operator (), with the weak form of . The Jacobian is computed using automatic differentiation
- ADVectorTimeDerivativeThe time derivative operator with the weak form of .
- AnisotropicDiffusionAnisotropic diffusion kernel with weak form given by .
- ArrayDiffusionThe array Laplacian operator (), with the weak form of .
- ArrayReactionThe array reaction operator with the weak form of .
- ArrayTimeDerivativeArray time derivative operator with the weak form of .
- BodyForceDemonstrates the multiple ways that scalar values can be introduced into kernels, e.g. (controllable) constants, functions, and postprocessors. Implements the weak form .
- CoefTimeDerivativeThe time derivative operator with the weak form of .
- ConservativeAdvectionConservative form of which in its weak form is given by: .
- CoupledForceImplements a source term proportional to the value of a coupled variable. Weak form: .
- CoupledTimeDerivativeTime derivative Kernel that acts on a coupled variable. Weak form: .
- DiffusionThe Laplacian operator (), with the weak form of .
- MassEigenKernelAn eigenkernel with weak form where is the eigenvalue.
- MassLumpedTimeDerivativeLumped formulation of the time derivative . Its corresponding weak form is where denotes the time derivative of the solution coefficient associated with node .
- MatCoupledForceImplements a forcing term RHS of the form PDE = RHS, where RHS = Sum_j c_j * m_j * v_j. c_j, m_j, and v_j are provided as real coefficients, material properties, and coupled variables, respectively.
- MatDiffusionDiffusion equation Kernel that takes an isotropic Diffusivity from a material property
- MaterialDerivativeRankFourTestKernelClass used for testing derivatives of a rank four tensor material property.
- MaterialDerivativeRankTwoTestKernelClass used for testing derivatives of a rank two tensor material property.
- MaterialDerivativeTestKernelClass used for testing derivatives of a scalar material property.
- MaterialPropertyValueResidual term (u - prop) to set variable u equal to a given material property prop
- NullKernelKernel that sets a zero residual.
- ReactionImplements a simple consuming reaction term with weak form .
- ScalarLagrangeMultiplierThis class is used to enforce integral of phi = V_0 with a Lagrange multiplier approach.
- TimeDerivativeThe time derivative operator with the weak form of .
- UserForcingFunctionDemonstrates the multiple ways that scalar values can be introduced into kernels, e.g. (controllable) constants, functions, and postprocessors. Implements the weak form .
- VectorBodyForceDemonstrates the multiple ways that scalar values can be introduced into kernels, e.g. (controllable) constants, functions, and postprocessors. Implements the weak form .
- VectorCoupledTimeDerivativeTime derivative Kernel that acts on a coupled vector variable. Weak form: .
- VectorDiffusionThe Laplacian operator (), with the weak form of .
- VectorTimeDerivativeThe time derivative operator with the weak form of .
- Heat Conduction App
- ADHeatConductionSame as
`Diffusion`

in terms of physics/residual, but the Jacobian is computed using forward automatic differentiation - ADHeatConductionTimeDerivativeAD Time derivative term of the heat equation for quasi-constant specific heat and the density .
- ADJouleHeatingSourceCalculates the heat source term corresponding to electrostatic Joule heating, with Jacobian contributions calculated using the automatic differentiation system.
- ADMatHeatSourceForce term in thermal transport to represent a heat source
- AnisoHeatConduction
- HeatCapacityConductionTimeDerivativeTime derivative term of the heat equation with the heat capacity as an argument.
- HeatConductionComputes residual/Jacobian contribution for term.
- HeatConductionTimeDerivativeTime derivative term of the heat equation for quasi-constant specific heat and the density .
- HeatSourceDemonstrates the multiple ways that scalar values can be introduced into kernels, e.g. (controllable) constants, functions, and postprocessors. Implements the weak form .
- HomogenizedHeatConductionKernel for asymptotic expansion homogenization for thermal conductivity
- INSADHeatConductionTimeDerivativeAD Time derivative term of the heat equation for quasi-constant specific heat and the density .
- JouleHeatingSourceCalculates the heat source term corresponding to electrostatic Joule heating.
- SpecificHeatConductionTimeDerivativeTime derivative term of the heat equation with the specific heat and the density as arguments.
- Tensor Mechanics App
- ADDynamicStressDivergenceTensorsResidual due to stress related Rayleigh damping and HHT time integration terms
- ADGravityApply gravity. Value is in units of acceleration.
- ADInertialForceShellCalculates the residual for the inertial force/moment and the contribution of mass dependent Rayleigh damping and HHT time integration scheme.
- ADStressDivergenceRSphericalTensorsCalculate stress divergence for a spherically symmetric 1D problem in polar coordinates.
- ADStressDivergenceRZTensorsCalculate stress divergence for an axisymmetric problem in cylindrical coordinates.
- ADStressDivergenceShellQuasi-static stress divergence kernel for Shell element
- ADStressDivergenceTensorsStress divergence kernel with automatic differentiation for the Cartesian coordinate system
- ADWeakPlaneStressPlane stress kernel to provide out-of-plane strain contribution.
- AsymptoticExpansionHomogenizationKernelKernel for asymptotic expansion homogenization for elasticity
- CosseratStressDivergenceTensorsStress divergence kernel for the Cartesian coordinate system
- DynamicStressDivergenceTensorsResidual due to stress related Rayleigh damping and HHT time integration terms
- GeneralizedPlaneStrainOffDiagGeneralized Plane Strain kernel to provide contribution of the out-of-plane strain to other kernels
- GravityApply gravity. Value is in units of acceleration.
- InertialForceCalculates the residual for the inertial force () and the contribution of mass dependent Rayleigh damping and HHT time integration scheme ($\eta \cdot M \cdot ((1+\alpha)velq2-\alpha \cdot vel-old) $)
- InertialForceBeamCalculates the residual for the inertial force/moment and the contribution of mass dependent Rayleigh damping and HHT time integration scheme.
- InertialTorqueKernel for inertial torque: density * displacement x acceleration
- MomentBalancing
- OutOfPlanePressureApply pressure in the out-of-plane direction in 2D plane stress or generalized plane strain models
- PhaseFieldFractureMechanicsOffDiagStress divergence kernel for phase-field fracture: Computes off diagonal damage dependent Jacobian components. To be used with StressDivergenceTensors or DynamicStressDivergenceTensors.
- PlasticHeatEnergyPlastic heat energy density = coeff * stress * plastic_strain_rate
- PoroMechanicsCouplingAdds , where the subscript is the component.
- StressDivergenceBeamQuasi-static and dynamic stress divergence kernel for Beam element
- StressDivergenceRSphericalTensorsCalculate stress divergence for a spherically symmetric 1D problem in polar coordinates.
- StressDivergenceRZTensorsCalculate stress divergence for an axisymmetric problem in cylindrical coordinates.
- StressDivergenceTensorsStress divergence kernel for the Cartesian coordinate system
- StressDivergenceTensorsTrussKernel for truss element
- WeakPlaneStressPlane stress kernel to provide out-of-plane strain contribution.
- DynamicTensorMechanics
- PoroMechanics
- TensorMechanics
- Phase Field App
- ACBarrierFunctionAllen-Cahn kernel used when 'mu' is a function of variables
- ACGBPolyGrain-Boundary model concentration dependent residual
- ACGrGrElasticDrivingForceAdds elastic energy contribution to the Allen-Cahn equation
- ACGrGrMultiMulti-phase poly-crystalline Allen-Cahn Kernel
- ACGrGrPolyGrain-Boundary model poly-crystalline interface Allen-Cahn Kernel
- ACInterfaceGradient energy Allen-Cahn Kernel
- ACInterface2DMultiPhase1Gradient energy Allen-Cahn Kernel where the derivative of interface parameter kappa wrt the gradient of order parameter is considered.
- ACInterface2DMultiPhase2Gradient energy Allen-Cahn Kernel where the interface parameter kappa is considered.
- ACInterfaceCleavageFractureGradient energy Allen-Cahn Kernel where crack propagation along weakcleavage plane is preferred
- ACInterfaceKobayashi1Anisotropic gradient energy Allen-Cahn Kernel Part 1
- ACInterfaceKobayashi2Anisotropic Gradient energy Allen-Cahn Kernel Part 2
- ACInterfaceStressInterface stress driving force Allen-Cahn Kernel
- ACKappaFunctionGradient energy term for when kappa as a function of the variable
- ACMultiInterfaceGradient energy Allen-Cahn Kernel with cross terms
- ACSEDGPolyStored Energy contribution to grain growth
- ACSwitchingKernel for Allen-Cahn equation that adds derivatives of switching functions and energies
- ADACInterfaceGradient energy Allen-Cahn Kernel
- ADAllenCahnAllen-Cahn Kernel that uses a DerivativeMaterial Free Energy
- ADCHSoretMobilityAdds contribution due to thermo-migration to the Cahn-Hilliard equation using a concentration 'u', temperature 'T', and thermal mobility 'mobility' (in units of length squared per time).
- ADCHSplitChemicalPotentialChemical potential kernel in Split Cahn-Hilliard that solves chemical potential in a weak form
- ADCHSplitConcentrationConcentration kernel in Split Cahn-Hilliard that solves chemical potential in a weak form
- ADGrainGrowthGrain-Boundary model poly-crystalline interface Allen-Cahn Kernel
- ADMatReactionKernel to add -L*v, where L=reaction rate, v=variable
- ADSplitCHParsedSplit formulation Cahn-Hilliard Kernel that uses a DerivativeMaterial Free Energy
- ADSplitCHWResSplit formulation Cahn-Hilliard Kernel for the chemical potential variable with a scalar (isotropic) mobility
- ADSplitCHWResAnisoSplit formulation Cahn-Hilliard Kernel for the chemical potential variable with a scalar (isotropic) mobility
- AllenCahnAllen-Cahn Kernel that uses a DerivativeMaterial Free Energy
- AllenCahnElasticEnergyOffDiagThis kernel calculates off-diagonal Jacobian of elastic energy in AllenCahn with respect to displacements
- AntitrappingCurrentKernel that provides antitrapping current at the interface for alloy solidification
- CHBulkPFCTradCahn-Hilliard kernel for a polynomial phase field crystal free energy.
- CHInterfaceGradient energy Cahn-Hilliard Kernel with a scalar (isotropic) mobility
- CHInterfaceAnisoGradient energy Cahn-Hilliard Kernel with a tensor (anisotropic) mobility
- CHMathSimple demonstration Cahn-Hilliard Kernel using an algebraic double-well potential
- CHPFCRFFCahn-Hilliard residual for the RFF form of the phase field crystal model
- CHSplitChemicalPotentialChemical potential kernel in Split Cahn-Hilliard that solves chemical potential in a weak form
- CHSplitConcentrationConcentration kernel in Split Cahn-Hilliard that solves chemical potential in a weak form
- CHSplitFluxComputes flux as nodal variable
- CahnHilliardCahn-Hilliard Kernel that uses a DerivativeMaterial Free Energy and a scalar (isotropic) mobility
- CahnHilliardAnisoCahn-Hilliard Kernel that uses a DerivativeMaterial Free Energy and a tensor (anisotropic) mobility
- CoefCoupledTimeDerivativeScaled time derivative Kernel that acts on a coupled variable
- CoefReactionImplements the residual term (p*u, test)
- ConservedLangevinNoiseSource term for noise from a ConservedNoise userobject
- CoupledAllenCahnCoupled Allen-Cahn Kernel that uses a DerivativeMaterial Free Energy
- CoupledMaterialDerivativeKernel that implements the first derivative of a function material property with respect to a coupled variable.
- CoupledSusceptibilityTimeDerivativeA modified coupled time derivative Kernel that multiplies the time derivative of a coupled variable by a generalized susceptibility
- CoupledSwitchingTimeDerivativeCoupled time derivative Kernel that multiplies the time derivative by $\frac{dh_\alpha}{d\eta_i} F_\alpha + \frac{dh_\beta}{d\eta_i} F_\beta + \dots)
- DiscreteNucleationForceTerm for inserting grain nuclei or phases in non-conserved order parameter fields
- GradientComponentSet the kernel variable to a specified component of the gradient of a coupled variable.
- HHPFCRFFReaction type kernel for the RFF phase fit crystal model
- KKSACBulkCKKS model kernel (part 2 of 2) for the Bulk Allen-Cahn. This includes all terms dependent on chemical potential.
- KKSACBulkFKKS model kernel (part 1 of 2) for the Bulk Allen-Cahn. This includes all terms NOT dependent on chemical potential.
- KKSCHBulkKKS model kernel for the Bulk Cahn-Hilliard term. This operates on the concentration 'c' as the non-linear variable
- KKSMultiACBulkCMulti-phase KKS model kernel (part 2 of 2) for the Bulk Allen-Cahn. This includes all terms dependent on chemical potential.
- KKSMultiACBulkFKKS model kernel (part 1 of 2) for the Bulk Allen-Cahn. This includes all terms NOT dependent on chemical potential.
- KKSMultiPhaseConcentrationKKS multi-phase model kernel to enforce . The non-linear variable of this kernel is , the final phase concentration in the list.
- KKSPhaseChemicalPotentialKKS model kernel to enforce the pointwise equality of phase chemical potentials dFa/dca = dFb/dcb. The non-linear variable of this kernel is ca.
- KKSPhaseConcentrationKKS model kernel to enforce the decomposition of concentration into phase concentration (1-h(eta))
*ca + h(eta)*cb - c = 0. The non-linear variable of this kernel is cb. - KKSSplitCHCResKKS model kernel for the split Bulk Cahn-Hilliard term. This kernel operates on the physical concentration 'c' as the non-linear variable
- LangevinNoiseSource term for non-conserved Langevin noise
- LaplacianSplitSplit with a variable that holds the Laplacian of a phase field variable.
- MaskedBodyForceKernel that defines a body force modified by a material mask
- MatAnisoDiffusionDiffusion equation Kernel that takes an anisotropic Diffusivity from a material property
- MatGradSquareCoupledGradient square of a coupled variable.
- MatReactionKernel to add -L*v, where L=reaction rate, v=variable
- MultiGrainRigidBodyMotionAdds rigid body motion to grains
- SimpleACInterfaceGradient energy for Allen-Cahn Kernel with constant Mobility and Interfacial parameter
- SimpleCHInterfaceGradient energy for Cahn-Hilliard equation with constant Mobility and Interfacial parameter
- SimpleCoupledACInterfaceGradient energy for Allen-Cahn Kernel with constant Mobility and Interfacial parameter for a coupled order parameter variable.
- SimpleSplitCHWResGradient energy for split Cahn-Hilliard equation with constant Mobility for a coupled order parameter variable.
- SingleGrainRigidBodyMotionAdds rigid mody motion to a single grain
- SoretDiffusionAdd Soret effect to Split formulation Cahn-Hilliard Kernel
- SplitCHMathSimple demonstration split formulation Cahn-Hilliard Kernel using an algebraic double-well potential
- SplitCHParsedSplit formulation Cahn-Hilliard Kernel that uses a DerivativeMaterial Free Energy
- SplitCHWResSplit formulation Cahn-Hilliard Kernel for the chemical potential variable with a scalar (isotropic) mobility
- SplitCHWResAnisoSplit formulation Cahn-Hilliard Kernel for the chemical potential variable with a tensor (anisotropic) mobility
- SusceptibilityTimeDerivativeA modified time derivative Kernel that multiplies the time derivative of a variable by a generalized susceptibility
- SwitchingFunctionConstraintEtaLagrange multiplier kernel to constrain the sum of all switching functions in a multiphase system. This kernel acts on a non-conserved order parameter eta_i.
- SwitchingFunctionConstraintLagrangeLagrange multiplier kernel to constrain the sum of all switching functions in a multiphase system. This kernel acts on the Lagrange multiplier variable.
- SwitchingFunctionPenaltyPenalty kernel to constrain the sum of all switching functions in a multiphase system.
- CHPFCRFFSplitKernel
- HHPFCRFFSplitKernel
- PFCRFFKernel
- PolycrystalElasticDrivingForce
- PolycrystalKernel
- PolycrystalStoredEnergy
- RigidBodyMultiKernel
- Peridynamics App
- ForceStabilizedSmallStrainMechanicsNOSPDClass for calculating residual and Jacobian for the non-ordinary state-based peridynamic solid mechanics formulation using a fictitious force method for stabilization.
- GeneralizedPlaneStrainOffDiagHNOSPDClass for calculating the off-diagonal Jacobian corresponding to coupling between displacements (or temperature) with scalar out-of-plane strain for the generalized plane strain using the HNOSPD formulation
- GeneralizedPlaneStrainOffDiagOSPDClass for calculating the off-diagonal Jacobian corresponding to coupling between displacements (or temperature) and the scalar out-of-plane strain for the generalized plane strain using the OSPD formulation
- HeatConductionBPDClass for calculating the residual and Jacobian for the bond-based peridynamic heat conduction formulation
- HeatSourceBPDClass for calculating the residual from heat source for the bond-based peridynamic heat conduction formulation
- HorizonStabilizedFiniteStrainMechanicsNOSPDClass for calculating the residual and Jacobian for the horizon-stabilized non-ordinary state-based peridynamic correspondence model under finite strain assumptions
- HorizonStabilizedSmallStrainMechanicsNOSPDClass for calculating the residual and Jacobian for the horizon-stabilized non-ordinary state-based peridynamic correspondence model under small strain assumptions
- MechanicsBPDClass for calculating the residual and Jacobian for the bond-based peridynamic mechanics formulation
- MechanicsOSPDClass for calculating the residual and Jacobian for the ordinary state-based peridynamic mechanics formulation
- WeakPlaneStressHNOSPDClass for calculating the residual and Jacobian for the peridynamic plane stress model using weak formulation
- Chemical Reactions App
- CoupledBEEquilibriumSubDerivative of equilibrium species concentration wrt time
- CoupledBEKineticDerivative of kinetic species concentration wrt time
- CoupledConvectionReactionSubConvection of equilibrium species
- CoupledDiffusionReactionSubDiffusion of equilibrium species
- DarcyFluxPressureDarcy flux: - cond * (Grad P - rho * g) where cond is the hydraulic conductivity, P is fluid pressure, rho is fluid density and g is gravity
- DesorptionFromMatrixMass flow rate from the matrix to the porespace. Add this to TimeDerivative kernel to get complete DE for the fluid adsorbed in the matrix
- DesorptionToPorespaceMass flow rate to the porespace from the matrix. Add this to the other kernels for the porepressure variable to form the complete DE
- PrimaryConvectionConvection of primary species
- PrimaryDiffusionDiffusion of primary species
- PrimaryTimeDerivativeDerivative of primary species concentration wrt time
- XFEMApp
- CrackTipEnrichmentStressDivergenceTensorsEnrich stress divergence kernel for small-strain simulations
- Geochemistry App
- GeochemistryDispersionKernel describing grad(porosity * tensor_coeff * grad(concentration)), where porosity is an AuxVariable (or just a real number), tensor_coeff is the hydrodynamic dispersion tensor and concentration is the 'variable' for this Kernel
- GeochemistryTimeDerivativeKernel describing porosity * d(concentration)/dt, where porosity is an AuxVariable (or just a real number) and concentration is the 'variable' for this Kernel. This Kernel should not be used if porosity is time-dependent. Mass lumping is employed for numerical stability
- Porous Flow App
- FluxLimitedTVDAdvectionConservative form of (advection), using the Flux Limited TVD scheme invented by Kuzmin and Turek
- PorousFlowAdvectiveFluxFully-upwinded advective flux of the component given by fluid_component
- PorousFlowBasicAdvectionAdvective flux of a Variable using the Darcy velocity of the fluid phase
- PorousFlowDesorpedMassTimeDerivativeDesorped component mass derivative wrt time.
- PorousFlowDesorpedMassVolumetricExpansionDesorped_mass * rate_of_solid_volumetric_expansion
- PorousFlowDispersiveFluxDispersive and diffusive flux of the component given by fluid_component in all phases
- PorousFlowEffectiveStressCouplingAdds , where the subscript is the component.
- PorousFlowEnergyTimeDerivativeDerivative of heat-energy-density wrt time
- PorousFlowExponentialDecayResidual = rate * (variable - reference). Useful for modelling exponential decay of a variable
- PorousFlowFluxLimitedTVDAdvectionAdvective flux of fluid species or heat using the Flux Limited TVD scheme invented by Kuzmin and Turek
- PorousFlowFullySaturatedDarcyBaseDarcy flux suitable for models involving a fully-saturated, single phase, single component fluid. No upwinding is used
- PorousFlowFullySaturatedDarcyFlowDarcy flux suitable for models involving a fully-saturated single phase, multi-component fluid. No upwinding is used
- PorousFlowFullySaturatedHeatAdvectionHeat flux that arises from the advection of a fully-saturated single phase fluid. No upwinding is used
- PorousFlowFullySaturatedMassTimeDerivativeFully-saturated version of the single-component, single-phase fluid mass derivative wrt time
- PorousFlowHeatAdvectionFully-upwinded heat flux, advected by the fluid
- PorousFlowHeatConductionHeat conduction in the Porous Flow module
- PorousFlowHeatMassTransferCalculate heat or mass transfer from a coupled variable v to the variable u. No mass lumping is performed here.
- PorousFlowHeatVolumetricExpansionEnergy-density*rate_of_solid_volumetric_expansion
- PorousFlowMassRadioactiveDecayRadioactive decay of a fluid component
- PorousFlowMassTimeDerivativeComponent mass derivative wrt time for component given by fluid_component
- PorousFlowMassVolumetricExpansionComponent_mass*rate_of_solid_volumetric_expansion
- PorousFlowPlasticHeatEnergyPlastic heat energy density source = (1 - porosity) * coeff * stress * plastic_strain_rate
- PorousFlowPreDisPrecipitation-dissolution of chemical species
- Misc App
- ADThermoDiffusionCalculates diffusion due to temperature gradient and Soret Coefficient
- CoefDiffusionKernel for diffusion with diffusivity = coef + function
- ThermoDiffusionKernel for thermo-diffusion (Soret effect, thermophoresis, etc.)
- Navier Stokes App
- DistributedForce
- DistributedPower
- INSADBoussinesqBodyForceComputes a body force for natural convection buoyancy.
- INSADEnergyAdvectionThis class computes the residual and Jacobian contributions for temperature advection for a divergence free velocity field.
- INSADEnergyAmbientConvectionComputes a heat source/sink due to convection from ambient surroundings.
- INSADEnergySUPGAdds the supg stabilization to the INS temperature/energy equation
- INSADEnergySourceComputes an arbitrary volumetric heat source (or sink).
- INSADGravityForceComputes a body force due to gravity.
- INSADMassThis class computes the mass equation residual and Jacobian contributions (the latter using automatic differentiation) for the incompressible Navier-Stokes equations.
- INSADMassPSPGThis class adds PSPG stabilization to the mass equation, enabling use of equal order shape functions for pressure and velocity variables
- INSADMomentumAdvectionAdds the advective term to the INS momentum equation
- INSADMomentumCoupledForceComputes a body force due to a coupled vector variable or a vector function
- INSADMomentumPressureAdds the pressure term to the INS momentum equation
- INSADMomentumSUPGAdds the supg stabilization to the INS momentum equation
- INSADMomentumTimeDerivativeThis class computes the time derivative for the incompressible Navier-Stokes momentum equation.
- INSADMomentumViscousAdds the viscous term to the INS momentum equation
- INSChorinCorrectorThis class computes the 'Chorin' Corrector equation in fully-discrete (both time and space) form.
- INSChorinPredictorThis class computes the 'Chorin' Predictor equation in fully-discrete (both time and space) form.
- INSChorinPressurePoissonThis class computes the pressure Poisson solve which is part of the 'split' scheme used for solving the incompressible Navier-Stokes equations.
- INSCompressibilityPenaltyThe penalty term may be used when Dirichlet boundary condition is applied to the entire boundary.
- INSMassThis class computes the mass equation residual and Jacobian contributions for the incompressible Navier-Stokes momentum equation.
- INSMassRZThis class computes the mass equation residual and Jacobian contributions for the incompressible Navier-Stokes momentum equation in RZ coordinates.
- INSMomentumLaplaceFormThis class computes momentum equation residual and Jacobian viscous contributions for the 'Laplacian' form of the governing equations.
- INSMomentumLaplaceFormRZThis class computes additional momentum equation residual and Jacobian contributions for the incompressible Navier-Stokes momentum equation in RZ (axisymmetric cylindrical) coordinates, using the 'Laplace' form of the governing equations.
- INSMomentumTimeDerivativeThis class computes the time derivative for the incompressible Navier-Stokes momentum equation.
- INSMomentumTractionFormThis class computes momentum equation residual and Jacobian viscous contributions for the 'traction' form of the governing equations.
- INSMomentumTractionFormRZThis class computes additional momentum equation residual and Jacobian contributions for the incompressible Navier-Stokes momentum equation in RZ (axisymmetric cylindrical) coordinates.
- INSPressurePoissonThis class computes the pressure Poisson solve which is part of the 'split' scheme used for solving the incompressible Navier-Stokes equations.
- INSProjectionThis class computes the 'projection' part of the 'split' method for solving incompressible Navier-Stokes.
- INSSplitMomentumThis class computes the 'split' momentum equation residual.
- INSTemperatureThis class computes the residual and Jacobian contributions for the incompressible Navier-Stokes temperature (energy) equation.
- INSTemperatureTimeDerivativeThis class computes the time derivative for the incompressible Navier-Stokes momentum equation.
- MassConvectiveFlux
- MomentumConvectiveFlux
- NSEnergyInviscidFluxThis class computes the inviscid part of the energy flux.
- NSEnergyThermalFluxThis class is responsible for computing residuals and Jacobian terms for the k * grad(T) * grad(phi) term in the Navier-Stokes energy equation.
- NSEnergyViscousFluxViscous flux terms in energy equation.
- NSGravityForceThis class computes the gravity force contribution.
- NSGravityPowerThis class computes the momentum contributed by gravity.
- NSMassInviscidFluxThis class computes the inviscid flux in the mass equation.
- NSMomentumInviscidFluxThe inviscid flux (convective + pressure terms) for the momentum conservation equations.
- NSMomentumInviscidFluxWithGradPThis class computes the inviscid flux with pressure gradient in the momentum equation.
- NSMomentumViscousFluxDerived instance of the NSViscousFluxBase class for the momentum equations.
- NSSUPGEnergyCompute residual and Jacobian terms form the SUPG terms in the energy equation.
- NSSUPGMassCompute residual and Jacobian terms form the SUPG terms in the mass equation.
- NSSUPGMomentumCompute residual and Jacobian terms form the SUPG terms in the momentum equation.
- NSTemperatureL2This class was originally used to solve for the temperature using an L2-projection.
- PressureGradient
- TotalEnergyConvectiveFlux
- Level Set App
- LevelSetAdvectionImplements the level set advection equation: , where the weak form is .
- LevelSetAdvectionSUPGSUPG stablization term for the advection portion of the level set equation.
- LevelSetForcingFunctionSUPGThe SUPG stablization term for a forcing function.
- LevelSetOlssonReinitializationThe re-initialization equation defined by Olsson et. al. (2007).
- LevelSetTimeDerivativeSUPGSUPG stablization terms for the time derivative of the level set equation.

### Kernels/CHPFCRFFSplitKernel

- Phase Field App
- CHPFCRFFSplitKernelAction

### Kernels/DynamicTensorMechanics

- Tensor Mechanics App
- DynamicTensorMechanicsActionSet up dynamic stress divergence kernels

### Kernels/HHPFCRFFSplitKernel

- Phase Field App
- HHPFCRFFSplitKernelActionSet up kernels for the rational function fit (RFF) phase field crystal model

### Kernels/PFCRFFKernel

- Phase Field App
- PFCRFFKernelActionSet up kernels for the rational function fit (RFF) phase field crystal model

### Kernels/PolycrystalElasticDrivingForce

- Phase Field App
- PolycrystalElasticDrivingForceActionAction that addes the elastic driving force for each order parameter

### Kernels/PolycrystalKernel

- Phase Field App
- PolycrystalKernelActionSet up ACGrGrPoly, ACInterface, TimeDerivative, and ACGBPoly kernels

### Kernels/PolycrystalStoredEnergy

- Phase Field App
- PolycrystalStoredEnergyActionAction that adds the contribution of stored energy associated with dislocations to grain growth models

### Kernels/PoroMechanics

- Tensor Mechanics App
- PoroMechanicsActionSet up stress divergence kernels with coordinate system aware logic

### Kernels/RigidBodyMultiKernel

- Phase Field App
- RigidBodyMultiKernelActionAction for applying Allen-Cahn equations and SingleGrainRigidBodyMotion to grains

### Kernels/TensorMechanics

- Tensor Mechanics App
- LegacyTensorMechanicsActionSet up stress divergence kernels with coordinate system aware logic

## Materials

- Moose App
- AddMaterialAction
- ADDerivativeParsedMaterialParsed Function Material with automatic derivatives.
- ADGenericConstantMaterial
- ADGenericFunctionMaterial
- ADParsedMaterialParsed Function Material.
- ADPiecewiseLinearInterpolationMaterialCompute a property using a piecewise linear interpolation to define its dependence on a variable
- DerivativeParsedMaterialParsed Function Material with automatic derivatives.
- DerivativeSumMaterialMeta-material to sum up multiple derivative materials
- GenericConstant2DArrayA material evaluating one material property in type of RealEigenMatrix
- GenericConstantArrayA material evaluating one material property in type of RealEigenVector
- GenericConstantMaterial
- GenericConstantRankTwoTensor
- GenericFunctionMaterial
- MaterialConverterConverts regular material properties to AD properties and visa versa
- ParsedMaterialParsed Function Material.
- PiecewiseLinearInterpolationMaterialCompute a property using a piecewise linear interpolation to define its dependence on a variable
- RankFourTensorMaterialConverterConverts regular material properties to AD properties and visa versa
- RankTwoTensorMaterialConverterConverts regular material properties to AD properties and visa versa
- Rdg App
- AEFVMaterialA material kernel for the advection equation using a cell-centered finite volume method.
- Heat Conduction App
- ADElectricalConductivityCalculates resistivity and electrical conductivity as a function of temperature, using copper for parameter defaults.
- ADHeatConductionMaterialGeneral-purpose material model for heat conduction
- AnisoHeatConductionMaterial
- ElectricalConductivityCalculates resistivity and electrical conductivity as a function of temperature, using copper for parameter defaults.
- GapConductance
- GapConductanceConstantMaterial to compute a constant, prescribed gap conductance
- HeatConductionMaterialGeneral-purpose material model for heat conduction
- SemiconductorLinearConductivityCalculates electrical conductivity of a semiconductor from temperature
- SideSetHeatTransferMaterialThis material constructs the necessary coefficients and properties for SideSetHeatTransferKernel.
- Fluid Properties App
- ADSaturationTemperatureMaterialComputes saturation temperature at some pressure
- ADSurfaceTensionMaterialComputes surface tension at some temperature
- FluidPropertiesMaterialComputes fluid properties using (u, v) formulation
- FluidPropertiesMaterialPTFluid properties using the (pressure, temperature) formulation
- SodiumPropertiesMaterialMaterial properties for liquid sodium sampled from SodiumProperties.
- Tensor Mechanics App
- ADAbruptSofteningSoftening model with an abrupt stress release upon cracking. This class relies on automatic differentiation and is intended to be used with ADComputeSmearedCrackingStress.
- ADComputeAxisymmetricRZFiniteStrainCompute a strain increment for finite strains under axisymmetric assumptions.
- ADComputeAxisymmetricRZIncrementalStrainCompute a strain increment and rotation increment for finite strains under axisymmetric assumptions.
- ADComputeAxisymmetricRZSmallStrainCompute a small strain in an Axisymmetric geometry
- ADComputeDilatationThermalExpansionFunctionEigenstrainComputes eigenstrain due to thermal expansion using a function that describes the total dilatation as a function of temperature
- ADComputeEigenstrainComputes a constant Eigenstrain
- ADComputeElasticityTensorCompute an elasticity tensor.
- ADComputeFiniteShellStrainCompute a large strain increment for the shell.
- ADComputeFiniteStrainCompute a strain increment and rotation increment for finite strains.
- ADComputeFiniteStrainElasticStressCompute stress using elasticity for finite strains
- ADComputeGreenLagrangeStrainCompute a Green-Lagrange strain.
- ADComputeIncrementalShellStrainCompute a small strain increment for the shell.
- ADComputeIncrementalSmallStrainCompute a strain increment and rotation increment for small strains.
- ADComputeInstantaneousThermalExpansionFunctionEigenstrainComputes eigenstrain due to thermal expansion using a function that describes the instantaneous thermal expansion as a function of temperature
- ADComputeIsotropicElasticityTensorCompute a constant isotropic elasticity tensor.
- ADComputeIsotropicElasticityTensorShellCompute a plane stress isotropic elasticity tensor.
- ADComputeLinearElasticStressCompute stress using elasticity for small strains
- ADComputeMeanThermalExpansionFunctionEigenstrainComputes eigenstrain due to thermal expansion using a function that describes the mean thermal expansion as a function of temperature
- ADComputeMultipleInelasticStressCompute state (stress and internal parameters such as plastic strains and internal parameters) using an iterative process. Combinations of creep models and plastic models may be used.
- ADComputeMultiplePorousInelasticStressCompute state (stress and internal parameters such as plastic strains and internal parameters) using an iterative process. A porosity material property is defined and is calculated from the trace of inelastic strain increment.
- ADComputePlaneFiniteStrainCompute strain increment and rotation increment for finite strain under 2D planar assumptions.
- ADComputePlaneIncrementalStrainCompute strain increment for small strain under 2D planar assumptions.
- ADComputePlaneSmallStrainCompute a small strain under generalized plane strain assumptions where the out of plane strain is generally nonzero.
- ADComputeRSphericalFiniteStrainCompute a strain increment and rotation increment for finite strains in 1D spherical symmetry problems.
- ADComputeRSphericalIncrementalStrainCompute a strain increment for incremental strains in 1D spherical symmetry problems.
- ADComputeRSphericalSmallStrainCompute a small strain 1D spherical symmetry case.
- ADComputeShellStressCompute in-plane stress using elasticity for shell
- ADComputeSmallStrainCompute a small strain.
- ADComputeSmearedCrackingStressCompute stress using a fixed smeared cracking model. Uses automatic differentiation
- ADComputeStrainIncrementBasedStressCompute stress after subtracting inelastic strain increments
- ADComputeThermalExpansionEigenstrainComputes eigenstrain due to thermal expansion with a constant coefficient
- ADComputeVariableIsotropicElasticityTensorCompute an isotropic elasticity tensor for elastic constants that change as a function of material properties
- ADExponentialSofteningSoftening model with an exponential softening response upon cracking. This class is intended to be used with ADComputeSmearedCrackingStress and relies on automatic differentiation.
- ADIsotropicPlasticityStressUpdateThis class uses the discrete material in a radial return isotropic plasticity model. This class is one of the basic radial return constitutive models, yet it can be used in conjunction with other creep and plasticity materials for more complex simulations.
- ADPowerLawCreepStressUpdateThis class uses the stress update material in a radial return isotropic power law creep model. This class can be used in conjunction with other creep and plasticity materials for more complex simulations.
- ADPowerLawSofteningSoftening model with an abrupt stress release upon cracking. This class is intended to be used with ADComputeSmearedCrackingStress and relies on automatic differentiation.
- ADRankTwoCartesianComponentAccess a component of a RankTwoTensor
- ADRankTwoCylindricalComponentCompute components of a rank-2 tensor in a cylindrical coordinate system
- ADRankTwoDirectionalComponentCompute a Direction scalar property of a RankTwoTensor
- ADRankTwoInvariantCompute a invariant property of a RankTwoTensor
- ADStrainEnergyRateDensityComputes the strain energy density rate using a combination of the elastic and inelastic components of the strain increment, which is a valid assumption for monotonic behavior.
- ADViscoplasticityStressUpdateThis material computes the non-linear homogenized gauge stress in order to compute the viscoplastic responce due to creep in porous materials. This material must be used in conjunction with ADComputeMultiplePorousInelasticStress
- AbruptSofteningSoftening model with an abrupt stress release upon cracking. This class is intended to be used with ComputeSmearedCrackingStress.
- CappedDruckerPragerCosseratStressUpdateCapped Drucker-Prager plasticity stress calculator for the Cosserat situation where the host medium (ie, the limit where all Cosserat effects are zero) is isotropic. Note that the return-map flow rule uses an isotropic elasticity tensor built with the 'host' properties defined by the user.
- CappedDruckerPragerStressUpdateCapped Drucker-Prager plasticity stress calculator
- CappedMohrCoulombCosseratStressUpdateCapped Mohr-Coulomb plasticity stress calculator for the Cosserat situation where the host medium (ie, the limit where all Cosserat effects are zero) is isotropic. Note that the return-map flow rule uses an isotropic elasticity tensor built with the 'host' properties defined by the user.
- CappedMohrCoulombStressUpdateNonassociative, smoothed, Mohr-Coulomb plasticity capped with tensile (Rankine) and compressive caps, with hardening/softening
- CappedWeakInclinedPlaneStressUpdateCapped weak inclined plane plasticity stress calculator
- CappedWeakPlaneCosseratStressUpdateCapped weak-plane plasticity Cosserat stress calculator
- CappedWeakPlaneStressUpdateCapped weak-plane plasticity stress calculator
- CombinedScalarDamageScalar damage model which is computed as a function of multiple scalar damage models
- CompositeEigenstrainAssemble an Eigenstrain tensor from multiple tensor contributions weighted by material properties
- CompositeElasticityTensorAssemble an elasticity tensor from multiple tensor contributions weighted by material properties
- ComputeAxisymmetric1DFiniteStrainCompute a strain increment and rotation increment for finite strains in an axisymmetric 1D problem
- ComputeAxisymmetric1DIncrementalStrainCompute strain increment for small strains in an axisymmetric 1D problem
- ComputeAxisymmetric1DSmallStrainCompute a small strain in an Axisymmetric 1D problem
- ComputeAxisymmetricRZFiniteStrainCompute a strain increment for finite strains under axisymmetric assumptions.
- ComputeAxisymmetricRZIncrementalStrainCompute a strain increment and rotation increment for small strains under axisymmetric assumptions.
- ComputeAxisymmetricRZSmallStrainCompute a small strain in an Axisymmetric geometry
- ComputeBeamResultantsCompute forces and moments using elasticity
- ComputeConcentrationDependentElasticityTensorCompute concentration dependent elasticity tensor.
- ComputeCosseratElasticityTensorCompute Cosserat elasticity and flexural bending rigidity tensors
- ComputeCosseratIncrementalSmallStrainCompute incremental small Cosserat strains
- ComputeCosseratLinearElasticStressCompute Cosserat stress and couple-stress elasticity for small strains
- ComputeCosseratSmallStrainCompute small Cosserat strains
- ComputeCrackedStressComputes energy and modifies the stress for phase field fracture
- ComputeDamageStressCompute stress for damaged elastic materials in conjunction with a damage model.
- ComputeDeformGradBasedStressComputes stress based on Lagrangian strain
- ComputeDilatationThermalExpansionFunctionEigenstrainComputes eigenstrain due to thermal expansion using a function that describes the total dilatation as a function of temperature
- ComputeEigenstrainComputes a constant Eigenstrain
- ComputeEigenstrainBeamFromVariableComputes an eigenstrain from a set of variables
- ComputeEigenstrainFromInitialStressComputes an eigenstrain from an initial stress
- ComputeElasticityBeamComputes the equivalent of the elasticity tensor for the beam element, which are vectors of material translational and flexural stiffness.
- ComputeElasticityTensorCompute an elasticity tensor.
- ComputeElasticityTensorCPCompute an elasticity tensor for crystal plasticity.
- ComputeExtraStressConstantComputes a constant extra stress that is added to the stress calculated by the constitutive model
- ComputeExtraStressVDWGasComputes a hydrostatic stress corresponding to the pressure of a van der Waals gas that is added as an extra_stress to the stress computed by the constitutive model
- ComputeFiniteBeamStrainCompute a rotation increment for finite rotations of the beam and computes the small/large strain increments in the current rotated configuration of the beam.
- ComputeFiniteStrainCompute a strain increment and rotation increment for finite strains.
- ComputeFiniteStrainElasticStressCompute stress using elasticity for finite strains
- ComputeGlobalStrainMaterial for storing the global strain values from the scalar variable
- ComputeIncrementalBeamStrainCompute a infinitesimal/large strain increment for the beam.
- ComputeIncrementalSmallStrainCompute a strain increment and rotation increment for small strains.
- ComputeInstantaneousThermalExpansionFunctionEigenstrainComputes eigenstrain due to thermal expansion using a function that describes the instantaneous thermal expansion as a function of temperature
- ComputeInterfaceStressStress in the plane of an interface defined by the gradient of an order parameter
- ComputeIsotropicElasticityTensorCompute a constant isotropic elasticity tensor.
- ComputeLayeredCosseratElasticityTensorComputes Cosserat elasticity and flexural bending rigidity tensors relevant for simulations with layered materials. The layering direction is assumed to be perpendicular to the 'z' direction.
- ComputeLinearElasticPFFractureStressComputes the stress and free energy derivatives for the phase field fracture model, with small strain
- ComputeLinearElasticStressCompute stress using elasticity for small strains
- ComputeLinearViscoelasticStressDivides total strain into elastic + creep + eigenstrains
- ComputeMeanThermalExpansionFunctionEigenstrainComputes eigenstrain due to thermal expansion using a function that describes the mean thermal expansion as a function of temperature
- ComputeMultiPlasticityStressMaterial for multi-surface finite-strain plasticity
- ComputeMultipleInelasticCosseratStressCompute state (stress and other quantities such as plastic strains and internal parameters) using an iterative process, as well as Cosserat versions of these quantities. Only elasticity is currently implemented for the Cosserat versions.Combinations of creep models and plastic models may be used
- ComputeMultipleInelasticStressCompute state (stress and internal parameters such as plastic strains and internal parameters) using an iterative process. Combinations of creep models and plastic models may be used.
- ComputePlaneFiniteStrainCompute strain increment and rotation increment for finite strain under 2D planar assumptions.
- ComputePlaneIncrementalStrainCompute strain increment for small strain under 2D planar assumptions.
- ComputePlaneSmallStrainCompute a small strain under generalized plane strain assumptions where the out of plane strain is generally nonzero.
- ComputePlasticHeatEnergyPlastic heat energy density = stress * plastic_strain_rate
- ComputeRSphericalFiniteStrainCompute a strain increment and rotation increment for finite strains in 1D spherical symmetry problems.
- ComputeRSphericalIncrementalStrainCompute a strain increment for incremental strains in 1D spherical symmetry problems.
- ComputeRSphericalSmallStrainCompute a small strain 1D spherical symmetry case.
- ComputeReducedOrderEigenstrainaccepts eigenstrains and computes a reduced order eigenstrain for consistency in the order of strain and eigenstrains.
- ComputeSmallStrainCompute a small strain.
- ComputeSmearedCrackingStressCompute stress using a fixed smeared cracking model
- ComputeStrainIncrementBasedStressCompute stress after subtracting inelastic strain increments
- ComputeSurfaceTensionKKSSurface tension of an interface defined by the gradient of an order parameter
- ComputeThermalExpansionEigenstrainComputes eigenstrain due to thermal expansion with a constant coefficient
- ComputeThermalExpansionEigenstrainBeamComputes eigenstrain due to thermal expansion with a constant coefficient
- ComputeVariableBaseEigenStrainComputes Eigenstrain based on material property tensor base
- ComputeVariableEigenstrainComputes an Eigenstrain and its derivatives that is a function of multiple variables, where the prefactor is defined in a derivative material
- ComputeVariableIsotropicElasticityTensorCompute an isotropic elasticity tensor for elastic constants that change as a function of material properties
- ComputeVolumetricDeformGradComputes volumetric deformation gradient and adjusts the total deformation gradient
- ComputeVolumetricEigenstrainComputes an eigenstrain that is defined by a set of scalar material properties that summed together define the volumetric change. This also computes the derivatives of that eigenstrain with respect to a supplied set of variable dependencies.
- EshelbyTensorComputes the Eshelby tensor as a function of strain energy density and the first Piola-Kirchhoff stress
- ExponentialSofteningSoftening model with an exponential softening response upon cracking. This class is intended to be used with ComputeSmearedCrackingStress.
- FiniteStrainCPSlipRateResCrystal Plasticity base class: FCC system with power law flow rule implemented
- FiniteStrainCrystalPlasticityCrystal Plasticity base class: FCC system with power law flow rule implemented
- FiniteStrainHyperElasticViscoPlasticMaterial class for hyper-elastic viscoplatic flow: Can handle multiple flow models defined by flowratemodel type user objects
- FiniteStrainPlasticMaterialAssociative J2 plasticity with isotropic hardening.
- FiniteStrainUObasedCPUserObject based Crystal Plasticity system.
- FluxBasedStrainIncrementCompute strain increment based on flux
- GBRelaxationStrainIncrementCompute strain increment based on lattice relaxation at GB
- GeneralizedKelvinVoigtModelGeneralized Kelvin-Voigt model composed of a serial assembly of unit Kelvin-Voigt modules
- GeneralizedMaxwellModelGeneralized Maxwell model composed of a parallel assembly of unit Maxwell modules
- HyperElasticPhaseFieldIsoDamageComputes damaged stress and energy in the intermediate configuration assuming isotropy
- HyperbolicViscoplasticityStressUpdateThis class uses the discrete material for a hyperbolic sine viscoplasticity model in which the effective plastic strain is solved for using a creep approach.
- InclusionProperties
- IsotropicPlasticityStressUpdateThis class uses the discrete material in a radial return isotropic plasticity model. This class is one of the basic radial return constitutive models, yet it can be used in conjunction with other creep and plasticity materials for more complex simulations.
- IsotropicPowerLawHardeningStressUpdateThis class uses the discrete material in a radial return isotropic plasticity power law hardening model, solving for the yield stress as the intersection of the power law relation curve and Hooke's law. This class can be used in conjunction with other creep and plasticity materials for more complex simulations.
- LinearElasticTrussComputes the linear elastic strain for a truss element
- LinearViscoelasticStressUpdateCalculates an admissible state (stress that lies on or within the yield surface, plastic strains, internal parameters, etc). This class is intended to be a parent class for classes with specific constitutive models.
- MultiPhaseStressMaterialCompute a global stress form multiple phase stresses
- PlasticTrussComputes the stress and strain for a truss element with plastic behavior defined by either linear hardening or a user-defined hardening function.
- PowerLawCreepStressUpdateThis class uses the stress update material in a radial return isotropic power law creep model. This class can be used in conjunction with other creep and plasticity materials for more complex simulations.
- PowerLawSofteningSoftening model with an abrupt stress release upon cracking. This class is intended to be used with ComputeSmearedCrackingStress.
- RankTwoCartesianComponentAccess a component of a RankTwoTensor
- RankTwoCylindricalComponentCompute components of a rank-2 tensor in a cylindrical coordinate system
- RankTwoDirectionalComponentCompute a Direction scalar property of a RankTwoTensor
- RankTwoInvariantCompute a invariant property of a RankTwoTensor
- SalehaniIrani3DCTraction3D Coupled (3DC) cohesive law of Salehani and Irani with no damage
- ScalarMaterialDamageScalar damage model for which the damage is prescribed by another material
- StrainEnergyDensityComputes the strain energy density using a combination of the elastic and inelastic components of the strain increment, which is a valid assumption for monotonic behavior.
- StrainEnergyRateDensityComputes the strain energy density rate using a combination of the elastic and inelastic components of the strain increment, which is a valid assumption for monotonic behavior.
- StressBasedChemicalPotentialChemical potential from stress
- SumTensorIncrementsCompute tensor property by summing tensor increments
- TemperatureDependentHardeningStressUpdateComputes the stress as a function of temperature and plastic strain from user-supplied hardening functions. This class can be used in conjunction with other creep and plasticity materials for more complex simulations
- TensileStressUpdateAssociative, smoothed, tensile (Rankine) plasticity with hardening/softening
- ThermalFractureIntegralCalculates summation of the derivative of the eigenstrains with respect to temperature.
- TwoPhaseStressMaterialCompute a global stress in a two phase model
- VolumeDeformGradCorrectedStressTransforms stress with volumetric term from previous configuration to this configuration
- Phase Field App
- ADConstantAnisotropicMobilityProvide a constant mobility tensor value
- ADGBEvolutionComputes necessary material properties for the isotropic grain growth model
- ADMathFreeEnergyMaterial that implements the math free energy and its derivatives: F = 1/4(1 + c)^2*(1 - c)^2
- AsymmetricCrossTermBarrierFunctionMaterialFree energy contribution asymmetric across interfaces between arbitrary pairs of phases.
- BarrierFunctionMaterialHelper material to provide g(eta) and its derivative in a polynomial. SIMPLE: eta
^{2*(1-eta)}2 LOW: eta*(1-eta) HIGH: eta^{2*(1-eta}2)^2 - CompositeMobilityTensorAssemble a mobility tensor from multiple tensor contributions weighted by material properties
- ComputePolycrystalElasticityTensorCompute an evolving elasticity tensor coupled to a grain growth phase field model.
- ConstantAnisotropicMobilityProvide a constant mobility tensor value
- CrossTermBarrierFunctionMaterialFree energy contribution symmetric across interfaces between arbitrary pairs of phases.
- DeformedGrainMaterial
- DerivativeMultiPhaseMaterialTwo phase material that combines n phase materials using a switching function with and n non-conserved order parameters (to be used with SwitchingFunctionConstraint*).
- DerivativeTwoPhaseMaterialTwo phase material that combines two single phase materials using a switching function.
- DiscreteNucleationFree energy contribution for nucleating discrete particles
- EBCoupledVarTestTest to see if vector of coupled variables works with ExpressionBuilder
- ElasticEnergyMaterialFree energy material for the elastic energy contributions.
- ExternalForceDensityMaterialProviding external applied force density to grains
- ForceDensityMaterialCalculating the force density acting on a grain
- GBAnisotropy
- GBDependentAnisotropicTensorCompute anisotropic rank two tensor based on GB phase variable
- GBDependentDiffusivityCompute diffusivity rank two tensor based on GB phase variable
- GBEvolutionComputes necessary material properties for the isotropic grain growth model
- GBWidthAnisotropy
- GrainAdvectionVelocityCalculation the advection velocity of grain due to rigid body translation and rotation
- GrandPotentialInterfaceCalculate Grand Potential interface parameters for a specified interfacial free energy and width
- IdealGasFreeEnergyFree energy of an ideal gas.
- InterfaceOrientationMaterial
- InterfaceOrientationMultiphaseMaterialThis Material accounts for the the orientation dependence of interfacial energy for multi-phase multi-order parameter phase-field model.
- KKSXeVacSolidMaterialKKS Solid phase free energy for Xe,Vac in UO2. Fm(cmg,cmv)
- MathEBFreeEnergyMaterial that implements the math free energy using the expression builder and automatic differentiation
- MathFreeEnergyMaterial that implements the math free energy and its derivatives: F = 1/4(1 + c)^2*(1 - c)^2
- MixedSwitchingFunctionMaterialHelper material to provide h(eta) and its derivative in one of two polynomial forms. MIX234 and MIX246
- MultiBarrierFunctionMaterialDouble well phase transformation barrier free energy contribution.
- PFCRFFMaterial
- PFCTradMaterialPolynomial coefficients for a phase field crystal correlation function
- PFParamsPolyFreeEnergyPhase field parameters for polynomial free energy for single component systems
- PhaseNormalTensorCalculate normal tensor of a phase based on gradient
- PolynomialFreeEnergyPolynomial free energy for single component systems
- RegularSolutionFreeEnergyMaterial that implements the free energy of a regular solution
- StrainGradDispDerivativesProvide the constant derivatives of strain w.r.t. the displacement gradient components.
- SwitchingFunction3PhaseMaterialMaterial for switching function that prevents formation of a third phase at a two-phase interface: h_i = eta_i
^{2/4 * [15 (1-eta_i) [1 + eta_i - (eta_k - eta_j)}2] + eta_i * (9eta_i^2 - 5)] - SwitchingFunctionMaterialHelper material to provide h(eta) and its derivative in one of two polynomial forms. SIMPLE: 3
*eta^2-2*eta^{3 HIGH: eta}3*(6*eta^2-15*eta+10) - SwitchingFunctionMultiPhaseMaterialCalculates the switching function for a given phase for a multi-phase, multi-order parameter model
- ThirdPhaseSuppressionMaterialFree Energy contribution that penalizes more than two order parameters being non-zero
- TimeStepMaterialProvide various time stepping quantities as material properties.
- VanDerWaalsFreeEnergyFree energy of a Van der Waals gas.
- VariableGradientMaterialCompute the norm of the gradient of a variable
- Peridynamics App
- ComputeFiniteStrainNOSPDClass for computing nodal quantities for residual and jacobian calculation for peridynamic correspondence model under finite strain assumptions
- ComputePlaneFiniteStrainNOSPDClass for computing nodal quantities for residual and jacobian calculation for peridynamic correspondence model under planar finite strain assumptions
- ComputePlaneSmallStrainNOSPDClass for computing nodal quantities for residual and jacobian calculation for peridynamic correspondence model under planar small strain assumptions
- ComputeSmallStrainConstantHorizonMaterialBPDClass for computing peridynamic micro elastic modulus for bond-based model using regular uniform mesh
- ComputeSmallStrainConstantHorizonMaterialOSPDClass for computing peridynamic micro elastic moduli for ordinary state-based model using regular uniform mesh
- ComputeSmallStrainNOSPDClass for computing nodal quantities for the residual and Jacobian calculation for the peridynamic correspondence model under small strain assumptions
- ComputeSmallStrainVariableHorizonMaterialBPDClass for computing peridynamic micro elastic modulus for bond-based model using irregular mesh
- ComputeSmallStrainVariableHorizonMaterialOSPDClass for computing peridynamic micro elastic moduli for ordinary state-based model using irregular mesh
- ThermalConstantHorizonMaterialBPDClass for computing peridynamic micro conductivity for bond-based model using regular uniform mesh
- ThermalVariableHorizonMaterialBPDClass for computing peridynamic micro conductivity for bond-based model using irregular mesh
- Chemical Reactions App
- LangmuirMaterialMaterial type that holds info regarding Langmuir desorption from matrix to porespace and viceversa
- MollifiedLangmuirMaterialMaterial type that holds info regarding MollifiedLangmuir desorption from matrix to porespace and viceversa
- XFEMApp
- ADLevelSetBiMaterialRankFourCompute a RankFourTensor material property for bi-materials problem (consisting of two different materials) defined by a level set function.
- ADLevelSetBiMaterialRankTwoCompute a RankTwoTensor material property for bi-materials problem (consisting of two different materials) defined by a level set function.
- ADLevelSetBiMaterialRealCompute a Real material property for bi-materials problem (consisting of two different materials) defined by a level set function.
- ComputeCrackTipEnrichmentSmallStrainComputes the crack tip enrichment at a point within a small strain formulation.
- LevelSetBiMaterialRankFourCompute a RankFourTensor material property for bi-materials problem (consisting of two different materials) defined by a level set function.
- LevelSetBiMaterialRankTwoCompute a RankTwoTensor material property for bi-materials problem (consisting of two different materials) defined by a level set function.
- LevelSetBiMaterialRealCompute a Real material property for bi-materials problem (consisting of two different materials) defined by a level set function.
- Porous Flow App
- PorousFlowAddMaterialActionMakes sure that the correct nodal and/or qp materials are added for each property
- PorousFlowAddMaterialJoinerAdds PorousFlowJoiner materials as required for each phase-dependent property
- PorousFlow1PhaseFullySaturatedThis Material is used for the fully saturated single-phase situation where porepressure is the primary variable
- PorousFlow1PhaseMD_GaussianThis Material is used for the single-phase situation where log(mass-density) is the primary variable. calculates the 1 porepressure and the 1 saturation in a 1-phase situation, and derivatives of these with respect to the PorousFlowVariables. A gaussian capillary function is assumed
- PorousFlow1PhasePThis Material is used for the fully saturated single-phase situation where porepressure is the primary variable
- PorousFlow2PhasePPThis Material calculates the 2 porepressures and the 2 saturations in a 2-phase situation, and derivatives of these with respect to the PorousFlowVariables
- PorousFlow2PhasePSThis Material calculates the 2 porepressures and the 2 saturations in a 2-phase situation, and derivatives of these with respect to the PorousFlowVariables.
- PorousFlowAqueousPreDisChemistryThis Material forms a std::vector of mineralisation reaction rates (L(precipitate)/L(solution)/s) appropriate to the aqueous precipitation-dissolution system provided. Note: the PorousFlowTemperature must be measured in Kelvin.
- PorousFlowAqueousPreDisMineralThis Material forms a std::vector of mineral concentrations (volume-of-mineral/volume-of-material) appropriate to the aqueous precipitation-dissolution system provided.
- PorousFlowBrineThis Material calculates fluid properties for brine at the quadpoints or nodes
- PorousFlowConstantBiotModulusComputes the Biot Modulus, which is assumed to be constant for all time. Sometimes 1 / BiotModulus is called storativity
- PorousFlowConstantThermalExpansionCoefficientComputes the effective thermal expansion coefficient, (biot_coeff - porosity) * drained_coefficient + porosity * fluid_coefficient.
- PorousFlowDarcyVelocityMaterialThis Material calculates the Darcy velocity for all phases
- PorousFlowDiffusivityConstThis Material provides constant tortuosity and diffusion coefficients
- PorousFlowDiffusivityMillingtonQuirkThis Material provides saturation-dependent diffusivity using the Millington-Quirk model
- PorousFlowEffectiveFluidPressureThis Material calculates an effective fluid pressure: effective_stress = total_stress + biot_coeff*effective_fluid_pressure. The effective_fluid_pressure = sum_{phases}(S_phase * P_phase)
- PorousFlowFluidStateClass for fluid state calculations using persistent primary variables and a vapor-liquid flash
- PorousFlowFluidStateBrineCO2Fluid state class for brine and CO2
- PorousFlowFluidStateSingleComponentClass for single component multiphase fluid state calculations using pressure and enthalpy
- PorousFlowFluidStateWaterNCGFluid state class for water and non-condensable gas
- PorousFlowJoinerThis Material forms a std::vector of properties, old properties (optionally), and derivatives, out of the individual phase properties
- PorousFlowMassFractionThis Material forms a std::vector<std::vector ...> of mass-fractions out of the individual mass fractions
- PorousFlowMassFractionAqueousEquilibriumChemistryThis Material forms a std::vector<std::vector ...> of mass-fractions (total concentrations of primary species (m
^{{3}(primary species)/m}{3}(solution)) and since this is for an aqueous system only, mass-fraction equals volume-fraction) corresponding to an aqueous equilibrium chemistry system. The first mass fraction is the concentration of the first primary species, etc, and the last mass fraction is the concentration of H2O. - PorousFlowMatrixInternalEnergyThis Material calculates the internal energy of solid rock grains, which is specific_heat_capacity * density * temperature. Kernels multiply this by (1 - porosity) to find the energy density of the porous rock in a rock-fluid system
- PorousFlowNearestQpProvides the nearest quadpoint to a node in each element
- PorousFlowPermeabilityConstThis Material calculates the permeability tensor assuming it is constant
- PorousFlowPermeabilityConstFromVarThis Material calculates the permeability tensor given by the input variables
- PorousFlowPermeabilityExponentialThis Material calculates the permeability tensor from an exponential function of porosity: k = k_ijk * BB exp(AA phi), where k_ijk is a tensor providing the anisotropy, phi is porosity, and AA and BB are empirical constants. The user can provide input for the function expressed in ln k, log k or exponential forms (see poroperm_function).
- PorousFlowPermeabilityKozenyCarmanThis Material calculates the permeability tensor from a form of the Kozeny-Carman equation, k = k_ijk * A * phi
^{n / (1 - phi)}m, where k_ijk is a tensor providing the anisotropy, phi is porosity, n and m are positive scalar constants and A is given in one of the following forms: A = k0 * (1 - phi0)^m / phi0^n (where k0 and phi0 are a reference permeability and porosity) or A = f * d^2 (where f is a scalar constant and d is grain diameter. - PorousFlowPermeabilityTensorFromVarThis Material calculates the permeability tensor from a coupled variable multiplied by a tensor
- PorousFlowPorosityThis Material calculates the porosity PorousFlow simulations
- PorousFlowPorosityConstThis Material calculates the porosity assuming it is constant
- PorousFlowPorosityHMBiotModulusThis Material calculates the porosity for hydro-mechanical simulations, assuming that the Biot modulus and the fluid bulk modulus are both constant. This is useful for comparing with solutions from poroelasticity theory, but is less accurate than PorousFlowPorosity
- PorousFlowRelativePermeabilityBCBrooks-Corey relative permeability
- PorousFlowRelativePermeabilityBWBroadbridge-White form of relative permeability
- PorousFlowRelativePermeabilityConstThis class sets the relative permeability to a constant value (default = 1)
- PorousFlowRelativePermeabilityCoreyThis Material calculates relative permeability of the fluid phase, using the simple Corey model ((S-S_res)/(1-sum(S_res)))^n
- PorousFlowRelativePermeabilityFLACThis Material calculates relative permeability of a phase using a model inspired by FLAC
- PorousFlowRelativePermeabilityVGThis Material calculates relative permeability of a phase using the van Genuchten model
- PorousFlowSingleComponentFluidThis Material calculates fluid properties at the quadpoints or nodes for a single component fluid
- PorousFlowTemperatureMaterial to provide temperature at the quadpoints or nodes and derivatives of it with respect to the PorousFlow variables
- PorousFlowThermalConductivityFromPorosityThis Material calculates rock-fluid combined thermal conductivity for the single phase, fully saturated case by using a linear weighted average. Thermal conductivity = phi * lambda_f + (1 - phi) * lambda_s, where phi is porosity, and lambda_f, lambda_s are thermal conductivities of the fluid and solid (assumed constant)
- PorousFlowThermalConductivityIdealThis Material calculates rock-fluid combined thermal conductivity by using a weighted sum. Thermal conductivity = dry_thermal_conductivity + S^exponent * (wet_thermal_conductivity - dry_thermal_conductivity), where S is the aqueous saturation
- PorousFlowTotalGravitationalDensityFullySaturatedFromPorosityThis Material calculates the porous medium density from the porosity, solid density (assumed constant) and fluid density, for the fully-saturated single fluid phase case, using a linear weighted average. density = phi * rho_f + (1 - phi) * rho_s, where phi is porosity and rho_f, rho_s are the densities of the fluid and solid phases.
- PorousFlowVolumetricStrainCompute volumetric strain and the volumetric_strain rate, for use in PorousFlow.
- Navier Stokes App
- AirAir.
- INSAD3EqnThis material computes properties needed for stabilized formulations of the mass, momentum, and energy equations.
- INSADMaterialThis is the material class used to compute some of the strong residuals for the INS equations.
- INSADStabilized3EqnThis is the material class used to compute the stabilization parameter tau for momentum and tau_energy for the energy equation.
- INSADTauMaterialThis is the material class used to compute the stabilization parameter tau.
- Misc App
- ADDensityCreates density AD material property
- DensityCreates density material property

## Mesh

- Moose App
- CreateDisplacedProblemAction
- DisplayGhostingActionAction to setup AuxVariables and AuxKernels to display ghosting when running in parallel
- SetupMeshAction
- SetupMeshCompleteAction
- AddMeshGeneratorActionAction for adding mesh generator objects
- AllSideSetsByNormalsGeneratorAdds sidesets to the entire mesh based on unique normals.
- AnnularMeshGeneratorFor rmin>0: creates an annular mesh of QUAD4 elements. For rmin=0: creates a disc mesh of QUAD4 and TRI3 elements. Boundary sidesets are created at rmax and rmin, and given these names. If dmin!
__0 and dmax!__360, a sector of an annulus or disc is created. In this case boundary sidesets are also created a dmin and dmax, and given these names - BlockDeletionGeneratorMesh generator which removes elements with the specified subdomain ID
- BoundingBoxNodeSetGeneratorAssigns all of the nodes either inside or outside of a bounding box to a new nodeset.
- BreakBoundaryOnSubdomainGeneratorBreak boundaries based on the subdomains to which their sides are attached. Naming convention for the new boundaries will be the old boundary name plus "_to_" plus the subdomain name
- BreakMeshByBlockGeneratorBreak boundaries based on the subdomains to which their sides are attached. Naming convention for the new boundaries will be the old boundary name plus "_to_" plus the subdomain name. At the momentthis only works on REPLICATED mesh
- CartesianMeshGeneratorThis CartesianMeshGenerator creates a non-uniform Cartesian mesh.
- CombinerGeneratorCombine multiple meshes (or copies of one mesh) together into one (disjoint) mesh. Can optionally translate those meshes before combining them.
- ConcentricCircleMeshGeneratorThis ConcentricCircleMeshGenerator source code is to generate concentric circle meshes.
- DistributedRectilinearMeshGeneratorCreate a line, square, or cube mesh with uniformly spaced or biased elements.
- ElementGeneratorGenerates individual elements given a list of nodal positions.
- ElementSubdomainIDGeneratorAllows the user to assign each element the subdomain ID of their choice
- ExtraNodesetGeneratorCreates a new node set and a new boundary made with the nodes the user provides.
- FancyExtruderGeneratorExtrudes a 2D mesh into 3D, can have variable a variable height for each elevation, variable number of layers within each elevation and remap subdomain_ids within each elevation
- FileMeshGeneratorRead a mesh from a file.
- GeneratedMeshGeneratorCreate a line, square, or cube mesh with uniformly spaced or biased elements.
- ImageMeshGeneratorGenerated mesh with the aspect ratio of a given image stack.
- ImageSubdomainGeneratorSamples an image at the coordinates of each element centroid, using the resulting pixel color value as each element's subdomain ID
- LowerDBlockFromSidesetGeneratorAdds lower dimensional elements on the specified sidesets.
- MeshCollectionGeneratorCollects multiple meshes into a single (unconnected) mesh.
- MeshExtruderGeneratorTakes a 1D or 2D mesh and extrudes the entire structure along the specified axis increasing the dimensionality of the mesh.
- MeshSideSetGeneratorAdd lower dimensional elements along the faces contained in a side set to set up mixed dimensional problems
- OrientedSubdomainBoundingBoxGeneratorDefines a subdomain inside or outside of a bounding box with arbitrary orientation.
- ParsedGenerateSidesetA MeshModifier that adds element sides to a sideset if the centroid satisfies the
`combinatorial_geometry`

expression. Optionally, element sides are also added if they are included in`included_subdomain_ids`

and if they feature the designated normal. - ParsedSubdomainMeshGeneratorUses a parsed expression (
`combinatorial_geometry`

) to determine if an element (via its centroid) is inside the region defined by the expression and assigns a new block ID. - PatchMeshGeneratorCreates 2D or 3D patch meshes.
- PatternedMeshGeneratorCreates a 2D mesh from a specified set of unique 'tiles' meshes and a two-dimensional pattern.
- PlaneDeletionGeneratorRemoves elements lying 'above' the plane (in the direction of the normal).
- RenameBlockGeneratorRenameBlockGenerator re-numbers or re-names an
`old_block_id`

or`old_block_name`

with a`new_block_id`

or`new_block_name`

. If using RenameBlockGenerator to merge blocks (by giving them the same name, for instance) it is advisable to specify all your blocks in`old_blocks`

to avoid inconsistencies - RenameBoundaryGeneratorRenameBoundaryGenerator re-numbers or re-names an
`old_boundary_id`

or`old_boundary_name`

with a`new_boundary_id`

or`new_boundary_name`

. If using RenameBoundaryGenerator to merge boundaries (by giving them the same name, for instance) it is advisable to specify all your boundaries in`old_boundaries`

to avoid inconsistencies - RinglebMeshGeneratorCreates a mesh for the Ringleb problem.
- SideSetsAroundSubdomainGeneratorAdds element faces that are on the exterior of the given block to the sidesets specified
- SideSetsBetweenSubdomainsGeneratorMeshGenerator that creates a sideset composed of the nodes located between two or more subdomains.
- SideSetsFromBoundingBoxGeneratorDefines new sidesets using currently-defined sideset IDs inside or outside of a bounding box.
- SideSetsFromNormalsGeneratorAdds a new named sideset to the mesh for all faces matching the specified normal.
- SideSetsFromPointsGeneratorAdds a new sideset starting at the specified point containing all connected element faces with the same normal.
- SmoothMeshGeneratorUtilizes a simple Laplacian based smoother to attempt to improve mesh quality. Will not move boundary nodes or nodes along block/subdomain boundaries
- SpiralAnnularMeshGeneratorCreates an annular mesh based on TRI3 or TRI6 elements on several rings.
- StackGeneratorUse the supplied meshes and stitch them on top of each other
- StitchedMeshGeneratorAllows multiple mesh files to be stiched together to form a single mesh.
- SubdomainBoundingBoxGeneratorChanges the subdomain ID of elements either (XOR) inside or outside the specified box to the specified ID.
- SubdomainIDGeneratorSets all the elements of the input mesh to a unique subdomain ID.
- TiledMeshGeneratorUse the supplied mesh and create a tiled grid by repeating this mesh in the x, y, and z directions.
- TransformGeneratorApplies a linear transform to the entire mesh.
- AnnularMeshFor rmin>0: creates an annular mesh of QUAD4 elements. For rmin=0: creates a disc mesh of QUAD4 and TRI3 elements. Boundary sidesets are created at rmax and rmin, and given these names. If dmin!
__0 and dmax!__360, a sector of an annulus or disc is created. In this case boundary sidesets are also created a dmin and dmax, and given these names - ConcentricCircleMeshThis ConcentricCircleMesh source code is to generate concentric circle meshes.
- FileMeshRead a mesh from a file.
- GeneratedMeshCreate a line, square, or cube mesh with uniformly spaced or biased elements.
- ImageMeshGenerated mesh with the aspect ratio of a given image stack.
- MeshGeneratorMeshMesh generated from parameters
- PatternedMeshCreates a 2D mesh from a specified set of unique 'tiles' meshes and a two-dimensional pattern.
- RinglebMeshCreates a mesh for the Ringleb problem.
- SpiralAnnularMeshCreates an annual mesh based on TRI3 elements (it can also be TRI6 elements) on several rings.
- StitchedMeshReads in all of the given meshes and stitches them all together into one mesh.
- TiledMeshUse the supplied mesh and create a tiled grid by repeating this mesh in the x,y, and z directions.
- Partitioner
- Peridynamics App
- MeshGeneratorPDMesh generator class to convert FE mesh to Peridynamics mesh
- PeridynamicsMeshMesh class to store and return peridynamics specific mesh data
- Heat Conduction App
- PatchSidesetGeneratorDivides the given sideset into smaller patches of roughly equal size.
- Phase Field App
- SphereSurfaceMeshGeneratorGenerated sphere mesh - a two dimensional manifold embedded in three dimensional space
- EBSDMeshMesh generated from a specified DREAM.3D EBSD data file.
- External Petsc Solver App
- PETScDMDAMeshCreate a square mesh from PETSc DMDA.

### Mesh/Partitioner

- Moose App
- PartitionerAction
- BlockWeightedPartitionerPartition mesh by weighting blocks
- GridPartitionerCreate a uniform grid that overlays the mesh to be partitioned. Assign all elements within each cell of the grid to the same processor.
- LibmeshPartitioner
- PetscExternalPartitionerPartition mesh using external packages via PETSc MatPartitioning interface
- RandomPartitionerAssigns element processor ids randomly with a given seed.

## MeshGenerators

- Moose App
- AddMeshGeneratorActionAction for adding mesh generator objects
- AllSideSetsByNormalsGeneratorAdds sidesets to the entire mesh based on unique normals.
- AnnularMeshGeneratorFor rmin>0: creates an annular mesh of QUAD4 elements. For rmin=0: creates a disc mesh of QUAD4 and TRI3 elements. Boundary sidesets are created at rmax and rmin, and given these names. If dmin!
__0 and dmax!__360, a sector of an annulus or disc is created. In this case boundary sidesets are also created a dmin and dmax, and given these names - BlockDeletionGeneratorMesh generator which removes elements with the specified subdomain ID
- BoundingBoxNodeSetGeneratorAssigns all of the nodes either inside or outside of a bounding box to a new nodeset.
- BreakBoundaryOnSubdomainGeneratorBreak boundaries based on the subdomains to which their sides are attached. Naming convention for the new boundaries will be the old boundary name plus "_to_" plus the subdomain name
- BreakMeshByBlockGeneratorBreak boundaries based on the subdomains to which their sides are attached. Naming convention for the new boundaries will be the old boundary name plus "_to_" plus the subdomain name. At the momentthis only works on REPLICATED mesh
- CartesianMeshGeneratorThis CartesianMeshGenerator creates a non-uniform Cartesian mesh.
- CombinerGeneratorCombine multiple meshes (or copies of one mesh) together into one (disjoint) mesh. Can optionally translate those meshes before combining them.
- ConcentricCircleMeshGeneratorThis ConcentricCircleMeshGenerator source code is to generate concentric circle meshes.
- DistributedRectilinearMeshGeneratorCreate a line, square, or cube mesh with uniformly spaced or biased elements.
- ElementGeneratorGenerates individual elements given a list of nodal positions.
- ElementSubdomainIDGeneratorAllows the user to assign each element the subdomain ID of their choice
- ExtraNodesetGeneratorCreates a new node set and a new boundary made with the nodes the user provides.
- FancyExtruderGeneratorExtrudes a 2D mesh into 3D, can have variable a variable height for each elevation, variable number of layers within each elevation and remap subdomain_ids within each elevation
- FileMeshGeneratorRead a mesh from a file.
- GeneratedMeshGeneratorCreate a line, square, or cube mesh with uniformly spaced or biased elements.
- ImageMeshGeneratorGenerated mesh with the aspect ratio of a given image stack.
- ImageSubdomainGeneratorSamples an image at the coordinates of each element centroid, using the resulting pixel color value as each element's subdomain ID
- LowerDBlockFromSidesetGeneratorAdds lower dimensional elements on the specified sidesets.
- MeshCollectionGeneratorCollects multiple meshes into a single (unconnected) mesh.
- MeshExtruderGeneratorTakes a 1D or 2D mesh and extrudes the entire structure along the specified axis increasing the dimensionality of the mesh.
- MeshSideSetGeneratorAdd lower dimensional elements along the faces contained in a side set to set up mixed dimensional problems
- OrientedSubdomainBoundingBoxGeneratorDefines a subdomain inside or outside of a bounding box with arbitrary orientation.
- ParsedGenerateSidesetA MeshModifier that adds element sides to a sideset if the centroid satisfies the
`combinatorial_geometry`

expression. Optionally, element sides are also added if they are included in`included_subdomain_ids`

and if they feature the designated normal. - ParsedSubdomainMeshGeneratorUses a parsed expression (
`combinatorial_geometry`

) to determine if an element (via its centroid) is inside the region defined by the expression and assigns a new block ID. - PatchMeshGeneratorCreates 2D or 3D patch meshes.
- PatternedMeshGeneratorCreates a 2D mesh from a specified set of unique 'tiles' meshes and a two-dimensional pattern.
- PlaneDeletionGeneratorRemoves elements lying 'above' the plane (in the direction of the normal).
- RenameBlockGeneratorRenameBlockGenerator re-numbers or re-names an
`old_block_id`

or`old_block_name`

with a`new_block_id`

or`new_block_name`

. If using RenameBlockGenerator to merge blocks (by giving them the same name, for instance) it is advisable to specify all your blocks in`old_blocks`

to avoid inconsistencies - RenameBoundaryGeneratorRenameBoundaryGenerator re-numbers or re-names an
`old_boundary_id`

or`old_boundary_name`

with a`new_boundary_id`

or`new_boundary_name`

. If using RenameBoundaryGenerator to merge boundaries (by giving them the same name, for instance) it is advisable to specify all your boundaries in`old_boundaries`

to avoid inconsistencies - RinglebMeshGeneratorCreates a mesh for the Ringleb problem.
- SideSetsAroundSubdomainGeneratorAdds element faces that are on the exterior of the given block to the sidesets specified
- SideSetsBetweenSubdomainsGeneratorMeshGenerator that creates a sideset composed of the nodes located between two or more subdomains.
- SideSetsFromBoundingBoxGeneratorDefines new sidesets using currently-defined sideset IDs inside or outside of a bounding box.
- SideSetsFromNormalsGeneratorAdds a new named sideset to the mesh for all faces matching the specified normal.
- SideSetsFromPointsGeneratorAdds a new sideset starting at the specified point containing all connected element faces with the same normal.
- SmoothMeshGeneratorUtilizes a simple Laplacian based smoother to attempt to improve mesh quality. Will not move boundary nodes or nodes along block/subdomain boundaries
- SpiralAnnularMeshGeneratorCreates an annular mesh based on TRI3 or TRI6 elements on several rings.
- StackGeneratorUse the supplied meshes and stitch them on top of each other
- StitchedMeshGeneratorAllows multiple mesh files to be stiched together to form a single mesh.
- SubdomainBoundingBoxGeneratorChanges the subdomain ID of elements either (XOR) inside or outside the specified box to the specified ID.
- SubdomainIDGeneratorSets all the elements of the input mesh to a unique subdomain ID.
- TiledMeshGeneratorUse the supplied mesh and create a tiled grid by repeating this mesh in the x, y, and z directions.
- TransformGeneratorApplies a linear transform to the entire mesh.
- Peridynamics App
- MeshGeneratorPDMesh generator class to convert FE mesh to Peridynamics mesh
- Heat Conduction App
- PatchSidesetGeneratorDivides the given sideset into smaller patches of roughly equal size.
- Phase Field App
- SphereSurfaceMeshGeneratorGenerated sphere mesh - a two dimensional manifold embedded in three dimensional space

## MeshModifiers

- Moose App
- AddMeshModifierAction
- AddAllSideSetsByNormalsAdds sidesets to the entire mesh based on unique normals
- AddExtraNodeset
- AddSideSetsFromBoundingBoxFind sidesets with given boundary ids in bounding box and add new boundary id. This can be done by finding all required boundary and adding the new boundary id to those sidesets. Alternatively, a number of boundary ids can be provided and all nodes within the bounding box that have all the required boundary ids will have a newboundary id added.
- AssignElementSubdomainID
- AssignSubdomainID
- BlockDeleterMesh modifier which removes elements with the specified subdomain ID
- BoundingBoxNodeSetAssigns all of the nodes either inside or outside of a bounding box to a new nodeset.
- BreakBoundaryOnSubdomainBreak boundaries based on the subdomains to which their sides are attached. Naming convention for the new boundaries will be the old boundary name plus "_to_" plus the subdomain name
- BreakMeshByBlockBreak boundaries based on the subdomains to which their sides are attached. Naming convention for the new boundaries will be the old boundary name plus "_to_" plus the subdomain name. At the momentthis only works on REPLICATED mesh
- ImageSubdomainSamples an image at the coordinates of each element centroid using the resulting value as each element's subdomain ID
- LowerDBlockFromSidesetAdds lower dimensional elements on the specified sidesets.
- MeshExtruderTakes a 1D or 2D mesh and extrudes the entire structure along the specified axis increasing the dimensionality of the mesh.
- MeshSideSetAdd lower dimensional elements along the faces contained in a side set to set up mixed dimensional problems
- OrientedSubdomainBoundingBox
- ParsedAddSidesetA MeshModifier that adds element's sides to a sideset if the centroid satisfies the combinatorial_geometry expression, (and optionally) if one of the side's elements is in included_subdomain_ids and if it features the correct normal.
- ParsedSubdomainMeshModifierMeshModifier that uses a parsed expression (combinatorial_geometry) to determine if an element (aka its centroid) is inside the combinatorial geometry and assigns a new block id.
- RenameBlockRenameBlock re-numbers or re-names an old_block_id or old_block_name with a new_block_id or new_block_name. If using RenameBlock to merge blocks (by giving them the same name, for instance) it is advisable to specify all your blocks in old_blocks to avoid inconsistencies
- SideSetsAroundSubdomainAdds element faces that are on the exterior of the given block to the sidesets specified
- SideSetsBetweenSubdomains
- SideSetsFromNormalsAdds a new named sideset to the mesh for all faces matching the specified normal.
- SideSetsFromPointsAdds a new sideset starting at the specified point containing all connected element faces with the same normal.
- SmoothMeshUtilizes a simple Laplacian based smoother to attempt to improve mesh quality. Will not move boundary nodes or nodes along block/subdomain boundaries
- SubdomainBoundingBoxChanges the subdomain ID of elements either (XOR) inside or outside the specified box to the specified ID.
- TransformApplies a linear transform to the entire mesh.

## Modules

- Navier Stokes App
- CompressibleNavierStokes
- IncompressibleNavierStokes
- Peridynamics App
- Peridynamics
- Fluid Properties App
- FluidProperties
- Tensor Mechanics App
- TensorMechanics
- Phase Field App
- PhaseField
- Fluid Properties Test App
- FluidProperties

### Modules/CompressibleNavierStokes

- Navier Stokes App
- CNSActionThis class allows us to have a section of the input file like the following which automatically adds Kernels and AuxKernels for all the required nonlinear and auxiliary variables.

### Modules/FluidProperties

- Fluid Properties App
- AddFluidPropertiesAction
- BrineFluidPropertiesFluid properties for brine
- CO2FluidPropertiesFluid properties for carbon dioxide (CO2) using the Span & Wagner EOS
- FlibeFluidPropertiesFluid properties for flibe
- FlinakFluidPropertiesFluid properties for flinak
- HeliumFluidPropertiesFluid properties for helium
- HydrogenFluidPropertiesFluid properties for Hydrogen (H2)
- IdealGasFluidPropertiesFluid properties for an ideal gas
- IdealRealGasMixtureFluidPropertiesClass for fluid properties of an arbitrary vapor mixture
- MethaneFluidPropertiesFluid properties for methane (CH4)
- NaClFluidPropertiesFluid properties for NaCl
- NitrogenFluidPropertiesFluid properties for Nitrogen (N2)
- SimpleFluidPropertiesFluid properties for a simple fluid with a constant bulk density
- SodiumPropertiesFluid properties for sodium
- StiffenedGasFluidPropertiesFluid properties for a stiffened gas
- StiffenedGasTwoPhaseFluidPropertiesTwo-phase stiffened gas fluid properties
- TabulatedFluidPropertiesFluid properties using bicubic interpolation on tabulated values provided
- TwoPhaseFluidPropertiesIndependent2-phase fluid properties for 2 independent single-phase fluid properties
- Water97FluidPropertiesFluid properties for water and steam (H2O) using IAPWS-IF97

### Modules/IncompressibleNavierStokes

- Navier Stokes App
- INSActionThis class allows us to have a section of the input file for setting up incompressible Navier-Stokes equations.

### Modules/Peridynamics

- Peridynamics App
- Mechanics

#### Modules/Peridynamics/Mechanics

- Peridynamics App
- GeneralizedPlaneStrain
- Master

##### Modules/Peridynamics/Mechanics/GeneralizedPlaneStrain

- Peridynamics App
- GeneralizedPlaneStrainActionPDClass for setting up the Kernel, ScalarKernel, and UserObject for peridynamic generalized plane strain model

##### Modules/Peridynamics/Mechanics/Master

- Peridynamics App
- MechanicsActionPDClass for setting up peridynamic kernels

### Modules/PhaseField

- Phase Field App
- Conserved
- DisplacementGradients
- EulerAngles2RGB
- GrainGrowth
- GrandPotential
- MortarPeriodicity
- Nonconserved

#### Modules/PhaseField/Conserved

- Phase Field App
- ConservedActionSet up the variable(s) and the kernels needed for a conserved phase field variable. Note that for a direct solve, the element family and order are overwritten with hermite and third.

#### Modules/PhaseField/DisplacementGradients

- Phase Field App
- DisplacementGradientsActionSet up variables, kernels, and materials for a the displacement gradients and their elastic free energy derivatives for non-split Cahn-Hilliard problems.

#### Modules/PhaseField/EulerAngles2RGB

- Phase Field App
- EulerAngle2RGBActionSet up auxvariables and auxkernels to output Euler angles as RGB values interpolated across inverse pole figure

#### Modules/PhaseField/GrainGrowth

- Phase Field App
- GrainGrowthActionSet up the variable and the kernels needed for a grain growth simulation

#### Modules/PhaseField/GrandPotential

- Phase Field App
- GrandPotentialKernelActionAutomatically generate most or all of the kernels for the grand potential model

#### Modules/PhaseField/MortarPeriodicity

- Phase Field App
- MortarPeriodicActionAdd mortar interfaces, Lagrange multiplier variables, and constraints to implement mortar based periodicity of values or gradients on a MortarPeriodicMesh

#### Modules/PhaseField/Nonconserved

- Phase Field App
- NonconservedActionSet up the variable and the kernels needed for a non-conserved phase field variable

### Modules/TensorMechanics

- Tensor Mechanics App
- CohesiveZoneMaster
- GeneralizedPlaneStrain
- GlobalStrain
- LineElementMaster
- Master

#### Modules/TensorMechanics/CohesiveZoneMaster

- Tensor Mechanics App
- CohesiveZoneMasterActionAction to create an instance of the cohesive zone model kernel for each displacement component

#### Modules/TensorMechanics/GeneralizedPlaneStrain

- Tensor Mechanics App
- GeneralizedPlaneStrainActionSet up the GeneralizedPlaneStrain environment

#### Modules/TensorMechanics/GlobalStrain

- Tensor Mechanics App
- GlobalStrainActionSet up the GlobalStrainAction environment

#### Modules/TensorMechanics/LineElementMaster

- Tensor Mechanics App
- CommonLineElementActionSets up variables, stress divergence kernels and materials required for a static analysis with beam or truss elements. Also sets up aux variables, aux kernels, and consistent or nodal inertia kernels for dynamic analysis with beam elements.
- LineElementActionSets up variables, stress divergence kernels and materials required for a static analysis with beam or truss elements. Also sets up aux variables, aux kernels, and consistent or nodal inertia kernels for dynamic analysis with beam elements.

#### Modules/TensorMechanics/Master

- Tensor Mechanics App
- CommonTensorMechanicsActionStore common tensor mechanics parameters
- TensorMechanicsActionSet up stress divergence kernels with coordinate system aware logic

## MultiApps

- Moose App
- AddMultiAppActionMooseObjectAction for creating objects from sub-blocks within the MultiApps block.
- CentroidMultiAppAutomatically generates Sub-App positions from centroids of elements in the master mesh.
- FullSolveMultiAppPerforms a complete simulation during each execution.
- TransientMultiAppMultiApp for performing coupled simulations with the master and sub-application both progressing in time.
- Stochastic Tools App
- SamplerFullSolveMultiAppCreates a full-solve type sub-application for each row of each Sampler matrix.
- SamplerTransientMultiAppCreates a sub-application for each row of each Sampler matrix.
- Level Set App
- LevelSetReinitializationMultiAppMultiApp capable of performing repeated complete solves for level set reinitialization.

## NodalKernels

- Moose App
- AddNodalKernelAction
- ConstantRate
- CoupledForceNodalKernelAdds a force proportional to the value of the coupled variable
- LowerBoundNodalKernelUsed to prevent a coupled variable from going below a lower bound
- PenaltyDirichletNodalKernelEnforces a Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the Dirichlet value on nodesets.
- ReactionNodalKernelImplements a simple consuming reaction term at nodes
- TimeDerivativeNodalKernel
- UpperBoundNodalKernelUsed to prevent a coupled variable from going above a upper bound
- UserForcingFunctionNodalKernel
- Tensor Mechanics App
- NodalGravityComputes the gravitational force for a given nodal mass.
- NodalRotationalInertiaCalculates the inertial torques and inertia proportional damping corresponding to the nodal rotational inertia.
- NodalTranslationalInertiaComputes the inertial forces and mass proportional damping terms corresponding to nodal mass.
- Peridynamics App
- PenaltyDirichletOldValuePDEnforces a Dirichlet boundary condition in a weak sense by penalizing differences between the current solution and the old solution for transient problems.

## NodalNormals

- Moose App
- AddNodalNormalsAction

## Outputs

- Moose App
- CommonOutputActionAdds short-cut syntax and common parameters to the Outputs block.
- AddOutputActionAction responsible for creating Output objects.
- CSVOutput for postprocessors, vector postprocessors, and scalar variables using comma seperated values (CSV).
- CheckpointOutput for MOOSE recovery checkpoint files.
- ConsoleObject for screen output.
- ControlOutputOutput for displaying objects and parameters associated with the Control system.
- DOFMapOutput degree-of-freedom (DOF) map.
- ExodusObject for output data in the Exodus II format
- GMVObject for outputting data in the GMV format
- GnuplotOutput for postprocessors and scalar variables in GNU plot format.
- MaterialPropertyDebugOutputDebug output object for displaying material property information.
- NemesisObject for output data in the Nemesis (parallel ExodusII) format.
- PerfGraphOutputControls output of the PerfGraph: the performance log for MOOSE
- SolutionHistoryOutputs the non-linear and linear iteration solve history.
- TecplotObject for outputting data in the Tecplot format
- TopResidualDebugOutputDebug output object for displaying the top contributing residuals.
- VTKOutput data using the Visualization Toolkit (VTK).
- VariableResidualNormsDebugOutputReports the residual norm for each variable.
- XDAObject for outputting data in the XDA/XDR format.
- XDRObject for outputting data in the XDA/XDR format.
- XMLOutputOutput for VectorPostprocessor using XML format.
- Stochastic Tools App
- SurrogateTrainerOutputOutput for trained surrogate model data.
- Geochemistry App
- GeochemicalModelInterrogatorPerforming simple manipulations of and querying a geochemical model
- GeochemistryConsoleOutputOutputs results from a GeochemistryReactor at a particular point

## PorousFlowBasicTHM

- Porous Flow App
- PorousFlowBasicTHMAdds Kernels and fluid-property Materials necessary to simulate a single-phase, single-component fully-saturated flow problem. No upwinding and no mass lumping of the fluid mass are used. The fluid-mass time derivative is close to linear, and is perfectly linear if multiply_by_density=false. These features mean the results may differ slightly from the Unsaturated Action case. To run a simulation you will also need to provide various other Materials for each mesh block, depending on your simulation type, viz: permeability, constant Biot modulus, constant thermal expansion coefficient, porosity, elasticity tensor, strain calculator, stress calculator, matrix internal energy, thermal conductivity, diffusivity

## PorousFlowFullySaturated

- Porous Flow App
- PorousFlowFullySaturatedAdds Kernels and fluid-property Materials necessary to simulate a single-phase fully-saturated flow problem. Full-upwinding of fluid flow is not available in this Action, so the results may differ slightly from the Unsaturated Action. However KT stabilization may be employed for both the fluid and any heat flow. No Kernels for diffusion and dispersion of fluid components are added. To run a simulation you will also need to provide various other Materials for each mesh block, depending on your simulation type, viz: permeability, porosity, elasticity tensor, strain calculator, stress calculator, matrix internal energy, thermal conductivity, diffusivity

## PorousFlowUnsaturated

- Porous Flow App
- PorousFlowUnsaturatedAdds Kernels and fluid-property Materials necessary to simulate a single-phase saturated-unsaturated flow problem. The saturation is computed using van Genuchten's expression. No Kernels for diffusion and dispersion of fluid components are added. To run a simulation you will also need to provide various other Materials for each mesh block, depending on your simulation type, viz: permeability, porosity, elasticity tensor, strain calculator, stress calculator, matrix internal energy, thermal conductivity, diffusivity

## Postprocessors

- Moose App
- AddPostprocessorAction
- SetupPostprocessorDataAction
- ADElementAverageMaterialPropertyComputes the average of a material property over a volume.
- ADElementExtremeMaterialPropertyDetermines the minimum or maximum of a material property over a volume.
- ADElementIntegralMaterialPropertyCompute the integral of the material property over the domain
- ADSideFluxAverageComputes the integral of the flux over the specified boundary
- ADSideFluxIntegralComputes the integral of the flux over the specified boundary
- AreaPostprocessorComputes the "area" or dimension - 1 "volume" of a given boundary or boundaries in your mesh.
- AverageElementSize
- AverageNodalVariableValueComputes the average value of a field by sampling all nodal solutions on the domain or within a subdomain
- AxisymmetricCenterlineAverageValueComputes the average value of a variable on a sideset located along the centerline of an axisymmetric model.
- ChangeOverTimePostprocessorComputes the change or relative change in a post-processor value over a timestep or the entire transient
- ChangeOverTimestepPostprocessorComputes the change or relative change in a post-processor value over a timestep or the entire transient
- CumulativeValuePostprocessor
- DifferencePostprocessorComputes the difference between two postprocessors
- ElementAverageMaterialPropertyComputes the average of a material property over a volume.
- ElementAverageSecondTimeDerivativeComputes the element averaged second derivative of variable
- ElementAverageTimeDerivativeComputes a volume integral of the time derivative of a given variable
- ElementAverageValueComputes a volume integral of the specified variable
- ElementExtremeMaterialPropertyDetermines the minimum or maximum of a material property over a volume.
- ElementExtremeValueFinds either the min or max elemental value of a a variable over the domain.
- ElementH1ErrorComputes a volume integral of the specified variable
- ElementH1SemiErrorComputes a volume integral of the specified variable
- ElementIntegralArrayVariablePostprocessorIntegral of one component of an array variable.
- ElementIntegralMaterialPropertyCompute the integral of the material property over the domain
- ElementIntegralVariablePostprocessorComputes a volume integral of the specified variable
- ElementL2DifferenceComputes the element-wise L2 difference between the current variable and a coupled variable.
- ElementL2ErrorComputes L2 error between a field variable and an analytical function
- ElementL2NormComputes a volume integral of the specified variable
- ElementVectorL2ErrorComputes the Vector L2 difference of up to three variables simultaneously (normally x, y, z)
- ElementW1pErrorComputes a volume integral of the specified variable
- ElementalVariableValueOutputs an elemental variable value at a particular location
- EmptyPostprocessor
- ExecutionerAttributeReporter
- FindValueOnLineFind a specific target value along a sampling line. The variable values along the line should change monotonically. The target value is searched using a bisection algorithm.
- FunctionElementIntegralIntegrates a function over elements
- FunctionSideIntegral
- FunctionValuePostprocessorComputes the value of a supplied function at a single point (scalable)
- GreaterThanLessThanPostprocessorCount number of DOFs of a non-linear variable that are greater than or less than a given threshold
- InterfaceAverageVariableValuePostprocessorComputes the average value of a variable on an interface. Note that this cannot be used on the centerline of an axisymmetric model.
- InterfaceIntegralVariableValuePostprocessorAdd access to variables and their gradient on an interface.
- LinearCombinationPostprocessorComputes a linear combination between an arbitrary number of post-processors
- MemoryUsageMemory usage statistics for the running simulation.
- NodalExtremeValue
- NodalL2Error
- NodalL2Norm
- NodalMaxValue
- NodalProxyMaxValue
- NodalSumComputes the sum of all of the nodal values of the specified variable. Note: This object sets the default "unique_node_execute" flag to true to avoid double counting nodes between shared blocks.
- NodalVariableValueOutputs values of a nodal variable at a particular location
- NumDOFsReturn the number of Degrees of freedom from either the NL, Aux or both systems.
- NumElemsReturn the number of active or total elements in the simulation.
- NumLinearIterations
- NumNodesReturns the total number of nodes in a simulation (works with DistributedMesh)
- NumNonlinearIterationsOutputs the number of nonlinear iterations
- NumPicardIterations
- NumRelationshipManagersReturn the number of relationship managers active.
- NumResidualEvaluations
- NumVarsReturn the number of variables from either the NL, Aux, or both systems.
- PercentChangePostprocessor
- PerfGraphDataRetrieves timing information from the PerfGraph.
- PerformanceDataProvides programmatic access to Performance Log Data
- PointValueCompute the value of a variable at a specified location
- PostprocessorComparisonCompares two post-processors and produces a boolean value
- ReceiverReports the value stored in this processor, which is usually filled in by another object. The Receiver does not compute its own value.
- RelativeDifferencePostprocessorComputes the absolute value of the relative difference between 2 post-processor values.
- RelativeSolutionDifferenceNormComputes the relative norm of the solution difference of two consecutive time steps.
- Residual
- ScalarL2Error
- ScalarVariable
- ScalePostprocessorScales a post-processor by a value
- SideAverageValueComputes the average value of a variable on a sideset. Note that this cannot be used on the centerline of an axisymmetric model.
- SideFluxAverageComputes the integral of the flux over the specified boundary
- SideFluxIntegralComputes the integral of the flux over the specified boundary
- SideIntegralVariablePostprocessorComputes a surface integral of the specified variable
- TimeExtremeValueA postprocessor for reporting the extreme value of another postprocessor over time.
- TimePostprocessorReports the current time
- TimestepSizeReports the timestep size
- TotalVariableValue
- VariableInnerProductComputes a volume integral of the specified variable
- VariableResidualComputes the Residual of a single variable in the solution vector.
- VectorPostprocessorComparisonCompares two vector post-processors of equal size and produces a boolean value
- VectorPostprocessorComponentReturns the value of the specified component of a VectorPostprocessor
- VolumePostprocessorComputes the volume of a specified block
- Rdg App
- BoundaryFluxPostprocessorComputes the side integral of a flux entry from a BoundaryFluxBase user object
- Heat Conduction App
- ADConvectiveHeatTransferSideIntegralComputes the total convective heat transfer across a boundary.
- ConvectiveHeatTransferSideIntegralComputes the total convective heat transfer across a boundary.
- GrayLambertSurfaceRadiationPPThis postprocessor allows to extract radiosity, heat flux density, and temperature from the GrayLambertSurfaceRadiationBase object.
- HomogenizedThermalConductivityPostprocessor for asymptotic expansion homogenization for thermal conductivity
- ThermalConductivityComputes the average value of a variable on a sideset. Note that this cannot be used on the centerline of an axisymmetric model.
- ViewFactorPPThis postprocessor allows to extract view factors from ViewFactor userobjects.
- Porous Flow App
- PorousFlowFluidMassCalculates the mass of a fluid component in a region
- PorousFlowHeatEnergyCalculates the sum of heat energy of fluid phase(s) and/or the porous skeleton in a region
- PorousFlowPlotQuantityExtracts the value from the PorousFlowSumQuantity UserObject
- Tensor Mechanics App
- ADMassComputes a volume integral of the specified variable
- ADMaterialTensorAverageComputes the average of a RankTwoTensor component over a volume.
- ADMaterialTensorIntegralThis postprocessor computes an element integral of a component of a material tensor as specified by the user-supplied indices
- ADSidesetReactionComputes the integrated reaction force in a user-specified direction on a sideset from the surface traction
- AsymptoticExpansionHomogenizationElasticConstantsPostprocessor for asymptotic expansion homogenization for elasticity
- CavityPressurePostprocessorInterfaces with the CavityPressureUserObject to store the initial number of moles of a gas contained within an internal volume.
- CrackFrontDataDetermines which nodes are along the crack front
- CriticalTimeStepComputes and reports the critical time step for the explicit solver.
- MassComputes a volume integral of the specified variable
- MaterialTensorAverageComputes the average of a RankTwoTensor component over a volume.
- MaterialTensorIntegralThis postprocessor computes an element integral of a component of a material tensor as specified by the user-supplied indices
- MaterialTimeStepPostprocessorThis postprocessor estimates a timestep that reduces the increment change in a material property below a given threshold.
- SidesetReactionComputes the integrated reaction force in a user-specified direction on a sideset from the surface traction
- TorqueReactionTorqueReaction calculates the torque in 2D and 3Dabout a user-specified axis of rotation centeredat a user-specied origin.
- Phase Field App
- AverageGrainVolumeCalculate average grain area in a polycrystal
- DiscreteNucleationDataOutput diagnostic data on a DiscreteNucleationInserter
- DiscreteNucleationTimeStepReturn a time step limit for nucleation event to be used by IterationAdaptiveDT
- FauxGrainTrackerFake grain tracker object for cases where the number of grains is equal to the number of order parameters.
- FauxPolycrystalVoronoiRandom Voronoi tessellation polycrystal when the number of order parameters equal to the number of grains
- FeatureFloodCountThe object is able to find and count "connected components" in any solution field or number of solution fields. A primary example would be to count "bubbles".
- FeatureVolumeFraction
- GrainBoundaryAreaCalculate total grain boundary length in 2D and area in 3D
- GrainTrackerGrain Tracker object for running reduced order parameter simulations without grain coalescence.
- GrainTrackerElasticityGrain Tracker object for running reduced order parameter simulations without grain coalescence.
- PFCElementEnergyIntegral
- PolycrystalCirclesPolycrystal circles generated from a vector input or read from a file
- PolycrystalEBSDObject for setting up a polycrystal structure from an EBSD Datafile
- PolycrystalHexPerturbed hexagonal polycrystal
- PolycrystalVoronoiRandom Voronoi tessellation polycrystal (used by PolycrystalVoronoiAction)
- Contact App
- ContactDOFSetSizeOutputs the number of dofs greater than a tolerance threshold indicating mechanical contact
- Peridynamics App
- BondStatusConvergedPostprocessorPDPostprocessor to check whether the bond status is converged within a time step
- NodalDisplacementDifferenceL2NormPDClass for computing the L2 norm of the difference between displacements and their analytic solutions
- NodalFunctionsL2NormPDClass for computing the L2 norm of functions
- NodalVariableIntegralPDClass for calculating the domain integral of nodal variables
- Navier Stokes App
- INSExplicitTimestepSelectorPostprocessor that computes the minimum value of h_min/|u|, where |u| is coupled in as an aux variable.
- NSEntropyErrorComputes entropy error.
- VolumetricFlowRateComputes the volumetric flow rate through a boundary.
- Misc App
- InternalVolumeComputes the volume of an enclosed area by performing an integral over a user-supplied boundary.
- Level Set App
- LevelSetCFLConditionCompute the minimum timestep from the Courant-Friedrichs-Lewy (CFL) condition for the level-set equation.
- LevelSetVolumeCompute the area or volume of the region inside or outside of a level set contour.
- Chemical Reactions App
- TotalMineralVolumeFractionTotal volume fraction of coupled mineral species

## Preconditioning

- Moose App
- SetupPreconditionerAction
- AddFieldSplitAction
- Split
- FDPFinite difference preconditioner (FDP) builds a numerical Jacobian for preconditioning, only use for testing and verification.
- FSP
- PBPPhysics-based preconditioner (PBP) allows individual physics to have their own preconditioner.
- SMPSingle matrix preconditioner (SMP) builds a preconditioner using user defined off-diagonal parts of the Jacobian.
- Contact App
- ContactSplitSplit-based preconditioner that partitions the domain into DOFs directly involved in contact (on contact surfaces) and those that are not

## Problem

- Moose App
- CreateProblemAction
- DynamicObjectRegistrationAction
- DisplacedProblem
- DumpObjectsProblemSingle purpose problem object that does not run the given input but allows deconstructing actions into their series of underlying Moose objects and variables.
- EigenProblem
- FEProblemA normal (default) Problem object that contains a single NonlinearSystem and a single AuxiliarySystem object.
- ReferenceResidualProblemProblem that checks for convergence relative to a user-supplied reference quantity rather than the initial residual
- Level Set App
- LevelSetProblemA specilized problem class that adds a custom call to MultiAppTransfer execution to transfer adaptivity for the level set reinitialization.
- LevelSetReinitializationProblemA specialied problem that has a method for resetting time for level set reinitialization execution.
- Contact App
- AugmentedLagrangianContactProblemManages nested solution for augmented Lagrange contact
- External Petsc Solver App
- ExternalPETScProblemProblem extension point for wrapping external applications

## ReactionNetwork

- Moose App
- AqueousEquilibriumReactions
- SolidKineticReactions
- Chemical Reactions App
- AqueousEquilibriumReactions
- SolidKineticReactions

### ReactionNetwork/AqueousEquilibriumReactions

- Moose App
- MooseVariableRepresents standard field variables, e.g. Lagrange, Hermite, or non-constant Monomials
- MooseVariableBaseBase class for Moose variables. This should never be the terminal object type
- MooseVariableConstMonomialSpecialization for constant monomials that avoids unnecessary loops
- MooseVariableFVRealBase class for Moose variables. This should never be the terminal object type
- MooseVariableScalarMoose wrapper class around scalar variables
- VectorMooseVariableRepresents vector field variables, e.g. Vector Lagrange or Nedelec
- Chemical Reactions App
- AddCoupledEqSpeciesActionAdds coupled equilibrium Kernels and AuxKernels for primary species
- AddPrimarySpeciesActionAdds Variables for all primary species
- AddSecondarySpeciesActionAdds AuxVariables for all secondary species

### ReactionNetwork/SolidKineticReactions

- Moose App
- MooseVariableRepresents standard field variables, e.g. Lagrange, Hermite, or non-constant Monomials
- MooseVariableBaseBase class for Moose variables. This should never be the terminal object type
- MooseVariableConstMonomialSpecialization for constant monomials that avoids unnecessary loops
- MooseVariableFVRealBase class for Moose variables. This should never be the terminal object type
- MooseVariableScalarMoose wrapper class around scalar variables
- VectorMooseVariableRepresents vector field variables, e.g. Vector Lagrange or Nedelec
- Chemical Reactions App
- AddCoupledSolidKinSpeciesActionAdds solid kinetic Kernels and AuxKernels for primary species
- AddPrimarySpeciesActionAdds Variables for all primary species
- AddSecondarySpeciesActionAdds AuxVariables for all secondary species

## Samplers

- Moose App
- AddSamplerAction
- Stochastic Tools App
- CartesianProductProvides complete Cartesian product for the supplied variables.
- CartesianProductSamplerProvides complete Cartesian product for the supplied variables.
- LatinHypercubeLatin Hypercube Sampler.
- MonteCarloMonte Carlo Sampler.
- MonteCarloSamplerMonte Carlo Sampler.
- QuadratureQuadrature sampler for Polynomial Chaos.
- QuadratureSamplerQuadrature sampler for Polynomial Chaos.
- SobolSobol variance-based sensitivity analysis Sampler.
- SobolSamplerSobol variance-based sensitivity analysis Sampler.

## ScalarKernels

- Moose App
- AddScalarKernelAction
- AverageValueConstraintThis class is used to enforce integral of phi with a Lagrange multiplier approach.
- CoupledODETimeDerivative
- NodalEqualValueConstraint
- ODETimeDerivative
- ParsedODEKernelParsed ODE function kernel.
- Tensor Mechanics App
- GeneralizedPlaneStrainGeneralized Plane Strain Scalar Kernel
- GlobalStrainScalar Kernel to solve for the global strain
- Peridynamics App
- GeneralizedPlaneStrainPDClass for claculating residual and diagonal Jacobian forstate-based peridynamic generalized plane strain formulation

## StochasticTools

- Stochastic Tools App
- StochasticToolsActionAction for performing some common functions for running stochastic simulations.

## Surrogates

- Stochastic Tools App
- AddSurrogateActionAdds SurrogateTrainer and SurrogateModel objects contained within the
`[Trainers]`

and`[Surrogates]`

input blocks. - GaussianProcessComputes and evaluates Gaussian Process surrogate model.
- NearestPointSurrogateSurrogate that evaluates the value from the nearest point from data in NearestPointTrainer
- PolynomialChaosComputes and evaluates polynomial chaos surrogate model.
- PolynomialRegressionSurrogateEvaluates polynomial regression model with coefficients computed from PolynomialRegressionTrainer.

## ThermalContact

- Heat Conduction App
- ThermalContactActionAction that controls the creation of all of the necessary objects for calculation of Thermal Contact

## TimeDependentReactionSolver

- Geochemistry App
- AddTimeDependentReactionSolverActionAction that sets up a time-dependent equilibrium reaction solver. This creates creates a time-dependent geochemistry solver, and adds AuxVariables corresonding to the molalities, etc

## TimeIndependentReactionSolver

- Geochemistry App
- AddTimeIndependentReactionSolverActionAction that sets up a time-dependent equilibrium reaction solver. This creates creates a time-dependent geochemistry solver, and adds AuxVariables corresonding to the molalities, etc

## Trainers

- Stochastic Tools App
- AddSurrogateActionAdds SurrogateTrainer and SurrogateModel objects contained within the
`[Trainers]`

and`[Surrogates]`

input blocks. - GaussianProcessTrainerProvides data preperation and training for a Gaussian Process surrogate model.
- NearestPointTrainerLoops over and saves sample values for NearestPointSurrogate.
- PolynomialChaosTrainerComputes and evaluates polynomial chaos surrogate model.
- PolynomialRegressionTrainerComputes coefficients for polynomial regession model.

## Transfers

- Moose App
- AddTransferActionAction for creating Transfer objects.
- MultiAppCopyTransferCopies variables (nonlinear and auxiliary) between multiapps that have identical meshes.
- MultiAppInterpolationTransferTransfers the value to the target domain from the nearest node in the source domain.
- MultiAppMeshFunctionTransferTransfers field data at the MultiApp position using solution the finite element function from the master application, via a 'libMesh::MeshFunction' object.
- MultiAppNearestNodeTransferTransfer the value to the target domain from the nearest node in the source domain.
- MultiAppPostprocessorInterpolationTransferTransfer postprocessor data from sub-application into field data on the master application.
- MultiAppPostprocessorToAuxScalarTransferTransfers from a postprocessor to an scalar auxiliary variable.
- MultiAppPostprocessorTransferTransfers postprocessor data between the master application and sub-application(s).
- MultiAppProjectionTransferPerform a projection between a master and sub-application mesh of a field variable.
- MultiAppScalarToAuxScalarTransferTransfers data between a scalar non-linear variable and a scalar auxiliary variable.
- MultiAppUserObjectTransferSamples a variable's value in the Master domain at the point where the MultiApp is and copies that value into a post-processor in the MultiApp
- MultiAppVariableValueSamplePostprocessorTransferTransfers the value of a variable within the master application at each sub-application position and transfers the value to a postprocessor on the sub-application(s).
- MultiAppVariableValueSampleTransferTransfers the value of a variable within the master application at each sub-application position and transfers the value to a field variable on the sub-application(s).
- MultiAppVectorPostprocessorTransferThis transfer distributes the N values of a VectorPostprocessor to Postprocessors located in N sub-apps or collects Postprocessor values from N sub-apps into a VectorPostprocessor
- Level Set App
- LevelSetMeshRefinementTransferTransfers the mesh from the master application to the sub application for the purposes of level set reinitialization problems with mesh adaptivity.
- Stochastic Tools App
- SamplerParameterTransferCopies Sampler data to a SamplerReceiver object.
- SamplerPostprocessorTransferTransfers data from Postprocessors on the sub-application to a VectorPostprocessor on the master application.
- SamplerTransferCopies Sampler data to a SamplerReceiver object.
- Functional Expansion Tools App
- MultiAppFXTransferTransfers coefficient arrays between objects that are derived from MutableCoefficientsInterface; currently includes the following types: FunctionSeries, FXBoundaryUserObject, and FXVolumeUserObject

## UserObjects

- Moose App
- AddUserObjectAction
- ElementIntegralVariableUserObject
- ElementQualityCheckerClass to check the quality of each element using different metrics from libmesh.
- GeometrySphereSnap nodes to the surface of a sphere on adaptivity
- GhostingUserObjectCreates ghosting maps that can be queried by external objects.
- InterfaceQpMaterialPropertyRealUOComputes the value, rate or increment of a Real Material property across an interface. The value, rate or increment is computed according to the provided interface_value_type parameter
- InterfaceQpValueUserObjectComputes the variable value, rate or increment across an interface. The value, rate or increment is computed according to the provided interface_value_type parameter
- LayeredAverage
- LayeredIntegral
- LayeredSideAverage
- LayeredSideFluxAverage
- LayeredSideIntegral
- NearestPointLayeredAverageComputes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z). Given a list of points this object computes the layered average closest to each one of those points.
- NearestPointLayeredIntegralComputes integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z). Given a list of points this object computes the layered integral closest to each one of those points.
- NearestPointLayeredSideAverageCompute layered side averages for nearest-point based subdomains
- NodalNormalsCorner
- NodalNormalsEvaluator
- NodalNormalsPreprocessor
- PostprocessorSpatialUserObjectUser object (spatial) that holds a postprocessor value.
- SolutionUserObjectReads a variable from a mesh in one simulation to another
- Terminator
- VerifyElementUniqueID
- VerifyNodalUniqueID
- Rdg App
- AEFVFreeOutflowBoundaryFluxFree outflow BC based boundary flux user object for the advection equation using a cell-centered finite volume method.
- AEFVSlopeLimitingOneDOne-dimensional slope limiting to get the limited slope of cell average variable for the advection equation using a cell-centered finite volume method.
- AEFVUpwindInternalSideFluxUpwind numerical flux scheme for the advection equation using a cell-centered finite volume method.
- Heat Conduction App
- ConstantViewFactorSurfaceRadiationConstantViewFactorSurfaceRadiation computes radiative heat transfer between side sets and the view factors are provided in the input file
- UnobstructedPlanarViewFactorComputes the view factors for planar faces in unubstructed radiative heat transfer.
- ViewFactorObjectSurfaceRadiationViewFactorObjectSurfaceRadiation computes radiative heat transfer between side sets and the view factors are computed by a ViewFactor object
- Fluid Properties App
- FluidPropertiesInterrogatorUser object for querying a single-phase or two-phase fluid properties object
- Tensor Mechanics App
- CavityPressureUserObjectUses the ideal gas law to compute internal pressure and an initial moles of gas quantity.
- CrackFrontDefinitionUsed to describe geometric characteristics of the crack front for fracture integral calculations
- CrystalPlasticitySlipRateGSSPhenomenological constitutive model slip rate class. Override the virtual functions in your class
- CrystalPlasticitySlipResistanceGSSPhenomenological constitutive models' slip resistance base class. Override the virtual functions in your class
- CrystalPlasticityStateVarRateComponentGSSPhenomenological constitutive model state variable evolution rate component base class. Override the virtual functions in your class
- CrystalPlasticityStateVarRateComponentVocePhenomenological Voce constitutive model state variable evolution rate component base class.
- CrystalPlasticityStateVariableCrystal plasticity state variable class. Override the virtual functions in your class
- ElementPropertyReadFileUser Object to read property data from an external file and assign to elements.
- EulerAngleFileReaderRead Euler angle data from a file and provide it to other objects.
- GeneralizedPlaneStrainUserObjectGeneralized plane strain UserObject to provide residual and diagonal Jacobian entries.
- GlobalStrainUserObjectGlobal Strain UserObject to provide Residual and diagonal Jacobian entry
- HEVPEqvPlasticStrainUser Object to integrate equivalent plastic strain
- HEVPEqvPlasticStrainRateUser Object computing equivalent plastic strain rate
- HEVPFlowRatePowerLawJ2User object to evaluate power law flow rate and flow direction based on J2
- HEVPLinearHardeningUser Object for linear hardening
- HEVPRambergOsgoodHardeningUser object for Ramberg-Osgood hardening power law hardening
- LinearViscoelasticityManagerManages the updating of the semi-implicit single-step first-order finite difference time-stepping scheme
- TensorMechanicsHardeningConstantNo hardening - the parameter is independent of the internal parameter(s)
- TensorMechanicsHardeningCubicHardening is Cubic
- TensorMechanicsHardeningCutExponentialHardening is Cut-exponential
- TensorMechanicsHardeningExponentialHardening is Exponential
- TensorMechanicsHardeningGaussianHardening is Gaussian
- TensorMechanicsHardeningPowerRuleHardening defined by power rule
- TensorMechanicsPlasticDruckerPragerNon-associative Drucker Prager plasticity with no smoothing of the cone tip.
- TensorMechanicsPlasticDruckerPragerHyperbolicNon-associative Drucker Prager plasticity with hyperbolic smoothing of the cone tip.
- TensorMechanicsPlasticIsotropicSDIsotropicSD plasticity for pressure sensitive materials and also models the strength differential effect
- TensorMechanicsPlasticJ2J2 plasticity, associative, with hardening
- TensorMechanicsPlasticMeanCapClass that limits the mean stress. Yield function = a*mean_stress - strength. mean_stress = (stress_xx + stress_yy + stress_zz)/3
- TensorMechanicsPlasticMeanCapTCAssociative mean-cap tensile and compressive plasticity with hardening/softening
- TensorMechanicsPlasticMohrCoulombNon-associative Mohr-Coulomb plasticity with hardening/softening
- TensorMechanicsPlasticMohrCoulombMultiNon-associative Mohr-Coulomb plasticity with hardening/softening
- TensorMechanicsPlasticOrthotropicOrthotropic plasticity for pressure sensitive materials and also models the strength differential effect
- TensorMechanicsPlasticSimpleTesterClass that can be used for testing multi-surface plasticity models. Yield function = a*stress_yy + b*stress_zz + c*stress_xx + d*(stress_xy + stress_yx)/2 + e*(stress_xz + stress_zx)/2 + f*(stress_yz + stress_zy)/2 - strength
- TensorMechanicsPlasticTensileAssociative tensile plasticity with hardening/softening, and tensile_strength = 1
- TensorMechanicsPlasticTensileMultiAssociative tensile plasticity with hardening/softening
- TensorMechanicsPlasticWeakPlaneShearNon-associative finite-strain weak-plane shear perfect plasticity. Here cohesion = 1, tan(phi) = 1 = tan(psi)
- TensorMechanicsPlasticWeakPlaneTensileAssociative weak-plane tensile plasticity with hardening/softening
- TensorMechanicsPlasticWeakPlaneTensileNAssociative weak-plane tensile plasticity with hardening/softening, with specified, fixed normal vector. (WeakPlaneTensile combined with specifying N in the Material might be preferable to you.)
- Phase Field App
- ComputeExternalGrainForceAndTorqueUserobject for calculating force and torque acting on a grain
- ComputeGrainForceAndTorqueUserobject for calculating force and torque acting on a grain
- ConservedMaskedNormalNoiseGaussian normal distributed random number noise provider with an applied spatially dependent material property mask for the ConservedLangevinNoise kernel.
- ConservedMaskedUniformNoiseUniformly distributed random number noise provider with an applied spatially dependent material property mask for the ConservedLangevinNoise kernel.
- ConservedNormalNoiseGaussian normal distributed random number noise provider for the ConservedLangevinNoise kernel.
- ConservedUniformNoiseUniformly distributed random number noise provider for the ConservedLangevinNoise kernel.
- ConstantGrainForceAndTorqueUserobject for calculating force and torque acting on a grain
- DiscreteNucleationFromFileManages the list of currently active nucleation sites and adds new sites according to a predetermined list from a CSV file (use this with sync_times).
- DiscreteNucleationInserterManages the list of currently active nucleation sites and adds new sites according to a given probability function.
- DiscreteNucleationMapGenerates a spatial smoothed map of all nucleation sites with the data of the DiscreteNucleationInserter for use by the DiscreteNucleation material.
- EBSDReaderLoad and manage DREAM.3D EBSD data files for running simulations on reconstructed microstructures.
- EulerAngleUpdaterProvide updated euler angles after rigid body rotation of the grains.
- GrainForceAndTorqueSumUserobject for summing forces and torques acting on a grain
- MaskedGrainForceAndTorqueUserobject for masking/pinning grains and making forces and torques acting on that grain zero
- RandomEulerAngleProviderAssign random Euler angles for each grain.
- SolutionRasterizerProcess an XYZ file of atomic coordinates and filter atoms via threshold or map variable values.
- Functional Expansion Tools App
- FXBoundaryFluxUserObjectGenerates an Functional Expansion representation for a boundary flux condition using a 'FunctionSeries'-type Function
- FXBoundaryValueUserObjectGenerates an Functional Expansion representation for a boundary value condition using a 'FunctionSeries'-type Function
- FXVolumeUserObjectGenerates an Functional Expansion representation of a variable value over a volume using a 'FunctionSeries'-type Function
- Peridynamics App
- GeneralizedPlaneStrainUserObjectHNOSPDClass for calculating the scalar residual and diagonal Jacobian entry of generalized plane strain in the NOSPD formulation
- GeneralizedPlaneStrainUserObjectOSPDClass for calculating the scalar residual and diagonal Jacobian entry of generalized plane strain in OSPD formulation
- GhostElemPDClass for ghosting elements accross processors
- NodalDamageIndexPDClass for computing damage index for each material point in peridynamic fracture modeling and simulation
- NodalNumIntactBondsPDClass for computing number of intact bonds for each material point in peridynamic fracture modeling and simulation
- NodalRankTwoComponentPDClass for calculating components of nodal rank-two stress and strain tensors from material properties (stress and strain) for edge elements (i.e., bonds) connected at that node. NOTE: This UserObject only applies to the NOSPD model.
- NodalRankTwoScalarPDClass for calculating scalar quantities of nodal rank-two stress and strain tensors from material properties (stress and strain) for edge elements (i.e., bonds) connected at that node. NOTE: This UserObject only applies to the NOSPD model.
- SingularShapeTensorEliminatorUserObjectPDUserObject to eliminate the existance of singular shape tensor
- XFEMApp
- CircleCutUserObjectCreates a UserObject for circular cuts on 3D meshes for XFEM
- EllipseCutUserObjectCreates a UserObject for elliptical cuts on 3D meshes for XFEM
- LevelSetCutUserObjectXFEM mesh cut by level set function
- LineSegmentCutSetUserObjectCreates a UserObject for a line segment cut on 2D meshes for XFEM
- LineSegmentCutUserObjectCreates a UserObject for a line segment cut on 2D meshes for XFEM
- MeshCut3DUserObjectCreates a UserObject for a mesh cutter in 3D problems
- MovingLineSegmentCutSetUserObjectCreates a UserObject for a moving line segment cut on 2D meshes for XFEM
- PointValueAtXFEMInterfaceObtain field values and gradients on the interface.
- RectangleCutUserObjectCreates a UserObject for planar cuts on 3D meshes for XFEM
- XFEMPhaseTransitionMovingInterfaceVelocitycalculate the interface velocity for a simple phase transition problem.
- XFEMRankTwoTensorMarkerUserObjectMark elements to be cut by XFEM based on a scalar extracted from a RankTwoTensor
- Geochemistry App
- GeochemicalModelDefinitionUser object that parses a geochemical database file, and only retains information relevant to the current geochemical model
- GeochemistryKineticRateUser object that defines a kinetic rate. Note that more than one rate can be prescribed to a single kinetic_species: the sum the individual rates defines the overall rate. GeochemistryKineticRate simply specifies the algebraic form for a kinetic rate: to actually use it in a calculation, you must use it in the GeochemicalModelDefinition. The rate is intrinsic_rate_constant * area_quantity * (mass of kinetic_species in grams, optionally) * (product_over_promoting_species m
^{promoting_species_index) * |1 - (Q/K)}theta|^eta * exp(activation_energy / R * (1/T0 - 1/T)) * sign(1 - (Q/K)). Please see the markdown documentation for examples - GeochemistryTimeDependentReactorUserObject that controls the time-dependent geochemistry reaction processes. Spatial dependence is not possible using this class
- GeochemistryTimeIndependentReactorUserObject that controls the time-independent geochemistry reaction processes. Spatial dependence is not possible using this class
- Porous Flow App
- AdvectiveFluxCalculatorConstantVelocityCompute K_ij (a measure of advective flux from node i to node j) and R+ and R- (which quantify amount of antidiffusion to add) in the Kuzmin-Turek FEM-TVD multidimensional scheme. Constant advective velocity is assumed
- PorousFlowAdvectiveFluxCalculatorSaturatedComputes the advective flux of fluid of given phase, assuming fully-saturated conditions. Hence this UserObject is only relevant to single-phase situations. Explicitly, the UserObject computes (density / viscosity) * (- permeability * (grad(P) - density * gravity)), using the Kuzmin-Turek FEM-TVD multidimensional stabilization scheme
- PorousFlowAdvectiveFluxCalculatorSaturatedHeatComputes the advective flux of heat energy in the given phase, assuming fully-saturated conditions. Hence this UserObject is only relevant to single-phase situations. Explicitly, the UserObject computes (density * enthalpy / viscosity) * (- permeability * (grad(P) - density * gravity)), using the Kuzmin-Turek FEM-TVD multidimensional stabilization scheme
- PorousFlowAdvectiveFluxCalculatorSaturatedMultiComponentComputes the advective flux of fluid of given phase and fluid component. Explicitly, the UserObject computes (mass_fraction * density / viscosity) * (- permeability * (grad(P) - density * gravity)), using the Kuzmin-Turek FEM-TVD multidimensional stabilization scheme
- PorousFlowAdvectiveFluxCalculatorUnsaturatedComputes the advective flux of fluid of given phase, assuming unsaturated conditions. Hence this UserObject is only relevant to single-phase situations, or multi-phase situations where each fluid component appears in one phase only. Explicitly, the UserObject computes (density * relative_permeability / viscosity) * (- permeability * (grad(P) - density * gravity)), using the Kuzmin-Turek FEM-TVD multidimensional stabilization scheme
- PorousFlowAdvectiveFluxCalculatorUnsaturatedHeatComputes the advective flux of heat energy in a given phase, assuming unsaturated conditions. Hence this UserObject is only relevant to single-phase situations, or multi-phase situations where each fluid component appears in one phase only. Explicitly, the UserObject computes (density * enthalpy * relative_permeability / viscosity) * (- permeability * (grad(P) - density * gravity)), using the Kuzmin-Turek FEM-TVD multidimensional stabilization scheme
- PorousFlowAdvectiveFluxCalculatorUnsaturatedMultiComponentComputes the advective flux of fluid of given phase and component. Hence this UserObject is relevant to multi-phase, multi-component situations. Explicitly, the UserObject computes (mass_fraction * density * relative_permeability / viscosity) * (- permeability * (grad(P) - density * gravity)), using the Kuzmin-Turek FEM-TVD multidimensional stabilization scheme
- PorousFlowBrineCO2Fluid state class for brine and CO2
- PorousFlowCapillaryPressureBCBrooks-Corey capillary pressure
- PorousFlowCapillaryPressureBWBroadbridge and White capillary pressure for negligable Kn
- PorousFlowCapillaryPressureConstConstant capillary pressure
- PorousFlowCapillaryPressureRSCRogers-Stallybrass-Clements version of effective saturation for the water phase, valid for residual saturations = 0, and viscosityOil = 2 * viscosityWater. seff_water = 1 / sqrt(1 + exp((Pc - shift) / scale)), where scale = 0.25 * scale_ratio * oil_viscosity.
- PorousFlowCapillaryPressureVGvan Genuchten capillary pressure
- PorousFlowDictatorHolds information on the PorousFlow variable names
- PorousFlowSumQuantityRecords total mass flowing into a borehole
- PorousFlowWaterNCGFluid state class for water and non-condensable gas
- PorousFlowWaterVaporFluid state class for water and vapor
- Contact App
- NodalAreaCompute the tributary area for nodes on a surface
- Navier Stokes App
- INSADObjectTrackerUser object used to track the kernels added to an INS simulation and determine what properties to calculate in INSADMaterial
- Misc App
- RigidBodyModes3D
- Level Set App
- LevelSetOlssonTerminatorTool for terminating the reinitialization of the level set equation based on the criteria defined by Olsson et. al. (2007).

## Variables

- Moose App
- AddVariableAction
- CopyNodalVarsAction
- MooseVariableRepresents standard field variables, e.g. Lagrange, Hermite, or non-constant Monomials
- MooseVariableBaseBase class for Moose variables. This should never be the terminal object type
- MooseVariableConstMonomialSpecialization for constant monomials that avoids unnecessary loops
- MooseVariableFVRealBase class for Moose variables. This should never be the terminal object type
- MooseVariableScalarMoose wrapper class around scalar variables
- VectorMooseVariableRepresents vector field variables, e.g. Vector Lagrange or Nedelec
- Phase Field App
- CHPFCRFFSplitVariables
- HHPFCRFFSplitVariables
- PFCRFFVariables
- PolycrystalVariables

### Variables/CHPFCRFFSplitVariables

- Phase Field App
- CHPFCRFFSplitVariablesAction

### Variables/HHPFCRFFSplitVariables

- Phase Field App
- HHPFCRFFSplitVariablesAction

### Variables/PFCRFFVariables

- Phase Field App
- PFCRFFVariablesAction

### Variables/PolycrystalVariables

- Phase Field App
- PolycrystalVariablesActionSet up order parameter variables for a polycrystal simulation

## VectorPostprocessors

- Moose App
- AddVectorPostprocessorAction
- CSVReaderConverts columns of a CSV file into vectors of a VectorPostprocessor.
- ConstantVectorPostprocessor
- CylindricalAverageCompute a cylindrical average of a variableas a function of radius throughout the simulation domain.
- Eigenvalues
- ElementValueSamplerSamples values of elemental variable(s).
- ElementVariablesDifferenceMax
- ElementsAlongLineOutputs the IDs of every element intersected by a user-defined line
- ElementsAlongPlaneOutputs the IDs of every element intersected by a user-defined plane
- HistogramVectorPostprocessorCompute a histogram for each column of a VectorPostprocessor
- IntersectionPointsAlongLine
- LeastSquaresFitPerforms a polynomial least squares fit on the data contained in another VectorPostprocessor
- LeastSquaresFitHistoryPerforms a polynomial least squares fit on the data contained in another VectorPostprocessor and stores the full time history of the coefficients
- LineFunctionSampler
- LineMaterialRealSamplerSamples real-valued material properties for all quadrature points in all elements that are intersected by a specified line
- LineValueSamplerSamples variable(s) along a specified line
- MaterialVectorPostprocessor
- NearestPointIntegralVariablePostprocessorCompute element variable integrals for nearest-point based subdomains
- NodalValueSamplerSamples values of nodal variable(s).
- PiecewiseFunctionTabulateTabulate the function nodes of a piecewise function, such as PiecewiseLinear or PiecewiseConstant
- PointValueSampler
- SideValueSampler
- SidesetInfoVectorPostprocessorThis VectorPostprocessor collects meta data for provided sidesets.
- SphericalAverage
- VectorMemoryUsageGet memory stats for all ranks in the simulation
- VectorOfPostprocessorsOutputs the values of an arbitrary user-specified set of postprocessors as a vector in the order specified by the user
- VolumeHistogram
- WorkBalanceComputes several metrics for workload balance per processor
- Heat Conduction App
- SurfaceRadiationVectorPostprocessorVectorPostprocessor for accessing information stored in surface radiation user object
- ViewfactorVectorPostprocessorVectorPostprocessor for accessing view factors from GrayLambertSurfaceRadiationBase UO
- Stochastic Tools App
- EvaluateSurrogateTool for sampling surrogate models.
- PolynomialChaosDataTool for extracting data from polynomial chaos user object and storing in VectorPostprocessor vectors.
- PolynomialChaosLocalSensitivityTool for calculating local sensitivity with polynomial chaos expansion.
- PolynomialChaosSobolStatisticsCompute SOBOL statistics values of a trained PolynomialChaos surrogate.
- PolynomialChaosStatisticsTool for calculating statistics with polynomial chaos expansion.
- SamplerDataTool for extracting Sampler object data and storing in VectorPostprocessor vectors.
- SobolStatisticsCompute SOBOL statistics values of a given VectorPostprocessor objects and vectors.
- StatisticsCompute statistical values of a given VectorPostprocessor objects and vectors.
- StochasticResultsStorage container for stochastic simulation results coming from a Postprocessor.
- Phase Field App
- EulerAngleUpdaterCheckProvide updated Euler angles after rigid body rotation of the grains.
- FeatureVolumeVectorPostprocessorThis object is designed to pull information from the data structures of a "FeatureFloodCount" or derived object (e.g. individual feature volumes)
- GrainForcesPostprocessorOutputs the values from GrainForcesPostprocessor
- GrainTextureVectorPostprocessorGives out info on the grain boundary properties
- Tensor Mechanics App
- InteractionIntegralComputes the interaction integral, which is used to compute various fracture mechanics parameters at a crack tip, including KI, KII, KIII, and the T stress.
- JIntegralComputes the J-Integral, a measure of the strain energy release rate at a crack tip, which can be used as a criterion for fracture growth. It can, alternatively, compute the C(t) integral
- LineMaterialRankTwoSamplerAccess a component of a RankTwoTensor
- LineMaterialRankTwoScalarSamplerCompute a scalar property of a RankTwoTensor
- MixedModeEquivalentKComputes the mixed-mode stress intensity factor given the , , and stress intensity factors

## XFEM

- XFEMApp
- XFEMActionAction to input general parameters and simulation options for use in XFEM.