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.

note

ExampleMaterial can call isPropertyActive(_diffusivity.id()) in its computeQpProperties to check whether this property is consumed during the run-time. This function provides a capability of skipping evaluations of certain material properties within a material when such evaluations are costly for performance optimization. MOOSE calls materials to do the evaluations when needed. This isPropertyActive routine gives code developers a finer control on the material property evaluation.

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>("property_name") 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.

Optional Properties

Objects can weakly couple to material properties that may or may not exist.

getOptionalMaterialProperty<TYPE>("property_name") retrieves an optional property with a name "property_name" to be consumed by the object.
getOptionalADMaterialProperty<TYPE>("property_name") retrieves an optional property with a name "property_name" to be consumed by the object that will include automatic differentiation.

This API returns a reference to an optional material property (OptionalMaterialProperty or OptionalADMaterialProperty). If the requested property is not provided by any material this reference will evaluate to false. It is the consuming object's responsibility to check for this before accessing the material property data. Note that the state of the returned reference is only finalized _after_ all materials have been constructed, so a validity check must _not_ be made in the constructor of a material class but either at time of first use in computeQpProperties or in initialSetup.

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. In this example, the exodus name is a special keyword used to signal to MOOSE that the material properties should be outputted to the output object created when setting Outputs/exodus=true.

[Materials<<<{"href": "index.html"}>>>]
  [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<<<{"href": "../Outputs/index.html"}>>>]
  exodus<<<{"description": "Output the results using the default settings for Exodus output."}>>> = true
[]

If multiple output objects exist in the [Outputs] block, one or more names can be provided to the "outputs" parameter. Alternatively, the reserved output name all can be used to output the material property to all output objects in the [Outputs] block, while the reserved output name none can be used to prevent the material property from being outputted to any output object. If all or none is specified in the outputs parameter, no other additional names should be specified. In the following example, data from block_1 will be outputted to both exodus1 and exodus2 output Exodus objects, while block_2 will only be outputted to the exodus2 object.

[Materials<<<{"href": "index.html"}>>>]
  [block_1]
    type = OutputTestMaterial
    block = 1
    output_properties = 'real_property'
    outputs = all
    variable = u
  []
  [block_2]
    type = OutputTestMaterial
    block = 2
    output_properties = 'vector_property'
    outputs = exodus2
    variable = u
  []
[]

[Outputs<<<{"href": "../Outputs/index.html"}>>>]
  [exodus1]
    type = Exodus<<<{"description": "Object for output data in the Exodus format", "href": "../../source/outputs/Exodus.html"}>>>
    hide<<<{"description": "A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names)."}>>> = u
  []
  [exodus2]
    type = Exodus<<<{"description": "Object for output data in the Exodus format", "href": "../../source/outputs/Exodus.html"}>>>
    hide<<<{"description": "A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names)."}>>> = u
  []
[]

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.

Functor Material Properties

Functor materials are a special kind of materials used for on-the-fly material property evaluation. Please refer to the syntax page for FunctorMaterials for more information.

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-82241149-f97a-41cc-abac-37b8baf9af7d");katex.render("f(p) = p^2v", element, {displayMode:true,throwOnError:false});

and

var element = document.getElementById("moose-equation-149ffb69-8c22-4124-b101-00bccdc77751");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-f1ce5141-dfe5-4713-b6d8-da4befaa17f8");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.

