---
license: cc-by-4.0
pretty_name: Kolmogorov flow
---

## Simulations of Kolmogorov flow at different Reynolds numbers

This directory contains HDF5 trajectory datasets for 2D Kolmogorov flow simulations across multiple Reynolds numbers.

Each simulation corresponds to monochromatic forcing of the Kolmogorov flow at fixed Reynolds number, corresponding to 6 snapshots for each of 10,000 turnover times. The total number of timepoints varies with Reynolds number due to the fixed timestep used for snapshots, but is typically around 60,000 time steps. Both the timestep and the snapshot interval are scaled by the Reynolds number, and burn-in time has been removed from each set of snapshots.
The geometry and forcing are identical to those used in [Chandler and Kerswell (2013)](https://doi.org/10.1017/jfm.2013.122).

Each `.h5` file contains a `trajectory` dataset that stores vorticity snapshots in a 3D array of shape (T, 512, 512), where T is the number of time steps. The file also includes fields for the Reynolds number, domain extent, injection mode, and time between snapshots.
In two-dimensions, the streamfunction can be uniquely identified from the vorticity using a Poisson solve, and so the raw vorticity fully characterizes the flow.

### Data validation

To ensure the data is valid

```bash
python check_data.py
```

### Usage example

To stream each simulation, we can use the `h5py` library to read the trajectory in chunks. Recall that h5py does not load data into memory until a cast forces it to be materialized, and so we can stream the data in chunks.

```python
import h5py
import numpy as np

all_obs = []
batch_size = 64  # number of time steps to read into memory at a time

## Load the data from the Hugging Face repository
from huggingface_hub import HfFileSystem
repo_id = "williamgilpin/kolmo"
path_in_repo = "re40.h5"  # adjust if stored in a subdirectory

fs = HfFileSystem()
with fs.open(f"datasets/{repo_id}/{path_in_repo}", "rb") as remote_f:
    with h5py.File(remote_f, "r") as f:

        ## Load the simulationmetadata. 
        reynolds_number = float(f.attrs["reynolds_number"])
        nu = 1.0 / reynolds_number # viscosity
        domain_extent = float(f.attrs.get("domain_extent", 2 * np.pi))
        injection_mode = int(f.attrs.get("injection_mode", f.attrs["forcing_frequency"]))
        time_between_snapshots = float(f.attrs["time_between_snapshots"])

        ## Iterate over the trajectory in chunks. Avoid casting the trajectory itself to a
        ## numpy array, because it's too large to fit into memory.
        traj = f["trajectory"]
        n_steps = traj.shape[0]
        first_batch = traj[:batch_size, 0, :, :]
        for start in range(first_batch.shape[0], n_steps, batch_size):
            print(f"Running {start} / {n_steps}", flush=True)
            stop = min(start + batch_size, n_steps)
            batch = traj[start:stop, 0, :, :]
            ## Can operate on the batch here.
```