Physics · CFD · Lattice Boltzmann
📅 July 2026 ⏱ ≈ 11 min read 🎯 Intermediate–Advanced

LBM boundary conditions — accuracy versus simplicity

Our earlier Lattice Boltzmann Method article introduced bounce-back and Zou-He walls in passing. In practice, boundary conditions are where most LBM codes gain or lose their accuracy: the collision and streaming steps are second-order accurate almost by construction, but a careless wall treatment can silently drop the whole simulation to first order, or introduce a slip velocity that ruins a drag or Strouhal-number (a dimensionless measure of how fast vortices are shed behind an obstacle) measurement. This article compares the main families — on-grid vs halfway bounce-back, Zou-He, interpolated bounce-back for curved geometry, and immersed boundary forcing — by accuracy order, robustness and implementation cost.

TL;DR: Getting boundary conditions right matters more than the bulk LBM solver: simple bounce-back is only first-order accurate, but shifting the wall to the midpoint between nodes (halfway bounce-back) gives second order for free. Zou-He handles inlets/outlets, interpolated bounce-back handles curved obstacles, and immersed boundary methods handle moving walls — pick the cheapest one that matches your geometry.

1. Why boundary conditions are the weak link in LBM

After streaming, a node adjacent to a solid wall is missing some of its incoming distribution functions f_i — the ones that would have arrived from inside the solid, where there is no fluid. A boundary condition's job is to reconstruct exactly these missing populations so that the macroscopic velocity and (where relevant) pressure at the wall match the physical condition — no-slip, prescribed inflow velocity, fixed outlet pressure, or a curved obstacle surface.

The bulk LBM update (BGK collision + streaming) is formally second-order accurate in space and time via the Chapman-Enskog expansion. Many boundary schemes, however, are only first-order accurate, or accurate only for walls aligned exactly with the lattice — and the error they introduce at the wall does not stay local: it pollutes the whole flow field over enough time steps, especially in recirculating or high-Reynolds-number flows.

2. On-grid vs halfway bounce-back

On-grid (simple) bounce-back places the solid wall exactly on a lattice node. Any population arriving there is reflected straight back:

f_ī(x_wall, t+1) = f_i*(x_wall, t) ī = opposite direction of i

This is trivial to implement and unconditionally stable, but the effective no-slip location is only first-order accurate — the true zero-velocity surface sits somewhere between the wall node and its neighbour, not exactly on the node, introducing an O(Δx) error in wall position that shows up as an O(Δx) error in drag coefficients and boundary-layer thickness.

Halfway bounce-back instead places the wall exactly midway between the last fluid node and the first solid node. The reflection rule is identical in code, but because the wall sits at the midpoint of the link, the effective no-slip location becomes second-order accurate — matching the accuracy of the bulk scheme, at zero extra computational cost. This single geometric choice — treating the wall as living between nodes, not on them — is the most impactful, cheapest accuracy fix available in LBM wall treatment.

Rule of thumb: unless there is a specific reason to align walls with nodes, always use halfway bounce-back. It costs nothing extra and doubles the formal order of accuracy at straight walls.

3. Zou-He velocity and pressure boundaries

Bounce-back only handles solid walls; it says nothing about prescribing a known inlet velocity or outlet pressure. Zou & He (1997) derived boundary populations by combining the known macroscopic condition with the bounce-back rule applied only to the non-equilibrium part of the distribution normal to the boundary. For a left inlet with velocity u = (u_x, 0) in D2Q9 (directions 1, 5, 8 unknown after streaming):

ρ_in = (f_0 + f_2 + f_4 + 2(f_3 + f_6 + f_7)) / (1 − u_x)
f_1 = f_3 + (2/3) ρ_in u_x
f_5 = f_7 − (1/2)(f_2 − f_4) + (1/6) ρ_in u_x
f_8 = f_6 + (1/2)(f_2 − f_4) + (1/6) ρ_in u_x

