ForwardEulerSolver

construction:Undocumented Class

The ForwardEulerSolver 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.

Semi-implicit time integration solver.

Overview

Performs explicit time integration using the Forward-Euler method.

Example Input File Syntax

[TensorSolver<<<{"href": "../../syntax/TensorSolver/index.html"}>>>]
  type = AdamsBashforthMoulton
  buffer = c
  substeps = 1000
  history_size = 1
  reciprocal_buffer = cbar
  linear_reciprocal = kappabarbar
  nonlinear_reciprocal = Mbarmubar
[]

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
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.
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
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.
substeps1Solver substeps per time step.
Default:1
C++ Type:unsigned int
Controllable:No
Description:Solver substeps per time step.
time_derivative_reciprocalBuffer with the reciprocal of the time derivative function
C++ Type:std::vector<std::string>
Controllable:No
Description:Buffer with the reciprocal of the time derivative function

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

(test/tests/cahnhilliard/cahnhilliard_explicit_smooth.i)
(test/tests/cahnhilliard/cahnhilliard_explicit.i)
(test/tests/postprocessors/postprocessors.i)
(examples/degeus_mechanics/mech.i)
(test/tests/mechanics/mech.i)
(test/tests/mechanics/mech3d.i)

(benchmarks/01_spinodal_decomposition/1a_solver.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]
    # map_to_aux_variable = 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'
    []
  []
[]

[UserObjects]
  [terminator]
    type = Terminator
    expression = change<1e-4
  []
[]

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

[AuxVariables]
  # [mu]
  #   family = MONOMIAL
  #   order = CONSTANT
  # []
  [c]
    # family = MONOMIAL
    # order = CONSTANT
  []
[]

