Field-Scale Dataset

A large-scale benchmark dataset of field-scale 3D subsurface velocity volumes (SOS-smoothed, depth-truncated to 619 samples) paired with 2D velocity slices, their corresponding acoustic wavefields, and multi-source shot-gather cubes. The dataset spans multiple geological settings and covers five frequency bands (3-6, 3-8.5, 3-12, 3-17.5, 3-25 Hz), supporting wavefield prediction, seismic inversion, source-aware training from the 64-source shot-gather cubes, and out-of-distribution evaluation across held-out geology and broader frequency bandwidths.

Maintained by the SubsurfaceGen project. Author affiliations withheld for double-blind review.

👀 Want a quick look first? Try the preview repo.

The full dataset above is ~12 TB across 47,078 HDF5 files — too large for a quick browse. We ship a hand-curated single-family preview that downloads in under 5 min (~2.8 GB) and contains exactly one example of each data type (3D model, 2D slice, wavefield, shot-gather cube), all derived from the same source slice and aligned with the manuscript's intro figure.

➡️ subsurfacegen/field-scale-dataset-preview

The preview repo's README has all five figures pre-rendered inline (no download needed) plus a runnable view_preview.py + executed view_preview.ipynb that show how to load and plot every file type with just numpy + matplotlib + h5py.

Dataset Summary

Dataset Structure

Parquet Index

The data/all.parquet file is a sidecar index that catalogs every HDF5 file in the dataset. Each row represents one HDF5 file. The slice_id column links related files together --- a velocity slice, its wavefield(s), and its shot gather(s) all share the same slice_id.

Browse the index using the Dataset Viewer above to explore all 25 columns interactively.

Data Types

Splits

Splits are assigned to 2D slice rows and inherited by their derived wavefield and gather rows (same slice_id ⇒ same split). The 42 3D model rows are not split-assigned and have split = null — use them for diagnostics, conditioning, or downstream studies rather than as train/test samples directly.

Propagation Time

• Wavefields exist at 5s propagation time only.
• Shot-gather cubes exist at 8s propagation time only (64 sources stacked per slice).

Schema (25 columns)

Directory Structure

dataset_root/
├── data/
│   ├── all.parquet                       # Sidecar index (25 columns, all rows)
│   ├── train.parquet                     # Same schema, split=train only
│   ├── test_in_dist.parquet
│   └── test_out_dist.parquet
├── models/
│   └── {model_type}_d619/               # 42 SOS-smoothed 3D volumes
│       └── {model_id}_sos.h5           # shape (619, 1000, 1000)
├── slices/                                # 4,276 individual 2D slices
│   └── slice_{slice_id}.h5
├── wavefields/
│   └── 5s/{freq_band}/                  # 5 bands × 4,276 = 21,380 files
│       └── wavefield_{slice_id}_*.h5
└── shot_gathers/
    └── 8s/{freq_band}/                  # 5 bands × 4,276 = 21,380 cubes
        └── shot_gather_cube_{slice_id}.h5

Usage

Browse the Index

import pandas as pd

# Load the full index
df = pd.read_parquet("data/all.parquet")

# Filter by split and data type
train_slices = df[(df.split == "train") & (df.data_type == "slice")]
train_wavefields = df[
    (df.split == "train") & (df.data_type == "wavefield")
    & (df.frequency_band == "3-6Hz")
]

# Pair velocity slices with wavefields for training
pairs = train_slices.merge(train_wavefields, on="slice_id", suffixes=("_vel", "_wf"))
print(f"Training pairs: {len(pairs)}")

Load Individual HDF5 Files

import h5py

# 3D SOS velocity volume (root-group attr "metadata" is a JSON string)
import json
with h5py.File("models/f3_d619/f3_042_sos.h5", "r") as f:
    volume = f["velocity"][:]             # (619, 1000, 1000) float32
    meta = json.loads(f.attrs["metadata"])
    print(meta["model_type"], meta["stats_smoothed"])

