Fluid Kinematics

The geometry and description of fluid motion without considering forces

Introduction

Fluid kinematics studies the motion of fluids without considering the forces that cause the motion. It describes how fluids move - velocity fields, acceleration, deformation rates - but not why they move.

This geometric description is essential for deriving conservation laws and understanding flow patterns before tackling the full dynamics problem.

Lagrangian vs Eulerian Description

Lagrangian Description

Follow individual fluid particles as they move through space:

$$\vec{x} = \vec{x}(\vec{x}_0, t)$$

• Track each particle's trajectory
• Natural for solid mechanics
• Useful for particle-laden flows
• Computationally expensive for fluids

Eulerian Description

Describe flow properties at fixed points in space:

$$\vec{v} = \vec{v}(\vec{x}, t)$$

• Field description (velocity field)
• Natural for fluid mechanics
• Fixed measurement locations
• Standard approach for Navier-Stokes

Material Derivative

The connection between descriptions - the rate of change following a fluid particle:

$$\frac{D\phi}{Dt} = \frac{\partial \phi}{\partial t} + (\vec{v} \cdot \nabla)\phi$$

∂φ/∂t - Local (Eulerian) rate of change at fixed point

(v·∇)φ - Convective change due to motion through varying field

Flow Visualization Lines

Streamlines

Curves tangent to the velocity field at a given instant:

$$\frac{dx}{v_x} = \frac{dy}{v_y} = \frac{dz}{v_z}$$

No flow crosses a streamline (by definition). In steady flow, streamlines are fixed in space.

Pathlines

Trajectories traced by individual fluid particles over time:

$$\frac{d\vec{x}}{dt} = \vec{v}(\vec{x}, t)$$

Obtained by integrating the velocity field along particle paths (Lagrangian).

Streaklines

The locus of all particles that have passed through a given point:

Like dye injection - shows the current positions of all particles that passed through the injection point. In experiments, smoke or dye traces produce streaklines.

Important Note

For steady flow, streamlines, pathlines, and streaklines all coincide. For unsteady flow, they differ and must be distinguished carefully.

Vorticity and Circulation

Vorticity

The curl of the velocity field - measures local rotation:

$$\vec{\omega} = \nabla \times \vec{v} = \begin{pmatrix} \frac{\partial v_z}{\partial y} - \frac{\partial v_y}{\partial z} \\ \frac{\partial v_x}{\partial z} - \frac{\partial v_z}{\partial x} \\ \frac{\partial v_y}{\partial x} - \frac{\partial v_x}{\partial y} \end{pmatrix}$$

Vorticity equals twice the angular velocity of a fluid element: ω = 2Ω

Circulation

Line integral of velocity around a closed curve:

$$\Gamma = \oint_C \vec{v} \cdot d\vec{l} = \int_S \vec{\omega} \cdot d\vec{A}$$

By Stokes' theorem, circulation equals the flux of vorticity through any surface bounded by C.

Irrotational Flow

ω = 0 everywhere → potential flow exists: v = ∇φ

Rotational Flow

ω ≠ 0 in some regions (boundary layers, wakes, vortices)

Reynolds Transport Theorem

The fundamental theorem relating system (Lagrangian) and control volume (Eulerian) analyses:

$$\frac{d}{dt}\int_{sys} \phi \rho \, dV = \frac{\partial}{\partial t}\int_{CV} \phi \rho \, dV + \oint_{CS} \phi \rho (\vec{v} \cdot \hat{n}) \, dA$$

Left Side

Rate of change of property φ for a system (material volume)

Right Side

Rate of change in CV + net flux through control surface

This theorem is the starting point for deriving integral forms of mass, momentum, and energy conservation.

Velocity Gradient and Deformation

The velocity gradient tensor describes how fluid elements deform:

$$\frac{\partial v_i}{\partial x_j} = \underbrace{\frac{1}{2}\left(\frac{\partial v_i}{\partial x_j} + \frac{\partial v_j}{\partial x_i}\right)}_{e_{ij} \text{ (strain rate)}} + \underbrace{\frac{1}{2}\left(\frac{\partial v_i}{\partial x_j} - \frac{\partial v_j}{\partial x_i}\right)}_{\omega_{ij} \text{ (rotation)}}$$

