yunplus/SuperWing

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 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. 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)

3. 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 3256\; \backslash times\; 128\; \backslash times\; 3$, and the three channels stand for $x,y,zx,\; y,\; z$. The surface physical quantities data.npy are on the same reference mesh with size $256\times 128\times 3256\; \backslash times\; 128\; \backslash times\; 3$, and the three channels stand for $C_p,C_{f,\tau },C_{f,z}C\_p,\; C\_\{f,\backslash 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\mathrm{/}c{)}_i\}\backslash \{(x/c)\_i\backslash \}$ 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 129257\; \backslash 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.

   

4. 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,zx,\; 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,8008\; \backslash times\; 2,204,800$ for each volumetric flow field.

5. 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,C\_p,\; \backslash 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}x,\; y,\; z,\; \backslash 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

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 = <your_model_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).

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 = <your_model_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.

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 = <your_model_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: