Simulation-based inference at the theoretical limit for fast, robust microstructural MRI with minimal diffusion data.
2 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.
The 5 matches
- [1] § Methods › Tensor-based frameworks ↔ DKI_funcs.py, lines 11 to 32 · score 0.83 · radial kurtosis, axial kurtosis, kurtosis fractional, kurtosis tensor, DKI metrics, KFA · block
oscr:b:NTG8D76KHJPFY-C· Report a mismatch - [2] § Methods › The AxCaliber model ↔ AxCaliber_funcs.py, lines 73 to 205 · score 0.82 · gamma distribution, restricted compartment, diffusion tensor, AxCaliber, exponential, scalar · block
oscr:b:1C6C2WPHF2HFK-H· Report a mismatch - [3] § Results › Application of SBI to AxCaliber ↔ AxCaliber_funcs.py, lines 73 to 205 · score 0.58 · restricted compartment, restricted signal, simulated signals, angle, hindered, fraction · block
oscr:b:1C6C2WPHF2HFK-H· Report a mismatch - [4] § Results › Application of SBI to AxCaliber ↔ AxCaliber_figs.ipynb, lines 553 to 575 · score 0.53 · reduced SBI, reduced NLLS, full NLLS, full SBI, angle, circle · Report a mismatch
- [5] § Methods › The AxCaliber model ↔ AxCaliber_figs.ipynb, lines 183 to 248 · score 0.52 · diffusion tensor, AxCaliber, gamma, Dh, hindered · Report a mismatch
Paper
Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC
The paper is loaded when this pane is shown.
The authors' code
Python · 383 lines · 14 KB · no license · 2 matches
- from DTI_funcs import *
- from scipy.special import j0, jv
- from scipy.optimize import bisect
- Delta = [0.017, 0.035, 0.061] # ms
- delta = 0.007 # ms
- def j1_derivative(x):
- """Derivative of J1(x) using the identity: J1'(x) = 0.5 * (J0(x) - J2(x))."""
- return 0.5 * (j0(x) - j2(x))
- def j2(x):
- """Bessel function J_2(x)."""
- return jv(2, x)
- def j1prime_zeros(n, x_max=100, step=0.1):
- """
- Find the first n positive roots of J1'(x) by scanning from x=0 to x_max.
- Parameters
- ----------
- n : int
- Number of roots to find
- x_max : float
- Maximum x to search
- step : float
- Step size for scanning sign changes
- Returns
- -------
- zeros : list of float
- List of the first n roots (x > 0) of J1'(x).
- """
- zeros = []
- x_vals = np.arange(0.0, x_max, step)
- f_prev = j1_derivative(x_vals[0])
- for i in range(1, len(x_vals)):
- f_curr = j1_derivative(x_vals[i])
- # Check for a sign change in [x_vals[i-1], x_vals[i]]
- if f_prev * f_curr < 0:
- root = bisect(j1_derivative, x_vals[i-1], x_vals[i])
- zeros.append(root)
- if len(zeros) == n:
- break
- f_prev = f_curr
- return zeros
- n_roots = 100
- Bessel_roots = np.array(j1prime_zeros(n_roots, x_max=10e6, step=0.01))
- def SpherAng(v_in):
- if v_in[2] < 0:
- v_in = -v_in # Flip the vector to the top hemisphere
- x, y, z = v_in
- r = np.linalg.norm(v_in)
- if r == 0:
- # Degenerate vector, define angles however you like:
- return 0.0, 0.0
- # Polar angle in [0, pi]
- theta = np.arccos(z / r)
- # Azimuthal angle in (-pi, pi]
- phi = np.arctan2(y, x)
- return theta,phi
- def AxCaliber(bvecs, bvals, Delta, delta, params):
- """
- Compute the combined diffusion signal in a fast, vectorized way.
- Parameters:
- bvecs : (M,3) array of b-vectors.
- bvals : (M,) array of b-values.
- Delta, delta : acquisition parameters (scalars)
- params : list/tuple of parameters:
- params[0] : fiber directions as an (N,2) array of spherical angles (theta, phi)
- params[1] : Dpar (scalar)
- params[2] : Dperp (scalar)
- params[3] : D (for hindered compartment; passed to vals_to_mat)
- params[4] : fiber fractions as an (N+1,) array
- (first element for hindered compartment, then one per fiber)
- params[5] : mean (scalar, for gamma distribution)
- params[6] : sig2 (scalar, for gamma distribution)
- params[7] : S0 (scalar)
- Returns:
- Signal : (M,) array of simulated signal values.
- """
- # Unpack parameters
- V_angles, Dpar, Dperp, D, fracs, mean, S0 = params
- # --- 1. Compute fiber unit vectors from spherical angles ---
- # Assume V_angles is an (N,2) array: each row is (theta, phi).
- theta_fibers = V_angles[:, 0]
- phi_fibers = V_angles[:, 1]
- V_unit = np.column_stack((np.sin(theta_fibers) * np.cos(phi_fibers),
- np.sin(theta_fibers) * np.sin(phi_fibers),
- np.cos(theta_fibers))) # shape: (N, 3)
- # --- 2. Compute angles between each fiber and each b-vector ---
- # Make sure bvecs is an array.
- bvecs = np.asarray(bvecs) # shape: (M,3)
- M = bvecs.shape[0]
- N = V_unit.shape[0]
- # Precompute norms of bvecs (we assume fibers are unit length so no extra norm is needed)
- bvec_norms = np.linalg.norm(bvecs, axis=1)
- # Avoid division by zero:
- safe_bvec_norms = np.where(bvec_norms == 0, 1, bvec_norms)
- # Compute the dot products for each fiber with all bvecs:
- # This gives a (N, M) array where the (i,j) element = v_i dot bvec_j.
- dots = V_unit @ bvecs.T # shape: (N, M)
- # Divide each column j by the norm of bvec j (broadcasting over fibers)
- cos_angles = dots / safe_bvec_norms # shape: (N, M)
- cos_angles = np.clip(cos_angles, -1, 1)
- # Get the angles in [0,pi]
- Angs = np.arccos(cos_angles)
- # For bvecs that are zero (norm==0), force the angle to zero.
- if np.any(bvec_norms == 0):
- Angs[:, bvec_norms == 0] = 0
- # If an angle is greater than pi/2, use pi - angle.
- Angs = np.where(Angs > np.pi/2, np.pi - Angs, Angs)
- # In the original code the first measurement was forced to zero (presumably b = 0)
- Angs[:, 0] = 0
- # --- 3. Precompute the gamma-distributed weights for the integration over R ---
- # Gamma distribution parameters:
- lam = mean*10000
- # Define R values (50 points between 0.0001 and 0.005)
- R_vals = np.arange(0.0001, 0.01, 0.0001) #
- transR = (R_vals * 10000).astype(int)
- weights = (lam**transR) * np.exp(-lam) / np.array([math.factorial(r) for r in transR.astype(int)]).astype(np.double)
- weights /= np.sum(weights)
- # --- 4. Precompute the "sumterm" that appears in the restricted compartment ---
- # Here we use m=10 terms and assume that a global array Bessel_roots is available.
- m = 10
- br = Bessel_roots[:m] # shape: (m,)
- br2 = br**2
- br6 = br**6
- # For each R in R_vals, compute the sumterm.
- # We need to broadcast over R and over the m terms.
- R2 = R_vals**2 # shape: (50,)
- # numerator: shape (50, m)
- num = (2 * Dperp * br2 * delta / R2[:, None] - 2 +
- 2 * np.exp(-Dperp * br2 * delta / R2[:, None]) +
- 2 * np.exp(-Dperp * br2 * Delta / R2[:, None]) -
- np.exp(-Dperp * br2 * (Delta - delta) / R2[:, None]) -
- np.exp(-Dperp * br2 * (Delta + delta) / R2[:, None]))
- # denominator: shape (50, m)
- den = (Dperp**2) * br6 * (br2 - 1) / (R_vals[:, None]**6)
- sumterm_R = np.sum(num / den, axis=1) # shape: (50,)
- # --- 5. Compute the restricted compartment signal ---
- # For each fiber orientation i (i = 0...N-1) and for each measurement j (j = 0...M-1)
- # we need to compute:
- # Restricted(b, theta, R) = exp(-b * (cos(theta)**2) * Dpar) *
- # exp(-2 * b * (sin(theta)**2) / ((Delta-delta/3)*delta**2) * sumterm)
- #
- # Notice that only the second exponential depends on R (via sumterm_R) and we need to integrate
- # over R with weights.
- #
- # Compute the part independent of R (base) and the factor x that multiplies sumterm_R.
- #
- # Angs has shape (N, M) (one row per fiber) and bvals is (M,).
- # (We assume that bvals is a 1D array; if not, cast it with np.asarray(bvals).)
- bvals = np.asarray(bvals) # shape: (M,)
- base = np.exp(-bvals * (np.cos(Angs)**2) * Dpar) # shape: (N, M)
- # Factor multiplying sumterm_R inside the second exponential.
- x = -2 * bvals * (np.sin(Angs)**2) / ((Delta - delta/3) * delta**2) # shape: (N, M)
- # For each fiber orientation and measurement, we want to compute:
- # f(i,j) = sum_{r=0}^{49} weights[r] * exp( x(i,j) * sumterm_R[r] )
- # We can compute the 3D array exp(x * sumterm_R) with shape (N, M, 50) and then contract out the last axis.
- exp_term = np.exp(x[..., None] * sumterm_R) # shape: (N, M, 50)
- # Now take the weighted sum over the last axis (the R axis):
- restricted_integral = np.tensordot(exp_term, weights, axes=([2], [0])) # shape: (N, M)
- # The restricted compartment signal for each fiber and measurement is then:
- Res = base * restricted_integral # shape: (N, M)
- #
- # Finally, combine the fibers by weighting each fiber's contribution by its fraction.
- # The original code did: np.sum([f * R for f,R in zip(fracs[1:],Res)], axis=0)
- # That is equivalent to a dot product: (fracs[1:]) dot (each row of Res).
- restricted_signal = np.dot(fracs[1:], Res) # shape: (M,)
- # --- 6. Compute the hindered compartment signal ---
- # Compute the diffusion tensor from D (using your vals_to_mat function).
- dh = vals_to_mat(D)
- # The hindered signal is given by:
- # Hi = exp(-b * s)
- # where s = sum((bvec @ dh)*bvec, axis=1). Here bvecs is (M,3).
- s = np.sum((bvecs @ dh) * bvecs, axis=1) # shape: (M,)
- hindered_signal = np.exp(-bvals * s) # shape: (M,)
- # --- 7. Combine compartments and scale by S0 ---
- Signal = fracs[0] * hindered_signal + restricted_signal
- return S0 * Signal
- def AxCal_Errors(TrueSig,TrueParams,GuessParams,Delta,bvecs,bvals):
- Res = np.linalg.norm(residuals(GuessParams,TrueSig,bvecs,bvals,Delta))
- alpha_err = np.abs(GuessParams[11]-TrueParams[11])
- angle_err1 = np.abs(GuessParams[0]-TrueParams[0])
- angle_err2 = np.abs(GuessParams[1]-TrueParams[1])
- Dpar_err = np.abs(TrueParams[2]-GuessParams[2])
- Dperp_err = np.abs(TrueParams[3]-GuessParams[3])
- MD_guess = np.linalg.eigh(vals_to_mat(GuessParams[4:10]))[0].mean()
- MD_true = np.linalg.eigh(vals_to_mat(TrueParams[4:10]))[0].mean()
- FA_guess = FracAni(np.linalg.eigh(vals_to_mat(GuessParams[4:10]))[0],MD_guess)
- FA_true = FracAni(np.linalg.eigh(vals_to_mat(TrueParams[4:10]))[0],MD_true)
- MD_err = np.abs(MD_guess-MD_true)
- FA_err = np.abs(FA_guess-FA_true)
- Frac_err = np.abs(TrueParams[10]-GuessParams[10])
- return Res, alpha_err,angle_err1,angle_err2,Dpar_err,Dperp_err,MD_err,FA_err,Frac_err
- def residuals(params,TrueSig,bvecs,bvals,Delta,EstS0 = True):
- if(EstS0):
- Signal = AxC_Simulator(params,bvecs,bvals,Delta,S0=params[-1])
- else:
- Signal = AxC_Simulator(params,bvecs,bvals,Delta)
- return TrueSig - Signal
- def AxC_Simulator(params,bvecs,bvals,Delta,S0=200):
- new_params = [np.array([params[:2]]),params[2],params[3],params[4:10],[params[10],1-params[10]],params[11],S0]
- Sig = []
- for bve,bva,d in zip(bvecs,bvals,Delta):
- Sig.append(AxCaliber(bve,bva,d,delta,new_params))
- return np.hstack(Sig)
- def shell_time_stats(b_dw, Δ_dw, y_dw):
- """
- Compute mean and variance of y for each (b, Δ) combination
- using DW-only arrays.
- Parameters
- ----------
- b_dw : (N,) array of DW b-values
- Δ_dw : (N,) array of DW diffusion times
- y_dw : (N,) array of DW log-attenuations
- Returns
- -------
- feats : 1D array of length 2 * (#unique b) * (#unique Δ)
- [mean_y(b1,Δ1), var_y(b1,Δ1), mean_y(b1,Δ2), var_y(b1,Δ2), ...]
- """
- b_dw = np.asarray(b_dw)
- Δ_dw = np.asarray(Δ_dw)
- y_dw = np.asarray(y_dw)
- shells = np.unique(b_dw)
- times = np.unique(Δ_dw)
- feats = []
- for b in shells:
- for Δ in times:
- m = (b_dw == b) & (Δ_dw == Δ)
- if np.any(m):
- y_sub = y_dw[m]
- feats.append(y_sub.mean())
- feats.append(y_sub.var())
- else:
- feats.append(0.0)
- feats.append(0.0)
- return np.array(feats, dtype=float)
- def AxcaliberFeatures(bvecs, bvals, Deltas, Signal):
- """
- Feature construction for AxCaliber-like data, analogous to DTIFeatures/DKIFeatures.
- Parameters
- ----------
- bvecs : (M, 3) array
- Gradient directions.
- bvals : (M,) array
- b-values corresponding to each gradient.
- Deltas : (M,) array
- Diffusion times (Delta) for each measurement.
- Signal : (M,) array
- Measured signal.
- Returns
- -------
- feats : (1 + 18 + 18*18,) array
- Concatenated feature vector:
- [ S0_hat,
- SigFeat (18,),
- AcqFeat (18*18,) ]
- """
- bvecs = np.asarray(bvecs, dtype=float)
- bvals = np.asarray(bvals, dtype=float)/1000
- Deltas = np.asarray(Deltas, dtype=float)
- Signal = np.asarray(Signal, dtype=float)
- if bvecs.shape[0] != bvals.shape[0] or bvals.shape[0] != Deltas.shape[0] \
- or Signal.shape[0] != bvals.shape[0]:
- raise ValueError("bvecs, bvals, Deltas, and Signal must all have the same length (M).")
- # ---- 1. Separate b=0 and DW ----
- S0_mask = (bvals == 0)
- dw_mask = (bvals > 0)
- if not np.any(S0_mask):
- raise ValueError("At least one b=0 measurement is required to estimate S0.")
- if np.sum(dw_mask) < 6:
- raise ValueError("At least 6 DW measurements are recommended for this feature mapping.")
- S0_hat = np.mean(Signal[S0_mask])
- S_dw = Signal[dw_mask]
- b_dw = bvals[dw_mask]
- g_dw = bvecs[dw_mask, :]
- Δ_dw = Deltas[dw_mask]
- # Response variable y = -ln(S / S0)
- y = -np.log(S_dw / S0_hat) # shape [N]
- N = y.size
- g1, g2, g3 = g_dw[:, 0], g_dw[:, 1], g_dw[:, 2]
- sqrtb = np.sqrt(b_dw)
- # ---- 2. Base diffusion-like design (6 terms, as in DTI) ----
- # Each term is effectively ~ b * g_i g_j
- # We construct it using the same pattern as your DTIFeatures.
- X_base = np.vstack([
- (sqrtb * g1) * (sqrtb * g1), # b * g1^2
- 2 * (sqrtb * g1) * (sqrtb * g2), # 2 b * g1 g2
- (sqrtb * g2) * (sqrtb * g2), # b * g2^2
- 2 * (sqrtb * g1) * (sqrtb * g3), # 2 b * g1 g3
- 2 * (sqrtb * g2) * (sqrtb * g3), # 2 b * g2 g3
- (sqrtb * g3) * (sqrtb * g3) # b * g3^2
- ]) # shape [6, N]
- # ---- 3. Time basis functions for Delta ----
- # Use a simple polynomial basis in Delta: [1, Δ, Δ^2]
- # Then modulate the 6 diffusion-like terms with each time basis.
- T0 = np.ones_like(Δ_dw) # Δ^0
- T1 = Δ_dw # Δ^1
- T2 = Δ_dw**2 # Δ^2
- # Each gives a 6×N block when multiplied with X_base.
- X_Δ0 = X_base # 6 × N
- X_Δ1 = X_base * T1 # 6 × N (broadcast over columns)
- X_Δ2 = X_base * T2 # 6 × N
- # Stack into a single design matrix: 18 × N
- X = np.vstack([X_Δ0, X_Δ1, X_Δ2]) # shape [18, N]
- # ---- 4. Acquisition and signal features ----
- # Acquisition features: design self-product
- XtX = X_base @ X_base.T # [18, 18]
- AcqFeat = (XtX / N).ravel() # length 18*18
- # Signal features: design–response product
- SigFeat = (X @ y) / N # length 18
- ShellTimeFeat = shell_time_stats(b_dw, Δ_dw, y)
- # ---- 5. Concatenate ----
- return np.hstack([S0_hat, SigFeat, AcqFeat,ShellTimeFeat])
- def Par_frac(i,j,Mat):
- MD = np.linalg.eigh(vals_to_mat(Mat[i,j]))[0].mean()
- FA = FracAni(np.linalg.eigh(vals_to_mat(Mat[i,j]))[0],MD)
- return i, j, [FA,MD]
AxCaliber_funcs.py at commit e166ec3, no license · at the source
Overview
- Institute of Neuroscience, CSIC-UMH, Alicante, Sant Joan d’Alacant, Spain
- Institute of Experimental Epileptology, University Hospital Bonn, Bonn, Germany
Abstract
The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.
Repositories
Its files are read in the Code ↔ Paper reader above, with 5 matches between paragraphs and lines of code.
TIB-Lab/SBIDTI
e166ec3542b2fa5ac15a6f7578199f192c3c4fe2, 27 January 2026Availability: 1 check, the latest on 27 September 2026: the link answers
- 27 September 2026: the link answers
8 files
- AxCaliber_figs.ipynb, Jupyter, 2,967 lines, 2 matches
- AxCaliber_funcs.py, Python, 383 lines, 2 matches
- DKI_figs.ipynb, Jupyter, 4,241 lines
- DKI_funcs.py, Python, 328 lines, 1 match
- DTI_figs.ipynb, Jupyter, 3,171 lines
- DTI_funcs.py, Python, 83 lines
- Imports.py, Python, 264 lines
- README.md, Text, 9 lines
Zenodo 18086195
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
- 27 September 2026: the link answers (HTTP 200)
8 files
- AxCaliber_figs.ipynb, Jupyter, 2,967 lines
- AxCaliber_funcs.py, Python, 383 lines
- DKI_figs.ipynb, Jupyter, 4,241 lines
- DKI_funcs.py, Python, 328 lines
- DTI_figs.ipynb, Jupyter, 3,171 lines
- DTI_funcs.py, Python, 83 lines
- Imports.py, Python, 264 lines
- README.md, Text, 9 lines
Code availability statement
The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:
- it points to the authors' code: TIB-Lab/
SBIDTI - it says that the code is available on request
Read it in the paper: doi.org/10.1038/s43856-026-01614-6.
Tracing map
Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.
What the map holds:
- 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
- 14 scripts, each with its path and the digest of its content;
- 5 matches between paragraphs of the paper and lines of the code (method lexical-v1);
- neither the text of the paper nor the code itself.
Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.
Data
No dataset and no data link were found in the paper.
Code and data availability statement
The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:
- it points to the authors' code: TIB-Lab/
SBIDTI - it says that the data are available on request
- it says that the code is available on request
Read it in the paper: doi.org/10.1038/s43856-026-01614-6.
Versions
The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.
Version 1, 27 September 2026: the first record
Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 3 keywords, 3 funders, 61 references.
Cite
This paper
Eggl, M. F., & De Santis, S. (2026). Simulation-based inference at the theoretical limit for fast, robust microstructural MRI with minimal diffusion data. Communications medicine, 6(1), 275. https://
BibTeX
@article{eggl2026simulat
author = {Eggl, Maximilian F and De Santis, Silvia},
title = {{Simulation-based inference at the theoretical limit for fast, robust microstructural MRI with minimal diffusion data}},
journal = {Communications medicine},
year = {2026},
month = may,
volume = {6},
number = {1},
pages = {275},
publisher = {Nature Publishing Group},
issn = {2730-664X},
doi = {10.1038/
url = {https://
pmid = {42062550},
pmcid = {PMC13157494}
}
RIS
TY - JOUR
AU - Eggl, Maximilian F
AU - De Santis, Silvia
TI - Simulation-based inference at the theoretical limit for fast, robust microstructural MRI with minimal diffusion data
T2 - Communications medicine
J2 - Commun Med (Lond)
PY - 2026
DA - 2026/
VL - 6
IS - 1
SP - 275
SN - 2730-664X
PB - Nature Publishing Group
DO - 10.1038/
UR - https://
LA - en
ER -
CSL-JSON
{
"id": "10.1038/
"type": "article-journal",
"title": "Simulation-based inference at the theoretical limit for fast, robust microstructural MRI with minimal diffusion data",
"container-title": "Communications medicine",
"author": [
{
"family": "Eggl",
"given": "Maximilian F"
},
{
"family": "De Santis",
"given": "Silvia"
}
],
"container-title-short":
"volume": "6",
"issue": "1",
"page": "275",
"DOI": "10.1038/
"PMID": "42062550",
"PMCID": "PMC13157494",
"ISSN": "2730-664X",
"publisher": "Nature Publishing Group",
"URL": "https://
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
1
]
]
}
}
The tracing map gets a citation of its own once an author has validated it and it has a DOI.
Similar papers
The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.
- [1] doi:10.1162/imag_a_00576 [code]
- Interplay between MRI-based axon diameter and myelination estimates in macaque and human brain.Journal: Imaging neuroscience (Cambridge, Mass.)In common: NumPy, structural MRI / diffusion, 13 references
- [2] doi:10.1002/advs.202307965 [code]
- DIMOND: DIffusion Model OptimizatioN with Deep Learning.Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)In common: DIPY, PyTorch, SciPy, 2 other tools, structural MRI / diffusion, 11 references
- [3] doi:10.1007/s12021-023-09630-w [code]
- A Method for In-Vivo Mapping of Axonal Diameter Distributions in the Human Brain Using Diffusion-Based Axonal Spectrum Imaging (AxSI).Journal: NeuroinformaticsIn common: DIPY, SciPy, NumPy, structural MRI / diffusion, 11 references
- [4] doi:10.1162/imag_a_00353
- Diffusion MRI with Machine Learning.Journal: Imaging neuroscience (Cambridge, Mass.)In common: structural MRI / diffusion, 13 references
- [5] doi:10.3389/fnins.2023.1209521
- Estimating axon radius using diffusion-relaxation MRI: calibrating a surface-based relaxation model with histology.Journal: Frontiers in neuroscienceIn common: structural MRI / diffusion, 11 references
- [6] doi:10.1002/nbm.70277 [code]
- Hierarchical Bayesian Modelling Improves Microstructural Parameter Mapping in Diffusion and Exchange MRI Data.Journal: NMR in biomedicineIn common: DIPY, SciPy, Matplotlib, 1 other tool, computational, structural MRI / diffusion, 8 references
- [7] doi:10.1002/hbm.26143
- Linear multi-scale modeling of diffusion MRI data: A framework for characterization of oriented structures across length scales.Journal: Human brain mappingIn common: structural MRI / diffusion, 12 references
- [8] doi:10.1162/imag_a_00288 [code]
- ACID: A comprehensive toolbox for image processing and modeling of brain, spinal cord, and ex vivo diffusion MRI data.Journal: Imaging neuroscience (Cambridge, Mass.)In common: Matplotlib, NumPy, structural MRI / diffusion, 11 references
- [9] doi:10.3389/fninf.2023.1191200 [code]
- versaFlow: a versatile pipeline for resolution adapted diffusion MRI processing and its application to studying the variability of the PRIME-DE database.Journal: Frontiers in neuroinformaticsIn common: DIPY, SciPy, NumPy, structural MRI / diffusion, 9 references
- [10] doi:10.1002/mrm.70378 [code]
- Investigating the Sensitivity of the Diffusion MRI Signal to Magnetization Transfer and Permeability via Monte-Carlo Simulations.Journal: Magnetic resonance in medicineIn common: SciPy, Matplotlib, NumPy, computational, structural MRI / diffusion, 8 references
Contribute
The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.
Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.
Claim this paper
Correct its record
Say what each link of this record is, remove the ones that are not the paper's, add the ones that are missing. The correction becomes a new version of the record, in its Versions section.
Validate its tracing map
You validate the map as this page shows it: 2 repositories of the authors' code, each at its verified commit and with its license, 14 scripts, and 5 matches between paragraphs and code (see the Code and Map sections). It then receives a DOI on Zenodo, with you (your ORCID iD) and OSCR as its creators; the code itself is not deposited.
The map's fingerprint: sha256:37762b7c1fbc2a0f…
Add the badge to the code's README
If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.
Markdown
<!-- oscr-badge:start -->
[](https://openscicode.org/badge/doi/10.1038/s43856-026-01614-6)
<!-- oscr-badge:end -->reStructuredText
.. oscr-badge:start
.. image:: https://openscicode.org/badge/doi/10.1038/s43856-026-01614-6.svg
:target: https://openscicode.org/badge/doi/10.1038/s43856-026-01614-6
:alt: OSCR
.. oscr-badge:endHTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1038/s43856-026-01614-6"><img src="https://openscicode.org/badge/doi/10.1038/s43856-026-01614-6.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".
If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.
Request its removal
To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).
Discussion, reproductions, activity
Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.
Report a mismatch between the code and the paper · Report a code error (signed in)
Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.
Report a reproduction failure (signed in)
Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.
Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.
