Tonic's picture
Protostar Climate submission: v2 forecast + v3/DCPP amendment audit (29 gated candidates)
49f3de8 verified
Raw History Blame Contribute Delete
6.73 kB
"""Fetch <=2018 Sentinel-2 L2A windows around each station (Planetary Computer).
Hard rule: every STAC query is capped at 2018-12-31; scene IDs are logged to a
manifest so the exact inputs are reproducible. For each city-year we keep the
least-cloudy scene per quarter (4 timesteps) at 64x64 px, 10 m (640 m window)
centred on the station -- the OlmoEarth sample geometry at small scale.
Output: data/eo/s2_<city_id>_<year>.npz with array (T=4, C=12, 64, 64) float32
in reflectance units (DN/10000), plus manifest.csv.
Bands (OlmoEarth order): B02 B03 B04 B08 B05 B06 B07 B8A B11 B12 B01 B09
20m/60m bands are read resampled to the 64x64 window (documented choice for
from-scratch training).
"""
from __future__ import annotations
import argparse
import json
import sys
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
import numpy as np
import pandas as pd
sys.path.insert(0, str(Path(__file__).parent))
from dataset import download, load_annual
from leakage import assert_dates_le_cutoff
END = "2018-12-31T23:59:59Z"
BANDS = ["B02", "B03", "B04", "B08", "B05", "B06", "B07", "B8A", "B11", "B12", "B01", "B09"]
SIZE = 64 # px at 10 m
def city_table(root: Path) -> pd.DataFrame:
annual = load_annual(root)
cities = (annual.drop_duplicates("ID")[["ID", "Name", "Lat", "Lon"]]
.rename(columns={"ID": "city_id"}))
return cities.sort_values("city_id").reset_index(drop=True)
def fetch_city_year(client, city_id: str, lat: float, lon: float, year: int,
out_dir: Path) -> tuple[bool, list[dict]]:
"""Returns (ok, manifest_rows). Thread-safe: no shared state."""
import planetary_computer
import rasterio
from rasterio.transform import from_bounds as tf_bounds
from rasterio.warp import transform as warp_transform
from rasterio.windows import from_bounds
out_path = out_dir / f"s2_{city_id}_{year}.npz"
if out_path.exists():
return True, []
dlat = 0.0032
dlon = 0.0032 / max(np.cos(np.radians(lat)), 0.2)
bbox = [lon - dlon, lat - dlat, lon + dlon, lat + dlat]
quarters = [(f"{year}-01-01", f"{year}-03-31"), (f"{year}-04-01", f"{year}-06-30"),
(f"{year}-07-01", f"{year}-09-30"), (f"{year}-10-01", f"{year}-12-31")]
timesteps, rows = [], []
for qi, (q0, q1) in enumerate(quarters):
assert_dates_le_cutoff([q1], f"STAC quarter end {city_id} {year} Q{qi+1}")
search = client.search(
collections=["sentinel-2-l2a"], bbox=bbox,
datetime=f"{q0}T00:00:00Z/{q1}T23:59:59Z",
query={"eo:cloud_cover": {"lt": 60}},
sortby=[{"field": "properties.eo:cloud_cover", "direction": "asc"}],
max_items=3,
)
items = list(search.items())
if not items:
return False, []
item = items[0]
signed = planetary_computer.sign(item)
bands_arr = []
target_bounds = None
for band in BANDS:
with rasterio.open(signed.assets[band].href) as src:
if target_bounds is None:
xs, ys = warp_transform("EPSG:4326", src.crs, [lon], [lat])
half = SIZE * 10 / 2
target_bounds = (xs[0] - half, ys[0] - half,
xs[0] + half, ys[0] + half)
win = from_bounds(*target_bounds, transform=src.transform)
arr = src.read(1, window=win, out_shape=(SIZE, SIZE),
boundless=True, fill_value=0)
bands_arr.append(arr.astype(np.float32) / 10000.0)
timesteps.append(np.stack(bands_arr))
rows.append({"city_id": city_id, "year": year, "quarter": qi + 1,
"scene_id": item.id, "datetime": str(item.datetime),
"cloud_cover": item.properties.get("eo:cloud_cover")})
np.savez_compressed(out_path, data=np.stack(timesteps).astype(np.float32))
return True, rows
def main() -> None:
ap = argparse.ArgumentParser()
ap.add_argument("--years", default="2018,2017", help="priority order")
ap.add_argument("--limit", type=int, default=0, help="0 = all cities")
ap.add_argument("--workers", type=int, default=8)
ap.add_argument("--out", default="data/eo")
args = ap.parse_args()
from pystac_client import Client
root = Path(__file__).resolve().parent.parent
data_root = download(root / "data" / "_source")
cities = city_table(data_root)
if args.limit:
cities = cities.head(args.limit)
out_dir = root / args.out
out_dir.mkdir(parents=True, exist_ok=True)
client = Client.open("https://planetarycomputer.microsoft.com/api/stac/v1")
manifest_path = out_dir / "manifest.csv"
manifest = pd.read_csv(manifest_path).to_dict("records") if manifest_path.exists() else []
seen = {(str(r["city_id"]), int(r["year"]), int(r["quarter"])) for r in manifest}
years = [int(y) for y in args.years.split(",")]
assert_dates_le_cutoff([f"{max(years)}-12-31"], "EO years")
tasks = [(row["city_id"], float(row["Lat"]), float(row["Lon"]), year)
for year in years for _, row in cities.iterrows()]
print(f"{len(tasks)} city-year tasks, {args.workers} workers", flush=True)
ok = fail = 0
with ThreadPoolExecutor(max_workers=args.workers) as ex:
futs = {ex.submit(fetch_city_year, client, c, la, lo, y, out_dir): (c, y)
for c, la, lo, y in tasks}
for i, fut in enumerate(as_completed(futs), 1):
city_id, year = futs[fut]
try:
done, rows = fut.result()
except Exception as exc:
print(f"FAIL {city_id} {year}: {type(exc).__name__}: {exc}", flush=True)
done, rows = False, []
for r in rows:
key = (str(r["city_id"]), int(r["year"]), int(r["quarter"]))
if key not in seen:
manifest.append(r); seen.add(key)
ok, fail = ok + bool(done), fail + (not done)
if i % 20 == 0:
print(f"... {i}/{len(tasks)}: {ok} ok, {fail} failed", flush=True)
pd.DataFrame(manifest).to_csv(manifest_path, index=False)
pd.DataFrame(manifest).to_csv(manifest_path, index=False)
print(f"done: {ok} city-years ok, {fail} failed; manifest rows={len(manifest)}")
(out_dir / "fetch_summary.json").write_text(json.dumps(
{"ok": ok, "failed": fail, "years": years, "bands": BANDS,
"end_cap": END}, indent=2))
if __name__ == "__main__":
main()