Kármán Vortex Street: Flow Instability, Strouhal Number & LBM Simulation

1. Reynolds Number Regimes

The Reynolds number Re = ρUD/μ = UD/ν (where U is free-stream velocity, D is cylinder diameter, ν = μ/ρ is kinematic viscosity) governs the flow topology:

The onset of vortex shedding at Re ≈ 47 is a supercritical Hopf bifurcation: the steady symmetric wake solution loses stability and a limit cycle (periodic shedding) is born. The bifurcation parameter is Re; the bifurcation is non-hysteretic (supercritical).

2. Strouhal Number & Shedding Frequency

The non-dimensional shedding frequency is the Strouhal number:

For a circular cylinder in the laminar shedding regime (50 < Re < 1000), Williamson & Brown (1998) give the empirical fit:

Two opposite-sign vortices are shed per cycle — one from each side — so the wake pattern has a spatial period of 2 × (U/f) × (lateral spacing). The downstream spacing of same-sign vortices (vortex street wavelength) is λ = U/f = D/St.

For the vortex street to be stable, the lateral-to-longitudinal spacing ratio must satisfy the von Kármán stability criterion:

Any other ratio causes the two rows to interact and quickly disrupt the pattern. This specific geometry was derived by von Kármán (1911) from the stability analysis of a double row of point vortices — an elegant application of 2D potential flow theory.

3. Linear Stability & Wake Instability

The transition from steady to periodic flow at Re ≈ 47 is explained by linear stability analysis of the Navier-Stokes equations linearised around the steady base flow U(x):

At Re < 47, all eigenvalues of L have negative real parts — perturbations decay. At Re = 47 a complex conjugate pair λ = ±iω₀ crosses the imaginary axis (the Hopf condition), and the steady wake is replaced by a growing oscillation with frequency ω₀ = 2πSt·U/D. Above Re = 47 the amplitude saturates via nonlinear effects; the flow settles onto a stable limit cycle (the periodic vortex street).

Absolute vs Convective Instability

The distinction between absolute and convective instability is critical for understanding why the vortex street persists:

• Convective instability: perturbations grow but are swept downstream (analogous to radiation damping). The wake acts as an amplifier but not a self-sustaining oscillator.
• Absolute instability: perturbations grow at a fixed spatial location. The flow acts as a self-excited oscillator with a well-defined natural frequency.

Koch (1985) showed that the near wake of the cylinder is absolutely unstable for Re > 25–35. This absolute instability "locks in" the shedding frequency, making the vortex street a global instability rather than a noise-amplified convective wave.

4. Drag, Lift & Pressure

The alternating vortex shedding produces a periodically varying lift force (crossflow) at frequency f_s and a weakly modulated drag force at frequency 2f_s:

The drag oscillation at 2f_s arises from the symmetric formation of vortices on alternate sides — each new vortex adds a positive increment to drag regardless of which side it is shed. The lift oscillation at f_s corresponds to the alternating sign of circulation in each shed vortex.

The pressure field decomposes into: (1) a mean pressure deficit in the wake (responsible for form drag), (2) oscillating near-wake pressure with period 1/f_s, and (3) the attached vortex pressure (suction on the side where the shear layer rolls up).

5. Vortex-Induced Vibration & Lock-in

If the cylinder is elastically mounted (mass m, spring k, damping c), it can vibrate in the crossflow direction. When the shedding frequency f_s approaches the structural natural frequency f_n = √(k/m) / (2π), a phenomenon called lock-in (or synchronisation) occurs:

• The shedding frequency "locks on" to f_n over a range of reduced velocities U_r = U/(f_n D) ≈ 4–8
• Within the lock-in range, the cylinder oscillates at f_n regardless of U
• Amplitude can reach 1–2 cylinder diameters — far larger than the ≈0.01D oscillations outside lock-in
• Energy is extracted from the flow and fed into structural vibration

Lock-in is exploited constructively in flow energy harvesters (piezoelectric patches on oscillating structures) and in fish locomotion: a trout swimming behind a D-shaped bluff body "surfs" the Kármán street, extracting energy from shed vortices via timed undulations of its body — demonstrated experimentally by Liao et al. (2003) in Science.

6. LBM D2Q9: Theory

The Lattice-Boltzmann Method (LBM) solves a discrete Boltzmann equation on a lattice. In D2Q9 (2D, 9 velocities), each cell stores 9 distribution functions fᵢ representing particle populations moving in 9 discrete directions:

The relaxation time τ controls viscosity: ν = cs²(τ − ½) = (1/3)(τ − ½). For τ ∈ (0.5, 2) the method is stable. The Reynolds number in LBM units is Re = U_LBM · D_LBM / ν_LBM.

