SecantSolver

construction:Undocumented Class

The SecantSolver has not been documented. The content listed below should be used as a starting point for documenting the class, which includes the typical automatic documentation associated with a MooseObject; however, what is contained is ultimately determined by what is necessary to make the documentation clear for users.

Implicit secant solver time integration.

Overview

Nonlinear solver using a secant update of the reciprocal nonlinear operator to accelerate fixed-point iterations. Useful when a Jacobian is expensive or unavailable.

Example Input File Syntax

[TensorSolver<<<{"href": "../../syntax/TensorSolver/index.html"}>>>]
  type = SecantSolver
  buffer = psi
  substeps = 3
  reciprocal_buffer = psibar
  linear_reciprocal = linear
  nonlinear_reciprocal = psi3bar
[]

Input Parameters

bufferThe buffer this solver is writing to
C++ Type:std::vector<std::string>
Controllable:No
Description:The buffer this solver is writing to
linear_reciprocalBuffer with the reciprocal of the linear prefactor (e.g. kappa*k^2). Either one buffer per nonlinear_reciprocal, or no buffer names, or `0` to skip linear reciprocal buffers for a given variable.
C++ Type:std::vector<std::string>
Controllable:No
Description:Buffer with the reciprocal of the linear prefactor (e.g. kappa*k^2). Either one buffer per nonlinear_reciprocal, or no buffer names, or `0` to skip linear reciprocal buffers for a given variable.
nonlinear_reciprocalBuffer with the reciprocal of the non-linear contribution
C++ Type:std::vector<std::string>
Controllable:No
Description:Buffer with the reciprocal of the non-linear contribution
reciprocal_bufferBuffer with the reciprocal of the integrated buffer
C++ Type:std::vector<std::string>
Controllable:No
Description:Buffer with the reciprocal of the integrated buffer

Required Parameters

absolute_tolerance1e-09Convergence tolerance.
Default:1e-09
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Convergence tolerance.
damping1Damping factor for the update step.
Default:1
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Damping factor for the update step.
dt_epsilon0.0001Semi-implicit stable timestep to bootstrap secant solve.
Default:0.0001
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Semi-implicit stable timestep to bootstrap secant solve.
forward_bufferThese buffers are updated with the corresponding buffers from forward_buffer_old. No integration is performed. Buffer forwarding is used only to resolve cyclic dependencies.
C++ Type:std::vector<std::string>
Controllable:No
Description:These buffers are updated with the corresponding buffers from forward_buffer_old. No integration is performed. Buffer forwarding is used only to resolve cyclic dependencies.
forward_buffer_newNew values to update `forward_buffer` with.
C++ Type:std::vector<std::string>
Controllable:No
Description:New values to update `forward_buffer` with.
max_iterations30Maximum number of secant solver iteration.
Default:30
C++ Type:unsigned int
Controllable:No
Description:Maximum number of secant solver iteration.
relative_tolerance1e-09Convergence tolerance.
Default:1e-09
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Convergence tolerance.
root_computePrimary compute object that updates the buffers. This is usually a ComputeGroup object. A ComputeGroup encompassing all computes will be generated automatically if the user does not provide this parameter.
C++ Type:std::string
Controllable:No
Description:Primary compute object that updates the buffers. This is usually a ComputeGroup object. A ComputeGroup encompassing all computes will be generated automatically if the user does not provide this parameter.
substeps1secant solver substeps per time step.
Default:1
C++ Type:unsigned int
Controllable:No
Description:secant solver substeps per time step.
verboseFalseShow convergence history.
Default:False
C++ Type:bool
Controllable:No
Description:Show convergence history.

Optional 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:No
Description:Set the enabled status of the MooseObject.

Advanced Parameters

Input Files

(benchmarks/02_oswald_ripening/2a_secant.i)
(benchmarks/01_spinodal_decomposition/1a_secant.i)
(test/tests/tensor_compute/coupled_pf_mech_secant.i)
(benchmarks/02_oswald_ripening/simple.i)
(test/tests/tensor_compute/rotating_grain_secant.i)

