LAST SEEN ONLINE:
NOV 22, 2026 11:36 UTC
LOCAL_TIME_SYNC:
--:--:-- | -- _
← Digital notebook
CFD 21 min read First-Principles CFD / Module 8

Module 8: Fluid-Flow Solvers and Pressure-Velocity Coupling

Understand how CFD solvers combine continuity and momentum equations, why pressure correction is needed for incompressible flow, and how SIMPLE, PISO, and PIMPLE algorithms construct a consistent pressure-velocity solution.

Introduction

In the previous modules, we developed the governing equations, discretized spatial derivatives, assembled algebraic systems, and examined time integration and convection schemes.

We now bring these ideas together to understand how a CFD solver calculates a fluid-flow field.

Solving the momentum equations alone is not enough for incompressible flow. The calculated velocity must also satisfy continuity, which expresses conservation of mass. Pressure plays a special role because it adjusts the velocity field to make the flow satisfy this constraint.

This creates a coupled numerical problem: pressure influences velocity, velocity must satisfy continuity, and both fields must be determined consistently.

Algorithms such as SIMPLE, PISO, and PIMPLE are designed to handle this pressure–velocity coupling.

Learning objectives

By the end of this module, you should be able to:

  • Explain why pressure–velocity coupling is necessary in incompressible CFD.
  • Identify the continuity and momentum equations used by a fluid-flow solver.
  • Understand why pressure is not obtained from a separate ordinary evolution equation in standard incompressible flow.
  • Follow the main steps in pressure-correction methods.
  • Distinguish SIMPLE, PISO, and PIMPLE.
  • Understand the roles of under-relaxation, residuals, and continuity errors.
  • Recognize how these algorithms relate to practical CFD software.
  • Build a conceptual connection between discretized equations and the operations performed by a CFD solver.

1. The equations of incompressible fluid flow

For a Newtonian fluid with constant density and viscosity, the incompressible governing equations are continuity and momentum.

1.1 Continuity equation

The general mass-conservation equation is

∂ρ∂t+∇⋅(ρu)=0\frac{\partial \rho}{\partial t} + \nabla\cdot(\rho\mathbf{u})=0

Here, ρ\rho is density and u\mathbf{u} is the velocity vector.

For constant density, the equation reduces to

∇⋅u=0\boxed{\nabla\cdot\mathbf{u}=0}

This is the incompressibility constraint.

It means that the velocity field must have zero divergence. For a fixed control volume, the net volumetric flow rate across its boundary must balance.

In three dimensions,

∂u∂x+∂v∂y+∂w∂z=0\frac{\partial u}{\partial x} + \frac{\partial v}{\partial y} + \frac{\partial w}{\partial z}=0

where uu, vv, and ww are the velocity components in the xx, yy, and zz directions.

1.2 Momentum equation

The incompressible Navier–Stokes momentum equation for constant properties is

∂u∂t+∇⋅(uu)=−1ρ∇p+ν∇2u+f\boxed{ \frac{\partial\mathbf{u}}{\partial t} + \nabla\cdot(\mathbf{u}\mathbf{u}) = -\frac{1}{\rho}\nabla p + \nu\nabla^2\mathbf{u} + \mathbf{f} }

where:

  • u\mathbf{u} is velocity.
  • pp is pressure.
  • ρ\rho is constant density.
  • ν\nu is kinematic viscosity.
  • f\mathbf{f} is body force per unit mass.

The equation represents momentum conservation. The terms describe transient change, convective transport, pressure forces, viscous diffusion, and body forces.

An equivalent convective form is

∂u∂t+(u⋅∇)u=−1ρ∇p+ν∇2u+f\frac{\partial\mathbf{u}}{\partial t} + (\mathbf{u}\cdot\nabla)\mathbf{u} = -\frac{1}{\rho}\nabla p + \nu\nabla^2\mathbf{u} + \mathbf{f}

For a divergence-free velocity field, the conservative and convective forms are mathematically equivalent under the stated assumptions.

1.3 Why these equations must be solved together

