RandomTensor

min

C++ Type:double

Unit:(no unit assumed)

Controllable:No

Description:Minimum value.

max

C++ Type:double

Unit:(no unit assumed)

Controllable:No

Description:Maximum value.

(examples/lbm/Phase-field/spinodal_decomposition.i)

#
# Spinodal decomposition
# PHYSICAL REVIEW E 97, 033309 (2018) - Section III.C
#

# Domain
Nx = 200
Ny = 200

# Fluid properties
rho_l = 1000.0
rho_g = 1.0
nu_l = 0.1
nu_g = 1.0
sigma = 0.2

# Phase field parameters
tau_h = 0.67
D = 4

[Domain]
  dim = 2
  nx = '${Nx}'
  ny = '${Ny}'
  xmax = '${Nx}'
  ymax = '${Ny}'
  device_names='cpu'
  parallel_mode = REAL_SPACE
  periodic_directions = 'X Y'
[]

[Stencil]
  [d2q9]
    type = LBMD2Q9
  []
[]

[TensorBuffers]
  # Macroscopic phase field variables
  [phi]
    type = LBMTensorBuffer
    buffer_type = ms
  []
  [grad_phi]
    type = LBMTensorBuffer
    buffer_type = mv
  []
  [laplacian_phi]
    type = LBMTensorBuffer
    buffer_type = ms
  []
  [mu]
    type = LBMTensorBuffer
    buffer_type = ms
  []
  [forces]
    type = LBMTensorBuffer
    buffer_type = mv
  []

  # Macroscopic hydrodynamic variables
  [velocity]
    type = LBMTensorBuffer
    buffer_type = mv
  []
  [pressure]
    type = LBMTensorBuffer
    buffer_type = ms
  []
  [rho]
    type = LBMTensorBuffer
    buffer_type = ms
  []

  # LBM phase field variabels
  [h]
    type = LBMTensorBuffer
    buffer_type = df
  []
  [h_post_collision]
    type = LBMTensorBuffer
    buffer_type = df
  []
  [h_eq]
    type = LBMTensorBuffer
    buffer_type = df
  []
  [relaxation_tensor]
    type = LBMTensorBuffer
    buffer_type = ms
  []

  # LBM hydrodynamic variables
  [fdummy]
    type = LBMTensorBuffer
    buffer_type = df
  []
  [f]
    type = LBMTensorBuffer
    buffer_type = df
  []
  [f_post_collision]
    type = LBMTensorBuffer
    buffer_type = df
  []
  [f_eq]
    type = LBMTensorBuffer
    buffer_type = df
  []
[]

[TensorComputes/Initialize]
  [phi_init]
    type = RandomTensor
    buffer = phi
    min = 0.3233
    max = 0.3433
  []
  [grad_phi_init]
    type = LBMIsotropicGradient
    buffer = grad_phi
    scalar_field = phi
  []
  [rho_init]
    type = ParsedCompute
    buffer = rho
    extra_symbols = true
    expression = 'phi*(rho_l - rho_g) + rho_g'
    constant_names = 'rho_l rho_g'
    constant_expressions = '${rho_l} ${rho_g}'
    inputs = phi
  []
  [pressure_init]
    type = LBMConstantTensor
    buffer = pressure
    constants = 0.3
  []
  # Phase field equilibrium distribution initialization
  [h_eq_init]
    type = LBMPhaseEquilibrium
    buffer = h_eq
    phi = phi
    velocity = velocity
  []
  [h_post_collision_init]
    type = LBMPhaseEquilibrium
    buffer = h_post_collision
    phi = phi
    velocity = velocity
  []
  [h_init]
    type = LBMPhaseEquilibrium
    buffer = h
    phi = phi
    velocity = velocity
  []
  # Hydrodynamic equilibrium distribution initialization
  [f_eq_init]
    type = LBMPressureCorrectedEquilibrium
    buffer = f_eq
    rho = rho
    velocity = velocity
    pressure = pressure
  []
  [f_post_collision_init]
    type = ParsedCompute
    buffer = f_post_collision
    expression = 'f_eq'
    inputs = f_eq
  []
  [f_init]
    type = ParsedCompute
    buffer = f
    expression = 'f_eq'
    inputs = f_eq
  []
[]