[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
  []
  [change]
    type = TensorIntegralChangePostprocessor
    buffer = c
  []
[]

[Problem]
  type = TensorProblem
  spectral_solve_substeps = 1000
[]

[Executioner]
  type = Transient
  num_steps = 1000
  [TimeStepper]
    type = IterationAdaptiveDT
    growth_factor = 1.1
    dt = 1
  []
  dtmax = 300
[]

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

(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_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/postprocessors/postprocessors.i)

[Domain]
  dim = 2
  nx = 40
  ny = 40
  xmax = 2
  ymax = 3
  mesh_mode = DUMMY
[]

[TensorBuffers]
  [c]
  []
  [c_bar]
  []
[]

[TensorComputes]
  [Initialize]
    [c]
      type = ParsedCompute
      buffer = c
      extra_symbols = true
      expression = -x+y+0.3
    []
    [c_bar]
      type = ForwardFFT
      buffer = c_bar
      input = c
    []
    [u]
      type = ConstantTensor
      buffer = u
      real = 0
    []
  []

  [Solve]
    [root]
      [test]
        type = ForwardFFT
        buffer = u_bar
        input = u
      []
    []
  []
[]

[TensorSolver]
  type = ForwardEulerSolver
  time_derivative_reciprocal = c_bar
  buffer = u
  reciprocal_buffer = u_bar
  substeps = 10
[]

[Postprocessors]
  [min_c]
    type = TensorExtremeValuePostprocessor
    buffer = c
    value_type = MIN
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [max_c]
    type = TensorExtremeValuePostprocessor
    buffer = c
    value_type = MAX
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [avg_c]
    type = TensorAveragePostprocessor
    buffer = c
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [int_c]
    type = TensorIntegralPostprocessor
    buffer = c
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [int_c_bar]
    type = ReciprocalIntegral
    buffer = c_bar
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [count]
    type = ComputeGroupExecutionCount
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 0
[]

[Outputs]
  csv = true
[]

(examples/degeus_mechanics/mech.i)

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

[TensorComputes]
  [Initialize]
    [Finit]
      type = RankTwoIdentity
      buffer = F
    []

    [phase]
      type = PhaseMechanicsTest
      buffer = phase
    []
    [K]
      type = ParsedCompute
      buffer = K
      expression = '(1-phase)*Ka + phase*Kb'
      inputs = phase
      constant_names = 'Ka Kb'
      constant_expressions = '0.833 8.33'
    []
    [mu]
      type = ParsedCompute
      buffer = mu
      expression = '(1-phase)*mua + phase*mub'
      inputs = phase
      constant_names = 'mua mub'
      constant_expressions = '0.386 3.86'
    []
  []

  [Solve]
    [hyper_elasticity]
      type = HyperElasticIsotropic
      buffer = stress
      F = Fnew
      K = K
      mu = mu
    []

    [root]
      [applied_strain]
        type = MacroscopicShearTensor
        buffer = applied_strain
      []
      [mech]
        type = FFTMechanics
        buffer = Fnew
        F = F
        K = K
        mu = mu
        l_tol = 1e-2
        nl_rel_tol = 2e-2
        nl_abs_tol = 2e-2
        constitutive_model = hyper_elasticity
        stress = stress
        applied_macroscopic_strain = applied_strain
      []
    []
  []

  [Postprocess]
    [displacements]
      type = ComputeDisplacements
      buffer = disp
      F = F
    []
    [vonmises]
      type = ComputeVonMisesStress
      buffer = sV
    []
  []
[]

[TensorSolver]
  # no variables are integrated by this solver (FFTMechanics performs a steady state mechanics solve)
  type = ForwardEulerSolver
  root_compute = root
  # deformation tensor is just forwarded Fnew -> F
  forward_buffer = F
  forward_buffer_new = Fnew
  substeps = 10
[]

[TensorOutputs]
  [deformation_tensor]
    type = XDMFTensorOutput
    buffer = 'disp sV F'
    output_mode = 'OVERSIZED_NODAL CELL CELL'
    enable_hdf5 = true
  []
[]

[Executioner]
  type = Transient
  num_steps = 100
  dt = 0.01
[]

(test/tests/mechanics/mech.i)

[Domain]
  dim = 2
  nx = 32
  ny = 32
  xmax = ${fparse 2*pi}
  ymax = ${fparse 2*pi}
  zmax = ${fparse 2*pi}
  mesh_mode = DUMMY
  parallel_mode = FFT_AUTO
[]

[TensorComputes]
  [Initialize]
    [phase]
      type = ParsedCompute
      expression = '(cos(x)/2+0.5)^1*(cos(y)/2+0.5)^1*(cos(z)/2+0.5)^1'
      extra_symbols = true
      buffer = phase
    []
    [K]
      type = ParsedCompute
      buffer = K
      expression = '(1-phase)*Ka + phase*Kb'
      inputs = phase
      constant_names = 'Ka Kb'
      constant_expressions = '1 10'
    []
    [mu]
      type = ParsedCompute
      buffer = mu
      expression = '(1-phase)*mua + phase*mub'
      inputs = phase
      constant_names = 'mua mub'
      constant_expressions = '0.5 5'
    []
    [Finit]
      type = RankTwoIdentity
      buffer = F
    []
  []

  [Solve]
    [hyper_elasticity]
      type = HyperElasticIsotropic
      buffer = stress
      F = Fnew
      K = K
      mu = mu
    []

    [root]
      [applied_strain]
        type = MacroscopicShearTensor
        buffer = applied_strain
      []
      [mech]
        type = FFTMechanics
        buffer = Fnew
        F = F
        K = K
        mu = mu
        l_max_its = 40
        l_tol = 1e-5
        nl_rel_tol = 2e-4
        nl_abs_tol = 2e-3
        constitutive_model = hyper_elasticity
        stress = stress
        applied_macroscopic_strain = applied_strain
      []
    []
  []

  [Postprocess]
    [displacements]
      type = ComputeDisplacements
      buffer = disp
      F = F
    []
    [vonmises]
      type = ComputeVonMisesStress
      buffer = sV
    []
  []
[]

[TensorSolver]
  # no variables are integrated by this solver (FFTMechanics performs a steady state mechanics solve)
  type = ForwardEulerSolver
  root_compute = root
  # deformation tensor is just forwarded Fnew -> F
  forward_buffer = F
  forward_buffer_new = Fnew
  substeps = 3
[]

[TensorOutputs]
  active = 'parallel' # serial

  [serial]
    type = XDMFTensorOutput
    file_base = mech_serial
    buffer = 'disp sV F phase'
    output_mode = 'OVERSIZED_NODAL CELL CELL NODE'
    enable_hdf5 = true
    execute_on = 'TIMESTEP_END'
  []
  [parallel]
    # NODE and OVERSIZED_NODAL are not yet available in parallel output
    type = XDMFTensorOutput
    file_base = mech_parallel
    buffer = 'sV F phase'
    output_mode = 'CELL CELL CELL'
    enable_hdf5 = true
    execute_on = 'TIMESTEP_END'
  []
[]


[Executioner]
  type = Transient
  num_steps = 3
  dt = 0.02
[]

(test/tests/mechanics/mech3d.i)

[Domain]
  dim = 3
  nx = 16
  ny = 16
  nz = 16
  xmax = ${fparse 2*pi}
  ymax = ${fparse 2*pi}
  zmax = ${fparse 2*pi}
  mesh_mode = DUMMY
  parallel_mode = FFT_AUTO
[]

[TensorComputes]
  [Initialize]
    [phase]
      type = ParsedCompute
      expression = '(cos(x)/2+0.5)^1*(cos(y)/2+0.5)^1*(cos(z)/2+0.5)^1'
      extra_symbols = true
      buffer = phase
    []
    [K]
      type = ParsedCompute
      buffer = K
      expression = '(1-phase)*Ka + phase*Kb'
      inputs = phase
      constant_names = 'Ka Kb'
      constant_expressions = '1 10'
    []
    [mu]
      type = ParsedCompute
      buffer = mu
      expression = '(1-phase)*mua + phase*mub'
      inputs = phase
      constant_names = 'mua mub'
      constant_expressions = '0.5 5'
    []
    [Finit]
      type = RankTwoIdentity
      buffer = F
    []
  []

  [Solve]
    [hyper_elasticity]
      type = HyperElasticIsotropic
      buffer = stress
      F = Fnew
      K = K
      mu = mu
    []

    [root]
      [applied_strain]
        type = MacroscopicShearTensor
        buffer = applied_strain
      []
      [mech]
        type = FFTMechanics
        buffer = Fnew
        F = F
        K = K
        mu = mu
        l_tol = 1e-2
        nl_rel_tol = 2e-2
        nl_abs_tol = 2e-2
        constitutive_model = hyper_elasticity
        stress = stress
        applied_macroscopic_strain = applied_strain
      []
    []
  []

  [Postprocess]
    [displacements]
      type = ComputeDisplacements
      buffer = disp
      F = F
    []
    [vonmises]
      type = ComputeVonMisesStress
      buffer = sV
    []
  []
[]

[TensorSolver]
  # no variables are integrated by this solver (FFTMechanics performs a steady state mechanics solve)
  type = ForwardEulerSolver
  root_compute = root
  # deformation tensor is just forwarded Fnew -> F
  forward_buffer = F
  forward_buffer_new = Fnew
  substeps = 10
[]

[TensorOutputs]
  active = 'parallel' # serial

  [serial]
    type = XDMFTensorOutput
    file_base = mech3d_serial
    buffer = 'disp sV F phase'
    output_mode = 'OVERSIZED_NODAL CELL CELL NODE'
    enable_hdf5 = true
    execute_on = 'TIMESTEP_END'
  []
  [parallel]
    # NODE and OVERSIZED_NODAL are not yet available in parallel output
    type = XDMFTensorOutput
    file_base = mech3d_parallel
    buffer = 'sV F phase'
    output_mode = 'CELL CELL CELL'
    enable_hdf5 = true
    execute_on = 'TIMESTEP_END'
  []
[]

[Executioner]
  type = Transient
  num_steps = 3
  dt = 0.01
[]

Overview
Example Input File Syntax
Input Parameters
Input Files