The momentum equation contains pressure gradients, so pressure affects the velocity field.

The continuity equation constrains velocity, so not every velocity field produced by an arbitrary pressure field is acceptable.

A valid incompressible solution must satisfy both equations simultaneously.

This is the central challenge of pressure–velocity coupling.

2. Why pressure is special in incompressible flow

In a standard incompressible formulation, pressure is not determined by an independent equation of state such as the ideal-gas law.

Instead, pressure acts as a constraint-enforcing field. Its spatial distribution adjusts the velocity so that the velocity satisfies continuity.

Consider a simple physical example: fluid flows through a channel that narrows.

The velocity must change as the cross-sectional area changes. The pressure field adjusts to help drive the required acceleration while maintaining mass conservation.

In a numerical calculation, a provisional velocity field may violate continuity. The solver therefore calculates a pressure correction and uses it to adjust the velocity.

This is why many incompressible CFD algorithms contain a pressure equation even though the pressure field is not advanced as an independent scalar transport equation in the same way as temperature.

3. The pressure equation from continuity and momentum

To understand pressure correction, begin with a simplified momentum equation.

After spatial discretization, a representative momentum equation for a cell can be written schematically as

aPuP=HP−VP∇pPa_P\mathbf{u}_P = \mathbf{H}_P - V_P\nabla p_P

where:

  • aPa_P is the momentum-equation diagonal coefficient.
  • uP\mathbf{u}_P is the cell velocity.
  • HP\mathbf{H}_P contains contributions from neighboring cells, explicit terms, and other known contributions.
  • VPV_P is the cell volume.
  • ∇pP\nabla p_P is the pressure gradient.

The precise coefficients depend on the discretization and solver. This expression is a simplified representation of a finite volume momentum equation.

Rearranging gives

uP=HPaP−VPaP∇pP\mathbf{u}_P = \frac{\mathbf{H}_P}{a_P} - \frac{V_P}{a_P}\nabla p_P

Define a provisional velocity as

uP∗=HPaP\mathbf{u}_P^* = \frac{\mathbf{H}_P}{a_P}

and define a coefficient

dP=VPaPd_P=\frac{V_P}{a_P}

Then the velocity can be represented as

uP=uP∗−dP∇pP\boxed{ \mathbf{u}_P = \mathbf{u}_P^* - d_P\nabla p_P }

This simplified relation illustrates the pressure correction mechanism: changing pressure changes velocity.

The coefficient dPd_P is schematic here. Its exact form depends on how the momentum equation and pressure-gradient term are discretized.

3.1 Apply the continuity constraint

For incompressible flow,

∇⋅u=0\nabla\cdot\mathbf{u}=0

Substituting the velocity relation gives

∇⋅(u∗−d∇p)=0\nabla\cdot \left( \mathbf{u}^* - d\nabla p \right)=0

Therefore,

∇⋅(d∇p)=∇⋅u∗\boxed{ \nabla\cdot(d\nabla p) = \nabla\cdot\mathbf{u}^* }

This expression is a simplified pressure equation.

It shows that the pressure field is calculated so that the pressure-corrected velocity satisfies continuity.

The exact discrete pressure equation depends on the mesh, face-flux formulation, boundary conditions, and momentum discretization. On a general finite volume mesh, the solver normally constructs a pressure equation using the discrete continuity equation and the face-flux correction rather than simply applying the displayed differential expression directly.

4. A predictor-corrector view of pressure–velocity coupling

A useful way to understand pressure-correction methods is to divide the calculation into a prediction and a correction.

Step 1 — Momentum prediction Solve the discretized momentum equation using an available pressure field to obtain a provisional velocity or provisional face flux.

Step 2 — Continuity check Evaluate the provisional flow’s mass imbalance. If the fluxes do not balance, the velocity field does not yet satisfy the incompressibility constraint.

Step 3 — Pressure correction Solve a pressure or pressure-correction equation derived from the continuity requirement.

Step 4 — Correct the flow Update pressure, velocity, and face fluxes so that continuity is better satisfied.

