OSCR

Task load modulates network interactions between bilateral fronto-parietal and cerebellar areas during verbal working memory.

Code ↔ Paper

10 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 10 matches
  1. [1] § STAR★Methods › Quantification and statistical analysis › Effective connectivity analysis ↔ scripts/10_run_watershed_masked.m, lines 85 to 118 · score 0.82 · watershed algorithm, binary masks, overlap map, activated voxels, sub, thresholded · Report a mismatch
  2. [2] § STAR★Methods › Quantification and statistical analysis › Effective connectivity analysis ↔ scripts/10_run_watershed_masked.m, lines 85 to 118 · score 0.80 · binary mask, overlap map, individual activation, Atlas, FLIRT, kernel · Report a mismatch
  3. [3] § STAR★Methods › Quantification and statistical analysis › Behavioral, statistical analyses ↔ scripts/31_analyse_plot_behavior_DCM.Rmd, lines 1096 to 1136 · score 0.67 · Wilcoxon signed rank, post hoc, Friedman, RT, interaction, behavioral · Report a mismatch
  4. [4] § STAR★Methods › Quantification and statistical analysis › fMRI analysis ↔ scripts/04_create_nuisance_regressors_individual_sess_memoslap.m, lines 54 to 88 · score 0.63 · nuisance regressors, aCompCor, motion, SPM12, blocked, fMRI · Report a mismatch
  5. [5] § STAR★Methods › Quantification and statistical analysis › Effective connectivity analysis ↔ scripts/09_create_interindividual_overlap_maps.m, lines 58 to 87 · score 0.62 · overlap map, individual activation, FWHM, smoothed, thresholded, ROI · Report a mismatch
  6. [6] § Results › Behavioral performance ↔ scripts/31_analyse_plot_behavior_DCM.Rmd, lines 1096 to 1136 · score 0.59 · Wilcoxon signed rank, Post hoc, Friedman, interaction, Behavioral · Report a mismatch
  7. [7] § Results › Behavioral performance ↔ scripts/31_analyse_plot_behavior_DCM.Rmd, lines 937 to 988 · score 0.59 · Wilcoxon signed rank, Post hoc, Friedman, Behavioral · Report a mismatch
  8. [8] § STAR★Methods › Quantification and statistical analysis › Effective connectivity analysis ↔ scripts/31_analyse_plot_behavior_DCM.Rmd, lines 522 to 602 · score 0.58 · correlation coefficients, Bayes factors, Bayesian, posterior, connectivity · Report a mismatch
  9. [9] § STAR★Methods › Quantification and statistical analysis › fMRI analysis ↔ scripts/06_first_level_simple_diagonal_concat_memoslap.m, lines 77 to 118 · score 0.58 · nuisance regressors, canonical, derivatives, HRF, diagonal, motion · Report a mismatch
  10. [10] § Results › Functional activation ↔ scripts/08_overlap_index_memoslap.py, lines 85 to 110 · score 0.51 · overlap coefficient, negative task activation, DMN, network, brain, voxels · 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

