ANSYS Fluent Overview

#+CATEGORY: ansys # :PROPERTIES: # :ID: uuid-ansys-overview # :END:

ANSYS Fluent Overview :: Solver Architecture and Capabilities

This note documents ANSYS Fluent's architecture, solver families, discretisation options, and workflow. It serves as the reference point for the ANSYS side of the comparison. Every ANSYS vs OpenFOAM section traces back here. Every turbulence, combustion, and multiphase comparison traces back here too.

Fluent's design philosophy differs from OpenFOAM. Fluent prioritises user-friendliness, robustness, and vendor support. OpenFOAM prioritises transparency and customisability. Both choices have real costs and benefits. See ANSYS vs OpenFOAM Comparison.

**Table of Contents**

• Solver Families :: Pressure-based vs density-based
• Discretisation Schemes :: Spatial and temporal options
• Pressure-Velocity Coupling :: SIMPLE, Coupled, PISO
• Mesh Capabilities :: Supported element types and formats
• Boundary Conditions :: Types and specification
• UDF and User Coding :: The UDF API
• Post-Processing :: Fluent's native tools
• See Also
• References

Solver Families :: Pressure-Based vs Density-Based

Fluent offers two distinct solver families, matching the categorisation used in Governing Equations and Compressible Flow.

**Pressure-Based Solvers**

The pressure-based solver solves the Navier-Stokes equations. It treats pressure (from a pressure-correction equation derived from continuity) as the primary variable. This enforces mass conservation. This is the default for incompressible and low-Mach compressible flows. Use it for Mach numbers below ~0.3. Fluent's low-Mach preconditioning extends this to Mach ~0.7–0.8 with the coupled pressure-based option.

The segregated pressure-based solver is the direct OpenFOAM analogue. It corresponds to simpleFoam (SIMPLE), pisoFoam (PISO), and pimpleFoam (PIMPLE). Fluent's coupled pressure-based solver handles strongly coupled problems more efficiently. It requires heavier linear algebra because the Jacobian is a block matrix (momentum + pressure). In OpenFOAM, solving the coupled system needs custom solvers or the buoyantBoussinesqSimpleFoam family. Most OpenFOAM pressure-based solvers do not include this.

**Density-Based Solvers**

The density-based solver handles high-speed compressible flow. Use it for Mach > 0.3, typically > 0.8 where shocks dominate. It solves the conservation equations in conservative form as a coupled system. This matches OpenFOAM's rhoCentralFoam (density-based, finite-volume with Riemann solvers) and rhoPimpleFoam (density-based, implicit). Fluent's density-based solver supports implicit and explicit time discretisation. Fluent uses a Riemann solver (AUSM+, Roe, HLLC) at each cell face in explicit mode. rhoCentralFoam does the same in OpenFOAM. Fluent also supports JST (Jameson-Schmidt-Turkel) artificial viscosity for shock-capturing in implicit mode. This offers an alternative to Riemann solvers.

The implicit density-based solver handles steady compressible flow. It matches sonicFoam in OpenFOAM. The explicit density-based solver handles transient compressible flows with shock-capturing. It matches rhoPimpleFoam and sonicFoam with explicit time stepping. Fluent supports more Riemann solvers than most OpenFOAM distributions. OpenFOAM typically uses Roe or AUSM+ in rhoCentralFoam. Fluent offers AUSM+, Roe, HLLC, and JST within a single solver framework.

Discretisation Schemes :: Spatial and Temporal Options

Fluent documents its discretisation schemes by order of accuracy and boundedness. This maps directly to the Numerical Schemes note and the OpenFOAM fvSchemes configuration.

Spatial discretisation options for the convective term:

The "High-resolution" scheme is Fluent's adaptive limiter. It matches OpenFOAM's TVD schemes with a Sweby limiter function. It blends between first-order upwind (near discontinuities) and second-order upwind (in smooth regions). It uses a bounded second-derivative limiter. This matches the TVD limiter philosophy in TVD Limiters.

Temporal discretisation:

Fluent supports Crank-Nicolson / backward Euler blending. A factor alpha controls the blend (alpha=1 is pure Crank-Nicolson). This matches OpenFOAM's CrankNicolson scheme with deltaTCoeff in fvSchemes. The blending prevents oscillations. Pure Crank-Nicolson can oscillate for steep gradients. The blend maintains second-order temporal accuracy for smooth solutions.

Pressure-Velocity Coupling :: SIMPLE, Coupled, PISO

Fluent implements the algorithms documented in Pressure-Velocity Coupling.

