test: accumulate same-trajectory space-time GPU rounding ledger

tests/validation/multigrid/spacetime_gpu.py

@@ -83,13 +83,21 @@ def rounding_ledger(plan, tables, before, after, g0, predicted, fine_phases, pre
     """Audit actual stored FP32 phases; never call a missing packet 'rounding'."""
     maps, n = plan.maps, plan.n
     f64 = lambda a: np.asarray(a, dtype=np.float64)
-    collision = (f64(g0[:, maps.coarse_active])-f64(before.coarse_f[:, maps.coarse_active])).sum(axis=1)
+    difference = f64(g0[:, maps.coarse_active])-f64(before.coarse_f[:, maps.coarse_active])
+    coarse_collision = difference.sum(axis=1)
+    cell_mass = [difference.sum(axis=0)]
+    collision = coarse_collision.copy(); fine_collision = []
     for f, g in fine_phases:
-        collision += .25*(f64(g[:, maps.fine_active])-f64(f[:, maps.fine_active])).sum(axis=1)
+        difference = f64(g[:, maps.fine_active])-f64(f[:, maps.fine_active])
+        fine_collision.append(.25*difference.sum(axis=1))
+        cell_mass.append(.25*difference.sum(axis=0))
+        collision += fine_collision[-1]
     np.testing.assert_array_equal(h, pre.astype(np.float32))
     origins = f64(g0).ravel()[tables['origins']]
     np.testing.assert_allclose(pre.mean(axis=1), origins, rtol=0, atol=2e-14)
     group = np.bincount(tables['origins']//(n*n), weights=f64(h).mean(axis=1)-origins, minlength=9)
+    interpolation = np.bincount(tables['origins']//(n*n), weights=pre.mean(axis=1)-origins, minlength=9)
+    child_cast = np.bincount(tables['origins']//(n*n), weights=f64(h).mean(axis=1)-pre.mean(axis=1), minlength=9)
     packet = np.empty(tables['times'].shape, np.float64)
     for when, source in ((-1, h), (0, fine_phases[0][1]), (1, fine_phases[1][1])):
         mask = tables['times'] == when
@@ -107,11 +115,17 @@ def rounding_ledger(plan, tables, before, after, g0, predicted, fine_phases, pre
     register_error = np.bincount(q, weights=reg_error, minlength=9)
     # directional() must sum converted arrays, not accumulate in FP32.
     total = lambda s: ref.directional(ref.cpu.State(f64(s.coarse_f), f64(s.fine_f)), maps)
-    raw = total(after)-total(before)-collision
+    net = total(after)-total(before)
+    raw = net-collision
     unexplained = raw-group-store_error-register_error
     limit = float(64*np.finfo(float).eps*total(before).sum())
     np.testing.assert_allclose(unexplained, 0, rtol=0, atol=limit)
-    return dict(raw=raw.tolist(), physical_collision=collision.tolist(),
+    return dict(raw=raw.tolist(), net_change=net.tolist(), physical_collision=collision.tolist(),
+                coarse_collision=coarse_collision.tolist(), fine0_collision=fine_collision[0].tolist(),
+                fine1_collision=fine_collision[1].tolist(), child_interpolation=interpolation.tolist(),
+                child_cast=child_cast.tolist(),
+                collision_cell_mass=[[float(a.sum()),float(a[a>0].sum()),float(a[a<0].sum()),float(abs(a).sum())]
+                                     for a in cell_mass],
                 child_rounding=group.tolist(), receiver_rounding=store_error.tolist(),
                 register_rounding=register_error.tolist(), unexplained=unexplained.tolist(),
                 unexplained_bound=limit, minimum_pre=float(pre.min()), minimum_stored=float(h.min()))