(test/tests/tensor_compute/rotating_grain_secant.i)

w=6

[Domain]
  dim = 2
  nx = 40
  ny = 40
  xmax = ${fparse w*pi*2}
  ymax = ${fparse w*pi*2/sin(pi/3)}
  mesh_mode = DOMAIN
[]

[AuxVariables]
  [phi]
  []
[]

[Outputs]
  exodus = false
[]

[TensorBuffers]
  [psi]
    map_to_aux_variable = phi
  []
  [psibar]
  []
  [psi3]
  []
  [psi3bar]
  []
  # constant tensors
  [linear]
  []
[]

crystal = '-(sin(sin(a)*y/2+cos(a)*x/2)^2 + sin(sin(a+1/3*pi)*y/2+cos(a+1/3*pi)*x/2)^2 + sin(sin(a-1/3*pi)*y/2+cos(a-1/3*pi)*x/2)^2 - 1.5)*0.25'
[Functions]
  [grain1]
    type = ParsedFunction
    expression = 'a := 0; ${crystal}'
  []
  [grain2]
    type = ParsedFunction
    expression = 'a := 0.95; ${crystal}'
  []
  [domain]
    type = ParsedFunction
    expression = 'r := (x-${w}*pi)^2+(y-${w}*pi)^2; if(r<(${w}*2/3*pi)^2, grain2, grain1)'
    symbol_names = 'grain1 grain2'
    symbol_values = 'grain1 grain2'
  []
[]

[TensorComputes]
  [Initialize]
    [psi]
      type = MooseFunctionTensor
      buffer = psi
      function = domain
    []
    [linear]
      type = SwiftHohenbergLinear
      buffer = linear
      alpha = 1
      r = 0.025
    []
  []

  [Solve]
    [psi3]
      type = ParsedCompute
      buffer = psi3
      expression = "0.20*psi^2-psi^3"
      inputs = psi
    []
    [psibar]
      type = ForwardFFT
      buffer = psibar
      input = psi
    []
    [psi3bar]
      type = ForwardFFT
      buffer = psi3bar
      input = psi3
    []
  []
[]

[TensorSolver]
  type = SecantSolver
  buffer = psi
  substeps = 3
  reciprocal_buffer = psibar
  linear_reciprocal = linear
  nonlinear_reciprocal = psi3bar
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 10
  [TimeStepper]
    type = TensorSolveIterationAdaptiveDT
    dt = 1
    max_iterations = 400
    min_iterations = 100
    growth_factor = 1.4
    cutback_factor = 0.9
  []
  dtmax = 500
[]

[TensorOutputs]
  [xdmf]
    type = XDMFTensorOutput
    buffer = 'psi'
    enable_hdf5 = true
    # Do not transpose output to avoid regolding the test. In practice the default
    # of transpose = true should always be used
    transpose = false
  []
[]

(benchmarks/02_oswald_ripening/2a_secant.i)

[Domain]
  dim = 2
  nx = 120
  ny = 120
  xmax = 200
  ymax = 200

  device_names = 'cuda:1'

  mesh_mode = DOMAIN
[]

fchem='fa:=rho^2*(c-ca)^2;
fb:=rho^2*(cb-c)^2;
h:=n1^3*(6*n1^2-15*n1+10) +
   n2^3*(6*n2^2-15*n2+10) +
   n3^3*(6*n3^2-15*n3+10) +
   n4^3*(6*n4^2-15*n4+10);
g:=n1^2*(1-n1)^2 +
   n2^2*(1-n2)^2 +
   n3^2*(1-n3)^2 +
   n4^2*(1-n4)^2 +
alpha*(
n1^2*n2^2 + n1^2*n3^2 + n1^2*n4^2 +
n2^2*n1^2 + n2^2*n3^2 + n2^2*n4^2 +
n3^2*n1^2 + n3^2*n2^2 + n3^2*n4^2 +
n4^2*n1^2 + n4^2*n2^2 + n4^2*n3^2);
(fa*(1-h) + fb*h + w*g)'

