OpenFOAM Mesh Quality: checkMesh, y+ and Non-Orthogonality

Mesh quality is the foundation of a stable OpenFOAM simulation. Poor mesh quality causes solver divergence, inaccurate results, and slow convergence — even when all numerical settings are correct. This guide explains how to read checkMesh output and what to do when metrics are out of range.

By CFDpilot · Updated April 2026

Running checkMesh

Run checkMesh on your case before starting the solver:

checkMesh

For a case with multiple time steps (after snappyHexMesh for example):

checkMesh -latestTime

The output reports mesh statistics and flags any issues with *** markers. Any line starting with *** is a warning that may affect solver stability.

Reading the full checkMesh output

A complete checkMesh report contains several sections. Here is what each section tells you:

Checking geometry...
    Overall domain bounding box (-0.5 -0.5 0) (0.5 0.5 1)
    Mesh has 3 geometric (non-empty/wedge) directions (1 1 1)
    Boundary openness (1.4e-17 -3.2e-18 2.8e-17) OK.
    Max cell openness = 2.7e-16 OK.
    Max aspect ratio = 4.3 OK.
    Min volume = 5.3e-09. Max volume = 2.1e-07.  Cell volumes OK.
    Mesh non-orthogonality Max: 38.5 average: 12.1
    *   Max skewness = 2.1, 2 highly skewed faces detected.
    Mesh OK.

The * prefix indicates a note (not yet a fatal warning). Lines with *** are serious warnings. The final line "Mesh OK" or "Failed X mesh checks" gives the overall verdict. Every line starting with *** must be addressed before the solver is started.

Non-orthogonality

Non-orthogonality measures the angle between the face normal vector and the vector connecting the two cell centres that share the face. A perfectly orthogonal mesh has 0° everywhere.

• Max < 40° — excellent, no special treatment needed
• Max 40–70° — acceptable, add 1–2 non-orthogonal correctors
• Max > 70° — problematic, convergence will be slow and unstable
• Max > 85° — critical, solver will likely diverge

Fix in fvSolution:

SIMPLE  // or PIMPLE
{
    nNonOrthogonalCorrectors 2;
}

Also switch Laplacian schemes to corrected or limited 0.5:

laplacianSchemes
{
    default  Gauss linear limited 0.5;
}

Why non-orthogonality degrades accuracy

The Laplacian operator discretisation in OpenFOAM is split into two parts: an orthogonal component (exact) and a non-orthogonal correction (approximation). When non-orthogonality is high, the correction term becomes large and must be iterated to convergence. Without correctors, the pressure equation is solved inaccurately, the velocity field develops spurious divergence, and the simulation becomes unstable.

The corrected Laplacian scheme applies the full non-orthogonal correction. The limited scheme applies a fraction (specified by the coefficient: 0.333 is conservative, 0.5 is standard, 1.0 is equivalent to corrected). Use limited 0.333 for very high non-orthogonality meshes where the full correction introduces its own instability.

Skewness

Skewness measures how far the face interpolation point is from the line connecting the two cell centres. High skewness introduces interpolation error that can destabilise the pressure-velocity coupling.

• Max < 2 — good
• Max 2–4 — acceptable for most cases
• Max > 4 — problematic, consider rebuilding the mesh
• Max > 10 — will cause divergence, mesh must be fixed

Fixing skewness in snappyHexMesh

Skewness above 4 in snappyHexMesh cases almost always comes from the surface layer addition step near complex or highly curved geometry. To fix:

addLayersControls
{
    relativeSizes       true;
    layers
    {
        wall
        {
            nSurfaceLayers   3;     // reduce if skewness is high
        }
    }
    expansionRatio          1.2;   // reduce from 1.3 for smoother grading
    finalLayerThickness     0.3;
    minThickness            0.1;   // allow layer removal before creating skewed cells
    featureAngle            130;  // increase to smooth over sharper features
    nRelaxIter              5;
    nSmoothSurfaceNormals   1;
    nSmoothNormals          3;
    maxFaceThicknessRatio   0.5;
    maxThicknessToMedialRatio 0.3;
}

The minThickness parameter is key: it allows snappyHexMesh to skip layer addition in regions where it would create poor quality cells, rather than forcing layers that result in high skewness.

y+ and wall treatment

For wall-bounded turbulent flows, the near-wall mesh resolution must match the wall treatment approach chosen in the turbulence model. Getting y+ wrong is one of the most common causes of inaccurate results in RANS simulations.

