Incompressible Navier–Stokes solver (centered formulation)

We wish to approximate numerically the incompressible, variable-density Navier–Stokes equations tu+(uu)=1ρ[p+(2μD)]+a u=0 with the deformation tensor D=[u+(u)T]/2.

The scheme implemented here is close to that used in Gerris (Popinet, 2003, Popinet, 2009, Lagrée et al, 2011).

We will use the generic time loop, a CFL-limited timestep, the Bell-Collela-Glaz advection scheme and the implicit viscosity solver. If embedded boundaries are used, a different scheme is used for viscosity.

#include "run.h"
#include "timestep.h"
#include "bcg.h"
# include "viscosity-embed.h"
# include "viscosity.h"

The primary variables are the centered pressure field p and the centered velocity field u. The centered vector field g will contain pressure gradients and acceleration terms.

We will also need an auxilliary face velocity field uf and the associated centered pressure field pf.

scalar p[];
vector u[], g[];
scalar pf[];
face vector uf[];

In the case of variable density, the user will need to define both the face and centered specific volume fields (α and αc respectively) i.e. 1/ρ. If not specified by the user, these fields are set to one i.e. the density is unity.

Viscosity is set by defining the face dynamic viscosity μ; default is zero.

The face field a defines the acceleration term; default is zero.

The statistics for the (multigrid) solution of the pressure Poisson problems and implicit viscosity are stored in mgp, mgpf, mgu respectively.

If stokes is set to true, the velocity advection term (uu) is omitted. This is a reference to Stokes flows for which inertia is negligible compared to viscosity.

(const) face vector μ = zerof, a = zerof, α = unityf;
(const) scalar ρ = unity;
mgstats mgp, mgpf, mgu;
bool stokes = false;

Boundary conditions

For the default symmetric boundary conditions, we need to ensure that the normal component of the velocity is zero after projection. This means that, at the boundary, the acceleration a must be balanced by the pressure gradient. Taking care of boundary orientation and staggering of a, this can be written

#define neumann_pressure(i) (a.n[i]*fm.n[i]/(α.n[i] + SEPS))

p[right] = neumann (neumann_pressure(ghost));
p[left]  = neumann (- neumann_pressure(0));

#if AXI
uf.n[bottom] = 0.;
uf.t[bottom] = dirichlet(0); // since uf is multiplied by the metric which
                             // is zero on the axis of symmetry
#else // !AXI
#  if dimension > 1
p[top]    = neumann (neumann_pressure(ghost));
p[bottom] = neumann (- neumann_pressure(0));
#  endif
#  if dimension > 2
p[front]  = neumann (neumann_pressure(ghost));
p[back]   = neumann (- neumann_pressure(0));
#  endif

Initial conditions

event defaults (i = 0)

  CFL = 0.8;

The pressures are never dumped.

  p.nodump = pf.nodump = true;