nic = 'epsilon*(cos((0.01*idx)*x-4)*cos((0.007+0.01*idx)*y)
       +cos((0.11+0.01*idx)*x)*cos((0.11+0.01*idx)*y)
       +psi*(cos((0.046+0.001*idx)*x+(0.0405+0.001*idx)*y)
       *cos((0.031+0.001*idx)*x-(0.004+0.001*idx)*y))^2)^2'

cnames = 'rho     ca  cb  alpha w L M'
cvalues= 'sqrt(2) 0.3 0.7 5     1 5 5'

[TensorBuffers]
  # variables
  [c]
  []
  [n1]
  []
  [n2]
  []
  [n3]
  []
  [n4]
  []

  [c_bar]
  []
  [n1_bar]
  []
  [n2_bar]
  []
  [n3_bar]
  []
  [n4_bar]
  []

  [mu_c]
  []
  [mu_n1]
  []
  [mu_n2]
  []
  [mu_n3]
  []
  [mu_n4]
  []

  [mu_c_bar]
  []
  [mu_n1_bar]
  []
  [mu_n2_bar]
  []
  [mu_n3_bar]
  []
  [mu_n4_bar]
  []

  [Mbar_mu_c_bar]
  []

  # constant tensors
  [Lbar] # FFT(M*laplacian)
  []
  [MkappaL2bar] # FFT(-M*kappa*laplacian^2)
  []
  [kappaLbar] # FFT(L*kappa*laplacian)
  []

  # postprocessing
  [F]
  []
  [Fgrad_c]
  []
  [Fgrad_n1]
  []
  [Fgrad_n2]
  []
  [Fgrad_n3]
  []
  [Fgrad_n4]
  []
  [bnds]
  []
[]

