OSCR

Simulation-based inference at the theoretical limit for fast, robust microstructural MRI with minimal diffusion data.

Code ↔ Paper

5 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 5 matches
  1. [1] § Methods › Tensor-based frameworks ↔ DKI_funcs.py, lines 11–32 · score 0.83 · radial kurtosis, axial kurtosis, kurtosis fractional, kurtosis tensor, DKI metrics, KFA
  2. [2] § Methods › The AxCaliber model ↔ AxCaliber_funcs.py, lines 73–205 · score 0.82 · gamma distribution, restricted compartment, diffusion tensor, AxCaliber, exponential, scalar
  3. [3] § Results › Application of SBI to AxCaliber ↔ AxCaliber_funcs.py, lines 73–205 · score 0.58 · restricted compartment, restricted signal, simulated signals, angle, hindered, fraction
  4. [4] § Results › Application of SBI to AxCaliber ↔ AxCaliber_figs.ipynb, lines 553–575 · score 0.53 · reduced SBI, reduced NLLS, full NLLS, full SBI, angle, circle
  5. [5] § Methods › The AxCaliber model ↔ AxCaliber_figs.ipynb, lines 183–248 · score 0.52 · diffusion tensor, AxCaliber, gamma, Dh, hindered

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: 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

  1. from DTI_funcs import *
  3. from scipy.special import j0, jv
  4. from scipy.optimize import bisect
  6. Delta = [0.017, 0.035, 0.061] # ms
  7. delta = 0.007 # ms
  9. def j1_derivative(x):
  10. """Derivative of J1(x) using the identity: J1'(x) = 0.5 * (J0(x) - J2(x))."""
  11. return 0.5 * (j0(x) - j2(x))
  13. def j2(x):
  14. """Bessel function J_2(x)."""
  15. return jv(2, x)
  17. def j1prime_zeros(n, x_max=100, step=0.1):
  18. """
  19. Find the first n positive roots of J1'(x) by scanning from x=0 to x_max.
  21. Parameters
  22. ----------
  23. n : int
  24. Number of roots to find
  25. x_max : float
  26. Maximum x to search
  27. step : float
  28. Step size for scanning sign changes
  30. Returns
  31. -------
  32. zeros : list of float
  33. List of the first n roots (x > 0) of J1'(x).
  34. """
  35. zeros = []
  36. x_vals = np.arange(0.0, x_max, step)
  38. f_prev = j1_derivative(x_vals[0])
  39. for i in range(1, len(x_vals)):
  40. f_curr = j1_derivative(x_vals[i])
  41. # Check for a sign change in [x_vals[i-1], x_vals[i]]
  42. if f_prev * f_curr < 0:
  43. root = bisect(j1_derivative, x_vals[i-1], x_vals[i])
  44. zeros.append(root)
  45. if len(zeros) == n:
  46. break
  47. f_prev = f_curr
  49. return zeros
  51. n_roots = 100
  52. Bessel_roots = np.array(j1prime_zeros(n_roots, x_max=10e6, step=0.01))
  54. def SpherAng(v_in):
  56. if v_in[2] < 0:
  57. v_in = -v_in # Flip the vector to the top hemisphere
  59. x, y, z = v_in
  60. r = np.linalg.norm(v_in)
  61. if r == 0:
  62. # Degenerate vector, define angles however you like:
  63. return 0.0, 0.0
  65. # Polar angle in [0, pi]
  66. theta = np.arccos(z / r)
  68. # Azimuthal angle in (-pi, pi]
  69. phi = np.arctan2(y, x)
  71. return theta,phi
  73. def AxCaliber(bvecs, bvals, Delta, delta, params):
  74. """
  75. Compute the combined diffusion signal in a fast, vectorized way.
  77. Parameters:
  78. bvecs : (M,3) array of b-vectors.
  79. bvals : (M,) array of b-values.
  80. Delta, delta : acquisition parameters (scalars)
  81. params : list/tuple of parameters:
  82. params[0] : fiber directions as an (N,2) array of spherical angles (theta, phi)
  83. params[1] : Dpar (scalar)
  84. params[2] : Dperp (scalar)
  85. params[3] : D (for hindered compartment; passed to vals_to_mat)
  86. params[4] : fiber fractions as an (N+1,) array
  87. (first element for hindered compartment, then one per fiber)
  88. params[5] : mean (scalar, for gamma distribution)
  89. params[6] : sig2 (scalar, for gamma distribution)
  90. params[7] : S0 (scalar)
  92. Returns:
  93. Signal : (M,) array of simulated signal values.
  94. """
  95. # Unpack parameters
  96. V_angles, Dpar, Dperp, D, fracs, mean, S0 = params
  98. # --- 1. Compute fiber unit vectors from spherical angles ---
  99. # Assume V_angles is an (N,2) array: each row is (theta, phi).
  100. theta_fibers = V_angles[:, 0]
  101. phi_fibers = V_angles[:, 1]
  102. V_unit = np.column_stack((np.sin(theta_fibers) * np.cos(phi_fibers),
  103. np.sin(theta_fibers) * np.sin(phi_fibers),
  104. np.cos(theta_fibers))) # shape: (N, 3)
  106. # --- 2. Compute angles between each fiber and each b-vector ---
  107. # Make sure bvecs is an array.
  108. bvecs = np.asarray(bvecs) # shape: (M,3)
  109. M = bvecs.shape[0]
  110. N = V_unit.shape[0]
  112. # Precompute norms of bvecs (we assume fibers are unit length so no extra norm is needed)
  113. bvec_norms = np.linalg.norm(bvecs, axis=1)
  114. # Avoid division by zero:
  115. safe_bvec_norms = np.where(bvec_norms == 0, 1, bvec_norms)
  117. # Compute the dot products for each fiber with all bvecs:
  118. # This gives a (N, M) array where the (i,j) element = v_i dot bvec_j.
  119. dots = V_unit @ bvecs.T # shape: (N, M)
  121. # Divide each column j by the norm of bvec j (broadcasting over fibers)
  122. cos_angles = dots / safe_bvec_norms # shape: (N, M)
  123. cos_angles = np.clip(cos_angles, -1, 1)
  124. # Get the angles in [0,pi]
  125. Angs = np.arccos(cos_angles)
  126. # For bvecs that are zero (norm==0), force the angle to zero.
  127. if np.any(bvec_norms == 0):
  128. Angs[:, bvec_norms == 0] = 0
  129. # If an angle is greater than pi/2, use pi - angle.
  130. Angs = np.where(Angs > np.pi/2, np.pi - Angs, Angs)
  131. # In the original code the first measurement was forced to zero (presumably b = 0)
  132. Angs[:, 0] = 0
  134. # --- 3. Precompute the gamma-distributed weights for the integration over R ---
  135. # Gamma distribution parameters:
  136. lam = mean*10000
  137. # Define R values (50 points between 0.0001 and 0.005)
  138. R_vals = np.arange(0.0001, 0.01, 0.0001) #
  139. transR = (R_vals * 10000).astype(int)
  141. weights = (lam**transR) * np.exp(-lam) / np.array([math.factorial(r) for r in transR.astype(int)]).astype(np.double)
  142. weights /= np.sum(weights)
  144. # --- 4. Precompute the "sumterm" that appears in the restricted compartment ---
  145. # Here we use m=10 terms and assume that a global array Bessel_roots is available.
  146. m = 10
  147. br = Bessel_roots[:m] # shape: (m,)
  148. br2 = br**2
  149. br6 = br**6
  150. # For each R in R_vals, compute the sumterm.
  151. # We need to broadcast over R and over the m terms.
  152. R2 = R_vals**2 # shape: (50,)
  153. # numerator: shape (50, m)
  154. num = (2 * Dperp * br2 * delta / R2[:, None] - 2 +
  155. 2 * np.exp(-Dperp * br2 * delta / R2[:, None]) +
  156. 2 * np.exp(-Dperp * br2 * Delta / R2[:, None]) -
  157. np.exp(-Dperp * br2 * (Delta - delta) / R2[:, None]) -
  158. np.exp(-Dperp * br2 * (Delta + delta) / R2[:, None]))
  159. # denominator: shape (50, m)
  160. den = (Dperp**2) * br6 * (br2 - 1) / (R_vals[:, None]**6)
  161. sumterm_R = np.sum(num / den, axis=1) # shape: (50,)
  163. # --- 5. Compute the restricted compartment signal ---
  164. # For each fiber orientation i (i = 0...N-1) and for each measurement j (j = 0...M-1)
  165. # we need to compute:
  166. # Restricted(b, theta, R) = exp(-b * (cos(theta)**2) * Dpar) *
  167. # exp(-2 * b * (sin(theta)**2) / ((Delta-delta/3)*delta**2) * sumterm)
  168. #
  169. # Notice that only the second exponential depends on R (via sumterm_R) and we need to integrate
  170. # over R with weights.
  171. #
  172. # Compute the part independent of R (base) and the factor x that multiplies sumterm_R.
  173. #
  174. # Angs has shape (N, M) (one row per fiber) and bvals is (M,).
  175. # (We assume that bvals is a 1D array; if not, cast it with np.asarray(bvals).)
  176. bvals = np.asarray(bvals) # shape: (M,)
  177. base = np.exp(-bvals * (np.cos(Angs)**2) * Dpar) # shape: (N, M)
  178. # Factor multiplying sumterm_R inside the second exponential.
  179. x = -2 * bvals * (np.sin(Angs)**2) / ((Delta - delta/3) * delta**2) # shape: (N, M)
  180. # For each fiber orientation and measurement, we want to compute:
  181. # f(i,j) = sum_{r=0}^{49} weights[r] * exp( x(i,j) * sumterm_R[r] )
  182. # We can compute the 3D array exp(x * sumterm_R) with shape (N, M, 50) and then contract out the last axis.
  183. exp_term = np.exp(x[..., None] * sumterm_R) # shape: (N, M, 50)
  184. # Now take the weighted sum over the last axis (the R axis):
  185. restricted_integral = np.tensordot(exp_term, weights, axes=([2], [0])) # shape: (N, M)
  186. # The restricted compartment signal for each fiber and measurement is then:
  187. Res = base * restricted_integral # shape: (N, M)
  188. #
  189. # Finally, combine the fibers by weighting each fiber's contribution by its fraction.
  190. # The original code did: np.sum([f * R for f,R in zip(fracs[1:],Res)], axis=0)
  191. # That is equivalent to a dot product: (fracs[1:]) dot (each row of Res).
  192. restricted_signal = np.dot(fracs[1:], Res) # shape: (M,)
  194. # --- 6. Compute the hindered compartment signal ---
  195. # Compute the diffusion tensor from D (using your vals_to_mat function).
  196. dh = vals_to_mat(D)
  197. # The hindered signal is given by:
  198. # Hi = exp(-b * s)
  199. # where s = sum((bvec @ dh)*bvec, axis=1). Here bvecs is (M,3).
  200. s = np.sum((bvecs @ dh) * bvecs, axis=1) # shape: (M,)
  201. hindered_signal = np.exp(-bvals * s) # shape: (M,)
  203. # --- 7. Combine compartments and scale by S0 ---
  204. Signal = fracs[0] * hindered_signal + restricted_signal
  205. return S0 * Signal
  207. def AxCal_Errors(TrueSig,TrueParams,GuessParams,Delta,bvecs,bvals):
  209. Res = np.linalg.norm(residuals(GuessParams,TrueSig,bvecs,bvals,Delta))
  210. alpha_err = np.abs(GuessParams[11]-TrueParams[11])
  212. angle_err1 = np.abs(GuessParams[0]-TrueParams[0])
  213. angle_err2 = np.abs(GuessParams[1]-TrueParams[1])
  215. Dpar_err = np.abs(TrueParams[2]-GuessParams[2])
  216. Dperp_err = np.abs(TrueParams[3]-GuessParams[3])
  218. MD_guess = np.linalg.eigh(vals_to_mat(GuessParams[4:10]))[0].mean()
  219. MD_true = np.linalg.eigh(vals_to_mat(TrueParams[4:10]))[0].mean()
  221. FA_guess = FracAni(np.linalg.eigh(vals_to_mat(GuessParams[4:10]))[0],MD_guess)
  222. FA_true = FracAni(np.linalg.eigh(vals_to_mat(TrueParams[4:10]))[0],MD_true)
  224. MD_err = np.abs(MD_guess-MD_true)
  225. FA_err = np.abs(FA_guess-FA_true)
  227. Frac_err = np.abs(TrueParams[10]-GuessParams[10])
  229. return Res, alpha_err,angle_err1,angle_err2,Dpar_err,Dperp_err,MD_err,FA_err,Frac_err
  231. def residuals(params,TrueSig,bvecs,bvals,Delta,EstS0 = True):
  232. if(EstS0):
  233. Signal = AxC_Simulator(params,bvecs,bvals,Delta,S0=params[-1])
  234. else:
  235. Signal = AxC_Simulator(params,bvecs,bvals,Delta)
  236. return TrueSig - Signal
  238. def AxC_Simulator(params,bvecs,bvals,Delta,S0=200):
  239. new_params = [np.array([params[:2]]),params[2],params[3],params[4:10],[params[10],1-params[10]],params[11],S0]
  240. Sig = []
  241. for bve,bva,d in zip(bvecs,bvals,Delta):
  242. Sig.append(AxCaliber(bve,bva,d,delta,new_params))
  243. return np.hstack(Sig)
  246. def shell_time_stats(b_dw, Δ_dw, y_dw):
  247. """
  248. Compute mean and variance of y for each (b, Δ) combination
  249. using DW-only arrays.
  251. Parameters
  252. ----------
  253. b_dw : (N,) array of DW b-values
  254. Δ_dw : (N,) array of DW diffusion times
  255. y_dw : (N,) array of DW log-attenuations
  257. Returns
  258. -------
  259. feats : 1D array of length 2 * (#unique b) * (#unique Δ)
  260. [mean_y(b1,Δ1), var_y(b1,Δ1), mean_y(b1,Δ2), var_y(b1,Δ2), ...]
  261. """
  262. b_dw = np.asarray(b_dw)
  263. Δ_dw = np.asarray(Δ_dw)
  264. y_dw = np.asarray(y_dw)
  266. shells = np.unique(b_dw)
  267. times = np.unique(Δ_dw)
  269. feats = []
  270. for b in shells:
  271. for Δ in times:
  272. m = (b_dw == b) & (Δ_dw == Δ)
  273. if np.any(m):
  274. y_sub = y_dw[m]
  275. feats.append(y_sub.mean())
  276. feats.append(y_sub.var())
  277. else:
  278. feats.append(0.0)
  279. feats.append(0.0)
  280. return np.array(feats, dtype=float)
  282. def AxcaliberFeatures(bvecs, bvals, Deltas, Signal):
  283. """
  284. Feature construction for AxCaliber-like data, analogous to DTIFeatures/DKIFeatures.
  286. Parameters
  287. ----------
  288. bvecs : (M, 3) array
  289. Gradient directions.
  290. bvals : (M,) array
  291. b-values corresponding to each gradient.
  292. Deltas : (M,) array
  293. Diffusion times (Delta) for each measurement.
  294. Signal : (M,) array
  295. Measured signal.
  297. Returns
  298. -------
  299. feats : (1 + 18 + 18*18,) array
  300. Concatenated feature vector:
  301. [ S0_hat,
  302. SigFeat (18,),
  303. AcqFeat (18*18,) ]
  304. """
  305. bvecs = np.asarray(bvecs, dtype=float)
  306. bvals = np.asarray(bvals, dtype=float)/1000
  307. Deltas = np.asarray(Deltas, dtype=float)
  308. Signal = np.asarray(Signal, dtype=float)
  310. if bvecs.shape[0] != bvals.shape[0] or bvals.shape[0] != Deltas.shape[0] \
  311. or Signal.shape[0] != bvals.shape[0]:
  312. raise ValueError("bvecs, bvals, Deltas, and Signal must all have the same length (M).")
  314. # ---- 1. Separate b=0 and DW ----
  315. S0_mask = (bvals == 0)
  316. dw_mask = (bvals > 0)
  318. if not np.any(S0_mask):
  319. raise ValueError("At least one b=0 measurement is required to estimate S0.")
  320. if np.sum(dw_mask) < 6:
  321. raise ValueError("At least 6 DW measurements are recommended for this feature mapping.")
  323. S0_hat = np.mean(Signal[S0_mask])
  325. S_dw = Signal[dw_mask]
  326. b_dw = bvals[dw_mask]
  327. g_dw = bvecs[dw_mask, :]
  328. Δ_dw = Deltas[dw_mask]
  330. # Response variable y = -ln(S / S0)
  331. y = -np.log(S_dw / S0_hat) # shape [N]
  332. N = y.size
  334. g1, g2, g3 = g_dw[:, 0], g_dw[:, 1], g_dw[:, 2]
  335. sqrtb = np.sqrt(b_dw)
  337. # ---- 2. Base diffusion-like design (6 terms, as in DTI) ----
  338. # Each term is effectively ~ b * g_i g_j
  339. # We construct it using the same pattern as your DTIFeatures.
  340. X_base = np.vstack([
  341. (sqrtb * g1) * (sqrtb * g1), # b * g1^2
  342. 2 * (sqrtb * g1) * (sqrtb * g2), # 2 b * g1 g2
  343. (sqrtb * g2) * (sqrtb * g2), # b * g2^2
  344. 2 * (sqrtb * g1) * (sqrtb * g3), # 2 b * g1 g3
  345. 2 * (sqrtb * g2) * (sqrtb * g3), # 2 b * g2 g3
  346. (sqrtb * g3) * (sqrtb * g3) # b * g3^2
  347. ]) # shape [6, N]
  349. # ---- 3. Time basis functions for Delta ----
  350. # Use a simple polynomial basis in Delta: [1, Δ, Δ^2]
  351. # Then modulate the 6 diffusion-like terms with each time basis.
  352. T0 = np.ones_like(Δ_dw) # Δ^0
  353. T1 = Δ_dw # Δ^1
  354. T2 = Δ_dw**2 # Δ^2
  356. # Each gives a 6×N block when multiplied with X_base.
  357. X_Δ0 = X_base # 6 × N
  358. X_Δ1 = X_base * T1 # 6 × N (broadcast over columns)
  359. X_Δ2 = X_base * T2 # 6 × N
  361. # Stack into a single design matrix: 18 × N
  362. X = np.vstack([X_Δ0, X_Δ1, X_Δ2]) # shape [18, N]
  364. # ---- 4. Acquisition and signal features ----
  365. # Acquisition features: design self-product
  366. XtX = X_base @ X_base.T # [18, 18]
  367. AcqFeat = (XtX / N).ravel() # length 18*18
  369. # Signal features: design–response product
  370. SigFeat = (X @ y) / N # length 18
  373. ShellTimeFeat = shell_time_stats(b_dw, Δ_dw, y)
  375. # ---- 5. Concatenate ----
  376. return np.hstack([S0_hat, SigFeat, AcqFeat,ShellTimeFeat])
  379. def Par_frac(i,j,Mat):
  380. MD = np.linalg.eigh(vals_to_mat(Mat[i,j]))[0].mean()
  382. FA = FracAni(np.linalg.eigh(vals_to_mat(Mat[i,j]))[0],MD)
  383. return i, j, [FA,MD]