R Markdown · 1,470 lines · 49 KB · no license · 4 matches

  1. ---
  2. title: "Behavioral_Brain_Correlations"
  3. author: "Gerasimos Gerardos"
  4. date: "2026-01-26"
  5. output: html_document
  6. ---
  8. ```{r setup, include=FALSE}
  9. knitr::opts_chunk$set(echo = TRUE)
  11. library(nlme)
  12. library(lme4)
  13. library(data.table)
  14. library(lmerTest)
  15. library(tidyverse)
  16. library(ICC)
  17. library(readxl)
  18. library(parameters)
  19. library(ggpubr)
  20. library(ggsignif)
  21. library(see)
  22. library(ARTool)
  23. library(BayesFactor)
  26. ```
  29. ```{r}
  30. if (!require("tidyverse")) install.packages("tidyverse", dependencies = T)
  31. if (!require("tidyr")) install.packages("tidyr", dependencies = T)
  32. if (!require("dplyr")) install.packages("diplyr", dependencies = T)
  33. if (!require("lubridate")) install.packages("lubridate", dependencies = T)
  34. if (!require("readr")) install.packages("readr", dependencies = T)
  35. if (!require("forcats")) install.packages("forcats", dependencies = T)
  36. if (!require("fs")) install.packages("fs", dependencies = T)
  37. if (!require("readxl")) install.packages("readxl", dependencies = T)
  38. if (!require("stats")) install.packages("stats", dependencies = T)
  39. if (!require("ggplot2")) install.packages("stats", dependencies = T)
  40. if (!require("base")) install.packages("stats", dependencies = T)
  41. library(car)
  42. if (!require("ggridges")) install.packages("ggridges", dependencies = T)
  43. if (!require("ggplot")) install.packages("ggplot", dependencies = T)
  44. if (!require("ggbeeswarm")) install.packages("ggbeeswarm", dependencies = T)
  45. if (!require("afex")) install.packages("afex", dependencies = T)
  46. if (!require("sjPlot")) install.packages("sjPlot", dependencies = T)
  47. if (!require("readxl")) install.packages("readxl", dependencies = T)
  48. if (!require("bayestestR")) install.packages("bayestestR", dependencies = T)
  49. if (!require("brms")) install.packages("brms", dependencies = T)
  50. ```
  53. Set working directory
  55. ```{r}
  56. work_directory <- "/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/LMM_DCM_Analysis/LMM_DCM_true_concat_512max/long_task_table"
  57. setwd(work_directory)
  59. ```
  60. Laod raw PsychoPy files
  61. ```{r}
  62. files <- list.files(work_directory, pattern = "*.csv", full.names = TRUE)
  64. # Initialize an empty list to store data frames
  65. data_list <- list()
  67. # Read each file and store it in the list
  68. for (file in files) {
  69. tryCatch({
  70. # Read each CSV file with the full path
  71. data <- read.csv(file, header = TRUE, sep = ",", na.strings = "NA", stringsAsFactors = FALSE)
  72. # Store the data frame in the list
  73. data_list[[file]] <- data
  74. }, error = function(e) {
  75. cat("Error in file:", file, "\n", e, "\n")
  76. })
  77. }
  78. ```
  80. Files connected:
  82. ```{r}
  84. # Identify common columns
  85. common_cols <- Reduce(intersect, lapply(data_list, names))
  87. # Filter each data frame to include only common columns
  88. filtered_data_list <- lapply(data_list, function(df) df[, common_cols, drop = FALSE])
  90. # Combine data frames using bind_rows
  91. Data_complete <- do.call(rbind,filtered_data_list)
  93. ## create a Data Set that ommits the NA values of the variable curr_n_back:
  95. Data_complete_clean <- Data_complete[!is.na(Data_complete$curr_n_back), ]
  97. # Check the structure of the new data set
  98. #str(Data_complete_clean)
  100. ```
  102. Accuracy:
  104. ```{r}
  106. # Calculate accuracy, false alarm rate, and miss rate by participant and difficulty level (curr_n_back)
  107. metrics_by_condition <- Data_complete_clean %>%
  108. group_by(participant, curr_n_back) %>%
  109. summarise(
  110. Correct = sum(result == "Correct", na.rm = TRUE),
  111. Correct_rejected = sum(result == "Okay", na.rm = TRUE),
  112. Miss = sum(result == "Absent", na.rm = TRUE),
  113. False_Alarm = sum(result == "Incorrect", na.rm = TRUE),
  114. Total = n()
  115. ) %>%
  116. mutate(
  117. Accuracy = (Correct + Correct_rejected) / Total,
  118. False_Alarm_rate = False_Alarm / Total,
  119. Miss_rate = Miss / Total
  120. )
  123. ```
  125. d' analysis
  127. ```{r}
  128. # adjusted ratios (Hautus, 1995) --> recommended by Gerry: Maybe ask him again? https://www.researchgate.net/post/What-does-a-high-D-prime-score-mean
  129. # https://neuropsychology.github.io/psycho.R/2018/03/29/SDT.html
  131. # Calculate hit rate (HR) and false alarm rate (FAR) for each participant and condition
  132. hit_false_alarm_rates <- Data_complete_clean %>%
  133. group_by(participant, curr_n_back, block.thisN) %>%
  134. summarise(
  135. Hits = sum(result == "Correct", na.rm = TRUE),
  136. Misses = sum(result == "Absent", na.rm = TRUE),
  137. False_Alarms = sum(result == "Incorrect", na.rm = TRUE),
  138. Correct_Rejections = sum(result == "Okay", na.rm = TRUE),
  139. Total_Target = Hits + Misses,
  140. Total_NonTarget = False_Alarms + Correct_Rejections,
  142. HR = (sum(result == "Correct", na.rm = TRUE) + 0.5) / (sum(result == "Correct", na.rm = TRUE) + sum(result == "Absent", na.rm = TRUE) + 1), # Adjusted Hit Rate: Hautus correction
  143. FAR = (sum(result == "Incorrect", na.rm = TRUE) + 0.5) / (sum(result == "Incorrect", na.rm = TRUE) + sum(result == "Okay", na.rm = TRUE) + 1) # Adjusted False Alarm Rate: Hautus correction
  144. )
  146. # Compute d' for each participant and condition
  147. d_prime_values <- hit_false_alarm_rates %>%
  148. mutate(d_prime = qnorm(HR) - qnorm(FAR)) %>%
  149. ungroup() %>%
  150. select(participant, curr_n_back, d_prime, block.thisN) %>%
  151. distinct() # Keep unique values
  153. # Print the d' values
  154. d_prime_values
  156. #write.csv(d_prime_values, "/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/nback_behaviour/tables/d_values_raw.csv", row.names = FALSE, col.names = TRUE)
  159. ```
  162. Average d-prime per session: if raw file not available load the d-prime raw table
  163. ```{r}
  164. #d_prime_values <- read.csv("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/nback_behaviour/tables/d_values_raw.csv", header = TRUE, stringsAsFactors = FALSE)
  166. # Calculate the average d' for each participant (without session identifier) and condition
  167. session_average_d_prime <- d_prime_values %>%
  168. group_by(participant, curr_n_back) %>%
  169. summarise(mean_d_prime = mean(d_prime, na.rm = TRUE)) %>%
  170. ungroup()
  172. # Print the averaged d' values
  173. session_average_d_prime
  175. ```
  177. NEW Averages grouped over Participants and sessions:
  179. ```{r}
  180. # Calculate the average d' for each participant and condition over the two sessions
  181. session_average_d_prime <- d_prime_values %>%
  182. mutate(participant_id = sapply(d_prime_values$participant, function(x) {
  183. # Extract the single match of "40xx"
  184. regmatches(x, regexpr("40\\d{2}", x))
  185. })) %>%
  186. group_by(participant_id, curr_n_back) %>%
  187. summarise(mean_d_prime = mean(d_prime, na.rm = TRUE)) %>%
  188. ungroup()
  190. # Print the averaged d' values
  191. session_average_d_prime
  193. ```
  194. Prepare data for statistics and plotting
  195. ```{r}
  196. d_n <- as.data.frame(session_average_d_prime)
  197. d_n$curr_n_back <- as.factor(d_n$curr_n_back)
  200. idx_nback <- unique(d_n$curr_n_back)
  201. d_n$out_flag <- NaN
  202. for (n in idx_nback) {
  203. # Calculate Tukey's fences
  204. Q1 <- quantile(d_n[d_n$curr_n_back==n, c("mean_d_prime")], 0.25)
  205. Q3 <- quantile(d_n[d_n$curr_n_back==n, c("mean_d_prime")], 0.75)
  206. IQR <- Q3 - Q1
  207. lower_fence <- Q1 - 1.5 * IQR
  208. upper_fence <- Q3 + 1.5 * IQR
  209. d_n[d_n$curr_n_back==n, c("out_flag")]<- ifelse(d_n[d_n$curr_n_back==n, c("mean_d_prime")] < lower_fence | d_n[d_n$curr_n_back==n, c("mean_d_prime")] > upper_fence, "outlier", "inlier")
  210. }
  212. d_n
  213. ```
  215. Friedman tests and post-hoc paired Wilcoxon tests
  216. ```{r}
  217. # Global test
  218. fried_test <- friedman.test(cbind(d_n$mean_d_prime[d_n$curr_n_back==0],
  219. d_n$mean_d_prime[d_n$curr_n_back==1],
  220. d_n$mean_d_prime[d_n$curr_n_back==2],
  221. d_n$mean_d_prime[d_n$curr_n_back==3]))
  223. avg_d_tests <- data.frame(
  224. method = fried_test$method,
  225. data = "0, 1, 2, 3 -back",
  226. statistic = as.numeric(fried_test$statistic),
  227. p_value = round(fried_test$p.value, 3),
  228. p_bonferroni = NA
  229. )
  231. paired_wilcox <- function(x, y) {
  232. # Perform paired Wilcoxon test
  233. test_result <- wilcox.test(x, y, paired = TRUE, exact = FALSE)
  234. return(test_result)
  235. }
  237. k = length(idx_nback)
  238. n_com = (k * (k - 1)) / 2
  240. if (avg_d_tests$p_value[1] < 0.5) {
  242. options(digits = 4)
  243. i = 0
  244. for (n in list( c("0", "1"), c("0", "2"),c("0", "3"), c("1", "2"),c("1", "3"), c("2", "3"))){
  246. x = d_n$mean_d_prime[d_n$curr_n_back==as.numeric(n[1])]
  247. y = d_n$mean_d_prime[d_n$curr_n_back==as.numeric(n[2])]
  248. wil_test <- paired_wilcox(x,y)
  250. ntest <- data.frame(
  251. method = wil_test$method,
  252. data = paste0(n[1],' vs ',n[2],' -back'),
  253. statistic = NA,
  254. p_value = round(wil_test$p.value, 3),
  255. p_bonferroni = round(wil_test$p.value*n_com, 3)
  256. )
  258. avg_d_tests[2+i,] <- ntest
  259. i = i+1
  261. }
  262. }
  264. avg_d_tests
  266. ```
  267. Plot results
  268. ```{r}
  271. dn <-ggplot(d_n, aes(x=curr_n_back, y=mean_d_prime, fill=curr_n_back)) +
  272. geom_violin() +
  273. geom_boxplot(width = 0.1, color = "black", fill = NA,outlier.shape = NA) +
  274. geom_jitter(position=position_jitter(0.03), aes(color = out_flag), size = 0.5)+
  275. scale_color_manual(values = c("black", "red3"))
  277. if (avg_d_tests$p_value[1] < 0.5) {
  278. dn <- dn +
  279. geom_signif(
  280. comparisons = list( c("0", "1"), c("1", "2"), c("2", "3")),
  281. map_signif_level = c("***"=0.001/n_com, "**"=0.01/n_com, "*"=0.05/n_com),
  282. y_position = 4, textsize = 5, vjust = 0.8,
  283. test = paired_wilcox) +
  284. geom_signif(
  285. comparisons = list( c("0", "2")),
  286. map_signif_level = c("***"=0.001/n_com, "**"=0.01/n_com, "*"=0.05/n_com),
  287. y_position = 4.2, textsize = 5, vjust = 0.8, tip_length = 0.02,
  288. test = paired_wilcox) +
  289. geom_signif(
  290. comparisons = list(c("1", "3")),
  291. map_signif_level = c("***"=0.001/n_com, "**"=0.01/n_com, "*"=0.05/n_com),
  292. y_position = 4.4, textsize = 5, vjust = 0.8, tip_length = 0.02,
  293. test = paired_wilcox) +
  294. geom_signif(
  295. comparisons = list( c("0", "3")),
  296. map_signif_level = c("***"=0.001/n_com, "**"=0.01/n_com, "*"=0.05/n_com),
  297. y_position =4.6, textsize = 5, vjust = 0.8,
  298. test = paired_wilcox)
  299. }
  301. dn <- dn +
  302. labs(x = "n-back Condition", y = "Sensitivity (d')") +
  303. #ggtitle("Mean Senstivity (d') per n-back Condition") + # for the main title
  304. theme_modern() +
  305. scale_fill_okabeito(palette = "full", order = c(1, 5, 3, 6))
  307. dn
  309. ```
  310. session tests
  312. ```{r}
  313. # Calculate the average d' for each participant and condition over the two sessions
  314. session_d_prime <- d_prime_values %>%
  315. group_by(participant, curr_n_back) %>%
  316. summarise(mean_d_prime = mean(d_prime, na.rm = TRUE)) %>%
  317. ungroup()
  319. # Print the averaged d' values
  320. session_d_prime
  322. ```
  323. ```{r}
  325. d_s <- session_d_prime
  326. d_s <- as.data.frame(d_s)
  327. d_s$session[grepl("1$", d_s$participant)] <- "1"
  328. d_s$session[grepl("2$", d_s$participant)] <- "2"
  330. d_s$participant <- sapply(d_s$participant, function(x) {
  331. # Extract the single match of "40xx"
  332. regmatches(x, regexpr("40\\d{2}", x))
  333. })
  336. d_s$out_flag <- NaN
  337. sess <- unique(d_s$session)
  338. for (n in idx_nback) {
  339. for (s in sess) {
  340. # Calculate Tukey's fences
  341. Q1 <- quantile(d_s[d_s$curr_n_back==n & d_s$sess==s, c("mean_d_prime")], 0.25)
  342. Q3 <- quantile(d_s[d_s$curr_n_back==n & d_s$sess==s, c("mean_d_prime")], 0.75)
  343. IQR <- Q3 - Q1
  344. lower_fence <- Q1 - 1.5 * IQR
  345. upper_fence <- Q3 + 1.5 * IQR
  346. d_s[d_s$curr_n_back==n & d_s$sess==s, c("out_flag")]<- ifelse(d_s[d_s$curr_n_back==n & d_s$sess==s, c("mean_d_prime")] < lower_fence | d_s[d_s$curr_n_back==n & d_s$sess==s, c("mean_d_prime")] > upper_fence, "outlier", "inlier")
  347. }
  348. }
  350. d_s
  351. ```
  353. ```{r}
  355. d_s$curr_n_back <- as.factor(d_s$curr_n_back)
  356. d_s$participant <-as.factor(d_s$participant)
  357. d_s$session <- as.factor(d_s$session)
  359. df_art <- art(mean_d_prime ~ curr_n_back * session + (1 | participant), data = d_s )
  361. # Perform ART ANOVA
  362. art_anova_results <- anova(df_art)
  365. # Print results
  366. print(art_anova_results)
  368. df_text <- capture.output(print(art_anova_results))
  371. if (art_anova_results['session','Pr(>F)']<=0.05 | art_anova_results['curr_n_back:session','Pr(>F)']<=0.05)
  372. {
  373. wide_ses <- d_s %>%
  374. unite("back_sess", curr_n_back, session, sep = "back_sess") %>% # combine back and sess
  375. pivot_wider(
  376. id_cols = code,
  377. names_from = back_sess,
  378. values_from = mean_d_prime
  379. )
  381. wide_matrix <- wide_ses %>%
  382. select(-participant) %>% # Remove the identifier column
  383. as.matrix() # Convert to matrix
  385. # Get all unique pairwise combinations of columns
  386. combinations <- combn(colnames(wide_matrix), 2, simplify = FALSE)
  388. # Apply paired Wilcoxon test to each pair
  389. wilcox_results <- lapply(combinations, function(pair) {
  390. test <- wilcox.test(wide_matrix[, pair[1]], wide_matrix[, pair[2]], paired = TRUE, exact = FALSE)
  391. data.frame(
  392. group1 = pair[1],
  393. group2 = pair[2],
  394. p_value = test$p.value
  395. )
  396. })
  398. # Combine results into a data frame
  399. results_df <- do.call(rbind, wilcox_results)
  401. # Apply Bonferroni correction
  402. results_df$adjusted_p <- p.adjust(results_df$p_value, method = "bonerroni")
  404. results_df <- results_df %>%
  405. mutate(significance = case_when(
  406. adjusted_p <= 0.001 ~ "***",
  407. adjusted_p <= 0.01 ~ "**",
  408. adjusted_p <= 0.05 ~ "*",
  409. TRUE ~ "ns"
  410. ))
  411. print(results_df)
  412. }
  415. ```
  416. ```{r}
  419. dses <- ggplot(d_s, aes(x = curr_n_back, y = mean_d_prime, fill = interaction(session, curr_n_back))) +
  420. geom_violin() +
  421. geom_boxplot(aes(group = interaction(session, curr_n_back)), position = position_dodge(width = 0.9), width = 0.1, color = "black", fill = NA,outlier.shape = NA) +
  422. geom_point(aes(group = interaction(session, curr_n_back)), position = position_dodge(width = 0.9), size = 0.5,color = "black") +
  424. # Lines connecting data points from session 1 to session 2
  425. geom_line(aes(x = as.numeric(curr_n_back) +
  426. ifelse(session == levels(session)[1], -0.375/2, 0.375/2),
  427. group = interaction(participant, curr_n_back)),
  428. alpha = 0.6, color = "gray40", linetype = "dotted") +
  429. #ggtitle("Sensitivity (d') of individual blocks per n-back level") + # for the main title
  430. labs(x = "n-back Condition", y = "Sensitivity (d')")+
  431. #stat_compare_means(method = "wilcox.test", paired = TRUE, label.y = 4.9, p.adjust.method = "bonferroni" )+
  432. theme_modern() +
  433. scale_fill_manual(name = "nback x session", labels = c("0back in ses-1","0back in ses-2","1back in ses-1","1back in ses-2","2back in ses-1","2back in ses-2","3back in ses-1","3back in ses-2"),
  434. values = c( "goldenrod1","goldenrod3", "dodgerblue","dodgerblue3","seagreen3","seagreen4","tomato1","tomato3")) +
  435. scale_color_manual(name = "nback x session", labels = c("0back in ses-1","0back in ses-2","1back in ses-1","1back in ses-2","2back in ses-1","2back in ses-2","3back in ses-1","3back in ses-2"),
  436. values = c( "goldenrod3","goldenrod4","dodgerblue3","dodgerblue4","seagreen4","darkgreen","tomato3","tomato4")) +
  437. theme(
  438. axis.ticks.length = unit(5, "pt"), # makes ticks longer (more dash-like)
  439. axis.ticks = element_line(linewidth = 0.5, linetype = "solid", color = "black")
  440. )+
  441. ylim(0.8, 4)
  443. dses
  444. ```
  446. Without 0back:
  448. ```{r}
  450. # Calculate the average d' for each participant and condition, excluding 0-back
  451. session_average_d_prime_123 <- session_average_d_prime %>%
  452. filter(curr_n_back != "0")
  454. # Print the averaged d' values
  455. session_average_d_prime_123
  457. ```
  459. ```{r}
  460. # Load the DCM connectivity data from Excel file
  461. dcm_data <- read_excel("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/DCM_true_concat_512max/modulatory_connectivity_B_n1back_Mean_DCM_analysis_mask_CER_PAR_IFG_ROI_s4fmap_brain_true_concat_512max.xlsx")
  463. # View the first few rows of your data to understand its structure
  464. #head(dcm_data)
  465. #head(session_average_d_prime_123)
  468. # Create a vector of participant IDs excluding 4004
  469. participant_ids <- unique(session_average_d_prime_123$participant_id)
  471. # Assign to the data frame
  472. dcm_data <- dcm_data %>%
  473. mutate(participant_id = participant_ids)
  475. # Print the updated dcm_data to verify the change
  476. #dcm_data
  478. # Combine the dPrime table with the B-matrix parameters table
  479. mcombined_data <- session_average_d_prime_123 %>%
  480. left_join(dcm_data, by = "participant_id") # Join by participant ID
  482. # Print the combined data
  483. #combined_data
  485. # Load the DCM connectivity data from Excel file
  486. dcm_data <- read_excel("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/DCM_true_concat_512max/modulatory_connectivity_B_n2back_Mean_DCM_analysis_mask_CER_PAR_IFG_ROI_s4fmap_brain_true_concat_512max.xlsx")
  488. # Assign to the data frame
  489. dcm_data <- dcm_data %>%
  490. mutate(participant_id = participant_ids)
  492. # Print the updated dcm_data to verify the change
  493. #dcm_data
  495. # Combine the dPrime table with the B-matrix parameters table
  496. mcombined_data <- mcombined_data %>%
  497. left_join(dcm_data, by = "participant_id") # Join by participant ID
  499. # Print the combined data
  500. #combined_data
  502. # Load the DCM connectivity data from Excel file
  503. dcm_data <- read_excel("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/DCM_true_concat_512max/modulatory_connectivity_B_n3back_Mean_DCM_analysis_mask_CER_PAR_IFG_ROI_s4fmap_brain_true_concat_512max.xlsx")
  505. # Assign to the data frame
  506. dcm_data <- dcm_data %>%
  507. mutate(participant_id = participant_ids)
  509. # Print the updated dcm_data to verify the change
  510. #dcm_data
  512. # Combine the dPrime table with the B-matrix parameters table
  513. mcombined_data <- mcombined_data %>%
  514. left_join(dcm_data, by = "participant_id") # Join by participant ID
  516. # Print the combined data
  517. mcombined_data
  521. ```
  522. ```{r}
  524. # Initialize a data frame to store correlation results with p-values
  525. Bayes_correlation_results_nback_mod <- data.frame(
  526. Connectivity_Variable = character(),
  527. Bayesian_Factor = numeric(),
  528. median_r = numeric(),
  529. CI_lower95_r = numeric(),
  530. CI_upper95_r= numeric(),
  531. Significance = character(),
  532. stringsAsFactors = FALSE
  533. )
  535. interpret_bayes_factor <- function(bf) {
  536. if (bf <= 1 ) {
  537. interpretation <- "Null"
  538. } else if (bf > 1 && bf <= 3) {
  539. interpretation <- "Weak"
  540. } else if (bf > 3 && bf <= 10) {
  541. interpretation <- "Moderate"
  542. } else if (bf > 10 && bf <= 30) {
  543. interpretation <- "Strong"
  544. } else if (bf > 30 && bf <= 100) {
  545. interpretation <- "Very strong "
  546. } else if (bf > 100) {
  547. interpretation <- "Extreme"
  548. } else {
  549. interpretation <- "Uninterpretable value"
  550. }
  551. return(interpretation)
  552. }
  554. for (n_level in 1:3) {
  555. # Filter data for 3-back condition
  556. Bayes_mod_data_nback <-mcombined_data %>%
  557. filter(curr_n_back == n_level)
  559. # Extract column names
  560. connectivity_variables <- colnames(mcombined_data)[startsWith(colnames(mcombined_data), paste0('n',as.character(n_level)))]
  562. # Loop through each connectivity variable, run cor.test, and extract the correlation coefficient and p-value
  563. for (var in connectivity_variables) {
  564. # Perform the cor.test for the current variable
  566. cor_test <- correlationBF(
  567. x = Bayes_mod_data_nback$mean_d_prime,
  568. y = Bayes_mod_data_nback[[var]]
  569. )
  572. set.seed(2025)
  573. post <- posterior(cor_test, iterations = 50000) # MCMC samples
  574. rho <- as.numeric(post[,"rho"]) # posterior draws of r
  576. median_r <- median(rho)
  577. ci_r <- quantile(rho, c(.025, .975)) # 95% credible interval
  578. c(median_r = median_r, l95 = ci_r[1], u95 = ci_r[2])
  579. # Determine significance based on p-value
  580. # Convert to data frame and extract the BF value
  581. bf_df <- as.data.frame(cor_test)
  582. bf_value <- bf_df$bf[1]
  584. significance <- interpret_bayes_factor(bf_value)
  586. # Append results to the data frame
  587. Bayes_correlation_results_nback_mod <- rbind(Bayes_correlation_results_nback_mod, data.frame(
  588. Connectivity_Variable = var,
  589. Bayesian_Factor = bf_value,
  590. median_r = median_r,
  591. CI_lower95_r = ci_r[1],
  592. CI_upper95_r = ci_r[2],
  593. Significance = significance
  594. ))
  595. }
  596. }
  597. # Print the updated correlation results with p-values and significance
  598. Bayes_correlation_results_nback_mod
  602. ```
  603. ```{r}
  606. filtered_bay_nback<- Bayes_correlation_results_nback_mod %>%
  607. filter(Significance != "Null" )
  608. kept_indices <- which(Bayes_correlation_results_nback_mod$Significance != "Null")
  610. colr = c("#0072B2","#009E73","#D55E00") #E69F00
  612. if (!is_empty(kept_indices)){
  613. for (i in 1:nrow(filtered_bay_nback))
  614. {
  615. n_level <- filtered_bay_nback$Connectivity_Variable[i]
  616. n_level <- as.numeric(substr(n_level, 2, 2))
  618. Bayes_mod_data_nback <-mcombined_data %>%
  619. filter(curr_n_back == n_level)
  622. con_name = filtered_bay_nback[i,1]
  623. just_con = substr(con_name, 8, nchar(con_name))
  625. # Convert the Bayes Factor output to a data frame and extract the relevant value
  626. bayes_factor_df_nback_mod <- as.data.frame(filtered_bay_nback[i,])
  627. bayes_factor_nback_mod <- bayes_factor_df_nback_mod$Bayesian_Factor[1] # Adjust as necessary based on the output structure
  628. r_bf = bayes_factor_df_nback_mod$median_r
  632. # Create the plot
  633. mbplot <- ggplot(Bayes_mod_data_nback, aes(x = mean_d_prime, y = .data[[con_name]])) +
  634. geom_point(alpha = 0.6) + # Scatter plot points
  635. geom_smooth(method = "lm", color = colr[n_level], se = FALSE) + # Regression line
  636. labs(
  637. title = paste0("Correlation of Sensitivity with Connectivity Modulation: \n", just_con, " in ", as.character(n_level), "-back"),
  638. x = "Mean Sensitivity (d')",
  639. y = "Modulation (Hz)"
  640. ) +
  641. theme_modern() +
  642. xlim(1, 3.5) +
  643. ylim(-1, 1) +
  645. theme(
  646. plot.title = element_text(hjust = 0.5, size = 14, face = "bold"),
  647. axis.title = element_text(size = 14)
  648. ) +
  649. # Add correlation and Bayes Factor text
  650. annotate("text", x = Inf, y = Inf,
  651. label = paste("BF:", round(bayes_factor_nback_mod, 3),"\nrho:",round(r_bf, 3)),
  652. hjust = 1.1, vjust = 1.5, size = 4, color = "black", fontface = "italic")
  655. print(mbplot)
  656. }
  657. }else {
  658. print('No evidence at all')
  659. }
  661. ```
  663. ```{r}
  664. # Load the DCM connectivity data from Excel file
  665. dcm_data <- read_excel("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/DCM_true_concat_512max/intrinsic_connectivity_A_Mean_DCM_analysis_mask_CER_PAR_IFG_ROI_s4fmap_brain_true_concat_512max.xlsx")
  667. # View the first few rows of your data to understand its structure
  668. head(dcm_data)
  669. head(session_average_d_prime)
  671. # Create a vector of participant IDs excluding 4004
  672. participant_ids <- unique(session_average_d_prime$participant_id)
  674. # Assign to the data frame
  675. dcm_data <- dcm_data %>%
  676. mutate(participant_id = participant_ids)
  678. # Print the updated dcm_data to verify the change
  679. print(dcm_data)
  681. avg0123 <- session_average_d_prime
  682. avg0123$mean_d_prime[avg0123$curr_n_back=='0'] <- avg0123$mean_d_prime[avg0123$curr_n_back=='0'] * 0.5
  684. avg0123 <- avg0123 %>%
  685. group_by(participant_id) %>% # Group by participant and n-back condition
  686. summarise(mean_d_prime = mean(mean_d_prime, na.rm = TRUE)) %>% # Calculate mean d'
  687. ungroup() # Remove grouping structure
  689. icombined_data <- avg0123 %>%
  690. left_join(dcm_data, by = "participant_id") # Join by participant ID
  693. # Print the combined data
  694. icombined_data
  696. ```
  697. ```{r}
  699. # Extract column names
  700. connectivity_variables <- colnames(icombined_data)[grepl("^[lr]", colnames(icombined_data))]
  702. # Initialize a data frame to store correlation results with p-values
  703. Bayes_correlation_results_nback_intr <- data.frame(
  704. Connectivity_Variable = character(),
  705. median_r = numeric(),
  706. CI_lower95_r = numeric(),
  707. CI_upper95_r= numeric(),
  708. Bayesian_Factor = numeric(),
  709. Significance = character(),
  710. stringsAsFactors = FALSE
  711. )
  713. interpret_bayes_factor <- function(bf) {
  714. if (bf <= 1 ) {
  715. interpretation <- "Null"
  716. } else if (bf > 1 && bf <= 3) {
  717. interpretation <- "Weak"
  718. } else if (bf > 3 && bf <= 10) {
  719. interpretation <- "Moderate"
  720. } else if (bf > 10 && bf <= 30) {
  721. interpretation <- "Strong"
  722. } else if (bf > 30 && bf <= 100) {
  723. interpretation <- "Very strong "
  724. } else if (bf > 100) {
  725. interpretation <- "Extreme"
  726. } else {
  727. interpretation <- "Uninterpretable value"
  728. }
  729. return(interpretation)
  730. }
  732. n_level = '0123'
  733. # Filter data for 3-back condition
  734. Bayes_intr_data_nback <-icombined_data
  738. # Loop through each connectivity variable, run cor.test, and extract the correlation coefficient and p-value
  739. for (var in connectivity_variables) {
  740. # Perform the cor.test for the current variable
  742. cor_test <- correlationBF(
  743. x = Bayes_intr_data_nback$mean_d_prime,
  744. y = Bayes_intr_data_nback[[var]]
  745. )
  746. set.seed(2025)
  747. post <- posterior(cor_test, iterations = 50000) # MCMC samples
  748. rho <- as.numeric(post[,"rho"]) # posterior draws of r
  750. median_r <- median(rho)
  751. ci_r <- quantile(rho, c(.025, .975)) # 95% credible interval
  752. c(median_r = median_r, l95 = ci_r[1], u95 = ci_r[2])
  753. # Determine significance based on p-value
  754. # Convert to data frame and extract the BF value
  755. bf_df <- as.data.frame(cor_test)
  756. bf_value <- bf_df$bf[1]
  758. significance <- interpret_bayes_factor(bf_value)
  760. # Determine significance based on p-value
  761. # Convert to data frame and extract the BF value
  762. bf_df <- as.data.frame(cor_test)
  763. bf_value <- bf_df$bf[1]
  765. significance <- interpret_bayes_factor(bf_value)
  767. # Append results to the data frame
  768. Bayes_correlation_results_nback_intr <- rbind(Bayes_correlation_results_nback_intr, data.frame(
  769. Connectivity_Variable = paste0('n',as.character(n_level),'back_', var),
  770. Bayesian_Factor = bf_value,
  771. median_r = median_r,
  772. CI_lower95_r = ci_r[1],
  773. CI_upper95_r = ci_r[2],
  774. Significance = significance
  775. ))
  776. }
  778. # Print the updated correlation results with p-values and significance
  779. Bayes_correlation_results_nback_intr
  781. ```
  782. ```{r}
  785. filtered_bay_nback<- Bayes_correlation_results_nback_intr %>%
  786. filter(Significance != "Null" )
  787. kept_indices <- which(Bayes_correlation_results_nback_intr$Significance != "Null")
  789. colr = c("#0072B2","#009E73","#D55E00", "#CC79A7")
  791. if (!is_empty(kept_indices)){
  793. for (i in 1:nrow(filtered_bay_nback))
  794. {
  795. n_level <-'0123'
  797. Bayes_intr_data_nback <-icombined_data
  799. con_name = filtered_bay_nback[i,1]
  800. area_name = substr(con_name, 11, nchar(con_name))
  803. # Convert the Bayes Factor output to a data frame and extract the relevant value
  804. bayes_factor_df_nback_intr <- as.data.frame(filtered_bay_nback[i,])
  805. bayes_factor_nback_intr <- bayes_factor_df_nback_intr$Bayesian_Factor[1] # Adjust as necessary based on the output structure
  806. r_bf = bayes_factor_df_nback_intr$median_r
  807. conn = Bayes_intr_data_nback[[area_name]][c(1:4,6:20)]
  808. dprime =Bayes_intr_data_nback$mean_d_prime[c(1:4,6:20)]
  811. # Create the plot
  812. ibplot <- ggplot(Bayes_intr_data_nback, aes(x = mean_d_prime, y = .data[[area_name]])) +
  813. geom_point(alpha = 0.6) + # Scatter plot points
  814. geom_smooth(method = "lm", color = colr[4], se = FALSE) + # Regression line
  815. labs(
  816. title = paste0("Correlation of Sensitivity in the 0, 1 ,2 & 3 -back with \nIntrinsic Connectivity: from_", area_name), #as.character(n_level),
  817. x = "Mean Sensitivity (d')",
  818. y = "Connection Strength (Hz)"
  819. ) +
  820. theme_modern() +
  821. xlim(1, 3.5) +
  822. ylim(-1, 1) +
  824. theme(
  825. plot.title = element_text(hjust = 0.5, size = 14, face = "bold"),
  826. axis.title = element_text(size = 14)
  827. ) +
  828. # Add correlation and Bayes Factor text
  829. annotate("text", x = Inf, y = Inf,
  830. label = paste("BF:", round(bayes_factor_nback_intr, 3),"\nrho:",round(r_bf, 3)),
  831. hjust = 1.1, vjust = 1.5, size = 4, color = "black", fontface = "italic")
  832. #("r:", round(correlation_result_nback_intr, 3), "\nBF:", round(bayes_factor_nback_intr, 3),"\np:",round(p_val, 3), "\np-FDR:",round(p_adj, 3)),
  834. print(ibplot)
  835. # ggsave(paste0("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/DCM_true_concat_512max/Performance_correlations/Bayes_dprime",as.character(n_level), "back_intrinsic_", area_name , ".png"), width = 7, height = 5, dpi = 1000)
  837. }
  838. }else {
  839. print('No evidence at all')
  840. }
  843. ```
  845. ```{r}
  847. # Step 1: Extract participant ID without the task identifier
  848. rt_data <- Data_complete_clean %>%
  849. mutate(participant_id = sapply(Data_complete_clean$participant, function(x) {
  850. # Extract the single match of "40xx"
  851. regmatches(x, regexpr("40\\d{2}", x))
  852. }))
  854. # Step 2: Filter for correct responses
  855. correct_responses <- rt_data %>%
  856. filter(result == "Correct")
  858. # Step 3 & 4: Group by the participant ID and condition, then calculate mean reaction time
  859. reaction_times <- correct_responses %>%
  860. group_by(participant_id, curr_n_back) %>%
  861. summarise(mean_cor_rt = mean(response.rt, na.rm = TRUE)) %>%
  862. ungroup()
  864. # Print the calculated reaction times
  865. reaction_times
  866. #write.csv(reaction_times, "/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/nback_behaviour/tables/rt_raw.csv", row.names = FALSE, col.names = TRUE)
  868. ```
  869. ``` {r}
  870. #reaction_times <- read.csv("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/nback_behaviour/tables/rt_raw.csv", header = TRUE, stringsAsFactors = FALSE)
  872. rt_nback <- reaction_times
  873. rt_nback <- as.data.frame(rt_nback)
  874. rt_nback$curr_n_back <- as.factor(rt_nback$curr_n_back)
  876. rt_nback$out_flag <- NaN
  877. for (n in idx_nback) {
  878. # Calculate Tukey's fences
  879. Q1 <- quantile(rt_nback[rt_nback$curr_n_back==n, c("mean_cor_rt")], 0.25)
  880. Q3 <- quantile(rt_nback[rt_nback$curr_n_back==n, c("mean_cor_rt")], 0.75)
  881. IQR <- Q3 - Q1
  882. lower_fence <- Q1 - 1.5 * IQR
  883. upper_fence <- Q3 + 1.5 * IQR
  884. rt_nback[rt_nback$curr_n_back==n, c("out_flag")] <- ifelse(rt_nback[rt_nback$curr_n_back==n, c("mean_cor_rt")] < lower_fence | rt_nback[rt_nback$curr_n_back==n, c("mean_cor_rt")] > upper_fence, "outlier", "inlier")
  885. }
  887. rt_nback
  891. ```
  892. ```{r}
  894. fried_test <- friedman.test(cbind(rt_nback$mean_cor_rt[rt_nback$curr_n_back==0],
  895. rt_nback$mean_cor_rt[rt_nback$curr_n_back==1],
  896. rt_nback$mean_cor_rt[rt_nback$curr_n_back==2],
  897. rt_nback$mean_cor_rt[rt_nback$curr_n_back==3]))
  901. avg_rt_tests <- data.frame(
  902. method = fried_test$method,
  903. data = "0, 1, 2, 3 -back",
  904. statistic = as.numeric(fried_test$statistic),
  905. p_value = round(fried_test$p.value, 3),
  906. p_bonferroni = NA
  907. )
  909. options(digits = 4)
  910. i = 0
  911. for (n in list( c("0", "1"), c("0", "2"),c("0", "3"), c("1", "2"),c("1", "3"), c("2", "3"))){
  913. x = rt_nback$mean_cor_rt[rt_nback$curr_n_back==as.numeric(n[1])]
  914. y = rt_nback$mean_cor_rt[rt_nback$curr_n_back==as.numeric(n[2])]
  915. wil_test <- paired_wilcox(x,y)
  917. ntest <- data.frame(
  918. method = wil_test$method,
  919. data = paste0(n[1],' vs ',n[2],' -back'),
  920. statistic = NA,
  921. p_value = round(wil_test$p.value, 3),
  922. p_bonferroni = round(wil_test$p.value*n_com, 3)
  923. )
  925. avg_rt_tests[2+i,] <- ntest
  926. i = i+1
  928. }
  930. avg_rt_tests
  933. #write.csv(avg_rt_tests, "/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/nback_behaviour/tables/rt_main_stat_tests.csv", row.names = FALSE, col.names = TRUE)
  934. ```
  937. ```{r}
  939. rtn <-ggplot(rt_nback, aes(x=curr_n_back, y=mean_cor_rt, fill=curr_n_back)) +
  940. geom_violin() + #outlier.colour="red", outlier.shape=8, outlier.size=1.5, notch=FALSE) +
  941. geom_boxplot(width = 0.1, color = "black", fill = NA,outlier.shape = NA) +
  942. geom_jitter(position=position_jitter(0.03), aes(color = out_flag), size = 0.5)+
  943. scale_color_manual(values = c("black", "red3"))
  946. if (avg_rt_tests$p_value[1] <= 0.05){
  947. rtn <- rtn+
  948. geom_signif(
  949. comparisons = list( c("0", "1"), c("1", "2"), c("2", "3")),
  950. map_signif_level = c("***"=0.001/n_com, "**"=0.01/n_com, "*"=0.05/n_com),
  951. y_position = 1.25-0.3, textsize = 5, vjust = 0.8, test =paired_wilcox) +
  952. geom_signif(
  953. comparisons = list( c("0", "2")),
  954. map_signif_level = c("***"=0.001/n_com, "**"=0.01/n_com, "*"=0.05/n_com),
  955. y_position = 1.3-0.3, textsize = 5, vjust = 0.8, tip_length = 0.02, test = paired_wilcox) +
  956. geom_signif(
  957. comparisons = list(c("1", "3")),
  958. map_signif_level = c("***"=0.001/n_com, "**"=0.01/n_com, "*"=0.05/n_com),
  959. y_position = 1.35-0.3, textsize = 5, vjust = 0.8, tip_length = 0.02, test = paired_wilcox) +
  960. geom_signif(
  961. comparisons = list( c("0", "3")),
  962. map_signif_level = c("***"=0.001/n_com, "**"=0.01/n_com, "*"=0.05/n_com),
  963. y_position =1.4-0.3, textsize = 5, vjust = 0.8, test = paired_wilcox)
  964. } else {
  965. rtn <- rtn+stat_compare_means(label.y = 1.3)
  966. }
  968. rtn <- rtn+
  969. ylim(0.4, 1.15) +
  970. #ggtitle("Response Speed per n-back Condition (only hit trials)") + # for the main title
  971. labs(x = "n-back Condition", y = "Response Time (sec)")+
  972. theme_modern() +
  973. # annotate("text", x = Inf, y = Inf,
  974. # label = paste("Friedman Test, p ~", as.character(round(as.numeric(fried_test["p.value"],3))), "\nPost-hoc Pairwise Wilcoxon Signed-Rank Test"),
  975. # hjust = 1, vjust = 1, size = 4, color = "black", fontface = "italic")+
  976. scale_fill_okabeito(palette = "full", order = c(1, 5, 3, 6)) +
  977. theme(legend.position = "none")+
  978. theme(
  979. axis.ticks.length = unit(5, "pt"), # makes ticks longer (more dash-like)
  980. axis.ticks = element_line(size = 0.5, linetype = "solid", color = "black")
  981. )
  985. rtn
  988. ```
  989. ```{r}
  991. # Step 1: Extract participant ID without the task identifier
  992. rt_data_sess <- Data_complete_clean %>%
  993. mutate(participant_id = sapply(Data_complete_clean$participant, function(x) {
  994. # Extract the single match of "40xx"
  995. regmatches(x, regexpr("40\\d{2}", x))})) %>%
  996. mutate(session = ifelse(grepl("1$", Data_complete_clean$participant), "1",
  997. ifelse(grepl("2$", Data_complete_clean$participant), "2", NA)))
  999. # Step 2: Filter for correct responses
  1000. correct_responses_sess <- rt_data_sess %>%
  1001. filter(result == "Correct")
  1003. # Step 3 & 4: Group by the participant ID and condition, then calculate mean reaction time
  1004. reaction_times_sess <- correct_responses_sess %>%
  1005. group_by(participant_id, session, curr_n_back) %>%
  1006. summarise(mean_cor_rt = mean(response.rt, na.rm = TRUE)) %>%
  1007. ungroup()
  1009. # Print the calculated reaction times
  1010. reaction_times_sess
  1012. #write.csv(reaction_times_sess, "/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/nback_behaviour/tables/rt_sess_raw.csv", row.names = FALSE, col.names = TRUE)
  1014. ```
  1015. ```{r}
  1016. #reaction_times_sess <- read.csv("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/nback_behaviour/tables/rt_sess_raw.csv", header = TRUE, stringsAsFactors = FALSE)
  1018. rt_sess <- as.data.frame(reaction_times_sess)
  1020. rt_sess$session <- as.factor(rt_sess$session)
  1021. rt_sess$curr_n_back <- as.factor(rt_sess$curr_n_back)
  1023. rt_sess$out_flag <- NaN
  1025. idx_nback <- unique(rt_sess$curr_n_back)
  1026. sess <- unique(rt_sess$session)
  1027. for (n in idx_nback) {
  1028. for (s in sess) {
  1029. # Calculate Tukey's fences
  1030. Q1 <- quantile(rt_sess[rt_sess$curr_n_back==n & rt_sess$session==s, c("mean_cor_rt")], 0.25)
  1031. Q3 <- quantile(rt_sess[rt_sess$curr_n_back==n & rt_sess$session==s, c("mean_cor_rt")], 0.75)
  1032. IQR <- Q3 - Q1
  1033. lower_fence <- Q1 - 1.5 * IQR
  1034. upper_fence <- Q3 + 1.5 * IQR
  1035. rt_sess[rt_sess$curr_n_back==n & rt_sess$session==s, c("out_flag")]<- ifelse(rt_sess[rt_sess$curr_n_back==n & rt_sess$session==s, c("mean_cor_rt")] < lower_fence | rt_sess[rt_sess$curr_n_back==n & rt_sess$session==s, c("mean_cor_rt")] > upper_fence, "outlier", "inlier")
  1036. }
  1037. }
  1039. rt_sess
  1041. ```
  1042. ```{r}
  1043. df_art_rt <- art(mean_cor_rt ~ curr_n_back * session + (1 | participant_id), data = rt_sess)
  1045. # Perform ART ANOVA
  1046. art_anova_results_rt <- anova(df_art_rt)
  1048. # Print results
  1049. art_anova_results_rt
  1051. if (art_anova_results['session','Pr(>F)']<=0.05 | art_anova_results['curr_n_back:session','Pr(>F)']<=0.05)
  1052. {
  1053. wide_ses <- rt_sess %>%
  1054. unite("back_sess", curr_n_back, session, sep = "back_sess") %>% # combine back and sess
  1055. pivot_wider(
  1056. id_cols = participant_id,
  1057. names_from = back_sess,
  1058. values_from = mean_cor_rt
  1059. )
  1061. wide_matrix <- wide_ses %>%
  1062. select(-participant_id) %>% # Remove the identifier column
  1063. as.matrix() # Convert to matrix
  1065. # Get all unique pairwise combinations of columns
  1066. combinations <- combn(colnames(wide_matrix), 2, simplify = FALSE)
  1068. # Apply paired Wilcoxon test to each pair
  1069. wilcox_results <- lapply(combinations, function(pair) {
  1070. test <- wilcox.test(wide_matrix[, pair[1]], wide_matrix[, pair[2]], paired = TRUE, exact = FALSE)
  1071. data.frame(
  1072. group1 = pair[1],
  1073. group2 = pair[2],
  1074. p_value = test$p.value
  1075. )
  1076. })
  1078. # Combine results into a data frame
  1079. results_df_rt <- do.call(rbind, wilcox_results)
  1081. # Apply Bonferroni correction
  1082. results_df_rt$adjusted_p <- p.adjust(results_df_rt$p_value, method = "fdr")
  1085. results_df_rt <- results_df_rt %>%
  1086. mutate(significance = case_when(
  1087. adjusted_p <= 0.001 ~ "***",
  1088. adjusted_p <= 0.01 ~ "**",
  1089. adjusted_p <= 0.05 ~ "*",
  1090. TRUE ~ "ns"
  1091. ))
  1092. results_df_rt
  1093. }
  1095. ```
  1096. ```{r}
  1098. rts <- ggplot(rt_sess, aes(x = curr_n_back, y = mean_cor_rt, fill = interaction(session,curr_n_back))) +
  1099. geom_violin() +
  1100. geom_boxplot(aes(group = interaction(session,curr_n_back)), position = position_dodge(width = 0.9), width = 0.1, color = "black", fill = NA,outlier.shape = NA) +
  1101. geom_point(aes(group = interaction(session,curr_n_back)), position = position_dodge(width = 0.9), size = 0.5,color = "black") +
  1103. # Lines connecting data points from session 1 to session 2
  1104. geom_line(aes(x = as.numeric(curr_n_back) +
  1105. ifelse(session == levels(session)[1], -0.375/2, 0.375/2),
  1106. group = interaction(participant_id, curr_n_back)),
  1107. alpha = 0.6, color = "gray40", linetype = "dotted") +
  1108. labs(x = "n-back Condition", y = "Response Time (sec)")+
  1109. theme_modern() +
  1110. scale_fill_manual(name = "nback x session", labels = c("0back in ses-1","0back in ses-2","1back in ses-1","1back in ses-2","2back in ses-1","2back in ses-2","3back in ses-1","3back in ses-2"),
  1111. values = c( "goldenrod1","goldenrod3", "dodgerblue","dodgerblue3","seagreen3","seagreen4","tomato1","tomato3")) +
  1112. scale_color_manual(name = "nback x session", labels = c("0back in ses-1","0back in ses-2","1back in ses-1","1back in ses-2","2back in ses-1","2back in ses-2","3back in ses-1","3back in ses-2"),
  1113. values = c( "goldenrod3","goldenrod4","dodgerblue3","dodgerblue4","seagreen4","darkgreen","tomato3","tomato4")) +
  1114. #scale_fill_okabeito(palette = "full", order = c(1, 5, 3, 6))+
  1115. theme(
  1116. axis.ticks.length = unit(5, "pt"), # makes ticks longer (more dash-like)
  1117. axis.ticks = element_line(size = 0.5, linetype = "solid", color = "black")
  1118. )
  1120. rts <- rts+
  1121. ylim(0.4, 1) +
  1122. #ggtitle("Response Speed per n-back Condition (only hit trials)") + # for the main title
  1123. labs(x = "n-back Condition", y = "Response Speed (sec)")+
  1124. theme_modern() +
  1125. # annotate("text", x = Inf, y = Inf,
  1126. # label = paste("Friedman Test, p ~", as.character(round(as.numeric(fried_test["p.value"],3))), "\nPost-hoc Pairwise Wilcoxon Signed-Rank Test"),
  1127. # hjust = 1, vjust = 1, size = 4, color = "black", fontface = "italic")+
  1128. #scale_fill_okabeito(palette = "full", order = c(1, 5, 3, 6)) +
  1129. #theme(legend.position = "none")+
  1130. theme(
  1131. axis.ticks.length = unit(5, "pt"), # makes ticks longer (more dash-like)
  1132. axis.ticks = element_line(size = 0.5, linetype = "solid", color = "black")
  1133. )
  1134. rts
  1136. ```
  1138. ```{r}
  1139. # Filter out the 0-back condition
  1140. reaction_times_123 <- reaction_times %>%
  1141. filter(curr_n_back != 0)
  1143. # Print the filtered reaction times to verify
  1144. reaction_times_123
  1146. ```
  1148. ```{r}
  1149. # Merge the filtered reaction times with the combined data
  1150. mcombined_data <- mcombined_data %>%
  1151. left_join(reaction_times_123, by = c("participant_id", "curr_n_back"))
  1153. mcombined_data
  1155. ```
  1157. ```{r}
  1158. # Initialize a data frame to store correlation results with p-values
  1159. Bayes_correlation_results_nback_mod_rt <- data.frame(
  1160. Connectivity_Variable = character(),
  1161. Bayesian_Factor = numeric(),
  1162. median_r = numeric(),
  1163. CI_lower95_r = numeric(),
  1164. CI_upper95_r= numeric(),
  1165. Significance = character(),
  1166. stringsAsFactors = FALSE
  1167. )
  1169. interpret_bayes_factor <- function(bf) {
  1170. if (bf <= 1 ) {
  1171. interpretation <- "Null"
  1172. } else if (bf > 1 && bf <= 3) {
  1173. interpretation <- "Weak"
  1174. } else if (bf > 3 && bf <= 10) {
  1175. interpretation <- "Moderate"
  1176. } else if (bf > 10 && bf <= 30) {
  1177. interpretation <- "Strong"
  1178. } else if (bf > 30 && bf <= 100) {
  1179. interpretation <- "Very strong "
  1180. } else if (bf > 100) {
  1181. interpretation <- "Extreme"
  1182. } else {
  1183. interpretation <- "Uninterpretable value"
  1184. }
  1185. return(interpretation)
  1186. }
  1188. for (n_level in 1:3) {
  1189. # Filter data for 3-back condition
  1190. Bayes_mod_data_nback <-mcombined_data %>%
  1191. filter(curr_n_back == n_level)
  1193. # Extract column names
  1194. connectivity_variables <- colnames(mcombined_data)[startsWith(colnames(mcombined_data), paste0('n',as.character(n_level)))]
  1196. # Loop through each connectivity variable, run cor.test, and extract the correlation coefficient and p-value
  1197. for (var in connectivity_variables) {
  1198. # Perform the cor.test for the current variable
  1200. cor_test <- correlationBF(
  1201. x = Bayes_mod_data_nback$mean_cor_rt,
  1202. y = Bayes_mod_data_nback[[var]]
  1203. )
  1207. set.seed(2025)
  1208. post <- posterior(cor_test, iterations = 50000) # MCMC samples
  1209. rho <- as.numeric(post[,"rho"]) # posterior draws of r
  1211. median_r <- median(rho)
  1212. ci_r <- quantile(rho, c(.025, .975)) # 95% credible interval
  1213. c(median_r = median_r, l95 = ci_r[1], u95 = ci_r[2])
  1214. # Determine significance based on p-value
  1215. # Convert to data frame and extract the BF value
  1216. bf_df <- as.data.frame(cor_test)
  1217. bf_value <- bf_df$bf[1]
  1219. significance <- interpret_bayes_factor(bf_value)
  1221. # Append results to the data frame
  1222. Bayes_correlation_results_nback_mod_rt <- rbind(Bayes_correlation_results_nback_mod_rt, data.frame(
  1223. Connectivity_Variable = var,
  1224. Bayesian_Factor = bf_value,
  1225. median_r = median_r,
  1226. CI_lower95_r = ci_r[1],
  1227. CI_upper95_r = ci_r[2],
  1228. Significance = significance
  1229. ))
  1230. }
  1231. }
  1232. # Print the updated correlation results with p-values and significance
  1233. Bayes_correlation_results_nback_mod_rt
  1235. ```
  1237. ```{r}
  1240. filtered_bay_nback<- Bayes_correlation_results_nback_mod_rt %>%
  1241. filter(Significance != "Null" )
  1243. kept_indices <- which(Bayes_correlation_results_nback_mod_rt$Significance != "Null")
  1245. colr = c("#0072B2","#009E73","#D55E00") #E69F00
  1247. if (!is_empty(kept_indices))
  1248. {
  1249. for (i in 1:nrow(filtered_bay_nback))
  1250. {
  1251. n_level <- filtered_bay_nback$Connectivity_Variable[i]
  1252. n_level <- as.numeric(substr(n_level, 2, 2))
  1254. Bayes_mod_data_nback <-mcombined_data %>%
  1255. filter(curr_n_back == n_level)
  1258. con_name = filtered_bay_nback[i,1]
  1259. just_con = substr(con_name, 8, nchar(con_name))
  1261. # Convert the Bayes Factor output to a data frame and extract the relevant value
  1262. bayes_factor_df_nback_mod <- as.data.frame(filtered_bay_nback[i,])
  1263. bayes_factor_nback_mod <- bayes_factor_df_nback_mod$Bayesian_Factor[1] # Adjust as necessary based on the output structure
  1264. r_bf = bayes_factor_df_nback_mod$median_r
  1268. # Create the plot
  1269. mbplot_rt <- ggplot(Bayes_mod_data_nback, aes(x = mean_cor_rt, y = .data[[con_name]])) +
  1270. geom_point(alpha = 0.6) + # Scatter plot points
  1271. geom_smooth(method = "lm", color = colr[n_level], se = FALSE) + # Regression line
  1272. labs(
  1273. title = paste0("Correlation of Response Time with Connectivity Modulation: \n", just_con, " in ", as.character(n_level), "-back"),
  1274. x = "Response Time (sec)",
  1275. y = "Modulation (Hz)"
  1276. ) +
  1277. theme_modern() +
  1278. xlim(1, 3.5) +
  1279. ylim(-1, 1) +
  1281. theme(
  1282. plot.title = element_text(hjust = 0.5, size = 14, face = "bold"),
  1283. axis.title = element_text(size = 14)
  1284. ) +
  1285. # Add correlation and Bayes Factor text
  1286. annotate("text", x = Inf, y = Inf,
  1287. label = paste("BF:", round(bayes_factor_nback_mod, 3),"\nrho:",round(r_bf, 3)),
  1288. hjust = 1.1, vjust = 1.5, size = 4, color = "black", fontface = "italic")
  1291. print(mbplot_rt)
  1293. # ggsave(paste0("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/DCM_true_concat_results/Performance_correlations/Bayes_rt_",as.character(n_level), "back_modulatory_", con_name , ".png"), width = 7, height = 5, dpi = 1000)
  1296. }
  1298. }else {
  1299. print('No evidence at all')
  1300. }
  1301. ```
  1304. ```{r}
  1306. avg0123_rt <- reaction_times
  1307. avg0123_rt$mean_cor_rt[avg0123$curr_n_back=='0'] <- avg0123_rt$mean_cor_rt[avg0123_rt$curr_n_back=='0'] * 0.5
  1309. avg0123_rt <- avg0123_rt %>%
  1310. group_by(participant_id) %>% # Group by participant and n-back condition
  1311. summarise(mean_cor_rt = mean(mean_cor_rt, na.rm = TRUE)) %>% # Calculate mean d'
  1312. ungroup() # Remove grouping structure
  1314. icombined_data <- avg0123_rt %>%
  1315. left_join(icombined_data, by = "participant_id") # Join by participant ID
  1318. # Print the combined data
  1319. icombined_data
  1321. ```
  1322. ```{r}
  1325. # Extract column names
  1326. connectivity_variables <- colnames(icombined_data)[grepl("^[lr]", colnames(icombined_data))]
  1328. # Initialize a data frame to store correlation results with p-values
  1329. Bayes_correlation_results_nback_intr_rt <- data.frame(
  1330. Connectivity_Variable = character(),
  1331. median_r = numeric(),
  1332. CI_lower95_r = numeric(),
  1333. CI_upper95_r= numeric(),
  1334. Bayesian_Factor = numeric(),
  1335. Significance = character(),
  1336. stringsAsFactors = FALSE
  1337. )
  1339. interpret_bayes_factor <- function(bf) {
  1340. if (bf <= 1 ) {
  1341. interpretation <- "Null"
  1342. } else if (bf > 1 && bf <= 3) {
  1343. interpretation <- "Weak"
  1344. } else if (bf > 3 && bf <= 10) {
  1345. interpretation <- "Moderate"
  1346. } else if (bf > 10 && bf <= 30) {
  1347. interpretation <- "Strong"
  1348. } else if (bf > 30 && bf <= 100) {
  1349. interpretation <- "Very strong "
  1350. } else if (bf > 100) {
  1351. interpretation <- "Extreme"
  1352. } else {
  1353. interpretation <- "Uninterpretable value"
  1354. }
  1355. return(interpretation)
  1356. }
  1358. n_level = '0123'
  1359. # Filter data for 3-back condition
  1360. Bayes_intr_data_nback <-icombined_data
  1364. # Loop through each connectivity variable, run cor.test, and extract the correlation coefficient and p-value
  1365. for (var in connectivity_variables) {
  1366. # Perform the cor.test for the current variable
  1368. cor_test <- correlationBF(
  1369. x = Bayes_intr_data_nback$mean_cor_rt,
  1370. y = Bayes_intr_data_nback[[var]]
  1371. )
  1372. set.seed(2025)
  1373. post <- posterior(cor_test, iterations = 50000) # MCMC samples
  1374. rho <- as.numeric(post[,"rho"]) # posterior draws of r
  1376. median_r <- median(rho)
  1377. ci_r <- quantile(rho, c(.025, .975)) # 95% credible interval
  1378. c(median_r = median_r, l95 = ci_r[1], u95 = ci_r[2])
  1379. # Determine significance based on p-value
  1380. # Convert to data frame and extract the BF value
  1381. bf_df <- as.data.frame(cor_test)
  1382. bf_value <- bf_df$bf[1]
  1384. significance <- interpret_bayes_factor(bf_value)
  1386. # Determine significance based on p-value
  1387. # Convert to data frame and extract the BF value
  1388. bf_df <- as.data.frame(cor_test)
  1389. bf_value <- bf_df$bf[1]
  1391. significance <- interpret_bayes_factor(bf_value)
  1393. # Append results to the data frame
  1394. Bayes_correlation_results_nback_intr_rt <- rbind(Bayes_correlation_results_nback_intr_rt, data.frame(
  1395. Connectivity_Variable = paste0('n',as.character(n_level),'back_', var),
  1396. Bayesian_Factor = bf_value,
  1397. median_r = median_r,
  1398. CI_lower95_r = ci_r[1],
  1399. CI_upper95_r = ci_r[2],
  1400. Significance = significance
  1401. ))
  1402. }
  1404. # Print the updated correlation results with p-values and significance
  1405. Bayes_correlation_results_nback_intr_rt
  1407. ```
  1409. ```{r}
  1412. filtered_bay_nback<- Bayes_correlation_results_nback_intr_rt %>%
  1413. filter(Significance != "Null" )
  1414. kept_indices <- which(Bayes_correlation_results_nback_intr_rt$Significance != "Null")
  1416. colr = c("#0072B2","#009E73","#D55E00", "#CC79A7")
  1418. if (!is_empty(kept_indices)){
  1420. for (i in 1:nrow(filtered_bay_nback))
  1421. {
  1422. n_level <-'0123'
  1424. Bayes_intr_data_nback <-icombined_data
  1426. con_name = filtered_bay_nback[i,1]
  1427. area_name = substr(con_name, 11, nchar(con_name))
  1430. # Convert the Bayes Factor output to a data frame and extract the relevant value
  1431. bayes_factor_df_nback_intr <- as.data.frame(filtered_bay_nback[i,])
  1432. bayes_factor_nback_intr <- bayes_factor_df_nback_intr$Bayesian_Factor[1] # Adjust as necessary based on the output structure
  1433. r_bf = bayes_factor_df_nback_intr$median_r
  1434. conn = Bayes_intr_data_nback[[area_name]][c(1:4,6:20)]
  1435. dprime =Bayes_intr_data_nback$mean_d_prime[c(1:4,6:20)]
  1438. # Create the plot
  1439. ibplot <- ggplot(Bayes_intr_data_nback, aes(x = mean_cor_rt, y = .data[[area_name]])) +
  1440. geom_point(alpha = 0.6) + # Scatter plot points
  1441. geom_smooth(method = "lm", color = colr[4], se = FALSE) + # Regression line
  1442. labs(
  1443. title = paste0("Correlation of Sensitivity in the 0, 1 ,2 & 3 -back with \nIntrinsic Connectivity: from_", area_name), #as.character(n_level),
  1444. x = "Mean Reaction Time (sec)",
  1445. y = "Connection Strength (Hz)"
  1446. ) +
  1447. theme_modern() +
  1448. xlim(0.4, 0.8) +
  1449. ylim(-1, 1) +
  1451. theme(
  1452. plot.title = element_text(hjust = 0.5, size = 14, face = "bold"),
  1453. axis.title = element_text(size = 14)
  1454. ) +
  1455. # Add correlation and Bayes Factor text
  1456. annotate("text", x = Inf, y = Inf,
  1457. label = paste("BF:", round(bayes_factor_nback_intr, 3),"\nrho:",round(r_bf, 3)),
  1458. hjust = 1.1, vjust = 1.5, size = 4, color = "black", fontface = "italic")
  1459. #("r:", round(correlation_result_nback_intr, 3), "\nBF:", round(bayes_factor_nback_intr, 3),"\np:",round(p_val, 3), "\np-FDR:",round(p_adj, 3)),
  1461. print(ibplot)
  1462. # ggsave(paste0("/data/pt_02809/MeMoSLAP/p4_dcm/final_codes/DCM_true_concat_512max/Performance_correlations/Bayes_dprime",as.character(n_level), "back_intrinsic_", area_name , ".png"), width = 7, height = 5, dpi = 1000)
  1464. }
  1465. }else {
  1466. print('No evidence at all')
  1467. }
  1470. ```