[TensorComputes/Solve]
  # Phase Field
  [compute_phi]
    type = LBMComputeDensity
    buffer = phi
    f = h
  []
  [grad_phi]
    type = LBMIsotropicGradient
    buffer = grad_phi
    scalar_field = phi
  []
  [laplacian_phi]
    type = LBMIsotropicLaplacian
    buffer = laplacian_phi
    scalar_field = phi
  []
  [potential]
    type = LBMComputeChemicalPotential
    buffer = mu
    phi = phi
    laplacian_phi = laplacian_phi
    thickness = D
    sigma = sigma
  []
  [forces]
    type = LBMComputeSurfaceForces
    buffer = forces
    chemical_potential = mu
    grad_phi = grad_phi
  []
  # Hydrodynamics
  [density]
    type = ParsedCompute
    buffer = rho
    extra_symbols = true
    expression = 'phi*(rho_l - rho_g) + rho_g'
    constant_names = 'rho_l rho_g'
    constant_expressions = '${rho_l} ${rho_g}'
    inputs = phi
  []
  [velocity]
    type = LBMComputeVelocity
    buffer = velocity
    f = f
    rho = rho
    enable_forces = true
    forces = forces
  []
  # Phase-field
  [h_eq]
    type = LBMPhaseEquilibrium
    buffer = h_eq
    phi = phi
    velocity = velocity
  []
  [phase_collision]
    type = LBMBGKCollision
    buffer = h_post_collision
    f = h
    feq = h_eq
    tau0 = tau_h
  []
  [apply_forces_phase]
    type = LBMAllenCahnSource
    buffer = h_post_collision
    phi = phi
    velocity = velocity
    grad_phi = grad_phi
    tau = tau_h
    thickness = D
  []
  # Hydrodynamics
  [relaxation_tensor]
    type = ParsedCompute
    buffer = relaxation_tensor
    extra_symbols = true
    expression = '(phi*(nu_l - nu_g) + nu_g)/cs2+0.5'
    constant_names = 'nu_l nu_g cs2'
    constant_expressions = '${nu_l} ${nu_g} 0.3333'
    inputs = phi
  []
  [pressure]
    type = LBMPhaseFieldPressure
    buffer = pressure
    f = f
    velocity = velocity
    grad_phi = grad_phi
    rho = rho
    rho_l = '${rho_l}'
    rho_g = '${rho_g}'
  []
  [f_eq]
    type = LBMPressureCorrectedEquilibrium
    buffer = f_eq
    rho = rho
    velocity = velocity
    pressure = pressure
  []
  [collision]
    type = LBMBGKCollision
    buffer = f_post_collision
    f = f
    feq = f_eq
    tau0 = 1.0
    is_dynamic_relaxation = true
    tau_tensor = relaxation_tensor
   []
  [apply_forces_hydro]
    type = LBMForceDistribution
    buffer = f_post_collision
    grad_phi = grad_phi
    velocity = velocity
    forces = forces
    tau_tensor = relaxation_tensor
    tau = 1.0
    rho_l = '${rho_l}'
    rho_g = '${rho_g}'
    is_dynamic_relaxation = true
  []
  [residual]
    type = LBMComputeResidual
    buffer = phi
    speed = phi
  []
[]

[TensorSolver]
  type = LBMStream
  buffer = 'h f'
  f_old = 'h_post_collision f_post_collision'
  root_compute = residual
[]

[Problem]
  type = LatticeBoltzmannProblem
  substeps = 500
  print_debug_output = true
  scalar_constant_names = 'tau_h D sigma'
  scalar_constant_values = '${tau_h} ${D} ${sigma}'
  log_interval = 100
[]

[Executioner]
  type = Transient
  num_steps = 100
[]

[TensorOutputs]
  [xdmf]
    type = XDMFTensorOutput
    buffer = 'phi rho velocity'
    output_mode = 'Cell Cell Cell'
    enable_hdf5 = true
    # transpose = false
  []
[]

(test/tests/cahnhilliard/cahnhilliard_explicit_smooth.i)

#
# Simple Cahn-Hilliard solve on a 2D grid. We create a matching (conforming)
# MOOSE mesh (with one element per FFT grid cell) and project the solution onto
# the MOOSE mesh to utilize the exodus output object.
#

[Domain]
  dim = 2
  nx = 50
  ny = 50
  xmax = 3
  ymax = 3
  mesh_mode = DOMAIN
  device_names = cpu
[]

[TensorBuffers]
  [c]
    map_to_aux_variable = c
  []
  [cbar]
  []
  [mu]
    map_to_aux_variable = mu
  []
[]

[TensorComputes]
  [Initialize]
    [c]
      # Random initial condition around a concentration of 1/2
      type = RandomTensor
      buffer = c
      min = 0.44
      max = 0.56
      seed = 0
    []
    [mu_init]
      type = ConstantTensor
      buffer = mu
    []

    # precompute fixed factors for the solve
    [Mbar]
      type = ReciprocalLaplacianFactor
      factor = 0.2 # Mobility
      buffer = Mbar
    []
    [Mkappabarbar]
      type = ReciprocalLaplacianSquareFactor
      factor = '${fparse 0.2 * 1e-4}' # M * kappa
      buffer = Mkappabarbar
    []
    [dc_dt_bar_IC]
      type = ConstantReciprocalTensor
      buffer = dc_dt_bar
    []

    [smooth]
      type = DeAliasingTensor
      buffer = smooth
    []
  []

  [Solve]
    [cahn_hilliard]
      [mu]
        type = ParsedCompute
        buffer = mu
        expression = '0.1*c^2*(c-1)^2'
        derivatives = c
        inputs = c
      []
      [mubar]
        type = ForwardFFT
        buffer = mubar
        input = mu
      []
      [dc_dt_bar]
        type = ParsedCompute
        buffer = dc_dt_bar
        expression = 'smooth * (Mbar*mubar - Mkappabarbar*cbar)'
        # expression = '(Mbar*mubar - Mkappabarbar*cbar)'
        inputs = 'Mbar mubar Mkappabarbar cbar smooth'
      []
      [cbar]
        type = ForwardFFT
        buffer = cbar
        input = c
      []
    []
  []
[]

