starman / code /layers /thermal_common.py
enzeeoai's picture
Publish verified Core native layers and full geomorphometry
a8e0542 verified
Raw History Blame Contribute Delete
27.2 kB
"""Helpers shared by the thermal & optical layers (tes_ti, tes_albedo, modis_lst, modis_albedo_ndvi,
modis_ati). Not a layer: it has no SOURCE and the driver never loads it by slug.
The layer modules list this file in ``CROSSWALKS`` so that a change here moves their code_version
(the driver hashes the module, itself and the CROSSWALKS files).
Contents
--------
* pixel geometry and NaN-aware bilinear sampling at a cell centroid (pixel-is-area rasters)
* MODIS scaling, fills, QC masks and UTC -> local solar time (constants are the T-A values)
* the 12-month climatology builder (download one granule, read it, apply QC, delete it)
* annual statistics from a 12-month stack, and the ATI formula
* percentile rank used by the ``ti_pct`` finalize passes
"""
from __future__ import annotations
import datetime as dt
import hashlib
import json
import math
import os
import shutil
import tempfile
import warnings
from pathlib import Path
import numpy as np
# --------------------------------------------------------------------------
# constants (T-A: data/raw/earth/thermal_optical_sources.json)
# --------------------------------------------------------------------------
YEARS = (2017, 2018, 2019, 2020, 2021)
CLIM_TAG = 'clim_2017_2021'
LST_SCALE = 0.02 # K per DN; fill 0, valid range >= 7500
LST_MIN_DN = 7500
LAND_PCT_MIN = 1 # Percent_land_in_grid valid 1..100, fill 0
VIEW_SCALE = 0.2 # hours (UTC) per DN; valid 0..120, fill 255
VIEW_MAX_DN = 120
NDVI_DIVISOR = 10000.0 # the "scale_factor" of 10000 is a divisor
NDVI_FILL = -3000
NDVI_VALID = (-2000, 10000)
NDVI_RELIABILITY_OK = (0, 1) # 0 good, 1 marginal; 2 snow/ice, 3 cloudy, 4 estimated, -1 fill
ALBEDO_SCALE = 0.001 # fill 32767, valid 0..32766
ALBEDO_FILL = 32767
ALBEDO_QUALITY_MAX = 2 # 0 best, 1 good, 2 relatively good; 3.. and 255 dropped
SNOW_MAX_VALID = 254 # Percent_Snow valid 0..254, fill 255
# thresholds of the derived columns (stored in the SOURCE of the layers that use them)
SNOW_MONTH_PCT = 10.0 # a monthly climatology value >= this Percent_Snow is a snow month
MIN_DELTA_T_K = 5.0 # months with LSTday - LSTnight below this give no ATI
BARE_NDVI_MAX = 0.20
BARE_SNOW_FRAC_MAX = 0.5
MODIS_DOI = {'MYD11C3': '10.5067/MODIS/MYD11C3.061', 'MYD13C2': '10.5067/MODIS/MYD13C2.061',
'MCD43C3': '10.5067/MODIS/MCD43C3.061'}
# --------------------------------------------------------------------------
# pixel geometry and sampling
# --------------------------------------------------------------------------
def pixel_rc(lat, lon, height: int, width: int):
"""Row and column of the pixel holding (lat, lon) in a global north-up raster whose corner
extents are -180..180 / 90..-90: ``row = floor((90 - lat) / dlat)``, ``col = floor((lon + 180) / dlon)``.
For 7200x3600 that is ``floor((90 - lat) * 20)`` and ``floor((lon + 180) * 20)``."""
lat = np.asarray(lat, dtype=np.float64)
lon = np.asarray(lon, dtype=np.float64)
row = np.floor((90.0 - lat) * height / 180.0).astype(np.int64)
col = np.floor((lon + 180.0) * width / 360.0).astype(np.int64)
return np.clip(row, 0, height - 1), np.clip(col, 0, width - 1)
def pixel_centre_lat(row, height: int):
return 90.0 - (np.asarray(row, dtype=np.float64) + 0.5) * 180.0 / height
def pixel_centre_lon(col, width: int):
return -180.0 + (np.asarray(col, dtype=np.float64) + 0.5) * 360.0 / width
def nearest_at(grid, lat, lon):
row, col = pixel_rc(lat, lon, *grid.shape)
return grid[row, col]
def bilinear_at(grid, lat, lon):
"""NaN-aware bilinear sample of a global pixel-is-area raster at (lat, lon) points.
Pixel centres are at index + 0.5, so the point's fractional pixel coordinate is
``x = (lon + 180) / dlon - 0.5``. NaN neighbours are dropped and the remaining weights
renormalised; longitude wraps, rows clamp at the poles.
Returns ``(value, interp_flag, valid_weight)``: ``valid_weight`` is the total bilinear weight on
finite neighbours (1 = all four, 0 = none, value NaN); ``interp_flag`` is True when a neighbour with
weight was NaN, so the value was interpolated from the rest.
"""
grid = np.asarray(grid)
h, w = grid.shape
lat = np.atleast_1d(np.asarray(lat, dtype=np.float64))
lon = np.atleast_1d(np.asarray(lon, dtype=np.float64))
y = (90.0 - lat) * h / 180.0 - 0.5
x = (lon + 180.0) * w / 360.0 - 0.5
y0 = np.floor(y).astype(np.int64)
x0 = np.floor(x).astype(np.int64)
fy, fx = y - y0, x - x0
acc = np.zeros(lat.shape)
wsum = np.zeros(lat.shape)
missing = np.zeros(lat.shape, dtype=bool)
for dy, wy in ((0, 1.0 - fy), (1, fy)):
r = np.clip(y0 + dy, 0, h - 1)
for dx, wx in ((0, 1.0 - fx), (1, fx)):
c = (x0 + dx) % w
v = grid[r, c].astype(np.float64)
wt = wy * wx
ok = np.isfinite(v)
acc += np.where(ok, v * wt, 0.0)
wsum += np.where(ok, wt, 0.0)
missing |= (~ok) & (wt > 1e-12)
value = np.where(wsum > 1e-12, acc / np.where(wsum > 1e-12, wsum, 1.0), np.nan)
return value, missing & (wsum > 1e-12), np.clip(wsum, 0.0, 1.0)
def sample_many(rasters: dict, names, lat, lon) -> dict:
"""``bilinear_at`` for several rasters: name -> (value, interp_flag, valid_weight)."""
return {n: bilinear_at(rasters[n], lat, lon) for n in names}
def round_count(value):
"""NaN-aware bilinear of a count -> integer month count (0 where there is no data)."""
return np.where(np.isfinite(value), np.rint(np.nan_to_num(value)), 0).astype(np.int8)
# --------------------------------------------------------------------------
# percentile statistics
# --------------------------------------------------------------------------
def sorted_percentiles(values, qs):
"""Row-wise NaN-aware percentiles (numpy's default linear method) of a 2-D array, vectorised.
``values`` is (n_cells, n_samples) with NaN for no data; returns a list of arrays, one per q in
``qs`` (0-100), NaN for rows with no finite sample. Works without a Python loop over cells.
"""
values = np.asarray(values, dtype=np.float64)
srt = np.sort(values, axis=1) # NaN sorts last
n = np.isfinite(values).sum(axis=1)
rows = np.arange(values.shape[0])
out = []
for q in qs:
pos = np.maximum(n - 1, 0) * (q / 100.0)
lo = np.floor(pos).astype(np.int64)
hi = np.minimum(lo + 1, np.maximum(n - 1, 0))
frac = pos - lo
a = srt[rows, np.minimum(lo, values.shape[1] - 1)] if values.shape[1] else np.full(len(rows), np.nan)
b = srt[rows, np.minimum(hi, values.shape[1] - 1)] if values.shape[1] else a
out.append(np.where(n > 0, a + (b - a) * frac, np.nan))
return out
def percentile_rank(values, reference):
"""Mid-rank percentile (0-100, ties share the average rank) of ``values`` within the finite
entries of ``reference``. Monotone non-decreasing in ``values``; NaN where ``values`` is NaN or the
reference is empty."""
values = np.asarray(values, dtype=np.float64)
ref = np.sort(np.asarray(reference, dtype=np.float64)[np.isfinite(reference)])
if not len(ref):
return np.full(values.shape, np.nan)
lo = np.searchsorted(ref, values, side='left')
hi = np.searchsorted(ref, values, side='right')
pct = 100.0 * (lo + hi) / (2.0 * len(ref))
return np.where(np.isfinite(values), pct, np.nan)
def join_flags(n: int, **masks) -> list[str]:
"""``quality_flags`` strings: the names of the true masks joined by ';' (driver convention)."""
names = list(masks)
arrays = [np.asarray(masks[k], dtype=bool) for k in names]
return [';'.join(names[j] for j in range(len(names)) if arrays[j][i]) for i in range(n)]
def split_flags(flags) -> list[set]:
return [set(p for p in (f or '').split(';') if p) for f in flags]
# --------------------------------------------------------------------------
# MODIS scaling, fills, QC
# --------------------------------------------------------------------------
def scale_lst(dn, land_pct=None):
"""MYD11C3 LST DN -> K (DN x 0.02). Fill 0 and DN < 7500 -> NaN; with ``land_pct`` also needs
Percent_land_in_grid >= 1. No QC_Day/QC_Night bits are used (their legend is unverified)."""
dn = np.asarray(dn)
ok = dn >= LST_MIN_DN
if land_pct is not None:
ok &= np.asarray(land_pct) >= LAND_PCT_MIN
return np.where(ok, dn.astype(np.float32) * np.float32(LST_SCALE), np.float32(np.nan))
def scale_view_time(dn):
"""MYD11C3 view time DN -> hours UTC (DN x 0.2). Fill 255 (valid 0..120) -> NaN."""
dn = np.asarray(dn)
return np.where(dn <= VIEW_MAX_DN, dn.astype(np.float32) * np.float32(VIEW_SCALE), np.float32(np.nan))
def utc_to_local_solar(hours_utc, lon_deg):
"""Local mean solar hours: ``(UTC + lon / 15) mod 24``, lon east-positive degrees (broadcasts)."""
return np.mod(np.asarray(hours_utc, dtype=np.float32) + np.asarray(lon_deg, dtype=np.float32) / 15.0,
np.float32(24.0))
def scale_ndvi(dn, reliability):
"""MYD13C2 NDVI DN -> NDVI (DN / 10000). Fill -3000 and reliability other than 0 or 1 -> NaN."""
dn = np.asarray(dn)
rel = np.asarray(reliability)
ok = (dn != NDVI_FILL) & (dn >= NDVI_VALID[0]) & (dn <= NDVI_VALID[1])
ok &= (rel >= NDVI_RELIABILITY_OK[0]) & (rel <= NDVI_RELIABILITY_OK[1])
return np.where(ok, dn.astype(np.float32) / np.float32(NDVI_DIVISOR), np.float32(np.nan))
def scale_albedo(dn, quality):
"""MCD43C3 white-sky albedo DN -> albedo (DN x 0.001). Fill 32767 and Albedo_Quality > 2 (3+, 255) -> NaN."""
dn = np.asarray(dn)
ok = (dn != ALBEDO_FILL) & (dn >= 0) & (np.asarray(quality) <= ALBEDO_QUALITY_MAX)
return np.where(ok, dn.astype(np.float32) * np.float32(ALBEDO_SCALE), np.float32(np.nan))
def scale_snow(dn):
"""MCD43C3 Percent_Snow: valid 0..254, fill 255 -> NaN."""
dn = np.asarray(dn)
return np.where(dn <= SNOW_MAX_VALID, dn.astype(np.float32), np.float32(np.nan))
# --------------------------------------------------------------------------
# climatology builder
# --------------------------------------------------------------------------
class MonthAccumulator:
"""Per-pixel accumulation of one calendar month over the years, for named variables.
``linear`` variables are averaged; ``circular24`` variables (local solar hours) use the circular
mean on a 24 h clock so 23.8 h and 0.2 h average to 0.0 h, not 12 h; ``any`` variables are OR-ed
booleans (land masks). float32 sums are plenty for five values of ~300 K.
"""
def __init__(self, shape):
self.shape = tuple(shape)
self.kind: dict[str, str] = {}
self._a: dict[str, np.ndarray] = {}
self._b: dict[str, np.ndarray] = {}
self._n: dict[str, np.ndarray] = {}
def _slot(self, name, kind):
if name not in self.kind:
self.kind[name] = kind
if kind == 'any':
self._a[name] = np.zeros(self.shape, dtype=bool)
else:
self._a[name] = np.zeros(self.shape, dtype=np.float32)
self._n[name] = np.zeros(self.shape, dtype=np.uint8)
if kind == 'circular24':
self._b[name] = np.zeros(self.shape, dtype=np.float32)
elif self.kind[name] != kind:
raise ValueError(f'{name} is {self.kind[name]}, not {kind}')
def add_linear(self, name, arr):
self._slot(name, 'linear')
ok = np.isfinite(arr)
np.add(self._a[name], arr, out=self._a[name], where=ok)
self._n[name] += ok
def add_circular24(self, name, hours):
self._slot(name, 'circular24')
ok = np.isfinite(hours)
ang = np.where(ok, hours, 0.0).astype(np.float32) * np.float32(2 * math.pi / 24.0)
self._a[name] += np.where(ok, np.sin(ang), 0).astype(np.float32)
self._b[name] += np.where(ok, np.cos(ang), 0).astype(np.float32)
self._n[name] += ok
def add_any(self, name, mask):
self._slot(name, 'any')
self._a[name] |= np.asarray(mask, dtype=bool)
def counts(self, name):
return self._n[name]
def results(self) -> dict:
"""name -> float32 array (NaN where nothing was seen) or uint8 0/1 for ``any`` variables."""
out = {}
for name, kind in self.kind.items():
if kind == 'any':
out[name] = self._a[name].astype(np.uint8)
continue
n = self._n[name]
with np.errstate(invalid='ignore', divide='ignore'):
if kind == 'linear':
val = self._a[name] / n
else:
ang = np.arctan2(self._a[name], self._b[name])
val = np.mod(ang, 2 * math.pi) * (24.0 / (2 * math.pi))
out[name] = np.where(n > 0, val, np.nan).astype(np.float32)
return out
def clim_path(folder, var: str) -> Path:
return Path(folder) / f'{var}_{CLIM_TAG}.tif'
class ClimWriter:
"""One 12-band GeoTIFF per variable (band m = calendar month m), deflate, tiled, written a month at a time."""
def __init__(self, folder, variables: dict, shape, resume: bool = False):
import rasterio
from rasterio.transform import from_origin
self.folder = Path(folder)
self.folder.mkdir(parents=True, exist_ok=True)
h, w = shape
transform = from_origin(-180.0, 90.0, 360.0 / w, 180.0 / h)
self.files = {}
for var, dtype in variables.items():
path = clim_path(self.folder, var)
if resume and path.exists():
self.files[var] = rasterio.open(path, 'r+')
continue
kwargs = dict(driver='GTiff', height=h, width=w, count=12, dtype=dtype, crs='EPSG:4326',
transform=transform, compress='deflate', tiled=True, blockxsize=256,
blockysize=256, interleave='band')
if np.dtype(dtype).kind == 'f':
kwargs.update(nodata=float('nan'), predictor=3)
self.files[var] = rasterio.open(path, 'w', **kwargs)
def write_month(self, month: int, arrays: dict) -> None:
for var, f in self.files.items():
f.write(arrays[var].astype(f.dtypes[0]), month)
def close(self) -> None:
for f in self.files.values():
f.close()
def month_spec(short_name: str, year: int, month: int, *, daily_day: int | None = None,
version: str = '061') -> dict:
"""One granule to fetch. Monthly products (MYD11C3, MYD13C2) are dated by the first of the month,
MCD43C3 (daily, 16-day window) by ``daily_day`` of the month."""
day = daily_day or 1
d = dt.date(year, month, day)
return {'short_name': short_name, 'version': version, 'year': year, 'month': month,
'doy': d.timetuple().tm_yday, 'date': d.isoformat(),
'end': (d + dt.timedelta(days=1 if daily_day else 27)).isoformat()}
_EA_READY = False
def earthaccess_download(spec: dict, dest) -> Path:
"""Download the one granule ``spec`` names into ``dest`` (whole granule; no OPeNDAP)."""
global _EA_READY
import earthaccess
if not _EA_READY:
for strategy in ('environment', 'netrc'):
try:
if earthaccess.login(strategy=strategy):
_EA_READY = True
break
except Exception:
continue
if not _EA_READY:
raise RuntimeError('earthaccess login failed: set EARTHDATA_USERNAME/PASSWORD or ~/.netrc')
results = earthaccess.search_data(short_name=spec['short_name'], version=spec['version'],
temporal=(spec['date'], spec['end']))
token = f".A{spec['year']}{spec['doy']:03d}."
hits = [r for r in results if token in str(r['umm'].get('GranuleUR', r))]
if len(hits) != 1:
raise RuntimeError(f"{spec['short_name']} {spec['date']}: expected 1 granule {token}, found {len(hits)}")
files = earthaccess.download(hits, str(dest))
if not files:
raise RuntimeError(f"{spec['short_name']} {spec['date']}: earthaccess downloaded nothing")
return Path(files[0])
def read_hdf4(path, names) -> dict:
"""Read raw (unscaled) SDS arrays from an HDF4 granule with pyhdf. Imported here so the layer
modules still load where pyhdf is missing."""
from pyhdf.SD import SD, SDC
sd = SD(str(path), SDC.READ)
try:
return {n: np.asarray(sd.select(n).get()) for n in names}
finally:
sd.end()
def read_granule(spec, *, download, read, sds_names, workdir, log=print, provenance=None):
"""Download one granule into its own folder under ``workdir``, read it, delete it.
The folder is removed even when the download or the read fails, so ``workdir`` is empty between
granules. Returns ``(data, nbytes)``; ``nbytes`` is what was read from the network (file size)."""
Path(workdir).mkdir(parents=True, exist_ok=True)
tmp = tempfile.mkdtemp(prefix='granule-', dir=workdir)
try:
path = Path(download(spec, tmp))
nbytes = path.stat().st_size
if provenance is not None:
with path.open('rb') as stream:
provenance.update(filename=path.name, sha256=hashlib.file_digest(stream, 'sha256').hexdigest(),
version=spec['version'])
data = read(path, sds_names)
log(f" {spec['short_name']} {spec['date']}: {path.name} {nbytes} bytes read")
return data, nbytes
finally:
shutil.rmtree(tmp, ignore_errors=True)
def default_workdir() -> Path:
base = os.environ.get('STARMAN_MODIS_TMP')
return Path(tempfile.mkdtemp(prefix='starman-modis-', dir=base))
def build_climatology(out_dir, *, variables: dict, specs_by_month: dict, shape, handle, sds_for,
download, read, workdir, log=print, after_month=None) -> dict:
"""Build the 12-month climatology GeoTIFFs for one layer, a calendar month at a time.
``variables`` name -> numpy dtype of its GeoTIFF
``specs_by_month`` {1..12: [granule spec, ...]} (all years, all products the layer reads)
``handle(spec, data, acc)`` applies scaling and QC and adds to the MonthAccumulator
``sds_for(spec)`` the SDS names to read for that granule
Resumable at month level through ``climatology_progress.json``. Returns the progress dict
(granules with bytes read, ``complete``).
"""
out_dir = Path(out_dir)
out_dir.mkdir(parents=True, exist_ok=True)
pfile = out_dir / 'climatology_progress.json'
progress = json.loads(pfile.read_text()) if pfile.exists() else {'months_done': [], 'granules': []}
expected = [(g['short_name'], g['date'], g['version']) for m in progress['months_done']
for g in specs_by_month.get(m, ())]
recorded = [(g['product'], g['date'], g.get('version', '061')) for g in progress['granules']]
if expected != recorded or any(m not in specs_by_month for m in progress['months_done']):
raise ValueError(f'MODIS source dates or versions differ from {pfile}; use a separate interim directory')
files_ok = all(clim_path(out_dir, v).exists() for v in variables)
if not files_ok:
progress = {'months_done': [], 'granules': []}
if progress.get('complete'):
return progress
writer = ClimWriter(out_dir, variables, shape, resume=bool(progress['months_done']))
try:
for month in sorted(specs_by_month):
if month in progress['months_done']:
continue
acc = MonthAccumulator(shape)
for spec in specs_by_month[month]:
provenance = {}
data, nbytes = read_granule(spec, download=download, read=read, sds_names=sds_for(spec),
workdir=workdir, log=log, provenance=provenance)
handle(spec, data, acc)
del data
progress['granules'].append({'product': spec['short_name'], 'date': spec['date'],
'bytes': nbytes, **provenance})
writer.write_month(month, acc.results())
progress['months_done'].append(month)
pfile.write_text(json.dumps(progress))
if after_month:
after_month(month, progress)
finally:
writer.close()
progress['complete'] = len(progress['months_done']) == len(specs_by_month)
progress['bytes_read_total'] = sum(g['bytes'] for g in progress['granules'])
pfile.write_text(json.dumps(progress))
return progress
def granule_checksum(progress: dict) -> str:
granules = progress['granules']
if all(g.get('sha256') for g in granules):
inputs = sorted((g['product'], g['version'], g['date'], g['sha256']) for g in granules)
label = 'granule-content-list-sha256'
else:
inputs = sorted((g['product'], g['date'], g['bytes']) for g in granules)
label = 'granule-inventory-sha256'
return f'{label}:' + hashlib.sha256(json.dumps(inputs).encode()).hexdigest()
# --------------------------------------------------------------------------
# annual statistics from 12-month stacks (axis 0 = calendar month)
# --------------------------------------------------------------------------
def _quiet():
return warnings.catch_warnings()
def nan_reduce(fn, stack):
with warnings.catch_warnings():
warnings.simplefilter('ignore', RuntimeWarning)
return fn(stack, axis=0)
def circular_mean_hours(stack):
ok = np.isfinite(stack)
ang = np.where(ok, stack, 0.0) * (2 * math.pi / 24.0)
s = np.where(ok, np.sin(ang), 0).sum(axis=0)
c = np.where(ok, np.cos(ang), 0).sum(axis=0)
hours = np.mod(np.arctan2(s, c), 2 * math.pi) * (24.0 / (2 * math.pi))
return np.where(ok.any(axis=0), hours, np.nan).astype(np.float32)
def lst_annual(day, night, day_view=None, night_view=None) -> dict:
"""Annual statistics from the 12-month LST climatology (K).
``lst_day_K`` / ``lst_night_K`` mean over the months valid for that variable
``lst_day_max_K`` / ``lst_night_min_K`` warmest monthly day value, coldest monthly night value
``lst_diurnal_K`` mean over months of (day - night), months with both
``lst_seasonal_range_K`` peak-to-peak range of the paired monthly (day + night) / 2 values
``lst_seasonal_amp_K`` half that range; both require at least two paired months
``n_months_valid`` months with both day and night LST
``lst_day_view_h`` / ``lst_night_view_h`` circular mean local solar view time (h)
"""
both = np.isfinite(day) & np.isfinite(night)
dm = np.where(both, day, np.nan)
nm = np.where(both, night, np.nan)
mean_t = (dm + nm) / 2.0
n_months = both.sum(axis=0)
seasonal_range = np.where(n_months >= 2, nan_reduce(np.nanmax, mean_t) - nan_reduce(np.nanmin, mean_t),
np.nan)
out = {
'lst_day_K': nan_reduce(np.nanmean, day),
'lst_night_K': nan_reduce(np.nanmean, night),
'lst_day_max_K': nan_reduce(np.nanmax, day),
'lst_night_min_K': nan_reduce(np.nanmin, night),
'lst_diurnal_K': nan_reduce(np.nanmean, dm - nm),
'lst_seasonal_range_K': seasonal_range,
'lst_seasonal_amp_K': seasonal_range / 2.0,
'n_months_valid': n_months.astype(np.float32),
}
if day_view is not None:
out['lst_day_view_h'] = circular_mean_hours(day_view)
if night_view is not None:
out['lst_night_view_h'] = circular_mean_hours(night_view)
return {k: np.asarray(v, dtype=np.float32) for k, v in out.items()}
def albedo_ndvi_annual(albedo, snow, ndvi, snow_month_pct: float = SNOW_MONTH_PCT) -> dict:
"""Annual statistics from the 12-month albedo / snow / NDVI climatology.
``albedo`` median over snow-free months (Percent_Snow known and < ``snow_month_pct``)
``albedo_snow_frac`` share of months with a snow value that are snow months
``ndvi_max`` / ``ndvi_mean`` over months with a valid NDVI
"""
snow_known = np.isfinite(snow)
free = snow_known & (snow < snow_month_pct)
alb = nan_reduce(np.nanmedian, np.where(free & np.isfinite(albedo), albedo, np.nan))
n_known = snow_known.sum(axis=0)
frac = np.where(n_known > 0, (snow_known & ~free).sum(axis=0) / np.maximum(n_known, 1), np.nan)
return {'albedo': alb.astype(np.float32), 'albedo_snow_frac': frac.astype(np.float32),
'ndvi_max': nan_reduce(np.nanmax, ndvi).astype(np.float32),
'ndvi_mean': nan_reduce(np.nanmean, ndvi).astype(np.float32)}
def ati_months(day, night, albedo, snow) -> dict:
"""Apparent thermal inertia per pixel: ``ATI_m = (1 - albedo_m) / (LSTday_m - LSTnight_m)`` (1/K) for
calendar months with known zero snow, an albedo in [0, 1], and a diurnal range of at least 5 K.
Returns ``ati_inv_K`` (median over valid months), ``ati_n_months`` and the counts of months that
had data but were dropped for snow (``n_snow``) or a small range (``n_small_dT``).
"""
dT = day - night
data = np.isfinite(day) & np.isfinite(night) & np.isfinite(albedo) & np.isfinite(snow)
data &= (albedo >= 0.0) & (albedo <= 1.0)
snowy = data & (snow != 0)
small = data & ~snowy & (dT < MIN_DELTA_T_K)
valid = data & ~snowy & ~small
with np.errstate(invalid='ignore', divide='ignore'):
ati = np.where(valid, (1.0 - albedo) / dT, np.nan)
return {'ati_inv_K': nan_reduce(np.nanmedian, ati).astype(np.float32),
'ati_n_months': valid.sum(axis=0).astype(np.float32),
'n_snow': snowy.sum(axis=0).astype(np.float32),
'n_small_dT': small.sum(axis=0).astype(np.float32)}
def derive_rasters(paths: dict, func, chunk_rows: int = 240) -> dict:
"""Run ``func`` over row chunks of 12-band climatology GeoTIFFs.
``paths`` {name: tif path}; ``func({name: (12, h, w) array}) -> {out: (h, w) array}``. Chunking keeps
memory at a few hundred MB instead of the whole 12 x 3600 x 7200 stacks. Returns full rasters.
"""
import rasterio
from rasterio.windows import Window
srcs = {k: rasterio.open(p) for k, p in paths.items()}
try:
first = next(iter(srcs.values()))
h, w = first.height, first.width
for k, s in srcs.items():
if (s.height, s.width) != (h, w):
raise ValueError(f'{k}: grid {s.height}x{s.width} differs from {h}x{w}')
out: dict = {}
for r0 in range(0, h, chunk_rows):
r1 = min(h, r0 + chunk_rows)
stacks = {}
for k, s in srcs.items():
a = s.read(window=Window(0, r0, w, r1 - r0))
stacks[k] = a.astype(np.float32) if a.dtype.kind == 'f' else a
res = func(stacks)
for name, arr in res.items():
if name not in out:
out[name] = np.empty((h, w), dtype=arr.dtype)
out[name][r0:r1] = arr
return out
finally:
for s in srcs.values():
s.close()