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.

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

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 · 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
  19. import numpy as np
  20. import pandas as pd
  21. import networkx as nx
  22. import os
  23. from scipy.stats import wilcoxon, mannwhitneyu
  25. # -------------------------------------------------------------------------
  26. # 0. Paths & Load data
  27. # -------------------------------------------------------------------------
  29. file_path = r'd:\DOCTORANTS\Roxane\Pipeline\hemisphere_matrices_with_both_layers.xlsx'
  31. output_path = r'd:\DOCTORANTS\Roxane\Pipeline\Results'
  32. os.makedirs(output_path, exist_ok=True)
  34. left_raw = pd.read_excel(file_path, sheet_name='Left_Hemisphere')
  35. right_raw = pd.read_excel(file_path, sheet_name='Right_Hemisphere')
  37. threshold = 0.175
  38. hemispheres = {
  39. 'Left': left_raw,
  40. 'Right': right_raw
  41. }
  43. # -------------------------------------------------------------------------
  44. # 1. Helper: preprocess hemisphere matrix
  45. # -------------------------------------------------------------------------
  47. def preprocess_hemisphere_df(df_raw):
  48. """
  49. Expected structure:
  50. - Row 0: column-layer labels (Name='Layer', Layer=NaN, ROI columns: NT/SD/CD)
  51. - Rows 1..: ROIs with columns:
  52. Name (ROI label), Layer ('NT','SD','CD'), then ROI correlation columns.
  54. Returns:
  55. df : DataFrame indexed by ROI Name; columns = 'Layer' + ROI columns.
  56. roi_cols : list of ROI column names (no 'Layer')
  57. """
  58. _col_layers_row = df_raw.iloc[0, :] # unused, kept for pattern
  59. df = df_raw.iloc[1:, :].copy()
  60. df = df.set_index('Name')
  61. roi_cols = [c for c in df.columns if c != 'Layer']
  62. return df, roi_cols
  64. # -------------------------------------------------------------------------
  65. # 2. Helper: summaries and per-NT centralities (unweighted + weighted)
  66. # -------------------------------------------------------------------------
  68. def summarize_vector(values):
  69. values = np.asarray(values, dtype=float)
  70. values = values[np.isfinite(values)]
  71. if len(values) == 0:
  72. return {'median': np.nan, 'mean': np.nan, 'std': np.nan, 'min': np.nan, 'max': np.nan}
  73. return {
  74. 'median': float(np.median(values)),
  75. 'mean': float(np.mean(values)),
  76. 'std': float(np.std(values, ddof=0)),
  77. 'min': float(np.min(values)),
  78. 'max': float(np.max(values)),
  79. }
  81. def compute_nt_centralities_for_combo(hemi_name, df, roi_cols,
  82. use_layers, type_label, layer_label, threshold):
  83. """
  84. Match original logic:
  86. 1. Build full graph G using only nodes whose row-layer is in use_layers.
  87. 2. Add edges between all node pairs with correlation >= threshold.
  88. Store: weight = r, dist = 1 - r
  89. 3. For each NT node:
  90. - Build subgraph of {that NT} + all NON-NT nodes in use_layers.
  91. - Compute:
  92. * Degree_Centrality (unweighted)
  93. * Closeness_Centrality (unweighted)
  94. * Strength (weighted degree = sum of r)
  95. * Closeness_Weighted (weighted closeness using distance='dist')
  96. """
  97. results_per_nt = []
  99. node_layer = df['Layer'].to_dict()
  101. # Only nodes with both rows and columns
  102. all_nodes = [n for n in df.index if n in roi_cols]
  104. # Nodes in chosen layers
  105. use_nodes = [n for n in all_nodes if node_layer.get(n) in use_layers]
  107. nt_nodes = [n for n in use_nodes if node_layer.get(n) == 'NT']
  108. non_nt_nodes = [n for n in use_nodes if node_layer.get(n) != 'NT']
  110. if not nt_nodes or not non_nt_nodes:
  111. return results_per_nt
  113. corr = df.loc[use_nodes, use_nodes].apply(pd.to_numeric, errors='coerce')
  115. G = nx.Graph()
  116. for n in use_nodes:
  117. G.add_node(n, layer=node_layer.get(n))
  119. for i, n1 in enumerate(use_nodes):
  120. for j in range(i + 1, len(use_nodes)):
  121. n2 = use_nodes[j]
  122. w = corr.loc[n1, n2]
  123. if pd.notna(w) and w >= threshold:
  124. w = float(w)
  125. G.add_edge(n1, n2, weight=w, dist=float(1.0 - w))
  127. for nt in nt_nodes:
  128. nodes_to_include = [nt] + non_nt_nodes
  129. subG = G.subgraph(nodes_to_include)
  131. if subG.number_of_nodes() <= 1:
  132. deg_cent = 0.0
  133. clo_cent = 0.0
  134. strength = 0.0
  135. clo_w = 0.0
  136. else:
  137. deg_cent = nx.degree_centrality(subG).get(nt, 0.0)
  138. clo_cent = nx.closeness_centrality(subG).get(nt, 0.0)
  140. strength = float(subG.degree(nt, weight="weight"))
  141. clo_w = nx.closeness_centrality(subG, distance="dist").get(nt, 0.0)
  143. results_per_nt.append({
  144. 'Hemisphere': hemi_name,
  145. 'Type': type_label,
  146. 'Layer': layer_label,
  147. 'Node_ROI': nt,
  148. 'Degree_Centrality': deg_cent,
  149. 'Closeness_Centrality': clo_cent,
  150. 'Strength': strength,
  151. 'Closeness_Weighted': clo_w
  152. })
  154. return results_per_nt
  156. # -------------------------------------------------------------------------
  157. # 3. Run centrality analysis
  158. # -------------------------------------------------------------------------
  160. centrality_nt_rows = []
  162. centrality_combos = [
  163. ('Layer Pairs', 'NTi-SD', ['NT', 'SD']),
  164. ('Layer Pairs', 'NTi-CD', ['NT', 'CD']),
  165. ('All layers', 'NTi-SD-CD', ['NT', 'SD', 'CD']),
  166. ]
  168. for hemi_name, hemi_raw in hemispheres.items():
  169. df, roi_cols = preprocess_hemisphere_df(hemi_raw)
  171. for type_label, layer_label, use_layers in centrality_combos:
  172. rows = compute_nt_centralities_for_combo(
  173. hemi_name=hemi_name,
  174. df=df,
  175. roi_cols=roi_cols,
  176. use_layers=use_layers,
  177. type_label=type_label,
  178. layer_label=layer_label,
  179. threshold=threshold
  180. )
  181. centrality_nt_rows.extend(rows)
  183. centrality_nt_df = pd.DataFrame(centrality_nt_rows)
  185. # -------------------------------------------------------------------------
  186. # 4. Summary tables
  187. # -------------------------------------------------------------------------
  189. def build_summary(df, value_col):
  190. if df.empty:
  191. return pd.DataFrame(columns=['Hemi', 'Type', 'Layer', 'median', 'mean', 'std', 'min', 'max'])
  193. grouped = (
  194. df.groupby(['Hemisphere', 'Type', 'Layer'])[value_col]
  195. .apply(list)
  196. .reset_index(name='values')
  197. )
  198. rows = []
  199. for _, r in grouped.iterrows():
  200. stats = summarize_vector(r['values'])
  201. stats.update({'Hemi': r['Hemisphere'], 'Type': r['Type'], 'Layer': r['Layer']})
  202. rows.append(stats)
  203. return pd.DataFrame(rows)[['Hemi', 'Type', 'Layer', 'median', 'mean', 'std', 'min', 'max']].round(4)
  205. degree_summary_df = build_summary(centrality_nt_df, 'Degree_Centrality')
  206. closeness_summary_df = build_summary(centrality_nt_df, 'Closeness_Centrality')
  207. strength_summary_df = build_summary(centrality_nt_df, 'Strength')
  208. closeness_w_summary_df = build_summary(centrality_nt_df, 'Closeness_Weighted')
  210. # -------------------------------------------------------------------------
  211. # 5. Permutation tests + Cohen's d + bootstrap CI + rank tests
  212. # Mean + median permutation statistics
  213. # -------------------------------------------------------------------------
  215. def permutation_test_paired_mean(x, y, n_perm=10000):
  216. x = np.asarray(x)
  217. y = np.asarray(y)
  218. diffs = x - y
  219. observed = np.mean(diffs)
  221. count = 0
  222. for _ in range(n_perm):
  223. signs = np.random.choice([-1, 1], size=len(diffs))
  224. perm_stat = np.mean(diffs * signs)
  225. if abs(perm_stat) >= abs(observed):
  226. count += 1
  227. return observed, (count + 1) / (n_perm + 1)
  229. def permutation_test_paired_median(x, y, n_perm=10000):
  230. x = np.asarray(x)
  231. y = np.asarray(y)
  232. diffs = x - y
  233. observed = np.median(diffs)
  235. count = 0
  236. for _ in range(n_perm):
  237. signs = np.random.choice([-1, 1], size=len(diffs))
  238. perm_stat = np.median(diffs * signs)
  239. if abs(perm_stat) >= abs(observed):
  240. count += 1
  241. return observed, (count + 1) / (n_perm + 1)
  243. def permutation_test_independent_mean(x, y, n_perm=10000):
  244. x = np.asarray(x)
  245. y = np.asarray(y)
  246. observed = np.mean(x) - np.mean(y)
  248. combined = np.concatenate([x, y])
  249. n_x = len(x)
  251. count = 0
  252. for _ in range(n_perm):
  253. perm = np.random.permutation(combined)
  254. perm_x = perm[:n_x]
  255. perm_y = perm[n_x:]
  256. perm_stat = np.mean(perm_x) - np.mean(perm_y)
  257. if abs(perm_stat) >= abs(observed):
  258. count += 1
  259. return observed, (count + 1) / (n_perm + 1)
  261. def permutation_test_independent_median(x, y, n_perm=10000):
  262. x = np.asarray(x)
  263. y = np.asarray(y)
  264. observed = np.median(x) - np.median(y)
  266. combined = np.concatenate([x, y])
  267. n_x = len(x)
  269. count = 0
  270. for _ in range(n_perm):
  271. perm = np.random.permutation(combined)
  272. perm_x = perm[:n_x]
  273. perm_y = perm[n_x:]
  274. perm_stat = np.median(perm_x) - np.median(perm_y)
  275. if abs(perm_stat) >= abs(observed):
  276. count += 1
  277. return observed, (count + 1) / (n_perm + 1)
  279. def cohens_d_paired(x, y):
  280. x = np.asarray(x)
  281. y = np.asarray(y)
  282. diff = x - y
  283. sd_diff = diff.std(ddof=1)
  284. return 0.0 if sd_diff == 0 else diff.mean() / sd_diff
  286. def cohens_d_independent(x, y):
  287. x = np.asarray(x)
  288. y = np.asarray(y)
  289. nx, ny = len(x), len(y)
  290. if nx < 2 or ny < 2:
  291. return 0.0
  292. sx = x.std(ddof=1)
  293. sy = y.std(ddof=1)
  294. sp = np.sqrt(((nx - 1) * sx**2 + (ny - 1) * sy**2) / (nx + ny - 2))
  295. return 0.0 if sp == 0 else (x.mean() - y.mean()) / sp
  297. def bootstrap_ci_paired(x, y, n_boot=10000, ci=95):
  298. x = np.asarray(x)
  299. y = np.asarray(y)
  300. diffs = x - y
  301. n = len(diffs)
  303. boot_ds = []
  304. for _ in range(n_boot):
  305. sample = np.random.choice(diffs, size=n, replace=True)
  306. sd = sample.std(ddof=1)
  307. d = sample.mean() / sd if sd != 0 else 0.0
  308. boot_ds.append(d)
  310. lower = np.percentile(boot_ds, (100 - ci) / 2)
  311. upper = np.percentile(boot_ds, 100 - (100 - ci) / 2)
  312. return lower, upper
  314. def bootstrap_ci_independent(x, y, n_boot=10000, ci=95):
  315. x = np.asarray(x)
  316. y = np.asarray(y)
  317. nx, ny = len(x), len(y)
  319. boot_ds = []
  320. for _ in range(n_boot):
  321. bx = np.random.choice(x, size=nx, replace=True)
  322. by = np.random.choice(y, size=ny, replace=True)
  323. sx = bx.std(ddof=1)
  324. sy = by.std(ddof=1)
  325. sp = np.sqrt(((nx - 1) * sx**2 + (ny - 1) * sy**2) / (nx + ny - 2)) if (nx + ny - 2) > 0 else 0.0
  326. d = (bx.mean() - by.mean()) / sp if sp != 0 else 0.0
  327. boot_ds.append(d)
  329. lower = np.percentile(boot_ds, (100 - ci) / 2)
  330. upper = np.percentile(boot_ds, 100 - (100 - ci) / 2)
  331. return lower, upper
  333. def get_vals_paired(df, hemi, layer1, layer2, centrality_key):
  334. sub = df[df["Hemisphere"] == hemi]
  335. pivot = sub.pivot_table(index="Node_ROI", columns="Layer", values=centrality_key)
  336. if layer1 not in pivot.columns or layer2 not in pivot.columns:
  337. return np.array([]), np.array([])
  338. pair = pivot[[layer1, layer2]].dropna()
  339. return pair[layer1].values, pair[layer2].values
  341. def get_vals_independent(df, hemi, layer, centrality_key):
  342. sub = df[(df["Hemisphere"] == hemi) & (df["Layer"] == layer)]
  343. return sub[centrality_key].values
  345. within_pairs = [
  346. ("NTi-SD", "NTi-CD"),
  347. ("NTi-SD", "NTi-SD-CD"),
  348. ("NTi-CD", "NTi-SD-CD")
  349. ]
  350. between_layers = ["NTi-SD", "NTi-CD", "NTi-SD-CD"]
  352. all_stats_degree = []
  353. all_stats_closeness = []
  354. all_stats_strength = []
  355. all_stats_closeness_w = []
  357. metrics = [
  358. ("Degree_Centrality", all_stats_degree),
  359. ("Closeness_Centrality", all_stats_closeness),
  360. ("Strength", all_stats_strength),
  361. ("Closeness_Weighted", all_stats_closeness_w),
  362. ]
  364. for centrality_key, results_list in metrics:
  366. # WITHIN HEMISPHERE (PAIRED)
  367. for hemi in ["Left", "Right"]:
  368. for layer1, layer2 in within_pairs:
  369. x, y = get_vals_paired(centrality_nt_df, hemi, layer1, layer2, centrality_key)
  370. if len(x) == 0 or len(y) == 0:
  371. continue
  373. obs_mean, p_perm_mean = permutation_test_paired_mean(x, y)
  374. obs_median, p_perm_median = permutation_test_paired_median(x, y)
  376. d = cohens_d_paired(x, y)
  377. ci_low, ci_high = bootstrap_ci_paired(x, y)
  379. try:
  380. _, w_p = wilcoxon(x, y, zero_method="wilcox")
  381. except Exception:
  382. w_p = np.nan
  384. results_list.append({
  385. "Metric": centrality_key,
  386. "Test Type": "Within Hemisphere (Paired)",
  387. "Hemisphere": hemi,
  388. "Contrast": f"{layer1} vs {layer2}",
  389. "Mean_diff": obs_mean,
  390. "Median_diff": obs_median,
  391. "p_perm_mean": p_perm_mean,
  392. "p_perm_median": p_perm_median,
  393. "Cohen_d": d,
  394. "CI_low": ci_low,
  395. "CI_high": ci_high,
  396. "Wilcoxon_p": w_p
  397. })
  399. # BETWEEN HEMISPHERES (INDEPENDENT)
  400. for layer in between_layers:
  401. x = get_vals_independent(centrality_nt_df, "Left", layer, centrality_key)
  402. y = get_vals_independent(centrality_nt_df, "Right", layer, centrality_key)
  403. if len(x) == 0 or len(y) == 0:
  404. continue
  406. obs_mean, p_perm_mean = permutation_test_independent_mean(x, y)
  407. obs_median, p_perm_median = permutation_test_independent_median(x, y)
  409. d = cohens_d_independent(x, y)
  410. ci_low, ci_high = bootstrap_ci_independent(x, y)
  412. try:
  413. _, u_p = mannwhitneyu(x, y, alternative="two-sided")
  414. except Exception:
  415. u_p = np.nan
  417. results_list.append({
  418. "Metric": centrality_key,
  419. "Test Type": "Between Hemispheres (Independent)",
  420. "Hemisphere": "Left vs Right",
  421. "Contrast": layer,
  422. "Mean_diff": obs_mean,
  423. "Median_diff": obs_median,
  424. "p_perm_mean": p_perm_mean,
  425. "p_perm_median": p_perm_median,
  426. "Cohen_d": d,
  427. "CI_low": ci_low,
  428. "CI_high": ci_high,
  429. "MannWhitney_p": u_p
  430. })
  432. stats_degree_df = pd.DataFrame(all_stats_degree)
  433. stats_closeness_df = pd.DataFrame(all_stats_closeness)
  434. stats_strength_df = pd.DataFrame(all_stats_strength)
  435. stats_closeness_w_df = pd.DataFrame(all_stats_closeness_w)
  437. # -------------------------------------------------------------------------
  438. # 5b. ADD ONLY p_perm_mean_FDR (BH-FDR), for Strength and Closeness_Weighted
  439. # Correction is done separately within each FAMILY (Within vs Between).
  440. # -------------------------------------------------------------------------
  442. def bh_fdr(pvals):
  443. """
  444. Benjamini–Hochberg FDR correction.
  445. Returns q-values with NaNs preserved.
  446. """
  447. pvals = np.asarray(pvals, dtype=float)
  448. qvals = np.full_like(pvals, np.nan, dtype=float)
  450. mask = np.isfinite(pvals)
  451. p = pvals[mask]
  452. m = p.size
  453. if m == 0:
  454. return qvals
  456. order = np.argsort(p)
  457. p_sorted = p[order]
  459. ranks = np.arange(1, m + 1, dtype=float)
  460. q_sorted = p_sorted * m / ranks
  462. # enforce monotonicity
  463. q_sorted = np.minimum.accumulate(q_sorted[::-1])[::-1]
  464. q_sorted = np.clip(q_sorted, 0.0, 1.0)
  466. q = np.empty_like(p_sorted)
  467. q[order] = q_sorted
  468. qvals[mask] = q
  469. return qvals
  471. def add_ppermmean_fdr_by_family(stats_df, family_col="Test Type"):
  472. """
  473. Adds ONLY p_perm_mean_FDR, corrected separately within each family:
  474. - Within Hemisphere (Paired)
  475. - Between Hemispheres (Independent)
  476. """
  477. df = stats_df.copy()
  478. if df.empty or "p_perm_mean" not in df.columns or family_col not in df.columns:
  479. return df
  481. df["p_perm_mean_FDR"] = np.nan
  482. for fam, idx in df.groupby(family_col).groups.items():
  483. df.loc[idx, "p_perm_mean_FDR"] = bh_fdr(df.loc[idx, "p_perm_mean"].values)
  485. return df
  487. # Apply ONLY to Strength and Weighted Closeness (as requested)
  488. stats_strength_df = add_ppermmean_fdr_by_family(stats_strength_df, family_col="Test Type")
  489. stats_closeness_w_df = add_ppermmean_fdr_by_family(stats_closeness_w_df, family_col="Test Type")
  491. # -------------------------------------------------------------------------
  492. # 6. Raincloud plots (Matplotlib-only)
  493. # y-lims: 0–1, 0–1.4, 0–4 as requested
  494. # -------------------------------------------------------------------------
  496. import matplotlib.pyplot as plt
  497. from scipy.stats import gaussian_kde
  499. def full_violin(ax, data, x, color, width=0.35, y_grid=400, y_min=0.0, y_max=1.0):
  500. data = np.asarray(data, dtype=float)
  501. data = data[np.isfinite(data)]
  502. if len(data) < 2:
  503. return
  504. kde = gaussian_kde(data)
  505. y = np.linspace(y_min, y_max, y_grid)
  506. dens = kde(y)
  507. dens = dens / dens.max() * width if dens.max() > 0 else dens
  508. ax.fill_betweenx(y, x - dens, x + dens, color=color, alpha=1.0, linewidth=0, zorder=1)
  510. def boxplot_clean(ax, data, x, width=0.18):
  511. data = np.asarray(data, dtype=float)
  512. data = data[np.isfinite(data)]
  513. if len(data) == 0:
  514. return
  515. ax.boxplot([data], positions=[x], widths=width, vert=True, showfliers=False, patch_artist=True,
  516. boxprops=dict(facecolor="white", edgecolor="black", linewidth=1, alpha=0.80),
  517. medianprops=dict(color="black", linewidth=1),
  518. whiskerprops=dict(color="black", linewidth=1),
  519. capprops=dict(color="black", linewidth=1))
  521. def strip_black(ax, data, x, jitter=0.12, size=40, alpha=0.7):
  522. data = np.asarray(data, dtype=float)
  523. data = data[np.isfinite(data)]
  524. if len(data) == 0:
  525. return
  526. xs = x + np.random.uniform(-jitter, jitter, size=len(data))
  527. ax.scatter(xs, data, s=size, color="black", alpha=alpha, linewidths=0, zorder=10)
  529. def clean_axes_keep_ticks(ax, tick_label_size=18, tick_size=5):
  530. for spine in ax.spines.values():
  531. spine.set_visible(False)
  532. ax.grid(False)
  533. ax.tick_params(axis="both", which="both", length=tick_size, width=1, color="black", labelsize=tick_label_size)
  535. def raincloud_two_groups(ax, a, b, label_a, label_b,
  536. x_positions=(1.0, 2.0),
  537. layer_a=None, layer_b=None,
  538. tick_label_size=18,
  539. y_min=0.0, y_max=1.0):
  540. a = np.asarray(a, dtype=float)
  541. b = np.asarray(b, dtype=float)
  543. xa, xb = x_positions
  544. color_map = {"SD": "green", "CD": "#ad4c4c"}
  546. full_violin(ax, a, xa, color=color_map.get(layer_a, "gray"), y_min=y_min, y_max=y_max)
  547. full_violin(ax, b, xb, color=color_map.get(layer_b, "gray"), y_min=y_min, y_max=y_max)
  548. boxplot_clean(ax, a, xa)
  549. boxplot_clean(ax, b, xb)
  551. strip_black(ax, a, xa)
  552. strip_black(ax, b, xb)
  554. ax.set_xticks([xa, xb])
  555. ax.set_xticklabels([label_a, label_b], fontsize=tick_label_size)
  556. ax.set_ylim(y_min, y_max)
  557. ax.tick_params(axis="y", labelsize=tick_label_size)
  558. clean_axes_keep_ticks(ax, tick_label_size=tick_label_size)
  560. def save_raincloud(fig, out_png, out_pdf=None, dpi=300):
  561. fig.tight_layout()
  562. fig.savefig(out_png, dpi=dpi, bbox_inches="tight")
  563. if out_pdf is not None:
  564. fig.savefig(out_pdf, bbox_inches="tight")
  565. plt.close(fig)
  567. # ----- Unweighted closeness (0–1) -----
  568. xL, yL = get_vals_paired(centrality_nt_df, "Left", "NTi-SD", "NTi-CD", "Closeness_Centrality")
  569. xR, yR = get_vals_paired(centrality_nt_df, "Right", "NTi-SD", "NTi-CD", "Closeness_Centrality")
  571. L_SD = get_vals_independent(centrality_nt_df, "Left", "NTi-SD", "Closeness_Centrality")
  572. R_SD = get_vals_independent(centrality_nt_df, "Right", "NTi-SD", "Closeness_Centrality")
  574. L_CD = get_vals_independent(centrality_nt_df, "Left", "NTi-CD", "Closeness_Centrality")
  575. R_CD = get_vals_independent(centrality_nt_df, "Right", "NTi-CD", "Closeness_Centrality")
  577. if len(xL) > 0 and len(yL) > 0:
  578. fig, ax = plt.subplots(figsize=(6, 5))
  579. raincloud_two_groups(ax, xL, yL, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=1.0)
  580. save_raincloud(fig,
  581. os.path.join(output_path, "Raincloud_Closeness_Left_NTi-SD_vs_NTi-CD.png"),
  582. os.path.join(output_path, "Raincloud_Closeness_Left_NTi-SD_vs_NTi-CD.pdf"))
  584. if len(xR) > 0 and len(yR) > 0:
  585. fig, ax = plt.subplots(figsize=(6, 5))
  586. raincloud_two_groups(ax, xR, yR, "NTi-SD", "NTi-CD", layer_a="SD", layer_b="CD", y_min=0.0, y_max=1.0)
  587. save_raincloud(fig,
  588. os.path.join(output_path, "Raincloud_Closeness_Right_NTi-SD_vs_NTi-CD.png"),
  589. os.path.join(output_path, "Raincloud_Closeness_Right_NTi-SD_vs_NTi-CD.pdf"))
  591. if len(L_SD) > 0 and len(R_SD) > 0:
  592. fig, ax = plt.subplots(figsize=(6, 5))
  593. raincloud_two_groups(ax, L_SD, R_SD, "Left", "Right", layer_a="SD", layer_b="SD", y_min=0.0, y_max=1.0)
  594. save_raincloud(fig,
  595. os.path.join(output_path, "Raincloud_Closeness_Left_vs_Right_NTi-SD.png"),
  596. os.path.join(output_path, "Raincloud_Closeness_Left_vs_Right_NTi-SD.pdf"))
  598. if len(L_CD) > 0 and len(R_CD) > 0:
  599. fig, ax = plt.subplots(figsize=(6, 5))
  600. raincloud_two_groups(ax, L_CD, R_CD, "Left", "Right", layer_a="CD", layer_b="CD", y_min=0.0, y_max=1.0)
  601. save_raincloud(fig,
  602. os.path.join(output_path, "Raincloud_Closeness_Left_vs_Right_NTi-CD.png"),
  603. os.path.join(output_path, "Raincloud_Closeness_Left_vs_Right_NTi-CD.pdf"))
  605. print("Closeness (unweighted) raincloud plots saved to:", output_path)
  607. # ----- Unweighted degree (0–1) -----
  608. xL_deg, yL_deg = get_vals_paired(centrality_nt_df, "Left", "NTi-SD", "NTi-CD", "Degree_Centrality")
  609. xR_deg, yR_deg = get_vals_paired(centrality_nt_df, "Right", "NTi-SD", "NTi-CD", "Degree_Centrality")
  611. L_SD_deg = get_vals_independent(centrality_nt_df, "Left", "NTi-SD", "Degree_Centrality")
  612. R_SD_deg = get_vals_independent(centrality_nt_df, "Right", "NTi-SD", "Degree_Centrality")
  614. L_CD_deg = get_vals_independent(centrality_nt_df, "Left", "NTi-CD", "Degree_Centrality")
  615. R_CD_deg = get_vals_independent(centrality_nt_df, "Right", "NTi-CD", "Degree_Centrality")
  617. if len(xL_deg) > 0 and len(yL_deg) > 0:
  618. fig, ax = plt.subplots(figsize=(6, 5))
  619. 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)
  620. save_raincloud(fig,
  621. os.path.join(output_path, "Raincloud_Degree_Left_NTi-SD_vs_NTi-CD.png"),
  622. os.path.join(output_path, "Raincloud_Degree_Left_NTi-SD_vs_NTi-CD.pdf"))
  624. if len(xR_deg) > 0 and len(yR_deg) > 0:
  625. fig, ax = plt.subplots(figsize=(6, 5))
  626. 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)
  627. save_raincloud(fig,
  628. os.path.join(output_path, "Raincloud_Degree_Right_NTi-SD_vs_NTi-CD.png"),
  629. os.path.join(output_path, "Raincloud_Degree_Right_NTi-SD_vs_NTi-CD.pdf"))
  631. if len(L_SD_deg) > 0 and len(R_SD_deg) > 0:
  632. fig, ax = plt.subplots(figsize=(6, 5))
  633. 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)
  634. save_raincloud(fig,
  635. os.path.join(output_path, "Raincloud_Degree_Left_vs_Right_NTi-SD.png"),
  636. os.path.join(output_path, "Raincloud_Degree_Left_vs_Right_NTi-SD.pdf"))
  638. if len(L_CD_deg) > 0 and len(R_CD_deg) > 0:
  639. fig, ax = plt.subplots(figsize=(6, 5))
  640. 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)
  641. save_raincloud(fig,
  642. os.path.join(output_path, "Raincloud_Degree_Left_vs_Right_NTi-CD.png"),
  643. os.path.join(output_path, "Raincloud_Degree_Left_vs_Right_NTi-CD.pdf"))
  645. print("Degree (unweighted) raincloud plots saved to:", output_path)
  647. # ----- Weighted closeness (0–1.4) -----
  648. xL_cw, yL_cw = get_vals_paired(centrality_nt_df, "Left", "NTi-SD", "NTi-CD", "Closeness_Weighted")
  649. xR_cw, yR_cw = get_vals_paired(centrality_nt_df, "Right", "NTi-SD", "NTi-CD", "Closeness_Weighted")
  651. L_SD_cw = get_vals_independent(centrality_nt_df, "Left", "NTi-SD", "Closeness_Weighted")
  652. R_SD_cw = get_vals_independent(centrality_nt_df, "Right", "NTi-SD", "Closeness_Weighted")
  654. L_CD_cw = get_vals_independent(centrality_nt_df, "Left", "NTi-CD", "Closeness_Weighted")
  655. R_CD_cw = get_vals_independent(centrality_nt_df, "Right", "NTi-CD", "Closeness_Weighted")
  657. if len(xL_cw) > 0 and len(yL_cw) > 0:
  658. fig, ax = plt.subplots(figsize=(6, 5))
  659. 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)
  660. save_raincloud(fig,
  661. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_NTi-SD_vs_NTi-CD.png"),
  662. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_NTi-SD_vs_NTi-CD.pdf"))
  664. if len(xR_cw) > 0 and len(yR_cw) > 0:
  665. fig, ax = plt.subplots(figsize=(6, 5))
  666. 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)
  667. save_raincloud(fig,
  668. os.path.join(output_path, "Raincloud_ClosenessWeighted_Right_NTi-SD_vs_NTi-CD.png"),
  669. os.path.join(output_path, "Raincloud_ClosenessWeighted_Right_NTi-SD_vs_NTi-CD.pdf"))
  671. if len(L_SD_cw) > 0 and len(R_SD_cw) > 0:
  672. fig, ax = plt.subplots(figsize=(6, 5))
  673. 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)
  674. save_raincloud(fig,
  675. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_vs_Right_NTi-SD.png"),
  676. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_vs_Right_NTi-SD.pdf"))
  678. if len(L_CD_cw) > 0 and len(R_CD_cw) > 0:
  679. fig, ax = plt.subplots(figsize=(6, 5))
  680. 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)
  681. save_raincloud(fig,
  682. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_vs_Right_NTi-CD.png"),
  683. os.path.join(output_path, "Raincloud_ClosenessWeighted_Left_vs_Right_NTi-CD.pdf"))
  685. print("Closeness (weighted) raincloud plots saved to:", output_path)
  687. # ----- Strength (0–4) -----
  688. xL_s, yL_s = get_vals_paired(centrality_nt_df, "Left", "NTi-SD", "NTi-CD", "Strength")
  689. xR_s, yR_s = get_vals_paired(centrality_nt_df, "Right", "NTi-SD", "NTi-CD", "Strength")
  691. L_SD_s = get_vals_independent(centrality_nt_df, "Left", "NTi-SD", "Strength")
  692. R_SD_s = get_vals_independent(centrality_nt_df, "Right", "NTi-SD", "Strength")
  694. L_CD_s = get_vals_independent(centrality_nt_df, "Left", "NTi-CD", "Strength")
  695. R_CD_s = get_vals_independent(centrality_nt_df, "Right", "NTi-CD", "Strength")
  697. if len(xL_s) > 0 and len(yL_s) > 0:
  698. fig, ax = plt.subplots(figsize=(6, 5))
  699. 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)
  700. save_raincloud(fig,
  701. os.path.join(output_path, "Raincloud_Strength_Left_NTi-SD_vs_NTi-CD.png"),
  702. os.path.join(output_path, "Raincloud_Strength_Left_NTi-SD_vs_NTi-CD.pdf"))
  704. if len(xR_s) > 0 and len(yR_s) > 0:
  705. fig, ax = plt.subplots(figsize=(6, 5))
  706. 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)
  707. save_raincloud(fig,
  708. os.path.join(output_path, "Raincloud_Strength_Right_NTi-SD_vs_NTi-CD.png"),
  709. os.path.join(output_path, "Raincloud_Strength_Right_NTi-SD_vs_NTi-CD.pdf"))
  711. if len(L_SD_s) > 0 and len(R_SD_s) > 0:
  712. fig, ax = plt.subplots(figsize=(6, 5))
  713. 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)
  714. save_raincloud(fig,
  715. os.path.join(output_path, "Raincloud_Strength_Left_vs_Right_NTi-SD.png"),
  716. os.path.join(output_path, "Raincloud_Strength_Left_vs_Right_NTi-SD.pdf"))
  718. if len(L_CD_s) > 0 and len(R_CD_s) > 0:
  719. fig, ax = plt.subplots(figsize=(6, 5))
  720. 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)
  721. save_raincloud(fig,
  722. os.path.join(output_path, "Raincloud_Strength_Left_vs_Right_NTi-CD.png"),
  723. os.path.join(output_path, "Raincloud_Strength_Left_vs_Right_NTi-CD.pdf"))
  725. print("Strength raincloud plots saved to:", output_path)
  727. # -------------------------------------------------------------------------
  728. # 7. Save results
  729. # -------------------------------------------------------------------------
  731. centrality_per_nt_file = os.path.join(output_path, 'NT_centrality_per_node_unweighted_and_weighted.xlsx')
  733. degree_summary_file = os.path.join(output_path, 'NT_degree_summary_sup14_style.xlsx')
  734. closeness_summary_file = os.path.join(output_path, 'NT_closeness_summary_sup15_style.xlsx')
  736. strength_summary_file = os.path.join(output_path, 'NT_strength_summary.xlsx')
  737. closeness_w_summary_file = os.path.join(output_path, 'NT_closeness_weighted_summary.xlsx')
  739. perm_degree_file = os.path.join(output_path, 'NT_permutation_stats_degree_mean_median.xlsx')
  740. perm_closeness_file = os.path.join(output_path, 'NT_permutation_stats_closeness_mean_median.xlsx')
  741. perm_strength_file = os.path.join(output_path, 'NT_permutation_stats_strength_mean_median.xlsx')
  742. perm_closeness_w_file = os.path.join(output_path, 'NT_permutation_stats_closeness_weighted_mean_median.xlsx')
  744. centrality_nt_df.to_excel(centrality_per_nt_file, index=False)
  746. degree_summary_df.to_excel(degree_summary_file, index=False)
  747. closeness_summary_df.to_excel(closeness_summary_file, index=False)
  748. strength_summary_df.to_excel(strength_summary_file, index=False)
  749. closeness_w_summary_df.to_excel(closeness_w_summary_file, index=False)
  751. # Degree/Closeness stats unchanged
  752. stats_degree_df.to_excel(perm_degree_file, index=False)
  753. stats_closeness_df.to_excel(perm_closeness_file, index=False)
  755. # Strength + Weighted Closeness stats now include p_perm_mean_FDR
  756. stats_strength_df.to_excel(perm_strength_file, index=False)
  757. stats_closeness_w_df.to_excel(perm_closeness_w_file, index=False)
  759. print("\nPer-NT centrality values saved to:", centrality_per_nt_file)
  760. print("\nAll results saved to:", output_path)
  761. print("Stats files:")
  762. print(perm_degree_file)
  763. print(perm_closeness_file)
  764. print(perm_strength_file)
  765. 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