Linear Strain

e_ii - elongation/compression along axes

Shear Strain

e_ij (i≠j) - angular deformation

Volumetric Strain

∇·v = e_ii - rate of volume change

Interactive Simulations

Vorticity and Circulation in a Rankine Vortex

Python

script.py43 lines

import numpy as np

# Rankine Vortex: solid-body rotation inside core,
# irrotational (potential) flow outside core

Gamma = 10.0      # circulation strength (m^2/s)
R_core = 1.0      # vortex core radius (m)
N = 20            # number of radial points

r = np.linspace(0.1, 5.0, N)

print("Rankine Vortex Flow Field")
print("=" * 60)
print(f"Circulation Gamma = {Gamma:.1f} m^2/s")
print(f"Core radius R = {R_core:.1f} m")
print()
print(f"{'r (m)':>8} {'v_theta (m/s)':>14} {'omega (1/s)':>12} {'Region':>12}")
print("-" * 50)

for ri in r:
    if ri <= R_core:
        # Solid body rotation inside core
        omega = Gamma / (2 * np.pi * R_core**2)
        v_theta = omega * ri
        vorticity = 2 * omega
        region = "Core"
    else:
        # Irrotational flow outside core
        v_theta = Gamma / (2 * np.pi * ri)
        vorticity = 0.0
        region = "Irrotational"
    print(f"{ri:8.2f} {v_theta:14.4f} {vorticity:12.4f} {region:>12}")

# Verify circulation using line integral
theta = np.linspace(0, 2*np.pi, 1000)
for R_path in [0.5, 1.0, 2.0, 4.0]:
    if R_path <= R_core:
        vt = (Gamma / (2*np.pi*R_core**2)) * R_path
    else:
        vt = Gamma / (2*np.pi*R_path)
    circ = vt * 2 * np.pi * R_path
    print(f"\nCirculation at r={R_path:.1f}m: {circ:.4f} m^2/s")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Strain Rate and Deformation in 2D Flow

Fortran

program.f9060 lines

program strain_rate
  implicit none
  ! Analyze strain rate tensor for a 2D stagnation point flow
  ! u = a*x, v = -a*y (incompressible, irrotational)
  real(8) :: a, x, y, dudx, dudy, dvdx, dvdy
  real(8) :: e11, e12, e22, omega_z
  real(8) :: principal1, principal2, max_shear
  integer :: i, j
  real(8) :: coords(5)

a = 2.0d0  ! strain rate parameter (1/s)
  coords = (/ -2.0d0, -1.0d0, 0.0d0, 1.0d0, 2.0d0 /)

write(*,'(A)') "2D Stagnation Point Flow: Strain Rate Analysis"
  write(*,'(A)') "================================================"
  write(*,'(A,F6.2,A)') "Flow: u = ", a, "*x,  v = -a*y"
  write(*,*)
  write(*,'(A6,A6,A10,A10,A10,A10,A12)') &
    "x", "y", "e_xx", "e_xy", "e_yy", "omega_z", "Max Shear"
  write(*,'(A)') repeat("-", 66)

do i = 1, 5
    do j = 1, 5
      x = coords(i)
      y = coords(j)

! Velocity gradients
      dudx = a
      dudy = 0.0d0
      dvdx = 0.0d0
      dvdy = -a

! Strain rate tensor: e_ij = 0.5*(du_i/dx_j + du_j/dx_i)
      e11 = dudx
      e22 = dvdy
      e12 = 0.5d0 * (dudy + dvdx)

! Vorticity (should be zero for irrotational flow)
      omega_z = 0.5d0 * (dvdx - dudy)

! Principal strain rates
      principal1 = 0.5d0*(e11+e22) + &
        sqrt(0.25d0*(e11-e22)**2 + e12**2)
      principal2 = 0.5d0*(e11+e22) - &
        sqrt(0.25d0*(e11-e22)**2 + e12**2)
      max_shear = 0.5d0*(principal1 - principal2)