The same derivation gives a pressure (density) outlet: prescribe ρ_out directly and solve the analogous three equations for the outgoing velocity component instead. Zou-He is second-order accurate and exactly reproduces a known uniform inflow with no start-up transient — a clear improvement over the older approach of simply setting all nine f_i to their equilibrium value at inflow, which is only first-order accurate and introduces spurious pressure waves at start-up.

Corner nodes: Zou-He becomes ambiguous at corners where two boundary types meet (e.g. inlet corner touching a no-slip wall) — three or more populations are unknown instead of the expected number. The common fix is to apply a special corner rule (bounce-back of the tangential non-equilibrium component) or simply treat the corner node with plain bounce-back.

4. Curved walls — interpolated bounce-back

Halfway bounce-back is exact only for walls that run exactly along lattice links. A circular cylinder or aerofoil intersects lattice links at an arbitrary fraction q ∈ (0, 1) of the link length from the fluid node. Treating this as ordinary halfway bounce-back (q = 0.5 everywhere) introduces an O(Δx) staircase error in geometry that dominates for coarse grids.

Bouzidi, Firdaouss & Lallemand (2001) derived a second-order accurate interpolated bounce-back that linearly (or quadratically) interpolates between the wall's exact intersection fraction q and the neighbouring fluid nodes:

For q < 1/2 (wall close to the fluid node):
f_ī(x_f, t+1) = 2q f_i*(x_f, t) + (1 − 2q) f_i*(x_ff, t)

For q ≥ 1/2 (wall close to the solid node):
f_ī(x_f, t+1) = (1/(2q)) f_i*(x_f, t) + ((2q − 1)/(2q)) f_ī*(x_f, t)

x_f: fluid node adjacent to the wall; x_ff: next fluid node further from the wall
q: fraction of the link length from x_f to the true wall location

This recovers second-order accuracy for arbitrarily curved solid boundaries at the cost of pre-computing q for every boundary link once at setup time (a geometric ray-intersection test) — a one-time cost that pays for itself immediately in accuracy for the Kármán-vortex-street and flow-past-cylinder class of simulations.

5. Immersed boundary method — moving/deformable walls

For walls that move or deform every time step (a beating heart valve, a flapping wing, a swimming fish), recomputing bounce-back geometry every frame is expensive and can introduce a "staircase" jitter in the moving boundary. The Immersed Boundary Method (IBM) instead represents the boundary as a set of Lagrangian marker points carrying a forcing term that is spread onto the underlying fixed Eulerian lattice via a smoothed delta function (e.g. the Peskin 4-point kernel):

F(x) = Σ_k F_k δ_h(x − X_k) ΔV_k spread Lagrangian force to lattice
U(X_k) = Σ_x u(x) δ_h(x − X_k) Δx^d interpolate velocity back to marker

The lattice never needs re-meshing as the boundary moves — only the marker positions and forces update — which makes IBM the method of choice for fluid-structure interaction, at the cost of a smeared (rather than sharp) no-slip condition of typically first-to-second order, depending on kernel choice and force computation scheme (direct forcing vs feedback forcing).

6. Open boundaries — outflow and free-slip

Besides walls and prescribed inlets, two further boundary types recur constantly:

7. Choosing a scheme — accuracy vs cost

SchemeGeometryOrderExtra cost
On-grid bounce-backstraight, lattice-aligned1stnone
Halfway bounce-backstraight, lattice-aligned2ndnone
Zou-Hestraight inlet/outlet2ndlow (per-node algebra)
Interpolated bounce-backarbitrary curved2ndmedium (setup-time q)
Immersed boundarymoving/deformable1st–2ndhigh (marker tracking, spreading)

The practical rule: use the cheapest scheme that matches your geometry exactly. Halfway bounce-back is free and should always replace on-grid bounce-back for flat walls; interpolated bounce-back is worth the one-time setup cost whenever the obstacle is curved and quantitative accuracy (drag, Strouhal number, pressure coefficient) matters; immersed boundary is reserved for genuinely moving geometry where re-meshing the lattice every step is not an option.

8. Practical checklist

🌀 Lattice-Boltzmann Flow

See halfway bounce-back and inlet/outlet boundaries running live in a 2D D2Q9 flow-past-cylinder simulation.

Open simulation →