1. What fvSolution Controls

system/fvSolution controls how the discretised equations are solved and how the solution algorithm couples them. In OpenFOAM Foundation 14, this includes linear equation solvers, tolerances, preconditioners or smoothers, under-relaxation, and algorithm controls such as SIMPLE and PIMPLE. [1] [2]

For the broader case layout, see Ocean Tech Review’s OpenFOAM 14 case structure guide and OpenFOAM 14 solver architecture.

2. fvSchemes vs fvSolution

The division of responsibility is fundamental. fvSchemes selects how derivatives and finite-volume operators are discretised. fvSolution controls how the resulting algebraic equations are solved and coupled. Foundation 14 explicitly places discretisation in fvSchemes and equation solvers, tolerances and algorithm controls in fvSolution. [2]

3. Foundation 14 DTCHullMoving as the Working Example

The principal marine reference used in this article is the official Foundation 14 DTCHullMoving tutorial. Its fvSolution is a useful example because it combines VOF free-surface transport, pressure solution, turbulence transport, PIMPLE coupling and moving-mesh controls. [8]

FoamFile
{
    format      ascii;
    class       dictionary;
    location    "system";
    object      fvSolution;
}

solvers
{
    "alpha.water.*"
    {
        nCorrectors     3;
        nSubCycles      1;

        MULESCorr       yes;
        alphaApplyPrevCorr  yes;

        MULES
        {
            nIter       1;
        }

        solver          smoothSolver;
        smoother        symGaussSeidel;
        tolerance       1e-10;
        relTol          0;
        minIter         1;
    }

    "pcorr.*"
    {
        solver          GAMG;
        smoother        DIC;
        tolerance       1e-3;
        relTol          0;
    };

    p_rgh
    {
        solver          GAMG;
        smoother        DIC;
        tolerance       5e-8;
        relTol          0;
    };

    p_rghFinal
    {
        $p_rgh;
        relTol          0;
    }

    "(U|k|omega).*"
    {
        solver          smoothSolver;
        smoother        symGaussSeidel;
        nSweeps         1;
        tolerance       1e-7;
        relTol          0;
        minIter         1;
    };
}

PIMPLE
{
    momentumPredictor no;

    nOuterCorrectors 3;
    nCorrectors      1;
    nNonOrthogonalCorrectors 0;

    correctPhi      yes;
    moveMeshOuterCorrectors yes;
    transportCorrectionFinal yes;
}

relaxationFactors
{
    equations
    {
        ".*" 1;
    }
}

cache
{
    grad(U);
}

4. From a Discretised Equation to Ax = b

Finite-volume discretisation produces sparse algebraic systems that can be written schematically as A x = b. A linear solver iteratively reduces the residual of an individual matrix equation until an applicable stopping condition is met. [3] [7]

The key distinction is that GAMG, PCG, PBiCGStab and smoothSolver are linear equation solvers. They are not the same thing as an OpenFOAM solver module such as incompressibleVoF, which defines the physical system and governing equations. [1] [15]

5. Linear Solver Families and Matrix Symmetry

OpenFOAM Foundation 14 provides several solver families. Matrix symmetry matters because advection generally produces asymmetric matrices, while some pressure-type systems are symmetric under appropriate formulations. [1] [4] [7]

CFD Direct recommends PCG with DIC for symmetric matrices and PBiCGStab with DILU for asymmetric matrices. [4]

6. Preconditioners and Smoothers Are Different

A preconditioner changes the algebraic problem so that a Krylov solver converges more efficiently. DIC is designed for symmetric systems and DILU for asymmetric systems. [4]

A smoother is used by algorithms such as smoothSolver and GAMG to reduce error components through repeated sweeps. In DTCHullMoving, DIC appears as the smoother for GAMG, while symGaussSeidel is the smoother for smoothSolver. [1] [8]

p_rgh
{
    solver      GAMG;
    smoother    DIC;
}

"(U|k|omega).*"
{
    solver      smoothSolver;
    smoother    symGaussSeidel;
}

7. smoothSolver and nSweeps

smoothSolver repeatedly applies a selected smoother and checks residual reduction. In Foundation 14, nSweeps controls the number of smoothing sweeps before the residual is recalculated. A value of 1 is used in DTCHullMoving for U, k and omega. [1] [8]

"(U|k|omega).*"
{
    solver      smoothSolver;
    smoother    symGaussSeidel;
    nSweeps     1;
    tolerance   1e-7;
    relTol      0;
    minIter     1;
}

8. GAMG for Pressure-Type Systems