[TensorSolver]
  type = ForwardEulerSolver
  time_derivative_reciprocal = dc_dt_bar
  root_compute = cahn_hilliard
  buffer = c
  reciprocal_buffer = cbar
  substeps = 50
[]

[AuxVariables]
  [mu]
    # the mu tensor  is projected onto this elemental variable
    family = MONOMIAL
    order = CONSTANT
  []
  [c]
    # the c tensor is projected onto this nodal variable
  []
[]

[Postprocessors]
  [C]
    type = TensorIntegralPostprocessor
    buffer = c
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 20
  dt = 0.5
[]

[Outputs]
  exodus = true
  csv = true
[]

(test/tests/cahnhilliard/cahnhilliard.i)

#
# Simple Cahn-Hilliard solve on a 2D grid. We create a matching (conforming)
# MOOSE mesh (with one element per FFT grid cell) and project the solution onto
# the MOOSE mesh to utilize the exodus output object.
#

[Domain]
  dim = 2
  nx = 20
  ny = 20
  xmax = 3
  ymax = 3
  mesh_mode = DOMAIN
[]

# In this input we fully trely on implicit TensorBuffer declaration

[TensorComputes]
  [Initialize]
    [c]
      # Random initial condition around a concentration of 1/2
      type = RandomTensor
      buffer = c
      min = 0.44
      max = 0.56
      seed = 0
    []
    [mu_init]
      type = ConstantTensor
      buffer = mu
    []

    # precompute fixed factors for the solve
    [Mbar]
      type = ReciprocalLaplacianFactor
      factor = 0.2 # Mobility
      buffer = Mbar
    []
    [kappabarbar]
      type = ReciprocalLaplacianSquareFactor
      factor = -0.001 # kappa
      buffer = kappabarbar
    []
  []

  [Solve]
    [cahn_hilliard]
      [mu]
        type = ParsedCompute
        buffer = mu
        expression = '0.1*c^2*(c-1)^2'
        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
      []
    []
  []
[]

[TensorSolver]
  type = AdamsBashforthMoulton
  root_compute = cahn_hilliard
  buffer = c
  reciprocal_buffer = cbar
  linear_reciprocal = kappabarbar
  nonlinear_reciprocal = Mbarmubar
  substeps = 10
[]

[AuxVariables]
  [mu]
    # the mu tensor  is projected onto this elemental variable
    family = MONOMIAL
    order = CONSTANT
  []
  [c]
    # the c tensor is projected onto this nodal variable
  []
[]

[AuxKernels]
  active = ''
  [c]
    type = ProjectTensorAux
    buffer = c
    variable = c
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [mu]
    type = ProjectTensorAux
    buffer = mu
    variable = mu
    execute_on = 'INITIAL TIMESTEP_END'
  []
[]

[Postprocessors]
  [min_c]
    type = SemiImplicitCriticalTimeStep
    buffer = kappabarbar
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [delta_int_c]
    type = TensorIntegralChangePostprocessor
    buffer = c
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 10
  dt = 1e-3
[]

[TensorOutputs]
  active = ''
  [xdmf]
    type = XDMFTensorOutput
    buffer = 'c mu'
    output_mode = 'Node Cell'
    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
  []

  [xdmf2]
    # second output to trigger the hdf5 thread safety error
    type = XDMFTensorOutput
    buffer = 'c'
    output_mode = 'Cell'
    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
  []
[]

[Outputs]
  exodus = true
  csv = true
[]

(examples/cahn_hilliard/cahnhilliard4.i)

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

  device_names = 'cuda'

  mesh_mode = DUMMY
  debug = true
[]

[TensorBuffers]
  [c]
  []
  [cbar]
  []
  [mu]
  []
  [mubar]
  []
  [Mbarmubar]
  []
  # constant tensors
  [Mbar]
  []
  [kappabarbar]
  []
[]

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

[TensorComputes]
  [Initialize]
    [c]
      type = RandomTensor
      buffer = c
      min = 0.44
      max = 0.56
    []
    [Mbar]
      type = ReciprocalLaplacianFactor
      factor = 0.2 # Mobility
      buffer = Mbar
    []
    [kappabarbar]
      type = ReciprocalLaplacianSquareFactor
      factor = -0.001 # kappa
      buffer = kappabarbar
    []
  []

  [Solve]
    [mu]
      type = ParsedCompute
      buffer = mu
      expression = '0.1*c^2*(c-1)^2 + c*sin(x/2)*0.005'
      extra_symbols = true
      derivatives = c
      # expression = "0.4*c^3-0.6*c^2+0.2*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
    []
  []
[]

[TensorTimeIntegrators]
  [c]
    type = FFTSemiImplicit
    buffer = c
    reciprocal_buffer = cbar
    linear_reciprocal = kappabarbar
    nonlinear_reciprocal = Mbarmubar
  []
[]