31_analyse_plot_behavior_DCM.Rmd at commit b788fe4, no license · at the source

Overview

Authors: Sabrina Turker1,2,3, Gerasimos Gerardos1,2,4, Felix Büch1,5, Beatrice Fumagalli2, Philipp Kuhnke1,2, Gesa Hartwigsen1,2
ORCID iDs: Sabrina Turker, Gerasimos Gerardos, Felix Büch, Beatrice Fumagalli
  1. Cognitive and Biological Psychology, Wilhelm Wundt Institute for Psychology, Leipzig University, Leipzig, Germany
  2. Research Group Cognition and Plasticity, Max Planck Institute for Human Cognitive and Brain Sciences Leipzig, Leipzig, Germany
  3. Brain and Language Lab, Department for Behavioral and Cognitive Biology, University of Vienna, Vienna, Austria
  4. Interdisciplinary Graduate Program in the Brain and Mind Sciences, University of Crete, Heraklion, Crete, Greece
  5. Clinical Psychology and Psychotherapy, Wilhelm Wundt Institute for Psychology, Leipzig University, Leipzig, Germany
Institutions: University of Vienna (Austria); Max Planck Institute for Human Cognitive and Brain Sciences (Germany); Leipzig University (Germany); University of Crete (Greece)
Journal: iScience, volume 29, issue 5, article 115502
Dates: received 30 September 2025; accepted 24 March 2026; published online 26 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.isci.2026.115502 · PMID 42004033 · PMCID PMC13091522 · OpenAlex W7140781893
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: cognitive (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, fMRI & imaging, Machine learning
Keywords: Neuroscience, Cognitive neuroscience
Topic: Neural and Behavioral Psychology Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: European Research Council (101043747); Deutsche Forschungsgemeinschaft (467143400, HA 6314/10\u20131); Max Planck Society
Citations: not cited yet (Europe PMC); 77 references in the paper

Abstract

Verbal working memory (VWM) relies on frontal and parietal regions, yet their functional interactions, particularly with the cerebellum, remain underexplored. Prior studies link higher VWM load to increased parieto-prefrontal coupling and associate stronger interactions with better performance. This suggests that connectivity may underlie individual differences in efficiency. However, fronto-parieto-cerebellar dynamics have not been systematically examined to date. We investigated activation and directed functional coupling between six pre-selected regions of interest during a VWM task. Higher task load increased activity in fronto-parietal regions and the cerebellum. Connectivity analyses revealed bidirectional facilitatory interactions between fronto-parietal regions, but reduced cerebello-cortical coupling as demands increased. Positive left parieto-frontal coupling with increasing load showed links to performance, indicating that less interaction was required for good performance. These effects were consistent across two sessions. Our study highlights that fronto-parietal coupling adapts to support increasing task demands, whereas reduced cerebello-cortical interactions suggest a distinct role for the cerebellum.

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

Repositories

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

OSF x94c2

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Languages: MATLAB (28), R (3), Python (1)
Size: 117 files, 32 scripts
Software Heritage: not checked
Found in: “Data and code availability”
Holds: 2 notebooks
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: SPM (15 files), Statistics and Machine Learning Toolbox (3 files), lme4 (2 files), lmerTest (2 files), nlme (2 files), tidyverse (2 files), afex (1 file), BayesFactor (1 file), brms (1 file), car (1 file), data.table (1 file), easystats (1 file), ggplot2 (1 file), ggpubr (1 file), NiBabel (1 file), NumPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
32 files
At the source: osf.io/x94c2/

ggerardos/vwm-task-dcm-memoslap

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: b788fe4d84d2bfcfad6c31201c73ebdabdcccbc0, 3 March 2026
Languages: MATLAB (28), R (3), Python (1)
Size: 34 files, 32 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: 2 notebooks
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: SPM (15 files), Statistics and Machine Learning Toolbox (3 files), lme4 (2 files), lmerTest (2 files), nlme (2 files), tidyverse (2 files), afex (1 file), BayesFactor (1 file), brms (1 file), car (1 file), data.table (1 file), easystats (1 file), ggplot2 (1 file), ggpubr (1 file), NiBabel (1 file), NumPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
32 files
At the source: github.com/ggerardos/vwm-task-dcm-memoslap

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

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 64 scripts, each with its path and the digest of its content;
  • 10 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 and code availability

Data: All raw and processed data generated in this study have been deposited at the OSF Platform and are publicly available at https://osf.io/x94c2/. Additional data supporting the findings of this study are available upon request from the corresponding author.

Code: All custom code and scripts used for data processing and analysis have been deposited at GitHub at https://github.com/ggerardos/vwm-task-dcm-memoslap and are also publicly available through the OSF Platform at https://osf.io/x94c2/.

Other Items: No supplementary software, algorithms, or related materials were developed as part of this study. All known and used software is cited in 10.3 and 10.4. Any additional information required to reanalyze the data reported in this paper is available from the corresponding author upon request.

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

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 2 keywords, 3 funders, 76 references.

Cite

This paper

Turker, S., Gerardos, G., Büch, F., Fumagalli, B., Kuhnke, P., & Hartwigsen, G. (2026). Task load modulates network interactions between bilateral fronto-parietal and cerebellar areas during verbal working memory. iScience, 29(5), 115502. https://doi.org/10.1016/j.isci.2026.115502

BibTeX

@article{turker2026task,
author = {Turker, Sabrina and Gerardos, Gerasimos and Büch, Felix and Fumagalli, Beatrice and Kuhnke, Philipp and Hartwigsen, Gesa},
title = {{Task load modulates network interactions between bilateral fronto-parietal and cerebellar areas during verbal working memory}},
journal = {iScience},
year = {2026},
month = mar,
volume = {29},
number = {5},
pages = {115502},
publisher = {Elsevier},
issn = {2589-0042},
doi = {10.1016/j.isci.2026.115502},
url = {https://doi.org/10.1016/j.isci.2026.115502},
pmid = {42004033},
pmcid = {PMC13091522}
}

RIS

TY - JOUR
AU - Turker, Sabrina
AU - Gerardos, Gerasimos
AU - Büch, Felix
AU - Fumagalli, Beatrice
AU - Kuhnke, Philipp
AU - Hartwigsen, Gesa
TI - Task load modulates network interactions between bilateral fronto-parietal and cerebellar areas during verbal working memory
T2 - iScience
J2 - iScience
PY - 2026
DA - 2026/03/26
VL - 29
IS - 5
SP - 115502
SN - 2589-0042
PB - Elsevier
DO - 10.1016/j.isci.2026.115502
UR - https://doi.org/10.1016/j.isci.2026.115502
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.isci.2026.115502",
"type": "article-journal",
"title": "Task load modulates network interactions between bilateral fronto-parietal and cerebellar areas during verbal working memory",
"container-title": "iScience",
"author": [
{
"family": "Turker",
"given": "Sabrina"
},
{
"family": "Gerardos",
"given": "Gerasimos"
},
{
"family": "Büch",
"given": "Felix"
},
{
"family": "Fumagalli",
"given": "Beatrice"
},
{
"family": "Kuhnke",
"given": "Philipp"
},
{
"family": "Hartwigsen",
"given": "Gesa"
}
],
"container-title-short": "iScience",
"volume": "29",
"issue": "5",
"page": "115502",
"DOI": "10.1016/j.isci.2026.115502",
"PMID": "42004033",
"PMCID": "PMC13091522",
"ISSN": "2589-0042",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.isci.2026.115502",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
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.neuroimage.2023.120373 [code]
Adaptive short-term plasticity in the typical reading network.
Journal: NeuroImage
In common: easystats, car, lmerTest, 2 other tools, cognitive, 6 references, author Sabrina Turker
[2] doi:10.1038/s41586-025-08888-1 [code]
Adversarial testing of global neuronal workspace and integrated information theories of consciousness.
Journal: Nature
In common: BayesFactor, afex, easystats, 8 other tools, cognitive, 4 references
[3] doi:10.1038/s41467-023-43747-5 [code]
Neural substrates of parallel devaluation-sensitive and devaluation-insensitive Pavlovian learning in humans.
Journal: Nature communications
In common: BayesFactor, brms, afex, 7 other tools, cognitive, 1 reference
[4] doi:10.1186/s11689-025-09651-3 [code]
The association between infant EEG aperiodic exponent and the trajectory of restricted and repetitive behaviors for toddlers with and without autism.
Journal: Journal of neurodevelopmental disorders
In common: brms, afex, nlme, 9 other tools
[5] doi:10.1038/s41514-024-00171-3 [code]
Mapping computational cognitive profiles of aging to dissociable brain and sociodemographic factors.
Journal: npj aging
In common: BayesFactor, brms, nlme, 9 other tools
[6] doi:10.1038/s41537-023-00333-4 [code]
Preserved electrophysiological markers of confidence in schizophrenia spectrum disorder.
Journal: Schizophrenia (Heidelberg, Germany)
In common: BayesFactor, brms, afex, 8 other tools
[7] doi:10.1038/s41366-023-01370-w [code]
A randomized controlled trial investigating the effect of liraglutide on self-reported liking and neural responses to food stimuli in participants with obesity.
Journal: International journal of obesity (2005)
In common: BayesFactor, brms, afex, 8 other tools, 1 reference
[8] doi:10.1016/j.nicl.2025.103881 [code]
Brain age gap reduction following exercise mirrors clinical improvements in schizophrenia spectrum disorders.
Journal: NeuroImage. Clinical
In common: BayesFactor, brms, easystats, 9 other tools
[9] doi:10.1038/s41467-026-73865-9 [code]
Histamine shapes the neurocomputational dynamics of human learning.
Journal: Nature communications
In common: BayesFactor, brms, easystats, 8 other tools, cognitive, 1 reference
[10] doi:10.1038/s41597-026-07377-y [code]
An open-access multi-site fMRI dataset for investigating conscious visual perception.
Journal: Scientific data
In common: BayesFactor, afex, easystats, 8 other tools, 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.isci.2026.115502.svg)](https://openscicode.org/badge/doi/10.1016/j.isci.2026.115502)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1016/j.isci.2026.115502.svg
   :target: https://openscicode.org/badge/doi/10.1016/j.isci.2026.115502
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1016/j.isci.2026.115502"><img src="https://openscicode.org/badge/doi/10.1016/j.isci.2026.115502.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.