[TensorComputes]
  [Initialize]
    [c]
      type = ParsedCompute
      buffer = c
      extra_symbols = true
      expression = 'c0+epsilon*(cos(0.105*x)*cos(0.11*y)+(cos(0.13*x)*cos(0.087*y))^2+cos(0.025*x-0.15*y)*cos(0.07*x-0.02*y))'
      constant_names = 'c0 epsilon'
      constant_expressions = '0.5 0.01'
    []
    [Lbar]
      type = ReciprocalLaplacianFactor
      # Mobility is pulled into the chemical potential below
      buffer = Lbar
    []
    [MkappaL2bar]
      type = ReciprocalLaplacianSquareFactor
      factor = -15 # -kappa_c*M
      buffer = MkappaL2bar
    []
    [kappaLbar]
      type = ReciprocalLaplacianFactor
      buffer = kappaLbar
      factor = 15 # kappa_ni*L
    []
    [n1]
      type = ParsedCompute
      buffer = n1
      expression = ${nic}
      extra_symbols = true
      constant_names       = 'idx epsilon psi'
      constant_expressions = '  1     0.1 1.5'
    []
    [n2]
      type = ParsedCompute
      buffer = n2
      expression = ${nic}
      extra_symbols = true
      constant_names       = 'idx epsilon psi'
      constant_expressions = '  2    0.1 1.5'
    []
    [n3]
      type = ParsedCompute
      buffer = n3
      expression = ${nic}
      extra_symbols = true
      constant_names       = 'idx epsilon psi'
      constant_expressions = '  3     0.1 1.5'
    []
    [n4]
      type = ParsedCompute
      buffer = n4
      expression = ${nic}
      extra_symbols = true
      constant_names       = 'idx epsilon psi'
      constant_expressions = '  4     0.1 1.5'
    []
  []

  [Solve]
    [mu_c]
      type = ParsedCompute
      buffer = mu_c
      expression = '${fchem}*M'
      constant_names = ${cnames}
      constant_expressions = ${cvalues}
      derivatives = c
      inputs = 'c n1 n2 n3 n4'
    []

    [mu_n1]
      type = ParsedCompute
      buffer = mu_n1
      expression = '${fchem}*(-L)'
      constant_names = ${cnames}
      constant_expressions = ${cvalues}
      derivatives = n1
      inputs = 'c n1 n2 n3 n4'
    []
    [mu_n2]
      type = ParsedCompute
      buffer = mu_n2
      expression = '${fchem}*(-L)'
      constant_names = ${cnames}
      constant_expressions = ${cvalues}
      derivatives = n2
      inputs = 'c n1 n2 n3 n4'
    []
    [mu_n3]
      type = ParsedCompute
      buffer = mu_n3
      expression = '${fchem}*(-L)'
      constant_names = ${cnames}
      constant_expressions = ${cvalues}
      derivatives = n3
      inputs = 'c n1 n2 n3 n4'
    []
    [mu_n4]
      type = ParsedCompute
      buffer = mu_n4
      expression = '${fchem}*(-L)'
      constant_names = ${cnames}
      constant_expressions = ${cvalues}
      derivatives = n4
      inputs = 'c n1 n2 n3 n4'
    []

    [mu_c_bar]
      type = ForwardFFT
      buffer = mu_c_bar
      input = mu_c
    []
    [mu_n1_bar]
      type = ForwardFFT
      buffer = mu_n1_bar
      input = mu_n1
    []
    [mu_n2_bar]
      type = ForwardFFT
      buffer = mu_n2_bar
      input = mu_n2
    []
    [mu_n3_bar]
      type = ForwardFFT
      buffer = mu_n3_bar
      input = mu_n3
    []
    [mu_n4_bar]
      type = ForwardFFT
      buffer = mu_n4_bar
      input = mu_n4
    []

    [Mbar_mu_c_bar]
      type = ParsedCompute
      buffer = Mbar_mu_c_bar
      expression = 'Lbar*mu_c_bar'
      inputs = 'Lbar mu_c_bar'
    []

    [c_bar]
      type = ForwardFFT
      buffer = c_bar
      input = c
    []
    [n1_bar]
      type = ForwardFFT
      buffer = n1_bar
      input = n1
    []
    [n2_bar]
      type = ForwardFFT
      buffer = n2_bar
      input = n2
    []
    [n3_bar]
      type = ForwardFFT
      buffer = n3_bar
      input = n3
    []
    [n4_bar]
      type = ForwardFFT
      buffer = n4_bar
      input = n4
    []
  []

  [Postprocess]
    [Fgrad_c]
      type = FFTGradientSquare
      buffer = Fgrad_c
      input = c
      factor = 1.5 # kappa/2
    []
    [Fgrad_n1]
      type = FFTGradientSquare
      buffer = Fgrad_n1
      input = n1
      factor = 1.5 # kappa/2
    []
    [Fgrad_n2]
      type = FFTGradientSquare
      buffer = Fgrad_n2
      input = n2
      factor = 1.5 # kappa/2
    []
    [Fgrad_n3]
      type = FFTGradientSquare
      buffer = Fgrad_n3
      input = n3
      factor = 1.5 # kappa/2
    []
    [Fgrad_n4]
      type = FFTGradientSquare
      buffer = Fgrad_n4
      input = n4
      factor = 1.5 # kappa/2
    []
    [F]
      type = ParsedCompute
      buffer = F
      expression = '${fchem} + Fgrad_c + Fgrad_n1 + Fgrad_n2 + Fgrad_n3 + Fgrad_n4'
      constant_names =  ${cnames}
      constant_expressions = ${cvalues}
      inputs = 'c n1 n2 n3 n4 Fgrad_c Fgrad_n1 Fgrad_n2 Fgrad_n3 Fgrad_n4'
    []
    [bnds]
      type = ParsedCompute
      buffer = bnds
      expression = 'n1^2 + n2^2 + n3^2 + n4^2'
      inputs = 'n1 n2 n3 n4'
    []
  []
[]

[TensorSolver]
  type = SecantSolver
  substeps = 1
  max_iterations = 1000
  # damping = 0.75
  relative_tolerance = 1e-6
  absolute_tolerance = 1e-6
  buffer = 'c n1 n2 n3 n4'
  dt_epsilon = 1e-7
  reciprocal_buffer = 'c_bar n1_bar n2_bar n3_bar n4_bar'
  linear_reciprocal = 'MkappaL2bar kappaLbar kappaLbar kappaLbar kappaLbar'
  nonlinear_reciprocal = 'Mbar_mu_c_bar mu_n1_bar mu_n2_bar mu_n3_bar mu_n4_bar'
  # verbose = true
