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 ex08_materials.md.

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;

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")),

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;

In the source file the method is defined. For the current example this definition computes the "diffusivity" as well another term, refer to ex08_materials.md.

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];
}

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 an 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;

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"))

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.

note:The declare/get calls must correspond

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")),

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 MaterialPropertyName 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.

warning:Stateful properties will increase memory use

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
[]

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.

Material sorting

Materials are sorted such that one material may consume a property produced by another material and know that the consumed property will be up-to-date, e.g. the producer material will execute before the consumer material. If a cyclic dependency is detected between two materials, then MOOSE will produce an error.

Advanced Topics

Evaluation of Material Properties on Element Faces

MOOSE creates three copies of a non-boundary restricted material for evaluations on quadrature points of elements, element faces on both the current element side and the neighboring element side. The name of the element interior material is the material name from the input file, while the name of the element face material is the material name appended with _face and the name of the neighbor face material is the material name appended with _neighbor. The element material can be identified in a material with its member variable _bnd=false. The other two copies have _bnd=true. The element face material and neighbor face material differentiate with each other by the value of another member variable _neighbor. If a material declares multiple material properties and some of them are not needed on element faces, users can switch off their declaration and evaluation based on member variable _bnd.

Interface Material Objects

MOOSE allows a material to be defined on an internal boundary of a mesh with a specific material type InterfaceMaterial. Material properties declared in interface materials are available on both sides of the boundary. Interface materials allows users to evaluate the properties on element faces based on quantities on both sides of the element face. Interface materials are often used along with InterfaceKernel.

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.

var element = document.getElementById("moose-equation-57650796-5fb7-4a3b-b9aa-8497c43bd14e");katex.render("f(p) = p^2v", element, {displayMode:true,throwOnError:false});

and

var element = document.getElementById("moose-equation-9c308344-18de-4110-9527-a3237df018bd");katex.render("f'(p) = 2pv,", element, {displayMode:true,throwOnError:false});

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;
}

