Simulate laminar/turbulent boundary layer growth on a flat plate using the Blasius solution. Adjust freestream velocity, kinematic viscosity, and plate length to observe the Reynolds number transition in real time.
// Boundary layer flow animation
(function() {
const el = document.getElementById('blAnimCanvas');
const ctx = el.getContext('2d');
const NPART = 60;
const particles = [];
let animT = 0;
function getParams() {
const Uinf = parseFloat(document.getElementById('uinf').value) || 5;
const L = parseFloat(document.getElementById('length').value) || 1.0;
const fs = document.getElementById('fluidSel').value;
const nuMap = { water: 1.004e-6, air: 1.516e-5, oil: 4.6e-5, custom: 15e-6 };
const nu = nuMap[fs] || 1.516e-5;
return { Uinf, L, nu };
}
function deltaLam(x, Uinf, nu) {
return x > 0 ? 5 * x / Math.sqrt(Uinf * x / nu) : 0;
}
function initParticles(W, H) {
particles.length = 0;
for (let i = 0; i < NPART; i++) {
particles.push({
x: Math.random() * W,
y: Math.random() * H * 0.95,
speed: 0
});
}
}
function resize() {
const dpr = window.devicePixelRatio || 1;
const w = el.parentElement.clientWidth - 36;
const H = Math.round(w * 0.38);
if (Math.abs(el.width - w * dpr) > 2 || el.height !== H * dpr) {
el.width = w * dpr;
el.height = H * dpr;
el.style.height = H + 'px';
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
initParticles(w, H);
}
return { W: w, H };
}
function frame() {
const { W, H } = resize();
const { Uinf, L, nu } = getParams();
const padL = 30, padR = 20;
const drawW = W - padL - padR;
const wallY = H - 22;
const showTurb = document.getElementById('showTurb').checked;
ctx.clearRect(0, 0, W, H);
// Background gradient (fluid domain)
const bgGrad = ctx.createLinearGradient(0, 0, 0, wallY);
bgGrad.addColorStop(0, '#001F3F');
bgGrad.addColorStop(1, '#002d5a');
ctx.fillStyle = bgGrad;
ctx.fillRect(padL, 0, drawW, wallY);
// Wall
ctx.fillStyle = '#003875';
ctx.fillRect(padL, wallY, drawW, H - wallY);
ctx.fillStyle = '#007BFF';
ctx.fillRect(padL, wallY, drawW, 2);
// Wall label
ctx.fillStyle = 'rgba(255,255,255,0.5)';
ctx.font = '10px Roboto Mono, monospace';
ctx.fillText('Flat plate', padL + 4, wallY + 14);
// Boundary layer profile line
const N = 80;
ctx.beginPath();
ctx.setLineDash([5, 3]);
ctx.strokeStyle = '#00B4D8';
ctx.lineWidth = 1.5;
for (let i = 0; i <= N; i++) {
const xFrac = i / N;
const xPhys = xFrac * L;
const px = padL + xFrac * drawW;
let dPx;
if (showTurb && xPhys > 0 && Uinf * xPhys / nu > 5e5) {
const delta = 0.37 * xPhys / Math.pow(Uinf * xPhys / nu, 0.2);
dPx = Math.min(delta / L * drawW * 2.5, wallY * 0.85);
} else {
const delta = deltaLam(xPhys, Uinf, nu);
dPx = Math.min(delta / L * drawW * 2.5, wallY * 0.85);
}
const py = wallY - dPx;
if (i === 0) ctx.moveTo(px, py);
else ctx.lineTo(px, py);
}
ctx.stroke();
ctx.setLineDash([]);
// Label for boundary layer
ctx.fillStyle = '#00B4D8';
ctx.font = '11px Noto Sans JP, sans-serif';
ctx.fillText('δ(x) Boundary layer', padL + 8, 18);
// Free stream arrow
ctx.strokeStyle = 'rgba(255,255,255,0.6)';
ctx.lineWidth = 1;
ctx.beginPath();
ctx.moveTo(padL + 8, H * 0.15);
ctx.lineTo(padL + 55, H * 0.15);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(padL + 55, H * 0.15);
ctx.lineTo(padL + 48, H * 0.15 - 4);
ctx.lineTo(padL + 48, H * 0.15 + 4);
ctx.closePath();
ctx.fillStyle = 'rgba(255,255,255,0.6)';
ctx.fill();
ctx.fillStyle = 'rgba(255,255,255,0.6)';
ctx.font = '10px Roboto Mono, monospace';
ctx.fillText('U∞', padL + 58, H * 0.15 + 4);
// Animate particles
animT += 1;
for (let p of particles) {
const xFrac = (p.x - padL) / drawW;
const xPhys = Math.max(0.001, xFrac * L);
let delta;
if (showTurb && Uinf * xPhys / nu > 5e5) {
delta = 0.37 * xPhys / Math.pow(Uinf * xPhys / nu, 0.2);
} else {
delta = deltaLam(xPhys, Uinf, nu);
}
const deltaScaled = Math.min(delta / L * drawW * 2.5, wallY * 0.85);
const distFromWall = wallY - p.y;
// Velocity profile: Blasius-like, 1 in free stream, ~0 near wall
let uFrac;
if (distFromWall <= 0) {
uFrac = 0;
} else if (deltaScaled < 1 || distFromWall > deltaScaled * 1.5) {
uFrac = 1.0;
} else {
const eta = distFromWall / deltaScaled;
// Approximate Blasius: u/U ≈ tanh(2.5*eta)
uFrac = Math.tanh(2.5 * eta);
}
const spd = uFrac * Uinf * 0.3;
p.x += spd;
// Fade color by layer: blue near wall, white in free stream
const alpha = 0.55 + uFrac * 0.35;
const r = Math.round(uFrac * 180);
const g = Math.round(100 + uFrac * 100);
const b = 255;
ctx.beginPath();
ctx.arc(p.x, p.y, 2, 0, Math.PI * 2);
ctx.fillStyle = `rgba(${r},${g},${b},${alpha})`;
ctx.fill();
// Reset particle when it exits right or is in the wall
if (p.x > padL + drawW || p.y >= wallY) {
p.x = padL + Math.random() * 20;
p.y = Math.random() * (wallY - 4);
}
}
requestAnimationFrame(frame);
}
frame();
})();
What is a Boundary Layer?
🙋
What exactly is a "boundary layer" on a flat plate? I hear the term a lot in aerodynamics.
🎓
Basically, it's the thin layer of fluid right next to a surface where the flow speed changes from zero at the wall to the full "freestream" velocity. In practice, it's where all the friction and drag forces come from. Try moving the "Kinematic Viscosity (ν)" slider in the simulator above from air to a thicker fluid like oil. You'll see the boundary layer get much thicker because the fluid "sticks" more to the plate.
🙋
Wait, really? So the air isn't moving at all right on the surface of the wing? And why does the layer "grow" along the plate?
🎓
That's right, it's called the "no-slip condition"—the fluid molecules right at the wall have zero velocity. The layer grows because the slowing effect of friction diffuses further into the flow as you move downstream. A common case is water flowing over a ship's hull. In the simulator, you can see this growth visually as the blue shaded region widens from the leading edge (left) to the trailing edge (right).
🙋
Okay, that makes sense for the smooth-looking layer. But what's the deal with the "Turbulent Boundary Layer" checkbox? It looks all wavy and chaotic.
🎓
Great question! That's a major transition. Initially, the layer is laminar—smooth and orderly. Further down the plate, it becomes unstable and transitions to turbulent, which is chaotic and mixes fluid rapidly. For instance, on a commercial airplane wing, the flow starts laminar at the front but becomes turbulent over most of the wing. Check that box in the simulator to see how the velocity profile becomes much fuller near the wall, which increases skin friction drag but also makes it harder for the flow to separate.
Physical Model & Key Equations
The growth of the laminar boundary layer thickness (δ) along a flat plate is derived from the principles of fluid viscosity and momentum, often using the Blasius solution. It depends on the distance from the leading edge (x) and the fluid's kinematic viscosity (ν).
Where: δ = Boundary layer thickness (m) x = Distance from leading edge (m) ν = Kinematic viscosity of the fluid (m²/s) – This is the parameter you adjust in the simulator. U∞ = Freestream velocity (m/s) – Held constant in this simulation.
Once the flow transitions to turbulent, the mixing of momentum is much more effective, leading to faster growth. The thickness for a turbulent boundary layer is governed by a different, empirical relationship.
$$ \delta_{turb}(x) \approx 0.37 x \left( \frac{\nu}{U_\infty x}\right)^{1/5}$$
Where variables are the same as above. Notice the exponent: the laminar layer grows with $\sqrt{x}$ (slower), while the turbulent layer grows with $x^{4/5}$ (much faster). This is why checking the "Turbulent" box in the simulator shows a dramatically thicker layer at the trailing edge.
Frequently Asked Questions
The transition point occurs at the position where the Reynolds number reaches approximately 5×10^5. When you change the mainstream velocity, kinematic viscosity, or plate length in the simulator, the transition position is updated in real time according to those conditions, and it is displayed as a switch on the boundary layer thickness graph.
The Blasius solution is an exact solution for the laminar boundary layer, where the velocity profile is nearly parabolic and the thickness is proportional to the square root of x. The 1/7th power law is an empirical rule for the turbulent boundary layer, where the thickness is proportional to x to the 0.8 power and grows more rapidly than in the laminar case. Both can be compared in the simulator.
The horizontal axis represents the distance from the plate (y-direction), and the vertical axis represents the flow velocity. The velocity is zero at the wall and asymptotically approaches the mainstream velocity at the outer edge. The laminar flow shows a gentle curve, while the turbulent flow has a steep gradient near the wall. By comparing with the Blasius solution, you can check the agreement with theory.
Increasing the kinematic viscosity reduces the Reynolds number, making the laminar region longer. Conversely, decreasing it causes earlier transition to turbulence and thickens the entire boundary layer. For example, this parameter adjustment is effective when simulating the difference between water and air.
Real-World Applications
Aircraft Wing Design: Engineers meticulously calculate boundary layer growth to predict drag and optimize fuel efficiency. They often use "laminar flow" wing sections to delay the transition to turbulence as long as possible, reducing skin friction. The simulator's visualization directly relates to the airflow over these surfaces.
Ship Hull Hydrodynamics: The boundary layer in water is crucial for determining the power needed to propel a ship. A thicker boundary layer, like when you set the simulator fluid to oil, means more frictional resistance. Hull coatings are designed to minimize this effect.
Heat Exchanger & Duct Flow: In pipes and ducts, the boundary layer determines the pressure drop and heat transfer rates. A turbulent boundary layer, while causing more drag, transfers heat more efficiently—a key trade-off in designing cooling systems for electronics or engines.
Automotive Aerodynamics: The boundary layer development over a car's body affects drag, lift, and even cooling airflow to the brakes and radiator. Managing where it transitions from laminar to turbulent is a key part of wind tunnel testing and computational fluid dynamics (CFD) analysis in CAE.
Common Misconceptions and Points of Caution
Model assumptions: The mathematical model used here relies on simplifying assumptions such as linearity, homogeneity, and isotropy. Always verify that your real system satisfies these assumptions before applying results directly to design decisions.
Units and scale: Many calculation errors arise from unit conversion mistakes or order-of-magnitude errors. Pay close attention to the units shown next to each parameter input.
Validating results: Always sanity-check simulator output against physical intuition or hand calculations. If a result seems unexpected, review your input parameters or verify with an independent method.
Related Engineering Fields
Structural & Mechanical Engineering: Solid mechanics, elasticity theory, and materials science form the foundation for many of the governing equations used here.
Fluid & Thermal Engineering: Fluid dynamics and heat transfer share similar mathematical structures (conservation equations, boundary-value problems) and frequently appear in multi-physics problems alongside structural analysis.
Control & Systems Engineering: Dynamic system analysis, state-space methods, and signal processing connect to the time-dependent behaviors modeled in this simulator.