--- pretty_name: "faNN — 3D RANS flow fields of a parametric axial fan rotor" tags: - physics - cfd - turbomachinery - 3d - plaid - regression size_categories: - n<1K license: etalab-2.0 --- # faNN — 3D RANS flow fields of a parametric axial fan rotor Steady 3D RANS solutions of a **14-blade axial fan rotor passage** for **75 parametric blade geometries** across their operating map. Geometries are derived from six real-world primary rotors (NASA R37, NASA R67, Safran LP4, DGEN-380, ECL5, PropHyDis) via parametric blending with Parablade; the blending weights are not released, so each geometry is only described by its mesh. Computations use FINE/Turbo v18 (Euranus) with the **k–ω SST** turbulence model and the Jameson scheme, on a shared structured multi-block hex mesh template: **9 806 346 nodes**, 9 429 120 hexahedra, y⁺ ≈ 1, identical topology for every sample. Operating points cover rotation speeds of 7 / 9 / 12 / 15 kRPM (99 / 152 / 91 / 42 released samples) from near-stall to near-choke, including windmilling; inlet total conditions are standard sea level (101 325 Pa, 288.15 K), and the outlet imposes a target mass flow through static pressure adaptation. ![Blade-skin isentropic Mach for nine samples across the operating map](assets/fann_skins.png) The dataset accompanies the paper *faNN: A realistic 3D RANS dataset bridging industrial turbomachinery and Deep Learning* (Fesquet, Bauerheim, Rojda, Bousquet, Binder — ISAE-Supaero / Liebherr-Aerospace). It is stored as a HuggingFace `DatasetDict` in the [PLAID](https://plaid-lib.readthedocs.io/) *bridge* layout (arrow tables + the `tree_constant_part.pkl` / `key_mappings.yaml` sidecars needed to rebuild full PLAID samples). All floats are float32. ## Splits | split | samples | contents | |------------|--------:|----------------------------------------------------------------| | `hf_train` | 295 | inputs **and** outputs | | `hf_test` | 89 | **inputs only** — outputs and result scalars withheld (blind) | `hf_test` combines 75 held-out operating points spanning 48 geometries (46 of which also appear in training, two of which do not) with 14 points covering the full operating map of one geometry excluded from training entirely. The benchmark task: from the mesh, the wall distance and the operating-condition scalars, predict the six output fields (`Density`, `Pressure`, `Temperature`, `VelocityX/Y/Z`) at each node. ## Coordinate system and reference frame - Machine axis = **x**; azimuth θ = `atan2(z, y)`; one blade passage of a 14-blade rotor (pitch 2π/14). Coordinates in meters. - **Velocities are absolute-frame Cartesian components.** The rotor spins about **−x̂** at `RotatingVelocityX` (rad/s): rotating walls (blade, hub) carry v_θ = −Ω·r, the casing and the swirl-free inlet are at rest. (Verified on the wall and inlet node values of the released fields.) - The flow is periodic by one pitch about x: points may be wrapped azimuthally provided the in-plane pair (`VelocityY`, `VelocityZ`) is rotated accordingly. - The mesh is structured but stored as a point cloud; the per-node integer indices `i`, `j`, `k`, `block_num` fold it back into its 14 AutoGrid blocks. `j` is the **global spanwise index** — `j = 0` at the hub, `j = 180` at the casing. ## What is in a sample - **Mesh** — `get_nodes()` → `(9806346, 3)` float32; `get_elements()["HEXA_8"]` → `(9429120, 8)` 0-based connectivity. - **Fields** (`Vertex`): both splits carry `TurbulentDistance` (wall distance, m) and the structured-block indices `i`, `j`, `k`, `block_num` (stored as float32; cast to int to fold the point cloud back into blocks). `hf_train` additionally carries the outputs: `VelocityX/Y/Z` (m/s), `Pressure` (Pa, static), `Density` (kg/m³), `Temperature` (K, static), and the k–ω SST turbulence quantities `TurbulentEnergyKinetic` (k, m²/s²), `TurbulentDissipationRate` (specific dissipation rate ω, 1/s) and `TurbulentViscosityRatio` (μₜ/μ). - **Scalars** — both splits: `RotatingVelocityX` (rad/s), `OutletPressure` (Pa), `InletPressureTotal` (Pa), `InletTemperatureTotal` (K), `SpecificHeatPressure` (cp), `SpecificHeatRatio` (γ), `GeometryNumber` (id). `hf_train` only: `MassFlow`, `IsentropicEfficiency` (0 for windmilling cases with Π ≤ 1), `PressureRatio`, `TemperatureRatio`, `TotalPressureRatioAbsolute`, `TotalTemperatureRatioAbsolute`, `Torque`, `Power`, `AxialThrust`, `InletMachRelative`. - The parametric design vector of each blade is **not** included. In the raw arrow schema the withheld `hf_test` columns exist (one schema per dataset) but hold only nulls. `sources.json` records each sample's provenance for `hf_train` and only an anonymous id for `hf_test`. ## Loading the data Requires a `plaid` release shipping `plaid.bridges.huggingface_bridge` (written with **pyplaid 0.1.10**, python ≥ 3.10): ```bash pip install pyplaid ``` ### From the HuggingFace Hub ```python from plaid.bridges import huggingface_bridge as hb ds = hb.load_dataset_from_hub("JeoaFesketto/faNN") # or streaming=True flat_cst, km = hb.load_tree_struct_from_hub("JeoaFesketto/faNN") ``` ### From a local copy ```python ds = hb.load_dataset_from_disk("faNN_plaid") # datasets.DatasetDict flat_cst, km = hb.load_tree_struct_from_disk("faNN_plaid") # constants + cgns types print({k: len(ds[k]) for k in ds}) # {'hf_train': 295, 'hf_test': 89} sample = hb.to_plaid_sample(ds["hf_train"], 0, flat_cst["hf_train"], km["cgns_types"]) nodes = sample.get_nodes() # (9806346, 3) float32, meters hexes = sample.get_elements()["HEXA_8"] # (9429120, 8) int, 0-based p = sample.get_field("Pressure") # (9806346,) float32 omega = sample.get_scalar("RotatingVelocityX") # rad/s; rpm = omega * 30 / pi ``` A fully reconstructed sample is ~0.6 GB in memory. For lighter access, read single arrow columns directly, e.g. `ds["hf_train"].data.column("Global/RotatingVelocityX")` for a scalar across all samples, or one field of one row via `ds["hf_train"][i]["Base_3_3/Zone/VertexFields/Pressure"]`. ### The blind split ```python sample = hb.to_plaid_sample(ds["hf_test"], 0, flat_cst["hf_test"], km["cgns_types"]) print(sample.get_field_names()) # ['TurbulentDistance', 'block_num', 'i', 'j', 'k'] — outputs withheld print(sample.get_scalar_names()) # the 7 condition/gas-property scalars ``` ## Visualising the data `visualize.py` (shipped in this repo) renders the dataset with **numpy + matplotlib + plaid only** — no VTK, no pyvista, no scipy. The structured block indices `i, j, k, block_num` are identical for every sample, so it reads single arrow columns per sample (memory-mapped, no full sample reconstruction) and triangulates the structured connectivity directly — the blade hole and block boundaries are exact. Both figures colour the flow by the **isentropic Mach number** `M_is`, computed as in the authors' post-processing from the local static pressure and the inlet-plane average of the relative total pressure. - **skins** — the grid above: samples spread over the operating map by farthest-point sampling on (speed, mass flow, pressure ratio); each cell shows the blade skin (pressure side | suction side) between the hub and shroud endwall lines, on colour and spatial scales shared across cells. - **sections** — blade-to-blade cuts of the blade blocks (2, 4, 5, 6, 7), styled like the dataset paper's operating-map insets: samples picked towards the outside of the (ṁ, Π) map — near-surge, windmilling, choke — each cut at blade root, mid span or blade tip, filled with static pressure under thin white isolines (per-cell scale). ```bash python visualize.py skins --source JeoaFesketto/faNN --out fann_skins.png python visualize.py sections --source JeoaFesketto/faNN --out fann_sections.png ``` `--source` is a local dataset folder or, as here, a Hub repo id; `-n` changes the grid side (default 3). The building blocks are importable — `FaNN` (fast column-level reader), `mis_at` (isentropic Mach), `SkinTopo` / `SectionTopo` (constant skin and passage-cut topologies), `skins_grid`, `sections_grid`. Blade shapes and flow regimes vary widely at the edges of the operating map — from windmilling with inverted loading (Π < 1) to near-surge suction peaks and choke: ![Blade-to-blade static pressure cuts of nine samples at the edge of the operating map](assets/fann_sections.png) ## Provenance Converged FINE/Turbo computations, exported per sample and verified field-by-field against the source solutions (worst relative difference ≈ 6·10⁻⁸, i.e. float32 rounding). `sources.json` lists the per-split sample order. ## Citation If you use this dataset, please cite the dataset paper: ```bibtex @article{fesquet2026fann, title = {faNN: A realistic 3D RANS dataset bridging industrial turbomachinery and Deep Learning}, author = {Fesquet, Jean and Bauerheim, Michael and Rojda, Ludovic and Bousquet, Yannick and Binder, Nicolas}, year = {2026}, note = {TODO(maintainer): update with arXiv id / DOI on publication} } ```