[]

[Postprocessors]
  [min_c]
    type = TensorExtremeValuePostprocessor
    buffer = c
    value_type = MIN
    execute_on = 'TIMESTEP_END'
  []
  [max_c]
    type = TensorExtremeValuePostprocessor
    buffer = c
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []
  [F]
    type = TensorIntegralPostprocessor
    buffer = F
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  # num_steps = 2
  end_time = 1e+5
  [TimeStepper]
    type = TensorSolveIterationAdaptiveDT
    dt = 0.1
    max_iterations = 500
    min_iterations = 300
    growth_factor = 1.1
    cutback_factor = 0.9
  []
[]

[Outputs]
  csv = true
  perf_graph = true
  execute_on = 'TIMESTEP_END'
[]

[TensorOutputs]
  [c]
    type = XDMFTensorOutput
    buffer = 'c bnds'
    output_mode = 'NODE NODE'
    enable_hdf5 = true
  []
[]

(benchmarks/01_spinodal_decomposition/1a_secant.i)

[Domain]
  dim = 2
  nx = 200
  ny = 200
  xmax = 200
  ymax = 200
  device_names = 'cuda'
  mesh_mode = DOMAIN
[]


[TensorBuffers]
  [c]
    map_to_aux_variable = c
  []
  [cbar]
  []
  [mu]
  []
  [mubar]
  []
  [Mbarmubar]
  []
  # constant tensors
  [Mbar]
  []
  [kappabarbar]
  []
  # postprocessing
  [F]
  []
  [Fgrad]
  []
[]

[TensorComputes]
  [Initialize]
    [c]
      type = ParsedCompute
      buffer = c
      extra_symbols = true
      expression = 'c0+epsilon*(cos(0.105*x)*cos(0.11*y)+(cos(0.13*x)*cos(0.087*y))^2+cos(0.025*x-0.15*y)*cos(0.07*x-0.02*y))'
      constant_names = 'c0 epsilon'
      constant_expressions = '0.5 0.01'
    []
    [Mbar]
      type = ReciprocalLaplacianFactor
      factor = 5 # Mobility
      buffer = Mbar
    []
    [kappabarbar]
      type = ReciprocalLaplacianSquareFactor
      factor = -10 # -kappa*M
      buffer = kappabarbar
    []
  []

  [Solve]
    [mu]
      type = ParsedCompute
      buffer = mu
      expression = 'rho_s*(c-c_alpha)^2*(c_beta-c)^2'
      constant_names =       'rho_s c_alpha c_beta'
      constant_expressions = '5     0.3     0.7'
      derivatives = c
      inputs = c
    []
    [mubar]
      type = ForwardFFT
      buffer = mubar
      input = mu
    []
    [Mbarmubar]
      type = ParsedCompute
      buffer = Mbarmubar
      expression = 'Mbar*mubar'
      inputs = 'Mbar mubar'
    []
    [cbar]
      type = ForwardFFT
      buffer = cbar
      input = c
    []
  []

  [Postprocess]
    [Fgrad]
      type = FFTGradientSquare
      buffer = Fgrad
      input = c
      factor = 1 # kappa/2
    []
    [F]
      type = ParsedCompute
      buffer = F
      expression = 'rho_s * (c-c_alpha)^2 * (c_beta-c)^2 + Fgrad'
      constant_names =       'rho_s c_alpha c_beta'
      constant_expressions = '5     0.3     0.7'
      inputs = 'c Fgrad'
    []
  []
[]

[TensorSolver]
  type = SecantSolver
  substeps = 5
  max_iterations = 50
  tolerance = 1e-7
  dt_epsilon = 1e-5
  buffer = c
  reciprocal_buffer = cbar
  linear_reciprocal = kappabarbar
  nonlinear_reciprocal = Mbarmubar
[]

[AuxVariables]
  [c]
  []
