Datasets:
Download code/layers/thermal_common.py from enzeeoai/starman: direct link, hf CLI and curl.
- Browser
- Download file 27.2 kB
-
https://huggingface.co/datasets/enzeeoai/starman/resolve/main/code/layers/thermal_common.py
- Command line
-
hf download hf://datasets/enzeeoai/starman/code/layers/thermal_common.py
-
curl -L -o thermal_common.py https://huggingface.co/datasets/enzeeoai/starman/resolve/main/code/layers/thermal_common.py
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() | |