# 2D velocity slice
with h5py.File("slices/slice_f3_042_il_0123.h5", "r") as f:
    velocity = f["velocity"][:]           # (nz, nx) float32
    model_type = f["velocity"].attrs["model_type"]

# Wavefield (5s)
with h5py.File("wavefields/5s/3-6Hz/wavefield_f3_042_il_0123_srchorizontal5.000km.h5", "r") as f:
    wavefield = f["wavefield"][:]         # (nt, nz, nx) float32
    freq_band = f["wavefield"].attrs["frequency_band"]

# Shot-gather cube (8s, 64 sources stacked)
with h5py.File("shot_gathers/8s/3-6Hz/shot_gather_cube_f3_042_il_0123.h5", "r") as f:
    cube = f["shot_gather_cube"][:]       # (n_sources, n_time, n_receivers) float32
    n_src = f["shot_gather_cube"].attrs["n_sources"]

Dataset Creation

Source Data

Field-scale 3D velocity models inspired by publicly available subsurface surveys:

• F3 (Netherlands North Sea)
• GOM (Gulf of Mexico)
• Fault (synthetic fault models)
• Salt Canopy (synthetic salt body models)
• SEAM (SEG Advanced Modeling)
• Penobscot (offshore Canada, held out for OOD testing)

Models are processed through structure-oriented smoothing (SOS), following Hale (2009, CWP-635), to produce smooth background velocity fields suitable for acoustic wave propagation, and depth-truncated to 619 samples so all volumes share a common depth.

Wavefield Generation

2D acoustic wavefields are generated by solving the constant-density acoustic wave equation on each velocity slice using finite-difference time-domain (FDTD) simulation, implemented with Devito — a Python DSL that compiles optimized stencil kernels from symbolic PDEs (Louboutin et al., 2019). Each slice is simulated for 5 seconds per frequency band.

Numerical simulation parameters (all bands):

Source wavelet — band-limited Ricker. The injected source time function is a Ricker wavelet (negative normalized second derivative of a Gaussian), then band-passed with a 4th-order Butterworth filter (forward-backward, zero-phase) and amplitude-normalized by sqrt(bandwidth / 24 Hz) so that wider-band sources carry physically consistent energy. Peak frequency f0 is chosen per band for spectral centering:

For each wavefield file, the source x-position is sampled uniformly at random along the slice (with a 0.5 km margin from each edge). Seeds are fixed (random_seed=42) so source placements are reproducible from the metadata.

Shot-Gather Cubes

For seismic inversion and source-aware studies, each slice is additionally simulated for 8 seconds with 64 equally-spaced sources (same 0.5 km edge margins), producing a stacked shot-gather cube per slice per band. Each cube has shape (64, n_time, 1000) (sources × decimated time samples × receivers), is stored under HDF5 key shot_gather_cube, and is time- decimated by factor 14. Simulation parameters are otherwise identical to the wavefield runs above.

References

• Devito (finite-difference solver) — Louboutin, M., Lange, M., Luporini, F., Kukreja, N., Witte, P. A., Herrmann, F. J., Velesko, P., & Gorman, G. J. (2019). Devito (v3.1.0): an embedded domain-specific language for finite differences and geophysical exploration. Geoscientific Model Development, 12(3), 1165-1187. https://doi.org/10.5194/gmd-12-1165-2019
• Structure-oriented smoothing (3D velocity preprocessing) — Hale, D. (2009). Structure-oriented smoothing and semblance. CWP-635, Center for Wave Phenomena, Colorado School of Mines.

Citation

@dataset{subsurfacegen_field_scale_dataset,
  title={Field-Scale Dataset: SOS-smoothed velocity volumes, 2D slices, wavefields, and 8s shot-gather cubes},
  author={Anonymous},
  year={2026},
  url={https://huggingface.co/datasets/subsurfacegen/field-scale-dataset},
}

License

This dataset is released under CC BY 4.0.

Contact

Removed for anonymous review.

📊 Structured Schema (Zero-Fabrication)

Estimated Rows: 94,114