subsurfacegen/field-scale-dataset

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 at Stanford.

Dataset Summary

Metric	Value
Total index rows	47078
Total HDF5 files	42760
3D SOS velocity volumes (619×1000×1000)	0
3D volume breakdown by model type	f3: 10, fault: 5, gom: 10, penobscot: 1, salt_canopy: 4, seam: 12
2D velocity slices	0
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)	0
slice	2D velocity slice — training input x	velocity	(nz, nx)	0
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={SubsurfaceGen, Stanford University},
  year={2026},
  url={https://huggingface.co/datasets/subsurfacegen/field-scale-dataset},
}

License

This dataset is released under CC BY 4.0.

Contact

SubsurfaceGen, Stanford University.