OpenFOAM · Solver Processing · 2026

OpenFOAM Solver Processing in 2026

Q: What is the processing stage in OpenFOAM?

The processing stage in OpenFOAM is the solving stage, where the solver actually computes the flow. It comes after pre-processing, which prepares the mesh and fields, and before post-processing, which analyses the results. Processing is configured through several parts of the case: the boundary conditions on each field, any mesh motion, the physics models such as turbulence, the numerical schemes in fvSchemes, the linear solver settings in fvSolution, and the choice of solver application. Getting these right is what makes a simulation accurate and stable.

Q: What are the main boundary conditions in OpenFOAM?

The most common OpenFOAM boundary conditions include fixedValue, which sets a fixed value such as an inlet velocity, and zeroGradient, which sets a zero normal gradient such as at an outlet. The inletOutlet condition switches between zero gradient for outflow and a fixed value for inflow, which protects outlets against backflow. Other important conditions are wall for solid walls, slip for frictionless walls, cyclic for periodic geometry, empty for two-dimensional cases, and totalPressure and pressureInletOutletVelocity for pressure-driven boundaries. You can list all available conditions for a solver with the listScalarBCs and listVectorBCs options.

Q: How does mesh motion work in OpenFOAM?

Mesh motion in OpenFOAM lets the mesh move or deform during the simulation, which is needed for moving parts such as valves, pistons, rotating machinery and floating objects. It is configured in the dynamicMeshDict, and solvers that support it, such as the transient pimpleFoam solver with dynamic mesh, advance the mesh in time. Options include solid-body motion, mesh morphing, overset or chimera meshes for bodies moving through a background mesh, multiple reference frames for steady rotation, and adaptive mesh refinement that refines the mesh where the solution needs it. The right choice depends on how the geometry moves.

Q: What are fvSchemes and fvSolution in OpenFOAM?

fvSchemes and fvSolution are the two numerical control files in the system directory. fvSchemes selects the discretization schemes, including the time scheme in ddtSchemes, the gradient scheme in gradSchemes, the convection scheme in divSchemes, and the diffusion scheme in laplacianSchemes. fvSolution selects the linear solver and preconditioner for each field, such as GAMG or PCG for pressure and smoothSolver for velocity, and sets solution controls including under-relaxation factors and the corrector loops such as the number of non-orthogonal, inner and outer correctors. Together they control the accuracy and stability of the solution.

Q: Which OpenFOAM solver application should I use?

The solver application should match your physics. For steady-state incompressible turbulent flow, simpleFoam is the standard choice. For transient incompressible flow, pimpleFoam is used, and icoFoam is a simple laminar transient solver. For two-phase flows with a free surface, interFoam uses the volume of fluid method. For compressible flow there are solvers such as rhoCentralFoam and sonicFoam, and for heat transfer with solids there is chtMultiRegionFoam. Buoyancy-driven flows use solvers such as buoyantSimpleFoam. Choosing the solver that matches steady or transient, compressible or incompressible, and single or multiphase is the first processing decision.

Q: What turbulence models does OpenFOAM support?

OpenFOAM supports the full range of turbulence modelling approaches. The most common are Reynolds-averaged Navier-Stokes, or RANS, models such as k-epsilon and k-omega SST, which are efficient and widely used for engineering flows. It also supports large eddy simulation, or LES, which resolves the larger turbulent structures for higher fidelity at higher cost, and direct numerical simulation, or DNS, which resolves all scales and is used mainly for research. The turbulence model is selected in the momentum transport properties file, along with the associated wall functions, and the choice depends on the accuracy required and the computing resources available.

The heart of every simulation: how to configure boundary conditions, mesh motion, physics models, numerical schemes and the right solver application to run an OpenFOAM case correctly.

Pre-processing builds the mesh; post-processing shows the results — but processing is where the physics actually gets solved. This is the stage where OpenFOAM turns your case files into a flow field, and it's where the most important decisions live: the boundary conditions, any mesh motion, the physics models, the numerics, and the solver application you run. Get these right and the solver converges to an accurate answer; get them wrong and it diverges. This 2026 guide walks through all five, so you can set up the processing stage with confidence.

What Is the Processing Stage?

