OpenFOAM Solver Selection Guide

#+CATEGORY: openfoam # :PROPERTIES: # :ID: uuid-openfoam-solver-selection # :END:

OpenFOAM Solver Selection :: Decision Tree for Choosing the Right Solver

This note provides a structured decision tree for selecting the right OpenFOAM solver for any given CFD problem. It maps physical assumptions (incompressible vs compressible, steady vs transient, laminar vs turbulent) to specific solvers. This is the practical counterpart to Governing Equations, which defines the equations each solver approximates.

Every OpenFOAM solver implements a specific subset of the Navier–Stokes equations. Choosing the wrong solver — for instance, using an incompressible solver for a flow with Mach > 0.3 — produces results that are qualitatively correct but quantitatively wrong (often by enough to invalidate engineering conclusions).

**Table of Contents**

• Decision Tree :: Step-by-step solver selection
• Incompressible Solvers :: simpleFoam, pimpleFoam, pisoFoam, icoFoam
• Compressible Solvers :: rhoSimpleFoam, rhoPimpleFoam, sonicFoam
• Buoyancy-Driven Solvers :: buoyantBoussinesqSimpleFoam, buoyantSimpleFoam
• Multiphase Solvers :: interFoam, twoPhaseEulerFoam, DPMFoam
• Combustion Solvers :: reactingFoam, XiFoam, engineFoam
• Turbulence Model Pairing :: which model for which solver
• See Also
• References

Solver Selection Decision Tree :: Step-by-Step Solver Selection

Select a solver by answering these questions in order:

. Incompressible or compressible? — Is density constant (incompressible), or does it vary via an equation of state (compressible)? If Ma < 0.3, incompressible is usually adequate. If not, use a compressible solver. . Steady-state or transient? — Is the flow time-independent (steady-state), or are transient effects important (transient)? Steady-state allows segregated SIMPLE solving; transient requires PISO/PIMPLE. . Turbulent or laminar? — If Re > ~3000 (pipe flow) or the flow is known to be turbulent, a turbulence model is needed. If laminar, use the laminar solver and do not specify a RAS/LES model. . Single-phase or multiphase? — Is there only one phase (single-phase), or is there a free surface (VOF), multiple immiscible fluids (Eulerian–Eulerian), or discrete particles (Eulerian–Lagrangian)? . Moving mesh or static mesh? — Does the mesh deform or move (dynamic mesh, rotating frame, FSI)? If yes, add the dynamicMeshDict and use a dYm solver variant. . Heat transfer or isothermal? — Is temperature (or enthalpy) a transported quantity? If yes, select a solver with energy equation support.

The result of this decision tree is a single solver name. The sections below enumerate all available solvers for each branch.

Incompressible Solvers :: simpleFoam, pimpleFoam, pisoFoam, icoFoam

The incompressible solver family solves the continuity equation (= \nabla \cdot \vec{v} = 0/) and the momentum equation for constant-density flow. Pressure acts as a Lagrange multiplier enforcing incompressibility. These correspond to Incompressible Flow.

**simpleFoam — Steady-state, incompressible, turbulent**

Uses the SIMPLE algorithm with a segregated solution approach. Always RANS — there is no transient term. The standard workhorse for engineering CFD: external aerodynamics (drag/lift of cars, buildings), internal flows (ducts, pumps, valves), and any steady-state incompressible turbulent flow.

fvSchemes (standard):

ddtSchemes
{
    default         none;      // steady-state: no time derivative
}
divSchemes
{
    default         none;
    div(phi,U)      bounded Gauss linearUpwind Grad U;
    div(phi,k)      bounded Gauss upwind;
    div(phi,omega)  bounded Gauss upwind;
}
laplacianSchemes
{
    default         bounded gauss linear corrected;
}

fvSolution (standard):

solvers
{
    p
    {
        solver          GAMG;
        tolerance       1e-7;
        relTol          0.1;
        smoother        gaussSeidel;
    }
    U
    {
        solver          smoothSolver;
        smoother        symGaussSeidel;
        tolerance       1e-8;
        relTol          0.1;
    }
    k
    {
        solver          GAMG;
        tolerance       1e-8;
        relTol          0.1;
    }
    omega
    {
        solver          GAMG;
        tolerance       1e-8;
        relTol          0.1;
    }
}
relaxationFactors
{
    fields
    {
        p               0.3;     // pressure under-relaxation
    }
    equations
    {
        U               0.7;     // momentum under-relaxation
        k               0.5;     // turbulent kinetic energy
        omega           0.5;     // specific dissipation rate
    }
}

