# Numerics setting for simulation of the flow around a 3D sd7003 airfoil using dual time stepping methodology

Dear developers of PyFR,
I would like to thank your team for providing the wonderful code PyFR for the high-fidelity CFD simulation.
I am quite interested in this code, especially in the LES simulation of external flow around aerodynamic bodies.
Currently, I am running the case of the flow around a sd7003 airfoil presented in your paper (On the utility of GPU accelerated high-order methods for unsteady flow simulations: A comparison with industry-standard tools, 2017 JCP), using the case files released with that paper.
The latest version of this code, PyFR 1.8, is used. The flow is assumed to be compressible and the Reynolds number is 60000. The code is run on CPU with openmp.
First, I tried the explicit Runge-Kutta time stepping method used in your JCP paper and everything is going well. The only problem is that with the explicit time marching scheme, the simulation is running slowly. For dt = 1e-5, the flow still has not started to separate after around 400k time steps.
So, to speed up the simulation, I wish to use the dual time stepping method to save the computational cost. However, I do not know how to set up the simulation for a compressible flow with implicit dual time stepping method.
It will be greatly appreciated if you can give me some advices on the following problems.

(1) How can we set the parameters for “solver-time-integrator”? The following is the setting used in my simulation. The simulation can be run slowly. But I believe that the values of some parameters are not assigned correctly.
Actually, I do not know what the necessary parameters for a dual time stepping method are as well as what their physical meaning and values are.
The objective is to increase the physical time step dt and save computational cost by using the implicit method.

``````[solver-time-integrator]
formulation = dual
scheme = bdf2
pseudo-scheme = rk4
controller = none // Should a controller be used?
pseudo-controller = none
tstart = 0.0
tend = 100.0
dt = 0.001 //dt=1e-5 for the explicit Runge-Kutta method used in your 2017 JCP paper
pseudo-dt = 0.000058
pseudo-niters-max = 30
pseudo-niters-min = 1
;pseudo-resid-norm = 12 // This line is commented, otherwise errors will be reported.
;pseudo-resid-norm = 6
pseudo-resid-tol = 5e-4 // Is this the absolute value of residual for each conserved variable? Is the solution converged and inner iteration stopped when the residual of some conserved variables drops below this value?
``````

(2) During the run of a simulation, one is concerned with what the progress of the run is, how many time steps has been advanced and so on.
So, is there any method to print these important information on screen or write them into a log file?

Hi JG

please see the tips by Niki here: https://groups.google.com/forum/#!topic/pyfrmailinglist/KCcsMNHbZKQ regarding the dual time stepping.

Anyhow, regarding your settings in [solver-time-integrator]:

the controller can be used for rk schemes with so called embedded pairs like rk34 and rk45. It is generally desirable to use those, so

``````scheme = bdf2
pseudo-scheme = rk45
controller = none ;this refers to the bdf2, which has no controller
pseudo-controller = pi
``````

for the pseudo dt, we typically start with a pseudo-dt which is 50 times smaller than the dt. Then we increase gradually, while making sure that the inner iterations are still converging of course.

Then
`pseudo-resid-norm = l2`, it’s a string not a integer (see http://www.pyfr.org/user_guide.php).
`pseudo-resid-tol = 5e-4 ;yes`

As pointed out by Niki, the p-multigrid could be beneficial so I would suggest trying it.

Finally, to monitor the convergence of the dual time step add the following lines to the .ini file (also check the user guide PyFR):

``````[soln-plugin-pseudostats]
flushsteps = 10
file = pseudostats.csv