void
NewtonMaterial::computeQpProperties()
{
  _p[_qp] = 0.5; // initial guess

  // Only attempt to solve if iterations are to be taken. This is usually not required, but needed
  // here to retain the old test behavior that would not trigger a discrete material evaluation. The
  // NestedSolve class will always evaluate the residual for the initial guess (and will return a
  // success state if the initial guess was exact).
  if (getParam<unsigned int>("max_iterations") > 0)
    _nested_solve.nonlinear(
        _p[_qp],
        // Lambda function to compute residual and jacobian. The initial guess is not
        // used here as it (_p) is directly coupled in the discrete material.
        [&](const Real & /*guess*/, Real & r, Real & j)
        {
          _discrete->computePropertiesAtQp(_qp);
          r = _f[_qp];
          j = _f_prime[_qp];
        });
}

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
ADCoupledGradientMaterialCreates a gradient material equal to the gradient of the coupled variable times a scalar material property.
ADCoupledValueFunctionMaterialCompute a function value from coupled variables
ADDerivativeParsedMaterialParsed Function Material with automatic derivatives.
ADDerivativeSumMaterialMeta-material to sum up multiple derivative materials
ADFluxFromGradientMaterialComputes a flux vector material property based on the gradient of a coupled variable and a scalar diffusivity.
ADFunctorChangeFunctorMaterialAdds a functor material property that computes the change in a functor value over a time step, fixed point iteration, or nonlinear iteration.
ADGenericConstant2DArrayA material evaluating one material property in type of RealEigenMatrix
ADGenericConstantFunctorMaterialFunctorMaterial object for declaring properties that are populated by evaluation of a Functor (a constant, variable, function or functor material property) objects.
ADGenericConstantMaterialDeclares material properties based on names and values prescribed by input parameters.
ADGenericConstantRankTwoTensorObject for declaring a constant rank two tensor as a material property.
ADGenericConstantRealVectorValueObject for declaring a constant 3-vector as a material property.
ADGenericConstantStdVectorMaterialDeclares material properties based on names and vector values prescribed by input parameters.
ADGenericConstantSymmetricRankTwoTensorObject for declaring a constant symmetric rank two tensor as a material property.
ADGenericConstantVectorFunctorMaterialFunctorMaterial object for declaring vector properties that are populated by evaluation of functor (constants, functions, variables, matprops) object.
ADGenericConstantVectorMaterialDeclares material properties based on names and vector values prescribed by input parameters.
ADGenericFunctionFunctorMaterialFunctorMaterial object for declaring properties that are populated by evaluation of a Functor (a constant, variable, function or functor material property) objects.
ADGenericFunctionMaterialMaterial object for declaring properties that are populated by evaluation of Function object.
ADGenericFunctionRankTwoTensorMaterial object for defining rank two tensor properties using functions.
ADGenericFunctionVectorMaterialMaterial object for declaring vector properties that are populated by evaluation of Function objects.
ADGenericFunctorGradientMaterialFunctorMaterial object for declaring properties that are populated by evaluation of gradients of Functors (a constant, variable, function or functor material property) objects.
ADGenericFunctorMaterialFunctorMaterial object for declaring properties that are populated by evaluation of a Functor (a constant, variable, function or functor material property) objects.
ADGenericFunctorTimeDerivativeMaterialFunctorMaterial object for declaring properties that are populated by evaluation of time derivatives of Functors objects. (such as variables, constants, postprocessors). The time derivative is only returned if the 'dot' functor routine is implemented.
ADGenericVectorFunctorMaterialFunctorMaterial object for declaring vector properties that are populated by evaluation of functor (constants, functions, variables, matprops) object.
ADParsedFunctorMaterialComputes a functor material from a parsed expression of other functors.
ADParsedMaterialParsed expression Material.
ADPiecewiseByBlockFunctorMaterialComputes a property value on a per-subdomain basis
ADPiecewiseByBlockVectorFunctorMaterialComputes a property value on a per-subdomain basis
ADPiecewiseConstantByBlockMaterialComputes a property value on a per-subdomain basis
ADPiecewiseLinearInterpolationMaterialCompute a property using a piecewise linear interpolation to define its dependence on a variable
ADVectorFromComponentVariablesMaterialComputes a vector material property from coupled variables
ADVectorMagnitudeFunctorMaterialThis class takes up to three scalar-valued functors corresponding to vector components or a single vector functor and computes the Euclidean norm.
CoupledGradientMaterialCreates a gradient material equal to the gradient of the coupled variable times a scalar material property.
CoupledValueFunctionMaterialCompute a function value from coupled variables
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
FunctorADConverterConverts regular functors to AD functors and AD functors to regular functors
FunctorChangeFunctorMaterialAdds a functor material property that computes the change in a functor value over a time step, fixed point iteration, or nonlinear iteration.
FunctorSmootherCreates smoother functor(s) using various averaging techniques
GenericConstant2DArrayA material evaluating one material property in type of RealEigenMatrix
GenericConstantArrayA material evaluating one material property in type of RealEigenVector
GenericConstantFunctorMaterialFunctorMaterial object for declaring properties that are populated by evaluation of a Functor (a constant, variable, function or functor material property) objects.
GenericConstantMaterialDeclares material properties based on names and values prescribed by input parameters.
GenericConstantRankTwoTensorObject for declaring a constant rank two tensor as a material property.
GenericConstantRealVectorValueObject for declaring a constant 3-vector as a material property.
GenericConstantStdVectorMaterialDeclares material properties based on names and vector values prescribed by input parameters.
GenericConstantSymmetricRankTwoTensorObject for declaring a constant symmetric rank two tensor as a material property.
GenericConstantVectorFunctorMaterialFunctorMaterial object for declaring vector properties that are populated by evaluation of functor (constants, functions, variables, matprops) object.
GenericConstantVectorMaterialDeclares material properties based on names and vector values prescribed by input parameters.
GenericFunctionFunctorMaterialFunctorMaterial object for declaring properties that are populated by evaluation of a Functor (a constant, variable, function or functor material property) objects.
GenericFunctionMaterialMaterial object for declaring properties that are populated by evaluation of Function object.
GenericFunctionRankTwoTensorMaterial object for defining rank two tensor properties using functions.
GenericFunctionVectorMaterialMaterial object for declaring vector properties that are populated by evaluation of Function objects.
GenericFunctorGradientMaterialFunctorMaterial object for declaring properties that are populated by evaluation of gradients of Functors (a constant, variable, function or functor material property) objects.
GenericFunctorMaterialFunctorMaterial object for declaring properties that are populated by evaluation of a Functor (a constant, variable, function or functor material property) objects.
GenericFunctorTimeDerivativeMaterialFunctorMaterial object for declaring properties that are populated by evaluation of time derivatives of Functors objects. (such as variables, constants, postprocessors). The time derivative is only returned if the 'dot' functor routine is implemented.
GenericVectorFunctorMaterialFunctorMaterial object for declaring vector properties that are populated by evaluation of functor (constants, functions, variables, matprops) object.
InterpolatedStatefulMaterialRankFourTensorAccess old state from projected data.
InterpolatedStatefulMaterialRankTwoTensorAccess old state from projected data.
InterpolatedStatefulMaterialRealAccess old state from projected data.
InterpolatedStatefulMaterialRealVectorValueAccess old state from projected data.
MaterialADConverterConverts regular material properties to AD properties and vice versa
MaterialConverterConverts regular material properties to AD properties and vice versa
MaterialFunctorConverterConverts functor to non-AD and AD regular material properties
NEML2ToMOOSERankFourTensorMaterialPropertyProvide an output (or its derivative) from a NEML2 model as a MOOSE material property of type RankFourTensorTempl<double>.
NEML2ToMOOSERankTwoTensorMaterialPropertyProvide an output (or its derivative) from a NEML2 model as a MOOSE material property of type RankTwoTensorTempl<double>.
NEML2ToMOOSERealMaterialPropertyProvide an output (or its derivative) from a NEML2 model as a MOOSE material property of type double.
NEML2ToMOOSERealVectorValueMaterialPropertyProvide an output (or its derivative) from a NEML2 model as a MOOSE material property of type libMesh::VectorValue<double>.
NEML2ToMOOSESymmetricRankFourTensorMaterialPropertyProvide an output (or its derivative) from a NEML2 model as a MOOSE material property of type SymmetricRankFourTensorTempl<double>.
NEML2ToMOOSESymmetricRankTwoTensorMaterialPropertyProvide an output (or its derivative) from a NEML2 model as a MOOSE material property of type SymmetricRankTwoTensorTempl<double>.
ParsedFunctorMaterialComputes a functor material from a parsed expression of other functors.
ParsedMaterialParsed expression Material.
PiecewiseByBlockFunctorMaterialComputes a property value on a per-subdomain basis
PiecewiseByBlockVectorFunctorMaterialComputes a property value on a per-subdomain basis
PiecewiseConstantByBlockMaterialComputes a property value on a per-subdomain basis
PiecewiseLinearInterpolationMaterialCompute a property using a piecewise linear interpolation to define its dependence on a variable
RankFourTensorMaterialADConverterConverts regular material properties to AD properties and vice versa
RankFourTensorMaterialConverterConverts regular material properties to AD properties and vice versa
RankTwoTensorFromComponentPropertiesAssembles a RankTwoTensor from scalar material properties or constants
RankTwoTensorMaterialADConverterConverts regular material properties to AD properties and vice versa
RankTwoTensorMaterialConverterConverts regular material properties to AD properties and vice versa
VectorFromComponentVariablesMaterialComputes a vector material property from coupled variables
VectorFunctorADConverterConverts regular functors to AD functors and AD functors to regular functors
VectorMagnitudeFunctorMaterialThis class takes up to three scalar-valued functors corresponding to vector components or a single vector functor and computes the Euclidean norm.
VectorMaterialFunctorConverterConverts functor to non-AD and AD regular material properties
Misc App
ADArrheniusMaterialPropertyArbitrary material property of the sum of an arbitary number ( $var element = document.getElementById("moose-equation-013eda63-11ad-4d09-88b2-5fd9c3a3c56d");katex.render("i", element, {displayMode:false,throwOnError:false});$ ) of Arrhenius functions $var element = document.getElementById("moose-equation-7d29ae49-5349-4a70-a81c-e1687dd167b7");katex.render("A_i * \\exp{-Q_i / (RT)}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-c6c20247-ee42-4b1e-b40a-1d9531304e8c");katex.render("A_i", element, {displayMode:false,throwOnError:false});$ is the frequency factor, $var element = document.getElementById("moose-equation-8dc17413-e97f-4d3d-9991-2b7ff2a3e9a4");katex.render("Q_i", element, {displayMode:false,throwOnError:false});$ is the activation energy, and $var element = document.getElementById("moose-equation-657579d6-9de6-485e-ad80-2e46d691f27c");katex.render("R", element, {displayMode:false,throwOnError:false});$ is the gas constant.
ADDensityCreates density material property. This class is deprecated, and its functionalityis replaced by StrainAdjustedDensity for cases when the density should be adjustedto account for material deformation. If it is not desired to adjust the density fordeformation, a variety of general-purpose Materials, such as GenericConstantMaterialor ParsedMaterial can be used to define the density. A StrainAdjustedDensity can also be used with '0 0 0' for the displacements.
ArrheniusMaterialPropertyArbitrary material property of the sum of an arbitary number ( $var element = document.getElementById("moose-equation-d703d1a2-f0ea-4943-9e49-fb189b503800");katex.render("i", element, {displayMode:false,throwOnError:false});$ ) of Arrhenius functions $var element = document.getElementById("moose-equation-d2314c0e-5c96-4754-9b34-112b93689251");katex.render("A_i * \\exp{-Q_i / (RT)}", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-5eb61936-da8c-4bb6-a0d5-3320d3c3a504");katex.render("A_i", element, {displayMode:false,throwOnError:false});$ is the frequency factor, $var element = document.getElementById("moose-equation-b70bdf43-712c-4de2-86ee-b64107ac8581");katex.render("Q_i", element, {displayMode:false,throwOnError:false});$ is the activation energy, and $var element = document.getElementById("moose-equation-efdf67db-8f7e-41b3-9f12-31294e4e6a6b");katex.render("R", element, {displayMode:false,throwOnError:false});$ is the gas constant.
DensityCreates density material property. This class is deprecated, and its functionalityis replaced by StrainAdjustedDensity for cases when the density should be adjustedto account for material deformation. If it is not desired to adjust the density fordeformation, a variety of general-purpose Materials, such as GenericConstantMaterialor ParsedMaterial can be used to define the density. A StrainAdjustedDensity can also be used with '0 0 0' for the displacements.
Fluid Properties App
ADSaturationPressureMaterialComputes saturation pressure at some temperature.
ADSaturationTemperatureMaterialComputes saturation temperature at some pressure
ADSurfaceTensionMaterialComputes surface tension at some temperature
FluidPropertiesMaterialComputes fluid properties using (specific internal energy, specific volume) formulation
FluidPropertiesMaterialPTFluid properties using the (pressure, temperature) formulation
FluidPropertiesMaterialVEComputes fluid properties using (specific internal energy, specific volume) formulation
SaturationPressureMaterialComputes saturation pressure at some temperature.
SodiumPropertiesMaterialMaterial properties for liquid sodium sampled from SodiumProperties.
Navier Stokes App
ADDittusBoelterFunctorMaterialComputes wall heat transfer coefficient using Dittus-Boelter equation
ADFunctorEffectiveDynamicViscosityComputes the effective dynamic viscosity mu_eff = mu + mu_t / factor
AirAir.
ConservedVarValuesMaterialProvides access to variables for a conserved variable set of density, total fluid energy, and momentum
DittusBoelterFunctorMaterialComputes wall heat transfer coefficient using Dittus-Boelter equation
ExponentialFrictionFunctorMaterialComputes a Reynolds number-exponential friction factor.
ExponentialFrictionMaterialComputes a Reynolds number-exponential friction factor.
FunctorEffectiveDynamicViscosityComputes the effective dynamic viscosity mu_eff = mu + mu_t / factor
FunctorErgunDragCoefficientsMaterial providing linear and quadratic drag coefficients based on the correlation developed by Ergun.
FunctorKappaFluidZero-thermal dispersion conductivity
GeneralFluidPropsComputes fluid properties using a (P, T) formulation
GeneralFunctorFluidPropsCreates functor fluid properties using a (P, T) formulation
GenericPorousMediumMaterialComputes generic material properties related to simulation of fluid flow in a porous medium
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.
INSFEMaterialComputes generic material properties related to simulation of fluid flow
INSFVEnthalpyFunctorMaterialThis is the material class used to compute enthalpy for the incompressible/weakly-compressible finite-volume implementation of the Navier-Stokes equations.
INSFVEnthalpyMaterialThis is the material class used to compute enthalpy for the incompressible/weakly-compressible finite-volume implementation of the Navier-Stokes equations.
INSFVMushyPorousFrictionFunctorMaterialComputes the mushy zone porous resistance for solidification/melting problems.
INSFVMushyPorousFrictionMaterialComputes the mushy zone porous resistance for solidification/melting problems.
INSFVkEpsilonViscosityFunctorMaterialComputes the turbulent dynamic viscosity given k and epsilon.
INSFVkEpsilonViscosityMaterialComputes the turbulent dynamic viscosity given k and epsilon.
LinearFVEnthalpyFunctorMaterialCreates functors for conversions between specific enthalpy and temperature
LinearFrictionFactorFunctorMaterialMaterial class used to compute a friction factor of the form A * f(r, t) + B * g(r, t) * |v_I| with A, B vector constants, f(r, t) and g(r, t) functors of space and time, and |v_I| the interstitial speed
MDFluidMaterialComputes generic material properties related to simulation of fluid flow
MixingLengthTurbulentViscosityFunctorMaterialComputes the material property corresponding to the total viscositycomprising the mixing length model turbulent total_viscosityand the molecular viscosity.
MixingLengthTurbulentViscosityMaterialComputes the material property corresponding to the total viscositycomprising the mixing length model turbulent total_viscosityand the molecular viscosity.
NSFVDispersePhaseDragFunctorMaterialComputes drag coefficient for dispersed phase.
NSFVFrictionFlowDiodeFunctorMaterialIncreases the anistropic friction coefficients, linear or quadratic, by K_i * |direction_i| when the diode is turned on with a boolean
NSFVFrictionFlowDiodeMaterialIncreases the anistropic friction coefficients, linear or quadratic, by K_i * |direction_i| when the diode is turned on with a boolean
NSFVMixtureFunctorMaterialCompute the arithmetic mean of material properties using a phase fraction.
NSFVMixtureMaterialCompute the arithmetic mean of material properties using a phase fraction.
NSFVPumpFunctorMaterialComputes the effective pump body force.
NSFVPumpMaterialComputes the effective pump body force.
NonADGeneralFunctorFluidPropsCreates functor fluid properties using a (P, T) formulation
PINSFEMaterialComputes generic material properties related to simulation of fluid flow in a porous medium
PINSFVSpeedFunctorMaterialThis is the material class used to compute the interstitial velocity norm for the incompressible and weakly compressible primitive superficial finite-volume implementation of porous media equations.
PorousConservedVarMaterialProvides access to variables for a conserved variable set of density, total fluid energy, and momentum
PorousMixedVarMaterialProvides access to variables for a primitive variable set of pressure, temperature, and superficial velocity
PorousPrimitiveVarMaterialProvides access to variables for a primitive variable set of pressure, temperature, and superficial velocity
ReynoldsNumberFunctorMaterialComputes a Reynolds number.
RhoFromPTFunctorMaterialComputes the density from coupled pressure and temperature functors (variables, functions, functor material properties
SoundspeedMatComputes the speed of sound
ThermalDiffusivityFunctorMaterialComputes the thermal diffusivity given the thermal conductivity, specific heat capacity, and fluid density.
WCNSFV2PSlipVelocityFunctorMaterialComputes the slip velocity for two-phase mixture model.
WCNSLinearFVMixtureFunctorMaterialCompute the arithmetic mean of material properties using a phase fraction.
Rdg App
AEFVMaterialA material kernel for the advection equation using a cell-centered finite volume method.
Heat Transfer App
ADAnisoHeatConductionMaterialGeneral-purpose material model for anisotropic heat conduction
ADChurchillChuHTCFunctorMaterialComputes a heat transfer coefficient using the Churchill-Chu correlation for natural convection.
ADConvectionHeatFluxFunctorMaterialComputes a convection heat flux from a solid surface to a fluid.
ADCylindricalGapHeatFluxFunctorMaterialComputes cylindrical gap heat flux due to conduction and radiation.
ADElectricalConductivityCalculates resistivity and electrical conductivity as a function of temperature, using copper for parameter defaults.
ADFinEfficiencyFunctorMaterialComputes fin efficiency.
ADFinEnhancementFactorFunctorMaterialComputes a heat transfer enhancement factor for fins.
ADHeatConductionMaterialGeneral-purpose material model for heat conduction
ADRadiativeP1DiffusionCoefficientMaterialComputes the P1 diffusion coefficient from the opacity and effective scattering cross section.
AnisoHeatConductionMaterialGeneral-purpose material model for anisotropic heat conduction
ChurchillChuHTCFunctorMaterialComputes a heat transfer coefficient using the Churchill-Chu correlation for natural convection.
ConvectionHeatFluxFunctorMaterialComputes a convection heat flux from a solid surface to a fluid.
CylindricalGapHeatFluxFunctorMaterialComputes cylindrical gap heat flux due to conduction and radiation.
ElectricalConductivityCalculates resistivity and electrical conductivity as a function of temperature, using copper for parameter defaults.
ElectromagneticHeatingMaterialMaterial class used to provide the electric field as a material property and computes the residual contributions for electromagnetic/electrostatic heating objects.
FinEfficiencyFunctorMaterialComputes fin efficiency.
FinEnhancementFactorFunctorMaterialComputes a heat transfer enhancement factor for fins.
FunctionPathEllipsoidHeatSourceDouble ellipsoid volumetric source heat with function path.
GapConductanceMaterial to compute an effective gap conductance based on the thermal conductivity of the gap and diffusive approximation to the radiative heat transfer.
GapConductanceConstantMaterial to compute a constant, prescribed gap conductance
HeatConductionMaterialGeneral-purpose material model for heat conduction
RadiativeP1DiffusionCoefficientMaterialComputes the P1 diffusion coefficient from the opacity and effective scattering cross section.
SemiconductorLinearConductivityCalculates electrical conductivity of a semiconductor from temperature
SideSetHeatTransferMaterialThis material constructs the necessary coefficients and properties for SideSetHeatTransferKernel.
ThermalComplianceComputes cost sensitivity needed for multimaterial SIMP method.
ThermalSensitivityComputes cost sensitivity needed for multimaterial SIMP method.

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://mooseframework.inl.gov
//
// 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 : public Material
{
public:
  ExampleMaterial(const InputParameters & parameters);

  static InputParameters validParams();

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://mooseframework.inl.gov
//
// 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);

InputParameters
ExampleMaterial::validParams()
{
  InputParameters params = Material::validParams();

  // 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://mooseframework.inl.gov
//
// 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 : public Material
{
public:
  ExampleMaterial(const InputParameters & parameters);

  static InputParameters validParams();

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://mooseframework.inl.gov
//
// 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);

InputParameters
ExampleMaterial::validParams()
{
  InputParameters params = Material::validParams();

  // 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://mooseframework.inl.gov
//
// 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"

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

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

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://mooseframework.inl.gov
//
// 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);

InputParameters
ExampleDiffusion::validParams()
{
  InputParameters params = Diffusion::validParams();
  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://mooseframework.inl.gov
//
// 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);

InputParameters
ExampleMaterial::validParams()
{
  InputParameters params = Material::validParams();

  // 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/tests/materials/output/output_multiple_files.i)

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

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

[Materials]
  [block_1]
    type = OutputTestMaterial
    block = 1
    output_properties = 'real_property'
    outputs = all
    variable = u
  []
  [block_2]
    type = OutputTestMaterial
    block = 2
    output_properties = 'vector_property'
    outputs = exodus2
    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]
  [exodus1]
    type = Exodus
    hide = u
  []
  [exodus2]
    type = Exodus
    hide = u
  []
[]

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

// This file is part of the MOOSE framework
// https://mooseframework.inl.gov
//
// 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 independent variable for the function");
  params.addParam<Real>("constant", 0, "The constant to add to the f equation.");
  params.set<bool>("compute") = false;
  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://mooseframework.inl.gov
//
// 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 += NestedSolve::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.set<Real>("relative_tolerance") = 1e-15;
  params.addRequiredParam<std::string>("p_name",
                                       "The name of the independent variable for the function");
  params.addRequiredParam<MaterialName>("material", "The material object to recompute.");
  return params;
}

NewtonMaterial::NewtonMaterial(const InputParameters & parameters)
  : Material(parameters),
    _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"))),
    _nested_solve(NestedSolve(parameters))
{
}

void
NewtonMaterial::initialSetup()
{
  _discrete = &getMaterial("material");
}

// MOOSEDOCS_START
void
NewtonMaterial::computeQpProperties()
{
  _p[_qp] = 0.5; // initial guess

  // Only attempt to solve if iterations are to be taken. This is usually not required, but needed
  // here to retain the old test behavior that would not trigger a discrete material evaluation. The
  // NestedSolve class will always evaluate the residual for the initial guess (and will return a
  // success state if the initial guess was exact).
  if (getParam<unsigned int>("max_iterations") > 0)
    _nested_solve.nonlinear(
        _p[_qp],
        // Lambda function to compute residual and jacobian. The initial guess is not
        // used here as it (_p) is directly coupled in the discrete material.
        [&](const Real & /*guess*/, Real & r, Real & j)
        {
          _discrete->computePropertiesAtQp(_qp);
          r = _f[_qp];
          j = _f_prime[_qp];
        });
}

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