The under-relaxation factors are critical: pressure relaxation at ~0.3 is necessary because the pressure equation is a Poisson equation (the solver is solving for the pressure field that enforces divergence-free velocity). Without under-relaxation, SIMPLE diverges almost immediately. Momentum at 0.5–0.7 is standard. Turbulent quantities at 0.5–0.8.

**pimpleFoam — Transient, incompressible, turbulent**

Uses PIMPLE (merged PISO + SIMPLE with unterelaxation). This is the most versatile incompressible solver. It can handle large timesteps (CFL > 1) thanks to the SIMPLE component (under-relaxation) while still maintaining transient accuracy via the PISO component (corrector loops).

For LES simulations, pimpleFoam is the standard choice. For transient RANS (e.g., vortex shedding behind a bluff body), it is also standard. The PISO correctors (nNonOrthogonalCorrectors, nCorrectors) control accuracy: for LES with small timesteps (CFL ~ 1–5), 1–2 PISO correctors are adequate. For RANS with CFL > 10, 2–3 correctors are needed.

fvSolution (standard for LES):

PIMPLE
{
    momentumPredictor   yes;     // solve momentum equation
    nCorrectors         2;      // PISO corrector loops
    nNonOrthogonalCorrectors 0; // non-orthogonal corrections (0 for hex meshes)
    consistent          yes;    // consistent alpha packing (for multiphase)
    pRefValue           101325; // reference pressure (fix singular pressure system)
    pRefDomain          cell;   // reference pressure location
    pRefCell            0;      // reference pressure cell
}

**pisoFoam — Transient, incompressible, laminar or small CFL**

Uses PISO without SIMPLE under-relaxation. Suitable only for CFL < 1 (small timesteps). This solver does not under-relax — each PISO iteration fully corrects the pressure and velocity field. It is the simplest and fastest incompressible transient solver but only works with small timesteps.

**icoFoam — Transient, incompressible, laminar**

The simplest of all. Laminar flow (no turbulence model). Uses SIMPLEC-like algorithm (modified SIMPLE). Useful for code verification, educational purposes, or flows at very low Reynolds numbers. It is the OpenFOAM analogue to ANSYS Fluent's simpleFoam in laminar mode — which is just a segregated pressure-based steady-state solver without turbulence.

Compressible Solvers :: rhoSimpleFoam, rhoPimpleFoam, sonicFoam

The compressible solver family solves the full Navier–Stokes equations with the energy equation and an equation of state (rho = f(p, T)). These correspond to Compressible Flow.

**rhoSimpleFoam — Steady-state, compressible, turbulent**

Density-based (or coupled pressure-based) steady-state solver. Solves mass, momentum, energy, and turbulence equations. Used for high-speed internal flows (nozzles, diffusers, turbomachinery) with Ma typically < 2 (shocks are not well resolved in steady-state). Supports RANS turbulence models.

The conservation equations are solved in conservative form (same as Conservation Laws), with rho as the density field:

solvers
{
    rho
    {
        solver          PBiCG;
        preconditioner  DIC;
        tolerance       1e-8;
        relTol          0.1;
    }
    p
    {
        solver          PBiCG;
        preconditioner  DIC;
        tolerance       1e-6;
        relTol          0.1;
    }
    rhoU
    {
        solver          PBiCG;
        preconditioner  DiagPC;
        tolerance       1e-8;
        relTol          0.1;
    }
    h
    {
        solver          PBiCG;
        preconditioner  DIC;
        tolerance       1e-8;
        relTol          0.1;
    }
}

**rhoPimpleFoam — Transient, compressible, turbulent**

The compressible equivalent of pimpleFoam. Handles shocks, expansion fans, and unsteady compressible flow with turbulence. Used for transient external compressible flow (transonic airfoils, high-speed projectiles, jet exhausts). Supports RANS, LES, and DES turbulence models.

For shock capturing, rhoPimpleFoam uses limited linear schemes for the convective term — typically TVD schemes with the Sweby/venkat limiter. This is documented in Compression Schemes and implemented via the TVD mechanism in fvSchemes.

**sonicFoam — Steady-state, compressible, laminar (no turbulence)**

The simplest compressible solver. Laminar only, steady-state. Solves mass, momentum, and energy without turbulence. Useful for verifying compressible flow implementations, subsonic/supersonic nozzles at low Re, and code verification.

Buoyancy-Driven Solvers :: buoyantBoussinesqSimpleFoam, buoyantSimpleFoam

Buoyancy-driven flow arises when density varies with temperature (Boussinesq approximation for small temperature differences, or fully compressible for larger differences).

