NEML2 syntax

The [NEML2] block in the MOOSE input file is the entry point for defining NEML2 material model(s). All parameters are listed at the bottom of the page.

note

This page is user-facing, i.e., the Input file syntax section explains how to write the MOOSE input file in order to connect MOOSE to NEML2 for material modeling.

note

For developers, please refer to the NEML2Action and NEML2ActionCommon pages regarding what objects are constructed by the underlying Action.

Input File Syntax

The basic structure of the [NEML2] block is shown below.

[NEML2<<<{"href": "index.html"}>>>]
  input<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Path to the NEML2 input file containing the NEML2 model(s).)"}>>> = 'models/${neml2_input}.i'
  [all]
    model<<<{"description": "Name of the NEML2 model, i.e., the string inside the brackets [] in the NEML2 input file that corresponds to the model you want to use."}>>> = 'model'
    verbose<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Whether to print additional information about the NEML2 model at the beginning of the simulation)"}>>> = true
    device<<<{"description": "Device on which to evaluate the NEML2 model. The string supplied must follow the following schema: (cpu|cuda)[:<device-index>] where cpu or cuda specifies the device type, and :<device-index> optionally specifies a device index. For example, device='cpu' sets the target compute device to be CPU, and device='cuda:1' sets the target compute device to be CUDA with device ID 1."}>>> = 'cpu'

    moose_input_types<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 input variable)"}>>> = 'MATERIAL'
    moose_inputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as inputs of the material model.)"}>>> = 'neml2_strain'
    neml2_inputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 input variables corresponding to each MOOSE data.)"}>>> = 'forces/E'

    moose_output_types<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 output variables)"}>>> = 'MATERIAL'
    moose_outputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the output of the material model.)"}>>> = 'neml2_stress'
    neml2_outputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 output variables corresponding to each MOOSE data.)"}>>> = 'state/S'

    moose_derivative_types<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 variable derivatives)"}>>> = 'MATERIAL'
    moose_derivatives<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model.)"}>>> = 'neml2_jacobian'
    neml2_derivatives<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)"}>>> = 'state/S forces/E'
  []
[]

The [NEML2] block has two parts:

A common area directly underneath the [NEML2] block.
Nested sub-blocks.

In the above example, there is only one sub-block named [all]. However, there can be as many sub-blocks as appropriate. Most of the parameters specified in the common area are also applied to each sub-block. In the case where a parameter is defined both in the common area and under a sub-block, the parameter defined under the sub-block overrides.

note

The only exception to the above rule is the "input" parameter which can only be specified in the common area.

Sub-blocks are used to specify multiple NEML2 material models used in the same simulation. The following example demonstrates the use of sub-blocks to specify two NEML2 material models on two different subdomains.

[NEML2<<<{"href": "index.html"}>>>]
  input<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Path to the NEML2 input file containing the NEML2 model(s).)"}>>> = 'models/${neml2_input}.i'
  verbose<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Whether to print additional information about the NEML2 model at the beginning of the simulation)"}>>> = true
  [A]
    model<<<{"description": "Name of the NEML2 model, i.e., the string inside the brackets [] in the NEML2 input file that corresponds to the model you want to use."}>>> = 'model1'
    block<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of blocks (subdomains) where the material model is defined)"}>>> = 'A'
    device<<<{"description": "Device on which to evaluate the NEML2 model. The string supplied must follow the following schema: (cpu|cuda)[:<device-index>] where cpu or cuda specifies the device type, and :<device-index> optionally specifies a device index. For example, device='cpu' sets the target compute device to be CPU, and device='cuda:1' sets the target compute device to be CUDA with device ID 1."}>>> = 'cpu'

    moose_input_types<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 input variable)"}>>> = 'MATERIAL'
    moose_inputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as inputs of the material model.)"}>>> = 'neml2_strain'
    neml2_inputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 input variables corresponding to each MOOSE data.)"}>>> = 'forces/E'

    moose_output_types<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 output variables)"}>>> = 'MATERIAL'
    moose_outputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the output of the material model.)"}>>> = 'neml2_stress'
    neml2_outputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 output variables corresponding to each MOOSE data.)"}>>> = 'state/S'

    moose_derivative_types<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 variable derivatives)"}>>> = 'MATERIAL'
    moose_derivatives<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model.)"}>>> = 'neml2_jacobian'
    neml2_derivatives<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)"}>>> = 'state/S forces/E'
  []
  [B]
    model<<<{"description": "Name of the NEML2 model, i.e., the string inside the brackets [] in the NEML2 input file that corresponds to the model you want to use."}>>> = 'model2'
    block<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of blocks (subdomains) where the material model is defined)"}>>> = 'B'
    device<<<{"description": "Device on which to evaluate the NEML2 model. The string supplied must follow the following schema: (cpu|cuda)[:<device-index>] where cpu or cuda specifies the device type, and :<device-index> optionally specifies a device index. For example, device='cpu' sets the target compute device to be CPU, and device='cuda:1' sets the target compute device to be CUDA with device ID 1."}>>> = 'cpu'

    moose_input_types<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 input variable)"}>>> = 'MATERIAL'
    moose_inputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as inputs of the material model.)"}>>> = 'neml2_strain'
    neml2_inputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 input variables corresponding to each MOOSE data.)"}>>> = 'forces/E'

    moose_output_types<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 output variables)"}>>> = 'MATERIAL'
    moose_outputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the output of the material model.)"}>>> = 'neml2_stress'
    neml2_outputs<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 output variables corresponding to each MOOSE data.)"}>>> = 'state/S'

    moose_derivative_types<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 variable derivatives)"}>>> = 'MATERIAL'
    moose_derivatives<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model.)"}>>> = 'neml2_jacobian'
    neml2_derivatives<<<{"description": "The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)"}>>> = 'state/S forces/E'
  []