Institutions: Centre National de la Recherche Scientifique (France); Inserm (France); Université de Montpellier (France); Institut de Génomique Fonctionnelle (France); Hôpital Gui de Chauliac (France); Université Paul-Valéry Montpellier (France); Praxiling (France); Université Paris Cité (France); Hôpital Lariboisière (France); Institut du Cerveau (France); Institut Universitaire de France (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
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
At the source: github.com/jdax34/scripts_article/tree/main/Article

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.1016/j.nicl.2026.104012 [code]
Structural-functional multilayer brain network properties and outcome of combined repetitive transcranial magnetic stimulation and psychotherapy for obsessive-compulsive disorder.
Journal: NeuroImage. Clinical
In common: NetworkX, ggplot2, seaborn, 6 other tools, structural MRI / diffusion, other condition, 3 references
[2] doi:10.1038/s41467-026-75959-w [code]
Charting higher-order models of brain function beyond pairwise interactions.
Journal: Nature communications
In common: NetworkX, seaborn, scikit-learn, 4 other tools, 4 references
[3] doi:10.1093/nc/niag029 [code]
A data-driven approach to identifying and evaluating connectivity-based neural correlates of conscious visual perception.
Journal: Neuroscience of consciousness
In common: broom, NetworkX, ggplot2, 7 other tools, 1 reference
[4] doi:10.1073/pnas.2531706123 [code]
Metabolism-weighted brain connectome reveals synaptic integration and vulnerability to neurodegeneration.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: NetworkX, seaborn, scikit-learn, 4 other tools, other condition, 3 references
[5] doi:10.1093/bioinformatics/btag592 [code]
Network-based stratification of allele-specific expression reveals patient subgroups in Huntington's disease.
Journal: Bioinformatics (Oxford, England)
In common: broom, NetworkX, ggplot2, 7 other tools, other condition
[6] doi:10.1002/advs.202523009 [code]
Personalized Network-Guided Neuromodulation Enhances Human Working Memory.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: ggplot2, seaborn, scikit-learn, 4 other tools, 3 references
[7] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: broom, NetworkX, ggplot2, 7 other tools
[8] doi:10.1126/sciadv.aee9425 [code]
Probabilistic inference of homonymous and heteronymous recurrent inhibition in human muscles from large-scale motor neuron recordings.
Journal: Science advances
In common: broom, NetworkX, ggplot2, 7 other tools
[9] doi:10.1038/s41467-026-74466-2 [code]
Neuromorphic hierarchical modular reservoirs.
Journal: Nature communications
In common: NetworkX, seaborn, scikit-learn, 4 other tools, 3 references
[10] doi:10.1038/s41746-026-02803-2 [code]
A clinical neuroimaging platform for rapid, automated lesion detection and personalized post-stroke outcome prediction.
Journal: NPJ digital medicine
In common: pandas, NumPy, clinical / translational, 5 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

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

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