Boundary conditions on the cylinder surface use bounce-back: any distribution function streaming into the solid is reflected back in the opposite direction with equal magnitude. This implements a no-slip condition second-order accurate for stationary boundaries.

7. LBM D2Q9: Implementation

// LBM D2Q9 — Kármán vortex street
// Grid: NX × NY lattice, cylinder at (cx, cy) radius R
// Vorticity rendered: ω = ∂v/∂x − ∂u/∂y (finite difference)

const W = 320, H = 160;
const CX = 70, CY = H >> 1, R = 12;
const TAU = 0.56;          // relaxation time → ν = (0.56−0.5)/3 = 0.02
const U0  = 0.1;           // inlet velocity (LBM units, must be ≪ 1)

// D2Q9 weights and velocity vectors
const W9 = [4/9, 1/9,1/9,1/9,1/9, 1/36,1/36,1/36,1/36];
const EX = [0, 1,0,-1, 0, 1,-1,-1, 1];
const EY = [0, 0,1, 0,-1, 1, 1,-1,-1];
const OPP= [0, 3,4, 1, 2, 7,8, 5, 6];  // bounce-back pairs

const N = W * H;
let f    = new Float32Array(9 * N);
let fTmp = new Float32Array(9 * N);
const solid = new Uint8Array(N);

// Mark cylinder cells
function initSolid() {
  for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) {
    const dx = x - CX, dy = y - CY;
    if (dx*dx + dy*dy <= R*R) solid[y*W+x] = 1;
  }
}

// Equilibrium distribution
function feq(i, rho, ux, uy) {
  const eu = EX[i]*ux + EY[i]*uy;
  const u2 = ux*ux + uy*uy;
  return W9[i] * rho * (1 + 3*eu + 4.5*eu*eu - 1.5*u2);
}

// Initialise uniform flow
function initFlow() {
  for (let n = 0; n < N; n++) {
    const rho0 = 1.0;
    for (let i = 0; i < 9; i++) f[9*n+i] = feq(i, rho0, U0, 0);
  }
}

function step() {
  const inv_tau = 1 / TAU;

  // Collision
  for (let n = 0; n < N; n++) {
    if (solid[n]) continue;
    let rho = 0, ux = 0, uy = 0;
    for (let i = 0; i < 9; i++) {
      const fi = f[9*n+i];
      rho += fi; ux += EX[i]*fi; uy += EY[i]*fi;
    }
    ux /= rho; uy /= rho;
    for (let i = 0; i < 9; i++) {
      f[9*n+i] += inv_tau * (feq(i, rho, ux, uy) - f[9*n+i]);
    }
  }

  // Streaming + boundary conditions
  for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) {
    const n0 = y*W + x;
    if (solid[n0]) {
      // Bounce-back for solid cells
      for (let i = 0; i < 9; i++) fTmp[9*n0+OPP[i]] = f[9*n0+i];
      continue;
    }
    for (let i = 0; i < 9; i++) {
      let nx = x + EX[i], ny = y + EY[i];
      // Left inlet: constant velocity inlet (Zou-He)
      if (nx < 0) { fTmp[9*n0+i] = feq(i, 1.0, U0, 0); continue; }
      // Right outlet: zero-gradient (copy from neighbour)
      if (nx >= W) { nx = W-1; }
      if (ny < 0)  ny = 0;
      if (ny >= H) ny = H-1;
      const nn = ny*W + nx;
      fTmp[9*nn+i] = f[9*n0+i];
    }
  }
  const tmp = f; f = fTmp; fTmp = tmp;
}

// Read vorticity ω = ∂v/∂x − ∂u/∂y (central differences)
function getVorticity(x, y) {
  const getU = (xx, yy) => {
    const n = Math.min(Math.max(yy,0),H-1)*W + Math.min(Math.max(xx,0),W-1);
    let rho=0, ux=0, uy=0;
    for (let i=0;i<9;i++){rho+=f[9*n+i];ux+=EX[i]*f[9*n+i];uy+=EY[i]*f[9*n+i];}
    return rho > 0 ? [ux/rho, uy/rho] : [0,0];
  };
  const [,vR] = getU(x+1, y); const [,vL] = getU(x-1, y);
  const [uT]  = getU(x, y+1); const [uB]  = getU(x, y-1);
  return 0.5 * ((vR - vL) - (uT - uB));
}
    

8. Interactive Vortex Street Simulation

The canvas below runs an LBM D2Q9 simulation at 320×160 lattice cells. Vorticity ωz = ∂v/∂x − ∂u/∂y is rendered using a diverging blue–white–red colourmap. Increase Re to see the transition from a steady wake to full periodic shedding.