[]

In each sub-block, there are a total of 6 groups of parameters that can be specified:

Configuration of the model
Transfer of input variables
Transfer of model parameters
Transfer of output variables
Transfer of derivatives (of output variables w.r.t. input variables)
Transfer of derivatives (of output variables w.r.t. model parameters)

The configuration of model is controlled by parameters such as "model", "verbose", "device", etc., each of which is explained in the syntax documentation at the bottom of the page.

The other 5 groups of parameters are all related to data transfer between MOOSE and NEML2. The 2nd and the 3rd groups of parameters correspond to the transfer of data from MOOSE to NEML2. The 4th, 5th and the 6th groups of parameters correspond to the transfer of data from NEML2 to MOOSE.

Each group has three parameters in the following form:

moose_<*>_types: List of types denoting the type of the MOOSE data structure.
moose_<*>s: Names of quantities to be transferred from/to MOOSE.
neml2_<*>s: Names of quantities to be transferred from/to NEML2.

where <*> are placeholders representing the data being transferred, e.g., input, parameter, output, derivative, parameter_derivative. Using input as an example, the three parameters are

moose_input_types
moose_inputs
neml2_inputs

The length of the three lists must be the same. "moose_input_types" is a list of enums denoting the type of the MOOSE data structure used to hold the input variables. The following enums are supported

MATERIAL: The input variables are retrieved from material properties stored at each quadrature point.
VARIABLE: The input variables are retrieved from (auxiliary) variables interpolated at each quadrature point.
POSTPROCESSOR: The input variables are retrieved from a postprocessor and broadcast to all quadrature points.

Currently, for the groups of parameters that control the data transfer from NEML2 to MOOSE, only the MATERIAL is supported, i.e., NEML2 output variables and derivatives can only be transferred to MOOSE material properties.

It is worth noting that for "neml2_derivatives" and "neml2_parameter_derivatives", a pair of names must be specified for each entry. The first name in the pair denotes the quantity (NEML2 output variable) to take derivative of, and the second name in the pair denotes the quantity (NEML2 input variable or model parameter) to take derivative with respect to.

Inspect NEML2 information

The MOOSE solid-mechanics module also provides a command-line option to inspect the NEML2 material model without running the entire simulation. This is achieved using the --parse-neml2-only command-line argument, i.e.


solid_mechanics-opt -i input.i --parse-neml2-only

Below is an example output


