How to implement staggered solving using MultiApp and Fixed Point Iteration?

[bo-qian]

Problem Background

My governing equations are solved using a MultiApp-based framework. For numerical stability, staggered iteration between CH (Cahn-Hilliard) and Stokes equations is required starting from the first time step. The solution framework and pseudocode are shown below:

Solution Framework Diagram:

Pseudocode (Lines 9-17):

Current Configuration

My input file configuration:

[Problem]
  verbose_multiapps=true
[]

[MultiApps]
  [./Stokes]
    type = FullSolveMultiApp
    input_files = ${stokes_input}
    execute_on = 'INITIAL MULTIAPP_FIXED_POINT_END'
    clone_parent_mesh = true
  [../]
[]

[Transfers]
  [./CHToStokes]
    type = MultiAppCopyTransfer
    to_multi_app = Stokes
    source_variable = 'c c_mid mu'
    variable = 'c c_mid mu_c'
    execute_on = 'MULTIAPP_FIXED_POINT_END'
  [../]
  [./StokesToCH_1]
    type = MultiAppCopyTransfer
    from_multi_app = Stokes
    source_variable = 'c mu_c' 
    variable = 'c mu'
    execute_on = 'INITIAL'
  [../]
  [./StokesToCH_2]
    type = MultiAppCopyTransfer
    from_multi_app = Stokes
    source_variable = 'velocity pressure' 
    variable = 'velocity pressure'
    execute_on = 'INITIAL MULTIAPP_FIXED_POINT_END'
  [../]
[]

[Preconditioning]
  [./CH_Stokes]
    type = SMP
    full = true
    petsc_options_iname = '-pc_type'
    petsc_options_value = 'ilu'
  [../]
[]

[Executioner]
  type = Transient
  solve_type = NEWTON
  line_search = 'none'
  verbose = true

  nl_max_its = 50
  nl_rel_tol = 1e-3

  dt = 0.005
  start_time = 0.0
  end_time = 1.0
  
  fixed_point_min_its = 1
  fixed_point_max_its = 50
  fixed_point_rel_tol = 1e-3
  fixed_point_abs_tol = 1e-2
  fixed_point_algorithm = picard
  auto_advance = true 
[]

Current Issue

The output shows successful convergence at each step, but the Picard iteration reduces the tolerance to zero after just one iteration:

Time Step 1, time = 0.005
         old time = 0
               dt = 0.005
           old dt = 0.005

Backing Up MultiApps on MULTIAPP_FIXED_POINT_END
Stokes0: Backed up MultiApp ... Mu_Initial
Backed up MultiApp ... Stokes
Finished Backing Up MultiApps on MULTIAPP_FIXED_POINT_END

Initial fixed point residual norm: 7.962059e+01

Beginning fixed point iteration 0

Main app solve:
    |residual|_2 of individual variables:
                      c:     39.0258
                      mu:    2.60487e-13
                      c_mid: 69.4005
 0 Nonlinear |R| = 7.962059e+01
      0 Linear |R| = 7.962059e+01
      1 Linear |R| = 2.156968e-07
default_nonlinear_convergencenl0: Converged due to relative/normalized residual norm 2.70906e-09 < relative tolerance (0.001)
    |residual|_2 of individual variables:
                      c:     4.11445e-08
                      mu:    2.11736e-07
                      c_mid: 5.46536e-14
 1 Nonlinear |R| = 2.156968e-07
 Solve Converged!
  Finished Solving                                                                       [  1.86 s] [  680 MB]

[DBG] Executing auxiliary kernels on elements on TIMESTEP_END
[DBG] Ordering of AuxKernels on block 0
[DBG] TotalFreeEnergy DegeneratePressure stress_xx stress_xy stress_yy stress_yx
[DBG] Computing elemental user objects on TIMESTEP_END
[DBG] Ordering of User Objects on block 0
[DBG] Executing ElementIntegralVariablePostprocessor on TIMESTEP_END
[DBG] Order of execution:
[DBG] total_energy

[DBG] Only user objects active on local element/sides are executed

 0 Picard |R| = 7.962059e+01
 1 Picard |R| = 0.000000e+00

Transfers on MULTIAPP_FIXED_POINT_END To MultiApps:
-------------------------------------------------------
|    Name    |         Type         |  From  |   To   |
-------------------------------------------------------
| CHToStokes | MultiAppCopyTransfer | Parent | Stokes |
-------------------------------------------------------
Transfers on MULTIAPP_FIXED_POINT_END Are Finished

No Transfers on MULTIAPP_FIXED_POINT_END Between MultiApps

Executing MultiApps on MULTIAPP_FIXED_POINT_END
Stokes0:     |residual|_2 of individual variables:
Stokes0:                    velocity: 5.96005
Stokes0:                    pressure: 0.00477855
Stokes0:  0 Nonlinear |R| = 5.960056e+00
Stokes0:       0 Linear |R| = 5.960056e+00
Stokes0:       1 Linear |R| = 3.949345e-14
Stokes0: default_nonlinear_convergencenl0: Converged due to residual norm 5.03411e-13 < 1e-07
Stokes0:     |residual|_2 of individual variables:
Stokes0:                    velocity: 5.00552e-13
Stokes0:                    pressure: 5.35684e-14
Stokes0:  1 Nonlinear |R| = 5.034106e-13
Stokes0:  Solve Converged!
Stokes0: Finished Solving                                                                [ 11.67 s] [  665 MB]
Subapp Stokes0 solve converged!
    Finished Executing MultiApps                                                         [ 14.00 s] [  665 MB]
