Add files using upload-large-folder tool

LICENSE

@@ -1,5 +1,111 @@
-This package aggregates collocated oceanographic data derived from upstream public products.
+DepthDif GeoTIFF Raster and Aligned ARGO Dataset
+Dataset license notice
 
-Use is subject to the terms and citation requirements of the upstream EN4/ARGO,
-GLORYS, OSTIA, sea-level, and sea-surface-salinity products. This file is a
-dataset license notice, not a replacement for upstream product licenses.
+SPDX-License-Identifier: CC-BY-4.0
+
+This dataset package is released by the DepthDif contributors under the
+Creative Commons Attribution 4.0 International license (CC BY 4.0).
+
+You may share and adapt this dataset package, including for commercial use,
+provided that you give appropriate credit, provide a link to the license, and
+indicate whether changes were made. The full license text is available at:
+https://creativecommons.org/licenses/by/4.0/legalcode
+
+Suggested citation for this package:
+DepthDif contributors. DepthDif GeoTIFF Raster and Aligned ARGO Dataset.
+Hugging Face dataset repository, 2026.
+
+Please cite or acknowledge DepthDif together with the upstream data products
+that are relevant to your use. This package contains transformed, collocated,
+and rasterized products derived from public oceanographic data sources. It does
+not replace the licenses, terms of use, or citation requirements attached to
+those upstream products. Where an upstream provider applies additional terms,
+those provider terms continue to apply to the corresponding source-derived
+content.
+
+Source-provider acknowledgments and citations
+============================================
+
+Copernicus Marine Service
+-------------------------
+This dataset uses Copernicus Marine Service products for GLORYS ocean
+reanalysis, OSTIA sea-surface temperature, gridded sea-level fields, and
+multi-observation sea-surface salinity/density. When using these derived fields,
+include the Copernicus Marine attribution statement:
+
+Generated using E.U. Copernicus Marine Service Information.
+
+Relevant Copernicus Marine products include:
+
+- GLOBAL_MULTIYEAR_PHY_001_030, Global Ocean Physics Reanalysis / GLORYS12V1,
+  doi:10.48670/moi-00021.
+- SST_GLO_SST_L4_REP_OBSERVATIONS_010_011, Global Ocean OSTIA Sea Surface
+  Temperature and Sea Ice Reprocessed, doi:10.48670/moi-00168.
+- SEALEVEL_GLO_PHY_L4_MY_008_047, Global Ocean Gridded L4 Sea Surface Heights
+  and derived variables, doi:10.48670/moi-00148.
+- MULTIOBS_GLO_PHY_S_SURFACE_MYNRT_015_013, Global Ocean Multi Observation
+  sea-surface salinity products, doi:10.48670/moi-00051.
+
+Copernicus Marine license information is available from the Copernicus Marine
+Service Commitments and Licence page:
+https://marine.copernicus.eu/user-corner/service-commitments-and-licence
+
+EN4 profile archive and ARGO observations
+-----------------------------------------
+The in-situ profile source for this package is the UK Met Office Hadley Centre
+EN4.2.2 profile archive. The source files identify EN4 as distributed under the
+UK Non-Commercial Government Licence and request attribution to the data
+providers. Users should check the current EN4 terms before any downstream use
+that depends on the profile-derived content.
+
+Please cite the EN4 dataset paper when using the profile component:
+Good, S. A., M. J. Martin, and N. A. Rayner. 2013. EN4: quality controlled
+ocean temperature and salinity profiles and monthly objective analyses with
+uncertainty estimates. Journal of Geophysical Research: Oceans 118, 6704-6716.
+doi:10.1002/2013JC009067.
+
+The EN4 profile archive contains Argo-origin observations. When using those
+profiles, also acknowledge the International Argo Program and the national
+programs that contribute to it. Argo is part of the Global Ocean Observing
+System. Useful references are:
+
+- Argo. 2000. Argo float data and metadata from Global Data Assembly Centre
+  (Argo GDAC). SEANOE. doi:10.17882/42182.
+- Wong, A. P. S., et al. 2020. Argo Data 1999-2019: Two Million
+  Temperature-Salinity Profiles and Subsurface Velocity Observations From a
+  Global Array of Profiling Floats. Frontiers in Marine Science 7:700.
+  doi:10.3389/fmars.2020.00700.
+
+More information about acknowledging Argo is available at:
+https://argo.ucsd.edu/data/acknowledging-argo/
+
+OSTIA, GHRSST, and Met Office context
+-------------------------------------
+The OSTIA sea-surface temperature fields are provided through Copernicus Marine
+and originate from the UK Met Office OSTIA/GHRSST product stream. For work that
+uses the SST context, acknowledge GHRSST, the Met Office, and Copernicus Marine
+as data providers where appropriate.
+
+A commonly cited OSTIA reference is:
+Donlon, C. J., M. Martin, J. D. Stark, J. Roberts-Jones, E. Fiedler, and
+W. Wimmer. 2012. The Operational Sea Surface Temperature and Sea Ice Analysis
+(OSTIA) system. Remote Sensing of Environment 116, 140-158.
+doi:10.1016/j.rse.2010.10.017.
+
+Sea-level and sea-surface-salinity context
+------------------------------------------
+The sea-level fields are Copernicus Marine L4 products distributed by the Sea
+Level Thematic Assembly Center. The sea-surface salinity and density fields are
+Copernicus Marine multi-observation products. Cite the product identifiers and
+DOIs listed above when those variables are used in analysis, training, or model
+outputs.
+
+Example acknowledgement
+-----------------------
+This work uses the DepthDif GeoTIFF Raster and Aligned ARGO Dataset, generated
+from transformed and collocated EN4/ARGO profile data, GLORYS ocean reanalysis,
+OSTIA sea-surface temperature, Copernicus Marine sea-level fields, and
+Copernicus Marine sea-surface-salinity products. It was generated using E.U.
+Copernicus Marine Service Information. Argo-origin observations were collected
+and made freely available by the International Argo Program and contributing
+national programs.

README.md

@@ -1,5 +1,5 @@
 ---
-license: other
+license: cc-by-4.0
 pretty_name: DepthDif GeoTIFF raster and aligned ARGO dataset
 tags:
 - oceanography
@@ -53,6 +53,10 @@ assets/
   figures/depthdif_schema.png
   data/geotiff_dataset_random100_surface.png
   data/argo_on_glorys_grid_3D.gif
+  data/argo_valid_pixels_per_patch.webp
+  data/patch_grid/patch_grid_global_overview.webp
+  data/patch_grid/patch_overlap_regional_example.webp
+  data/patch_grid/land_fraction_filter_examples.webp
   data/profile_comparison_good_alignment.png
   data/profile_comparison_bad_alignment.png
 rasters/
@@ -76,8 +80,14 @@ metadata/
 examples/
   open_with_xarray.py
   subset_by_region_time.py
+  torch_dataloader.py
+depthdif_dataset/
+  dataset.py
+  dataloaders.py
+  normalizations.py
 manifest.yaml
 masks/