[]

[Postprocessors]
  [min_c]
    type = TensorExtremeValuePostprocessor
    buffer = c
    value_type = MIN
    execute_on = 'TIMESTEP_END'
  []
  [max_c]
    type = TensorExtremeValuePostprocessor
    buffer = c
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []
  [F]
    type = TensorIntegralPostprocessor
    buffer = F
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 900
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.01
    dt = 1
  []
  # dtmax = 200
[]

[Outputs]
  exodus = true
  csv = true
  perf_graph = true
  execute_on = 'TIMESTEP_END'
[]

(test/tests/tensor_compute/coupled_pf_mech_secant.i)

[Domain]
  dim = 3
  nx = 128
  ny = 128
  nz = 128
  xmax = ${fparse pi*4}
  ymax = ${fparse pi*4}
  zmax = ${fparse pi*4}
  mesh_mode = DUMMY
[]

[TensorBuffers]
  # phase field
  [c]
  []
  [cbar]
  []
  [mu]
  []
  [mubar]
  []
  [Mbarmubar]
  []

  # mechanics
  [disp_x]
  []
  [disp_y]
  []
  [disp_z]
  []
  [mumechbar]
  []
  [mumech]
  []

  # constant tensors
  [Mbar]
  []
  [kappabarbar]
  []
[]

[TensorOutputs]
  [xdmf]
    type = XDMFTensorOutput
    buffer = 'c disp_x disp_y disp_z mu mumech'
    output_mode = 'Node Node Node Node Cell Cell'
    enable_hdf5 = true
  []
[]

[TensorComputes]
  [Initialize]
    [c]
      type = RandomTensor
      buffer = c
      min = 0.44
      max = 0.56
    []
    [mu_init]
      type = ConstantTensor
      buffer = mu
    []
    [mumech_init]
      type = ConstantTensor
      buffer = mumech
    []
    [disp_x]
      type = RandomTensor
      buffer = disp_x
      min = 0
      max = 0
    []
    [disp_y]
      type = RandomTensor
      buffer = disp_y
      min = 0
      max = 0
    []
    [disp_z]
      type = RandomTensor
      buffer = disp_z
      min = 0
      max = 0
    []
    [Mbar]
      type = ReciprocalLaplacianFactor
      factor = 0.2 # Mobility
      buffer = Mbar
    []
    [kappabarbar]
      type = ReciprocalLaplacianSquareFactor
      factor = -0.001 # kappa
      buffer = kappabarbar
    []
  []

  [Solve]
    [mu]
      # chemical potential (real space)
      type = ParsedCompute
      buffer = mu
      expression = '0.1*c^2*(c-1)^2' # + c*sin(x/2)*0.005'
      extra_symbols = true
      derivatives = c
      inputs = c
    []
    [mubar]
      # chemical potential (reciprocal space)
      type = ForwardFFT
      buffer = mubar
      input = mu
    []
    [mumechbar]
      # mechanical chemical potential (reciprocal space)
      type = FFTElasticChemicalPotential
      buffer = mumechbar
      cbar = cbar
      displacements = 'disp_x disp_y disp_z'
      lambda = 100
      mu = 50
      e0 = 0.02
    []
    [mumech]
      # chemical potential (reciprocal space)
      type = InverseFFT
      buffer = mumech
      input = mumechbar
    []

    [Mbarmubar]
      type = ParsedCompute
      buffer = Mbarmubar
      expression = 'Mbar*(mubar+mumechbar)'
      inputs = 'Mbar mubar mumechbar'
    []
    [cbar]
      type = ForwardFFT
      buffer = cbar
      input = c
    []

    [qsmech]
      type = FFTQuasistaticElasticity
      displacements = 'disp_x disp_y disp_z'
      cbar = cbar
      lambda = 100
      mu = 50
      e0 = 0.02
    []
  []
[]

[TensorSolver]
  type = SecantSolver
  substeps = 1
  max_iterations = 1000
  # damping = 0.75
  relative_tolerance = 1e-6
  absolute_tolerance = 1e-6
  buffer = c
  dt_epsilon = 1e-7
  reciprocal_buffer = cbar
  linear_reciprocal = kappabarbar
  nonlinear_reciprocal = Mbarmubar
  verbose = true