Second, define another material (NewtonMaterial) that computes the value of $var element = document.getElementById("moose-equation-aed7cdd0-d713-4bfd-bd16-f25112e44487");katex.render("p: f(p)=0", element, {displayMode:false,throwOnError:false});$ 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;
  }
}

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.
ADDerivativeSumMaterialMeta-material to sum up multiple derivative materials
ADGenericConstantMaterialDeclares material properties based on names and values prescribed by input parameters.
ADGenericConstantRankTwoTensorObject for declaring a constant rank two tensor as a material property.
ADGenericConstantVectorMaterialDeclares material properties based on names and vector values prescribed by input parameters.
ADGenericFunctionMaterialMaterial object for declaring properties that are populated by evaluation of Function object.
ADGenericFunctionRankTwoTensorMaterial object for defining rank two tensor properties using functions.
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
FVADPropValPerSubdomainMaterialComputes a property value on a per-subdomain basis
FVPropValPerSubdomainMaterialComputes a property value on a per-subdomain basis
GenericConstant2DArrayA material evaluating one material property in type of RealEigenMatrix
GenericConstantArrayA material evaluating one material property in type of RealEigenVector
GenericConstantMaterialDeclares material properties based on names and values prescribed by input parameters.
GenericConstantRankTwoTensorObject for declaring a constant rank two tensor as a material property.
GenericConstantVectorMaterialDeclares material properties based on names and vector values prescribed by input parameters.
GenericFunctionMaterialMaterial object for declaring properties that are populated by evaluation of Function object.
GenericFunctionRankTwoTensorMaterial object for defining rank two tensor properties using functions.
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
Heat Conduction App
ADAnisoHeatConductionMaterialGeneral-purpose material model for anisotropic heat conduction
ADElectricalConductivityCalculates resistivity and electrical conductivity as a function of temperature, using copper for parameter defaults.
ADHeatConductionMaterialGeneral-purpose material model for heat conduction
AnisoHeatConductionMaterialGeneral-purpose material model for anisotropic heat conduction
ElectricalConductivityCalculates resistivity and electrical conductivity as a function of temperature, using copper for parameter defaults.
FunctionPathEllipsoidHeatSourceDouble ellipsoid volumetric source heat with function path.
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.
Black Bear App
ADSteelCreepDamageOhSteel scalar damage model: Material 'suddenly' loses load-carrying capacity. This can model, e.g., 316H creep failure. See Oh et al (2011).
ConcreteASREigenstrainComputes the volumetric expansion eigenstrain due to alkali-silica reaction.
ConcreteASRMicrocrackingDamageScalar damage model based on ASR extent
ConcreteDryingShrinkageComputes concrete drying shrinkage
ConcreteExpansionMicrocrackingDamageScalar damage model based on extent of internal expansion
ConcreteLogarithmicCreepModelLogarithmic viscoelastic model for cementitious materials.
ConcreteThermalMoistureMaterial parameters for thermal and moisture transport in concrete.
MazarsDamageMazars scalar damage model
NEMLStressUse a constitutive model in the NEML library to compute stress
NEMLThermalExpansionEigenstrainUse a model in the NEML library to compute thermal expansion
SteelCreepDamageOhSteel scalar damage model: Material 'suddenly' loses load-carrying capacity. This can model, e.g., 316H creep failure. See Oh et al (2011).
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.
ADCombinedScalarDamageScalar damage model which is computed as a function of multiple scalar damage models
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
ADComputeDamageStressCompute stress for damaged elastic materials in conjunction with a damage model.
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.
ADHillCreepStressUpdateThis class uses the stress update material in a generalized radial return anisotropic power law creep model. This class can be used in conjunction with other creep and plasticity materials for more complex simulations.
ADHillElastoPlasticityStressUpdateThis 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.
ADHillPlasticityStressUpdateThis 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.
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.
ADIsotropicPowerLawHardeningStressUpdateThis 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.
ADPorosityFromStrainPorosity calculation from the inelastic strain.
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
ADScalarMaterialDamageScalar damage model for which the damage is prescribed by another material
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.
ADTemperatureDependentHardeningStressUpdateComputes 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
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
AbaqusUMATStressCoupling material to use Abaqus UMAT models in MOOSE
AbruptSofteningSoftening model with an abrupt stress release upon cracking. This class is intended to be used with ComputeSmearedCrackingStress.
BiLinearMixedModeTractionMixed mode bilinear traction separation law.
CZMComputeDisplacementJumpSmallStrainCompute the total displacement jump across a czm interface in local coordinates for the Small Strain kinematic formulation
CZMComputeDisplacementJumpTotalLagrangianCompute the displacement jump increment across a czm interface in local coordinates for the Total Lagrangian kinematic formulation
CZMComputeGlobalTractionSmallStrainComputes the czm traction in global coordinates for a small strain kinematic formulation
CZMComputeGlobalTractionTotalLagrangianCompute the equilibrium traction (PK1) and its derivatives for the Total Lagrangian formulation.
CZMRealVectorCartesianComponentAccess a component of a RealVectorValue defined on a cohesive zone
CZMRealVectorScalarCompute the normal or tangent component of a vector quantity defined on a cohesive interface.
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
ComputeCrystalPlasticityThermalEigenstrain
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.
ComputeElasticityTensorConstantRotationCPCompute an elasticity tensor for crystal plasticity, formulated in the reference frame, with constant Euler angles.
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
ComputeMultipleCrystalPlasticityStressCrystal Plasticity base class: handles the Newton iteration over the stress residual and calculates the Jacobian based on constitutive laws from multiple material classes that are inherited from CrystalPlasticityStressUpdateBase
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.
CrystalPlasticityKalidindiUpdateKalidindi version of homogeneous crystal plasticity.
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
HillConstantsBuild and rotate the Hill Tensor. It can be used with other Hill plasticity and creep materials.
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.
PorosityFromStrainPorosity calculation from the inelastic strain.
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.
PureElasticTractionSeparationPure elastic traction separation law.
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
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.
ADXFEMCutSwitchingMaterialRankFourTensorSwitch the material property based on the CutSubdomainID.
ADXFEMCutSwitchingMaterialRankThreeTensorSwitch the material property based on the CutSubdomainID.
ADXFEMCutSwitchingMaterialRankTwoTensorSwitch the material property based on the CutSubdomainID.
ADXFEMCutSwitchingMaterialRealSwitch the material property based on the CutSubdomainID.
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.
XFEMCutSwitchingMaterialRankFourTensorSwitch the material property based on the CutSubdomainID.
XFEMCutSwitchingMaterialRankThreeTensorSwitch the material property based on the CutSubdomainID.
XFEMCutSwitchingMaterialRankTwoTensorSwitch the material property based on the CutSubdomainID.
XFEMCutSwitchingMaterialRealSwitch the material property based on the CutSubdomainID.
Misc App
ADDensityCreates density AD material property
DensityCreates density material property