GAMG is OpenFOAM’s generalised geometric-algebraic multigrid solver. It constructs coarser algebraic levels so that error components with long spatial influence can be reduced efficiently. CFD Direct identifies multigrid as particularly effective for pressure-type equations. [1] [7]

DTCHullMoving uses:

p_rgh
{
    solver      GAMG;
    smoother    DIC;
    tolerance   5e-8;
    relTol      0;
}

Advanced GAMG controls include nCellsInCoarsestLevel, mergeLevels, pre/post sweeps and finest-level sweeps. They are optimisation controls, not values that should be changed automatically. [1]

9. tolerance and relTol

tolerance is an absolute stopping threshold for the normalised algebraic residual of a linear solve. relTol is a relative criterion based on the reduction from the initial residual of that same solve. [1] [3]

Conceptually, the relative condition is:

current residual / initial residual < relTol

Foundation 14 commonly uses relTol 0 in transient cases when each solve is intended to continue to its absolute tolerance. Other valid transient configurations use non-zero intermediate relTol values together with tighter Final solves. [1] [8] [10]

10. minIter, maxIter and Linear-Solver Stopping

OpenFOAM can terminate an iterative linear solve when an applicable residual criterion is reached or when the iteration limit is reached. minIter forces a minimum number of iterations; maxIter is a maximum iteration limit and does not prove convergence. Foundation 14 documents a default maxIter of 1000 when it is not specified. [1]

11. Final Solver Entries and Dictionary Reuse

OpenFOAM cases often define a normal solver block and a corresponding Final block. Dictionary substitution allows the final block to inherit the original settings and override only selected entries. Foundation 14 documents this pattern for repeated solves. [1]

p
{
    solver      GAMG;
    tolerance   1e-7;
    relTol      0.01;
}

pFinal
{
    $p;
    relTol      0;
}

The purpose is often to permit cheaper intermediate solves and then drive the final solve to the absolute tolerance. In DTCHullMoving, p_rgh already has relTol 0, so the inherited p_rghFinal currently has the same relative criterion but still provides a distinct final-solve configuration hook. [8]

12. Regular Expressions in the solvers Dictionary

OpenFOAM dictionary keywords can use regular expressions. DTCHullMoving groups several fields with:

"(U|k|omega).*"
{
    solver      smoothSolver;
    smoother    symGaussSeidel;
    tolerance   1e-7;
    relTol      0;
}

This allows one solver definition to match velocity and turbulence-related field names covered by the expression. The same mechanism is used for entries such as "alpha.water.*" and "pcorr.*". [8] [16]

13. Pressure–Velocity Coupling

In incompressible flow, mass conservation and momentum conservation are coupled through a pressure equation together with velocity and flux corrections. SIMPLE, PISO and PIMPLE organise the sequence and repetition of these corrections. [6] [7]

14. SIMPLE for Steady CFD

SIMPLE is generally used for steady flow solutions. Because steady equations lack the stabilising diagonal contribution of a time derivative, under-relaxation is commonly important for convergence. [5] [7]

Foundation 14 tutorials show the familiar starting pattern:

relaxationFactors
{
    fields
    {
        p 0.3;
    }

    equations
    {
        U 0.7;
        "(k|omega|epsilon).*" 0.7;
    }
}

CFD Direct notes that equation under-relaxation around 0.7 is commonly applied for steady flow and can be reduced toward 0.5 for less convergent cases. Foundation 14 tutorials also use p 0.3 and U 0.7 as common steady starting values. [5] [17]

15. PISO for Transient CFD

PISO is a transient pressure–velocity correction framework. The time derivative improves matrix diagonal dominance compared with a purely steady formulation, so conventional steady-state under-relaxation is generally less central to the transient algorithm. [7]

CFD Direct notes that typical PISO configurations may use two pressure solutions with a non-orthogonal correction or three pressure solutions without one, but actual Foundation 14 cases must be read as complete algorithms rather than tuned by one number in isolation. [7]

16. PIMPLE and Outer Iteration

PIMPLE combines PISO-style correctors with SIMPLE-style outer iteration. The outer loop allows coefficients, source terms, transport models and other coupled quantities to be updated within a time step. [6]

PIMPLE
{
    nOuterCorrectors 3;
    nCorrectors      1;
    nNonOrthogonalCorrectors 0;
}

DTCHullMoving uses three outer correctors, while other Foundation 14 transient examples use different values. More outer correctors increase computational work and should be justified by stronger within-step coupling or by measurable changes in the quantities of interest. [8] [9] [10]

17. nOuterCorrectors, nCorrectors and nNonOrthogonalCorrectors

