---
license: cc-by-4.0
pretty_name: DiSCo replay phantom
tags:
  - diffusion-mri
  - monte-carlo
  - replay-pack
  - tractography-phantom
---

# 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 a replay pack, 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; this dataset is the
substrate itself in replayable form: the same 12,196 strands, two tubes per strand (the listed inner diameter and
the outer tube at 1/0.7 of it), the dataset's 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 with every tier (positions, occupancy, wall
contact, the strand field along the path).

## Use me

**Install** dmipy-sim from its main branch (the reader lives there); the dataset is public, no login is needed:

```
pip install "git+https://github.com/dmrai-lab/dmipy-sim@main" "huggingface_hub>=0.25"
```

**1. You want images and no compute.** `disco/reference/` holds pre-replayed volumes on the 40³ grid as S/S0
NIfTI with their gradient tables: DiSCo's own 364-measurement protocol as bare diffusion (the dataset's own
simulation) and with white matter at 3 T and 7 T (T2 per pool, surface relaxivity, the sheath's susceptibility),
four other acquisitions (a clinical b = 1000 shell, a three-shell research scheme, a Connectome 2.0 b = 6000
shell, a 50 Hz OGSE), the per-voxel floor, the record of what each was read with, the comparison with the
dataset's own images, and tractography scores. Read its `README.md` first.

**2. You want to replay your own acquisition.** Open the pack by reference; nothing is downloaded whole, every byte
read is one the replay uses (HTTP range reads of the columnar layout under `disco/`):

```python
from dmipy_sim.replay import ReplayPack
from dmipy_sim import sequences
from dmipy_sim.spec.tissue import Tissue

pack = ReplayPack.open("hf://SubstrateCommons/disco-replay/disco")       # 150 M walkers, 31,802 voxels; ~0 bytes so far
seq = sequences.pgse([[1, 0, 0], [0, 0, 1]], 0.0102, 0.0167, bvalues=[1e9, 1e9], TE=0.0535)   # SI: s/m², s; any grid, any TE ≤ 100 ms

print(pack.plan(seq))                                                    # bands, tiers, bytes: decided before any transfer
view = pack.view(K=32, voxels=[(20, 20, 20)])                            # one voxel's rows at 32 bands (~1 MB): an ordinary ReplayPack
S = view.replay(seq)                                                     # bare diffusion, the dataset's own physics
wm = Tissue(T2={"intra": 0.05, "extra": 0.055, "myelin": 0.01}, rho=1.16e-6, chi_iso=-1e-7, chi_aniso=-1e-7)
view = pack.view(K=32, modes=8, contact=True, voxels=[(20, 20, 20)])     # the tiers the physics needs
S_3T = view.replay(seq, tissue=wm, scanner=3.0)                          # relaxation, wall contact, the sheath field at 3 T

from dmipy_sim.replay.study import Acquisition, Protocol, Study
study = Study(Protocol([Acquisition(seq)]), tissues=[None, wm], scanners=[None, 3.0, 7.0], pairs=[(0, 0), (1, 1), (1, 2)])
S, floor, plan = pack.image(study)                                       # the whole grid: one pass over the rows, every pair from it
```

`S` is `(pairs, 40, 40, 40, measurements)`, NaN where the pack holds no walkers; `floor` the split-half floor of
each volume, measured in the same pass. A study names a protocol (sequences, each in a pose), the tissues and the
scanners; the bands are contracted once per acquisition and every tissue and scanner is arithmetic on the result. A replay returns the signal as measured (with the relaxation decay at TE when a tissue carries
a T2); divide by a b = 0 measurement of the same setting for S/S0, as the reference volumes are. A pass over all rows streams 20 to 100 GB depending on the tiers (about 10 to 25 minutes at
50-75 MB/s) and needs a GPU for the sums; a voxel takes a second. The replay knobs are three objects, each
stated once: `tissue` (a `Tissue`, or `pack.nominal` for the spec's values), `scanner` (a field in tesla or a
catalogue scanner), `orientation`. Nothing is applied silently: the default is bare diffusion. The
[replay guide](https://github.com/dmrai-lab/dmipy-sim/tree/main/docs/replay-guide) in dmipy-sim is the manual:
one page per object, the table of what each knob touches and which channel it needs, images by reference, and
a [DiSCo recipe](https://github.com/dmrai-lab/dmipy-sim/blob/main/docs/replay-guide/recipes/disco.md).

**3. You want the walkers themselves.** `disco/` is the lossless form of the pack: every walker of the fill, in
columns (`disco/columns/*.safetensors`), with nothing requantised; `pack.view(...)` returns any voxels' rows as an
ordinary `ReplayPack`, and a top-up (a later pass) appends its rows to `disco/columns`. The embedded spec cites the
strand file at `substrate/DiSCo_Strands_Trajectories.tck`: replay from the dataset's directory, or copy
`substrate/` under `$DMIPY_SIM_SURFACE_DIR`.

## What is certified

| | |
|---|---|
| state | pass 1 complete (0.16 of the plan, 1,399 shards, 1.5e8 walkers, certified floor median 0.033) + the repair of 332 voxels whose pool the plan had clipped (dmipy-sim#295; `columnar.repair` in `disco/manifest.json`); pass 2, the 0.84 top-up to the 0.008 floor, is held |
| validation | DiSCo's own protocol replayed against the dataset's noise-free images: correlation 0.989 / 0.990 / 0.988 / 0.981 per shell, per-voxel r.m.s. 0.013 against the certified floor 0.035; a uniform +1 % of S0 because the dataset's tubes are triangle meshes (inner volume 0.953 of the pack's); the replay scores 0.91 on the dataset's connectome through a CSD + probabilistic tracking pipeline, where the dataset's own images score 0.905 |
| walk | 100 ms gradient-on budget; K = 256 bands (1.28 kHz: every human scanner class at ε = 5e-3), the bands at 16 bits below mode 16 and 8 bits above, nanometre reconstruction; 3,349 saves set by the Connectome 2.0 envelope |
| tiers | C0 positions, C1 occupancy (static, impermeable), C2 wall contact, C3 the strand field along the path (32 modes, refocusing depth 16); the sheath between the tubes holds no water and is the susceptibility source |
| field | the exact field of every segment within 18 µm in closed form, the rest through a far grid on 2.5 µm nodes (read error 0.08 % of the field at walker positions); checked against an independent k-space route to 0.03-0.22 % (`substrate/far_field_check.txt`) |
| outside | voxels farther than 46 µm from every strand hold free extra water and carry no walkers |
| limits | no myelin water (a multi-echo replay sees two pools where white matter has three); refocusing depth 8 for the field channel; the band and envelope above |

## Layout

```
disco/                        THE PACK, lossless, in columns (152.8 M rows, 187.7 GB in 237 parts): manifest.json (meta +
                              every column's byte layout), index.json (row range per voxel and pool), columns/*.safetensors;
                              a top-up appends to columns/
disco/moments/                the shape-moment layout contracted from disco/ (its manifest names disco/manifest.json's sha256)
disco/reference/              pre-replayed volumes, their records, the comparison with DiSCo, tractography scores, a card
manifest.json                 the fill's recipe: substrate, grid, walk, codec, plan, variants, code commit
plan/                         walkers per voxel per pool; the 1,399 voxel blocks and their seeds
substrate/                    DiSCo's strand files, unchanged (SOURCE.md: provenance and hashes); the far field grid
certificate/                  the fill's measured certificate (disco.json: a scaled block, the full battery; every block
                              inherits it), with the certifying block's pack and the record of its walk
STATUS.md, worker/            the fill's status page at the end of pass 1, and the worker
```

## Contributing compute

`worker/README.md`: one process fills blocks in a pipeline, claims by file, no scheduler; every shard records the
code commit, the seed and the sha256 of what it uploaded, and carries the record of its run, and a finished pass
is appended to `disco/columns`. Pass 1 was walked by five machines (a GH200, three L40S, a Kaggle T4) in 151
GPU-hours over two days.

## 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.