[]

[Postprocessors]
  [min_c]
    type = TensorExtremeValuePostprocessor
    buffer = c
    value_type = MIN
    execute_on = 'TIMESTEP_END'
  []
  [max_c]
    type = TensorExtremeValuePostprocessor
    buffer = c
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []

  [min_disp_x]
    type = TensorExtremeValuePostprocessor
    buffer = disp_x
    value_type = MIN
    execute_on = 'TIMESTEP_END'
  []
  [max_disp_x]
    type = TensorExtremeValuePostprocessor
    buffer = disp_x
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []
  [min_disp_y]
    type = TensorExtremeValuePostprocessor
    buffer = disp_y
    value_type = MIN
    execute_on = 'TIMESTEP_END'
  []
  [max_disp_y]
    type = TensorExtremeValuePostprocessor
    buffer = disp_y
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []
  [min_disp_z]
    type = TensorExtremeValuePostprocessor
    buffer = disp_z
    value_type = MIN
    execute_on = 'TIMESTEP_END'
  []
  [max_disp_z]
    type = TensorExtremeValuePostprocessor
    buffer = disp_z
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []

  [C]
    type = TensorIntegralPostprocessor
    buffer = c
    execute_on = 'TIMESTEP_END'
  []
  [cavg]
    type = TensorAveragePostprocessor
    buffer = c
    execute_on = 'TIMESTEP_END'
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  end_time = 100
  [TimeStepper]
    type = TensorSolveIterationAdaptiveDT
    dt = 0.1
    max_iterations = 500
    min_iterations = 300
    growth_factor = 1.1
    cutback_factor = 0.9
  []
[]

[Outputs]
  csv = true
  perf_graph = true
  execute_on = 'TIMESTEP_END'
[]

(benchmarks/02_oswald_ripening/simple.i)

[Domain]
  dim = 2
  nx = 4
  ny = 4
  xmax = 1
  ymax = 1

  device_names = 'cuda:0'

  mesh_mode = DOMAIN
[]

[TensorBuffers]
  # variables
  [n1]
  []
  [n2]
  []
  [n3]
  []

  [n1_bar]
  []
  [n2_bar]
  []
  [n3_bar]
  []

  [mu_n1]
  []
  [mu_n2]
  []
  [mu_n3]
  []

  [mu_n1_bar]
  []
  [mu_n2_bar]
  []
  [mu_n3_bar]
  []

  [Lbar] # zero
  []
[]

[TensorComputes]
  [Initialize]
    [Lbar]
      type = ConstantReciprocalTensor
      buffer = Lbar
      real = 0
      imaginary = 0
    []

    [n1]
      type = ConstantTensor
      buffer = n1
      real = 1
    []
    [n2]
      type = ConstantTensor
      buffer = n2
      real = 1
    []
    [n3]
      type = ConstantTensor
      buffer = n3
      real = 1
    []

    [mu_n1]
      type = ConstantTensor
      buffer = mu_n1
      real = 1
    []
  []

  [Solve]
    [mu_n2]
      type = ParsedCompute
      buffer = mu_n2
      expression = 'n3'
      inputs = n3
    []
    [mu_n3]
      type = ParsedCompute
      buffer = mu_n3
      expression = 'n3*n3'
      inputs = n3
    []

    [mu_n1_bar]
      type = ForwardFFT
      buffer = mu_n1_bar
      input = mu_n1
    []
    [mu_n2_bar]
      type = ForwardFFT
      buffer = mu_n2_bar
      input = mu_n2
    []
    [mu_n3_bar]
      type = ForwardFFT
      buffer = mu_n3_bar
      input = mu_n3
    []

    [n1_bar]
      type = ForwardFFT
      buffer = n1_bar
      input = n1
    []
    [n2_bar]
      type = ForwardFFT
      buffer = n2_bar
      input = n2
    []
    [n3_bar]
      type = ForwardFFT
      buffer = n3_bar
      input = n3
    []
  []