Available Actions

Moose App
AddMaterialActionAdd a Material object to the simulation.

(moose/examples/ex08_materials/include/materials/ExampleMaterial.h)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "Material.h"
#include "LinearInterpolation.h"

class ExampleMaterial;

template <>
InputParameters validParams<ExampleMaterial>();

class ExampleMaterial : public Material
{
public:
  ExampleMaterial(const InputParameters & parameters);

protected:
  virtual void computeQpProperties() override;

private:
  /// member variable to hold the computed diffusivity coefficient
  MaterialProperty<Real> & _diffusivity;
  /// member variable to hold the computed convection velocity gradient term
  MaterialProperty<RealGradient> & _convection_velocity;

  /// A place to store the coupled variable gradient for calculating the convection velocity
  /// property.
  const VariableGradient & _diffusion_gradient;

  /// A helper object for performaing linear interpolations on tabulated data for calculating the
  /// diffusivity property.
  LinearInterpolation _piecewise_func;
};

(moose/examples/ex08_materials/src/materials/ExampleMaterial.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "ExampleMaterial.h"

registerMooseObject("ExampleApp", ExampleMaterial);

template <>
InputParameters
validParams<ExampleMaterial>()
{
  InputParameters params = validParams<Material>();

  // Allow users to specify vectors defining the points of a piecewise function formed via linear
  // interpolation.
  params.addRequiredParam<std::vector<Real>>(
      "independent_vals",
      "The vector of z-coordinate values for a piecewise function's independent variable");
  params.addRequiredParam<std::vector<Real>>(
      "dependent_vals", "The vector of diffusivity values for a piecewise function's dependent");

  // Allow the user to specify which independent variable's gradient to use for calculating the
  // convection velocity property:
  params.addCoupledVar(
      "diffusion_gradient",
      "The gradient of this variable will be used to compute a velocity vector property.");

  return params;
}

ExampleMaterial::ExampleMaterial(const InputParameters & parameters)
  : Material(parameters),
    // Declare that this material is going to provide a Real value typed
    // material property named "diffusivity" that Kernels and other objects can use.
    // This property is "bound" to the class's "_diffusivity" member.
    _diffusivity(declareProperty<Real>("diffusivity")),

    // Also declare a second "convection_velocity" RealGradient value typed property.
    _convection_velocity(declareProperty<RealGradient>("convection_velocity")),

    // Get the reference to the variable coupled into this Material.
    _diffusion_gradient(isCoupled("diffusion_gradient") ? coupledGradient("diffusion_gradient")
                                                        : _grad_zero),

    // Initialize our piecewise function helper with the user-specified interpolation points.
    _piecewise_func(getParam<std::vector<Real>>("independent_vals"),
                    getParam<std::vector<Real>>("dependent_vals"))
{
}

void
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];
}

(moose/examples/ex08_materials/include/materials/ExampleMaterial.h)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "Material.h"
#include "LinearInterpolation.h"

class ExampleMaterial;

template <>
InputParameters validParams<ExampleMaterial>();

class ExampleMaterial : public Material
{
public:
  ExampleMaterial(const InputParameters & parameters);

protected:
  virtual void computeQpProperties() override;

private:
  /// member variable to hold the computed diffusivity coefficient
  MaterialProperty<Real> & _diffusivity;
  /// member variable to hold the computed convection velocity gradient term
  MaterialProperty<RealGradient> & _convection_velocity;

  /// A place to store the coupled variable gradient for calculating the convection velocity
  /// property.
  const VariableGradient & _diffusion_gradient;

  /// A helper object for performaing linear interpolations on tabulated data for calculating the
  /// diffusivity property.
  LinearInterpolation _piecewise_func;
};