Processing (the solving stage) sits between pre-processing and post-processing. It's configured through five areas — the exact structure of this guide:



Boundary Conditions



Mesh Motion



Models



Numerics

⚙

Solver Applications

Where it fits: after you've built the case and mesh (see our OpenFOAM learning guide) and applied the setup hacks, processing is where you choose how the equations are solved.

1. Boundary Conditions

Every field (velocity U, pressure p, turbulence k/epsilon…) needs a boundary condition on every patch. These are set in the field files in the 0/ directory. The most important ones:

Condition	What it does	Typical use
`fixedValue`	Sets a fixed value	Inlet velocity/temperature
`zeroGradient`	Zero normal gradient	Outlet, fully-developed flow
`inletOutlet`	zeroGradient out, fixedValue on backflow	Outlets (backflow protection)
`totalPressure` / `prghTotalPressure`	Fixes total pressure	Pressure-driven inlets/outlets
`pressureInletOutletVelocity`	Velocity for pressure boundaries	With totalPressure
`noSlip` / `slip`	Wall: zero / frictionless velocity	Solid walls
`cyclic`	Links two patches as periodic	Repeated geometry
`empty`	Marks a direction as 2D	2D simulations

Discover them yourself: list every condition a solver supports with simpleFoam -listScalarBCs -listVectorBCs, and get a description of any one with foamInfo inletOutlet. Set inlet turbulence values with the turbulence intensity calculator.

#1 divergence cause: unphysical or mismatched BCs. Every field needs a sensible condition on every patch, and outlets should use inletOutlet to survive backflow.

2. Mesh Motion

When parts of your geometry move — valves, pistons, rotating machinery, floating objects — the mesh must move too. This is dynamic mesh, configured in constant/dynamicMeshDict and run with a motion-capable solver.

Approach	Best for
Solid-body / morphing motion	Prescribed movement, deforming domains
MRF (Multiple Reference Frame)	Steady rotation (fans, pumps) — cheap
Overset (chimera) mesh	Bodies moving through a background mesh
AMR (adaptive mesh refinement)	Refine where the solution needs it (e.g. interfaces)

Transient solvers like pimpleFoam with dynamic mesh (historically pimpleDyMFoam) advance the mesh each time step using a hybrid PISO-SIMPLE (PIMPLE) algorithm. Keep the Courant number in check for moving meshes.

3. Models

The models define the physics OpenFOAM solves. The most important is the turbulence model, set in constant/momentumTransport (or turbulenceProperties):

Approach	Models	Cost / fidelity
RANS	k-ε, k-ω SST, Spalart-Allmaras	Low cost — most engineering flows
LES	Smagorinsky, WALE, k-equation	Higher cost — resolves large eddies
DNS	(no model — resolve all scales)	Research only — very expensive

Other model families:

Thermophysical models — how density, viscosity, conductivity behave (incompressible, compressible, Boussinesq).
Multiphase models — e.g. the Volume of Fluid (VOF) method in interFoam for free surfaces.
Transport / source models (fvModels, fvOptions) — add porosity, MRF zones, heat sources, etc.

Model choice drives everything: k-ω SST is the reliable default for wall-bounded and separated flows; match the near-wall mesh to it with the y+ calculator, and confirm the flow regime with the Reynolds number calculator.

4. Numerics

The numerics control how the equations are discretized and solved — via two files in system/:

fvSchemes — discretization schemes

ddtSchemes      { default   steadyState; }   // time
gradSchemes     { default   Gauss linear; }   // gradients
divSchemes      { div(phi,U) bounded Gauss linearUpwind grad(U); }  // convection
laplacianSchemes{ default   Gauss linear corrected; } // diffusion
interpolationSchemes { default linear; }

fvSolution — linear solvers & control

solvers
{
    p   { solver GAMG;  preconditioner DIC;  tolerance 1e-6; }
    U   { solver smoothSolver; smoother GaussSeidel; tolerance 1e-8; }
}
relaxationFactors { U 0.7;  p 0.3; }        // under-relaxation (SIMPLE)
SIMPLE { nNonOrthogonalCorrectors 2; }      // mesh non-orthogonality
PIMPLE { nCorrectors 2; nOuterCorrectors 3; } // transient inner/outer loops

