# Materials System

The material system is the primary mechanism for defining spatially varying properties. The system allows properties to be defined in a single object (a `Material`

) and shared among the many other systems such as the Kernel or BoundaryCondition systems. Material objects are designed to directly couple to solution variables as well as other materials and therefore allow for capturing the true nonlinear behavior of the equations.

The material system relies on a producer/consumer relationship: `Material`

objects **produce** properties and other objects (including materials) **consume** these properties.

The properties are produced on demand, thus the computed values are always up to date. For example, a property that relies on a solution variable (e.g., thermal conductivity as function of temperature) will be computed with the current temperature during the solve iterations, so the properties are tightly coupled.

The material system supports the use of automatic differentiation for property calculations, as such there are two approaches for producing and consuming properties: with and without automatic differentiation. The following sections detail the producing and consuming properties using the two approaches. To further understand automatic differentiation, please refer to the Automatic Differentiation page for more information.

The proceeding sections briefly describe the different aspects of a `Material`

object for producing and computing the properties as well as how other objects consume the properties. For an example of how a `Material`

object is created and used please refer to Example 8 : Material Properties.

## Producing/Computing Properties

Properties must be produced by a `Material`

object by declaring the property with one of two methods:

`declareProperty<TYPE>("property_name")`

declares a property with a name "property_name" to be computed by the`Material`

object.`declareADProperty<TYPE>`

declares a property with a name "property_name" to be computed by the`Material`

object that will include automatic differentiation.

The `TYPE`

is any valid C++ type such an `int`

or `Real`

or `std::vector<Real>`

. The properties must then be computed within the `computeQpProperties`

method defined within the object.

The property name is an arbitrary name of the property, this name should be set such that it corresponds to the value be computed (e.g., "diffusivity"). The name provided here is the same name that will be used for consuming the property. More information on names is provided in Property Names section below.

For example, consider a simulation that requires a diffusivity term. In the `Material`

object header a property is declared (in the C++ since) as follows.

```
MaterialProperty<Real> & _diffusivity;
```

(examples/ex08_materials/include/materials/ExampleMaterial.h)All properties will either be a `MaterialProperty<TYPE>`

or `ADMaterialProperty<TYPE>`

and must be a non-const reference. Again, the `TYPE`

can be any C++ type. In this example, a scalar `Real`

number is being used.

In the source file the reference is initialized in the initialization list using the aforementioned declare functions as follows. This declares the property (in the material property sense) to be computed.

```
_diffusivity(declareProperty<Real>("diffusivity")),
```

(examples/ex08_materials/src/materials/ExampleMaterial.C)The final step for producing a property is to compute the value. The computation occurs within a `Material`

object `computeQpProperties`

method. As the method name suggests, the purpose of the method is to compute the values of properties at a quadrature point. This method is a virtual method that must be overridden. To do this, in the header the virtual method is declared (again in the C++ sense).

```
virtual void computeQpProperties() override;
```

(examples/ex08_materials/include/materials/ExampleMaterial.h)In the source file the method is defined. For the current example this definition computes the "diffusivity" as well another term, refer to Example 8 : Material Properties.

```
ExampleMaterial::computeQpProperties()
{
// Diffusivity is the value of the interpolated piece-wise function described by the user
_diffusivity[_qp] = _piecewise_func.sample(_q_point[_qp](2));
// Convection velocity is set equal to the gradient of the variable set by the user.
_convection_velocity[_qp] = _diffusion_gradient[_qp];
}
```

(examples/ex08_materials/src/materials/ExampleMaterial.C)The purpose of the content of this method is to assign values for the properties at a quadrature point. Recall that "_diffusivity" is a reference to a `MaterialProperty`

type. The `MaterialProperty`

type is a container that stores the values of a property for each quadrature point. Therefore, this container must be indexed by `_qp`

to compute the value for a specific quadrature point.

## Consuming Properties

Objects that require material properties consume them using one of two functions

`getMaterialProperty<TYPE>("property_name")`

retrieves a property with a name "property_name" to be consumed by the object.`getADMaterialProperty<TYPE>`

retrieves a property with a name "property_name" to be consumed by the object that will include automatic differentiation.

For on object to consume a property the same basic procedure is followed. First in the consuming objects header file a `MaterialProperty`

with the correct type (e.g., `Real`

for the diffusivity example) is declared (in the C++ sense) as follows. Notice, that the member variable is a **const** reference. The const is important. Consuming objects cannot modify a property, it only uses the property so it is marked to be constant.

```
const MaterialProperty<Real> & _diffusivity;
```

(examples/ex08_materials/include/kernels/ExampleDiffusion.h)In the source file the reference is initialized in the initialization list using the aforementioned get methods. This method initializes the `_diffusivity`

member variable to reference the desired value of the property as computed by the material object.

```
: Diffusion(parameters), _diffusivity(getMaterialProperty<Real>("diffusivity"))
```

(examples/ex08_materials/src/kernels/ExampleDiffusion.C)The name used in the get method, "diffusivity", in this case is not arbitrary. This name corresponds with the name used to declare the property in the material object.

If a material property is declared for automatic differentiation (AD) using `declareADProperty`

then it **must** be consumed with the `getADMaterialProperty`

. The same is true for non-automatic differentiation; properties declared with `declareProperty`

**must** be consumed with the `getMaterialProperty`

method.

## Property Names

When creating a Material object and declaring the properties that shall be computed, it is often desirable to allow for the property name to be changed via the input file. This may be accomplished by adding an input parameter for assigning the name. For example, considering the example above the following code snippet adds an input parameter, "diffusivity_name", that allows the input file to set the name of the diffusivity property, but by default the name remains "diffusivity".