**buoyantBoussinesqSimpleFoam — Steady, incompressible, Boussinesq buoyancy**

Uses the Boussinesq approximation: density is constant everywhere except in the buoyancy term:

= \rho = \rho_0 [1 - \beta (T - T_0)]

This is appropriate for natural convection where the temperature difference is small relative to the absolute temperature (e.g., room-scale ventilation, heated enclosure flows). The solver couples momentum and energy through the buoyancy source term but treats density as constant for the continuity and momentum advection.

**buoyantSimpleFoam — Steady, compressible, buoyancy**

Full compressible treatment. Density varies via the ideal gas law:

= \rho = p / (R T)

This solver is for natural convection at high temperature differences, or chimney flows, where the Boussinesq approximation would be inadequate. It is the OpenFOAM equivalent of Fluent's buoyantBoussinesqSimpleFoam (Boussinesq) or coupled pressure-based with energy equation enabled — but Fluent does not offer a separate buoyancy solver; buoyancy is handled via a UDF or the bodyForceFilter.

Multiphase Solvers :: interFoam, twoPhaseEulerFoam, DPMFoam

Multiphase flow solvers are organised by the approach to tracking phases: Volume of Fluid (VOF) for sharp interfaces, Eulerian–Eulerian for interpenetrating continua, and Eulerian–Lagrangian for discrete particles.

**interFoam — VOF, two-phase, incompressible, immiscible**

The standard VOF solver. Tracks a single volume fraction field (= \alpha/) — =\alpha = 1/ indicates phase 1 (e.g., water), =\alpha = 0/ indicates phase 2 (e.g., air). The interface is one cell wide (or two cells with MULES correction). Surface tension is modelled via the Continuum Surface Force (CSF) model — equal and opposite forces on either side of the interface, proportional to surface tension coefficient and interpolated curvature.

fvSchemes
{
    div(phi,alpha)      MULES interIsoAdvector;  // interface compression (MULES)
}

The MULES (multidimensional universally limited encoder) scheme enforces boundedness of the volume fraction field (never < 0 or > 1). This is critical: loss of boundedness leads to negative or > 1 volume fractions, which produce unphysical densities and viscosities. MULES is the open-source answer to Fluent's Geo-Reconstruct VOF scheme — both are second-order accurate in space and strictly bounded.

For dynamic meshes with free surfaces, use interDyMFoam (interFoam with dynamic mesh).

**reactingTwoPhaseEulerFoam — Reacting, multiphase Eulerian–Eulerian**

Combines VOF with chemical reactions. Used for boiling with gas evolution, reacting sprays, and other multiphase-reacting flows.

**twoPhaseEulerFoam — Eulerian–Eulerian, multi-fluid**

Each phase is treated as an interpenetrating continuum with its own velocity field. This is appropriate for bubbly flow, fluidised beds, and dense particle suspensions where phase-drag models close the momentum exchange between phases. The governing equations are:

$$$$ \frac{\partial}{\partial t}(\alpha_k \rho_k) + \nabla \cdot (\alpha_k \rho_k \vec{v}_k) = 0 $$$$ $$$$ \frac{\partial}{\partial t}(\alpha_k \rho_k \vec{v}_k) + \nabla \cdot (\alpha_k \rho_k \vec{v}_k \vec{v}_k) = -\alpha_k \nabla p + \nabla \cdot \vec{\tau}_k + \vec{F}_{k,exchange} + \alpha_k \rho_k \vec{g} $$$$

where =\alpha_k/ is the volume fraction of phase k, and =\vec{F}_{k,exchange}/ is the momentum exchange (drag, lift, virtual mass) between phases.

**DPMFoam — Eulerian–Lagrangian, disperse phase in continuous fluid**

Tracks individual particle or droplet trajectories through a continuous phase flow field. The continuous phase (gas or liquid) is solved with a standard incompressible or compressible solver. The discrete phase is solved using Lagrangian particles with force balance:

$$$$ \frac{d\vec{v}_p}{dt} = \vec{F}_D (\vec{v} - \vec{v}_p) + \frac{\vec{g} (\rho_p - \rho)}{\rho_p} + \vec{F}_{other} $$$$

This is equivalent to ANSYS Fluent's Discrete Phase Model (DPM). OpenFOAM's DPMFoam is the basic form; for dense suspensions with particle–particle interactions, use MPPICFoam (Multiphase Particle-in-Cell).

Combustion Solvers :: reactingFoam, XiFoam, engineFoam

Combustion solvers add species transport chemical reaction source terms to the conservation equations. The computational cost is dominated by the chemistry source term evaluation.

