NurshatMenglik/Paired_Boussinesq_Compressible_Dataset

Paired Boussinesq / Compressible Natural Convection — 10,000 Simulations (version 2)

📄 Paper: A Neural Surrogate Approach for Simulating Natural Convection Problems (arXiv:2606.25259) — Nurshat Menglik, Alex Shao, David Hyde.

Version 2 (September 2026) replaces the original release. All 10,000 pairs were regenerated; see What changed in version 2. The original files remain available unchanged under the tag v1.0-legacy (snapshot_download(..., revision="v1.0-legacy")). New work should use version 2.

10,000 matched pairs of steady 2D natural-convection simulations in the unit square cavity. Every sample solves the same randomized problem twice — once with the Boussinesq model and once with the fully compressible model — so the two members differ only in the physics, not in the geometry, boundary data, or discretization. This is the raw finite-element output of the data-generation pipeline used in the paper.

Both solves use a monolithic, fully implicit mixed finite element method (Taylor–Hood: [P2]^2 velocity, P1 scalars) implemented in FEniCSx/DOLFINx.

Contents

manifest.csv plus 10,000 sample folders sample_000000 … sample_009999 (~112 GB). The mesh resolution is swept in four blocks of 2,500:

ids	mesh (res)
0 – 2499	32 × 32
2500 – 4999	64 × 64
5000 – 7499	128 × 128
7500 – 9999	256 × 256

Each folder contains 23 files:

File	Description
meta.json	Generation parameters and the steady-state record of both solves
T_bouss.npy, T_comp.npy	Temperature (P1 nodal values)
ux_bouss.npy, uy_bouss.npy	Boussinesq velocity components (P2 nodal values)
ux_comp.npy, uy_comp.npy	Compressible velocity components (P2 nodal values)
p_bouss.npy, p_comp.npy	Pressure, min–max normalized to [0, 1] per sample
p_bouss_raw.npy, p_comp_raw.npy	Pressure as solved (not normalized)
p_bouss_pert_raw.npy, p_comp_pert_raw.npy	Raw pressure with its mean removed
rho_comp.npy	Density (compressible solve only)
coords_*.npy	(n, 2) node coordinates matching each field above

All arrays are float64 flat nodal arrays, not images. Always pair a field with its own coords_*.npy: the node ordering differs between samples, and because the solves ran in parallel the arrays can contain nodes on processor interfaces more than once (same coordinates, same value). The nodes lie on a uniform grid — (res+1)² points for the P1 fields and (2·res+1)² for the P2 velocities — so they can be placed on a regular array without interpolation (see Loading).

Parameters

• Rayleigh number Ra log-uniform in [1e2, 3e6], capped at 2e6 whenever the top or bottom wall is conducting (median 1.5e4). Mach number Ma is tied to Ra by a log–log map (8.3e-5 … 1.4e-2). Pr = 0.71, γ = 1.4, Fr = 1.095.
• T_init = 1, ΔT = 1.2, so wall temperatures span [0.4, 1.6]. This is deliberately far outside the Boussinesq regime (density typically varies by a factor of 3–4 across a sample, up to 5.3), which is what makes the pair informative.
• Each wall has a complexity dial n (numT_left/right/top/bot in meta.json). Left and right walls: n ∈ {1,2,3}; top and bottom: n ∈ {0,1,2} with n = 0 meaning adiabatic. n = 1 is a constant wall temperature; n ≥ 2 is a smooth random trace built from n − 1 Fourier modes with k^{-1.5} decay, scaled to stay inside [0.4, 1.6] pointwise. When both side walls have n = 1 the sample is the classical differentially heated cavity (hot left, cold right, adiabatic top and bottom): 1,159 samples (legacy_cavity = 1 in the manifest).
• Both members are marched to steady state: integration stops when the per-step relative change of the non-pressure fields falls below 1e-6. A step on which Newton does not iterate is never accepted as evidence of steadiness by itself; such exits are certified by the decay history and the residual (steady_zero_it_verified). The full record is under march in meta.json.

Units and conventions (read before comparing the two members)

• Both members are in one unit system, the buoyancy (free-fall) scales: velocity in U = sqrt(gβΔT·L), pressure in ρ₀U², temperature as T/T₀. The Boussinesq member is solved with the Boussinesq equations non-dimensionalized on this same velocity scale (coefficients sqrt(Pr/Ra), 1, 1/sqrt(Ra·Pr) instead of the Pr, Pr·Ra, 1 of the thermal-diffusion convention), so the two velocity fields of a pair are directly comparable (|u| ≈ 0.25–0.3 in both at high Ra). To recover the thermal-diffusion (de Vahl Davis) convention for the Boussinesq member multiply its velocities by sqrt(Ra·Pr) and its pressures by Ra·Pr (sqrt_RaPr in manifest.csv).
• The two pressure fields are different quantities. The compressible pressure is the thermodynamic pressure: its raw perturbation is dominated by the hydrostatic gradient. The Boussinesq pressure is the Lagrange multiplier of incompressibility, fixed at one point; in the code its weak form carries +∫ p ∇·v while the compressible momentum equation carries −∫ p ∇·v, so the stored Boussinesq raw pressure is the negative of the paper's. The normalized p_*.npy files hide all of this; use the raw files if pressure matters to you.
• Temperature and the coordinates are directly comparable between the two members.

