OSCR

Neurovascular effects of tadalafil in patients with cerebral small vessel disease: ETLAS-2 substudy.

Code ↔ Paper

6 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 6 matches
  1. [1] § Materials and methods › MRI analysis › Dual-echo pCASL MRI ↔ dual_echo_pcasl_ETLAS2_scripts.py, lines 625–714 · score 0.79 · design matrix, hypercapnia response, visual stimulation, convolved, Gamma, cosine
  2. [2] § Materials and methods › MRI ↔ dp_pcasl_tools.py, lines 213–232 · score 0.68 · diffusion weighted, arterial transit, DP pCASL, attenuated, exchange
  3. [3] § Materials and methods › MRI analysis › BOLD fMRI ↔ dual_echo_pcasl_ETLAS2_scripts.py, lines 508–623 · score 0.67 · fMRI, design matrix, motion corrected, FWHM, HRF, smoothed
  4. [4] § Materials and methods › MRI analysis › Dual-echo pCASL MRI ↔ dual_echo_pcasl_ETLAS2_scripts.py, lines 438–475 · score 0.64 · partition coefficient, efficiency, relaxation, slice, delay, post
  5. [5] § Materials and methods › Dual-echo pCASL MRI ↔ dual_echo_pcasl_ETLAS2_scripts.py, lines 508–623 · score 0.60 · dual echo pCASL, Visual stimulation, CO2, repetition, matrix, duration
  6. [6] § Materials and methods › Statistical analysis ↔ dp_pcasl_tools.py, lines 30–74 · score 0.55 · GLM fitting, DP pCASL, Tools, pipelining

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 · 714 lines · 35 KB · CC-BY-4.0 · 4 matches

  1. """Dual-echo pCASL processing scripts for ETLAS2 dataset.
  3. This module contains core processing pipelines used in the ETLAS2 paper:
  4. Neurovascular effects of tadalafil in patients with
  5. cerebral small vessel disease: ETLAS-2 substudy
  7. - motion correction and template registration for dual-echo pCASL (echo 1 + echo 2)
  8. - CBF scaling image generation
  9. - first-level GLM fitting for calibrated fMRI with hypercapnia/visual stimuli
  11. The functions expect BIDS-like subject/session folder structure for input data.
  12. """
  14. import ants
  15. import pandas as pd
  16. import antspynet
  17. import numpy as np
  18. import json
  19. import os
  20. import nilearn.glm as glm
  21. import nibabel as nib
  22. from scipy.stats import gamma
  23. import shutil
  25. def motion_correction_to_template(subject, rawdata_folder, dual_echo_pcasl_folder, transformations_folder, template_fn):
  26. """Run rigid registration of pCASL/M0 to T1w and MNI template.
  28. This function performs motion correction on dual-echo pCASL data using control
  29. volumes, registers the corrected series to anatomical T1w and template space,
  30. and applies the full transform chain to both echo 1 and echo 2 volumes.
  31. Scaling images for CBF quantification are also computed and warped to template.
  32. Optionally processes follow-up session data with longitudinal T1 alignment.
  34. Parameters:
  35. - subject: subject label (e.g. sub-001)
  36. - rawdata_folder: base input folder with BIDS-like structure
  37. - dual_echo_pcasl_folder: output folder for processed pCASL images
  38. - transformations_folder: output folder for transform matrices
  39. - template_fn: full path to target template image (e.g. MNI)
  40. """
  43. # ------------------------------------------------------------------
  44. # Load input images from baseline session (T1w, pCASL echo1/echo2, M0 scans)
  45. # - T1 is anatomical reference
  46. # - pcasl_e1/e2 are perfusion series requiring motion correction
  47. # - m0_e1/e2 are baseline M0 acquisitions; averaged across time for scaling
  48. # ------------------------------------------------------------------
  49. t1 = ants.image_read(os.path.join(rawdata_folder, subject, 'ses-baseline', 'anat', f'{subject}_ses-baseline_T1w.nii.gz'))
  50. pcasl_e1 = ants.image_read(os.path.join(rawdata_folder, subject, 'ses-baseline', 'perf', f'{subject}_ses-baseline_echo-1_asl.nii.gz'))
  51. pcasl_e2 = ants.image_read(os.path.join(rawdata_folder, subject, 'ses-baseline', 'perf', f'{subject}_ses-baseline_echo-2_asl.nii.gz'))
  53. # M0 average across all M0 timepoints for each echo.
  54. m0_e1 = ants.get_average_of_timeseries(ants.image_read(os.path.join(rawdata_folder, subject, 'ses-baseline', 'perf', f'{subject}_ses-baseline_echo-1_m0scan.nii.gz')))
  55. m0_e2 = ants.get_average_of_timeseries(ants.image_read(os.path.join(rawdata_folder, subject, 'ses-baseline', 'perf', f'{subject}_ses-baseline_echo-2_m0scan.nii.gz')))
  57. template = ants.image_read(template_fn)
  59. # ------------------------------------------------------------------
  60. # Perform motion correction using control volumes only (avoid label-control contrast drift).
  61. # 1) select even frames (control) from echo1
  62. # 2) rigid motion correct to a midpoint reference
  63. # 3) get motion parameters (FD) for later QC/o output
  64. # ------------------------------------------------------------------
  65. pcasl_e1_con = ants.list_to_ndimage(pcasl_e1, ants.ndimage_to_list(pcasl_e1)[0::2])
  66. pcasl_e1_con_registration_init = ants.motion_correction(pcasl_e1_con, aff_metric='meansquares')
  67. pcasl_e1_con_registration = ants.motion_correction(
  68. pcasl_e1_con,
  69. fixed=ants.get_average_of_timeseries(pcasl_e1_con_registration_init['motion_corrected']),
  70. aff_metric='meansquares'
  71. )
  73. # Reference for subsequent registration is average motion-corrected control series.
  74. reference = ants.get_average_of_timeseries(pcasl_e1_con_registration['motion_corrected'])
  76. # Brain extraction for bias correction. This mask is used to avoid background influence.
  77. reference_mask = antspynet.utilities.brain_extraction(reference, modality='bold')
  78. ref_tmp = ants.image_clone(reference)
  79. ref_tmp[reference_mask < 0.1] = np.nan
  81. # N4 bias correction to reduce intensity non-uniformity before registration.
  82. reference_n4 = ants.n4_bias_field_correction(reference / np.nanmean(ref_tmp.numpy(), axis=(0,1)), mask=reference_mask > 0.1)
  84. # Register to anatomical T1 and M0 to reference
  85. pcasl_to_t1 = ants.registration(
  86. t1,
  87. reference_n4,
  88. type_of_transform='Rigid',
  89. aff_metric='mattes',
  90. initial_transform='Identity',
  91. aff_iterations=(200),
  92. aff_shrink_factors=(1),
  93. aff_smoothing_sigmas=(0)
  94. )
  95. pcasl_xfms = pcasl_e1_con_registration['motion_parameters']
  96. m0_to_pcasl = ants.registration(
  97. reference_n4,
  98. m0_e1,
  99. type_of_transform='Rigid',
  100. aff_metric='mattes',
  101. initial_transform='Identity',
  102. aff_iterations=(200),
  103. aff_shrink_factors=(1),
  104. aff_smoothing_sigmas=(0)
  105. )
  107. # Prepare a reference 4D image in template field-of-view for resampling.
  108. # We copy orientation from template while maintaining ASL time dimension shape.
  109. direction = pcasl_e1.direction.copy()
  110. direction[0:3,0:3] = template.direction
  111. reference_image = ants.from_numpy(
  112. np.zeros(template.shape + (pcasl_e1.shape[-1],)),
  113. origin=template.origin + (pcasl_e1.origin[-1],),
  114. spacing=template.spacing + (pcasl_e1.spacing[-1],),
  115. direction=direction
  116. )
  118. # The T1w-to-MNI transform is external (SAMSEG / preprocessing output).
  119. t1_to_template_xfm_fn = os.path.join(transformations_folder, subject, f'{subject}_ses-baseline_T1w-to-MNI.mat')
  121. # Apply chain of transforms to each pCASL timepoint:
  122. # 1) subject T1 -> template (inverse because we are moving data to template)
  123. # 2) pCASL->T1 from registration
  124. # 3) volume-level motion transform per volume (from motion correction)
  125. # This is done for both echos.
  126. pcasl_e1_mc = ants.list_to_ndimage(reference_image, [
  127. ants.apply_transforms(template,
  128. ants.ndimage_to_list(pcasl_e1)[i],
  129. [t1_to_template_xfm_fn, pcasl_to_t1['fwdtransforms'][0], pcasl_xfms[int(i/2)][0]],
  130. whichtoinvert=[True, False, False],
  131. interpolator='linear')
  132. for i in range(len(ants.ndimage_to_list(pcasl_e1)))
  133. ])
  134. pcasl_e2_mc = ants.list_to_ndimage(reference_image, [
  135. ants.apply_transforms(template,
  136. ants.ndimage_to_list(pcasl_e2)[i],
  137. [t1_to_template_xfm_fn, pcasl_to_t1['fwdtransforms'][0], pcasl_xfms[int(i/2)][0]],
  138. whichtoinvert=[True, False, False],
  139. interpolator='linear')
  140. for i in range(len(ants.ndimage_to_list(pcasl_e2)))])
  142. # Calculate ASL scaling from M0 (mgr to perfusion units).
  143. # This is needed later to convert posted ASL signal to quantitative CBF.
  144. scaling_e1 = calculate_cbf_scaling(m0_e1, os.path.join(rawdata_folder, subject, 'ses-baseline', 'perf', f'{subject}_ses-baseline_echo-1_asl.json'))
  145. scaling_e2 = calculate_cbf_scaling(m0_e2, os.path.join(rawdata_folder, subject, 'ses-baseline', 'perf', f'{subject}_ses-baseline_echo-1_asl.json'))
  147. # Warp M0 volumes into template space for consistent quantification.
  148. m0_e1_mc = ants.apply_transforms(
  149. template,
  150. m0_e1,
  151. [t1_to_template_xfm_fn, pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  152. whichtoinvert=[True, False, False],
  153. interpolator='linear'
  154. )
  155. m0_e2_mc = ants.apply_transforms(
  156. template,
  157. m0_e2,
  158. [t1_to_template_xfm_fn, pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  159. whichtoinvert=[True, False, False],
  160. interpolator='linear'
  161. )
  163. # Upsample/dilate mask areas to reduce edge artifacts in scaling division.
  164. # This is an ExploreASL-inspired heuristic with erode+dilate combination.
  165. m0_mask = antspynet.utilities.brain_extraction(m0_e2, modality='bold')
  166. m0_mask_eroded = ants.morphology(m0_mask, 'erode', 1, mtype='grayscale')
  167. m0_mask_dilated = ants.morphology(m0_mask, 'dilate', 1, mtype='grayscale')
  168. scaling_e1_dilated = (
  169. scaling_e1 * ants.smooth_image(m0_mask_eroded, 1)
  170. + ants.morphology(scaling_e1 * (m0_mask > 0.999), 'dilate', 1, mtype='grayscale')
  171. * ants.smooth_image(m0_mask_dilated - m0_mask_eroded, 1)
  172. )
  173. scaling_e2_dilated = (
  174. scaling_e2 * ants.smooth_image(m0_mask_eroded, 1)
  175. + ants.morphology(scaling_e2 * (m0_mask > 0.999), 'dilate', 1, mtype='grayscale')
  176. * ants.smooth_image(m0_mask_dilated - m0_mask_eroded, 1)
  177. )
  179. # Reproject dilated scaling images to template space.
  180. scaling_e1_mc = ants.apply_transforms(
  181. template,
  182. scaling_e1_dilated,
  183. [t1_to_template_xfm_fn, pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  184. whichtoinvert=[True, False, False],
  185. interpolator='linear'
  186. )
  187. scaling_e2_mc = ants.apply_transforms(
  188. template,
  189. scaling_e2_dilated,
  190. [t1_to_template_xfm_fn, pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  191. whichtoinvert=[True, False, False],
  192. interpolator='linear'
  193. )
  195. # Warp a brain mask to template space and binarize after interp.
  196. m0_mask_mc = (
  197. ants.apply_transforms(
  198. template,
  199. m0_mask,
  200. [t1_to_template_xfm_fn, pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  201. whichtoinvert=[True, False, False],
  202. interpolator='genericLabel'
  203. ) > 0.999
  204. )
  206. # Save transform files for later QC and reuse.
  207. # - asl-to-T1 uses pcasl_to_t1 full forward transform
  208. # - m0-to-asl uses m0_to_pcasl transform
  209. # - per-volume motion transforms are stored in asl_mc/
  210. os.makedirs(os.path.join(transformations_folder, subject), exist_ok=True)
  211. os.makedirs(os.path.join(transformations_folder, subject, 'asl_mc'), exist_ok=True)
  212. shutil.copyfile(pcasl_to_t1['fwdtransforms'][0], os.path.join(transformations_folder, subject, f'{subject}_ses-baseline_asl-to-T1w.mat'))
  213. shutil.copyfile(m0_to_pcasl['fwdtransforms'][0], os.path.join(transformations_folder, subject, f'{subject}_ses-baseline_m0scan-to-asl.mat'))
  215. for i, xfm in enumerate(pcasl_xfms):
  216. shutil.copyfile(xfm[0], os.path.join(transformations_folder, subject, 'asl_mc', f'{subject}_ses-baseline_asl-moco_{i:03}.mat'))
  218. # Ensure output directory exists and store final processed images.
  219. out_basename = os.path.join(dual_echo_pcasl_folder, subject, 'ses-baseline', f'{subject}_ses-baseline')
  220. os.makedirs(os.path.join(dual_echo_pcasl_folder, subject, 'ses-baseline'), exist_ok=True)
  222. scaling_e1.to_filename(out_basename + '_echo-1_scaling.nii.gz')
  223. scaling_e1_dilated.to_filename(out_basename + '_echo-1_scaling_dilated.nii.gz')
  224. scaling_e1_mc.to_filename(out_basename + '_rec-moco_echo-1_scaling.nii.gz')
  226. scaling_e2.to_filename(out_basename + '_echo-2_scaling.nii.gz')
  227. scaling_e2_dilated.to_filename(out_basename + '_echo-2_scaling_dilated.nii.gz')
  228. scaling_e2_mc.to_filename(out_basename + '_rec-moco_echo-2_scaling.nii.gz')
  230. # Save output volumes from baseline run
  231. pcasl_e1_mc.to_filename(out_basename + '_rec-moco_echo-1_asl.nii.gz')
  232. pcasl_e2_mc.to_filename(out_basename + '_rec-moco_echo-2_asl.nii.gz')
  234. m0_e1_mc.to_filename(out_basename + '_rec-moco_echo-1_m0scan.nii.gz')
  235. m0_e2_mc.to_filename(out_basename + '_rec-moco_echo-2_m0scan.nii.gz')
  236. m0_mask_mc.to_filename(out_basename + '_rec-moco_brainmask.nii.gz')
  238. # Save framewise displacement (repeated for label/control alternation) for QC.
  239. motion = np.zeros(len(pcasl_e1_con_registration['FD']) * 2)
  240. motion[0::2] = pcasl_e1_con_registration['FD']
  241. motion[1::2] = pcasl_e1_con_registration['FD']
  242. np.savetxt(out_basename + '_rec-moco_framewisedisplacement.txt', motion)
  244. # Optional follow-up session processing. If present, process follow-up data similarly to baseline.
  245. # Follow-up pipeline replicates motion correction + template registration chain,
  246. # then adds follow-up->baseline T1 alignment for longitudinal consistency.
  247. dual_session = os.path.exists(os.path.join(rawdata_folder, subject, 'ses-followup', 'perf'))
  248. if dual_session:
  249. # Load baseline and follow-up anatomical volumes.
  250. t1_baseline = ants.image_read(os.path.join(rawdata_folder, subject, 'ses-baseline', 'anat', f'{subject}_ses-baseline_T1w.nii.gz'))
  251. t1 = ants.image_read(os.path.join(rawdata_folder, subject, 'ses-followup', 'anat', f'{subject}_ses-followup_T1w.nii.gz'))
  253. # Load follow-up pCASL echo series and M0 scans.
  254. pcasl_e1 = ants.image_read(os.path.join(rawdata_folder, subject, 'ses-followup', 'perf', f'{subject}_ses-followup_echo-1_asl.nii.gz'))
  255. pcasl_e2 = ants.image_read(os.path.join(rawdata_folder, subject, 'ses-followup', 'perf', f'{subject}_ses-followup_echo-2_asl.nii.gz'))
  257. m0_e1 = ants.get_average_of_timeseries(ants.image_read(os.path.join(rawdata_folder, subject, 'ses-followup', 'perf', f'{subject}_ses-followup_echo-1_m0scan.nii.gz')))
  258. m0_e2 = ants.get_average_of_timeseries(ants.image_read(os.path.join(rawdata_folder, subject, 'ses-followup', 'perf', f'{subject}_ses-followup_echo-2_m0scan.nii.gz')))
  260. # Motion correction on follow-up echo1 control frames.
  261. pcasl_e1_con = ants.list_to_ndimage(pcasl_e1, ants.ndimage_to_list(pcasl_e1)[0::2])
  262. pcasl_e1_con_registration_init = ants.motion_correction(pcasl_e1_con, aff_metric='meansquares')
  263. pcasl_e1_con_registration = ants.motion_correction(
  264. pcasl_e1_con,
  265. fixed=ants.get_average_of_timeseries(pcasl_e1_con_registration_init['motion_corrected']),
  266. aff_metric='meansquares'
  267. )
  269. # Build follow-up reference image and bias correction mask.
  270. reference = ants.get_average_of_timeseries(pcasl_e1_con_registration['motion_corrected'])
  271. reference_mask = antspynet.utilities.brain_extraction(reference, modality='bold')
  272. ref_tmp = ants.image_clone(reference)
  273. ref_tmp[reference_mask < 0.1] = np.nan
  274. reference_n4 = ants.n4_bias_field_correction(reference / np.nanmean(ref_tmp.numpy(), axis=(0,1)), mask=reference_mask > 0.1)
  276. # Register follow-up reference to follow-up T1 and M0 to reference.
  277. pcasl_to_t1 = ants.registration(
  278. t1,
  279. reference_n4,
  280. type_of_transform='Rigid',
  281. aff_metric='mattes',
  282. initial_transform='Identity',
  283. aff_iterations=(200),
  284. aff_shrink_factors=(1),
  285. aff_smoothing_sigmas=(0)
  286. )
  287. pcasl_xfms = pcasl_e1_con_registration['motion_parameters']
  288. m0_to_pcasl = ants.registration(
  289. reference_n4,
  290. m0_e1,
  291. type_of_transform='Rigid',
  292. aff_metric='mattes',
  293. initial_transform='Identity',
  294. aff_iterations=(200),
  295. aff_shrink_factors=(1),
  296. aff_smoothing_sigmas=(0)
  297. )
  299. # Register follow-up T1 to baseline T1, enabling longitudinal transform chain.
  300. t1_followup_to_baseline = ants.registration(
  301. t1_baseline,
  302. t1,
  303. type_of_transform='Rigid',
  304. aff_metric='mattes',
  305. initial_transform='Identity',
  306. aff_iterations=(200),
  307. aff_shrink_factors=(1),
  308. aff_smoothing_sigmas=(0)
  309. )
  311. # Prepare workspace for follow-up pCASL resampling in template space.
  312. direction = pcasl_e1.direction.copy()
  313. direction[0:3,0:3] = template.direction
  314. reference_image = ants.from_numpy(
  315. np.zeros(template.shape + (pcasl_e1.shape[-1],)),
  316. origin=template.origin + (pcasl_e1.origin[-1],),
  317. spacing=template.spacing + (pcasl_e1.spacing[-1],),
  318. direction=direction
  319. )
  321. # Apply full transform chain to follow-up echo1 and echo2 volumes:
  322. # template <- (T1_baseline<-T1_followup <-- pcasl_t1 <-- pcasl_vol_moco).
  323. pcasl_e1_mc = ants.list_to_ndimage(reference_image, [
  324. ants.apply_transforms(
  325. template,
  326. ants.ndimage_to_list(pcasl_e1)[i],
  327. [t1_to_template_xfm_fn, t1_followup_to_baseline['fwdtransforms'][0], pcasl_to_t1['fwdtransforms'][0], pcasl_xfms[int(i/2)][0]],
  328. whichtoinvert=[True, False, False, False],
  329. interpolator='linear'
  330. )
  331. for i in range(len(ants.ndimage_to_list(pcasl_e1)))
  332. ])
  334. pcasl_e2_mc = ants.list_to_ndimage(reference_image, [
  335. ants.apply_transforms(
  336. template,
  337. ants.ndimage_to_list(pcasl_e2)[i],
  338. [t1_to_template_xfm_fn, t1_followup_to_baseline['fwdtransforms'][0], pcasl_to_t1['fwdtransforms'][0], pcasl_xfms[int(i/2)][0]],
  339. whichtoinvert=[True, False, False, False],
  340. interpolator='linear'
  341. )
  342. for i in range(len(ants.ndimage_to_list(pcasl_e2)))
  343. ])
  345. # Recompute scaling for follow-up M0 images and warp to template.
  346. scaling_e1 = calculate_cbf_scaling(m0_e1, os.path.join(rawdata_folder, subject, 'ses-followup', 'perf', f'{subject}_ses-followup_echo-1_asl.json'))
  347. scaling_e2 = calculate_cbf_scaling(m0_e2, os.path.join(rawdata_folder, subject, 'ses-followup', 'perf', f'{subject}_ses-followup_echo-1_asl.json'))
  349. m0_e1_mc = ants.apply_transforms(
  350. template,
  351. m0_e1,
  352. [t1_to_template_xfm_fn, t1_followup_to_baseline['fwdtransforms'][0], pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  353. interpolator='linear',
  354. whichtoinvert=[True, False, False, False]
  355. )
  356. m0_e2_mc = ants.apply_transforms(
  357. template,
  358. m0_e2,
  359. [t1_to_template_xfm_fn, t1_followup_to_baseline['fwdtransforms'][0], pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  360. interpolator='linear',
  361. whichtoinvert=[True, False, False, False]
  362. )
  364. # Dilate follow-up scale masks and intensity maps in the same manner as baseline.
  365. m0_mask = antspynet.utilities.brain_extraction(m0_e2, modality='bold')
  366. m0_mask_eroded = ants.morphology(m0_mask, 'erode', 1, mtype='grayscale')
  367. m0_mask_dilated = ants.morphology(m0_mask, 'dilate', 1, mtype='grayscale')
  369. scaling_e1_dilated = (
  370. scaling_e1 * ants.smooth_image(m0_mask_eroded, 1)
  371. + ants.morphology(scaling_e1 * (m0_mask > 0.999), 'dilate', 1, mtype='grayscale')
  372. * ants.smooth_image(m0_mask_dilated - m0_mask_eroded, 1)
  373. )
  374. scaling_e2_dilated = (
  375. scaling_e2 * ants.smooth_image(m0_mask_eroded, 1)
  376. + ants.morphology(scaling_e2 * (m0_mask > 0.999), 'dilate', 1, mtype='grayscale')
  377. * ants.smooth_image(m0_mask_dilated - m0_mask_eroded, 1)
  378. )
  380. scaling_e1_mc = ants.apply_transforms(
  381. template,
  382. scaling_e1_dilated,
  383. [t1_to_template_xfm_fn, t1_followup_to_baseline['fwdtransforms'][0], pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  384. whichtoinvert=[True, False, False, False],
  385. interpolator='linear'
  386. )
  387. scaling_e2_mc = ants.apply_transforms(
  388. template,
  389. scaling_e2_dilated,
  390. [t1_to_template_xfm_fn, t1_followup_to_baseline['fwdtransforms'][0], pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  391. whichtoinvert=[True, False, False, False],
  392. interpolator='linear'
  393. )
  395. m0_mask_mc = (
  396. ants.apply_transforms(
  397. template,
  398. m0_mask,
  399. [t1_to_template_xfm_fn, t1_followup_to_baseline['fwdtransforms'][0], pcasl_to_t1['fwdtransforms'][0], m0_to_pcasl['fwdtransforms'][0]],
  400. interpolator='genericLabel',
  401. whichtoinvert=[True, False, False, False]
  402. ) > 0.999
  403. )
  405. # Save follow-up transforms and output files (same patterns as baseline)
  406. os.makedirs(os.path.join(transformations_folder, subject), exist_ok=True)
  407. os.makedirs(os.path.join(transformations_folder, subject, 'asl_mc'), exist_ok=True)
  408. shutil.copyfile(t1_followup_to_baseline['fwdtransforms'][0], os.path.join(transformations_folder, subject, f'{subject}_followup-T1w-to-baseline-T1w.mat'))
  409. shutil.copyfile(pcasl_to_t1['fwdtransforms'][0], os.path.join(transformations_folder, subject, f'{subject}_ses-followup_asl-to-T1w.mat'))
  410. shutil.copyfile(m0_to_pcasl['fwdtransforms'][0], os.path.join(transformations_folder, subject, f'{subject}_ses-followup_m0scan-to-asl.mat'))
  412. for i, xfm in enumerate(pcasl_xfms):
  413. shutil.copyfile(xfm[0], os.path.join(transformations_folder, subject, 'asl_mc', f'{subject}_ses-followup_asl-moco_{i:03}.mat'))
  415. out_basename = os.path.join(dual_echo_pcasl_folder, subject, 'ses-followup', f'{subject}_ses-followup')
  416. os.makedirs(os.path.join(dual_echo_pcasl_folder, subject, 'ses-followup'), exist_ok=True)
  418. scaling_e1.to_filename(out_basename + '_echo-1_scaling.nii.gz')
  419. scaling_e1_dilated.to_filename(out_basename + '_echo-1_scaling_dilated.nii.gz')
  420. scaling_e1_mc.to_filename(out_basename + '_rec-moco_echo-1_scaling.nii.gz')
  422. scaling_e2.to_filename(out_basename + '_echo-2_scaling.nii.gz')
  423. scaling_e2_dilated.to_filename(out_basename + '_echo-2_scaling_dilated.nii.gz')
  424. scaling_e2_mc.to_filename(out_basename + '_rec-moco_echo-2_scaling.nii.gz')
  426. pcasl_e1_mc.to_filename(out_basename + '_rec-moco_echo-1_asl.nii.gz')
  427. pcasl_e2_mc.to_filename(out_basename + '_rec-moco_echo-2_asl.nii.gz')
  429. m0_e1_mc.to_filename(out_basename + '_rec-moco_echo-1_m0scan.nii.gz')
  430. m0_e2_mc.to_filename(out_basename + '_rec-moco_echo-2_m0scan.nii.gz')
  431. m0_mask_mc.to_filename(out_basename + '_rec-moco_brainmask.nii.gz')
  433. motion = np.zeros(len(pcasl_e1_con_registration['FD']) * 2)
  434. motion[0::2] = pcasl_e1_con_registration['FD']
  435. motion[1::2] = pcasl_e1_con_registration['FD']
  436. np.savetxt(out_basename + '_rec-moco_framewisedisplacement.txt', motion)
  438. def calculate_cbf_scaling(m0, sidecar_fn, blood_t1=1.65, lambda_full=0.9):
  439. """Compute voxel-wise pCASL scaling from M0 image and BIDS sidecar metadata.
  441. This function uses the general kinetic model from Alsop et al., MRM 2000
  442. (DOI: 10.1002/mrm.10559), applying a single-bolus correction and
  443. optional slice-timing support.
  445. Parameters:
  446. - m0: M0 image (anatomical reference)
  447. - sidecar_fn: path to BIDS JSON sidecar with pCASL acquisition parameters
  448. - blood_t1: T1 relaxation time of blood (seconds)
  449. - lambda_full: brain-blood partition coefficient
  451. Returns:
  452. - scaling: voxel-wise scaling image in units ml/100g/min (same geometry as m0 input)
  453. """
  455. sidecar = json.load(open(sidecar_fn))
  457. # Extract pCASL parameters from sidecar metadata.
  458. inversion_eff = sidecar.get('LabelingEfficiency', 0.95)
  459. bolus_duration = sidecar.get('LabelingDuration', 1.65)
  460. postlabeling_delay = sidecar.get('PostLabelingDelay', 2.0)
  461. slice_time = sidecar.get('SliceTiming', np.zeros(m0.shape[2]))
  463. # Convert slice timing to seconds if needed and add post-labeling delay.
  464. slice_time = np.array(slice_time, dtype=float)
  465. if slice_time.max() > 4:
  466. slice_time *= 0.001
  467. slice_time += postlabeling_delay
  469. # Apply kinetic model (Eq. 1 in Alsop et al., MRM 2000) to compute scaling.
  470. # Output is in ml/100g/min.
  471. scaling = m0 * 2.0 * inversion_eff * blood_t1 * (1.0 / lambda_full) * (
  472. np.exp(-slice_time / blood_t1) - np.exp(-(bolus_duration + slice_time) / blood_t1)
  473. ) / 6000.0
  475. return scaling
  477. def hypercapnia_response_function(tr, oversampling=16, onset=0.0, time_length=240):
  478. """Generate a canonical hypercapnia response function using a gamma distribution.
  480. Parameters:
  481. - tr: repetition time (seconds)
  482. - oversampling: factor for temporal upsampling of the response function
  483. - onset: delay before response begins (seconds)
  484. - time_length: total duration of response function (seconds)
  486. Returns:
  487. - response_function: normalized gamma PDF used as HRF for hypercapnia regressors
  488. """
  489. # Calculate temporal resolution after oversampling
  490. dt = tr / oversampling
  492. # Create time vector with oversampled resolution, then shift by onset delay
  493. time_stamps = np.linspace(0, time_length, np.rint(time_length / dt).astype(int))
  494. time_stamps -= onset
  496. # Gamma function parameters estimated from hypercapnia data
  497. # delay: shape parameter (governs rise time)
  498. # dispersion: scale parameter (governs width/duration of response)
  499. delay = 1.55
  500. dispersion = 33
  502. # Compute gamma probability density function and normalize to sum to 1
  503. response_function = gamma.pdf(time_stamps, delay, scale=dispersion, loc=0)
  504. response_function /= response_function.sum()
  506. return response_function
  508. def fit_calibrated_fmri_glm(subject, session, rawdata_folder, dual_echo_pcasl_folder):
  509. """Fit calibrated fMRI GLM for one subject/session using echo 1/2 outputs.
  511. This function uses pre-processed, motion-corrected pCASL images and session
  512. event timings to estimate task- and hypercapnia-related responses.
  513. """
  515. # ------------------------------------------------------------------
  516. # File I/O and initial metadata loading
  517. # ------------------------------------------------------------------
  518. output_folder = os.path.join(dual_echo_pcasl_folder, subject, session, 'glm_results')
  519. os.makedirs(output_folder, exist_ok=True)
  520. sidecar = json.load(open(os.path.join(rawdata_folder, subject, session, 'perf', f'{subject}_{session}_echo-1_asl.json')))
  521. pcasl_e1 = nib.load(os.path.join(dual_echo_pcasl_folder, subject, session, f'{subject}_{session}_rec-moco_echo-1_asl.nii.gz'))
  522. pcasl_e2 = nib.load(os.path.join(dual_echo_pcasl_folder, subject, session, f'{subject}_{session}_rec-moco_echo-2_asl.nii.gz'))
  523. events = pd.read_table(os.path.join(rawdata_folder, subject, session, 'perf', f'{subject}_{session}_echo-1_events.tsv'))
  524. context = pd.read_csv(os.path.join(rawdata_folder, subject, session, 'perf', f'{subject}_{session}_echo-1_aslcontext.tsv'), sep='\t')
  525. motion = np.loadtxt(os.path.join(dual_echo_pcasl_folder, subject, session, f'{subject}_{session}_rec-moco_framewisedisplacement.txt'))
  527. # ------------------------------------------------------------------
  528. # Ensure t_r is in seconds and construct frame times for design matrix.
  529. # ------------------------------------------------------------------
  530. t_r = sidecar['RepetitionTime']
  531. if t_r > 1000:
  532. t_r /= 1000.0
  534. n_frames = sidecar['TotalAcquiredPairs'] * 2
  535. frame_times = np.arange(n_frames) * t_r
  537. # ------------------------------------------------------------------
  538. # Construct first-level GLM design matrix for main task and hypercapnia.
  539. # ------------------------------------------------------------------
  540. X1 = glm.first_level.make_first_level_design_matrix(
  541. frame_times,
  542. events=events[events['trial_type'] != 'Hypercapnia, 5% CO2'],
  543. drift_model='cosine',
  544. high_pass=0.001,
  545. add_regs=pd.DataFrame(motion, columns=['FD']),
  546. hrf_model='glover'
  547. )
  549. # In pCASL, label/control toggles; encode as +1 / -1 for ASL difference.
  550. X1['ASL'] = np.array((context == 'label') * -1)
  552. # Hypercapnia event regressor, using a custom response function.
  553. onset = events[events['trial_type'] == 'Hypercapnia, 5% CO2']['onset'].values
  554. duration = events[events['trial_type'] == 'Hypercapnia, 5% CO2']['duration'].values
  555. amplitude = np.ones_like(onset)
  556. exp_condition = np.vstack((onset, duration, amplitude))
  558. # Custom hypercapnia response function estimated from the patient group data.
  559. HC_reg = glm.first_level.compute_regressor(
  560. exp_condition,
  561. hypercapnia_response_function,
  562. frame_times
  563. )
  565. X1['Hypercapnia'] = HC_reg[0]
  567. # pCASL contrast terms for interactions with label/control pattern.
  568. X1['ASL Hypercapnia'] = X1['Hypercapnia'] * X1['ASL']
  569. X1['ASL visual stimulation'] = X1['visual stimulation'] * X1['ASL']
  570. X1['ASL visual stimulation, hypercapnia'] = X1['visual stimulation, hypercapnia'] * X1['ASL']
  572. X1.to_csv(os.path.join(output_folder, f'design_matrix.csv'))
  574. # Set up GLM
  575. pcasl_glm = glm.first_level.FirstLevelModel(
  576. noise_model='ar1',
  577. standardize=False,
  578. minimize_memory=False,
  579. signal_scaling=False,
  580. mask_img=False,
  581. n_jobs=-1,
  582. smoothing_fwhm=None
  583. )
  585. # Fit GLM to echo-1 data
  586. glm_e1_results = pcasl_glm.fit(pcasl_e1, design_matrices=X1)
  588. # Compute and write all contrasts, echo-1
  589. for contrast in glm_e1_results.design_matrices_[0].keys():
  590. results = glm_e1_results.compute_contrast(contrast, output_type='all')
  591. for k in results.keys():
  592. results[k].to_filename(os.path.join(output_folder, f'glm_e1_{contrast.replace(" ", "_").replace(",", "")}_{k}.nii.gz'))
  594. # Read nuisance regressors, echo-1
  595. drift1_e1 = ants.image_read(os.path.join(output_folder, "glm_e1_drift_1_effect_size.nii.gz"))
  596. drift2_e1 = ants.image_read(os.path.join(output_folder, "glm_e1_drift_2_effect_size.nii.gz"))
  597. FD_e1 = ants.image_read(os.path.join(output_folder, "glm_e1_FD_effect_size.nii.gz"))
  599. # Regress out nuisances, echo-1
  600. pcasl_e1_nn = ants.image_read(os.path.join(dual_echo_pcasl_folder, subject, session, f'{subject}_{session}_rec-moco_echo-1_asl.nii.gz'))
  601. for i in range(pcasl_e1.shape[-1]):
  602. pcasl_e1_nn[:, :, :, i] = pcasl_e1_nn[:,:,:,i] - (drift1_e1 * X1['drift_1'].array[i] + drift2_e1 * X1['drift_2'].array[i] + FD_e1 * X1['FD'].array[i]).numpy()
  603. pcasl_e1_nn.to_filename(os.path.join(output_folder, f'pcasl_e1_nuisance-regressed.nii.gz'))
  605. # Fit GLM to echo-2 data
  606. glm_e2_results = pcasl_glm.fit(pcasl_e2, design_matrices=X1)
  608. # Compute and write all contrasts, echo-2
  609. for contrast in glm_e2_results.design_matrices_[0].keys():
  610. results = glm_e2_results.compute_contrast(contrast, output_type='all')
  611. for k in results.keys():
  612. results[k].to_filename(os.path.join(output_folder, f'glm_e2_{contrast.replace(" ", "_").replace(",", "")}_{k}.nii.gz'))
  614. # Read nuisance regressors, echo-2
  615. drift1_e2 = ants.image_read(os.path.join(output_folder, "glm_e2_drift_1_effect_size.nii.gz"))
  616. drift2_e2 = ants.image_read(os.path.join(output_folder, "glm_e2_drift_2_effect_size.nii.gz"))
  617. FD_e2 = ants.image_read(os.path.join(output_folder, "glm_e2_FD_effect_size.nii.gz"))
  619. # Regress out nuisances, echo-2
  620. pcasl_e2_nn = ants.image_read(os.path.join(dual_echo_pcasl_folder, subject, session, f'{subject}_{session}_rec-moco_echo-2_asl.nii.gz'))
  621. for i in range(pcasl_e1.shape[-1]):
  622. pcasl_e2_nn[:, :, :, i] = pcasl_e2_nn[:, :, :, i] - (drift1_e2 * X1['drift_1'].array[i] + drift2_e2 * X1['drift_2'].array[i] + FD_e2 * X1['FD'].array[i]).numpy()
  623. pcasl_e2_nn.to_filename(os.path.join(output_folder, f'pcasl_e2_nuisance-regressed.nii.gz'))
  625. def get_design(framewise_displacement):
  626. """Construct an experimental design matrix for the dual-echo experiment.
  628. This design is tied to the original scan protocol (640 time points, 4.5s TR,
  629. specific hypercapnia and visual stimulation onsets). pCASL alternates label
  630. and control volumes along the time axis, so we create regressors with doubled
  631. time dimension (640) from underlying event definitions (320 points) and
  632. distributed on every second frame.
  633. """
  635. # Apply framewise displacement from motion correction to both repeated echoes.
  636. # Input framewise_displacement is length 320, output vector length 640: one FD
  637. # entry for each echo volume (even and odd indexes).
  638. fd = np.zeros(640)
  639. fd[0::2] = framewise_displacement
  640. fd[1::2] = framewise_displacement
  642. design = glm.first_level.make_first_level_design_matrix(
  643. np.arange(640) * 2.25, # correct TR value for data series
  644. drift_model='cosine',
  645. high_pass=0.001,
  646. add_regs=pd.DataFrame(fd, columns=['framewise_displacement'])
  647. ).drop('constant', axis=1)
  649. # Define event timing at the 320-sample (non-echo duplicated) level.
  650. time_stamps = np.arange(320) * 4.5
  652. # Hypercapnia stimulus blocks: 64 ON / 64 OFF / 64 ON ...
  653. hc_stim = np.array([0]*64 + [1]*64 + [0]*64 + [1]*64 + [0]*64)
  655. # Visual task blocks: 32s OFF, 8s ON, repeated 5 times.
  656. vis_stim = np.array(([0]*32 + [1]*8 + [0]*8 + [1]*8 + [0]*8) * 5)
  658. # Data-driven kernels for ASL/BOLD responses, based on earlier model estimates.
  659. vis_hrf_asl = [0, 0.7210, 0.2563, 0.0216, 0.0010]
  660. vis_hrf_bold = [0, 0.8545, 0.2876, -0.0532, -0.0643, -0.0206, -0.0035, -0.0004]
  662. # Use a gamma function for the hypercapnia response (same model as hypercapnia_response_function)
  663. hc_hrf = gamma.pdf(time_stamps, 1.55, scale=33, loc=0)
  664. hc_hrf /= hc_hrf.sum()
  666. # Convolve condition time-series with HRF and split into echo 1/echo 2 (
  667. # control-label alternation) rows.
  668. hc_resp = np.zeros(640)
  669. hc_resp[0::2] = np.convolve(hc_stim, hc_hrf)[0:320]
  670. hc_resp[1::2] = np.convolve(hc_stim, hc_hrf)[0:320]
  672. vis_resp_nc_asl = np.zeros(640)
  673. vis_resp_nc_asl[0::2] = np.convolve(vis_stim * (1 - hc_stim), vis_hrf_asl)[0:320]
  674. vis_resp_nc_asl[1::2] = np.convolve(vis_stim * (1 - hc_stim), vis_hrf_asl)[0:320]
  676. vis_resp_hc_asl = np.zeros(640)
  677. vis_resp_hc_asl[0::2] = np.convolve(vis_stim * hc_stim, vis_hrf_asl)[0:320]
  678. vis_resp_hc_asl[1::2] = np.convolve(vis_stim * hc_stim, vis_hrf_asl)[0:320]
  680. vis_resp_nc_bold = np.zeros(640)
  681. vis_resp_nc_bold[0::2] = np.convolve(vis_stim * (1 - hc_stim), vis_hrf_bold)[0:320]
  682. vis_resp_nc_bold[1::2] = np.convolve(vis_stim * (1 - hc_stim), vis_hrf_bold)[0:320]
  684. vis_resp_hc_bold = np.zeros(640)
  685. vis_resp_hc_bold[0::2] = np.convolve(vis_stim * hc_stim, vis_hrf_bold)[0:320]
  686. vis_resp_hc_bold[1::2] = np.convolve(vis_stim * hc_stim, vis_hrf_bold)[0:320]
  688. # Multiplicative label/control regressors for echo-specific contrast (ASL-style).
  689. c_e1 = [1, 0, 1, 0] * 160
  690. c_e2 = [0, 1, 0, 1] * 160
  691. l_e1 = [0, 0, -1, 0] * 160
  692. l_e2 = [0, 0, 0, -1] * 160
  694. design['01_constant_e1'] = c_e1
  695. design['02_constant_e2'] = c_e2
  696. design['03_label_e1'] = l_e1
  697. design['04_label_e2'] = l_e2
  699. design['05_hypercapnia_constant_e1'] = hc_resp * c_e1
  700. design['06_hypercapnia_constant_e2'] = hc_resp * c_e2
  701. design['07_hypercapnia_label_e1'] = hc_resp * l_e1
  702. design['08_hypercapnia_label_e2'] = hc_resp * l_e2
  704. design['09_visualresponse_constant_e1'] = vis_resp_nc_bold * c_e1
  705. design['10_visualresponse_constant_e2'] = vis_resp_nc_bold * c_e2
  706. design['11_visualresponse_label_e1'] = vis_resp_nc_asl * l_e1
  707. design['12_visualresponse_label_e2'] = vis_resp_nc_asl * l_e2
  709. design['13_visualresponse_hypercapnia_constant_e1'] = vis_resp_hc_bold * c_e1
  710. design['14_visualresponse_hypercapnia_constant_e2'] = vis_resp_hc_bold * c_e2
  711. design['15_visualresponse_hypercapnia_label_e1'] = vis_resp_hc_asl * l_e1
  712. design['16_visualresponse_hypercapnia_label_e2'] = vis_resp_hc_asl * l_e2
  714. return design

dual_echo_pcasl_ETLAS2_scripts.py, under CC-BY-4.0 · at the source

Overview

Authors: Joakim Ölmestig1,2,3, Kristian N Mortensen2, Birgitte Fagerlund4,5, Nadia Naveed6, Mette M Nordling6, Hanne Christensen3,7, Helle K Iversen3,8, Mai B Poulsen9, Hartwig R Siebner2,3,7, Christina Kruuse1,3,10
ORCID iDs: Hanne Christensen, Helle K Iversen, Christina Kruuse
  1. Neurovascular Research Unit, Department of Neurology, Copenhagen University Hospital—Herlev and Gentofte, Herlev 2730, Denmark
  2. Danish Research Centre for Magnetic Resonance, Department of Radiology and Nuclear Medicine, Copenhagen University Hospital—Amager and Hvidovre, Hvidovre 2650, Denmark
  3. Department of Clinical Medicine, University of Copenhagen, Copenhagen 2200, Denmark
  4. Child and Adolescent Mental Health Center, Copenhagen University Hospital, Mental Health Services CPH, Hellerup 2900, Denmark
  5. Department of Psychology, University of Copenhagen, Copenhagen 1353, Denmark
  6. Department of Radiology, Copenhagen University Hospital—Herlev and Gentofte, Herlev 2730, Denmark
  7. Department of Neurology, Copenhagen University Hospital—Bispebjerg and Frederiksberg, Copenhagen 2400, Denmark
  8. Department of Neurology, Copenhagen University Hospital—Rigshospitalet, Glostrup 2600, Denmark
  9. Department of Neurology, Copenhagen University Hospital—North Zealand, Hillerød 3400, Denmark
  10. Department of Brain and Spinal Cord Injury, Neuroscience Centre, Copenhagen University Hospital—Rigshospitalet, Glostrup 2600, Denmark
Institutions: University of Copenhagen (Denmark); Amager Hospital (Denmark); Herlev Hospital (Denmark); Copenhagen University Hospital (Denmark); Gentofte Hospital (Denmark); Mental Health Services (Denmark); Bispebjerg Hospital (Denmark); Rigshospitalet (Denmark)
Journal: Brain communications, volume 8, issue 4, article fcag309
Dates: received 3 December 2025; accepted 22 July 2026; published online 13 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1093/braincomms/fcag309 · PMID 42643719 · PMCID PMC13504703 · OpenAlex W7202401237
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), fMRI (modality), human (organism), stroke (population), clinical / translational (subfield)
Methods: Statistics, fMRI & imaging
Keywords: cerebral blood flow, cerebrovascular reactivity, neurovascular coupling, pCASL, fMRI
Journal subjects: Clinical Trial
Topic: Acute Ischemic Stroke Management (Epidemiology, Medicine), according to OpenAlex
Funding: Novo Nordisk Foundation—Investigator Initiated Clinical Trials (NNF20OC0063912); Foundation for Research in Neurology; Frimodt-Heineke Foundation; Herlev and Gentofte Hospitals Research Fund
Citations: not cited yet (Europe PMC); 26 references in the paper

Abstract

Cerebral small vessel disease is a major contributor to stroke and cognitive impairment, often associated with reduced cerebral blood flow and cerebrovascular reactivity. In this study, we used MRI to investigate if daily treatment with the phosphodiesterase-5 inhibitor tadalafil over 3 months improved cerebral blood flow and cerebrovascular reactivity in patients with cerebral small vessel disease.

Using a randomized, placebo-controlled, parallel-group design, this MRI sub-study was prospectively performed as part of the Effect of Tadalafil in Lacunar Stroke 2 trial, which included a total of 76 participants, of whom 60 were included in the per-protocol analysis. Patients with cerebral small vessel disease and prior stroke or transient ischaemic attack received either tadalafil (20 mg/day) or placebo for 3 months and completed the study. Neurovascular outcomes were assessed at baseline and at the 3-month follow-up using dual-echo pseudo-continuous arterial spin labelling MRI to evaluate reactivity to hypercapnia and visual stimulation. Endpoints included changes in whole-brain baseline cerebral blood flow and cerebrovascular reactivity, visual stimulation response, and neurovascular coupling index. In addition, we investigated arterial transit time measured using diffusion-prepared pseudo-continuous arterial spin labelling and changes in event-related sensory blood-oxygen-level-dependent responses in the primary somatosensory cortex (S1) after stimulation of the index finger.

In total, 60 participants (median age: 66.5, 14 females) were included in this per-protocol sub-study analysis (28 on tadalafil and 32 on placebo). Forty-two pseudo-continuous arterial spin labelling datasets (20 on tadalafil and 22 on placebo), 53 blood-oxygen-level-dependent functional MRI datasets (26 on tadalafil and 27 on placebo), and 45 arterial transit time datasets (22 on tadalafil and 23 on placebo) were of sufficient quality to be included in the analysis. Baseline whole-brain cerebral blood flow was 25.4 ± 5.1 ml/100 g/min. Compared to placebo, tadalafil significantly increased whole-brain cerebral blood flow with a mean group difference of 3.33 ± 0.97 ml/100 g/min at follow-up (P = 0.001). None of the other MRI-based outcome metrics differed between groups.

Three months of tadalafil treatment significantly enhanced whole-brain cerebral blood flow in patients with cerebral small vessel disease without altering cerebrovascular reactivity, neurovascular coupling, arterial transit time, and event-related blood-oxygen-level-dependent responses. The clinical significance of a tadalafil-induced increase in cerebral blood flow remains to be determined in prospective studies covering longer treatment periods.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 6 matches between paragraphs and lines of code.

Zenodo 19233779

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Languages: Python (4), MATLAB (1)
Size: 7 files, 5 scripts
Software Heritage: not checked
Found in: “Data availability”
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: ANTs (2 files), Nilearn (2 files), NumPy (2 files), pandas (2 files), SciPy (2 files), Image Processing Toolbox (1 file), Statistics and Machine Learning Toolbox (1 file), NiBabel (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
6 files
At the source: doi.org/10.5281/zenodo.19233779

The paper's code and data availability statement is in the Data section.

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 5 scripts, each with its path and the digest of its content;
  • 6 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.

Data availability

The data that support the findings of this study are available from the corresponding author upon reasonable request. Python and MATLAB scripts used for MRI processing and data collection are available at: https://doi.org/10.5281/zenodo.19233779.

Reproduced under the paper's license (CC BY), from the paper cited above.

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, 10 authors, 5 keywords, 4 funders, 26 references.

Cite

This paper

Ölmestig, J., Mortensen, K. N., Fagerlund, B., Naveed, N., Nordling, M. M., Christensen, H., Iversen, H. K., Poulsen, M. B., Siebner, H. R., & Kruuse, C. (2026). Neurovascular effects of tadalafil in patients with cerebral small vessel disease: ETLAS-2 substudy. Brain communications, 8(4), fcag309. https://doi.org/10.1093/braincomms/fcag309

BibTeX

@article{olmestig2026neurovascular,
author = {Ölmestig, Joakim and Mortensen, Kristian N and Fagerlund, Birgitte and Naveed, Nadia and Nordling, Mette M and Christensen, Hanne and Iversen, Helle K and Poulsen, Mai B and Siebner, Hartwig R and Kruuse, Christina},
title = {{Neurovascular effects of tadalafil in patients with cerebral small vessel disease: ETLAS-2 substudy}},
journal = {Brain communications},
year = {2026},
month = aug,
volume = {8},
number = {4},
pages = {fcag309},
publisher = {Oxford University Press},
issn = {2632-1297},
doi = {10.1093/braincomms/fcag309},
url = {https://doi.org/10.1093/braincomms/fcag309},
pmid = {42643719},
pmcid = {PMC13504703}
}

RIS

TY - JOUR
AU - Ölmestig, Joakim
AU - Mortensen, Kristian N
AU - Fagerlund, Birgitte
AU - Naveed, Nadia
AU - Nordling, Mette M
AU - Christensen, Hanne
AU - Iversen, Helle K
AU - Poulsen, Mai B
AU - Siebner, Hartwig R
AU - Kruuse, Christina
TI - Neurovascular effects of tadalafil in patients with cerebral small vessel disease: ETLAS-2 substudy
T2 - Brain communications
J2 - Brain Commun
PY - 2026
DA - 2026/08/13
VL - 8
IS - 4
SP - fcag309
SN - 2632-1297
PB - Oxford University Press
DO - 10.1093/braincomms/fcag309
UR - https://doi.org/10.1093/braincomms/fcag309
LA - en
ER -

CSL-JSON

{
"id": "10.1093/braincomms/fcag309",
"type": "article-journal",
"title": "Neurovascular effects of tadalafil in patients with cerebral small vessel disease: ETLAS-2 substudy",
"container-title": "Brain communications",
"author": [
{
"family": "Ölmestig",
"given": "Joakim"
},
{
"family": "Mortensen",
"given": "Kristian N"
},
{
"family": "Fagerlund",
"given": "Birgitte"
},
{
"family": "Naveed",
"given": "Nadia"
},
{
"family": "Nordling",
"given": "Mette M"
},
{
"family": "Christensen",
"given": "Hanne"
},
{
"family": "Iversen",
"given": "Helle K"
},
{
"family": "Poulsen",
"given": "Mai B"
},
{
"family": "Siebner",
"given": "Hartwig R"
},
{
"family": "Kruuse",
"given": "Christina"
}
],
"container-title-short": "Brain Commun",
"volume": "8",
"issue": "4",
"page": "fcag309",
"DOI": "10.1093/braincomms/fcag309",
"PMID": "42643719",
"PMCID": "PMC13504703",
"ISSN": "2632-1297",
"publisher": "Oxford University Press",
"URL": "https://doi.org/10.1093/braincomms/fcag309",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
13
]
]
}
}

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.1371/journal.pbio.3003856 [code]
Aging and metabolism contribute separately to brain-body health.
Journal: PLoS biology
In common: ANTs, Nilearn, Image Processing Toolbox, 6 other tools, structural MRI / diffusion, clinical / translational
[2] doi:10.1038/s41467-026-73668-y [code]
Convergent and divergent brain-cognition development in early adolescence.
Journal: Nature communications
In common: ANTs, Nilearn, Image Processing Toolbox, 6 other tools, fMRI
[3] doi:10.1016/j.xcrm.2026.102943 [code]
Parent-of-origin effects in Alzheimer's liability dissociate neurocognitive and cardiovascular traits in at-risk individuals.
Journal: Cell reports. Medicine
In common: ANTs, Nilearn, Image Processing Toolbox, 6 other tools, clinical / translational
[4] doi:10.1038/s41586-026-10631-3 [code]
A prognostic human brain network for diffuse midline glioma.
Journal: Nature
In common: ANTs, Nilearn, Image Processing Toolbox, 6 other tools, clinical / translational
[5] doi:10.1038/s41467-026-76452-0 [code]
Music evokes shared neural representations of imagined narratives across sensory modalities.
Journal: Nature communications
In common: ANTs, Nilearn, Image Processing Toolbox, 6 other tools
[6] doi:10.1038/s41467-026-71568-9 [code]
Convergent and selective representations of pain, appetitive processes, aversive processes, and cognitive control in the insula.
Journal: Nature communications
In common: ANTs, Nilearn, Image Processing Toolbox, 6 other tools
[7] doi:10.1038/s41398-026-04025-2 [code]
Brain energetic landscapes shape state dysregulation in major depressive disorder: a morphological network controllability perspective.
Journal: Translational psychiatry
In common: ANTs, Nilearn, Image Processing Toolbox, 6 other tools
[8] doi:10.1038/s41467-026-71151-2 [code]
Common and distinct neural correlates of social interaction processing and theory of mind in narratives.
Journal: Nature communications
In common: ANTs, Nilearn, Image Processing Toolbox, 6 other tools
[9] doi:10.1002/epi.70296 [code]
Fully automated three-dimensional deep learning-based magnetic resonance imaging segmentation of brain cavities in epilepsy surgery.
Journal: Epilepsia
In common: ANTs, Nilearn, Image Processing Toolbox, 5 other tools, structural MRI / diffusion, clinical / translational
[10] doi:10.1038/s41467-026-76812-w [code]
Assessing molecular, cellular and transcriptomic bases of laminar perfusion and cytoarchitecture coupling in the human cortex.
Journal: Nature communications
In common: ANTs, Nilearn, NiBabel, 5 other tools, stroke, structural MRI / diffusion

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.