Add Seismic3DOffsetTilesTemplate and Seismic3DReceiverGathersTemplate

Add two new seismic dataset templates:

- Seismic3DOffsetTilesTemplate: 5D template for wide-azimuth data
  organized by CDP location with offset vector tile decomposition.
  Supports time and depth domains.

- Seismic3DReceiverGathersTemplate: Template for fixed receiver
  surveys (OBN, OBC, land) organized by receiver position.
  Time domain only.

Also fixes duplicate entries in the expected template names test list.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: BrianMichell

src/mdio/builder/template_registry.py

@@ -26,7 +26,9 @@
 from mdio.builder.templates.seismic_3d_cdp import Seismic3DCdpGathersTemplate
 from mdio.builder.templates.seismic_3d_coca import Seismic3DCocaGathersTemplate
 from mdio.builder.templates.seismic_3d_obn import Seismic3DObnReceiverGathersTemplate
+from mdio.builder.templates.seismic_3d_offset_tiles import Seismic3DOffsetTilesTemplate
 from mdio.builder.templates.seismic_3d_poststack import Seismic3DPostStackTemplate
+from mdio.builder.templates.seismic_3d_receiver_gathers import Seismic3DReceiverGathersTemplate
 from mdio.builder.templates.seismic_3d_shot_receiver_line import Seismic3DShotReceiverLineGathersTemplate
 from mdio.builder.templates.seismic_3d_streamer_field import Seismic3DStreamerFieldRecordsTemplate
 from mdio.builder.templates.seismic_3d_streamer_shot import Seismic3DStreamerShotGathersTemplate
@@ -135,6 +137,13 @@ def _register_default_templates(self) -> None:
         self.register(Seismic3DCocaGathersTemplate("time"))
         self.register(Seismic3DCocaGathersTemplate("depth"))
 
+        # Receiver Gathers (OBN, OBC, land fixed-spread) - time domain only
+        self.register(Seismic3DReceiverGathersTemplate())
+
+        # Offset Tiles
+        self.register(Seismic3DOffsetTilesTemplate("time"))
+        self.register(Seismic3DOffsetTilesTemplate("depth"))
+
         # Field (shot) data
         self.register(Seismic2DStreamerShotGathersTemplate())
         self.register(Seismic3DStreamerShotGathersTemplate())

src/mdio/builder/templates/seismic_3d_offset_tiles.py

@@ -0,0 +1,111 @@
+"""Seismic3DOffsetTilesTemplate MDIO v1 dataset templates."""
+
+from typing import Any
+
+from mdio.builder.schemas import compressors
+from mdio.builder.schemas.dtype import ScalarType
+from mdio.builder.schemas.v1.variable import CoordinateMetadata
+from mdio.builder.templates.base import AbstractDatasetTemplate
+from mdio.builder.templates.types import SeismicDataDomain
+
+
+class Seismic3DOffsetTilesTemplate(AbstractDatasetTemplate):
+    """Seismic Offset Tiles pre-stack 3D Dataset template.
+
+    A 5D template for wide-azimuth seismic data organized by offset vector tiles.
+    Data is binned by CDP location (inline, crossline) with offset vector
+    decomposition into inline and crossline offset tile components.
+
+    Dimensions:
+        - inline: Inline bin position
+        - crossline: Crossline bin position
+        - inline_offset_tile: Inline component of the offset vector tile
+        - crossline_offset_tile: Crossline component of the offset vector tile
+        - time/depth: Sample dimension
+
+    This organization is optimal for:
+        - Wide-azimuth data preservation
+        - 5D interpolation and regularization
+        - Azimuthal analysis and processing
+        - Offset vector filtering
+
+    The offset vector tiles partition the offset-azimuth space into a regular grid,
+    preserving both offset magnitude and azimuth information in a format suitable
+    for modern wide-azimuth processing workflows.
+
+    Args:
+        data_domain: The domain of the dataset ('time' or 'depth').
+    """
+
+    def __init__(self, data_domain: SeismicDataDomain = "time"):
+        super().__init__(data_domain=data_domain)
+
+        self._dim_names = (
+            "inline",
+            "crossline",
+            "inline_offset_tile",
+            "crossline_offset_tile",
+            self._data_domain,
+        )
+        self._physical_coord_names = ("cdp_x", "cdp_y")
+        self._logical_coord_names = ()
+        self._var_chunk_shape = (4, 4, 6, 6, 4096)
+
+    @property
+    def _name(self) -> str:
+        return f"OffsetTiles3D{self._data_domain.capitalize()}"
+
+    def _load_dataset_attributes(self) -> dict[str, Any]:
+        return {"surveyType": "3D", "gatherType": "offset_tiles"}
+
+    def _add_coordinates(self) -> None:
+        # Add dimension coordinates
+        self._builder.add_coordinate(
+            "inline",
+            dimensions=("inline",),
+            data_type=ScalarType.INT32,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("inline")),
+        )
+        self._builder.add_coordinate(
+            "crossline",
+            dimensions=("crossline",),
+            data_type=ScalarType.INT32,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("crossline")),
+        )
+        self._builder.add_coordinate(
+            "inline_offset_tile",
+            dimensions=("inline_offset_tile",),
+            data_type=ScalarType.INT16,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("inline_offset_tile")),
+        )
+        self._builder.add_coordinate(
+            "crossline_offset_tile",
+            dimensions=("crossline_offset_tile",),
+            data_type=ScalarType.INT16,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("crossline_offset_tile")),
+        )
+        self._builder.add_coordinate(
+            self.trace_domain,
+            dimensions=(self.trace_domain,),
+            data_type=ScalarType.INT32,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key(self.trace_domain)),
+        )
+
+        # Add non-dimension coordinates
+        compressor = compressors.Blosc(cname=compressors.BloscCname.zstd)
+
+        # CDP coordinates (vary by inline, crossline)
+        self._builder.add_coordinate(
+            "cdp_x",
+            dimensions=("inline", "crossline"),
+            data_type=ScalarType.FLOAT64,
+            compressor=compressor,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("cdp_x")),
+        )
+        self._builder.add_coordinate(
+            "cdp_y",
+            dimensions=("inline", "crossline"),
+            data_type=ScalarType.FLOAT64,
+            compressor=compressor,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("cdp_y")),
+        )