**Segregated Mode (SIMPLE-family)**

Fluent's segregated pressure-based solver uses a variant of SIMPLE (Semi-Implicit Method for Pressure-Linked Equations). The user sets under-relaxation factors (URF) in the solver controls panel. These map to the relaxationFactors in OpenFOAM's fvSolution dictionary. Fluent defaults to:

Set these URFs interactively in the GUI (Solver → Controls → Solutions Controls) in Fluent. Do not use a text file. The under-relaxation philosophy matches OpenFOAM: each equation solves with under-relaxation =p_{n}^{new} = \alpha p_{n}^{calc} + (1-\alpha) p_{n}^{old}/. The difference is GUI-driven vs file-driven. Fluent also supports schemed under-relaxation for accelerated convergence in steady-state simulations with pseudo-time stepping.

**Coupled Mode**

The coupled pressure-based solver solves momentum + pressure in a single matrix system. It has NO separate pressure-correction step. Monitor convergence by residuals of the coupled system. This approach is more efficient than segregated SIMPLE for strongly coupled problems. These include high Mach number, buoyancy-dominated flow, and strong source terms. It requires more memory and more expensive linear algebra.

Fluent's coupled solver uses AMG (Algebraic Multigrid) for the coupled matrix. This matches OpenFOAM's GAMG solver for pressure, extended to the block system. Use coupled mode for buoyant flows, high-speed compressible flow, and rotating machinery. OpenFOAM needs rhoPimpleFoam, buoyantPimpleFoam, or a custom solver for these cases.

**PISO Option**

