OSCR

Memory and Resting-State Connectivity in Acute Transient Global Amnesia: A Case-Control fMRI Study.

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] § Materials and Methods › Statistical Analysis ↔ analysis/functions.py, lines 129–219 · score 0.76 · Aligned Rank Transform, Post hoc, Shapiro, ART, ANOVA, scores
  2. [2] § Results › Functional MRI ↔ analysis/ICA.ipynb, lines 50–65 · score 0.73 · dorsal DMN, ventral DMN, right SN, voxel, ECN, ICA
  3. [3] § Materials and Methods › Neuropsychological Battery ↔ analysis/main_analysis.ipynb, lines 81–200 · score 0.58 · cued recall, free recall, anterograde memory, incidental, clap, Mnemosyne
  4. [4] § Materials and Methods › Statistical Analysis ↔ analysis/functions.py, lines 129–219 · score 0.58 · post hoc, Linear, predictors, variables, fitted, Model
  5. [5] § Results › Neuropsychological Results ↔ analysis/main_analysis.ipynb, lines 81–200 · score 0.54 · cued recall, free recall, Anterograde memory, incidental, AES, scores

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 · 785 lines · 34 KB · no license · 2 matches

  1. import numpy as np
  2. import math
  3. from scipy import stats
  4. import scipy
  5. import scipy.io
  6. from scipy import stats
  7. import scipy.cluster.hierarchy as sch
  8. import statsmodels.stats.api as sms
  9. import statsmodels.formula.api as smf
  10. from statsmodels.stats.anova import AnovaRM
  11. import pingouin as pg
  12. from scipy.stats import shapiro, levene, rankdata
  13. import pandas as pd
  14. import matplotlib.pyplot as plt
  15. import seaborn as sns
  16. import plotly.figure_factory as ff
  17. import os
  18. import warnings
  20. toyDict = {}
  23. # To change backslashes : follow path by .replace(os.sep, '/')
  25. cwd = os.getcwd()
  27. fMRI_dataroot = cwd + '/../data/fMRI_data'
  28. neuropsy_dataroot = cwd + '/../data/neuropsy_data/Comportement/Bases de données/'
  29. IRMs_datapath = cwd + '/../data/sMRI/ANALYSE-ICTUS-5AOUT-15_editedElias.ods'
  31. #plots_path = cwd + '/../results/plots/'
  32. plots_path = cwd + '/../plots/'
  34. #plots_path = 'C:/Users/Lenovo/Desktop/Ictus/analysis/fMRI_neuropsy_analysis/../results/plots/'
  36. def gather(param, pT1 = 'pT1', pT2 = 'pT2', pT3 = 'pT3', cT1 = 'cT1', cT2 = 'cT2', cT3 = 'cT3', trans = toyDict, df = pd.DataFrame()):
  38. translated = trans.loc[param]
  39. if translated[pT1] == 'NaN' : pT1values = [np.nan]*20
  40. else : pT1values = df[pT1][translated[pT1]]
  42. if translated[pT2] == 'NaN' : pT2values = [np.nan]*20
  43. else : pT2values = df[pT2][translated[pT2]]
  45. if translated[pT3] == 'NaN' : pT3values = [np.nan]*20
  46. else : pT3values = df[pT3][translated[pT3]]
  48. if translated[cT1] == 'NaN' : cT1values = [np.nan]*20
  49. else : cT1values = df[cT1][translated[cT1]]
  51. if translated[cT2] == 'NaN' : cT2values = [np.nan]*20
  52. else : cT2values = df[cT2][translated[cT2]]
  54. if translated[cT3] == 'NaN' : cT3values = [np.nan]*20
  55. else : cT3values = df[cT3][translated[cT3]]
  57. return [pT1values, pT2values, pT3values, cT1values, cT2values, cT3values]
  60. ## STATISTICAL ANALYSIS ##
  61. ##########################
  63. def confint(data, confidence=0.95):
  64. a = 1.0 * np.array(data)
  65. n = len(a)
  66. m, se = np.mean(a), scipy.stats.sem(a)
  67. h = se * scipy.stats.t.ppf((1 + confidence) / 2., n-1)
  68. return m, m-h, m+h
  71. def aligned_rank_transform(df, subject_col, dv, within, between):
  72. """
  73. Perform the Aligned Rank Transform on the data.
  75. Parameters:
  76. df : DataFrame
  77. Data containing the variables.
  78. subject_col : str
  79. The column name representing subjects.
  80. dv : str
  81. The dependent variable column name.
  82. within : str
  83. The within-subject factor column name.
  84. between : str
  85. The between-subject factor column name.
  87. Returns:
  88. DataFrame
  89. The transformed data with an added column for aligned ranks.
  90. """
  91. # Align the data
  93. #global overall_mean, aligned_data, within_means, between_means, cell_means
  95. overall_mean = df[dv].mean()
  96. aligned_data = df.copy()
  98. # Calculate marginal means for the main effects and interaction
  99. within_means = df.groupby(within)[dv].transform('mean')
  100. between_means = df.groupby(between)[dv].transform('mean')
  101. cell_means = df.groupby([within, between])[dv].transform('mean')
  103. # Align data for main effects and interaction
  104. #aligned_within = df[dv] - within_means + overall_mean
  105. #aligned_between = df[dv] - between_means + overall_mean
  106. #aligned_interaction = df[dv] - cell_means + overall_mean
  108. residuals = df[dv] - cell_means
  110. aligned_within = residuals + within_means - overall_mean
  111. aligned_between = residuals + between_means - overall_mean
  112. aligned_interaction = residuals + cell_means - overall_mean
  114. # Verify that each column of aligned responses sums to zero
  115. within_bool = np.isclose(aligned_within.sum(), 0), "Aligned within responses do not sum to zero"
  116. between_bool = np.isclose(aligned_between.sum(), 0), "Aligned between responses do not sum to zero"
  117. interaction_bool = np.isclose(aligned_interaction.sum(), 0), "Aligned interaction responses do not sum to zero"
  119. for boolean, name in zip((within_bool, between_bool, interaction_bool), ('within', 'betweenn', 'interaction')) :
  120. if not boolean : print('WARNING : {} alignement does not sum to zero'.format(name))
  122. # Rank the aligned data
  123. aligned_data['AlignedRankWithin'] = rankdata(aligned_within)
  124. aligned_data['AlignedRankBetween'] = rankdata(aligned_between)
  125. aligned_data['AlignedRankInteraction'] = rankdata(aligned_interaction)
  127. return aligned_data
  129. def myANOVA(data, display = False, perform_parametric_anova = False): # 2nd argument : perform regular anova whatever Shapiro's results
  131. if type(data) != type(np.array(0)) : data = np.array(data)
  132. # Flatten the array into a long format
  133. data_flat = data.flatten()
  135. # Generate the Subject, Group, and Time labels correctly
  136. subjects = np.hstack( (np.tile(np.arange(1, 21), 3), np.tile(np.arange(21, 41), 3))) # Each subject appears 6 times (3 times per group)
  137. times = np.tile(['T1']*20 + ['T2']*20 + ['T3']*20, 2) # Each time point repeats for all subjects in both groups
  138. groups = np.array(['Patient']*60 + ['Control']*60) # Each group label is repeated for 3 time points for all 20 subjects
  140. # Creating the DataFrame
  141. df = pd.DataFrame({
  142. 'Subject': subjects,
  143. 'Group': groups,
  144. 'Time': times,
  145. 'Score': data_flat
  146. })
  149. # ASSUMPTIONS CHECK
  150. ###################
  152. # Convert categorical variables to dummy variables for regression
  153. df_dummies = pd.get_dummies(df, columns=['Group', 'Time'], drop_first=True)
  155. # Fit a linear regression model with dummy variables
  156. results = pg.linear_regression(df_dummies[['Group_Patient', 'Time_T2', 'Time_T3']], df_dummies['Score'])
  157. df_dummies['predicted'] = results['coef'].values[0] + np.dot(df_dummies[['Group_Patient', 'Time_T2', 'Time_T3']], results['coef'].values[1:])
  158. df['residuals'] = df['Score'] - df_dummies['predicted']
  160. # Normality test on the residuals
  161. normality = shapiro(df['residuals'])
  163. # Homogeneity of variances test
  164. homoscedasticity = levene(df[df['Time'] == 'T1']['Score'],
  165. df[df['Time'] == 'T2']['Score'],
  166. df[df['Time'] == 'T3']['Score'])
  168. # Sphericity test using Mauchly's test in pingouin
  169. sphericity = pg.sphericity(df, dv='Score', subject='Subject', within='Time')
  172. # ART-transfrom (ranking within each combination of Group and Time for each Subject) if data non normal
  173. #if normality.pvalue < 0.05 :
  174. #df['Score'] = df.groupby(['Subject', 'Group', 'Time'])['Score'].rank(method='average')
  175. #df['Score'] = df.groupby(['Group', 'Time'])['Score'].rank(method='average')
  176. #return df, normality, homoscedasticity, sphericity
  178. # Perform the two-way repeated measures ANOVA
  179. #############################################
  180. if (normality.pvalue < 0.05 and not perform_parametric_anova) :
  181. # Apply Aligned Rank Transform
  182. print('Performing ART ANOVA...')
  184. artDf = aligned_rank_transform(df, subject_col='Subject', dv='Score', within='Time', between='Group')
  186. aov_between = pg.mixed_anova(dv='AlignedRankBetween', between='Group', within='Time', subject='Subject', data=artDf)
  187. aov_between = aov_between.loc[aov_between['Source'] == 'Group']
  189. aov_within = pg.mixed_anova(dv='AlignedRankWithin', between='Group', within='Time', subject='Subject', data=artDf)
  190. aov_within = aov_within.loc[aov_within['Source'] == 'Time']
  192. aov_interaction = pg.mixed_anova(dv='AlignedRankInteraction', between='Group', within='Time', subject='Subject', data=artDf)
  193. aov_interaction = aov_interaction.loc[aov_interaction['Source'] == 'Interaction']
  195. aov = pd.concat([aov_within, aov_between, aov_interaction], axis=0, ignore_index=True)
  197. else:
  198. dv = aov = pg.mixed_anova(dv='Score', between='Group', within='Time', subject='Subject', data=df)
  200. #df['Group_Time'] = df['Group'] + '_' + df['Time']
  202. #tukey = pg.pairwise_tukey(data=df, dv='Score', between='Group_Time')
  204. # Post-hoc tests within subjects with FDR correction (Benjamini-Hochberg)
  205. #post_hoc_within = pg.pairwise_ttests(data=df, dv='value', within='time', subject='subject', padjust='fdr_bh')
  206. # (nice but studies only one factor...)
  207. # rem to do Games-Howell post-hoc tests if homoscedasticity not met !!! (if it exists for mixed models...)
  209. if display :
  210. print("ANOVA Table:")
  211. print(aov)
  212. print("\nNormality test (Shapiro-Wilk) on residuals:")
  213. print(f"Statistic: {normality.statistic}, p-value: {normality.pvalue}")
  214. print("\nLevene's Test for Homogeneity of variances across time points:")
  215. print(f"Statistic: {homoscedasticity.statistic}, p-value: {homoscedasticity.pvalue}")
  216. print("\nSphericity test (Mauchly's):")
  217. print(f"W-value: {sphericity[0]}, p-value: {sphericity[1]}, is sphericity met: {sphericity[2]}")
  219. return aov, normality, homoscedasticity, sphericity #, tukey
  223. def cluster_corr(corr_array, inplace=False):
  224. """
  225. Rearranges the correlation matrix, corr_array, so that groups of highly
  226. correlated variables are next to eachother
  228. Parameters
  229. ----------
  230. corr_array : pandas.DataFrame or numpy.ndarray
  231. a NxN correlation matrix
  233. Returns
  234. -------
  235. pandas.DataFrame or numpy.ndarray
  236. a NxN correlation matrix with the columns and rows rearranged
  237. """
  238. pairwise_distances = sch.distance.pdist(corr_array)
  239. linkage = sch.linkage(pairwise_distances, method='complete')
  240. cluster_distance_threshold = pairwise_distances.max()/2
  241. idx_to_cluster_array = sch.fcluster(linkage, cluster_distance_threshold,
  242. criterion='distance')
  243. idx = np.argsort(idx_to_cluster_array)
  245. if not inplace:
  246. corr_array = corr_array.copy()
  248. if isinstance(corr_array, pd.DataFrame):
  249. return corr_array.iloc[idx, :].T.iloc[idx, :]
  250. return corr_array[idx, :][:, idx]
  252. #DON'T FORGET we've included data computations in the function
  257. def compute_pairwise_tests(data, anova_res, sign_threshold, nsessions):
  259. ## Determine, from ANOVA results, what comparisons should be made
  260. if not type(anova_res) == type(pd.DataFrame()) : aov = anova_res[0] # Take only anova results, without shapiro, Levene...
  261. else : aov = anova_res
  263. pvalues = np.empty((nsessions*2,nsessions*2))
  264. pvalues[:] = np.nan
  266. if ( (aov['Source'] == 'No anova provided').any() \
  267. or (aov.loc[aov['Source'] == 'Interaction']['p-unc'] < sign_threshold).any() \
  268. or ( (aov.loc[aov['Source'] == 'Time']['p-unc'] < sign_threshold).any() \
  269. and (aov.loc[aov['Source'] == 'Group']['p-unc'] < sign_threshold).any())) :
  271. indexes_to_compare = [(0,1), (1,2), (0,2), (3,4), (4,5), (3,5), (0,3), (1,4), (2,5)]
  272. comparisons = ['PxP', 'PxP', 'PxP_wide', 'CxC', 'CxC', 'CxC_wide', 'PxC', 'PxC', 'PxC']
  274. else :
  275. if ( aov.loc[aov['Source'] == 'Time']['p-unc'] < sign_threshold ).any() :
  276. indexes_to_compare = [(0,1), (1,2), (0,2), (3,4), (4,5), (3,5)]
  277. comparisons = ['PxP', 'PxP', 'PxP_wide', 'CxC', 'CxC', 'CxC_wide']
  278. elif ( aov.loc[aov['Source'] == 'Group']['p-unc'] < sign_threshold ).any() :
  279. indexes_to_compare = [(0,3), (1,4), (2,5)]
  280. comparisons = ['PxC', 'PxC', 'PxC']
  281. else :
  282. indexes_to_compare = []
  283. comparisons = []
  285. ## Perform pairwise T tests
  287. for (x, y) in indexes_to_compare : # We could use the comparisons list here
  288. if abs(x - y) >= nsessions : # Between-group comparison
  289. pvalues[(x,y)] = stats.ttest_ind(data[x], data[y], equal_var=False).pvalue
  290. else : #Within-group comparison
  291. pvalues[(x,y)] = stats.ttest_rel(data[x], data[y]).pvalue
  293. return pvalues, indexes_to_compare, comparisons
  295. def plot_pairwise_tests(data, anova_res, sign_threshold, nsessions, xPositions,
  296. plot_type, confint_upper_bounds = np.zeros(6), confint_lower_bounds = np.zeros(6), lower_controls_asterisks = 0):
  298. # Plots pairwise comparisons and returns the min and max y values of the plotted comparisons, along with the scale and scale divider
  300. if plot_type == 'boxplot' :
  301. maxvalue = np.max(data)
  302. minvalue = np.min(data)
  303. minvalue_except_pT1 = np.min(data[1:]) # We won't consider pT1 min value for plotting within-controls significativity
  304. elif plot_type == 'graphchart' :
  305. maxvalue = np.max([np.nanmean(data[i]) + confint_upper_bounds[i] for i in range(len(data))])
  306. minvalue = np.min([np.nanmean(data[i]) - confint_lower_bounds[i] for i in range(len(data))])
  307. minvalue_except_pT1 = np.min(np.nanmean(data[1:,:], axis = 1) - confint_lower_bounds[1:]) # We won't consider pT1 min value for plotting within-controls significativity
  308. else :
  309. raise ValueError('Choose a plot type between graphchart and boxplot')
  310. scale = (maxvalue - minvalue)
  311. #plt.ylim([minvalue - 0.15, maxvalue+scale/5])
  312. #plt.ylim(60)
  314. # Generic prototype supporting two sessions : [(x,y) for (x,y) in itertools.product('twice the list...') if x != y]
  315. # We want to compare :
  316. # Les p entre eux -> (0,1), (1,2), (0,2)
  317. # Les c entre eux -> (3,4), (4,5), (3,5)
  318. # Les p et c appariés -> (0,3), (1,4), (2,5)
  320. pvalues, indexes_to_compare, comparisons = compute_pairwise_tests(data, anova_res, sign_threshold, nsessions)
  322. # Determine display from pairwise comparison results
  324. y_loc_asterisk_max = 0 # will be modified if asterisks are plotted. Will determine the top limit of the y axis
  325. y_loc_asterisk_min = minvalue # will be modified if asterisks are below mean value. Legend and anova results will be plotted below if plotted
  326. scdvd = 12 #scale divider, modulates vertical spacing of significance lines
  328. for (x,y), comparison in zip(indexes_to_compare, comparisons) :
  329. pvalue = pvalues[x,y]
  330. if np.isnan(pvalue) : print('NaN pvalue')
  331. if pvalue < 0.005 : asterisk = '*\u2009*\u2009*'
  332. elif pvalue < 0.01 : asterisk = '*\u2009*'
  333. elif pvalue < 0.05 : asterisk = '*'
  334. else : asterisk = 'ns'
  335. #offset = 0.05 * (pvalue < 0.01)
  336. #y_loc_asterisk = scale/3 + max([data_means[i]+yerr[i] for i in [session, session+nsessions]])
  337. if pvalue >=0.05 :
  338. weight = 'normal'
  339. fontsize = 10
  340. else :
  341. weight = 'bold'
  342. fontsize = 12
  344. # Y_locations
  345. spacing = 1.5*scale/scdvd # Average spacing between max data points and lines, and between lines
  347. yloc_lowest_upper_line = np.array((maxvalue + scale/scdvd, maxvalue+ scale/scdvd)) \
  348. - spacing * (not any(['PxC' in comp for comp in comparisons])) # If no b/w grp comparisons we lower within-patients comparisons
  349. yloc_lower_line = np.array((minvalue_except_pT1 - scale/scdvd, minvalue_except_pT1 - scale/scdvd))
  350. if comparison == 'PxC' : # Between-group comparison
  351. yloc_line = yloc_lowest_upper_line
  352. elif comparison == 'PxP' :
  353. yloc_line = yloc_lowest_upper_line + spacing
  354. elif comparison == 'PxP_wide' :
  355. yloc_line = yloc_lowest_upper_line + 2*spacing
  356. elif comparison == 'CxC' :
  357. yloc_line = yloc_lower_line + lower_controls_asterisks
  358. elif comparison == 'CxC_wide' :
  359. yloc_line = yloc_lower_line - spacing + lower_controls_asterisks
  361. groupwise_xPositions = [xPositions[i] for i in (0,2,4,1,3,5)]# x positions ordered according to group orders in data
  362. #groupwise_xPositions = [xPositions[i] for i in (1,3,5,1,3,5)]
  364. # x_locations
  365. if comparison in ('PxP', 'CxC') :
  366. lag = 0.02 #Add some space between adjacent lines
  367. if y in (1,4) : xloc_line = ((groupwise_xPositions[x], groupwise_xPositions[y]-lag))
  368. elif x in (1,4) : xloc_line = ((groupwise_xPositions[x]+lag, groupwise_xPositions[y]))
  369. else : print('PROBLEM')
  370. else :
  371. intergroup_comp_wider = 0 # Only useful for graphcharts, see below
  372. if plot_type == "graphchart" :
  373. if abs(y - x) == 3 : # Means intergroups comparison
  374. intergroup_comp_wider = 0.03 # otherwise intergroup comparison lines too short
  375. xloc_line = ((groupwise_xPositions[x]-intergroup_comp_wider, groupwise_xPositions[y]+intergroup_comp_wider))
  377. # Colors
  378. if comparison in ('CxC', 'CxC_wide') : color = 'steelblue'
  379. elif comparison in ('PxP', 'PxP_wide') : color = 'indianred'
  380. else : color = 'black'
  382. y_loc_asterisk = yloc_line[0] + 0.2*scale/scdvd
  384. if y_loc_asterisk > y_loc_asterisk_max : y_loc_asterisk_max = y_loc_asterisk
  385. if y_loc_asterisk < y_loc_asterisk_min : y_loc_asterisk_min = y_loc_asterisk
  389. #return asterisk, weight, fontsize, color, xloc_line, yloc_line, y_loc_asterisk
  391. plt.text(sum(xloc_line)/2, y_loc_asterisk, asterisk, horizontalalignment = 'center',
  392. size = fontsize, weight = weight, color = color)
  394. plt.plot(xloc_line,
  395. yloc_line, color = color, linewidth = 1)
  397. #if y_loc_asterisk_max != 0 : plt.ylim(top = y_loc_asterisk_max + scale/scdvd )
  398. return y_loc_asterisk_min, y_loc_asterisk_max, scale, scdvd
  401. def niceGraphChart(data, title = 'Title', ylabel = 'Mean $\\rho$',
  402. xlabels = 'default', legend_loc = 'lower left', yerr = 'confint',
  403. save_as = 'do_not_save', plots_path = plots_path, show = True, sign = False,
  404. anova_res = pd.DataFrame(['No anova provided'], [0], ['Source']), sign_threshold = 0.05, fullsize=False,
  405. lower_controls_asterisks = 0, display_aov_text = False, x_aov_text = 1, y_aov_text = 1): # lower_controls_asterisk : DYI solution for lowering the comparison lines when misplaced (e.g. cross the patients data lines...). Enter negative values
  407. nsessions = int(len(data) /2)
  408. if xlabels == 'default' :
  409. if nsessions == 2 : xlabels = ('Day 0', 'Day 3')
  410. else : xlabels = ("Day 0", "Day 3", "Day 90")
  412. data_means = [np.nanmean(elem) for elem in data]
  413. pData_means=data_means[:nsessions]
  414. cData_means=data_means[nsessions:]
  416. print(pData_means)
  418. confints = []
  419. for sessionTime in range(6):
  420. confints.append(confint(data[sessionTime]))
  422. # Get the upper and lower spans from confints and mean
  423. upper_confint_spans = [confint[2] - confint[0] for confint in confints]
  424. lower_confint_spans = [confint[0] - confint[1] for confint in confints]
  426. #if yerr == 'std' : yerr = [np.std(elem) for elem in data]
  428. interstice = 0.05 # Between the two datapoints of two groups at one session
  430. if fullsize : fig = plt.figure(dpi=300)
  431. else : fig = plt.figure()
  433. Controls = plt.errorbar(
  434. x=(np.arange(nsessions) + interstice),#xlabels,
  435. y=cData_means,
  436. yerr=(lower_confint_spans[nsessions:], upper_confint_spans[nsessions:]),#yerr[nsessions:],#std_cT1vT2sign[3:],
  437. capsize=4,
  438. marker='o',
  439. color='steelblue',
  440. markersize=4,
  441. linewidth=2,
  442. zorder = 1,
  443. linestyle='-') # alternative : '--' for dashed
  445. Patients = plt.errorbar(
  446. x=xlabels,
  447. y=pData_means,
  448. yerr=(lower_confint_spans[:nsessions], upper_confint_spans[:nsessions]),#yerr[:nsessions],
  449. capsize=4,
  450. marker='s',
  451. color='indianred',
  452. markersize=4,
  453. linewidth=2,
  454. zorder = 2,
  455. linestyle='-')
  457. xPositions = [(x - interstice/2, x + interstice/2) for x in range(nsessions)]
  458. xPositions = [x for tup in xPositions for x in tup]
  460. if sign :
  461. y_loc_asterisk_min, y_loc_asterisk_max, scale, scdvd = plot_pairwise_tests(data, anova_res, sign_threshold, nsessions, xPositions,
  462. 'graphchart', upper_confint_spans, lower_confint_spans, lower_controls_asterisks )
  464. '''
  465. if sign :
  466. maxvalue = max(np.add(data_means,yerr))
  467. minvalue = min(np.subtract(data_means,yerr))
  468. scale = (maxvalue - minvalue) /5
  469. #plt.ylim([minvalue - 0.15, maxvalue+1])
  470. plt.ylim([minvalue - 0.15*scale, maxvalue+scale])
  471. for session in range(int(len(data_means)/2)):
  472. pvalue = stats.ttest_ind(data[session], data[session+nsessions], equal_var=False).pvalue
  473. if pvalue < 0.005 : asterisk = '*\u2009*\u2009*'
  474. elif pvalue < 0.01 : asterisk = '*\u2009*'
  475. elif pvalue < 0.05 : asterisk = '*'
  476. else : asterisk = 'ns'
  477. offset = 0.05 * (pvalue < 0.01)
  478. y_loc_asterisk = scale/3 + max([data_means[i]+yerr[i] for i in [session, session+nsessions]])
  479. if pvalue >=0.05 : weight = 'normal'
  480. else : weight = 'bold'
  481. plt.text(session - offset, y_loc_asterisk, asterisk, size = 12, weight = weight)
  482. '''
  485. if sign :
  486. if y_loc_asterisk_max != 0 : plt.ylim(bottom = y_loc_asterisk_min - scale/scdvd, top = y_loc_asterisk_max + scale/scdvd)
  487. plt.xlim(-0.15,nsessions -1 +0.15)
  488. legend = plt.legend((Patients, Controls),("Patients","Controls"), loc = legend_loc)
  490. #plot aov results :
  491. if display_aov_text and not (anova_res[0]['Source'] == 'No anova provided').any():
  493. aov_res = anova_res[0]
  494. aov_text_time = f"T : F({aov_res['DF1'][0]},{aov_res['DF2'][0]}) = {np.round(aov_res['F'][0], 2)}, p = {np.round(aov_res['p-unc'][0], 2)}"
  495. aov_text_group = f"G : F({aov_res['DF1'][1]},{aov_res['DF2'][1]}) = {np.round(aov_res['F'][1], 2)}, p = {np.round(aov_res['p-unc'][1], 2)}"
  496. aov_text_int = f"X : F({aov_res['DF1'][2]},{aov_res['DF2'][2]}) = {np.round(aov_res['F'][2], 2)}, p = {np.round(aov_res['p-unc'][2], 2)}"
  497. aov_text = '\n'.join([aov_text_time, aov_text_group, aov_text_int])
  499. # Place text box horizontally aligned to legend
  500. # Get the bounding box of the legend in display coordinates
  501. bbox = legend.get_window_extent()
  503. # Get the transformation to convert display coordinates to data coordinates
  504. trans = plt.gca().transData.inverted()
  506. # Transform the bounding box to data coordinates
  507. bbox_in_data = bbox.transformed(trans)
  509. # Get the coordinates of the legend (x, y, width, height) in data coordinates
  510. legend_coordinates_data = bbox_in_data.bounds
  512. y_aov_text = legend_coordinates_data[1] + legend_coordinates_data[3] / 2 # Adjust y to match the center of the legend box
  513. x_aov_text = 2.1
  514. text_box_height = legend_coordinates_data[3] # The height of the legend
  516. # Add text with a matching box height
  517. plt.text(x_aov_text, y_aov_text, aov_text, size=8, bbox=dict(facecolor='none', edgecolor='gray', boxstyle=f'round,pad={text_box_height/2}'),
  518. horizontalalignment='right', verticalalignment='center')
  520. plt.ylabel(ylabel)
  521. plt.title(title)
  522. ## widen both limits to give some whitespace to the plot
  523. #plt.ylim(-5, 105)
  524. #plt.xlim(-0.2, 3.2)
  525. # plt.savefig('Fig2.png', dpi=300, bbox_inches='tight')
  526. #plt.margins(5,5)
  527. if not save_as == 'do_not_save':
  528. plt.savefig(plots_path + save_as, dpi=300, bbox_inches='tight')
  529. print('Saved at' + str(plots_path+save_as))
  530. if show : plt.show()
  533. def niceBoxplot(data, title = 'Title', ylabel = 'Score',
  534. xlabels = 'default', legend_loc = 'lower left', yerr = 'default', scatter = True, notch = True,
  535. save_as = 'do_not_save', plots_path = plots_path, show = True, sign = False,
  536. anova_res = pd.DataFrame(['No anova provided'], [0], ['Source']),
  537. sign_threshold = 0.05, fullsize=False, lower_controls_asterisks = 0, display_aov_text = False) :
  539. nsessions = int(len(data) /2)
  540. if xlabels == 'default' :
  541. if nsessions == 2 : xlabels = ('Day 0', 'Day 3')
  542. else : xlabels = ('Day 0', 'Day 3', 'Day 90')
  544. if fullsize : fig = plt.figure(dpi=300)
  545. else : fig = plt.figure()
  547. #data = [data[i] for i in [index in tup for tup in [(0+session, 0+session +nsessions) for session in range(nsessions)] for index in tup]]
  548. nsessions = int(len(data)/2)
  549. order = [index for tup in [(0+session, 0+session +nsessions) for session in range(nsessions)] for index in tup]
  550. data_reordered = [data[index] for index in order]
  551. interstice = 0.3
  552. xPositions = [(x-interstice/2, x+interstice/2) for x in range(nsessions)]
  553. xPositions = [x for tup in xPositions for x in tup]
  554. xs = [np.random.normal(x , 0.05, len(data[0])) for x in xPositions]
  555. colored_plots = not scatter # We'll fill the boxes if we don't scatter
  556. box = plt.boxplot(data_reordered, positions = xPositions, showfliers = False, autorange = True, widths = 0.25, notch = notch, \
  557. patch_artist = colored_plots)#, labels=xlabels)
  558. palette = [color for tup in [('indianred', 'steelblue')*nsessions] for color in tup]
  559. if scatter :
  560. for x, val, c in zip(xs, data_reordered, palette):
  561. plt.scatter(x, val, alpha=0.8, color=c, s = 10)
  562. else :
  563. for patch, color in zip(box['boxes'], palette):
  564. patch.set_facecolor(color)
  566. if sign : y_loc_asterisk_min, y_loc_asterisk_max, scale, scdvd = plot_pairwise_tests(data, anova_res, sign_threshold, nsessions, xPositions, 'boxplot',
  567. lower_controls_asterisks = lower_controls_asterisks)
  570. '''
  571. if sign :
  572. maxvalue = np.max(data)
  573. minvalue = np.min(data)
  574. minvalue_except_pT1 = np.min(data[1:]) # We won't consider pT1 min value for plotting within-controls sign
  575. scale = (maxvalue - minvalue)
  576. plt.ylim([minvalue - 0.15, maxvalue+scale/5])
  577. #plt.ylim([minvalue - 0.15, maxvalue+1])
  578. #plt.ylim([minvalue - 0.15*scale, maxvalue+scale])
  579. for session in [2*i for i in range(nsessions)]:
  580. pvalue = stats.ttest_ind(data[session], data[session+1], equal_var=False).pvalue
  581. if pvalue < 0.005 : asterisk = '*\u2009*\u2009*'
  582. elif pvalue < 0.01 : asterisk = '*\u2009*'
  583. elif pvalue < 0.05 : asterisk = '*'
  584. else : asterisk = 'ns'
  585. #offset = 0.05 * (pvalue < 0.01)
  586. #y_loc_asterisk = scale/3 + max([data_means[i]+yerr[i] for i in [session, session+nsessions]])
  587. y_loc_asterisk = maxvalue + scale/10
  588. if pvalue >=0.05 : weight = 'normal'
  589. else : weight = 'bold'
  590. plt.text(int(session/2), y_loc_asterisk, asterisk, horizontalalignment = 'center', size = 12, weight = weight)
  591. plt.plot((xPositions[session], xPositions[session+1]),
  592. (maxvalue + scale/12, maxvalue+scale/12), color = 'black', linewidth = 1)
  593. '''
  595. #plt.xlim(-0.15,nsessions -1 +0.15)
  596. #plt.legend(("Patients","Controls"), colors = ('steelblue', 'indianred'), loc = legend_loc)
  598. from matplotlib.lines import Line2D
  599. colors = ('indianred', 'steelblue')
  600. lines = [Line2D([0], [0], color=c, linewidth=1, linestyle='None', marker = 'o', markersize = 3) for c in colors]
  601. labels = ['Patients', 'Controls']
  602. legend = plt.legend(lines, labels, loc = legend_loc, handletextpad = 0.1, handlelength=1, borderaxespad=0.5, fontsize = 8)
  604. if sign :
  605. if y_loc_asterisk_max != 0 and y_loc_asterisk_min < y_loc_asterisk_max:
  606. plt.ylim(bottom = y_loc_asterisk_min - scale/scdvd, top = y_loc_asterisk_max + scale/scdvd)
  607. #plt.xlim(-0.15,nsessions -1 +0.15)
  608. #legend = plt.legend((Patients, Controls),("Patients","Controls"), loc = legend_loc)
  610. #plot aov results :
  611. if display_aov_text and not (anova_res[0]['Source'] == 'No anova provided').any():
  613. aov_res = anova_res[0]
  614. aov_text_time = f"T : F({aov_res['DF1'][0]},{aov_res['DF2'][0]}) = {np.round(aov_res['F'][0], 2)}, p = {np.round(aov_res['p-unc'][0], 2)}"
  615. aov_text_group = f"G : F({aov_res['DF1'][1]},{aov_res['DF2'][1]}) = {np.round(aov_res['F'][1], 2)}, p = {np.round(aov_res['p-unc'][1], 2)}"
  616. aov_text_int = f"X : F({aov_res['DF1'][2]},{aov_res['DF2'][2]}) = {np.round(aov_res['F'][2], 2)}, p = {np.round(aov_res['p-unc'][2], 2)}"
  617. aov_text = '\n'.join([aov_text_time, aov_text_group, aov_text_int])
  619. # Place text box horizontally aligned to legend
  620. # Get the bounding box of the legend in display coordinates
  621. bbox = legend.get_window_extent()
  623. # Get the transformation to convert display coordinates to data coordinates
  624. trans = plt.gca().transData.inverted()
  626. # Transform the bounding box to data coordinates
  627. bbox_in_data = bbox.transformed(trans)
  629. # Get the coordinates of the legend (x, y, width, height) in data coordinates
  630. legend_coordinates_data = bbox_in_data.bounds
  632. y_aov_text = legend_coordinates_data[1] + legend_coordinates_data[3] / 2 # Adjust y to match the center of the legend box
  633. x_aov_text = 2.6
  634. text_box_height = legend_coordinates_data[3] # The height of the legend
  636. # Add text with a matching box height
  637. plt.text(x_aov_text, y_aov_text, aov_text, size=8, bbox=dict(facecolor='none', edgecolor='gray', boxstyle=f'round,pad={text_box_height/2}'),
  638. horizontalalignment='right', verticalalignment='center')
  641. plt.ylabel(ylabel)
  642. plt.xticks(ticks = range(len(xlabels)), labels=xlabels)
  643. plt.title(title)
  645. if not save_as == 'do_not_save' : plt.savefig(plots_path + save_as)
  647. plt.show()
  650. def RLvsRI_plot(RL, RI, RECO = np.zeros((6,20)), save_as = 'do_not_save', title = 'Title', ylabel = 'score', session = 1, nsessions = 3,
  651. need_to_add_RI_to_RL = True, sign = True):
  653. session -= 1
  655. if need_to_add_RI_to_RL :
  656. pT1_RI_sum = np.add(RI[session], RL[session])
  657. cT1_RI_sum = np.add(RI[session+nsessions], RL[session+nsessions])
  658. pT1_RECO_sum = np.add(RECO[session], pT1_RI_sum)
  659. cT1_RECO_sum = np.add(RECO[session+nsessions], cT1_RI_sum)
  660. else :
  661. pT1_RI_sum = RI[session]
  662. cT1_RI_sum = RI[session+nsessions]
  663. pT1_RECO_sum = RECO[session]
  664. cT1_RECO_sum = RECO[session+nsessions]
  666. fig, ax = plt.subplots(dpi=300)
  668. pT1_RL_data = np.mean(RL[session])
  669. cT1_RL_data = np.mean(RL[session+nsessions])
  671. pT1_RI_data = np.mean(pT1_RI_sum)
  672. cT1_RI_data = np.mean(cT1_RI_sum)
  674. pT1_RECO_data = np.mean(pT1_RECO_sum)
  675. cT1_RECO_data = np.mean(cT1_RECO_sum)
  677. ax.bar('Controls', cT1_RECO_data, color = 'moccasin')
  678. ax.bar('Controls', cT1_RI_data, color = 'orange')
  679. ax.bar('Controls', cT1_RL_data, color = 'blue')
  681. ax.bar('Patients', pT1_RECO_data, color = 'moccasin')
  682. ax.bar('Patients', pT1_RI_data, color = 'orange')
  683. ax.bar('Patients', pT1_RL_data, color = "blue")
  685. ax.legend(('RECO', 'RI', 'RL'))
  687. if sign :
  688. maxvalue = max(pT1_RI_data, cT1_RI_data)
  689. minvalue = 0
  690. scale = (maxvalue - minvalue) /5
  691. #plt.ylim([minvalue - 0.15, maxvalue+1])
  692. plt.ylim([minvalue - 0.15*scale, maxvalue+scale])
  694. pvalue = stats.ttest_ind(pT1_RI_sum, cT1_RI_sum, equal_var=False).pvalue
  695. if pvalue < 0.005 : asterisk = '*\u2009*\u2009*'
  696. elif pvalue < 0.01 : asterisk = '*\u2009*'
  697. elif pvalue < 0.05 : asterisk = '*'
  698. else : asterisk = 'ns'
  699. offset = 0.05 * (pvalue < 0.01)
  700. #y_loc_asterisk = scale/3 + max([data_means[i]+yerr[i] for i in [session, session+nsessions]])
  701. y_loc_asterisk = maxvalue + scale/2
  702. if pvalue >=0.05 : weight = 'normal'
  703. else : weight = 'bold'
  704. plt.text(0.5 - offset, y_loc_asterisk, asterisk, size = 12, weight = weight)
  705. plt.plot((0,1), (y_loc_asterisk - scale/8, y_loc_asterisk - scale/8), color = 'black')
  707. ax.set_ylabel(ylabel)
  708. ax.set_title(title)
  710. if not save_as == 'do_not_save' : plt.savefig(plots_path + save_as)
  712. plt.show()
  715. def niceScatterplot(data1, data2, plotEdges = True, title = 'Title', ylabel = 'Score', showMeans = False,
  716. xlabels = ('T1', 'T2'), legend_loc = 'upper right', yerr = 'default', zscores = False,
  717. save_as = 'do_not_save', plots_path = plots_path, show = True, sign = False, fullsize=False):
  719. fig, ax = plt.subplots(tight_layout=True, dpi = 100)
  721. #colors = ["cornflowerblue", "salmon"]
  722. #colors = ["cornflowerblue", "cornflowerblue"]
  724. colors = ['darkseagreen', 'antiquewhite', 'aqua', 'aquamarine', 'azure',
  725. 'beige', 'bisque', 'black', 'blanchedalmond', 'blue',
  726. 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse',
  727. 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson']
  729. colors = ['DarkRed', 'DarkOrange', 'DarkGreen', 'DarkCyan','DarkBlue','LightSalmon',
  730. 'LightGoldenRodYellow',
  731. 'LightGreen',
  732. 'LightSkyBlue',
  733. 'LightSlateGray',
  734. 'Salmon',
  735. 'SandyBrown',
  736. 'MediumSeaGreen',
  737. 'CornflowerBlue',
  738. 'SlateGray',
  739. 'Tomato',
  740. 'Gold',
  741. 'LimeGreen',
  742. 'SkyBlue',
  743. 'SteelBlue']
  745. width=0.3
  746. dotsize = 25
  748. #plt.xlim(-0.5, 1.5)
  749. plt.tick_params(axis='x', which='major', labelsize='10')
  751. #diffT1T2 = np.array([cDiff_T1vT2[:32], pDiff_T1vT2[:32]]).transpose()
  752. if zscores : data1, data2 = stats.zscore(data1), stats.zscore(data2)
  753. data = np.array([data1, data2])
  755. x_store = np.array([np.ones(data1.shape), np.ones(data1.shape)])
  756. y_store = np.array([np.ones(data1.shape), np.ones(data1.shape)])
  758. for i, l in enumerate(xlabels):
  759. x = np.ones(data.shape[1])*i + (np.random.rand(data.shape[1])*width-width/2.)
  760. ax.scatter(x, data[i], color=colors, s=dotsize)
  761. x_store[i] = x
  762. y_store[i] = data[i]
  763. median = np.median(data[i])#.mean()
  764. if showMeans : ax.plot([i-width/2. - 0.1, i+width/2. +0.1],[median,median], color="k")
  766. if plotEdges :
  767. for i in range(data.shape[1]):
  768. plt.plot([x_store[0][i], x_store[1][i]],[y_store[0][i], y_store[1][i]], color = colors[i])
  770. ax.set_xticks(range(len(xlabels)))
  771. ax.set_xticklabels(xlabels)
  773. ax.set_ylabel(ylabel, fontsize=11)
  774. ax.set_title(title, fontsize=12)
  776. def linregPlot(X = None, Y = None):
  777. reg = stats.linregress(X, Y)
  778. x_pred = np.arange(min(X), max(X), 0.01)
  779. y_pred = np.multiply(reg.slope, x_pred) + reg.intercept
  780. plt.scatter(X, Y)
  781. plt.plot(x_pred, y_pred, color = 'red')
  782. summary_stats = 'R² : ' + str(np.round(reg.rvalue, decimals = 2)) + '\np-value : ' + str(np.round(reg.pvalue, decimals = 2))
  783. scale = (max(X) - min(X))/4
  784. plt.text(max(X)- scale, max(Y), s = summary_stats, horizontalalignment = 'left', verticalalignment = 'top', size = 12, c = 'r')

functions.py at commit c950a5a, no license · at the source

Overview

Authors: Elias El Otmani1, Emmanuel Barbeau2, Béatrice Lemesle3, Emilie Milongo‐Rigal3, Sophie Fernandez4, Sandrine Charpentier4,5, Jean‐François Albucher1,6, Nicolas Raposo1,6, Fabrice Bonneville1,7, Patrice Péran1, Jérémie Pariente1,3
ORCID iDs: Elias El Otmani, Nicolas Raposo
  1. ToNIC Toulouse NeuroImaging Center, UMR 1214, Universit. De Toulouse, INSERM, Paul Sabatier University (UT3) Toulouse France
  2. CNRS, Cerco Toulouse France
  3. Department of Neurology Neuroscience Centre, Toulouse‐Purpan University Hospital Toulouse Cedex France
  4. Department of Emergency Medicine University Hospital of Toulouse Toulouse France
  5. Laboratory of Epidemiology and Analyses in Public Health UMR 1295 Inserm, Toulouse University France
  6. Department of Neurolog Clinical Investigation Center, CIC1436, Toulouse University Hospital Toulouse France
  7. Department of Neuroradiology University Hospital of Toulouse Toulouse France
Institutions: Université Toulouse III - Paul Sabatier (France); Inserm (France); Toulouse NeuroImaging Center (France); Centre National de la Recherche Scientifique (France); Centre de recherche cerveau et cognition (France); Hôpital Purpan (France); Centre Hospitalier Universitaire de Toulouse (France); Université de Toulouse (France); Centre d'Epidémiologie et de Recherche en santé des POPulations de Toulouse (France); Centre d’Investigation Clinique 1436 (France)
Journal: Annals of clinical and translational neurology, article 10.1002/acn3.70396
Dates: received 16 February 2026; accepted 21 March 2026; published online 10 April 2026; in print April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/acn3.70396 · PMID 41958247 · PMCID PMC13394162 · OpenAlex W7153314802
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: fMRI (modality), human (organism), cognitive (subfield)
Methods: Preprocessing, Statistics, Smoothing, state filtering, decompositions, Connectivity, fMRI & imaging
Keywords: episodic memory, memory networks, transient global amnesia
Topic: Memory and Neural Mechanisms (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Université Toulouse III ‐ Paul Sabatier; Centre Hospitalier Universitaire de Toulouse; Institut des Sciences du Cerveau de Toulouse
Citations: not cited yet (Europe PMC); 47 references in the paper

Abstract

Background and Objectives: Transient global amnesia (TGA) is a striking model of isolated amnesia. While hippocampal lesions are well described, the network‐level mechanisms and the precise neuropsychological profile remain debated. Our objective was thus to characterize functional and neuropsychological correlates of acute TGA and their longitudinal evolution.

Methods: Prospective, single‐center case–control study of 20 patients with acute TGA and 20 age‐ and sex‐matched healthy controls. All participants completed neuropsychological testing and underwent structural and functional MRI at three time points: acute phase (< 24 h from onset), day 3, and 3 months. Primary outcomes were neuropsychological performance across episodic, semantic, and metamemory domains and resting‐state fMRI connectivity within the episodic memory network. Secondary outcomes were functional connectivity within the Default Mode (DMN), Executive (ECN), and Salience (SN) networks.

Results: A total of 40 participants were included (20 patients with TGA, mean age 65.5 years, 45% women; 20 controls, mean age 64.3 years, 45% women). In patients, median delay from symptoms' onset to MRI was 6.67 h. Neuropsychologically, patients showed profound multimodal anterograde amnesia during the acute phase, resolving by 3 months. This deficit was largely isolated, sparing semantic memory and metamemory. Structurally, small bilateral lesions were present in most patients. Functionally, acute hypoconnectivity was observed within the extended hippocampal system, particularly between parahippocampal and cingulate cortices, normalizing by 3 months. No consistent disruption was found in large‐scale networks (default mode, executive control, salience).

Interpretation: TGA is associated with transient, selective hypoconnectivity within the mesiotemporal–cingulate episodic memory network, aligning with previous reports and further precising the functional anatomy. The finding of a profound anterograde amnesia was replicated and its recovery timecourse was elucidated. Semantic memory and metamemory remain preserved, clarifying inconsistencies in prior reports. These findings suggest that TGA reflects a transient limbic dysconnectivity syndrome rather than a diffuse network disorder, reconciling structural lesions with clinical and functional data.

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 5 matches between paragraphs and lines of code.

EliasElOtmani/TGA

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: c950a5a092e4dcf92e29236d88503057babccfae, 13 February 2026
Languages: Jupyter (10), Python (2)
Size: 1,998 files, 12 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: 3 notebooks
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (11 files), NumPy (11 files), pandas (9 files), SciPy (9 files), Pingouin (6 files), Plotly (6 files), seaborn (6 files), statsmodels (6 files), NiBabel (2 files), Nilearn (2 files)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
11 files
At the source: github.com/EliasElOtmani/TGA

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;
  • 11 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.

Data Availability Statement

Light data such as neuropsychological data, 1st‐level preprocessed fMRI ROI‐to‐ROI data and python codes are available at https://github.com/EliasElOtmani/TGA. Heavy data such as raw fMRI, ICA and MRI data are available upon request.

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, 29 September 2026: the first record

Recorded: type, language, journal, pages, dates, 11 authors, 3 keywords, 3 funders, 45 references.

Cite

This paper

El Otmani, E., Barbeau, E., Lemesle, B., Milongo‐Rigal, E., Fernandez, S., Charpentier, S., Albucher, J., Raposo, N., Bonneville, F., Péran, P., & Pariente, J. (2026). Memory and Resting-State Connectivity in Acute Transient Global Amnesia: A Case-Control fMRI Study. Annals of clinical and translational neurology, 10.1002/acn3.70396. https://doi.org/10.1002/acn3.70396

BibTeX

@article{elotmani2026memory,
author = {El Otmani, Elias and Barbeau, Emmanuel and Lemesle, Béatrice and Milongo‐Rigal, Emilie and Fernandez, Sophie and Charpentier, Sandrine and Albucher, Jean‐François and Raposo, Nicolas and Bonneville, Fabrice and Péran, Patrice and Pariente, Jérémie},
title = {{Memory and Resting-State Connectivity in Acute Transient Global Amnesia: A Case-Control fMRI Study}},
journal = {Annals of clinical and translational neurology},
year = {2026},
month = apr,
pages = {10.1002/acn3.70396},
publisher = {Wiley},
issn = {2328-9503},
doi = {10.1002/acn3.70396},
url = {https://doi.org/10.1002/acn3.70396},
pmid = {41958247},
pmcid = {PMC13394162}
}

RIS

TY - JOUR
AU - El Otmani, Elias
AU - Barbeau, Emmanuel
AU - Lemesle, Béatrice
AU - Milongo‐Rigal, Emilie
AU - Fernandez, Sophie
AU - Charpentier, Sandrine
AU - Albucher, Jean‐François
AU - Raposo, Nicolas
AU - Bonneville, Fabrice
AU - Péran, Patrice
AU - Pariente, Jérémie
TI - Memory and Resting-State Connectivity in Acute Transient Global Amnesia: A Case-Control fMRI Study
T2 - Annals of clinical and translational neurology
J2 - Ann Clin Transl Neurol
PY - 2026
DA - 2026/04/10
SP - 10.1002/acn3.70396
SN - 2328-9503
PB - Wiley
DO - 10.1002/acn3.70396
UR - https://doi.org/10.1002/acn3.70396
LA - en
ER -

CSL-JSON

{
"id": "10.1002/acn3.70396",
"type": "article-journal",
"title": "Memory and Resting-State Connectivity in Acute Transient Global Amnesia: A Case-Control fMRI Study",
"container-title": "Annals of clinical and translational neurology",
"author": [
{
"family": "El Otmani",
"given": "Elias"
},
{
"family": "Barbeau",
"given": "Emmanuel"
},
{
"family": "Lemesle",
"given": "Béatrice"
},
{
"family": "Milongo‐Rigal",
"given": "Emilie"
},
{
"family": "Fernandez",
"given": "Sophie"
},
{
"family": "Charpentier",
"given": "Sandrine"
},
{
"family": "Albucher",
"given": "Jean‐François"
},
{
"family": "Raposo",
"given": "Nicolas"
},
{
"family": "Bonneville",
"given": "Fabrice"
},
{
"family": "Péran",
"given": "Patrice"
},
{
"family": "Pariente",
"given": "Jérémie"
}
],
"container-title-short": "Ann Clin Transl Neurol",
"page": "10.1002/acn3.70396",
"DOI": "10.1002/acn3.70396",
"PMID": "41958247",
"PMCID": "PMC13394162",
"ISSN": "2328-9503",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/acn3.70396",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
10
]
]
}
}

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.1038/s41467-026-75662-w [code]
Distinct Roles of Deep and Superficial Cortical Layers in Tone Prediction, Comparison, and Adaptation in Human Auditory Cortices.
Journal: Nature communications
In common: Pingouin, Nilearn, NiBabel, 6 other tools, cognitive, 1 reference
[2] doi:10.1038/s41467-026-74566-z [code]
Low-dimensional and optimised representations of high-level information in the expert brain.
Journal: Nature communications
In common: Pingouin, Nilearn, Plotly, 7 other tools, cognitive
[3] doi:10.1162/imag.a.1269 [code]
From early to contemporary normative modeling: Mapping individual differences in neurophysiological signals.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Pingouin, Nilearn, Plotly, 7 other tools
[4] doi:10.1371/journal.pbio.3003684 [code]
The retrieval of previously learned motor memories is facilitated by the reinstatement of default mode network manifold structures.
Journal: PLoS biology
In common: Pingouin, Nilearn, NiBabel, 5 other tools, fMRI, cognitive, 1 reference
[5] doi:10.1162/imag.a.105 [code]
Right posterior theta reflects human parahippocampal phase resetting by salient cues during goal-directed navigation
Journal: n/a
In common: Pingouin, Nilearn, NiBabel, 6 other tools, fMRI, cognitive
[6] doi:10.1002/agm2.70073 [code]
Foreign Language Learning in Older Adults Modifies Resting-State Functional Connectivity Between the Subcortical Structures and the Cortex.
Journal: Aging medicine (Milton (N.S.W))
In common: Nilearn, NiBabel, statsmodels, 5 other tools, fMRI, 2 references
[7] doi:10.1162/netn.a.544 [code]
Brain network reconfiguration during reward prediction error processing.
Journal: Network neuroscience (Cambridge, Mass.)
In common: Nilearn, Plotly, NiBabel, 6 other tools, fMRI, cognitive
[8] doi:10.1016/j.xcrm.2026.102793 [code]
A predictive corticospinal model for pain perception.
Journal: Cell reports. Medicine
In common: Pingouin, Nilearn, NiBabel, 6 other tools, fMRI
[9] doi:10.1038/s41597-026-07377-y [code]
An open-access multi-site fMRI dataset for investigating conscious visual perception.
Journal: Scientific data
In common: Pingouin, Nilearn, NiBabel, 6 other tools, fMRI
[10] doi:10.1162/imag.a.1321 [code]
Phase similarity between similar objects indicates representational merging across retrieval training but not sleep.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Pingouin, Nilearn, Plotly, 6 other tools, cognitive

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.