*** NEML2 MATERIAL MODEL SUMMARY BEGIN ***
Input file location:       modules/solid_mechanics/test/tests/neml2/viscoplasticity_chaboche.i:34
Input file path:           NEML2/all
Material model Name:       model
Evaluation device:         cpu
Automatic differentiation: Disabled
Material model structure:
------------------------------------------------------------------
|   Type    |         Name          | Tensor type | Storage size |
------------------------------------------------------------------
| input     | forces/E              | SR2         |            6 |
| input     | forces/t              | Scalar      |            1 |
| input     | old_forces/E          | SR2         |            6 |
| input     | old_forces/t          | Scalar      |            1 |
| input     | old_state/S           | SR2         |            6 |
| input     | old_state/internal/X1 | SR2         |            6 |
| input     | old_state/internal/X2 | SR2         |            6 |
| input     | old_state/internal/ep | Scalar      |            1 |
| input     | state/S               | SR2         |            6 |
| input     | state/internal/X1     | SR2         |            6 |
| input     | state/internal/X2     | SR2         |            6 |
| input     | state/internal/ep     | Scalar      |            1 |
| output    | state/S               | SR2         |            6 |
| output    | state/internal/X1     | SR2         |            6 |
| output    | state/internal/X2     | SR2         |            6 |
| output    | state/internal/ep     | Scalar      |            1 |
| parameter | X1rate.A              | Scalar      |            1 |
| parameter | X1rate.C              | Scalar      |            1 |
| parameter | X1rate.a              | Scalar      |            1 |
| parameter | X1rate.g              | Scalar      |            1 |
| parameter | X2rate.A              | Scalar      |            1 |
| parameter | X2rate.C              | Scalar      |            1 |
| parameter | X2rate.a              | Scalar      |            1 |
| parameter | X2rate.g              | Scalar      |            1 |
| parameter | elasticity.E          | Scalar      |            1 |
| parameter | elasticity.nu         | Scalar      |            1 |
| parameter | flow_rate.eta         | Scalar      |            1 |
| parameter | flow_rate.n           | Scalar      |            1 |
| parameter | isoharden.R           | Scalar      |            1 |
| parameter | isoharden.d           | Scalar      |            1 |
| parameter | yield.sy              | Scalar      |            1 |
| buffer    | Eerate.c              | Tensor      |            2 |
| buffer    | kinharden.c           | Tensor      |            1 |
| buffer    | overstress.c          | Tensor      |            2 |
------------------------------------------------------------------
*** NEML2 MATERIAL MODEL SUMMARY END ***

Common parameters

inputThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Path to the NEML2 input file containing the NEML2 model(s).)
C++ Type:DataFileName
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Path to the NEML2 input file containing the NEML2 model(s).)

Required Parameters