Low-Re wall treatment (resolve the boundary layer)

Requires y+ ≈ 1 at the first cell centre from the wall. Use this when you need accurate skin friction, heat transfer, or separation prediction. The boundary layer is fully resolved — no wall functions.

Wall BC: kLowReWallFunction, epsilonLowReWallFunction, nutLowReWallFunction

High-Re wall treatment (wall functions)

Requires y+ between 30 and 300 at the first cell centre. Wall functions model the boundary layer instead of resolving it. More economical for high-Re external flows where the boundary layer details are not the primary interest.

Wall BC: kqRWallFunction, epsilonWallFunction, nutkWallFunction

Estimating the first cell height for target y+

// Target y+ = 1 (low-Re)
// Δy = y+ * ν / u_τ
// u_τ = U_∞ * sqrt(C_f/2), C_f ≈ 0.058 * Re^(-0.2) for flat plate
// Example: U=10 m/s, L=1m, ν=1.5e-5 m²/s
// Re = 6.7e5 → C_f = 0.00315 → u_τ = 0.397 m/s → Δy = 3.8e-5 m

// Target y+ = 50 (wall functions)
// Δy = 50 * 1.5e-5 / 0.397 = 1.89e-3 m ≈ 1.9 mm

Verifying y+ after running

Use the yPlus function object to compute and write the y+ field during or after the simulation:

// Add to controlDict functions block
functions
{
    yPlus
    {
        type            yPlus;
        libs            (fieldFunctionObjects);
        writeControl    writeTime;
    }
}

// Or run as post-processing:
simpleFoam -postProcess -func yPlus -latestTime

This writes a yPlus field to the time directory, which you can visualise in ParaView. If you see y+ below 1 with high-Re wall functions, or y+ above 5 with low-Re treatment, the mesh must be refined or coarsened near the wall.

Aspect ratio and cell size

High aspect ratio cells (very elongated) are common in boundary layer meshes and are acceptable as long as the primary flow direction is aligned with the long axis. However, high aspect ratio cells in shear layers or recirculation zones can cause stability issues. Keep aspect ratio below 1000 for most cases.

Aspect ratio in boundary layers

In wall-resolved boundary layer meshes, aspect ratios of 100–500 are routine and not problematic if the long axis aligns with the main flow direction. The same cell rotated 90° — long axis perpendicular to the wall — would be a serious problem. Check aspect ratio statistics alongside the flow topology to determine whether high values are acceptable in context.

// Typical boundary layer mesh: first cell at y+=1
// Δy = 3.8e-5 m (wall-normal)
// Δx = 0.01 m (streamwise, typical for external flow)
// Aspect ratio = 0.01 / 3.8e-5 ≈ 263 — acceptable if aligned with flow

Cell volume ratio between adjacent cells

Abrupt changes in cell volume across mesh interfaces (especially between refinement levels in snappyHexMesh) degrade accuracy and slow convergence. The volume ratio between adjacent cells should ideally stay below 3:1. snappyHexMesh controls this through nCellsBetweenLevels:

castellatedMeshControls
{
    nCellsBetweenLevels   3;  // buffer cells between refinement levels
    refinementRegions
    {
        wake_region
        {
            mode    inside;
            levels  ((0.1 2));
        }
    }
}

Setting nCellsBetweenLevels 3 instead of the default 1 inserts additional transition layers between refinement levels, smoothing the volume ratio gradient and improving both accuracy and convergence near refinement interfaces.

Mesh quality thresholds: quick reference

Here is a consolidated reference table for the key checkMesh metrics and what action each range requires:

• Non-orthogonality max < 40° — no action needed
• Non-orthogonality max 40–70° — add nNonOrthogonalCorrectors 1–2, use corrected Laplacian
• Non-orthogonality max 70–85° — add nNonOrthogonalCorrectors 3, use limited Laplacian, improve mesh if possible
• Non-orthogonality max > 85° — rebuild mesh, numerical compensation insufficient
• Skewness max < 2 — no action needed
• Skewness max 2–4 — acceptable, monitor for instability
• Skewness max > 4 — adjust snappyHexMesh parameters, reduce layers
• Skewness max > 10 — divergence expected, mesh must be rebuilt
• Aspect ratio > 1000 — acceptable only if aligned with flow; problematic in shear layers
• Negative cell volumes — fatal, mesh rebuild required, cannot run solver