Samples that deviate from the canonical draw

manifest.csv has one row per sample (Ra, Ma, seed, wall dials, node counts, steady-state status and step counts of both solves, field ranges, sqrt_RaPr, and the two columns below). 9,928 samples are exactly the canonical draw for their id.

• retry = fine_atol_tightening (63 samples, all Ra < 400): same draw, same physics, same acceptance rules; the nonlinear tolerance was tightened in finer steps so that the march could be certified steady.
• retry = ra_cap_nudge (8 samples): the canonical Rayleigh number did not reach a steady state, so Ra was lowered with the wall temperatures unchanged. Ra_canonical holds the original value: ids 2691 (−37%), 4802 (−39%), 6434 (−39%), 6460 (−39%), 7176 (−19%), 8715 (−18%), 9069 (−68%), 9539 (−39%).
• retry = dt_half (1 sample, id 4757, Ra = 1.2e6): same draw, same physics, same acceptance rules; the Boussinesq march in the shared velocity scale did not converge with the standard start-up time step, so the start-up step was halved (dt = 0.025, recorded in meta.json). The steady state it reaches agrees with a solve in the thermal-diffusion convention, rescaled, to 3e-9 relative L2.

What changed in version 2

1. Boussinesq buoyancy term. In version 1 the Boussinesq member's body force was assembled with T/T_init instead of (T − T_init)/ΔT. With ΔT = 1.2 this equals a hydrostatic pressure ramp plus an effective Rayleigh number of 1.2·Ra, while the compressible member ran at Ra. Version 2 uses (T − T_init)/ΔT, so both members of a pair are at the same Rayleigh number.
2. Steady states instead of a fixed end time. Version 1 marched every sample to a fixed time with a fixed step; above Ra ≈ 1e5 that left some fields still evolving. Version 2 marches to a certified steady state (see above).
3. Boundary data. Version 1 put a random Fourier trace on all four walls. Version 2 uses the per-wall dials described above, which add adiabatic walls, constant walls and the classical cavity as special cases.
4. Nonlinear solver tolerances now scale with each model's residual scale, and the Boussinesq Newton solve is seeded from the previous state.
5. Raw pressure files were added; the per-sample PNG previews were dropped.
6. The Boussinesq member is solved in the compressible member's velocity scale (see Units), so both members of a pair leave the solvers in one unit system.
7. Draws use a new seed, so version 2 samples are not re-solves of the version 1 problems. The seed stream of the res-32 block is the one used for the in-distribution test split of NeuralConvection_2D_TrainTest: its first 200 samples are the same problems at 64 × 64, so do not train on that block if you evaluate on that split.

Loading

import json, numpy as np

d = "sample_007500"
meta = json.load(open(f"{d}/meta.json"))
T, xy = np.load(f"{d}/T_comp.npy"), np.load(f"{d}/coords_T_comp.npy")

# place a P1 field on its (res+1) x (res+1) grid, no interpolation needed
n = meta["res"]
ij = np.rint(xy * n).astype(int)
grid = np.empty((n + 1, n + 1)); grid[ij[:, 1], ij[:, 0]] = T      # grid[y, x]
# P2 velocities: use 2*n in place of n

# both members are already in the same (free-fall) units; ux_bouss.npy and ux_comp.npy compare directly
ux_bouss, ux_comp = np.load(f"{d}/ux_bouss.npy"), np.load(f"{d}/ux_comp.npy")

If you want ready-to-train tensors on a uniform grid instead of raw FE output, use NeuralConvection_2D_TrainTest and NeuralConvection_3D_TrainTest.

Source

Version 2 was generated with a revised version of DataGeneration/genData_stochastic_fourierBC.py (recorded as generator in every meta.json) from https://github.com/Nurshat317/NeuralConvection. Version 1 was generated with DataGeneration/genData.py.

License

Released under CC BY 4.0. You are free to share and adapt this data, including commercially, provided you give appropriate credit and indicate any changes. The requested form of credit is a citation to the paper below.

Citation

If you use this dataset in your research, please cite:

@article{menglik2026neural,
  title         = {A Neural Surrogate Approach for Simulating Natural Convection Problems},
  author        = {Menglik, Nurshat and Shao, Alex and Hyde, David},
  journal       = {arXiv preprint arXiv:2606.25259},
  year          = {2026},
  eprint        = {2606.25259},
  archivePrefix = {arXiv},
  primaryClass  = {physics.comp-ph},
  url           = {https://arxiv.org/abs/2606.25259}
}

• Paper: arXiv:2606.25259
• Code: github.com/Nurshat317/NeuralConvection