src/mdio/builder/templates/seismic_3d_receiver_gathers.py

@@ -0,0 +1,119 @@
+"""Seismic3DReceiverGathersTemplate MDIO v1 dataset templates."""
+
+from typing import Any
+
+from mdio.builder.schemas import compressors
+from mdio.builder.schemas.dtype import ScalarType
+from mdio.builder.schemas.v1.variable import CoordinateMetadata
+from mdio.builder.templates.base import AbstractDatasetTemplate
+
+
+class Seismic3DReceiverGathersTemplate(AbstractDatasetTemplate):
+    """Seismic receiver gather pre-stack 3D Dataset template.
+
+    A template for surveys with fixed receiver positions (OBN, OBC, land fixed-spread)
+    where data is organized by receiver position for receiver-side processing.
+    Shots are organized by shot lines with a calculated shot index.
+
+    This template is time-domain only as receiver gathers are typically used
+    for early-stage processing before depth conversion.
+
+    Dimensions:
+        - receiver: Index of the receiver node/station
+        - shot_line: Shot line or swath identifier
+        - shot_index: Sequential index of shots within the line (calculated, 0-N)
+        - time: Sample dimension
+
+    This organization is optimal for:
+        - Receiver-side wavefield separation (up/down)
+        - Receiver-consistent deconvolution
+        - Multi-component processing
+        - Mirror imaging from OBN
+    """
+
+    def __init__(self) -> None:
+        super().__init__(data_domain="time")
+
+        self._dim_names = ("receiver", "shot_line", "shot_index", "time")
+        self._calculated_dims = ("shot_index",)
+        self._physical_coord_names = (
+            "receiver_x",
+            "receiver_y",
+            "source_coord_x",
+            "source_coord_y",
+        )
+        self._logical_coord_names = ("shot_point",)
+        self._var_chunk_shape = (1, 1, 512, 4096)
+
+    @property
+    def _name(self) -> str:
+        return "ReceiverGathers3D"
+
+    def _load_dataset_attributes(self) -> dict[str, Any]:
+        return {"surveyType": "3D", "gatherType": "receiver_gathers"}
+
+    def _add_coordinates(self) -> None:
+        # Add dimension coordinates
+        # Note: shot_index is calculated (0-N), so we don't add a coordinate for it
+        self._builder.add_coordinate(
+            "receiver",
+            dimensions=("receiver",),
+            data_type=ScalarType.UINT32,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("receiver")),
+        )
+        self._builder.add_coordinate(
+            "shot_line",
+            dimensions=("shot_line",),
+            data_type=ScalarType.UINT32,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("shot_line")),
+        )
+        self._builder.add_coordinate(
+            self.trace_domain,
+            dimensions=(self.trace_domain,),
+            data_type=ScalarType.INT32,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key(self.trace_domain)),
+        )
+
+        # Add non-dimension coordinates
+        compressor = compressors.Blosc(cname=compressors.BloscCname.zstd)
+
+        # Receiver coordinates (fixed per receiver)
+        self._builder.add_coordinate(
+            "receiver_x",
+            dimensions=("receiver",),
+            data_type=ScalarType.FLOAT64,
+            compressor=compressor,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("receiver_x")),
+        )
+        self._builder.add_coordinate(
+            "receiver_y",
+            dimensions=("receiver",),
+            data_type=ScalarType.FLOAT64,
+            compressor=compressor,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("receiver_y")),
+        )
+
+        # Shot point coordinate (actual shot point numbers, varies by shot_line and shot_index)
+        self._builder.add_coordinate(
+            "shot_point",
+            dimensions=("shot_line", "shot_index"),
+            data_type=ScalarType.UINT32,
+            compressor=compressor,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("shot_point")),
+        )
+
+        # Source coordinates (vary by shot_line and shot_index)
+        self._builder.add_coordinate(
+            "source_coord_x",
+            dimensions=("shot_line", "shot_index"),
+            data_type=ScalarType.FLOAT64,
+            compressor=compressor,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("source_coord_x")),
+        )
+        self._builder.add_coordinate(
+            "source_coord_y",
+            dimensions=("shot_line", "shot_index"),
+            data_type=ScalarType.FLOAT64,
+            compressor=compressor,
+            metadata=CoordinateMetadata(units_v1=self.get_unit_by_key("source_coord_y")),
+        )