[]

[TensorSolver]
  # type = SecantSolver
  type = BroydenSolver
  substeps = 1
  max_iterations = 10
  damping = 0.5
  buffer = 'n1 n2 n3'
  tolerance = 1e-5
  dt_epsilon = 1e-5
  reciprocal_buffer = 'n1_bar n2_bar n3_bar'
  linear_reciprocal = 'Lbar   Lbar   Lbar'
  nonlinear_reciprocal = 'mu_n1_bar mu_n2_bar mu_n3_bar'
  verbose = true
[]

[Postprocessors]
  [n1]
    type = TensorAveragePostprocessor
    buffer = n1
    execute_on = 'TIMESTEP_END'
  []
  [n2]
    type = TensorAveragePostprocessor
    buffer = n2
    execute_on = 'TIMESTEP_END'
  []
  [n3]
    type = TensorAveragePostprocessor
    buffer = n3
    execute_on = 'TIMESTEP_END'
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 1
  dt = 1e-2
[]

[Outputs]
  perf_graph = true
  execute_on = 'TIMESTEP_END'
[]

(test/tests/tensor_compute/rotating_grain_secant.i)

w=6

[Domain]
  dim = 2
  nx = 40
  ny = 40
  xmax = ${fparse w*pi*2}
  ymax = ${fparse w*pi*2/sin(pi/3)}
  mesh_mode = DOMAIN
[]

[AuxVariables]
  [phi]
  []
[]

[Outputs]
  exodus = false
[]

[TensorBuffers]
  [psi]
    map_to_aux_variable = phi
  []
  [psibar]
  []
  [psi3]
  []
  [psi3bar]
  []
  # constant tensors
  [linear]
  []
[]

crystal = '-(sin(sin(a)*y/2+cos(a)*x/2)^2 + sin(sin(a+1/3*pi)*y/2+cos(a+1/3*pi)*x/2)^2 + sin(sin(a-1/3*pi)*y/2+cos(a-1/3*pi)*x/2)^2 - 1.5)*0.25'
[Functions]
  [grain1]
    type = ParsedFunction
    expression = 'a := 0; ${crystal}'
  []
  [grain2]
    type = ParsedFunction
    expression = 'a := 0.95; ${crystal}'
  []
  [domain]
    type = ParsedFunction
    expression = 'r := (x-${w}*pi)^2+(y-${w}*pi)^2; if(r<(${w}*2/3*pi)^2, grain2, grain1)'
    symbol_names = 'grain1 grain2'
    symbol_values = 'grain1 grain2'
  []
[]

[TensorComputes]
  [Initialize]
    [psi]
      type = MooseFunctionTensor
      buffer = psi
      function = domain
    []
    [linear]
      type = SwiftHohenbergLinear
      buffer = linear
      alpha = 1
      r = 0.025
    []
  []

  [Solve]
    [psi3]
      type = ParsedCompute
      buffer = psi3
      expression = "0.20*psi^2-psi^3"
      inputs = psi
    []
    [psibar]
      type = ForwardFFT
      buffer = psibar
      input = psi
    []
    [psi3bar]
      type = ForwardFFT
      buffer = psi3bar
      input = psi3
    []
  []
[]

[TensorSolver]
  type = SecantSolver
  buffer = psi
  substeps = 3
  reciprocal_buffer = psibar
  linear_reciprocal = linear
  nonlinear_reciprocal = psi3bar
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 10
  [TimeStepper]
    type = TensorSolveIterationAdaptiveDT
    dt = 1
    max_iterations = 400
    min_iterations = 100
    growth_factor = 1.4
    cutback_factor = 0.9
  []
  dtmax = 500
[]

[TensorOutputs]
  [xdmf]
    type = XDMFTensorOutput
    buffer = 'psi'
    enable_hdf5 = true
    # Do not transpose output to avoid regolding the test. In practice the default
    # of transpose = true should always be used
    transpose = false
  []
[]

Overview
Example Input File Syntax
Input Parameters
Input Files