| --- |
| license: cc-by-4.0 |
| task_categories: [other] |
| tags: [mri, diffusion-mri, monte-carlo, microstructure, replay-pack, rpk, restricted-diffusion] |
| pretty_name: Canonical Pores — Monte-Carlo Replay Packs |
| --- |
| |
| # Canonical Pores — Monte-Carlo Replay Packs |
|
|
| Converged Monte-Carlo diffusion walks in the three geometries that have exact analytical solutions — |
| **parallel planes, cylinders, spheres** — frozen so that **any** acquisition can be computed afterwards |
| without re-simulating. |
|
|
| **600 substrates**: 200 diameters per shape, **0.1–20.0 µm in 0.1 µm steps**, each walked to |
| **T = 200 ms** at D₀ = 2.0×10⁻⁹ m²/s. One `.rpk` (safetensors) per substrate. |
|
|
| ## What you can replay |
|
|
| A replay pack is not a lookup table of pre-computed signals. It stores the walk itself, so the forward |
| model is evaluated at read time: |
|
|
| | you supply | how it is handled | exact? | |
| |---|---|---| |
| | **any gradient waveform** `G(t)` — PGSE, OGSE, PGSTE, CPMG-with-gradients, b-tensor (STE/PTE), arbitrary | projected onto the pack's temporal basis; the gradient phase is *linear* in position, so Parseval applies | exact for waveform content within the stored bands | |
| | **surface relaxivity** ρ, any value | the pack's boundary-local-time channel, replayed | **exact** — not a mean-field `exp(-TE·ρ·S/V)` tag-on | |
| | **per-compartment T₁ / T₂** | compartment map + relaxation log-weights | exact | |
| | **any b-value, Δ, δ, direction, orientation** | consequences of the waveform above | — | |
|
|
| There is **no short-pulse (SGP) and no Gaussian-phase approximation** anywhere in that path. That is the |
| point of the dataset: the analytical models (`P2`–`P5`, `C2`–`C5`, `S2`–`S5` in |
| [dmipy-fit](https://github.com/dmrai-lab/dmipy-fit)) each hold under some acquisition assumption; replay |
| holds for the acquisition you actually ran. |
|
|
| **Not in these packs**: susceptibility / off-resonance (no field channel), magnetization transfer, and |
| diffusivity is fixed per pack — D₀ is baked into the walk, not a replay knob. (Time-rescaling to a |
| different D₀ is a planned extension.) |
|
|
| ## What has been *certified*, and what that does not mean |
|
|
| Every substrate's replay was compared against the exact eigenmode (matrix-method) solution and sized until |
| the worst residual met **ε = 5×10⁻³**, measured over a battery of PGSE acquisitions: |
| (δ, Δ) ∈ {(10,20), (10,40), (10,60), (10,100), (5,40)} ms × b ∈ {1, 3, 5}×10⁹ s/m², plus a |
| surface-relaxivity battery. Walker counts were **measured**, never extrapolated: each candidate count was |
| replayed and compared to the analytic reference on up to five *disjoint* blocks, all of which had to pass. |
|
|
| **That battery is where the bound was measured — it is not a limit on what the pack replays.** The |
| distinction matters in one direction only: a waveform whose temporal content falls outside the tested |
| spectral range (very high-frequency OGSE, pulses shorter than the save grid) is still *replayable*, but its |
| error is not covered by the quoted ε. For these three geometries you can settle that yourself — the exact |
| analytical model ships in dmipy-fit (`P5PlaneMatrixMethod`, `C5CylinderMatrixMethod`, |
| `S5SphereMatrixMethod`), so any acquisition you care about can be checked directly against ground truth. |
| That is precisely what makes this dataset the validity proof for replay on substrates where no analytic |
| answer exists. |
|
|
| Practical resolution limits: the save grid is n_t ∈ {2000, 4000, 8000} over 200 ms, so features finer than |
| that grid are not resolved; and the position codec keeps K ∈ {128, 196} temporal bands, which bounds the |
| waveform bandwidth represented. |
| |
| | shape | substrates | all meet ε=5e-3 | worst residual | |
| |---|---|---|---| |
| | plane | 200 | ✅ | see `manifest.json` | |
| | cylinder | 200 | ✅ | see `manifest.json` | |
| | sphere | 200 | ✅ | see `manifest.json` | |
| |
| Each pack carries its own certification in metadata (`grid.worst_residual`, `grid.ladder`), so no consumer |
| has to trust this table. |
|
|
| ## Tiers: fetch only what you need |
|
|
| Two independent selections, and they **compose into a single contiguous byte range** — verified against |
| HuggingFace range requests (`Accept-Ranges: bytes`, HTTP 206). |
|
|
| **1. Precision (walkers).** Walkers are the leading axis of every per-walker tensor, and any prefix is an |
| unbiased sub-ensemble with floor ∝ 1/√n. Each pack ships the **measured** prefix length for each floor: |
|
|
| ```python |
| grid["prefix_tiers"] # e.g. {"0.03": 1000, "0.02": 1000, "0.01": 1000, "0.005": 1000} |
| ``` |
|
|
| **2. Spatial axis.** Positions are stored as **one tensor per axis** (`pos_x`, `pos_y`, `pos_z`, each |
| `(n_walkers, K)`), so you fetch only the components your geometry needs — a slab restricts one direction |
| (the other two are free and analytic), a cylinder two, a sphere three. All three are always present, so |
| rotating / b-tensor encodings that need the joint trajectory lose nothing. |
|
|
| Measured on a 17.36 MiB pack: one axis + a 2,000-walker prefix = **0.49 MiB, a 36× reduction**. |
|
|
| ```python |
| from safetensors import safe_open |
| with safe_open("cylinder/d10.00um.rpk", framework="np") as f: |
| x = f.get_slice("pos_x")[0:2000] # one axis, coarse tier: one contiguous read |
| ``` |
|
|
| **Status of the two selections.** Both are real and verified at the byte level, but only one is automatic |
| today: |
|
|
| * **Per-diameter fetch is automatic.** The `X6` compartments resolve a fitted diameter to the two |
| bracketing packs and download only those, so a fit transfers ~tens of MiB, never the dataset. |
| * **Coarser-ε prefix fetch is automatic too**, via `eps=`: |
|
|
| ```python |
| from dmipy_fit.data.mc_replay import load_replay_family |
| fam = load_replay_family("cylinder", 2e-9, eps=1e-2) # range-reads each pack down to its 1e-2 tier |
| ``` |
|
|
| Measured live on this dataset (cylinder d=13.45 µm, 50,000-row pack): ε=5e-3 moves 43.39 MiB, |
| ε=1e-2 moves 17.36 MiB, ε=3e-2 moves **4.34 MiB** — a 10× reduction — with the delivered accuracy |
| tracking the request. The tier count comes from `manifest.json`, so choosing one costs no transfer, |
| and an ε with no measured tier raises rather than silently returning something coarser. |
|
|
| `axes=` restricts which position components are fetched (1 for a slab, 2 for a cylinder's transverse |
| plane) for a further 1.5–3×. It is **not** defaulted: rotating / b-tensor encodings need the joint |
| trajectory, so ask for it only when your encoding is fixed-direction. |
|
|
| ## Usage |
|
|
| ```python |
| from dmipy_sim import read_rpk, compile_scheme, replay_signal |
| pack = read_rpk("cylinder/d05.00um.rpk") |
| W = compile_scheme(G, dt, pack.meta["compression"]["K"]) # G: (n_meas, n_t, 3), any waveform |
| E = replay_signal(pack, W) # + rho_over_D= for surface relaxivity |
| ``` |
|
|
| As fit compartments (`X6`), with the same parameters as their analytic siblings: |
|
|
| ```python |
| from dmipy_fit.signal_models.cylinder_models import C6MonteCarloReplayCylinder |
| model = C6MonteCarloReplayCylinder() # mu, lambda_par, diameter — fetches packs on demand |
| ``` |
|
|
| `manifest.json` lists every substrate with its walker count, size, certified residual and prefix tiers. |
|
|
| ## Layout |
|
|
| ``` |
| canonical/D0-2.00e-9/{plane,cylinder,sphere}/d<NN.NN>um.rpk |
| manifest.json |
| ``` |
|
|
| ## Citation |
|
|
| Generated with [`dmipy-sim`](https://github.com/dmrai-lab/dmipy-sim). Please cite the dataset DOI and the |
| dmipy-sim replay-pack reference. CC-BY-4.0. |
|
|
