OSCR

Beyond one-to-one mappings: Modelling distributed lesion-symptom relationships with multilayer networks.

Code ↔ Paper

8 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.

8 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.

The 8 matches
  1. [1] § Material and method › Network analysis › Multilayer community detection ↔ Article/Louvain.py, lines 459 to 544 · score 0.62 · resolution parameter, partition stability, NMI, pairwise, modularity, Louvain · block oscr:b:KD671GX7GA2YB-V · Report a mismatch
  2. [2] § Material and method › Network analysis › Connectivity and density analyses ↔ Article/Compute_Weighted_centralities.py, lines 442 to 469 · score 0.60 · Benjamini Hochberg FDR, weights · block oscr:b:8W1R5RJW0PYR8-A · Report a mismatch
  3. [3] § Material and method › Neuropsychological assessment and missing data handling ↔ Article/Preprocessing_data/1_Imputations.R, lines 27 to 145 · score 0.59 · imputation model, MICE, variables, imputed, Age, Predictive · block oscr:b:0ZYQTSH8S8QWA-H · Report a mismatch
  4. [4] § Material and method › Network analysis › Multilayer centrality of neuropsychological task nodes ↔ Article/Compute_Weighted_centralities.py, lines 81 to 154 · score 0.57 · weighted closeness centrality, Weighted degree centrality, summing, strength, edges, correlations · block oscr:b:FEK3DQFYN8TH5-Q · Report a mismatch
  5. [5] § Material and method › Network analysis › Connectivity and density analyses ↔ Article/Correlation_Matrix_Creation.py, lines 53 to 105 · score 0.53 · Spearman correlation, layer combination, block, network, hemisphere · block oscr:b:G1C129A1CGSMX-7 · Report a mismatch
  6. [6] § Results › NT-centered multilayer centrality analyses ↔ Article/Compute_Weighted_centralities.py, lines 345 to 397 · score 0.53 · NTi CD, NTi SD, closeness centrality, median, permutation, Weighted · block oscr:b:53XJT2CXHW3DH-W · Report a mismatch
  7. [7] § Material and method › Neuropsychological assessment and missing data handling ↔ Article/Preprocessing_data/4_Reg_Lin_Multiple.py, lines 14 to 63 · score 0.50 · linear regression, age, imputations, scores, hemisphere · block oscr:b:EPFYEQMF0Y0GN-1 · Report a mismatch
  8. [8] § Material and method › Network analysis › Multilayer centrality of neuropsychological task nodes ↔ Article/Interactive_Weighted_centralities_NT_driven.py, lines 20 to 65 · score 0.50 · weighted degree, closeness centrality, cortical damage, interactions, neuropsychological, nodes · block oscr:b:DTT5A6333RS7G-7 · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 765 lines · 30 KB · no license · 3 matches

  1. # Centrality analysis for NT nodes (degree & closeness)
  2. #
  3. # UPDATE 1: adds median-based permutation tests (paired + independent)
  4. # UPDATE 2: computes WEIGHTED centrality measures:
  5. # - Strength (weighted degree = sum of edge weights)
  6. # - Closeness_Weighted (weighted closeness using distance = 1 - r)
  7. #
  8. # UPDATE 3 (YOUR REQUEST): adds ONLY p_perm_mean_FDR (BH-FDR) for:
  9. # - Strength table
  10. # - Closeness_Weighted table
  11. # FDR is applied separately by FAMILY (Within vs Between hemisphere).
  12. #
  13. # PLOTS:
  14. # - Degree_Centrality (unweighted): ylim 0–1
  15. # - Closeness_Centrality (unweighted): ylim 0–1
  16. # - Closeness_Weighted: ylim 0–1.4
  17. # - Strength: ylim 0–4
  18. import numpy as np
  19. import pandas as pd
  20. import networkx as nx
  21. import os
  22. from scipy.stats import wilcoxon, mannwhitneyu
  23. # -------------------------------------------------------------------------
  24. # 0. Paths & Load data
  25. # -------------------------------------------------------------------------
  26. file_path = r'd:\DOCTORANTS\Roxane\Pipeline\hemisphere_matrices_with_both_layers.xlsx'
  27. output_path = r'd:\DOCTORANTS\Roxane\Pipeline\Results'
  28. os.makedirs(output_path, exist_ok=True)
  29. left_raw = pd.read_excel(file_path, sheet_name='Left_Hemisphere')
  30. right_raw = pd.read_excel(file_path, sheet_name='Right_Hemisphere')
  31. threshold = 0.175
  32. hemispheres = {
  33. 'Left': left_raw,
  34. 'Right': right_raw
  35. }
  36. # -------------------------------------------------------------------------
  37. # 1. Helper: preprocess hemisphere matrix
  38. # -------------------------------------------------------------------------
  39. def preprocess_hemisphere_df(df_raw):
  40. """
  41. Expected structure:
  42. - Row 0: column-layer labels (Name='Layer', Layer=NaN, ROI columns: NT/SD/CD)
  43. - Rows 1..: ROIs with columns:
  44. Name (ROI label), Layer ('NT','SD','CD'), then ROI correlation columns.
  45. Returns:
  46. df : DataFrame indexed by ROI Name; columns = 'Layer' + ROI columns.
  47. roi_cols : list of ROI column names (no 'Layer')
  48. """
  49. _col_layers_row = df_raw.iloc[0, :] # unused, kept for pattern
  50. df = df_raw.iloc[1:, :].copy()
  51. df = df.set_index('Name')
  52. roi_cols = [c for c in df.columns if c != 'Layer']
  53. return df, roi_cols
  54. # -------------------------------------------------------------------------
  55. # 2. Helper: summaries and per-NT centralities (unweighted + weighted)
  56. # -------------------------------------------------------------------------
  57. def summarize_vector(values):
  58. values = np.asarray(values, dtype=float)
  59. values = values[np.isfinite(values)]
  60. if len(values) == 0:
  61. return {'median': np.nan, 'mean': np.nan, 'std': np.nan, 'min': np.nan, 'max': np.nan}
  62. return {
  63. 'median': float(np.median(values)),
  64. 'mean': float(np.mean(values)),
  65. 'std': float(np.std(values, ddof=0)),
  66. 'min': float(np.min(values)),
  67. 'max': float(np.max(values)),
  68. }
  69. def compute_nt_centralities_for_combo(hemi_name, df, roi_cols,
  70. use_layers, type_label, layer_label, threshold):
  71. """
  72. Match original logic:
  73. 1. Build full graph G using only nodes whose row-layer is in use_layers.
  74. 2. Add edges between all node pairs with correlation >= threshold.
  75. Store: weight = r, dist = 1 - r
  76. 3. For each NT node:
  77. - Build subgraph of {that NT} + all NON-NT nodes in use_layers.
  78. - Compute:
  79. * Degree_Centrality (unweighted)
  80. * Closeness_Centrality (unweighted)
  81. * Strength (weighted degree = sum of r)
  82. * Closeness_Weighted (weighted closeness using distance='dist')
  83. """
  84. results_per_nt = []
  85. node_layer = df['Layer'].to_dict()
  86. # Only nodes with both rows and columns
  87. all_nodes = [n for n in df.index if n in roi_cols]
  88. # Nodes in chosen layers
  89. use_nodes = [n for n in all_nodes if node_layer.get(n) in use_layers]
  90. nt_nodes = [n for n in use_nodes if node_layer.get(n) == 'NT']
  91. non_nt_nodes = [n for n in use_nodes if node_layer.get(n) != 'NT']
  92. if not nt_nodes or not non_nt_nodes:
  93. return results_per_nt
  94. corr = df.loc[use_nodes, use_nodes].apply(pd.to_numeric, errors='coerce')
  95. G = nx.Graph()
  96. for n in use_nodes:
  97. G.add_node(n, layer=node_layer.get(n))
  98. for i, n1 in enumerate(use_nodes):
  99. for j in range(i + 1, len(use_nodes)):
  100. n2 = use_nodes[j]
  101. w = corr.loc[n1, n2]
  102. if pd.notna(w) and w >= threshold:
  103. w = float(w)
  104. G.add_edge(n1, n2, weight=w, dist=float(1.0 - w))
  105. for nt in nt_nodes:
  106. nodes_to_include = [nt] + non_nt_nodes
  107. subG = G.subgraph(nodes_to_include)
  108. if subG.number_of_nodes() <= 1:
  109. deg_cent = 0.0
  110. clo_cent = 0.0
  111. strength = 0.0
  112. clo_w = 0.0
  113. else:
  114. deg_cent = nx.degree_centrality(subG).get(nt, 0.0)
  115. clo_cent = nx.closeness_centrality(subG).get(nt, 0.0)
  116. strength = float(subG.degree(nt, weight="weight"))
  117. clo_w = nx.closeness_centrality(subG, distance="dist").get(nt, 0.0)
  118. results_per_nt.append({
  119. 'Hemisphere': hemi_name,
  120. 'Type': type_label,
  121. 'Layer': layer_label,
  122. 'Node_ROI': nt,
  123. 'Degree_Centrality': deg_cent,
  124. 'Closeness_Centrality': clo_cent,
  125. 'Strength': strength,
  126. 'Closeness_Weighted': clo_w
  127. })
  128. return results_per_nt
  129. # -------------------------------------------------------------------------
  130. # 3. Run centrality analysis
  131. # -------------------------------------------------------------------------
  132. centrality_nt_rows = []
  133. centrality_combos = [
  134. ('Layer Pairs', 'NTi-SD', ['NT', 'SD']),
  135. ('Layer Pairs', 'NTi-CD', ['NT', 'CD']),
  136. ('All layers', 'NTi-SD-CD', ['NT', 'SD', 'CD']),
  137. ]
  138. for hemi_name, hemi_raw in hemispheres.items():
  139. df, roi_cols = preprocess_hemisphere_df(hemi_raw)
  140. for type_label, layer_label, use_layers in centrality_combos:
  141. rows = compute_nt_centralities_for_combo(
  142. hemi_name=hemi_name,
  143. df=df,
  144. roi_cols=roi_cols,
  145. use_layers=use_layers,
  146. type_label=type_label,
  147. layer_label=layer_label,
  148. threshold=threshold
  149. )
  150. centrality_nt_rows.extend(rows)
  151. centrality_nt_df = pd.DataFrame(centrality_nt_rows)
  152. # -------------------------------------------------------------------------
  153. # 4. Summary tables
  154. # -------------------------------------------------------------------------
  155. def build_summary(df, value_col):
  156. if df.empty:
  157. return pd.DataFrame(columns=['Hemi', 'Type', 'Layer', 'median', 'mean', 'std', 'min', 'max'])
  158. grouped = (
  159. df.groupby(['Hemisphere', 'Type', 'Layer'])[value_col]
  160. .apply(list)
  161. .reset_index(name='values')
  162. )
  163. rows = []
  164. for _, r in grouped.iterrows():
  165. stats = summarize_vector(r['values'])
  166. stats.update({'Hemi': r['Hemisphere'], 'Type': r['Type'], 'Layer': r['Layer']})
  167. rows.append(stats)
  168. return pd.DataFrame(rows)[['Hemi', 'Type', 'Layer', 'median', 'mean', 'std', 'min', 'max']].round(4)
  169. degree_summary_df = build_summary(centrality_nt_df, 'Degree_Centrality')
  170. closeness_summary_df = build_summary(centrality_nt_df, 'Closeness_Centrality')
  171. strength_summary_df = build_summary(centrality_nt_df, 'Strength')
  172. closeness_w_summary_df = build_summary(centrality_nt_df, 'Closeness_Weighted')
  173. # -------------------------------------------------------------------------
  174. # 5. Permutation tests + Cohen's d + bootstrap CI + rank tests
  175. # Mean + median permutation statistics
  176. # -------------------------------------------------------------------------
  177. def permutation_test_paired_mean(x, y, n_perm=10000):
  178. x = np.asarray(x)
  179. y = np.asarray(y)
  180. diffs = x - y
  181. observed = np.mean(diffs)
  182. count = 0
  183. for _ in range(n_perm):
  184. signs = np.random.choice([-1, 1], size=len(diffs))
  185. perm_stat = np.mean(diffs * signs)
  186. if abs(perm_stat) >= abs(observed):
  187. count += 1
  188. return observed, (count + 1) / (n_perm + 1)
  189. def permutation_test_paired_median(x, y, n_perm=10000):
  190. x = np.asarray(x)
  191. y = np.asarray(y)
  192. diffs = x - y
  193. observed = np.median(diffs)
  194. count = 0
  195. for _ in range(n_perm):
  196. signs = np.random.choice([-1, 1], size=len(diffs))
  197. perm_stat = np.median(diffs * signs)
  198. if abs(perm_stat) >= abs(observed):
  199. count += 1
  200. return observed, (count + 1) / (n_perm + 1)
  201. def permutation_test_independent_mean(x, y, n_perm=10000):
  202. x = np.asarray(x)
  203. y = np.asarray(y)
  204. observed = np.mean(x) - np.mean(y)
  205. combined = np.concatenate([x, y])
  206. n_x = len(x)
  207. count = 0
  208. for _ in range(n_perm):
  209. perm = np.random.permutation(combined)
  210. perm_x = perm[:n_x]
  211. perm_y = perm[n_x:]
  212. perm_stat = np.mean(perm_x) - np.mean(perm_y)
  213. if abs(perm_stat) >= abs(observed):
  214. count += 1
  215. return observed, (count + 1) / (n_perm + 1)
  216. def permutation_test_independent_median(x, y, n_perm=10000):
  217. x = np.asarray(x)
  218. y = np.asarray(y)
  219. observed = np.median(x) - np.median(y)
  220. combined = np.concatenate([x, y])
  221. n_x = len(x)
  222. count = 0
  223. for _ in range(n_perm):
  224. perm = np.random.permutation(combined)
  225. perm_x = perm[:n_x]
  226. perm_y = perm[n_x:]
  227. perm_stat = np.median(perm_x) - np.median(perm_y)
  228. if abs(perm_stat) >= abs(observed):
  229. count += 1
  230. return observed, (count + 1) / (n_perm + 1)
  231. def cohens_d_paired(x, y):
  232. x = np.asarray(x)
  233. y = np.asarray(y)
  234. diff = x - y
  235. sd_diff = diff.std(ddof=1)
  236. return 0.0 if sd_diff == 0 else diff.mean() / sd_diff
  237. def cohens_d_independent(x, y):
  238. x = np.asarray(x)
  239. y = np.asarray(y)
  240. nx, ny = len(x), len(y)
  241. if nx < 2 or ny < 2:
  242. return 0.0
  243. sx = x.std(ddof=1)
  244. sy = y.std(ddof=1)
  245. sp = np.sqrt(((nx - 1) * sx**2 + (ny - 1) * sy**2) / (nx + ny - 2))
  246. return 0.0 if sp == 0 else (x.mean() - y.mean()) / sp
  247. def bootstrap_ci_paired(x, y, n_boot=10000, ci=95):
  248. x = np.asarray(x)
  249. y = np.asarray(y)
  250. diffs = x - y
  251. n = len(diffs)
  252. boot_ds = []
  253. for _ in range(n_boot):
  254. sample = np.random.choice(diffs, size=n, replace=True)
  255. sd = sample.std(ddof=1)
  256. d = sample.mean() / sd if sd != 0 else 0.0
  257. boot_ds.append(d)
  258. lower = np.percentile(boot_ds, (100 - ci) / 2)
  259. upper = np.percentile(boot_ds, 100 - (100 - ci) / 2)
  260. return lower, upper
  261. def bootstrap_ci_independent(x, y, n_boot=10000, ci=95):
  262. x = np.asarray(x)
  263. y = np.asarray(y)
  264. nx, ny = len(x), len(y)
  265. boot_ds = []
  266. for _ in range(n_boot):
  267. bx = np.random.choice(x, size=nx, replace=True)
  268. by = np.random.choice(y, size=ny, replace=True)
  269. sx = bx.std(ddof=1)
  270. sy = by.std(ddof=1)
  271. sp = np.sqrt(((nx - 1) * sx**2 + (ny - 1) * sy**2) / (nx + ny - 2)) if (nx + ny - 2) > 0 else 0.0
  272. d = (bx.mean() - by.mean()) / sp if sp != 0 else 0.0
  273. boot_ds.append(d)
  274. lower = np.percentile(boot_ds, (100 - ci) / 2)
  275. upper = np.percentile(boot_ds, 100 - (100 - ci) / 2)
  276. return lower, upper
  277. def get_vals_paired(df, hemi, layer1, layer2, centrality_key):
  278. sub = df[df["Hemisphere"] == hemi]
  279. pivot = sub.pivot_table(index="Node_ROI", columns="Layer", values=centrality_key)
  280. if layer1 not in pivot.columns or layer2 not in pivot.columns:
  281. return np.array([]), np.array([])
  282. pair = pivot[[layer1, layer2]].dropna()
  283. return pair[layer1].values, pair[layer2].values
  284. def get_vals_independent(df, hemi, layer, centrality_key):
  285. sub = df[(df["Hemisphere"] == hemi) & (df["Layer"] == layer)]
  286. return sub[centrality_key].values
  287. within_pairs = [
  288. ("NTi-SD", "NTi-CD"),
  289. ("NTi-SD", "NTi-SD-CD"),
  290. ("NTi-CD", "NTi-SD-CD")
  291. ]
  292. between_layers = ["NTi-SD", "NTi-CD", "NTi-SD-CD"]
  293. all_stats_degree = []
  294. all_stats_closeness = []
  295. all_stats_strength = []
  296. all_stats_closeness_w = []
  297. metrics = [
  298. ("Degree_Centrality", all_stats_degree),
  299. ("Closeness_Centrality", all_stats_closeness),
  300. ("Strength", all_stats_strength),
  301. ("Closeness_Weighted", all_stats_closeness_w),
  302. ]
  303. for centrality_key, results_list in metrics:
  304. # WITHIN HEMISPHERE (PAIRED)
  305. for hemi in ["Left", "Right"]:
  306. for layer1, layer2 in within_pairs:
  307. x, y = get_vals_paired(centrality_nt_df, hemi, layer1, layer2, centrality_key)
  308. if len(x) == 0 or len(y) == 0:
  309. continue
  310. obs_mean, p_perm_mean = permutation_test_paired_mean(x, y)
  311. obs_median, p_perm_median = permutation_test_paired_median(x, y)
  312. d = cohens_d_paired(x, y)
  313. ci_low, ci_high = bootstrap_ci_paired(x, y)
  314. try:
  315. _, w_p = wilcoxon(x, y, zero_method="wilcox")
  316. except Exception:
  317. w_p = np.nan
  318. results_list.append({
  319. "Metric": centrality_key,
  320. "Test Type": "Within Hemisphere (Paired)",
  321. "Hemisphere": hemi,
  322. "Contrast": f"{layer1} vs {layer2}",
  323. "Mean_diff": obs_mean,
  324. "Median_diff": obs_median,
  325. "p_perm_mean": p_perm_mean,
  326. "p_perm_median": p_perm_median,
  327. "Cohen_d": d,
  328. "CI_low": ci_low,
  329. "CI_high": ci_high,
  330. "Wilcoxon_p": w_p
  331. })
  332. # BETWEEN HEMISPHERES (INDEPENDENT)
  333. for layer in between_layers:
  334. x = get_vals_independent(centrality_nt_df, "Left", layer, centrality_key)
  335. y = get_vals_independent(centrality_nt_df, "Right", layer, centrality_key)
  336. if len(x) == 0 or len(y) == 0:
  337. continue
  338. obs_mean, p_perm_mean = permutation_test_independent_mean(x, y)
  339. obs_median, p_perm_median = permutation_test_independent_median(x, y)
  340. d = cohens_d_independent(x, y)
  341. ci_low, ci_high = bootstrap_ci_independent(x, y)
  342. try:
  343. _, u_p = mannwhitneyu(x, y, alternative="two-sided")
  344. except Exception:
  345. u_p = np.nan
  346. results_list.append({
  347. "Metric": centrality_key,
  348. "Test Type": "Between Hemispheres (Independent)",
  349. "Hemisphere": "Left vs Right",
  350. "Contrast": layer,
  351. "Mean_diff": obs_mean,
  352. "Median_diff": obs_median,
  353. "p_perm_mean": p_perm_mean,
  354. "p_perm_median": p_perm_median,
  355. "Cohen_d": d,
  356. "CI_low": ci_low,
  357. "CI_high": ci_high,
  358. "MannWhitney_p": u_p
  359. })
  360. stats_degree_df = pd.DataFrame(all_stats_degree)
  361. stats_closeness_df = pd.DataFrame(all_stats_closeness)
  362. stats_strength_df = pd.DataFrame(all_stats_strength)
  363. stats_closeness_w_df = pd.DataFrame(all_stats_closeness_w)
  364. # -------------------------------------------------------------------------
  365. # 5b. ADD ONLY p_perm_mean_FDR (BH-FDR), for Strength and Closeness_Weighted
  366. # Correction is done separately within each FAMILY (Within vs Between).
  367. # -------------------------------------------------------------------------
  368. def bh_fdr(pvals):
  369. """
  370. Benjamini–Hochberg FDR correction.
  371. Returns q-values with NaNs preserved.
  372. """
  373. pvals = np.asarray(pvals, dtype=float)
  374. qvals = np.full_like(pvals, np.nan, dtype=float)
  375. mask = np.isfinite(pvals)
  376. p = pvals[mask]
  377. m = p.size
  378. if m == 0:
  379. return qvals
  380. order = np.argsort(p)
  381. p_sorted = p[order]
  382. ranks = np.arange(1, m + 1, dtype=float)
  383. q_sorted = p_sorted * m / ranks
  384. # enforce monotonicity
  385. q_sorted = np.minimum.accumulate(q_sorted[::-1])[::-1]
  386. q_sorted = np.clip(q_sorted, 0.0, 1.0)
  387. q = np.empty_like(p_sorted)
  388. q[order] = q_sorted
  389. qvals[mask] = q
  390. return qvals
  391. def add_ppermmean_fdr_by_family(stats_df, family_col="Test Type"):
  392. """
  393. Adds ONLY p_perm_mean_FDR, corrected separately within each family:
  394. - Within Hemisphere (Paired)
  395. - Between Hemispheres (Independent)
  396. """
  397. df = stats_df.copy()
  398. if df.empty or "p_perm_mean" not in df.columns or family_col not in df.columns:
  399. return df
  400. df["p_perm_mean_FDR"] = np.nan
  401. for fam, idx in df.groupby(family_col).groups.items():
  402. df.loc[idx, "p_perm_mean_FDR"] = bh_fdr(df.loc[idx, "p_perm_mean"].values)
  403. return df
  404. # Apply ONLY to Strength and Weighted Closeness (as requested)
  405. stats_strength_df = add_ppermmean_fdr_by_family(stats_strength_df, family_col="Test Type")
  406. stats_closeness_w_df = add_ppermmean_fdr_by_family(stats_closeness_w_df, family_col="Test Type")
  407. # -------------------------------------------------------------------------
  408. # 6. Raincloud plots (Matplotlib-only)
  409. # y-lims: 0–1, 0–1.4, 0–4 as requested
  410. # -------------------------------------------------------------------------
  411. import matplotlib.pyplot as plt
  412. from scipy.stats import gaussian_kde
  413. def full_violin(ax, data, x, color, width=0.35, y_grid=400, y_min=0.0, y_max=1.0):
  414. data = np.asarray(data, dtype=float)
  415. data = data[np.isfinite(data)]
  416. if len(data) < 2:
  417. return
  418. kde = gaussian_kde(data)
  419. y = np.linspace(y_min, y_max, y_grid)
  420. dens = kde(y)
  421. dens = dens / dens.max() * width if dens.max() > 0 else dens
  422. ax.fill_betweenx(y, x - dens, x + dens, color=color, alpha=1.0, linewidth=0, zorder=1)
  423. def boxplot_clean(ax, data, x, width=0.18):
  424. data = np.asarray(data, dtype=float)
  425. data = data[np.isfinite(data)]
  426. if len(data) == 0:
  427. return
  428. ax.boxplot([data], positions=[x], widths=width, vert=True, showfliers=False, patch_artist=True,
  429. boxprops=dict(facecolor="white", edgecolor="black", linewidth=1, alpha=0.80),
  430. medianprops=dict(color="black", linewidth=1),
  431. whiskerprops=dict(color="black", linewidth=1),
  432. capprops=dict(color="black", linewidth=1))
  433. def strip_black(ax, data, x, jitter=0.12, size=40, alpha=0.7):
  434. data = np.asarray(data, dtype=float)
  435. data = data[np.isfinite(data)]
  436. if len(data) == 0:
  437. return
  438. xs = x + np.random.uniform(-jitter, jitter, size=len(data))
  439. ax.scatter(xs, data, s=size, color="black", alpha=alpha, linewidths=0, zorder=10)
  440. def clean_axes_keep_ticks(ax, tick_label_size=18, tick_size=5):
  441. for spine in ax.spines.values():
  442. spine.set_visible(False)
  443. ax.grid(False)
  444. ax.tick_params(axis="both", which="both", length=tick_size, width=1, color="black", labelsize=tick_label_size)
  445. def raincloud_two_groups(ax, a, b, label_a, label_b,
  446. x_positions=(1.0, 2.0),
  447. layer_a=None, layer_b=None,
  448. tick_label_size=18,
  449. y_min=0.0, y_max=1.0):
  450. a = np.asarray(a, dtype=float)
  451. b = np.asarray(b, dtype=float)
  452. xa, xb = x_positions
  453. color_map = {"SD": "green", "CD": "#ad4c4c"}
  454. full_violin(ax, a, xa, color=color_map.get(layer_a, "gray"), y_min=y_min, y_max=y_max)
  455. full_violin(ax, b, xb, color=color_map.get(layer_b, "gray"), y_min=y_min, y_max=y_max)
  456. boxplot_clean(ax, a, xa)
  457. boxplot_clean(ax, b, xb)
  458. strip_black(ax, a, xa)
  459. strip_black(ax, b, xb)
  460. ax.set_xticks([xa, xb])
  461. ax.set_xticklabels([label_a, label_b], fontsize=tick_label_size)
  462. ax.set_ylim(y_min, y_max)
  463. ax.tick_params(axis="y", labelsize=tick_label_size)
  464. clean_axes_keep_ticks(ax, tick_label_size=tick_label_size)
  465. def save_raincloud(fig, out_png, out_pdf=None, dpi=300):
  466. fig.tight_layout()
  467. fig.savefig(out_png, dpi=dpi, bbox_inches="tight")
  468. if out_pdf is not None:
  469. fig.savefig(out_pdf, bbox_inches="tight")
  470. plt.close(fig)
  471. # ----- Unweighted closeness (0–1) -----
  472. xL, yL = get_vals_paired(centrality_nt_df, "Left", "NTi-SD", "NTi-CD", "Closeness_Centrality")
  473. xR, yR = get_vals_paired(centrality_nt_df, "Right", "NTi-SD", "NTi-CD", "Closeness_Centrality")
  474. L_SD = get_vals_independent(centrality_nt_df, "Left", "NTi-SD", "Closeness_Centrality")
  475. R_SD = get_vals_independent(centrality_nt_df, "Right", "NTi-SD", "Closeness_Centrality")
  476. L_CD = get_vals_independent(centrality_nt_df, "Left", "NTi-CD", "Closeness_Centrality")
  477. R_CD = get_vals_independent(centrality_nt_df, "Right", "NTi-CD", "Closeness_Centrality")
  478. if len(xL) > 0 and len(yL) > 0:
  479. fig, ax = plt.subplots(figsize=(6, 5))
  480. raincloud_two_groups(ax, xL, yL, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=1.0)
  481. save_raincloud(fig,
  482. os.path.join(output_path, "Raincloud_Closeness_Left_NTi-SD_vs_NTi-CD.png"),
  483. os.path.join(output_path, "Raincloud_Closeness_Left_NTi-SD_vs_NTi-CD.pdf"))
  484. if len(xR) > 0 and len(yR) > 0:
  485. fig, ax = plt.subplots(figsize=(6, 5))
  486. raincloud_two_groups(ax, xR, yR, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=1.0)
  487. save_raincloud(fig,
  488. os.path.join(output_path, "Raincloud_Closeness_Right_NTi-SD_vs_NTi-CD.png"),
  489. os.path.join(output_path, "Raincloud_Closeness_Right_NTi-SD_vs_NTi-CD.pdf"))
  490. if len(L_SD) > 0 and len(R_SD) > 0:
  491. fig, ax = plt.subplots(figsize=(6, 5))
  492. raincloud_two_groups(ax, L_SD, R_SD, "Left", "Right", layer_a="SD", layer_b="SD", y_min=0.0, y_max=1.0)
  493. save_raincloud(fig,
  494. os.path.join(output_path, "Raincloud_Closeness_Left_vs_Right_NTi-SD.png"),
  495. os.path.join(output_path, "Raincloud_Closeness_Left_vs_Right_NTi-SD.pdf"))
  496. if len(L_CD) > 0 and len(R_CD) > 0:
  497. fig, ax = plt.subplots(figsize=(6, 5))
  498. raincloud_two_groups(ax, L_CD, R_CD, "Left", "Right", layer_a="CD", layer_b="CD", y_min=0.0, y_max=1.0)
  499. save_raincloud(fig,
  500. os.path.join(output_path, "Raincloud_Closeness_Left_vs_Right_NTi-CD.png"),
  501. os.path.join(output_path, "Raincloud_Closeness_Left_vs_Right_NTi-CD.pdf"))
  502. print("Closeness (unweighted) raincloud plots saved to:", output_path)
  503. # ----- Unweighted degree (0–1) -----
  504. xL_deg, yL_deg = get_vals_paired(centrality_nt_df, "Left", "NTi-SD", "NTi-CD", "Degree_Centrality")
  505. xR_deg, yR_deg = get_vals_paired(centrality_nt_df, "Right", "NTi-SD", "NTi-CD", "Degree_Centrality")
  506. L_SD_deg = get_vals_independent(centrality_nt_df, "Left", "NTi-SD", "Degree_Centrality")
  507. R_SD_deg = get_vals_independent(centrality_nt_df, "Right", "NTi-SD", "Degree_Centrality")
  508. L_CD_deg = get_vals_independent(centrality_nt_df, "Left", "NTi-CD", "Degree_Centrality")
  509. R_CD_deg = get_vals_independent(centrality_nt_df, "Right", "NTi-CD", "Degree_Centrality")
  510. if len(xL_deg) > 0 and len(yL_deg) > 0:
  511. fig, ax = plt.subplots(figsize=(6, 5))
  512. raincloud_two_groups(ax, xL_deg, yL_deg, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=1.0)
  513. save_raincloud(fig,
  514. os.path.join(output_path, "Raincloud_Degree_Left_NTi-SD_vs_NTi-CD.png"),
  515. os.path.join(output_path, "Raincloud_Degree_Left_NTi-SD_vs_NTi-CD.pdf"))
  516. if len(xR_deg) > 0 and len(yR_deg) > 0:
  517. fig, ax = plt.subplots(figsize=(6, 5))
  518. raincloud_two_groups(ax, xR_deg, yR_deg, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=1.0)
  519. save_raincloud(fig,
  520. os.path.join(output_path, "Raincloud_Degree_Right_NTi-SD_vs_NTi-CD.png"),
  521. os.path.join(output_path, "Raincloud_Degree_Right_NTi-SD_vs_NTi-CD.pdf"))
  522. if len(L_SD_deg) > 0 and len(R_SD_deg) > 0:
  523. fig, ax = plt.subplots(figsize=(6, 5))
  524. raincloud_two_groups(ax, L_SD_deg, R_SD_deg, "Left", "Right", layer_a="SD", layer_b="SD", y_min=0.0, y_max=1.0)
  525. save_raincloud(fig,
  526. os.path.join(output_path, "Raincloud_Degree_Left_vs_Right_NTi-SD.png"),
  527. os.path.join(output_path, "Raincloud_Degree_Left_vs_Right_NTi-SD.pdf"))
  528. if len(L_CD_deg) > 0 and len(R_CD_deg) > 0:
  529. fig, ax = plt.subplots(figsize=(6, 5))
  530. raincloud_two_groups(ax, L_CD_deg, R_CD_deg, "Left", "Right", layer_a="CD", layer_b="CD", y_min=0.0, y_max=1.0)
  531. save_raincloud(fig,
  532. os.path.join(output_path, "Raincloud_Degree_Left_vs_Right_NTi-CD.png"),
  533. os.path.join(output_path, "Raincloud_Degree_Left_vs_Right_NTi-CD.pdf"))
  534. print("Degree (unweighted) raincloud plots saved to:", output_path)
  535. # ----- Weighted closeness (0–1.4) -----
  536. xL_cw, yL_cw = get_vals_paired(centrality_nt_df, "Left", "NTi-SD", "NTi-CD", "Closeness_Weighted")
  537. xR_cw, yR_cw = get_vals_paired(centrality_nt_df, "Right", "NTi-SD", "NTi-CD", "Closeness_Weighted")
  538. L_SD_cw = get_vals_independent(centrality_nt_df, "Left", "NTi-SD", "Closeness_Weighted")
  539. R_SD_cw = get_vals_independent(centrality_nt_df, "Right", "NTi-SD", "Closeness_Weighted")
  540. L_CD_cw = get_vals_independent(centrality_nt_df, "Left", "NTi-CD", "Closeness_Weighted")
  541. R_CD_cw = get_vals_independent(centrality_nt_df, "Right", "NTi-CD", "Closeness_Weighted")
  542. if len(xL_cw) > 0 and len(yL_cw) > 0:
  543. fig, ax = plt.subplots(figsize=(6, 5))
  544. raincloud_two_groups(ax, xL_cw, yL_cw, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=1.4)
  545. save_raincloud(fig,
  546. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_NTi-SD_vs_NTi-CD.png"),
  547. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_NTi-SD_vs_NTi-CD.pdf"))
  548. if len(xR_cw) > 0 and len(yR_cw) > 0:
  549. fig, ax = plt.subplots(figsize=(6, 5))
  550. raincloud_two_groups(ax, xR_cw, yR_cw, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=1.4)
  551. save_raincloud(fig,
  552. os.path.join(output_path, "Raincloud_ClosenessWeighted_Right_NTi-SD_vs_NTi-CD.png"),
  553. os.path.join(output_path, "Raincloud_ClosenessWeighted_Right_NTi-SD_vs_NTi-CD.pdf"))
  554. if len(L_SD_cw) > 0 and len(R_SD_cw) > 0:
  555. fig, ax = plt.subplots(figsize=(6, 5))
  556. raincloud_two_groups(ax, L_SD_cw, R_SD_cw, "Left", "Right", layer_a="SD", layer_b="SD", y_min=0.0, y_max=1.4)
  557. save_raincloud(fig,
  558. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_vs_Right_NTi-SD.png"),
  559. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_vs_Right_NTi-SD.pdf"))
  560. if len(L_CD_cw) > 0 and len(R_CD_cw) > 0:
  561. fig, ax = plt.subplots(figsize=(6, 5))
  562. raincloud_two_groups(ax, L_CD_cw, R_CD_cw, "Left", "Right", layer_a="CD", layer_b="CD", y_min=0.0, y_max=1.4)
  563. save_raincloud(fig,
  564. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_vs_Right_NTi-CD.png"),
  565. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_vs_Right_NTi-CD.pdf"))
  566. print("Closeness (weighted) raincloud plots saved to:", output_path)
  567. # ----- Strength (0–4) -----
  568. xL_s, yL_s = get_vals_paired(centrality_nt_df, "Left", "NTi-SD", "NTi-CD", "Strength")
  569. xR_s, yR_s = get_vals_paired(centrality_nt_df, "Right", "NTi-SD", "NTi-CD", "Strength")
  570. L_SD_s = get_vals_independent(centrality_nt_df, "Left", "NTi-SD", "Strength")
  571. R_SD_s = get_vals_independent(centrality_nt_df, "Right", "NTi-SD", "Strength")
  572. L_CD_s = get_vals_independent(centrality_nt_df, "Left", "NTi-CD", "Strength")
  573. R_CD_s = get_vals_independent(centrality_nt_df, "Right", "NTi-CD", "Strength")
  574. if len(xL_s) > 0 and len(yL_s) > 0:
  575. fig, ax = plt.subplots(figsize=(6, 5))
  576. raincloud_two_groups(ax, xL_s, yL_s, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=4.0)
  577. save_raincloud(fig,
  578. os.path.join(output_path, "Raincloud_Strength_Left_NTi-SD_vs_NTi-CD.png"),
  579. os.path.join(output_path, "Raincloud_Strength_Left_NTi-SD_vs_NTi-CD.pdf"))
  580. if len(xR_s) > 0 and len(yR_s) > 0:
  581. fig, ax = plt.subplots(figsize=(6, 5))
  582. raincloud_two_groups(ax, xR_s, yR_s, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=4.0)
  583. save_raincloud(fig,
  584. os.path.join(output_path, "Raincloud_Strength_Right_NTi-SD_vs_NTi-CD.png"),
  585. os.path.join(output_path, "Raincloud_Strength_Right_NTi-SD_vs_NTi-CD.pdf"))
  586. if len(L_SD_s) > 0 and len(R_SD_s) > 0:
  587. fig, ax = plt.subplots(figsize=(6, 5))
  588. raincloud_two_groups(ax, L_SD_s, R_SD_s, "Left", "Right", layer_a="SD", layer_b="SD", y_min=0.0, y_max=4.0)
  589. save_raincloud(fig,
  590. os.path.join(output_path, "Raincloud_Strength_Left_vs_Right_NTi-SD.png"),
  591. os.path.join(output_path, "Raincloud_Strength_Left_vs_Right_NTi-SD.pdf"))
  592. if len(L_CD_s) > 0 and len(R_CD_s) > 0:
  593. fig, ax = plt.subplots(figsize=(6, 5))
  594. raincloud_two_groups(ax, L_CD_s, R_CD_s, "Left", "Right", layer_a="CD", layer_b="CD", y_min=0.0, y_max=4.0)
  595. save_raincloud(fig,
  596. os.path.join(output_path, "Raincloud_Strength_Left_vs_Right_NTi-CD.png"),
  597. os.path.join(output_path, "Raincloud_Strength_Left_vs_Right_NTi-CD.pdf"))
  598. print("Strength raincloud plots saved to:", output_path)
  599. # -------------------------------------------------------------------------
  600. # 7. Save results
  601. # -------------------------------------------------------------------------
  602. centrality_per_nt_file = os.path.join(output_path, 'NT_centrality_per_node_unweighted_and_weighted.xlsx')
  603. degree_summary_file = os.path.join(output_path, 'NT_degree_summary_sup14_style.xlsx')
  604. closeness_summary_file = os.path.join(output_path, 'NT_closeness_summary_sup15_style.xlsx')
  605. strength_summary_file = os.path.join(output_path, 'NT_strength_summary.xlsx')
  606. closeness_w_summary_file = os.path.join(output_path, 'NT_closeness_weighted_summary.xlsx')
  607. perm_degree_file = os.path.join(output_path, 'NT_permutation_stats_degree_mean_median.xlsx')
  608. perm_closeness_file = os.path.join(output_path, 'NT_permutation_stats_closeness_mean_median.xlsx')
  609. perm_strength_file = os.path.join(output_path, 'NT_permutation_stats_strength_mean_median.xlsx')
  610. perm_closeness_w_file = os.path.join(output_path, 'NT_permutation_stats_closeness_weighted_mean_median.xlsx')
  611. centrality_nt_df.to_excel(centrality_per_nt_file, index=False)
  612. degree_summary_df.to_excel(degree_summary_file, index=False)
  613. closeness_summary_df.to_excel(closeness_summary_file, index=False)
  614. strength_summary_df.to_excel(strength_summary_file, index=False)
  615. closeness_w_summary_df.to_excel(closeness_w_summary_file, index=False)
  616. # Degree/Closeness stats unchanged
  617. stats_degree_df.to_excel(perm_degree_file, index=False)
  618. stats_closeness_df.to_excel(perm_closeness_file, index=False)
  619. # Strength + Weighted Closeness stats now include p_perm_mean_FDR
  620. stats_strength_df.to_excel(perm_strength_file, index=False)
  621. stats_closeness_w_df.to_excel(perm_closeness_w_file, index=False)
  622. print("\nPer-NT centrality values saved to:", centrality_per_nt_file)
  623. print("\nAll results saved to:", output_path)
  624. print("Stats files:")
  625. print(perm_degree_file)
  626. print(perm_closeness_file)
  627. print(perm_strength_file)
  628. print(perm_closeness_w_file)

Compute_Weighted_centralities.py at commit 90d3dfe, no license · at the source

Overview

Authors: Roxane Nave1, Sam Ng1,2, Sylvie Moritz-Gasser1,2,3, Lorelei Berger3, Emmanuel Mandonnet4,5,6, Hugues Duffau1,2, Guillaume Herbet2,3,7,8
ORCID iDs: Guillaume Herbet
  1. Institute of Functional Genomics, University of Montpellier, INSERM, CNRS, 141 rue de la Cardonille, 34091 Montpellier, France
  2. Department of Neurosurgery, Gui de Chauliac Hospital, Montpellier University Medical Center, 80 Av Augustin Fliche, 34295 Montpellier, France
  3. Praxiling laboratory, UMR 5267, CNRS, Paul Valéry – Montpellier 3 University, rue de Mende, 34090 Montpellier, France
  4. Department of neurosurgery, Lariboisière Hospital, Paris, France
  5. Frontlab, Paris Brain Institute, CNRS UMR 7225, INSERM U1127, Paris, France
  6. Université de Paris Cité, Paris, France
  7. University of Montpellier, Department of Medicine, Campus ADV, 641, avenue du Doyen Gaston Guiraud, 34090 Montpellier, France
  8. Institut Universitaire de France, Paris, France
Journal: NeuroImage. Clinical, volume 51, article 104052
Dates: received 18 March 2026; accepted 26 August 2026; published online 26 August 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.nicl.2026.104052 · PMID 42669223 · PMCID PMC13551937 · OpenAlex W7204252405
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: structural MRI / diffusion (modality), human (organism), other condition (population), clinical / translational (subfield)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Graphs, fMRI & imaging
Keywords: Lesion–symptom mapping, Multilayer network analysis, Structural disconnection, Cognitive deficits, Low-grade glioma
MeSH: Brain*, Brain Mapping*, Brain Neoplasms*, Glioma*, Nerve Net*, Adult, Female, Humans, Magnetic Resonance Imaging, Male, Middle Aged, Neural Pathways, Neuropsychological Tests, White Matter (* major topic)
Topic: Mental Health Research Topics (Experimental and Cognitive Psychology, Psychology), according to OpenAlex
Citations: not cited yet (Europe PMC); 47 references in the paper

Abstract

Lesion–symptom mapping is widely used to identify causal relationships between brain structures and behaviour, and has played a central role in neuropsychologically informed network models of cognition. However, even recent approaches remain constrained by a one-to-one mapping framework, which oversimplifies the complex relationships between network-level damage and cognitive deficits. In addition, the non-orthogonality of cortical and white matter damage makes it difficult to disentangle their distinct contributions. Here, we used graph-based multilayer network analysis to address these limitations and evaluate clinical relevance. Using neuroanatomical and longitudinal neuropsychological data from 252 patients who underwent awake neurosurgery for low-grade glioma, we constructed interactive, three-layer networks for each hemisphere. Layer 1 comprised neuropsychological tasks (NT), layer 2 structural disconnections (SD), and layer 3 cortical damage (CD). Nodes represented tasks, white matter tracts, and cortical parcels, respectively, whereas within-layer edges captured correlations in performance or co-occurring damage patterns. Multilayer community detection identified domain- and hemisphere-specific brain–behaviour motifs linking executive, language, and spatial functions to distinct combinations of cortical and white matter disruption, a pattern confirmed by two spatial embedding approaches. Centrality analyses revealed a continuum of mapping relationships, ranging from one-to-one to one-to-many associations, indicating that tasks such as verbal fluency are better explained by multiple disconnection mechanisms. Additional analyses uncovered many-to-one and many-to-many relationships and highlighted tracts and cortical regions with domain-general relevance. Together, these findings support a neurobiologically grounded, network-oriented account of how structural brain damage gives rise to cognitive deficits, with implications for clinical care.

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

jdax34/scripts_article

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 90d3dfebce8d4a2b5d80026f09c1f5c80e6188f8, 15 July 2026
Languages: Python (9), R (1)
Size: 12 files, 10 scripts
Software Heritage: not archived
Found in: the text, “Multilayer network construction and visualizatio”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (9 files), NumPy (7 files), Matplotlib (4 files), NetworkX (4 files), scikit-learn (4 files), broom (1 file), ggplot2 (1 file), SciPy (1 file), seaborn (1 file), tidyverse (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
11 files

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;
  • 10 scripts, each with its path and the digest of its content;
  • 8 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 authors do not have permission to share data.

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, pages, dates, 7 authors, 5 keywords, 14 MeSH terms, 45 references.

Cite

This paper

Nave, R., Ng, S., Moritz-Gasser, S., Berger, L., Mandonnet, E., Duffau, H., & Herbet, G. (2026). Beyond one-to-one mappings: Modelling distributed lesion-symptom relationships with multilayer networks. NeuroImage. Clinical, 51, 104052. https://doi.org/10.1016/j.nicl.2026.104052

BibTeX

@article{nave2026beyond,
author = {Nave, Roxane and Ng, Sam and Moritz-Gasser, Sylvie and Berger, Lorelei and Mandonnet, Emmanuel and Duffau, Hugues and Herbet, Guillaume},
title = {{Beyond one-to-one mappings: Modelling distributed lesion-symptom relationships with multilayer networks}},
journal = {NeuroImage. Clinical},
year = {2026},
month = aug,
volume = {51},
pages = {104052},
publisher = {Elsevier},
issn = {2213-1582},
doi = {10.1016/j.nicl.2026.104052},
url = {https://doi.org/10.1016/j.nicl.2026.104052},
pmid = {42669223},
pmcid = {PMC13551937}
}

RIS

TY - JOUR
AU - Nave, Roxane
AU - Ng, Sam
AU - Moritz-Gasser, Sylvie
AU - Berger, Lorelei
AU - Mandonnet, Emmanuel
AU - Duffau, Hugues
AU - Herbet, Guillaume
TI - Beyond one-to-one mappings: Modelling distributed lesion-symptom relationships with multilayer networks
T2 - NeuroImage. Clinical
J2 - Neuroimage Clin
PY - 2026
DA - 2026/08/26
VL - 51
SP - 104052
SN - 2213-1582
PB - Elsevier
DO - 10.1016/j.nicl.2026.104052
UR - https://doi.org/10.1016/j.nicl.2026.104052
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.nicl.2026.104052",
"type": "article-journal",
"title": "Beyond one-to-one mappings: Modelling distributed lesion-symptom relationships with multilayer networks",
"container-title": "NeuroImage. Clinical",
"author": [
{
"family": "Nave",
"given": "Roxane"
},
{
"family": "Ng",
"given": "Sam"
},
{
"family": "Moritz-Gasser",
"given": "Sylvie"
},
{
"family": "Berger",
"given": "Lorelei"
},
{
"family": "Mandonnet",
"given": "Emmanuel"
},
{
"family": "Duffau",
"given": "Hugues"
},
{
"family": "Herbet",
"given": "Guillaume"
}
],
"container-title-short": "Neuroimage Clin",
"volume": "51",
"page": "104052",
"DOI": "10.1016/j.nicl.2026.104052",
"PMID": "42669223",
"PMCID": "PMC13551937",
"ISSN": "2213-1582",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.nicl.2026.104052",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
26
]
]
}
}

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-022-28030-3 [code]
Contribution of the medial eye field network to the voluntary deployment of visuospatial attention.
Journal: Nature communications
In common: other condition, 6 references, author Guillaume Herbet
[2] doi:10.1002/hbm.70115 [code]
Iowa Brain-Behavior Modeling Toolkit: An Open-Source MATLAB Tool for Inferential and Predictive Modeling of Imaging-Behavior and Lesion-Deficit Relationships.
Journal: Human brain mapping
In common: 10 references
[3] doi:10.1093/braincomms/fcae254 [code]
Data-driven biomarkers better associate with stroke motor outcomes than theory-based biomarkers.
Journal: Brain communications
In common: seaborn, scikit-learn, pandas, 3 other tools, structural MRI / diffusion, clinical / translational, 5 references
[4] doi:10.1002/hbm.26279 [code]
The central role of the left inferior longitudinal fasciculus in the face-name retrieval network.
Journal: Human brain mapping
In common: other condition, 4 references, author Guillaume Herbet
[5] doi:10.1007/s00429-025-03015-2 [code]
A probabilistic map of motor and cognitive functions: a meta-analysis of 4325 stimulation sites.
Journal: Brain structure & function
In common: pandas, Matplotlib, NumPy, 6 references
[6] doi:10.3389/fnins.2025.1409107 [code]
Analysis of clinical anatomical correlates of motor deficits in stroke by multivariate lesion inference based on game theory.
Journal: Frontiers in neuroscience
In common: scikit-learn, pandas, SciPy, 2 other tools, 5 references
[7] doi:10.1093/braincomms/fcaf218 [code]
Determinants of brain network resilience after stroke.
Journal: Brain communications
In common: NetworkX, seaborn, tidyverse, 5 other tools, 3 references
[8] doi:10.1093/braincomms/fcaf477 [code]
From acute neglect to chronic constructional deficits: parietotemporal contributions to long-term post-stroke impairments.
Journal: Brain communications
In common: seaborn, scikit-learn, pandas, 3 other tools, clinical / translational, 4 references
[9] doi:10.1038/s42003-023-04733-1 [code]
Bayesian stroke modeling details sex biases in the white matter substrates of aphasia.
Journal: Communications biology
In common: seaborn, scikit-learn, pandas, 3 other tools, clinical / translational, 4 references
[10] doi:10.1093/neuonc/noaf234 [code]
A non-local diffusion magnetic resonance imaging tract density biomarker to stratify, predict, and interpret survival rates in human glioblastoma.
Journal: Neuro-oncology
In common: NetworkX, seaborn, scikit-learn, 4 other tools, structural MRI / diffusion, clinical / translational, other condition, 2 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1016/j.nicl.2026.104052.svg)](https://openscicode.org/badge/doi/10.1016/j.nicl.2026.104052)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1016/j.nicl.2026.104052.svg
   :target: https://openscicode.org/badge/doi/10.1016/j.nicl.2026.104052
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1016/j.nicl.2026.104052"><img src="https://openscicode.org/badge/doi/10.1016/j.nicl.2026.104052.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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