starman / code /layers /swim2.py
enzeeoai's picture
Publish verified Core native layers and full geomorphometry
a8e0542 verified
Raw History Blame Contribute Delete
8.34 kB
"""SWIM 2.0 ice-consistency maps -> per-cell `ice_consistency*` and `ice_frac` (planet mars).
SWIM consistency fraction is distinct from Earth permafrost extent. The rasters (7200 x 2400, equidistant cylindrical on a
3,396,190 m sphere) are already -180..180 east-positive, so there is no roll; the first column is
centred at about -180.05 deg, so pixel centres are wrapped modulo 360 before they are assigned to cells.
Each raster window is read from the local file; nothing is downloaded.
Columns
-------
ice_consistency_0_1m / _1_5m / _gt5m cell mean of the c0_1 / c1_5 / c_5 map (-1..+1; +1 consistent with ice)
ice_consistency cell mean of max(c0_1, c1_5): ice within the top ~5 m
ice_frac share of valid pixels with max(c0_1, c1_5) > ICE_THRESHOLD
n_px, valid_frac pixels assigned to the cell; share of them valid in all used maps
"""
from __future__ import annotations
from pathlib import Path
import numpy as np
import pyarrow as pa
from . import _climatology as clim
from . import _cellmap as cm
SOURCE = {
'product': 'Subsurface Water Ice Mapping (SWIM) 2.0 data products',
'version': 'SWIM 2.0 (Dec 2020 - Feb 2021 files)',
'url': 'https://swim.psi.edu/SWIM2Products.php',
'licence': 'No licence text on swim.psi.edu; non-commercial use accepted (Enzo, 2026-11-13).',
'planet': 'mars',
}
VERSION = 'v0.1'
MISSING_FLAG = 'outside_coverage' # groups with no raster rows: every cell is poleward of 60 deg
MARS_RADIUS_M = 3396190.0
LAT_LIMIT_DEG = 60.0
NODATA = -100.0
DEPTH_FILES = {'c0_1': 'SWIM2_c0_1.tif', 'c1_5': 'SWIM2_c1_5.tif', 'c_5': 'SWIM2_c_5.tif'}
ICE_DEPTH_MAPS = ('c0_1', 'c1_5') # "ice within the top ~5 m"; config constant
ICE_THRESHOLD = 0.0 # ice_frac counts pixels with the combined value above this
_C = {'dtype': 'float32', 'unit': '1', 'comparison': 'within_planet'}
COLUMNS = {
'ice_consistency_0_1m': {**_C, 'description': 'SWIM 2.0 combined ice consistency, depth 0-1 m '
'(-1 no ice .. +1 ice), cell mean'},
'ice_consistency_1_5m': {**_C, 'description': 'SWIM 2.0 combined ice consistency, depth 1-5 m, cell mean'},
'ice_consistency_gt5m': {**_C, 'description': 'SWIM 2.0 combined ice consistency, depth > 5 m, cell mean'},
'ice_consistency': {**_C, 'description': 'cell mean of max(0-1 m, 1-5 m) consistency: ice within the '
'top ~5 m. Scale -1..+1, not comparable with Earth ice_frac'},
'ice_frac': {'dtype': 'float32', 'unit': '1', 'comparison': 'planet_specific',
'description': 'fraction of valid pixels whose max(0-1 m, 1-5 m) consistency is > 0 '
'(positive modeled ice consistency within ~5 m; not permafrost area fraction)'},
'n_px': {'dtype': 'int32', 'unit': 'count', 'comparison': 'within_planet', 'fill': 0,
'description': 'raster pixels whose centre lies in the cell'},
'valid_frac': {'dtype': 'float32', 'unit': '1', 'comparison': 'within_planet', 'fill': 0.0,
'description': 'share of those pixels that are valid (not -100 / non-finite) in the used maps'},
}
LIMITATIONS = [
'SWIM 2.0 spans +-60 deg latitude only; cells poleward are NaN with outside_coverage.',
'The documented +1 km areoid elevation cutoff is not encoded as nodata; whether highlands are '
'masked is unchecked (K-C compares c-map values against elevation above 1000 m).',
'ice_consistency* is a -1..+1 consistency score (not a fraction); ice_frac counts pixels with '
'max(0-1 m, 1-5 m) > 0, a presence measure, so it is only loosely comparable with Earth permafrost area fraction.',
'Pixels are ~3 km, so a 5 km cell holds only a few; n_px and valid_frac are stored.',
'No licence text was found; non-commercial research use only.',
]
def clean(values) -> np.ndarray:
"""NaN for the declared nodata (-100) and for non-finite values."""
v = np.asarray(values, dtype=np.float64)
return np.where(np.isfinite(v) & (v != NODATA), v, np.nan)
def pixel_lonlat(transform, rows, cols, radius_m: float = MARS_RADIUS_M):
"""Pixel-centre (lon, lat) in degrees for 1-D ``rows`` x ``cols`` (meshgrid, shape rows x cols)."""
x = transform.c + (np.asarray(cols) + 0.5) * transform.a
y = transform.f + (np.asarray(rows) + 0.5) * transform.e
lon = np.degrees(x / radius_m)
lat = np.degrees(y / radius_m)
return np.meshgrid(lon, lat)
def cell_stats(rows_idx, maps: dict[str, np.ndarray], n_cells: int) -> dict[str, np.ndarray]:
"""Per-cell columns from pixel arrays (same shape as ``rows_idx``; ``rows_idx`` < 0 means not in the group)."""
clean_maps = {k: clean(v) for k, v in maps.items()}
out: dict[str, np.ndarray] = {}
for key, name in (('c0_1', 'ice_consistency_0_1m'), ('c1_5', 'ice_consistency_1_5m'),
('c_5', 'ice_consistency_gt5m')):
out[name], _ = cm.cell_mean(rows_idx, clean_maps[key], n_cells)
used = np.stack([clean_maps[k] for k in ICE_DEPTH_MAPS])
ok = np.all(np.isfinite(used), axis=0)
combined = np.where(ok, np.max(np.where(np.isfinite(used), used, -np.inf), axis=0), np.nan)
out['ice_consistency'], n_ok = cm.cell_mean(rows_idx, combined, n_cells)
ice, _ = cm.cell_mean(rows_idx, np.where(ok, (combined > ICE_THRESHOLD).astype(float), np.nan), n_cells)
out['ice_frac'] = ice
n_px = cm.cell_count(rows_idx, n_cells)
out['n_px'] = n_px
with np.errstate(invalid='ignore', divide='ignore'):
out['valid_frac'] = np.where(n_px > 0, n_ok / n_px, 0.0)
return out
def plan(band_group, ctx):
south, north = cm.lat_window(ctx.grid, ctx.bands)
if south >= LAT_LIMIT_DEG or north <= -LAT_LIMIT_DEG:
return []
return [{'key': f'swim2_{k}', 'url': str(Path(ctx.raw_dir) / f), 'method': 'local'}
for k, f in DEPTH_FILES.items()]
def read_window(path, south: float, north: float):
"""The raster rows covering ``south``..``north`` degrees: ``(array, transform, row0)``."""
import rasterio
from rasterio.windows import Window
with rasterio.open(path) as src:
t = src.transform
top = np.degrees(t.f / MARS_RADIUS_M)
step = np.degrees(-t.e / MARS_RADIUS_M)
r0 = max(0, int(np.floor((top - north) / step)) - 1)
r1 = min(src.height, int(np.ceil((top - south) / step)) + 1)
if r1 <= r0:
return None, t, 0
data = src.read(1, window=Window(0, r0, src.width, r1 - r0))
return data, t, r0
def reduce(band_group, items, ctx):
cells = ctx.cells(band_group)
south, north = cm.lat_window(ctx.grid, ctx.bands)
maps, transform, row0 = {}, None, 0
for fetched in items:
key = fetched.key.removeprefix('swim2_')
maps[key], transform, row0 = read_window(fetched.path, south, north)
return build_rows(ctx.grid, ctx.bands, cells, maps, transform, row0)
def build_rows(grid, bands, cells, maps, transform, row0) -> pa.Table:
n = len(cells)
lat_c = cells['center_lat'].to_numpy(zero_copy_only=False)
any_map = next(iter(maps.values()), None)
if any_map is None:
stats = cell_stats(np.zeros(0, dtype=np.int64), {k: np.zeros(0) for k in ('c0_1', 'c1_5', 'c_5')}, n)
else:
nrows, ncols = any_map.shape
lon, lat = pixel_lonlat(transform, np.arange(row0, row0 + nrows), np.arange(ncols))
rows_idx = cm.group_rows(grid, bands, lat, lon).ravel()
stats = cell_stats(rows_idx, {k: v.ravel() for k, v in maps.items()}, n)
outside = np.abs(lat_c) > LAT_LIMIT_DEG
flags = clim.Flags(n)
flags.add(outside, 'outside_coverage')
no_pixels = ~outside & (stats['valid_frac'] <= 0)
flags.add(no_pixels, 'no_source')
data = {'region_id': cells['region_id']}
for name in ('ice_consistency_0_1m', 'ice_consistency_1_5m', 'ice_consistency_gt5m',
'ice_consistency', 'ice_frac'):
data[name] = pa.array(np.where(outside, np.nan, stats[name]).astype(np.float32))
data['n_px'] = pa.array(np.where(outside, 0, stats['n_px']).astype(np.int32))
data['valid_frac'] = pa.array(np.where(outside, 0.0, stats['valid_frac']).astype(np.float32))
data['quality_flags'] = pa.array(flags.strings(), type=pa.string())
return pa.table(data)