AxCaliber_funcs.py at commit e166ec3, no license · at the source

Overview

Authors: Maximilian F Eggl1,2, Silvia De Santis1
ORCID iDs: Maximilian F Eggl, Silvia De Santis
  1. Institute of Neuroscience, CSIC-UMH, Alicante, Sant Joan d’Alacant, Spain
  2. Institute of Experimental Epileptology, University Hospital Bonn, Bonn, Germany
Institutions: University Hospital Bonn (Germany); Instituto de Neurociencias (Spain)
Journal: Communications medicine, volume 6, issue 1, article 275
Dates: received 20 August 2025; accepted 13 April 2026; published online 1 May 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s43856-026-01614-6 · PMID 42062550 · PMCID PMC13157494 · OpenAlex W7159614343
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), computational (subfield)
Methods: Connectivity, Statistics, fMRI & imaging, Physiology & signal measures
Keywords: Magnetic resonance imaging, Diffusion tensor imaging, Computational neuroscience
Topic: Advanced Neuroimaging Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: Generalitat Valenciana (Regional Government of Valencia) (CIDE- GENT/2021/015); "la Caixa" Foundation (Caixa Foundation) (LCF/BQ/PI23/11970039); Ministry of Economy and Competitiveness | Agencia Estatal de Investigación (Spanish Agencia Estatal de Investigación) (CNS2023-14488)
Citations: cited by 2 papers (Europe PMC); 79 references in the paper

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

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: e166ec3542b2fa5ac15a6f7578199f192c3c4fe2, 27 January 2026
Languages: Python (4), Jupyter (3)
Size: 12 files, 7 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, 3 notebooks
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: DIPY (3 files), SciPy (3 files), Matplotlib (2 files), NumPy (1 file), PyTorch (1 file), scikit-image (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
8 files
At the source: github.com/TIB-Lab/SBIDTI

Zenodo 18086195

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: DIPY (3 files), SciPy (3 files), Matplotlib (2 files), NumPy (1 file), PyTorch (1 file), scikit-image (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
8 files
At the source:

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://doi.org/10.1038/s43856-026-01614-6

BibTeX

@article{eggl2026simulation,
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/s43856-026-01614-6},
url = {https://doi.org/10.1038/s43856-026-01614-6},
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/05/01
VL - 6
IS - 1
SP - 275
SN - 2730-664X
PB - Nature Publishing Group
DO - 10.1038/s43856-026-01614-6
UR - https://doi.org/10.1038/s43856-026-01614-6
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s43856-026-01614-6",
"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": "Commun Med (Lond)",
"volume": "6",
"issue": "1",
"page": "275",
"DOI": "10.1038/s43856-026-01614-6",
"PMID": "42062550",
"PMCID": "PMC13157494",
"ISSN": "2730-664X",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s43856-026-01614-6",
"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.1002/nbm.70277 [code]
Hierarchical Bayesian Modelling Improves Microstructural Parameter Mapping in Diffusion and Exchange MRI Data.
Journal: NMR in biomedicine
In common: DIPY, SciPy, Matplotlib, 1 other tool, computational, structural MRI / diffusion, 8 references
[2] 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 medicine
In common: SciPy, Matplotlib, NumPy, computational, structural MRI / diffusion, 8 references
[3] doi:10.1002/hbm.70513 [code]
Deep Learning Empowered Microstructure Codebook: New Paradigm for Multi-Parameter Tissue Characterization Estimation.
Journal: Human brain mapping
In common: DIPY, PyTorch, NumPy, structural MRI / diffusion, 7 references
[4] doi:10.1038/s41598-026-39162-7 [code]
White matter microstructure differences in obstructive sleep apnea severity groups assessed by diffusion tensor metrics and biophysical modeling.
Journal: Scientific reports
In common: DIPY, scikit-image, SciPy, 1 other tool, structural MRI / diffusion, 6 references
[5] doi:10.1038/s41598-026-51531-w [code]
Multimodal age-dependent diffusion-MRI analysis of the neocortex in a rat model of cortical dysplasia.
Journal: Scientific reports
In common: DIPY, scikit-image, SciPy, 2 other tools, structural MRI / diffusion, 5 references
[6] doi:10.1002/hbm.70553 [code]
Axon Diameter Mapping in the Living Human Brain with Ultra-High-Gradient Diffusion MRI at 500 mT/m Gradient Strength.
Journal: Human brain mapping
In common: NumPy, structural MRI / diffusion, 7 references
[7] doi:10.1371/journal.pone.0346132 [code]
Analysis of cortical dysplasias using b-tensor encoding diffusion MRI in an animal model.
Journal: PloS one
In common: DIPY, scikit-image, SciPy, 2 other tools, structural MRI / diffusion, 4 references
[8] doi:10.1162/imag.a.1341 [code]
Massively parallelized brain tractography using compute clusters, supercomputers, and graphics processing units.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: DIPY, SciPy, Matplotlib, 1 other tool, structural MRI / diffusion, 5 references
[9] doi:10.1002/mrm.70336 [code]
Offline Reconstruction of Diffusion MRI Acquisitions for Comparison Between Complex PCA-Based and AI-Based Denoising.
Journal: Magnetic resonance in medicine
In common: DIPY, SciPy, Matplotlib, 1 other tool, structural MRI / diffusion, 4 references
[10] doi:10.1002/mp.70599 [code]
Accurate estimation of intravoxel incoherent motion parameters based on implicit neural representation.
Journal: Medical physics
In common: PyTorch, SciPy, NumPy, structural MRI / diffusion, 5 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.

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: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.