Datasets:
File size: 12,859 Bytes
a8e0542 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 | """ISRIC SoilGrids 2.0 (1000 m, 0-5 cm): rock fraction, effective grain size and texture, Earth only.
No download step: ``plan()`` returns the four local files in ``data/raw/earth/soilgrids/<var>/``. Per
pixel the stored integers are divided by 10 (ISRIC conversion table: g/kg -> %, cm3/dm3 -> vol %),
sand + silt + clay are renormalized to 100 % (the raw sums are 998-1003 g/kg), and the effective grain
size is the geometric mean diameter of the fine earth (Shirazi & Boersma 1984),
d_g = exp(f_clay ln 0.001 + f_silt ln 0.026 + f_sand ln 1.025) [mm] -> x 1000 = um.
Pixel centres of the Interrupted Goode Homolosine grid are transformed to longitude / latitude and
assigned to cells by centre. Earth only: no Mars rows. ``rock_frac_pct``, ``sand_pct``, ``silt_pct`` and
``clay_pct`` are Earth-only filters. ``grain_eff_um`` is a texture-derived diameter, not a
validated counterpart of the thermally inferred Mars grain size.
"""
from __future__ import annotations
import sys
from pathlib import Path
import numpy as np
import pyarrow as pa
import rasterio
from pyproj import Transformer
from rasterio.windows import Window
_PIPELINE = str(Path(__file__).resolve().parent.parent)
if _PIPELINE not in sys.path:
sys.path.insert(0, _PIPELINE)
import terrain_features as tf # noqa: E402
VERSION = 'v0.2'
SOURCE = {
'product': 'ISRIC SoilGrids 2.0 aggregated 1000 m, 0-5 cm mean (cfvo, sand, silt, clay)',
'version': 'v2.0 (files modified 2022-06-02)',
'url': 'https://files.isric.org/soilgrids/latest/data_aggregated/1000m/',
'licence': 'CC BY 4.0 (ISRIC data policy; attribution text not quoted, cite Poggio et al. 2021)',
'planet': 'earth',
}
VARIABLES = ('cfvo', 'sand', 'silt', 'clay')
FILE_PATTERN = '{var}_0-5cm_mean_1000.tif'
NODATA = -32768
CONVERSION_FACTOR = {'cfvo': 10.0, 'sand': 10.0, 'silt': 10.0, 'clay': 10.0} # ISRIC table: stored / 10
D_CLAY_MM, D_SILT_MM, D_SAND_MM = 0.001, 0.026, 1.025
MM_TO_UM = 1000.0
LOW_COVERAGE = tf.LOW_COVERAGE_FRACTION
ROW_MARGIN = 3 # rows read beyond the group's latitude range
_PCT = {'dtype': 'float32', 'unit': '%', 'comparison': 'planet_specific'}
COLUMNS = {
'rock_frac_pct': {**_PCT, 'description': 'Mean coarse-fragment volume fraction (cfvo / 10), vol %. '
'Earth only: no Mars twin in v0.1'},
'rock_frac_pct_std': {**_PCT, 'description': 'Standard deviation of rock_frac_pct over the cell\'s pixels'},
'rock_frac_pct_p10': {**_PCT, 'description': '10th percentile of rock_frac_pct'},
'rock_frac_pct_p50': {**_PCT, 'description': 'Median rock_frac_pct'},
'rock_frac_pct_p90': {**_PCT, 'description': '90th percentile of rock_frac_pct'},
'grain_eff_um': {'dtype': 'float32', 'unit': 'um', 'comparison': 'planet_specific',
'description': 'Effective grain size exp(mean ln d) of the fine earth, d the geometric mean '
'diameter (Shirazi & Boersma 1984); no validated thermal-grain counterpart'},
'grain_eff_um_p10': {'dtype': 'float32', 'unit': 'um', 'comparison': 'planet_specific',
'description': '10th percentile of per-pixel grain size'},
'grain_eff_um_p90': {'dtype': 'float32', 'unit': 'um', 'comparison': 'planet_specific',
'description': '90th percentile of per-pixel grain size'},
'sand_pct': {**_PCT, 'description': 'Mean sand mass fraction after renormalizing sand+silt+clay to 100 %'},
'silt_pct': {**_PCT, 'description': 'Mean silt mass fraction (renormalized)'},
'clay_pct': {**_PCT, 'description': 'Mean clay mass fraction (renormalized)'},
'n_px': {'dtype': 'int32', 'unit': 'count', 'comparison': 'planet_specific', 'fill': 0,
'description': '1 km pixels with valid sand, silt and clay whose centre is in the cell'},
'valid_frac': {'dtype': 'float32', 'unit': 'fraction', 'comparison': 'planet_specific', 'fill': 0.0,
'description': 'n_px over the cell area in km2 (SoilGrids pixels are 1 km2), capped at 1'},
}
LIMITATIONS = [
'SoilGrids is weak in deserts; it is masked over ice sheets, glaciers, open water and urban cores, '
'and has no Antarctica (flag no_coverage).',
'The 1000 m aggregation kernel (mean of the 250 m means) is not documented in anything we read.',
'rock_frac_pct, sand_pct, silt_pct and clay_pct have no Mars twin in v0.1 (Earth-only filters); the '
'Mars grain_eff_um is an effective thermal grain size; this is not an absolute pair.',
'grain_eff_um covers the fine earth only (sand, silt, clay); coarse fragments are in rock_frac_pct.',
'Cells are assigned by pixel centre; with 1 km pixels a 5 km cell holds ~25 of them.',
'Pixels outside the valid Homolosine lobes are excluded by inverse/forward projection round-trip; '
'a finite inverse alone can alias a different lobe at polar latitudes.',
]
# --------------------------------------------------------------------------
# pixel stage (pure numpy)
# --------------------------------------------------------------------------
def convert(raw: np.ndarray, var: str) -> np.ndarray:
"""Stored Int16 -> mapped unit divided by ISRIC's factor (percent); nodata becomes NaN."""
raw = np.asarray(raw)
return np.where(raw == NODATA, np.nan, raw.astype(np.float64) / CONVERSION_FACTOR[var])
def renormalize(sand, silt, clay) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
"""Scale sand, silt and clay (percent) so they sum to exactly 100; NaN if any is missing."""
total = sand + silt + clay
with np.errstate(invalid='ignore', divide='ignore'):
scale = np.where(total > 0, 100.0 / total, np.nan)
return sand * scale, silt * scale, clay * scale
def grain_size_um(sand_pct, silt_pct, clay_pct) -> np.ndarray:
"""Geometric mean grain diameter in um of renormalized texture percentages."""
ln_d = (clay_pct * np.log(D_CLAY_MM) + silt_pct * np.log(D_SILT_MM) + sand_pct * np.log(D_SAND_MM)) / 100.0
return MM_TO_UM * np.exp(ln_d)
def assign_cells(lon, lat, grid, bands: list[int]) -> np.ndarray:
"""Index of each (lon, lat) within the band group's cells in grid order, -1 outside the group."""
lon, lat = np.asarray(lon, dtype=np.float64), np.asarray(lat, dtype=np.float64)
bands = np.asarray(bands)
counts = grid.column_counts[bands].astype(np.int64)
offset = np.concatenate([[0], np.cumsum(counts)[:-1]])
band = np.searchsorted(grid.edges_deg, lat, side='right') - 1
band = np.where(lat == 90.0, len(grid.column_counts) - 1, band)
in_group = (band >= bands[0]) & (band <= bands[-1]) & np.isfinite(lat) & np.isfinite(lon)
local = np.clip(band - bands[0], 0, len(bands) - 1)
n = counts[local]
wrapped = (lon + 180.0) % 360.0 - 180.0
col = np.minimum(((wrapped + 180.0) / 360.0 * n).astype(np.int64), n - 1)
return np.where(in_group, offset[local] + col, -1)
def cell_statistics(cell, rock, sand, silt, clay, n_cells: int) -> dict:
"""Per-cell statistics of the pixels of one band group (``cell`` = index in the group, -1 skip)."""
texture_ok = (cell >= 0) & np.isfinite(sand) & np.isfinite(silt) & np.isfinite(clay)
rock_ok = (cell >= 0) & np.isfinite(rock)
out = {name: np.full(n_cells, np.nan) for name in COLUMNS}
n_px = np.bincount(cell[texture_ok], minlength=n_cells)[:n_cells]
out['n_px'] = n_px
if rock_ok.any():
c, v = cell[rock_ok], rock[rock_ok]
p, counts, _ = tf.grouped_percentiles(v, c, n_cells, (10, 50, 90))
total = np.bincount(c, weights=v, minlength=n_cells)[:n_cells]
squares = np.bincount(c, weights=v * v, minlength=n_cells)[:n_cells]
has = counts > 0
mean = np.where(has, total / np.maximum(counts, 1), np.nan)
out['rock_frac_pct'] = mean
out['rock_frac_pct_std'] = np.where(has, np.sqrt(np.maximum(squares / np.maximum(counts, 1) - mean ** 2, 0)), np.nan)
out['rock_frac_pct_p10'], out['rock_frac_pct_p50'], out['rock_frac_pct_p90'] = p
if texture_ok.any():
c = cell[texture_ok]
s, si, cl = sand[texture_ok], silt[texture_ok], clay[texture_ok]
grain = grain_size_um(s, si, cl)
has = n_px > 0
for name, values in (('sand_pct', s), ('silt_pct', si), ('clay_pct', cl)):
out[name] = np.where(has, np.bincount(c, weights=values, minlength=n_cells)[:n_cells] / np.maximum(n_px, 1), np.nan)
mean_ln = np.bincount(c, weights=np.log(grain), minlength=n_cells)[:n_cells] / np.maximum(n_px, 1)
out['grain_eff_um'] = np.where(has, np.exp(mean_ln), np.nan)
p, _, _ = tf.grouped_percentiles(grain, c, n_cells, (10, 90))
out['grain_eff_um_p10'], out['grain_eff_um_p90'] = p
return out
# --------------------------------------------------------------------------
# driver interface
# --------------------------------------------------------------------------
def plan(band_group, ctx):
return [{'key': f'soilgrids:{var}', 'url': str(Path(ctx.raw_dir) / var / FILE_PATTERN.format(var=var)),
'method': 'local'} for var in VARIABLES]
def _row_window(src, grid, bands) -> tuple[int, int]:
"""Rows of the raster that can hold pixels of the group (y depends only on latitude in IGH)."""
lat_lo, lat_hi = float(grid.edges_deg[bands[0]]), float(grid.edges_deg[bands[-1] + 1])
to_igh = Transformer.from_crs('EPSG:4326', src.crs, always_xy=True)
ys = []
for lon in (-100.0, -60.0, 20.0, 30.0):
for lat in (lat_lo, lat_hi):
_, y = to_igh.transform(lon, max(min(lat, 90.0), -90.0))
if np.isfinite(y):
ys.append(y)
if not ys:
return 0, 0
top = src.transform.f
height_px = abs(src.transform.e)
first = int(np.floor((top - max(ys)) / height_px)) - ROW_MARGIN
last = int(np.ceil((top - min(ys)) / height_px)) + ROW_MARGIN
return max(first, 0), min(last, src.height)
def read_group_pixels(paths: dict, grid, bands: list[int]) -> dict:
"""lon/lat of every valid pixel of the group's rows, and the converted variables."""
with rasterio.open(paths['sand']) as ref:
r0, r1 = _row_window(ref, grid, bands)
crs, transform, width = ref.crs, ref.transform, ref.width
empty = {'lon': np.zeros(0), 'lat': np.zeros(0), **{v: np.zeros(0) for v in VARIABLES}}
if r1 <= r0:
return empty
stacks = {}
for var in VARIABLES:
with rasterio.open(paths[var]) as src:
if (src.crs != crs) or src.transform != transform:
raise ValueError(f'{paths[var]}: grid differs from the sand layer')
stacks[var] = src.read(1, window=Window(0, r0, width, r1 - r0))
any_valid = np.zeros(stacks['sand'].shape, dtype=bool)
for var in VARIABLES:
any_valid |= stacks[var] != NODATA
rows, cols = np.nonzero(any_valid)
if rows.size == 0:
return empty
x = transform.c + (cols + 0.5) * transform.a
y = transform.f + (rows + r0 + 0.5) * transform.e
lon, lat = Transformer.from_crs(crs, 'EPSG:4326', always_xy=True).transform(x, y)
out = {'lon': np.asarray(lon), 'lat': np.asarray(lat)}
for var in VARIABLES:
out[var] = convert(stacks[var][rows, cols], var)
round_x, round_y = Transformer.from_crs('EPSG:4326', crs, always_xy=True).transform(lon, lat)
valid = (np.isfinite(out['lon']) & np.isfinite(out['lat']) &
(np.abs(np.asarray(round_x) - x) < 0.001) &
(np.abs(np.asarray(round_y) - y) < 0.001))
return {k: v[valid] for k, v in out.items()}
def reduce(band_group, items, ctx):
paths = {f.key.split(':', 1)[1]: Path(f.path) for f in items.all()}
grid, bands = ctx.grid, ctx.bands
cells = ctx.cells(band_group)
n_cells = len(cells)
pixels = read_group_pixels(paths, grid, bands)
cell = assign_cells(pixels['lon'], pixels['lat'], grid, bands)
sand, silt, clay = renormalize(pixels['sand'], pixels['silt'], pixels['clay'])
stats = cell_statistics(cell, pixels['cfvo'], sand, silt, clay, n_cells)
area = cells['area_km2'].to_numpy()
n_px = stats['n_px']
with np.errstate(invalid='ignore', divide='ignore'):
valid_frac = np.where(area > 0, np.minimum(n_px / area, 1.0), 0.0)
flags = []
for n, v in zip(n_px, valid_frac):
if n == 0:
flags.append('no_coverage')
elif v < LOW_COVERAGE:
flags.append('low_coverage')
else:
flags.append('')
table = {'region_id': cells['region_id']}
for name, spec in COLUMNS.items():
values = n_px if name == 'n_px' else valid_frac if name == 'valid_frac' else stats[name]
table[name] = pa.array(np.asarray(values), type=pa.type_for_alias(spec['dtype']))
table['quality_flags'] = pa.array(flags, type=pa.string())
return pa.table(table)
|