**reactingFoam — Non-premixed, non-reacting or reacting**

The general-purpose reacting flow solver. Supports detailed chemistry (via CHEMKIN-format mechanisms), finite-rate chemistry, and eddy-dissipation models. The species transport equation:

$$$$ \frac{\partial (\rho Y_k)}{\partial t} + \nabla \cdot (\rho \vec{v} Y_k) = \nabla \cdot \left(\frac{\mu_t}{Sc_t} \nabla Y_k\right) + \dot{\omega}_k $$$$

is solved for each species, where =\dot{\omega}_k/ is the net production rate from chemical reactions (evaluated at each cell per timestep). The chemistry solver is typically VODE (an ODE solver for stiff reaction systems), compiled into the solver at build time.

For non-premixed combustion, the flamelet approach reduces the dimensional space of the chemistry from (N species + temperature) to (mixture fraction + scalar dissipation rate). This is done via the flameletPsiThermo thermophysical package, which pre-tabulates chemistry into a lookup table (psiThermo).

**XiFoam — Premixed combustion**

Models premixed combustion using the flame surface density approach:

= \nabla \cdot (\rho \tilde{\Xi} \vec{S}_L \hat{n}) /

where =\tilde{\Xi}/ is the filtered flame surface density and =S_L/ is the laminar flame speed. Suitable for spark-ignition and homogeneous charge compression ignition (HCCI) engine simulations.

**engineFoam — Spark-ignition engine simulation**

A specialized combustion solver for internal combustion engines, with moving mesh (dynamic mesh) for piston motion and valve opening. Includes:

. spark ignition (flame initiation model) . moving valve kinematics . charge motion (swirl, tumble) . wall heat transfer . exhaust gas recirculation (EGR)

This maps to Fluent's Engine Mode with moving mesh and detailed spray chemistry, which uses its own custom solver (not the standard Fluent solver). The moving mesh is handled via dynamicMeshDict with solidBodyMotion solvers in OpenFOAM; in Fluent, it uses Dynamic Mesh Zone with smoothMesh and layering.

For diesel/spray combustion, OpenFOAM uses reactingTwoPhaseEulerFoam (Eulerian–Eulerian with spray models) or external coupling to OpenFOAM-PIC (a Lagrangian particle tracking library). Fluent has a built-in Lagrangian droplet tracking model that is more mature.

Turbulence Model Pairing :: Which Model for Which Solver

Not every turbulence model is compatible with every solver. The selection is constrained by physics and by implementation.

The default recommendation for all wall-bounded turbulent flows is the =kOmegaSST/ model (SST = Shear Stress Transport, from Menter 1994). Reasons from Turbulence Models:

. Accurate in adverse pressure gradients (where k-\epsilon fails) . No wall-function required (low-Re formulation integrates through the viscous sublayer when y+ ~ 1) . Blends k-\omega near walls, k-\epsilon in free stream (via blending function) . Captures the correct limit of shear stress in boundary layers (the SST correction)

For flows with strong curvature, rotation, or separation, consider RSM (Reynolds Stress Model) — but note that RSM in OpenFOAM is less tested than in ANSYS Fluent and can be numerically more challenging.

See Also :: Related Notes

. Governing Equations — equations each solver solves . Incompressible Flow — physics assumptions and limits . Compressible Flow — compressible solver selection and shock capturing . Turbulence Models — RANS, LES, DES model descriptions . Pressure-Velocity Coupling — SIMPLE, SIMPLEC, PISO, PIMPLE . Compression Schemes — TVD limiters for compressible flows . Numerical Schemes in OpenFOAM — fvSchemes and fvSolution configuration . OpenFOAM Case Setup — turbulenceProperties, transportProperties . OpenFOAM Multiphase Flows — VOF, Eulerian-Eulerian, DPM solvers . OpenFOAM Combustion — reacting and premixed combustion solvers . ANSYS Fluent Overview — Fluent's solver architecture . ANSYS vs OpenFOAM Comparison — comprehensive solver comparison

References

. Weller, H.G., Tabor, G., Jasak, H., & Fureby, C. (1998). "A tensorial approach to computational continuum mechanics using object-oriented techniques." Computers in Physics, 12(6), 620-631. (Original OpenFOAM paper.) . Juhaero, T. (2012). OpenFOAM for CFD — A Tutorial Approach. APSCEN Press. (Solver selection guide.) . OpenFOAM User Guide (latest version). ESI OpenCFD. (Solver descriptions and tutorials.) . Versteeg, H.K. & Malalasekera, W. (2007). An Introduction to Computational Fluid Dynamics. Chapter 7 (Turbulence modelling).