if (mod((i-1)*5+j-1, 5) == 0) then
        write(*,'(F6.1,F6.1,F10.3,F10.3,F10.3,F10.3,F12.3)') &
          x, y, e11, e12, e22, omega_z, max_shear
      end if
    end do
  end do

write(*,*)
  write(*,'(A)') "Note: Vorticity = 0 confirms irrotational flow."
  write(*,'(A,F6.2,A)') "Divergence = e_xx + e_yy = ", &
    a + (-a), " (incompressible)"
end program strain_rate

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

Detailed Derivations

Derivation: Material Derivative D/Dt

Let φ(x, y, z, t) be any scalar field (temperature, density, etc.) described in the Eulerian frame. A fluid particle at position x(t) experiences the value φ(x(t), t).

The rate of change of φ following the particle is found by the chain rule:

$$\frac{d\phi}{dt}\bigg|_{\text{particle}} = \frac{\partial \phi}{\partial t} + \frac{\partial \phi}{\partial x}\frac{dx}{dt} + \frac{\partial \phi}{\partial y}\frac{dy}{dt} + \frac{\partial \phi}{\partial z}\frac{dz}{dt}$$

Recognise that dx/dt = u, dy/dt = v, dz/dt = w are the velocity components. Combining:

$$\boxed{\frac{D\phi}{Dt} = \underbrace{\frac{\partial \phi}{\partial t}}_{\text{local}} + \underbrace{(\vec{u} \cdot \nabla)\phi}_{\text{convective}}}$$

Local term ∂φ/∂t: the rate of change at a fixed point in space (e.g., temperature rising at a weather station). Convective term (u·∇)φ: change due to the particle moving through a spatially varying field (e.g., moving into a hotter region).

For a vector field v, the material derivative becomes:

$$\frac{D\vec{v}}{Dt} = \frac{\partial \vec{v}}{\partial t} + (\vec{v}\cdot\nabla)\vec{v}$$

This is the acceleration of a fluid particle and appears on the left side of the Navier-Stokes equations.

Derivation: Stream Function ψ for 2D Incompressible Flow

For 2D incompressible flow, the continuity equation is:

$$\frac{\partial u}{\partial x} + \frac{\partial v}{\partial y} = 0$$

Define a scalar function ψ(x, y) such that:

$$u = \frac{\partial \psi}{\partial y}, \qquad v = -\frac{\partial \psi}{\partial x}$$

Verify that continuity is satisfied automatically:

$$\frac{\partial u}{\partial x} + \frac{\partial v}{\partial y} = \frac{\partial^2 \psi}{\partial x \partial y} - \frac{\partial^2 \psi}{\partial y \partial x} = 0 \quad \checkmark$$