[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'
  []
  [C]
    type = TensorIntegralPostprocessor
    buffer = c
    execute_on = 'TIMESTEP_END'
  []
  [cavg]
    type = TensorAveragePostprocessor
    buffer = c
    execute_on = 'TIMESTEP_END'
  []
[]

[Problem]
  type = TensorProblem
  spectral_solve_substeps = 1000
[]

[Executioner]
  type = Transient
  num_steps = 50
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.8
    dt = 0.1
  []
  dtmax = 500
[]

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

(examples/cahn_hilliard/cahnhilliard.i)

#
# Simple Cahn-Hilliard solve on a 2D grid. We create a matching (conforming)
# MOOSE mesh (with one element per FFT grid cell) and project the solution onto
# the MOOSE mesh to utilize the exodus output object.
#

[Domain]
  dim = 2
  nx = 200
  ny = 200

  xmax = ${fparse pi*8}
  ymax = ${fparse pi*8}

  # automatically create a matching mesh
  mesh_mode = DOMAIN
[]


[TensorBuffers]
  [c]
    # perform fast mapping to the matching mesh by directly writing to
    # the solution vector of the specified Auxvariable
    map_to_aux_variable = c
  []
  [cbar]
  []
  [mu]
    map_to_aux_variable = mu
  []
  [mubar]
  []
  [Mbarmubar]
  []
  # constant tensors
  [Mbar]
  []
  [kappabarbar]
  []
[]

[TensorComputes]
  [Initialize]
    [c]
      # Random initial condition around a concentration of 1/2
      type = RandomTensor
      buffer = c
      min = 0.44
      max = 0.56
    []

    # precompute fixed factors for the solve
    [Mbar]
      type = ReciprocalLaplacianFactor
      factor = 0.2 # Mobility
      buffer = Mbar
    []
    [kappabarbar]
      type = ReciprocalLaplacianSquareFactor
      factor = -0.001 # kappa
      buffer = kappabarbar
    []
    [mu_init]
      type = ConstantTensor
      buffer = mu
      real = 0
    []
  []

  [Solve]
    [cahn_hilliard]
      [mu]
        type = ParsedCompute
        buffer = mu
        expression = '0.1*c^2*(c-1)^2'
        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
      []
    []
  []
[]

[TensorSolver]
  type = AdamsBashforthMoulton
  root_compute = cahn_hilliard
  buffer = c
  reciprocal_buffer = cbar
  linear_reciprocal = kappabarbar
  nonlinear_reciprocal = Mbarmubar
  substeps = 1000
[]

[AuxVariables]
  [mu]
    # the mu tensor  is projected onto this elemental variable
    family = MONOMIAL
    order = CONSTANT
  []
  [c]
    # the c tensor is projected onto this nodal variable
  []
[]

# a slower but more flexible alternative to `map_to_aux_variable` is running
# these `ProjectTensorAux` AuxKernels to perform the projection. This aprpoach
# also supports non-conforming meshes.
[AuxKernels]
  # [c]
  #   type = ProjectTensorAux
  #   buffer = c
  #   variable = c
  #   execute_on = final
  # []
  # [f]
  #   type = ProjectTensorAux
  #   buffer = f
  #   variable = f
  #   execute_on = TIMESTEP_END
  # []
[]

[Postprocessors]
  [min_c]
    type = ElementExtremeValue
    variable = c
    value_type = MIN
    execute_on = 'TIMESTEP_END'
  []
  [max_c]
    type = ElementExtremeValue
    variable = c
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []
  # [F]
  #   type = ElementIntegralVariablePostprocessor
  #   variable = f
  #   execute_on = 'TIMESTEP_END'
  # []
  [C]
    type = ElementIntegralVariablePostprocessor
    variable = c
    execute_on = 'TIMESTEP_END'
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 100
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.8
    dt = 0.1
  []
  dtmax = 1000
[]

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

(test/tests/cahnhilliard/cahnhilliard_explicit.i)

#
# Simple Cahn-Hilliard solve on a 2D grid. We create a matching (conforming)
# MOOSE mesh (with one element per FFT grid cell) and project the solution onto
# the MOOSE mesh to utilize the exodus output object.
#

[Domain]
  dim = 2
  nx = 50
  ny = 50
  xmax = 3
  ymax = 3
  mesh_mode = DOMAIN
  device_names = cpu
[]

[TensorBuffers]
  [c]
    map_to_aux_variable = c
  []
  [cbar]
  []
  [mu]
    map_to_aux_variable = mu
  []
  [mubar]
  []
  [dc_dt_bar]
  []
  # constant tensors
  [Mbar]
  []
  [Mkappabarbar]
  []
[]

[TensorComputes]
  [Initialize]
    [c]
      # Random initial condition around a concentration of 1/2
      type = RandomTensor
      buffer = c
      min = 0.44
      max = 0.56
      seed = 0
    []
    [mu_init]
      type = ConstantTensor
      buffer = mu
    []

    # precompute fixed factors for the solve
    [Mbar]
      type = ReciprocalLaplacianFactor
      factor = 0.2 # Mobility
      buffer = Mbar
    []
    [Mkappabarbar]
      type = ReciprocalLaplacianSquareFactor
      factor = '${fparse 0.2 * 1e-4}' # M * kappa
      buffer = Mkappabarbar
    []
    [dc_dt_bar_IC]
      type = ConstantReciprocalTensor
      buffer = dc_dt_bar
    []
  []

  [Solve]
    [cahn_hilliard]
      [mu]
        type = ParsedCompute
        buffer = mu
        expression = '0.1*c^2*(c-1)^2'
        derivatives = c
        inputs = c
      []
      [mubar]
        type = ForwardFFT
        buffer = mubar
        input = mu
      []
      [dc_dt_bar]
        type = ParsedCompute
        buffer = dc_dt_bar
        expression = 'Mbar*mubar - Mkappabarbar*cbar'
        inputs = 'Mbar mubar Mkappabarbar cbar'
      []
      [cbar]
        type = ForwardFFT
        buffer = cbar
        input = c
      []
    []
  []
[]

[TensorSolver]
  type = ForwardEulerSolver
  time_derivative_reciprocal = dc_dt_bar
  root_compute = cahn_hilliard
  buffer = c
  reciprocal_buffer = cbar
  substeps = 50
[]

[AuxVariables]
  [mu]
    # the mu tensor  is projected onto this elemental variable
    family = MONOMIAL
    order = CONSTANT
  []
  [c]
    # the c tensor is projected onto this nodal variable
  []
[]

[Problem]
  type = TensorProblem
[]

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

[Outputs]
  exodus = true
  csv = true
[]

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

(examples/swift_hohenberg/swifthohenberg.i)

#
# Solve a simple Swift-Hohenberg crystal phase field problem. The initial condition is
# a random melt, which crystalizes out.
#

[Domain]
  dim = 2
  nx = 400
  ny = 400
  xmax = ${fparse pi*2*30}
  ymax = ${fparse pi*2*30}

  device_names = 'cuda'

  mesh_mode = DOMAIN
[]

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

  # output
  [filter]
    map_to_aux_variable = filter
  []
  [filterbar]
  []
[]

[AuxVariables]
  [psi]
  []
  [filter]
  []
[]

[TensorComputes]
  [Initialize]
    [psi]
      type = RandomTensor
      buffer = psi
      min = 0
      max = 0.07
    []
    [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
    []
  []

  [Postprocess]
    [low_pass]
      type = ParsedCompute
      buffer = filterbar
      extra_symbols = true
      expression = 'psibar * exp(-k2*10)'
      inputs = psibar
    []
    [filter]
      type = InverseFFT
      buffer = filter
      input = filterbar
    []
  []
[]

[TensorTimeIntegrators]
  [c]
    type = FFTSemiImplicit
    buffer = psi
    reciprocal_buffer = psibar
    linear_reciprocal = linear
    nonlinear_reciprocal = psi3bar
  []
[]

[Problem]
  type = TensorProblem
  spectral_solve_substeps = 1000
[]

[Executioner]
  type = Transient
  num_steps = 300
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.2
    dt = 10
  []
  dtmax = 1000
[]

[Postprocessors]
  [min_psi]
    type = TensorExtremeValuePostprocessor
    buffer = psi
    value_type = MIN
    execute_on = 'TIMESTEP_END'
  []
  [max_psi]
    type = TensorExtremeValuePostprocessor
    buffer = psi
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []
  [Psi]
    type = TensorIntegralPostprocessor
    buffer = psi
  []
[]

[TensorOutputs]
  [xdmf]
    type = XDMFTensorOutput
    buffer = 'psi'
    output_mode = 'Node'
    enable_hdf5 = true
  []
[]

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

(examples/cahn_hilliard/cahnhilliard2.i)

#
# The same simple Cahn-Hilliard solve as cahnhilliard.i, but on a 3D grid
# and using the faster TensorOutputs system.
#

[Domain]
  dim = 3
  nx = 200
  ny = 200
  nz = 200
  xmax = ${fparse pi*8}
  ymax = ${fparse pi*8}
  zmax = ${fparse pi*8}

  # run on a CUDA device (adjust this to `cpu` if not available)
  device_names = 'cuda'

  # create a single element dummy mesh. Output will use the custom XDMF output
  # in the `TensorOutputs` system.
  mesh_mode = DUMMY
[]

[TensorBuffers]
  [c]
  []
  [cbar]
  []
  [mu]
  []
  [mubar]
  []
  [Mbarmubar]
  []
  # constant tensors
  [Mbar]
  []
  [kappabarbar]
  []
[]

[TensorOutputs]
  # the TensorOutouts system supports asynchronous threaded output.
  # for GOU calculations a copy of the solution fields is moved to the CPU,
  # and while the output files are written the next time step is already
  # starting to compute.
  [xdmf]
    type = XDMFTensorOutput
    buffer = 'c mu'
    enable_hdf5 = true
  []
[]

[TensorComputes]
  [Initialize]
    [c]
      type = RandomTensor
      buffer = c
      min = 0.44
      max = 0.56
    []
    [Mbar]
      type = ReciprocalLaplacianFactor
      factor = 0.2 # Mobility
      buffer = Mbar
    []
    [kappabarbar]
      type = ReciprocalLaplacianSquareFactor
      factor = -0.001 # kappa
      buffer = kappabarbar
    []
  []

  [Solve]
    [mu]
      type = ParsedCompute
      buffer = mu
      expression = '0.1*c^2*(c-1)^2'
      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
    []
  []
[]

[TensorSolver]
  type = AdamsBashforthMoulton
  buffer = c
  reciprocal_buffer = cbar
  linear_reciprocal = kappabarbar
  nonlinear_reciprocal = Mbarmubar
  substeps = 1000
[]

[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'
  []
  [C]
    type = TensorIntegralPostprocessor
    buffer = c
    execute_on = 'TIMESTEP_END'
  []
  [cavg]
    type = TensorAveragePostprocessor
    buffer = c
    execute_on = 'TIMESTEP_END'
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 100
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.8
    dt = 0.1
  []
  dtmax = 1000
[]

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

(test/tests/tensor_compute/group.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
    []
    [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
    []

    [group]
      type = ComputeGroup
      computes = 'cbar mumech mu mubar'
    []
  []
[]

[TensorSolver]
  type = AdamsBashforthMoulton
  buffer = c
  reciprocal_buffer = cbar
  linear_reciprocal = kappabarbar
  nonlinear_reciprocal = Mbarmubar
[]

[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
  spectral_solve_substeps = 1000
  print_debug_output = true
[]

[Executioner]
  type = Transient
  num_steps = 100
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.8
    dt = 0.1
  []
  dtmax = 1000
[]

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

(test/tests/tensor_compute/parallel.i)

[Domain]
  device_names = "cuda:1 cuda:0 cpu"
  device_weights = "10 10 1"

  parallel_mode = FFT_SLAB

  dim = 2
  nx = 400
  ny = 400
  xmax = ${fparse pi*2*30}
  ymax = ${fparse pi*2*30}
[]


# [Mesh]
#   type = GeneratedMesh
#   dim =1
# []


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

  # output
  [filter]
    # map_to_aux_variable = filter
  []
  [filterbar]
  []
[]

[AuxVariables]
  [psi]
  []
  [filter]
  []
[]

[TensorComputes]
  [Initialize]
    [psi]
      type = RandomTensor
      buffer = psi
      min = 0
      max = 0.07
    []
    [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
    []
  []

  [Postprocess]
    [low_pass]
      type = ParsedCompute
      buffer = filterbar
      extra_symbols = true
      expression = 'psibar * exp(-k2*10)'
      inputs = psibar
    []
    [filter]
      type = InverseFFT
      buffer = filter
      input = filterbar
    []
  []
[]

[TensorTimeIntegrators]
  [c]
    type = FFTSemiImplicit
    buffer = psi
    reciprocal_buffer = psibar
    linear_reciprocal = linear
    nonlinear_reciprocal = psi3bar
  []
[]

[Problem]
  type = TensorProblem
  spectral_solve_substeps = 1000
[]

[Executioner]
  type = Transient
  num_steps = 300
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.2
    dt = 10
  []
  dtmax = 1000
[]

[Postprocessors]
  [min_psi]
    type = TensorExtremeValuePostprocessor
    buffer = psi
    value_type = MIN
    execute_on = 'TIMESTEP_END'
  []
  [max_psi]
    type = TensorExtremeValuePostprocessor
    buffer = psi
    value_type = MAX
    execute_on = 'TIMESTEP_END'
  []
  [Psi]
    type = TensorIntegralPostprocessor
    buffer = psi
  []
[]

# [TensorOutputs]
#   [xdmf]
#     type = XDMFTensorOutput
#     buffer = 'psi'
#     output_mode = 'Node'
#     enable_hdf5 = true
#   []
# []

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

(test/tests/tensor_compute/coupled_pf_mech.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
    []
    [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
    []
  []
[]

[TensorTimeIntegrators]
  [c]
    type = FFTSemiImplicit
    buffer = c
    reciprocal_buffer = cbar
    linear_reciprocal = kappabarbar
    nonlinear_reciprocal = Mbarmubar
  []
[]

[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
  spectral_solve_substeps = 1000
  print_debug_output = true
[]

[Executioner]
  type = Transient
  num_steps = 100
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.8
    dt = 0.1
  []
  dtmax = 1000
[]

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

(examples/cahn_hilliard/cahnhilliard3.i)

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

  device_names = 'cuda'

  mesh_mode = DUMMY
[]

[TensorBuffers]
  [c]
  []
  [cbar]
  []
  [mu]
  []
  [mubar]
  []
  [Mbarmubar]
  []
  # constant tensors
  [Mbar]
  []
  [kappabarbar]
  []
[]

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

[TensorComputes]
  [Initialize]
    [c]
      type = RandomTensor
      buffer = c
      min = 0.44
      max = 0.56
    []
    [Mbar]
      type = ReciprocalLaplacianFactor
      factor = 0.2 # Mobility
      buffer = Mbar
    []
    [kappabarbar]
      type = ReciprocalLaplacianSquareFactor
      factor = -0.001 # kappa
      buffer = kappabarbar
    []
  []

  [Solve]
    [mu]
      type = ParsedCompute
      buffer = mu
      expression = '0.1*c^2*(c-1)^2'
      derivatives = c
      # expression = "0.4*c^3-0.6*c^2+0.2*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
    []
  []
[]

[TensorTimeIntegrators]
  [c]
    type = FFTSemiImplicit
    buffer = c
    reciprocal_buffer = cbar
    linear_reciprocal = kappabarbar
    nonlinear_reciprocal = Mbarmubar
  []
[]

[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'
  []
  [C]
    type = TensorIntegralPostprocessor
    buffer = c
    execute_on = 'TIMESTEP_END'
  []
  [cavg]
    type = TensorAveragePostprocessor
    buffer = c
    execute_on = 'TIMESTEP_END'
  []
[]

[Problem]
  type = TensorProblem
  spectral_solve_substeps = 1000
[]

[Executioner]
  type = Transient
  num_steps = 20
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.8
    dt = 0.1
  []
  dtmax = 1000
[]

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

(examples/phase_field_crystal/pfc_fcc_atomic_structure_3d.i)

# 3D FCC PFC test showing atomic-scale density fluctuations
# Based on PhysRevE.81.061601 two-mode FCC PFC model

# Grid parameters - 3D resolution
N = 64  # Grid points per dimension (64^3 = 262k points)

# PFC model parameters - LARGER epsilon for clearer atomic structure
psi_mean = -0.2         # Mean density
epsilon = 0.15          # Larger undercooling for stronger modulations
R1_param = 0.0          # Two-mode coupling (0 for max FCC stability)
Q1_param = ${fparse sqrt(4.0/3.0)}  # FCC wave number ratio

# Domain size: want several unit cells
# The (111) wavelength is 2*pi/q0 = 2*pi*sqrt(3/4) ≈ 5.44 (dimensionless)
# Fit 8 wavelengths in each direction
Lx = ${fparse 8 * 2 * ${pi} / ${Q1_param}}
Ly = ${Lx}
Lz = ${Lx}

[Domain]
    dim = 3
    nx = ${N}
    ny = ${N}
    nz = ${N}
    xmax = ${Lx}
    ymax = ${Ly}
    zmax = ${Lz}
[]

[TensorComputes]
    [Initialize]
        # Random perturbations to seed crystal growth
        [psi]
            type = RandomTensor
            buffer = psi
            max = ${fparse ${psi_mean} + 0.01}
            min = ${fparse ${psi_mean} - 0.01}
            seed = 12345
        []

        # Linear operator for FCC
        [linear]
            type = FCCPFCLinear
            buffer = 'linear'
            eps = ${epsilon}
            R1 = ${R1_param}
            Q1 = ${Q1_param}
            mobility = 1.0
        []

        # Dealiasing for cubic nonlinearity
        [smooth_operator]
            type = DeAliasingTensor
            buffer = smooth_operator
            method = HOULI
        []
    []

    [Solve]
        # Nonlinear term
        [nl_div_psi_cubed]
            type = FCCPFCNonlinear
            buffer = NL
            psi = psi
            dealiasing = smooth_operator
            mobility = 1.0
        []

        # FFT for spectral solver
        [psi_hat]
            type = ForwardFFT
            buffer = psi_hat
            input = psi
        []
    []
[]

[TensorSolver]
    type = AdamsBashforthMoulton
    buffer = 'psi'
    linear_reciprocal = 'linear'
    nonlinear_reciprocal = 'NL'
    reciprocal_buffer = 'psi_hat'
    corrector_order = 1
    corrector_steps = 3
    predictor_order = 1
    substeps = 10000
[]

[Postprocessors]
    [max_psi]
        type = TensorExtremeValuePostprocessor
        buffer = psi
        value_type = MAX
        execute_on = 'initial timestep_end'
    []
    [min_psi]
        type = TensorExtremeValuePostprocessor
        buffer = psi
        value_type = MIN
        execute_on = 'initial timestep_end'
    []
    [mean_psi]
        type = TensorAveragePostprocessor
        buffer = psi
        execute_on = 'initial timestep_end'
    []
[]

[TensorOutputs]
    [xdmf]
        type = XDMFTensorOutput
        buffer = 'psi'
        enable_hdf5 = true
    []
[]

[Executioner]
    type = Transient
    num_steps = 200  # Reduced for 3D (much more expensive)
    dt = 5
[]

[Outputs]
    perf_graph = true
    csv = true
[]

(examples/phase_field_crystal/pfc_fcc_atomic_structure.i)

# FCC PFC test designed to clearly show atomic-scale density fluctuations
# Using larger epsilon for stronger density modulations
# Based on PhysRevE.81.061601 two-mode FCC PFC model

# Grid parameters - fine resolution to resolve atomic peaks
N = 4  # Grid points per dimension

# PFC model parameters - LARGER epsilon for clearer atomic structure
psi_mean = -0.2         # Mean density
epsilon = 0.15          # Larger undercooling for stronger modulations
R1_param = 0.0          # Two-mode coupling (0 for max FCC stability)
Q1_param = ${fparse sqrt(4.0/3.0)}  # FCC wave number ratio

# Domain size: want several unit cells but fine enough resolution
# The (111) wavelength is 2*pi/q0 = 2*pi*sqrt(3/4) ≈ 5.44 (dimensionless)
# Let's fit about 'N' wavelengths in each direction
Lx = ${fparse N * 2 * pi / ${Q1_param}}
Ly = ${Lx}

[Domain]
    dim = 2
    nx = ${fparse ${N} * 8 }
    ny = ${fparse ${N} * 8 }
    xmax = ${Lx}
    ymax = ${Ly}
[]

[TensorComputes]
    [Initialize]
        # Random perturbations to seed crystal growth
        [psi]
            type = RandomTensor
            buffer = psi
            max = ${fparse ${psi_mean} + 0.01}
            min = ${fparse ${psi_mean} - 0.01}
            seed = 12345
        []

        # Linear operator for FCC
        [linear]
            type = FCCPFCLinear
            buffer = 'linear'
            eps = ${epsilon}
            R1 = ${R1_param}
            Q1 = ${Q1_param}
            mobility = 1.0
        []

        # Dealiasing for cubic nonlinearity
        [smooth_operator]
            type = DeAliasingTensor
            buffer = smooth_operator
            method = HOULI
        []
    []

    [Solve]
        # Nonlinear term
        [nl_div_psi_cubed]
            type = FCCPFCNonlinear
            buffer = NL
            psi = psi
            dealiasing = smooth_operator
            mobility = 1.0
        []

        # FFT for spectral solver
        [psi_hat]
            type = ForwardFFT
            buffer = psi_hat
            input = psi
        []
    []
[]

[TensorSolver]
    type = AdamsBashforthMoulton
    buffer = 'psi'
    linear_reciprocal = 'linear'
    nonlinear_reciprocal = 'NL'
    reciprocal_buffer = 'psi_hat'
    corrector_order = 1
    corrector_steps = 3
    predictor_order = 1
    substeps = 10000
[]

[Postprocessors]
    [max_psi]
        type = TensorExtremeValuePostprocessor
        buffer = psi
        value_type = MAX
        execute_on = 'initial timestep_end'
    []
    [min_psi]
        type = TensorExtremeValuePostprocessor
        buffer = psi
        value_type = MIN
        execute_on = 'initial timestep_end'
    []
    [mean_psi]
        type = TensorAveragePostprocessor
        buffer = psi
        execute_on = 'initial timestep_end'
    []
[]

[TensorOutputs]
    [xdmf]
        type = XDMFTensorOutput
        buffer = 'psi'
        enable_hdf5 = true
    []
[]

[Executioner]
    type = Transient
    num_steps = 1000
    dt = 20  # Larger timestep for faster evolution
[]

[Outputs]
    perf_graph = true
    csv = true
[]

(test/tests/tensor_compute/pfc_fcc.i)

# FCC PFC test designed to clearly show atomic-scale density fluctuations
# Using larger epsilon for stronger density modulations
# Based on PhysRevE.81.061601 two-mode FCC PFC model

# Grid parameters - fine resolution to resolve atomic peaks
N = 1  # Grid points per dimension

# PFC model parameters - LARGER epsilon for clearer atomic structure
psi_mean = -0.2         # Mean density
epsilon = 0.15          # Larger undercooling for stronger modulations
R1_param = 0.0          # Two-mode coupling (0 for max FCC stability)
Q1_param = ${fparse sqrt(4.0/3.0)}  # FCC wave number ratio

# Domain size: want several unit cells but fine enough resolution
# The (111) wavelength is 2*pi/q0 = 2*pi*sqrt(3/4) ≈ 5.44 (dimensionless)
# Let's fit about 'N' wavelengths in each direction
Lx = ${fparse N * 2 * pi / ${Q1_param}}
Ly = ${Lx}

[Domain]
    dim = 2
    nx = ${fparse ${N} * 8 }
    ny = ${fparse ${N} * 8 }
    xmax = ${Lx}
    ymax = ${Ly}
[]

[TensorComputes]
    [Initialize]
        # Random perturbations to seed crystal growth
        [psi]
            type = RandomTensor
            buffer = psi
            max = ${fparse ${psi_mean} + 0.01}
            min = ${fparse ${psi_mean} - 0.01}
            seed = 12345
        []

        # Linear operator for FCC
        [linear]
            type = FCCPFCLinear
            buffer = 'linear'
            eps = ${epsilon}
            R1 = ${R1_param}
            Q1 = ${Q1_param}
            mobility = 1.0
        []

        # Dealiasing for cubic nonlinearity
        [smooth_operator]
            type = DeAliasingTensor
            buffer = smooth_operator
            method = HOULI
        []
    []

    [Solve]
        # Nonlinear term
        [nl_div_psi_cubed]
            type = FCCPFCNonlinear
            buffer = NL
            psi = psi
            dealiasing = smooth_operator
            mobility = 1.0
        []

        # FFT for spectral solver
        [psi_hat]
            type = ForwardFFT
            buffer = psi_hat
            input = psi
        []
    []
[]

[TensorSolver]
    type = AdamsBashforthMoulton
    buffer = 'psi'
    linear_reciprocal = 'linear'
    nonlinear_reciprocal = 'NL'
    reciprocal_buffer = 'psi_hat'
    corrector_order = 1
    corrector_steps = 3
    predictor_order = 1
    substeps = 1000
[]

[Postprocessors]
    [max_psi]
        type = TensorExtremeValuePostprocessor
        buffer = psi
        value_type = MAX
        execute_on = 'initial timestep_end'
    []
    [min_psi]
        type = TensorExtremeValuePostprocessor
        buffer = psi
        value_type = MIN
        execute_on = 'initial timestep_end'
    []
    [mean_psi]
        type = TensorAveragePostprocessor
        buffer = psi
        execute_on = 'initial timestep_end'
    []
[]

[TensorOutputs]
    [xdmf]
        type = XDMFTensorOutput
        buffer = 'psi'
        enable_hdf5 = true
    []
[]

[Executioner]
    type = Transient
    num_steps = 100
    dt = 0.2  # Larger timestep for faster evolution
[]

[Outputs]
    perf_graph = true
    csv = true
[]