shamash-orogen 0.2.0__tar.gz

shamash_orogen-0.2.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: shamash-orogen
+Version: 0.2.0
+Summary: Algorithms that turn a plate-tectonic history into terrain: seafloor age and depth, collision history, and from there a global DEM.
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: shapely>=2
+
+# shamash-orogen
+
+Algorithms that turn a plate-tectonic history into terrain: the
+reconstruction of the plates themselves, and from it global lon/lat grids that
+GDAL and QGIS read directly. Its input is one tectonics phase as
+[shamash-core](https://codeberg.org/schobernoise/shamash-core) lays it out
+(`<body>/tectonics/phase-N/`: the plates and continents as drawn and every
+plate's Euler pole; then a snapshot of them every few Myr, and the present with
+new seafloor shared along mid-ocean ridges). shamash-core depends on it and
+calls it in-process.
+
+Plain Python with numpy and shapely; it never imports GDAL, QGIS or pygplates:
+
+```bash
+uv pip install --python ~/Dev/projects/shamash/shamash-core/venv/bin/python -e ~/Dev/projects/shamash-orogen
+```
+
+## Algorithms
+
+One verb each, all `python -m orogen VERB PHASE OUT [--resolution DEG] [--crs WKTFILE]`
+but `reconstruct`, which writes into the phase:
+
+- **`reconstruct`**: the plates drawn at `duration` Ma turned rigidly about
+  their Euler poles at a constant rate to 0 Ma (Rodrigues' rotation, Cox &
+  Hart 1986), cut at the antimeridian and closed through a pole a plate comes
+  to cover; continents split along the plates and carried by them; slivers of
+  imperfect snapping resolved; the overlap and gap reported. Writes
+  `reconstructed/{plates,continents}_<t>Ma.geojson` every `step` Myr and
+  `next/`, the present made to tile the globe again (overlaps to the plate
+  with more continent, gaps shared along mid-ocean ridges). ea's 19 plates,
+  21 snapshots: 4 s.
+- **`seafloor`**: seafloor age and depth at the present. Within each plate's
+  half of an opened ocean, age runs from 0 at the ridge to the phase's duration
+  at the plate's edge; ocean floor older than the phase is assumed `duration +
+  --initial-age` (60 Myr). Depth from age by GDH1 (Stein & Stein 1992).
+  Writes `seafloor_age.asc`, `seafloor_depth.asc`.
+- **`history`**: where the action was. On a fixed grid, the Myr each cell lay
+  under two or more plates (convergence) and under none (divergence) over the
+  phase. Writes `overlap_myr.asc`, `gap_myr.asc`.
+- **`boundaries`**: the present plate boundaries every 0.5°, classified from
+  the two plates' Euler-pole velocities and the crust on each side:
+  collision, subduction, island arc, rift, ridge, transform; with the
+  shortening each has seen (closing rate × duration). Writes
+  `boundaries.geojson`.
+- **`orogeny`**: the relief the boundaries raise or cut, Earth-shaped
+  heuristic profiles across each kind (flat-topped collision ranges, trench and
+  cordillera, trench and island arc, rift valley). Writes `relief.asc`.
+- **`dem`**: everything composed: continental lowlands rising inland, shelf
+  and slope down to the age-depth ocean floor, the boundaries' relief, and
+  fractal noise on the sphere, rougher where the ground was raised; relief and
+  noise scaled by Earth's gravity over `--gravity`, clipped to `--range`.
+  Writes `dem.png` (16-bit, `--range` spans black to white), `dem_8bit.png`
+  (the same rounded away from sea level, for a drawing program to reproduce
+  exactly) and `dem.json`,
+  and with `--asc` the float grid `dem.asc`. ea's phase 1 at 0.1°: 2 minutes.
+
+- **`climate`** (`orogen climate DEM_PNG OUT --planet planet.json --range LOW
+  HIGH`): a body's climate from its heights and the parameters shamash-core
+  writes to `climate/planet.json`. A seasonal energy balance model on the
+  lon/lat grid (outgoing radiation linearised about the body's own
+  equilibrium, moist and anisotropic heat transport, ice that brightens the
+  albedo while its global mean stays the body's Bond albedo), Hadley cells
+  from Held & Hou scaled to Earth's 30 deg, an ITCZ that follows the warmest
+  air, rain at the ITCZ and along storm tracks, carried upwind over land by a
+  semi-Lagrangian sweep, and the sea's heat carried by wind-driven gyres
+  (`ocean.py`, the Stommel model: western boundary currents, coastal
+  upwelling). Writes monthly-derived temperatures, precipitation,
+  Köppen-Geiger classes (`koppen.py`, Kottek et al. 2006, coloured as Beck et
+  al. 2018), solstice winds, ocean currents and `climate.json`. Earth at
+  1 deg: 23 s, 64% of land cells in the right main class.
+
+`--crs` takes the body's geographic CRS as WKT (shamash-core's
+`qgis/project.json` holds it) and writes it beside each grid as a `.prj`.
+
+## Roadmap
+
+- [x] Seafloor age and depth, convergence footprint (0.5° in seconds)
+- [x] Plate boundaries classified from relative Euler velocities: collision,
+      subduction, island arc, rift, transform
+- [x] Mountain, trench and arc profiles from them
+- [x] One global DEM at 0.1°, as a 16-bit PNG
+- [ ] Erosion: the ranges are smooth heuristic profiles plus noise, with no
+      valleys cut by water
+- [ ] More than one phase: ocean floor and mountains carried from phase to
+      phase instead of each phase starting fresh
+- [x] `shamash map terrain`, writing the inputs and running this
+- [x] The reconstruction itself, replacing pygplates (2026-10-16)
+- [x] A climate model with Köppen-Geiger classes (2026-10-16)
+- [x] Wind-driven ocean currents and coastal upwelling (2026-10-16)
+- [ ] Climate: monsoons, a North Atlantic Drift that reaches Norway, cloud-albedo
+- [ ] Release to PyPI, since shamash-core depends on it

shamash_orogen-0.2.0/README.md

@@ -0,0 +1,91 @@
+# shamash-orogen
+
+Algorithms that turn a plate-tectonic history into terrain: the
+reconstruction of the plates themselves, and from it global lon/lat grids that
+GDAL and QGIS read directly. Its input is one tectonics phase as
+[shamash-core](https://codeberg.org/schobernoise/shamash-core) lays it out
+(`<body>/tectonics/phase-N/`: the plates and continents as drawn and every
+plate's Euler pole; then a snapshot of them every few Myr, and the present with
+new seafloor shared along mid-ocean ridges). shamash-core depends on it and
+calls it in-process.
+
+Plain Python with numpy and shapely; it never imports GDAL, QGIS or pygplates:
+
+```bash
+uv pip install --python ~/Dev/projects/shamash/shamash-core/venv/bin/python -e ~/Dev/projects/shamash-orogen
+```
+
+## Algorithms
+
+One verb each, all `python -m orogen VERB PHASE OUT [--resolution DEG] [--crs WKTFILE]`
+but `reconstruct`, which writes into the phase:
+
+- **`reconstruct`**: the plates drawn at `duration` Ma turned rigidly about
+  their Euler poles at a constant rate to 0 Ma (Rodrigues' rotation, Cox &
+  Hart 1986), cut at the antimeridian and closed through a pole a plate comes
+  to cover; continents split along the plates and carried by them; slivers of
+  imperfect snapping resolved; the overlap and gap reported. Writes
+  `reconstructed/{plates,continents}_<t>Ma.geojson` every `step` Myr and
+  `next/`, the present made to tile the globe again (overlaps to the plate
+  with more continent, gaps shared along mid-ocean ridges). ea's 19 plates,
+  21 snapshots: 4 s.
+- **`seafloor`**: seafloor age and depth at the present. Within each plate's
+  half of an opened ocean, age runs from 0 at the ridge to the phase's duration
+  at the plate's edge; ocean floor older than the phase is assumed `duration +
+  --initial-age` (60 Myr). Depth from age by GDH1 (Stein & Stein 1992).
+  Writes `seafloor_age.asc`, `seafloor_depth.asc`.
+- **`history`**: where the action was. On a fixed grid, the Myr each cell lay
+  under two or more plates (convergence) and under none (divergence) over the
+  phase. Writes `overlap_myr.asc`, `gap_myr.asc`.
+- **`boundaries`**: the present plate boundaries every 0.5°, classified from
+  the two plates' Euler-pole velocities and the crust on each side:
+  collision, subduction, island arc, rift, ridge, transform; with the
+  shortening each has seen (closing rate × duration). Writes
+  `boundaries.geojson`.
+- **`orogeny`**: the relief the boundaries raise or cut, Earth-shaped
+  heuristic profiles across each kind (flat-topped collision ranges, trench and
+  cordillera, trench and island arc, rift valley). Writes `relief.asc`.
+- **`dem`**: everything composed: continental lowlands rising inland, shelf
+  and slope down to the age-depth ocean floor, the boundaries' relief, and
+  fractal noise on the sphere, rougher where the ground was raised; relief and
+  noise scaled by Earth's gravity over `--gravity`, clipped to `--range`.
+  Writes `dem.png` (16-bit, `--range` spans black to white), `dem_8bit.png`
+  (the same rounded away from sea level, for a drawing program to reproduce
+  exactly) and `dem.json`,
+  and with `--asc` the float grid `dem.asc`. ea's phase 1 at 0.1°: 2 minutes.
+
+- **`climate`** (`orogen climate DEM_PNG OUT --planet planet.json --range LOW
+  HIGH`): a body's climate from its heights and the parameters shamash-core
+  writes to `climate/planet.json`. A seasonal energy balance model on the
+  lon/lat grid (outgoing radiation linearised about the body's own
+  equilibrium, moist and anisotropic heat transport, ice that brightens the
+  albedo while its global mean stays the body's Bond albedo), Hadley cells
+  from Held & Hou scaled to Earth's 30 deg, an ITCZ that follows the warmest
+  air, rain at the ITCZ and along storm tracks, carried upwind over land by a
+  semi-Lagrangian sweep, and the sea's heat carried by wind-driven gyres
+  (`ocean.py`, the Stommel model: western boundary currents, coastal
+  upwelling). Writes monthly-derived temperatures, precipitation,
+  Köppen-Geiger classes (`koppen.py`, Kottek et al. 2006, coloured as Beck et
+  al. 2018), solstice winds, ocean currents and `climate.json`. Earth at
+  1 deg: 23 s, 64% of land cells in the right main class.
+
+`--crs` takes the body's geographic CRS as WKT (shamash-core's
+`qgis/project.json` holds it) and writes it beside each grid as a `.prj`.
+
+## Roadmap
+
+- [x] Seafloor age and depth, convergence footprint (0.5° in seconds)
+- [x] Plate boundaries classified from relative Euler velocities: collision,
+      subduction, island arc, rift, transform
+- [x] Mountain, trench and arc profiles from them
+- [x] One global DEM at 0.1°, as a 16-bit PNG
+- [ ] Erosion: the ranges are smooth heuristic profiles plus noise, with no
+      valleys cut by water
+- [ ] More than one phase: ocean floor and mountains carried from phase to
+      phase instead of each phase starting fresh
+- [x] `shamash map terrain`, writing the inputs and running this
+- [x] The reconstruction itself, replacing pygplates (2026-10-16)
+- [x] A climate model with Köppen-Geiger classes (2026-10-16)
+- [x] Wind-driven ocean currents and coastal upwelling (2026-10-16)
+- [ ] Climate: monsoons, a North Atlantic Drift that reaches Norway, cloud-albedo
+- [ ] Release to PyPI, since shamash-core depends on it

shamash_orogen-0.2.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "shamash-orogen"
+version = "0.2.0"
+description = "Algorithms that turn a plate-tectonic history into terrain: seafloor age and depth, collision history, and from there a global DEM."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+dependencies = [
+    "numpy",
+    "shapely>=2",
+]
+
+[project.scripts]
+orogen = "orogen.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}

shamash_orogen-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

shamash_orogen-0.2.0/src/orogen/__init__.py

@@ -0,0 +1 @@
+"""Algorithms that turn a plate-tectonic history into terrain."""

shamash_orogen-0.2.0/src/orogen/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from orogen.cli import main
+
+sys.exit(main())

shamash_orogen-0.2.0/src/orogen/boundaries.py

@@ -0,0 +1,251 @@
+"""The present plate boundaries of a phase, sampled and classified.
+
+Boundaries are where the plates of next/ meet -- the present with overlaps
+resolved and new seafloor shared along ridges, so the plates tile the globe.
+Every SPACING degrees along each, the two plates' velocities come from their
+Euler poles (v = omega x r, the phase's constant rotations): the part across
+the boundary says whether they close or open, the part along it marks a
+transform. The crust a few hundred km to each side then names the kind:
+
+    closing   continent | continent  -> collision
+              ocean | continent      -> subduction, the ocean going under
+              ocean | ocean          -> island arc, the older floor going under
+    opening   continent on either side -> rift; ocean only -> ridge
+    sliding   -> transform
+
+Since the rotations are constant, a boundary point has closed at the same
+rate all phase long: shortening = closing rate x duration (mm/yr x Myr = km).
+"""
+
+import dataclasses
+import json
+import math
+from collections import Counter
+from dataclasses import dataclass
+
+import numpy
+import shapely
+
+from orogen import phase
+
+#: Degrees between boundary samples.
+SPACING = 0.5
+
+#: Degrees to each side of a boundary at which its crust is looked up.
+SIDE = 1.5
+
+#: mm/yr below which a boundary is not moving at all.
+STILL = 1.0
+
+#: A boundary closes or opens when that part of the motion is at least this
+#: share of the sliding part; otherwise it is a transform.
+DOMINANT = 0.5
+
+#: Samples to each side over which a boundary's kind, and its shortening, are
+#: smoothed along it. Near a threshold the kind flickered from sample to
+#: sample (dashed trenches), and shortening jumping between neighbours cut
+#: straight steps into the ranges.
+KIND_WINDOW = 3
+SHORTENING_WINDOW = 5
+
+
+@dataclass(frozen=True)
+class Sample:
+    lon: float
+    lat: float
+    normal: tuple  # (east, north) unit vector into the overriding side
+    kind: str
+    closing: float  # mm/yr, negative when opening
+    sliding: float  # mm/yr
+    shortening: float  # km over the phase, 0 unless closing
+
+
+def angular_velocities(settings: dict) -> dict:
+    """{plate_id: omega, rad/Myr as an xyz vector}."""
+    return {
+        plate["plate_id"]: math.radians(plate["rate"])
+        * unit(plate["pole"]["lon"], plate["pole"]["lat"])
+        for plate in settings["plates"]
+    }
+
+
+def unit(lon, lat) -> numpy.ndarray:
+    lon, lat = math.radians(lon), math.radians(lat)
+    return numpy.array(
+        [math.cos(lat) * math.cos(lon), math.cos(lat) * math.sin(lon), math.sin(lat)]
+    )
+
+
+def local_velocity(omega, lon, lat, radius_km) -> numpy.ndarray:
+    """(east, north) velocity in km/Myr, i.e. mm/yr, of a point on a plate."""
+    v = radius_km * numpy.cross(omega, unit(lon, lat))
+    east = numpy.array([-math.sin(math.radians(lon)), math.cos(math.radians(lon)), 0])
+    north = numpy.cross(unit(lon, lat), east)
+    return numpy.array([v @ east, v @ north])
+
+
+def classify(directory, age_at) -> list:
+    """Every boundary sample of the phase's present. age_at(lon, lat) gives
+    the seafloor age there, to tell which ocean floor is older."""
+    settings = phase.settings(directory)
+    omega = angular_velocities(settings)
+    radius = settings["radius"] / 1000
+    duration = float(settings["duration"])
+    plates = phase.plates(directory / "next" / "plates.geojson")
+    land = phase.land(phase.snapshot(directory, "continents", 0.0))
+    shapely.prepare(land)
+    samples = []
+    ids = sorted(plates)
+    for i, a in enumerate(ids):
+        for b in ids[i + 1 :]:
+            shared = plates[a].boundary.intersection(plates[b].buffer(1e-6))
+            lines = [
+                part
+                for part in shapely.get_parts(shared)
+                if part.geom_type == "LineString"
+            ]
+            for line in shapely.get_parts(
+                shapely.line_merge(shapely.multilinestrings(lines))
+            ):
+                if line.length < SPACING / 2:
+                    continue
+                described = []
+                for point, tangent in along(line):
+                    lon, lat, normal, closing, sliding = sample(
+                        point, tangent, a, b, plates, omega, radius
+                    )
+                    described.append(
+                        describe(
+                            lon, lat, normal, closing, sliding, land, duration, age_at
+                        )
+                    )
+                samples += smoothed(described)
+    return samples
+
+
+def smoothed(line: list) -> list:
+    """The samples of one boundary line, in order, each taking the commonest
+    kind among its neighbours (with the overriding side of the nearest
+    neighbour of that kind), the side most of its neighbours' normals point
+    to, and the mean shortening around it. Near-equal seafloor ages on both
+    sides of an arc flipped its side from sample to sample, drawing the
+    trench as bars across the boundary."""
+    retyped = []
+    for i, current in enumerate(line):
+        near = range(max(0, i - KIND_WINDOW), min(len(line), i + KIND_WINDOW + 1))
+        kind = Counter(line[j].kind for j in near).most_common(1)[0][0]
+        model = line[
+            min((j for j in near if line[j].kind == kind), key=lambda j: abs(j - i))
+        ]
+        retyped.append(dataclasses.replace(current, kind=kind, normal=model.normal))
+    out = []
+    for i, current in enumerate(retyped):
+        span = retyped[max(0, i - SHORTENING_WINDOW) : i + SHORTENING_WINDOW + 1]
+        east = sum(s.normal[0] for s in span)
+        north = sum(s.normal[1] for s in span)
+        flip = current.normal[0] * east + current.normal[1] * north < 0
+        out.append(
+            dataclasses.replace(
+                current,
+                normal=(
+                    (-current.normal[0], -current.normal[1]) if flip else current.normal
+                ),
+                shortening=sum(s.shortening for s in span) / len(span),
+            )
+        )
+    return out
+
+
+def along(line):
+    """(point, unit tangent in east/north) every SPACING degrees of a line."""
+    count = max(1, round(line.length / SPACING))
+    for k in range(count):
+        at = (k + 0.5) / count * line.length
+        p = line.interpolate(at)
+        ahead = line.interpolate(min(at + SPACING / 4, line.length))
+        behind = line.interpolate(max(at - SPACING / 4, 0))
+        east = (ahead.x - behind.x) * math.cos(math.radians(p.y))
+        north = ahead.y - behind.y
+        norm = math.hypot(east, north)
+        if norm > 0:
+            yield p, (east / norm, north / norm)
+
+
+def sample(point, tangent, a, b, plates, omega, radius):
+    """(lon, lat, normal from a into b, closing and sliding mm/yr)."""
+    normal = (tangent[1], -tangent[0])
+    if not plates[b].contains(offset(point, normal, SIDE / 3)):
+        normal = (-normal[0], -normal[1])
+    relative = local_velocity(omega[a], point.x, point.y, radius) - local_velocity(
+        omega[b], point.x, point.y, radius
+    )
+    closing = float(relative @ numpy.array(normal))
+    sliding = float(relative @ numpy.array(tangent))
+    return (point.x, point.y, normal, closing, sliding)
+
+
+def offset(point, direction, degrees):
+    """The point `degrees` of arc away along an (east, north) direction."""
+    lat = point.y + direction[1] * degrees
+    lon = point.x + direction[0] * degrees / max(math.cos(math.radians(point.y)), 0.05)
+    return shapely.Point((lon + 180) % 360 - 180, max(-89.9, min(89.9, lat)))
+
+
+def describe(lon, lat, normal, closing, sliding, land, duration, age_at) -> Sample:
+    """Name the boundary and turn its normal towards the overriding side
+    (for a collision, a ridge or a transform the side does not matter)."""
+    p = shapely.Point(lon, lat)
+    into_b = land.contains(offset(p, normal, SIDE))
+    into_a = land.contains(offset(p, (-normal[0], -normal[1]), SIDE))
+    if abs(closing) < STILL and abs(sliding) < STILL:
+        kind = "still"
+    elif closing >= DOMINANT * abs(sliding):
+        if into_a and into_b:
+            kind = "collision"
+        elif into_a or into_b:
+            kind = "subduction"
+            if into_a:
+                normal = (-normal[0], -normal[1])
+        else:
+            kind = "arc"
+            age_a = age_at(offset(p, (-normal[0], -normal[1]), SIDE))
+            age_b = age_at(offset(p, normal, SIDE))
+            if age_b > age_a:
+                normal = (-normal[0], -normal[1])
+    elif -closing >= DOMINANT * abs(sliding):
+        kind = "rift" if into_a or into_b else "ridge"
+    else:
+        kind = "transform"
+    return Sample(
+        lon,
+        lat,
+        normal,
+        kind,
+        closing,
+        sliding,
+        closing * duration if closing > 0 else 0.0,
+    )
+
+
+def write(path, samples):
+    """The samples as GeoJSON points, to look at in QGIS."""
+    features = [
+        {
+            "type": "Feature",
+            "properties": {
+                "kind": s.kind,
+                "closing": round(s.closing, 2),
+                "sliding": round(s.sliding, 2),
+                "shortening_km": round(s.shortening),
+                "normal_east": round(s.normal[0], 3),
+                "normal_north": round(s.normal[1], 3),
+            },
+            "geometry": {"type": "Point", "coordinates": [s.lon, s.lat]},
+        }
+        for s in samples
+    ]
+    path.write_text(
+        json.dumps({"type": "FeatureCollection", "features": features}),
+        encoding="utf-8",
+    )
+    print("wrote", path)

shamash_orogen-0.2.0/src/orogen/cli.py

@@ -0,0 +1,155 @@
+"""`orogen VERB PHASE OUT`: one verb per algorithm, each reading a shamash-core
+tectonics phase directory and writing ESRI ASCII grids into OUT; `orogen
+reconstruct PHASE` writes the phase's own snapshots instead, so takes no OUT,
+and `orogen climate DEM OUT --planet planet.json` reads a dem.png instead."""
+
+import json
+
+import argparse
+import time
+from collections import Counter
+from pathlib import Path
+
+from orogen import (
+    boundaries,
+    climate,
+    dem,
+    history,
+    orogeny,
+    phase,
+    reconstruction,
+    seafloor,
+)
+from orogen.grid import Grid, read_png16
+
+
+def run_seafloor(args, grid, crs):
+    ages = seafloor.age(args.phase, grid, args.initial_age)
+    grid.write(args.out / "seafloor_age.asc", ages, crs)
+    grid.write(args.out / "seafloor_depth.asc", -seafloor.depth(ages), crs)
+
+
+def run_history(args, grid, crs):
+    overlap, gap = history.footprint(args.phase, grid)
+    grid.write(args.out / "overlap_myr.asc", overlap, crs)
+    grid.write(args.out / "gap_myr.asc", gap, crs)
+
+
+def run_boundaries(args, grid, crs):
+    ages = seafloor.age(args.phase, grid, args.initial_age)
+    samples = boundaries.classify(args.phase, lambda p: grid.at(ages, p.x, p.y))
+    boundaries.write(args.out / "boundaries.geojson", samples)
+    for kind, count in Counter(s.kind for s in samples).most_common():
+        print("  {:<10} {:>5} samples".format(kind, count))
+
+
+def run_orogeny(args, grid, crs):
+    ages = seafloor.age(args.phase, grid, args.initial_age)
+    samples = boundaries.classify(args.phase, lambda p: grid.at(ages, p.x, p.y))
+    radius_km = phase.settings(args.phase)["radius"] / 1000
+    grid.write(args.out / "relief.asc", orogeny.relief(samples, grid, radius_km), crs)
+
+
+def run_dem(args, grid, crs):
+    heights = dem.build(
+        args.phase,
+        args.out,
+        grid,
+        args.gravity,
+        args.range,
+        args.seed,
+        args.initial_age,
+        args.asc,
+        crs,
+    )
+    print(
+        "elevation {:.0f}..{:.0f} m, land {:.1%} of cells".format(
+            heights.min(), heights.max(), (heights > 0).mean()
+        )
+    )
+
+
+def run_climate(args, grid, crs):
+    if args.planet is None:
+        raise SystemExit("climate needs --planet, the planet.json shamash-core writes")
+    planet = json.loads(args.planet.read_text(encoding="utf-8"))
+    summary = climate.build(
+        read_png16(args.phase, *args.range), planet, grid, args.out, crs
+    )
+    print(json.dumps(summary))
+
+
+def run_reconstruct(args, grid, crs):
+    reconstruction.build(args.phase, overwrite=args.overwrite)
+
+
+VERBS = {
+    "reconstruct": run_reconstruct,
+    "climate": run_climate,
+    "seafloor": run_seafloor,
+    "history": run_history,
+    "boundaries": run_boundaries,
+    "orogeny": run_orogeny,
+    "dem": run_dem,
+}
+
+
+def parse_args(argv=None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(prog="orogen", description=__doc__)
+    parser.add_argument("verb", choices=VERBS)
+    parser.add_argument(
+        "phase",
+        type=Path,
+        help="<body>/tectonics/phase-N; for climate, the dem.png to read",
+    )
+    parser.add_argument("out", type=Path, nargs="?", help="every verb but reconstruct")
+    parser.add_argument("--resolution", type=float, default=0.5, help="degrees")
+    parser.add_argument(
+        "--crs", type=Path, help="a file holding the body's geographic CRS as WKT"
+    )
+    parser.add_argument(
+        "--initial-age",
+        type=float,
+        default=seafloor.INITIAL_AGE,
+        help="Myr, the age of the ocean floor a phase starts with",
+    )
+    parser.add_argument(
+        "--gravity", type=float, default=dem.EARTH_GRAVITY, help="m/s2 of the body"
+    )
+    parser.add_argument(
+        "--range",
+        type=float,
+        nargs=2,
+        default=(-11200.0, 9200.0),
+        metavar=("LOW", "HIGH"),
+        help="m, the elevation range of the map project (dem.png spans it)",
+    )
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument(
+        "--asc", action="store_true", help="dem also writes the float grid, dem.asc"
+    )
+    parser.add_argument(
+        "--planet",
+        type=Path,
+        help="climate: the body's parameters, climate/planet.json from shamash-core",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="reconstruct replaces the phase's snapshots",
+    )
+    args = parser.parse_args(argv)
+    if args.out is None and args.verb != "reconstruct":
+        parser.error("{} writes into OUT; give one".format(args.verb))
+    return args
+
+
+def main(argv=None) -> int:
+    args = parse_args(argv)
+    if args.out:
+        args.out.mkdir(parents=True, exist_ok=True)
+    crs = args.crs.read_text(encoding="utf-8") if args.crs else None
+    started = time.perf_counter()
+    VERBS[args.verb](args, Grid(args.resolution), crs)
+    print("{} took {:.1f} s".format(args.verb, time.perf_counter() - started))
+    return 0