DGGSpace as a regridding source descends its own subtree (42x)

[asinghvi17]

Stack position: 1 of 4 — main ← #62 claude/dgg-source-subtree ← #63 claude/subzone-store ← #64 claude/copdem-production ← #65 claude/perf-ladder (draft)

This is a stacked PR chain. Each PR's base is the previous branch, so each diff shows only its own commits. Do not squash-merge out of order; merge bottom-up and retarget children after each merge.

---

What

A DGGSpace used as a regridding source no longer falls back to a generic cap tree over its linear index range. It descends its own subtree, through a new grid seam.

Measured on the benchmarked path: ≈42×, bit-identical output.

Why

GR.subtree(::DGGSpace, inds) had two fast paths and both were shut for a Copernicus DEM source — _iswholespace is false for a chunk, and _chunkcursor requires treeify(grid) to be a HierarchicalGridCursor, which a CopernicusDEMSystem grid's is not. Every block build therefore got a GR.CellCapTree, which bisects the linear index range. With row-major pixel order, every node above about depth 11 of 17 is a band of complete pixel rows spanning the tile's whole degree of longitude, and its cap stays ~200 km wide however thin the band. Nothing prunes on longitude, and the dual-tree candidate search re-descends the destination at every one of those surplus nodes. Against a RasterGrid over the same pixels, get_all_candidate_pairs cost 228× more for the same clipping work.

The four commits

• acf6909 — pin ConservativeRegridding and GeometryOps to SHAs, not branch names. Both [sources] revisions had moved under main: claude/budget-frontier resolved to 89ec5ca5, which predates Trees.split_weight and so cannot precompile GlobalRegridding; as/intersection_area resolved to 02750768, which predates intersection_area itself and fails at the first weight block. A fresh instantiate of main hits both today. Pinned to the revisions the campaigns actually measured against: CR 6a4b997, GO 2825c476. Still temporary pins (regrid-notes/cr-pin-state, go-pin-state still apply) — but a SHA cannot move. Also makes bench a workspace member sharing the root Manifest, with the Zarr dependency the store work needs.

• 4d55dd4 (F1) — DGG.subcursor(grid, inds) -> tree | nothing, a new unexported grid seam (src/interface/grid.jl), tried by GR.subtree(::DGGSpace, inds) before _chunkcursor. Default is nothing; a hierarchical grid needs no method, since regridding already descends to the chunk's ancestor. CopernicusDEM implements it by reusing _block_cursor's run-to-rectangle test over the window rather than over the whole grid. A BlockCursor node is an index rectangle whose cap is an exact O(1) box and whose Bisected split takes the longer axis — the same shape RasterCellTree gives the raster arm, so this closes the gap rather than narrowing it. Ranges that are not one lattice rectangle keep the cap-tree fallback.

  The seam deliberately takes the grid, not the root tree — the only shape that works for PartialGrid sources, where the whole-grid tree is a HierarchicalGridCursor.

  Sparse sources work out of the box: DGGSpace(PartialGrid(land tiles); chunklevel=0) gives one chunk per held tile and windows normally. Verified with pole, band-edge and equatorial tiles; matrices equal the CellCapTree arm and the full lazy regrid is bit-identical.

• ecd4f34 (F4) — CapCachedTree gains an index offset (caps[p - offset], offset = 0 whole-space, first(inds) - 1 for a chunk), so the same wrapper serves a chunk cursor. Previously a chunk's _chunkcursor handed the dual-tree search a bare cursor whose node_extent and child_indices_extents both re-derived every cell cap from Fallbacks.cell_cap → cell_boundary — an inverse projection per cell, once per opposing node. On the Copernicus source A/B that destination-side recomputation was 43 % of the whole block build. subtree wraps chunk cursors up to _CHUNK_CAP_CACHE_MAX = 2^16; above that the fill costs more than the revisits it saves. Caps, leaf entries and cells are the raw cursor's bit for bit, and the tests check that against _chunkcursor directly.