These three numbers are not interchangeable. A case with three outer correctors and one pressure corrector does not perform the same sequence as one outer corrector and three pressure correctors. [1] [6] [8]

nNonOrthogonalCorrectors controls an algorithmic correction loop; the spatial discretisation of non-orthogonal terms belongs in fvSchemes, not fvSolution.

18. momentumPredictor

DTCHullMoving uses:

momentumPredictor no;

This disables the optional initial momentum-predictor solve in the coupling sequence. It does not remove the momentum equation from the simulation. Foundation documentation notes that disabling the predictor is common in some multiphase calculations. [1] [8]

19. Moving-Mesh Controls: correctPhi and moveMeshOuterCorrectors

Moving-mesh free-surface simulations introduce flux and mesh-motion controls that are irrelevant to a fixed-mesh steady case.

correctPhi                yes;
moveMeshOuterCorrectors   yes;

In the Foundation 14 VOF solver infrastructure, correctPhi controls flux correction following mesh change. moveMeshOuterCorrectors instructs the algorithm to move the mesh at the start of every PIMPLE outer corrector rather than only the first. [14] [15]

These controls are therefore particularly relevant to dynamic sinkage and trim, freely moving bodies and other moving-mesh marine calculations.

20. transportCorrectionFinal

DTCHullMoving also uses:

transportCorrectionFinal yes;

Foundation 14 source documentation defines this switch as controlling whether transport models are corrected only on the final PIMPLE outer iteration or on every outer iteration. [14]

21. relaxationFactors

Under-relaxation limits how much a field or equation changes between iterations and is especially important in steady-state CFD. Foundation 14 distinguishes field relaxation from equation relaxation. [1] [5]

For transient incompressible cases, Foundation practice commonly uses:

relaxationFactors
{
    equations
    {
        ".*" 1;
    }
}

For equation relaxation, a factor of 1 is commonly used in transient incompressible calculations to ensure diagonal equality; lower factors increase under-relaxation. By contrast, steady tutorials commonly use pressure field relaxation around 0.3 and equation relaxation around 0.7. [5] [17]

22. Residuals and What Convergence Means

The residual measures the imbalance remaining in an algebraic equation for the current iterate. Because the exact solution is generally unknown, residuals provide a practical convergence measure for the matrix solve. [3]

For CFD work, three distinct ideas should be kept separate:

A small linear residual does not by itself prove that a ship-resistance coefficient, wave signal or hydrodynamic load is converged. CFD Direct explicitly recommends monitoring suitable objective metrics such as force coefficients, and ITTC recommends examining forces, moments and important flow quantities alongside residual histories. [5] [12] [13]

23. residualControl for Steady Calculations

residualControl applies convergence limits at the outer solution-algorithm level rather than inside a single matrix solve. Foundation 14 tutorials use this mechanism to stop steady calculations when the initial residuals of all specified fields fall below their thresholds. [11] [17]

SIMPLE
{
    residualControl
    {
        p               1e-3;
        U               1e-4;
        "(k|epsilon)"   1e-4;
    }
}

The values above are taken from an official Foundation 14 steady incompressible tutorial and should be treated as a tutorial starting point, not as a marine-CFD validation criterion. [17]

24. VOF and MULES Controls in fvSolution

Free-surface VOF cases contain phase-fraction controls in addition to conventional linear-solver entries. DTCHullMoving uses:

"alpha.water.*"
{
    nCorrectors     3;
    nSubCycles      1;

    MULESCorr       yes;
    alphaApplyPrevCorr  yes;

    MULES
    {
        nIter       1;
    }

    solver          smoothSolver;
    smoother        symGaussSeidel;
    tolerance       1e-10;
    relTol          0;
    minIter         1;
}

Foundation 14 source documentation identifies the phase-correction count, sub-cycling, semi-implicit MULES switch and reuse of the previous compression correction as separate phase-transport controls. [15]

25. Foundation 14 Marine-Related Settings Compared

Real tutorial configurations are more informative than a single universal recipe. The table below compares release-matched Foundation 14 cases. [8] [9] [10]

The point is not that one row is “best”. The cases demonstrate that Foundation 14 supports materially different solver strategies for different transient problems.

26. Starting Point: Steady Single-Phase Hull RANS

A steady single-phase hull-resistance calculation is closer in algorithmic structure to Foundation 14 steady incompressible tutorials than to DTCHullMoving. A defensible starting pattern is pressure with GAMG, velocity/turbulence with a smooth solver, SIMPLE coupling, and steady under-relaxation. [5] [17]

