diff --git a/website/blog/2026-09-09-isrm-esm.md b/website/blog/2026-09-09-isrm-esm.md new file mode 100644 index 000000000..22eead81a --- /dev/null +++ b/website/blog/2026-09-09-isrm-esm.md @@ -0,0 +1,1193 @@ +--- +title: Using EarthSciLab for calculations with the InMAP Source Receptor Matrix (ISRM) +author: Chris Tessum +authorURL: https://github.com/ctessum +--- + +The existing online ways of using the InMAP source-receptor matrix (ISRM) are being +retired in favor of a new service, [EarthSciLab](https://earthscilab.com). +This tutorial walks through running point, area, and line source analyses +through the ISRM using EarthSciLab and Python. + + + + +## Introduction + +In the past, there have been three ways to interact with ISRM: 1) downloading the ISRM file and working with it locally; 2) using the service hosted at inmap.run, and 3) using the [Zarr](https://zarr.dev/) version of ISRM hosted online. + +You will always be able to use ISRM on your own computer, but we will be removing (free) access to the two online options in favor of a new service which we will describe in this post. There are two reasons for this: 1) as usage has increased, making the online services available for free has become a financial burden; and 2) the new service offers capabilities that the two old options do not. + +### earthscilab.com + +[EarthSciLab](https://earthscilab.com) is an online service that allows users to specify a model as a system of equations, and then run the model either in their browser or using cloud computing resources. It is built on top of [EarthSciAST](https://github.com/EarthSciML/EarthSciAST), an open-source system for compiling equations into runnable model simulations. + +Simulations that are run in EarthSciLab using your browser are free, but the service charges for simulations run using cloud computing resources, so that it is able to recoup the cost of those resources. Because the ISRM is a large file stored in the cloud, doing the calculations in this notebook using EarthSciLab may cost you a little bit. However, for calculations of the scale included in this notebook, the cost to you is minimal and may be zero. + +### Bugs fixed compared to previous versions + +While creating this tutorial, I found a couple of bugs in previous versions of ISRM and the code that interacted with it. Both of them have been fixed in this version, but have not yet been fixed in the older versions. + +1. In the Go code for the `inmap srpredict` command that performed analyses using the ISRM, interpolations for plume rises that fell between available layers are performed backwards, so a plume that should have been near the bottom of a gap between layers was placed near the top, and vice versa. For more details and an analysis of the impacts, refer [here](https://github.com/spatialmodel/inmap/issues/121). + +2. In the Zarr version of ISRM (at s3://inmap-model/isrm_v1.2.1.zarr), the `layers` variable which specified which vertical layers SR matrices had been calculated for read [0, 1, 2], when it should have said [0, 3, 6]. This has been fixed in a new version of the file at s3://inmap-model/isrm_v1.2.2.zarr, which has also be re-compressed to take up less space. + +If you prefer, a working [Jupyter notebook](https://jupyter.org/) version of this tutorial is available [here](https://github.com/spatialmodel/inmap/blob/master/website/static/blog/2026-09-09-isrm-esm/isrm_esm.ipynb). + +--- +## Setup + +Below is a bunch of code related to logging into the EarthSciLab service, setting up our ISRM calculation in the format required for EarthSciLab (which is a general service for evaluating geoscience equations and doesn't include any InMAP- or ISRM-related functionality itself), and actually running the simulation. You don't need to understand the code in the next cell in order to run your own analyses using ISRM. + +```python +import base64 +import copy +import io +import json +import pathlib +import ssl +import tempfile +import time +import urllib.error +import urllib.parse +import urllib.request +import webbrowser +import zipfile + +import earthsci_ast +import geopandas as gpd +import numpy as np +import pandas as pd +from shapely.geometry import LineString, Polygon, box + +API = "https://api.earthscilab.com" +WORKOS = "https://api.workos.com" +REPO_RAW = "https://raw.githubusercontent.com/EarthSciML/isrm.esm/main/" + +_downloads = {} + + +def download(url): + """`url`'s bytes, fetched once per kernel and kept in memory.""" + if url not in _downloads: + with urllib.request.urlopen(url, timeout=900) as resp: + _downloads[url] = resp.read() + print(f"fetched {url.rsplit('/', 1)[-1]} ({len(_downloads[url]):,} bytes)") + return _downloads[url] + + +class HttpError(Exception): + def __init__(self, status, body, url): + super().__init__(f"HTTP {status} from {url}: {body[:600]}") + self.status, self.body = status, body + + +class OAuthError(Exception): + """A 400 from WorkOS carrying an OAuth 2.0 `error` code.""" + def __init__(self, error, description): + super().__init__(f"{error}: {description}") + self.error = error + + +def _open(req, timeout): + try: + return urllib.request.urlopen(req, timeout=timeout, context=ssl.create_default_context()) + except urllib.error.HTTPError as e: + body = e.read().decode("utf-8", "replace") + try: + payload = json.loads(body) + except ValueError: + payload = {} + if e.code == 400 and "error" in payload: + raise OAuthError(payload["error"], payload.get("error_description", "")) from None + raise HttpError(e.code, body, req.full_url) from None + + +def http_json(method, url, *, json_body=None, form=None, raw=None, headers=None, timeout=120.0): + """One request, JSON in and JSON out (or `None` for an empty 204 body).""" + data, hdrs = None, dict(headers or {}) + if json_body is not None: + data = json.dumps(json_body).encode() + hdrs["Content-Type"] = "application/json" + elif form is not None: + data = urllib.parse.urlencode(form).encode() + hdrs["Content-Type"] = "application/x-www-form-urlencoded" + elif raw is not None: + data = raw + hdrs["Content-Type"] = "application/octet-stream" + req = urllib.request.Request(url, data=data, headers=hdrs, method=method) + with _open(req, timeout) as resp: + body = resp.read() + return json.loads(body) if body else None + +class Session: + """A signed-in EarthSciLab caller, refreshed on demand.""" + + DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code" + + def __init__(self): + self.client_id = http_json("GET", f"{API}/auth/config")["client_id"] + self._access = None + self._refresh_token = None + + @staticmethod + def _expiry(token): + if not token: + return 0.0 + try: + payload = token.split(".")[1] + payload += "=" * (-len(payload) % 4) + return float(json.loads(base64.urlsafe_b64decode(payload)).get("exp", 0)) + except Exception: + return 0.0 + + def _adopt(self, response): + self._access = response["access_token"] + # Refresh tokens ROTATE. Keeping the new one is not housekeeping — hold on + # to the old one and the next refresh fails. + if response.get("refresh_token"): + self._refresh_token = response["refresh_token"] + + def _refresh(self): + if not self._refresh_token: + return False + try: + self._adopt(http_json("POST", f"{WORKOS}/user_management/authenticate", form={ + "grant_type": "refresh_token", "refresh_token": self._refresh_token, + "client_id": self.client_id})) + return True + except OAuthError: + self._refresh_token = None + return False + + def login(self): + start = http_json("POST", f"{WORKOS}/user_management/authorize/device", + form={"client_id": self.client_id}) + print(f"\n Your code is: {start['user_code']}") + print(f" Open: {start['verification_uri_complete']}\n") + try: + webbrowser.open(start["verification_uri_complete"]) + except Exception: + pass + interval = float(start.get("interval", 5)) + deadline = time.time() + float(start.get("expires_in", 300)) + while time.time() < deadline: + time.sleep(interval) + try: + self._adopt(http_json("POST", f"{WORKOS}/user_management/authenticate", form={ + "grant_type": self.DEVICE_GRANT, "device_code": start["device_code"], + "client_id": self.client_id})) + return + except OAuthError as e: + if e.error == "authorization_pending": + continue + if e.error == "slow_down": + interval += 1 + continue + raise RuntimeError(f"sign-in refused: {e}") from None + raise RuntimeError("sign-in timed out; run this cell again") + + def headers(self): + if time.time() > self._expiry(self._access) - 60: + if not self._refresh(): + self.login() + return {"Authorization": f"Bearer {self._access}"} + + def get(self, path, timeout=120.0): + return http_json("GET", f"{API}{path}", headers=self.headers(), timeout=timeout) + + def post(self, path, body=None, timeout=300.0): + return http_json("POST", f"{API}{path}", json_body=body, + headers=self.headers(), timeout=timeout) + + def put_bytes(self, path, payload, timeout=600.0): + return http_json("PUT", f"{API}{path}", raw=payload, + headers=self.headers(), timeout=timeout) + + def stream(self, path, timeout): + headers = dict(self.headers(), Accept="text/event-stream") + req = urllib.request.Request(f"{API}{path}", headers=headers, method="GET") + return _open(req, timeout) + + +# Each emission column, and the SR pathway it feeds. +PATHWAYS = {"PM25": "PrimaryPM25", "VOC": "SOA", "NOx": "pNO3", + "NH3": "pNH4", "SOx": "pSO4"} +STACK = ["STKHGT", "STKDIAM", "STKTEMP", "STKVEL"] + +TOTALS = ["TotalPM25", "deathsK", "deathsL"] +CELL = ["rcv_W", "rcv_S", "rcv_E", "rcv_N"] # each receptor's own rectangle +OBSERVEDS = TOTALS + CELL + +# The InMAP grid's own projection, and a SPHERE rather than an ellipsoid. The +# documents project lon/lat with these same parameters, so a length or an area +# measured here is the one the document measures. +LCC = ("+proj=lcc +lat_1=33 +lat_2=45 +lat_0=40 +lon_0=-97 " + "+a=6370997 +b=6370997 +units=m +no_defs") + +# The readers declare a file's CRS and reproject nothing, and the documents do +# the projection themselves, so the file goes out geographic. +FILE_CRS = "EPSG:4269" + +FAMILIES = {"Point": "point", "MultiPoint": "point", + "Polygon": "polygon", "MultiPolygon": "polygon", + "LineString": "line", "MultiLineString": "line"} + +TEMPLATES = {("point", True): "isrm_gdf_point.esm", + ("point", False): "isrm_gdf_point_flat.esm", + ("polygon", False): "isrm_gdf_polygon.esm", + ("line", False): "isrm_gdf_line.esm"} + +# `GET /datasets/{id}/field` clamps to this and a query cannot raise it. The +# receptor axis is 52,411, so a whole field fits and comes back at stride 1. +MAX_VALUES = 262_144 + + +def _explode(gdf, columns): + """One row per part, with every emission column split among the parts.""" + multi = int(gdf.geom_type.str.startswith("Multi").sum()) + gdf = gdf.reset_index(drop=True) # so the parent index is unique + parts = gdf.explode(index_parts=False) # ... and repeated once per part + if len(parts) == len(gdf): + return parts.reset_index(drop=True) + + measure = parts.geometry.area + if not (measure > 0).any(): + measure = parts.geometry.length + if not (measure > 0).any(): # points: all a point has is its count + measure = pd.Series(1.0, index=parts.index) + share = measure / measure.groupby(level=0).transform("sum") + + parts = parts.copy() + for column in columns: + parts[column] = parts[column].astype(float) * share + print(f" split {multi} multi-part record(s) into {len(parts) - len(gdf)} extra " + f"part(s), emissions shared by area/length") + return parts.reset_index(drop=True) + + +def _drop_holes(gdf): + """Replace each polygon by its exterior ring.""" + holes = int(sum(len(g.interiors) for g in gdf.geometry)) + if not holes: + return gdf + gdf = gdf.copy() + gdf["geometry"] = [Polygon(g.exterior) for g in gdf.geometry] + print(f" dropped {holes} interior ring(s); mass unchanged, footprint now " + f"includes the holes") + return gdf + + +def _segmentize(gdf, columns): + """Cut every polyline into two-vertex segments, emission split by length.""" + rows = [] + for _, record in gdf.iterrows(): + coords = list(record.geometry.coords) + segments = [LineString([a, b]) for a, b in zip(coords, coords[1:])] + lengths = np.array([s.length for s in segments], dtype=float) + share = (lengths / lengths.sum() if lengths.sum() > 0 + else np.full(len(segments), 1.0 / len(segments))) + for segment, fraction in zip(segments, share): + rows.append({**{c: float(record[c]) * fraction for c in columns}, + "geometry": segment}) + print(f" cut {len(gdf)} polyline(s) into {len(rows)} two-vertex segment(s)") + return gpd.GeoDataFrame(rows, geometry="geometry", crs=gdf.crs) + + +def normalize(gdf): + """A frame the reader can be handed, and what the document needs to know.""" + if gdf.crs is None: + raise ValueError("the frame has no CRS; set one so it can be reprojected to " + "the geographic CRS the documents project from") + + columns = [c for c in PATHWAYS if c in gdf.columns] + if not columns: + raise ValueError(f"no emission column: expected one or more of " + f"{list(PATHWAYS)} in kg/yr, got {list(gdf.columns)}") + + families = {FAMILIES.get(t) for t in gdf.geom_type.unique()} + if len(families) != 1 or None in families: + raise ValueError(f"one geometry family per frame; got " + f"{sorted(gdf.geom_type.unique())}") + family = families.pop() + + stack = [c for c in STACK if c in gdf.columns] + plume = family == "point" and len(stack) == len(STACK) + if family == "point" and stack and not plume: + raise ValueError(f"plume rise needs all of {STACK}; the frame has {stack}") + + # Work in the grid's own metres: every share below is a ratio of areas or + # lengths, and the document computes them in this same projection. + frame = _explode(gdf.to_crs(LCC), columns) + if family == "polygon": + frame = _drop_holes(frame) + if family == "line": + frame = _segmentize(frame, columns) + + keep = columns + (STACK if plume else []) + frame = frame[keep + ["geometry"]].copy() + for column in keep: + frame[column] = np.asarray(frame[column], dtype=float) + + # The vertex axis the reader pads to, and the document declares. + nvert_max = (1 if family == "point" else + 2 if family == "line" else + max(len(g.exterior.coords) for g in frame.geometry)) + + frame = frame.to_crs(FILE_CRS) + print(f" {len(frame):,} records · {family} · nvert_max {nvert_max} · " + f"{', '.join(keep)}" + (" · ASME plume rise" if plume else "")) + return frame, family, columns, plume, nvert_max + + +def shapefile_zip(frame): + """The frame as a zipped four-file shapefile set, in memory. + + GDAL writes a shapefile as several files with a shared stem, so this is the + one step that needs a directory — a temporary one, gone on the way out. + `emis.shp` is the member every generated document names. + """ + with tempfile.TemporaryDirectory() as tmp: + frame.to_file(pathlib.Path(tmp) / "emis.shp", driver="ESRI Shapefile", + engine="pyogrio") + buffer = io.BytesIO() + with zipfile.ZipFile(buffer, "w") as archive: + for part in sorted(pathlib.Path(tmp).iterdir()): + archive.writestr(part.name, part.read_bytes()) + return buffer.getvalue() + + +def equation_refs(doc): + """`lhs` -> every variable its right-hand side needs.""" + loaded = earthsci_ast.load_document(copy.deepcopy(doc)) + model = loaded.models[next(iter(doc["models"]))] + return {eq.lhs: earthsci_ast.free_variables(eq.rhs) for eq in model.equations} + + +def prune_pathways(doc, columns): + """Keep only the pathways the frame has columns for.""" + model = doc["models"]["ISRM"] + variables, equations = model["variables"], model["equations"] + report = doc["metadata"]["x_esd"]["report"] + + keep = [PATHWAYS[c] for c in columns] + report["pathways"] = [p for p in report["pathways"] if p["sr_array"] in keep] + + total = next(e for e in equations if e["lhs"] == "TotalPM25") + terms = [{"op": "index", "args": [f"conc_{p}", "rcv"]} for p in keep] + total["rhs"]["args"] = [f"conc_{p}" for p in keep] + total["rhs"]["expr"]["args"][1] = ({"op": "+", "args": terms} if len(terms) > 1 + else terms[0]) + + roots = [report["total_pm25"], *report["deaths"].values(), report["record_field"], + *CELL, "rcv_cx", "rcv_cy"] + for pathway in report["pathways"]: + roots += [pathway["concentration"], *pathway["emissions"], + "pm_" + pathway["sr_array"]] + + refs = equation_refs(doc) + needed, stack = set(), list(roots) + while stack: + name = stack.pop() + if name in needed or name not in variables: + continue + needed.add(name) + stack.extend(refs.get(name, set()) & set(variables)) + + dropped = sorted(set(variables) - needed) + model["variables"] = {n: v for n, v in variables.items() if n in needed} + model["equations"] = [e for e in equations if e["lhs"] in needed] + live = {(v.get("update") or {}).get("source") for v in model["variables"].values()} + for source in [s for s in doc["data_sources"] if s not in live]: + doc["data_sources"].pop(source) + dropped.append(source) + if dropped: + print(f" pruned {len(dropped)} variable(s)/source(s); {len(keep)} pathway(s) " + f"kept: {', '.join(keep)}") + return doc + + +def fold_in_template_library(doc): + """Merge the imported `expression_templates` in, and drop the import key. + + Not using `earthsci_ast.emit_document` because it closes the metaparameters + into the index sets, turning `emis_records: {size: "N_REC"}` into `{size: 0}`. + """ + for model in doc["models"].values(): + merged = {} + for imported in model.pop("expression_template_imports", []) or []: + library = json.loads(download(REPO_RAW + imported["ref"].rsplit("/", 1)[-1])) + merged.update(library.get("expression_templates") or {}) + merged.update(model.get("expression_templates") or {}) # the document's own win + model["expression_templates"] = merged + return doc + + +def build_document(family, plume, columns, nvert_max, url, records=None): + """The template, made into the document this particular frame needs.""" + name = TEMPLATES[(family, plume)] + doc = fold_in_template_library(json.loads(download(REPO_RAW + name))) + + source = doc["data_sources"]["Emis"] + source["source"]["url_template"] = url + + # `nvert_max` is TWO declarations that have to agree: what the reader pads the + # vertex axis to, and how wide the document says that axis is. Setting only + # the reader's half is not a validation error and not a wrong number — the + # engine reads a [records, 5, 2] array into a [records, 56, 2] parameter and + # the worker dies with no message at all. The axis is found through the + # geometry variable rather than by name, because each family calls it + # something different (N_EVERT, N_PVERT, N_LVERT). + source["reader_options"]["nvert_max"] = nvert_max + model = doc["models"]["ISRM"] + geometry = next(name for name, v in model["variables"].items() + if ((v.get("update") or {}).get("from") or {}) + .get("file_variable") == "geometry") + axis = model["variables"][geometry]["shape"][1] + doc["metaparameters"][doc["index_sets"][axis]["size"]]["default"] = nvert_max + + if records: + # Scale is a DOCUMENT edit, not a request parameter: a loader-level + # `select` range on the source that discovers its own extent. + source["select"] = {"axes": [{"range": {"start": 0, "stop": records}}]} + + prune_pathways(doc, columns) + + # Cheaper to hear it from the library than from the API, which rejects an + # invalid document with a bare "not valid under any of the schemas listed in + # the 'oneOf' keyword" and 60 KB of echoed model, naming nothing. + result = earthsci_ast.validate(earthsci_ast.load_document(copy.deepcopy(doc))) + problems = list(result.schema_errors) + list(result.structural_errors) + if problems: + raise RuntimeError("the document this frame produced is invalid:\n " + + "\n ".join(str(p) for p in problems[:6])) + + print(f" {name} · {axis} width {nvert_max} · valid" + + (f" · first {records:,} records" if records else "")) + return doc + +TERMINAL = {"succeeded", "failed", "cancelled", "capped"} + + +def money(dollars): + return "—" if dollars is None else ( + f"${dollars:.4f}" if 0 < abs(dollars) < 0.01 else f"${dollars:.2f}") + + +def clock(seconds): + seconds = int(seconds) + if seconds >= 3600: + return f"{seconds // 3600}h{seconds % 3600 // 60:02d}m" + return f"{seconds // 60}m{seconds % 60:02d}s" if seconds >= 60 else f"{seconds}s" + + +def upload_dataset(session, payload, name, esio_format="shapefile"): + """Put bytes in the dataset store under `name`; return the committed record.""" + created = session.post("/datasets", {"format": esio_format, "origin": "upload"}) + if created["upload"]["mode"] != "proxy": + raise RuntimeError(f"this deployment wants a {created['upload']['mode']!r} " + "upload, not a proxied one") + if len(payload) > created["max_object_bytes"]: + raise RuntimeError(f"{name} is {len(payload):,} B, over the " + f"{created['max_object_bytes']:,} B per-object ceiling") + session.put_bytes(f"{created['upload']['url']}?key={urllib.parse.quote(name)}", + payload) + dataset = session.post(f"/datasets/{created['id']}/commit") + print(f" uploaded {name} ({len(payload):,} B) as dataset {dataset['id']}") + return dataset + + +def dataset_url(dataset): + """Where a document's `url_template` should point at this dataset.""" + base = dataset["store_url"].rstrip("/") + return base if dataset.get("format") == "zarr" else f"{base}/{dataset['object_key']}" + + +def quote(doc, observeds): + """Price the run. No auth — `POST /quote` has no database.""" + routing = http_json("POST", f"{API}/quote", timeout=300.0, + json_body={"esm": doc, "kind": "evaluate", + "observeds": observeds}) + option = routing.get("dispatchable") + if not option: + raise RuntimeError(f"no dispatchable backend: {routing.get('reason')}") + estimate, sizing = option["estimate"], routing.get("sizing") or {} + print(f" {option['backend']} · {sizing.get('vcpus')} vCPU / " + f"{sizing.get('memory_mb')} MB · {clock(estimate['resource_seconds'])} " + f"predicted (cap {clock(estimate['max_resource_seconds'])}) · " + f"{money(estimate['price'])}") + return estimate["price"] + + +def watch(session, run_id): + """Follow a run to a terminal event, surviving a dropped connection. + + The stream replays everything already recorded before it streams, so a + reconnect sees what it missed — including a terminal event that landed while + we were disconnected. + """ + started = time.time() + while True: + try: + with session.stream(f"/runs/{run_id}/events", timeout=240.0) as resp: + for line in resp: + line = line.decode("utf-8", "replace").strip() + if not line.startswith("data:"): + continue + event = json.loads(line[5:]).get("kind") or {} + kind = event.get("type") + if kind == "progress": + f = event.get("fraction", 0.0) + print(f"\r [{'#' * int(f * 40):<40}] {f * 100:5.1f}% " + f"elapsed {clock(time.time() - started)}", end="", flush=True) + elif kind in ("queued", "started"): + print(f" {kind}", flush=True) + elif kind in TERMINAL: + print() + return event + except (HttpError, OAuthError, urllib.error.URLError, OSError, ValueError) as e: + print(f"\n (stream dropped: {e}; the run is server-side and unaffected)") + run = session.get(f"/runs/{run_id}") + if run["status"] in TERMINAL: + return {"type": run["status"]} + time.sleep(5) + + +def read_fields(session, dataset_id, names): + """One 1-D array per name.""" + dataset = session.get(f"/datasets/{dataset_id}") + pins = ",".join(f"{d['name']}:0" for d in dataset.get("dims", []) if d["size"] == 1) + series = {} + for name in names: + query = {"var": name, "max_values": MAX_VALUES} + if pins: + query["at"] = pins + field = session.get(f"/datasets/{dataset_id}/field?{urllib.parse.urlencode(query)}") + if len(field["axes"]) != 1 or field["axes"][0]["stride"] != 1: + raise RuntimeError(f"{name}: expected one free axis read whole: " + f"{field['axes']}") + series[name] = field["values"] + return series + + +def receptor_frame(series): + """The answer as a GeoDataFrame: one cell rectangle per receptor. + + Handed back in the InMAP/EPA Lambert conformal projection + Call `.to_crs(...)` to switch to another CRS. + """ + cells = [box(w, s, e, n) for w, s, e, n in + zip(series["rcv_W"], series["rcv_S"], series["rcv_E"], series["rcv_N"])] + return gpd.GeoDataFrame({name: series[name] for name in TOTALS}, + geometry=cells, crs=LCC) + +def run_isrm(gdf, records=None, max_price=None): + """Run the InMAP ISRM over `gdf` on EarthSciLab, and bring the answer back. + + `gdf` carries one row per source, geometry in any CRS, and a column per + pollutant in kg/yr (see 2.1). Returns a GeoDataFrame of the 52,411 receptor + cells with TotalPM25 in µg/m³ and the two mortality estimates, and the run's + id in `.attrs`. + """ + print("layer") + frame, family, columns, plume, nvert_max = normalize(gdf) + + print("upload") + dataset = upload_dataset(session, shapefile_zip(frame), "emis.zip") + + print("document") + doc = build_document(family, plume, columns, nvert_max, + dataset_url(dataset), records=records) + + print("quote") + price = quote(doc, OBSERVEDS) + + print("run") + run = session.post("/runs", { + "esm": doc, "kind": "evaluate", "observeds": OBSERVEDS, + "max_price": price if max_price is None else max_price}) + print(f" run {run['id']} — {run['status']} on {run['backend']}, " + f"{money(run['price'])}") + outcome = watch(session, run["id"]) + if outcome["type"] != "succeeded": + raise RuntimeError(f"run {run['id']} {outcome['type']}: " + f"{outcome.get('message', '')}") + print(f" succeeded in {clock(outcome.get('resource_seconds', 0))} of resource time") + + receptors = receptor_frame(read_fields(session, outcome["dataset_id"], OBSERVEDS)) + receptors.attrs.update(run_id=run["id"], dataset_id=dataset["id"], + records=len(frame), pathways=columns) + for name in TOTALS: + print(f" sum({name})".ljust(22) + repr(float(receptors[name].sum()))) + return receptors +``` + +### Sign in + +Before you can run an analysis or simulation, you will need an EarthSciLab account. Go to https://earthscilab.com/ and click "Sign in" in the upper right corner of the page, then click "Sign up" and follow the instructions. + +Once you have an account, run the code in the cell below and then follow the instructions to login to your account in this notebook. + +```python +session = Session() +print("signed in as", session.get("/me")["email"]) +print("credit:", session.get("/credits")) +``` + +## Run an analysis + +An order to calculate air quality impacts using ISRM in EarthSciLab, you will need a [GeoPandas](https://geopandas.org/en/stable/) GeoDataFrame including the geometry of each emissions record, plus the following information: + +| column | units | meaning | +|---|---|---| +| `PM25` | kg/yr | emissions of primary PM2.5, resulting in `PrimaryPM25` concentrations | +| `NOx` | kg/yr | emissions of NOx, resulting in `pNO3` concentrations | +| `NH3` | kg/yr | emissions of NH3, resulting in `pNH4` concentrations | +| `SOx` | kg/yr | emissions of SO2, resulting in `pSO4` concentrations | +| `VOC` | kg/yr | emissions of VOCs, resulting in `SOA` concentrations | +| `STKHGT` | m | stack height — POINT frames only | +| `STKDIAM` | m | stack exit diameter | +| `STKTEMP` | K | exit gas temperature | +| `STKVEL` | m/s | exit gas velocity | + +Each record should either have information for all four stack parameter columns or for none. +If the stack parameters are specified, a point source's mass is allocated to a vertical emission height using a plume rise algorithm; +otherwise emissions are assumed to occur at ground level. + +Below, we will demonstrate a couple of analyses to get you started: + +### Example point source analysis + +The cell below creates a function that download's a US EPA emissions inventory for electricity generating units (EGUs) +and processes it into the required geodataframe format described above: + +```python +FF10_URL = ("https://gaftp.epa.gov/air/emismod/2016/alpha/2016fd/emissions/" + "2016fd_inputs_point.zip") + +# FF10 point columns are positional (0-based), as EarthSciIO's own reader has +# them; isrm_point.esm's metadata.x_esd.columns names the same indices. +FF10 = {12: "POLID", 13: "ANN_VALUE", 17: "STKHGT", 18: "STKDIAM", + 19: "STKTEMP", 21: "STKVEL", 23: "LONGITUDE", 24: "LATITUDE"} + +SHORT_TON_KG = 907.18474 + + +def _compared_codes(node, found=None): + """Every integer an `==` in this expression compares against. + + Collected by walking rather than by indexing, because the shape of a mask + depends on how many codes it covers: `is_VOC` is an `or` of 35 `==` nodes + and `is_NH3` is a single bare `==`. + """ + found = set() if found is None else found + if isinstance(node, dict): + if node.get("op") == "==": + args = node.get("args") or [] + if len(args) == 2 and isinstance(args[1], (int, float)): + found.add(int(args[1])) + for value in node.values(): + _compared_codes(value, found) + elif isinstance(node, list): + for item in node: + _compared_codes(item, found) + return found + + +def pollutant_classes(): + """`POLID` -> emission column, read out of isrm_point.esm itself.""" + model = json.loads(download(REPO_RAW + "isrm_point.esm"))["models"]["ISRM"] + codes = model["variables"]["pollutant"]["update"]["from"]["codes"]["map"] + classes = {} + for column in PATHWAYS: + mask = next(e for e in model["equations"] if e["lhs"] == f"is_{column}") + wanted = _compared_codes(mask["rhs"]) + for polid, code in codes.items(): + if code in wanted: + classes[polid.upper()] = column + return classes + + +def egu_points(limit=None): + """The EGU inventory as one row per stack, in SI units.""" + classes = pollutant_classes() + with zipfile.ZipFile(io.BytesIO(download(FF10_URL))) as archive: + member = next(n for n in archive.namelist() + if "egu" in n.lower() and not n.endswith("/")) + raw = pd.read_csv(io.BytesIO(archive.read(member)), header=None, comment="#", + usecols=list(FF10), names=None, dtype=str, + engine="python", on_bad_lines="skip") + raw = raw.rename(columns=FF10) + # One asserted header line survives the '#' comments. + if str(raw.iloc[0]["POLID"]).strip().lower() in ("polid", "poll"): + raw = raw.iloc[1:] + print(f" {member}: {len(raw):,} FF10 rows") + + raw["column"] = raw["POLID"].str.strip().str.upper().map(classes) + raw = raw.dropna(subset=["column"]) + numeric = ["ANN_VALUE", "STKHGT", "STKDIAM", "STKTEMP", "STKVEL", + "LONGITUDE", "LATITUDE"] + for name in numeric: + raw[name] = pd.to_numeric(raw[name], errors="coerce") + raw = raw.dropna(subset=numeric) + print(f" {len(raw):,} rows classified into {sorted(raw['column'].unique())}") + + # A stack IS its location plus its four parameters: rows that agree on all + # six are the same physical stack, and summing them is exact for a linear + # model. Pivoting on that key is what turns long into wide. + key = ["LONGITUDE", "LATITUDE", "STKHGT", "STKDIAM", "STKTEMP", "STKVEL"] + wide = (raw.pivot_table(index=key, columns="column", values="ANN_VALUE", + aggfunc="sum", fill_value=0.0) + .reset_index()) + wide.columns.name = None + print(f" pivoted to {len(wide):,} stacks") + if limit: + wide = wide.head(limit) + + emissions = [c for c in PATHWAYS if c in wide.columns] + for column in emissions: + wide[column] = wide[column] * SHORT_TON_KG # short ton/yr -> kg/yr + wide["STKHGT"] = wide["STKHGT"] * 0.3048 # ft -> m + wide["STKDIAM"] = wide["STKDIAM"] * 0.3048 + wide["STKVEL"] = wide["STKVEL"] * 0.3048 # ft/s -> m/s + wide["STKTEMP"] = (wide["STKTEMP"] - 32.0) * 5.0 / 9.0 + 273.15 # degF -> K + + return gpd.GeoDataFrame( + wide[emissions + STACK], + geometry=gpd.points_from_xy(wide["LONGITUDE"], wide["LATITUDE"]), + crs="EPSG:4269") +``` + +Now, we can run the function we created above to get the emissions geodataframe: + +```python +points = egu_points(limit=100) # <- Change to limit=None to run the full inventory. The limit is just for a quick test. +print() +print(points[[c for c in PATHWAYS if c in points.columns]].sum().to_string()) +points.head(3) +``` + + 2016fd_cb6_16j/inputs/ptegu/egucems_2016v2_POINT_20180327_HCLCLaug_12apr2018_v2.csv: 93,459 FF10 rows + 24,597 rows classified into ['NH3', 'NOx', 'PM25', 'SOx', 'VOC'] + pivoted to 2,159 stacks + + PM25 1.336610e+06 + VOC 5.199170e+05 + NOx 4.129675e+06 + NH3 9.602069e+05 + SOx 3.480194e+06 + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PM25VOCNOxNH3SOxSTKHGTSTKDIAMSTKTEMPSTKVELgeometry
021772.4337607348.19639471331.9361062068.3812077457.05856354.86404.2672372.0388890.272278POINT (-122.6862 48.8287)
12449.39879890.7184748164.6626603265.865064544.31084425.60323.3528394.26111121.153120POINT (-122.487 48.7451)
21451.49558490.7184746350.2931802177.243376362.87389625.60323.3528394.26111121.153120POINT (-122.487 48.7454)
+
+ +Now, we can run the `run_isrm` function we created at the top of the notebook to calculate the resulting PM2.5 concentrations. It can take a while, depending on how many emissions records you are processing. Also, there will be a progress bar but it may get stuck for a while at around 75%; this is normal. + +```python +point_receptors = run_isrm(points) +``` + + layer + 100 records · point · nvert_max 1 · PM25, VOC, NOx, NH3, SOx, STKHGT, STKDIAM, STKTEMP, STKVEL · ASME plume rise + upload + uploaded emis.zip (26,476 B) as dataset 7e562bc1-6aea-4bdd-aab1-34b0c0b435b0 + document + isrm_gdf_point.esm · emis_vertex width 1 · valid + quote + cloud_batch · 4.0 vCPU / 16384 MB · 10m00s predicted (cap 1h20m) · $0.04 + run + run 8a632caa-d3f0-41e5-babc-f53900505468 — running on cloud_batch, $0.04 + queued + started + [###################################### ] 96.3% elapsed 2m32s + succeeded in 2m11s of resource time + sum(TotalPM25) 281.24156822422736 + sum(deathsK) 43.91889991152327 + sum(deathsL) 98.79455102893459 + +#### Plotting the result + +The cell below creates a function to show our calculate concentrations or health impacts on a map: + +```python +import matplotlib.pyplot as plt +from matplotlib.colors import ListedColormap + +# `Blues` with its white end trimmed off: at pure white the lowest cells are +# invisible against the page. +SEQUENTIAL = ListedColormap(plt.get_cmap("Blues")(np.linspace(0.15, 1.0, 256))) + +# State outlines, to give the concentration field somewhere to stand. 20m is the +# coarsest of the three cartographic generalisations the Census publishes — at +# the scale these maps are drawn at, the finer ones are only more vertices. +STATES_URL = ("https://www2.census.gov/geo/tiger/GENZ2020/shp/" + "cb_2020_us_state_20m.zip") + +_states = {} + + +def states(): + """State boundaries in the receptor grid's projection, read once.""" + if "gdf" not in _states: + _states["gdf"] = gpd.read_file(io.BytesIO(download(STATES_URL))).to_crs(LCC) + return _states["gdf"] + + +def show(receptors, title="", column="TotalPM25", units="µg/m³", + clip_pct=99.0, share=1.0, height=6.4, boundaries=True): + """The receptor grid as a choropleth.""" + v = receptors[column].to_numpy() + vmax = np.percentile(v, clip_pct) or v.max() or 1.0 + + bounds = receptors.total_bounds + if share: + order = np.argsort(v)[::-1] + keep = order[:np.searchsorted(np.cumsum(v[order]), v.sum() * share) + 1] + bounds = receptors.iloc[keep].total_bounds + x0, y0, x1, y1 = bounds + pad = 0.06 * max(x1 - x0, y1 - y0) + + # The figure follows the MAP's shape: these are metres in both directions, so + # the axes are equal-aspect and their width follows the extent. + span = height * (x1 - x0) / (y1 - y0) + fig, ax = plt.subplots(figsize=(min(13.0, max(4.5, span)) + 1.8, height), dpi=150) + + # No edge colour: at 52,411 cells a stroke per rectangle is most of the ink on + # the page, and the boundaries it draws are the grid's, not the data's. + receptors.plot(ax=ax, column=column, cmap=SEQUENTIAL, vmin=0.0, vmax=vmax, + linewidth=0.0, edgecolor="none", rasterized=True, legend=True, + legend_kwds={"label": f"{column} ({units})", "shrink": 0.55, + "extend": "max" if v.max() > vmax else "neither"}) + + # Over the choropleth, and thin enough not to compete with it. Reprojected to + # whatever CRS the caller handed the receptors over in, so a `.to_crs(...)` + # upstream carries the outlines with it. + if boundaries: + states().to_crs(receptors.crs).boundary.plot( + ax=ax, color="0.35", linewidth=0.4, zorder=3) + + ax.set_xlim(x0 - pad, x1 + pad) + ax.set_ylim(y0 - pad, y1 + pad) + ax.set_aspect("equal") + ax.set_axis_off() + ax.set_title( + f"{title or column}\n" + f"{receptors.attrs.get('records', len(receptors)):,} emission records · " + f"{', '.join(receptors.attrs.get('pathways', []))} · " + f"run {receptors.attrs.get('run_id', '?')[:8]}\n" + f"scale clipped at the {clip_pct:g}th percentile ({vmax:.3g} {units}); " + f"true maximum {v.max():.3g} {units}", + fontsize=9, loc="left") + fig.tight_layout() + return ax +``` + +Now, we can use that function to make our map: + +```python +show(point_receptors, "PM2.5 from EGU point sources, through the InMAP ISRM") +plt.show() +``` + + +![png](/blog/2026-09-09-isrm-esm/output_15_0.png) + + +--- +### Example area source analysis + +We can use the same set of functions with a polygon-type geodataframe to simulate impacts of area emission sources. Here, we give all the counties in Illinois a consistent rate of emissions: + +```python +COUNTIES_URL = ("https://www2.census.gov/geo/tiger/GENZ2020/shp/" + "cb_2020_us_county_20m.zip") +STATE = "17" # Illinois +RATE_PM25 = 1000.0 # kg/yr per km² of land area — an example rate + +counties = gpd.read_file(io.BytesIO(download(COUNTIES_URL))) +counties = counties[counties["STATEFP"] == STATE].copy() +counties["PM25"] = RATE_PM25 * counties["ALAND"] / 1e6 +polygons = counties[["NAME", "PM25", "geometry"]] +print(f"{len(polygons)} counties · {polygons['PM25'].sum():,.0f} kg/yr of primary PM2.5") +polygons.head(3) +``` + + 102 counties · 143,778,461 kg/yr of primary PM2.5 + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NAMEPM25geometry
2Stephenson1461392.061POLYGON ((-89.92647 42.50579, -89.83759 42.504...
11Putnam414649.315POLYGON ((-89.46639 41.23387, -89.35673 41.233...
105Richland932484.098POLYGON ((-88.25778 38.73114, -88.25858 38.847...
+
+ +```python +polygon_receptors = run_isrm(polygons) +``` + + layer + 102 records · polygon · nvert_max 56 · PM25 + upload + uploaded emis.zip (32,094 B) as dataset bec630dc-e16d-4d6c-ba6c-bff82fe70e6d + document + pruned 20 variable(s)/source(s); 1 pathway(s) kept: PrimaryPM25 + isrm_gdf_polygon.esm · poly_vertex width 56 · valid + quote + cloud_batch · 4.0 vCPU / 16384 MB · 10m00s predicted (cap 1h20m) · $0.04 + run + run 74baed7f-877c-4f68-8319-4df323e75605 — running on cloud_batch, $0.04 + queued + started + [####################################### ] 97.6% elapsed 2m34s + succeeded in 2m14s of resource time + sum(TotalPM25) 4219.068006714893 + sum(deathsK) 1406.9517405485624 + sum(deathsL) 3176.194766023125 + +```python +show(polygon_receptors, "PM2.5 from an Illinois county area-source layer") +plt.show() +``` + + +![png](/blog/2026-09-09-isrm-esm/output_19_0.png) + + +--- +## Example line source analysis + +Here, we calculate impacts of emissions on interstates in Illinois, with a constant rate of emission per kilometer of road. Before running the air quality analysis, we simplify the line shapes to reduce computational burden. (We simplify to 200m segments, which is still one fifth of InMAP's smallest grid cells.) + +```python +ROADS_URL = (f"https://www2.census.gov/geo/tiger/TIGER2020/PRISECROADS/" + f"tl_2020_{STATE}_prisecroads.zip") +SIMPLIFY_M = 200.0 # a fifth of the ISRM grid's finest cell +RATE_ROAD_PM25 = 40.0 # kg/yr per km of road — example rates, as above +RATE_ROAD_NOX = 400.0 + +roads = gpd.read_file(io.BytesIO(download(ROADS_URL))) +interstates = roads[(roads["MTFCC"] == "S1100") & (roads["RTTYP"] == "I")].to_crs(LCC) +interstates["geometry"] = interstates.simplify(SIMPLIFY_M) + +km = interstates.length / 1000.0 +interstates["PM25"] = RATE_ROAD_PM25 * km +interstates["NOx"] = RATE_ROAD_NOX * km +lines = interstates[["FULLNAME", "PM25", "NOx", "geometry"]] +print(f"{len(lines)} road(s) · {km.sum():,.0f} km · " + f"{lines['PM25'].sum():,.0f} kg/yr PM2.5, {lines['NOx'].sum():,.0f} kg/yr NOx") +lines.head(3) +``` + + 292 road(s) · 7,350 km · 294,004 kg/yr PM2.5, 2,940,040 kg/yr NOx + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FULLNAMEPM25NOxgeometry
4056I- 57527.6539895276.539890LINESTRING (729166.377 -47083.84, 729759.571 -...
4061I- 3551153.17838711531.783871LINESTRING (739525.605 227788.524, 739083.546 ...
4089I- 2941434.35802414343.580243LINESTRING (747536.216 242857.167, 747643.526 ...
+
+ +```python +line_receptors = run_isrm(lines) +``` + + layer + cut 292 polyline(s) into 1931 two-vertex segment(s) + 1,931 records · line · nvert_max 2 · PM25, NOx + upload + uploaded emis.zip (280,947 B) as dataset 3295a982-c57f-4c9c-bb72-483cdc82cf28 + document + pruned 15 variable(s)/source(s); 2 pathway(s) kept: PrimaryPM25, pNO3 + isrm_gdf_line.esm · line_vertex width 2 · valid + quote + cloud_batch · 4.0 vCPU / 16384 MB · 10m00s predicted (cap 1h20m) · $0.04 + run + run 90026046-ca04-4022-b854-3a9313bd29a2 — running on cloud_batch, $0.04 + queued + started + [###################################### ] 96.9% elapsed 2m26s + succeeded in 2m03s of resource time + sum(TotalPM25) 42.41880153885225 + sum(deathsK) 13.106555416146492 + sum(deathsL) 29.473888255125694 + +```python +show(line_receptors, "PM2.5 from Illinois interstate line sources") +plt.show() +``` + + +![png](/blog/2026-09-09-isrm-esm/output_23_0.png) + + +--- +## Cleaning up + +Each run uploaded an emissions dataset. You will theoretically be billed for storing these on the server, although the cost for files this size is minimal. The cell below will delete them, you can also do it at https://earthscilab.com. + +```python +for receptors in (point_receptors, polygon_receptors, line_receptors): + dataset_id = receptors.attrs["dataset_id"] + http_json("DELETE", f"{API}/datasets/{dataset_id}", headers=session.headers()) + print("deleted", dataset_id) +``` + + deleted 7e562bc1-6aea-4bdd-aab1-34b0c0b435b0 + deleted bec630dc-e16d-4d6c-ba6c-bff82fe70e6d + deleted 3295a982-c57f-4c9c-bb72-483cdc82cf28 + +## Conclusion + +That's all for this tutorial! If you have any questions or run into any issues, feel free to get touch at https://earthsciml.discourse.group/ or https://groups.google.com/g/inmap-users. diff --git a/website/static/blog/2026-09-09-isrm-esm/isrm_esm.ipynb b/website/static/blog/2026-09-09-isrm-esm/isrm_esm.ipynb new file mode 100644 index 000000000..9cca6ef2d --- /dev/null +++ b/website/static/blog/2026-09-09-isrm-esm/isrm_esm.ipynb @@ -0,0 +1,1495 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Using EarthSciLab for calculations with the InMAP Source Receptor Matrix (ISRM)\n", + "\n", + "Author: Chris Tessum (ctessum@illinois.edu)\n", + "\n", + "## Introduction\n", + "\n", + "In the past, there have been three ways to interact with ISRM: 1) downloading the ISRM file and working with it locally; 2) using the service hosted at inmap.run, and 3) using the [Zarr](https://zarr.dev/) version of ISRM hosted online.\n", + "\n", + "You will always be able to use ISRM on your own computer, but we will be removing (free) access to the two online options in favor of a new service which we will describe in this post. There are two reasons for this: 1) as usage has increased, making the online services available for free has become a financial burden; and 2) the new service offers capabilities that the two old options do not.\n", + "\n", + "### earthscilab.com\n", + "\n", + "[EarthSciLab](https://earthscilab.com) is an online service that allows users to specify a model as a system of equations, and then run the model either in their browser or using cloud computing resources. It is built on top of [EarthSciAST](https://github.com/EarthSciML/EarthSciAST), an open-source system for compiling equations into runnable model simulations.\n", + "\n", + "Simulations that are run in EarthSciLab using your browser are free, but the service charges for simulations run using cloud computing resources, so that it is able to recoup the cost of those resources. Because the ISRM is a large file stored in the cloud, doing the calculations in this notebook using EarthSciLab may cost you a little bit. However, for calculations of the scale included in this notebook, the cost to you is minimal and may be zero.\n", + "\n", + "### Bugs fixed compared to previous versions\n", + "\n", + "While creating this tutorial, I found a couple of bugs in previous versions of ISRM and the code that interacted with it. Both of them have been fixed in this version, but have not yet been fixed in the older versions.\n", + "\n", + "1. In the Go code for the `inmap srpredict` command that performed analyses using the ISRM, interpolations for plume rises that fell between available layers are performed backwards, so a plume that should have been near the bottom of a gap between layers was placed near the top, and vice versa. For more details and an analysis of the impacts, refer [here](https://github.com/spatialmodel/inmap/issues/121).\n", + "\n", + "2. In the Zarr version of ISRM (at s3://inmap-model/isrm_v1.2.1.zarr), the `layers` variable which specified which vertical layers SR matrices had been calculated for read [0, 1, 2], when it should have said [0, 3, 6]. This has been fixed in a new version of the file at s3://inmap-model/isrm_v1.2.2.zarr, which has also be re-compressed to take up less space." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Setup\n", + "\n", + "Below is a bunch of code related to logging into the EarthSciLab service, setting up our ISRM calculation in the format required for EarthSciLab (which is a general service for evaluating geoscience equations and doesn't include any InMAP- or ISRM-related functionality itself), and actually running the simulation. You don't need to understand the code in the next cell in order to run your own analyses using ISRM." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b99ab797", + "metadata": {}, + "outputs": [], + "source": [ + "import base64\n", + "import copy\n", + "import io\n", + "import json\n", + "import pathlib\n", + "import ssl\n", + "import tempfile\n", + "import time\n", + "import urllib.error\n", + "import urllib.parse\n", + "import urllib.request\n", + "import webbrowser\n", + "import zipfile\n", + "\n", + "import earthsci_ast\n", + "import geopandas as gpd\n", + "import numpy as np\n", + "import pandas as pd\n", + "from shapely.geometry import LineString, Polygon, box\n", + "\n", + "API = \"https://api.earthscilab.com\"\n", + "WORKOS = \"https://api.workos.com\"\n", + "REPO_RAW = \"https://raw.githubusercontent.com/EarthSciML/isrm.esm/main/\"\n", + "\n", + "_downloads = {}\n", + "\n", + "\n", + "def download(url):\n", + " \"\"\"`url`'s bytes, fetched once per kernel and kept in memory.\"\"\"\n", + " if url not in _downloads:\n", + " with urllib.request.urlopen(url, timeout=900) as resp:\n", + " _downloads[url] = resp.read()\n", + " print(f\"fetched {url.rsplit('/', 1)[-1]} ({len(_downloads[url]):,} bytes)\")\n", + " return _downloads[url]\n", + "\n", + "\n", + "class HttpError(Exception):\n", + " def __init__(self, status, body, url):\n", + " super().__init__(f\"HTTP {status} from {url}: {body[:600]}\")\n", + " self.status, self.body = status, body\n", + "\n", + "\n", + "class OAuthError(Exception):\n", + " \"\"\"A 400 from WorkOS carrying an OAuth 2.0 `error` code.\"\"\"\n", + " def __init__(self, error, description):\n", + " super().__init__(f\"{error}: {description}\")\n", + " self.error = error\n", + "\n", + "\n", + "def _open(req, timeout):\n", + " try:\n", + " return urllib.request.urlopen(req, timeout=timeout, context=ssl.create_default_context())\n", + " except urllib.error.HTTPError as e:\n", + " body = e.read().decode(\"utf-8\", \"replace\")\n", + " try:\n", + " payload = json.loads(body)\n", + " except ValueError:\n", + " payload = {}\n", + " if e.code == 400 and \"error\" in payload:\n", + " raise OAuthError(payload[\"error\"], payload.get(\"error_description\", \"\")) from None\n", + " raise HttpError(e.code, body, req.full_url) from None\n", + "\n", + "\n", + "def http_json(method, url, *, json_body=None, form=None, raw=None, headers=None, timeout=120.0):\n", + " \"\"\"One request, JSON in and JSON out (or `None` for an empty 204 body).\"\"\"\n", + " data, hdrs = None, dict(headers or {})\n", + " if json_body is not None:\n", + " data = json.dumps(json_body).encode()\n", + " hdrs[\"Content-Type\"] = \"application/json\"\n", + " elif form is not None:\n", + " data = urllib.parse.urlencode(form).encode()\n", + " hdrs[\"Content-Type\"] = \"application/x-www-form-urlencoded\"\n", + " elif raw is not None:\n", + " data = raw\n", + " hdrs[\"Content-Type\"] = \"application/octet-stream\"\n", + " req = urllib.request.Request(url, data=data, headers=hdrs, method=method)\n", + " with _open(req, timeout) as resp:\n", + " body = resp.read()\n", + " return json.loads(body) if body else None\n", + "\n", + "class Session:\n", + " \"\"\"A signed-in EarthSciLab caller, refreshed on demand.\"\"\"\n", + "\n", + " DEVICE_GRANT = \"urn:ietf:params:oauth:grant-type:device_code\"\n", + "\n", + " def __init__(self):\n", + " self.client_id = http_json(\"GET\", f\"{API}/auth/config\")[\"client_id\"]\n", + " self._access = None\n", + " self._refresh_token = None\n", + "\n", + " @staticmethod\n", + " def _expiry(token):\n", + " if not token:\n", + " return 0.0\n", + " try:\n", + " payload = token.split(\".\")[1]\n", + " payload += \"=\" * (-len(payload) % 4)\n", + " return float(json.loads(base64.urlsafe_b64decode(payload)).get(\"exp\", 0))\n", + " except Exception:\n", + " return 0.0\n", + "\n", + " def _adopt(self, response):\n", + " self._access = response[\"access_token\"]\n", + " # Refresh tokens ROTATE. Keeping the new one is not housekeeping — hold on\n", + " # to the old one and the next refresh fails.\n", + " if response.get(\"refresh_token\"):\n", + " self._refresh_token = response[\"refresh_token\"]\n", + "\n", + " def _refresh(self):\n", + " if not self._refresh_token:\n", + " return False\n", + " try:\n", + " self._adopt(http_json(\"POST\", f\"{WORKOS}/user_management/authenticate\", form={\n", + " \"grant_type\": \"refresh_token\", \"refresh_token\": self._refresh_token,\n", + " \"client_id\": self.client_id}))\n", + " return True\n", + " except OAuthError:\n", + " self._refresh_token = None\n", + " return False\n", + "\n", + " def login(self):\n", + " start = http_json(\"POST\", f\"{WORKOS}/user_management/authorize/device\",\n", + " form={\"client_id\": self.client_id})\n", + " print(f\"\\n Your code is: {start['user_code']}\")\n", + " print(f\" Open: {start['verification_uri_complete']}\\n\")\n", + " try:\n", + " webbrowser.open(start[\"verification_uri_complete\"])\n", + " except Exception:\n", + " pass\n", + " interval = float(start.get(\"interval\", 5))\n", + " deadline = time.time() + float(start.get(\"expires_in\", 300))\n", + " while time.time() < deadline:\n", + " time.sleep(interval)\n", + " try:\n", + " self._adopt(http_json(\"POST\", f\"{WORKOS}/user_management/authenticate\", form={\n", + " \"grant_type\": self.DEVICE_GRANT, \"device_code\": start[\"device_code\"],\n", + " \"client_id\": self.client_id}))\n", + " return\n", + " except OAuthError as e:\n", + " if e.error == \"authorization_pending\":\n", + " continue\n", + " if e.error == \"slow_down\":\n", + " interval += 1\n", + " continue\n", + " raise RuntimeError(f\"sign-in refused: {e}\") from None\n", + " raise RuntimeError(\"sign-in timed out; run this cell again\")\n", + "\n", + " def headers(self):\n", + " if time.time() > self._expiry(self._access) - 60:\n", + " if not self._refresh():\n", + " self.login()\n", + " return {\"Authorization\": f\"Bearer {self._access}\"}\n", + "\n", + " def get(self, path, timeout=120.0):\n", + " return http_json(\"GET\", f\"{API}{path}\", headers=self.headers(), timeout=timeout)\n", + "\n", + " def post(self, path, body=None, timeout=300.0):\n", + " return http_json(\"POST\", f\"{API}{path}\", json_body=body,\n", + " headers=self.headers(), timeout=timeout)\n", + "\n", + " def put_bytes(self, path, payload, timeout=600.0):\n", + " return http_json(\"PUT\", f\"{API}{path}\", raw=payload,\n", + " headers=self.headers(), timeout=timeout)\n", + "\n", + " def stream(self, path, timeout):\n", + " headers = dict(self.headers(), Accept=\"text/event-stream\")\n", + " req = urllib.request.Request(f\"{API}{path}\", headers=headers, method=\"GET\")\n", + " return _open(req, timeout)\n", + "\n", + "\n", + "# Each emission column, and the SR pathway it feeds.\n", + "PATHWAYS = {\"PM25\": \"PrimaryPM25\", \"VOC\": \"SOA\", \"NOx\": \"pNO3\",\n", + " \"NH3\": \"pNH4\", \"SOx\": \"pSO4\"}\n", + "STACK = [\"STKHGT\", \"STKDIAM\", \"STKTEMP\", \"STKVEL\"]\n", + "\n", + "TOTALS = [\"TotalPM25\", \"deathsK\", \"deathsL\"]\n", + "CELL = [\"rcv_W\", \"rcv_S\", \"rcv_E\", \"rcv_N\"] # each receptor's own rectangle\n", + "OBSERVEDS = TOTALS + CELL\n", + "\n", + "# The InMAP grid's own projection, and a SPHERE rather than an ellipsoid. The\n", + "# documents project lon/lat with these same parameters, so a length or an area\n", + "# measured here is the one the document measures.\n", + "LCC = (\"+proj=lcc +lat_1=33 +lat_2=45 +lat_0=40 +lon_0=-97 \"\n", + " \"+a=6370997 +b=6370997 +units=m +no_defs\")\n", + "\n", + "# The readers declare a file's CRS and reproject nothing, and the documents do\n", + "# the projection themselves, so the file goes out geographic.\n", + "FILE_CRS = \"EPSG:4269\"\n", + "\n", + "FAMILIES = {\"Point\": \"point\", \"MultiPoint\": \"point\",\n", + " \"Polygon\": \"polygon\", \"MultiPolygon\": \"polygon\",\n", + " \"LineString\": \"line\", \"MultiLineString\": \"line\"}\n", + "\n", + "TEMPLATES = {(\"point\", True): \"isrm_gdf_point.esm\",\n", + " (\"point\", False): \"isrm_gdf_point_flat.esm\",\n", + " (\"polygon\", False): \"isrm_gdf_polygon.esm\",\n", + " (\"line\", False): \"isrm_gdf_line.esm\"}\n", + "\n", + "# `GET /datasets/{id}/field` clamps to this and a query cannot raise it. The\n", + "# receptor axis is 52,411, so a whole field fits and comes back at stride 1.\n", + "MAX_VALUES = 262_144\n", + "\n", + "\n", + "def _explode(gdf, columns):\n", + " \"\"\"One row per part, with every emission column split among the parts.\"\"\"\n", + " multi = int(gdf.geom_type.str.startswith(\"Multi\").sum())\n", + " gdf = gdf.reset_index(drop=True) # so the parent index is unique\n", + " parts = gdf.explode(index_parts=False) # ... and repeated once per part\n", + " if len(parts) == len(gdf):\n", + " return parts.reset_index(drop=True)\n", + "\n", + " measure = parts.geometry.area\n", + " if not (measure > 0).any():\n", + " measure = parts.geometry.length\n", + " if not (measure > 0).any(): # points: all a point has is its count\n", + " measure = pd.Series(1.0, index=parts.index)\n", + " share = measure / measure.groupby(level=0).transform(\"sum\")\n", + "\n", + " parts = parts.copy()\n", + " for column in columns:\n", + " parts[column] = parts[column].astype(float) * share\n", + " print(f\" split {multi} multi-part record(s) into {len(parts) - len(gdf)} extra \"\n", + " f\"part(s), emissions shared by area/length\")\n", + " return parts.reset_index(drop=True)\n", + "\n", + "\n", + "def _drop_holes(gdf):\n", + " \"\"\"Replace each polygon by its exterior ring.\"\"\"\n", + " holes = int(sum(len(g.interiors) for g in gdf.geometry))\n", + " if not holes:\n", + " return gdf\n", + " gdf = gdf.copy()\n", + " gdf[\"geometry\"] = [Polygon(g.exterior) for g in gdf.geometry]\n", + " print(f\" dropped {holes} interior ring(s); mass unchanged, footprint now \"\n", + " f\"includes the holes\")\n", + " return gdf\n", + "\n", + "\n", + "def _segmentize(gdf, columns):\n", + " \"\"\"Cut every polyline into two-vertex segments, emission split by length.\"\"\"\n", + " rows = []\n", + " for _, record in gdf.iterrows():\n", + " coords = list(record.geometry.coords)\n", + " segments = [LineString([a, b]) for a, b in zip(coords, coords[1:])]\n", + " lengths = np.array([s.length for s in segments], dtype=float)\n", + " share = (lengths / lengths.sum() if lengths.sum() > 0\n", + " else np.full(len(segments), 1.0 / len(segments)))\n", + " for segment, fraction in zip(segments, share):\n", + " rows.append({**{c: float(record[c]) * fraction for c in columns},\n", + " \"geometry\": segment})\n", + " print(f\" cut {len(gdf)} polyline(s) into {len(rows)} two-vertex segment(s)\")\n", + " return gpd.GeoDataFrame(rows, geometry=\"geometry\", crs=gdf.crs)\n", + "\n", + "\n", + "def normalize(gdf):\n", + " \"\"\"A frame the reader can be handed, and what the document needs to know.\"\"\"\n", + " if gdf.crs is None:\n", + " raise ValueError(\"the frame has no CRS; set one so it can be reprojected to \"\n", + " \"the geographic CRS the documents project from\")\n", + "\n", + " columns = [c for c in PATHWAYS if c in gdf.columns]\n", + " if not columns:\n", + " raise ValueError(f\"no emission column: expected one or more of \"\n", + " f\"{list(PATHWAYS)} in kg/yr, got {list(gdf.columns)}\")\n", + "\n", + " families = {FAMILIES.get(t) for t in gdf.geom_type.unique()}\n", + " if len(families) != 1 or None in families:\n", + " raise ValueError(f\"one geometry family per frame; got \"\n", + " f\"{sorted(gdf.geom_type.unique())}\")\n", + " family = families.pop()\n", + "\n", + " stack = [c for c in STACK if c in gdf.columns]\n", + " plume = family == \"point\" and len(stack) == len(STACK)\n", + " if family == \"point\" and stack and not plume:\n", + " raise ValueError(f\"plume rise needs all of {STACK}; the frame has {stack}\")\n", + "\n", + " # Work in the grid's own metres: every share below is a ratio of areas or\n", + " # lengths, and the document computes them in this same projection.\n", + " frame = _explode(gdf.to_crs(LCC), columns)\n", + " if family == \"polygon\":\n", + " frame = _drop_holes(frame)\n", + " if family == \"line\":\n", + " frame = _segmentize(frame, columns)\n", + "\n", + " keep = columns + (STACK if plume else [])\n", + " frame = frame[keep + [\"geometry\"]].copy()\n", + " for column in keep:\n", + " frame[column] = np.asarray(frame[column], dtype=float)\n", + "\n", + " # The vertex axis the reader pads to, and the document declares.\n", + " nvert_max = (1 if family == \"point\" else\n", + " 2 if family == \"line\" else\n", + " max(len(g.exterior.coords) for g in frame.geometry))\n", + "\n", + " frame = frame.to_crs(FILE_CRS)\n", + " print(f\" {len(frame):,} records · {family} · nvert_max {nvert_max} · \"\n", + " f\"{', '.join(keep)}\" + (\" · ASME plume rise\" if plume else \"\"))\n", + " return frame, family, columns, plume, nvert_max\n", + "\n", + "\n", + "def shapefile_zip(frame):\n", + " \"\"\"The frame as a zipped four-file shapefile set, in memory.\n", + "\n", + " GDAL writes a shapefile as several files with a shared stem, so this is the\n", + " one step that needs a directory — a temporary one, gone on the way out.\n", + " `emis.shp` is the member every generated document names.\n", + " \"\"\"\n", + " with tempfile.TemporaryDirectory() as tmp:\n", + " frame.to_file(pathlib.Path(tmp) / \"emis.shp\", driver=\"ESRI Shapefile\",\n", + " engine=\"pyogrio\")\n", + " buffer = io.BytesIO()\n", + " with zipfile.ZipFile(buffer, \"w\") as archive:\n", + " for part in sorted(pathlib.Path(tmp).iterdir()):\n", + " archive.writestr(part.name, part.read_bytes())\n", + " return buffer.getvalue()\n", + "\n", + "\n", + "def equation_refs(doc):\n", + " \"\"\"`lhs` -> every variable its right-hand side needs.\"\"\"\n", + " loaded = earthsci_ast.load_document(copy.deepcopy(doc))\n", + " model = loaded.models[next(iter(doc[\"models\"]))]\n", + " return {eq.lhs: earthsci_ast.free_variables(eq.rhs) for eq in model.equations}\n", + "\n", + "\n", + "def prune_pathways(doc, columns):\n", + " \"\"\"Keep only the pathways the frame has columns for.\"\"\"\n", + " model = doc[\"models\"][\"ISRM\"]\n", + " variables, equations = model[\"variables\"], model[\"equations\"]\n", + " report = doc[\"metadata\"][\"x_esd\"][\"report\"]\n", + "\n", + " keep = [PATHWAYS[c] for c in columns]\n", + " report[\"pathways\"] = [p for p in report[\"pathways\"] if p[\"sr_array\"] in keep]\n", + "\n", + " total = next(e for e in equations if e[\"lhs\"] == \"TotalPM25\")\n", + " terms = [{\"op\": \"index\", \"args\": [f\"conc_{p}\", \"rcv\"]} for p in keep]\n", + " total[\"rhs\"][\"args\"] = [f\"conc_{p}\" for p in keep]\n", + " total[\"rhs\"][\"expr\"][\"args\"][1] = ({\"op\": \"+\", \"args\": terms} if len(terms) > 1\n", + " else terms[0])\n", + "\n", + " roots = [report[\"total_pm25\"], *report[\"deaths\"].values(), report[\"record_field\"],\n", + " *CELL, \"rcv_cx\", \"rcv_cy\"]\n", + " for pathway in report[\"pathways\"]:\n", + " roots += [pathway[\"concentration\"], *pathway[\"emissions\"],\n", + " \"pm_\" + pathway[\"sr_array\"]]\n", + "\n", + " refs = equation_refs(doc)\n", + " needed, stack = set(), list(roots)\n", + " while stack:\n", + " name = stack.pop()\n", + " if name in needed or name not in variables:\n", + " continue\n", + " needed.add(name)\n", + " stack.extend(refs.get(name, set()) & set(variables))\n", + "\n", + " dropped = sorted(set(variables) - needed)\n", + " model[\"variables\"] = {n: v for n, v in variables.items() if n in needed}\n", + " model[\"equations\"] = [e for e in equations if e[\"lhs\"] in needed]\n", + " live = {(v.get(\"update\") or {}).get(\"source\") for v in model[\"variables\"].values()}\n", + " for source in [s for s in doc[\"data_sources\"] if s not in live]:\n", + " doc[\"data_sources\"].pop(source)\n", + " dropped.append(source)\n", + " if dropped:\n", + " print(f\" pruned {len(dropped)} variable(s)/source(s); {len(keep)} pathway(s) \"\n", + " f\"kept: {', '.join(keep)}\")\n", + " return doc\n", + "\n", + "\n", + "def fold_in_template_library(doc):\n", + " \"\"\"Merge the imported `expression_templates` in, and drop the import key.\n", + "\n", + " Not using `earthsci_ast.emit_document` because it closes the metaparameters \n", + " into the index sets, turning `emis_records: {size: \"N_REC\"}` into `{size: 0}`.\n", + " \"\"\"\n", + " for model in doc[\"models\"].values():\n", + " merged = {}\n", + " for imported in model.pop(\"expression_template_imports\", []) or []:\n", + " library = json.loads(download(REPO_RAW + imported[\"ref\"].rsplit(\"/\", 1)[-1]))\n", + " merged.update(library.get(\"expression_templates\") or {})\n", + " merged.update(model.get(\"expression_templates\") or {}) # the document's own win\n", + " model[\"expression_templates\"] = merged\n", + " return doc\n", + "\n", + "\n", + "def build_document(family, plume, columns, nvert_max, url, records=None):\n", + " \"\"\"The template, made into the document this particular frame needs.\"\"\"\n", + " name = TEMPLATES[(family, plume)]\n", + " doc = fold_in_template_library(json.loads(download(REPO_RAW + name)))\n", + "\n", + " source = doc[\"data_sources\"][\"Emis\"]\n", + " source[\"source\"][\"url_template\"] = url\n", + "\n", + " # `nvert_max` is TWO declarations that have to agree: what the reader pads the\n", + " # vertex axis to, and how wide the document says that axis is. Setting only\n", + " # the reader's half is not a validation error and not a wrong number — the\n", + " # engine reads a [records, 5, 2] array into a [records, 56, 2] parameter and\n", + " # the worker dies with no message at all. The axis is found through the\n", + " # geometry variable rather than by name, because each family calls it\n", + " # something different (N_EVERT, N_PVERT, N_LVERT).\n", + " source[\"reader_options\"][\"nvert_max\"] = nvert_max\n", + " model = doc[\"models\"][\"ISRM\"]\n", + " geometry = next(name for name, v in model[\"variables\"].items()\n", + " if ((v.get(\"update\") or {}).get(\"from\") or {})\n", + " .get(\"file_variable\") == \"geometry\")\n", + " axis = model[\"variables\"][geometry][\"shape\"][1]\n", + " doc[\"metaparameters\"][doc[\"index_sets\"][axis][\"size\"]][\"default\"] = nvert_max\n", + "\n", + " if records:\n", + " # Scale is a DOCUMENT edit, not a request parameter: a loader-level\n", + " # `select` range on the source that discovers its own extent.\n", + " source[\"select\"] = {\"axes\": [{\"range\": {\"start\": 0, \"stop\": records}}]}\n", + "\n", + " prune_pathways(doc, columns)\n", + "\n", + " # Cheaper to hear it from the library than from the API, which rejects an\n", + " # invalid document with a bare \"not valid under any of the schemas listed in\n", + " # the 'oneOf' keyword\" and 60 KB of echoed model, naming nothing.\n", + " result = earthsci_ast.validate(earthsci_ast.load_document(copy.deepcopy(doc)))\n", + " problems = list(result.schema_errors) + list(result.structural_errors)\n", + " if problems:\n", + " raise RuntimeError(\"the document this frame produced is invalid:\\n \"\n", + " + \"\\n \".join(str(p) for p in problems[:6]))\n", + "\n", + " print(f\" {name} · {axis} width {nvert_max} · valid\"\n", + " + (f\" · first {records:,} records\" if records else \"\"))\n", + " return doc\n", + "\n", + "TERMINAL = {\"succeeded\", \"failed\", \"cancelled\", \"capped\"}\n", + "\n", + "\n", + "def money(dollars):\n", + " return \"—\" if dollars is None else (\n", + " f\"${dollars:.4f}\" if 0 < abs(dollars) < 0.01 else f\"${dollars:.2f}\")\n", + "\n", + "\n", + "def clock(seconds):\n", + " seconds = int(seconds)\n", + " if seconds >= 3600:\n", + " return f\"{seconds // 3600}h{seconds % 3600 // 60:02d}m\"\n", + " return f\"{seconds // 60}m{seconds % 60:02d}s\" if seconds >= 60 else f\"{seconds}s\"\n", + "\n", + "\n", + "def upload_dataset(session, payload, name, esio_format=\"shapefile\"):\n", + " \"\"\"Put bytes in the dataset store under `name`; return the committed record.\"\"\"\n", + " created = session.post(\"/datasets\", {\"format\": esio_format, \"origin\": \"upload\"})\n", + " if created[\"upload\"][\"mode\"] != \"proxy\":\n", + " raise RuntimeError(f\"this deployment wants a {created['upload']['mode']!r} \"\n", + " \"upload, not a proxied one\")\n", + " if len(payload) > created[\"max_object_bytes\"]:\n", + " raise RuntimeError(f\"{name} is {len(payload):,} B, over the \"\n", + " f\"{created['max_object_bytes']:,} B per-object ceiling\")\n", + " session.put_bytes(f\"{created['upload']['url']}?key={urllib.parse.quote(name)}\",\n", + " payload)\n", + " dataset = session.post(f\"/datasets/{created['id']}/commit\")\n", + " print(f\" uploaded {name} ({len(payload):,} B) as dataset {dataset['id']}\")\n", + " return dataset\n", + "\n", + "\n", + "def dataset_url(dataset):\n", + " \"\"\"Where a document's `url_template` should point at this dataset.\"\"\"\n", + " base = dataset[\"store_url\"].rstrip(\"/\")\n", + " return base if dataset.get(\"format\") == \"zarr\" else f\"{base}/{dataset['object_key']}\"\n", + "\n", + "\n", + "def quote(doc, observeds):\n", + " \"\"\"Price the run. No auth — `POST /quote` has no database.\"\"\"\n", + " routing = http_json(\"POST\", f\"{API}/quote\", timeout=300.0,\n", + " json_body={\"esm\": doc, \"kind\": \"evaluate\",\n", + " \"observeds\": observeds})\n", + " option = routing.get(\"dispatchable\")\n", + " if not option:\n", + " raise RuntimeError(f\"no dispatchable backend: {routing.get('reason')}\")\n", + " estimate, sizing = option[\"estimate\"], routing.get(\"sizing\") or {}\n", + " print(f\" {option['backend']} · {sizing.get('vcpus')} vCPU / \"\n", + " f\"{sizing.get('memory_mb')} MB · {clock(estimate['resource_seconds'])} \"\n", + " f\"predicted (cap {clock(estimate['max_resource_seconds'])}) · \"\n", + " f\"{money(estimate['price'])}\")\n", + " return estimate[\"price\"]\n", + "\n", + "\n", + "def watch(session, run_id):\n", + " \"\"\"Follow a run to a terminal event, surviving a dropped connection.\n", + "\n", + " The stream replays everything already recorded before it streams, so a\n", + " reconnect sees what it missed — including a terminal event that landed while\n", + " we were disconnected.\n", + " \"\"\"\n", + " started = time.time()\n", + " while True:\n", + " try:\n", + " with session.stream(f\"/runs/{run_id}/events\", timeout=240.0) as resp:\n", + " for line in resp:\n", + " line = line.decode(\"utf-8\", \"replace\").strip()\n", + " if not line.startswith(\"data:\"):\n", + " continue\n", + " event = json.loads(line[5:]).get(\"kind\") or {}\n", + " kind = event.get(\"type\")\n", + " if kind == \"progress\":\n", + " f = event.get(\"fraction\", 0.0)\n", + " print(f\"\\r [{'#' * int(f * 40):<40}] {f * 100:5.1f}% \"\n", + " f\"elapsed {clock(time.time() - started)}\", end=\"\", flush=True)\n", + " elif kind in (\"queued\", \"started\"):\n", + " print(f\" {kind}\", flush=True)\n", + " elif kind in TERMINAL:\n", + " print()\n", + " return event\n", + " except (HttpError, OAuthError, urllib.error.URLError, OSError, ValueError) as e:\n", + " print(f\"\\n (stream dropped: {e}; the run is server-side and unaffected)\")\n", + " run = session.get(f\"/runs/{run_id}\")\n", + " if run[\"status\"] in TERMINAL:\n", + " return {\"type\": run[\"status\"]}\n", + " time.sleep(5)\n", + "\n", + "\n", + "def read_fields(session, dataset_id, names):\n", + " \"\"\"One 1-D array per name.\"\"\"\n", + " dataset = session.get(f\"/datasets/{dataset_id}\")\n", + " pins = \",\".join(f\"{d['name']}:0\" for d in dataset.get(\"dims\", []) if d[\"size\"] == 1)\n", + " series = {}\n", + " for name in names:\n", + " query = {\"var\": name, \"max_values\": MAX_VALUES}\n", + " if pins:\n", + " query[\"at\"] = pins\n", + " field = session.get(f\"/datasets/{dataset_id}/field?{urllib.parse.urlencode(query)}\")\n", + " if len(field[\"axes\"]) != 1 or field[\"axes\"][0][\"stride\"] != 1:\n", + " raise RuntimeError(f\"{name}: expected one free axis read whole: \"\n", + " f\"{field['axes']}\")\n", + " series[name] = field[\"values\"]\n", + " return series\n", + "\n", + "\n", + "def receptor_frame(series):\n", + " \"\"\"The answer as a GeoDataFrame: one cell rectangle per receptor.\n", + "\n", + " Handed back in the InMAP/EPA Lambert conformal projection\n", + " Call `.to_crs(...)` to switch to another CRS.\n", + " \"\"\"\n", + " cells = [box(w, s, e, n) for w, s, e, n in\n", + " zip(series[\"rcv_W\"], series[\"rcv_S\"], series[\"rcv_E\"], series[\"rcv_N\"])]\n", + " return gpd.GeoDataFrame({name: series[name] for name in TOTALS},\n", + " geometry=cells, crs=LCC)\n", + "\n", + "def run_isrm(gdf, records=None, max_price=None):\n", + " \"\"\"Run the InMAP ISRM over `gdf` on EarthSciLab, and bring the answer back.\n", + "\n", + " `gdf` carries one row per source, geometry in any CRS, and a column per\n", + " pollutant in kg/yr (see 2.1). Returns a GeoDataFrame of the 52,411 receptor\n", + " cells with TotalPM25 in µg/m³ and the two mortality estimates, and the run's\n", + " id in `.attrs`.\n", + " \"\"\"\n", + " print(\"layer\")\n", + " frame, family, columns, plume, nvert_max = normalize(gdf)\n", + "\n", + " print(\"upload\")\n", + " dataset = upload_dataset(session, shapefile_zip(frame), \"emis.zip\")\n", + "\n", + " print(\"document\")\n", + " doc = build_document(family, plume, columns, nvert_max,\n", + " dataset_url(dataset), records=records)\n", + "\n", + " print(\"quote\")\n", + " price = quote(doc, OBSERVEDS)\n", + "\n", + " print(\"run\")\n", + " run = session.post(\"/runs\", {\n", + " \"esm\": doc, \"kind\": \"evaluate\", \"observeds\": OBSERVEDS,\n", + " \"max_price\": price if max_price is None else max_price})\n", + " print(f\" run {run['id']} — {run['status']} on {run['backend']}, \"\n", + " f\"{money(run['price'])}\")\n", + " outcome = watch(session, run[\"id\"])\n", + " if outcome[\"type\"] != \"succeeded\":\n", + " raise RuntimeError(f\"run {run['id']} {outcome['type']}: \"\n", + " f\"{outcome.get('message', '')}\")\n", + " print(f\" succeeded in {clock(outcome.get('resource_seconds', 0))} of resource time\")\n", + "\n", + " receptors = receptor_frame(read_fields(session, outcome[\"dataset_id\"], OBSERVEDS))\n", + " receptors.attrs.update(run_id=run[\"id\"], dataset_id=dataset[\"id\"],\n", + " records=len(frame), pathways=columns)\n", + " for name in TOTALS:\n", + " print(f\" sum({name})\".ljust(22) + repr(float(receptors[name].sum())))\n", + " return receptors" + ] + }, + { + "cell_type": "markdown", + "id": "b87aa472", + "metadata": {}, + "source": [ + "### Sign in\n", + "\n", + "Before you can run an analysis or simulation, you will need an EarthSciLab account. Go to https://earthscilab.com/ and click \"Sign in\" in the upper right corner of the page, then click \"Sign up\" and follow the instructions.\n", + "\n", + "Once you have an account, run the code in the cell below and then follow the instructions to login to your account in this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8ac9ba96", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ] + } + ], + "source": [ + "session = Session()\n", + "print(\"signed in as\", session.get(\"/me\")[\"email\"])\n", + "print(\"credit:\", session.get(\"/credits\"))" + ] + }, + { + "cell_type": "markdown", + "id": "03fe7d1f", + "metadata": {}, + "source": [ + "## Run an analysis\n", + "\n", + "An order to calculate air quality impacts using ISRM in EarthSciLab, you will need a [GeoPandas](https://geopandas.org/en/stable/) GeoDataFrame including the geometry of each emissions record, plus the following information:\n", + "\n", + "| column | units | meaning |\n", + "|---|---|---|\n", + "| `PM25` | kg/yr | emissions of primary PM2.5, resulting in `PrimaryPM25` concentrations |\n", + "| `NOx` | kg/yr | emissions of NOx, resulting in `pNO3` concentrations |\n", + "| `NH3` | kg/yr | emissions of NH3, resulting in `pNH4` concentrations |\n", + "| `SOx` | kg/yr | emissions of SO2, resulting in `pSO4` concentrations |\n", + "| `VOC` | kg/yr | emissions of VOCs, resulting in `SOA` concentrations |\n", + "| `STKHGT` | m | stack height — POINT frames only |\n", + "| `STKDIAM` | m | stack exit diameter |\n", + "| `STKTEMP` | K | exit gas temperature |\n", + "| `STKVEL` | m/s | exit gas velocity |\n", + "\n", + "Each record should either have information for all four stack parameter columns or for none. \n", + "If the stack parameters are specified, a point source's mass is allocated to a vertical emission height using a plume rise algorithm; \n", + "otherwise emissions are assumed to occur at ground level.\n", + "\n", + "Below, we will demonstrate a couple of analyses to get you started:" + ] + }, + { + "cell_type": "markdown", + "id": "e10732b1", + "metadata": {}, + "source": [ + "\n", + "### Example point source analysis\n", + "\n", + "The cell below creates a function that download's a US EPA emissions inventory for electricity generating units (EGUs)\n", + "and processes it into the required geodataframe format described above:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b82a18f7", + "metadata": {}, + "outputs": [], + "source": [ + "FF10_URL = (\"https://gaftp.epa.gov/air/emismod/2016/alpha/2016fd/emissions/\"\n", + " \"2016fd_inputs_point.zip\")\n", + "\n", + "# FF10 point columns are positional (0-based), as EarthSciIO's own reader has\n", + "# them; isrm_point.esm's metadata.x_esd.columns names the same indices.\n", + "FF10 = {12: \"POLID\", 13: \"ANN_VALUE\", 17: \"STKHGT\", 18: \"STKDIAM\",\n", + " 19: \"STKTEMP\", 21: \"STKVEL\", 23: \"LONGITUDE\", 24: \"LATITUDE\"}\n", + "\n", + "SHORT_TON_KG = 907.18474\n", + "\n", + "\n", + "def _compared_codes(node, found=None):\n", + " \"\"\"Every integer an `==` in this expression compares against.\n", + "\n", + " Collected by walking rather than by indexing, because the shape of a mask\n", + " depends on how many codes it covers: `is_VOC` is an `or` of 35 `==` nodes\n", + " and `is_NH3` is a single bare `==`.\n", + " \"\"\"\n", + " found = set() if found is None else found\n", + " if isinstance(node, dict):\n", + " if node.get(\"op\") == \"==\":\n", + " args = node.get(\"args\") or []\n", + " if len(args) == 2 and isinstance(args[1], (int, float)):\n", + " found.add(int(args[1]))\n", + " for value in node.values():\n", + " _compared_codes(value, found)\n", + " elif isinstance(node, list):\n", + " for item in node:\n", + " _compared_codes(item, found)\n", + " return found\n", + "\n", + "\n", + "def pollutant_classes():\n", + " \"\"\"`POLID` -> emission column, read out of isrm_point.esm itself.\"\"\"\n", + " model = json.loads(download(REPO_RAW + \"isrm_point.esm\"))[\"models\"][\"ISRM\"]\n", + " codes = model[\"variables\"][\"pollutant\"][\"update\"][\"from\"][\"codes\"][\"map\"]\n", + " classes = {}\n", + " for column in PATHWAYS:\n", + " mask = next(e for e in model[\"equations\"] if e[\"lhs\"] == f\"is_{column}\")\n", + " wanted = _compared_codes(mask[\"rhs\"])\n", + " for polid, code in codes.items():\n", + " if code in wanted:\n", + " classes[polid.upper()] = column\n", + " return classes\n", + "\n", + "\n", + "def egu_points(limit=None):\n", + " \"\"\"The EGU inventory as one row per stack, in SI units.\"\"\"\n", + " classes = pollutant_classes()\n", + " with zipfile.ZipFile(io.BytesIO(download(FF10_URL))) as archive:\n", + " member = next(n for n in archive.namelist()\n", + " if \"egu\" in n.lower() and not n.endswith(\"/\"))\n", + " raw = pd.read_csv(io.BytesIO(archive.read(member)), header=None, comment=\"#\",\n", + " usecols=list(FF10), names=None, dtype=str,\n", + " engine=\"python\", on_bad_lines=\"skip\")\n", + " raw = raw.rename(columns=FF10)\n", + " # One asserted header line survives the '#' comments.\n", + " if str(raw.iloc[0][\"POLID\"]).strip().lower() in (\"polid\", \"poll\"):\n", + " raw = raw.iloc[1:]\n", + " print(f\" {member}: {len(raw):,} FF10 rows\")\n", + "\n", + " raw[\"column\"] = raw[\"POLID\"].str.strip().str.upper().map(classes)\n", + " raw = raw.dropna(subset=[\"column\"])\n", + " numeric = [\"ANN_VALUE\", \"STKHGT\", \"STKDIAM\", \"STKTEMP\", \"STKVEL\",\n", + " \"LONGITUDE\", \"LATITUDE\"]\n", + " for name in numeric:\n", + " raw[name] = pd.to_numeric(raw[name], errors=\"coerce\")\n", + " raw = raw.dropna(subset=numeric)\n", + " print(f\" {len(raw):,} rows classified into {sorted(raw['column'].unique())}\")\n", + "\n", + " # A stack IS its location plus its four parameters: rows that agree on all\n", + " # six are the same physical stack, and summing them is exact for a linear\n", + " # model. Pivoting on that key is what turns long into wide.\n", + " key = [\"LONGITUDE\", \"LATITUDE\", \"STKHGT\", \"STKDIAM\", \"STKTEMP\", \"STKVEL\"]\n", + " wide = (raw.pivot_table(index=key, columns=\"column\", values=\"ANN_VALUE\",\n", + " aggfunc=\"sum\", fill_value=0.0)\n", + " .reset_index())\n", + " wide.columns.name = None\n", + " print(f\" pivoted to {len(wide):,} stacks\")\n", + " if limit:\n", + " wide = wide.head(limit)\n", + "\n", + " emissions = [c for c in PATHWAYS if c in wide.columns]\n", + " for column in emissions:\n", + " wide[column] = wide[column] * SHORT_TON_KG # short ton/yr -> kg/yr\n", + " wide[\"STKHGT\"] = wide[\"STKHGT\"] * 0.3048 # ft -> m\n", + " wide[\"STKDIAM\"] = wide[\"STKDIAM\"] * 0.3048\n", + " wide[\"STKVEL\"] = wide[\"STKVEL\"] * 0.3048 # ft/s -> m/s\n", + " wide[\"STKTEMP\"] = (wide[\"STKTEMP\"] - 32.0) * 5.0 / 9.0 + 273.15 # degF -> K\n", + "\n", + " return gpd.GeoDataFrame(\n", + " wide[emissions + STACK],\n", + " geometry=gpd.points_from_xy(wide[\"LONGITUDE\"], wide[\"LATITUDE\"]),\n", + " crs=\"EPSG:4269\")" + ] + }, + { + "cell_type": "markdown", + "id": "a146319f", + "metadata": {}, + "source": [ + "Now, we can run the function we created above to get the emissions geodataframe:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88c801ac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 2016fd_cb6_16j/inputs/ptegu/egucems_2016v2_POINT_20180327_HCLCLaug_12apr2018_v2.csv: 93,459 FF10 rows\n", + " 24,597 rows classified into ['NH3', 'NOx', 'PM25', 'SOx', 'VOC']\n", + " pivoted to 2,159 stacks\n", + "\n", + "PM25 1.336610e+06\n", + "VOC 5.199170e+05\n", + "NOx 4.129675e+06\n", + "NH3 9.602069e+05\n", + "SOx 3.480194e+06\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PM25VOCNOxNH3SOxSTKHGTSTKDIAMSTKTEMPSTKVELgeometry
021772.4337607348.19639471331.9361062068.3812077457.05856354.86404.2672372.0388890.272278POINT (-122.6862 48.8287)
12449.39879890.7184748164.6626603265.865064544.31084425.60323.3528394.26111121.153120POINT (-122.487 48.7451)
21451.49558490.7184746350.2931802177.243376362.87389625.60323.3528394.26111121.153120POINT (-122.487 48.7454)
\n", + "
" + ], + "text/plain": [ + " PM25 VOC NOx NH3 SOx STKHGT \\\n", + "0 21772.433760 7348.196394 71331.936106 2068.381207 7457.058563 54.8640 \n", + "1 2449.398798 90.718474 8164.662660 3265.865064 544.310844 25.6032 \n", + "2 1451.495584 90.718474 6350.293180 2177.243376 362.873896 25.6032 \n", + "\n", + " STKDIAM STKTEMP STKVEL geometry \n", + "0 4.2672 372.038889 0.272278 POINT (-122.6862 48.8287) \n", + "1 3.3528 394.261111 21.153120 POINT (-122.487 48.7451) \n", + "2 3.3528 394.261111 21.153120 POINT (-122.487 48.7454) " + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "points = egu_points(limit=100) # <- Change to limit=None to run the full inventory. The limit is just for a quick test.\n", + "print()\n", + "print(points[[c for c in PATHWAYS if c in points.columns]].sum().to_string())\n", + "points.head(3)" + ] + }, + { + "cell_type": "markdown", + "id": "5a9f9266", + "metadata": {}, + "source": [ + "Now, we can run the `run_isrm` function we created at the top of the notebook to calculate the resulting PM2.5 concentrations. It can take a while, depending on how many emissions records you are processing. Also, there will be a progress bar but it may get stuck for a while at around 75%; this is normal." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "243d6332", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "layer\n", + " 100 records · point · nvert_max 1 · PM25, VOC, NOx, NH3, SOx, STKHGT, STKDIAM, STKTEMP, STKVEL · ASME plume rise\n", + "upload\n", + " uploaded emis.zip (26,476 B) as dataset 7e562bc1-6aea-4bdd-aab1-34b0c0b435b0\n", + "document\n", + " isrm_gdf_point.esm · emis_vertex width 1 · valid\n", + "quote\n", + " cloud_batch · 4.0 vCPU / 16384 MB · 10m00s predicted (cap 1h20m) · $0.04\n", + "run\n", + " run 8a632caa-d3f0-41e5-babc-f53900505468 — running on cloud_batch, $0.04\n", + " queued\n", + " started\n", + " [###################################### ] 96.3% elapsed 2m32s\n", + " succeeded in 2m11s of resource time\n", + " sum(TotalPM25) 281.24156822422736\n", + " sum(deathsK) 43.91889991152327\n", + " sum(deathsL) 98.79455102893459\n" + ] + } + ], + "source": [ + "point_receptors = run_isrm(points)" + ] + }, + { + "cell_type": "markdown", + "id": "e0a1f493", + "metadata": {}, + "source": [ + "#### Plotting the result\n", + "\n", + "The cell below creates a function to show our calculate concentrations or health impacts on a map:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "14eb6fe6", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import ListedColormap\n", + "\n", + "# `Blues` with its white end trimmed off: at pure white the lowest cells are\n", + "# invisible against the page.\n", + "SEQUENTIAL = ListedColormap(plt.get_cmap(\"Blues\")(np.linspace(0.15, 1.0, 256)))\n", + "\n", + "# State outlines, to give the concentration field somewhere to stand. 20m is the\n", + "# coarsest of the three cartographic generalisations the Census publishes — at\n", + "# the scale these maps are drawn at, the finer ones are only more vertices.\n", + "STATES_URL = (\"https://www2.census.gov/geo/tiger/GENZ2020/shp/\"\n", + " \"cb_2020_us_state_20m.zip\")\n", + "\n", + "_states = {}\n", + "\n", + "\n", + "def states():\n", + " \"\"\"State boundaries in the receptor grid's projection, read once.\"\"\"\n", + " if \"gdf\" not in _states:\n", + " _states[\"gdf\"] = gpd.read_file(io.BytesIO(download(STATES_URL))).to_crs(LCC)\n", + " return _states[\"gdf\"]\n", + "\n", + "\n", + "def show(receptors, title=\"\", column=\"TotalPM25\", units=\"µg/m³\",\n", + " clip_pct=99.0, share=1.0, height=6.4, boundaries=True):\n", + " \"\"\"The receptor grid as a choropleth.\"\"\"\n", + " v = receptors[column].to_numpy()\n", + " vmax = np.percentile(v, clip_pct) or v.max() or 1.0\n", + "\n", + " bounds = receptors.total_bounds\n", + " if share:\n", + " order = np.argsort(v)[::-1]\n", + " keep = order[:np.searchsorted(np.cumsum(v[order]), v.sum() * share) + 1]\n", + " bounds = receptors.iloc[keep].total_bounds\n", + " x0, y0, x1, y1 = bounds\n", + " pad = 0.06 * max(x1 - x0, y1 - y0)\n", + "\n", + " # The figure follows the MAP's shape: these are metres in both directions, so\n", + " # the axes are equal-aspect and their width follows the extent.\n", + " span = height * (x1 - x0) / (y1 - y0)\n", + " fig, ax = plt.subplots(figsize=(min(13.0, max(4.5, span)) + 1.8, height), dpi=150)\n", + "\n", + " # No edge colour: at 52,411 cells a stroke per rectangle is most of the ink on\n", + " # the page, and the boundaries it draws are the grid's, not the data's.\n", + " receptors.plot(ax=ax, column=column, cmap=SEQUENTIAL, vmin=0.0, vmax=vmax,\n", + " linewidth=0.0, edgecolor=\"none\", rasterized=True, legend=True,\n", + " legend_kwds={\"label\": f\"{column} ({units})\", \"shrink\": 0.55,\n", + " \"extend\": \"max\" if v.max() > vmax else \"neither\"})\n", + "\n", + " # Over the choropleth, and thin enough not to compete with it. Reprojected to\n", + " # whatever CRS the caller handed the receptors over in, so a `.to_crs(...)`\n", + " # upstream carries the outlines with it.\n", + " if boundaries:\n", + " states().to_crs(receptors.crs).boundary.plot(\n", + " ax=ax, color=\"0.35\", linewidth=0.4, zorder=3)\n", + "\n", + " ax.set_xlim(x0 - pad, x1 + pad)\n", + " ax.set_ylim(y0 - pad, y1 + pad)\n", + " ax.set_aspect(\"equal\")\n", + " ax.set_axis_off()\n", + " ax.set_title(\n", + " f\"{title or column}\\n\"\n", + " f\"{receptors.attrs.get('records', len(receptors)):,} emission records · \"\n", + " f\"{', '.join(receptors.attrs.get('pathways', []))} · \"\n", + " f\"run {receptors.attrs.get('run_id', '?')[:8]}\\n\"\n", + " f\"scale clipped at the {clip_pct:g}th percentile ({vmax:.3g} {units}); \"\n", + " f\"true maximum {v.max():.3g} {units}\",\n", + " fontsize=9, loc=\"left\")\n", + " fig.tight_layout()\n", + " return ax" + ] + }, + { + "cell_type": "markdown", + "id": "10ccb18d", + "metadata": {}, + "source": [ + "Now, we can use that function to make our map:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "d015f6cd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show(point_receptors, \"PM2.5 from EGU point sources, through the InMAP ISRM\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "94a2e602", + "metadata": {}, + "source": [ + "---\n", + "### Example area source analysis\n", + "\n", + "We can use the same set of functions with a polygon-type geodataframe to simulate impacts of area emission sources. Here, we give all the counties in Illinois a consistent rate of emissions:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "e6e399b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "102 counties · 143,778,461 kg/yr of primary PM2.5\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NAMEPM25geometry
2Stephenson1461392.061POLYGON ((-89.92647 42.50579, -89.83759 42.504...
11Putnam414649.315POLYGON ((-89.46639 41.23387, -89.35673 41.233...
105Richland932484.098POLYGON ((-88.25778 38.73114, -88.25858 38.847...
\n", + "
" + ], + "text/plain": [ + " NAME PM25 \\\n", + "2 Stephenson 1461392.061 \n", + "11 Putnam 414649.315 \n", + "105 Richland 932484.098 \n", + "\n", + " geometry \n", + "2 POLYGON ((-89.92647 42.50579, -89.83759 42.504... \n", + "11 POLYGON ((-89.46639 41.23387, -89.35673 41.233... \n", + "105 POLYGON ((-88.25778 38.73114, -88.25858 38.847... " + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "COUNTIES_URL = (\"https://www2.census.gov/geo/tiger/GENZ2020/shp/\"\n", + " \"cb_2020_us_county_20m.zip\")\n", + "STATE = \"17\" # Illinois\n", + "RATE_PM25 = 1000.0 # kg/yr per km² of land area — an example rate\n", + "\n", + "counties = gpd.read_file(io.BytesIO(download(COUNTIES_URL)))\n", + "counties = counties[counties[\"STATEFP\"] == STATE].copy()\n", + "counties[\"PM25\"] = RATE_PM25 * counties[\"ALAND\"] / 1e6\n", + "polygons = counties[[\"NAME\", \"PM25\", \"geometry\"]]\n", + "print(f\"{len(polygons)} counties · {polygons['PM25'].sum():,.0f} kg/yr of primary PM2.5\")\n", + "polygons.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "606ab3b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "layer\n", + " 102 records · polygon · nvert_max 56 · PM25\n", + "upload\n", + " uploaded emis.zip (32,094 B) as dataset bec630dc-e16d-4d6c-ba6c-bff82fe70e6d\n", + "document\n", + " pruned 20 variable(s)/source(s); 1 pathway(s) kept: PrimaryPM25\n", + " isrm_gdf_polygon.esm · poly_vertex width 56 · valid\n", + "quote\n", + " cloud_batch · 4.0 vCPU / 16384 MB · 10m00s predicted (cap 1h20m) · $0.04\n", + "run\n", + " run 74baed7f-877c-4f68-8319-4df323e75605 — running on cloud_batch, $0.04\n", + " queued\n", + " started\n", + " [####################################### ] 97.6% elapsed 2m34s\n", + " succeeded in 2m14s of resource time\n", + " sum(TotalPM25) 4219.068006714893\n", + " sum(deathsK) 1406.9517405485624\n", + " sum(deathsL) 3176.194766023125\n" + ] + } + ], + "source": [ + "polygon_receptors = run_isrm(polygons)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "1bc2aaad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show(polygon_receptors, \"PM2.5 from an Illinois county area-source layer\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "12e0bac9", + "metadata": {}, + "source": [ + "---\n", + "## Example line source analysis\n", + "\n", + "Here, we calculate impacts of emissions on interstates in Illinois, with a constant rate of emission per kilometer of road. Before running the air quality analysis, we simplify the line shapes to reduce computational burden. (We simplify to 200m segments, which is still one fifth of InMAP's smallest grid cells.)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "668e95cf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "292 road(s) · 7,350 km · 294,004 kg/yr PM2.5, 2,940,040 kg/yr NOx\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FULLNAMEPM25NOxgeometry
4056I- 57527.6539895276.539890LINESTRING (729166.377 -47083.84, 729759.571 -...
4061I- 3551153.17838711531.783871LINESTRING (739525.605 227788.524, 739083.546 ...
4089I- 2941434.35802414343.580243LINESTRING (747536.216 242857.167, 747643.526 ...
\n", + "
" + ], + "text/plain": [ + " FULLNAME PM25 NOx \\\n", + "4056 I- 57 527.653989 5276.539890 \n", + "4061 I- 355 1153.178387 11531.783871 \n", + "4089 I- 294 1434.358024 14343.580243 \n", + "\n", + " geometry \n", + "4056 LINESTRING (729166.377 -47083.84, 729759.571 -... \n", + "4061 LINESTRING (739525.605 227788.524, 739083.546 ... \n", + "4089 LINESTRING (747536.216 242857.167, 747643.526 ... " + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ROADS_URL = (f\"https://www2.census.gov/geo/tiger/TIGER2020/PRISECROADS/\"\n", + " f\"tl_2020_{STATE}_prisecroads.zip\")\n", + "SIMPLIFY_M = 200.0 # a fifth of the ISRM grid's finest cell\n", + "RATE_ROAD_PM25 = 40.0 # kg/yr per km of road — example rates, as above\n", + "RATE_ROAD_NOX = 400.0\n", + "\n", + "roads = gpd.read_file(io.BytesIO(download(ROADS_URL)))\n", + "interstates = roads[(roads[\"MTFCC\"] == \"S1100\") & (roads[\"RTTYP\"] == \"I\")].to_crs(LCC)\n", + "interstates[\"geometry\"] = interstates.simplify(SIMPLIFY_M)\n", + "\n", + "km = interstates.length / 1000.0\n", + "interstates[\"PM25\"] = RATE_ROAD_PM25 * km\n", + "interstates[\"NOx\"] = RATE_ROAD_NOX * km\n", + "lines = interstates[[\"FULLNAME\", \"PM25\", \"NOx\", \"geometry\"]]\n", + "print(f\"{len(lines)} road(s) · {km.sum():,.0f} km · \"\n", + " f\"{lines['PM25'].sum():,.0f} kg/yr PM2.5, {lines['NOx'].sum():,.0f} kg/yr NOx\")\n", + "lines.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "a0ba4ddd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "layer\n", + " cut 292 polyline(s) into 1931 two-vertex segment(s)\n", + " 1,931 records · line · nvert_max 2 · PM25, NOx\n", + "upload\n", + " uploaded emis.zip (280,947 B) as dataset 3295a982-c57f-4c9c-bb72-483cdc82cf28\n", + "document\n", + " pruned 15 variable(s)/source(s); 2 pathway(s) kept: PrimaryPM25, pNO3\n", + " isrm_gdf_line.esm · line_vertex width 2 · valid\n", + "quote\n", + " cloud_batch · 4.0 vCPU / 16384 MB · 10m00s predicted (cap 1h20m) · $0.04\n", + "run\n", + " run 90026046-ca04-4022-b854-3a9313bd29a2 — running on cloud_batch, $0.04\n", + " queued\n", + " started\n", + " [###################################### ] 96.9% elapsed 2m26s\n", + " succeeded in 2m03s of resource time\n", + " sum(TotalPM25) 42.41880153885225\n", + " sum(deathsK) 13.106555416146492\n", + " sum(deathsL) 29.473888255125694\n" + ] + } + ], + "source": [ + "line_receptors = run_isrm(lines)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "040a0468", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show(line_receptors, \"PM2.5 from Illinois interstate line sources\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ef1782c1", + "metadata": {}, + "source": [ + "---\n", + "## Cleaning up\n", + "\n", + "Each run uploaded an emissions dataset. You will theoretically be billed for storing these on the server, although the cost for files this size is minimal. The cell below will delete them, you can also do it at https://earthscilab.com." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "55e3c2ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "deleted 7e562bc1-6aea-4bdd-aab1-34b0c0b435b0\n", + "deleted bec630dc-e16d-4d6c-ba6c-bff82fe70e6d\n", + "deleted 3295a982-c57f-4c9c-bb72-483cdc82cf28\n" + ] + } + ], + "source": [ + "for receptors in (point_receptors, polygon_receptors, line_receptors):\n", + " dataset_id = receptors.attrs[\"dataset_id\"]\n", + " http_json(\"DELETE\", f\"{API}/datasets/{dataset_id}\", headers=session.headers())\n", + " print(\"deleted\", dataset_id)" + ] + }, + { + "cell_type": "markdown", + "id": "5f449a5b", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "That's all for this tutorial! If you have any questions or run into any issues, feel free to get touch at https://earthsciml.discourse.group/ or https://groups.google.com/g/inmap-users." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv (3.14.3.final.0)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/website/static/blog/2026-09-09-isrm-esm/output_15_0.png b/website/static/blog/2026-09-09-isrm-esm/output_15_0.png new file mode 100644 index 000000000..c19e06488 Binary files /dev/null and b/website/static/blog/2026-09-09-isrm-esm/output_15_0.png differ diff --git a/website/static/blog/2026-09-09-isrm-esm/output_19_0.png b/website/static/blog/2026-09-09-isrm-esm/output_19_0.png new file mode 100644 index 000000000..7c472a0ff Binary files /dev/null and b/website/static/blog/2026-09-09-isrm-esm/output_19_0.png differ diff --git a/website/static/blog/2026-09-09-isrm-esm/output_23_0.png b/website/static/blog/2026-09-09-isrm-esm/output_23_0.png new file mode 100644 index 000000000..73172e88a Binary files /dev/null and b/website/static/blog/2026-09-09-isrm-esm/output_23_0.png differ