SubstrateCommons/disco-replay

DiSCo as a replay phantom

The DiSCo substrate (Rafael-Patino, Girard, Truffet, Pizzolato, Caruyer, Thiran, The diffusion-simulated connectivity (DiSCo) dataset, Data in Brief 38 (2021) 107429, doi:10.1016/j.dib.2021.107429; data doi:10.17632/fgf86jdfg6.3, CC BY 4.0) walked once and stored as replay packs (.rpk, replay-pack-spec codec registry 0.6.0), so that any acquisition a human scanner can play is a replay of the same walk, voxel by voxel on the dataset's own 40³ grid of 25 µm voxels, with a per-voxel Monte-Carlo certificate.

DiSCo published one acquisition of this substrate (four shells, 90 directions each, TE 53.5 ms). This dataset is the substrate itself in replayable form: the same 12,196 strands, the same two tubes per strand (the listed inner diameter and the outer tube at 1/0.7 of it), the same diffusivity in both pools (0.6e-9 m²/s), intra water inside the inner tube and extra water outside the outer one, walked for 100 ms.

What a pack certifies

walk length	100 ms gradient-on budget; shorter echo times are prefixes (ReplayPack.prefix(TE))
band	K = 256 modes over 100 ms, 1.28 kHz: every human scanner class (Prisma, Connectom, MAGNUS, Connectome 2.0) at ε = 5e-3 with margin ≥ 1.4; preclinical systems out of scope
save grid	3349 saves, set by the Connectome 2.0 envelope (500 mT/m) so the in-step path error stays below a tenth of the floor of the densest voxel
per-voxel floor	0.008 on the worst of DiSCo's four shells, the dataset's own precision (10⁹ particles over 64,000 voxels)
tiers	C0 positions, C1 occupancy (static, impermeable), C2 wall contact, C3 the strand field along the path (K_path = 32, refocusing depth 16; the field read at every 4th save, 120 µs, which biases a 7 T spin-echo field signal by 3e-4 against the 8e-3 floor target)
field	the strand field as the exact field of every segment (the dipole kernel integrated along the segment, the sheath a tube of susceptibility; within a strand's tube and one radius beyond, its nearest segment's whole cylinder carries the local terms): the segments within 18 µm of a walker in closed form, the rest through an exact far grid on 2.5 µm nodes (substrate/far_field_h2.5um.npy + .json, switch 11–18 µm; read error 0.98 % of the far part, 0.08 % of the field at walker positions, falling with the spacing); checked on the whole tract against an independent moment-conserving k-space route to 0.03–0.22 % (substrate/far_field_check.txt, dmipy-sim#265)
positions	bridge_dst with integer band containers: exact float32 endpoints, bands at 16 bits below mode 16 and 8 bits above, nanometre reconstruction
outside	voxels farther than 46 µm from every strand hold free extra water and carry no walkers: the analytic free-diffusion substrate applies

One walk, every tier. The intra and extra pools are walked with positions (C0), occupancy (C1), wall contact (C2) and the strand field sampled along their paths (C3); the sheath between the two tubes holds no water and is not seeded, but it is the susceptibility source (the myelin's chi is the sheath's, not its water's). DiSCo's own published simulation is the replay of these packs with the field off. Capability limits: no myelin water (a short-echo or multi-echo replay sees two pools where white matter has three), a refocusing depth of 8 for the field channel (K_path = 32), the band and envelope above.

Layout

manifest.json                 the recipe: substrate, grid, walk, codec, plan, variants, code commit
substrate/                    DiSCo's strand files, unchanged (SOURCE.md: provenance and hashes)
plan/plan_pilot5_8pv_100ms.npz  walkers per voxel per pool (the pilot's floors brought to the target)
plan/blocks.json              1399 contiguous voxel blocks of at most 1M walkers, one seed each
blocks/disco/block-NNNN.pK.rpk   pass K of block NNNN (manifest plan.passes: pass 1 is 0.16 of every block's counts, the
                                 0.02 floor; pass 2 the 0.84 top-up from its own seed stream): its walkers, its per-voxel
                                 certificate at its own count; block-NNNN.rpk without a pass tag is the whole block
blocks/disco/block-NNNN.pK.json  the shard's summary: host, pass, timings, sha256, floors per pool
blocks/disco/block-NNNN.pK.run/  the record of the walk that made it (manifest, event log with memory over time, summary)
claims/disco/                 blocks a worker is filling right now, each with a heartbeat (progress, ETA, memory)
STATUS.md                     the fill's state per contributor and the time to each pass's end (python -m dmipy_sim.fill.status, every 30 min)
certificate/disco.json        the fill's measured certificate (a scaled block, the full battery); every block inherits it
smoke/disco/                  scaled-down blocks from machines proving themselves
worker/                       disco_fill.py and how to run it on another GPU

A shard's embedded spec cites the strand file at substrate/DiSCo_Strands_Trajectories.tck (with its sha256) rather than carrying 12,196 centerlines: replay from the dataset's directory, or copy substrate/ under $DMIPY_SIM_SURFACE_DIR (default ~/.cache/dmipy-sim/surfaces).

A shard is a complete replay pack of its voxel block. dmipy_sim.replay.bank.merge_packs joins shards; a consumer who wants a region reads the blocks whose i, j, k ranges cover it (plan/blocks.json) and, within a shard, only the tensors it needs (safetensors range reads; the first band tensor of each axis is a K = 16 prefix).

Consuming

from dmipy_sim.replay import ReplayPack
from dmipy_sim import pgse
pk = ReplayPack.load("blocks/disco/block-0000.rpk")          # from the dataset's directory (the spec cites substrate/)
# a block filled in passes: its passes merge into the block at the plan's floor (the union's walker weights)
from dmipy_sim.replay.bank import merge_packs
pk = merge_packs(["blocks/disco/block-0012.p1.rpk", "blocks/disco/block-0012.p2.rpk"], id="disco/block-0012", overlap="recertify")
seq = pgse([[1, 0, 0], [0, 0, 1]], 0.015, 0.040, bvalues=[3e9, 3e9])   # SI: s/m^2, seconds; any grid, any TE <= 100 ms
S = pk.replay(seq)                       # the nominal replay: the embedded spec's T2 at TE = 100 ms
S_diffusion = pk.replay(seq, tissue=False)   # the bare diffusion signal

The acquisition is on its own grid: the replay projects the waveform's exact per-save weights onto the bridge basis, so nothing is resampled and the pack's save grid is not a consumer's concern (a PGSE on 257, 1000 or 3349 samples replays to the same signal to 1e-5, the waveform's own ramp discretisation).

Phantom.partition cuts a pack into voxels by seed position; every walker carries the volume it stands for (f_pool,v / n_pool,v), so a coarser or rotated grid is a weighted mean and its floor follows from the weights.

Contributing compute

See worker/README.md: one process fills blocks in a pipeline (the walk of the next block on the GPU while the last one packs on the CPU and uploads), claims by file, no scheduler. Every shard records the code commit, the host, the seed and the sha256 of what was uploaded, and carries the record of the run that made it; a claim's heartbeat says how far a block in progress is. A block round fits a 31 GB / 15 GB machine (a Kaggle session).

Attribution

Substrate: Rafael-Patino et al. 2021 (CC BY 4.0). Replay packs: dmipy-sim (dmrai-lab), replay-pack-spec. Cite the dataset paper for the substrate and the replay paper for the packs.