solvers
{
    p
    {
        solver      GAMG;
        tolerance   1e-7;
        relTol      0.1;
        smoother    GaussSeidel;
    }

    "(U|k|omega)"
    {
        solver      smoothSolver;
        smoother    GaussSeidel;
        tolerance   1e-8;
        relTol      0.1;
    }
}

relaxationFactors
{
    fields
    {
        p 0.3;
    }
    equations
    {
        U           0.7;
        "(k|omega)" 0.7;
    }
}

These values are consistent with Foundation 14 steady tutorial practice. For ship resistance, the run should additionally be judged by resistance, forces and any relevant sinkage/trim behaviour rather than by residuals alone. [12] [13] [17]

27. Starting Point: Moving Free-Surface Hull

For a moving VOF hull in Foundation 14, DTCHullMoving is the closest release-matched baseline among the examples discussed here:

Those numbers are best described as a Foundation 14 DTCHullMoving baseline, not a validated default for every ship. [8]

28. Starting Point: Floating Body in Waves

The Foundation 14 floatingObjectWaves tutorial provides a second moving free-surface reference. Its documented configuration uses pressure tolerance 1e-8, U/turbulence tolerance 1e-6, relTol 0, two PIMPLE outer correctors, one pressure–velocity corrector, and moving-mesh flux correction. [9]

For wave–body motion, this is a more relevant reference than copying a steady SIMPLE setup because the algorithm must handle transient pressure–velocity coupling, free-surface transport and body/mesh motion together.

29. Starting Point: Wave-Dominated Transient Flow

The Foundation 14 waveSubSurface tutorial uses a different strategy: PCG with DIC for pressure and PBiCGStab with DILU for U/turbulence, with non-zero intermediate relTol values and Final blocks that set relTol 0. [10]

p
{
    solver          PCG;
    preconditioner  DIC;
    tolerance       1e-9;
    relTol          0.01;
}

"(U|k|epsilon)"
{
    solver          PBiCGStab;
    preconditioner  DILU;
    tolerance       1e-6;
    relTol          0.1;
}

PIMPLE
{
    nOuterCorrectors 2;
    nCorrectors      1;
    nNonOrthogonalCorrectors 0;
}

This is direct evidence that neither GAMG nor relTol 0 on every intermediate solve should be presented as universal transient requirements.

30. Propeller CFD: What Can and Cannot Be Prescribed

A propeller calculation may involve rotating frames, moving/sliding/overset meshes, strong wake interaction and unsteady blade loading. The Foundation 14 examples cited in this article do not justify publishing one universal ship-propeller fvSolution dictionary.

The defensible approach is to start from the exact Foundation 14 solver and mesh-motion formulation being used, select linear solvers compatible with the assembled matrices, use final solves that are sufficiently tight, and verify convergence using thrust, torque and the relevant unsteady loads. ITTC likewise treats different naval-hydrodynamic applications as requiring application-specific numerical procedures. [12]

31. When to Tighten Tolerances or Add Correctors

Tighter settings are useful only when they reduce a meaningful numerical deficiency. A change is defensible when a tighter linear solve or additional coupling iteration measurably changes continuity, pressure–velocity consistency, forces, motions or another target quantity.

Simply changing every tolerance from 1e-6 to 1e-10 can increase cost without reducing the dominant CFD error. [3] [12]

32. Common fvSolution Mistakes

33. Frequently Asked Questions

34. References

1. OpenFOAM Foundation 14 User Guide — Solution and algorithm control
2. OpenFOAM Foundation 14 User Guide — Case file structure
3. Greenshields and Weller — Residual
4. Greenshields and Weller — Preconditioning and asymmetry
5. Greenshields and Weller — Steady-state convergence
6. Greenshields and Weller — The PIMPLE algorithm
7. Greenshields and Weller — Summary of algorithms and solvers
8. OpenFOAM Foundation 14 — DTCHullMoving fvSolution
9. OpenFOAM Foundation 14 — floatingObjectWaves fvSolution
10. OpenFOAM Foundation 14 — waveSubSurface fvSolution
11. OpenFOAM Foundation 14 User Guide — Backward-facing step tutorial
12. ITTC 2024 — Practical Guidelines for Ship CFD Applications, 7.5-03-02-03
13. ITTC 2024 — Practical Guidelines for Ship Resistance CFD, 7.5-03-02-04
14. OpenFOAM Foundation 14 Source Guide — pimpleNoLoopControl
15. OpenFOAM Foundation 14 Source Guide — incompressibleVoF
16. OpenFOAM Foundation 14 User Guide — Basic input/output file format
17. OpenFOAM Foundation 14 — turbineSiting fvSolution