Datasets:

subsurfacegen
/

field-scale-dataset

license: cc-by-4.0
task_categories:
  - image-to-image
tags:
  - benchmark
  - geoscience
  - seismology
  - geophysics
  - subsurface
  - velocity-model
  - acoustic-wavefield
  - wave-propagation
  - scientific-computing
  - physics-informed
  - HDF5
pretty_name: Field-Scale Dataset
size_categories:
  - 10K<n<100K
configs:
  - config_name: default
    data_files:
      - split: all
        path: data/all.parquet
      - split: train
        path: data/train.parquet
      - split: test_in_dist
        path: data/test_in_dist.parquet
      - split: test_out_dist
        path: data/test_out_dist.parquet
dataset_info:
  features:
    - name: slice_id
      dtype: string
    - name: model_id
      dtype: string
    - name: data_type
      dtype: string
    - name: model_type
      dtype: string
    - name: split
      dtype: string
    - name: file_path
      dtype: string
    - name: orientation
      dtype: string
    - name: slice_index
      dtype: int32
    - name: slice_location_m
      dtype: float32
    - name: slice_axis
      dtype: int32
    - name: volume_shape
      dtype: string
    - name: depth_samples
      dtype: int32
    - name: width_samples
      dtype: int32
    - name: propagation_time_s
      dtype: float32
    - name: frequency_band
      dtype: string
    - name: f_min_hz
      dtype: float32
    - name: f_max_hz
      dtype: float32
    - name: velocity_min_m_per_s
      dtype: float32
    - name: velocity_max_m_per_s
      dtype: float32
    - name: velocity_mean_m_per_s
      dtype: float32
    - name: velocity_std_m_per_s
      dtype: float32
    - name: source_x_km
      dtype: float32
    - name: source_z_km
      dtype: float32
    - name: source_x_idx
      dtype: int32
    - name: source_z_idx
      dtype: int32

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

Metric	Value
Total index rows	47078
Total HDF5 files	47078
3D SOS velocity volumes (619×1000×1000)	42
3D volume breakdown by model type	f3: 10, fault: 5, gom: 10, penobscot: 1, salt_canopy: 4, seam: 12
2D velocity slices	4276
Wavefields (5s)	21380
Shot-gather cubes (8s, 64 sources each)	21380
Train samples (slice rows)	4096
Test in-distribution (slice rows)	100
Test out-of-distribution (slice rows)	80
Model types	`f3`, `fault`, `gom`, `penobscot`, `salt_canopy`, `seam`
Frequency bands	`3-12Hz`, `3-17.5Hz`, `3-25Hz`, `3-6Hz`, `3-8.5Hz`

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

`data_type`	Description	HDF5 Key	Shape	Count
`model`	3D SOS-smoothed velocity volume (depth-truncated to 619)	`velocity`	`(619, 1000, 1000)`	42
`slice`	2D velocity slice — training input x	`velocity`	`(nz, nx)`	4276
`wavefield`	2D acoustic wavefield — training target y (5s)	`wavefield`	`(nt, nz, nx)`	21380
`gather`	Multi-source shot-gather cube (8s, 64 sources)	`shot_gather_cube`	`(n_sources, n_time, n_receivers)`	21380

Splits

Split	Description
`train`	Training data (all model types)
`test_in_dist`	In-distribution test (same model types as train, different slices)
`test_out_dist`	Out-of-distribution test (held-out geology)

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)

#	Column	Type	Description
1	`slice_id`	string	Links related files (e.g., `f3_042_il0123`). Null for 3D models
2	`model_id`	string	Source 3D model (e.g., `f3_042`)
3	`data_type`	string	`model` \| `slice` \| `wavefield` \| `gather`
4	`model_type`	string	Geological category (e.g., `f3`, `gom`, `fault`)
5	`split`	string	`train` \| `test_in_dist` \| `test_out_dist`
6	`file_path`	string	Relative path to HDF5 file
7	`orientation`	string	`inline` or `crossline`
8	`slice_index`	int32	Index in original 3D volume
9	`slice_location_m`	float32	Physical position in meters
10	`slice_axis`	int32	1 (inline) or 2 (crossline)
11	`volume_shape`	string	Source volume dims (e.g., `960x1000x1000`)
12	`depth_samples`	int32	nz of this array (varies by model type)
13	`width_samples`	int32	nx of this array
14	`propagation_time_s`	float32	Wavefields=5.0, shot-gather cubes=8.0
15	`frequency_band`	string	e.g., `3-25Hz`
16	`f_min_hz`	float32	Band minimum frequency
17	`f_max_hz`	float32	Band maximum frequency
18	`velocity_min_m_per_s`	float32	Min velocity (m/s)
19	`velocity_max_m_per_s`	float32	Max velocity (m/s)
20	`velocity_mean_m_per_s`	float32	Mean velocity (m/s)
21	`velocity_std_m_per_s`	float32	Std velocity (m/s)
22	`source_x_km`	float32	Source X position (km)
23	`source_z_km`	float32	Source Z depth (km)
24	`source_x_idx`	int32	Source X grid index
25	`source_z_idx`	int32	Source Z grid index

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

Parameter	Value
Solver / kernels	Devito `examples.seismic` AcquisitionGeometry + Model
Grid spacing	10 m × 10 m
Time step	1.0 ms
FD stencil space order	8
Absorbing boundary	60-cell sponge (Devito `bcs="damp"`)
Top boundary	Free surface (`fs=True`)
Wavefield temporal subsample	factor 14 (stored every 14th step)
Receivers	1,000 per slice, streamer at 10 m depth
Source depth	10 m

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:

Band	f0 (Hz)	Bandpass
3-6 Hz	4.5	3.0 – 6.0
3-8.5 Hz	5.75	3.0 – 8.5
3-12 Hz	7.5	3.0 – 12.0
3-17.5 Hz	10.25	3.0 – 17.5
3-25 Hz	14.0	3.0 – 25.0

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.