"""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)