(moose/examples/ex08_materials/src/materials/ExampleMaterial.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "ExampleMaterial.h"

registerMooseObject("ExampleApp", ExampleMaterial);

template <>
InputParameters
validParams<ExampleMaterial>()
{
  InputParameters params = validParams<Material>();

  // Allow users to specify vectors defining the points of a piecewise function formed via linear
  // interpolation.
  params.addRequiredParam<std::vector<Real>>(
      "independent_vals",
      "The vector of z-coordinate values for a piecewise function's independent variable");
  params.addRequiredParam<std::vector<Real>>(
      "dependent_vals", "The vector of diffusivity values for a piecewise function's dependent");

  // Allow the user to specify which independent variable's gradient to use for calculating the
  // convection velocity property:
  params.addCoupledVar(
      "diffusion_gradient",
      "The gradient of this variable will be used to compute a velocity vector property.");

  return params;
}

ExampleMaterial::ExampleMaterial(const InputParameters & parameters)
  : Material(parameters),
    // Declare that this material is going to provide a Real value typed
    // material property named "diffusivity" that Kernels and other objects can use.
    // This property is "bound" to the class's "_diffusivity" member.
    _diffusivity(declareProperty<Real>("diffusivity")),

    // Also declare a second "convection_velocity" RealGradient value typed property.
    _convection_velocity(declareProperty<RealGradient>("convection_velocity")),

    // Get the reference to the variable coupled into this Material.
    _diffusion_gradient(isCoupled("diffusion_gradient") ? coupledGradient("diffusion_gradient")
                                                        : _grad_zero),

    // Initialize our piecewise function helper with the user-specified interpolation points.
    _piecewise_func(getParam<std::vector<Real>>("independent_vals"),
                    getParam<std::vector<Real>>("dependent_vals"))
{
}

void
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];
}

(moose/examples/ex08_materials/include/kernels/ExampleDiffusion.h)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "Diffusion.h"

// Forward Declarations
class ExampleDiffusion;

/**
 * validParams returns the parameters that this Kernel accepts / needs
 * The actual body of the function MUST be in the .C file.
 */
template <>
InputParameters validParams<ExampleDiffusion>();

class ExampleDiffusion : public Diffusion
{
public:
  ExampleDiffusion(const InputParameters & parameters);

protected:
  virtual Real computeQpResidual() override;
  virtual Real computeQpJacobian() override;

  /**
   * This MooseArray will hold the reference we need to our
   * material property from the Material class
   */
  const MaterialProperty<Real> & _diffusivity;
};

(moose/examples/ex08_materials/src/kernels/ExampleDiffusion.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "ExampleDiffusion.h"

/**
 * This function defines the valid parameters for
 * this Kernel and their default values
 */
registerMooseObject("ExampleApp", ExampleDiffusion);

template <>
InputParameters
validParams<ExampleDiffusion>()
{
  InputParameters params = validParams<Diffusion>();
  return params;
}

ExampleDiffusion::ExampleDiffusion(const InputParameters & parameters)
  : Diffusion(parameters), _diffusivity(getMaterialProperty<Real>("diffusivity"))
{
}

Real
ExampleDiffusion::computeQpResidual()
{
  // Reusing the Diffusion Kernel's residual calculation
  return _diffusivity[_qp] * Diffusion::computeQpResidual();
}

Real
ExampleDiffusion::computeQpJacobian()
{
  // Reusing the Diffusion Kernel's jacobian calculation
  return _diffusivity[_qp] * Diffusion::computeQpJacobian();
}

(moose/examples/ex08_materials/src/materials/ExampleMaterial.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "ExampleMaterial.h"

registerMooseObject("ExampleApp", ExampleMaterial);

template <>
InputParameters
validParams<ExampleMaterial>()
{
  InputParameters params = validParams<Material>();

  // Allow users to specify vectors defining the points of a piecewise function formed via linear
  // interpolation.
  params.addRequiredParam<std::vector<Real>>(
      "independent_vals",
      "The vector of z-coordinate values for a piecewise function's independent variable");
  params.addRequiredParam<std::vector<Real>>(
      "dependent_vals", "The vector of diffusivity values for a piecewise function's dependent");

  // Allow the user to specify which independent variable's gradient to use for calculating the
  // convection velocity property:
  params.addCoupledVar(
      "diffusion_gradient",
      "The gradient of this variable will be used to compute a velocity vector property.");

  return params;
}

ExampleMaterial::ExampleMaterial(const InputParameters & parameters)
  : Material(parameters),
    // Declare that this material is going to provide a Real value typed
    // material property named "diffusivity" that Kernels and other objects can use.
    // This property is "bound" to the class's "_diffusivity" member.
    _diffusivity(declareProperty<Real>("diffusivity")),

    // Also declare a second "convection_velocity" RealGradient value typed property.
    _convection_velocity(declareProperty<RealGradient>("convection_velocity")),

    // Get the reference to the variable coupled into this Material.
    _diffusion_gradient(isCoupled("diffusion_gradient") ? coupledGradient("diffusion_gradient")
                                                        : _grad_zero),

    // Initialize our piecewise function helper with the user-specified interpolation points.
    _piecewise_func(getParam<std::vector<Real>>("independent_vals"),
                    getParam<std::vector<Real>>("dependent_vals"))
{
}

void
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];
}