```
params.addParam<MaterialPropertyName>("diffusivity_name", "diffusivity",
"The name of the diffusivity material property.");
```

In the material object, the declare function is simply changed to use the parameter name rather than string by itself. By default a property will be declared with the name "diffusivity".

```
_diffusivity_name(declareProperty<Real>("diffusivity_name")),
```

(examples/ex08_materials/src/materials/ExampleMaterial.C)However, if the user wants to alter this name to something else, such as "not_diffusivity" then the input parameter "diffusivity_name" is simply added to the input file block for the material.

```
[Materials]
[example]
type = ExampleMaterial
diffusivity_name = not_diffusivity
[]
[]
```

On the consumer side, the get method will now be required to use the name "not_diffusivity" to retrieve the property. Consuming objects can also use the same procedure to allow for custom property names by adding a parameter and using the parameter name in the get method in the same fashion.

## Default Material Properties

The index.html#material-name input parameter also provides the ability to set default values for scalar (`Real`

) properties. In the above example, the input file can use number or parsed function (see ParsedFunction) to define a the property value. For example, the input snippet above could set a constant value.

```
[Materials]
[example]
type = ExampleMaterial
diffusivity_name = 12345
[]
[]
```

## Stateful Material Properties

In general properties are computed on demand and not stored. However, in some cases values of material properties from a previous timestep may be required. To access properties two methods exist:

`getMaterialPropertyOld<TYPE>`

returns a reference to the property from the previous timestep.`getMaterialPropertyOlder<TYPE>`

returns a reference to the property from two timesteps before the current.

This is often referred to as a "state" variable, in MOOSE we refer to them as "stateful material properties." As stated, material properties are usually computed on demand.

When a stateful property is requested through one of the above methods this is no longer the case. When it is computed the value is also stored for every quadrature point on every element. As such, stateful properties can become memory intensive, especially if the property being stored is a vector or tensor value.

## Material Property Output

Output of `Material`

properties is enabled by setting the "outputs" parameter. The following example creates two additional variables called "mat1" and "mat2" that will show up in the output file.

```
[Materials]
[block_1]
type = OutputTestMaterial
block = 1
output_properties = 'real_property tensor_property'
outputs = exodus
variable = u
[]
[block_2]
type = OutputTestMaterial
block = 2
output_properties = 'vector_property tensor_property'
outputs = exodus
variable = u
[]
[]
[Outputs]
exodus = true
[]
```

(test/tests/materials/output/output_block.i)`Material`

properties can be of arbitrary (C++) type, but not all types can be output. The following table lists the types of properties that are available for automatic output.

Type | AuxKernel | Variable Name(s) |
---|---|---|

Real | `MaterialRealAux` | prop |

RealVectorValue | `MaterialRealVectorValueAux` | prop_1, prop_2, and prop_3 |

RealTensorValue | `MaterialRealTensorValueAux` | prop_11, prop_12, prop_13, prop_21, etc. |

## Advanced Topics

### Discrete Material Objects

A "Discrete" `Material`

is an object that may be detached from MOOSE and computed explicitly from other objects. An object inheriting from MaterialPropertyInterface may explicitly call the compute methods of a `Material`

object via the `getMaterial`

method.

The following should be considered when computing `Material`

properties explicitly.

It is possible to disable the automatic computation of a

`Material`

object by MOOSE by setting the`compute=false`

parameter.When

`compute=false`

is set the compute method (`computeQpProperties`

) is**not**called by MOOSE, instead it must be called explicitly in your application using the`computeProperties`

method that accepts a quadrature point index.When

`compute=false`

an additional method should be defined,`resetQpProperties`

, which sets the properties to a safe value (e.g., 0) for later calls to the compute method. Not doing this can lead to erroneous material properties values.

The original intent for this functionality was to enable to ability for material properties to be computed via iteration by another object, as in the following example. First, consider define a material (`RecomputeMaterial`

) that computes the value of a function and its derivative.

and

where v is known value and not a function of p. The following is the compute portion of this object.

```
void
RecomputeMaterial::computeQpProperties()
{
Real x = _p[_qp];
_f[_qp] = x * x - _constant;
_f_prime[_qp] = 2 * x;
}
```

(test/src/materials/RecomputeMaterial.C)Second, define another material (`NewtonMaterial`

) that computes the value of using Newton iterations. This material declares a material property (`_p`

) which is what is solved for by iterating on the material properties containing `f`

and `f'`

from `RecomputeMaterial`

. The `_discrete`

member is a reference to a `Material`

object retrieved with `getMaterial`

.

```
// MOOSEDOCS_START
void
NewtonMaterial::computeQpProperties()
{
_p[_qp] = 0.5; // initial guess
// Newton iteration for find p
for (unsigned int i = 0; i < _max_iterations; ++i)
{
_discrete.computePropertiesAtQp(_qp);
_p[_qp] -= _f[_qp] / _f_prime[_qp];
if (std::abs(_f[_qp]) < _tol)
break;
}
}
```

(test/src/materials/NewtonMaterial.C)To create and use a "Discrete" `Material`

use the following to guide the process.

Create a

`Material`

object by, in typical MOOSE fashion, inheriting from the`Material`

object in your own application.In your input file, set

`compute=false`

for this new object.From within another object (e.g., another Material) that inherits from

`MaterialPropertyInterface`

call the`getMaterial`

method. Note, this method returns a reference to a`Material`

object, be sure to include`&`

when calling or declaring the variable.When needed, call the

`computeProperties`

method of the`Material`

being sure to provide the current quadrature point index to the method (`_qp`

in most cases).

## Available Objects

- Moose App
- 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
- 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

## Available Actions

- Moose App
- AddMaterialAction
- 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