Pressure usually uses GAMG or PCG (with DIC); velocity uses smoothSolver or PBICGStab (with DILU).
Under-relaxation (steady/SIMPLE) keeps the solution from oscillating.
nNonOrthogonalCorrectors handles skewed meshes; nCorrectors/nOuterCorrectors control the PIMPLE loops.

Golden rule of numerics: start with robust, low-order schemes (upwind) to get a stable solution, then switch to higher-order (linearUpwind, limitedLinear) for accuracy. Verify results don't depend on the mesh with a grid-independence test.

5. Solver Applications

Finally, you pick the solver application — the executable that matches your physics. OpenFOAM ships dozens; the essentials:

Solver	Physics
`simpleFoam`	Steady, incompressible, turbulent (SIMPLE)
`pimpleFoam`	Transient, incompressible, turbulent (PIMPLE)
`icoFoam`	Transient, incompressible, laminar
`interFoam`	Two-phase (VOF) free-surface flow
`buoyantSimpleFoam`	Steady buoyant / HVAC flow
`rhoCentralFoam` / `sonicFoam`	Compressible / high-speed flow
`chtMultiRegionFoam`	Conjugate heat transfer (fluid + solid)

The first processing decision: match the solver to steady vs transient, incompressible vs compressible, and single- vs multi-phase. Run it from the case directory, redirecting to a log to monitor residuals. Explore the ecosystem in our best open-source CFD tools guide.

The Processing Workflow

Boundary conditions — set every field/patch in 0/.
Mesh motion — configure dynamicMeshDict if parts move.
Models — pick turbulence (+ thermophysical/multiphase) in constant/.
Numerics — set fvSchemes & fvSolution in system/.
Solver application — choose & run the matching solver.
Monitor — watch residuals & a physical quantity for convergence.

Authoritative external references: the OpenFOAM User Guide (boundaries, numerics, solvers) and the OpenFOAM documentation.

Frequently Asked Questions

What is the processing stage in OpenFOAM?

The solving stage, between pre- and post-processing. It's configured via boundary conditions, mesh motion, physics models, numerical schemes (fvSchemes/fvSolution) and the solver application.

What are the main boundary conditions in OpenFOAM?

fixedValue (inlet), zeroGradient (outlet), inletOutlet (backflow protection), wall/slip, cyclic (periodic), empty (2D), plus pressure conditions. List them with -listScalarBCs/-listVectorBCs.

How does mesh motion work in OpenFOAM?

Via dynamicMeshDict and a motion-capable solver (e.g. pimpleFoam with dynamic mesh). Options: solid-body/morphing motion, MRF for steady rotation, overset meshes, and adaptive mesh refinement.

What are fvSchemes and fvSolution in OpenFOAM?

fvSchemes sets discretization (ddt/grad/div/laplacian schemes); fvSolution sets linear solvers (GAMG/PCG/smoothSolver), relaxation and corrector loops. Together they control accuracy and stability.

Which OpenFOAM solver application should I use?

Match the physics: simpleFoam (steady incompressible), pimpleFoam (transient), interFoam (two-phase), rhoCentralFoam (compressible), chtMultiRegionFoam (conjugate heat transfer).

What turbulence models does OpenFOAM support?

RANS (k-ε, k-ω SST), LES (Smagorinsky, WALE) and DNS. Chosen in the momentum transport properties, with the choice driven by required accuracy vs cost.

Conclusion

Processing is where an OpenFOAM case comes alive — and it comes down to five decisions: physical boundary conditions on every patch, the right mesh motion for moving parts, the correct physics models (especially turbulence), stable-then-accurate numerics in fvSchemes and fvSolution, and the solver application that matches your flow. Set these deliberately — start robust, verify convergence, and refine — and OpenFOAM will reward you with accurate, stable results. Master the processing stage, and you've mastered the core of running CFD in OpenFOAM.

For more OpenFOAM, CFD and simulation tutorials plus free engineering calculators, explore Free CFD Tutorial. If this guide helped you, please share it with your fellow CFD engineers and students.

Search This Blog

Free Engineering Simulation Tutorial - Opensource Software & Simulation Guides