(moose/test/tests/materials/output/output_block.i)

[Mesh]
  type = FileMesh
  file = rectangle.e
  dim = 2
  uniform_refine = 1
[]

[Variables]
  [u]
  []
[]

[Kernels]
  [diff]
    type = CoefDiffusion
    variable = u
    coef = 0.5
  []
  [time]
    type = TimeDerivative
    variable = u
  []
[]

[BCs]
  [left]
    type = DirichletBC
    variable = u
    boundary = 1
    value = 0
  []
  [right]
    type = DirichletBC
    variable = u
    boundary = 2
    value = 2
  []
[]

[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
  []
[]

[Executioner]
  type = Transient
  num_steps = 5
  dt = 0.1
  solve_type = PJFNK
  petsc_options_iname = '-pc_type -pc_hypre_type'
  petsc_options_value = 'hypre boomeramg'
[]

[Outputs]
  exodus = true
[]

(moose/test/src/materials/RecomputeMaterial.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

// MOOSE includes
#include "RecomputeMaterial.h"

registerMooseObject("MooseTestApp", RecomputeMaterial);

InputParameters
RecomputeMaterial::validParams()
{
  InputParameters params = Material::validParams();
  params.addRequiredParam<std::string>("f_name",
                                       "The name of the property that holds the value to "
                                       "of the function for which the root is being "
                                       "computed");
  params.addRequiredParam<std::string>(
      "f_prime_name",
      "The name of the property that holds the value to of the derivative of the function");
  params.addRequiredParam<std::string>("p_name",
                                       "The name of the independant variable for the function");
  params.addParam<Real>("constant", 0, "The constant to add to the f equation.");
  return params;
}

RecomputeMaterial::RecomputeMaterial(const InputParameters & parameters)
  : Material(parameters),
    _f(declareProperty<Real>(getParam<std::string>("f_name"))),
    _f_prime(declareProperty<Real>(getParam<std::string>("f_prime_name"))),
    _p(getMaterialProperty<Real>(getParam<std::string>("p_name"))),
    _constant(getParam<Real>("constant"))
{
}

void
RecomputeMaterial::resetQpProperties()
{
  _f[_qp] = 84;
  _f_prime[_qp] = 42;
}

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

(moose/test/src/materials/NewtonMaterial.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

// MOOSE includes
#include "NewtonMaterial.h"
#include "Material.h"

registerMooseObject("MooseTestApp", NewtonMaterial);

InputParameters
NewtonMaterial::validParams()
{
  InputParameters params = Material::validParams();
  params.addRequiredParam<std::string>("f_name",
                                       "The name of the property that holds the value of "
                                       "the function for which the root is being "
                                       "computed");
  params.addRequiredParam<std::string>(
      "f_prime_name",
      "The name of the property that holds the value to of the derivative of the function");
  params.addRequiredParam<std::string>("p_name",
                                       "The name of the independent variable for the function");
  params.addParam<Real>("tol", 1e-12, "Newton solution tolerance.");
  params.addParam<unsigned int>("max_iterations", 42, "The maximum number of Newton iterations.");
  params.addRequiredParam<MaterialName>("material", "The material object to recompute.");
  return params;
}

NewtonMaterial::NewtonMaterial(const InputParameters & parameters)
  : Material(parameters),
    _tol(getParam<Real>("tol")),
    _f(getMaterialProperty<Real>(getParam<std::string>("f_name"))),
    _f_prime(getMaterialProperty<Real>(getParam<std::string>("f_prime_name"))),
    _p(declareProperty<Real>(getParam<std::string>("p_name"))),
    _max_iterations(getParam<unsigned int>("max_iterations")),
    _discrete(getMaterial("material"))
{
}

// 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;
  }
}

Producing / Computing Properties
Consuming Properties
Property Names
Default Material Properties
Stateful Material Properties
Material Property Output
Material sorting
Advanced Topics
Available Objects
Available Actions