+requirements-loader.txt
 ```
 
 The `rasters/` directory is intentionally at the repository root. It contains
@@ -97,8 +107,8 @@ sea-surface-salinity context.
 
 All GeoTIFF rasters are exported on the GLORYS 0.1 degree global grid
 (`EPSG:4326`, 3600 x 1800 pixels, west-to-east longitudes from -180 to 180 and
-north-to-south latitudes from 90 to -90). The current package contains 761
-weekly target dates per raster product, from 2010-01-01 through 2024-07-26.
+north-to-south latitudes from 90 to -90). The current package contains 1283
+weekly target dates per raster product, from 2000-01-01 through 2024-07-26.
 Files are named `<variable>_YYYYMMDD.tif`.
 
 The GLORYS variables are depth-resolved 50-band GeoTIFFs:
@@ -119,6 +129,211 @@ Raster pixels are stored as `uint8` with `255` reserved for nodata. Valid codes
 per-file statistics, source filenames, compression, target dates, and the full
 depth axis are also recorded there.
 
+## PyTorch Dataset and DataLoader
+
+The repository includes a standalone loader package in `depthdif_dataset/`.
+It is designed to work directly from a local Hugging Face dataset checkout
+without installing the full DepthDif training repository.
+
+Install the loader dependencies in your environment:
+
+```bash
+pip install -r requirements-loader.txt
+```
+
+Minimal PyTorch usage from the dataset repository root:
+
+```python
+from depthdif_dataset import ArgoGeoTIFFGriddedPatchDataset, build_dataloader
+
+dataset = ArgoGeoTIFFGriddedPatchDataset(
+    geotiff_root_dir=".",
+    split="all",
+    tile_size=128,
+    patch_stride=128,
+    max_dates=1,
+    metadata_cache_dir=None,
+)
+loader = build_dataloader(dataset, batch_size=2, num_workers=0)
+batch = next(iter(loader))
+print(batch["x"].shape, batch["eo"].shape, batch["land_mask"].shape)
+```
+
+The default sample contains normalized tensors for sparse ARGO temperature
+input (`x`), dense GLORYS temperature target (`y`), dense surface context
+(`eo`), validity masks, the ocean `land_mask`, target `date`, patch
+coordinates, and a small `info` dictionary. Set `include_salinity=True` to
+add `x_salinity`, `y_salinity`, and their masks. Use `eo_source="sss"` with
+`eo_var_name="sos"` to use sea-surface salinity as the surface context
+instead of OSTIA SST.
+
+A runnable smoke test is included:
+
+```bash
+python examples/torch_dataloader.py --root . --date-start 20000101 --max-dates 1 --batch-size 2
+```
+
+ARGO-support filtering for train/validation splits requires counting profile
+overlap per patch/date. The loader skips that scan for `split="all"` unless
+`count_argo_support=True` or `--require-argo` is set in the example script.
+
+### Patch Grid, Overlap, and Land Filtering
+
+The loader builds square patches on the fixed 0.1 degree GLORYS grid. With the
+default `tile_size=128`, one sample covers a 12.8 x 12.8 degree region and has
+50 depth bands. `patch_stride` controls how far the next patch starts:
+
+- `patch_stride=128`: non-overlapping global tiles.
+- `patch_stride=96`: 32-pixel overlap, or 3.2 degrees at 0.1 degree resolution.
+- `patch_stride=32`: 96-pixel overlap, or 9.6 degrees at 0.1 degree resolution.
+
+Smaller strides create more samples and make neighboring patches share more
+context, but they also increase row-index size and training time. If you use
+overlap for train/validation splits, prefer a temporal validation split such as
+`val_year=2018`; spatial random splits with overlapping patches can leak nearly
+identical context between train and validation.
+
+<p align="center">
+  <img src="assets/data/patch_grid/patch_grid_global_overview.webp" width="78%" alt="Global patch grid overview" />
+</p>
+
+<p align="center">
+  <img src="assets/data/patch_grid/patch_overlap_regional_example.webp" width="72%" alt="Regional example of overlapping patch windows" />
+</p>
+
+`max_land_fraction` filters out patches that are mostly land. The default
+`max_land_fraction=0.30` keeps patches with at least 70 percent ocean pixels.
+Increase it for coastal finetuning, or decrease it for open-ocean training.
+The returned `land_mask` tensor uses `1` for ocean/support pixels and `0` for
+land or unavailable support.
+
+<p align="center">
+  <img src="assets/data/patch_grid/land_fraction_filter_examples.webp" width="72%" alt="Examples of patch filtering by land fraction" />
+</p>
+
+### Common Loader Recipes
+
+Use a small date slice for quick inspection without building a large metadata
+cache:
+
+```python
+dataset = ArgoGeoTIFFGriddedPatchDataset(
+    geotiff_root_dir=".",
+    split="all",
+    date_start=20000101,
+    max_dates=1,
+    tile_size=128,
+    patch_stride=128,
+    metadata_cache_dir=None,
+)
+```
+
+Use overlapping patches for training:
+
+```python
+dataset = ArgoGeoTIFFGriddedPatchDataset(
+    geotiff_root_dir=".",
+    split="train",
+    tile_size=128,
+    patch_stride=32,
+    val_year=2018,
+    metadata_cache_dir="depthdif_cache",
+)
+```
+
+Use salinity targets and ARGO salinity inputs:
+
+```python
+dataset = ArgoGeoTIFFGriddedPatchDataset(
+    geotiff_root_dir=".",
+    split="all",
+    include_salinity=True,
+    output_fields=("temperature", "salinity"),
+    metadata_cache_dir=None,
+    max_dates=1,
+)
+```
+
+Use sea-surface salinity as the surface context instead of OSTIA SST:
+
+```python
+dataset = ArgoGeoTIFFGriddedPatchDataset(
+    geotiff_root_dir=".",
+    split="all",
+    eo_source="sss",
+    eo_var_name="sos",
+    include_salinity=True,
+    metadata_cache_dir=None,
+    max_dates=1,
+)
+```
+
+Use synthetic sparse observations sampled from the dense GLORYS target instead
+of real ARGO profiles:
+
+```python
+dataset = ArgoGeoTIFFGriddedPatchDataset(
+    geotiff_root_dir=".",
+    split="all",
+    synthetic_mode=True,
+    synthetic_pixel_count=250,
+    require_argo_for_all=False,
+    metadata_cache_dir=None,
+    max_dates=1,
+)
+```
+
+Filter samples to patch/date rows that contain ARGO support. This does extra
+index work and is worth caching when used repeatedly:
+
+```python
+dataset = ArgoGeoTIFFGriddedPatchDataset(
+    geotiff_root_dir=".",
+    split="all",
+    count_argo_support=True,
+    require_argo_for_all=True,
+    metadata_cache_dir="depthdif_cache",
+    date_start=20000101,
+    max_dates=1,
+)
+```
+
+The ARGO support map below shows why this filter changes the row distribution:
+many open-ocean patches have dense support, while other valid ocean patches may
+have no profiles for a given weekly target date.
+
+<p align="center">
+  <img src="assets/data/argo_valid_pixels_per_patch.webp" width="78%" alt="ARGO valid pixels per training patch" />
+</p>
+
+### Sample Dictionary
+
+The default dataset returns normalized tensors:
+
+- `x`: sparse ARGO temperature input, shape `(50, tile_size, tile_size)`.
+- `y`: dense GLORYS temperature target, shape `(50, tile_size, tile_size)`.
+- `eo`: dense surface context, shape `(1, tile_size, tile_size)`.
+- `x_valid_mask` and `y_valid_mask`: boolean temperature masks.
+- `x_valid_mask_1d`: depth-collapsed sparse-input support mask.
+- `land_mask`: ocean/support mask, shape `(1, tile_size, tile_size)`.
+- `date`: target date as `YYYYMMDD`.
+- `coords`: patch center latitude and longitude when `return_coords=True`.
+- `info`: patch/date metadata when `return_info=True`.
+
+When `include_salinity=True`, samples also include `x_salinity`,
+`y_salinity`, `x_salinity_valid_mask`, `y_salinity_valid_mask`, and
+`x_salinity_valid_mask_1d`.
+
+Temperatures are normalized from Celsius using the DepthDif training statistics;
+salinity is normalized from PSU. To recover physical units:
+
+```python
+from depthdif_dataset import salinity_normalize, temperature_normalize
+
+temperature_c = temperature_normalize(mode="denorm", tensor=batch["y"])
+salinity_psu = salinity_normalize(mode="denorm", tensor=batch["y_salinity"])
+```
+
 ## ARGO Alignment Examples
 
 ARGO profiles are projected onto the fixed 50-level GLORYS depth axis before
@@ -156,9 +371,14 @@ variables = pd.read_parquet("indices/variables.parquet")
 
 Coverage:
 
-- Raster target dates: 2010-01-01 to 2024-07-26
-- Enriched ARGO profile dates: 2010-01-01 to 2024-07-31
+- Raster target dates: 2000-01-01 to 2024-07-26
+- Raster target date count per product: 1283
+- Enriched ARGO profiles: 9485977
+- Enriched ARGO profile dates: 2000-01-01 to 2024-07-31
+- Compact grid-indexed ARGO profiles: 9451644
 - GLORYS depth levels: 50
 
-Upstream product licenses and citation requirements for EN4/ARGO, GLORYS,
-OSTIA, sea-level, and sea-surface-salinity products still apply.
+The package is released as CC BY 4.0. Upstream product licenses and citation
+requirements for EN4/ARGO, GLORYS, OSTIA, sea-level, and
+sea-surface-salinity products still apply; see `LICENSE` for the attribution
+notice.

argo/argo_profiles_on_grid.zarr/.zmetadata

@@ -1 +1 @@
-{"metadata": {".zgroup": {"zarr_format": 2}, ".zattrs": {"created_by": "depth_recon.data.dataset_creation.export_dataset_geotiff.export_dataset_geotiff", "source_kind": "enriched", "temperature_units": "K", "temperature_stretch": {"name": "temperature_kelvin", "storage_dtype": "uint8", "minimum": 270.15, "maximum": 308.15, "units": "K", "nodata": 255, "valid_code_min": 0, "valid_code_max": 254, "valid_code_count": 255, "quantization_step": 0.14960629921259844, "max_abs_quantization_error": 0.07480314960629922, "decode": "minimum + code / 254 * (maximum - minimum)"}, "salinity_stretch": {"name": "salinity", "storage_dtype": "uint8", "minimum": 30.0, "maximum": 40.0, "units": "PSU", "nodata": 255, "valid_code_min": 0, "valid_code_max": 254, "valid_code_count": 255, "quantization_step": 0.03937007874015748, "max_abs_quantization_error": 0.01968503937007874, "decode": "minimum + code / 254 * (maximum - minimum)"}, "temporal_assignment": "nearest GLORYS target date inside centered 7-day window"}, "argo_psal_uint8/.zattrs": {"nodata": 255, "name": "salinity", "storage_dtype": "uint8", "minimum": 30.0, "maximum": 40.0, "units": "PSU", "valid_code_min": 0, "valid_code_max": 254, "valid_code_count": 255, "quantization_step": 0.03937007874015748, "max_abs_quantization_error": 0.01968503937007874, "decode": "minimum + code / 254 * (maximum - minimum)", "_ARRAY_DIMENSIONS": ["profile", "glorys_depth"]}, "argo_psal_uint8/.zarray": {"shape": [6608517, 50], "chunks": [50000, 50], "dtype": "|u1", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "argo_psal_valid/.zattrs": {"dtype": "bool", "_ARRAY_DIMENSIONS": ["profile", "glorys_depth"]}, "argo_psal_valid/.zarray": {"shape": [6608517, 50], "chunks": [50000, 50], "dtype": "|i1", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "argo_temp_kelvin_uint8/.zattrs": {"nodata": 255, "name": "temperature_kelvin", "storage_dtype": "uint8", "minimum": 270.15, "maximum": 308.15, "units": "K", "valid_code_min": 0, "valid_code_max": 254, "valid_code_count": 255, "quantization_step": 0.14960629921259844, "max_abs_quantization_error": 0.07480314960629922, "decode": "minimum + code / 254 * (maximum - minimum)", "_ARRAY_DIMENSIONS": ["profile", "glorys_depth"]}, "argo_temp_kelvin_uint8/.zarray": {"shape": [6608517, 50], "chunks": [50000, 50], "dtype": "|u1", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "argo_temp_valid/.zattrs": {"dtype": "bool", "_ARRAY_DIMENSIONS": ["profile", "glorys_depth"]}, "argo_temp_valid/.zarray": {"shape": [6608517, 50], "chunks": [50000, 50], "dtype": "|i1", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "glorys_depth/.zattrs": {"_ARRAY_DIMENSIONS": ["glorys_depth"]}, "glorys_depth/.zarray": {"shape": [50], "chunks": [50], "dtype": "<f4", "fill_value": "NaN", "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "grid_col/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "grid_col/.zarray": {"shape": [6608517], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "grid_row/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "grid_row/.zarray": {"shape": [6608517], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "latitude/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "latitude/.zarray": {"shape": [6608517], "chunks": [50000], "dtype": "<f4", "fill_value": "NaN", "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "longitude/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "longitude/.zarray": {"shape": [6608517], "chunks": [50000], "dtype": "<f4", "fill_value": "NaN", "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "profile/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "profile/.zarray": {"shape": [6608517], "chunks": [103259], "dtype": "<i8", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "profile_date/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "profile_date/.zarray": {"shape": [6608517], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "profile_source_file/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "profile_source_file/.zarray": {"shape": [6608517], "chunks": [50000], "dtype": "<U33", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "source_profile_idx/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "source_profile_idx/.zarray": {"shape": [6608517], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "target_date/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "target_date/.zarray": {"shape": [6608517], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}}, "zarr_consolidated_format": 1}
+{"metadata": {".zgroup": {"zarr_format": 2}, ".zattrs": {"created_by": "depth_recon.data.dataset_creation.export_dataset_geotiff.export_dataset_geotiff", "source_kind": "enriched", "temperature_units": "K", "temperature_stretch": {"name": "temperature_kelvin", "storage_dtype": "uint8", "minimum": 270.15, "maximum": 308.15, "units": "K", "nodata": 255, "valid_code_min": 0, "valid_code_max": 254, "valid_code_count": 255, "quantization_step": 0.14960629921259844, "max_abs_quantization_error": 0.07480314960629922, "decode": "minimum + code / 254 * (maximum - minimum)"}, "salinity_stretch": {"name": "salinity", "storage_dtype": "uint8", "minimum": 30.0, "maximum": 40.0, "units": "PSU", "nodata": 255, "valid_code_min": 0, "valid_code_max": 254, "valid_code_count": 255, "quantization_step": 0.03937007874015748, "max_abs_quantization_error": 0.01968503937007874, "decode": "minimum + code / 254 * (maximum - minimum)"}, "temporal_assignment": "nearest GLORYS target date inside centered 7-day window"}, "argo_psal_uint8/.zattrs": {"nodata": 255, "name": "salinity", "storage_dtype": "uint8", "minimum": 30.0, "maximum": 40.0, "units": "PSU", "valid_code_min": 0, "valid_code_max": 254, "valid_code_count": 255, "quantization_step": 0.03937007874015748, "max_abs_quantization_error": 0.01968503937007874, "decode": "minimum + code / 254 * (maximum - minimum)", "_ARRAY_DIMENSIONS": ["profile", "glorys_depth"]}, "argo_psal_uint8/.zarray": {"shape": [9451644, 50], "chunks": [50000, 50], "dtype": "|u1", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "argo_psal_valid/.zattrs": {"dtype": "bool", "_ARRAY_DIMENSIONS": ["profile", "glorys_depth"]}, "argo_psal_valid/.zarray": {"shape": [9451644, 50], "chunks": [50000, 50], "dtype": "|i1", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "argo_temp_kelvin_uint8/.zattrs": {"nodata": 255, "name": "temperature_kelvin", "storage_dtype": "uint8", "minimum": 270.15, "maximum": 308.15, "units": "K", "valid_code_min": 0, "valid_code_max": 254, "valid_code_count": 255, "quantization_step": 0.14960629921259844, "max_abs_quantization_error": 0.07480314960629922, "decode": "minimum + code / 254 * (maximum - minimum)", "_ARRAY_DIMENSIONS": ["profile", "glorys_depth"]}, "argo_temp_kelvin_uint8/.zarray": {"shape": [9451644, 50], "chunks": [50000, 50], "dtype": "|u1", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "argo_temp_valid/.zattrs": {"dtype": "bool", "_ARRAY_DIMENSIONS": ["profile", "glorys_depth"]}, "argo_temp_valid/.zarray": {"shape": [9451644, 50], "chunks": [50000, 50], "dtype": "|i1", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "glorys_depth/.zattrs": {"_ARRAY_DIMENSIONS": ["glorys_depth"]}, "glorys_depth/.zarray": {"shape": [50], "chunks": [50], "dtype": "<f4", "fill_value": "NaN", "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "grid_col/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "grid_col/.zarray": {"shape": [9451644], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "grid_row/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "grid_row/.zarray": {"shape": [9451644], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "latitude/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "latitude/.zarray": {"shape": [9451644], "chunks": [50000], "dtype": "<f4", "fill_value": "NaN", "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "longitude/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "longitude/.zarray": {"shape": [9451644], "chunks": [50000], "dtype": "<f4", "fill_value": "NaN", "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "profile/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "profile/.zarray": {"shape": [9451644], "chunks": [147682], "dtype": "<i8", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "profile_date/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "profile_date/.zarray": {"shape": [9451644], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "profile_source_file/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "profile_source_file/.zarray": {"shape": [9451644], "chunks": [50000], "dtype": "<U33", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "source_profile_idx/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "source_profile_idx/.zarray": {"shape": [9451644], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}, "target_date/.zattrs": {"_ARRAY_DIMENSIONS": ["profile"]}, "target_date/.zarray": {"shape": [9451644], "chunks": [50000], "dtype": "<i4", "fill_value": null, "order": "C", "filters": null, "dimension_separator": ".", "compressor": {"id": "blosc", "cname": "lz4", "clevel": 5, "shuffle": 1, "blocksize": 0}, "zarr_format": 2}}, "zarr_consolidated_format": 1}

depthdif_dataset/__init__.py

@@ -0,0 +1,28 @@
+"""Standalone PyTorch loaders for the DepthDif Hugging Face dataset."""
+
+from .dataloaders import (
+    DepthTileDataModule,
+    build_dataloader,
+    build_train_val_dataloaders,
+    split_dataset,
+)
+from .dataset import (
+    ArgoGeoTIFFGriddedPatchDataset,
+    ArgoGeoTIFFProfileStore,
+    GeoTIFFPatchIndex,
+    GeoTIFFRasterStore,
+)
+from .normalizations import salinity_normalize, temperature_normalize
+
+__all__ = [
+    "ArgoGeoTIFFGriddedPatchDataset",
+    "ArgoGeoTIFFProfileStore",
+    "DepthTileDataModule",
+    "GeoTIFFPatchIndex",
+    "GeoTIFFRasterStore",
+    "build_dataloader",
+    "build_train_val_dataloaders",
+    "salinity_normalize",
+    "split_dataset",
+    "temperature_normalize",
+]

depthdif_dataset/dataloaders.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from typing import Any
+
+import torch
+from torch.utils.data import DataLoader, Dataset, Subset, random_split
+
+
+def build_dataloader(
+    dataset: Dataset,
+    *,
+    batch_size: int = 16,
+    shuffle: bool = True,
+    num_workers: int = 0,
+    pin_memory: bool = True,
+    persistent_workers: bool = False,
+    prefetch_factor: int | None = 2,
+) -> DataLoader:
+    """Build a PyTorch DataLoader with the DepthDif training defaults."""
+    num_workers = int(num_workers)
+    kwargs: dict[str, Any] = dict(
+        dataset=dataset,
+        batch_size=int(batch_size),
+        shuffle=bool(shuffle),
+        num_workers=num_workers,
+        pin_memory=bool(pin_memory),
+        persistent_workers=bool(persistent_workers) and num_workers > 0,
+    )
+    # PyTorch only accepts prefetch_factor when worker processes are enabled.
+    if num_workers > 0 and prefetch_factor is not None:
+        kwargs["prefetch_factor"] = int(prefetch_factor)
+    return DataLoader(**kwargs)
+
+
+def split_dataset(
+    dataset: Dataset,
+    *,
+    val_fraction: float = 0.2,
+    seed: int = 7,
+) -> tuple[Subset, Subset]:
+    """Create a deterministic train/validation split from one dataset."""
+    total_len = len(dataset)
+    if total_len == 0:
+        raise RuntimeError("Dataset is empty; cannot create train/val split.")
+
+    val_len = int(round(total_len * float(val_fraction)))
+    if total_len > 1:
+        val_len = min(max(val_len, 1 if val_fraction > 0.0 else 0), total_len - 1)
+    else:
+        val_len = 0
+    train_len = total_len - val_len
+    generator = torch.Generator().manual_seed(int(seed))
+    train_dataset, val_dataset = random_split(
+        dataset,
+        [train_len, val_len],
+        generator=generator,
+    )
+    return train_dataset, val_dataset
+
+
+def build_train_val_dataloaders(
+    dataset: Dataset,
+    *,
+    val_dataset: Dataset | None = None,
+    dataloader_cfg: dict[str, Any] | None = None,
+    val_fraction: float = 0.2,
+    seed: int = 7,
+) -> tuple[DataLoader, DataLoader]:
+    """Build train and validation DataLoaders from one or two datasets."""
+    cfg = dict(dataloader_cfg or {})
+    if val_dataset is None:
+        train_dataset, val_dataset = split_dataset(
+            dataset,
+            val_fraction=val_fraction,
+            seed=seed,
+        )
+    else:
+        train_dataset = dataset
+
+    train_loader = build_dataloader(
+        train_dataset,
+        batch_size=int(cfg.get("batch_size", 16)),
+        shuffle=bool(cfg.get("shuffle", True)),
+        num_workers=int(cfg.get("num_workers", 4)),
+        pin_memory=bool(cfg.get("pin_memory", True)),
+        persistent_workers=bool(cfg.get("persistent_workers", False)),
+        prefetch_factor=cfg.get("prefetch_factor", 2),
+    )
+    val_loader = build_dataloader(
+        val_dataset,
+        batch_size=int(cfg.get("val_batch_size", cfg.get("batch_size", 16))),
+        # Keep the repository's intended behavior: validation is shuffled by default.
+        shuffle=bool(cfg.get("val_shuffle", True)),
+        num_workers=int(cfg.get("val_num_workers", 0)),
+        pin_memory=bool(cfg.get("pin_memory", True)),
+        persistent_workers=bool(cfg.get("val_persistent_workers", False)),
+        prefetch_factor=cfg.get("prefetch_factor", 2),
+    )
+    return train_loader, val_loader
+
+
+class DepthTileDataModule:
+    """Small PyTorch-only DataModule-style wrapper for DepthDif tiles."""
+
+    def __init__(
+        self,
+        *,
+        dataset: Dataset,
+        val_dataset: Dataset | None = None,
+        dataloader_cfg: dict[str, Any] | None = None,
+        val_fraction: float = 0.2,
+        seed: int = 7,
+    ) -> None:
+        """Store dataset and loader settings without requiring Lightning."""
+        self.dataset = dataset
+        self.val_dataset = val_dataset
+        self.dataloader_cfg = dataloader_cfg or {}
+        self.val_fraction = float(val_fraction)
+        self.seed = int(seed)
+        self.train_dataset: Subset | Dataset | None = (
+            dataset if val_dataset is not None else None
+        )
+        self._train_val_split_done = val_dataset is not None
+
+    def setup(self, stage: str | None = None) -> None:
+        """Prepare deterministic train/validation datasets."""
+        _ = stage
+        if self._train_val_split_done:
+            return
+        self.train_dataset, self.val_dataset = split_dataset(
+            self.dataset,
+            val_fraction=self.val_fraction,
+            seed=self.seed,
+        )
+        self._train_val_split_done = True
+
+    def train_dataloader(self) -> DataLoader:
+        """Return the configured training DataLoader."""
+        if not self._train_val_split_done:
+            self.setup("fit")
+        return build_train_val_dataloaders(
+            self.train_dataset,
+            val_dataset=self.val_dataset,
+            dataloader_cfg=self.dataloader_cfg,
+            val_fraction=self.val_fraction,
+            seed=self.seed,
+        )[0]
+
+    def val_dataloader(self) -> DataLoader:
+        """Return the configured validation DataLoader."""
+        if not self._train_val_split_done:
+            self.setup("fit")
+        return build_train_val_dataloaders(
+            self.train_dataset,
+            val_dataset=self.val_dataset,
+            dataloader_cfg=self.dataloader_cfg,
+            val_fraction=self.val_fraction,
+            seed=self.seed,
+        )[1]

depthdif_dataset/dataset.py

@@ -0,0 +1,1781 @@
+from __future__ import annotations
+
+import hashlib
+import os
+from collections import OrderedDict
+from pathlib import Path
+from typing import Any, Sequence
+
+import numpy as np
+import pandas as pd
+import rasterio
+from rasterio.windows import Window
+import torch
+from torch.utils.data import Dataset
+from tqdm import tqdm
+import xarray as xr
+import yaml
+import zarr
+
+from .grid_utils import (
+    MISSING_TEXT_VALUES,
+    _GridParams,
+    _build_land_mask_patch_table,
+    _center_lon_deg,
+    _deep_update_config,
+    _force_include_cache_hash,
+    _normalize_lon,
+    _parse_date_int,
+    _parse_force_include_regions,
+    _path_cache_hash,
+    _sanitize_cache_text,
+    _validate_grid_params,
+)
+from .normalizations import (
+    CELSIUS_TO_KELVIN_OFFSET,
+    salinity_normalize,
+    temperature_normalize,
+)
+
+VALID_CODE_MAX = 254.0
+NODATA_CODE = 255
+
+
+def _decode_stretched_uint8(values: np.ndarray, stretch: dict[str, Any]) -> np.ndarray:
+    """Decode uint8 GeoTIFF values into physical units from manifest metadata."""
+    arr = np.asarray(values, dtype=np.uint8)
+    nodata = int(stretch.get("nodata", NODATA_CODE))
+    valid_code_max = float(stretch.get("valid_code_max", VALID_CODE_MAX))
+    minimum = np.float32(stretch["minimum"])
+    maximum = np.float32(stretch["maximum"])
+    out = np.full(arr.shape, np.nan, dtype=np.float32)
+    valid = arr != nodata
+    out[valid] = minimum + (
+        arr[valid].astype(np.float32)
+        / np.float32(valid_code_max)
+        * np.float32(maximum - minimum)
+    )
+    return out
+
+
+def _kelvin_to_celsius(values: np.ndarray) -> np.ndarray:
+    """Convert decoded Kelvin temperature values to Celsius for model normalization."""
+    return np.asarray(values, dtype=np.float32) - np.float32(CELSIUS_TO_KELVIN_OFFSET)
+
+
+def _resolve_manifest_path(root_dir: Path, raw_path: str | Path) -> Path:
+    """Resolve a manifest path that may be absolute or export-root relative."""
+    path = Path(raw_path)
+    if path.is_absolute():
+        return path
+    return root_dir / path
+
+
+def _resolve_land_mask_path(root_dir: Path, raw_path: str | Path) -> Path:
+    """Resolve a land-mask path inside the packaged GeoTIFF dataset root."""
+    export_path = _resolve_manifest_path(root_dir, raw_path)
+    if not export_path.exists():
+        raise FileNotFoundError(
+            "Land-mask GeoTIFF must be present in the packaged dataset layout: "
+            f"{export_path}"
+        )
+    return export_path
+
+
+def _records_by_date(
+    entries: Sequence[dict[str, Any]], root_dir: Path
+) -> dict[int, Path]:
+    """Map manifest raster entries by date."""
+    records: dict[int, Path] = {}
+    for entry in entries:
+        records[int(entry["date"])] = _resolve_manifest_path(root_dir, entry["path"])
+    return records
+
+
+def _date_signature(dates: Sequence[int]) -> str:
+    """Return a compact hashable date coverage signature."""
+    if not dates:
+        return "empty"
+    raw = (int(min(dates)), int(max(dates)), int(len(dates)))
+    return "-".join(str(value) for value in raw)
+
+
+class RasterDatasetCache:
+    """Small LRU cache for rasterio datasets opened by one worker process."""
+
+    def __init__(self, max_open: int = 8) -> None:
+        """Initialize a bounded raster path cache."""
+        self.max_open = int(max_open)
+        self._pid = os.getpid()
+        self._items: OrderedDict[Path, rasterio.io.DatasetReader] = OrderedDict()
+
+    def _ensure_current_process(self) -> None:
+        """Drop inherited file handles after DataLoader worker forks."""
+        pid = os.getpid()
+        if pid == self._pid:
+            return
+        self.close()
+        self._pid = pid
+
+    def get(self, path: Path) -> rasterio.io.DatasetReader:
+        """Return an opened raster dataset for ``path``."""
+        self._ensure_current_process()
+        path = Path(path)
+        if path in self._items:
+            src = self._items.pop(path)
+            self._items[path] = src
+            return src
+        src = rasterio.open(path)
+        self._items[path] = src
+        while len(self._items) > self.max_open:
+            _, old = self._items.popitem(last=False)
+            old.close()
+        return src
+
+    def close(self) -> None:
+        """Close all cached raster datasets."""
+        for src in self._items.values():
+            src.close()
+        self._items.clear()
+
+
+class GeoTIFFRasterStore:
+    """Date-indexed GeoTIFF raster source for one exported variable."""
+
+    def __init__(
+        self,
+        *,
+        paths_by_date: dict[int, Path],
+        stretch: dict[str, Any],
+        cache: RasterDatasetCache,
+        kelvin_temperature: bool,
+    ) -> None:
+        """Initialize a date-to-raster lookup."""
+        self.paths_by_date = dict(paths_by_date)
+        self.stretch = dict(stretch)
+        self.cache = cache
+        self.kelvin_temperature = bool(kelvin_temperature)
+
+    @property
+    def dates(self) -> set[int]:
+        """Return available YYYYMMDD dates."""
+        return set(int(value) for value in self.paths_by_date)
+
+    def read_patch(
+        self,
+        *,
+        target_date: int,
+        grid_y0: int,
+        grid_x0: int,
+        tile_size: int,
+    ) -> np.ndarray:
+        """Read and decode one patch for ``target_date``."""
+        path = self.paths_by_date[int(target_date)]
+        src = self.cache.get(path)
+        window = Window(
+            col_off=int(grid_x0),
+            row_off=int(grid_y0),
+            width=int(tile_size),
+            height=int(tile_size),
+        )
+        encoded = src.read(window=window)
+        decoded = _decode_stretched_uint8(encoded, self.stretch)
+        if self.kelvin_temperature:
+            decoded = _kelvin_to_celsius(decoded)
+        return decoded.astype(np.float32, copy=False)
+
+
+class ArgoGeoTIFFProfileStore:
+    """Profile-indexed ARGO zarr source exported with the GeoTIFF dataset."""
+
+    def __init__(self, path: str | Path, *, include_salinity: bool = False) -> None:
+        """Open a compact ARGO profile zarr store."""
+        self.path = Path(path)
+        if not self.path.exists():
+            raise FileNotFoundError(f"ARGO profile zarr does not exist: {self.path}")
+        self.include_salinity = bool(include_salinity)
+        self._pid = os.getpid()
+        self.ds = self._open_dataset()
+        self._zarr_pid = os.getpid()
+        self._zarr_group = self._open_zarr_group()
+        required = {
+            "target_date",
+            "grid_row",
+            "grid_col",
+            "argo_temp_kelvin_uint8",
+            "argo_temp_valid",
+        }
+        if self.include_salinity:
+            required.update({"argo_psal_uint8", "argo_psal_valid"})
+        missing = sorted(name for name in required if name not in self.ds)
+        if missing:
+            raise RuntimeError(
+                f"ARGO profile zarr is missing required variables {missing}: {self.path}"
+            )
+        self.target_date = np.asarray(self.ds["target_date"].values, dtype=np.int32)
+        self.grid_row = np.asarray(self.ds["grid_row"].values, dtype=np.int32)
+        self.grid_col = np.asarray(self.ds["grid_col"].values, dtype=np.int32)
+        self.depth_axis_m = np.asarray(
+            self.ds["glorys_depth"].values, dtype=np.float32
+        ).reshape(-1)
+        temp_valid = np.asarray(self.ds["argo_temp_valid"].values, dtype=bool)
+        self._has_valid_temp = temp_valid.any(axis=1)
+        (
+            self._valid_profile_indices_by_date,
+            self._profile_index_bounds_by_date,
+        ) = self._build_valid_profile_index()
+        self.temperature_stretch = self._temperature_stretch()
+        self.salinity_stretch = (
+            self._salinity_stretch() if self.include_salinity else None
+        )
+
+    def _open_dataset(self) -> xr.Dataset:
+        """Open the zarr dataset in the current process."""
+        return xr.open_zarr(self.path, consolidated=None)
+
+    def _open_zarr_group(self) -> zarr.Group:
+        """Open the zarr group used for direct array reads."""
+        return zarr.open_group(self.path, mode="r")
+
+    def _ensure_current_process(self) -> xr.Dataset:
+        """Reopen zarr handles after DataLoader worker forks."""
+        pid = os.getpid()
+        if pid == self._pid:
+            return self.ds
+        # Do not close inherited xarray/zarr handles in a forked worker; closing
+        # those locks after fork can block before the worker reads its first batch.
+        self.ds = self._open_dataset()
+        self._pid = pid
+        return self.ds
+
+    def _ensure_zarr_group(self) -> zarr.Group:
+        """Return a direct zarr group opened in the current process."""
+        pid = os.getpid()
+        if pid != self._zarr_pid:
+            self._zarr_group = self._open_zarr_group()
+            self._zarr_pid = pid
+        return self._zarr_group
+
+    def _build_valid_profile_index(
+        self,
+    ) -> tuple[np.ndarray, dict[int, tuple[int, int]]]:
+        """Build date slices over valid-temperature profile indices."""
+        valid_indices = np.flatnonzero(self._has_valid_temp).astype(np.int64)
+        if valid_indices.size == 0:
+            return valid_indices, {}
+
+        # Querying per sample must not scan the full multi-million-profile store.
+        order = np.argsort(self.target_date[valid_indices], kind="stable")
+        sorted_indices = valid_indices[order]
+        sorted_dates = self.target_date[sorted_indices]
+        unique_dates, starts, counts = np.unique(
+            sorted_dates, return_index=True, return_counts=True
+        )
+        bounds = {
+            int(date): (int(start), int(start + count))
+            for date, start, count in zip(
+                unique_dates.tolist(),
+                starts.tolist(),
+                counts.tolist(),
+                strict=False,
+            )
+        }
+        return sorted_indices, bounds
+
+    def _temperature_stretch(self) -> dict[str, Any]:
+        """Read temperature stretch metadata from variable or dataset attributes."""
+        ds = self._ensure_current_process()
+        attrs = dict(ds["argo_temp_kelvin_uint8"].attrs)
+        if "minimum" in attrs and "maximum" in attrs:
+            return attrs
+        ds_attrs = dict(ds.attrs)
+        stretch = ds_attrs.get("temperature_stretch")
+        if isinstance(stretch, dict):
+            return stretch
+        raise RuntimeError(
+            f"ARGO profile zarr lacks temperature stretch metadata: {self.path}"
+        )
+
+    def _salinity_stretch(self) -> dict[str, Any]:
+        """Read salinity stretch metadata from variable or dataset attributes."""
+        ds = self._ensure_current_process()
+        attrs = dict(ds["argo_psal_uint8"].attrs)
+        if "minimum" in attrs and "maximum" in attrs:
+            return attrs
+        ds_attrs = dict(ds.attrs)
+        stretch = ds_attrs.get("salinity_stretch")
+        if isinstance(stretch, dict):
+            return stretch
+        raise RuntimeError(
+            f"ARGO profile zarr lacks salinity stretch metadata: {self.path}"
+        )
+
+    def query_indices(
+        self,
+        *,
+        target_date: int,
+        grid_y0: int,
+        grid_x0: int,
+        tile_size: int,
+    ) -> np.ndarray:
+        """Return profile indices assigned to one date and grid patch."""
+        y0 = int(grid_y0)
+        x0 = int(grid_x0)
+        tile = int(tile_size)
+        bounds = self._profile_index_bounds_by_date.get(int(target_date))
+        if bounds is None:
+            return np.zeros((0,), dtype=np.int64)
+        start, stop = bounds
+        candidates = self._valid_profile_indices_by_date[start:stop]
+        mask = (
+            (self.grid_row[candidates] >= y0)
+            & (self.grid_row[candidates] < y0 + tile)
+            & (self.grid_col[candidates] >= x0)
+            & (self.grid_col[candidates] < x0 + tile)
+        )
+        return candidates[mask].astype(np.int64, copy=False)
+
+    def load_temperature_profiles(self, indices: np.ndarray) -> np.ndarray:
+        """Load selected ARGO temperature profiles as Celsius arrays."""
+        indices = np.asarray(indices, dtype=np.int64).reshape(-1)
+        depth_size = int(self.depth_axis_m.size)
+        if indices.size == 0:
+            return np.zeros((0, depth_size), dtype=np.float32)
+        group = self._ensure_zarr_group()
+        encoded = np.asarray(
+            group["argo_temp_kelvin_uint8"].get_orthogonal_selection(
+                (indices, slice(None))
+            ),
+            dtype=np.uint8,
+        )
+        valid = np.asarray(
+            group["argo_temp_valid"].get_orthogonal_selection((indices, slice(None))),
+            dtype=bool,
+        )
+        kelvin = _decode_stretched_uint8(encoded, self.temperature_stretch)
+        kelvin[~valid] = np.nan
+        return _kelvin_to_celsius(kelvin).astype(np.float32, copy=False)
+
+    def load_salinity_profiles(self, indices: np.ndarray) -> np.ndarray:
+        """Load selected ARGO salinity profiles as raw PSU arrays."""
+        if self.salinity_stretch is None:
+            raise RuntimeError(
+                "ARGO salinity profiles were not enabled for this store."
+            )
+        indices = np.asarray(indices, dtype=np.int64).reshape(-1)
+        depth_size = int(self.depth_axis_m.size)
+        if indices.size == 0:
+            return np.zeros((0, depth_size), dtype=np.float32)
+        group = self._ensure_zarr_group()
+        encoded = np.asarray(
+            group["argo_psal_uint8"].get_orthogonal_selection((indices, slice(None))),
+            dtype=np.uint8,
+        )
+        valid = np.asarray(
+            group["argo_psal_valid"].get_orthogonal_selection((indices, slice(None))),
+            dtype=bool,
+        )
+        salinity = _decode_stretched_uint8(encoded, self.salinity_stretch)
+        salinity[~valid] = np.nan
+        return salinity.astype(np.float32, copy=False)
+
+    def close(self) -> None:
+        """Close the opened zarr dataset."""
+        self.ds.close()
+
+
+class GeoTIFFPatchIndex:
+    """Build compact patch/date metadata rows for GeoTIFF training stores."""
+
+    CACHE_VERSION = 1
+
+    def __init__(
+        self,
+        *,
+        root_dir: Path,
+        dates: Sequence[int],
+        argo_store: ArgoGeoTIFFProfileStore | None,
+        cache_dir: str | Path | None,
+        grid_params: _GridParams,
+    ) -> None:
+        """Initialize index inputs."""
+        self.root_dir = Path(root_dir)
+        self.dates = sorted(int(value) for value in dates)
+        self.argo_store = argo_store
+        self.cache_dir = None if cache_dir is None else Path(cache_dir)
+        self.grid_params = grid_params
+        _validate_grid_params(self.grid_params)
+        if str(self.grid_params.patch_grid_source).strip().lower() != "land_mask":
+            raise ValueError(
+                "GeoTIFF datasets require grid.patch_grid_source='land_mask'."
+            )
+
+    def load_rows(self) -> list[dict[str, Any]]:
+        """Load cached rows or build a fresh patch/date registry."""
+        cache_path = self._cache_path()
+        if cache_path is not None and cache_path.exists():
+            return pd.read_csv(cache_path).to_dict(orient="records")
+
+        patch_df = _build_land_mask_patch_table(self.grid_params)
+        if self.grid_params.val_year is None:
+            patch_records = patch_df.to_dict(orient="records")
+            phases = self._split_phases(len(patch_records))
+            for rec, phase in zip(patch_records, phases, strict=False):
+                rec["split"] = phase
+                rec["phase"] = phase
+            patch_df = pd.DataFrame.from_records(patch_records)
+        support_counts = self._build_support_counts(patch_df)
+        rows: list[dict[str, Any]] = []
+        export_index = 0
+        for date_value in self.dates:
+            for patch in patch_df.to_dict(orient="records"):
+                patch_id = int(patch["patch_id"])
+                row = dict(patch)
+                row["date"] = int(date_value)
+                row["export_index"] = int(export_index)
+                if self.grid_params.val_year is not None:
+                    phase = self._phase_for_date(int(date_value))
+                    row["split"] = phase
+                    row["phase"] = phase
+                else:
+                    phase = str(patch.get("split", patch.get("phase", "train")))
+                    row["split"] = phase
+                    row["phase"] = phase
+                row["argo_profile_count"] = int(
+                    support_counts.get((patch_id, int(date_value)), 0)
+                )
+                rows.append(row)
+                export_index += 1
+
+        if cache_path is not None:
+            cache_path.parent.mkdir(parents=True, exist_ok=True)
+            pd.DataFrame.from_records(rows).to_csv(cache_path, index=False)
+        return rows
+
+    def _cache_path(self) -> Path | None:
+        """Return the metadata cache path for these index settings."""
+        if self.cache_dir is None:
+            return None
+        res_text = str(float(self.grid_params.resolution_deg)).replace(".", "p")
+        land_text = str(float(self.grid_params.max_land_fraction)).replace(".", "p")
+        grid_source = _sanitize_cache_text(self.grid_params.patch_grid_source)
+        mask_hash = _path_cache_hash(self.grid_params.land_mask_path)
+        force_hash = _force_include_cache_hash(self.grid_params.force_include_regions)
+        root_hash = hashlib.sha1(str(self.root_dir).encode("utf-8")).hexdigest()[:8]
+        split_text = (
+            f"valyear{int(self.grid_params.val_year)}"
+            if self.grid_params.val_year is not None
+            else "patchsplit"
+        )
+        name = (
+            f"argo_geotiff_gridded_v{self.CACHE_VERSION}_root{root_hash}_"
+            f"dates{_date_signature(self.dates)}_"
+            f"tile{int(self.grid_params.tile_size)}_res{res_text}_"
+            f"stride{int(self.grid_params.effective_patch_stride)}_"
+            f"grid{grid_source}_land{land_text}_mask{mask_hash}_"
+            f"force{force_hash}_{split_text}.csv"
+        )
+        return self.cache_dir / name
+
+    def _phase_for_date(self, date_value: int) -> str:
+        """Return the train/validation phase for one date."""
+        year = int(date_value) // 10000
+        return "val" if year == int(self.grid_params.val_year) else "train"
+
+    def _split_phases(self, n_patches: int) -> list[str]:
+        """Return deterministic spatial train/validation phases."""
+        phases = np.full((int(n_patches),), "train", dtype=object)
+        val_len = int(round(int(n_patches) * float(self.grid_params.val_fraction)))
+        if n_patches > 1:
+            val_len = min(
+                max(val_len, 1 if self.grid_params.val_fraction > 0.0 else 0),
+                int(n_patches) - 1,
+            )
+        else:
+            val_len = 0
+        if val_len > 0:
+            rng = np.random.default_rng(int(self.grid_params.split_seed))
+            val_indices = rng.permutation(np.arange(int(n_patches)))[:val_len]
+            phases[val_indices] = "val"
+        return [str(value) for value in phases.tolist()]
+
+    def _build_support_counts(
+        self,
+        patch_df: pd.DataFrame,
+    ) -> dict[tuple[int, int], int]:
+        """Count ARGO profiles per overlapping patch/date row."""
+        support_counts: dict[tuple[int, int], int] = {}
+        if self.argo_store is None or patch_df.empty or not self.dates:
+            return support_counts
+
+        date_set = set(int(value) for value in self.dates)
+        tile = int(self.grid_params.tile_size)
+        patch_by_start = {
+            (int(row["grid_y0"]), int(row["grid_x0"])): int(row["patch_id"])
+            for row in patch_df.to_dict(orient="records")
+        }
+        y_starts = np.asarray(
+            sorted({key[0] for key in patch_by_start}), dtype=np.int64
+        )
+        x_starts = np.asarray(
+            sorted({key[1] for key in patch_by_start}), dtype=np.int64
+        )
+        selected_profile_indices: list[np.ndarray] = []
+        for date_value in sorted(date_set):
+            bounds = self.argo_store._profile_index_bounds_by_date.get(int(date_value))
+            if bounds is None:
+                continue
+            start, stop = bounds
+            selected_profile_indices.append(
+                self.argo_store._valid_profile_indices_by_date[start:stop]
+            )
+        if not selected_profile_indices:
+            return support_counts
+        profile_indices = np.concatenate(selected_profile_indices).astype(
+            np.int64,
+            copy=False,
+        )
+
+        for profile_idx in tqdm(
+            profile_indices.tolist(),
+            total=int(profile_indices.size),
+            desc="Counting ARGO overlap support",
+            unit="profile",
+            dynamic_ncols=True,
+        ):
+            date_value = int(self.argo_store.target_date[profile_idx])
+            row_idx = int(self.argo_store.grid_row[profile_idx])
+            col_idx = int(self.argo_store.grid_col[profile_idx])
+            y_candidates = y_starts[(y_starts <= row_idx) & (row_idx < y_starts + tile)]
+            x_candidates = x_starts[(x_starts <= col_idx) & (col_idx < x_starts + tile)]
+            for y0 in y_candidates.tolist():
+                for x0 in x_candidates.tolist():
+                    patch_id = patch_by_start.get((int(y0), int(x0)))
+                    if patch_id is None:
+                        continue
+                    key = (int(patch_id), int(date_value))
+                    support_counts[key] = support_counts.get(key, 0) + 1
+        return support_counts
+
+
+DEFAULT_DATASET_ROOT_DIR = Path(__file__).resolve().parents[1]
+DEFAULT_GEOTIFF_ROOT_DIR = DEFAULT_DATASET_ROOT_DIR.as_posix()
+DEFAULT_METADATA_CACHE_DIR = (DEFAULT_DATASET_ROOT_DIR / "depthdif_cache").as_posix()
+DEFAULT_CONFIG_PATH = (
+    Path(__file__).resolve().parent / "configs/default_dataset.yaml"
+).as_posix()
+DEFAULT_LAND_MASK_RELATIVE_PATH = "masks/world_land_mask_glorys_0p1.tif"
+EO_SOURCE_DEFAULTS = {"ostia": "analysed_sst", "sss": "sos"}
+EO_STRETCH_BY_SOURCE_VAR = {
+    ("ostia", "analysed_sst"): ("temperature_kelvin", "temperature"),
+    ("sss", "sos"): ("salinity", "salinity"),
+}
+
+
+class ArgoGeoTIFFGriddedPatchDataset(Dataset):
+    """Dataset that lazily reads training patches from exported GeoTIFF stores."""
+
+    DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_PATH
+    DEFAULT_GEOTIFF_ROOT_DIR = DEFAULT_DATASET_ROOT_DIR.as_posix()
+    DEFAULT_METADATA_CACHE_DIR = (
+        DEFAULT_DATASET_ROOT_DIR / "depthdif_cache"
+    ).as_posix()
+
+    def __init__(
+        self,
+        *,
+        geotiff_root_dir: str | Path = DEFAULT_GEOTIFF_ROOT_DIR,
+        metadata_cache_dir: str | Path | None = DEFAULT_METADATA_CACHE_DIR,
+        split: str = "all",
+        tile_size: int = 128,
+        resolution_deg: float = 0.1,
+        patch_grid_source: str = "land_mask",
+        land_mask_path: str | Path | None = None,
+        patch_stride: int | None = None,
+        max_land_fraction: float = 0.30,
+        force_include_regions: Sequence[dict[str, Any]] | None = None,
+        finetune_sampling: dict[str, Any] | None = None,
+        temporal_window_days: int = 7,
+        glorys_var_name: str = "thetao",
+        ostia_var_name: str = "analysed_sst",
+        eo_source: str = "ostia",
+        eo_var_name: str | None = None,
+        require_argo_for_train: bool = True,
+        require_argo_for_val: bool = True,
+        require_argo_for_all: bool = False,
+        synthetic_mode: bool = False,
+        synthetic_pixel_count: int = 250,
+        return_info: bool = True,
+        return_coords: bool = True,
+        include_salinity: bool = False,
+        output_fields: Sequence[str] | str | None = None,
+        date_start: int | str | None = None,
+        date_end: int | str | None = None,
+        max_dates: int | None = None,
+        count_argo_support: bool | None = None,
+        random_seed: int = 7,
+        cache_size: int = 8,
+        val_fraction: float = 0.2,
+        val_year: int | None = None,
+    ) -> None:
+        """Initialize the GeoTIFF-backed patch dataset."""
+        self.split = str(split).strip().lower()
+        if self.split not in {"all", "train", "val"}:
+            raise ValueError("split must be one of: 'all', 'train', 'val'")
+        self.root_dir = Path(geotiff_root_dir)
+        self.manifest_path = self.root_dir / "manifest.yaml"
+        if not self.manifest_path.exists():
+            raise FileNotFoundError(
+                f"GeoTIFF manifest does not exist: {self.manifest_path}"
+            )
+        with self.manifest_path.open("r", encoding="utf-8") as f:
+            self.manifest = yaml.safe_load(f)
+
+        self.tile_size = int(tile_size)
+        self.resolution_deg = float(resolution_deg)
+        self.patch_grid_source = str(patch_grid_source)
+        manifest_grid = self.manifest.get("grid", {})
+        configured_land_mask = (
+            land_mask_path
+            or manifest_grid.get("source")
+            or DEFAULT_LAND_MASK_RELATIVE_PATH
+        )
+        self.land_mask_path = _resolve_land_mask_path(
+            self.root_dir,
+            configured_land_mask,
+        )
+        self.patch_stride = None if patch_stride is None else int(patch_stride)
+        self.max_land_fraction = float(max_land_fraction)
+        self.force_include_regions = _parse_force_include_regions(force_include_regions)
+        self.finetune_sampling = self._normalize_finetune_sampling(finetune_sampling)
+        self.finetune_sampling_summary: dict[str, Any] = {
+            "enabled": bool(self.finetune_sampling["enabled"]),
+            "applied": False,
+            "split": self.split,
+        }
+        self.temporal_window_days = int(temporal_window_days)
+        self.glorys_var_name = str(glorys_var_name)
+        self.ostia_var_name = str(ostia_var_name)
+        self.eo_source, self.eo_var_name = self._normalize_eo_selection(
+            eo_source=eo_source,
+            eo_var_name=eo_var_name,
+            ostia_var_name=self.ostia_var_name,
+        )
+        self.eo_stretch_name, self.eo_normalization = self._resolve_eo_metadata(
+            self.eo_source, self.eo_var_name
+        )
+        self.return_info = bool(return_info)
+        self.return_coords = bool(return_coords)
+        self.output_fields = self._normalize_output_fields(
+            output_fields, include_salinity=bool(include_salinity)
+        )
+        self.include_salinity = "salinity" in self.output_fields
+        self._loads_temperature = "temperature" in self.output_fields
+        self.random_seed = int(random_seed)
+        self.require_argo_for_train = bool(require_argo_for_train)
+        self.require_argo_for_val = bool(require_argo_for_val)
+        self.require_argo_for_all = bool(require_argo_for_all)
+        self.synthetic_mode = bool(synthetic_mode)
+        self.synthetic_pixel_count = int(synthetic_pixel_count)
+        self.date_start = self._optional_int(date_start)
+        self.date_end = self._optional_int(date_end)
+        self.max_dates = None if max_dates is None else int(max_dates)
+        if self.temporal_window_days < 1:
+            raise ValueError("sampling.temporal_window_days must be >= 1.")
+        if self.synthetic_pixel_count < 0:
+            raise ValueError("synthetic.pixel_count must be >= 0.")
+        if self.max_dates is not None and self.max_dates < 1:
+            raise ValueError("max_dates must be >= 1 when provided.")
+        if (
+            self.date_start is not None
+            and self.date_end is not None
+            and int(self.date_start) > int(self.date_end)
+        ):
+            raise ValueError("date_start must be <= date_end.")
+
+        self.raster_cache = RasterDatasetCache(max_open=cache_size)
+        self._depth_axis_m = np.asarray(
+            self.manifest.get("depth_axis_m", ()), dtype=np.float32
+        ).reshape(-1)
+        if self._depth_axis_m.size == 0:
+            raise RuntimeError("GeoTIFF manifest is missing depth_axis_m.")
+
+        self.argo_store = self._open_argo_store()
+        if self.argo_store is not None and int(
+            self.argo_store.depth_axis_m.size
+        ) != int(self._depth_axis_m.size):
+            raise RuntimeError(
+                "ARGO profile zarr depth axis does not match GeoTIFF manifest depth_axis_m."
+            )
+
+        self.glorys_store, self.salinity_store, self.eo_store = (
+            self._build_raster_stores()
+        )
+        # Backward-compatible alias for callers that still inspect the old name.
+        self.ostia_store = self.eo_store
+        self.available_dates = self._filter_available_dates(
+            sorted(self.glorys_store.dates & self.eo_store.dates)
+        )
+        if not self.available_dates:
+            raise RuntimeError("No overlapping GeoTIFF raster dates were found.")
+        self.count_argo_support = self._resolve_count_argo_support(count_argo_support)
+        if self._require_argo_for_current_split() and not self.count_argo_support:
+            raise ValueError(
+                "count_argo_support=False is incompatible with requiring ARGO "
+                "profiles for the current split."
+            )
+        if self.include_salinity:
+            if self.salinity_store is None:
+                raise RuntimeError("GeoTIFF salinity store was not initialized.")
+            missing_salinity_dates = sorted(
+                set(self.available_dates) - self.salinity_store.dates
+            )
+            if missing_salinity_dates:
+                raise RuntimeError(
+                    "GeoTIFF manifest is missing GLORYS salinity 'so' rasters "
+                    f"for dates: {missing_salinity_dates[:5]}"
+                )
+
+        grid_params = _GridParams(
+            tile_size=self.tile_size,
+            resolution_deg=self.resolution_deg,
+            invalid_threshold=0.5,
+            invalid_mask_flags=("land",),
+            val_fraction=float(val_fraction),
+            val_year=None if val_year is None else int(val_year),
+            split_seed=self.random_seed,
+            patch_grid_source=self.patch_grid_source,
+            land_mask_path=self.land_mask_path,
+            patch_stride=self.patch_stride,
+            max_land_fraction=self.max_land_fraction,
+            force_include_regions=self._effective_force_include_regions(),
+        )
+        index = GeoTIFFPatchIndex(
+            root_dir=self.root_dir,
+            dates=self.available_dates,
+            argo_store=self.argo_store if self.count_argo_support else None,
+            cache_dir=metadata_cache_dir,
+            grid_params=grid_params,
+        )
+        rows = index.load_rows()
+        rows = self._filter_rows(rows)
+        rows = self._apply_finetune_sampling(rows)
+        if not rows:
+            raise RuntimeError("Dataset is empty after split/ARGO filtering.")
+        self._rows = rows
+
+    def _filter_available_dates(self, dates: Sequence[int]) -> list[int]:
+        """Apply optional date-window controls before row indexing."""
+        filtered = [
+            int(date)
+            for date in dates
+            if (self.date_start is None or int(date) >= int(self.date_start))
+            and (self.date_end is None or int(date) <= int(self.date_end))
+        ]
+        if self.max_dates is not None:
+            filtered = filtered[: int(self.max_dates)]
+        return filtered
+
+    def _resolve_count_argo_support(self, value: bool | None) -> bool:
+        """Decide whether to compute profile counts during index creation."""
+        if value is not None:
+            return bool(value)
+        # The profile-count pass scans the compact ARGO store. Keep first use of
+        # downloaded checkouts fast unless this split filters by ARGO support.
+        return bool(self._require_argo_for_current_split())
+
+    @staticmethod
+    def _normalize_eo_selection(
+        *,
+        eo_source: str,
+        eo_var_name: str | None,
+        ostia_var_name: str,
+    ) -> tuple[str, str]:
+        """Resolve the dense surface EO raster group and variable."""
+        source = str(eo_source or "ostia").strip().lower()
+        if not source:
+            source = "ostia"
+        var_name = eo_var_name
+        if var_name is None:
+            var_name = (
+                ostia_var_name if source == "ostia" else EO_SOURCE_DEFAULTS.get(source)
+            )
+        if var_name is None or not str(var_name).strip():
+            raise ValueError(f"No EO variable configured for source {source!r}.")
+        return source, str(var_name).strip()
+
+    @staticmethod
+    def _resolve_eo_metadata(eo_source: str, eo_var_name: str) -> tuple[str, str]:
+        """Return manifest stretch and normalization family for one EO raster."""
+        key = (str(eo_source).strip().lower(), str(eo_var_name).strip())
+        metadata = EO_STRETCH_BY_SOURCE_VAR.get(key)
+        if metadata is None:
+            supported = ", ".join(
+                f"{source}/{var}" for source, var in sorted(EO_STRETCH_BY_SOURCE_VAR)
+            )
+            raise ValueError(
+                "Unsupported EO raster selection "
+                f"{key[0]!r}/{key[1]!r}. Supported selections: {supported}."
+            )
+        return metadata
+
+    def _open_argo_store(self) -> ArgoGeoTIFFProfileStore | None:
+        """Open the optional compact ARGO zarr profile store."""
+        argo_info = self.manifest.get("argo", {})
+        raw_path = argo_info.get("path")
+        if raw_path is None or str(raw_path).strip().lower() in MISSING_TEXT_VALUES:
+            return None
+        return ArgoGeoTIFFProfileStore(
+            _resolve_manifest_path(self.root_dir, raw_path),
+            include_salinity=self.include_salinity,
+        )
+
+    def _build_raster_stores(
+        self,
+    ) -> tuple[GeoTIFFRasterStore, GeoTIFFRasterStore | None, GeoTIFFRasterStore]:
+        """Build date-indexed dense raster stores from manifest entries."""
+        rasters = self.manifest.get("rasters", {})
+        stretch = self.manifest.get("stretch", {})
+        temp_stretch = stretch.get("temperature_kelvin")
+        if not isinstance(temp_stretch, dict):
+            raise RuntimeError(
+                "GeoTIFF manifest is missing temperature_kelvin stretch."
+            )
+        eo_stretch = stretch.get(self.eo_stretch_name)
+        if not isinstance(eo_stretch, dict):
+            raise RuntimeError(
+                "GeoTIFF manifest is missing EO stretch "
+                f"{self.eo_stretch_name!r} for {self.eo_source}/{self.eo_var_name}."
+            )
+        glorys_rasters = rasters.get("glorys", {})
+        glorys_entries = (
+            glorys_rasters.get(self.glorys_var_name, [])
+            if isinstance(glorys_rasters, dict)
+            else []
+        )
+        eo_rasters = rasters.get(self.eo_source, {})
+        eo_entries = (
+            eo_rasters.get(self.eo_var_name, []) if isinstance(eo_rasters, dict) else []
+        )
+        if not glorys_entries or not eo_entries:
+            raise RuntimeError(
+                "GeoTIFF manifest is missing GLORYS/EO raster entries for "
+                f"{self.glorys_var_name!r}/{self.eo_source}/{self.eo_var_name}."
+            )
+        salinity_store = None
+        if self.include_salinity:
+            salinity_stretch = stretch.get("salinity")
+            if not isinstance(salinity_stretch, dict):
+                raise RuntimeError("GeoTIFF manifest is missing salinity stretch.")
+            salinity_entries = (
+                glorys_rasters.get("so", []) if isinstance(glorys_rasters, dict) else []
+            )
+            if not salinity_entries:
+                raise RuntimeError(
+                    "GeoTIFF manifest is missing GLORYS salinity 'so' raster entries."
+                )
+            salinity_store = GeoTIFFRasterStore(
+                paths_by_date=_records_by_date(salinity_entries, self.root_dir),
+                stretch=salinity_stretch,
+                cache=self.raster_cache,
+                kelvin_temperature=False,
+            )
+        return (
+            GeoTIFFRasterStore(
+                paths_by_date=_records_by_date(glorys_entries, self.root_dir),
+                stretch=temp_stretch,
+                cache=self.raster_cache,
+                kelvin_temperature=True,
+            ),
+            salinity_store,
+            GeoTIFFRasterStore(
+                paths_by_date=_records_by_date(eo_entries, self.root_dir),
+                stretch=eo_stretch,
+                cache=self.raster_cache,
+                kelvin_temperature=self.eo_normalization == "temperature",
+            ),
+        )
+
+    @property
+    def rows(self) -> list[dict[str, Any]]:
+        """Return patch/date metadata rows."""
+        return self._rows
+
+    @property
+    def depth_axis_m(self) -> np.ndarray:
+        """Return the GLORYS depth axis in meters."""
+        return self._depth_axis_m.copy()
+
+    @classmethod
+    def from_config(
+        cls,
+        config_path: str | Path | None = None,
+        *,
+        split: str = "all",
+        dataset_overrides: dict[str, Any] | None = None,
+    ) -> "ArgoGeoTIFFGriddedPatchDataset":
+        """Build a GeoTIFF dataset from a YAML data config."""
+        if config_path is None:
+            config_path = cls.DEFAULT_CONFIG_PATH
+        config_path = Path(config_path).expanduser()
+        if not config_path.is_absolute():
+            config_path = (DEFAULT_DATASET_ROOT_DIR / config_path).resolve()
+        with config_path.open("r", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f)
+
+        ds_cfg = cfg.get("data", cfg).get("dataset", {})
+        if dataset_overrides:
+            ds_cfg = _deep_update_config(ds_cfg, dataset_overrides)
+        return cls(
+            geotiff_root_dir=cls._cfg_get(
+                ds_cfg,
+                "core.geotiff_root_dir",
+                "geotiff_root_dir",
+                default=cls.DEFAULT_GEOTIFF_ROOT_DIR,
+            ),
+            metadata_cache_dir=cls._cfg_get(
+                ds_cfg,
+                "core.metadata_cache_dir",
+                "metadata_cache_dir",
+                default=cls.DEFAULT_METADATA_CACHE_DIR,
+            ),
+            split=split,
+            tile_size=int(
+                cls._cfg_get(ds_cfg, "grid.tile_size", "tile_size", default=128)
+            ),
+            resolution_deg=float(
+                cls._cfg_get(
+                    ds_cfg, "grid.resolution_deg", "resolution_deg", default=0.1
+                )
+            ),
+            patch_grid_source=str(
+                cls._cfg_get(
+                    ds_cfg,
+                    "grid.patch_grid_source",
+                    "patch_grid_source",
+                    default="land_mask",
+                )
+            ),
+            land_mask_path=cls._cfg_get(
+                ds_cfg,
+                "grid.land_mask_path",
+                "land_mask_path",
+                default=None,
+            ),
+            patch_stride=cls._optional_int(
+                cls._cfg_get(
+                    ds_cfg,
+                    "grid.patch_stride",
+                    "patch_stride",
+                    default=None,
+                )
+            ),
+            max_land_fraction=float(
+                cls._cfg_get(
+                    ds_cfg,
+                    "grid.max_land_fraction",
+                    "max_land_fraction",
+                    default=0.30,
+                )
+            ),
+            force_include_regions=cls._cfg_get(
+                ds_cfg,
+                "grid.force_include_regions",
+                "force_include_regions",
+                default=None,
+            ),
+            finetune_sampling=cls._cfg_get(
+                ds_cfg,
+                "finetune_sampling",
+                "finetune_sampling",
+                default=None,
+            ),
+            temporal_window_days=int(
+                cls._cfg_get(
+                    ds_cfg,
+                    "sampling.temporal_window_days",
+                    "temporal_window_days",
+                    default=7,
+                )
+            ),
+            glorys_var_name=str(
+                cls._cfg_get(
+                    ds_cfg,
+                    "sampling.glorys_var_name",
+                    "glorys_var_name",
+                    default="thetao",
+                )
+            ),
+            ostia_var_name=str(
+                cls._cfg_get(
+                    ds_cfg,
+                    "sampling.ostia_var_name",
+                    "ostia_var_name",
+                    default="analysed_sst",
+                )
+            ),
+            eo_source=str(
+                cls._cfg_get(
+                    ds_cfg,
+                    "sampling.eo_source",
+                    "eo_source",
+                    default="ostia",
+                )
+            ),
+            eo_var_name=cls._cfg_get(
+                ds_cfg,
+                "sampling.eo_var_name",
+                "eo_var_name",
+                default=None,
+            ),
+            val_fraction=float(cfg.get("split", {}).get("val_fraction", 0.2)),
+            val_year=cls._optional_int(cfg.get("split", {}).get("val_year", None)),
+            date_start=cls._cfg_get(
+                ds_cfg, "sampling.date_start", "date_start", default=None
+            ),
+            date_end=cls._cfg_get(
+                ds_cfg, "sampling.date_end", "date_end", default=None
+            ),
+            max_dates=cls._optional_int(
+                cls._cfg_get(ds_cfg, "sampling.max_dates", "max_dates", default=None)
+            ),
+            count_argo_support=cls._optional_bool(
+                cls._cfg_get(
+                    ds_cfg,
+                    "selection.count_argo_support",
+                    "count_argo_support",
+                    default=None,
+                )
+            ),
+            require_argo_for_train=bool(
+                cls._cfg_get(
+                    ds_cfg,
+                    "selection.require_argo_for_train",
+                    "require_argo_for_train",
+                    default=True,
+                )
+            ),
+            require_argo_for_val=bool(
+                cls._cfg_get(
+                    ds_cfg,
+                    "selection.require_argo_for_val",
+                    "require_argo_for_val",
+                    default=True,
+                )
+            ),
+            require_argo_for_all=bool(
+                cls._cfg_get(
+                    ds_cfg,
+                    "selection.require_argo_for_all",
+                    "require_argo_for_all",
+                    default=False,
+                )
+            ),
+            synthetic_mode=bool(
+                cls._cfg_get(
+                    ds_cfg, "synthetic.enabled", "synthetic_enabled", default=False
+                )
+            ),
+            synthetic_pixel_count=int(
+                cls._cfg_get(
+                    ds_cfg,
+                    "synthetic.pixel_count",
+                    "synthetic_pixel_count",
+                    default=250,
+                )
+            ),
+            return_info=bool(
+                cls._cfg_get(ds_cfg, "output.return_info", "return_info", default=True)
+            ),
+            return_coords=bool(
+                cls._cfg_get(
+                    ds_cfg, "output.return_coords", "return_coords", default=True
+                )
+            ),
+            include_salinity=bool(
+                cls._cfg_get(
+                    ds_cfg,
+                    "output.include_salinity",
+                    "include_salinity",
+                    default=False,
+                )
+            ),
+            output_fields=cls._cfg_get(
+                ds_cfg, "output.fields", "output_fields", default=None
+            ),
+            random_seed=int(
+                cls._cfg_get(ds_cfg, "runtime.random_seed", "random_seed", default=7)
+            ),
+            cache_size=int(
+                cls._cfg_get(ds_cfg, "runtime.cache_size", "cache_size", default=8)
+            ),
+        )
+
+    @staticmethod
+    def _cfg_get(
+        cfg: dict[str, Any],
+        nested_key: str,
+        flat_key: str,
+        *,
+        default: Any,
+    ) -> Any:
+        """Read nested config values while keeping flat-key compatibility."""
+        node: Any = cfg
+        for part in nested_key.split("."):
+            if not isinstance(node, dict) or part not in node:
+                node = None
+                break
+            node = node[part]
+        if node is not None:
+            return node
+        _ = flat_key
+        return default
+
+    @staticmethod
+    def _normalize_output_fields(
+        output_fields: Sequence[str] | str | None,
+        *,
+        include_salinity: bool,
+    ) -> tuple[str, ...]:
+        """Resolve physical fields loaded for each dataset sample."""
+        if output_fields is None:
+            return ("temperature", "salinity") if include_salinity else ("temperature",)
+        if isinstance(output_fields, str):
+            fields = (output_fields,)
+        else:
+            fields = tuple(str(field) for field in output_fields)
+        normalized = tuple(field.strip().lower() for field in fields if field.strip())
+        if not normalized:
+            raise ValueError("dataset.output.fields must contain at least one field.")
+        unsupported = sorted(set(normalized) - {"temperature", "salinity"})
+        if unsupported:
+            raise ValueError(
+                "dataset.output.fields contains unsupported fields: "
+                f"{unsupported}. Supported fields are: temperature, salinity."
+            )
+        if len(set(normalized)) != len(normalized):
+            raise ValueError("dataset.output.fields cannot contain duplicates.")
+        return normalized
+
+    @staticmethod
+    def _optional_bool(value: Any) -> bool | None:
+        """Parse nullable boolean config values."""
+        if value is None:
+            return None
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in MISSING_TEXT_VALUES:
+                return None
+            if normalized in {"true", "yes", "on", "1"}:
+                return True
+            if normalized in {"false", "no", "off", "0"}:
+                return False
+        if isinstance(value, bool):
+            return value
+        raise ValueError(f"Expected a nullable boolean value, got {value!r}.")
+
+    @staticmethod
+    def _optional_int(value: Any) -> int | None:
+        """Parse nullable integer config values."""
+        if value is None:
+            return None
+        if isinstance(value, str) and value.strip().lower() in MISSING_TEXT_VALUES:
+            return None
+        return int(value)
+
+    @staticmethod
+    def _normalize_finetune_sampling(raw_cfg: dict[str, Any] | None) -> dict[str, Any]:
+        """Normalize optional hard-area finetuning row-sampling settings."""
+        cfg = dict(raw_cfg or {})
+        hard_fraction = float(cfg.get("hard_fraction", 0.75))
+        if not (0.0 < hard_fraction <= 1.0):
+            raise ValueError("finetune_sampling.hard_fraction must be in (0, 1].")
+        default_max_land_fraction = float(cfg.get("default_max_land_fraction", 0.85))
+        if not (0.0 <= default_max_land_fraction <= 1.0):
+            raise ValueError(
+                "finetune_sampling.default_max_land_fraction must be in [0, 1]."
+            )
+
+        raw_splits = cfg.get("apply_to_splits", ("train",))
+        if isinstance(raw_splits, str):
+            apply_to_splits = (raw_splits.strip().lower(),)
+        else:
+            apply_to_splits = tuple(str(value).strip().lower() for value in raw_splits)
+        if not apply_to_splits or any(
+            value not in {"all", "train", "val"} for value in apply_to_splits
+        ):
+            raise ValueError(
+                "finetune_sampling.apply_to_splits must contain split names from "
+                "{'all', 'train', 'val'}."
+            )
+
+        hard_regions: list[dict[str, Any]] = []
+        for idx, raw_region in enumerate(cfg.get("hard_regions", ()) or ()):
+            if not isinstance(raw_region, dict):
+                raise ValueError(
+                    "Each finetune_sampling.hard_regions item must be a mapping."
+                )
+            region = dict(raw_region)
+            region["name"] = str(region.get("name", f"hard_region_{idx}"))
+            region["lon_min"] = float(region["lon_min"])
+            region["lon_max"] = float(region["lon_max"])
+            region["lat_min"] = float(region["lat_min"])
+            region["lat_max"] = float(region["lat_max"])
+            region["max_land_fraction"] = float(
+                region.get("max_land_fraction", default_max_land_fraction)
+            )
+            if not (0.0 <= region["max_land_fraction"] <= 1.0):
+                raise ValueError(
+                    "finetune_sampling.hard_regions[].max_land_fraction must be "
+                    "in [0, 1]."
+                )
+            hard_regions.append(region)
+
+        return {
+            "enabled": bool(cfg.get("enabled", False)),
+            "hard_fraction": hard_fraction,
+            "apply_to_splits": apply_to_splits,
+            "relax_land_filter": bool(cfg.get("relax_land_filter", True)),
+            "default_max_land_fraction": default_max_land_fraction,
+            "hard_regions": tuple(hard_regions),
+        }
+
+    def _finetune_applies_to_current_split(self) -> bool:
+        """Return whether hard-area finetuning should filter this split."""
+        if not bool(self.finetune_sampling["enabled"]):
+            return False
+        apply_to_splits = set(self.finetune_sampling["apply_to_splits"])
+        return "all" in apply_to_splits or self.split in apply_to_splits
+
+    def _effective_force_include_regions(self) -> tuple[Any, ...]:
+        """Return force-include regions, extended by finetune boxes when needed."""
+        if not (
+            self._finetune_applies_to_current_split()
+            and bool(self.finetune_sampling["relax_land_filter"])
+        ):
+            return self.force_include_regions
+
+        merged = {region.name: region for region in self.force_include_regions}
+        for raw_region in self.finetune_sampling["hard_regions"]:
+            parsed_region = _parse_force_include_regions([raw_region])[0]
+            existing = merged.get(parsed_region.name)
+            if existing is not None:
+                # Duplicate named boxes keep the most permissive finetune land cap.
+                parsed_region = parsed_region.__class__(
+                    name=parsed_region.name,
+                    lon_min=parsed_region.lon_min,
+                    lon_max=parsed_region.lon_max,
+                    lat_min=parsed_region.lat_min,
+                    lat_max=parsed_region.lat_max,
+                    max_land_fraction=max(
+                        float(existing.max_land_fraction),
+                        float(parsed_region.max_land_fraction),
+                    ),
+                )
+            merged[parsed_region.name] = parsed_region
+        return tuple(merged.values())
+
+    @staticmethod
+    def _row_in_hard_region(
+        row: dict[str, Any], regions: Sequence[dict[str, Any]]
+    ) -> bool:
+        """Return whether a patch center falls inside any hard finetune box."""
+        lat_center = float(row.get("lat_center", np.nan))
+        lon_center = _normalize_lon(float(row.get("lon_center", np.nan)))
+        if not (np.isfinite(lat_center) and np.isfinite(lon_center)):
+            return False
+        for region in regions:
+            lat_min = min(float(region["lat_min"]), float(region["lat_max"]))
+            lat_max = max(float(region["lat_min"]), float(region["lat_max"]))
+            lon_min = min(float(region["lon_min"]), float(region["lon_max"]))
+            lon_max = max(float(region["lon_min"]), float(region["lon_max"]))
+            if lat_min <= lat_center <= lat_max and lon_min <= lon_center <= lon_max:
+                return True
+        return False
+
+    def _apply_finetune_sampling(
+        self, rows: list[dict[str, Any]]
+    ) -> list[dict[str, Any]]:
+        """Apply deterministic hard/easy row filtering for finetuning runs."""
+        if not self._finetune_applies_to_current_split():
+            self.finetune_sampling_summary = {
+                "enabled": bool(self.finetune_sampling["enabled"]),
+                "applied": False,
+                "split": self.split,
+                "total_rows": len(rows),
+            }
+            return rows
+
+        regions = self.finetune_sampling["hard_regions"]
+        hard_indices = [
+            idx
+            for idx, row in enumerate(rows)
+            if self._row_in_hard_region(row, regions)
+        ]
+        if not hard_indices:
+            raise RuntimeError(
+                "Finetune hard-area sampling matched no rows for split "
+                f"{self.split!r}. Check data.dataset.finetune_sampling.hard_regions."
+            )
+
+        hard_fraction = float(self.finetune_sampling["hard_fraction"])
+        hard_index_set = set(hard_indices)
+        easy_indices = [idx for idx in range(len(rows)) if idx not in hard_index_set]
+        requested_easy = int(
+            round(len(hard_indices) * (1.0 - hard_fraction) / hard_fraction)
+        )
+        selected_easy: list[int] = []
+        if requested_easy > 0 and easy_indices:
+            sample_count = min(int(requested_easy), len(easy_indices))
+            rng = np.random.default_rng(int(self.random_seed))
+            selected_easy = sorted(
+                int(value)
+                for value in rng.choice(easy_indices, size=sample_count, replace=False)
+            )
+
+        selected_indices = sorted(hard_indices + selected_easy)
+        filtered_rows = [rows[idx] for idx in selected_indices]
+        actual_hard_fraction = len(hard_indices) / float(len(filtered_rows))
+        self.finetune_sampling_summary = {
+            "enabled": True,
+            "applied": True,
+            "split": self.split,
+            "target_hard_fraction": hard_fraction,
+            "actual_hard_fraction": actual_hard_fraction,
+            "hard_rows": len(hard_indices),
+            "easy_rows": len(selected_easy),
+            "total_rows": len(filtered_rows),
+            "available_easy_rows": len(easy_indices),
+            "region_names": [str(region["name"]) for region in regions],
+        }
+        return filtered_rows
+
+    def _filter_rows(self, rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Apply split and ARGO-support filters."""
+        if self.split in {"train", "val"}:
+            rows = [
+                row
+                for row in rows
+                if str(row.get("split", row.get("phase", ""))).strip().lower()
+                == self.split
+            ]
+        require_argo = self._require_argo_for_current_split()
+        if require_argo:
+            rows = [row for row in rows if int(row.get("argo_profile_count", 0)) > 0]
+        return rows
+
+    def _require_argo_for_current_split(self) -> bool:
+        """Return whether the current split requires sparse ARGO support."""
+        if self.synthetic_mode:
+            return False
+        if self.split == "train":
+            return self.require_argo_for_train
+        if self.split == "val":
+            return self.require_argo_for_val
+        return self.require_argo_for_all
+
+    def __len__(self) -> int:
+        """Return dataset row count."""
+        return len(self._rows)
+
+    def _load_y_patch(self, row: dict[str, Any]) -> np.ndarray:
+        """Load the dense GLORYS target patch."""
+        y_np = self.glorys_store.read_patch(
+            target_date=int(row["date"]),
+            grid_y0=int(row["grid_y0"]),
+            grid_x0=int(row["grid_x0"]),
+            tile_size=self.tile_size,
+        )
+        if y_np.ndim != 3:
+            raise RuntimeError(
+                f"Expected GLORYS patch shape (D,H,W), got {tuple(y_np.shape)}"
+            )
+        if int(y_np.shape[0]) != int(self._depth_axis_m.size):
+            raise RuntimeError(
+                "GLORYS raster band count does not match manifest depth_axis_m: "
+                f"{int(y_np.shape[0])} != {int(self._depth_axis_m.size)}"
+            )
+        return y_np.astype(np.float32, copy=False)
+
+    def _load_y_salinity_patch(self, row: dict[str, Any]) -> np.ndarray:
+        """Load the dense GLORYS salinity target patch as raw PSU."""
+        if self.salinity_store is None:
+            raise RuntimeError("GeoTIFF salinity output is not enabled.")
+        salinity_np = self.salinity_store.read_patch(
+            target_date=int(row["date"]),
+            grid_y0=int(row["grid_y0"]),
+            grid_x0=int(row["grid_x0"]),
+            tile_size=self.tile_size,
+        )
+        if salinity_np.ndim != 3:
+            raise RuntimeError(
+                "Expected GLORYS salinity patch shape (D,H,W), "
+                f"got {tuple(salinity_np.shape)}"
+            )
+        if int(salinity_np.shape[0]) != int(self._depth_axis_m.size):
+            raise RuntimeError(
+                "GLORYS salinity raster band count does not match manifest "
+                f"depth_axis_m: {int(salinity_np.shape[0])} != "
+                f"{int(self._depth_axis_m.size)}"
+            )
+        return salinity_np.astype(np.float32, copy=False)
+
+    def _load_land_mask_patch(self, row: dict[str, Any]) -> np.ndarray:
+        """Load the configured on-disk world-mask patch as an ocean mask."""
+        src = self.raster_cache.get(self.land_mask_path)
+        window = Window(
+            col_off=int(row["grid_x0"]),
+            row_off=int(row["grid_y0"]),
+            width=int(self.tile_size),
+            height=int(self.tile_size),
+        )
+        land_np = src.read(1, window=window)
+        expected_shape = (int(self.tile_size), int(self.tile_size))
+        if land_np.shape != expected_shape:
+            raise RuntimeError(
+                "Land-mask patch shape does not match dataset tile_size: "
+                f"{tuple(land_np.shape)} != {expected_shape}"
+            )
+        # The world raster stores 1 for land, while model masks use 1 for ocean.
+        return (np.asarray(land_np, dtype=np.float32) <= 0.5).astype(
+            np.float32,
+            copy=False,
+        )[None, ...]
+
+    def _load_eo_patch(self, row: dict[str, Any]) -> np.ndarray:
+        """Load the configured dense surface-context patch."""
+        eo_np = self.eo_store.read_patch(
+            target_date=int(row["date"]),
+            grid_y0=int(row["grid_y0"]),
+            grid_x0=int(row["grid_x0"]),
+            tile_size=self.tile_size,
+        )
+        if eo_np.ndim == 3 and int(eo_np.shape[0]) == 1:
+            eo_np = eo_np[0]
+        if eo_np.ndim != 2:
+            raise RuntimeError(
+                f"Expected EO patch shape (H,W), got {tuple(eo_np.shape)}"
+            )
+        return eo_np.astype(np.float32, copy=False)[None, ...]
+
+    def _normalize_eo_tensor(self, tensor: torch.Tensor) -> torch.Tensor:
+        """Normalize the EO channel according to its physical variable family."""
+        if self.eo_normalization == "temperature":
+            return temperature_normalize(mode="norm", tensor=tensor)
+        if self.eo_normalization == "salinity":
+            return salinity_normalize(mode="norm", tensor=tensor)
+        raise RuntimeError(f"Unsupported EO normalization: {self.eo_normalization}")
+
+    def _spatial_support_from_valid_mask(
+        self,
+        valid_mask_np: np.ndarray,
+        *,
+        source_name: str,
+    ) -> np.ndarray:
+        """Collapse a per-band validity mask into one spatial ocean-support mask."""
+        valid_np = np.asarray(valid_mask_np, dtype=bool)
+        if valid_np.ndim == 3:
+            spatial_mask = valid_np.any(axis=0, keepdims=True)
+        elif valid_np.ndim == 2:
+            spatial_mask = valid_np[None, ...]
+        else:
+            raise RuntimeError(
+                f"{source_name} support must be shaped as (C,H,W) or (H,W), "
+                f"got {tuple(valid_np.shape)}."
+            )
+        expected_shape = (1, int(self.tile_size), int(self.tile_size))
+        if tuple(spatial_mask.shape) != expected_shape:
+            raise RuntimeError(
+                f"{source_name} support shape does not match dataset tile_size: "
+                f"{tuple(spatial_mask.shape)} != {expected_shape}."
+            )
+        return spatial_mask.astype(np.float32, copy=False)
+
+    def _build_land_mask_patch(
+        self,
+        row: dict[str, Any],
+        *,
+        y_valid_mask_np: np.ndarray | None,
+        eo_np: np.ndarray | None,
+    ) -> np.ndarray:
+        """Build one spatial ocean mask from GLORYS, EO, or the on-disk mask."""
+        if y_valid_mask_np is not None:
+            return self._spatial_support_from_valid_mask(
+                y_valid_mask_np,
+                source_name="GLORYS target",
+            )
+        if eo_np is not None:
+            return self._spatial_support_from_valid_mask(
+                np.isfinite(eo_np),
+                source_name="EO surface context",
+            )
+        if self.land_mask_path.exists():
+            return self._load_land_mask_patch(row)
+        raise RuntimeError(
+            "Could not build land_mask: GLORYS target support was unavailable, "
+            "EO support was unavailable, and the configured on-disk land mask "
+            f"does not exist: {self.land_mask_path}"
+        )
+
+    def _empty_sparse_patch(self) -> tuple[np.ndarray, np.ndarray]:
+        """Return an empty sparse profile patch and validity mask."""
+        depth_size = int(self._depth_axis_m.size)
+        shape = (depth_size, self.tile_size, self.tile_size)
+        return np.full(shape, np.nan, dtype=np.float32), np.zeros(shape, dtype=bool)
+
+    def _rasterize_profile_values(
+        self,
+        row: dict[str, Any],
+        indices: np.ndarray,
+        values: np.ndarray,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Rasterize selected profile values into one sparse patch."""
+        depth_size = int(self._depth_axis_m.size)
+        if indices.size == 0:
+            return self._empty_sparse_patch()
+        if values.ndim != 2 or int(values.shape[1]) != depth_size:
+            raise RuntimeError(
+                "ARGO profile values do not match manifest depth_axis_m: "
+                f"{tuple(values.shape)}"
+            )
+
+        value_sum = np.zeros(
+            (depth_size, self.tile_size, self.tile_size), dtype=np.float64
+        )
+        value_count = np.zeros(
+            (depth_size, self.tile_size, self.tile_size), dtype=np.uint16
+        )
+        y0 = int(row["grid_y0"])
+        x0 = int(row["grid_x0"])
+        for local_idx, profile_idx in enumerate(indices.tolist()):
+            row_idx = int(self.argo_store.grid_row[int(profile_idx)]) - y0
+            col_idx = int(self.argo_store.grid_col[int(profile_idx)]) - x0
+            if (
+                row_idx < 0
+                or row_idx >= self.tile_size
+                or col_idx < 0
+                or col_idx >= self.tile_size
+            ):
+                continue
+            profile = values[int(local_idx)]
+            valid = np.isfinite(profile)
+            if not np.any(valid):
+                continue
+            # Multiple ARGO profiles can land on the same grid cell and depth.
+            value_sum[valid, row_idx, col_idx] += profile[valid].astype(np.float64)
+            value_count[valid, row_idx, col_idx] += 1
+
+        value_np = np.full(value_sum.shape, np.nan, dtype=np.float32)
+        value_valid = value_count > 0
+        value_np[value_valid] = (
+            value_sum[value_valid] / value_count[value_valid].astype(np.float64)
+        ).astype(
+            np.float32,
+            copy=False,
+        )
+        return value_np, value_valid
+
+    def _query_temperature_valid_argo_indices(self, row: dict[str, Any]) -> np.ndarray:
+        """Return temperature-valid ARGO indices for the current patch."""
+        if self.argo_store is None:
+            return np.zeros((0,), dtype=np.int64)
+        return self.argo_store.query_indices(
+            target_date=int(row["date"]),
+            grid_y0=int(row["grid_y0"]),
+            grid_x0=int(row["grid_x0"]),
+            tile_size=self.tile_size,
+        )
+
+    def _rasterize_argo_patch(
+        self, row: dict[str, Any]
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Rasterize compact ARGO temperature observations into one patch."""
+        indices = self._query_temperature_valid_argo_indices(row)
+        if indices.size == 0 or self.argo_store is None:
+            return self._empty_sparse_patch()
+        values = self.argo_store.load_temperature_profiles(indices)
+        return self._rasterize_profile_values(row, indices, values)
+
+    def _rasterize_argo_salinity_patch(
+        self, row: dict[str, Any]
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Rasterize compact ARGO salinity observations into one patch."""
+        if not self.include_salinity:
+            raise RuntimeError("ARGO salinity output is not enabled.")
+        indices = self._query_temperature_valid_argo_indices(row)
+        if indices.size == 0 or self.argo_store is None:
+            return self._empty_sparse_patch()
+        # Keep salinity on the same temperature-valid support used for filtering.
+        values = self.argo_store.load_salinity_profiles(indices)
+        return self._rasterize_profile_values(row, indices, values)
+
+    def _synthetic_rng_for_row(
+        self,
+        row: dict[str, Any],
+        *,
+        idx: int,
+    ) -> np.random.Generator:
+        """Build a deterministic synthetic-sampling RNG for one row."""
+        seed = np.random.SeedSequence(
+            [
+                int(self.random_seed),
+                int(row.get("patch_id", 0)),
+                int(row.get("date", 0)),
+                int(idx),
+            ]
+        )
+        return np.random.default_rng(seed)
+
+    def _build_synthetic_x_from_glorys(
+        self,
+        y_np: np.ndarray,
+        y_valid_mask_np: np.ndarray,
+        row: dict[str, Any],
+        *,
+        idx: int,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Build sparse synthetic observations by sampling the dense target."""
+        x_np = np.full(y_np.shape, np.nan, dtype=np.float32)
+        x_valid = np.zeros(y_valid_mask_np.shape, dtype=bool)
+        if self.synthetic_pixel_count == 0:
+            return x_np, x_valid
+
+        valid_columns = np.asarray(y_valid_mask_np, dtype=bool).any(axis=0)
+        flat_valid_columns = np.flatnonzero(valid_columns.reshape(-1))
+        if flat_valid_columns.size == 0:
+            return x_np, x_valid
+
+        sample_count = min(
+            int(self.synthetic_pixel_count), int(flat_valid_columns.size)
+        )
+        rng = self._synthetic_rng_for_row(row, idx=idx)
+        selected = rng.choice(flat_valid_columns, size=sample_count, replace=False)
+        row_indices, col_indices = np.unravel_index(selected, valid_columns.shape)
+        for row_idx, col_idx in zip(row_indices.tolist(), col_indices.tolist()):
+            depth_valid = y_valid_mask_np[:, int(row_idx), int(col_idx)]
+            if not np.any(depth_valid):
+                continue
+            # Synthetic mode uses decoded dense target values as sparse input.
+            x_np[depth_valid, int(row_idx), int(col_idx)] = y_np[
+                depth_valid,
+                int(row_idx),
+                int(col_idx),
+            ]
+            x_valid[depth_valid, int(row_idx), int(col_idx)] = True
+        return x_np, x_valid
+
+    def __getitem__(self, idx: int) -> dict[str, Any]:
+        """Return one model-ready training sample."""
+        row = self._rows[int(idx)]
+        eo_np = self._load_eo_patch(row)
+        temperature_payload: dict[str, torch.Tensor] | None = None
+        salinity_payload: dict[str, torch.Tensor] | None = None
+        land_support_np: np.ndarray | None = None
+
+        if self._loads_temperature:
+            y_np = self._load_y_patch(row)
+            y_valid_mask_np = np.isfinite(y_np)
+            if self.synthetic_mode:
+                x_np, x_valid_mask_np = self._build_synthetic_x_from_glorys(
+                    y_np,
+                    y_valid_mask_np,
+                    row,
+                    idx=int(idx),
+                )
+            else:
+                x_np, x_valid_mask_np = self._rasterize_argo_patch(row)
+
+            x = temperature_normalize(mode="norm", tensor=torch.from_numpy(x_np))
+            y = temperature_normalize(mode="norm", tensor=torch.from_numpy(y_np))
+            x = torch.nan_to_num(x, nan=0.0, posinf=0.0, neginf=0.0)
+            y = torch.nan_to_num(y, nan=0.0, posinf=0.0, neginf=0.0)
+            x_valid_mask = torch.from_numpy(
+                x_valid_mask_np.astype(np.bool_, copy=False)
+            )
+            y_valid_mask = torch.from_numpy(
+                y_valid_mask_np.astype(np.bool_, copy=False)
+            )
+            temperature_payload = {
+                "x": x,
+                "y": y,
+                "x_valid_mask": x_valid_mask,
+                "y_valid_mask": y_valid_mask,
+                "x_valid_mask_1d": x_valid_mask.any(dim=0, keepdim=True),
+            }
+            land_support_np = y_valid_mask_np
+
+        if self.include_salinity:
+            y_salinity_np = self._load_y_salinity_patch(row)
+            y_salinity_valid_mask_np = np.isfinite(y_salinity_np)
+            if self.synthetic_mode:
+                x_salinity_np, x_salinity_valid_mask_np = (
+                    self._build_synthetic_x_from_glorys(
+                        y_salinity_np,
+                        y_salinity_valid_mask_np,
+                        row,
+                        idx=int(idx),
+                    )
+                )
+            else:
+                x_salinity_np, x_salinity_valid_mask_np = (
+                    self._rasterize_argo_salinity_patch(row)
+                )
+            x_salinity = salinity_normalize(
+                mode="norm", tensor=torch.from_numpy(x_salinity_np)
+            )
+            y_salinity = salinity_normalize(
+                mode="norm", tensor=torch.from_numpy(y_salinity_np)
+            )
+            x_salinity = torch.nan_to_num(x_salinity, nan=0.0, posinf=0.0, neginf=0.0)
+            y_salinity = torch.nan_to_num(y_salinity, nan=0.0, posinf=0.0, neginf=0.0)
+            x_salinity_valid_mask = torch.from_numpy(
+                x_salinity_valid_mask_np.astype(np.bool_, copy=False)
+            )
+            y_salinity_valid_mask = torch.from_numpy(
+                y_salinity_valid_mask_np.astype(np.bool_, copy=False)
+            )
+            salinity_payload = {
+                "x_salinity": x_salinity,
+                "y_salinity": y_salinity,
+                "x_salinity_valid_mask": x_salinity_valid_mask,
+                "y_salinity_valid_mask": y_salinity_valid_mask,
+                "x_salinity_valid_mask_1d": x_salinity_valid_mask.any(
+                    dim=0, keepdim=True
+                ),
+            }
+            if land_support_np is None:
+                # Salinity-only runs should derive the spatial mask from salinity support.
+                land_support_np = y_salinity_valid_mask_np
+
+        land_mask_np = self._build_land_mask_patch(
+            row,
+            y_valid_mask_np=land_support_np,
+            eo_np=eo_np,
+        )
+        eo = self._normalize_eo_tensor(torch.from_numpy(eo_np))
+        eo = torch.nan_to_num(eo, nan=0.0, posinf=0.0, neginf=0.0)
+        sample: dict[str, Any] = {
+            "eo": eo,
+            "land_mask": torch.from_numpy(land_mask_np),
+            "date": _parse_date_int(row.get("date", 19700115)),
+        }
+        if temperature_payload is not None:
+            sample.update(temperature_payload)
+        if salinity_payload is not None:
+            sample.update(salinity_payload)
+        if self.return_coords:
+            sample["coords"] = torch.tensor(
+                [
+                    0.5 * (float(row["lat0"]) + float(row["lat1"])),
+                    _center_lon_deg(float(row["lon0"]), float(row["lon1"])),
+                ],
+                dtype=torch.float32,
+            )
+        if self.return_info:
+            info = dict(row)
+            info["x_source"] = "glorys_synthetic" if self.synthetic_mode else "argo"
+            info["synthetic_pixel_count"] = (
+                int(self.synthetic_pixel_count) if self.synthetic_mode else 0
+            )
+            sample["info"] = info
+        return sample

depthdif_dataset/grid_utils.py

@@ -0,0 +1,443 @@
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Sequence
+
+import numpy as np
+import pandas as pd
+import rasterio
+from tqdm import tqdm
+
+MISSING_TEXT_VALUES = frozenset({"", "__missing__", "nan", "none", "null"})
+DEFAULT_DATASET_ROOT_DIR = Path(__file__).resolve().parents[1]
+DEFAULT_LAND_MASK_PATH = str(
+    DEFAULT_DATASET_ROOT_DIR / "masks/world_land_mask_glorys_0p1.tif"
+)
+
+
+def resolve_package_path(path: str | Path) -> Path:
+    """Resolve paths relative to this Hugging Face dataset checkout."""
+    candidate = Path(path).expanduser()
+    if candidate.is_absolute():
+        return candidate
+    repo_relative = DEFAULT_DATASET_ROOT_DIR / candidate
+    if repo_relative.exists():
+        return repo_relative
+    return candidate
+
+
+def _parse_date_int(value: Any) -> int:
+    """Parse a model date integer while avoiding leap-day calendar issues."""
+    raw = str(value).strip()
+    if raw.isdigit():
+        date_int = int(raw)
+        month = (date_int // 100) % 100
+        day = date_int % 100
+        # Keep dataset dates compatible with the model's fixed non-leap calendar.
+        if month == 2 and day == 29:
+            return date_int - 1
+        return date_int
+    return 20100101
+
+
+def _normalize_lon(lon: float) -> float:
+    """Normalize longitude to the -180..180 degree range."""
+    return float(((float(lon) + 180.0) % 360.0) - 180.0)
+
+
+def _center_lon_deg(lon0: float, lon1: float) -> float:
+    """Return the circular midpoint longitude in degrees."""
+    lon0_rad = np.deg2rad(lon0)
+    lon1_rad = np.deg2rad(lon1)
+    sin_sum = np.sin(lon0_rad) + np.sin(lon1_rad)
+    cos_sum = np.cos(lon0_rad) + np.cos(lon1_rad)
+    return float(np.rad2deg(np.arctan2(sin_sum, cos_sum)))
+
+
+@dataclass(frozen=True)
+class _ForceIncludeRegion:
+    """Named region that relaxes land-fraction filtering for patch centers."""
+
+    name: str
+    lon_min: float
+    lon_max: float
+    lat_min: float
+    lat_max: float
+    max_land_fraction: float
+
+
+@dataclass(frozen=True)
+class _GridParams:
+    """Patch-grid construction parameters shared by dataset backends."""
+
+    tile_size: int
+    resolution_deg: float
+    invalid_threshold: float
+    invalid_mask_flags: tuple[str, ...]
+    val_fraction: float
+    val_year: int | None
+    split_seed: int
+    patch_grid_source: str = "land_mask"
+    land_mask_path: str | Path | None = DEFAULT_LAND_MASK_PATH
+    patch_stride: int | None = None
+    max_land_fraction: float = 0.30
+    force_include_regions: tuple[_ForceIncludeRegion, ...] = ()
+
+    @property
+    def effective_patch_stride(self) -> int:
+        """Return the configured stride, defaulting to non-overlapping tiles."""
+        return int(self.tile_size if self.patch_stride is None else self.patch_stride)
+
+
+@dataclass(frozen=True)
+class _PatchGridLookup:
+    """Compact lookup from global pixel coordinates to retained patch ids."""
+
+    patch_by_start: dict[tuple[int, int], int]
+    y_starts: np.ndarray
+    x_starts: np.ndarray
+    grid_top: float
+    grid_left: float
+    tile_size: int
+    resolution_deg: float
+
+
+def _sanitize_cache_text(value: Any) -> str:
+    """Sanitize arbitrary config text for use in cache filenames."""
+    text = str(value).strip().lower().replace("\\", "/")
+    for old, new in (("/", "-"), (".", "p"), (" ", ""), (":", "-")):
+        text = text.replace(old, new)
+    return text
+
+
+def _path_cache_hash(path: str | Path | None) -> str:
+    """Return a short stable hash for a path-like cache key."""
+    if path is None:
+        return "none"
+    raw = str(Path(path)).encode("utf-8")
+    return hashlib.sha1(raw).hexdigest()[:8]
+
+
+def _deep_update_config(
+    base: dict[str, Any], overrides: dict[str, Any]
+) -> dict[str, Any]:
+    """Return a copy of a config mapping with nested override values applied."""
+    out = dict(base)
+    for key, value in overrides.items():
+        if isinstance(value, dict) and isinstance(out.get(key), dict):
+            out[key] = _deep_update_config(out[key], value)
+        else:
+            out[key] = value
+    return out
+
+
+def _force_include_cache_hash(regions: Sequence[_ForceIncludeRegion]) -> str:
+    """Return a short stable hash for force-include region settings."""
+    if not regions:
+        return "none"
+    parts = [
+        (
+            region.name,
+            f"{region.lon_min:.6f}",
+            f"{region.lon_max:.6f}",
+            f"{region.lat_min:.6f}",
+            f"{region.lat_max:.6f}",
+            f"{region.max_land_fraction:.6f}",
+        )
+        for region in regions
+    ]
+    raw = repr(parts).encode("utf-8")
+    return hashlib.sha1(raw).hexdigest()[:8]
+
+
+def _parse_force_include_regions(value: Any) -> tuple[_ForceIncludeRegion, ...]:
+    """Parse optional force-include region mappings from dataset config."""
+    if value is None:
+        return ()
+    if isinstance(value, str) and value.strip().lower() in MISSING_TEXT_VALUES:
+        return ()
+    if not isinstance(value, (list, tuple)):
+        raise ValueError("grid.force_include_regions must be a list of mappings.")
+
+    regions: list[_ForceIncludeRegion] = []
+    for idx, raw_region in enumerate(value):
+        if not isinstance(raw_region, dict):
+            raise ValueError("Each grid.force_include_regions item must be a mapping.")
+        name = str(raw_region.get("name", f"region_{idx}"))
+        lon_min = float(raw_region["lon_min"])
+        lon_max = float(raw_region["lon_max"])
+        lat_min = float(raw_region["lat_min"])
+        lat_max = float(raw_region["lat_max"])
+        max_land_fraction = float(raw_region.get("max_land_fraction", 1.0))
+        regions.append(
+            _ForceIncludeRegion(
+                name=name,
+                lon_min=min(lon_min, lon_max),
+                lon_max=max(lon_min, lon_max),
+                lat_min=min(lat_min, lat_max),
+                lat_max=max(lat_min, lat_max),
+                max_land_fraction=max_land_fraction,
+            )
+        )
+    return tuple(regions)
+
+
+def _grid_starts(size: int, tile: int, stride: int) -> list[int]:
+    """Return grid start indices that always include the final valid tile."""
+    if tile < 1:
+        raise ValueError("grid.tile_size must be >= 1.")
+    if stride < 1:
+        raise ValueError("grid.patch_stride must be >= 1.")
+    if int(size) < int(tile):
+        raise RuntimeError("Source grid is smaller than the requested tile size.")
+
+    last_start = int(size) - int(tile)
+    starts = list(range(0, last_start + 1, int(stride)))
+    if not starts or starts[-1] != last_start:
+        starts.append(last_start)
+    return starts
+
+
+def _summed_area_table(mask: np.ndarray) -> np.ndarray:
+    """Build a summed-area table for fast rectangular mask sums."""
+    values = np.asarray(mask, dtype=np.float64)
+    table = np.zeros((values.shape[0] + 1, values.shape[1] + 1), dtype=np.float64)
+    table[1:, 1:] = values.cumsum(axis=0).cumsum(axis=1)
+    return table
+
+
+def _window_sum(table: np.ndarray, *, y0: int, x0: int, tile: int) -> float:
+    """Return a square-window sum from a summed-area table."""
+    y1 = int(y0) + int(tile)
+    x1 = int(x0) + int(tile)
+    return float(
+        table[y1, x1]
+        - table[int(y0), x1]
+        - table[y1, int(x0)]
+        + table[int(y0), int(x0)]
+    )
+
+
+def _validate_grid_params(grid_params: _GridParams) -> None:
+    """Validate patch-grid settings before building a registry."""
+    tile = int(grid_params.tile_size)
+    stride = int(grid_params.effective_patch_stride)
+    if tile < 1:
+        raise ValueError("grid.tile_size must be >= 1.")
+    if stride < 1:
+        raise ValueError("grid.patch_stride must be >= 1.")
+    if stride < tile and grid_params.val_year is None:
+        raise ValueError(
+            "Overlapping patch grids require split.val_year to avoid spatial "
+            "train/val leakage. Set split.val_year or use patch_stride >= tile_size."
+        )
+    if not (0.0 <= float(grid_params.max_land_fraction) <= 1.0):
+        raise ValueError("grid.max_land_fraction must be in [0, 1].")
+    for region in grid_params.force_include_regions:
+        if not (0.0 <= float(region.max_land_fraction) <= 1.0):
+            raise ValueError(
+                "grid.force_include_regions[].max_land_fraction must be in [0, 1]."
+            )
+    source = str(grid_params.patch_grid_source).strip().lower()
+    if source not in {"land_mask", "ostia_mask"}:
+        raise ValueError("grid.patch_grid_source must be 'land_mask' or 'ostia_mask'.")
+
+
+def _force_include_region_for_patch(
+    *,
+    lat_center: float,
+    lon_center: float,
+    land_fraction: float,
+    regions: Sequence[_ForceIncludeRegion],
+) -> _ForceIncludeRegion | None:
+    """Return the matching force-include region for a patch, if any."""
+    for region in regions:
+        lon_value = _normalize_lon(float(lon_center))
+        if (
+            region.lat_min <= float(lat_center) <= region.lat_max
+            and region.lon_min <= lon_value <= region.lon_max
+            and float(land_fraction) <= float(region.max_land_fraction)
+        ):
+            return region
+    return None
+
+
+def _build_patch_lookup(
+    patch_df: pd.DataFrame, grid_params: _GridParams
+) -> _PatchGridLookup:
+    """Build a compact lookup from retained patch starts to patch ids."""
+    if patch_df.empty:
+        raise RuntimeError("Cannot build patch lookup from an empty patch table.")
+
+    records = patch_df.to_dict(orient="records")
+    first = records[0]
+    resolution = float(grid_params.resolution_deg)
+    grid_top = max(float(first["lat0"]), float(first["lat1"])) + (
+        int(first["grid_y0"]) * resolution
+    )
+    grid_left = min(float(first["lon0"]), float(first["lon1"])) - (
+        int(first["grid_x0"]) * resolution
+    )
+    patch_by_start = {
+        (int(row["grid_y0"]), int(row["grid_x0"])): int(row["patch_id"])
+        for row in records
+    }
+    y_starts = np.asarray(
+        sorted({int(row["grid_y0"]) for row in records}), dtype=np.int64
+    )
+    x_starts = np.asarray(
+        sorted({int(row["grid_x0"]) for row in records}), dtype=np.int64
+    )
+    return _PatchGridLookup(
+        patch_by_start=patch_by_start,
+        y_starts=y_starts,
+        x_starts=x_starts,
+        grid_top=float(grid_top),
+        grid_left=float(grid_left),
+        tile_size=int(grid_params.tile_size),
+        resolution_deg=resolution,
+    )
+
+
+def _candidate_starts_for_pixel(
+    starts: np.ndarray, pixel_idx: int, tile: int
+) -> np.ndarray:
+    """Return patch start indices whose tile contains one pixel index."""
+    starts = np.asarray(starts, dtype=np.int64)
+    if starts.size == 0:
+        return starts
+    mask = (starts <= int(pixel_idx)) & (int(pixel_idx) < (starts + int(tile)))
+    return starts[mask]
+
+
+def _patch_ids_for_profile(
+    lookup: _PatchGridLookup,
+    *,
+    lat: float,
+    lon: float,
+) -> list[int]:
+    """Return all retained patch ids containing one profile location."""
+    if not np.isfinite(lat) or not np.isfinite(lon):
+        return []
+
+    row_idx = int(
+        np.floor((float(lookup.grid_top) - float(lat)) / lookup.resolution_deg)
+    )
+    lon_value = _normalize_lon(float(lon))
+    if float(lookup.grid_left) >= 0.0 and lon_value < float(lookup.grid_left):
+        # Some legacy OSTIA grids use 0..360 longitude coordinates while ARGO
+        # profile longitudes are normalized to -180..180.
+        lon_value += 360.0
+    col_idx = int(
+        np.floor((lon_value - float(lookup.grid_left)) / lookup.resolution_deg)
+    )
+    y_candidates = _candidate_starts_for_pixel(
+        lookup.y_starts,
+        row_idx,
+        lookup.tile_size,
+    )
+    x_candidates = _candidate_starts_for_pixel(
+        lookup.x_starts,
+        col_idx,
+        lookup.tile_size,
+    )
+    patch_ids: list[int] = []
+    for y0 in y_candidates.tolist():
+        for x0 in x_candidates.tolist():
+            patch_id = lookup.patch_by_start.get((int(y0), int(x0)))
+            if patch_id is not None:
+                patch_ids.append(int(patch_id))
+    return patch_ids
+
+
+def _build_land_mask_patch_table(grid_params: _GridParams) -> pd.DataFrame:
+    """Build retained patch metadata from the authoritative land-mask GeoTIFF."""
+    land_mask_path = resolve_package_path(
+        DEFAULT_LAND_MASK_PATH
+        if grid_params.land_mask_path is None
+        else grid_params.land_mask_path
+    )
+    if not land_mask_path.exists():
+        raise FileNotFoundError(f"Land-mask GeoTIFF does not exist: {land_mask_path}")
+
+    with rasterio.open(land_mask_path) as src:
+        land_mask = src.read(1)
+        transform = src.transform
+        width = int(src.width)
+        height = int(src.height)
+
+    tile = int(grid_params.tile_size)
+    stride = int(grid_params.effective_patch_stride)
+    resolution = float(grid_params.resolution_deg)
+    if not np.isclose(
+        float(transform.a), resolution, rtol=0.0, atol=1.0e-8
+    ) or not np.isclose(
+        abs(float(transform.e)),
+        resolution,
+        rtol=0.0,
+        atol=1.0e-8,
+    ):
+        raise RuntimeError(
+            "Land-mask GeoTIFF resolution does not match dataset.grid.resolution_deg: "
+            f"{float(transform.a)} x {abs(float(transform.e))} != {resolution}"
+        )
+
+    y_starts = _grid_starts(height, tile, stride)
+    x_starts = _grid_starts(width, tile, stride)
+    land_bool = np.asarray(land_mask, dtype=np.float32) > 0.5
+    table = _summed_area_table(land_bool)
+    max_land_fraction = float(grid_params.max_land_fraction)
+
+    records: list[dict[str, Any]] = []
+    patch_id = 0
+    for y0 in tqdm(
+        y_starts,
+        desc="Building land-mask patch grid",
+        unit="row",
+        dynamic_ncols=True,
+    ):
+        for x0 in x_starts:
+            land_fraction = _window_sum(table, y0=y0, x0=x0, tile=tile) / float(
+                tile * tile
+            )
+            left = float(transform.c) + (float(x0) * resolution)
+            right = left + (float(tile) * resolution)
+            top = float(transform.f) - (float(y0) * resolution)
+            bottom = top - (float(tile) * resolution)
+            lat_center = 0.5 * (float(bottom) + float(top))
+            lon_center = _center_lon_deg(float(left), float(right))
+            force_region = _force_include_region_for_patch(
+                lat_center=lat_center,
+                lon_center=lon_center,
+                land_fraction=land_fraction,
+                regions=grid_params.force_include_regions,
+            )
+            if land_fraction > max_land_fraction and force_region is None:
+                continue
+            records.append(
+                {
+                    "patch_id": int(patch_id),
+                    "grid_y0": int(y0),
+                    "grid_x0": int(x0),
+                    "lat0": float(bottom),
+                    "lat1": float(top),
+                    "lon0": float(left),
+                    "lon1": float(right),
+                    "lat_center": lat_center,
+                    "lon_center": lon_center,
+                    "land_fraction": float(land_fraction),
+                    "ocean_fraction": float(1.0 - land_fraction),
+                    "invalid_fraction": float(land_fraction),
+                    "force_included": bool(force_region is not None),
+                    "force_include_region": (
+                        "" if force_region is None else force_region.name
+                    ),
+                }
+            )
+            patch_id += 1
+
+    if not records:
+        raise RuntimeError("No valid patches were built from the land-mask grid.")
+    return pd.DataFrame.from_records(records)

depthdif_dataset/normalizations.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import torch
+
+# Dataset-level statistics provided by user.
+CELSIUS_TO_KELVIN_OFFSET = 273.15
+Y_MEAN = 289.74267177946783
+Y_STD = 10.933397487585731
+SALINITY_MEAN = 34.54260282159372
+SALINITY_STD = 1.158266487751096
+PLOT_STD_MULTIPLIER = 2.5
+PLOT_TEMP_MIN = -10.740821939496481
+PLOT_TEMP_MAX = 43.92616549843217
+PLOT_SALINITY_MIN = 30.0
+PLOT_SALINITY_MAX = 40.0
+PLOT_CMAP = "turbo"
+PLOT_SALINITY_CMAP = "winter"
+
+
+def temperature_normalize(mode: str, tensor: torch.Tensor) -> torch.Tensor:
+    """Compute temperature normalize and return the result.
+
+    Args:
+        mode (str): Input value.
+        tensor (torch.Tensor): Tensor input for the computation.
+
+    Returns:
+        torch.Tensor: Tensor output produced by this call.
+    """
+    if mode not in {"norm", "denorm"}:
+        raise ValueError("mode must be 'norm' or 'denorm'")
+
+    mean = torch.as_tensor(Y_MEAN, dtype=tensor.dtype, device=tensor.device)
+    std = torch.as_tensor(Y_STD, dtype=tensor.dtype, device=tensor.device)
+    kelvin_offset = torch.as_tensor(
+        CELSIUS_TO_KELVIN_OFFSET, dtype=tensor.dtype, device=tensor.device
+    )
+
+    if mode == "norm":
+        tensor_kelvin = tensor + kelvin_offset
+        return (tensor_kelvin - mean) / std
+    denorm_kelvin = tensor * std + mean
+    # Convert back to Celsius so callers keep receiving physical temperatures in C.
+    return denorm_kelvin - kelvin_offset
+
+
+def salinity_normalize(mode: str, tensor: torch.Tensor) -> torch.Tensor:
+    """Compute salinity normalization and return the result.
+
+    Args:
+        mode (str): Input value.
+        tensor (torch.Tensor): Tensor input for the computation.
+
+    Returns:
+        torch.Tensor: Tensor output produced by this call.
+    """
+    if mode not in {"norm", "denorm"}:
+        raise ValueError("mode must be 'norm' or 'denorm'")
+
+    mean = torch.as_tensor(SALINITY_MEAN, dtype=tensor.dtype, device=tensor.device)
+    std = torch.as_tensor(SALINITY_STD, dtype=tensor.dtype, device=tensor.device)
+
+    if mode == "norm":
+        return (tensor - mean) / std
+    return tensor * std + mean
+
+
+def salinity_to_plot_unit(
+    tensor: torch.Tensor,
+    *,
+    tensor_is_normalized: bool = True,
+) -> torch.Tensor:
+    """Compute salinity plot unit and return the result.
+
+    Args:
+        tensor (torch.Tensor): Tensor input for the computation.
+        tensor_is_normalized (bool): Boolean flag controlling behavior.
+
+    Returns:
+        torch.Tensor: Tensor output produced by this call.
+    """
+    salinity = (
+        salinity_normalize(mode="denorm", tensor=tensor)
+        if tensor_is_normalized
+        else tensor
+    )
+    s_min = torch.as_tensor(
+        PLOT_SALINITY_MIN, dtype=salinity.dtype, device=salinity.device
+    )
+    s_max = torch.as_tensor(
+        PLOT_SALINITY_MAX, dtype=salinity.dtype, device=salinity.device
+    )
+    denom = torch.clamp(s_max - s_min, min=torch.finfo(salinity.dtype).eps)
+    return ((salinity - s_min) / denom).clamp(0.0, 1.0)
+
+
+def temperature_to_plot_unit(
+    tensor: torch.Tensor,
+    *,
+    tensor_is_normalized: bool = True,
+) -> torch.Tensor:
+    """Compute temperature to plot unit and return the result.
+
+    Args:
+        tensor (torch.Tensor): Tensor input for the computation.
+        tensor_is_normalized (bool): Boolean flag controlling behavior.
+
+    Returns:
+        torch.Tensor: Tensor output produced by this call.
+    """
+    temp = (
+        temperature_normalize(mode="denorm", tensor=tensor)
+        if tensor_is_normalized
+        else tensor
+    )
+    t_min = torch.as_tensor(PLOT_TEMP_MIN, dtype=temp.dtype, device=temp.device)
+    t_max = torch.as_tensor(PLOT_TEMP_MAX, dtype=temp.dtype, device=temp.device)
+    denom = torch.clamp(t_max - t_min, min=torch.finfo(temp.dtype).eps)
+    return ((temp - t_min) / denom).clamp(0.0, 1.0)

examples/torch_dataloader.py

@@ -0,0 +1,86 @@
+# Example with all options:
+#   python examples/torch_dataloader.py --root . --split all --batch-size 2 --num-workers 0 --tile-size 128 --patch-stride 128 --max-land-fraction 0.30 --date-start 20000101 --date-end 20000101 --max-dates 1 --include-salinity --metadata-cache-dir /tmp/depthdif_cache --require-argo
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+from typing import Any
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from depthdif_dataset import ArgoGeoTIFFGriddedPatchDataset, build_dataloader
+
+
+def _shape_or_value(value: Any) -> Any:
+    """Return tensor shapes for compact terminal output."""
+    return tuple(value.shape) if hasattr(value, "shape") else value
+
+
+def main() -> None:
+    """Open the packaged dataset and print the first PyTorch batch."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=REPO_ROOT)
+    parser.add_argument("--split", choices=("all", "train", "val"), default="all")
+    parser.add_argument("--batch-size", type=int, default=2)
+    parser.add_argument("--num-workers", type=int, default=0)
+    parser.add_argument("--tile-size", type=int, default=128)
+    parser.add_argument("--patch-stride", type=int, default=128)
+    parser.add_argument("--max-land-fraction", type=float, default=0.30)
+    parser.add_argument("--date-start", type=int, default=None)
+    parser.add_argument("--date-end", type=int, default=None)
+    parser.add_argument("--max-dates", type=int, default=1)
+    parser.add_argument("--include-salinity", action="store_true")
+    parser.add_argument(
+        "--metadata-cache-dir",
+        type=Path,
+        default=None,
+        help="Optional cache directory for patch/date metadata CSVs.",
+    )
+    parser.add_argument(
+        "--require-argo",
+        action="store_true",
+        help="Filter rows to patches with ARGO profiles; this may scan the compact ARGO store on first use.",
+    )
+    args = parser.parse_args()
+
+    dataset = ArgoGeoTIFFGriddedPatchDataset(
+        geotiff_root_dir=args.root,
+        split=args.split,
+        tile_size=args.tile_size,
+        patch_stride=args.patch_stride,
+        max_land_fraction=args.max_land_fraction,
+        date_start=args.date_start,
+        date_end=args.date_end,
+        max_dates=args.max_dates,
+        include_salinity=args.include_salinity,
+        require_argo_for_train=args.require_argo,
+        require_argo_for_val=args.require_argo,
+        require_argo_for_all=args.require_argo,
+        count_argo_support=args.require_argo,
+        metadata_cache_dir=args.metadata_cache_dir,
+    )
+    loader = build_dataloader(
+        dataset,
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        shuffle=True,
+    )
+    batch = next(iter(loader))
+
+    print(f"dataset rows: {len(dataset)}")
+    print(f"depth levels: {len(dataset.depth_axis_m)}")
+    print(
+        f"date coverage in this run: {dataset.available_dates[0]}..{dataset.available_dates[-1]}"
+    )
+    for key, value in batch.items():
+        if key == "info":
+            continue
+        print(f"{key}: {_shape_or_value(value)}")
+
+
+if __name__ == "__main__":
+    main()

metadata/citation.cff

@@ -3,4 +3,4 @@ message: "If you use this dataset, cite DepthDif and the upstream EN4/ARGO, GLOR
 title: "DepthDif aligned ARGO profile collocation dataset"
 authors:
   - family-names: "DepthDif contributors"
-license: "other"
+license: "CC-BY-4.0"

metadata/dataset_description.json

@@ -1,19 +1,19 @@
 {
   "name": "OceanVariableReconstruction",
-  "created_utc": "2026-05-21T06:26:40+00:00",
+  "created_utc": "2026-06-02T16:56:29+00:00",
   "zarr_path": "data/argo_glors_ostia_ssh.zarr",
-  "profile_count": 6637381,
+  "profile_count": 9485977,
   "glorys_depth_count": 50,
   "profile_date_range": {
-    "start": 20100101,
+    "start": 20000101,
     "end": 20240731,
-    "start_iso": "2010-01-01",
+    "start_iso": "2000-01-01",
     "end_iso": "2024-07-31"
   },
   "bbox": [
     -999.99,
     -999.99,
-    179.99985,
+    179.999954,
     168.8678
   ],
   "variables": [
@@ -78,13 +78,13 @@
   "zarr_attrs": {
     "description": "ARGO profiles enriched with freshly collocated GLORYS, OSTIA, sea-level, and SSS fields.",
     "created_by": "depth_recon.data.dataset_creation.export_aligned_argo.b_export_enriched_argo_profiles",
-    "created_utc": "2026-05-20T14:16:25+00:00",
+    "created_utc": "2026-06-01T13:53:04+00:00",
     "requested_date_range": {
-      "start_date": 20100101,
+      "start_date": 20000101,
       "end_date": 20240731
     },
-    "batch_size": 2048,
-    "cache_size_per_worker": 8,
+    "batch_size": 8192,
+    "cache_size_per_worker": 4,
     "max_profiles": null,
     "workers": 12,
     "path_policy": "No absolute source filesystem paths are stored. profile_source_file stores source filenames only.",
@@ -92,36 +92,36 @@
     "depth_axis": "GLORYS native depth coordinate, in meters, loaded from the first readable GLORYS file.",
     "source_file_summary": {
       "argo": {
-        "file_count": 169,
-        "first_file": "EN.4.2.2.f.profiles.g10.201001.nc",
+        "file_count": 289,
+        "first_file": "EN.4.2.2.f.profiles.g10.200001.nc",
         "last_file": "EN.4.2.2.f.profiles.g10.202407.nc"
       },
       "glorys": {
-        "file_count": 843,
-        "first_file": "mercatorglorys12v1_gl12_mean_20100101_R20100106.nc",
-        "last_file": "mercatorglorys12v1_gl12_mean_20260220_R20260225.nc",
-        "first_date": 20100101,
-        "last_date": 20260220
+        "file_count": 1283,
+        "first_file": "mercatorglorys12v1_gl12_mean_20000101_R20000105.nc",
+        "last_file": "mercatorglorys12v1_gl12_mean_20240726_R20240731.nc",
+        "first_date": 20000101,
+        "last_date": 20240726
       },
       "ostia": {
-        "file_count": 5326,
-        "first_file": "20100101120000-UKMO-L4_GHRSST-SSTfnd-OSTIA-GLOB_REP-v02.0-fv02.0.nc",
+        "file_count": 8979,
+        "first_file": "20000101120000-UKMO-L4_GHRSST-SSTfnd-OSTIA-GLOB_REP-v02.0-fv02.0.nc",
         "last_file": "20240731120000-UKMO-L4_GHRSST-SSTfnd-OSTIA-GLOB_REP-v02.0-fv02.0.nc",
-        "first_date": 20100101,
+        "first_date": 20000101,
         "last_date": 20240731
       },
       "sealevel": {
-        "file_count": 5326,
-        "first_file": "dt_global_allsat_phy_l4_20100101_20241016.nc",
+        "file_count": 8979,
+        "first_file": "dt_global_allsat_phy_l4_20000101_20241016.nc",
         "last_file": "dt_global_allsat_phy_l4_20240731_20250429.nc",
-        "first_date": 20100101,
+        "first_date": 20000101,
         "last_date": 20240731
       },
       "sss": {
-        "file_count": 5326,
-        "first_file": "dataset-sss-ssd-rep-daily_20100101T1200Z_P20241017T0000Z.nc",
+        "file_count": 8979,
+        "first_file": "dataset-sss-ssd-rep-daily_20000101T1200Z_P20241017T0000Z.nc",
         "last_file": "dataset-sss-ssd-rep-daily_20240731T1200Z_P20260101T0000Z.nc",
-        "first_date": 20100101,
+        "first_date": 20000101,
         "last_date": 20240731
       }
     },
@@ -130,18 +130,18 @@
         "provider": "UK Met Office Hadley Centre",
         "product": "EN4.2.2 profile archive",
         "role": "In-situ profile observations projected onto the GLORYS depth grid.",
-        "file_count": 169,
-        "representative_file": "EN.4.2.2.f.profiles.g10.201001.nc",
-        "first_file": "EN.4.2.2.f.profiles.g10.201001.nc",
+        "file_count": 289,
+        "representative_file": "EN.4.2.2.f.profiles.g10.200001.nc",
+        "first_file": "EN.4.2.2.f.profiles.g10.200001.nc",
         "last_file": "EN.4.2.2.f.profiles.g10.202407.nc",
         "global_attrs": {
           "licence": "EN4 is distributed under the Non Commercial Government Licence: http://www.nationalarchives.gov.uk/doc/non-commercial-government-licence/version/2/. The data are available for non-commercial use with attribution to the data providers, please see the product website (see global attribute: references) for terms and conditions.",
           "references": "Website and paper: https://www.metoffice.gov.uk/hadobs/en4/; Good, S. A., M. J. Martin and N. A. Rayner, 2013. EN4: quality controlled ocean temperature and salinity profiles and monthly objective analyses with uncertainty estimates, Journal of Geophysical Research: Oceans, 118, 6704-6716, doi:10.1002/2013JC009067",
-          "history": "Fri Apr  2 19:50:52 2021: ncks -O -x -v TEMP_UNIQUE_ID,PSAL_UNIQUE_ID EN.4.2.2.f.profiles.g10.201001.nc EN.4.2.2.f.profiles.g10.201001.nc\nFri Apr  2 19:50:48 2021: ncks -O -x -v BKPT,BKPS EN.4.2.2.f.profiles.g10.201001.nc EN.4.2.2.f.profiles.g10.201001.nc\nFri Apr  2 19:22:43 2021: ncatted -a _FillValue,BKPS,c,f,99999.0 profiles.nc\nFri Apr  2 19:22:42 2021: ncatted -a _FillValue,BKPT,c,f,99999.0 profiles.nc\nFri Apr  2 19:22:40 2021: ncatted -a _FillValue,POTM_CORRECTED,c,f,99999.0 profiles.nc\nFri Apr  2 19:22:39 2021: ncatted -a _FillValue,TEMP,c,f,99999.0 profiles.nc\nFri Apr  2 19:22:37 2021: ncatted -a _FillValue,PSAL_CORRECTED,c,f,99999.0 profiles.nc\nFri Apr  2 19:22:25 2021: ncatted -a _FillValue,DEPH_CORRECTED,c,f,99999.0 profiles.nc",
+          "history": "Wed Mar 24 13:36:17 2021: ncks -O -x -v TEMP_UNIQUE_ID,PSAL_UNIQUE_ID EN.4.2.2.f.profiles.g10.200001.nc EN.4.2.2.f.profiles.g10.200001.nc\nWed Mar 24 13:36:12 2021: ncks -O -x -v BKPT,BKPS EN.4.2.2.f.profiles.g10.200001.nc EN.4.2.2.f.profiles.g10.200001.nc\nWed Mar 24 13:25:27 2021: ncatted -a _FillValue,BKPS,c,f,99999.0 profiles.nc\nWed Mar 24 13:25:27 2021: ncatted -a _FillValue,BKPT,c,f,99999.0 profiles.nc\nWed Mar 24 13:25:26 2021: ncatted -a _FillValue,POTM_CORRECTED,c,f,99999.0 profiles.nc\nWed Mar 24 13:25:26 2021: ncatted -a _FillValue,TEMP,c,f,99999.0 profiles.nc\nWed Mar 24 13:25:25 2021: ncatted -a _FillValue,PSAL_CORRECTED,c,f,99999.0 profiles.nc\nWed Mar 24 13:25:21 2021: ncatted -a _FillValue,DEPH_CORRECTED,c,f,99999.0 profiles.nc",
           "NCO": "netCDF Operators version 4.7.5 (Homepage = http://nco.sf.net, Code = http://github.com/nco/nco)"
         },
         "dimensions": {
-          "N_PROF": 31697,
+          "N_PROF": 11320,
           "N_CALIB": 1,
           "N_PARAM": 5,
           "N_LEVELS": 400,
@@ -354,15 +354,15 @@
         "provider": "Copernicus Marine Service",
         "product": "Global Ocean Physics Reanalysis / GLORYS12V1",
         "role": "3D ocean reanalysis fields and 2D model surface/ice fields sampled at profile points.",
-        "file_count": 843,
-        "representative_file": "mercatorglorys12v1_gl12_mean_20100101_R20100106.nc",
-        "first_file": "mercatorglorys12v1_gl12_mean_20100101_R20100106.nc",
-        "last_file": "mercatorglorys12v1_gl12_mean_20260220_R20260225.nc",
+        "file_count": 1283,
+        "representative_file": "mercatorglorys12v1_gl12_mean_20000101_R20000105.nc",
+        "first_file": "mercatorglorys12v1_gl12_mean_20000101_R20000105.nc",
+        "last_file": "mercatorglorys12v1_gl12_mean_20240726_R20240731.nc",
         "global_attrs": {
           "title": "daily mean fields from Global Ocean Physics Analysis and Forecast updated Daily",
           "easting": "longitude",
           "northing": "latitude",
-          "history": "2017/08/19 20:09:56 MERCATOR OCEAN Netcdf creation",
+          "history": "2017/05/29 22:40:48 MERCATOR OCEAN Netcdf creation",
           "source": "MERCATOR GLORYS12V1",
           "institution": "MERCATOR OCEAN",
           "references": "http://www.mercator-ocean.fr",
@@ -370,12 +370,12 @@
           "Conventions": "CF-1.4",
           "domain_name": "GL12",
           "field_type": "mean",
-          "field_date": "2010-01-01 00:00:00",
-          "field_julian_date": 21915.0,
+          "field_date": "2000-01-01 00:00:00",
+          "field_julian_date": 18262.0,
           "julian_day_unit": "days since 1950-01-01 00:00:00",
-          "forecast_range": "2-day_forecast",
+          "forecast_range": "3-day_forecast",
           "forecast_type": "hindcast",
-          "bulletin_date": "2010-01-06 00:00:00",
+          "bulletin_date": "2000-01-05 00:00:00",
           "bulletin_type": "operational",
           "longitude_min": -180.0,
           "longitude_max": 179.9166717529297,
@@ -404,8 +404,8 @@
               "standard_name": "sea_water_potential_temperature",
               "units": "degrees_C",
               "unit_long": "Degrees Celsius",
-              "valid_min": -32754,
-              "valid_max": 19721,
+              "valid_min": -32764,
+              "valid_max": 18468,
               "cell_methods": "area: mean"
             }
           },
@@ -423,7 +423,7 @@
               "units": "1e-3",
               "unit_long": "Practical Salinity Unit",
               "valid_min": 1,
-              "valid_max": 27001,
+              "valid_max": 27353,
               "cell_methods": "area: mean"
             }
           },
@@ -440,8 +440,8 @@
               "standard_name": "eastward_sea_water_velocity",
               "units": "m s-1",
               "unit_long": "Meters per second",
-              "valid_min": -3168,
-              "valid_max": 3110,
+              "valid_min": -3510,
+              "valid_max": 3894,
               "cell_methods": "area: mean"
             }
           },
@@ -458,8 +458,8 @@
               "standard_name": "northward_sea_water_velocity",
               "units": "m s-1",
               "unit_long": "Meters per second",
-              "valid_min": -3256,
-              "valid_max": 3567,
+              "valid_min": -3234,
+              "valid_max": 3332,
               "cell_methods": "area: mean"
             }
           },
@@ -475,8 +475,8 @@
               "standard_name": "sea_surface_height_above_geoid",
               "units": "m",
               "unit_long": "Meters",
-              "valid_min": -6349,
-              "valid_max": 5181,
+              "valid_min": -6382,
+              "valid_max": 4883,
               "cell_methods": "area: mean"
             }
           },
@@ -493,7 +493,7 @@
               "units": "m",
               "unit_long": "Meters",
               "valid_min": 1,
-              "valid_max": 12516,
+              "valid_max": 8881,
               "cell_methods": "area: mean"
             }
           },
@@ -509,8 +509,8 @@
               "standard_name": "sea_water_potential_temperature_at_sea_floor",
               "units": "degrees_C",
               "unit_long": "Degrees Celsius",
-              "valid_min": -32752,
-              "valid_max": 19810,
+              "valid_min": -32639,
+              "valid_max": 18498,
               "cell_methods": "area: mean"
             }
           },
@@ -527,7 +527,7 @@
               "units": "m",
               "unit_long": "Meters",
               "valid_min": 1,
-              "valid_max": 7672,
+              "valid_max": 8041,
               "cell_methods": "area: mean where sea_ice"
             }
           },
@@ -544,7 +544,7 @@
               "units": "1",
               "unit_long": "Fraction",
               "valid_min": 1,
-              "valid_max": 28027,
+              "valid_max": 28317,
               "cell_methods": "area: mean where sea_ice"
             }
           },
@@ -560,8 +560,8 @@
               "standard_name": "eastward_sea_ice_velocity",
               "units": "m s-1",
               "unit_long": "Meters per second",
-              "valid_min": -21266,
-              "valid_max": 28902,
+              "valid_min": -20539,
+              "valid_max": 32652,
               "cell_methods": "area: mean where sea_ice"
             }
           },
@@ -577,8 +577,8 @@
               "standard_name": "northward_sea_ice_velocity",
               "units": "m s-1",
               "unit_long": "Meters per second",
-              "valid_min": -32158,
-              "valid_max": 23067,
+              "valid_min": -32637,
+              "valid_max": 24967,
               "cell_methods": "area: mean where sea_ice"
             }
           },
@@ -591,8 +591,8 @@
               "long_name": "Time (hours since 1950-01-01)",
               "standard_name": "time",
               "calendar": "gregorian",
-              "valid_min": 525972.0,
-              "valid_max": 525972.0,
+              "valid_min": 438300.0,
+              "valid_max": 438300.0,
               "units": "hours since 1950-01-01 00:00:00",
               "axis": "T"
             }
@@ -651,9 +651,9 @@
         "provider": "Copernicus Marine Service / UK Met Office OSTIA",
         "product": "SST_GLO_SST_L4_REP_OBSERVATIONS_010_011",
         "role": "Daily analysed sea-surface temperature and mask fields sampled at profile points.",
-        "file_count": 5326,
-        "representative_file": "20100101120000-UKMO-L4_GHRSST-SSTfnd-OSTIA-GLOB_REP-v02.0-fv02.0.nc",
-        "first_file": "20100101120000-UKMO-L4_GHRSST-SSTfnd-OSTIA-GLOB_REP-v02.0-fv02.0.nc",
+        "file_count": 8979,
+        "representative_file": "20000101120000-UKMO-L4_GHRSST-SSTfnd-OSTIA-GLOB_REP-v02.0-fv02.0.nc",
+        "first_file": "20000101120000-UKMO-L4_GHRSST-SSTfnd-OSTIA-GLOB_REP-v02.0-fv02.0.nc",
         "last_file": "20240731120000-UKMO-L4_GHRSST-SSTfnd-OSTIA-GLOB_REP-v02.0-fv02.0.nc",
         "global_attrs": {
           "Conventions": "CF-1.4, ACDD-1.3",
@@ -669,11 +669,11 @@
           "uuid": "a2df4a18-6f19-4772-9532-39307a0e2794",
           "gds_version_id": "2.4",
           "netcdf_version_id": "4.1",
-          "date_created": "20190818T061207Z",
-          "start_time": "20100101T000000Z",
-          "time_coverage_start": "20100101T000000Z",
-          "stop_time": "20100102T000000Z",
-          "time_coverage_end": "20100102T000000Z",
+          "date_created": "20190813T064931Z",
+          "start_time": "20000101T000000Z",
+          "time_coverage_start": "20000101T000000Z",
+          "stop_time": "20000102T000000Z",
+          "time_coverage_end": "20000102T000000Z",
           "file_quality_level": 3,
           "Metadata_Conventions": "Unidata Observation Dataset v1.0",
           "metadata_link": "http://podaac.jpl.nasa.gov/ws/metadata/dataset?format=gcmd&shortName=UKMO-L4HRfnd-GLOB-OSTIA",
@@ -834,9 +834,9 @@
         "product": "SEALEVEL_GLO_PHY_L4_MY_008_047",
         "dataset_id": "cmems_obs-sl_glo_phy-ssh_my_allsat-l4-duacs-0.125deg_P1D",
         "role": "Daily sea-level, geostrophic current, and ice-flag fields sampled at profile points.",
-        "file_count": 5326,
-        "representative_file": "dt_global_allsat_phy_l4_20100101_20241016.nc",
-        "first_file": "dt_global_allsat_phy_l4_20100101_20241016.nc",
+        "file_count": 8979,
+        "representative_file": "dt_global_allsat_phy_l4_20000101_20241016.nc",
+        "first_file": "dt_global_allsat_phy_l4_20000101_20241016.nc",
         "last_file": "dt_global_allsat_phy_l4_20240731_20250429.nc",
         "global_attrs": {
           "Conventions": "CF-1.6",
@@ -861,8 +861,8 @@
           "standard_name_vocabulary": "NetCDF Climate and Forecast (CF) Metadata Convention Standard Name Table v37",
           "summary": "SSALTO/DUACS Delayed-Time Level-4 sea surface height and derived variables measured by multi-satellite altimetry observations over Global Ocean.",
           "title": "DT merged all satellites Global Ocean Gridded SSALTO/DUACS Sea Surface Height L4 product and derived variables",
-          "date_created": "2024-10-16T16:52:55Z",
-          "history": "2024-10-16 16:52:55Z: Creation",
+          "date_created": "2024-10-16T01:14:28Z",
+          "history": "2024-10-16 01:14:28Z: Creation",
           "geospatial_lat_max": 89.9375,
           "geospatial_lat_min": -89.9375,
           "geospatial_lat_resolution": 0.125,
@@ -878,9 +878,9 @@
           "geospatial_vertical_units": "m",
           "time_coverage_duration": "P1D",
           "time_coverage_resolution": "P1D",
-          "time_coverage_end": "2010-01-01T12:00:00Z",
-          "time_coverage_start": "2009-12-31T12:00:00Z",
-          "platform": "Jason-1 Interleaved, OSTM/Jason-2, Envisat"
+          "time_coverage_end": "2000-01-01T12:00:00Z",
+          "time_coverage_start": "1999-12-31T12:00:00Z",
+          "platform": "ERS-2, Topex/Poseidon, Geosat Follow On"
         },
         "dimensions": {
           "latitude": 1440,
@@ -1106,9 +1106,9 @@
         "product": "MULTIOBS_GLO_PHY_S_SURFACE_MYNRT_015_013",
         "dataset_id": "cmems_obs-mob_glo_phy-sss_my_multi_P1D",
         "role": "Daily sea-surface salinity, density, and sea-ice fields sampled at profile points.",
-        "file_count": 5326,
-        "representative_file": "dataset-sss-ssd-rep-daily_20100101T1200Z_P20241017T0000Z.nc",
-        "first_file": "dataset-sss-ssd-rep-daily_20100101T1200Z_P20241017T0000Z.nc",
+        "file_count": 8979,
+        "representative_file": "dataset-sss-ssd-rep-daily_20000101T1200Z_P20241017T0000Z.nc",
+        "first_file": "dataset-sss-ssd-rep-daily_20000101T1200Z_P20241017T0000Z.nc",
         "last_file": "dataset-sss-ssd-rep-daily_20240731T1200Z_P20260101T0000Z.nc",
         "global_attrs": {
           "Conventions": "CF-1.7",
@@ -1117,7 +1117,7 @@
           "institution": "CNR",
           "contact": "servicedesk.cmems@mercator-ocean.eu",
           "netcdf_version_id": "4.9.3-development of Jun  4 2023 14:13:36",
-          "creation_date": "Thu 17 Oct 2024 10:57:11",
+          "creation_date": "Thu 17 Oct 2024 10:53:20",
           "product_version": "1.1",
           "grid_resolution": "0.125 degrees",
           "software_version": "SSS/SSD HR Processor v1.1",
@@ -1247,5 +1247,8 @@
       "sealevel_tpa_correction": "The Copernicus source metadata marks this field as not implemented in the current product version, so values may be NaN."
     }
   },
-  "includes_geotiff_assets": true
+  "includes_geotiff_assets": true,
+  "license": "CC-BY-4.0",
+  "license_url": "https://creativecommons.org/licenses/by/4.0/",
+  "attribution_notice": "Use of this package should acknowledge DepthDif and the upstream EN4/ARGO, Copernicus Marine GLORYS, OSTIA, sea-level, and sea-surface-salinity products. See LICENSE for source-provider attribution and citation details."
 }

metadata/stac-item.json

@@ -5,7 +5,7 @@
   "bbox": [
     -999.99,
     -999.99,
-    179.99985,
+    179.999954,
     168.8678
   ],
   "geometry": {
@@ -17,11 +17,11 @@
           -999.99
         ],
         [
-          179.99985,
+          179.999954,
           -999.99
         ],
         [
-          179.99985,
+          179.999954,
           168.8678
         ],
         [
@@ -37,9 +37,12 @@
   },
   "properties": {
     "datetime": null,
-    "start_datetime": "2010-01-01",
+    "start_datetime": "2000-01-01",
     "end_datetime": "2024-07-31",
-    "created": "2026-05-21T06:26:40+00:00"
+    "created": "2026-06-02T16:56:29+00:00",
+    "license": "CC-BY-4.0",
+    "license_url": "https://creativecommons.org/licenses/by/4.0/",
+    "attribution": "Generated using E.U. Copernicus Marine Service Information and derived from EN4/ARGO, OSTIA, sea-level, and sea-surface-salinity source products. See LICENSE."
   },
   "assets": {
     "zarr": {

requirements-loader.txt

@@ -0,0 +1,9 @@
+numpy
+pandas
+pyarrow
+PyYAML
+rasterio
+torch
+tqdm
+xarray
+zarr