---
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`](https://huggingface.co/datasets/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

```python
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

```python
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

```bibtex
@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](https://creativecommons.org/licenses/by/4.0/).

## Contact

Removed for anonymous review.