Step 5 — Repeat as required Iterate until the coupled equations satisfy the selected convergence criteria.

This is the basic idea behind many pressure-correction algorithms. The specific equations, number of corrections, and iteration structure differ among methods.

5. Why correcting cell velocity is not enough

In a finite volume solver, continuity is usually enforced through fluxes across cell faces.

For a cell PP, the discrete mass balance can be written as

∑fm˙f=0\sum_f \dot{m}_f=0

where m˙f\dot{m}_f is the signed mass flow rate through face ff. The sign convention must be consistent, for example positive outward from the cell.

For constant density, the equivalent volumetric flux balance is

∑fΦf=0\sum_f \Phi_f=0

where Φf\Phi_f is the signed volumetric flow rate through a face.

A pressure-correction algorithm therefore needs a consistent way to correct face fluxes, not just the cell-centered velocity.

On a collocated mesh, pressure and velocity are stored at the same cell centers. A suitable face-flux interpolation is needed to avoid pressure–velocity decoupling and nonphysical pressure oscillations. In common finite volume approaches, a Rhie–Chow-type interpolation helps construct face fluxes that respond appropriately to neighboring pressure values.

The precise implementation varies by solver and discretization.

6. The SIMPLE algorithm

SIMPLE stands for Semi-Implicit Method for Pressure-Linked Equations.

It is a widely used pressure–velocity coupling algorithm, particularly for steady incompressible flow.

The central idea is to solve momentum equations using an available pressure field, calculate a pressure correction from continuity, and update the solution iteratively.

6.1 Main SIMPLE steps

  1. Initialize pressure, velocity, and any additional fields.
  2. Assemble and solve the momentum equations using the current pressure estimate.
  3. Calculate provisional face fluxes.
  4. Form and solve a pressure-correction equation from the discrete continuity requirement.
  5. Correct pressure, velocity, and face fluxes.
  6. Apply under-relaxation when appropriate.
  7. Solve any additional transport equations, such as turbulence or energy equations.
  8. Repeat until the convergence criteria are satisfied.

6.2 Pressure correction

Let the provisional pressure be p∗p^* and the pressure correction be p′p'.

Then the corrected pressure can be written as

p=p∗+p′p=p^*+p'

The provisional velocity is corrected using the pressure correction:

u=u∗−d∇p′\mathbf{u}=\mathbf{u}^*-d\nabla p'

This equation is schematic and assumes the relevant momentum-derived coefficient is represented by dd.

The pressure correction is chosen to reduce the mass imbalance of the provisional fluxes.

In SIMPLE, the velocity correction is based on an approximation to the response of the momentum equations. The method then repeats the momentum and pressure-correction sequence to converge the coupled solution.

6.3 Under-relaxation

For steady calculations, the full calculated update may be too aggressive. Under-relaxation limits how much a variable changes during one iteration.

A generic under-relaxed update is

ϕk+1=ϕk+ωϕ(ϕcalck+1−ϕk)\phi^{k+1} = \phi^k + \omega_\phi \left( \phi_{\mathrm{calc}}^{k+1}-\phi^k \right)

where:

  • ϕk\phi^k is the current iterative value.
  • ϕcalck+1\phi_{\mathrm{calc}}^{k+1} is the newly calculated value.
  • ωϕ\omega_\phi is the relaxation factor.

For the usual under-relaxation range,

0<ωϕ≤10<\omega_\phi\leq1

A smaller value reduces the size of each update. This may improve robustness but can slow convergence.

Under-relaxation is an iterative stabilization technique. It does not repair an incorrect physical model, invalid boundary conditions, or a fundamentally unsuitable discretization.

6.4 Strengths and limitations of SIMPLE

Strengths

  • Conceptually straightforward.
  • Well suited to many steady incompressible flow calculations.
  • Works naturally with iterative solution of the coupled equations.
  • Widely available in finite volume CFD software.

Limitations

  • May require many outer iterations.
  • Convergence can be sensitive to relaxation factors and equation coupling.
  • Strongly coupled or transient problems may benefit from other algorithmic arrangements.