This holds identically by equality of mixed partial derivatives (Schwarz's theorem).

Lines of constant ψ are streamlines. Along a streamline dψ = 0:

$$d\psi = \frac{\partial \psi}{\partial x}dx + \frac{\partial \psi}{\partial y}dy = -v\,dx + u\,dy = 0$$

This gives dy/dx = v/u, which is the streamline equation.

The volume flow rate between two streamlines ψ₁ and ψ₂ is Q = ψ₂ − ψ₁, providing a direct physical interpretation of the stream function.

Derivation: Velocity Potential φ for Irrotational Flow

If the flow is irrotational, then the vorticity vanishes everywhere:

$$\vec{\omega} = \nabla \times \vec{u} = 0$$

From vector calculus, any curl-free vector field can be written as the gradient of a scalar potential:

$$\boxed{\vec{u} = \nabla\phi} \quad \Longrightarrow \quad u = \frac{\partial \phi}{\partial x},\; v = \frac{\partial \phi}{\partial y},\; w = \frac{\partial \phi}{\partial z}$$

For an incompressible fluid, ∇·u = 0. Substituting u = ∇φ:

$$\boxed{\nabla^2\phi = 0}$$

Laplace's equation! This is a linear PDE, so solutions can be superposed — the foundation of potential flow theory.

Lines of constant φ (equipotential lines) are perpendicular to streamlines (ψ = const), forming an orthogonal grid. This allows construction of flow nets for solving potential flow problems graphically.

Derivation: Vorticity Transport Equation

Start with the incompressible Navier-Stokes equation:

$$\frac{\partial \vec{u}}{\partial t} + (\vec{u}\cdot\nabla)\vec{u} = -\frac{1}{\rho}\nabla p + \nu\nabla^2\vec{u} + \vec{g}$$

Take the curl (∇×) of both sides. Key identities: ∇×(∇p) = 0 and ∇×(∇φ) = 0 for any scalar field. Also use the vector identity:

$$(\vec{u}\cdot\nabla)\vec{u} = (\nabla\times\vec{u})\times\vec{u} + \nabla\!\left(\frac{|\vec{u}|^2}{2}\right)$$

After taking the curl and simplifying (pressure gradient and gravity terms vanish for constant-density barotropic flow):

$$\boxed{\frac{D\vec{\omega}}{Dt} = (\vec{\omega}\cdot\nabla)\vec{u} + \nu\nabla^2\vec{\omega}}$$

(ω·∇)u — vortex stretching/tilting: vortex tubes can be stretched or tilted by velocity gradients (absent in 2D). ν∇²ω — viscous diffusion of vorticity: vorticity spreads by molecular diffusion, analogous to heat conduction.

Derivation: Reynolds Transport Theorem

Let B be an extensive property (mass, momentum, energy) and b = B/m the intensive form. The system (material volume) has property B_sys = ∫_sys ρb dV.

At time t, the system coincides with a fixed control volume (CV). At t + dt, the system has moved. Divide the region into three parts: the CV interior, the outflow region (II), and the inflow region (I).

Write the system property at t + dt:

$$B_{sys}(t+dt) = B_{CV}(t+dt) + dB_{\text{out}} - dB_{\text{in}}$$

The mass flowing out through area element dA in time dt is dm = ρ(u·n̂) dA dt. Thus dB_out − dB_in = &oint;_CS ρb(u·n̂) dA dt.

Form the time derivative and take the limit dt → 0:

$$\boxed{\frac{dB_{sys}}{dt} = \frac{\partial}{\partial t}\int_{CV} \rho\,b\,dV + \oint_{CS} \rho\,b\,(\vec{u}\cdot\hat{n})\,dA}$$

This converts any Lagrangian conservation law (for the system) into an Eulerian form (for the control volume). Setting b = 1 yields mass conservation; b = v yields momentum; b = e yields energy.

Flow Visualization: Streamlines, Pathlines & Streaklines

Comparison of the three flow-line types. In steady flow they coincide; in unsteady flow they differ.

Advanced Simulations

Streamfunction Contours: Rankine Body (Source + Sink + Uniform Flow)

Python

script.py71 lines

import numpy as np

# Rankine body: superposition of uniform flow + source + sink
# psi = U*y + (m/(2*pi)) * (theta_source - theta_sink)

U_inf = 1.0       # freestream velocity (m/s)
m = 5.0            # source/sink strength (m2/s)
a = 1.0            # half-distance between source and sink

# Grid
N = 15
xs = np.linspace(-4, 4, N)
ys = np.linspace(-3, 3, N)

print("=== Rankine Body: Stream Function Values ===")
print("  Uniform flow U = {:.1f} m/s".format(U_inf))
print("  Source at (-{0}, 0), Sink at (+{0}, 0), strength m = {1:.1f}".format(a, m))
print()

# Compute stream function on grid
print("  Stream function psi(x, y) at selected points:")
print("  {:>6s}  {:>6s}  {:>10s}  {:>10s}  {:>10s}".format("x", "y", "psi", "u", "v"))
print("  " + "-" * 48)

# Sample points along y=0 to find stagnation points
print()
print("--- Searching for stagnation points along y-axis (y=0) ---")
for xi in np.linspace(-3, 3, 61):
    yi = 0.001  # slightly off axis to avoid singularity
    r1 = np.sqrt((xi + a)**2 + yi**2)
    r2 = np.sqrt((xi - a)**2 + yi**2)
    theta1 = np.arctan2(yi, xi + a)
    theta2 = np.arctan2(yi, xi - a)

u_val = U_inf + (m/(2*np.pi)) * ((xi+a)/r1**2 - (xi-a)/r2**2)
    v_val = (m/(2*np.pi)) * (yi/r1**2 - yi/r2**2)

if abs(u_val) < 0.05:
        print("  Near stagnation at x = {:.3f}, u = {:.4f}".format(xi, u_val))

# Body half-length from analytic formula
x_stag = np.sqrt(a**2 + m*a/(np.pi*U_inf))
print()
print("  Analytic stagnation point: x = +/- {:.4f} m".format(x_stag))

# Compute psi and velocity at several points around the body
print()
print("--- Flow field at selected points ---")
print("  {:>6s}  {:>6s}  {:>10s}  {:>10s}  {:>10s}  {:>10s}".format(
    "x", "y", "psi", "u", "v", "speed"))
print("  " + "-" * 58)

sample_pts = [(-3,0.5), (-2,1), (-1,1.5), (0,2), (1,1.5), (2,1), (3,0.5),
              (0,0.5), (0,1.0), (0,1.5), (0,2.0), (0,2.5)]
for (xi, yi) in sample_pts:
    r1 = np.sqrt((xi+a)**2 + yi**2)
    r2 = np.sqrt((xi-a)**2 + yi**2)
    theta1 = np.arctan2(yi, xi+a)
    theta2 = np.arctan2(yi, xi-a)
    psi = U_inf*yi + (m/(2*np.pi))*(theta1 - theta2)
    u_val = U_inf + (m/(2*np.pi))*((xi+a)/r1**2 - (xi-a)/r2**2)
    v_val = (m/(2*np.pi))*(yi/r1**2 - yi/r2**2)
    spd = np.sqrt(u_val**2 + v_val**2)
    print("  {:6.1f}  {:6.1f}  {:10.4f}  {:10.4f}  {:10.4f}  {:10.4f}".format(
        xi, yi, psi, u_val, v_val, spd))

# Vorticity (should be zero for potential flow)
print()
print("  Vorticity everywhere = 0 (irrotational potential flow)")
print("  Body psi = {:.4f} (dividing streamline)".format(0.0))

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Vorticity Field: Lamb-Oseen Vortex Decay

Python

script.py37 lines

import numpy as np

# Lamb-Oseen vortex: exact unsteady solution to Navier-Stokes
# v_theta(r,t) = Gamma/(2*pi*r) * (1 - exp(-r^2/(4*nu*t)))
# omega_z(r,t) = Gamma/(4*pi*nu*t) * exp(-r^2/(4*nu*t))

Gamma = 10.0       # circulation (m2/s)
nu = 1e-3          # kinematic viscosity (m2/s) - like water

print("=== Lamb-Oseen Vortex: Vorticity Diffusion ===")
print("  Gamma = {:.1f} m2/s, nu = {:.1e} m2/s".format(Gamma, nu))
print()

times = [0.1, 0.5, 1.0, 2.0, 5.0, 10.0]
r_vals = np.linspace(0.01, 0.3, 15)

for t in times:
    r_core = np.sqrt(4*nu*t)  # core radius
    omega_max = Gamma / (4*np.pi*nu*t)
    print("--- t = {:.1f} s, core radius = {:.4f} m, omega_max = {:.2f} 1/s ---".format(
        t, r_core, omega_max))
    print("  {:>8s}  {:>12s}  {:>12s}".format("r (m)", "v_theta", "omega_z"))
    print("  " + "-" * 36)
    for r in r_vals[::3]:
        vt = Gamma/(2*np.pi*r) * (1 - np.exp(-r**2/(4*nu*t)))
        wz = Gamma/(4*np.pi*nu*t) * np.exp(-r**2/(4*nu*t))
        print("  {:8.4f}  {:12.4f}  {:12.4f}".format(r, vt, wz))
    print()

# Verify total circulation is conserved
print("=== Circulation Conservation Check ===")
for t in times:
    r_large = 10*np.sqrt(4*nu*t)
    circ = Gamma * (1 - np.exp(-r_large**2/(4*nu*t)))
    print("  t = {:5.1f} s, Gamma(r={:.2f}) = {:.6f} (should be {:.1f})".format(
        t, r_large, circ, Gamma))

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Fluid Statics Conservation Laws →