cli_argsAdditional command line arguments to use when parsing the NEML2 input file.
C++ Type:std::vector<std::string>
Controllable:No
Description:Additional command line arguments to use when parsing the NEML2 input file.
devicecpuDevice on which to evaluate the NEML2 model. The string supplied must follow the following schema: (cpu|cuda)[:] where cpu or cuda specifies the device type, and : optionally specifies a device index. For example, device='cpu' sets the target compute device to be CPU, and device='cuda:1' sets the target compute device to be CUDA with device ID 1.
Default:cpu
C++ Type:std::string
Controllable:No
Description:Device on which to evaluate the NEML2 model. The string supplied must follow the following schema: (cpu|cuda)[:] where cpu or cuda specifies the device type, and : optionally specifies a device index. For example, device='cpu' sets the target compute device to be CPU, and device='cuda:1' sets the target compute device to be CUDA with device ID 1.
export_output_targetsThe export targets corresponding to each MOOSE material property specified in export_outputs.
C++ Type:std::vector<std::vector<OutputName>>
Controllable:No
Description:The export targets corresponding to each MOOSE material property specified in export_outputs.
export_outputsList of MOOSE material properties to export which correspond to NEML2 output variables or output derivatives. Each material property's export targets can be specified by export_output_targets. The default export target is 'none'.
C++ Type:std::vector<MaterialPropertyName>
Unit:(no unit assumed)
Controllable:No
Description:List of MOOSE material properties to export which correspond to NEML2 output variables or output derivatives. Each material property's export targets can be specified by export_output_targets. The default export target is 'none'.
initialize_output_valuesList of MOOSE material properties whose initial values (evaluated at the 0th time step) will be used to initialize stateful properties. See the description of initialize_outputs for more details.
C++ Type:std::vector<MaterialPropertyName>
Unit:(no unit assumed)
Controllable:No
Description:List of MOOSE material properties whose initial values (evaluated at the 0th time step) will be used to initialize stateful properties. See the description of initialize_outputs for more details.
initialize_outputsList of MOOSE material properties to be initialized. Each these properties must correspond to a stateful NEML2 variable (which appears on both the input old state sub-axis and the output state sub-axis). These MOOSE material properties will be initialized with the values of properties specified in the initialize_output_values list.
C++ Type:std::vector<MaterialPropertyName>
Unit:(no unit assumed)
Controllable:No
Description:List of MOOSE material properties to be initialized. Each these properties must correspond to a stateful NEML2 variable (which appears on both the input old state sub-axis and the output state sub-axis). These MOOSE material properties will be initialized with the values of properties specified in the initialize_output_values list.
modelName of the NEML2 model, i.e., the string inside the brackets [] in the NEML2 input file that corresponds to the model you want to use.
C++ Type:std::string
Controllable:No
Description:Name of the NEML2 model, i.e., the string inside the brackets [] in the NEML2 input file that corresponds to the model you want to use.
moose_derivative_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 variable derivatives)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 variable derivatives)
moose_derivativesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model.)
moose_input_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 input variable)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 input variable)
moose_inputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as inputs of the material model.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as inputs of the material model.)
moose_output_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 output variables)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 output variables)
moose_outputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the output of the material model.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the output of the material model.)
moose_parameter_derivative_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 parameter derivatives)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 parameter derivatives)
moose_parameter_derivativesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model w.r.t. model parameters.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model w.r.t. model parameters.)
moose_parameter_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 model parameter)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 model parameter)
moose_parametersThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as parameters of the material model.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as parameters of the material model.)
neml2_derivativesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)
C++ Type:std::vector<std::vector<std::string>>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)
neml2_inputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 input variables corresponding to each MOOSE data.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 input variables corresponding to each MOOSE data.)
neml2_outputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 output variables corresponding to each MOOSE data.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 output variables corresponding to each MOOSE data.)
neml2_parameter_derivativesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)
C++ Type:std::vector<std::vector<std::string>>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)
neml2_parametersThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 model parameters corresponding to each MOOSE data.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 model parameters corresponding to each MOOSE data.)
skip_inputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 variables to skip error checking when setting up the model input. If an input variable is skipped, its value will stay zero. If a required input variable is not skipped, an error will be raised.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 variables to skip error checking when setting up the model input. If an input variable is skipped, its value will stay zero. If a required input variable is not skipped, an error will be raised.)
skip_variablesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 variables to skip when setting up the model input. If an input variable is skipped, its value will stay zero. If a required input variable is not skipped, an error will be raised.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 variables to skip when setting up the model input. If an input variable is skipped, its value will stay zero. If a required input variable is not skipped, an error will be raised.)
verboseTrueThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Whether to print additional information about the NEML2 model at the beginning of the simulation)
Default:True
C++ Type:bool
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Whether to print additional information about the NEML2 model at the beginning of the simulation)

Optional Parameters

allow_duplicate_execution_on_initialFalseIn the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
Default:False
C++ Type:bool
Controllable:No
Description:In the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
execute_onTIMESTEP_ENDThe list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
Default:TIMESTEP_END
C++ Type:ExecFlagEnum
Options:NONE, INITIAL, LINEAR, NONLINEAR_CONVERGENCE, NONLINEAR, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM
Controllable:No
Description:The list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
execution_order_group0Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
Default:0
C++ Type:int
Controllable:No
Description:Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
force_postauxFalseForces the UserObject to be executed in POSTAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in POSTAUX
force_preauxFalseForces the UserObject to be executed in PREAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREAUX
force_preicFalseForces the UserObject to be executed in PREIC during initial setup
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREIC during initial setup

Execution Scheduling Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:Yes
Description:Set the enabled status of the MooseObject.
use_displaced_meshFalseWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

Advanced Parameters

prop_getter_suffixAn optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
C++ Type:MaterialPropertyName
Unit:(no unit assumed)
Controllable:No
Description:An optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
use_interpolated_stateFalseFor the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.
Default:False
C++ Type:bool
Controllable:No
Description:For the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.

Material Property Retrieval Parameters

Sub-block parameters