SIMPLE is not limited exclusively to steady problems, but it is commonly associated with steady-state pressure–velocity coupling.

7. The PISO algorithm

PISO stands for Pressure-Implicit with Splitting of Operators.

It was developed for pressure–velocity coupling and is commonly used in transient CFD calculations.

Like SIMPLE, PISO predicts velocity and then uses pressure correction to enforce continuity. A key difference is that PISO typically performs multiple pressure-correction steps within a time step, reducing the need for repeated outer momentum solves in many transient implementations.

7.1 Main PISO steps

A simplified PISO time-step sequence is:

  1. Start from the previous time level.
  2. Assemble and solve the momentum equation to obtain a provisional velocity.
  3. Construct provisional face fluxes.
  4. Solve a pressure-correction equation.
  5. Correct pressure, velocity, and face fluxes.
  6. Perform additional pressure-correction steps as required by the algorithm.
  7. Advance to the next time step.

The exact sequence depends on the formulation and software implementation. Some solvers include additional non-orthogonal pressure corrections or other steps.

7.2 Why multiple corrections help

A single pressure correction may not adequately account for all coupling effects between pressure and momentum in a particular formulation.

Additional correction steps improve the consistency between pressure and velocity within the current time step.

The aim is to reduce the continuity error without necessarily repeating the entire momentum solution after every pressure correction.

7.3 PISO and time accuracy

PISO is a pressure–velocity coupling algorithm, not a time-discretization scheme by itself.

A transient solver still needs a temporal scheme such as Euler or a backward time scheme. It also needs spatial discretization schemes for convection and diffusion.

The time scheme controls temporal truncation error, while the pressure–velocity algorithm controls how the coupled equations are solved.

A well-converged PISO step does not automatically guarantee that the selected time step is accurate enough.

8. The PIMPLE algorithm

PIMPLE combines ideas from SIMPLE and PISO and is commonly used for transient simulations where additional outer iterations are beneficial.

It allows the solver to perform outer corrector iterations around the pressure–velocity solution and inner pressure-correction steps.

A simplified structure is:

  1. Advance to a new time level.
  2. Perform an outer iteration.
  3. Solve the momentum equation.
  4. Perform one or more pressure-correction steps.
  5. Update the coupled fields.
  6. Repeat outer iterations if required.
  7. Accept the time step and proceed.

This can be useful when the flow is strongly nonlinear or when tighter coupling is required within a time step.

PIMPLE can also be configured to perform fewer outer iterations for computational efficiency when the problem allows it.

8.1 SIMPLE, PISO, and PIMPLE compared

FeatureSIMPLEPISOPIMPLE
Common useSteady flowTransient flowTransient flow with outer iterations
Pressure correctionsIterative correctionMultiple corrections within a time stepMultiple corrections and optional outer iterations
Outer iterationsCentral to the methodOften limited in standard transient useExplicitly configurable
Under-relaxationCommon in steady calculationsDepends on formulation and solverDepends on solver configuration
Main purposeConverge coupled steady equationsImprove pressure–velocity consistency during a time stepCombine time-step correction with additional nonlinear coupling

These are common patterns rather than strict restrictions. The actual behavior depends on the solver implementation and configuration.

9. Residuals and convergence

CFD solvers commonly report residuals to indicate how well the discretized equations are being solved.

Suppose a discretized equation is

Ax=bA\mathbf{x}=\mathbf{b}

For an approximate solution x\mathbf{x}, the algebraic residual vector is

r=b−Ax\mathbf{r}=\mathbf{b}-A\mathbf{x}

A residual norm measures the size of this vector.

For example, the Euclidean norm is

∥r∥2=∑iri2\|\mathbf{r}\|_2 = \sqrt{\sum_i r_i^2}

A smaller residual generally indicates that the approximate solution satisfies the algebraic system more closely.

However, residual values are affected by equation scaling, normalization, solver implementation, and the selected norm. A residual of a given magnitude does not have a universal physical interpretation across all equations and solvers.