Finished Executing MultiApps on MULTIAPP_FIXED_POINT_END

  Finished Executing MultiApps                                                           [ 14.00 s] [  665 MB]

Transfers on MULTIAPP_FIXED_POINT_END From MultiApps:
---------------------------------------------------------
|     Name     |         Type         |  From  |   To   |
---------------------------------------------------------
| StokesToCH_2 | MultiAppCopyTransfer | Stokes | Parent |
---------------------------------------------------------
Transfers on MULTIAPP_FIXED_POINT_END Are Finished

Fixed point convergence reason: CONVERGED_ABS

Outlier Variable Residual Norms:
  mu: 2.117362e-07

Postprocessor Values:
+----------------+----------------+
| time           | total_energy   |
+----------------+----------------+
|   0.000000e+00 |   1.966624e+04 |
|   5.000000e-03 |   1.959524e+04 |
+----------------+----------------+

Stokes0: Backed up MultiApp ... Mu_Initial
Backed up MultiApp ... Stokes

Specific Questions

1. Configuration Validation: Does my current Fixed Point iteration setup correctly achieve the intended staggered solution approach?

2. Residual Anomaly: Why does the Picard residual become zero? This doesn't seem reasonable from a numerical perspective.

3. Custom Convergence Criterion: How can I implement the following convergence criterion in MOOSE?

Mathematical Description of Desired Convergence Criterion

The convergence criterion for staggered iteration in this system is defined as follows:

Let:

• resnorm_CH be the residual norm of the C equation (from combined weak form),
• resnorm_Stokes be the residual norm of the Stokes equation,
• resnorm_CH_mid and resnorm_Stokes_mid be the residual norms from previous iteration for C and Stokes equations respectively,
• error_indicator be the maximum relative error in residual norms.

The error indicator is given by:

error_indicator = max( (resnorm_CH - resnorm_CH_mid) / resnorm_CH_mid,
                      (resnorm_Stokes_mid - resnorm_Stokes) / resnorm_Stokes )

Convergence is achieved when:

error_indicator ≤ tolerance_Stagger

If the iteration count exceeds the maximum allowed iteration_StaggerMax and the error indicator still exceeds the specified tolerance, a runtime error should be raised:

if (iterationCounter == iteration_StaggerMax and error_indicator > tolerance_Stagger)

Corresponding error message should be generated.

---

I would appreciate detailed guidance on these three questions.

[GiudGiud]

Hello

For numerical stability, staggered iteration between CH (Cahn-Hilliard) and Stokes equations is required starting from the first time step.

Have you tried using relaxation using line search parameters in the Newton (non-multiapp) setup?

Configuration Validation: Does my current Fixed Point iteration setup correctly achieve the intended staggered solution approach?

It seems so but we d need a full input file to be sure what is being solved & transferred and compare the schemes.

Residual Anomaly: Why does the Picard residual become zero? This doesn't seem reasonable from a numerical perspective.

Yes this seems wrong. The Picard residual is by default the residual of the parent application.

Custom Convergence Criterion: How can I implement the following convergence criterion in MOOSE?

You ll need to create a new Convergence object
Note that convergence objects can use postprocessor values, so feel free to have these quantities computed by postprocessors and load them in the Convergence object using the getPostprocessorValue routine

[GiudGiud]

ok for tri3 it's a bug.
You can insert something similar to this code in DistributedMG to fix it.
I ll do this in a PR soon.
Thanks for reporting!

[GiudGiud]

use this to convert to tri in the meantime
https://mooseframework.inl.gov/source/meshgenerators/ElementsToSimplicesConverter.html

[bo-qian]

For this criterion you might be able to do it from the input file
Use a transfer on timestep_end to send the residual from the child app to the parent app.
Then use a ParsedPostprcoessor, executed on MULTIAPP_FIXED_POINT_CONVERGENCE, to combine the two residuals.
And use that in DefaultMultiAppFixedPointConvergence

Thank you for your answer. Do you have any controllable/reference examples for these implementation details? It's quite difficult for me to implement it myself, as I am not very familiar with the details you mentioned.

use this to convert to tri in the meantime
https://mooseframework.inl.gov/source/meshgenerators/ElementsToSimplicesConverter.html

OK, thank you, I will try it later.

[bo-qian]

what do you mean?
quad4 is fine for parallel computing

I mean the mesh generator DistributedRectilinearMeshGenerator is suitable for parallel computing, not for QUAD4.

[GiudGiud]

Do you have any controllable/reference examples for these implementation details?

This object to get the residual in both apps
https://mooseframework.inl.gov/source/postprocessors/Residual.html
This to transfer the residual from the child to the parent
https://mooseframework.inl.gov/source/transfers/MultiAppPostprocessorTransfer.html
this for combining the PPs:
https://mooseframework.inl.gov/source/postprocessors/ParsedPostprocessor.html

This page should show you how to use a PP for declaring convergence
DefaultMultiAppFixedPointConvergence