batch_index_generator_nameThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Name of the NEML2BatchIndexGenerator user object. The default name is 'neml2_index__' where is the NEML2 model's name, and is this action sub-block's name.)
C++ Type:std::string
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Name of the NEML2BatchIndexGenerator user object. The default name is 'neml2_index__' where is the NEML2 model's name, and is this action sub-block's name.)
blockThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of blocks (subdomains) where the material model is defined)
C++ Type:std::vector<SubdomainName>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of blocks (subdomains) where the material model is defined)
devicecpuDevice on which to evaluate the NEML2 model. The string supplied must follow the following schema: (cpu|cuda)[:] where cpu or cuda specifies the device type, and : optionally specifies a device index. For example, device='cpu' sets the target compute device to be CPU, and device='cuda:1' sets the target compute device to be CUDA with device ID 1.
Default:cpu
C++ Type:std::string
Controllable:No
Description:Device on which to evaluate the NEML2 model. The string supplied must follow the following schema: (cpu|cuda)[:] where cpu or cuda specifies the device type, and : optionally specifies a device index. For example, device='cpu' sets the target compute device to be CPU, and device='cuda:1' sets the target compute device to be CUDA with device ID 1.
executor_nameThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Name of the NEML2ModelExecutor user object. The default name is 'neml2__' where is the NEML2 model's name, and is this action sub-block's name.)
C++ Type:std::string
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Name of the NEML2ModelExecutor user object. The default name is 'neml2__' where is the NEML2 model's name, and is this action sub-block's name.)
export_output_targetsThe export targets corresponding to each MOOSE material property specified in export_outputs.
C++ Type:std::vector<std::vector<OutputName>>
Controllable:No
Description:The export targets corresponding to each MOOSE material property specified in export_outputs.
export_outputsList of MOOSE material properties to export which correspond to NEML2 output variables or output derivatives. Each material property's export targets can be specified by export_output_targets. The default export target is 'none'.
C++ Type:std::vector<MaterialPropertyName>
Unit:(no unit assumed)
Controllable:No
Description:List of MOOSE material properties to export which correspond to NEML2 output variables or output derivatives. Each material property's export targets can be specified by export_output_targets. The default export target is 'none'.
initialize_output_valuesList of MOOSE material properties whose initial values (evaluated at the 0th time step) will be used to initialize stateful properties. See the description of initialize_outputs for more details.
C++ Type:std::vector<MaterialPropertyName>
Unit:(no unit assumed)
Controllable:No
Description:List of MOOSE material properties whose initial values (evaluated at the 0th time step) will be used to initialize stateful properties. See the description of initialize_outputs for more details.
initialize_outputsList of MOOSE material properties to be initialized. Each these properties must correspond to a stateful NEML2 variable (which appears on both the input old state sub-axis and the output state sub-axis). These MOOSE material properties will be initialized with the values of properties specified in the initialize_output_values list.
C++ Type:std::vector<MaterialPropertyName>
Unit:(no unit assumed)
Controllable:No
Description:List of MOOSE material properties to be initialized. Each these properties must correspond to a stateful NEML2 variable (which appears on both the input old state sub-axis and the output state sub-axis). These MOOSE material properties will be initialized with the values of properties specified in the initialize_output_values list.
modelName of the NEML2 model, i.e., the string inside the brackets [] in the NEML2 input file that corresponds to the model you want to use.
C++ Type:std::string
Controllable:No
Description:Name of the NEML2 model, i.e., the string inside the brackets [] in the NEML2 input file that corresponds to the model you want to use.
moose_derivative_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 variable derivatives)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 variable derivatives)
moose_derivativesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model.)
moose_input_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 input variable)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 input variable)
moose_inputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as inputs of the material model.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as inputs of the material model.)
moose_output_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 output variables)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 output variables)
moose_outputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the output of the material model.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the output of the material model.)
moose_parameter_derivative_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 parameter derivatives)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: MOOSE types used to hold the NEML2 parameter derivatives)
moose_parameter_derivativesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model w.r.t. model parameters.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data used to hold the derivative of the material model w.r.t. model parameters.)
moose_parameter_typesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 model parameter)
C++ Type:MultiMooseEnum
Options:MATERIAL, VARIABLE, POSTPROCESSOR
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Type of each MOOSE data to be used as NEML2 model parameter)
moose_parametersThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as parameters of the material model.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of MOOSE data to be used as parameters of the material model.)
neml2_derivativesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)
C++ Type:std::vector<std::vector<std::string>>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)
neml2_inputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 input variables corresponding to each MOOSE data.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 input variables corresponding to each MOOSE data.)
neml2_outputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 output variables corresponding to each MOOSE data.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 output variables corresponding to each MOOSE data.)
neml2_parameter_derivativesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)
C++ Type:std::vector<std::vector<std::string>>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of pairs of NEML2 variables to take derivatives (i.e., first in the pair w.r.t. the second in the pair).)
neml2_parametersThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 model parameters corresponding to each MOOSE data.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 model parameters corresponding to each MOOSE data.)
skip_inputsThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 variables to skip error checking when setting up the model input. If an input variable is skipped, its value will stay zero. If a required input variable is not skipped, an error will be raised.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 variables to skip error checking when setting up the model input. If an input variable is skipped, its value will stay zero. If a required input variable is not skipped, an error will be raised.)
skip_variablesThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 variables to skip when setting up the model input. If an input variable is skipped, its value will stay zero. If a required input variable is not skipped, an error will be raised.)
C++ Type:std::vector<std::string>
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: List of NEML2 variables to skip when setting up the model input. If an input variable is skipped, its value will stay zero. If a required input variable is not skipped, an error will be raised.)
verboseTrueThe `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Whether to print additional information about the NEML2 model at the beginning of the simulation)
Default:True
C++ Type:bool
Controllable:No
Description:The `NEML2` library is required but not enabled. Refer to the documentation for guidance on how to enable it. (Original description: Whether to print additional information about the NEML2 model at the beginning of the simulation)

Optional Parameters

allow_duplicate_execution_on_initialFalseIn the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
Default:False
C++ Type:bool
Controllable:No
Description:In the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
execute_onTIMESTEP_ENDThe list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
Default:TIMESTEP_END
C++ Type:ExecFlagEnum
Options:NONE, INITIAL, LINEAR, NONLINEAR_CONVERGENCE, NONLINEAR, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM
Controllable:No
Description:The list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
execution_order_group0Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
Default:0
C++ Type:int
Controllable:No
Description:Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
force_postauxFalseForces the UserObject to be executed in POSTAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in POSTAUX
force_preauxFalseForces the UserObject to be executed in PREAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREAUX
force_preicFalseForces the UserObject to be executed in PREIC during initial setup
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREIC during initial setup

Execution Scheduling Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:Yes
Description:Set the enabled status of the MooseObject.
use_displaced_meshFalseWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

Advanced Parameters

prop_getter_suffixAn optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
C++ Type:MaterialPropertyName
Unit:(no unit assumed)
Controllable:No
Description:An optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
use_interpolated_stateFalseFor the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.
Default:False
C++ Type:bool
Controllable:No
Description:For the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.

Material Property Retrieval Parameters

(moose/modules/solid_mechanics/test/tests/neml2/elasticity.i)

neml2_input = elasticity
N = 2

[GlobalParams]
  displacements = 'disp_x disp_y disp_z'
[]

[Mesh]
  [gmg]
    type = GeneratedMeshGenerator
    dim = 3
    nx = ${N}
    ny = ${N}
    nz = ${N}
  []
[]

[Physics]
  [SolidMechanics]
    [QuasiStatic]
      [all]
        strain = SMALL
        new_system = true
        add_variables = true
        formulation = TOTAL
        volumetric_locking_correction = true
      []
    []
  []
[]

[NEML2]
  input = 'models/${neml2_input}.i'
  [all]
    model = 'model'
    verbose = true
    device = 'cpu'

    moose_input_types = 'MATERIAL'
    moose_inputs = 'neml2_strain'
    neml2_inputs = 'forces/E'

    moose_output_types = 'MATERIAL'
    moose_outputs = 'neml2_stress'
    neml2_outputs = 'state/S'

    moose_derivative_types = 'MATERIAL'
    moose_derivatives = 'neml2_jacobian'
    neml2_derivatives = 'state/S forces/E'
  []
[]

[Materials]
  [convert_strain]
    type = RankTwoTensorToSymmetricRankTwoTensor
    from = 'mechanical_strain'
    to = 'neml2_strain'
  []
  [stress]
    type = ComputeLagrangianObjectiveCustomSymmetricStress
    custom_small_stress = 'neml2_stress'
    custom_small_jacobian = 'neml2_jacobian'
  []
[]

[BCs]
  [xfix]
    type = DirichletBC
    variable = disp_x
    boundary = left
    value = 0
  []
  [yfix]
    type = DirichletBC
    variable = disp_y
    boundary = bottom
    value = 0
  []
  [zfix]
    type = DirichletBC
    variable = disp_z
    boundary = back
    value = 0
  []
  [xdisp]
    type = FunctionDirichletBC
    variable = disp_x
    boundary = right
    function = t
    preset = false
  []
[]

[Executioner]
  type = Transient
  solve_type = NEWTON
  petsc_options_iname = '-pc_type'
  petsc_options_value = 'lu'
  automatic_scaling = true
  dt = 1e-3
  dtmin = 1e-3
  num_steps = 5
  residual_and_jacobian_together = true
[]

[Outputs]
  file_base = '${neml2_input}'
  exodus = true
[]

(moose/modules/solid_mechanics/test/tests/neml2/blocks_different_model.i)

neml2_input = elasticity_2
N = 2

[GlobalParams]
  displacements = 'disp_x disp_y disp_z'
[]

[Mesh]
  [gmg]
    type = GeneratedMeshGenerator
    dim = 3
    nx = ${N}
    ny = ${N}
    nz = ${N}
  []
  [A]
    type = SubdomainBoundingBoxGenerator
    input = gmg
    block_id = 1
    block_name = A
    bottom_left = '0 0 0'
    top_right = '1 1 0.5'
  []
  [B]
    type = SubdomainBoundingBoxGenerator
    input = A
    block_id = 2
    block_name = B
    bottom_left = '0 0 0.5'
    top_right = '1 1 1'
  []
[]

[Physics]
  [SolidMechanics]
    [QuasiStatic]
      [all]
        strain = SMALL
        new_system = true
        add_variables = true
        formulation = TOTAL
        volumetric_locking_correction = true
      []
    []
  []
[]

[NEML2]
  input = 'models/${neml2_input}.i'
  verbose = true
  [A]
    model = 'model1'
    block = 'A'
    device = 'cpu'

    moose_input_types = 'MATERIAL'
    moose_inputs = 'neml2_strain'
    neml2_inputs = 'forces/E'

    moose_output_types = 'MATERIAL'
    moose_outputs = 'neml2_stress'
    neml2_outputs = 'state/S'

    moose_derivative_types = 'MATERIAL'
    moose_derivatives = 'neml2_jacobian'
    neml2_derivatives = 'state/S forces/E'
  []
  [B]
    model = 'model2'
    block = 'B'
    device = 'cpu'

    moose_input_types = 'MATERIAL'
    moose_inputs = 'neml2_strain'
    neml2_inputs = 'forces/E'

    moose_output_types = 'MATERIAL'
    moose_outputs = 'neml2_stress'
    neml2_outputs = 'state/S'

    moose_derivative_types = 'MATERIAL'
    moose_derivatives = 'neml2_jacobian'
    neml2_derivatives = 'state/S forces/E'
  []
[]

[Materials]
  [convert_strain]
    type = RankTwoTensorToSymmetricRankTwoTensor
    from = 'mechanical_strain'
    to = 'neml2_strain'
  []
  [stress]
    type = ComputeLagrangianObjectiveCustomSymmetricStress
    custom_small_stress = 'neml2_stress'
    custom_small_jacobian = 'neml2_jacobian'
  []
[]

[BCs]
  [xfix]
    type = DirichletBC
    variable = disp_x
    boundary = left
    value = 0
  []
  [yfix]
    type = DirichletBC
    variable = disp_y
    boundary = bottom
    value = 0
  []
  [zfix]
    type = DirichletBC
    variable = disp_z
    boundary = back
    value = 0
  []
  [xdisp]
    type = FunctionDirichletBC
    variable = disp_x
    boundary = right
    function = t
    preset = false
  []
[]

[Executioner]
  type = Transient
  solve_type = NEWTON
  petsc_options_iname = '-pc_type'
  petsc_options_value = 'lu'
  automatic_scaling = true
  dt = 1e-3
  dtmin = 1e-3
  num_steps = 5
  residual_and_jacobian_together = true
[]

[Outputs]
  exodus = true
[]