9.1 Residual convergence is not enough

A simulation may have small algebraic residuals but still contain:

  • An incorrect boundary condition.
  • An insufficiently resolved mesh.
  • An inaccurate time step.
  • An unsuitable physical model.
  • A significant global mass imbalance.
  • A solution that has not reached a steady physical state.

Convergence should therefore be assessed using several indicators.

9.2 Practical convergence indicators

Monitor:

  • Residual histories for pressure, velocity, and other solved variables.
  • Global mass imbalance.
  • Flow rate at inlets and outlets.
  • Pressure drop.
  • Forces such as drag and lift.
  • Temperatures or heat-transfer rates.
  • Time histories for transient calculations.

For a steady calculation, engineering quantities should become sufficiently insensitive to further iterations. For a transient calculation, the solver must converge the equations appropriately at each time step while preserving the evolution of the physical solution.

10. Continuity error and mass conservation

For incompressible flow, the discrete continuity equation requires the net mass flow rate across each cell boundary to balance.

For a cell PP,

∑fm˙f=0\sum_f \dot{m}_f=0

In practice, the numerical solution may have a nonzero imbalance because the equations are solved iteratively and to finite tolerances.

A normalized cell mass imbalance can be expressed schematically as

ϵP=∣∑fm˙f∣∑f∣m˙f∣+ε\epsilon_P = \frac{ \left|\sum_f\dot{m}_f\right| }{ \sum_f|\dot{m}_f|+\varepsilon }

where ε\varepsilon is a small positive number used to avoid division by zero. This is an illustrative diagnostic definition, not a universal software formula.

A global imbalance can be estimated from the difference between total inlet and outlet mass flow rates:

m˙imbalance=∑m˙in−∑m˙out\dot{m}_{\mathrm{imbalance}} = \sum \dot{m}_{\mathrm{in}} - \sum \dot{m}_{\mathrm{out}}

The signs and conventions must be defined consistently. For steady flow without mass sources, the total inlet and outlet mass flow rates should agree within numerical tolerances.

Mass conservation is an essential check because a solver may report small algebraic residuals while the flow still exhibits an unacceptable imbalance.

11. Boundary conditions and pressure–velocity coupling

Pressure–velocity coupling also depends on how boundary conditions are specified.

Typical boundary types include:

  • Velocity inlet: prescribes an inlet velocity or related flow condition.
  • Pressure outlet: prescribes a pressure reference or outlet pressure condition.
  • No-slip wall: sets the fluid velocity equal to the stationary wall velocity, usually zero for a fixed wall.
  • Symmetry boundary: imposes appropriate zero-normal-flow and zero-normal-gradient constraints for the idealized symmetry plane.

The exact pressure and velocity conditions must be compatible with the governing equations and the physical problem.

11.1 Pressure reference

In many incompressible formulations, only pressure gradients influence the momentum equation. Adding a constant to pressure therefore does not change the pressure gradient.

As a result, the pressure field may need a reference value or another appropriate constraint to remove the mathematical indeterminacy.

This is often called fixing the pressure reference or pressure datum.

It does not mean that the physical pressure everywhere is zero. It means the numerical system needs a defined reference when the equations determine pressure only up to an additive constant.

11.2 Inlet and outlet compatibility

Boundary conditions should provide enough information to define the problem without imposing incompatible constraints.

For example, prescribing all velocity components and pressure indiscriminately at every boundary can overconstrain some formulations.

The correct choices depend on whether the problem is internal or external flow, whether the boundary is an inlet or outlet, and how the governing equations are formulated.

12. A conceptual pressure-correction demonstration in Python

The following small example illustrates a mathematical idea: a provisional velocity field can have a nonzero divergence, and a pressure-like correction can be obtained by solving a Poisson equation.

This is not a complete CFD solver. It is a one-dimensional discrete analogy intended to demonstrate the correction principle. A one-dimensional incompressible velocity field satisfying strict periodic or closed-boundary constraints is highly restricted, so this example should not be interpreted as a physical one-dimensional incompressible flow simulation.