Fluent runs PISO (Pressure-Implicit with Splitting of Operators) in segregated mode. The Number of PISO Corrections parameter controls this. The code re-solves the pressure equation N times per timestep with N PISO corrections. This corrects the velocity field further. PISO does not apply to steady-state (only SIMPLE/SLIMPLEC). PISO outperforms SIMPLE for transient simulations with small timesteps (CFL < 1). For CFL > 1, use PIMPLE (OpenFOAM's blend of SIMPLE + PISO with under-relaxation). Fluent achieves this in coupled implicit mode.

Mesh Capabilities

Fluent supports the following element types:

Fluent recommends polyhedral meshes over tetrahedral for 3D simulations. They offer better accuracy per cell. They have fewer non-orthogonal faces and better conditioning. They also maintain the automatic mesh generation capability of tets. The polyhedral conversion preserves the original surface triangles. It replaces interior cells with polyhedra. Each polyhedron has 12–20 faces on average, compared to a hex's 6. This matches OpenFOAM's polyDualMesh utility (which converts tet meshes to polyhedral). Fluent performs the conversion natively in its meshing module. It needs no separate utility.

Fluent Meshing (standalone pre-processor) supports:

. Patch conforming (legacy) and patch independent (topology-based) tetrahedral generation . Automatic boundary layer (inflation layer) generation (like snappyHexMesh's addLayers in OpenFOAM) . Polygonal/polyhedral meshing (face-based algorithm) . Mesh adaptation (h-refinement based on gradient/error indicators) . Sliding/moving interface support (AMI equivalents)

Fluent's mesh import supports: IGES, STEP, Parasolid, ACIS (.sat), STL (facet), Nastran, Abaqus, Ansys Mechanical (.cdb, .mpch5), Medit (.msh), CGNS, Gmsh (.msh), OpenFOAM (.msh with fluent3dToMsh), and STAR-CCM+ (.sim). OpenFOAM's fluent3DMeshToFoam does the reverse. It imports Fluent-format grids into OpenFOAM. This bidirectional exchange is standard in the ANSYS vs OpenFOAM workflow.

Boundary Conditions

Fluent's boundary condition types match those in Boundary Conditions:

Fluent uses the terms "Velocity Inlet" (Dirichlet on velocity) and "Pressure Outlet" (Dirichlet on pressure backflow, Neumann on inflow). This matches OpenFOAM's inletOutlet BCs.

For turbulence BCs at inlets, Fluent requires turbulence intensity (=I/) and hydraulic diameter (=D_h/) or turbulence length scale (=L/). These values compute k and \omega/ (or \epsilon/):

$$$$ k = \tfrac{3}{2} (U I)^2, \quad \omega = \frac{\sqrt{k}}{C_\mu^{1/4} l} $$$$

This matches OpenFOAM's turbulentIntensityKineticEnergyInlet and turbulentMixingLengthFrequencyInlet BCs. It also matches the analytical estimates in Turbulence Models. Fluent presents these values as GUI inputs. OpenFOAM computes them from BC parameters.

UDF and User Coding :: The UDF API

User-Defined Functions (UDFs) are C-language functions. Fluent compiles them at runtime. They replace OpenFOAM's custom solver development + fvOptions/fvModels. UDFs cover:

**Example: UDF for variable viscosity**

DEFINE_PROPERTY(cell_viscosity, thread, d)
{
  real T = F_T(f, thread);  // temperature at cell centroid
  return mu_ref * exp(-E_ref / (8314.4 * T));  // Arrhenius
}

This matches setting transportProperties in OpenFOAM to a non-Newtonian model (e.g., nonNewtonianIllichiPS for temperature-dependent viscosity). UDFs accept any C expression. They are not limited to models pre-implemented in Fluent. This flexibility matches OpenFOAM's custom fvOption source terms. UDFs compile into Fluent's executable. OpenFOAM's fvOptions come from a dictionary.

In OpenFOAM, write a source term class in finiteVolume/src/fvOptions/sources/, compile it with wmake, then reference it in system/fvOptions. UDFs are faster to write (no C++ needed) but less transparent. The Fluent UDF API is well-documented. OpenFOAM's API is also well-documented but requires C++ knowledge. Fluent prioritises accessibility. OpenFOAM prioritises transparency.

**Mesh Motion UDFs and Dynamic Mesh**

Fluent supports dynamic mesh (moving boundaries, 6DOF, arbitrary mesh motion):

. Layering (boundary layer splitting — like snappyHexMesh addLayers, but dynamic) . Smoothing (laplacian mesh smoothing — like OpenFOAM's laplacianFvMotion) . Local remeshing (tetrahedral cell replacement — like OpenFOAM's dynamicRefineFvMesh) . 6DOF rigid body motion (solver for translation + rotation)

These match OpenFOAM's dynamicFvMesh families in Dynamic Meshes. Fluent's layering method is more robust than OpenFOAM's layer addition in dynamic mesh mode. snappyHexMesh layers cannot retract. Fluent can un-layer cells when the boundary moves inward. OpenFOAM uses polyTopoChange for dynamic topology. This matches Fluent's local remeshing but is less mature.

Post-Processing :: Fluent's Native Tools

Fluent's built-in post-processing includes:

Fluent's Monitors and Surface Integrals panels provide in-run data output for quantitative post-processing (force coefficients, surface averages, line probes). This matches OpenFOAM's functionObjects (forces, forceCoeffs, fieldValues, samples) in OpenFOAM Post-Processing. Fluent's equivalent to foamToVTK is the Export → VTK command. It writes .vtk files for ParaView or CFD-Post.

CFD-Post (a standalone ANSYS post-processor) provides more advanced features. These include expression-based field computation, report definitions, custom variables, animation export, and Python automation (CFD-Post macro language / PyCFX). In OpenFOAM, use postProcess utility + Python (paraview.simple / pvpython) + third-party tools (foamLog, foamDictionary).

See Also :: Related Notes

. Governing Equations — the system Fluent solves (mass, momentum, energy conservation) . Numerical Schemes — spatial and temporal discretisation theory . TVD Limiters — bounded schemes, limiter philosophy . Pressure-Velocity Coupling — SIMPLE, PISO, coupled solvers . Boundary Conditions — BC types and well-posedness . Numerical Schemes in OpenFOAM — fvSchemes configuration . OpenFOAM Case Setup — fvSolution relaxation factors . OpenFOAM Dynamic Meshes — mesh motion comparison . OpenFOAM Post-Processing — functionObjects vs Fluent monitors . ANSYS vs OpenFOAM Comparison — comprehensive comparison . ANSYS Turbulence Models — Fluent's turbulence model suite . ANSYS Combustion — combustion models comparison . ANSYS Multiphase — multiphase model comparison

References

. ANSYS Fluent Theory Guide (latest version).ANSYS Inc. . ANSYS Fluent User's Guide (latest version). ANSYS Inc. . ANSYS Fluent Coding Manual (UDF reference). ANSYS Inc. . Versteeg, H.K. & Malalasekera, W. (2007). An Introduction to Computational Fluid Dynamics: The Finite Volume Method. Chapter 5 (Pressure-velocity coupling), Chapter 7 (Discretisation schemes). . Hirsch, C. (1989). Numerical Computation of Internal and External Flows (Vol. 1). Chapter 11 (Discretisation), Chapter 13 (Non-iterative solution).