• 660640f (F2) — _mergecaps folds the smallest cap containing two caps (the same construction GO.UnitSpherical._merge and DGG.Fallbacks.merge_caps use) instead of centring on the mean of its inputs' centres and taking max(distance + radius). The old form inflates a node by the spread of its children, and _cellcapnode then merges child extents bottom-up, so the inflation compounds level by level. On one 1200×1200 GLO-90 tile at 45°N: root cap 274.9 → 94.6 km (true 68.1 km), depth-3 median 224.2 → 45.9 km, depth-11 maximum 203.9 → 39.4 km. Caps only prune, so this is a speed change, not a semantic one — and it is the fallback every system without a windowed cursor still takes.

Numbers

At -t 8, load 19–20:

case	before	after
A/B box:10,10.05,45,45.05, IGeo7 L12, ancestor 7	61 s (cap-tree fallback)	1.39–1.50 s (≈42×, 33.6–36.2k cells/s)
same A/B, forced cap-tree arm (F4 then F2)	61.9 → 32.8 → 13.0 s
zarr-spike run-D region	234.2 s	7.6–7.8 s

Raster path unchanged (179–188 s against 183.6 s recorded).

Tests

Full suite 987,238 pass / 17 broken / 0 fail (+76 new assertions); GlobalRegridding 2,202 pass.

Known gotcha recorded in the notes: a chunk tree's Trees.ncells answers for the chunk while its leaves hold global positions, so weights only flow through a block build's index maps — the chunk-level test is checktree, not a matrix comparison.

Notes

Full record: regrid-notes/2026-08-20-copdem-zarr-spike.md §13.

Deferred there and not in this PR: D1's remaining ~39 km cap floor (the split is on the linear index range, so a shallow node is a band of complete pixel rows spanning the tile's full degree of longitude — a separate change), plus F3/F5/F6/F7 (§13.4).

🤖 Generated with Claude Code

https://claude.ai/code/session_01AC7rbi9eqZypWseMjBGSJ2

[asinghvi17]

Fixed the [sources] pins so a fresh instantiate of this stack works.

GeometryOps 2825c476647cfe6791dbb89fffb8592697b46995 → 36c853e0de865251e1395ff01e9d34cda9e9bfa8 (tip of GO claude/perf-ladder-predicates, GO PR #476), in all five blocks — root, docs/, test/, lib/GlobalRegridding/, lib/DiscreteGlobalGridsConformanceTesting/. The five were previously consistent at 2825c476, but #65 had already moved only the root block to 36c853e0, so merging the stack forward gave a workspace whose members disagreed on the GeometryOps rev. The two commits in between are the spherical_orient fast path and the SphericalCap squared-chord intersection: perf only, bit-identical, measured during the perf-ladder campaign.

ConservativeRegridding stays at 6a4b997ab2e66dea45b5b62b5b2f32f0a3b279b0 — re-checked, not changed. It is the current tip of CR claude/budget-frontier, reachable from that remote ref, and its tree does define Trees.split_weight (src/trees/interfaces.jl:52). The "a fresh resolve loses split_weight" report did not reproduce.

Fresh-instantiate evidence, throwaway depot sharing nothing with ~/.julia (both git sources cloned from scratch):

JULIA_DEPOT_PATH=<tmp> julia --project=. -e \
  'using Pkg; Pkg.instantiate(); Pkg.precompile("DiscreteGlobalGrids")'

92 dependencies precompiled, including GeometryOps, ConservativeRegridding, GlobalRegridding and DiscreteGlobalGrids; the generated Manifest carries repo-rev = 36c853e0… / 6a4b997… beside Pkg's own git-tree-sha1; and both isdefined(GeometryOps, :intersection_area) and isdefined(ConservativeRegridding.Trees, :split_weight) hold. (No Manifest is tracked in this repo — .gitignore line 2 — so the fix is Project.toml only.)

Targeted suites on the new pins, julia -t 4:

suite	pass	broken	fail
lib/GlobalRegridding (full)	2202	1	0
test/systems/crosssystem/regrid.jl	116	0	0
test/systems/crosssystem/regridding_conservation.jl	76	12	0
test/systems/CopernicusDEM/runtests.jl	16162	3	0
test/systems/crosssystem/regrid_acceptance.jl	22	0	0

Pushed here as 1183e6f, then merged forward (no rebases, no force-pushes): claude/subzone-store → 55e676d (#63), claude/copdem-production → e08860f (#64). claude/perf-ladder (#65) is untouched; its root block already pins 36c853e0, so that merge stays trivial.