The default density field is set to unity (times the metric).

  if (α.x.i == unityf.x.i) {
    α = fm;
    ρ = cm;
  else if (!is_constant(α.x)) {
    face vector alphav = α;
      alphav.x[] = fm.x[];
    boundary ((scalar *){α});

On trees, refinement of the face-centered velocity field needs to preserve the divergence-free condition.

#if TREE
  uf.x.refine = refine_face_solenoidal;

When using embedded boundaries, the restriction and prolongation operators need to take the boundary into account.

#if EMBED  
  for (scalar s in {p,u}) {
    s.restriction = restriction_embed_linear;
    s.refine = s.prolongation = refine_embed_linear;
#endif // EMBED
#endif // TREE

After user initialisation, we initialise the face velocity and fluid properties.

double dtmax;

event init (i = 0)
  boundary ((scalar *){u});
  trash ({uf});
    uf.x[] = fm.x[]*(u.x[] + u.x[-1])/2.;
  boundary ((scalar *){uf});

We update fluid properties.

  event ("properties");

We set the initial timestep (this is useful only when restoring from a previous run).

  dtmax = DT;
  event ("stability");

Time integration

The timestep for this iteration is controlled by the CFL condition, applied to the face centered velocity field uf; and the timing of upcoming events.

event set_dtmax (i++,last) dtmax = DT;

event stability (i++,last) {
  dt = dtnext (stokes ? dtmax : timestep (uf, dtmax));

If we are using VOF or diffuse tracers, we need to advance them (to time t+Δt/2) here. Note that this assumes that tracer fields are defined at time tΔt/2 i.e. are lagging the velocity/pressure fields by half a timestep.

event vof (i++,last);
event tracer_advection (i++,last);
event tracer_diffusion (i++,last);

The fluid properties such as specific volume (fields α and αc) or dynamic viscosity (face field μf) – at time t+Δt/2 – can be defined by overloading this event.

event properties (i++,last) {
  boundary ({α, μ, ρ});

Predicted face velocity field

For second-order in time integration of the velocity advection term (uu), we need to define the face velocity field uf at time t+Δt/2. We use a version of the Bell-Collela-Glaz advection scheme and the pressure gradient and acceleration terms at time t (stored in vector g).

void prediction()
  vector du;
  foreach_dimension() {
    scalar s = new scalar;
    du.x = s;

  if (u.x.gradient)
        du.x[] = u.x.gradient (u.x[-1], u.x[], u.x[1])/Δ;
        du.x[] = center_gradient (u.x);
  boundary ((scalar *){du});

  trash ({uf});
  foreach_face() {
    double un = dt*(u.x[] + u.x[-1])/(2.*Δ), s = sign(un);
    int i = -(s + 1.)/2.;
    uf.x[] = u.x[i] + (g.x[] + g.x[-1])*dt/4. + s*(1. - s*un)*du.x[i]*Δ/2.;
    #if dimension > 1
    if (fm.y[i,0] && fm.y[i,1]) {
      double fyy = u.y[i] < 0. ? u.x[i,1] - u.x[i] : u.x[i] - u.x[i,-1];
      uf.x[] -= dt*u.y[i]*fyy/(2.*Δ);
    #if dimension > 2
    if (fm.z[i,0,0] && fm.z[i,0,1]) {
      double fzz = u.z[i] < 0. ? u.x[i,0,1] - u.x[i] : u.x[i] - u.x[i,0,-1];
      uf.x[] -= dt*u.z[i]*fzz/(2.*Δ);
    uf.x[] *= fm.x[];
  boundary ((scalar *){uf});

  delete ((scalar *){du});

Advection term

We predict the face velocity field uf at time t+Δt/2 then project it to make it divergence-free. We can then use it to compute the velocity advection term, using the standard Bell-Collela-Glaz advection scheme for each component of the velocity field.

event advection_term (i++,last)
  if (!stokes) {
    mgpf = project (uf, pf, α, dt/2., mgpf.nrelax);
    advection ((scalar *){u}, uf, dt, (scalar *){g});

Viscous term

We first define a function which adds the pressure gradient and acceleration terms.

static void correction (double dt)
      u.x[] += dt*g.x[];
  boundary ((scalar *){u});  

The viscous term is computed implicitly. We first add the pressure gradient and acceleration terms, as computed at time t, then call the implicit viscosity solver. We then remove the acceleration and pressure gradient terms as they will be replaced by their values at time t+Δt.

event viscous_term (i++,last)
  if (constant(μ.x) != 0.) {
    correction (dt);
    mgu = viscosity (u, μ, ρ, dt, mgu.nrelax);
    correction (-dt);

The (provisionary) face velocity field at time t+Δt is obtained by simple interpolation. We also reset the acceleration field (if it is not a constant).

  face vector af = a;
  trash ({uf,af});
  foreach_face() {
    uf.x[] = fm.x[]*face_value (u.x, 0);
    if (!is_constant(af.x))
      af.x[] = 0.;

Acceleration term

The acceleration term a needs careful treatment as many equilibrium solutions depend on exact balance between the acceleration term and the pressure gradient: for example Laplace’s balance for surface tension or hydrostatic pressure in the presence of gravity.

To ensure a consistent discretisation, the acceleration term is defined on faces as are pressure gradients and the centered combined acceleration and pressure gradient term g is obtained by averaging.

event acceleration (i++,last)
  boundary ((scalar *){a});
    uf.x[] += dt*fm.x[]*a.x[];
  boundary ((scalar *){uf});

Approximate projection

To get the pressure field at time t+Δt we project the face velocity field (which will also be used for tracer advection at the next timestep).

event projection (i++,last)
  mgp = project (uf, p, α, dt, mgp.nrelax);

We then compute a face field gf combining both acceleration and pressure gradient.

  face vector gf[];
    gf.x[] = fm.x[]*a.x[] - α.x[]*(p[] - p[-1])/Δ;
  boundary_flux ({gf});

We average these face values to obtain the centered, combined acceleration and pressure gradient field.

  trash ({g});
      g.x[] = (gf.x[] + gf.x[1])/(fm.x[] + fm.x[1] + SEPS);
  boundary ((scalar *){g});

And finally add this term to the centered velocity field.

  correction (dt);


After mesh adaptation fluid properties need to be updated.

#if TREE
event adapt (i++,last) {
  event ("properties");

See also