---
license: cc-by-sa-4.0
---
SuperWing, a comprehensive benchmark dataset of transonic swept wings comprising 4239 wing shapes and nearly 30,000 flow fields across diverse geometries and
operating conditions. Unlike previous efforts that rely on perturbations of a baseline wing, SuperWing is generated using a simplified yet expressive
parameterization scheme. By incorporating spanwise-varying dihedral, twist, and airfoil characteristics, the dataset captures realistic design complexity and
ensures greater diversity than existing ones. Please refer to our [arXiv paper](https://arxiv.org/abs/2512.14397) for more details on the dataset.
# Features:
1. Focusing on the **"kink" wings** (with two segments instead of one in the spanwise direction) under transonic regime (Mach number between 0.75 and 0.90), which bring more complex flow features and are closer to the industry.
2. **More diversity** on the wing shape by generating them from basic parameters instead of perturbing from a baseline wing shape
3. RANS simulation with **well-validated** solver `ADflow` and structural computational mesh.
# Data format:
1. Geometric parameters
`config.dat` includes the basic shape parameters to build a wing from scratch, with the method detailed in our [arXiv paper](https://arxiv.org/abs/2512.14397). For each wing
shape, we provide 8 operating conditions, but note that they are not exactly the operating conditions in the final dataset since some of them may not lead to convergent
results.
|indexs|type|variables|comments|
|-|-|-|-|
|1-7| global planform parameter | sweep angle, dihedral angle at tip, dihedral angle at kink, aspect ratio, taper ratio, kink adjustment, root adjustment |
|8-17| spanwise variation of airfoils | thickness ratios (x3), camber ratios (x3), twist angles (x4) |
|18-38| baseline airfoil shape | CSTs (9th order) for upper (x10) and lower (x10) surface, max thickness |
|39-56| Mach numbers and angles of attacks |
2. Index file
`index.npy` provides the crucial information for all provided samples; it has 12 channels, with each channel listed below:
|index|description|
|-|-|
|0|wing shape index (corresponding to in `config.dat`)|
|1|operating condition index (count in each wing shape) |
|2|angle of attack (in degrees)|
|3|mach number|
|4|reference area (to calculate coefficient)|
|5|half span length|
|6,7,8|lift, drag, pitching moment (acc. LE) coefficient from the solver|
|9,10,11|lift, drag, pitching moment (acc. LE) coefficient by recalculating from the surface flow (there are ones used for ML models)|
4. Reference surface mesh and surface physical quantities on this reference mesh
The reference mesh `geom0` contains the cell-centric coordinates of the reference surface mesh with size \\( 256 \times 128 \times 3 \\), and the three channels stand
for \\( x, y, z \\). The surface physical quantities `data.npy` are on the same reference mesh with size \\( 256 \times 128 \times 3 \\), and the three channels stand for
\\( C_p, C_{f,\tau}, C_{f,z} \\). (the latter two are the decomposed friction coefficients on the streamwise and spanwise directions). **These data can serve as input and
output for a machine learning model that predicts the aerodynamics of wings**.
**reference mesh**: The simulation mesh on the wing surface is first interpolated to a reference mesh. In the spanwise ($j$-direction), 128 cross-sectional planes are
sampled with even spacing, and tips are excluded. For each cross-section (i-direction), a fixed set of normalized chordwise positions \\( \{(x/c)_i\} \\) s is used for both
the upper and lower surfaces, and the tail edge is represented only with one cell. The reference mesh along the wing surface is then unfolded as shown below, resulting
in a final vertex surface grid of \\( 257 \times 129 \\) points per wing (`origingeom.npy`). This is useful when we need to calculate coefficients from the surface flow outputs.
The cell-centric grid for the mesh is obtained just by averaging the coordinates at the four vertices.
5. Volumetric flow quantities on the near-field simulation mesh
Volumetric flow data are also provided for potential future use. We provide the cell-centric coordinates and five core flow quantities at each simulation cell, and the flow
quantities are in the order of density, pressure, and the velocities in the \\(x, y, z \\) directions. Since the simulation requires a large far field to implement the
freestream boundary condition, the values at the far mesh points are the same as the freestream condition. To avoid this reluctance, we truncate the flow field at 51 in the
far-field direction for each block. The original structural mesh blocks are flattened to one dimension and concatenated to each other, which leads to a size of
\\(8 \times 2,204,800 \\) for each volumetric flow field.
6. Raw solver input & output
The raw input surface mesh (`wing.xyz`), output of surface flow (`surf.cgns`), and 3D volume fields (`vol.cgns`) are also available in their original formats (CGNS files with the ADF format). They need the
CGNS library to be read out. Since they are too large, they are available via university storage upon reasonable request to the authors.
The table below summarizes the data. (N=28856, Nshape=4239)
|Type | File | Description | Shape | Size |
|-|-|-|-|-|
|Geometric parameters | `Configs.dat` | shape parameters | N x 57 | 5.0 MB
|Information | `index.npy` | group information, operating conditions, and aerodynamic coefficients | N x 12 | 2.8 MB
|Surface mesh | `origingeom.npy` | reference surface mesh (grid points) | Nshape x 3 x 129 x 257 | 3.3 GB
| | `geom0.npy` | reference surface mesh (cell center) | Nshape x 3 x 128 x 256 | 3.3 GB
|Surface flow | `data.npy` | \\( C_p, \bm {C_f} \\) at reference mesh (cell center) | N x 3 x 128 x 256 | 22.7 GB
|Volume flow | `data_vol.*.npy.zst` | \\(x, y, z, \rho, p, v_x, v_y, v_z\\) at near-field volumetric simulation mesh (cell center) | N x 8 x 2,204,800 | 2.3 TB （46 files）
|Raw data | `*\wing.xyz` | surface simulation mesh | | 7.8 GB
| | `*\surf.cgns` | raw surface flow output | | 161.5 GB
| | `*\vol.cgns` | raw flow field output | | 5.5 TB
The simulations are conducted on the 160-core high-performance computing cluster at AeroLab, Tsinghua University, for over four months.
# Train-test split
The default training-testing split is decided by the **shape indices**, so that the samples in the testing dataset contain shapes that are totally unseen during training. We
select 90\% shapes and their sample number (corresponding to the rows in `index.npy`) are in `training_samples_index.txt`.
# Postprocess
## Aerodynamic coefficients
One can integrate surface flow (formatted as in `data.npy`) to get the aerodynamic coefficients (i.e., the lift coefficient $C_L$, the drag coefficient $C_D$, the pitching
moment coefficient $C_{M,z}$) with the code in `floGen` (`flogen.post`). We also provide the `post.py` file here for simple download.
Remark.
1. It uses `pytorch`.
2. The geometric information should be with the grid point mesh (`origingeom.npy`), not the cell-centric mesh (`geom0.npy`).
3. The values in `data.npy` are already non-dimensionalized with the freestream condition
```python
import post
geom = torch.from_numpy(np.load('origingeom.npy'))[i_shape]).float().to(device)
aoa = 3.0
ref_area = np.load('index.npy')[i_sample, 4]
output = # with shape (H, W, 3)
cf_xyz = post._get_xz_cf_t(geom, output[..., 1:]) # transfer to xyz coordinates
force_coefficients = post.get_force_2d_t(geom=geom, aoa=aoa, cp=output[..., 0], cf=cf_xyz) / ref_area # returns: CD, CL, CZ
moment_coefficients = post.get_moment_2d_t(geom=geom, cp=output[..., 0], cf=cf_xyz, ref_point=[0.25, 0, 0]) / ref_area # returns: CMx, CMy, CMz
```
One can also use the `cfdpost` repo (https://github.com/YangYunjia/cfdpost).
```python
from cfdpost.wing.basic import BasicWing
geom = torch.from_numpy(np.load('origingeom.npy'))[i_shape]).float().to(device)
geom_infos = {}
geom_infos['ref_area'] = np.load('index.npy')[i_sample, 4]
aoa = 3.0
output = # with shape (H, W, 3)
wg1 = BasicWing(paras=geom_infos, aoa=aoa, iscentric=True)
wg1.read_formatted_surface(geometry=geom, data=output, isinitg=False, isnormed=False)
wg1.aero_force()
cl_real = wg1.coefficients # CL, CD, CMz
```
## Visualization
To visualize the wing surface field, we provide a brief code that gives a not bad looking.
```python
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
def color_map(data, c_map, alpha, dmin=None, dmax=None):
dmin = np.nanmin(data) if dmin is None else dmin
dmax = np.nanmax(data) if dmax is None else dmax
_c_map = mpl.colormaps.get_cmap(c_map)
norm = mpl.colors.Normalize(vmin=dmin, vmax=dmax)
_sm = mpl.cm.ScalarMappable(norm=norm, cmap=_c_map)
_colors = _sm.to_rgba(data)
_colors[..., -1] = alpha
return _colors, _sm
geom = np.load('data/ppn2norigingeom.npy')[0]
output = # with shape (H, W, 3)
fig = plt.figure(figsize=(10, 4), dpi=200)
ax = fig.add_subplot(projection='3d')
elev = 68; azim =120
colors, sm = color_map(output[..., 0], 'gist_rainbow', alpha=1, dmin=-1, dmax=1) # cp
ax.plot_surface(*geom[[0,2,1]], facecolors=colors, edgecolor='none', rstride=1, cstride=3, shade=True)
ax.view_init(elev=elev, azim=azim)
ax.set_axis_off()
ax.grid(False)
ax.xaxis.pane.set_visible(False)
ax.yaxis.pane.set_visible(False)
ax.zaxis.pane.set_visible(False)
plt.show()
```
This should gives sth. like:
