Dataset: Drag reduction and induced spanwise flow over sinusoidally modulated riblets

Direct numerical simulations of channel flow over riblets whose crests follow a
sinusoid in the streamwise direction, together with Stokes-flow simulations used to
compute their protrusion heights. The dataset contains the time-averaged flow statistics
used in the paper, the scripts that process them, and the script that produces the
figures.

Contact: Stefano Cipelli, Institute of Fluid Mechanics, Karlsruhe Institute of Technology
(stefano.cipelli@kit.edu)

Contents

database/
├── README.md
├── requirements.txt
├── raw/                                 time-averaged statistics (HDF5)
│   ├── turbulent/
│   │   ├── channel/dy10/stats2d.h5      smooth-wall reference channel
│   │   └── <shape>/<geometry>/<size>/
│   │       ├── stats2d.h5               x-averaged statistics
│   │       └── stats3d.h5               3D statistics
│   └── stokes/
│       ├── sinusoidal/<shape>/b<beta>/{stats2d,stats3d}.h5
│       └── grid_convergence/<ibm|coco>/<grid>/{stats2d,stats3d}.h5
├── processed/
│   ├── stokes.h5                        output of process_stokes.py
│   └── turbulent.h5                     output of process_turbulent.py
├── scripts/
│   ├── sinrib_common.py                 shared routines (I/O, geometry, averaging, fits)
│   ├── process_stokes.py                raw/stokes     -> processed/stokes.h5
│   ├── process_turbulent.py             raw/turbulent  -> processed/turbulent.h5
│   └── make_figures.py                  processed/*    -> figures/*.pdf
└── figures/                             figures produced by make_figures.py

Simulations

The incompressible Navier–Stokes equations are solved with a second-order
finite-difference code on a staggered grid. The riblets are represented with an
immersed-boundary method (IBM), in most runs with a corner correction (COCO).

Turbulent channel. The flow is driven by a constant pressure gradient Π.
All quantities are scaled with the channel half-height δ and with u_τ,0 = (δΠ/ρ)^½, the
nominal friction velocity. The nominal friction Reynolds number is Re_τ,0 = 1/ν = 400.
Both channel walls carry riblets.

For example, raw/turbulent/tra_30/l1000_b08/lg14/ holds the trapezoidal riblet with
ℓ_g⁺ ≈ 14, λ_x⁺ = 1000 and β = 8°. The ℓ_g⁺ values are nominal; the exact values are in
processed/turbulent.h5 under summary/<shape>/lg_plus.

The lgNN-minimal-p directories are minimal-span channels that also sample the
pressure. They exist for λ_x⁺ = 1000 and all β and ℓ_g⁺, and for the trapezoidal riblet
at ℓ_g⁺ = 14 and β = 12° also for λ_x⁺ = 500–1500. They are used for the pressure drag
and for the maximum spanwise velocity of the trapezoidal riblet at ℓ_g⁺ = 14, β = 12°.

Stokes flow. These runs compute the protrusion heights of the same cross-sections.
In sinusoidal/<shape>/b<beta>, β = 0 is the straight riblet. In
grid_convergence/<method>/<grid>, the triangular riblet with β = 12° is run with
standard IBM and with COCO on six grids; the grid name is the number of points per
riblet spacing in y.

Raw data format

Each HDF5 file contains:

• the fields listed below, as float64 arrays,
• the coordinate arrays x (3D files only), y and z,
• a group parameters whose attributes are the solver input parameters
  (nu, spacing, crest, valley, lambda, ampl, nx, ny, nz, Lx, Ly, …),
• file attributes: the verbatim solver input (riblets_in), the number of samples
  (sample_number) and the source file (source).

• stats2d.h5 is averaged in time and x. Arrays are indexed [y, z] and span the full
  domain: y over L_y, z from wall to wall.
• stats3d.h5 is averaged in time. Arrays are indexed [x, y, z]. For the full-size
  turbulent runs the fields are also phase-averaged over the n_riblets identical riblets
  in y (attribute n_riblets_averaged), so y spans one riblet spacing. Minimal-channel
  and Stokes runs are stored without this average.
• Values at grid points inside the riblets are those written by the solver; they carry
  no physical meaning. The scripts mask them using the geometry (sinrib_common.in_body).
• Riblet geometry: the crest is at z = crest, the groove bottom at z = valley, and
  the crest line is y_c(x) = ampl sin(2πx/lambda) + n·spacing.

Processing

cd scripts
python process_stokes.py        # seconds
python process_turbulent.py     # about an hour; --skip-3d / --skip-dp for parts
python make_figures.py

process_stokes.py computes the longitudinal and transverse protrusion heights h∥ and
h⊥ (scaled with ℓ_g) from the x- and y-averaged profiles U(z), V(z). A straight line is
fitted to each profile above the riblets and extrapolated to zero velocity.

process_turbulent.py performs four steps:

1. ΔU⁺. The virtual origin z_T is the shift of the riblet Reynolds-shear-stress
   profile that best matches the smooth channel over 0.01 ≤ z ≤ 0.1. The friction velocity
   is then u_τ = (1 + z_T)^½, and ΔU⁺ is the mean difference of the velocity profiles over
   100 ≤ z⁺ ≤ 150.
2. Spanwise velocity. ⟨v⟩_y is taken at 8 stations x = λ_x/8 … λ_x from the 3D
   statistics, phase-averaged over the riblets, over all wavelengths in the domain and over
   both walls, excluding the points inside the riblets. It is fitted with the analytical Stokes-layer solution
   v = C Re[e^{ikx} Ai(−i(z−Δz)/δ_x e^{−4iπ/3})], δ_x = (ν/(u_z0 k))^{1/3}. Its maximum
   over x and z is also computed.
3. Cross-plane slice. (u, v, w) in the y–z plane at x/λ_x = 0.
4. Pressure drag. D_p/D is computed in the minimal channels from the streamwise
   pressure gradient on the u-grid, integrated over the fluid part of each cell.

Averaging choices reproduce the values of the paper:

• the 2D turbulent statistics use a superficial y-average (solid points count as zero);
• the Stokes profiles use an intrinsic (fluid-only) average;
• the geometry masks use the nominal riblet position.

Each routine's docstring gives the details.

Figures

Requirements

Python ≥ 3.9 with numpy, scipy, h5py and matplotlib (requirements.txt). The HDF5 files
can also be read with any HDF5 library (MATLAB h5read, Julia HDF5.jl, h5dump, …).

Licence

CC BY 4.0