I have 4 questions regarding: Step 6 – Implicit coupling (Step 6 – Implicit coupling | preCICE - The Coupling Library)

(I use the two figures from your website to describe my questions. One figure is the “Fixed time window” in Step 5 – Non-matching timestep sizes. The other figure is the pseudo-code in Step 6 – Implicit coupling)

```
My 1st question is about the condition “if(precice.isActionRequired(coric)){ // timestep not converged”:
```

What will cause this condition to be TRUE?

My understanding is that it can be TRUE only when ADVANCE checks the convergence when time is at t^(n+1).

If the convergence is not satisfied, this time window is failed and precice will try to redo the time window t^n→t^(n+1), so reloadOldState().

```
My 2nd question is if this condition is FALSE, why does precice endTimeStep()?
```

If solver A does subcycle and just finishes τ^(k-1), (we still need march τ^k to reach t^(n+1)), ADVANCE shouldn’t check convergence yet, so FALSE.

Then we enter this ELSE branch to endTimeStep(). But we should ask solver A to do τ^k instead of endTimeStep(), right?

```
My 3rd question is if timestep not converged, what will precice do to make it converge when redo the time window with reloadOldState()?
```

My understanding is that reloadOldState() will restart from the status at t^n, right?

Some background is that:

For my implicit solver, it is based on a Newton-Raphson loop to solve each τ^(k-1).

If my implicit solver can’t converge for τ^(k-1), what it does is to reduce τ^(k-1) to a smaller time increment, for example 0.25*τ^(k-1) to retry.

Basically, my implicit solver retry the Newon loop with a smaller time increment to linearize the nonlinear problem if it is highly nonlinear.

We call this reduction of time increment size a cutback. The trade-off is we needs more number of time increments to solve the whole problem.

But it appears precice can’t use such a method because can be only either fixed or first-participant.

If my implicit solver reduces each τ^(k-1) (or in another words, my implicit solver increases the number of subcycles from t^n→t^(n+1)), is this a recommended way to redo the time window t^n→t^(n+1)?

If time window is small like t^(n+1)-t^n< τ^(k-1), my implicit solver should use the time increment size of t^(n+1)-t^n instead of its own τ^(k-1).

If here my implicit solver can’t converge, it will reduce to 0.25(t^(n+1)-t^n) to retry, then my implicit solver will enter subcycling too.

```
My last question is for both functions precice.readBlockVectorData and precice.writeBlockVectorData.
```

Why don’t we put them under “if (precice.isReadDataAvailable())” and “if (precice.isWriteDataRequired(dt))” as in “Step 5 – Non-matching timestep sizes”.

My answer is that they are dummy here, meaning these two won’t have any effect on the results because they will be exchanged/refreshed only in ADVANCE when time reaches t^(n+1).

Thanks a lot in advance.

Best

Hongwu