For a scalar provisional field u∗(x)u^*(x), consider the correction

u=u∗−dp′dxu=u^*-\frac{dp'}{dx}

Enforcing the one-dimensional constraint

dudx=0\frac{du}{dx}=0

gives

d2p′dx2=du∗dx\frac{d^2p'}{dx^2} = \frac{du^*}{dx}

The example solves the discrete correction equation with a zero-mean constraint on the correction field. Periodic finite differences are used only to illustrate the algebraic structure.

import numpy as np
import matplotlib.pyplot as plt

# Demonstration grid
n = 100
length = 1.0
dx = length / n
x = np.arange(n) * dx

# Illustrative provisional periodic velocity field
u_star = np.sin(2.0 * np.pi * x / length)

# Periodic first derivative
def derivative_periodic(field, spacing):
    return (
        np.roll(field, -1) - np.roll(field, 1)
    ) / (2.0 * spacing)

# Periodic second derivative
def second_derivative_periodic(field, spacing):
    return (
        np.roll(field, -1)
        - 2.0 * field
        + np.roll(field, 1)
    ) / spacing**2

# The correction equation is:
# laplacian(p_prime) = derivative(u_star)
rhs = derivative_periodic(u_star, dx)

# Construct the discrete periodic Laplacian matrix.
laplacian = np.zeros((n, n))

for i in range(n):
    laplacian[i, i] = -2.0 / dx**2
    laplacian[i, (i - 1) % n] = 1.0 / dx**2
    laplacian[i, (i + 1) % n] = 1.0 / dx**2

# The periodic Laplacian has a constant null space.
# Replace one row with a zero-mean pressure-correction constraint.
laplacian[0, :] = 1.0 / n
rhs[0] = 0.0

p_prime = np.linalg.solve(laplacian, rhs)

# Correct the velocity using the pressure-correction gradient.
u = u_star - derivative_periodic(p_prime, dx)

# Calculate a discrete divergence-like derivative.
div_u_star = derivative_periodic(u_star, dx)
div_u = derivative_periodic(u, dx)

print("Maximum provisional divergence:",
      np.max(np.abs(div_u_star)))

print("Maximum corrected divergence:",
      np.max(np.abs(div_u)))

fig, axes = plt.subplots(3, 1, figsize=(8, 9), sharex=True)

axes[0].plot(x, u_star)
axes[0].set_ylabel("Provisional u*")
axes[0].grid(True)

axes[1].plot(x, p_prime)
axes[1].set_ylabel("Correction p'")
axes[1].grid(True)

axes[2].plot(x, u)
axes[2].set_ylabel("Corrected u")
axes[2].set_xlabel("x")
axes[2].grid(True)

plt.tight_layout()
plt.show()

12.1 What this example demonstrates

The provisional field is constructed without enforcing the divergence constraint. A pressure-like correction is then calculated from a discrete Poisson equation and used to modify the field.

The example also highlights a common numerical issue: the periodic Laplacian has a constant null space. A pressure-correction system therefore requires an appropriate reference or compatibility treatment.

The central idea is relevant to incompressible CFD, but real solvers use multidimensional vector fields, mesh-dependent fluxes, momentum-equation coefficients, physical boundary conditions, and more carefully constructed discrete operators.

The code is intended as an educational demonstration rather than a benchmark-quality pressure–velocity implementation.

13. How this connects to OpenFOAM

OpenFOAM provides solvers that implement pressure–velocity coupling for different classes of flow problems.

Examples include:

  • simpleFoam, commonly used for steady incompressible flow with SIMPLE-based coupling.
  • pisoFoam, commonly used for transient incompressible flow with PISO-based coupling.
  • pimpleFoam, commonly used for transient incompressible flow with PIMPLE-based coupling.

Availability and exact solver behavior depend on the OpenFOAM distribution and release.

The numerical algorithm is only one part of a working case. The solver also relies on:

  • The mesh.
  • Initial and boundary conditions.
  • Physical properties.
  • Time and spatial discretization schemes.
  • Linear-solver settings.
  • Convergence and time-step controls.

In an OpenFOAM case, system/fvSolution typically contains linear-solver settings and algorithm controls, while system/fvSchemes contains spatial and temporal discretization choices.

For example, a SIMPLE control section may have a structure similar to the following:

SIMPLE
{
    nNonOrthogonalCorrectors 0;
}

This is only a small illustrative fragment, not a complete fvSolution file. Non-orthogonal correction settings and other controls should be selected according to the mesh and the solver’s requirements.

Do not assume that changing the coupling algorithm alone will fix a poorly constructed mesh, incorrect boundary conditions, or an unsuitable physical model.

14. A practical workflow for debugging a fluid-flow solver

When a calculation fails to converge or produces an implausible result, investigate the problem systematically.

  1. Check the mesh. Inspect cell quality, skewness, non-orthogonality, and near-wall resolution as appropriate for the case.
  2. Check boundary conditions. Confirm that inlet, outlet, and wall conditions match the physical problem.
  3. Check physical properties. Verify density, viscosity, dimensions, and unit consistency.
  4. Check the initial field. Unrealistic initial values can cause strong early transients or convergence difficulties.
  5. Inspect residual histories. Determine whether the equations converge, stagnate, or diverge.
  6. Monitor conservation. Check mass balance and relevant fluxes.
  7. Inspect physical quantities. Review pressure drop, velocity profiles, forces, temperatures, and other outputs.
  8. Review discretization. If needed, start with robust schemes before testing higher-order options.
  9. Adjust algorithm controls carefully. Relaxation factors, pressure corrections, and iteration limits should be changed based on the observed failure mode.
  10. Verify the result. Compare against analytical solutions, benchmark data, or systematic mesh and time-step studies.

A converged solver is not automatically a validated simulation. Numerical convergence, verification, and physical validation answer different questions.

15. Common misconceptions

Misconception 1: Pressure is simply another transported scalar

In standard incompressible formulations, pressure is closely tied to the continuity constraint. Its role differs from that of temperature or concentration.

Misconception 2: A small residual guarantees mass conservation

Residuals measure algebraic equation errors. Mass balance should be checked separately using the discrete face fluxes and global flow rates.

Misconception 3: PISO is a time-discretization scheme

PISO is a pressure–velocity coupling algorithm. The temporal derivative still requires a time-integration scheme.

Misconception 4: PIMPLE is always faster than SIMPLE or PISO

Performance depends on the problem, mesh, time step, solver settings, and degree of coupling. No algorithm is universally fastest.

Misconception 5: Under-relaxation improves physical accuracy automatically

Under-relaxation controls iterative updates. It can help achieve convergence, but it does not replace mesh refinement, time-step refinement, or model validation.

Misconception 6: Every CFD problem uses the same pressure equation

The pressure equation depends on the governing equations, the momentum discretization, the mesh, boundary conditions, and the chosen coupling algorithm.

16. Key takeaways

  • Incompressible CFD must satisfy both momentum conservation and the continuity constraint.
  • Pressure adjusts the velocity field so that discrete mass conservation is satisfied.
  • Pressure-correction methods use a provisional flow field, solve a pressure equation, and correct pressure, velocity, and face fluxes.
  • SIMPLE is commonly used for steady pressure–velocity coupling.
  • PISO uses multiple pressure corrections within a time step and is common in transient calculations.
  • PIMPLE combines pressure corrections with optional outer iterations for transient problems.
  • Under-relaxation can improve iterative robustness but may slow convergence.
  • Residuals, mass imbalance, physical quantities, and resolution studies should all be considered when assessing a simulation.
  • The coupling algorithm, time scheme, spatial discretization, mesh, and boundary conditions work together to determine the quality of a CFD solution.

What’s next?

In Module 9: Verification, Validation, and Numerical Quality, we will examine how to determine whether a CFD implementation is correct, whether a numerical solution is sufficiently resolved, and whether simulation results agree with physical evidence. We will bring together analytical solutions, benchmark cases, conservation checks, grid refinement, and uncertainty.