The dataset contains results from approximately 150 direct numerical simulations of turbulent channel flows with riblets on both walls.
The friction Reynolds number is 400, and the results are obtained with a second-order finite differences code which advances in time with a third order Runge-Kutta scheme.
The wall geometry is resolved with an immersed-boundary method, and statistics are averaged over approximately 80 large-eddy-turnover time units.

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.
| parameter | values | directory name |
|---|---|---|
| cross-section | triangular, 60° tip angle; trapezoidal, 30° | tri_60, tra_30 |
| riblet size ℓ_g⁺ = ℓ_g/ν | ≈ 10, 12, 14, 17 | lg10, lg12, lg14, lg17 |
| wavelength λ_x⁺ | 250, 500, 750, 1000, 1250, 1500 | l0250 … l1500 |
| maximum crest inclination β | 4°, 8°, 12° | b04, b08, b12 |
| straight riblets | – | straight |
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).
  | field | meaning |
  |---|---|
  | U, V, W | mean velocity components (streamwise, spanwise, wall-normal) |
  | uu, vv, ww, uw, uv | Reynolds stresses ⟨u_i′u_j′⟩ |
  | P | mean pressure (only in the runs that sampled it: *-minimal-p, 2D and 3D) |
• 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