Time Integration / Steady Solvers

The Integration section selects the time-integration scheme and controls how the time step is determined and when the run will stop.

Supported schemes

Only these schemes are supported:

• ssprk3 – third-order strong-stability-preserving Runge–Kutta (explicit).
• bdf1 – first-order backward differentiation (implicit) with optional steady/unsteady modes.
• sequence – proprietary multi-grid integrator that automatically converges to steady state (see special notes below).

Common keys for ssprk3 and bdf1

Key	Required?	Description
scheme	yes	Choose ssprk3 or bdf1.
Time-step control		Exactly one of the following must be set:
fixed_CFL + CFL	—	Hold CFL constant and compute dt from grid size and wave speed.
timestep	—	Hold dt constant (seconds or solver time units).
omit both fixed_CFL and timestep, but set CFL	—	Compute dt dynamically from CFL at startup, then freeze it (rare).
End condition		Exactly one of the following must be set:
max_steps	—	Stop after this many time steps.
max_time	—	Stop after this physical time (solver units).
max_time_char	—	Stop after this many characteristic times; see time_scale.
time_scale	yes	Characteristic time used for reporting and for max_time_char. May be an expression using dictionary values (e.g., Lscale/umag). Must be positive.

All numerical values are in the global solver unit system.

Restart compatibility:

• ssprk3 and bdf1 read and continue time and iteration counters from a restart database.
• sequence ignores restart files.

---

Scheme: ssprk3

A third-order strong-stability-preserving Runge–Kutta explicit integrator.
Good for unsteady flows and scale-resolving turbulence simulations.

Example: fixed CFL

Integration
{
    CFL        = 0.65
    fixed_CFL  = true
    scheme     = "ssprk3"
    max_time   = 0.01
    time_scale = 0.01
}

Example: fixed time step

Integration
{
    scheme    = "ssprk3"
    timestep  = 1.0e-6
    max_steps = 500000
    time_scale = 0.01
}

---

Scheme: bdf1

A first-order backward-differentiation implicit integrator for steady or unsteady problems.

Additional keys (expert):

Key	Default	Purpose
steady	true	true for steady-state (recommended), false for unsteady.
linsolve_relax	0.9	Linear-solver relaxation factor.
max_linsolve_iterations	2	Max inner linear-solver iterations per time step.
linsolve_tolerance	1e-8	Linear-solver convergence tolerance.
CFL_local	0.5	Starting local CFL for implicit update.
CFL_ramp	false	Enable adaptive CFL ramping to accelerate steady problems.
CFL_ramp_min	0.5	Minimum allowed CFL when ramping.
CFL_ramp_max	10000.0	Maximum allowed CFL when ramping.
CFL_ramp_beta	1.2	Growth factor per interval.
CFL_ramp_interval	25	Steps between ramp evaluations.

Example:

Integration
{
    scheme     = "bdf1"
    fixed_CFL  = true
    CFL        = 5.0
    max_time_char = 10.0
    time_scale = Lscale/umag
    steady     = true
    CFL_ramp   = true
}

---

Scheme: sequence (special)

The sequence solver is a proprietary multi-grid method that automatically solves steady state.
It is not restartable and does not support subdomains.

Keys:

Key	Required	Description
scheme	yes	"sequence".
Subintegrator	yes	Inner time integrator block. Must specify an allowed scheme (e.g. ssprk3) and typical CFL/time-step settings. Do not add end conditions here — they are internally overridden.
Freestream	yes	One expression per primitive variable, specifying the free-stream reference state used to compute sweep direction and inflow conditions.

Optional tuning (advanced):

• window_width (default 4)
• window_advance (default 2)
• solve_time (default 2.5)

Example:

Integration
{
    scheme = "sequence"
    Subintegrator
    {
        scheme    = "ssprk3"
        CFL       = 0.45
        fixed_CFL = true
    }
    Freestream
    {
        P = "Qinf::pinf"
        T = "Qinf::Tinf"
        U = "Qinf::uinf"
        V = "Qinf::vinf"
        W = "Qinf::winf"
    }
}