From 8fb889621070dd91ef2c4d8b40c431143e4437bc Mon Sep 17 00:00:00 2001 From: Kianoosh Hosseini <31733665+kianooshhosseini@users.noreply.github.com> Date: Thu, 27 Feb 2025 00:15:05 -0500 Subject: [PATCH] adding the task --- .../mfe_d_face_measure_computations_v2_mini.R | 146 + code/stats/mfe_d_face_stats_v3.R | 272 + code/stats/mfe_e_face_data_organizer_v1.R | 344 ++ .../mfe_e_face_measure_computations_v1.R | 417 ++ .../mfe_e_face_measure_computations_v2.R | 442 ++ .../mfe_e_face_measure_computations_v3.R | 512 ++ code/stats/mfe_e_face_stats_v1.R | 227 + code/stats/mfe_e_face_stats_v2.R | 264 + code/stats/mfe_e_face_stats_v3.R | 289 ++ materials/mfe_e/blockSelect.csv | 13 + materials/mfe_e/blockSelect_practice.csv | 2 + materials/mfe_e/flanker_main_block_1.csv | 33 + materials/mfe_e/flanker_main_block_10.csv | 33 + materials/mfe_e/flanker_main_block_11.csv | 33 + materials/mfe_e/flanker_main_block_12.csv | 33 + materials/mfe_e/flanker_main_block_2.csv | 33 + materials/mfe_e/flanker_main_block_3.csv | 33 + materials/mfe_e/flanker_main_block_4.csv | 33 + materials/mfe_e/flanker_main_block_5.csv | 33 + materials/mfe_e/flanker_main_block_6.csv | 33 + materials/mfe_e/flanker_main_block_7.csv | 33 + materials/mfe_e/flanker_main_block_8.csv | 33 + materials/mfe_e/flanker_main_block_9.csv | 33 + materials/mfe_e/flanker_practice_block.csv | 21 + materials/mfe_e/img/cover_background.png | Bin 0 -> 4808 bytes materials/mfe_e/img/fixationCross.png | Bin 0 -> 9514 bytes .../mfe_e/img/halfV_trial_csv_creator.asv | 313 ++ materials/mfe_e/img/halfV_trial_csv_creator.m | 318 ++ materials/mfe_e/img/leftArrow.png | Bin 0 -> 26785 bytes .../img/neutralC/flanker_main_block_1.csv | 33 + .../img/neutralC/flanker_main_block_10.csv | 33 + .../img/neutralC/flanker_main_block_11.csv | 33 + .../img/neutralC/flanker_main_block_12.csv | 33 + .../img/neutralC/flanker_main_block_2.csv | 33 + .../img/neutralC/flanker_main_block_3.csv | 33 + .../img/neutralC/flanker_main_block_4.csv | 33 + .../img/neutralC/flanker_main_block_5.csv | 33 + .../img/neutralC/flanker_main_block_6.csv | 33 + .../img/neutralC/flanker_main_block_7.csv | 33 + .../img/neutralC/flanker_main_block_8.csv | 33 + .../img/neutralC/flanker_main_block_9.csv | 33 + .../img/neutralC/flanker_practice_block.csv | 21 + materials/mfe_e/img/neutralC/readMe.rtf | 8 + materials/mfe_e/img/neutralC/surp_table1.csv | 49 + materials/mfe_e/img/neutralC/surp_table2.csv | 49 + materials/mfe_e/img/neutralC/surp_table3.csv | 49 + materials/mfe_e/img/neutralC/surp_table4.csv | 49 + materials/mfe_e/img/neutralC/surp_table5.csv | 49 + materials/mfe_e/img/neutralC/surp_table6.csv | 49 + materials/mfe_e/img/neutralC/surp_table7.csv | 49 + materials/mfe_e/img/neutralC/surp_table8.csv | 49 + materials/mfe_e/img/rightArrow.png | Bin 0 -> 26875 bytes materials/mfe_e/img/transp_fixation.png | Bin 0 -> 4138 bytes materials/mfe_e/img/trial_csv_creator.asv | 240 + materials/mfe_e/index.html | 23 + materials/mfe_e/mfe_e.psyexp | 3326 ++++++++++++ materials/mfe_e/mfe_e.py | 4241 +++++++++++++++ materials/mfe_e/mfe_e_lastrun.py | 4587 +++++++++++++++++ materials/mfe_e/orig_surp_table1.csv | 49 + materials/mfe_e/orig_surp_table2.csv | 49 + materials/mfe_e/orig_surp_table3.csv | 49 + materials/mfe_e/orig_surp_table4.csv | 49 + materials/mfe_e/orig_surp_table5.csv | 49 + materials/mfe_e/orig_surp_table6.csv | 49 + materials/mfe_e/orig_surp_table7.csv | 49 + materials/mfe_e/orig_surp_table8.csv | 49 + .../{task1/protocol.md => mfe_e/readme.md} | 0 materials/mfe_e/readme.txt | 3 + materials/mfe_e/surp_table1.csv | 49 + materials/mfe_e/surp_table2.csv | 49 + materials/mfe_e/surp_table3.csv | 49 + materials/mfe_e/surp_table4.csv | 49 + materials/mfe_e/surp_table5.csv | 49 + materials/mfe_e/surp_table6.csv | 49 + materials/mfe_e/surp_table7.csv | 49 + materials/mfe_e/surp_table8.csv | 49 + materials/mfe_e/surpriseBlock_select_A.xlsx | Bin 0 -> 8987 bytes materials/task1/readme.md | 9 - materials/task1/scripts/readme.md | 7 - materials/task1/stimuli/readme.md | 7 - sourcedata/.DS_Store | Bin 6148 -> 6148 bytes 81 files changed, 17997 insertions(+), 23 deletions(-) create mode 100644 code/stats/mfe_d_face_measure_computations_v2_mini.R create mode 100644 code/stats/mfe_d_face_stats_v3.R create mode 100644 code/stats/mfe_e_face_data_organizer_v1.R create mode 100644 code/stats/mfe_e_face_measure_computations_v1.R create mode 100644 code/stats/mfe_e_face_measure_computations_v2.R create mode 100644 code/stats/mfe_e_face_measure_computations_v3.R create mode 100644 code/stats/mfe_e_face_stats_v1.R create mode 100644 code/stats/mfe_e_face_stats_v2.R create mode 100644 code/stats/mfe_e_face_stats_v3.R create mode 100644 materials/mfe_e/blockSelect.csv create mode 100644 materials/mfe_e/blockSelect_practice.csv create mode 100644 materials/mfe_e/flanker_main_block_1.csv create mode 100644 materials/mfe_e/flanker_main_block_10.csv create mode 100644 materials/mfe_e/flanker_main_block_11.csv create mode 100644 materials/mfe_e/flanker_main_block_12.csv create mode 100644 materials/mfe_e/flanker_main_block_2.csv create mode 100644 materials/mfe_e/flanker_main_block_3.csv create mode 100644 materials/mfe_e/flanker_main_block_4.csv create mode 100644 materials/mfe_e/flanker_main_block_5.csv create mode 100644 materials/mfe_e/flanker_main_block_6.csv create mode 100644 materials/mfe_e/flanker_main_block_7.csv create mode 100644 materials/mfe_e/flanker_main_block_8.csv create mode 100644 materials/mfe_e/flanker_main_block_9.csv create mode 100644 materials/mfe_e/flanker_practice_block.csv create mode 100644 materials/mfe_e/img/cover_background.png create mode 100644 materials/mfe_e/img/fixationCross.png create mode 100644 materials/mfe_e/img/halfV_trial_csv_creator.asv create mode 100644 materials/mfe_e/img/halfV_trial_csv_creator.m create mode 100644 materials/mfe_e/img/leftArrow.png create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_1.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_10.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_11.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_12.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_2.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_3.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_4.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_5.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_6.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_7.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_8.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_main_block_9.csv create mode 100644 materials/mfe_e/img/neutralC/flanker_practice_block.csv create mode 100644 materials/mfe_e/img/neutralC/readMe.rtf create mode 100644 materials/mfe_e/img/neutralC/surp_table1.csv create mode 100644 materials/mfe_e/img/neutralC/surp_table2.csv create mode 100644 materials/mfe_e/img/neutralC/surp_table3.csv create mode 100644 materials/mfe_e/img/neutralC/surp_table4.csv create mode 100644 materials/mfe_e/img/neutralC/surp_table5.csv create mode 100644 materials/mfe_e/img/neutralC/surp_table6.csv create mode 100644 materials/mfe_e/img/neutralC/surp_table7.csv create mode 100644 materials/mfe_e/img/neutralC/surp_table8.csv create mode 100644 materials/mfe_e/img/rightArrow.png create mode 100644 materials/mfe_e/img/transp_fixation.png create mode 100644 materials/mfe_e/img/trial_csv_creator.asv create mode 100644 materials/mfe_e/index.html create mode 100644 materials/mfe_e/mfe_e.psyexp create mode 100644 materials/mfe_e/mfe_e.py create mode 100644 materials/mfe_e/mfe_e_lastrun.py create mode 100644 materials/mfe_e/orig_surp_table1.csv create mode 100644 materials/mfe_e/orig_surp_table2.csv create mode 100644 materials/mfe_e/orig_surp_table3.csv create mode 100644 materials/mfe_e/orig_surp_table4.csv create mode 100644 materials/mfe_e/orig_surp_table5.csv create mode 100644 materials/mfe_e/orig_surp_table6.csv create mode 100644 materials/mfe_e/orig_surp_table7.csv create mode 100644 materials/mfe_e/orig_surp_table8.csv rename materials/{task1/protocol.md => mfe_e/readme.md} (100%) create mode 100644 materials/mfe_e/readme.txt create mode 100644 materials/mfe_e/surp_table1.csv create mode 100644 materials/mfe_e/surp_table2.csv create mode 100644 materials/mfe_e/surp_table3.csv create mode 100644 materials/mfe_e/surp_table4.csv create mode 100644 materials/mfe_e/surp_table5.csv create mode 100644 materials/mfe_e/surp_table6.csv create mode 100644 materials/mfe_e/surp_table7.csv create mode 100644 materials/mfe_e/surp_table8.csv create mode 100644 materials/mfe_e/surpriseBlock_select_A.xlsx delete mode 100644 materials/task1/readme.md delete mode 100644 materials/task1/scripts/readme.md delete mode 100644 materials/task1/stimuli/readme.md diff --git a/code/stats/mfe_d_face_measure_computations_v2_mini.R b/code/stats/mfe_d_face_measure_computations_v2_mini.R new file mode 100644 index 0000000..b4b30b6 --- /dev/null +++ b/code/stats/mfe_d_face_measure_computations_v2_mini.R @@ -0,0 +1,146 @@ +# This script will load, and organize the pavlovia data. Then, computes measures of interest. +# For each participant, a single, new, organized csv file that has all the necessary information will be generated. +# Author: Kianoosh Hosseini at NDCLab @FIU (https://Kianoosh.info; https://NDClab.com) +# Last Update: 2024-10-17 (YYYY-MM-DD) +# This version computes hit rates by binning the face delay. +### This version just computes number of errors for all participants without any exclusion. + +library(tidyverse) +library(dplyr) +library(stringr) +library(psycho) # to compute d' measures, etc. + +#Working directory should be the Psychopy experiment directory. +proje_wd <- "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-d-dataset" +setwd(proje_wd) + + +input_raw_path <- paste(proje_wd, "sourcedata", "checked", "psychopy", sep ="/", collapse = NULL) # input data directory +input_organized_path <- paste(proje_wd, "derivatives", "psychopy", "csv_output", sep ="/", collapse = NULL) # input directory for data files generated by the organizer script! +output_path <- paste(proje_wd, "derivatives", "psychopy", "stat_output", sep ="/", collapse = NULL) # output directory +proc_fileName <- "processed_data_mfe_d_Proj_v3.csv" # output filename +flanker_csv_fileName <- "_mfe_d_flankerDat_v1.csv" # each output csv file will have this on its filename +surprise_csv_fileName <- "_mfe_d_surpriseDat_v1.csv" # each output csv file will have this on its filename + + +## creating a list of all raw data csv files in the input folder. +raw_datafiles_list <- c() # an empty list that will be filled in the next "for" loop! +csvSelect <- list.files(input_raw_path, pattern = ".csv") # listing only csv files +for (i in 1:length(csvSelect)){ + temp_for_file <- ifelse (str_detect(csvSelect[i], "mfe_d", negate = FALSE), 1, 0) + if (temp_for_file == 1){ + temp_list <- csvSelect[i] + raw_datafiles_list <- c(raw_datafiles_list, temp_list) + } +} +# Creating the main empty dataframe that will be filled with the data from the loop below: +main_df <- setNames(data.frame(matrix(ncol = 25, nrow = 0)), c("participant_id", "congAcc", "incongAcc", + "incongruent_dat_meanRT", "errorDat_meanRT", "congruent_dat_meanRT", "corrDat_meanRT", + "congCorr_meanRT", "incongCorr_meanRT", "congCorr_logMeanRT", + "congErr_meanRT", "incongErr_meanRT", "congErr_logMeanRT", "incongErr_logMeanRT", + "incongCorr_logMeanRT", "flankEff_meanACC", "flankEff_meanRT", "flankEff_logMeanRT", + "reported_errors", "committed_errors", "memoryBias_score", "num_incong_errorDat", + "faceDuration_avg", "faceDuration_min", "faceDuration_max")) + + +# Looping over all participants +for (subject in 1:length(raw_datafiles_list)){ + #for this participant, find the raw csv file + psychopy_file <- paste(input_raw_path,raw_datafiles_list[subject], sep = "/", collapse = NULL) + + #read in the data for this participant, establish id, and remove extraneous variables + psychopyDat <- read.csv(file = psychopy_file, stringsAsFactors = FALSE, na.strings=c("", "NA")) + participant_id <- psychopyDat$id[1] + + # Load this participant's flanker and surprise data frames + flanker_name <- paste0(participant_id, flanker_csv_fileName, sep = "", collapse = NULL) + surprise_name <- paste0(participant_id, surprise_csv_fileName, sep = "", collapse = NULL) + flanker_df <- read.csv(file = paste(input_organized_path, flanker_name, sep = "/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + surprise_df <- read.csv(file = paste(input_organized_path, surprise_name, sep = "/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + + + incong_flankerDat <- filter(flanker_df, current_trial_congruency == 0) + cong_flankerDat <- filter(flanker_df, current_trial_congruency == 1) + + incongAcc <- mean(as.numeric(incong_flankerDat$current_trial_accuracy)) + congAcc <- mean(as.numeric(cong_flankerDat$current_trial_accuracy)) + + # subset the data for correct and error trials, separately for congruent and incongruent trials, creating new data frames for each + corrDat <- flanker_df[flanker_df$current_trial_accuracy == 1,] + corrDat_meanRT <- mean(corrDat$current_trial_rt, na.rm = TRUE) + + congruent_dat <- flanker_df[flanker_df$current_trial_congruency == 1,] + congruent_dat_meanRT <- mean(congruent_dat$current_trial_rt, na.rm = TRUE) + + cong_corrDat <- corrDat[corrDat$current_trial_congruency == 1,] + incong_corrDat <- corrDat[corrDat$current_trial_congruency == 0,] + + errorDat <- flanker_df[flanker_df$current_trial_accuracy == 0,] + errorDat_meanRT <- mean(errorDat$current_trial_rt, na.rm = TRUE) + + incongruent_dat <- flanker_df[flanker_df$current_trial_congruency == 0,] + incongruent_dat_meanRT <- mean(incongruent_dat$current_trial_rt, na.rm = TRUE) + + + cong_errorDat <- errorDat[errorDat$current_trial_congruency == 1,] + incong_errorDat <- errorDat[errorDat$current_trial_congruency == 0,] + #for correct trials, compute mean RT (raw and log-corrected) + congCorr_meanRT <- mean(cong_corrDat$current_trial_rt, na.rm = TRUE) + incongCorr_meanRT <- mean(incong_corrDat$current_trial_rt, na.rm = TRUE) + + congErr_meanRT <- mean(cong_errorDat$current_trial_rt, na.rm = TRUE) + incongErr_meanRT <- mean(incong_errorDat$current_trial_rt, na.rm = TRUE) + + congCorr_logMeanRT <- mean(log((1+cong_corrDat$current_trial_rt)), na.rm = TRUE) + incongCorr_logMeanRT <- mean(log((1+incong_corrDat$current_trial_rt)), na.rm = TRUE) + + congErr_logMeanRT <- mean(log((1+cong_errorDat$current_trial_rt)), na.rm = TRUE) + incongErr_logMeanRT <- mean(log((1+incong_errorDat$current_trial_rt)), na.rm = TRUE) + + # compute flanker-effect scores for accuracy, RT, log-RT + flankEff_meanACC <- incongAcc - congAcc + flankEff_meanRT <- incongCorr_meanRT - congCorr_meanRT + flankEff_logMeanRT <- incongCorr_logMeanRT - congCorr_logMeanRT + + # + # number of committed errors in the flanker task + committed_errors <- nrow(errorDat) + # number of reported errors + psychopyDatTrim <- psychopyDat[("errorNum_text_box.text")] # stores the number of reported errors by subjects + reported_errors <- subset(psychopyDatTrim, complete.cases(psychopyDatTrim$errorNum_text_box.text)) + reported_errors <- reported_errors$errorNum_text_box.text # number of reported errors by participants + reported_errors <- str_extract_all(reported_errors, '\\d+\\.?\\d*') # to extract all sequences of digits from the input string + # There was a participant who had reported 70/100. values 70 and 100. To solve this issue, I replace this kind of values with NAs! + if (length(reported_errors) == 0){ # there is no reported errors + reported_errors <- NA + memoryBias_score <- NA + } else { + reported_errors <- parse_number(reported_errors[[1]]) # in cases like 70/100, we will have 70 100 at this stage. So, length(reported_errors) will + # higher than 1. + if (length(reported_errors) > 1){ # In case they have reported sth like 70/100 + reported_errors <- NA + memoryBias_score <- NA + } else if (length(reported_errors) == 1){ + reported_errors <- reported_errors[1] + memoryBias_score <- ((reported_errors - committed_errors)/ reported_errors) # percent bias score calculation + } + } + + + num_incong_errorDat <- nrow(incong_errorDat) + faceDuration_avg <- mean(flanker_df$current_trial_faceDuration) + faceDuration_min <- min(flanker_df$current_trial_faceDuration) + faceDuration_max <- max(flanker_df$current_trial_faceDuration) + #### filling the main data frame + main_df[nrow(main_df) + 1,] <-c(participant_id, congAcc, incongAcc, + incongruent_dat_meanRT, errorDat_meanRT, congruent_dat_meanRT, corrDat_meanRT, + congCorr_meanRT, incongCorr_meanRT, congCorr_logMeanRT, + congErr_meanRT, incongErr_meanRT, congErr_logMeanRT, incongErr_logMeanRT, + incongCorr_logMeanRT, flankEff_meanACC, flankEff_meanRT, flankEff_logMeanRT, + reported_errors, committed_errors, memoryBias_score, num_incong_errorDat, + faceDuration_avg, faceDuration_min, faceDuration_max) +} # Closing the loop for each participant + + + + diff --git a/code/stats/mfe_d_face_stats_v3.R b/code/stats/mfe_d_face_stats_v3.R new file mode 100644 index 0000000..846eb56 --- /dev/null +++ b/code/stats/mfe_d_face_stats_v3.R @@ -0,0 +1,272 @@ +# This script will run stats on mini_mfe data. +# Author: Kianoosh Hosseini at NDCLab @FIU (https://Kianoosh.info; https://NDClab.com) +# Last Update: 2024-10-02 (YYYY-MM-DD) + +library(tidyverse) +library(dplyr) +library(stringr) +library(psycho) +library(car) +library(lme4) +library(ggplot2) +library(emmeans) +library(report) +library(sjPlot) +library(effsize) + + +#Working directory should be the Psychopy experiment directory. +proje_wd <- "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-d-dataset" +setwd(proje_wd) + +processed_file_input <- paste(proje_wd, "derivatives", "psychopy", "stat_output", sep ="/", collapse = NULL) # input data directory + +main_df <- read.csv(file = paste(processed_file_input, "processed_data_mfe_d_Proj_v3.csv", sep ="/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + + +# Check the values in every column in main_df and remove the outliers based on +- 3SD. +# Write a function that removes the outliers from an array +remove_outliers <- function(x) { + mean_x <- mean(as.numeric(x), na.rm = TRUE) + sd_x <- sd(as.numeric(x), na.rm = TRUE) + for (xx in 1:length(x)){ + if (!is.na(x[xx])){ + if (x[xx] < (mean_x - 3*sd_x) | x[xx] > (mean_x + 3*sd_x)){ + x[xx] <- NA + } + } + } + return(x) +} +# apply this outlier removing function to all the columns in the dataframe except for participant ID column. +new_main_df <- main_df +new_main_df[-c(1, ncol(new_main_df))] <- apply(main_df[-c(1, ncol(main_df))], 2, remove_outliers) +main_df <- new_main_df + +mean(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # +sd(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # +median(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # + + +mean(main_df$post_error_acc, na.rm = TRUE) # +sd(main_df$post_error_acc, na.rm = TRUE) # + + +mean(main_df$post_error_rt, na.rm = TRUE) # +sd(main_df$post_error_rt, na.rm = TRUE) # + + +# flanker task stats +# Accuracy +mean(main_df$congAcc, na.rm = TRUE) +sd(main_df$congAcc, na.rm = TRUE) +# normality test +shapiro.test(main_df$congAcc) + + +mean(main_df$incongAcc, na.rm = TRUE) +sd(main_df$incongAcc, na.rm = TRUE) + +shapiro.test(main_df$incongAcc) +median(main_df$incongAcc, na.rm = TRUE) +IQR(main_df$incongAcc, na.rm = TRUE) +median(main_df$congAcc, na.rm = TRUE) +IQR(main_df$congAcc, na.rm = TRUE) + +# as they are not normal, we perform non-parametric Wilcoxon test instead of t-test +wil_acc <- wilcox.test(main_df$congAcc, main_df$incongAcc, alternative = 'greater', paired = TRUE, na.action = na.omit) +Z_acc <- qnorm(wil_acc$p.value/2) # z-score +r_acc <- abs(Z_acc)/sqrt(32) # r (effect size) However, I reported Cohen's d in the paper. # formulas are from https://stats.stackexchange.com/questions/330129/how-to-get-the-z-score-in-wilcox-test-in-r#:~:text=How%20can%20i%20get%20the,for%20wilcox%20test%20in%20R%3F&text=The%20R%20code%20never%20stores,to%20the%20equivalent%20z%2Dscore. +cohen.d(main_df$congAcc, main_df$incongAcc, paired=TRUE) + + +# RT (unit in seconds) +mean(main_df$congCorr_meanRT, na.rm = TRUE) +sd(main_df$congCorr_meanRT, na.rm = TRUE) +shapiro.test(main_df$congCorr_meanRT) +median(main_df$congCorr_meanRT, na.rm = TRUE) +IQR(main_df$congCorr_meanRT, na.rm = TRUE) + +mean(main_df$incongCorr_meanRT, na.rm = TRUE) +sd(main_df$incongCorr_meanRT, na.rm = TRUE) +shapiro.test(main_df$incongCorr_meanRT) +median(main_df$incongCorr_meanRT, na.rm = TRUE) +IQR(main_df$incongCorr_meanRT, na.rm = TRUE) + +mean(main_df$congErr_meanRT, na.rm = TRUE) +sd(main_df$congErr_meanRT, na.rm = TRUE) +shapiro.test(main_df$congErr_meanRT) + + +mean(main_df$incongErr_meanRT, na.rm = TRUE) +sd(main_df$incongErr_meanRT, na.rm = TRUE) +shapiro.test(main_df$incongErr_meanRT) + + +wil_RT <- wilcox.test(main_df$congCorr_meanRT, main_df$incongCorr_meanRT, alternative = 'less', paired = TRUE, na.action = na.omit) +Z_RT <- qnorm(wil_RT$p.value/2) +r_RT <- abs(Z_RT)/sqrt(32) +cohen.d(main_df$congCorr_meanRT, main_df$incongCorr_meanRT,paired=TRUE) +report(wilcox.test(main_df$congCorr_meanRT, main_df$incongCorr_meanRT, alternative = 'less', paired = TRUE, na.action = na.omit)) +################################################## +# Surprise memory task in mfe_c_face task +mean(main_df$overall_hitRate, na.rm = TRUE) +sd(main_df$overall_hitRate, na.rm = TRUE) + +mean(main_df$early_error_hitRate, na.rm = TRUE) +sd(main_df$early_error_hitRate, na.rm = TRUE) +shapiro.test(main_df$error_hitRate) # + +mean(main_df$late_error_hitRate, na.rm = TRUE) +sd(main_df$late_error_hitRate, na.rm = TRUE) + +mean(main_df$early_correct_hitRate, na.rm = TRUE) # +sd(main_df$early_correct_hitRate, na.rm = TRUE) # + +mean(main_df$late_correct_hitRate, na.rm = TRUE) # +sd(main_df$late_correct_hitRate, na.rm = TRUE) # + +shapiro.test(main_df$correct_hitRate) # + +mean(main_df$post_error_hitRate, na.rm = TRUE) +sd(main_df$post_error_hitRate, na.rm = TRUE) +shapiro.test(main_df$post_error_hitRate) # + +mean(main_df$post_correct_hitRate, na.rm = TRUE) # +sd(main_df$post_correct_hitRate, na.rm = TRUE) # +shapiro.test(main_df$post_correct_hitRate) # + + +t.test(main_df$early_correct_hitRate, main_df$early_error_hitRate, paired = TRUE, na.action = na.omit) # +t.test(main_df$late_correct_hitRate, main_df$late_error_hitRate, paired = TRUE, na.action = na.omit) #sig + + +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$overall_hitRate, method = 'pearson', na.action = na.omit) +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$flankEff_meanACC, method = 'pearson', na.action = na.omit) +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$incongAcc, method = 'pearson', na.action = na.omit) + + +################################################## +# Hit Rate correlation with SCAARED social + +lm_for_cor_fit_line <- lm(early_hitRate_error_minus_correct ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=early_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "EARLY Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=early_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "EARLY Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=early_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "EARLY Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +lm_for_cor_fit_line <- lm(late_hitRate_error_minus_correct ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$late_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=late_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "late Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +lm_for_cor_fit_line <- lm(late_error_hitRate ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=late_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "late Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=late_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "late Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + + +# scaared total +lm_for_cor_fit_line <- lm(early_hitRate_error_minus_correct ~ scaared_b_scrdTotal_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$early_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=early_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "early Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=early_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "early Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=early_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "early Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + + +lm_for_cor_fit_line <- lm(late_hitRate_error_minus_correct ~ scaared_b_scrdTotal_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$late_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=late_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "late Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=late_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "late Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=late_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "late Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +# Hit Rate correlation with SCAARED GA + +lm_for_cor_fit_line <- lm(hitRate_error_minus_correct ~ scaared_b_scrdGA_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdGA_s1_r1_e1, main_df$hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdGA_s1_r1_e1, y=hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED General anxiety score", y = "Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +cor.test(main_df$scaared_b_scrdGA_s1_r1_e1, main_df$hitRate_post_error_minus_correct, method = 'pearson', na.action = na.omit) + + + +current_pep_HR_reg <- lm(hitRate_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdSoc_s1_r1_e1 , data = main_df) +summary(current_pep_HR_reg) +# plot +plot_model(current_pep_HR_reg, type = "eff", terms = c("epepq15_scrdTotal_s1_r1_e1","scaared_b_scrdSoc_s1_r1_e1")) + + + + +current_pep_HR_reg <- lm(hitRate_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdGA_s1_r1_e1 , data = main_df) +summary(current_pep_HR_reg) +# plot + + +########################## POST +post_pep_HR_reg <- lm(hitRate_post_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdSoc_s1_r1_e1 , data = main_df) +summary(post_pep_HR_reg) +# plot +plot_model(post_pep_HR_reg, type = "eff", terms = c("epepq15_scrdTotal_s1_r1_e1","scaared_b_scrdSoc_s1_r1_e1")) + + +post_pep_HR_reg <- lm(hitRate_post_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdGA_s1_r1_e1 , data = main_df) +summary(post_pep_HR_reg) +# plot \ No newline at end of file diff --git a/code/stats/mfe_e_face_data_organizer_v1.R b/code/stats/mfe_e_face_data_organizer_v1.R new file mode 100644 index 0000000..046778b --- /dev/null +++ b/code/stats/mfe_e_face_data_organizer_v1.R @@ -0,0 +1,344 @@ +# This script will load, and organize the Psychopy data for the mfe_e (face) study. +# For each participant, a single, new, organized csv file that has all the necessary information will be generated. +# Author: Kianoosh Hosseini at NDCLab @FIU (https://Kianoosh.info; https://NDClab.com) +# Last Update: 2024-12-04 (YYYY-MM-DD) + +library(tidyverse) +library(dplyr) +library(stringr) + +#Working directory should be the Psychopy experiment directory. +proje_wd <- "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset" +setwd(proje_wd) + +# Defining the input and output folders. +input_path <- paste(proje_wd, "sourcedata", "checked", "psychopy", sep ="/", collapse = NULL) # input data directory +output_path <- paste(proje_wd, "derivatives", "psychopy", "csv_output", sep ="/", collapse = NULL) # Directory that each new csv file will be stored +flanker_csv_fileName <- "_mfe_e_flankerDat_v1.csv" # each output csv file will have this on its filename +surprise_csv_fileName <- "_mfe_e_surpriseDat_v1.csv" # each output csv file will have this on its filename + + +## creating a list of all data csv files in the input folder. +datafiles_list <- c() # an empty list that will be filled in the next "for" loop! +csvSelect <- list.files(input_path, pattern = ".csv") # listing only csv files +for (i in 1:length(csvSelect)){ + temp_for_file <- ifelse (str_detect(csvSelect[i], "mfe_e", negate = FALSE), 1, 0) + if (temp_for_file == 1){ + temp_list <- csvSelect[i] + datafiles_list <- c(datafiles_list, temp_list) + } +} + + + +# will loop over all participant datafiles. +for(subject in 1:length(datafiles_list)){ + # creating an empty data frame that will store all the information drawn from the flanker task of a participant. + # This data frame will be saved as a csv file for this participant. + flanker_df <- setNames(data.frame(matrix(ncol = 31, nrow = 0)), c("participant_id", "current_trial_face", "pre_trial_face", "post_trial_face", + "current_trial_accuracy", "pre_trial_accuracy", "post_trial_accuracy", + "current_trial_congruency", "pre_trial_congruency", "post_trial_congruency", + "current_trial_rt", "pre_trial_rt", "post_trial_rt", + "current_trial_responded", "pre_trial_responded", "post_trial_responded", + "current_trial_legitResponse", "pre_trial_legitResponse", "post_trial_legitResponse", + "current_trial_resp_nums", "pre_trial_resp_nums", "post_trial_resp_nums", + "current_trial_resp_less_than_a_sec", "pre_trial_resp_less_than_a_sec", "post_trial_resp_less_than_a_sec", + "current_trial_face_delay_time", "pre_trial_face_delay_time", "post_trial_face_delay_time", + "current_trial_faceDuration", "pre_trial_faceDuration", "post_trial_faceDuration")) + # creating an empty data frame that will store all the information drawn from the surprise task of a participant. + # This data frame will be saved as a csv file for this participant. + surprise_df <- setNames(data.frame(matrix(ncol = 5, nrow = 0)), c("participant_id", "face", "surpAcc", "memory_surp_responses", "memory_surp_rt")) + + #for this participant, find the csv file + psychopy_file <- paste(input_path,datafiles_list[subject], sep = "/", collapse = NULL) + + #read in the data for this participant, establish id, and remove extraneous variables + psychopyDat <- read.csv(file = psychopy_file, stringsAsFactors = FALSE, na.strings=c("", "NA")) + participant_id <- psychopyDat$id[1] + + psychopyDatTrim <- psychopyDat[c("id", + "old_face_in_surp", # the old faces displayed in the surp task + "which_side_old_face_displayed", + "surprise_key_resp.keys", # The answers in the surprise task + "surprise_key_resp.rt", # The RTs of the answers in the surprise task + "congruent", # whether the flanker trial is congruent + "stimNum", + "accuracy", # whether the flanker trial response is correct + "current_flanker_routine_time", # true length of the time + "face_delay_time", # the delay between beginning of the the second flanker routine (either right after participant's response or 1 second after the start of the first routine in case of no response) and the face appearance + "faceDuration", #how long the face image is displayed + "faceDuration_plus_faceDelay_time", # the length of the second routine + "task1_stim_keyResp.keys", # the flanker trial responses before the face appearance + "task_stim_keyResp2.keys", # the flanker trial responses during the routine in which the face appears + "errorNum_text_box.text", # stores the number of reported errors after the flanker task + "prac_cover_background.started", # allows to remove the flanker practice trials + "straightFace", # the face images shown during the flanker task + "task1_stim_keyResp.rt", # this stores reaction time for each flanker trial before the face appearance + #"task_stim_keyResp2.rt", # this stores reaction time for each flanker trial during the routine in which the face appears (for subjects with no response during the second routine among all trials, this column will not exist.) + "task_trial_loop.thisTrialN", # the counter of trials within each flanker block + "errorPercent_text_box.text")] # stores the reported percentage of errors after the flanker task + + #remove practice trials and any rows that do not reflect experiment data + remove_prac_trials <- subset(psychopyDatTrim, !complete.cases(psychopyDatTrim$prac_cover_background.started)) # removes practice trials + + flankerDat <- subset(remove_prac_trials, complete.cases(remove_prac_trials$congruent)) # only keeps flanker trials. For this study, flankerDat should have only 384 rows! + + # Extracting the flanker RT during the first routine (the routine that does show the arrows without the face image). + flankerDat$task1_stim_keyResp.rt <- str_replace_all(flankerDat$task1_stim_keyResp.rt,"\\[", "") # removes the bracket + flankerDat$task1_stim_keyResp.rt <- str_replace_all(flankerDat$task1_stim_keyResp.rt,"\\]", "") # removes the bracket + flankerDat$task1_stim_keyResp.rt <- gsub(",.*","",flankerDat$task1_stim_keyResp.rt) # removing the RT of the second response within the same trial. + flankerDat$task1_stim_keyResp.rt <- as.numeric(flankerDat$task1_stim_keyResp.rt) + + + # Lets add a column that tells how many responses have been made in a given flanker trial + # Given the nature of this task, if a participant responds within 1-second of the start of the trial (starting with showing flanking arrows), + # the routine ends and the next routine, in which the face image appears, starts. + # Determine whether a response was made during the first routine and then count it. + for (flanker_trial in 1:nrow(flankerDat)){ + response_keys <- str_extract_all(flankerDat$task1_stim_keyResp.keys[flanker_trial], "[A-Za-z]+") # to extract all sequences of characters from the input string + # The response_keys is a list with 1 component. To count the number of elements in each component, we use "lengths" function. + if (response_keys[[1]][1] == "None"){ + flankerDat$responded_less_than_a_sec[flanker_trial] <- 0 # no response in less than 1 second. + } else{ + flankerDat$responded_less_than_a_sec[flanker_trial] <- 1 # responded in less than 1 second. + } + } + # Determine whether a response was made during the second routine (when the face appears) and then count it. + for (flanker_trial in 1:nrow(flankerDat)){ + response_keys <- str_extract_all(flankerDat$task_stim_keyResp2.keys[flanker_trial], "[A-Za-z]+") # to extract all sequences of characters from the input string + # The response_keys is a list with 1 component. To count the number of elements in each component, we use "lengths" function. + if (response_keys[[1]][1] == "None"){ + flankerDat$number_of_responses_after_a_sec[flanker_trial] <- 0 + } else{ + flankerDat$number_of_responses_after_a_sec[flanker_trial] <- lengths(response_keys) + } + } + + # Count the total number of responses in every trial (including both routines) + # Also, if a participant responds in less than a sec, we use the RT from the first routine. + # However, if they don't respond until after one second, we put "NA" for the flanker trial RT. + for (flanker_trial in 1:nrow(flankerDat)){ + if (flankerDat$responded_less_than_a_sec[flanker_trial] == 1){ + flankerDat$number_of_responses[flanker_trial] <- 1 + flankerDat$number_of_responses_after_a_sec[flanker_trial] + flankerDat$flanker_trial_rt[flanker_trial] <- flankerDat$task1_stim_keyResp.rt[flanker_trial] + } else if (flankerDat$responded_less_than_a_sec[flanker_trial] == 0){ + flankerDat$number_of_responses[flanker_trial] <- 0 + flankerDat$number_of_responses_after_a_sec[flanker_trial] + flankerDat$flanker_trial_rt[flanker_trial] <- NA + } + } + + + # loop over all flanker trials. + for (trial in 1:nrow(flankerDat)){ + current_trial_face <- flankerDat$straightFace[trial] + current_trial_congruency <- flankerDat$congruent[trial] + current_trial_rt <- flankerDat$flanker_trial_rt[trial] + current_trial_resp_nums <- flankerDat$number_of_responses[trial] # number of responses for the current trial + current_trial_resp_less_than_a_sec <- flankerDat$responded_less_than_a_sec[trial] + current_trial_face_delay_time <- flankerDat$face_delay_time[trial] + current_trial_faceDuration <- flankerDat$faceDuration[trial] + + if (flankerDat$task_trial_loop.thisTrialN[trial] == 0){ # if the trial is the first in its block + pre_trial_face <- NA + pre_trial_congruency <- NA + pre_trial_rt <- NA + pre_trial_resp_nums <- NA + pre_trial_resp_less_than_a_sec <- NA + pre_trial_face_delay_time <- NA + pre_trial_faceDuration <- NA + } else { + pre_trial_face <- flankerDat$straightFace[trial - 1] + pre_trial_congruency <- flankerDat$congruent[trial - 1] + pre_trial_rt <- flankerDat$flanker_trial_rt[trial - 1] + pre_trial_resp_nums <- flankerDat$number_of_responses[trial - 1] + pre_trial_resp_less_than_a_sec <- flankerDat$responded_less_than_a_sec[trial - 1] + pre_trial_face_delay_time <- flankerDat$face_delay_time[trial - 1] + pre_trial_faceDuration <- flankerDat$faceDuration[trial - 1] + } + if (flankerDat$task_trial_loop.thisTrialN[trial] == 31){ # if the trial is the last in its block + post_trial_face <- NA + post_trial_congruency <- NA + post_trial_rt <- NA + post_trial_resp_nums <- NA + post_trial_resp_less_than_a_sec <- NA + post_trial_face_delay_time <- NA + post_trial_faceDuration <- NA + } else { + post_trial_face <- flankerDat$straightFace[trial + 1] + post_trial_congruency <- flankerDat$congruent[trial + 1] + post_trial_rt <- flankerDat$flanker_trial_rt[trial + 1] + post_trial_resp_nums <- flankerDat$number_of_responses[trial + 1] + post_trial_resp_less_than_a_sec <- flankerDat$responded_less_than_a_sec[trial + 1] + post_trial_face_delay_time <- flankerDat$face_delay_time[trial + 1] + post_trial_faceDuration <- flankerDat$faceDuration[trial + 1] + } + + if (flankerDat$number_of_responses[trial] == 0){ # When no response made in a flanker task trial + current_trial_responded <- 0 # 0 = not responded; 1 = responded + # Because of an error in the Python code for the Psychopy task, the accuracy values reported by Psychopy are not correct in trials with no response. + # Thus, I am putting NAs for accuracy in trials in which no response has been made! + current_trial_accuracy <- 0 # Accuracy is considered 0 when there is no response + } else if (flankerDat$number_of_responses[trial] >= 1){ # When a response made in a flanker task trial + current_trial_responded <- 1 + current_trial_accuracy <- flankerDat$accuracy[trial] + } + if (flankerDat$task_trial_loop.thisTrialN[trial] == 0){ # if the trial is the first in its block + pre_trial_responded <- NA + pre_trial_accuracy <- NA + } else { + if (flankerDat$number_of_responses[trial - 1] == 0){ # When no response made in a flanker task trial + pre_trial_responded <- 0 # 0 = not responded; 1 = responded + pre_trial_accuracy <- 0 # Accuracy is considered 0 when there is no response + } else if (flankerDat$number_of_responses[trial - 1 ] >= 1){ # When a response made in a flanker task trial + pre_trial_responded <- 1 + pre_trial_accuracy <- flankerDat$accuracy[trial - 1] + } + } + if (flankerDat$task_trial_loop.thisTrialN[trial] == 31){ # if the trial is the last in its block + post_trial_responded <- NA + post_trial_accuracy <- NA + } else { + if (flankerDat$number_of_responses[trial + 1] == 0){ # When no response made in a flanker task trial + post_trial_responded <- 0 # 0 = not responded; 1 = responded + post_trial_accuracy <- 0 # Accuracy is considered 0 when there is no response + } else if (flankerDat$number_of_responses[trial + 1 ] >= 1){ # When a response made in a flanker task trial + post_trial_responded <- 1 + post_trial_accuracy <- flankerDat$accuracy[trial + 1] + } + } + # if a flanker response occurs after 1 second (during the second routine), we will mark a non-legiResponse. + if (current_trial_responded == 1 && !is.na(current_trial_rt) && current_trial_rt > 0.15 ){ + current_trial_legitResponse <- 1 + } else { + current_trial_legitResponse <- 0 + } + if (flankerDat$task_trial_loop.thisTrialN[trial] == 0){ + pre_trial_legitResponse <- NA + } else { + if (pre_trial_responded == 1 && !is.na(pre_trial_rt) && pre_trial_rt > 0.15 ){ + pre_trial_legitResponse <- 1 + } else { + pre_trial_legitResponse <- 0 + } + } + + if (flankerDat$task_trial_loop.thisTrialN[trial] == 31){ + post_trial_legitResponse <- NA + } else { + if (post_trial_responded == 1 && !is.na(post_trial_rt) && post_trial_rt > 0.15 ){ + post_trial_legitResponse <- 1 + } else { + post_trial_legitResponse <- 0 + } + } + + + flanker_df[nrow(flanker_df) + 1,] <-c(participant_id, current_trial_face, pre_trial_face, post_trial_face, + current_trial_accuracy, pre_trial_accuracy, post_trial_accuracy, + current_trial_congruency, pre_trial_congruency, post_trial_congruency, + current_trial_rt, pre_trial_rt, post_trial_rt, + current_trial_responded, pre_trial_responded, post_trial_responded, + current_trial_legitResponse, pre_trial_legitResponse, post_trial_legitResponse, + current_trial_resp_nums, pre_trial_resp_nums, post_trial_resp_nums, + current_trial_resp_less_than_a_sec, pre_trial_resp_less_than_a_sec, post_trial_resp_less_than_a_sec, + current_trial_face_delay_time, pre_trial_face_delay_time, post_trial_face_delay_time, + current_trial_faceDuration, pre_trial_faceDuration, post_trial_faceDuration) + } # Closing the loop for each trial + + flanker_name <- paste0(participant_id, flanker_csv_fileName, sep = "", collapse = NULL) + write.csv(flanker_df, paste(output_path, flanker_name, sep = "/", collapse = NULL), row.names=FALSE) # Writing the flanker CSV file to disk + + ## Creating the Surprise csv file for each participant + # We have one surprise task in this study (i.e., Surprise memory) + surprise_memory_dat <- subset(remove_prac_trials, complete.cases(remove_prac_trials$old_face_in_surp)) # keeps rows from the surprise memory task + + # Looping through surprise memory trials. + for (surpTrial in 1:nrow(surprise_memory_dat)){ + face <- surprise_memory_dat$old_face_in_surp[surpTrial] + if (surprise_memory_dat$which_side_old_face_displayed[surpTrial] == "right"){ + surpAcc <- ifelse(surprise_memory_dat$surprise_key_resp.keys[surpTrial] == "k", 1, 0) # correctly chose the old face, the output will be 1, otherwise 0 + } else if (surprise_memory_dat$which_side_old_face_displayed[surpTrial] == "left"){ + surpAcc <- ifelse(surprise_memory_dat$surprise_key_resp.keys[surpTrial] == "s", 1, 0) # correctly chose the old face, the output will be 1, otherwise 0 + } + memory_surp_rt <- surprise_memory_dat$surprise_key_resp.rt[surpTrial] + memory_surp_responses <- surprise_memory_dat$surprise_key_resp.keys[surpTrial] + surprise_df[nrow(surprise_df) + 1,] <-c(participant_id, face, surpAcc, memory_surp_responses, memory_surp_rt) + + } # closing the surprise memory trial loop + # Adding an additional column to surprise_df to identify whether we should keep that trial in the surprise memory task or not (based on RT). + + for (kk in 1:nrow(surprise_df)){ + surprise_df$keep_surp_memory_trial_based_on_rt[kk] <- ifelse (surprise_df$memory_surp_rt[kk] > 0.2, 1, 0) # 0.2 is 200 msec for the reaction time. + } + + # Adding a column that tells to which surprise block a given surp trial belongs. + surprise_df$surp_block_num <- rep(1:8, each = 48) + + # If a participant has 3 blocks to be removed due to the following criteria, that participant will + # be excluded. However, if a participant has two or less than two blocks for exclusion, we keep those blocks and the participant + # and do not exclude them. + # The Block exclusion criteria are: + # 1. If a person has chosen the same response in >= 90% cases in a given surprise task block, that block will be marked for exclusion. + # TBD 2. If a person has chosen the same response for at least 20 times in a row in a given surprise block, that block will be marked for exclusion. + + # Add columns that identifies whether a given surprise block will be excluded or not as well as the number of used items + # in responding to surprise trials (max will be 6). + surprise_df <- surprise_df %>% + add_column(exclude_block = NA, number_of_surp_resp_items_used = NA) + surprise_df$number_of_surp_resp_items_used <- length(group_size(group_by(surprise_df,memory_surp_responses))) + + num_sub_blocks_excluded <- 0 # will count the number of to-be-excluded blocks for the current participant + for (surp_block in 1:8){ + # Step 1: Select rows of the current surprise block + selected_rows <- surprise_df[surprise_df$surp_block_num == surp_block, ] + + # Step 2: Compute the percentage of the most used response in the current surprise task. + percent_of_max_surp_response <- (max(group_size(group_by(selected_rows,memory_surp_responses)))/sum(group_size(group_by(selected_rows,memory_surp_responses)))) * 100 # Percentage of the most chosen response in this block + + # Step 3: If the the most common response has been used >= 90 %, the current block will be marked for exclusion. + if (percent_of_max_surp_response >= 90){ + surprise_df[surprise_df$surp_block_num == surp_block, "exclude_block"] <- 1 + ### Printing output + print(paste("Block ", surp_block," of participant", participant_id," was makrked for exclusion due to response frequency criterion.")) + #### end of printing output + num_sub_blocks_excluded <- num_sub_blocks_excluded + 1 + # we use 'next' to jump to the next block without further checking for the second criterion. + next # jumps to the next iteration of the 'for' loop which is the next block + } else if (percent_of_max_surp_response < 90){ + surprise_df[surprise_df$surp_block_num == surp_block, "exclude_block"] <- 0 + # We check for the second criterion: + # 2. If a person has chosen the same response for at least times in a row in a given + # surprise block, that block will be marked for exclusion. + + for (surprise_block_trial in 1:(nrow(selected_rows) - 19)){ + the_same_surp_answer_counter <- 1 + ref_surp_answer <- selected_rows$memory_surp_responses[surprise_block_trial] + for (ggg in 1:19){ + following_surp_answer <- selected_rows$memory_surp_responses[surprise_block_trial + ggg] + same_answer <- ifelse (ref_surp_answer == following_surp_answer, 1, 0) + if (same_answer){ + the_same_surp_answer_counter <- the_same_surp_answer_counter + 1 + } else{ + break # the answer is different. so, I break the counter loop to proceed with the following surprise_block_trial. + } + } + # Check to see if the same answer counter is at 20. + if (the_same_surp_answer_counter >= 20){ + surprise_df[surprise_df$surp_block_num == surp_block, "exclude_block"] <- 1 + num_sub_blocks_excluded <- num_sub_blocks_excluded + 1 + ### Printing output + print(paste("Participant ", participant_id, " has repeated ans in block ", surp_block)) + #### end of printing output + break # break this loop to jump to the next block + } + } + } + } + surprise_df$num_blocks_excluded <- num_sub_blocks_excluded + surprise_name <- paste0(participant_id, surprise_csv_fileName, sep = "", collapse = NULL) + write.csv(surprise_df, paste(output_path, surprise_name, sep = "/", collapse = NULL), row.names=FALSE) # Writing the surprise CSV file to disk + + +} # closing the loop for each participant + + diff --git a/code/stats/mfe_e_face_measure_computations_v1.R b/code/stats/mfe_e_face_measure_computations_v1.R new file mode 100644 index 0000000..9d9cd87 --- /dev/null +++ b/code/stats/mfe_e_face_measure_computations_v1.R @@ -0,0 +1,417 @@ +# This script will load, and organize the pavlovia data. Then, computes measures of interest. +# For each participant, a single, new, organized csv file that has all the necessary information will be generated. +# Author: Kianoosh Hosseini at NDCLab @FIU (https://Kianoosh.info; https://NDClab.com) +# Last Update: 2024-12-05 (YYYY-MM-DD) +# This version computes post-trial hit rates as well. +library(tidyverse) +library(dplyr) +library(stringr) +library(psycho) # to compute d' measures, etc. + +#Working directory should be the Psychopy experiment directory. +proje_wd <- "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset" +setwd(proje_wd) + + +input_raw_path <- paste(proje_wd, "sourcedata", "checked", "psychopy", sep ="/", collapse = NULL) # input data directory +input_organized_path <- paste(proje_wd, "derivatives", "psychopy", "csv_output", sep ="/", collapse = NULL) # input directory for data files generated by the organizer script! +output_path <- paste(proje_wd, "derivatives", "psychopy", "stat_output", sep ="/", collapse = NULL) # output directory +proc_fileName <- "processed_data_mfe_e_Proj_v1.csv" # output filename +flanker_csv_fileName <- "_mfe_e_flankerDat_v1.csv" # each output csv file will have this on its filename +surprise_csv_fileName <- "_mfe_e_surpriseDat_v1.csv" # each output csv file will have this on its filename + + +## creating a list of all raw data csv files in the input folder. +raw_datafiles_list <- c() # an empty list that will be filled in the next "for" loop! +csvSelect <- list.files(input_raw_path, pattern = ".csv") # listing only csv files +for (i in 1:length(csvSelect)){ + temp_for_file <- ifelse (str_detect(csvSelect[i], "mfe_e", negate = FALSE), 1, 0) + if (temp_for_file == 1){ + temp_list <- csvSelect[i] + raw_datafiles_list <- c(raw_datafiles_list, temp_list) + } +} +# Creating the main empty dataframe that will be filled with the data from the loop below: +main_df <- setNames(data.frame(matrix(ncol = 43, nrow = 0)), c("participant_id", "congAcc", "incongAcc", + "incongruent_dat_meanRT", "errorDat_meanRT", "congruent_dat_meanRT", "corrDat_meanRT", + "congCorr_meanRT", "incongCorr_meanRT", "congCorr_logMeanRT", + "congErr_meanRT", "incongErr_meanRT", "congErr_logMeanRT", "incongErr_logMeanRT", + "incongCorr_logMeanRT", "flankEff_meanACC", "flankEff_meanRT", "flankEff_logMeanRT", + "reported_errors", "committed_errors", "memoryBias_score", "overall_hitRate", "error_hitRate", + "correct_hitRate", "num_incong_correctFaces_reported_new", "num_incong_correctFaces_reported_old", + "num_incong_errorFaces_reported_new", "num_incong_errorFaces_reported_old", "hit_num", "false_alrams_num", + "miss_num", "corr_rej_num", "incong_error_hit_num", + "incong_correct_hit_num", "incong_error_miss_num", + "incong_correct_miss_num", "post_error_hitRate", "post_correct_hitRate", "hitRate_error_minus_correct", "hitRate_post_error_minus_correct", "post_error_acc", "post_error_rt", "overall_dPrime")) + +# Counters for the number of excluded people based on each criterion +num_of_participants_removed_based_on_memory_surp_trial_removal <- 0 # Will be updated in the loop below +num_of_participants_removed_based_on_accuracy <- 0 # Will be updated in the loop below +num_of_participants_removed_based_on_incong_error_num <- 0 # Will be updated in the loop below +num_participants_removed_based_on_num_incong_error_faces_in_memory_surp <- 0 # Will be updated in the loop below +num_of_participants_removed_based_on_surp_response_frequency_andOR_repeated_ans <- 0 + +# Looping over all participants +for (subject in 1:length(raw_datafiles_list)){ + #for this participant, find the raw csv file + psychopy_file <- paste(input_raw_path,raw_datafiles_list[subject], sep = "/", collapse = NULL) + + #read in the data for this participant, establish id, and remove extraneous variables + psychopyDat <- read.csv(file = psychopy_file, stringsAsFactors = FALSE, na.strings=c("", "NA")) + participant_id <- psychopyDat$id[1] + + # Load this participant's flanker and surprise data frames + flanker_name <- paste0(participant_id, flanker_csv_fileName, sep = "", collapse = NULL) + surprise_name <- paste0(participant_id, surprise_csv_fileName, sep = "", collapse = NULL) + flanker_df <- read.csv(file = paste(input_organized_path, flanker_name, sep = "/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + surprise_df <- read.csv(file = paste(input_organized_path, surprise_name, sep = "/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + + # removing participants based on whether they just pressed the keys without actually paying attention to the task. + # We check this by "keep_surp_memory_trial_based_on_rt" variables + # in the surprise_df data frame. O means that they have responded faster than 200 ms during the given trial + # and therefore, we need to remove that surprise trial. + # If more than 37.5% of surprise trials are removed, we exclude that participant. + number_of_removed_trials_in_the_memory_surp <- nrow(surprise_df) - (sum(surprise_df$keep_surp_memory_trial_based_on_rt)) + number_of_faces_in_surp_memory_task <- nrow(surprise_df) + surp_rt_threshold <- round(0.375 * number_of_faces_in_surp_memory_task) + + if (number_of_removed_trials_in_the_memory_surp <= surp_rt_threshold){ # Participants who have less than surp_rt_threshold surprise + # trials removed, will be included. + + # Check to see if this participant has the flanker accuracy above 60% + if (mean(as.numeric(flanker_df$current_trial_accuracy)) >= 0.6){ + + # If this participant has at least 3 blocks marked for exclusion (based on response frequency and repeated responses), we exclude them. + if (surprise_df$num_blocks_excluded[1] <= 3){ + + # check to see if the participant has at least 8 legit incongruent errors or not. + incong_flankerDat <- filter(flanker_df, current_trial_congruency == 0) + cong_flankerDat <- filter(flanker_df, current_trial_congruency == 1) + error_incong_flankerDat <- filter(incong_flankerDat, current_trial_accuracy == 0) + legit_error_incong_flankerDat <- filter(error_incong_flankerDat, current_trial_legitResponse == 1) + if (nrow(legit_error_incong_flankerDat) >= 8 ){ + + # Checking to see if there are at least 8 incongruent error faces in the surprise_df of this participant. + # First we need to remove the trials that are marked based on rt! + surprise_df <- filter(surprise_df, keep_surp_memory_trial_based_on_rt == 1) + num_incong_error_faces_in_surp <- 0 + # Counting the number of legit incong error faces available in surprise_df! + for (rr in 1:nrow(legit_error_incong_flankerDat)){ + temp_face <- legit_error_incong_flankerDat$current_trial_face[rr] + temp_for_surp <- filter(surprise_df, face == temp_face) + errorFace_exist_in_surpDat <- ifelse(nrow(temp_for_surp) == 1, 1,0) + if (errorFace_exist_in_surpDat == 1){ + num_incong_error_faces_in_surp <- num_incong_error_faces_in_surp + 1 + } + } # Closing the loop that counts the number of incong error faces available in surprise_df! + if (num_incong_error_faces_in_surp >= 8){ + + incongAcc <- mean(as.numeric(incong_flankerDat$current_trial_accuracy)) + congAcc <- mean(as.numeric(cong_flankerDat$current_trial_accuracy)) + + # subset the data for correct and error trials, separately for congruent and incongruent trials, creating new data frames for each + corrDat <- flanker_df[flanker_df$current_trial_accuracy == 1,] + corrDat_meanRT <- mean(corrDat$current_trial_rt, na.rm = TRUE) + + congruent_dat <- flanker_df[flanker_df$current_trial_congruency == 1,] + congruent_dat_meanRT <- mean(congruent_dat$current_trial_rt, na.rm = TRUE) + + cong_corrDat <- corrDat[corrDat$current_trial_congruency == 1,] + incong_corrDat <- corrDat[corrDat$current_trial_congruency == 0,] + + errorDat <- flanker_df[flanker_df$current_trial_accuracy == 0,] + errorDat_meanRT <- mean(errorDat$current_trial_rt, na.rm = TRUE) + + incongruent_dat <- flanker_df[flanker_df$current_trial_congruency == 0,] + incongruent_dat_meanRT <- mean(incongruent_dat$current_trial_rt, na.rm = TRUE) + + + cong_errorDat <- errorDat[errorDat$current_trial_congruency == 1,] + incong_errorDat <- errorDat[errorDat$current_trial_congruency == 0,] + #for correct trials, compute mean RT (raw and log-corrected) + congCorr_meanRT <- mean(cong_corrDat$current_trial_rt, na.rm = TRUE) + incongCorr_meanRT <- mean(incong_corrDat$current_trial_rt, na.rm = TRUE) + + congErr_meanRT <- mean(cong_errorDat$current_trial_rt, na.rm = TRUE) + incongErr_meanRT <- mean(incong_errorDat$current_trial_rt, na.rm = TRUE) + + congCorr_logMeanRT <- mean(log((1+cong_corrDat$current_trial_rt)), na.rm = TRUE) + incongCorr_logMeanRT <- mean(log((1+incong_corrDat$current_trial_rt)), na.rm = TRUE) + + congErr_logMeanRT <- mean(log((1+cong_errorDat$current_trial_rt)), na.rm = TRUE) + incongErr_logMeanRT <- mean(log((1+incong_errorDat$current_trial_rt)), na.rm = TRUE) + + # compute flanker-effect scores for accuracy, RT, log-RT + flankEff_meanACC <- incongAcc - congAcc + flankEff_meanRT <- incongCorr_meanRT - congCorr_meanRT + flankEff_logMeanRT <- incongCorr_logMeanRT - congCorr_logMeanRT + + # + # number of committed errors in the flanker task + committed_errors <- nrow(errorDat) + # number of reported errors + psychopyDatTrim <- psychopyDat[("errorNum_text_box.text")] # stores the number of reported errors by subjects + reported_errors <- subset(psychopyDatTrim, complete.cases(psychopyDatTrim$errorNum_text_box.text)) + reported_errors <- reported_errors$errorNum_text_box.text # number of reported errors by participants + reported_errors <- str_extract_all(reported_errors, '\\d+\\.?\\d*') # to extract all sequences of digits from the input string + # There was a participant who had reported 70/100. values 70 and 100. To solve this issue, I replace this kind of values with NAs! + if (length(reported_errors) == 0){ # there is no reported errors + reported_errors <- NA + memoryBias_score <- NA + } else { + reported_errors <- parse_number(reported_errors[[1]]) # in cases like 70/100, we will have 70 100 at this stage. So, length(reported_errors) will + # higher than 1. + if (length(reported_errors) > 1){ # In case they have reported sth like 70/100 + reported_errors <- NA + memoryBias_score <- NA + } else if (length(reported_errors) == 1){ + reported_errors <- reported_errors[1] + memoryBias_score <- ((reported_errors - committed_errors)/ reported_errors) # percent bias score calculation + } + } + + + ### number of incong error faces identified as old + num_incong_errorFaces_reported_old <- 0 # this is the number of incongruent error faces that they report as OLD and will be updated in the loop below: + num_incong_errorFaces_reported_new <- 0 + for (iii in 1:nrow(error_incong_flankerDat)){ + if (error_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- error_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong error face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_incong_errorFaces_reported_old <- num_incong_errorFaces_reported_old + 1 # The number of incongruent error faces that they report as OLD + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_incong_errorFaces_reported_new <- num_incong_errorFaces_reported_new + 1 # The number of incongruent error faces that they report as New + } + } + } + } # closing the loop over error incong flankerDat + + # Post incong Error ACC and RT + post_error_acc <- mean(as.numeric(legit_error_incong_flankerDat$post_trial_accuracy), na.rm = TRUE) + post_error_rt <- mean(as.numeric(legit_error_incong_flankerDat$post_trial_rt), na.rm = TRUE) + + ### number of incong correct faces identified as old + num_incong_correctFaces_reported_old <- 0 # this is the number of incongruent correct faces that they report as Old and will be updated in the loop below: + num_incong_correctFaces_reported_new <- 0 + for (iii in 1:nrow(incong_corrDat)){ + if (incong_corrDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- incong_corrDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong correct face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_incong_correctFaces_reported_old <- num_incong_correctFaces_reported_old + 1 # The number of incongruent correct faces that they report as Old + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_incong_correctFaces_reported_new <- num_incong_correctFaces_reported_new + 1 # The number of incongruent correct faces that they report as New + } + } + } + } # closing the loop over correct incong flankerDat + + # Overall hits, misses, FAs, and Correct rejections regardless of errors and corrects. + hit_num <- 0 + miss_num <- 0 + corr_rej_num <- 0 + false_alrams_num <- 0 + + for (surpTrial in 1:nrow(surprise_df)){ + if (surprise_df$surpAcc[surpTrial] == 1) { # The old face is identified correctly as old + hit_num <- hit_num + 1 + corr_rej_num <- corr_rej_num + 1 + } else if (surprise_df$surpAcc[surpTrial] == 0){ # The old face is identified incorrectly as new + miss_num <- miss_num + 1 + false_alrams_num <- false_alrams_num + 1 + } + } # Closing the loop over surprise_df trials + + overall_hitRate <- (hit_num) / ((hit_num) + miss_num) # hit rate + overall_false_alarm_rate <- (false_alrams_num)/ ((false_alrams_num) + (corr_rej_num)) + overall_dPrime <- psycho::dprime(hit_num, false_alrams_num, miss_num, corr_rej_num) + overall_dPrime <- overall_dPrime$dprime + + incong_error_hit_num <- num_incong_errorFaces_reported_old + incong_error_miss_num <- num_incong_errorFaces_reported_new + error_hitRate <- (incong_error_hit_num) / ((incong_error_hit_num) + incong_error_miss_num) # hit rate + + + incong_correct_hit_num <- num_incong_correctFaces_reported_old + incong_correct_miss_num <- num_incong_correctFaces_reported_new + correct_hitRate <- (incong_correct_hit_num) / ((incong_correct_hit_num) + incong_correct_miss_num) # hit rate + + hitRate_error_minus_correct <- error_hitRate - correct_hitRate + #### post trials (under construction) + ### number of post error faces identified as old + num_post_errorFaces_reported_old <- 0 # this is the number of incongruent correct faces that they report as Old and will be updated in the loop below: + num_post_errorFaces_reported_new <- 0 + for (iii in 1:nrow(error_incong_flankerDat)){ + if (!is.na(error_incong_flankerDat$post_trial_legitResponse[iii])){ # In case current trial is the last trial in the block, post trial will be NA! So, this condition will prevent from errors! + if (error_incong_flankerDat$post_trial_legitResponse[iii] == 1){ # if this trial is legit + if (error_incong_flankerDat$post_trial_accuracy[iii] == 1){ # post trials must be correct while they can be either incongruent or congruent. + temp_face_from_flanker <- error_incong_flankerDat$post_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong correct face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_post_errorFaces_reported_old <- num_post_errorFaces_reported_old + 1 + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_post_errorFaces_reported_new <- num_post_errorFaces_reported_new + 1 + } + } + } + } + } + } # closing the loop over correct incong flankerDat + + ### number of post correct faces identified as old + num_post_correctFaces_reported_old <- 0 # this is the number of incongruent correct faces that they report as Old and will be updated in the loop below: + num_post_correctFaces_reported_new <- 0 + for (iii in 1:nrow(incong_corrDat)){ + if (!is.na(incong_corrDat$post_trial_legitResponse[iii])){ # In case current trial is the last trial in the block, post trial will be NA! So, this condition will prevent from errors! + if (incong_corrDat$post_trial_legitResponse[iii] == 1){ # if this trial is legit + if (incong_corrDat$post_trial_accuracy[iii] == 1){ # post trials must be correct while they can be either incongruent or congruent. + temp_face_from_flanker <- incong_corrDat$post_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong correct face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_post_correctFaces_reported_old <- num_post_correctFaces_reported_old + 1 + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_post_correctFaces_reported_new <- num_post_correctFaces_reported_new + 1 + } + } + } + } + } + } # closing the loop over correct incong flankerDat + + # If this participant has less than 8 post-error images present in the surprise data frame, + # post hit rate values will be NAs. + if (num_post_errorFaces_reported_new + num_post_errorFaces_reported_old >= 8){ + incong_post_error_hit_num <- num_post_errorFaces_reported_old + incong_post_error_miss_num <- num_post_errorFaces_reported_new + post_error_hitRate <- (incong_post_error_hit_num) / ((incong_post_error_hit_num) + incong_post_error_miss_num) # hit rate + + + incong_post_correct_hit_num <- num_post_correctFaces_reported_old + incong_post_correct_miss_num <- num_post_correctFaces_reported_new + post_correct_hitRate <- (incong_post_correct_hit_num) / ((incong_post_correct_hit_num) + incong_post_correct_miss_num) # hit rate + + hitRate_post_error_minus_correct <- post_error_hitRate - post_correct_hitRate + + } else if (num_post_errorFaces_reported_new + num_post_errorFaces_reported_old < 8){ + post_error_hitRate <- NA + post_correct_hitRate <- NA + hitRate_post_error_minus_correct <- NA + } + + #### filling the main data frame + main_df[nrow(main_df) + 1,] <-c(participant_id, congAcc, incongAcc, + incongruent_dat_meanRT, errorDat_meanRT, congruent_dat_meanRT, corrDat_meanRT, + congCorr_meanRT, incongCorr_meanRT, congCorr_logMeanRT, + congErr_meanRT, incongErr_meanRT, congErr_logMeanRT, incongErr_logMeanRT, + incongCorr_logMeanRT, flankEff_meanACC, flankEff_meanRT, flankEff_logMeanRT, + reported_errors, committed_errors, memoryBias_score, overall_hitRate, error_hitRate, + correct_hitRate, num_incong_correctFaces_reported_new, num_incong_correctFaces_reported_old, + num_incong_errorFaces_reported_new, num_incong_errorFaces_reported_old, hit_num, false_alrams_num, + miss_num, corr_rej_num, incong_error_hit_num, + incong_correct_hit_num, incong_error_miss_num, + incong_correct_miss_num, post_error_hitRate, post_correct_hitRate, hitRate_error_minus_correct, hitRate_post_error_minus_correct, post_error_acc, post_error_rt, overall_dPrime) + + + } else { # If a participant has been excluded because they had less than 8 legit incong error faces in the surprise memory task, we add 1 to the counter below. + num_participants_removed_based_on_num_incong_error_faces_in_memory_surp <- num_participants_removed_based_on_num_incong_error_faces_in_memory_surp + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to not having 8 legit incong error faces in the surprise memory task.")) + #### end of printing output + } + } else { # If a participant has been excluded because they had less than 8 legit incong errors, we add 1 to the counter below. + num_of_participants_removed_based_on_incong_error_num <- num_of_participants_removed_based_on_incong_error_num + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to not having 8 legit incong errors in the flanker task.")) + #### end of printing output + } + } else { # if a participant has been excluded based on whether they have chosen the most chosen surprise response >= 90% and/or repeatedly choosing the same answer (12 times in a row at least)! + num_of_participants_removed_based_on_surp_response_frequency_andOR_repeated_ans <- num_of_participants_removed_based_on_surp_response_frequency_andOR_repeated_ans + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to response frequency and/or repeated answer criteria.")) + #### end of printing output + } + } else { # If a participant has been excluded because they had less than 60% flanker accuracy, we add 1 to the counter below. + num_of_participants_removed_based_on_accuracy <- num_of_participants_removed_based_on_accuracy + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to flanker accuracy below 60%.")) + #### end of printing output + } + } else { # If a participant has been excluded because they had more than 37.5% surp trial removed, we add 1 to the counter below. + num_of_participants_removed_based_on_memory_surp_trial_removal <- num_of_participants_removed_based_on_memory_surp_trial_removal + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded as at least 37.5 % of their surprise trials were removed due to fast RT than 200 ms.")) + #### end of printing output + } +} # Closing the loop for each participant + + + + +### Loading RedCap questionnaire data +redcapDat <- read.csv(file = "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset/derivatives/preprocessed/redcap/202410v0memoryforerr_SCRD_2024-12-03_2224.csv") + +# stai state before and after the flanker task were not properly scored on the HPC due to an error in the naming. +# They will be scored here. +# STAI state before +redcapDat$stai5_scrdS_s1_r1_e1 <- rowSums(redcapDat[ , c("stai5_i1_s1_r1_e1", "stai5_i2_s1_r1_e1", "stai5_i3_s1_r1_e1", "stai5_i4_s1_r1_e1","stai5_i5_s1_r1_e1")]) + +# STAI state After +redcapDat$stai5_scrdS_s1_r1_e2 <- rowSums(redcapDat[ , c("stai5_i1_s1_r1_e1_v2","stai5_i2_s1_r1_e1_v2", "stai5_i3_s1_r1_e1_v2", "stai5_i4_s1_r1_e1_v2","stai5_i5_s1_r1_e1_v2")]) +# STAI state difference (After minus Before) +redcapDat$stai5_scrdS_diff <- (redcapDat$stai5_scrdS_s1_r1_e2 - redcapDat$stai5_scrdS_s1_r1_e1) + + +# scoring postTask_D questionnaire (sum posttaskd_i1, posttaskd_i3, posttaskd_i4,posttaskd_i5) +redcapDat$postTask_d_s1_r1_e1 <- rowSums(redcapDat[ , c("posttaskd_i1_s1_r1_e1","posttaskd_i3_s1_r1_e1", "posttaskd_i4_s1_r1_e1", "posttaskd_i5_s1_r1_e1")]) + + + +# Keeping the columns that we need! +redcapDat <- redcapDat[c("record_id", "demo_c_yob_s1_r1_e1", "scaared_b_scrdSoc_s1_r1_e1", "scaared_b_scrdGA_s1_r1_e1", "scaared_b_scrdTotal_s1_r1_e1", + "bfne_b_scrdTotal_s1_r1_e1", "epepq15_scrdTotal_s1_r1_e1", "phq8_scrdTotal_s1_r1_e1", + "stai5_scrdS_s1_r1_e1", "stai5_scrdS_s1_r1_e2", "stai5_scrdS_diff", "postTask_d_s1_r1_e1")] + + +# adding new columns to the "main_df" dataframe from redcapDat +for (rr in 1:nrow(main_df)){ + temp_id <- main_df$participant_id[rr] + tempDat <- filter(redcapDat, record_id == temp_id) + if (nrow(tempDat) == 1){ + main_df$scaared_b_scrdSoc_s1_r1_e1[rr] <- tempDat$scaared_b_scrdSoc_s1_r1_e1 + main_df$scaared_b_scrdTotal_s1_r1_e1[rr] <- tempDat$scaared_b_scrdTotal_s1_r1_e1 + main_df$bfne_b_scrdTotal_s1_r1_e1[rr] <- tempDat$bfne_b_scrdTotal_s1_r1_e1 + main_df$epepq15_scrdTotal_s1_r1_e1[rr] <- tempDat$epepq15_scrdTotal_s1_r1_e1 + main_df$phq8_scrdTotal_s1_r1_e1[rr] <- tempDat$phq8_scrdTotal_s1_r1_e1 + main_df$stai5_scrdS_s1_r1_e1[rr] <- tempDat$stai5_scrdS_s1_r1_e1 + main_df$stai5_scrdS_s1_r1_e2[rr] <- tempDat$stai5_scrdS_s1_r1_e2 + main_df$stai5_scrdS_diff[rr] <- tempDat$stai5_scrdS_diff + main_df$postTask_d_s1_r1_e1[rr] <- tempDat$postTask_d_s1_r1_e1 + main_df$scaared_b_scrdGA_s1_r1_e1[rr] <- tempDat$scaared_b_scrdGA_s1_r1_e1 + } else if (nrow(tempDat) == 0){ + main_df$scaared_b_scrdSoc_s1_r1_e1[rr] <- NA + main_df$scaared_b_scrdTotal_s1_r1_e1[rr] <- NA + main_df$bfne_b_scrdTotal_s1_r1_e1[rr] <- NA + main_df$epepq15_scrdTotal_s1_r1_e1[rr] <- NA + main_df$phq8_scrdTotal_s1_r1_e1[rr] <- NA + main_df$stai5_scrdS_s1_r1_e1[rr] <- NA + main_df$stai5_scrdS_s1_r1_e2[rr] <- NA + main_df$stai5_scrdS_diff[rr] <- NA + main_df$postTask_d_s1_r1_e1[rr] <- NA + main_df$scaared_b_scrdGA_s1_r1_e1[rr] <- NA + } +} + + + +################## +# Save the dataset +#write the extracted and computed summary scores to disk +write.csv(main_df, paste(output_path, proc_fileName, sep = "/", collapse = NULL), row.names=FALSE) +################## + + diff --git a/code/stats/mfe_e_face_measure_computations_v2.R b/code/stats/mfe_e_face_measure_computations_v2.R new file mode 100644 index 0000000..43af223 --- /dev/null +++ b/code/stats/mfe_e_face_measure_computations_v2.R @@ -0,0 +1,442 @@ +# This script will load, and organize the pavlovia data. Then, computes measures of interest. +# For each participant, a single, new, organized csv file that has all the necessary information will be generated. +# Author: Kianoosh Hosseini at NDCLab @FIU (https://Kianoosh.info; https://NDClab.com) +# Last Update: 2024-12-05 (YYYY-MM-DD) +# This version computes hit rates by binning the face delay. This script computes two bins (early vs. late). +# Early is below 500 ms and late is after 500 ms. +### take everyone that met the cutoffs for enough trials when not binning +### and then just bin them and consider if they still have enough in each seperate bin. + +library(tidyverse) +library(dplyr) +library(stringr) +library(psycho) # to compute d' measures, etc. + +#Working directory should be the Psychopy experiment directory. +proje_wd <- "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset" +setwd(proje_wd) + + +input_raw_path <- paste(proje_wd, "sourcedata", "checked", "psychopy", sep ="/", collapse = NULL) # input data directory +input_organized_path <- paste(proje_wd, "derivatives", "psychopy", "csv_output", sep ="/", collapse = NULL) # input directory for data files generated by the organizer script! +output_path <- paste(proje_wd, "derivatives", "psychopy", "stat_output", sep ="/", collapse = NULL) # output directory +proc_fileName <- "processed_data_mfe_e_Proj_v2.csv" # output filename +flanker_csv_fileName <- "_mfe_e_flankerDat_v1.csv" # each output csv file will have this on its filename +surprise_csv_fileName <- "_mfe_e_surpriseDat_v1.csv" # each output csv file will have this on its filename + + +## creating a list of all raw data csv files in the input folder. +raw_datafiles_list <- c() # an empty list that will be filled in the next "for" loop! +csvSelect <- list.files(input_raw_path, pattern = ".csv") # listing only csv files +for (i in 1:length(csvSelect)){ + temp_for_file <- ifelse (str_detect(csvSelect[i], "mfe_e", negate = FALSE), 1, 0) + if (temp_for_file == 1){ + temp_list <- csvSelect[i] + raw_datafiles_list <- c(raw_datafiles_list, temp_list) + } +} +# Creating the main empty dataframe that will be filled with the data from the loop below: +main_df <- setNames(data.frame(matrix(ncol = 49, nrow = 0)), c("participant_id", "congAcc", "incongAcc", + "incongruent_dat_meanRT", "errorDat_meanRT", "congruent_dat_meanRT", "corrDat_meanRT", + "congCorr_meanRT", "incongCorr_meanRT", "congCorr_logMeanRT", + "congErr_meanRT", "incongErr_meanRT", "congErr_logMeanRT", "incongErr_logMeanRT", + "incongCorr_logMeanRT", "flankEff_meanACC", "flankEff_meanRT", "flankEff_logMeanRT", + "reported_errors", "committed_errors", "memoryBias_score", "overall_hitRate", "early_error_hitRate", + "early_correct_hitRate", "num_early_incong_correctFaces_reported_new", "num_early_incong_correctFaces_reported_old", + "num_early_incong_errorFaces_reported_new", "num_early_incong_errorFaces_reported_old", "late_error_hitRate", + "late_correct_hitRate", "num_late_incong_correctFaces_reported_new", "num_late_incong_correctFaces_reported_old", + "num_late_incong_errorFaces_reported_new", "num_late_incong_errorFaces_reported_old", "hit_num", "false_alrams_num", + "miss_num", "corr_rej_num", "early_incong_error_hit_num", + "early_incong_correct_hit_num", "early_incong_error_miss_num", + "early_incong_correct_miss_num", "early_hitRate_error_minus_correct", "late_incong_error_hit_num", + "late_incong_correct_hit_num", "late_incong_error_miss_num", + "late_incong_correct_miss_num", "late_hitRate_error_minus_correct","overall_dPrime")) + +# Counters for the number of excluded people based on each criterion +num_of_participants_removed_based_on_memory_surp_trial_removal <- 0 # Will be updated in the loop below +num_of_participants_removed_based_on_accuracy <- 0 # Will be updated in the loop below +num_of_participants_removed_based_on_incong_error_num <- 0 # Will be updated in the loop below +num_participants_removed_based_on_num_incong_error_faces_in_memory_surp <- 0 # Will be updated in the loop below +num_of_participants_removed_based_on_surp_response_frequency_andOR_repeated_ans <- 0 + +# Looping over all participants +for (subject in 1:length(raw_datafiles_list)){ + #for this participant, find the raw csv file + psychopy_file <- paste(input_raw_path,raw_datafiles_list[subject], sep = "/", collapse = NULL) + + #read in the data for this participant, establish id, and remove extraneous variables + psychopyDat <- read.csv(file = psychopy_file, stringsAsFactors = FALSE, na.strings=c("", "NA")) + participant_id <- psychopyDat$id[1] + + # Load this participant's flanker and surprise data frames + flanker_name <- paste0(participant_id, flanker_csv_fileName, sep = "", collapse = NULL) + surprise_name <- paste0(participant_id, surprise_csv_fileName, sep = "", collapse = NULL) + flanker_df <- read.csv(file = paste(input_organized_path, flanker_name, sep = "/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + surprise_df <- read.csv(file = paste(input_organized_path, surprise_name, sep = "/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + + # removing participants based on whether they just pressed the keys without actually paying attention to the task. + # We check this by "keep_surp_memory_trial_based_on_rt" variables + # in the surprise_df data frame. O means that they have responded faster than 200 ms during the given trial + # and therefore, we need to remove that surprise trial. + # If more than 37.5% of surprise trials are removed, we exclude that participant. + number_of_removed_trials_in_the_memory_surp <- nrow(surprise_df) - (sum(surprise_df$keep_surp_memory_trial_based_on_rt)) + number_of_faces_in_surp_memory_task <- nrow(surprise_df) + surp_rt_threshold <- round(0.375 * number_of_faces_in_surp_memory_task) + + if (number_of_removed_trials_in_the_memory_surp <= surp_rt_threshold){ # Participants who have less than surp_rt_threshold surprise + # trials removed, will be included. + + # Check to see if this participant has the flanker accuracy above 60% + if (mean(as.numeric(flanker_df$current_trial_accuracy)) >= 0.6){ + + # If this participant has at least 3 blocks marked for exclusion (based on response frequency and repeated responses), we exclude them. + if (surprise_df$num_blocks_excluded[1] <= 3){ + + # check to see if the participant has at least 8 legit incongruent errors or not. + incong_flankerDat <- filter(flanker_df, current_trial_congruency == 0) + cong_flankerDat <- filter(flanker_df, current_trial_congruency == 1) + error_incong_flankerDat <- filter(incong_flankerDat, current_trial_accuracy == 0) + legit_error_incong_flankerDat <- filter(error_incong_flankerDat, current_trial_legitResponse == 1) + if (nrow(legit_error_incong_flankerDat) >= 8 ){ + + # Checking to see if there are at least 8 incongruent error faces in the surprise_df of this participant. + # First we need to remove the trials that are marked based on rt! + surprise_df <- filter(surprise_df, keep_surp_memory_trial_based_on_rt == 1) + num_incong_error_faces_in_surp <- 0 + # Counting the number of legit incong error faces available in surprise_df! + for (rr in 1:nrow(legit_error_incong_flankerDat)){ + temp_face <- legit_error_incong_flankerDat$current_trial_face[rr] + temp_for_surp <- filter(surprise_df, face == temp_face) + errorFace_exist_in_surpDat <- ifelse(nrow(temp_for_surp) == 1, 1,0) + if (errorFace_exist_in_surpDat == 1){ + num_incong_error_faces_in_surp <- num_incong_error_faces_in_surp + 1 + } + } # Closing the loop that counts the number of incong error faces available in surprise_df! + if (num_incong_error_faces_in_surp >= 8){ + + incongAcc <- mean(as.numeric(incong_flankerDat$current_trial_accuracy)) + congAcc <- mean(as.numeric(cong_flankerDat$current_trial_accuracy)) + + # subset the data for correct and error trials, separately for congruent and incongruent trials, creating new data frames for each + corrDat <- flanker_df[flanker_df$current_trial_accuracy == 1,] + corrDat_meanRT <- mean(corrDat$current_trial_rt, na.rm = TRUE) + + congruent_dat <- flanker_df[flanker_df$current_trial_congruency == 1,] + congruent_dat_meanRT <- mean(congruent_dat$current_trial_rt, na.rm = TRUE) + + cong_corrDat <- corrDat[corrDat$current_trial_congruency == 1,] + incong_corrDat <- corrDat[corrDat$current_trial_congruency == 0,] + + errorDat <- flanker_df[flanker_df$current_trial_accuracy == 0,] + errorDat_meanRT <- mean(errorDat$current_trial_rt, na.rm = TRUE) + + incongruent_dat <- flanker_df[flanker_df$current_trial_congruency == 0,] + incongruent_dat_meanRT <- mean(incongruent_dat$current_trial_rt, na.rm = TRUE) + + + cong_errorDat <- errorDat[errorDat$current_trial_congruency == 1,] + incong_errorDat <- errorDat[errorDat$current_trial_congruency == 0,] + #for correct trials, compute mean RT (raw and log-corrected) + congCorr_meanRT <- mean(cong_corrDat$current_trial_rt, na.rm = TRUE) + incongCorr_meanRT <- mean(incong_corrDat$current_trial_rt, na.rm = TRUE) + + congErr_meanRT <- mean(cong_errorDat$current_trial_rt, na.rm = TRUE) + incongErr_meanRT <- mean(incong_errorDat$current_trial_rt, na.rm = TRUE) + + congCorr_logMeanRT <- mean(log((1+cong_corrDat$current_trial_rt)), na.rm = TRUE) + incongCorr_logMeanRT <- mean(log((1+incong_corrDat$current_trial_rt)), na.rm = TRUE) + + congErr_logMeanRT <- mean(log((1+cong_errorDat$current_trial_rt)), na.rm = TRUE) + incongErr_logMeanRT <- mean(log((1+incong_errorDat$current_trial_rt)), na.rm = TRUE) + + # compute flanker-effect scores for accuracy, RT, log-RT + flankEff_meanACC <- incongAcc - congAcc + flankEff_meanRT <- incongCorr_meanRT - congCorr_meanRT + flankEff_logMeanRT <- incongCorr_logMeanRT - congCorr_logMeanRT + + # + # number of committed errors in the flanker task + committed_errors <- nrow(errorDat) + # number of reported errors + psychopyDatTrim <- psychopyDat[("errorNum_text_box.text")] # stores the number of reported errors by subjects + reported_errors <- subset(psychopyDatTrim, complete.cases(psychopyDatTrim$errorNum_text_box.text)) + reported_errors <- reported_errors$errorNum_text_box.text # number of reported errors by participants + reported_errors <- str_extract_all(reported_errors, '\\d+\\.?\\d*') # to extract all sequences of digits from the input string + # There was a participant who had reported 70/100. values 70 and 100. To solve this issue, I replace this kind of values with NAs! + if (length(reported_errors) == 0){ # there is no reported errors + reported_errors <- NA + memoryBias_score <- NA + } else { + reported_errors <- parse_number(reported_errors[[1]]) # in cases like 70/100, we will have 70 100 at this stage. So, length(reported_errors) will + # higher than 1. + if (length(reported_errors) > 1){ # In case they have reported sth like 70/100 + reported_errors <- NA + memoryBias_score <- NA + } else if (length(reported_errors) == 1){ + reported_errors <- reported_errors[1] + memoryBias_score <- ((reported_errors - committed_errors)/ reported_errors) # percent bias score calculation + } + } + ############################################################################################################## + ############################################## EARLY BIN ##################################################### + ############################################################################################################## + early_bin_error_incong_flankerDat <- filter(error_incong_flankerDat, current_trial_face_delay_time <= 0.5) + early_bin_correct_incong_flankerDat <- filter(incong_corrDat, current_trial_face_delay_time <= 0.5) + + ### number of incong error faces identified as old + num_early_incong_errorFaces_reported_old <- 0 # this is the number of incongruent error faces that they report as OLD and will be updated in the loop below: + num_early_incong_errorFaces_reported_new <- 0 + for (iii in 1:nrow(early_bin_error_incong_flankerDat)){ + if (early_bin_error_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- early_bin_error_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong error face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_early_incong_errorFaces_reported_old <- num_early_incong_errorFaces_reported_old + 1 # The number of incongruent error faces that they report as OLD + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_early_incong_errorFaces_reported_new <- num_early_incong_errorFaces_reported_new + 1 # The number of incongruent error faces that they report as New + } + } + } + } # closing the loop over error incong flankerDat + + + ### number of incong correct faces identified as old + num_early_incong_correctFaces_reported_old <- 0 # this is the number of incongruent correct faces that they report as Old and will be updated in the loop below: + num_early_incong_correctFaces_reported_new <- 0 + for (iii in 1:nrow(early_bin_correct_incong_flankerDat)){ + if (early_bin_correct_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- early_bin_correct_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong correct face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_early_incong_correctFaces_reported_old <- num_early_incong_correctFaces_reported_old + 1 # The number of incongruent correct faces that they report as Old + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_early_incong_correctFaces_reported_new <- num_early_incong_correctFaces_reported_new + 1 # The number of incongruent correct faces that they report as New + } + } + } + } # closing the loop over correct incong flankerDat + + + ############################################################################################################## + ############################################## LATE BIN ##################################################### + ############################################################################################################## + late_bin_error_incong_flankerDat <- filter(error_incong_flankerDat, current_trial_face_delay_time > 0.5) + late_bin_correct_incong_flankerDat <- filter(incong_corrDat, current_trial_face_delay_time > 0.5) + + ### number of incong error faces identified as old + num_late_incong_errorFaces_reported_old <- 0 # this is the number of incongruent error faces that they report as OLD and will be updated in the loop below: + num_late_incong_errorFaces_reported_new <- 0 + for (iii in 1:nrow(late_bin_error_incong_flankerDat)){ + if (late_bin_error_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- late_bin_error_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong error face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_late_incong_errorFaces_reported_old <- num_late_incong_errorFaces_reported_old + 1 # The number of incongruent error faces that they report as OLD + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_late_incong_errorFaces_reported_new <- num_late_incong_errorFaces_reported_new + 1 # The number of incongruent error faces that they report as New + } + } + } + } # closing the loop over error incong flankerDat + + + ### number of incong correct faces identified as old + num_late_incong_correctFaces_reported_old <- 0 # this is the number of incongruent correct faces that they report as Old and will be updated in the loop below: + num_late_incong_correctFaces_reported_new <- 0 + for (iii in 1:nrow(late_bin_correct_incong_flankerDat)){ + if (late_bin_correct_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- late_bin_correct_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong correct face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_late_incong_correctFaces_reported_old <- num_late_incong_correctFaces_reported_old + 1 # The number of incongruent correct faces that they report as Old + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_late_incong_correctFaces_reported_new <- num_late_incong_correctFaces_reported_new + 1 # The number of incongruent correct faces that they report as New + } + } + } + } # closing the loop over correct incong flankerDat + + + + # Overall hits, misses, FAs, and Correct rejections regardless of errors and corrects. + hit_num <- 0 + miss_num <- 0 + corr_rej_num <- 0 + false_alrams_num <- 0 + + for (surpTrial in 1:nrow(surprise_df)){ + if (surprise_df$surpAcc[surpTrial] == 1) { # The old face is identified correctly as old + hit_num <- hit_num + 1 + corr_rej_num <- corr_rej_num + 1 + } else if (surprise_df$surpAcc[surpTrial] == 0){ # The old face is identified incorrectly as new + miss_num <- miss_num + 1 + false_alrams_num <- false_alrams_num + 1 + } + } # Closing the loop over surprise_df trials + + overall_hitRate <- (hit_num) / ((hit_num) + miss_num) # hit rate + overall_false_alarm_rate <- (false_alrams_num)/ ((false_alrams_num) + (corr_rej_num)) + overall_dPrime <- psycho::dprime(hit_num, false_alrams_num, miss_num, corr_rej_num) + overall_dPrime <- overall_dPrime$dprime + + if (nrow(early_bin_error_incong_flankerDat) >= 8){ + early_incong_error_hit_num <- num_early_incong_errorFaces_reported_old + early_incong_error_miss_num <- num_early_incong_errorFaces_reported_new + early_error_hitRate <- (early_incong_error_hit_num) / ((early_incong_error_hit_num) + early_incong_error_miss_num) # hit rate + } else if (nrow(early_bin_error_incong_flankerDat) < 8){ + early_incong_error_hit_num <- NA + early_incong_error_miss_num <- NA + early_error_hitRate <- NA + } + + if (nrow(late_bin_error_incong_flankerDat) >= 8){ + late_incong_error_hit_num <- num_late_incong_errorFaces_reported_old + late_incong_error_miss_num <- num_late_incong_errorFaces_reported_new + late_error_hitRate <- (late_incong_error_hit_num) / ((late_incong_error_hit_num) + late_incong_error_miss_num) # hit rate + } else if (nrow(late_bin_error_incong_flankerDat) < 8){ + late_incong_error_hit_num <- NA + late_incong_error_miss_num <- NA + late_error_hitRate <- NA + } + + + early_incong_correct_hit_num <- num_early_incong_correctFaces_reported_old + early_incong_correct_miss_num <- num_early_incong_correctFaces_reported_new + early_correct_hitRate <- (early_incong_correct_hit_num) / ((early_incong_correct_hit_num) + early_incong_correct_miss_num) # hit rate + + late_incong_correct_hit_num <- num_late_incong_correctFaces_reported_old + late_incong_correct_miss_num <- num_late_incong_correctFaces_reported_new + late_correct_hitRate <- (late_incong_correct_hit_num) / ((late_incong_correct_hit_num) + late_incong_correct_miss_num) # hit rate + + if (nrow(early_bin_error_incong_flankerDat) >= 8){ + early_hitRate_error_minus_correct <- early_error_hitRate - early_correct_hitRate + } else if (nrow(early_bin_error_incong_flankerDat) < 8){ + early_hitRate_error_minus_correct <- NA + } + if (nrow(late_bin_error_incong_flankerDat) >= 8){ + late_hitRate_error_minus_correct <- late_error_hitRate - late_correct_hitRate + } else if (nrow(late_bin_error_incong_flankerDat) < 8){ + late_hitRate_error_minus_correct <- NA + } + + + #### filling the main data frame + main_df[nrow(main_df) + 1,] <-c(participant_id, congAcc, incongAcc, + incongruent_dat_meanRT, errorDat_meanRT, congruent_dat_meanRT, corrDat_meanRT, + congCorr_meanRT, incongCorr_meanRT, congCorr_logMeanRT, + congErr_meanRT, incongErr_meanRT, congErr_logMeanRT, incongErr_logMeanRT, + incongCorr_logMeanRT, flankEff_meanACC, flankEff_meanRT, flankEff_logMeanRT, + reported_errors, committed_errors, memoryBias_score, overall_hitRate, early_error_hitRate, + early_correct_hitRate, num_early_incong_correctFaces_reported_new, num_early_incong_correctFaces_reported_old, + num_early_incong_errorFaces_reported_new, num_early_incong_errorFaces_reported_old, late_error_hitRate, + late_correct_hitRate, num_late_incong_correctFaces_reported_new, num_late_incong_correctFaces_reported_old, + num_late_incong_errorFaces_reported_new, num_late_incong_errorFaces_reported_old, hit_num, false_alrams_num, + miss_num, corr_rej_num, early_incong_error_hit_num, + early_incong_correct_hit_num, early_incong_error_miss_num, + early_incong_correct_miss_num, early_hitRate_error_minus_correct, late_incong_error_hit_num, + late_incong_correct_hit_num, late_incong_error_miss_num, + late_incong_correct_miss_num, late_hitRate_error_minus_correct,overall_dPrime) + + + } else { # If a participant has been excluded because they had less than 8 legit incong error faces in the surprise memory task, we add 1 to the counter below. + num_participants_removed_based_on_num_incong_error_faces_in_memory_surp <- num_participants_removed_based_on_num_incong_error_faces_in_memory_surp + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to not having 8 legit incong error faces in the surprise memory task.")) + #### end of printing output + } + } else { # If a participant has been excluded because they had less than 8 legit incong errors, we add 1 to the counter below. + num_of_participants_removed_based_on_incong_error_num <- num_of_participants_removed_based_on_incong_error_num + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to not having 8 legit incong errors in the flanker task.")) + #### end of printing output + } + } else { # if a participant has been excluded based on whether they have chosen the most chosen surprise response >= 90% and/or repeatedly choosing the same answer (12 times in a row at least)! + num_of_participants_removed_based_on_surp_response_frequency_andOR_repeated_ans <- num_of_participants_removed_based_on_surp_response_frequency_andOR_repeated_ans + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to response frequency and/or repeated answer criteria.")) + #### end of printing output + } + } else { # If a participant has been excluded because they had less than 60% flanker accuracy, we add 1 to the counter below. + num_of_participants_removed_based_on_accuracy <- num_of_participants_removed_based_on_accuracy + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to flanker accuracy below 60%.")) + #### end of printing output + } + } else { # If a participant has been excluded because they had more than 37.5% surp trial removed, we add 1 to the counter below. + num_of_participants_removed_based_on_memory_surp_trial_removal <- num_of_participants_removed_based_on_memory_surp_trial_removal + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded as at least 37.5 % of their surprise trials were removed due to fast RT than 200 ms.")) + #### end of printing output + } +} # Closing the loop for each participant + + + + +### Loading RedCap questionnaire data +redcapDat <- read.csv(file = "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset/derivatives/preprocessed/redcap/202410v0memoryforerr_SCRD_2024-12-03_2224.csv") + +# stai state before and after the flanker task were not properly scored on the HPC due to an error in the naming. +# They will be scored here. +# STAI state before +redcapDat$stai5_scrdS_s1_r1_e1 <- rowSums(redcapDat[ , c("stai5_i1_s1_r1_e1", "stai5_i2_s1_r1_e1", "stai5_i3_s1_r1_e1", "stai5_i4_s1_r1_e1","stai5_i5_s1_r1_e1")]) + +# STAI state After +redcapDat$stai5_scrdS_s1_r1_e2 <- rowSums(redcapDat[ , c("stai5_i1_s1_r1_e1_v2","stai5_i2_s1_r1_e1_v2", "stai5_i3_s1_r1_e1_v2", "stai5_i4_s1_r1_e1_v2","stai5_i5_s1_r1_e1_v2")]) +# STAI state difference (After minus Before) +redcapDat$stai5_scrdS_diff <- (redcapDat$stai5_scrdS_s1_r1_e2 - redcapDat$stai5_scrdS_s1_r1_e1) + + +# scoring postTask_D questionnaire (sum posttaskd_i1, posttaskd_i3, posttaskd_i4,posttaskd_i5) +redcapDat$postTask_d_s1_r1_e1 <- rowSums(redcapDat[ , c("posttaskd_i1_s1_r1_e1","posttaskd_i3_s1_r1_e1", "posttaskd_i4_s1_r1_e1", "posttaskd_i5_s1_r1_e1")]) + + + +# Keeping the columns that we need! +redcapDat <- redcapDat[c("record_id", "demo_c_yob_s1_r1_e1", "scaared_b_scrdSoc_s1_r1_e1", "scaared_b_scrdGA_s1_r1_e1", "scaared_b_scrdTotal_s1_r1_e1", + "bfne_b_scrdTotal_s1_r1_e1", "epepq15_scrdTotal_s1_r1_e1", "phq8_scrdTotal_s1_r1_e1", + "stai5_scrdS_s1_r1_e1", "stai5_scrdS_s1_r1_e2", "stai5_scrdS_diff", "postTask_d_s1_r1_e1")] + + +# adding new columns to the "main_df" dataframe from redcapDat +for (rr in 1:nrow(main_df)){ + temp_id <- main_df$participant_id[rr] + tempDat <- filter(redcapDat, record_id == temp_id) + if (nrow(tempDat) == 1){ + main_df$scaared_b_scrdSoc_s1_r1_e1[rr] <- tempDat$scaared_b_scrdSoc_s1_r1_e1 + main_df$scaared_b_scrdTotal_s1_r1_e1[rr] <- tempDat$scaared_b_scrdTotal_s1_r1_e1 + main_df$bfne_b_scrdTotal_s1_r1_e1[rr] <- tempDat$bfne_b_scrdTotal_s1_r1_e1 + main_df$epepq15_scrdTotal_s1_r1_e1[rr] <- tempDat$epepq15_scrdTotal_s1_r1_e1 + main_df$phq8_scrdTotal_s1_r1_e1[rr] <- tempDat$phq8_scrdTotal_s1_r1_e1 + main_df$stai5_scrdS_s1_r1_e1[rr] <- tempDat$stai5_scrdS_s1_r1_e1 + main_df$stai5_scrdS_s1_r1_e2[rr] <- tempDat$stai5_scrdS_s1_r1_e2 + main_df$stai5_scrdS_diff[rr] <- tempDat$stai5_scrdS_diff + main_df$postTask_d_s1_r1_e1[rr] <- tempDat$postTask_d_s1_r1_e1 + main_df$scaared_b_scrdGA_s1_r1_e1[rr] <- tempDat$scaared_b_scrdGA_s1_r1_e1 + } else if (nrow(tempDat) == 0){ + main_df$scaared_b_scrdSoc_s1_r1_e1[rr] <- NA + main_df$scaared_b_scrdTotal_s1_r1_e1[rr] <- NA + main_df$bfne_b_scrdTotal_s1_r1_e1[rr] <- NA + main_df$epepq15_scrdTotal_s1_r1_e1[rr] <- NA + main_df$phq8_scrdTotal_s1_r1_e1[rr] <- NA + main_df$stai5_scrdS_s1_r1_e1[rr] <- NA + main_df$stai5_scrdS_s1_r1_e2[rr] <- NA + main_df$stai5_scrdS_diff[rr] <- NA + main_df$postTask_d_s1_r1_e1[rr] <- NA + main_df$scaared_b_scrdGA_s1_r1_e1[rr] <- NA + } +} + + + +#################### +# Save the dataset +#write the extracted and computed summary scores to disk +write.csv(main_df, paste(output_path, proc_fileName, sep = "/", collapse = NULL), row.names=FALSE) +################## + + diff --git a/code/stats/mfe_e_face_measure_computations_v3.R b/code/stats/mfe_e_face_measure_computations_v3.R new file mode 100644 index 0000000..598f446 --- /dev/null +++ b/code/stats/mfe_e_face_measure_computations_v3.R @@ -0,0 +1,512 @@ +# This script will load, and organize the pavlovia data. Then, computes measures of interest. +# For each participant, a single, new, organized csv file that has all the necessary information will be generated. +# Author: Kianoosh Hosseini at NDCLab @FIU (https://Kianoosh.info; https://NDClab.com) +# Last Update: 2024-12-05 (YYYY-MM-DD) +# This version computes hit rates by binning the face delay. This script computes three bins (early vs. mid vs. late). +# Early is below 334 ms mid is between 334 and 667 ms and late is after 667 ms. +### take everyone that met the cutoffs for enough trials when not binning +### and then just bin them and consider if they still have enough in each seperate bin. + +library(tidyverse) +library(dplyr) +library(stringr) +library(psycho) # to compute d' measures, etc. + +#Working directory should be the Psychopy experiment directory. +proje_wd <- "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset" +setwd(proje_wd) + + +input_raw_path <- paste(proje_wd, "sourcedata", "checked", "psychopy", sep ="/", collapse = NULL) # input data directory +input_organized_path <- paste(proje_wd, "derivatives", "psychopy", "csv_output", sep ="/", collapse = NULL) # input directory for data files generated by the organizer script! +output_path <- paste(proje_wd, "derivatives", "psychopy", "stat_output", sep ="/", collapse = NULL) # output directory +proc_fileName <- "processed_data_mfe_e_Proj_v3.csv" # output filename +flanker_csv_fileName <- "_mfe_e_flankerDat_v1.csv" # each output csv file will have this on its filename +surprise_csv_fileName <- "_mfe_e_surpriseDat_v1.csv" # each output csv file will have this on its filename + + +## creating a list of all raw data csv files in the input folder. +raw_datafiles_list <- c() # an empty list that will be filled in the next "for" loop! +csvSelect <- list.files(input_raw_path, pattern = ".csv") # listing only csv files +for (i in 1:length(csvSelect)){ + temp_for_file <- ifelse (str_detect(csvSelect[i], "mfe_e", negate = FALSE), 1, 0) + if (temp_for_file == 1){ + temp_list <- csvSelect[i] + raw_datafiles_list <- c(raw_datafiles_list, temp_list) + } +} +# Creating the main empty dataframe that will be filled with the data from the loop below: +main_df <- setNames(data.frame(matrix(ncol = 60, nrow = 0)), c("participant_id", "congAcc", "incongAcc", + "incongruent_dat_meanRT", "errorDat_meanRT", "congruent_dat_meanRT", "corrDat_meanRT", + "congCorr_meanRT", "incongCorr_meanRT", "congCorr_logMeanRT", + "congErr_meanRT", "incongErr_meanRT", "congErr_logMeanRT", "incongErr_logMeanRT", + "incongCorr_logMeanRT", "flankEff_meanACC", "flankEff_meanRT", "flankEff_logMeanRT", + "reported_errors", "committed_errors", "memoryBias_score", "overall_hitRate", "early_error_hitRate", + "early_correct_hitRate", "num_early_incong_correctFaces_reported_new", "num_early_incong_correctFaces_reported_old", + "num_early_incong_errorFaces_reported_new", "num_early_incong_errorFaces_reported_old", "mid_error_hitRate", + "mid_correct_hitRate", "num_mid_incong_correctFaces_reported_new", "num_mid_incong_correctFaces_reported_old", + "num_mid_incong_errorFaces_reported_new", "num_mid_incong_errorFaces_reported_old","late_error_hitRate", + "late_correct_hitRate", "num_late_incong_correctFaces_reported_new", "num_late_incong_correctFaces_reported_old", + "num_late_incong_errorFaces_reported_new", "num_late_incong_errorFaces_reported_old", "hit_num", "false_alrams_num", + "miss_num", "corr_rej_num", "early_incong_error_hit_num", + "early_incong_correct_hit_num", "early_incong_error_miss_num", + "early_incong_correct_miss_num", "early_hitRate_error_minus_correct", "mid_incong_error_hit_num", + "mid_incong_correct_hit_num", "mid_incong_error_miss_num", + "mid_incong_correct_miss_num", "mid_hitRate_error_minus_correct", "late_incong_error_hit_num", + "late_incong_correct_hit_num", "late_incong_error_miss_num", + "late_incong_correct_miss_num", "late_hitRate_error_minus_correct","overall_dPrime")) + +# Counters for the number of excluded people based on each criterion +num_of_participants_removed_based_on_memory_surp_trial_removal <- 0 # Will be updated in the loop below +num_of_participants_removed_based_on_accuracy <- 0 # Will be updated in the loop below +num_of_participants_removed_based_on_incong_error_num <- 0 # Will be updated in the loop below +num_participants_removed_based_on_num_incong_error_faces_in_memory_surp <- 0 # Will be updated in the loop below +num_of_participants_removed_based_on_surp_response_frequency_andOR_repeated_ans <- 0 + +# Looping over all participants +for (subject in 1:length(raw_datafiles_list)){ + #for this participant, find the raw csv file + psychopy_file <- paste(input_raw_path,raw_datafiles_list[subject], sep = "/", collapse = NULL) + + #read in the data for this participant, establish id, and remove extraneous variables + psychopyDat <- read.csv(file = psychopy_file, stringsAsFactors = FALSE, na.strings=c("", "NA")) + participant_id <- psychopyDat$id[1] + + # Load this participant's flanker and surprise data frames + flanker_name <- paste0(participant_id, flanker_csv_fileName, sep = "", collapse = NULL) + surprise_name <- paste0(participant_id, surprise_csv_fileName, sep = "", collapse = NULL) + flanker_df <- read.csv(file = paste(input_organized_path, flanker_name, sep = "/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + surprise_df <- read.csv(file = paste(input_organized_path, surprise_name, sep = "/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + + # removing participants based on whether they just pressed the keys without actually paying attention to the task. + # We check this by "keep_surp_memory_trial_based_on_rt" variables + # in the surprise_df data frame. O means that they have responded faster than 200 ms during the given trial + # and therefore, we need to remove that surprise trial. + # If more than 37.5% of surprise trials are removed, we exclude that participant. + number_of_removed_trials_in_the_memory_surp <- nrow(surprise_df) - (sum(surprise_df$keep_surp_memory_trial_based_on_rt)) + number_of_faces_in_surp_memory_task <- nrow(surprise_df) + surp_rt_threshold <- round(0.375 * number_of_faces_in_surp_memory_task) + + if (number_of_removed_trials_in_the_memory_surp <= surp_rt_threshold){ # Participants who have less than surp_rt_threshold surprise + # trials removed, will be included. + + # Check to see if this participant has the flanker accuracy above 60% + if (mean(as.numeric(flanker_df$current_trial_accuracy)) >= 0.6){ + + # If this participant has at least 3 blocks marked for exclusion (based on response frequency and repeated responses), we exclude them. + if (surprise_df$num_blocks_excluded[1] <= 3){ + + # check to see if the participant has at least 8 legit incongruent errors or not. + incong_flankerDat <- filter(flanker_df, current_trial_congruency == 0) + cong_flankerDat <- filter(flanker_df, current_trial_congruency == 1) + error_incong_flankerDat <- filter(incong_flankerDat, current_trial_accuracy == 0) + legit_error_incong_flankerDat <- filter(error_incong_flankerDat, current_trial_legitResponse == 1) + if (nrow(legit_error_incong_flankerDat) >= 8 ){ + + # Checking to see if there are at least 8 incongruent error faces in the surprise_df of this participant. + # First we need to remove the trials that are marked based on rt! + surprise_df <- filter(surprise_df, keep_surp_memory_trial_based_on_rt == 1) + num_incong_error_faces_in_surp <- 0 + # Counting the number of legit incong error faces available in surprise_df! + for (rr in 1:nrow(legit_error_incong_flankerDat)){ + temp_face <- legit_error_incong_flankerDat$current_trial_face[rr] + temp_for_surp <- filter(surprise_df, face == temp_face) + errorFace_exist_in_surpDat <- ifelse(nrow(temp_for_surp) == 1, 1,0) + if (errorFace_exist_in_surpDat == 1){ + num_incong_error_faces_in_surp <- num_incong_error_faces_in_surp + 1 + } + } # Closing the loop that counts the number of incong error faces available in surprise_df! + if (num_incong_error_faces_in_surp >= 8){ + + incongAcc <- mean(as.numeric(incong_flankerDat$current_trial_accuracy)) + congAcc <- mean(as.numeric(cong_flankerDat$current_trial_accuracy)) + + # subset the data for correct and error trials, separately for congruent and incongruent trials, creating new data frames for each + corrDat <- flanker_df[flanker_df$current_trial_accuracy == 1,] + corrDat_meanRT <- mean(corrDat$current_trial_rt, na.rm = TRUE) + + congruent_dat <- flanker_df[flanker_df$current_trial_congruency == 1,] + congruent_dat_meanRT <- mean(congruent_dat$current_trial_rt, na.rm = TRUE) + + cong_corrDat <- corrDat[corrDat$current_trial_congruency == 1,] + incong_corrDat <- corrDat[corrDat$current_trial_congruency == 0,] + + errorDat <- flanker_df[flanker_df$current_trial_accuracy == 0,] + errorDat_meanRT <- mean(errorDat$current_trial_rt, na.rm = TRUE) + + incongruent_dat <- flanker_df[flanker_df$current_trial_congruency == 0,] + incongruent_dat_meanRT <- mean(incongruent_dat$current_trial_rt, na.rm = TRUE) + + + cong_errorDat <- errorDat[errorDat$current_trial_congruency == 1,] + incong_errorDat <- errorDat[errorDat$current_trial_congruency == 0,] + #for correct trials, compute mean RT (raw and log-corrected) + congCorr_meanRT <- mean(cong_corrDat$current_trial_rt, na.rm = TRUE) + incongCorr_meanRT <- mean(incong_corrDat$current_trial_rt, na.rm = TRUE) + + congErr_meanRT <- mean(cong_errorDat$current_trial_rt, na.rm = TRUE) + incongErr_meanRT <- mean(incong_errorDat$current_trial_rt, na.rm = TRUE) + + congCorr_logMeanRT <- mean(log((1+cong_corrDat$current_trial_rt)), na.rm = TRUE) + incongCorr_logMeanRT <- mean(log((1+incong_corrDat$current_trial_rt)), na.rm = TRUE) + + congErr_logMeanRT <- mean(log((1+cong_errorDat$current_trial_rt)), na.rm = TRUE) + incongErr_logMeanRT <- mean(log((1+incong_errorDat$current_trial_rt)), na.rm = TRUE) + + # compute flanker-effect scores for accuracy, RT, log-RT + flankEff_meanACC <- incongAcc - congAcc + flankEff_meanRT <- incongCorr_meanRT - congCorr_meanRT + flankEff_logMeanRT <- incongCorr_logMeanRT - congCorr_logMeanRT + + # + # number of committed errors in the flanker task + committed_errors <- nrow(errorDat) + # number of reported errors + psychopyDatTrim <- psychopyDat[("errorNum_text_box.text")] # stores the number of reported errors by subjects + reported_errors <- subset(psychopyDatTrim, complete.cases(psychopyDatTrim$errorNum_text_box.text)) + reported_errors <- reported_errors$errorNum_text_box.text # number of reported errors by participants + reported_errors <- str_extract_all(reported_errors, '\\d+\\.?\\d*') # to extract all sequences of digits from the input string + # There was a participant who had reported 70/100. values 70 and 100. To solve this issue, I replace this kind of values with NAs! + if (length(reported_errors) == 0){ # there is no reported errors + reported_errors <- NA + memoryBias_score <- NA + } else { + reported_errors <- parse_number(reported_errors[[1]]) # in cases like 70/100, we will have 70 100 at this stage. So, length(reported_errors) will + # higher than 1. + if (length(reported_errors) > 1){ # In case they have reported sth like 70/100 + reported_errors <- NA + memoryBias_score <- NA + } else if (length(reported_errors) == 1){ + reported_errors <- reported_errors[1] + memoryBias_score <- ((reported_errors - committed_errors)/ reported_errors) # percent bias score calculation + } + } + ############################################################################################################## + ############################################## EARLY BIN ##################################################### + ############################################################################################################## + early_bin_error_incong_flankerDat <- filter(error_incong_flankerDat, current_trial_face_delay_time < 0.334) + early_bin_correct_incong_flankerDat <- filter(incong_corrDat, current_trial_face_delay_time < 0.334) + + ### number of incong error faces identified as old + num_early_incong_errorFaces_reported_old <- 0 # this is the number of incongruent error faces that they report as OLD and will be updated in the loop below: + num_early_incong_errorFaces_reported_new <- 0 + for (iii in 1:nrow(early_bin_error_incong_flankerDat)){ + if (early_bin_error_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- early_bin_error_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong error face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_early_incong_errorFaces_reported_old <- num_early_incong_errorFaces_reported_old + 1 # The number of incongruent error faces that they report as OLD + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_early_incong_errorFaces_reported_new <- num_early_incong_errorFaces_reported_new + 1 # The number of incongruent error faces that they report as New + } + } + } + } # closing the loop over error incong flankerDat + + + ### number of incong correct faces identified as old + num_early_incong_correctFaces_reported_old <- 0 # this is the number of incongruent correct faces that they report as Old and will be updated in the loop below: + num_early_incong_correctFaces_reported_new <- 0 + for (iii in 1:nrow(early_bin_correct_incong_flankerDat)){ + if (early_bin_correct_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- early_bin_correct_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong correct face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_early_incong_correctFaces_reported_old <- num_early_incong_correctFaces_reported_old + 1 # The number of incongruent correct faces that they report as Old + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_early_incong_correctFaces_reported_new <- num_early_incong_correctFaces_reported_new + 1 # The number of incongruent correct faces that they report as New + } + } + } + } # closing the loop over correct incong flankerDat + + ############################################################################################################## + ############################################## Middle BIN #################################################### + ############################################################################################################## + mid_bin_error_incong_flankerDat <- filter(error_incong_flankerDat, current_trial_face_delay_time >= 0.334 & current_trial_face_delay_time <=0.667 ) + mid_bin_correct_incong_flankerDat <- filter(incong_corrDat, current_trial_face_delay_time >= 0.334 & current_trial_face_delay_time <=0.667) + + ### number of incong error faces identified as old + num_mid_incong_errorFaces_reported_old <- 0 # this is the number of incongruent error faces that they report as OLD and will be updated in the loop below: + num_mid_incong_errorFaces_reported_new <- 0 + for (iii in 1:nrow(mid_bin_error_incong_flankerDat)){ + if (mid_bin_error_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- mid_bin_error_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong error face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_mid_incong_errorFaces_reported_old <- num_mid_incong_errorFaces_reported_old + 1 # The number of incongruent error faces that they report as OLD + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_mid_incong_errorFaces_reported_new <- num_mid_incong_errorFaces_reported_new + 1 # The number of incongruent error faces that they report as New + } + } + } + } # closing the loop over error incong flankerDat + + + ### number of incong correct faces identified as old + num_mid_incong_correctFaces_reported_old <- 0 # this is the number of incongruent correct faces that they report as Old and will be updated in the loop below: + num_mid_incong_correctFaces_reported_new <- 0 + for (iii in 1:nrow(mid_bin_correct_incong_flankerDat)){ + if (mid_bin_correct_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- mid_bin_correct_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong correct face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_mid_incong_correctFaces_reported_old <- num_mid_incong_correctFaces_reported_old + 1 # The number of incongruent correct faces that they report as Old + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_mid_incong_correctFaces_reported_new <- num_mid_incong_correctFaces_reported_new + 1 # The number of incongruent correct faces that they report as New + } + } + } + } # closing the loop over correct incong flankerDat + + + ############################################################################################################## + ############################################## LATE BIN ##################################################### + ############################################################################################################## + late_bin_error_incong_flankerDat <- filter(error_incong_flankerDat, current_trial_face_delay_time > 0.667) + late_bin_correct_incong_flankerDat <- filter(incong_corrDat, current_trial_face_delay_time > 0.667) + + ### number of incong error faces identified as old + num_late_incong_errorFaces_reported_old <- 0 # this is the number of incongruent error faces that they report as OLD and will be updated in the loop below: + num_late_incong_errorFaces_reported_new <- 0 + for (iii in 1:nrow(late_bin_error_incong_flankerDat)){ + if (late_bin_error_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- late_bin_error_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong error face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_late_incong_errorFaces_reported_old <- num_late_incong_errorFaces_reported_old + 1 # The number of incongruent error faces that they report as OLD + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_late_incong_errorFaces_reported_new <- num_late_incong_errorFaces_reported_new + 1 # The number of incongruent error faces that they report as New + } + } + } + } # closing the loop over error incong flankerDat + + + ### number of incong correct faces identified as old + num_late_incong_correctFaces_reported_old <- 0 # this is the number of incongruent correct faces that they report as Old and will be updated in the loop below: + num_late_incong_correctFaces_reported_new <- 0 + for (iii in 1:nrow(late_bin_correct_incong_flankerDat)){ + if (late_bin_correct_incong_flankerDat$current_trial_legitResponse[iii] == 1){ # if this trial is legit + temp_face_from_flanker <- late_bin_correct_incong_flankerDat$current_trial_face[iii] + temp_face_row_in_surp <- filter(surprise_df, face == temp_face_from_flanker) + if (nrow(temp_face_row_in_surp) == 1){ # if old incong correct face exist in the surprise_df + if (temp_face_row_in_surp$surpAcc == 1){ # the old face is chosen as old correctly + num_late_incong_correctFaces_reported_old <- num_late_incong_correctFaces_reported_old + 1 # The number of incongruent correct faces that they report as Old + } else if (temp_face_row_in_surp$surpAcc == 0){ # the new face is chosen as old incorrectly + num_late_incong_correctFaces_reported_new <- num_late_incong_correctFaces_reported_new + 1 # The number of incongruent correct faces that they report as New + } + } + } + } # closing the loop over correct incong flankerDat + + + + # Overall hits, misses, FAs, and Correct rejections regardless of errors and corrects. + hit_num <- 0 + miss_num <- 0 + corr_rej_num <- 0 + false_alrams_num <- 0 + + for (surpTrial in 1:nrow(surprise_df)){ + if (surprise_df$surpAcc[surpTrial] == 1) { # The old face is identified correctly as old + hit_num <- hit_num + 1 + corr_rej_num <- corr_rej_num + 1 + } else if (surprise_df$surpAcc[surpTrial] == 0){ # The old face is identified incorrectly as new + miss_num <- miss_num + 1 + false_alrams_num <- false_alrams_num + 1 + } + } # Closing the loop over surprise_df trials + + overall_hitRate <- (hit_num) / ((hit_num) + miss_num) # hit rate + overall_false_alarm_rate <- (false_alrams_num)/ ((false_alrams_num) + (corr_rej_num)) + overall_dPrime <- psycho::dprime(hit_num, false_alrams_num, miss_num, corr_rej_num) + overall_dPrime <- overall_dPrime$dprime + + if (nrow(early_bin_error_incong_flankerDat) >= 8){ + early_incong_error_hit_num <- num_early_incong_errorFaces_reported_old + early_incong_error_miss_num <- num_early_incong_errorFaces_reported_new + early_error_hitRate <- (early_incong_error_hit_num) / ((early_incong_error_hit_num) + early_incong_error_miss_num) # hit rate + } else if (nrow(early_bin_error_incong_flankerDat) < 8){ + early_incong_error_hit_num <- NA + early_incong_error_miss_num <- NA + early_error_hitRate <- NA + } + + if (nrow(mid_bin_error_incong_flankerDat) >= 8){ + mid_incong_error_hit_num <- num_mid_incong_errorFaces_reported_old + mid_incong_error_miss_num <- num_mid_incong_errorFaces_reported_new + mid_error_hitRate <- (mid_incong_error_hit_num) / ((mid_incong_error_hit_num) + mid_incong_error_miss_num) # hit rate + } else if (nrow(mid_bin_error_incong_flankerDat) < 8){ + mid_incong_error_hit_num <- NA + mid_incong_error_miss_num <- NA + mid_error_hitRate <- NA + } + + if (nrow(late_bin_error_incong_flankerDat) >= 8){ + late_incong_error_hit_num <- num_late_incong_errorFaces_reported_old + late_incong_error_miss_num <- num_late_incong_errorFaces_reported_new + late_error_hitRate <- (late_incong_error_hit_num) / ((late_incong_error_hit_num) + late_incong_error_miss_num) # hit rate + } else if (nrow(late_bin_error_incong_flankerDat) < 8){ + late_incong_error_hit_num <- NA + late_incong_error_miss_num <- NA + late_error_hitRate <- NA + } + + + early_incong_correct_hit_num <- num_early_incong_correctFaces_reported_old + early_incong_correct_miss_num <- num_early_incong_correctFaces_reported_new + early_correct_hitRate <- (early_incong_correct_hit_num) / ((early_incong_correct_hit_num) + early_incong_correct_miss_num) # hit rate + + mid_incong_correct_hit_num <- num_mid_incong_correctFaces_reported_old + mid_incong_correct_miss_num <- num_mid_incong_correctFaces_reported_new + mid_correct_hitRate <- (mid_incong_correct_hit_num) / ((mid_incong_correct_hit_num) + mid_incong_correct_miss_num) # hit rate + + late_incong_correct_hit_num <- num_late_incong_correctFaces_reported_old + late_incong_correct_miss_num <- num_late_incong_correctFaces_reported_new + late_correct_hitRate <- (late_incong_correct_hit_num) / ((late_incong_correct_hit_num) + late_incong_correct_miss_num) # hit rate + + if (nrow(early_bin_error_incong_flankerDat) >= 8){ + early_hitRate_error_minus_correct <- early_error_hitRate - early_correct_hitRate + } else if (nrow(early_bin_error_incong_flankerDat) < 8){ + early_hitRate_error_minus_correct <- NA + } + + if (nrow(mid_bin_error_incong_flankerDat) >= 8){ + mid_hitRate_error_minus_correct <- mid_error_hitRate - mid_correct_hitRate + } else if (nrow(mid_bin_error_incong_flankerDat) < 8){ + mid_hitRate_error_minus_correct <- NA + } + + if (nrow(late_bin_error_incong_flankerDat) >= 8){ + late_hitRate_error_minus_correct <- late_error_hitRate - late_correct_hitRate + } else if (nrow(late_bin_error_incong_flankerDat) < 8){ + late_hitRate_error_minus_correct <- NA + } + + + #### filling the main data frame + main_df[nrow(main_df) + 1,] <-c(participant_id, congAcc, incongAcc, + incongruent_dat_meanRT, errorDat_meanRT, congruent_dat_meanRT, corrDat_meanRT, + congCorr_meanRT, incongCorr_meanRT, congCorr_logMeanRT, + congErr_meanRT, incongErr_meanRT, congErr_logMeanRT, incongErr_logMeanRT, + incongCorr_logMeanRT, flankEff_meanACC, flankEff_meanRT, flankEff_logMeanRT, + reported_errors, committed_errors, memoryBias_score, overall_hitRate, early_error_hitRate, + early_correct_hitRate, num_early_incong_correctFaces_reported_new, num_early_incong_correctFaces_reported_old, + num_early_incong_errorFaces_reported_new, num_early_incong_errorFaces_reported_old, mid_error_hitRate, + mid_correct_hitRate, num_mid_incong_correctFaces_reported_new, num_mid_incong_correctFaces_reported_old, + num_mid_incong_errorFaces_reported_new, num_mid_incong_errorFaces_reported_old, late_error_hitRate, + late_correct_hitRate, num_late_incong_correctFaces_reported_new, num_late_incong_correctFaces_reported_old, + num_late_incong_errorFaces_reported_new, num_late_incong_errorFaces_reported_old, hit_num, false_alrams_num, + miss_num, corr_rej_num, early_incong_error_hit_num, + early_incong_correct_hit_num, early_incong_error_miss_num, + early_incong_correct_miss_num, early_hitRate_error_minus_correct, mid_incong_error_hit_num, + mid_incong_correct_hit_num, mid_incong_error_miss_num, + mid_incong_correct_miss_num, mid_hitRate_error_minus_correct, late_incong_error_hit_num, + late_incong_correct_hit_num, late_incong_error_miss_num, + late_incong_correct_miss_num, late_hitRate_error_minus_correct,overall_dPrime) + + + } else { # If a participant has been excluded because they had less than 8 legit incong error faces in the surprise memory task, we add 1 to the counter below. + num_participants_removed_based_on_num_incong_error_faces_in_memory_surp <- num_participants_removed_based_on_num_incong_error_faces_in_memory_surp + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to not having 8 legit incong error faces in the surprise memory task.")) + #### end of printing output + } + } else { # If a participant has been excluded because they had less than 8 legit incong errors, we add 1 to the counter below. + num_of_participants_removed_based_on_incong_error_num <- num_of_participants_removed_based_on_incong_error_num + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to not having 8 legit incong errors in the flanker task.")) + #### end of printing output + } + } else { # if a participant has been excluded based on whether they have chosen the most chosen surprise response >= 90% and/or repeatedly choosing the same answer (12 times in a row at least)! + num_of_participants_removed_based_on_surp_response_frequency_andOR_repeated_ans <- num_of_participants_removed_based_on_surp_response_frequency_andOR_repeated_ans + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to response frequency and/or repeated answer criteria.")) + #### end of printing output + } + } else { # If a participant has been excluded because they had less than 60% flanker accuracy, we add 1 to the counter below. + num_of_participants_removed_based_on_accuracy <- num_of_participants_removed_based_on_accuracy + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded due to flanker accuracy below 60%.")) + #### end of printing output + } + } else { # If a participant has been excluded because they had more than 37.5% surp trial removed, we add 1 to the counter below. + num_of_participants_removed_based_on_memory_surp_trial_removal <- num_of_participants_removed_based_on_memory_surp_trial_removal + 1 + ### Printing output + print(paste("Participant ", participant_id, " was excluded as at least 37.5 % of their surprise trials were removed due to fast RT than 200 ms.")) + #### end of printing output + } +} # Closing the loop for each participant + + + + +### Loading RedCap questionnaire data +redcapDat <- read.csv(file = "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset/derivatives/preprocessed/redcap/202410v0memoryforerr_SCRD_2024-12-03_2224.csv") + +# stai state before and after the flanker task were not properly scored on the HPC due to an error in the naming. +# They will be scored here. +# STAI state before +redcapDat$stai5_scrdS_s1_r1_e1 <- rowSums(redcapDat[ , c("stai5_i1_s1_r1_e1", "stai5_i2_s1_r1_e1", "stai5_i3_s1_r1_e1", "stai5_i4_s1_r1_e1","stai5_i5_s1_r1_e1")]) + +# STAI state After +redcapDat$stai5_scrdS_s1_r1_e2 <- rowSums(redcapDat[ , c("stai5_i1_s1_r1_e1_v2","stai5_i2_s1_r1_e1_v2", "stai5_i3_s1_r1_e1_v2", "stai5_i4_s1_r1_e1_v2","stai5_i5_s1_r1_e1_v2")]) +# STAI state difference (After minus Before) +redcapDat$stai5_scrdS_diff <- (redcapDat$stai5_scrdS_s1_r1_e2 - redcapDat$stai5_scrdS_s1_r1_e1) + + +# scoring postTask_D questionnaire (sum posttaskd_i1, posttaskd_i3, posttaskd_i4,posttaskd_i5) +redcapDat$postTask_d_s1_r1_e1 <- rowSums(redcapDat[ , c("posttaskd_i1_s1_r1_e1","posttaskd_i3_s1_r1_e1", "posttaskd_i4_s1_r1_e1", "posttaskd_i5_s1_r1_e1")]) + + + +# Keeping the columns that we need! +redcapDat <- redcapDat[c("record_id", "demo_c_yob_s1_r1_e1", "scaared_b_scrdSoc_s1_r1_e1", "scaared_b_scrdGA_s1_r1_e1", "scaared_b_scrdTotal_s1_r1_e1", + "bfne_b_scrdTotal_s1_r1_e1", "epepq15_scrdTotal_s1_r1_e1", "phq8_scrdTotal_s1_r1_e1", + "stai5_scrdS_s1_r1_e1", "stai5_scrdS_s1_r1_e2", "stai5_scrdS_diff", "postTask_d_s1_r1_e1")] + + +# adding new columns to the "main_df" dataframe from redcapDat +for (rr in 1:nrow(main_df)){ + temp_id <- main_df$participant_id[rr] + tempDat <- filter(redcapDat, record_id == temp_id) + if (nrow(tempDat) == 1){ + main_df$scaared_b_scrdSoc_s1_r1_e1[rr] <- tempDat$scaared_b_scrdSoc_s1_r1_e1 + main_df$scaared_b_scrdTotal_s1_r1_e1[rr] <- tempDat$scaared_b_scrdTotal_s1_r1_e1 + main_df$bfne_b_scrdTotal_s1_r1_e1[rr] <- tempDat$bfne_b_scrdTotal_s1_r1_e1 + main_df$epepq15_scrdTotal_s1_r1_e1[rr] <- tempDat$epepq15_scrdTotal_s1_r1_e1 + main_df$phq8_scrdTotal_s1_r1_e1[rr] <- tempDat$phq8_scrdTotal_s1_r1_e1 + main_df$stai5_scrdS_s1_r1_e1[rr] <- tempDat$stai5_scrdS_s1_r1_e1 + main_df$stai5_scrdS_s1_r1_e2[rr] <- tempDat$stai5_scrdS_s1_r1_e2 + main_df$stai5_scrdS_diff[rr] <- tempDat$stai5_scrdS_diff + main_df$postTask_d_s1_r1_e1[rr] <- tempDat$postTask_d_s1_r1_e1 + main_df$scaared_b_scrdGA_s1_r1_e1[rr] <- tempDat$scaared_b_scrdGA_s1_r1_e1 + } else if (nrow(tempDat) == 0){ + main_df$scaared_b_scrdSoc_s1_r1_e1[rr] <- NA + main_df$scaared_b_scrdTotal_s1_r1_e1[rr] <- NA + main_df$bfne_b_scrdTotal_s1_r1_e1[rr] <- NA + main_df$epepq15_scrdTotal_s1_r1_e1[rr] <- NA + main_df$phq8_scrdTotal_s1_r1_e1[rr] <- NA + main_df$stai5_scrdS_s1_r1_e1[rr] <- NA + main_df$stai5_scrdS_s1_r1_e2[rr] <- NA + main_df$stai5_scrdS_diff[rr] <- NA + main_df$postTask_d_s1_r1_e1[rr] <- NA + main_df$scaared_b_scrdGA_s1_r1_e1[rr] <- NA + } +} + + + +#################### +# Save the dataset +#write the extracted and computed summary scores to disk +write.csv(main_df, paste(output_path, proc_fileName, sep = "/", collapse = NULL), row.names=FALSE) +################## + + diff --git a/code/stats/mfe_e_face_stats_v1.R b/code/stats/mfe_e_face_stats_v1.R new file mode 100644 index 0000000..2ebef4a --- /dev/null +++ b/code/stats/mfe_e_face_stats_v1.R @@ -0,0 +1,227 @@ +# This script will run stats on mini_mfe data. +# Author: Kianoosh Hosseini at NDCLab @FIU (https://Kianoosh.info; https://NDClab.com) +# Last Update: 2024-12-05 (YYYY-MM-DD) + +library(tidyverse) +library(dplyr) +library(stringr) +library(psycho) +library(car) +library(lme4) +library(ggplot2) +library(emmeans) +library(report) +library(sjPlot) +library(effsize) + + +#Working directory should be the Psychopy experiment directory. +proje_wd <- "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset" +setwd(proje_wd) + +processed_file_input <- paste(proje_wd, "derivatives", "psychopy", "stat_output", sep ="/", collapse = NULL) # input data directory + +main_df <- read.csv(file = paste(processed_file_input, "processed_data_mfe_e_Proj_v1.csv", sep ="/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + + +# Check the values in every column in main_df and remove the outliers based on +- 3SD. +# Write a function that removes the outliers from an array +remove_outliers <- function(x) { + mean_x <- mean(as.numeric(x), na.rm = TRUE) + sd_x <- sd(as.numeric(x), na.rm = TRUE) + for (xx in 1:length(x)){ + if (!is.na(x[xx])){ + if (x[xx] < (mean_x - 3*sd_x) | x[xx] > (mean_x + 3*sd_x)){ + x[xx] <- NA + } + } + } + return(x) +} +# apply this outlier removing function to all the columns in the dataframe except for participant ID column. +new_main_df <- main_df +new_main_df[-c(1, ncol(new_main_df))] <- apply(main_df[-c(1, ncol(main_df))], 2, remove_outliers) +main_df <- new_main_df + +mean(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # +sd(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # +median(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # + + +mean(main_df$post_error_acc, na.rm = TRUE) # +sd(main_df$post_error_acc, na.rm = TRUE) # + + +mean(main_df$post_error_rt, na.rm = TRUE) # +sd(main_df$post_error_rt, na.rm = TRUE) # + + +# flanker task stats +# Accuracy +mean(main_df$congAcc, na.rm = TRUE) +sd(main_df$congAcc, na.rm = TRUE) +# normality test +shapiro.test(main_df$congAcc) + + +mean(main_df$incongAcc, na.rm = TRUE) +sd(main_df$incongAcc, na.rm = TRUE) + +shapiro.test(main_df$incongAcc) +median(main_df$incongAcc, na.rm = TRUE) +IQR(main_df$incongAcc, na.rm = TRUE) +median(main_df$congAcc, na.rm = TRUE) +IQR(main_df$congAcc, na.rm = TRUE) + +# as they are not normal, we perform non-parametric Wilcoxon test instead of t-test +wil_acc <- wilcox.test(main_df$congAcc, main_df$incongAcc, alternative = 'greater', paired = TRUE, na.action = na.omit) +Z_acc <- qnorm(wil_acc$p.value/2) # z-score +r_acc <- abs(Z_acc)/sqrt(32) # r (effect size) However, I reported Cohen's d in the paper. # formulas are from https://stats.stackexchange.com/questions/330129/how-to-get-the-z-score-in-wilcox-test-in-r#:~:text=How%20can%20i%20get%20the,for%20wilcox%20test%20in%20R%3F&text=The%20R%20code%20never%20stores,to%20the%20equivalent%20z%2Dscore. +cohen.d(main_df$congAcc, main_df$incongAcc, paired=TRUE) + + +# RT (unit in seconds) +mean(main_df$congCorr_meanRT, na.rm = TRUE) +sd(main_df$congCorr_meanRT, na.rm = TRUE) +shapiro.test(main_df$congCorr_meanRT) +median(main_df$congCorr_meanRT, na.rm = TRUE) +IQR(main_df$congCorr_meanRT, na.rm = TRUE) + +mean(main_df$incongCorr_meanRT, na.rm = TRUE) +sd(main_df$incongCorr_meanRT, na.rm = TRUE) +shapiro.test(main_df$incongCorr_meanRT) +median(main_df$incongCorr_meanRT, na.rm = TRUE) +IQR(main_df$incongCorr_meanRT, na.rm = TRUE) + +mean(main_df$congErr_meanRT, na.rm = TRUE) +sd(main_df$congErr_meanRT, na.rm = TRUE) +shapiro.test(main_df$congErr_meanRT) + + +mean(main_df$incongErr_meanRT, na.rm = TRUE) +sd(main_df$incongErr_meanRT, na.rm = TRUE) +shapiro.test(main_df$incongErr_meanRT) + + +wil_RT <- wilcox.test(main_df$congCorr_meanRT, main_df$incongCorr_meanRT, alternative = 'less', paired = TRUE, na.action = na.omit) +Z_RT <- qnorm(wil_RT$p.value/2) +r_RT <- abs(Z_RT)/sqrt(32) +cohen.d(main_df$congCorr_meanRT, main_df$incongCorr_meanRT,paired=TRUE) +report(wilcox.test(main_df$congCorr_meanRT, main_df$incongCorr_meanRT, alternative = 'less', paired = TRUE, na.action = na.omit)) +################################################## +# Surprise memory task in mfe_c_face task +mean(main_df$overall_hitRate, na.rm = TRUE) +sd(main_df$overall_hitRate, na.rm = TRUE) + +mean(main_df$error_hitRate, na.rm = TRUE) +sd(main_df$error_hitRate, na.rm = TRUE) +shapiro.test(main_df$error_hitRate) # + +mean(main_df$correct_hitRate, na.rm = TRUE) # +sd(main_df$correct_hitRate, na.rm = TRUE) # +shapiro.test(main_df$correct_hitRate) # + +mean(main_df$post_error_hitRate, na.rm = TRUE) +sd(main_df$post_error_hitRate, na.rm = TRUE) +shapiro.test(main_df$post_error_hitRate) # + +mean(main_df$post_correct_hitRate, na.rm = TRUE) # +sd(main_df$post_correct_hitRate, na.rm = TRUE) # +shapiro.test(main_df$post_correct_hitRate) # + + +t.test(main_df$correct_hitRate, main_df$error_hitRate, paired = TRUE, na.action = na.omit) # + +t.test(main_df$post_correct_hitRate, main_df$post_error_hitRate, paired = TRUE, na.action = na.omit) # sig + +report(t.test(main_df$correct_hitRate, main_df$error_hitRate, alternative = 'less', paired = TRUE, na.action = na.omit)) +cohen.d(main_df$correct_hitRate, main_df$error_hitRate, paired=TRUE) + +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$overall_hitRate, method = 'pearson', na.action = na.omit) +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$flankEff_meanACC, method = 'pearson', na.action = na.omit) +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$incongAcc, method = 'pearson', na.action = na.omit) + + +################################################## +# Hit Rate correlation with SCAARED social + +lm_for_cor_fit_line <- lm(hitRate_error_minus_correct ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$hitRate_post_error_minus_correct, method = 'pearson', na.action = na.omit) + + +# scaared total +lm_for_cor_fit_line <- lm(hitRate_error_minus_correct ~ scaared_b_scrdTotal_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +# Hit Rate correlation with SCAARED GA + +lm_for_cor_fit_line <- lm(hitRate_error_minus_correct ~ scaared_b_scrdGA_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdGA_s1_r1_e1, main_df$hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdGA_s1_r1_e1, y=hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED General anxiety score", y = "Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +cor.test(main_df$scaared_b_scrdGA_s1_r1_e1, main_df$hitRate_post_error_minus_correct, method = 'pearson', na.action = na.omit) + + + +current_pep_HR_reg <- lm(hitRate_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdSoc_s1_r1_e1 , data = main_df) +summary(current_pep_HR_reg) +# plot +plot_model(current_pep_HR_reg, type = "eff", terms = c("epepq15_scrdTotal_s1_r1_e1","scaared_b_scrdSoc_s1_r1_e1")) + + + + +current_pep_HR_reg <- lm(hitRate_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdGA_s1_r1_e1 , data = main_df) +summary(current_pep_HR_reg) +# plot + + +########################## POST +post_pep_HR_reg <- lm(hitRate_post_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdSoc_s1_r1_e1 , data = main_df) +summary(post_pep_HR_reg) +# plot +plot_model(post_pep_HR_reg, type = "eff", terms = c("epepq15_scrdTotal_s1_r1_e1","scaared_b_scrdSoc_s1_r1_e1")) + + +post_pep_HR_reg <- lm(hitRate_post_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdGA_s1_r1_e1 , data = main_df) +summary(post_pep_HR_reg) +# plot \ No newline at end of file diff --git a/code/stats/mfe_e_face_stats_v2.R b/code/stats/mfe_e_face_stats_v2.R new file mode 100644 index 0000000..f0549ee --- /dev/null +++ b/code/stats/mfe_e_face_stats_v2.R @@ -0,0 +1,264 @@ +# This script will run stats on mini_mfe data. +# Author: Kianoosh Hosseini at NDCLab @FIU (https://Kianoosh.info; https://NDClab.com) +# Last Update: 2024-12-05 (YYYY-MM-DD) + +library(tidyverse) +library(dplyr) +library(stringr) +library(psycho) +library(car) +library(lme4) +library(ggplot2) +library(emmeans) +library(report) +library(sjPlot) +library(effsize) + + +#Working directory should be the Psychopy experiment directory. +proje_wd <- "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset" +setwd(proje_wd) + +processed_file_input <- paste(proje_wd, "derivatives", "psychopy", "stat_output", sep ="/", collapse = NULL) # input data directory + +main_df <- read.csv(file = paste(processed_file_input, "processed_data_mfe_e_Proj_v2.csv", sep ="/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + + +# Check the values in every column in main_df and remove the outliers based on +- 3SD. +# Write a function that removes the outliers from an array +remove_outliers <- function(x) { + mean_x <- mean(as.numeric(x), na.rm = TRUE) + sd_x <- sd(as.numeric(x), na.rm = TRUE) + for (xx in 1:length(x)){ + if (!is.na(x[xx])){ + if (x[xx] < (mean_x - 3*sd_x) | x[xx] > (mean_x + 3*sd_x)){ + x[xx] <- NA + } + } + } + return(x) +} +# apply this outlier removing function to all the columns in the dataframe except for participant ID column. +new_main_df <- main_df +new_main_df[-c(1, ncol(new_main_df))] <- apply(main_df[-c(1, ncol(main_df))], 2, remove_outliers) +main_df <- new_main_df + +mean(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # +sd(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # +median(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # + + +mean(main_df$post_error_acc, na.rm = TRUE) # +sd(main_df$post_error_acc, na.rm = TRUE) # + + +mean(main_df$post_error_rt, na.rm = TRUE) # +sd(main_df$post_error_rt, na.rm = TRUE) # + + +# flanker task stats +# Accuracy +mean(main_df$congAcc, na.rm = TRUE) +sd(main_df$congAcc, na.rm = TRUE) +# normality test +shapiro.test(main_df$congAcc) + + +mean(main_df$incongAcc, na.rm = TRUE) +sd(main_df$incongAcc, na.rm = TRUE) + +shapiro.test(main_df$incongAcc) +median(main_df$incongAcc, na.rm = TRUE) +IQR(main_df$incongAcc, na.rm = TRUE) +median(main_df$congAcc, na.rm = TRUE) +IQR(main_df$congAcc, na.rm = TRUE) + +# as they are not normal, we perform non-parametric Wilcoxon test instead of t-test +wil_acc <- wilcox.test(main_df$congAcc, main_df$incongAcc, alternative = 'greater', paired = TRUE, na.action = na.omit) +Z_acc <- qnorm(wil_acc$p.value/2) # z-score +r_acc <- abs(Z_acc)/sqrt(32) # r (effect size) However, I reported Cohen's d in the paper. # formulas are from https://stats.stackexchange.com/questions/330129/how-to-get-the-z-score-in-wilcox-test-in-r#:~:text=How%20can%20i%20get%20the,for%20wilcox%20test%20in%20R%3F&text=The%20R%20code%20never%20stores,to%20the%20equivalent%20z%2Dscore. +cohen.d(main_df$congAcc, main_df$incongAcc, paired=TRUE) + + +# RT (unit in seconds) +mean(main_df$congCorr_meanRT, na.rm = TRUE) +sd(main_df$congCorr_meanRT, na.rm = TRUE) +shapiro.test(main_df$congCorr_meanRT) +median(main_df$congCorr_meanRT, na.rm = TRUE) +IQR(main_df$congCorr_meanRT, na.rm = TRUE) + +mean(main_df$incongCorr_meanRT, na.rm = TRUE) +sd(main_df$incongCorr_meanRT, na.rm = TRUE) +shapiro.test(main_df$incongCorr_meanRT) +median(main_df$incongCorr_meanRT, na.rm = TRUE) +IQR(main_df$incongCorr_meanRT, na.rm = TRUE) + +mean(main_df$congErr_meanRT, na.rm = TRUE) +sd(main_df$congErr_meanRT, na.rm = TRUE) +shapiro.test(main_df$congErr_meanRT) + + +mean(main_df$incongErr_meanRT, na.rm = TRUE) +sd(main_df$incongErr_meanRT, na.rm = TRUE) +shapiro.test(main_df$incongErr_meanRT) + + +wil_RT <- wilcox.test(main_df$congCorr_meanRT, main_df$incongCorr_meanRT, alternative = 'less', paired = TRUE, na.action = na.omit) +Z_RT <- qnorm(wil_RT$p.value/2) +r_RT <- abs(Z_RT)/sqrt(32) +cohen.d(main_df$congCorr_meanRT, main_df$incongCorr_meanRT,paired=TRUE) +report(wilcox.test(main_df$congCorr_meanRT, main_df$incongCorr_meanRT, alternative = 'less', paired = TRUE, na.action = na.omit)) +################################################## +# Surprise memory task in mfe_c_face task +mean(main_df$overall_hitRate, na.rm = TRUE) +sd(main_df$overall_hitRate, na.rm = TRUE) + +mean(main_df$early_error_hitRate, na.rm = TRUE) +sd(main_df$early_error_hitRate, na.rm = TRUE) + + +mean(main_df$late_error_hitRate, na.rm = TRUE) +sd(main_df$late_error_hitRate, na.rm = TRUE) + +mean(main_df$early_correct_hitRate, na.rm = TRUE) # +sd(main_df$early_correct_hitRate, na.rm = TRUE) # + +mean(main_df$late_correct_hitRate, na.rm = TRUE) # +sd(main_df$late_correct_hitRate, na.rm = TRUE) # + +shapiro.test(main_df$correct_hitRate) # + + +t.test(main_df$early_correct_hitRate, main_df$early_error_hitRate, paired = TRUE, na.action = na.omit) # +t.test(main_df$late_correct_hitRate, main_df$late_error_hitRate, paired = TRUE, na.action = na.omit) # + + +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$overall_hitRate, method = 'pearson', na.action = na.omit) +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$flankEff_meanACC, method = 'pearson', na.action = na.omit) +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$incongAcc, method = 'pearson', na.action = na.omit) + + +################################################## +# Hit Rate correlation with SCAARED social + +lm_for_cor_fit_line <- lm(early_hitRate_error_minus_correct ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=early_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "EARLY Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=early_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "EARLY Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=early_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "EARLY Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +lm_for_cor_fit_line <- lm(late_hitRate_error_minus_correct ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$late_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=late_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "late Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +lm_for_cor_fit_line <- lm(late_error_hitRate ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=late_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "late Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=late_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "late Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + + +# scaared total +lm_for_cor_fit_line <- lm(early_hitRate_error_minus_correct ~ scaared_b_scrdTotal_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$early_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=early_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "early Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=early_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "early Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=early_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "early Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + + +lm_for_cor_fit_line <- lm(late_hitRate_error_minus_correct ~ scaared_b_scrdTotal_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$late_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=late_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "late Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=late_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "late Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=late_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "late Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +# Hit Rate correlation with SCAARED GA + +lm_for_cor_fit_line <- lm(hitRate_error_minus_correct ~ scaared_b_scrdGA_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdGA_s1_r1_e1, main_df$hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdGA_s1_r1_e1, y=hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED General anxiety score", y = "Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +cor.test(main_df$scaared_b_scrdGA_s1_r1_e1, main_df$hitRate_post_error_minus_correct, method = 'pearson', na.action = na.omit) + + + +current_pep_HR_reg <- lm(hitRate_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdSoc_s1_r1_e1 , data = main_df) +summary(current_pep_HR_reg) +# plot +plot_model(current_pep_HR_reg, type = "eff", terms = c("epepq15_scrdTotal_s1_r1_e1","scaared_b_scrdSoc_s1_r1_e1")) + + + + +current_pep_HR_reg <- lm(hitRate_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdGA_s1_r1_e1 , data = main_df) +summary(current_pep_HR_reg) +# plot + + +########################## POST +post_pep_HR_reg <- lm(hitRate_post_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdSoc_s1_r1_e1 , data = main_df) +summary(post_pep_HR_reg) +# plot +plot_model(post_pep_HR_reg, type = "eff", terms = c("epepq15_scrdTotal_s1_r1_e1","scaared_b_scrdSoc_s1_r1_e1")) + + +post_pep_HR_reg <- lm(hitRate_post_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdGA_s1_r1_e1 , data = main_df) +summary(post_pep_HR_reg) +# plot \ No newline at end of file diff --git a/code/stats/mfe_e_face_stats_v3.R b/code/stats/mfe_e_face_stats_v3.R new file mode 100644 index 0000000..1375881 --- /dev/null +++ b/code/stats/mfe_e_face_stats_v3.R @@ -0,0 +1,289 @@ +# This script will run stats on mini_mfe data. +# Author: Kianoosh Hosseini at NDCLab @FIU (https://Kianoosh.info; https://NDClab.com) +# Last Update: 2024-12-05 (YYYY-MM-DD) + +library(tidyverse) +library(dplyr) +library(stringr) +library(psycho) +library(car) +library(lme4) +library(ggplot2) +library(emmeans) +library(report) +library(sjPlot) +library(effsize) + + +#Working directory should be the Psychopy experiment directory. +proje_wd <- "/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset" +setwd(proje_wd) + +processed_file_input <- paste(proje_wd, "derivatives", "psychopy", "stat_output", sep ="/", collapse = NULL) # input data directory + +main_df <- read.csv(file = paste(processed_file_input, "processed_data_mfe_e_Proj_v3.csv", sep ="/", collapse = NULL), stringsAsFactors = FALSE, na.strings=c("", "NA")) + + +# Check the values in every column in main_df and remove the outliers based on +- 3SD. +# Write a function that removes the outliers from an array +remove_outliers <- function(x) { + mean_x <- mean(as.numeric(x), na.rm = TRUE) + sd_x <- sd(as.numeric(x), na.rm = TRUE) + for (xx in 1:length(x)){ + if (!is.na(x[xx])){ + if (x[xx] < (mean_x - 3*sd_x) | x[xx] > (mean_x + 3*sd_x)){ + x[xx] <- NA + } + } + } + return(x) +} +# apply this outlier removing function to all the columns in the dataframe except for participant ID column. +new_main_df <- main_df +new_main_df[-c(1, ncol(new_main_df))] <- apply(main_df[-c(1, ncol(main_df))], 2, remove_outliers) +main_df <- new_main_df + +mean(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # +sd(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # +median(main_df$epepq15_scrdTotal_s1_r1_e1, na.rm = TRUE) # + + +mean(main_df$post_error_acc, na.rm = TRUE) # +sd(main_df$post_error_acc, na.rm = TRUE) # + + +mean(main_df$post_error_rt, na.rm = TRUE) # +sd(main_df$post_error_rt, na.rm = TRUE) # + + +# flanker task stats +# Accuracy +mean(main_df$congAcc, na.rm = TRUE) +sd(main_df$congAcc, na.rm = TRUE) +# normality test +shapiro.test(main_df$congAcc) + + +mean(main_df$incongAcc, na.rm = TRUE) +sd(main_df$incongAcc, na.rm = TRUE) + +shapiro.test(main_df$incongAcc) +median(main_df$incongAcc, na.rm = TRUE) +IQR(main_df$incongAcc, na.rm = TRUE) +median(main_df$congAcc, na.rm = TRUE) +IQR(main_df$congAcc, na.rm = TRUE) + +# as they are not normal, we perform non-parametric Wilcoxon test instead of t-test +wil_acc <- wilcox.test(main_df$congAcc, main_df$incongAcc, alternative = 'greater', paired = TRUE, na.action = na.omit) +Z_acc <- qnorm(wil_acc$p.value/2) # z-score +r_acc <- abs(Z_acc)/sqrt(32) # r (effect size) However, I reported Cohen's d in the paper. # formulas are from https://stats.stackexchange.com/questions/330129/how-to-get-the-z-score-in-wilcox-test-in-r#:~:text=How%20can%20i%20get%20the,for%20wilcox%20test%20in%20R%3F&text=The%20R%20code%20never%20stores,to%20the%20equivalent%20z%2Dscore. +cohen.d(main_df$congAcc, main_df$incongAcc, paired=TRUE) + + +# RT (unit in seconds) +mean(main_df$congCorr_meanRT, na.rm = TRUE) +sd(main_df$congCorr_meanRT, na.rm = TRUE) +shapiro.test(main_df$congCorr_meanRT) +median(main_df$congCorr_meanRT, na.rm = TRUE) +IQR(main_df$congCorr_meanRT, na.rm = TRUE) + +mean(main_df$incongCorr_meanRT, na.rm = TRUE) +sd(main_df$incongCorr_meanRT, na.rm = TRUE) +shapiro.test(main_df$incongCorr_meanRT) +median(main_df$incongCorr_meanRT, na.rm = TRUE) +IQR(main_df$incongCorr_meanRT, na.rm = TRUE) + +mean(main_df$congErr_meanRT, na.rm = TRUE) +sd(main_df$congErr_meanRT, na.rm = TRUE) +shapiro.test(main_df$congErr_meanRT) + + +mean(main_df$incongErr_meanRT, na.rm = TRUE) +sd(main_df$incongErr_meanRT, na.rm = TRUE) +shapiro.test(main_df$incongErr_meanRT) + + +wil_RT <- wilcox.test(main_df$congCorr_meanRT, main_df$incongCorr_meanRT, alternative = 'less', paired = TRUE, na.action = na.omit) +Z_RT <- qnorm(wil_RT$p.value/2) +r_RT <- abs(Z_RT)/sqrt(32) +cohen.d(main_df$congCorr_meanRT, main_df$incongCorr_meanRT,paired=TRUE) +report(wilcox.test(main_df$congCorr_meanRT, main_df$incongCorr_meanRT, alternative = 'less', paired = TRUE, na.action = na.omit)) +################################################## +# Surprise memory task in mfe_c_face task +mean(main_df$overall_hitRate, na.rm = TRUE) +sd(main_df$overall_hitRate, na.rm = TRUE) + +mean(main_df$early_error_hitRate, na.rm = TRUE) +sd(main_df$early_error_hitRate, na.rm = TRUE) + +mean(main_df$mid_error_hitRate, na.rm = TRUE) +sd(main_df$mid_error_hitRate, na.rm = TRUE) + +mean(main_df$late_error_hitRate, na.rm = TRUE) +sd(main_df$late_error_hitRate, na.rm = TRUE) + +mean(main_df$early_correct_hitRate, na.rm = TRUE) # +sd(main_df$early_correct_hitRate, na.rm = TRUE) # + +mean(main_df$mid_correct_hitRate, na.rm = TRUE) # +sd(main_df$mid_correct_hitRate, na.rm = TRUE) # + +mean(main_df$late_correct_hitRate, na.rm = TRUE) # +sd(main_df$late_correct_hitRate, na.rm = TRUE) # + +shapiro.test(main_df$correct_hitRate) # + + +t.test(main_df$early_correct_hitRate, main_df$early_error_hitRate, paired = TRUE, na.action = na.omit) # +t.test(main_df$mid_correct_hitRate, main_df$mid_error_hitRate, paired = TRUE, na.action = na.omit) # +t.test(main_df$late_correct_hitRate, main_df$late_error_hitRate, paired = TRUE, na.action = na.omit) # + + +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$overall_hitRate, method = 'pearson', na.action = na.omit) +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$flankEff_meanACC, method = 'pearson', na.action = na.omit) +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$incongAcc, method = 'pearson', na.action = na.omit) + + +################################################## +# Hit Rate correlation with SCAARED social + +lm_for_cor_fit_line <- lm(early_hitRate_error_minus_correct ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=early_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "EARLY Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=early_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "EARLY Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=early_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "EARLY Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +lm_for_cor_fit_line <- lm(mid_hitRate_error_minus_correct ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=mid_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "Middle Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=mid_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "Middle Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=mid_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "Middle Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + +lm_for_cor_fit_line <- lm(late_hitRate_error_minus_correct ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$late_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=late_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "late Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +lm_for_cor_fit_line <- lm(late_error_hitRate ~ scaared_b_scrdSoc_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) + +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=late_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "late Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +cor.test(main_df$scaared_b_scrdSoc_s1_r1_e1, main_df$late_correct_hitRate, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdSoc_s1_r1_e1, y=late_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED social anxiety score", y = "late Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + + +# scaared total +lm_for_cor_fit_line <- lm(early_hitRate_error_minus_correct ~ scaared_b_scrdTotal_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$early_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=early_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "early Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=early_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "early Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=early_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "early Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +lm_for_cor_fit_line <- lm(mid_hitRate_error_minus_correct ~ scaared_b_scrdTotal_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$mid_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=mid_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "middle Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$mid_error_hitRate, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=mid_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "middle Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$mid_correct_hitRate, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=mid_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "middle Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + + +lm_for_cor_fit_line <- lm(late_hitRate_error_minus_correct ~ scaared_b_scrdTotal_s1_r1_e1, main_df) +summary(lm_for_cor_fit_line) +cor.test(main_df$scaared_b_scrdTotal_s1_r1_e1, main_df$late_hitRate_error_minus_correct, method = 'pearson', na.action = na.omit) +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=late_hitRate_error_minus_correct)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "late Error vs. Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=late_error_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "late Error Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + +ggplot(main_df, aes(x=scaared_b_scrdTotal_s1_r1_e1, y=late_correct_hitRate)) + geom_point(size = 4) + geom_smooth(method="lm") + + labs(x = "SCAARED total anxiety score", y = "late Correct Hit rate") + + theme_bw() + theme(panel.border = element_blank(), panel.grid.major = element_blank(), + panel.grid.minor = element_blank(), axis.line = element_line(colour = "black")) + theme(axis.text = element_text(size = 15)) + theme(text = element_text(size = 18)) + + + +current_pep_HR_reg <- lm(early_hitRate_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdSoc_s1_r1_e1 , data = main_df) +summary(current_pep_HR_reg) + +current_pep_HR_reg <- lm(mid_hitRate_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdSoc_s1_r1_e1 , data = main_df) +summary(current_pep_HR_reg) + +current_pep_HR_reg <- lm(late_hitRate_error_minus_correct ~ epepq15_scrdTotal_s1_r1_e1*scaared_b_scrdSoc_s1_r1_e1 , data = main_df) +summary(current_pep_HR_reg) + +# plot +plot_model(current_pep_HR_reg, type = "eff", terms = c("scaared_b_scrdSoc_s1_r1_e1","epepq15_scrdTotal_s1_r1_e1")) + + + + + diff --git a/materials/mfe_e/blockSelect.csv b/materials/mfe_e/blockSelect.csv new file mode 100644 index 0000000..5b3fd31 --- /dev/null +++ b/materials/mfe_e/blockSelect.csv @@ -0,0 +1,13 @@ +whichBlock +flanker_main_block_1.csv +flanker_main_block_2.csv +flanker_main_block_3.csv +flanker_main_block_4.csv +flanker_main_block_5.csv +flanker_main_block_6.csv +flanker_main_block_7.csv +flanker_main_block_8.csv +flanker_main_block_9.csv +flanker_main_block_10.csv +flanker_main_block_11.csv +flanker_main_block_12.csv \ No newline at end of file diff --git a/materials/mfe_e/blockSelect_practice.csv b/materials/mfe_e/blockSelect_practice.csv new file mode 100644 index 0000000..68a7223 --- /dev/null +++ b/materials/mfe_e/blockSelect_practice.csv @@ -0,0 +1,2 @@ +whichBlock +flanker_practice_block.csv \ No newline at end of file diff --git a/materials/mfe_e/flanker_main_block_1.csv b/materials/mfe_e/flanker_main_block_1.csv new file mode 100644 index 0000000..e3094ec --- /dev/null +++ b/materials/mfe_e/flanker_main_block_1.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-258-125-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-638-250-1-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-219-295-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-242-121-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-241-141-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-227-099-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-233-171-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-313-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-212-117-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-231-155-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-017-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-620-218-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-209-052-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-206-079-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-010-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-727-195-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-238-190-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-005-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-247-051-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-657-308-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-242-011-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-686-097-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-226-175-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-665-015-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-245-166-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-617-174-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-026-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-202-122-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-018-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-653-008-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-033-028-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-250-169-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_10.csv b/materials/mfe_e/flanker_main_block_10.csv new file mode 100644 index 0000000..ca76c73 --- /dev/null +++ b/materials/mfe_e/flanker_main_block_10.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MM-316-156-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-212-050-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-205-100-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-224-099-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-230-203-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-218-183-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-651-308-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-250-167-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-011-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-033-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-213-188-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-203-066-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-231-357-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-214-090-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-041-021-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-239-136-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-253-202-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-710-016-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-684-008-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-019-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-021-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-041-035-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-224-176-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-039-031-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-201-076-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-029-031-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-337-026-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-205-141-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-213-031-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-215-247-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-693-172-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-634-382-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_11.csv b/materials/mfe_e/flanker_main_block_11.csv new file mode 100644 index 0000000..1137541 --- /dev/null +++ b/materials/mfe_e/flanker_main_block_11.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-212-050-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-217-162-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-201-035-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-327-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-229-160-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-217-085-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-232-070-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-043-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-675-015-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-300-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MM-304-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-008-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-637-007-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-248-129-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-685-004-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-340-026-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-039-029-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-254-167-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-236-090-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-012-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-215-70-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-051-035-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-024-015-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-224-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-709-103-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-329-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-608-390-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-213-076-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-604-014-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-226-174-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-243-218-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-619-197-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_12.csv b/materials/mfe_e/flanker_main_block_12.csv new file mode 100644 index 0000000..f8ef96c --- /dev/null +++ b/materials/mfe_e/flanker_main_block_12.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-625-225-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-336-016-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-033-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-045-003-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-254-152-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-223-133-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-673-389-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-247-095-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-222-240-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-225-164-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-744-114-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-239-171-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-208-127-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-004-014-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-013-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-227-207-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-010-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-228-065-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-006-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-210-050-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-738-191-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-238-129-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-210-220-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-659-359-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-202-107-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-028-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-241-188-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-312-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-213-134-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-701-312-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-003-003-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-221-184-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_2.csv b/materials/mfe_e/flanker_main_block_2.csv new file mode 100644 index 0000000..6818a2b --- /dev/null +++ b/materials/mfe_e/flanker_main_block_2.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-009-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-025-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-689-263-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-697-015-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-243-212-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-021-021-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-012-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-237-223-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-328-020-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-030-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MM-306-010-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-219-101-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-028-003-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-249-163-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-020-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-241-210-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-676-017-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-227-191-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-221-005-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-240-013-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-023-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-606-008-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-222-147-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-207-014-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-205-153-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-238-154-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-615-167-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-244-231-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-212-066-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-009-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-043-071-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-243-148-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_3.csv b/materials/mfe_e/flanker_main_block_3.csv new file mode 100644 index 0000000..2f4a37d --- /dev/null +++ b/materials/mfe_e/flanker_main_block_3.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-703-182-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-226-119-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-225-154-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-251-124-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-001-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-253-004-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-743-006-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-229-179-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-242-176-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-333-012-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-650-315-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-359-019-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-219-008-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-645-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-623-129-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-237-264-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-038-037-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-671-601-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-232-187-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-616-214-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-211-052-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-033-025-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-004-010-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-235-147-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-218-072-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-352-054-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-020-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-200-099-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-220-120-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-036-023-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-214-122-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-228-188-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_4.csv b/materials/mfe_e/flanker_main_block_4.csv new file mode 100644 index 0000000..dce41b4 --- /dev/null +++ b/materials/mfe_e/flanker_main_block_4.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-215-155-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-217-189-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-234-208-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-632-097-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-235-121-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-040-003-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-636-011-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-206-143-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-205-155-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-018-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-302-027-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-245-111-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-669-111-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-233-236-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-020-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-253-119-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-678-482-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-241-125-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-042-026-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-235-168-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-244-168-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-307-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-239-148-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-250-200-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-004-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-732-260-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-213-126-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-635-010-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-204-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-225-102-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-246-242-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-210-086-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_5.csv b/materials/mfe_e/flanker_main_block_5.csv new file mode 100644 index 0000000..9234ac1 --- /dev/null +++ b/materials/mfe_e/flanker_main_block_5.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-742-103-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-696-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-707-105-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-238-242-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-677-452-1-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-208-068-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-230-150-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-029-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-006-017-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-044-034-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-241-235-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-248-036-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-213-061-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-014-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-301-024-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-726-248-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-034-030-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-233-112-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-214-308-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-204-133-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-002-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-236-177-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-027-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-247-179-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-234-086-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-207-024-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-729-393-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-036-027-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-036-003-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-721-341-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-207-004-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-011-002-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_6.csv b/materials/mfe_e/flanker_main_block_6.csv new file mode 100644 index 0000000..f199e11 --- /dev/null +++ b/materials/mfe_e/flanker_main_block_6.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-023-010-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-015-015-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-216-121-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-215-120-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-217-085-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-674-281-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-028-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-236-221-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-040-022-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-257-161-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-639-263-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-002-004-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-201-080-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-003-003-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-022-017-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MM-319-052-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-728-041-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-204-189-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-247-240-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-002-009-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-027-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-672-305-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-255-140-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-029-024-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-225-127-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-211-174-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-235-241-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-252-076-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-718-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-038-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-208-266-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-026-002-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_7.csv b/materials/mfe_e/flanker_main_block_7.csv new file mode 100644 index 0000000..85fe21a --- /dev/null +++ b/materials/mfe_e/flanker_main_block_7.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-012-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-648-337-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-228-196-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-249-239-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-041-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-228-212-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-243-075-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-214-165-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-244-068-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-646-023-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-201-057-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MM-317-061-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-240-206-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-642-295-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-216-082-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-006-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-248-128-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-309-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-212-097-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-025-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-247-165-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-017-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-212-315-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-251-013-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-335-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-215-041-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-240-083-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-019-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-005-010-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-026-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-205-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-202-109-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_8.csv b/materials/mfe_e/flanker_main_block_8.csv new file mode 100644 index 0000000..c5b1362 --- /dev/null +++ b/materials/mfe_e/flanker_main_block_8.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-237-052-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-245-084-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-023-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-201-063-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-027-003-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-254-201-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-018-017-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-629-234-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-244-222-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MM-321-021-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-221-147-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-318-022-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-700-009-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-627-178-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-253-075-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-238-023-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-218-207-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-009-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-204-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-342-022-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-719-221-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-211-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-200-046-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-226-095-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-018-039-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-255-219-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-232-078-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-023-029-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-215-157-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-221-091-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-321-003-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-013-001-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_main_block_9.csv b/materials/mfe_e/flanker_main_block_9.csv new file mode 100644 index 0000000..7a3529c --- /dev/null +++ b/materials/mfe_e/flanker_main_block_9.csv @@ -0,0 +1,33 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-660-464-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-343-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-706-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-217-082-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-305-014-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-007-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-702-101-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-206-078-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-237-172-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-001-014-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-218-074-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-667-369-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-030-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MM-324-069-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-244-163-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-015-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-220-134-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-316-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-222-092-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-253-130-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-233-190-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-680-369-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-014-002-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-225-130-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-626-375-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LF-255-088-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-303-013-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-MF-357-002-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-664-651-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-200-045-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-250-170-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-209-038-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/flanker_practice_block.csv b/materials/mfe_e/flanker_practice_block.csv new file mode 100644 index 0000000..be32b65 --- /dev/null +++ b/materials/mfe_e/flanker_practice_block.csv @@ -0,0 +1,21 @@ +middleStim,leftStim,rightStim,stimNum,congruent,target,locationC,locationR,locationL,straightFace,imageSize +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-010-004-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-019-001-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-224-126-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-011-016-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-203-086-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-247-084-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-215-145-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-232-204-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-032-024-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IM-670-215-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-213-056-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BF-216-132-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-IF-714-008-1-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-239-155-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-BM-228-145-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AF-216-106-N.jpg,"[.035, .035]" +img/rightArrow.png,img/leftArrow.png,img/leftArrow.png,7,0,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WF-031-027-N.jpg,"[.035, .035]" +img/leftArrow.png,img/rightArrow.png,img/rightArrow.png,8,0,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-LM-249-001-N.jpg,"[.035, .035]" +img/rightArrow.png,img/rightArrow.png,img/rightArrow.png,5,1,right,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-WM-234-118-N.jpg,"[.035, .035]" +img/leftArrow.png,img/leftArrow.png,img/leftArrow.png,6,1,left,"[0,0]","[0.0385,0]","[-0.0385,0]",img/neutralC/CFD-AM-240-191-N.jpg,"[.035, .035]" diff --git a/materials/mfe_e/img/cover_background.png b/materials/mfe_e/img/cover_background.png new file mode 100644 index 0000000000000000000000000000000000000000..641c71f33ec448b51cdc049cfd519987b1df161a GIT binary patch literal 4808 zcmeAS@N?(olHy`uVBq!ia0y~yU_QXWz;uCw4JZ;{F1dw)L8#x;#WAEJ?(KC$FBV1y z=Zm&86O@~#a+FP*x${5oovIrg)1>b;*EgH&ybIJb3PwYK{1Euj|JmmLj2fRe9o|0c~s$O@Qfyk(X239QjC_5qqV|lr8(ME7;PYpHVa2mtNF3b`RR`> v?m>DF>w&!o^7|&EI!8lbGz11Z1nPgYUfa8(ra;)t4dfJ0S3j3^P6GZx^prwft-re2+uTM zUj{88n}dOcQHp^Tqy&iV7^UHCH%1KxX0SNWoc2rx7N{COAPoc{J3xA%H1h&RsA{0t z0w$PhrV9(05p0mYPSJ0|K#H@#BeIx*A#WE5GhVy5QJjH6#oN=xF{Fa=?ahs=<~(k!mTvPEcbGP(c!c-*fazwghM`p3_|yq1%fumAC|{rpSu z-)mX+Wi&32|57$h`GX~=4G>g+dsF=D==^W_tv@sGA74LPxMIfb8;2m#?GWowaOEVg z3fRxpOijt}pP8wFIi-vT1J%tZfYZYpPL964vv1D;bFQ$mxX-=g08TF()De)V zIRWAVGNnb#oSj0P7Y(`f1%%_odZqs7W-0m(61pN!UwEF7Z^ ziP3hK!e|R}w81T)K;5pxyesPe>K~l9|NrN-{{BDVm(Qwx;N${!glhhNy*~c||8JlA zOY`gh{d{+K_xUf!f8S)WYdes?|L?cI-|yG=O#gp!w*UW=_rDnao45bp-Cuuxe(wLc z$sE{^`7r&!WOe^P-pA}YS?ol9Je!?w_viGd`G3`?8to_q_ofm89SU^f?w$j47U(Eg zoO*Cf5Y(q`bY(oav7*#k7|hw!@Ia$k+8x~07Gq^O{^;skA28<>Q`2IeJQ;8gJVHc3 zraOGQF_@#l&Cxe%2{0%|gKIQ(F|my1lVM)09Ju^x&;H|kYkz;c9$)|WxBlNohDJ~c zeY9I#CWz_%{r&ZypZUHreJ}8XiRB+~AnboZxBCBwIg2?3egr&NKEJN&@2{`z@qd2a z=diJ}tNVVp{Qoo7|M5&LO-%nLdkI_)hKzk3&{eR=6ORWEQ86?wXn4SpRMiC;|J(sA zmft?ohKz*@0E=QrAAfL3&d9XA;lYmB8db<3VG~o6a>q+e$k^!vF#(zF-Rq$PYXJ@g zEQYqOkO9>@Oiho=K2C)g&cVger?6}}WVp34+M(c%-aaA7(5oZkLBS(mL?HGS089Pb zN5dh8D`+TKG|iZ&1hF@d@nGTZA6^i{S%3p_qn-i<`)Ev!CO=SfYcx-d78Jl_Fj}OK z)>FXRbF}guZBYP|!DusSv_T7;njUSX51p<@MOFQ`sSJ&~4&2_JAHTOMRQ~r-zCXZW vy8Soq>bOBVKcj0_ApJw?gvJkXrvJ=c-NvqKZf#`)tvT{^^>bP0l+XkKJgQ>a literal 0 HcmV?d00001 diff --git a/materials/mfe_e/img/halfV_trial_csv_creator.asv b/materials/mfe_e/img/halfV_trial_csv_creator.asv new file mode 100644 index 0000000..da5ae09 --- /dev/null +++ b/materials/mfe_e/img/halfV_trial_csv_creator.asv @@ -0,0 +1,313 @@ +%% This script is written by Kianoosh Hosseini at NDClab (See https://Kianoosh.info and https://ndclab.com) in May 2022 and updated in september 2023. +%%% For Chicago faces ... +% This code was originally written for loading the rendered images we have, +% not the natural face images from the Chicago database. + +%This script reads the faces' files in the neutralC (neutral faces from the Chicago face database) folder and then loads all +%faces in a single column. + +clear % clear matlab workspace +clc % clear matlab command window + +%% Loading all the neutral Chicago faces. +main_dir = '/Users/kihossei/Documents/GitHub/mfe_c_face/materials/PsychopyTask/mfe_c_face/img'; +faceData_location = [main_dir filesep 'neutralC']; %Location of stored faces (i.e., renders folder) +cd(faceData_location) +data_file_lists = dir; +data_file_lists = data_file_lists(~ismember({data_file_lists.name},{'.', '..', '.DS_Store'})); +data_file_lists = {data_file_lists.name}; +data_file_lists = string(data_file_lists); +allFaces_filename_pattern = '-N'; % The face file that has this pattern in its name will be loaded. +allFaces = contains(data_file_lists, allFaces_filename_pattern, 'IgnoreCase',true); +allFaces = data_file_lists(allFaces); +allFaces = allFaces'; +for lisar1=1:length(allFaces) + allFaces(lisar1) = append('img/neutralC/',allFaces(lisar1)); +end + +%% After creating a list of all faces, randomly sample 384 faces. 384 is the number of trials. We also select additional 20 faces as practice trials. +% Chicago face database (CFD + CFD-MR + CFD-INDIA) has 827 face images in total. +% So, we load 404 faces in total. +faces = randsample(allFaces, 404); +trialFaces_for_surprise = faces; % This stores the list of faces that are going to be shown in practice and main trials. +surpriseFaces = ~contains(allFaces, faces, 'IgnoreCase',true); +surpriseFaces = allFaces(surpriseFaces); % these are the faces in the neutralC folder that are not selected to be shown during practice and main trials. We need +% these as foil faces in the surprise memory task. +% As the surprise task is two-alternative forced choice, so we need to randomly select 384 foil faces. +surpriseFaces = randsample(surpriseFaces, 384); +foilFaces = surpriseFaces; +for abrak1=1:length(foilFaces) % adding a second column that mentions if this is a new face (i.e., foil). For new faces, we have "1" as true. + foilFaces(abrak1,2) = '1'; % new? +end + +%% A loop that creates 12 CSV files for the blocks. +arrowSize = '[.035, .035]'; +first_rightFlanker_location = '[0.0385,0]'; +second_rightFlanker_location = '[-0.0385,0]'; + +rightArrow = 'img/rightArrow.png'; +leftArrow = 'img/leftArrow.png'; +for jaguar=1:13 % 12 of these files will be for the main blocks. The last one with 20 trials will be the practice block. + if jaguar==13 + firstDat = randsample(faces, 20); % this practice block will have 20 trials. + pracFaces_intact = firstDat; % we need this for the 2nd csv file. + % we need to randomly select half of the faces to have right arrow as the target arrow and the + % remaining half will have left arrow as their target. + rightDir_faces = randsample(firstDat, 20/2); % faces with right arrow as target + leftDir_faces = ~contains(firstDat, rightDir_faces, 'IgnoreCase',true); + leftDir_faces = firstDat(leftDir_faces); % contains the remaining faces with left arrow as target + + % Randomly selecting half of the right-directed and left-directed arrows to be congruent and the remaining half be incongruent. + %there is going to be the table that has 6 columns; the 1st column is the target arrow; the 2nd and 3rd are distractor arrows; 4th column is stimNum; 5th column is congrunet?; 6th is the target arrow direction. + % rightDir_faces has 10 face images. + rightCong = randsample(rightDir_faces, 20/4); % 5 of these face images will be right arrow and Congruent. + rightCong_intact = rightCong; % We need this for the next step. + nav_temp1 = rightCong; % stores the list of faces + % Let's create right-directed congruent rows. + for zebra=1:length(rightCong) + rightCong(zebra,1)= rightArrow; + rightCong(zebra,2)= rightArrow; + rightCong(zebra,3)= rightArrow; + rightCong(zebra,4)= 5; % stimNum + rightCong(zebra,5)= 1; %congruent? + rightCong(zebra,6)= 'right'; %target + rightCong(zebra,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightCong(zebra,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + rightCong(zebra,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + + nav_temp = nav_temp1(zebra); % the face that is going to be shown in this trial + rightCong(zebra,10)= nav_temp; % Straight_face: The face image displayed in the background + rightCong(zebra,11)= arrowSize; % Size for the background image + end + rightIncong = ~contains(rightDir_faces, rightCong_intact, 'IgnoreCase',true); % finds the remaining 5 face images that are not used above as right-directed and congruent. + rightIncong = rightDir_faces(rightIncong); % the target arrow will be right and incongruent. + nav_temp2 = rightIncong; + % Let's create right-directed incongruent rows. + for zebra2=1:length(rightIncong) + rightIncong(zebra2,1)= rightArrow; + rightIncong(zebra2,2)= leftArrow; + rightIncong(zebra2,3)= leftArrow; + rightIncong(zebra2,4)= 7; % stimNum + rightIncong(zebra2,5)= 0; % congruent? + rightIncong(zebra2,6)= 'right'; %target + rightIncong(zebra2,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightIncong(zebra2,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + rightIncong(zebra2,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp2(zebra2); % the face that is going to be shown in this trial + rightIncong(zebra2,10)= nav_temp; % Straight_face + rightIncong(zebra2,11)= arrowSize; % Size for the image + end + + leftCong = randsample(leftDir_faces, 20/4); % % 5 of these face images will be left arrow and Congruent. + leftCong_intact = leftCong; % We need this in the next step in order to select remaining 5 face images to be used for leftDir Incong! + nav_temp3 = leftCong; + % Let's create left-directed congruent rows. + for zebra3=1:length(leftCong) + leftCong(zebra3,1)= leftArrow; + leftCong(zebra3,2)= leftArrow; + leftCong(zebra3,3)= leftArrow; + leftCong(zebra3,4)= 6; % stimNum + leftCong(zebra3,5)= 1; % congruent? + leftCong(zebra3,6)= 'left'; %target + leftCong(zebra3,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftCong(zebra3,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + leftCong(zebra3,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp3(zebra3); + leftCong(zebra3,10)= nav_temp; % Straight_face + leftCong(zebra3,11)= arrowSize; % Size for the image + end + leftIncong = ~contains(leftDir_faces, leftCong_intact, 'IgnoreCase',true); + leftIncong = leftDir_faces(leftIncong); % the target faces that will be incongruent. + nav_temp4 = leftIncong; + % Let's create left-directed incongruent rows. + for zebra4=1:length(leftIncong) + leftIncong(zebra4,1)= leftArrow; + leftIncong(zebra4,2)= rightArrow; + leftIncong(zebra4,3)= rightArrow; + leftIncong(zebra4,4)= 8; % stimNum + leftIncong(zebra4,5)= 0; % congruent? + leftIncong(zebra4,6)= 'left'; %target + leftIncong(zebra4,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftIncong(zebra4,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + leftIncong(zebra4,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp4(zebra4); + leftIncong(zebra4,10)= nav_temp; % Straight_face + leftIncong(zebra4,11)= arrowSize; % Size for the image + end + % Creating the main table that contains all we have created above for the 1st CSV file (practice block). + mainTable = table([rightCong(:,1);rightIncong(:,1);leftCong(:,1);leftIncong(:,1)],[rightCong(:,2);rightIncong(:,2);leftCong(:,2);leftIncong(:,2)],[rightCong(:,3);rightIncong(:,3);leftCong(:,3);leftIncong(:,3)],[rightCong(:,4);rightIncong(:,4);leftCong(:,4);leftIncong(:,4)],[rightCong(:,5);rightIncong(:,5);leftCong(:,5);leftIncong(:,5)],[rightCong(:,6);rightIncong(:,6);leftCong(:,6);leftIncong(:,6)],[rightCong(:,7);rightIncong(:,7);leftCong(:,7);leftIncong(:,7)],[rightCong(:,8);rightIncong(:,8);leftCong(:,8);leftIncong(:,8)],[rightCong(:,9);rightIncong(:,9);leftCong(:,9);leftIncong(:,9)],[rightCong(:,10);rightIncong(:,10);leftCong(:,10);leftIncong(:,10)],[rightCong(:,11);rightIncong(:,11);leftCong(:,11);leftIncong(:,11)]); + mainTable = table2array(mainTable); + mainTable = mainTable(randperm(size(mainTable, 1)), : ); % Shuffle the data randomly by rows. + mainTable = array2table(mainTable); + mainTable.Properties.VariableNames = {'middleStim','leftStim','rightStim', 'stimNum','congruent','target','locationC','locationR','locationL', 'straightFace','imageSize'}; + fileName = append("flanker_practice_table",".csv"); + writetable(mainTable, fileName) + % let's update faces for the next round of this loop. So, it will not + % have the 20 faces used in this loop. + facesTemp = ~contains(faces, pracFaces_intact, 'IgnoreCase',true); + faces = faces(facesTemp); + else + % The first 12 csv files will be used for the arrow flanker task. + firstDat = randsample(faces, 32); % each block will have 32 trials. + firstDat_intact = firstDat; % we will use this to remove the faces already picked for this block. So, this will allow avoiding showing + % repeatitive face images in blocks. + % we need to randomly select half of the faces to be right directed and the + % remaining half will be left-directed. + rightDir_faces = randsample(firstDat, 32/2); % right-directed faces + leftDir_faces = ~contains(firstDat, rightDir_faces, 'IgnoreCase',true); + leftDir_faces = firstDat(leftDir_faces); % contains the remaining 192 faces that will be left-directed. + + % Randomly selecting half of the right-directed and left-directed faces to be congruent and the remaining half be incongruent. + %there is going to be the table that has 6 columns; the 1st column is the target; the 2nd and 3rd are distractor faces; 4th column is stimNum; 5th column is congrunet?; 6th is the target. + rightCong = randsample(rightDir_faces, 32/4); % Congruent right_dir faces. + rightCong_intact = rightCong; % We need this for the next step. + nav_temp1 = rightCong; + % Let's create right-directed congruent rows. + for zebra=1:length(rightCong) + rightCong(zebra,1)= rightArrow; + rightCong(zebra,2)= rightArrow; + rightCong(zebra,3)= rightArrow; + rightCong(zebra,4)= 5; % stimNum + rightCong(zebra,5)= 1; %congruent? + rightCong(zebra,6)= 'right'; %target + rightCong(zebra,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightCong(zebra,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + rightCong(zebra,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + % in the lines below, I am creating a column consisting the + % straight looking faces for the background. + nav_temp = nav_temp1(zebra); + rightCong(zebra,10)= nav_temp; % Straight_face + rightCong(zebra,11)= arrowSize; % Size for the image + + end + rightIncong = ~contains(rightDir_faces, rightCong_intact, 'IgnoreCase',true); + rightIncong = rightDir_faces(rightIncong); % Incongruent right_dir faces. + nav_temp2 = rightIncong; + % Let's create right-directed incongruent rows. + for zebra2=1:length(rightIncong) + rightIncong(zebra2,1)= rightArrow; + rightIncong(zebra2,2)= leftArrow; + rightIncong(zebra2,3)= leftArrow; + rightIncong(zebra2,4)= 7; % stimNum + rightIncong(zebra2,5)= 0; % congruent? + rightIncong(zebra2,6)= 'right'; %target + rightIncong(zebra2,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightIncong(zebra2,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + rightIncong(zebra2,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp2(zebra2); + rightIncong(zebra2,10)= nav_temp; % Straight_face + rightIncong(zebra2,11)= arrowSize; % Size for the image + end + + leftCong = randsample(leftDir_faces, 32/4); % Congruent left_dir faces. + leftCong_intact = leftCong; % We need this for the next step. + nav_temp3 = leftCong; + % Let's create left-directed congruent rows. + for zebra3=1:length(leftCong) + leftCong(zebra3,1)= leftArrow; + leftCong(zebra3,2)= leftArrow; + leftCong(zebra3,3)= leftArrow; + leftCong(zebra3,4)= 6; % stimNum + leftCong(zebra3,5)= 1; % congruent? + leftCong(zebra3,6)= 'left'; %target + leftCong(zebra3,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftCong(zebra3,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + leftCong(zebra3,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp3(zebra3); + leftCong(zebra3,10)= nav_temp; % Straight_face + leftCong(zebra3,11)= arrowSize; % Size for the image + end + leftIncong = ~contains(leftDir_faces, leftCong_intact, 'IgnoreCase',true); + leftIncong = leftDir_faces(leftIncong); % Incongruent left_dir faces. + nav_temp4 = leftIncong; + % Let's create left-directed incongruent rows. + for zebra4=1:length(leftIncong) + leftIncong(zebra4,1)= leftArrow; + leftIncong(zebra4,2)= rightArrow; + leftIncong(zebra4,3)= rightArrow; + leftIncong(zebra4,4)= 8; % stimNum + leftIncong(zebra4,5)= 0; % congruent? + leftIncong(zebra4,6)= 'left'; %target + leftIncong(zebra4,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftIncong(zebra4,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + leftIncong(zebra4,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp4(zebra4); + leftIncong(zebra4,10)= nav_temp; % Straight_face + leftIncong(zebra4,11)= arrowSize; % Size for the image + end + % Creating the main table that contains all we have created above for the 1st CSV file. + mainTable = table([rightCong(:,1);rightIncong(:,1);leftCong(:,1);leftIncong(:,1)],[rightCong(:,2);rightIncong(:,2);leftCong(:,2);leftIncong(:,2)],[rightCong(:,3);rightIncong(:,3);leftCong(:,3);leftIncong(:,3)],[rightCong(:,4);rightIncong(:,4);leftCong(:,4);leftIncong(:,4)],[rightCong(:,5);rightIncong(:,5);leftCong(:,5);leftIncong(:,5)],[rightCong(:,6);rightIncong(:,6);leftCong(:,6);leftIncong(:,6)],[rightCong(:,7);rightIncong(:,7);leftCong(:,7);leftIncong(:,7)],[rightCong(:,8);rightIncong(:,8);leftCong(:,8);leftIncong(:,8)],[rightCong(:,9);rightIncong(:,9);leftCong(:,9);leftIncong(:,9)],[rightCong(:,10);rightIncong(:,10);leftCong(:,10);leftIncong(:,10)],[rightCong(:,11);rightIncong(:,11);leftCong(:,11);leftIncong(:,11)]); + mainTable = table2array(mainTable); + mainTable = mainTable(randperm(size(mainTable, 1)), : ); % Shuffle the data randomly by rows. + mainTable = array2table(mainTable); + mainTable.Properties.VariableNames = {'middleStim','leftStim','rightStim', 'stimNum','congruent','target','locationC','locationR','locationL', 'straightFace','imageSize'}; + fileName = append("flanker_main_table_",string(jaguar),".csv"); + writetable(mainTable, fileName) + % let's update faces for the next round of this loop. So, it will not + % have the 32 faces used in this loop. + facesTemp = ~contains(faces, firstDat_intact, 'IgnoreCase',true); + faces = faces(facesTemp); + end +end +% "trialFaces_for_surprise" includes all the faces shown in the practice and +% 12 main blocks of the flanker task. +includeFaces_for_surprise = ~contains(trialFaces_for_surprise, pracFaces_intact, 'IgnoreCase',true); % Exclude the trials shown in the practice block. +flanker_faces_to_be_in_surprise = trialFaces_for_surprise(includeFaces_for_surprise); % will include the list of faces that are shown in the main 12 blocks. + +for abrak2=1:length(flanker_faces_to_be_in_surprise) % adding a second column that mentions if this is a new face (i.e., foil). For old faces, we have "0" as true. + flanker_faces_to_be_in_surprise(abrak2,2) = '0'; % new? +end + + + +% create a column that has the same rows as the number of total trials in +% the flanker task. Then, create a column vector that has right and left. +% Finally, repea +old_face_displayed_side = ["right" ;"left"]; +old_face_displayed_side = repmat(old_face_displayed_side, 384/2, 1); +old_face_displayed_side = old_face_displayed_side(randperm(size(old_face_displayed_side, 1)), : ); % Shuffle the data randomly by rows. + +% Create a new table with following columns: + % First Column: old_face_in_surp + % Second Column: new_face_in_surp + % Third column: which_side_old_face_displayed +surpriseTable = table(flanker_faces_to_be_in_surprise(:,1),foilFaces(:,1), old_face_displayed_side(:,1)); +surpriseTable = table2array(surpriseTable); +surpriseTable = surpriseTable(randperm(size(surpriseTable, 1)), : ); % Shuffle the data randomly by rows. +surpriseTable = array2table(surpriseTable); +surpriseTable.Properties.VariableNames = {'old_face_in_surp', 'new_face_in_surp', 'which_side_old_face_displayed'}; + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +nRows_surpList = height(surpriseTable); +% We want to have 8 blocks of trials in the surprise task. So, we need to +% create 8 csv files as mentioned above. + +surp_table1 = surpriseTable(1:(nRows_surpList/8),:); +writetable(surp_table1, "surp_table1.csv") + +surp_table2 = surpriseTable((nRows_surpList/8)+1:2*(nRows_surpList/8),:); +writetable(surp_table2, "surp_table2.csv") + +surp_table3 = surpriseTable((2*(nRows_surpList/8))+1:3*(nRows_surpList/8),:); +writetable(surp_table3, "surp_table3.csv") + +surp_table4 = surpriseTable((3*(nRows_surpList/8))+1:4*(nRows_surpList/8),:); +writetable(surp_table4, "surp_table4.csv") + +surp_table5 = surpriseTable((4*(nRows_surpList/8))+1:5*(nRows_surpList/8),:); +writetable(surp_table5, "surp_table5.csv") + +surp_table6 = surpriseTable((5*(nRows_surpList/8))+1:6*(nRows_surpList/8),:); +writetable(surp_table6, "surp_table6.csv") + +surp_table7 = surpriseTable((6*(nRows_surpList/8))+1:7*(nRows_surpList/8),:); +writetable(surp_table7, "surp_table7.csv") + +surp_table8 = surpriseTable((7*(nRows_surpList/8))+1:8*(nRows_surpList/8),:); +writetable(surp_table8, "surp_table8.csv") + + + + + diff --git a/materials/mfe_e/img/halfV_trial_csv_creator.m b/materials/mfe_e/img/halfV_trial_csv_creator.m new file mode 100644 index 0000000..d1b3611 --- /dev/null +++ b/materials/mfe_e/img/halfV_trial_csv_creator.m @@ -0,0 +1,318 @@ +%% This script is written by Kianoosh Hosseini at NDClab (See https://Kianoosh.info and https://ndclab.com) in May 2022 and updated in september 2023. +%%% For Chicago faces ... +% This code was originally written for loading the rendered images we have, +% not the natural face images from the Chicago database. + +%This script reads the faces' files in the neutralC (neutral faces from the Chicago face database) folder and then loads all +%faces in a single column. + +clear % clear matlab workspace +clc % clear matlab command window + +%% Loading all the neutral Chicago faces. +main_dir = '/Users/kihossei/Documents/GitHub/mfe_c_face/materials/PsychopyTask/mfe_c_face/img'; +output_dir = '/Users/kihossei/Documents/GitHub/mfe_c_face/materials/PsychopyTask/mfe_c_face'; +faceData_location = [main_dir filesep 'neutralC']; %Location of stored faces (i.e., renders folder) +cd(faceData_location) +data_file_lists = dir; +data_file_lists = data_file_lists(~ismember({data_file_lists.name},{'.', '..', '.DS_Store'})); +data_file_lists = {data_file_lists.name}; +data_file_lists = string(data_file_lists); +allFaces_filename_pattern = '-N'; % The face file that has this pattern in its name will be loaded. +allFaces = contains(data_file_lists, allFaces_filename_pattern, 'IgnoreCase',true); +allFaces = data_file_lists(allFaces); +allFaces = allFaces'; +for lisar1=1:length(allFaces) + allFaces(lisar1) = append('img/neutralC/',allFaces(lisar1)); +end + +%% After creating a list of all faces, randomly sample 384 faces. 384 is the number of trials. We also select additional 20 faces as practice trials. +% Chicago face database (CFD + CFD-MR + CFD-INDIA) has 827 face images in total. +% So, we load 404 faces in total. +faces = randsample(allFaces, 404); +trialFaces_for_surprise = faces; % This stores the list of faces that are going to be shown in practice and main trials. +surpriseFaces = ~contains(allFaces, faces, 'IgnoreCase',true); +surpriseFaces = allFaces(surpriseFaces); % these are the faces in the neutralC folder that are not selected to be shown during practice and main trials. We need +% these as foil faces in the surprise memory task. +% As the surprise task is two-alternative forced choice, so we need to randomly select 384 foil faces. +surpriseFaces = randsample(surpriseFaces, 384); +foilFaces = surpriseFaces; +for abrak1=1:length(foilFaces) % adding a second column that mentions if this is a new face (i.e., foil). For new faces, we have "1" as true. + foilFaces(abrak1,2) = '1'; % new? +end + +cd(output_dir) % change directory to save outputs in the output directory +%% A loop that creates 12 CSV files for the blocks. +arrowSize = '[.035, .035]'; +first_rightFlanker_location = '[0.0385,0]'; +second_rightFlanker_location = '[-0.0385,0]'; + +rightArrow = 'img/rightArrow.png'; +leftArrow = 'img/leftArrow.png'; +for jaguar=1:13 % 12 of these files will be for the main blocks. The last one with 20 trials will be the practice block. + if jaguar==13 + firstDat = randsample(faces, 20); % this practice block will have 20 trials. + pracFaces_intact = firstDat; % we need this for the 2nd csv file. + % we need to randomly select half of the faces to have right arrow as the target arrow and the + % remaining half will have left arrow as their target. + rightDir_faces = randsample(firstDat, 20/2); % faces with right arrow as target + leftDir_faces = ~contains(firstDat, rightDir_faces, 'IgnoreCase',true); + leftDir_faces = firstDat(leftDir_faces); % contains the remaining faces with left arrow as target + + % Randomly selecting half of the right-directed and left-directed arrows to be congruent and the remaining half be incongruent. + %there is going to be the table that has 6 columns; the 1st column is the target arrow; the 2nd and 3rd are distractor arrows; 4th column is stimNum; 5th column is congrunet?; 6th is the target arrow direction. + % rightDir_faces has 10 face images. + rightCong = randsample(rightDir_faces, 20/4); % 5 of these face images will be right arrow and Congruent. + rightCong_intact = rightCong; % We need this for the next step. + nav_temp1 = rightCong; % stores the list of faces + % Let's create right-directed congruent rows. + for zebra=1:length(rightCong) + rightCong(zebra,1)= rightArrow; + rightCong(zebra,2)= rightArrow; + rightCong(zebra,3)= rightArrow; + rightCong(zebra,4)= 5; % stimNum + rightCong(zebra,5)= 1; %congruent? + rightCong(zebra,6)= 'right'; %target + rightCong(zebra,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightCong(zebra,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + rightCong(zebra,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + + nav_temp = nav_temp1(zebra); % the face that is going to be shown in this trial + rightCong(zebra,10)= nav_temp; % Straight_face: The face image displayed in the background + rightCong(zebra,11)= arrowSize; % Size for the background image + end + rightIncong = ~contains(rightDir_faces, rightCong_intact, 'IgnoreCase',true); % finds the remaining 5 face images that are not used above as right-directed and congruent. + rightIncong = rightDir_faces(rightIncong); % the target arrow will be right and incongruent. + nav_temp2 = rightIncong; + % Let's create right-directed incongruent rows. + for zebra2=1:length(rightIncong) + rightIncong(zebra2,1)= rightArrow; + rightIncong(zebra2,2)= leftArrow; + rightIncong(zebra2,3)= leftArrow; + rightIncong(zebra2,4)= 7; % stimNum + rightIncong(zebra2,5)= 0; % congruent? + rightIncong(zebra2,6)= 'right'; %target + rightIncong(zebra2,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightIncong(zebra2,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + rightIncong(zebra2,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp2(zebra2); % the face that is going to be shown in this trial + rightIncong(zebra2,10)= nav_temp; % Straight_face + rightIncong(zebra2,11)= arrowSize; % Size for the image + end + + leftCong = randsample(leftDir_faces, 20/4); % % 5 of these face images will be left arrow and Congruent. + leftCong_intact = leftCong; % We need this in the next step in order to select remaining 5 face images to be used for leftDir Incong! + nav_temp3 = leftCong; + % Let's create left-directed congruent rows. + for zebra3=1:length(leftCong) + leftCong(zebra3,1)= leftArrow; + leftCong(zebra3,2)= leftArrow; + leftCong(zebra3,3)= leftArrow; + leftCong(zebra3,4)= 6; % stimNum + leftCong(zebra3,5)= 1; % congruent? + leftCong(zebra3,6)= 'left'; %target + leftCong(zebra3,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftCong(zebra3,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + leftCong(zebra3,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp3(zebra3); + leftCong(zebra3,10)= nav_temp; % Straight_face + leftCong(zebra3,11)= arrowSize; % Size for the image + end + leftIncong = ~contains(leftDir_faces, leftCong_intact, 'IgnoreCase',true); + leftIncong = leftDir_faces(leftIncong); % the target faces that will be incongruent. + nav_temp4 = leftIncong; + % Let's create left-directed incongruent rows. + for zebra4=1:length(leftIncong) + leftIncong(zebra4,1)= leftArrow; + leftIncong(zebra4,2)= rightArrow; + leftIncong(zebra4,3)= rightArrow; + leftIncong(zebra4,4)= 8; % stimNum + leftIncong(zebra4,5)= 0; % congruent? + leftIncong(zebra4,6)= 'left'; %target + leftIncong(zebra4,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftIncong(zebra4,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + leftIncong(zebra4,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp4(zebra4); + leftIncong(zebra4,10)= nav_temp; % Straight_face + leftIncong(zebra4,11)= arrowSize; % Size for the image + end + % Creating the main table that contains all we have created above for the 1st CSV file (practice block). + mainTable = table([rightCong(:,1);rightIncong(:,1);leftCong(:,1);leftIncong(:,1)],[rightCong(:,2);rightIncong(:,2);leftCong(:,2);leftIncong(:,2)],[rightCong(:,3);rightIncong(:,3);leftCong(:,3);leftIncong(:,3)],[rightCong(:,4);rightIncong(:,4);leftCong(:,4);leftIncong(:,4)],[rightCong(:,5);rightIncong(:,5);leftCong(:,5);leftIncong(:,5)],[rightCong(:,6);rightIncong(:,6);leftCong(:,6);leftIncong(:,6)],[rightCong(:,7);rightIncong(:,7);leftCong(:,7);leftIncong(:,7)],[rightCong(:,8);rightIncong(:,8);leftCong(:,8);leftIncong(:,8)],[rightCong(:,9);rightIncong(:,9);leftCong(:,9);leftIncong(:,9)],[rightCong(:,10);rightIncong(:,10);leftCong(:,10);leftIncong(:,10)],[rightCong(:,11);rightIncong(:,11);leftCong(:,11);leftIncong(:,11)]); + mainTable = table2array(mainTable); + mainTable = mainTable(randperm(size(mainTable, 1)), : ); % Shuffle the data randomly by rows. + mainTable = array2table(mainTable); + mainTable.Properties.VariableNames = {'middleStim','leftStim','rightStim', 'stimNum','congruent','target','locationC','locationR','locationL', 'straightFace','imageSize'}; + fileName = append("flanker_practice_block",".csv"); + writetable(mainTable, fileName) + % let's update faces for the next round of this loop. So, it will not + % have the 20 faces used in this loop. + facesTemp = ~contains(faces, pracFaces_intact, 'IgnoreCase',true); + faces = faces(facesTemp); + else + % The first 12 csv files will be used for the arrow flanker task. + firstDat = randsample(faces, 32); % each block will have 32 trials. + firstDat_intact = firstDat; % we will use this to remove the faces already picked for this block. So, this will allow avoiding showing + % repeatitive face images in blocks. + % we need to randomly select half of the faces to be right directed and the + % remaining half will be left-directed. + rightDir_faces = randsample(firstDat, 32/2); % right-directed faces + leftDir_faces = ~contains(firstDat, rightDir_faces, 'IgnoreCase',true); + leftDir_faces = firstDat(leftDir_faces); % contains the remaining 192 faces that will be left-directed. + + % Randomly selecting half of the right-directed and left-directed faces to be congruent and the remaining half be incongruent. + %there is going to be the table that has 6 columns; the 1st column is the target; the 2nd and 3rd are distractor faces; 4th column is stimNum; 5th column is congrunet?; 6th is the target. + rightCong = randsample(rightDir_faces, 32/4); % Congruent right_dir faces. + rightCong_intact = rightCong; % We need this for the next step. + nav_temp1 = rightCong; + % Let's create right-directed congruent rows. + for zebra=1:length(rightCong) + rightCong(zebra,1)= rightArrow; + rightCong(zebra,2)= rightArrow; + rightCong(zebra,3)= rightArrow; + rightCong(zebra,4)= 5; % stimNum + rightCong(zebra,5)= 1; %congruent? + rightCong(zebra,6)= 'right'; %target + rightCong(zebra,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightCong(zebra,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + rightCong(zebra,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + % in the lines below, I am creating a column consisting the + % straight looking faces for the background. + nav_temp = nav_temp1(zebra); + rightCong(zebra,10)= nav_temp; % Straight_face + rightCong(zebra,11)= arrowSize; % Size for the image + + end + rightIncong = ~contains(rightDir_faces, rightCong_intact, 'IgnoreCase',true); + rightIncong = rightDir_faces(rightIncong); % Incongruent right_dir faces. + nav_temp2 = rightIncong; + % Let's create right-directed incongruent rows. + for zebra2=1:length(rightIncong) + rightIncong(zebra2,1)= rightArrow; + rightIncong(zebra2,2)= leftArrow; + rightIncong(zebra2,3)= leftArrow; + rightIncong(zebra2,4)= 7; % stimNum + rightIncong(zebra2,5)= 0; % congruent? + rightIncong(zebra2,6)= 'right'; %target + rightIncong(zebra2,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightIncong(zebra2,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + rightIncong(zebra2,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp2(zebra2); + rightIncong(zebra2,10)= nav_temp; % Straight_face + rightIncong(zebra2,11)= arrowSize; % Size for the image + end + + leftCong = randsample(leftDir_faces, 32/4); % Congruent left_dir faces. + leftCong_intact = leftCong; % We need this for the next step. + nav_temp3 = leftCong; + % Let's create left-directed congruent rows. + for zebra3=1:length(leftCong) + leftCong(zebra3,1)= leftArrow; + leftCong(zebra3,2)= leftArrow; + leftCong(zebra3,3)= leftArrow; + leftCong(zebra3,4)= 6; % stimNum + leftCong(zebra3,5)= 1; % congruent? + leftCong(zebra3,6)= 'left'; %target + leftCong(zebra3,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftCong(zebra3,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + leftCong(zebra3,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp3(zebra3); + leftCong(zebra3,10)= nav_temp; % Straight_face + leftCong(zebra3,11)= arrowSize; % Size for the image + end + leftIncong = ~contains(leftDir_faces, leftCong_intact, 'IgnoreCase',true); + leftIncong = leftDir_faces(leftIncong); % Incongruent left_dir faces. + nav_temp4 = leftIncong; + % Let's create left-directed incongruent rows. + for zebra4=1:length(leftIncong) + leftIncong(zebra4,1)= leftArrow; + leftIncong(zebra4,2)= rightArrow; + leftIncong(zebra4,3)= rightArrow; + leftIncong(zebra4,4)= 8; % stimNum + leftIncong(zebra4,5)= 0; % congruent? + leftIncong(zebra4,6)= 'left'; %target + leftIncong(zebra4,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftIncong(zebra4,8)= first_rightFlanker_location; % Right image Location on the screen for the Psychopy + leftIncong(zebra4,9)= second_rightFlanker_location; % Left image Location on the screen for the Psychopy + nav_temp = nav_temp4(zebra4); + leftIncong(zebra4,10)= nav_temp; % Straight_face + leftIncong(zebra4,11)= arrowSize; % Size for the image + end + % Creating the main table that contains all we have created above for the 1st CSV file. + mainTable = table([rightCong(:,1);rightIncong(:,1);leftCong(:,1);leftIncong(:,1)],[rightCong(:,2);rightIncong(:,2);leftCong(:,2);leftIncong(:,2)],[rightCong(:,3);rightIncong(:,3);leftCong(:,3);leftIncong(:,3)],[rightCong(:,4);rightIncong(:,4);leftCong(:,4);leftIncong(:,4)],[rightCong(:,5);rightIncong(:,5);leftCong(:,5);leftIncong(:,5)],[rightCong(:,6);rightIncong(:,6);leftCong(:,6);leftIncong(:,6)],[rightCong(:,7);rightIncong(:,7);leftCong(:,7);leftIncong(:,7)],[rightCong(:,8);rightIncong(:,8);leftCong(:,8);leftIncong(:,8)],[rightCong(:,9);rightIncong(:,9);leftCong(:,9);leftIncong(:,9)],[rightCong(:,10);rightIncong(:,10);leftCong(:,10);leftIncong(:,10)],[rightCong(:,11);rightIncong(:,11);leftCong(:,11);leftIncong(:,11)]); + mainTable = table2array(mainTable); + mainTable = mainTable(randperm(size(mainTable, 1)), : ); % Shuffle the data randomly by rows. + mainTable = array2table(mainTable); + mainTable.Properties.VariableNames = {'middleStim','leftStim','rightStim', 'stimNum','congruent','target','locationC','locationR','locationL', 'straightFace','imageSize'}; + fileName = append("flanker_main_block_",string(jaguar),".csv"); + writetable(mainTable, fileName) + % let's update faces for the next round of this loop. So, it will not + % have the 32 faces used in this loop. + facesTemp = ~contains(faces, firstDat_intact, 'IgnoreCase',true); + faces = faces(facesTemp); + end +end +% "trialFaces_for_surprise" includes all the faces shown in the practice and +% 12 main blocks of the flanker task. +includeFaces_for_surprise = ~contains(trialFaces_for_surprise, pracFaces_intact, 'IgnoreCase',true); % Exclude the trials shown in the practice block. +flanker_faces_to_be_in_surprise = trialFaces_for_surprise(includeFaces_for_surprise); % will include the list of faces that are shown in the main 12 blocks. + +for abrak2=1:length(flanker_faces_to_be_in_surprise) % adding a second column that mentions if this is a new face (i.e., foil). For old faces, we have "0" as true. + flanker_faces_to_be_in_surprise(abrak2,2) = '0'; % new? +end + + + +% create a column that has the same rows as the number of total trials in +% the flanker task. Then, create a column vector that has right and left. +% Finally, repeat that vector 384/2 in order to have a column that has 384 +% rows. Half of them will be right and the other half will be left. After +% all, shuffle them randomly by rows. +old_face_displayed_side = ["right" ;"left"]; +old_face_displayed_side = repmat(old_face_displayed_side, 384/2, 1); +old_face_displayed_side = old_face_displayed_side(randperm(size(old_face_displayed_side, 1)), : ); % Shuffle the data randomly by rows. + +% Create a new table with following columns: + % First Column: old_face_in_surp (will have all the faces shown in the + % flanker task) + % Second Column: new_face_in_surp (will have all the new (foil) faces) + % Third column: which_side_old_face_displayed +surpriseTable = table(flanker_faces_to_be_in_surprise(:,1),foilFaces(:,1), old_face_displayed_side(:,1)); +surpriseTable = table2array(surpriseTable); +surpriseTable = surpriseTable(randperm(size(surpriseTable, 1)), : ); % Shuffle the data randomly by rows. +surpriseTable = array2table(surpriseTable); +surpriseTable.Properties.VariableNames = {'old_face_in_surp', 'new_face_in_surp', 'which_side_old_face_displayed'}; + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +nRows_surpList = height(surpriseTable); +% We want to have 8 blocks of trials in the surprise task. So, we need to +% create 8 csv files as mentioned above. + +surp_table1 = surpriseTable(1:(nRows_surpList/8),:); +writetable(surp_table1, "orig_surp_table1.csv") + +surp_table2 = surpriseTable((nRows_surpList/8)+1:2*(nRows_surpList/8),:); +writetable(surp_table2, "orig_surp_table2.csv") + +surp_table3 = surpriseTable((2*(nRows_surpList/8))+1:3*(nRows_surpList/8),:); +writetable(surp_table3, "orig_surp_table3.csv") + +surp_table4 = surpriseTable((3*(nRows_surpList/8))+1:4*(nRows_surpList/8),:); +writetable(surp_table4, "orig_surp_table4.csv") + +surp_table5 = surpriseTable((4*(nRows_surpList/8))+1:5*(nRows_surpList/8),:); +writetable(surp_table5, "orig_surp_table5.csv") + +surp_table6 = surpriseTable((5*(nRows_surpList/8))+1:6*(nRows_surpList/8),:); +writetable(surp_table6, "orig_surp_table6.csv") + +surp_table7 = surpriseTable((6*(nRows_surpList/8))+1:7*(nRows_surpList/8),:); +writetable(surp_table7, "orig_surp_table7.csv") + +surp_table8 = surpriseTable((7*(nRows_surpList/8))+1:8*(nRows_surpList/8),:); +writetable(surp_table8, "orig_surp_table8.csv") + + + + + diff --git a/materials/mfe_e/img/leftArrow.png b/materials/mfe_e/img/leftArrow.png new file mode 100644 index 0000000000000000000000000000000000000000..5a403355a1103ba2f2029c3055eed0f2ef811c5d GIT binary patch literal 26785 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 W-@`SaPvc79AIDl}{rIFIv=Ff-BTWEWy*VPWAk z*si;ag@s&C{6!_>->4|p*Whm?uU-1uEO%=~`td*f4_O)()DT@Aa3(lEtW@+>BojYtAp< zb@b@bYuA2uYPDS7yzz@h-Iou3C%e23*J_OO&u(QQQMhUU|Nr~{_zVip(_AYkyE615 z+uGV}9v=OD(@%Zdzgt+zL76P62=DY6c-Q~!{e!-jkvV4RA@=07-T!XNvz!sW^3-IX z>FoQmK)Die#*EafuhsVXqs{UJgB$B4hT4h=zuO+%ANKHveNlmRyb+n#?SQm?{ znTb`0^zHw244d-nI+5+&-^e8;CjH+ZE~Z~#t;%4FzG)b*a-?m&7(=V>oxjbQ37&Za zW2_-puT>K@7tJ8Nw^p^jpA_x3`A>neF)`ZBitcOZ1SK6_O7m8usPmUa90MF#!;v59_`|KFW5 z;>e=%#KOP6cV6FcXh-v%y_$m3?&AMWE00yf&QrtM>3zlN(+`h!Zg70%;I=YEf9^6E z`^hGO^@RssoPXd{H}n1R@XYVJ(*g>1ANFT#Q=dN)v6#iA;kTX|i39cFin)0&-{9POL_`>QTix~5P6_r$se!#QkB0nJUQ|6-R<3* zuO)n#f7gOoI?qOtV+VJP;lAN_nB$~U( z@ODai^Fq09g?N5RK;6}o-98-Tkg9gaOU@yp#j4W^G9ZB zL>G+mUnnIeM*ExL(OEh^(ox%NLdh-Z~k7RNu} zbs+or;(t%!6-Z-lZ~L4rnbN@pB=w^lZL4q3|0-cE?dhd&qpcg|;gO9$kaIc(<3)@Hl?I$?_=E?!JpzhC?2jw@3loSl+$Udmj7tqhmQJlH#QQB+j4+@rg^ z^RXWsWRskn+%-;5_4yON3X3Rc8QGI(?K3m=yIpQN|MavQ-ac=sNW=U)G4HalhCe>u z^<Bl+`PO$KE>M)Bp06iJMs4N zs<^-*&!zKEJGBh=`IlR21?}2~Lo%i*xsi?Cfy0_7P5zK;{{_4QI3oe!n9xc#F0NC3 zk*Z1^_Yj+KoNhCcJzkqa=Hqn{WitM1(aXv!&h3RRKl`&&Q#4NeXtuC#?i9Ui`)t#{ zO<7=56*J#|*}>N?N$R_1j5TEF$FH?%nGP%Aoj>eh9JYUV+jULK!iD8OUatw~TG3wY zZu56ys3Orlp%3)be$>ky|Ti z-#ogO|tI4$3lZF+j*z0-;-!qs!XXtTn8YBS<#-w@HhH|MlQt=K#<+})j_zoaZx zC7AEG(EOfOvcUkT?FyZHaxIVHsPV9&hu!P!o|M=h_%EYL;bBv$Td&Gn&HRY35P``y z+}Jig*lG%s{pls6Gq>#vSjh4S?TJ9tz(uYV>PJ45?7ULN2ww2u@Y{i+yUxq!9v57K z6F;_1WcDGfHfluv8ud1dreclk=|@%#R&qo~u(__N69% z_{@?m=U};N#}0gYePu=5vWU4;ved;XNi5hOvA%F)fTd*{9NKTVs}l(_EltcYbQ|~F zo+e;P1+&Wo#Lplg)LvIL6}~w;#*nYvLbg+lQjY9GI#P_B0TQ04 zh##IKiouOH4NVi341{kEPBh{-8or^?^9Cm+j+jW{4)3E<7A+biwO58O8QkA4W1Q$b zBU#Hf6*0FEa_dw_uK{2AF#}r1S!`zFV|849*+k;^3D15ZlewU^elO18-KAe$^h$*J*X3x%?=T?nUB zybF`(uEo+Ezq_wtOb0>8!YpQbNey(eMI$x@Y(`a=B(Ug>YC+=6qEd;l-nJR`)aYJF*n#mZ>4^|LFFM?A!ffT{Cte4Rt+v&`~kLy&<-F-RY=tz;;wDhVN75Db?lYenaPC!qvHBNT+9Y1(Y z=HgpH34-a1MX$b&+%eBn_xoN1&3#$De>5{HF{o;`c$_2ueIF0uSrhq(vq zWJl#5{JDBx=@@cN(at}Bz?Q{Ftg1d69KfdOgnuL{r@VCJ6A_u}=$@IVPuIyY&vR|b zz4lq_qCv7Qaj7=!BU(+xA}S%Lr0Ve?Wa}h^+SZC0pW38ND^J!fnmcJj;-p>Gs4tC! zwa>D13afkr3_n;Ewbs7;$@M%>LE;?gt$5xOJ;TZ^%czSNi>P@rgBL6+|1*$-(3EKy zU;9P8UYz(HZ3-7V`gkNSkCiZ4=LQLwY<$I(G-0x}XPLyVoRG2A4vJJuhz5UnE`#GFCxdW$U(Kyy88w@n`>uZC~1^MovpT^G4x4KLRvuR%i5dPL% z<40e6R9F9IU%J}px{9%||C67!o27SLUccIJ&OoM!u>MP2j3t%bu{!os^y#TS*zDDH z``XjCp4oGI*YCnWbsZRz(NY+a&&Rj5Ha>cfeTM+%J$s)=SlFGAc5BH!92i3&8m15K zB%iM-_zGdNDgk58Wih@VUtL1tzJL7I^Dx|P8?m95O8t=(p8Dj>d>ju_ma0eBhb-gk zN-mB5S^KQ#>d#37dPtuv+e`#ww`p^pjo(}7*9c=LW9b7Ad|LTZ|iKQVF2PAxYbxE?Prw4H0hd%!p5h2@5vC^r7 zde6EZ`9!Y&%#V<`^wENvAte5NiMa8m>SYh?}_s`|fYN`P1leA%RN% zWq18=EdsZ8X1siMmZRuk|8{3U;nrrm{ z9>+!{4k!!nb*;~&rCgwXfjr<^cd>hiYIji6W53~xf*b#+lm8H=Hnkdiwm7A(YMKUT z+nsIFtk*wW{`V*X?VAN+2VvEFaD?^2vhK5UHoN5XWF=v<06y3mVY8~D0YtU-1Q@=@ zeSf>Y*j7@r;6Jb*!6&;AV1KPmF~#%~-s``JB-XQ8JI(Um0Rrx;UzoAEp0!y*HkOEL zr;zqWIk;wMjA(LyQ+BIHxE)7!e5K20N#jJNQ;Wmy5*}NJknZ0S*TOwQry~hI~1PcdfPnDn(Q>HOl)NdEGY0I z-%g=52($B;|E^}>gtKfkz`?;)+eJu}BY3I(gFTY|XDD~}+`dt^!{^}biM4BYWuDu5 zEp9cUr?yy;{r&p4$J+Zg!8K3yC!6pT`#1JIuwvur9ZVB;qS8y`sn1$Hc@KUE84f zCw2)UOesAjbA{r8=P;MMwvT%M>`fwk%6~88IBQkqkuzt`=;-KFR#vXDxcjYn%0+~f z&HnuP^IM8M;?2rGx{f+a)0-UQ}}UK=3=JF+2<&<5o>1msJ62F>rU`$)h#h9=2I zKxE18=FKwdzTa-W&M-+<|1Mp(m%4nN=k%X(csKA{Klp^O-7#BmIyQ`#tW}bUz;a&= ztjk(g8(x)5JCFLGBuqA8gHUby}9+tAq!LS&>cT)I?>H#C5_DE?u8x z?7F$5T7rp(`^$0j@F)gNdX`CiZ!dC7Ai`|QQcshoqpvQ&qi&I;)7OygPfr)Aj95PLzjt)p^HWeQ5mrUnm;X`djFmRz z64fZtj}}GF_>zs4s+XQSe_m*_Z?4LSn$N(VO=Z^92T*%-i9UWqp)}@ za_YXGm^68bsD@>!_w5#|EwfWzDkIw?q*^5$Lg)?P%t+=>0oFGAeb0TXA$qbJIK*=& zv+dr&$}r9*V^P(kA3R5SO%N`dfI3cz9&_JwXIbNbRXZ@u%+%Uc7>RN)subxYrvZgg1|_GtX@U&cK0R+2~|q zk>8_1;hr>b0D;-g&@nCgfOMTbJSj`2E|)^-@#HDj;>C;E*cw8^?Res!tl18{A(2vUOEAi|>nkYWn z>3WBBLee1#FL^#pV|SKOfR>@ZzdtIHUGKP;NjhXQo}O7$RJ#H81v*xcjn+7~i=Jyw z@7hd6vicV~8l9&mNF!DK9_6A^oty7mk4Mn9< zS=f4apO^Oysc^a#QnsDQFmmvqL3@3DJuqV6J>f(>Mg+N`p`j_uSXk?nhOocdG5_jn zT>_Iumwq3pck5B=*$G-B-%oE5Rn5c!jIFhk)uZEwjvUGDiJ zt8g>`=ij>)0on{6@|U{Q)`Nw}#eni5lDraZl#2wm8jo>$ld$uGJh0g{r<75j?y+$C zTUMoNML>UJ|8Gb$pKo(-A-{xaOuD}se0Mv;=PKZ^^RHbMtXr$7ZMz+YyUN-b2T|Mu zN2LgIE6@M-#4E3luhQQ~6%-WozPRvr6Mv~b<0yIO&YjpZffG@54+(4@oj+sgFx%mD zca%Od8e`o7T6xk3B&d`l5^2Vp0SU5vu7b;Q*|_Aou5ki&xh#@rp16Wp8e>iV6C%o^ z^srvD;l@_R4>GJycuUYEkiEx;lKsCO*tki3u%ukIk0_}6+wNt^XxRDpu&#NjZ$!1U zWPW~o9Y)izP!!&E-!maJjD8H)a#i#P;_PCCg}`6mtsWdM@=l|K)5j?-clYJ^Tt#{D z^;2QXg{X7f>j^};P$vZ;R#Y><`Pms+7x(qnq0WlIuU;XZ>6@f(nTBNxa722}dy7fm z^tT6fu7m6IiZe}9yG)Mpts&0{oQsIKrtEeVudb0-aWMTfWifzyK{o@jH4mvOAfXt5 zXyQW3Ii8Um1_&8YcE#TPyRL|x;tZ|jncKumox2Yk1}Hy;C9K{XZ%?dlRKN8_!;@dUNK;P_7dRwUeyP1E+2l-@8zyLl&W-EKY#9h+i7F=uNqAhZAx3EM& zY%u~z?VFff?vW_EioShWKv9cTOP)=(aZ_0nTb_i&4g9=PzYGBZzXdKA+<4gA|4wE& zU7vMKyM#wl?@fYYAN*O=J>lg%x;z&QBHoaoCVvgvqo$PPl`)`bNO7-Nk!M_4xKmx& z-+%k%!*7V9$nBf3%8^?>S5X&d8eeb8eN!zEe3|X*-a>esZ zN~UBg|MH`Ku3lCzRWXeK=4~-sjrkgQK;Qhzm{Wo3%^9rTS;WxNgY0jQN|F2I4 zTJw92C`Rz|_3qE(Y99gtfP&#-V*_z%^5+Qn%-~se=ccGnHSs8yB8635H!j%&=n#c? zD#AT8l}gJpx>oq=hOEmP^IR%Bz{WbyZ*7Y1OhuqlVb!B01iWJUBRW+rIktl@*CIdV zsC@GUYp_r8jm0IRq=S^BT~9Wlf5$za<@$Ipg`ho3#W zbglK+Ty_tZVlCWO+G16>uhh=u`p4=dI{ge`h8iU)rpBg?#Yf)n;uA$MXm+aeqg|k? z?Gf9sVOMm6$#s<>I2xDnr9$rQ;CUt4#JH-~n3Z_$zp?`Pr$zL@XbK~qDmIcyGctOE z=%Cy)3cgzF#AOd|&th2CgR0iY?_ExNmkF3$(I09rD(m3OlVr-1hL)=YO^!$#UcE&* zW`5Z53@rp6#MbD^@CiQt=`~Ulx-Cw%N$=-?awTiwlMTM#+5l`^p1$y8Z&cli_z=2t zVrLYr^&3!jO6JMW*PMdhNq34loF;V|m4fU7<@5gji<$Q^Br+Qc5UK5z06&G#Zp=kl z3M=cQPUn8@Mvf0A?xoS-9oT$wv2D7B1D|6avo3RmEM6o8?cQLMs8nc zbV0s-%|79C@7D)u>!EmJkD|D!F?mR3;l&7Pz_f_hAZ#=nWg^9Jh3-)^qg5;2l0Tu? zY0m18s*9%>gHv6<|MJ>P2ZPD13%Nvq{mhPW$f=<KQlP>XCC7@*9|4gn!tO~V_+u-^kn>)PE7xwT|22AJhP}({I<*E0^gx_muDF`mUg{2;#QXy zlI;ZQ^==}`5>$KXyPACs8sv3sBU;_W@=GajnUu`tzdiSz>W-fE2mdh0@!`n{FH|jn zU<$7HP8I5YJpwOviq2o~poybLTU#6Nk4&V#UUQc=V>6jRG3qs-smG3650BAusQ=N# zYuBXZZ61?y2TIy-_>J>>F}B4dLpEJKy(lES*OylTXB6*opd9>XiyuWcI@Ny2HcdsP z7Qe=#w)#Y@Fgb;fNN_;GfNUTx`W~6Pumwxu{$p8s3-(d$f=0LHJ@`7&Sm@H!E`7LH zmr+5+k5PV30ypdpnN;Ns_~%F}a#cWx&c%}Q^0{W|+6!+Q-=SvGkmgEryaAD|Jq@;Q zv^`Jb#km`>9BYdrlSrg?B_lr3cA8P@Py$&|l6jEuI>&0>PRr60KM$|;GxiGuPq%zS zeOQ)Np>qR4hM_+WycfnBqe8CcuU}AzV+W5Ikg0Ml{f&N)DaI#?WBi~+l|*O=*+ z-@1eHe>~h1Q$GGqqSGX>@d&2pt83&tDuw&{>7)gFPOELyxv$M=g1aS&W+a2Kw&VHI zU+hxHkNe!Mm#C4-kNkP}`-pRQd0C5XipFbIsu;IE;cf~}f}4H6p*PVd(rZeIMSEy_ z>^VM>buqZ3k=Yr2zXWxSy^T5y9Wq#qL3tE%7a}9a&Ek~$g0S|NXhp$NiL`7dR3LZR zq7T1K9F@vjb0Fyq1DHX%L(!#C>LhIe;x+D3s+aPBQg|>S#i_x!zg_1Ikv~ZfDN5D% zJbSc_{n1%{o42s!)qh)#lTMp%z}9ZDMT1?E8q_w?V_1?p+tN8T0LZd!G%s!w8`UMU z#M2&bvT1*^CqYu+MZm{1k+Y;&Q4nP9Yb**57d>L|!_j0t!K2>lk+D)`g_X9US*2-U z1L|A#I&%ZXh_^m#1;~VV>NNmPh1bFjZpXR(3*#)ovaGJncW!RhC~W8D=O6pHvwSN{ zuo}54dS$En1<|asQ_}%SI#Vu*@J$yZAzpu`pM`&C#tw7 zin=shuue)@^IIC7&r4#Qi@3MjilHzj@>Qrl&KKA_d9qprq&}PTSsXd~^ffLdMWRho z$RlfC$AK#MG?NibG$m2^ezD2kMiG(qgwudw9sJ}8Z}YW1E_FGLDC(3%h#DWT_C){9 zcvJ=0mE*ow)zpMl+^s-FY^udqwx=m>U~xw!Hwd#M(|!>(mq&PYFp$ zPJ{P_N~_e2gpd6gFQS3lEb_5L^LnG>E9PK%{}R$;wy%c?DBzm>33Smzn{Usrhhpcv zG!Z?9BpF$#`L9)>PlAB0Mxz*#(2-!Ba4whRLwH?KP~N^-pB?p|?yt3syDd!-Qg+Q0 zHtZ;L$+&K`mWO+*n8W^H01!CSHer8}&AxA*?dMJW7jJn%X1uztnm@tG!NIY{ERF7D zlch{al1+Qtfa+@=!8 z9@H#5{a?1=DYy)*OG9O>)YFh@z<08E&k@QQdNZZag-FCjwfB#9s=I&QUo>KLA$;B_ z!>Rmht-WFM?dvoVb-4^8l(b27Uole0eny05{zFpavNjqwd_i{(Hw=opRsGypURG|y1u&?xEJd4rb z<@xm`DZo(k1u@cr(53YT63n{<#sp%31A2WiAxeRG#4_6hy;78KatOXAWicum8c)De z`(8{<-~qYH&V_X3@RWQ-to&PRQaM_}f^Hj>_t5@dC2=}?W+dH>j2O_euD_ijxnV>IY&UI0-&55zMZ>r5>?F^~99vR+nW*b# z$C^xwYJU(=vuRA$lzII*@(1s)9yxLr6>WyyHsL51R>{e|x|~$ahZF)A75eBr}rsgbb#rb>Gc^weAo*^l1hw@DL3WZ|^ZcXrpH?oN+iI@ zoag-_=5Q69v-^jVdniw?yEJ7Q95nyoc!9QowS4M_Vcr9IyC-Tun%CkJebiaQt@@0M zsZxewsOU<|GEjh{ab?(YHt8bWg}iK?ZTA5;aJ6`*3XLVP%Q9?0(7z0lB?*E@LymY=>$- z`%2oLqqC8r=s?|v+P3WE-(t4krLmH%;cIpzonawsaRBvhk&@Eo6NTDl_P5OzaXN#K zaKxq#=b~VJG>!NcMg9#5nO|N*+APmn*?mRJO~YmGpL=erxGW-lVRLTca_>y{5peHI zf2)xcpLRiTr)LTEg$wXP1)&iF*^w7$SaW$5->hKJ1s3w`Qngc4B>){T9mqB~rP7(} zJ?jkwN%>SI=X#o-KLDFvzT4=IMM~%Ck`$CB%3hz1_KGgz67kg4zALl!Y0n-0FCgpJ zkWICw3+KbJWkK4SFJ4^am+XYpW6lLj{DxE5sQe-_7dLE@V7d{lP$X1qK2ZdKUIT0U z!KTzaN^Oc}&f^`j#)%LoO53oed~;Z(7Hj;HmFOqXMtfh3Yg{<`1NBJwpv5s6auyqC zM?Vw=i6fv}!*_dSGd%}h#V#WY@S?B#u2LS=!_JJbv(F^>DY>!*$dm5O^j=9BnU?_# zH{~SQqxeUUDZ(WT(@^Dsv+nSRT0(XXsK^BaOBf}o?F_t`y270Ukw*-)M0^YhcKGkNjj4X$e{-!;)9~1F0sFo|D+?I+4%a8H z{iflUUTK(7Fd0nLuJ`HTE@&>fbdRl4`?lFvH;S%9K^V?Mk+%wVo}OG2S80g)4$;fBWkO787@QujRy_2OP{M!TMoZ}ZTEPc+9O zza^_*1!Q4Cg9FcMvL2Ox)h^wKeqe+3H?Gu^GK!^^NPEH+-}-+2u<@J0tT|uUSE0ZLOJ+d&x5HGp&^y2f5t#TuVZ)a=4uwPc5N^bU1#^q zg}Pi0%7e4uWiPJOngL5{ZkQTU=_;wMfhI%(-Q2RUw(;IU{UN)=wi6;c3z7LrqcK9@#0MHV7J!0#y}m>g}S=BlZqDXTw1+N===HWr8zte zNgS$A((ih5LbFLCPmHNXa&Nx};0(D+e&EEnQN!a?vy@Z&v!VD!F!XhJS0kerC30ef z`4mKmi|i89ViOzm{%9LR(86wX>zNuqEKvN@>-q3GDQ+6`cJ`Q3n%%%Y;5>qQVC`WFUy$pI_=`A9qiGM<;5__vG)`M>-4Z zq6!LHBHA?5gp0=RY7(#+APBy8bL+B3>C^UWvvLA z?Wtd#eqFr2Q7y{fLh!Cv;EgcA@D$jYlcH9ctW zCamapy+<7l4d~+foH!76iB=OzHxQ1_8Dk4Mh2%lW*<@>-x?Bf)ln0aGcre1~(z-2DNov+0FchZp0F;DKmw?D&lU(b;Um6{8p)Evf|Ztib+WHLZovN zObvKcKv@+&wpW6|A8|lZ`WL*=-43=V+Nf`mHa!4rs?+%S1{faX-0zycDX7P0!4Wcv z?ibacM!3X+g^TOs3PBcb@nq5$S!c3Ql8Ej`?x>V7j5mjYeXK`bhD4-%>lneIiAN0(=R`cpA}_|QcL_-K#~>;m$W5On=UWRI%8pv&zEiB+Y$I_`%=iRCVV z0c{?BviphuD7KboSM~=@8v|R$eoE3BJoCdn>5b4+gwY2U?-jnY36GqBX7~>KJw01p zFwwvdL9dOS(CWI+Kxcn;EL#h0F;L3ZUW(U3K5(M!ozGg7sa0v44N#vTkF42qYdv5( z;^*W>p+5wsh3YjnYbE-o%y=?{#3B%~BYhy1-O6@7eIllU+momPoAfRR!AR`L?Q4!e z?A@-Ki;II)vC-tf#Q9Wb9?zY4v2AihPml6sO#zy7bFEisM7t&@Iy}lc1oI@BgnBA9 zu89y5ArK;;YfUoGfTDy|EsEQaoDz5j^83J4D*xP^ru z!|Xuv-vjLkN!HZN-(h!Nwfzz!4_H{M>I8xab)Wn?PiTJZrw1%b?DcL|bp6VN7W&-sy>n(IP_9@q!id+ev7nb5L18C^L;- zuzzezZ{MM&5jnLZ>Ykyp{B&UrK;5~qn04s^h61@5}JXiW%HdYa}efOLj&ai$RhPEhj_>C z;6^M?K)eCZEo0z`g#43eI|(U$h2ZGk$t_Y$S@?n0)26kAXl6|?Mql=$g@Xx;J2nr$ z1H*ssDs#&jVQZO%Z_cb-Ac4cA9FZD%vCQ6kxND!E|5U%}Y4sC7G9x8q_soJgpKML- zB2L_f-L^dFcc))>^G|swglvmkn-Ry3TwA#HFCj_{Z}TS9vTBAjpO=`X_y7WTsAsfx z^Dq?t)mFbRMatq#HEtW&5NCRgOmLY$Q)hEm80u(it9W!Bks({jLT`7eWC?mO*pls1 zh~N+a2`>Q9+4ARW2Es~7fb#Yx}=nKr@L1fe7(6cA0jd?#DFO3QBEJL;@U zNa_eb!7ESnH+?~^T8$v>9w+8$O6ZYx#T64~O-Tv-zR8^@E53f=!i6`28Is5}`uv0* z0&&(}3<`UQAy#Pkd*T2;c${66{C`3xjUh`$r7ybPfi7TnAG+!|uKwp&ajJx5QV$DE zt&0Ht>*1uK&-tzm~L)_7?Ir^hc;q%n&7%^Oeeg4 z>e|Ur;_TA?(kh=lQ_4x-tkXbaoWYBUKF?f5xcOajz};~e%)85BGAd(Fa`rWe9p!*i zS^9fYIkECcIo)?~;QfQ_qtvyi$9@H7Eb_ujzgZEu0ir6ja~3_CXhdln?klaD6f$;_ z5aKOxEF}(IUMkJ+j*BE`Udp>Wduz1!^PF$OpG?~F>?3hpQ&MJ`+b_ZF(cK#C9Mw8m zrNuLH2|f{>)=$V`M&b#cBu>T{CkBvya>8Qym>Z$H?a^Xs#G_?75PmZtpINPpeE0dI zM)g}RyqE8C=>u~)bJYmQ`#ZH?aVlnJW*Zbfc~hPcweC`LAwn@cB@u(J=em8RUjDmG4sfRGzvGJ{!AT_Ni0{}hA{?D*3VR^yuFpdm1x`>S?J9tIe(rV0DH z?9jRHN6<^o)Yykt@M3vk7aXv(Lok!cM5WjtR*x4GdP5uVC4&6mD;`x~CP}lqwwubv zq+kbLpWl3TG|u7zF7a%m$6{a%8c_sU1h!^hA%qc66LZG{M3}iPY1#z`+8+$c1+Bz> z#a5z8rDmk9BPNJ5t7h~P^ID7!GHTe?%X+A`l*@XC%AHq|?Ab@oOx#pCNr1Xh4oGKj zg60XB$ONl6n)>u1wGG*>^7Df2lUUv>`1O@FgJEWSh0)3@Jh3`7nsxxINA!CVqe3IG z^x}HR?9P~*f)DDuxz1StZIXGtG44A_0j^_Fj?&C^g zU%aSBq@r!0fN055*ZF%15+&)r4JO-gjr<}eB72V`p;xfqdh)gL<^{WeU1b426$`b$ zP%XFP<+RUimBY*Vk=7Scz^$3W#j+I zOS4tXfdIJs7nqa+0c{|;(?ofBZwPA_NuQYOvcEx9y58*xS_lNHcWWMNxbr1epL**?`U$}dM9Ub zH%WSdlpN&MLZeqqxTF{x-%J{KqY_*%*5%pwr+sQ0cA|6-|*f73B!kp;FcCaUZ`A8iirw+i42w z4NZB8jn05@FsOMA`v}pfet6bpC3YtsgVa`EZ+1lpz3D<-8YP&%AM1y4s`X1aq|lJ_ z3gh*F+ECtk*iATIr0<2TLEYyB}THD!;=j8t1dq|3B@TTx)- zHOCPeyoY8LRXQwGOMTh}8O)QOnw|aylGri%R?5ZD*~cdvLp^Y&+5`pWO*D=Y+)$&* z^9!VlIgkiUFz`MON~polW*nh$x?sW3xWv%Yl(gByqx;}ApkyI?pE)0Vil-or0ll@> z%;dqm6twj^LVBe6d0F+fHv~mPCeQNQe3bc z8EGY(^NUPCjDVL#n5fw@5POunAc7#e30~i;73{h@@9~iRyXN!@@Q-5p_XV6wmOyM< z@qO{QuYF-Oy^K=+_xoc=s!vV!gaa)VS$t$e593nI;%s-b(|rV8Gn-V zurz%i<=ZN#l(r0gP(Jy``|sV9=NzU_c@#M8CFpbuN})~s(FTY~amh~_Ns$u3P(c2< zP{P)weCw|0E;f)7P-E3Upe}-P%#_V}$?-B<{~Tt%c2_o%(TK@)3YIxrEYHEX6=kr~e%0gI6Izydc~&W6d>@))Qhsl zlgOOC?0_2C;NTORqv@BxkKD2!Q}n=EbV*+{i^+g}4xpD4-+rR&ly_ zU4g0-I%2UX21@3_fDIm98aS6%8oy;(tKwvWK&hLuE?VR!e7uv}8Uio1xu0S*1J&n` zVN6#6^c~|Gb<##mWvd?1L^*hQjfIJ!EJRr_V3o`CLZ0oGOpGjH9}v-k4v87D5{b~q zPDJ_3wHY)*0#oSLYLX+XP(FDhxIb79{m2E8w_|c%h60vcKvcbk<#9q#isFF>1#4PBb9h$N^_^L_M1asu4KLTG%*e(HrbrCNdRF?_~YIQPRV}bVQ^tQS!?K z#e+w?%ZDN-TsHm>3SVd2lW(`rM{oP~?Pg{%Z?$D@DNhu@$DTpUzJKrC)RPm}P!xpw zBYF02?OB8RlK|FW^$5{7Yk1@{nLU&snUU#V-GiT8!A5)s19h@x)e6m37&pme>&7%l zFmwXIRv5Q)6?`Ge!zWEHUrPAXQ7VX$Bi`PH9)Vd8|M!4g`Lyda8xYR!kD(~Ib6qD- zWc599<}y-V3L&e{Ki({K9vY%1f7VI+oH-X?!w&Ri^HVV3N{*;+(Se}nq4WyY8#itg z2K?v>98N}yqWfO`X`762efNWPP4D?hn zlaE}^{|aR|Fx_5P_qbmKCz3Nb=+D@F5~+Ob~bUw3|$^q2n~4|7{En#3*&oO^|z zK7DHUEi8+tAddmX;g;VY`EX?rz7!jPHT&=M<0*w_!&*@F?L>B0@Y(u++P05Lzz+*k z%#(QhvOTBuPkX7$_(=wx(8!sN22!hedWuIfbmXA~zh4xv;lvL|b5jw;lu;?9tR?LB z;)Jm8YbG!kFe65nfbQmned~kqB@!r>oyQ$f_;49UdiR17eopE!#aJ1EA(6PgBtp_W{=;)zcS(9eobt7on1nsI;8`lQM2cu{LE>iY z^0mUp>y}}wColOk8?wHAT?#QHY2%g3E)D>5XV=Zw^HVRP?B6;cThyg|wc|85oizBLQ;n=7Am`vs z+4h~1&^(?)`SygYsHjM=zXK6S-KI=KjHj4+ju_I!?$Ui(o4e9*uWbe5s-Z8Naa5;x z)zD7@s~XNJ?2F?}E$>UEO8pZZE#~+C)1M7SWFBfRHcGt=UfKc0K){3}+PuGpyZwl< z6GA@>;-9Bp*jD*w`ol*^9|AlS?sFDQ+zg;dQ|-QhHsvn9N#5XpTCA9#tjHkmAg{V2 z1Qy5dRI%eZ`eQQkJU}D9_K|Vp#s~K^gGR_x>!+7F9GSt0b-kSs=BoC*-7im$ki^hX zv3To1H7HTw)EMFt{-=2hCR;0FlB=w^=@w+f3z{UQ=e62pAU*R^Fha%9F>burkA$2x zOMX*r|0@{ZCC~z~>KB#>(~yX<4Te>^$^JlR#`dxA+DEO&w~!-<{zpiqxGeSSqZTx4 zoOfh^KnUn+W?OY>0lA9@O|Hkj-xF0mL~~@jNGfG}*}0ldlelW_AN!mQ3%m1<=+d8Q zl2WGZlJkV|pz^K&gav5Yv46L1)c^K=m)w5FRyEWYyyWB9d6mpxGNj;1>OOZ4D}&wr zKHc^8sW+;5tZwq!es~YYC{TV8p;-3Qwslm0TL;wrxF7T!0Pr)apx~$Uq6R+~e^$X= z#;nkJ=bU3`m2K`ioX)q7yoH|tO*gh(C=59M@fFWXUqcJ(6wt?+?%>F|nheQfRU~=^ zUmrwn6bCybKY~)mbzJv>5Tg9ZaSNsB|IIMJV8s#*4?XP5UKfEn7Fcp+gnJ~Pffhl! z`a!f_b5kb$#J(nDZTj0e8WLp*n(z>5{I``8KeNs+#w9_A72esn^nYSqL$-gi1yo|z zMR#tJC6`ljWjxV2fuQ4}s3tM(U0{9W`9We>wmQQj`UA$=Zr_YUj&-cL`gSf`&T!YC zuSOeb?BXDzl%?iq6}8^!KZU0~!Bjz=25ti44quLO@Mst45FW;PtTrw>u#xK zEumyipIxEq`!(;nKSqqk=sAa#(UNlRl#5tQ;-I2=z9&bPn3Px{EIcQpALzT=&qWeO9ps3rJYYgs!MkW@Td3jv^QKQ1^dp&t|6L3k~T1xa`OPNi!2cx8o^@pqrZ#q5{pp`v+dIUk^1(pgzaP z4R|Uzx&sUd@k&om4{}Ex5M_L6niW*i1WwVi)oj?jkC3Yp9|PGxxrE`@uL?DXYAArR zd6RJY;FT2af^nrlOX|WSSz$z83N$GIdO?TyN3UW1IDLd z!pIR(MlqR-i6}6&i1}g+t$|#1o#<4@Hwg_FI_s6l6U&HR7P8D1G``@p9a_R0X#YDJ z_h48TnAIynMQ*LWk9pSVGPp^aoiJx;08mp2$8K;DLIU3Ztv+zeC}e4<-NoeP<)I#% zPm(c&=At#v<`?jf%j~*EH@B^(O38q-PvEMu<*B~_3c%&YD$cS$_*4<&ilN#f(m?_+ z9mcl|dcs$x05MrocvW|Uj(KzJmr)BLGcvR-^0I)cV7{+!ODeN6&XL7H%M;=oOb?_s zQg{hi^)w=Zqi@YlN}-csVyN^IS+?$U(>i-zF*t zOnj_Ss8C7>e#djpo__l5^WkR?@jWT<`>CQ{&6RhZk&=1|sTocq%iI(RA%60j$Tp~S zK@x{=dHUQ9qS;lE@D3M_e2Qr=L3vv+F=kA-MN~!LuXUL3kD15uhgUQ%{Ma65do!$9 zN|j*3#C{Vef&m|MQ`p?qshme-5+4wlk;u5(rokfDc0)<@0Tiq+c%1_|iV_aY51O@# z;6k8AsM_=#AA$O}HkVdr>+``wqbP)ZR?n?n(%TF!+U@M3o8TgOAw zxy*0uk(n!fR}Ygm;Ct1kvdwPqlJ4Yg$Fw7p=@6d1BY>J|NmF&oons1MCOeKDR065` zZzBh1z$0RE1~doyD&aiABqaEswn{9`xbh;J6{$Up$a#Ha7vWLGO?%(@84 z-EG_vFxYM|Gz_x3`EJXRKdVsV6XP_IbF3o*R3yGihpK0DUdqMgirNaa(L)tuXX!n# zSd|&l9;k+Q3jq}2Djpsa3XP)YQ;;I_k{?5EQ#lZk|Ehmc@I3S`sL4)COM{u^yd!j3 z`wqyM0PK6BS&zFfpPl&&f^huca_`8wwSE7PzX)#O$^8(U0JP zJ}3>m@201?H4}V$ecWAu!v~Q~LgXm^NvKqD9l1`XW7-xceI28u&^YFGFnF<1Yr#-U zGa!MBC>%6 zVmsnvSQuD=++p|I{kqSjAUJsASu!nLzquJ-+{xXg<6-4Bm-*yKc?pD266auFp47~j z5tib}69dDjo)IL3(+oNZS+@qJc3gv*%IP{7v zNnRXLXpy6Qz=%RXcFw&@G@zsmX*sfx12#X9MHOd2D1?y*ms@y3D@uIJr!EEB^GiJ- z&zBJcD=HAj=A|TUIobZgP>tw5``a?oLNXxzyR(sifq=wSY?D|bf*OSHds=HYTMaKd4+`TBtItbpPv<(##o1p{(BPNp#Y!*snAA@ zaj}p(*wiwa{up@N;{?fuCJ=V9@B*?P!+s9tz!Cs=kz@w*m;XQIUHL;ydmFDYxuwv8 zqSV}rJFbwem8qztqOzqBl~fZ_No7)ILd$JKi9}S_9!z5ejPj-+*j%K0U3z2;vaq zR8(Fa9L@*Z4}&!oIWm@TP{7t302p8wr=yFf?og^ijm8Kb85wip-ERwpQd&~?WLS3;i*|p#h>ny1nkt5#?&jmr6w;Ay9;1QGue-T0*FzUl zj6OPU85WpKYbv(M;?DJ`brD}LAGWX?avd&v!(T!D>rv8Tw8!>_hbw5!xNnL1PyjE0 zQoY6QXlLYXypclvvLo#C>wHlYZLo;2j)V1v{ITnp1u$2DE)U<=L@7-I3e z$5fXa;hE;q%IMKNIFpdPyu-`7R<_TE*m=N^QOJWHAYP;J8O~Pry0%MtxS77_U++iO zD<@Dlp)UPn#BFBcRd_2#63-Fr>@?qizh_!8f|cC&MS!>`W@@3a)7)joxY03!-+pw? z=081j3u4`l9F4|zTRWy_$JOPff!k2^bu=tr7o1`!v3Ir*QJWp zv_2h~{*}I7!~D0I<*djAo#{$#@)gCrQdBBXqdNB}5e=k9p6W|{5>TvJ>D#Wmy!=~B zcWn6YPN=X?jV#s7N%NA=9iw;S4c)C^fn9Rqfh7+zLuKZrq(4doH08C)|C`6c z*Eppj;hqtrD(_ioNuwJyyB+mmfgqzru`rVCE z{7J2(slbh&X4vRps?G;b0#j}I0=MSblYN1K{Di}gupmcCgMrA%d%Idb+zx}}4cc2N z$o%ThzLOON6S@pq`d^QT2UoS@Xf8dOG(QbCPp+x-VF{wM(s)jwZJ{V(^bU~R)gbgP z(HpPIIiQT0q4xdqsxT9LtAFq#w~#XnfopBpayja874eTAzpnx6gbHQr@!{#zaQDIG zq8n8fvXd=ak;XsF=f;SEH^p0VQ^UdO{kGs=}KBxStDrLiY?NevgT@qxd zR)5&FMv}P+p|$~jp0RLWH?Y1BYYTl&IM_MlZs_z;Ur$^jPAjoovQ`{#QED6<9m@kEnak)nwz`jo)iWzCoy+|569VB$s{c+NNElKzTr9Qwvcrz_V3kQ#n z!L~TMb7U(+Mff~Wb6{i{V+37=*A8QCQmkhvt9$;Qxh-TRLTyt%I-CeyS5pV>>S14m z!e7vrSs+}ZVmuB#hI8b?mB){N$KW*N<#;f~FHehZnXphkpxbgjEuahqJJV*M#TVk| zPu*Vq_Iw1D#QVAiml^dGlGBQkC8Pg_K2`G zqYu2hHc^BW*Gp`^-6O8lk|i8H zy}-tcn~{_ZywA#2Hj3N&WsJ zH`dyDyNUz=Bd*_hrN%5O6Naq8yBxO62Y19~KD)fD#PDIR=q@pMg~B0R?l&1eD#lcO zFSx2m`B3lrJ9__xgbZd*^p@s;^=fOtA6o{=Rix=n*R;E44-!XFah8Og`o+E%)%ufs zF66ZCR=w8rKIFlil?Kt%&%XHVHwV~4k#D+#-RHclgwns~W4S*a>Urht4dYB)ud&PO zR_7)ZS}!F!41AU=wnKh&{1mh1lAYwO3%r!FxXBt?;S3iVQg*KQL>JaNA{3;U>={JX zBF@mIMiyhEkKqyX2GzbAUPDfW>H>}j>C>7PMdZMoH|5M7$7k$ z&scOeK7+SJI*g>ok$0g@N*VJg92XLD%t|=0=2ano>3hm0|FxPvs#g<937><@`{ z#`lsU9@|e>86%>#;L|`;Fmk^4vnz|Y`-T)5=css-Fp{7z4OAY;%b~v1~AjFlHXF*$(!|mJ;<lSi9U?Ir z=CO>FVR_sGAZoDN&_(3;3pwo)O=jtn^xS=4FW8dj_kJ{O86Up+#f99jr2mR7P9z)B zFM;20itf)$Fg60CrCV^C%e*vuI&o=Z7B-acDR;1gtl0R86FXxD+d;3Q@0C=cgZ)e; z#b)QzOZ*4FGo?QBUXB!Vw9Nw0_#&kh2bzS{o_Kev+n!!!g@7F0mutW1MHkUS4k7`k*8Dr33?t_ZK z{I&}w*>7k2<_3^WBqiaM&P#J>bOk>Y_2Kx^jL=5FemmXn<7*(4lFSS?o5)kVcd zc{y#9=ekRGytS;CsSPr!uYK8hd2XG5aqM=xmytP5iR{s_2idZU98*pVw3gzZe9%=> z$ly6;J2*{VZzhzIX0c@_tMo-y_!*tZ;6-aypR8|lw;!&;F{NvbGVdoEjEk`-;8woq z83^;#_nksNP~;qNJe4e()RY)juGLv1D6{R@wBY-Ny{2`n>W{%&^-{APKKK{E&I_4D zPZvsw7O}lm4Bq}{mj*v}ab|tn%BWb2?^m9(&uJQ@)qCbXiBZ+nOI_xZs)yW+9yHbA zREg-7ufeYIH#Y~F(7<`^r^VLV)l39+m@>%=V;02m3 zKKdC|fu%F7DlanY7n&-Itl9AcVOpJ5XC4%{_*ezT^y=Gy?U@ICz3y{T zyzHz)6{g!Vx4Sf6{gK>Q@~V;@`+xqM8*=?p;k=Qn U^Ru4}Na2r_g{^tcBA4+00Th7xH2?qr literal 0 HcmV?d00001 diff --git a/materials/mfe_e/img/transp_fixation.png b/materials/mfe_e/img/transp_fixation.png new file mode 100644 index 0000000000000000000000000000000000000000..7be40f3ac2b5f25847a2a51b6b481274761b6ae3 GIT binary patch literal 4138 zcmeAS@N?(olHy`uVBq!ia0y~yU_QXWz;uCw4JZ;{F1dw)f&ZhYi(^Pd+}j%)eX|`! zTrY+*Uv+ZH)a!jev5@7tyUM*N?_HNf3MScJX9emR1*0KAUI^4beOo90{ddVZ%ja{7 z&+UwV_vO$_wu;L4-+vcDh5p|G3CzEqd|~_h?Zps5+xKO*RS)+(d^%TA+Ju4OgY;g9 zE=OhthVD3pqYD@r8eH`!Bwb)&IIu|E!!Uz^A>ktT5(%KX4KG-Oc%&E@BEB$bvhgx7 z=u|a|Gy~JT*r@i=pc_p#qgiIOxEL)eN2`g^Dsp5u56(N@-*+F<(6ao#=eBACXXSpm z<}zq|taQ2bgQt7%zJL7d=jF%1HXEqn_S{c@P9Av;z)@YJAut*O10DkZ4%wg0zc*F$ RREsdkEuOA^F6*2UngC-i@pk|K literal 0 HcmV?d00001 diff --git a/materials/mfe_e/img/trial_csv_creator.asv b/materials/mfe_e/img/trial_csv_creator.asv new file mode 100644 index 0000000..17d3cc7 --- /dev/null +++ b/materials/mfe_e/img/trial_csv_creator.asv @@ -0,0 +1,240 @@ +%% This script is written by Kianoosh Hosseini at NDClab (See https://Kianoosh.info and https://ndclab.com) in May. 2022. + +%This script reads the faces' files in the renders folder and then loads all +%45 and -45 faces in a single column. + +clear % clear matlab workspace +clc % clear matlab command window + +%% Loading all the right-directed faces. +%main_dir = 'C:\Users\kihossei\Desktop\MFE_Flanker\img'; +main_dir = '/Users/khoss005/Library/CloudStorage/OneDrive-FloridaInternationalUniversity/Projects/Psychopy/MFE_Flanker/img'; +faceData_location = [main_dir filesep 'renders']; %Location of stored faces (i.e., renders folder) +cd(faceData_location) +data_file_lists = dir; +data_file_lists = data_file_lists(~ismember({data_file_lists.name},{'.', '..', '.DS_Store'})); +data_file_lists = {data_file_lists.name}; +data_file_lists = string(data_file_lists); +allFaces_filename_pattern = '_45'; % The face file that has this pattern in its name will be loaded. +allFaces = contains(data_file_lists, allFaces_filename_pattern, 'IgnoreCase',true); +allFaces = data_file_lists(allFaces); +allFaces = allFaces'; +for lisar1=1:length(allFaces) + allFaces(lisar1) = append('img/renders/',allFaces(lisar1)); +end + +%% After creating a list of all faces, randomly sample 384 faces. 384 is the number of trials. We also select additional 20 faces as practice trials. +faces = randsample(allFaces, 404); +trialFaces_for_surprise = faces; % This stores the list of faces that are going to be shown in practicae and main trials. +surpriseFaces = ~contains(allFaces, faces, 'IgnoreCase',true); +surpriseFaces = allFaces(surpriseFaces); % these are the faces in the renders folder that are not selected to be shown during practice and main trials. We need +% these as foil faces in the surprise memory task. +% As we will show 50% foils, we will need to randomly select 384/2 faces +% from this surpriseFaces. +surpriseFaces = randsample(surpriseFaces, 384/2); +% We need to show faces that are looking straight forward during the +% surprise memory task. So, we change these surpriseFaces to be looking +% straight forward. +for Soubatan1=1:length(surpriseFaces) + surpriseFaces(Soubatan1) = strrep(surpriseFaces(Soubatan1),'_45','_0'); %renaming to have looking straight forward faces +end +foilFaces = surpriseFaces; +for abrak1=1:length(foilFaces) % adding a second column that mentions if this is a new face (i.e., foil). For new faces + foilFaces(abrak1,2) = 'new'; +end + +%% A loop that creates 12 CSV files for the blocks. +for jaguar=1:13 % 12 of these files will be for the main blocks. The last one with 20 trials will be the practice block. + if jaguar==13 + firstDat = randsample(faces, 20); % this practice block will have 20 trials. + pracFaces_intact = firstDat; % we need this for the 2nd csv file. + % we need to randomly select half of the faces to be right directed and the + % remaining half will be left-directed. + rightDir_faces = randsample(firstDat, 20/2); % right-directed faces + leftDir_faces = ~contains(firstDat, rightDir_faces, 'IgnoreCase',true); + leftDir_faces = firstDat(leftDir_faces); % contains the remaining 192 faces that will be left-directed. + for lisar2=1:length(leftDir_faces) + leftDir_faces(lisar2) = strrep(leftDir_faces(lisar2),'_45','_-45'); %renaming to have left-directed faces + end + % Randomly selecting half of the right-directed and left-directed faces to be congruent and the remaining half be incongruent. + %there is going to be the table that has 6 columns; the 1st column is the target; the 2nd and 3rd are distractor faces; 4th column is stimNum; 5th column is congrunet?; 6th is the target. + rightCong = randsample(rightDir_faces, 20/4); % Congruent faces. + rightCong_intact = rightCong; % We need this for the next step. + % Let's create right-directed congruent rows. + for zebra=1:length(rightCong) + rightCong(zebra,1)= rightCong(zebra); + rightCong(zebra,2)= rightCong(zebra); + rightCong(zebra,3)= rightCong(zebra); + rightCong(zebra,4)= 5; % stimNum + rightCong(zebra,5)= 1; %congruent? + rightCong(zebra,6)= 'right'; %target + rightCong(zebra,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightCong(zebra,8)= '[.18,0]'; % Right image Location on the screen for the Psychopy + rightCong(zebra,9)= '[-.18,0]'; % Left image Location on the screen for the Psychopy + + end + rightIncong = ~contains(rightDir_faces, rightCong_intact, 'IgnoreCase',true); + rightIncong = rightDir_faces(rightIncong); % the target faces that will be incongruent. + % Let's create right-directed incongruent rows. + for zebra2=1:length(rightIncong) + rightIncong(zebra2,1)= rightIncong(zebra2); + tempIncong_name = strrep(rightIncong(zebra2),'_45','_-45'); + rightIncong(zebra2,2)= tempIncong_name; + rightIncong(zebra2,3)= tempIncong_name; + rightIncong(zebra2,4)= 7; % stimNum + rightIncong(zebra2,5)= 0; % congruent? + rightIncong(zebra2,6)= 'right'; %target + rightIncong(zebra2,7)= '[0.08,0]'; % Center image Location on the screen for the Psychopy + rightIncong(zebra2,8)= '[.18,0]'; % Right image Location on the screen for the Psychopy + rightIncong(zebra2,9)= '[-.18,0]'; % Left image Location on the screen for the Psychopy + + end + + leftCong = randsample(leftDir_faces, 20/4); % Congruent faces. + leftCong_intact = leftCong; % We need this for the next step. + % Let's create left-directed congruent rows. + for zebra3=1:length(leftCong) + leftCong(zebra3,1)= leftCong(zebra3); + leftCong(zebra3,2)= leftCong(zebra3); + leftCong(zebra3,3)= leftCong(zebra3); + leftCong(zebra3,4)= 6; % stimNum + leftCong(zebra3,5)= 1; % congruent? + leftCong(zebra3,6)= 'left'; %target + leftCong(zebra3,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftCong(zebra3,8)= '[.18,0]'; % Right image Location on the screen for the Psychopy + leftCong(zebra3,9)= '[-.18,0]'; % Left image Location on the screen for the Psychopy + end + leftIncong = ~contains(leftDir_faces, leftCong_intact, 'IgnoreCase',true); + leftIncong = leftDir_faces(leftIncong); % the target faces that will be incongruent. + % Let's create left-directed incongruent rows. + for zebra4=1:length(leftIncong) + leftIncong(zebra4,1)= leftIncong(zebra4); + tempIncong_name = strrep(leftIncong(zebra4),'_-45','_45'); + leftIncong(zebra4,2)= tempIncong_name; + leftIncong(zebra4,3)= tempIncong_name; + leftIncong(zebra4,4)= 8; % stimNum + leftIncong(zebra4,5)= 0; % congruent? + leftIncong(zebra4,6)= 'left'; %target + leftIncong(zebra4,7)= '[-0.08,0]'; % Center image Location on the screen for the Psychopy + leftIncong(zebra4,8)= '[.18,0]'; % Right image Location on the screen for the Psychopy + leftIncong(zebra4,9)= '[-.18,0]'; % Left image Location on the screen for the Psychopy + end + % Creating the main table that contains all we have created above for the 1st CSV file. + mainTable = table([rightCong(:,1);rightIncong(:,1);leftCong(:,1);leftIncong(:,1)],[rightCong(:,2);rightIncong(:,2);leftCong(:,2);leftIncong(:,2)],[rightCong(:,3);rightIncong(:,3);leftCong(:,3);leftIncong(:,3)],[rightCong(:,4);rightIncong(:,4);leftCong(:,4);leftIncong(:,4)],[rightCong(:,5);rightIncong(:,5);leftCong(:,5);leftIncong(:,5)],[rightCong(:,6);rightIncong(:,6);leftCong(:,6);leftIncong(:,6)],[rightCong(:,7);rightIncong(:,7);leftCong(:,7);leftIncong(:,7)],[rightCong(:,8);rightIncong(:,8);leftCong(:,8);leftIncong(:,8)],[rightCong(:,9);rightIncong(:,9);leftCong(:,9);leftIncong(:,9)]); + mainTable = table2array(mainTable); + mainTable = mainTable(randperm(size(mainTable, 1)), : ); % Shuffle the data randomly by rows. + mainTable = array2table(mainTable); + mainTable.Properties.VariableNames = {'middleStim','leftStim','rightStim', 'stimNum','congruent','target','locationC','locationR','locationL'}; + fileName = append("trialTable_practice",".csv"); + writetable(mainTable, fileName) + % let's update faces for the next round of this loop. So, it will not + % have the 32 faces used in this loop. + facesTemp = ~contains(faces, pracFaces_intact, 'IgnoreCase',true); + faces = faces(facesTemp); + else + firstDat = randsample(faces, 32); % each block will have 32 trials. + firstDat_intact = firstDat; % we need this for the 2nd csv file. + % we need to randomly select half of the faces to be right directed and the + % remaining half will be left-directed. + rightDir_faces = randsample(firstDat, 32/2); % right-directed faces + leftDir_faces = ~contains(firstDat, rightDir_faces, 'IgnoreCase',true); + leftDir_faces = firstDat(leftDir_faces); % contains the remaining 192 faces that will be left-directed. + for lisar2=1:length(leftDir_faces) + leftDir_faces(lisar2) = strrep(leftDir_faces(lisar2),'_45','_-45'); %renaming to have left-directed faces + end + % Randomly selecting half of the right-directed and left-directed faces to be congruent and the remaining half be incongruent. + %there is going to be the table that has 6 columns; the 1st column is the target; the 2nd and 3rd are distractor faces; 4th column is stimNum; 5th column is congrunet?; 6th is the target. + rightCong = randsample(rightDir_faces, 32/4); % Congruent faces. + rightCong_intact = rightCong; % We need this for the next step. + % Let's create right-directed congruent rows. + for zebra=1:length(rightCong) + rightCong(zebra,1)= rightCong(zebra); + rightCong(zebra,2)= rightCong(zebra); + rightCong(zebra,3)= rightCong(zebra); + rightCong(zebra,4)= 5; % stimNum + rightCong(zebra,5)= 1; %congruent? + rightCong(zebra,6)= 'right'; %target + rightCong(zebra,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + rightCong(zebra,8)= '[.18,0]'; % Right image Location on the screen for the Psychopy + rightCong(zebra,9)= '[-.18,0]'; % Left image Location on the screen for the Psychopy + + end + rightIncong = ~contains(rightDir_faces, rightCong_intact, 'IgnoreCase',true); + rightIncong = rightDir_faces(rightIncong); % the target faces that will be incongruent. + % Let's create right-directed incongruent rows. + for zebra2=1:length(rightIncong) + rightIncong(zebra2,1)= rightIncong(zebra2); + tempIncong_name = strrep(rightIncong(zebra2),'_45','_-45'); + rightIncong(zebra2,2)= tempIncong_name; + rightIncong(zebra2,3)= tempIncong_name; + rightIncong(zebra2,4)= 7; % stimNum + rightIncong(zebra2,5)= 0; % congruent? + rightIncong(zebra2,6)= 'right'; %target + rightIncong(zebra2,7)= '[0.08,0]'; % Center image Location on the screen for the Psychopy + rightIncong(zebra2,8)= '[.18,0]'; % Right image Location on the screen for the Psychopy + rightIncong(zebra2,9)= '[-.18,0]'; % Left image Location on the screen for the Psychopy + + end + + leftCong = randsample(leftDir_faces, 32/4); % Congruent faces. + leftCong_intact = leftCong; % We need this for the next step. + % Let's create left-directed congruent rows. + for zebra3=1:length(leftCong) + leftCong(zebra3,1)= leftCong(zebra3); + leftCong(zebra3,2)= leftCong(zebra3); + leftCong(zebra3,3)= leftCong(zebra3); + leftCong(zebra3,4)= 6; % stimNum + leftCong(zebra3,5)= 1; % congruent? + leftCong(zebra3,6)= 'left'; %target + leftCong(zebra3,7)= '[0,0]'; % Center image Location on the screen for the Psychopy + leftCong(zebra3,8)= '[.18,0]'; % Right image Location on the screen for the Psychopy + leftCong(zebra3,9)= '[-.18,0]'; % Left image Location on the screen for the Psychopy + end + leftIncong = ~contains(leftDir_faces, leftCong_intact, 'IgnoreCase',true); + leftIncong = leftDir_faces(leftIncong); % the target faces that will be incongruent. + % Let's create left-directed incongruent rows. + for zebra4=1:length(leftIncong) + leftIncong(zebra4,1)= leftIncong(zebra4); + tempIncong_name = strrep(leftIncong(zebra4),'_-45','_45'); + leftIncong(zebra4,2)= tempIncong_name; + leftIncong(zebra4,3)= tempIncong_name; + leftIncong(zebra4,4)= 8; % stimNum + leftIncong(zebra4,5)= 0; % congruent? + leftIncong(zebra4,6)= 'left'; %target + leftIncong(zebra4,7)= '[-0.08,0]'; % Center image Location on the screen for the Psychopy + leftIncong(zebra4,8)= '[.18,0]'; % Right image Location on the screen for the Psychopy + leftIncong(zebra4,9)= '[-.18,0]'; % Left image Location on the screen for the Psychopy + end + % Creating the main table that contains all we have created above for the 1st CSV file. + mainTable = table([rightCong(:,1);rightIncong(:,1);leftCong(:,1);leftIncong(:,1)],[rightCong(:,2);rightIncong(:,2);leftCong(:,2);leftIncong(:,2)],[rightCong(:,3);rightIncong(:,3);leftCong(:,3);leftIncong(:,3)],[rightCong(:,4);rightIncong(:,4);leftCong(:,4);leftIncong(:,4)],[rightCong(:,5);rightIncong(:,5);leftCong(:,5);leftIncong(:,5)],[rightCong(:,6);rightIncong(:,6);leftCong(:,6);leftIncong(:,6)],[rightCong(:,7);rightIncong(:,7);leftCong(:,7);leftIncong(:,7)],[rightCong(:,8);rightIncong(:,8);leftCong(:,8);leftIncong(:,8)],[rightCong(:,9);rightIncong(:,9);leftCong(:,9);leftIncong(:,9)]); + mainTable = table2array(mainTable); + mainTable = mainTable(randperm(size(mainTable, 1)), : ); % Shuffle the data randomly by rows. + mainTable = array2table(mainTable); + mainTable.Properties.VariableNames = {'middleStim','leftStim','rightStim', 'stimNum','congruent','target','locationC','locationR','locationL'}; + fileName = append("trialTable_",string(jaguar),".csv"); + writetable(mainTable, fileName) + % let's update faces for the next round of this loop. So, it will not + % have the 32 faces used in this loop. + facesTemp = ~contains(faces, firstDat_intact, 'IgnoreCase',true); + faces = faces(facesTemp); + end +end +includeFaces_for_surprise = ~contains(trialFaces_for_surprise, pracFaces_intact, 'IgnoreCase',true); % Exclude the trials shown in the practice block. +trialFaces_for_surprise = trialFaces_for_surprise(includeFaces_for_surprise); % Includes the list of faces that are shown in the main 12 blocks. +% We need to show faces that are looking straight forward during the +% surprise memory task. So, we change these trialFaces to be looking +% straight forward. +for Soubatan2=1:length(trialFaces_for_surprise) + trialFaces_for_surprise(Soubatan2) = strrep(trialFaces_for_surprise(Soubatan2),'_45','_0'); % renaming to have looking straight forward faces. +end +for abrak2=1:length(trialFaces_for_surprise) % adding a second column that mentions this row is an old face (shown in trials). + trialFaces_for_surprise(abrak2,2) = 'old'; +end +surpriseTable = table([foilFaces(:,1);trialFaces_for_surprise(:,1)],[foilFaces(:,2);trialFaces_for_surprise(:,2)]); +surpriseTable = table2array(surpriseTable); +surpriseTable = surpriseTable(randperm(size(surpriseTable, 1)), : ); % Shuffle the data randomly by rows. +surpriseTable = array2table(surpriseTable); +surpriseTable.Properties.VariableNames = {'surpriseFaces'}; +writetable(surpriseTable, "surpriseTable.csv") + + diff --git a/materials/mfe_e/index.html b/materials/mfe_e/index.html new file mode 100644 index 0000000..465ec9b --- /dev/null +++ b/materials/mfe_e/index.html @@ -0,0 +1,23 @@ + + + + + + mini_mfe_online_s1_r1_e1 [PsychoPy] + + + + + +
+ + + + + + + + + + + diff --git a/materials/mfe_e/mfe_e.psyexp b/materials/mfe_e/mfe_e.psyexp new file mode 100644 index 0000000..210b0cd --- /dev/null +++ b/materials/mfe_e/mfe_e.psyexp @@ -0,0 +1,3326 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/materials/mfe_e/mfe_e.py b/materials/mfe_e/mfe_e.py new file mode 100644 index 0000000..ca639bb --- /dev/null +++ b/materials/mfe_e/mfe_e.py @@ -0,0 +1,4241 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +This experiment was created using PsychoPy3 Experiment Builder (v2022.2.2), + on Thu Aug 29 00:38:26 2024 +If you publish work using this script the most relevant publication is: + + Peirce J, Gray JR, Simpson S, MacAskill M, Höchenberger R, Sogo H, Kastman E, Lindeløv JK. (2019) + PsychoPy2: Experiments in behavior made easy Behav Res 51: 195. + https://doi.org/10.3758/s13428-018-01193-y + +""" + +# --- Import packages --- +from psychopy import locale_setup +from psychopy import prefs +from psychopy import sound, gui, visual, core, data, event, logging, clock, colors, layout +from psychopy.constants import (NOT_STARTED, STARTED, PLAYING, PAUSED, + STOPPED, FINISHED, PRESSED, RELEASED, FOREVER) + +import numpy as np # whole numpy lib is available, prepend 'np.' +from numpy import (sin, cos, tan, log, log10, pi, average, + sqrt, std, deg2rad, rad2deg, linspace, asarray) +from numpy.random import random, randint, normal, shuffle, choice as randchoice +import os # handy system and path functions +import sys # to get file system encoding + +import psychopy.iohub as io +from psychopy.hardware import keyboard + +# Run 'Before Experiment' code from code_6 +# This code will load 8 surprise csv files and then randomly shuffle contents of each column and then saves them. +import os +import numpy as np +import pandas as pd +import pathlib + +# Make a list of files that we need to load +# get the current working directory +current_working_directory = os.getcwd() +input_path = pathlib.Path(current_working_directory) +# input_path = pathlib.Path("/Users/kihossei/Documents/GitHub/mfe_c_face/materials/PsychopyTask/mfe_c_face") +files_list = list(input_path.glob("orig_surp_table*")) +i = 0 # counter that will be used for saved file names + +for item in files_list: + csvFile = pd.read_csv(item) + csvFile['old_face_in_surp'] = np.random.permutation(csvFile['old_face_in_surp'].values) # shuffles rows in this column randomly + csvFile['new_face_in_surp'] = np.random.permutation(csvFile['new_face_in_surp'].values) # shuffles rows in this column randomly + csvFile['which_side_old_face_displayed'] = np.random.permutation(csvFile['which_side_old_face_displayed'].values) # shuffles rows in this column randomly + # saving the dataframe without row number + # Get the current name of the file + current_name = item.name + # Get the new name of the file + i = i + 1 + new_name = "surp_table{0}.csv".format(i) + # Rename the file + new_item = pathlib.Path.joinpath(item.parent, new_name) + csvFile.to_csv(new_item, index = False) + + + + +# Ensure that relative paths start from the same directory as this script +_thisDir = os.path.dirname(os.path.abspath(__file__)) +os.chdir(_thisDir) +# Store info about the experiment session +psychopyVersion = '2022.2.2' +expName = 'mfe_d' # from the Builder filename that created this script +expInfo = { + 'id': '', +} +# --- Show participant info dialog -- +dlg = gui.DlgFromDict(dictionary=expInfo, sortKeys=False, title=expName) +if dlg.OK == False: + core.quit() # user pressed cancel +expInfo['date'] = data.getDateStr() # add a simple timestamp +expInfo['expName'] = expName +expInfo['psychopyVersion'] = psychopyVersion + +# Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc +filename = _thisDir + os.sep + u'data/%s_%s_%s' % (expInfo['id'], expName, expInfo['date']) + +# An ExperimentHandler isn't essential but helps with data saving +thisExp = data.ExperimentHandler(name=expName, version='', + extraInfo=expInfo, runtimeInfo=None, + originPath='/Users/kihossei/Documents/GitHub/mfe_d/materials/PsychopyTask/mfe_d/mfe_d.py', + savePickle=True, saveWideText=True, + dataFileName=filename) +# save a log file for detail verbose info +logFile = logging.LogFile(filename+'.log', level=logging.DEBUG) +logging.console.setLevel(logging.WARNING) # this outputs to the screen, not a file + +endExpNow = False # flag for 'escape' or other condition => quit the exp +frameTolerance = 0.001 # how close to onset before 'same' frame + +# Start Code - component code to be run after the window creation + +# --- Setup the Window --- +win = visual.Window( + size=[1440, 900], fullscr=True, screen=0, + winType='pyglet', allowStencil=False, + monitor='dm_200a', color='0.5000, 0.5000, 0.5000', colorSpace='rgb', + blendMode='avg', useFBO=True, + units='height') +win.mouseVisible = False +# store frame rate of monitor if we can measure it +expInfo['frameRate'] = win.getActualFrameRate() +if expInfo['frameRate'] != None: + frameDur = 1.0 / round(expInfo['frameRate']) +else: + frameDur = 1.0 / 60.0 # could not measure, so guess +# --- Setup input devices --- +ioConfig = {} + +# Setup iohub keyboard +ioConfig['Keyboard'] = dict(use_keymap='psychopy') + +ioSession = '1' +if 'session' in expInfo: + ioSession = str(expInfo['session']) +ioServer = io.launchHubServer(window=win, **ioConfig) +eyetracker = None + +# create a default keyboard (e.g. to check for escape) +defaultKeyboard = keyboard.Keyboard(backend='iohub') + +# --- Initialize components for Routine "JS_code" --- + +# --- Initialize components for Routine "setup" --- +# Run 'Begin Experiment' code from setup_code + + +win.mouseVisible = False #hide mouse cursor + + +# --- Initialize components for Routine "welcome" --- +welcome_text = visual.TextStim(win=win, name='welcome_text', + text="Arrow Game\n\nWelcome to the arrow game. In this game, arrows will be quickly flashed on the screen. Your goal is to respond to the direction of the MIDDLE arrow, and to respond as quickly as you can without making mistakes. \n\nIf the MIDDLE arrow is pointing to the right, use your right hand to press the 'K' key on your keyboard. If the MIDDLE arrow is pointing to the left, use your left hand to press the 'S' key on your keyboard. \n\nPress the 'K' key to continue\n", + font='Arial', + units='height', pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +welcome_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "instructRight" --- +instructRight_text = visual.TextStim(win=win, name='instructRight_text', + text="Below, the MIDDLE arrow is pointing to the right, so you would respond by pressing the 'K' key on your keyboard with your right hand.\n\nPress the 'K' key to continue", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +instructRight_centerImg = visual.ImageStim( + win=win, + name='instructRight_centerImg', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(0, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-1.0) +instructRight_rightImg1 = visual.ImageStim( + win=win, + name='instructRight_rightImg1', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +instructRight_leftImg1 = visual.ImageStim( + win=win, + name='instructRight_leftImg1', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(-.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +instructRight_rightImg2 = visual.ImageStim( + win=win, + name='instructRight_rightImg2', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +instructRight_leftImg2 = visual.ImageStim( + win=win, + name='instructRight_leftImg2', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(-.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +insructRight_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "instructLeft" --- +instructLeft_text = visual.TextStim(win=win, name='instructLeft_text', + text="Below, the MIDDLE arrow is pointing to the left, so you would respond by pressing the 'S' key on your keyboard with your left hand.\n\nPress the 'S' key to continue", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +instructLeft_centerImg = visual.ImageStim( + win=win, + name='instructLeft_centerImg', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(0, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-1.0) +instructLeft_rightImg1 = visual.ImageStim( + win=win, + name='instructLeft_rightImg1', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +instructLeft_leftImg1 = visual.ImageStim( + win=win, + name='instructLeft_leftImg1', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(-.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +instructLeft_rightImg2 = visual.ImageStim( + win=win, + name='instructLeft_rightImg2', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +instructLeft_leftImg2 = visual.ImageStim( + win=win, + name='instructLeft_leftImg2', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(-.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +instructLeft_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "instructInconRight" --- +instructInconRight_text = visual.TextStim(win=win, name='instructInconRight_text', + text="Sometimes the MIDDLE arrow will point in a different direction from the other arrows. However, your goal is to always respond based on the direction of the MIDDLE arrow.\n\nBelow, the MIDDLE arrow is pointing to the right, so you would respond by pressing the 'K' key on your keyboard with your right hand.\n\nPress the 'K' key to continue", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +instructIncon_centerImg = visual.ImageStim( + win=win, + name='instructIncon_centerImg', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(0, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-1.0) +instructIncon_rightImg1 = visual.ImageStim( + win=win, + name='instructIncon_rightImg1', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +instructIncon_leftImg1 = visual.ImageStim( + win=win, + name='instructIncon_leftImg1', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(-.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +instructIncon_leftImg2 = visual.ImageStim( + win=win, + name='instructIncon_leftImg2', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(-.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +instructIncon_rightImg2 = visual.ImageStim( + win=win, + name='instructIncon_rightImg2', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +insructInconRight_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "instructInconLeft" --- +instructInconLeft_text = visual.TextStim(win=win, name='instructInconLeft_text', + text="Below, the MIDDLE arrow is pointing to the left, so you would respond by pressing the 'S' key on your keyboard with your left hand.\n\n\nPress the 'S' key to continue", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +instructInconLeft_centerImg = visual.ImageStim( + win=win, + name='instructInconLeft_centerImg', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(0, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-1.0) +instructInconLeft_rightImg1 = visual.ImageStim( + win=win, + name='instructInconLeft_rightImg1', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +instructInconLeft_leftImg1 = visual.ImageStim( + win=win, + name='instructInconLeft_leftImg1', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(-.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +instructInconLeft_rightImg2 = visual.ImageStim( + win=win, + name='instructInconLeft_rightImg2', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +instructInconLeft_leftImg2 = visual.ImageStim( + win=win, + name='instructInconLeft_leftImg2', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(-.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +instructInconLeft_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "prac_blockReminders" --- +# Run 'Begin Experiment' code from prac_initAcc_code +#initialize the following variables at the start of experiment +trialNum = 0 +accuracy = 0 +numCorr = 0 +blockAcc = 0 +prac_blockText = visual.TextStim(win=win, name='prac_blockText', + text='Practice', + font='Arial', + pos=(0, .3), height=0.06, wrapWidth=1.3, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +prac_reminder_text = visual.TextStim(win=win, name='prac_reminder_text', + text="You will now practice responding to the arrows. Remember to always respond to the direction of the MIDDLE arrow.\n\nRespond as quickly as you can without making mistakes.\n\nTo get ready, rest your right and left index fingers on the 'K' and 'S' keys of your keyboard, then press the 'K' key when you are ready to begin.\n", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-2.0); +prac_reminder_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "initFixation" --- +initFixation_img = visual.ImageStim( + win=win, + name='initFixation_img', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=0.0) + +# --- Initialize components for Routine "prac_stimRoutine" --- +# Run 'Begin Experiment' code from prac_isi_code +#initialize the thisISI variable +thisISI = 0 +bigFace = visual.ImageStim( + win=win, + name='bigFace', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=(0., 0.0), size=(13.59, 9.55), + color=[1,1,1], colorSpace='rgb', opacity=0.85, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-1.0) +cover_background_2 = visual.ImageStim( + win=win, + name='cover_background_2', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=None, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-2.0) +prac_centerImg = visual.ImageStim( + win=win, + name='prac_centerImg', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +prac_rightImg1 = visual.ImageStim( + win=win, + name='prac_rightImg1', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +prac_rightImg2 = visual.ImageStim( + win=win, + name='prac_rightImg2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +prac_leftImg1 = visual.ImageStim( + win=win, + name='prac_leftImg1', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-6.0) +prac_leftImg2 = visual.ImageStim( + win=win, + name='prac_leftImg2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-7.0) +prac_fixImg = visual.ImageStim( + win=win, + name='prac_fixImg', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-8.0) +prac_stim_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "prac_blockFeed" --- +prac_blockFeed_text = visual.TextStim(win=win, name='prac_blockFeed_text', + text='', + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-1.0); +prac_pressContinue = visual.TextStim(win=win, name='prac_pressContinue', + text="Press the 'K' key", + font='Arial', + pos=(0, -.3), height=0.04, wrapWidth=1.3, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-2.0); +prac_blockFeed_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "ringBell" --- +ringBell_text = visual.TextStim(win=win, name='ringBell_text', + text='Ring the bell to let the experimenter know that you finished the practice.', + font='Open Sans', + pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +bellKey = keyboard.Keyboard() + +# --- Initialize components for Routine "task_blockReminders" --- +# Run 'Begin Experiment' code from task_blockReminder_code +#initialize the following variables at the start of experiment +blockCounter = 0 + +#note that we do not need to initialize the accuracy and numCorr vars here +#because they were already initialilzed in the code snippet of the practice loop +task_blockText = visual.TextStim(win=win, name='task_blockText', + text='', + font='Arial', + pos=(0, .3), height=0.06, wrapWidth=1.3, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +task_blockReminders_text = visual.TextStim(win=win, name='task_blockReminders_text', + text="Remember to always respond to the direction of the MIDDLE arrow.\n\nRespond as quickly as you can without making mistakes.\n\nTo get ready, rest your right and left index fingers on the 'K' and 'S' keys of your keyboard, then press the 'K' key when you are ready to begin.\n\n", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-2.0); +task_blockReminders_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "initFixation" --- +initFixation_img = visual.ImageStim( + win=win, + name='initFixation_img', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=0.0) + +# --- Initialize components for Routine "task_stimRoutine" --- +# Run 'Begin Experiment' code from task_isi_code +#no need to initialize thisISI, as already done in practice code snippit +bigFace_2 = visual.ImageStim( + win=win, + name='bigFace_2', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=(0, 0.0), size=(13.59, 9.55), + color=[1,1,1], colorSpace='rgb', opacity=0.85, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-1.0) +cover_background = visual.ImageStim( + win=win, + name='cover_background', units='deg', + image='img/cover_background.png', mask=None, anchor='center', + ori=0.0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=None, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-2.0) +task_centerImg = visual.ImageStim( + win=win, + name='task_centerImg', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +task_rightImg1 = visual.ImageStim( + win=win, + name='task_rightImg1', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +task_rightImg2 = visual.ImageStim( + win=win, + name='task_rightImg2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +task_leftImg1 = visual.ImageStim( + win=win, + name='task_leftImg1', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-6.0) +task_leftImg2 = visual.ImageStim( + win=win, + name='task_leftImg2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-7.0) +task_fixImg = visual.ImageStim( + win=win, + name='task_fixImg', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-8.0) +task1_stim_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "task_blockFeed" --- +task_blockFeed_text = visual.TextStim(win=win, name='task_blockFeed_text', + text='', + font='Arial', + pos=(0, 0.1), height=0.12, wrapWidth=1.8, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-1.0); +task_blockFeed_text2 = visual.TextStim(win=win, name='task_blockFeed_text2', + text='', + font='Arial', + pos=(0, -0.3), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-2.0); +task_blockFeed_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "ringBell2" --- +ringBell_text_2 = visual.TextStim(win=win, name='ringBell_text_2', + text='Please ring the bell to let the experimenter know you finished the game.', + font='Open Sans', + pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +bellKey_2 = keyboard.Keyboard() + +# --- Initialize components for Routine "errorNumbers" --- +errorNumbers_text_2 = visual.TextStim(win=win, name='errorNumbers_text_2', + text="Excluding the practice, How many errors do you think you made in this game?\n\nPlease provide a number as your best estimate.\n\n\nPlease enter your answer using the keyboard. \nAfter entering your answer, press the 'Space' key to continue", + font='Open Sans', + pos=(0, 0.12), height=0.03, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +errorNum_text_box = visual.TextBox2( + win, text=None, font='Open Sans', + pos=(0, -0.3), letterHeight=0.05, + size=(0.2, 0.2), borderWidth=2.0, + color=[-1.0000, -1.0000, -1.0000], colorSpace='rgb', + opacity=None, + bold=True, italic=False, + lineSpacing=1.0, + padding=0.0, alignment='center', + anchor='bottom-center', + fillColor=[1.0000, 1.0000, 1.0000], borderColor=[-1.0000, -1.0000, -1.0000], + flipHoriz=False, flipVert=False, languageStyle='LTR', + editable=True, + name='errorNum_text_box', + autoLog=True, +) +errorN_key_resp_2 = keyboard.Keyboard() + +# --- Initialize components for Routine "errorPercentage" --- +errorNumbers_text_3 = visual.TextStim(win=win, name='errorNumbers_text_3', + text="Excluding the practice, what percentage of your responses do you think were errors during the arrow game? \n\nPlease provide a number as your best estimate.\n\nPlease enter your answer using the keyboard. \nAfter entering your answer, press the 'Space' key to continue", + font='Open Sans', + pos=(0, 0.12), height=0.03, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +errorPercent_text_box = visual.TextBox2( + win, text=None, font='Open Sans', + pos=(0, -0.3), letterHeight=0.05, + size=(0.2, 0.2), borderWidth=2.0, + color=[-1.0000, -1.0000, -1.0000], colorSpace='rgb', + opacity=None, + bold=True, italic=False, + lineSpacing=1.0, + padding=0.0, alignment='center', + anchor='bottom-center', + fillColor=[1.0000, 1.0000, 1.0000], borderColor=[-1.0000, -1.0000, -1.0000], + flipHoriz=False, flipVert=False, languageStyle='LTR', + editable=True, + name='errorPercent_text_box', + autoLog=True, +) +errorN_key_resp_3 = keyboard.Keyboard() + +# --- Initialize components for Routine "botherRate" --- +botherRate_text = visual.TextStim(win=win, name='botherRate_text', + text="How much did it bother you when you made an error during the arrow game? \n\nYour answer should be on a scale from 0 (not at all) to 10 (very much). \n\n\nPlease enter your answer using the keyboard. \nAfter entering your answer, press the 'Space' key to continue", + font='Open Sans', + pos=(0, 0.12), height=0.03, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +bother_text_box = visual.TextBox2( + win, text=None, font='Open Sans', + pos=(0, -0.3), letterHeight=0.05, + size=(0.2, 0.2), borderWidth=2.0, + color=[-1.0000, -1.0000, -1.0000], colorSpace='rgb', + opacity=None, + bold=True, italic=False, + lineSpacing=1.0, + padding=0.0, alignment='center', + anchor='bottom-center', + fillColor=[1.0000, 1.0000, 1.0000], borderColor=[-1.0000, -1.0000, -1.0000], + flipHoriz=False, flipVert=False, languageStyle='LTR', + editable=True, + name='bother_text_box', + autoLog=True, +) +botherRate_key_resp = keyboard.Keyboard() + +# --- Initialize components for Routine "ringBell3" --- +ringBell_text_3 = visual.TextStim(win=win, name='ringBell_text_3', + text='Ring the bell to let the experimenter know when you complete answering the surveys.', + font='Open Sans', + pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +bellKey_3 = keyboard.Keyboard() + +# --- Initialize components for Routine "surpriseInstruct" --- +instruct_surprise1 = visual.TextStim(win=win, name='instruct_surprise1', + text='You will now begin a task in which you will be shown two images of faces. Then, you need to choose the face image that you think you have seen in the previous Arrow game (old face).\n\nFor example:\n\nIf the face image on the right side is the one you think you have seen in the Arrow game, press the K key.\n\nIf the face image on the left side is the one you think you have seen in the Arrow game, press the S key.\n\nPlease press the K key to continue.', + font='Open Sans', + pos=(0, 0), height=0.04, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +instruct_surp1_key_resp = keyboard.Keyboard() + +# --- Initialize components for Routine "surp_taskReminders" --- +# Run 'Begin Experiment' code from task_blockReminder_code_2 +#initialize the following variables at the start of experiment +blockCounterZ1 = 0 +blockNumText = "" + +text_2 = visual.TextStim(win=win, name='text_2', + text='', + font='Open Sans', + pos=(0, .3), height=0.06, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +task_blockText_2 = visual.TextStim(win=win, name='task_blockText_2', + text='', + font='Open Sans', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-2.0); +task_blockReminders_keyResp_2 = keyboard.Keyboard() + +# --- Initialize components for Routine "fixation2" --- +polygon = visual.ShapeStim( + win=win, name='polygon', vertices='cross', + size=(0.05, 0.05), + ori=0.0, pos=(0, 0), anchor='center', + lineWidth=1.0, colorSpace='rgb', lineColor='white', fillColor='white', + opacity=None, depth=-1.0, interpolate=True) + +# --- Initialize components for Routine "surpriseTask" --- +# Run 'Begin Experiment' code from code_6 +old_img_position = [0, 0] +new_img_position = [0, 0] +text = visual.TextStim(win=win, name='text', + text='Choose the face you have seen before (old)', + font='Open Sans', + units='deg', pos=(0, 10), height=1.5, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +old_face_image = visual.ImageStim( + win=win, + name='old_face_image', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=[0,0], size=(13.59, 9.55), + color=[1,1,1], colorSpace='rgb', opacity=None, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-2.0) +new_face_image = visual.ImageStim( + win=win, + name='new_face_image', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=[0,0], size=(13.59, 9.55), + color=[1,1,1], colorSpace='rgb', opacity=None, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-3.0) +instructsurpA1_right = visual.TextStim(win=win, name='instructsurpA1_right', + text='', + font='Open Sans', + units='deg', pos=[0,0], height=1.2, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-4.0); +instructsurpA2_left = visual.TextStim(win=win, name='instructsurpA2_left', + text='', + font='Open Sans', + units='deg', pos=(-13.3, -5), height=1.2, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-5.0); +surprise_key_resp = keyboard.Keyboard() + +# --- Initialize components for Routine "fixation2" --- +polygon = visual.ShapeStim( + win=win, name='polygon', vertices='cross', + size=(0.05, 0.05), + ori=0.0, pos=(0, 0), anchor='center', + lineWidth=1.0, colorSpace='rgb', lineColor='white', fillColor='white', + opacity=None, depth=-1.0, interpolate=True) + +# --- Initialize components for Routine "ringBell4" --- +ringBell_text_4 = visual.TextStim(win=win, name='ringBell_text_4', + text='Ring the bell to let the experimenter know you completed the game.', + font='Open Sans', + pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +bellKey_4 = keyboard.Keyboard() + +# --- Initialize components for Routine "finishMessage" --- +finishMessage_text = visual.TextStim(win=win, name='finishMessage_text', + text='Thank you for your participation!', + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); + +# Create some handy timers +globalClock = core.Clock() # to track the time since experiment started +routineTimer = core.Clock() # to track time remaining of each (possibly non-slip) routine + +# --- Prepare to start Routine "JS_code" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# keep track of which components have finished +JS_codeComponents = [] +for thisComponent in JS_codeComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "JS_code" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in JS_codeComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "JS_code" --- +for thisComponent in JS_codeComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "JS_code" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "setup" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# keep track of which components have finished +setupComponents = [] +for thisComponent in setupComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "setup" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in setupComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "setup" --- +for thisComponent in setupComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "setup" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "welcome" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +welcome_keyResp.keys = [] +welcome_keyResp.rt = [] +_welcome_keyResp_allKeys = [] +# keep track of which components have finished +welcomeComponents = [welcome_text, welcome_keyResp] +for thisComponent in welcomeComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "welcome" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *welcome_text* updates + if welcome_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + welcome_text.frameNStart = frameN # exact frame index + welcome_text.tStart = t # local t and not account for scr refresh + welcome_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(welcome_text, 'tStartRefresh') # time at next scr refresh + welcome_text.setAutoDraw(True) + + # *welcome_keyResp* updates + waitOnFlip = False + if welcome_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + welcome_keyResp.frameNStart = frameN # exact frame index + welcome_keyResp.tStart = t # local t and not account for scr refresh + welcome_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(welcome_keyResp, 'tStartRefresh') # time at next scr refresh + welcome_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(welcome_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(welcome_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if welcome_keyResp.status == STARTED and not waitOnFlip: + theseKeys = welcome_keyResp.getKeys(keyList=['k'], waitRelease=False) + _welcome_keyResp_allKeys.extend(theseKeys) + if len(_welcome_keyResp_allKeys): + welcome_keyResp.keys = _welcome_keyResp_allKeys[-1].name # just the last key pressed + welcome_keyResp.rt = _welcome_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in welcomeComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "welcome" --- +for thisComponent in welcomeComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "welcome" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "instructRight" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +insructRight_keyResp.keys = [] +insructRight_keyResp.rt = [] +_insructRight_keyResp_allKeys = [] +# keep track of which components have finished +instructRightComponents = [instructRight_text, instructRight_centerImg, instructRight_rightImg1, instructRight_leftImg1, instructRight_rightImg2, instructRight_leftImg2, insructRight_keyResp] +for thisComponent in instructRightComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "instructRight" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instructRight_text* updates + if instructRight_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_text.frameNStart = frameN # exact frame index + instructRight_text.tStart = t # local t and not account for scr refresh + instructRight_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_text, 'tStartRefresh') # time at next scr refresh + instructRight_text.setAutoDraw(True) + + # *instructRight_centerImg* updates + if instructRight_centerImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_centerImg.frameNStart = frameN # exact frame index + instructRight_centerImg.tStart = t # local t and not account for scr refresh + instructRight_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_centerImg, 'tStartRefresh') # time at next scr refresh + instructRight_centerImg.setAutoDraw(True) + + # *instructRight_rightImg1* updates + if instructRight_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_rightImg1.frameNStart = frameN # exact frame index + instructRight_rightImg1.tStart = t # local t and not account for scr refresh + instructRight_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_rightImg1, 'tStartRefresh') # time at next scr refresh + instructRight_rightImg1.setAutoDraw(True) + + # *instructRight_leftImg1* updates + if instructRight_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_leftImg1.frameNStart = frameN # exact frame index + instructRight_leftImg1.tStart = t # local t and not account for scr refresh + instructRight_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_leftImg1, 'tStartRefresh') # time at next scr refresh + instructRight_leftImg1.setAutoDraw(True) + + # *instructRight_rightImg2* updates + if instructRight_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_rightImg2.frameNStart = frameN # exact frame index + instructRight_rightImg2.tStart = t # local t and not account for scr refresh + instructRight_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_rightImg2, 'tStartRefresh') # time at next scr refresh + instructRight_rightImg2.setAutoDraw(True) + + # *instructRight_leftImg2* updates + if instructRight_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_leftImg2.frameNStart = frameN # exact frame index + instructRight_leftImg2.tStart = t # local t and not account for scr refresh + instructRight_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_leftImg2, 'tStartRefresh') # time at next scr refresh + instructRight_leftImg2.setAutoDraw(True) + + # *insructRight_keyResp* updates + waitOnFlip = False + if insructRight_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + insructRight_keyResp.frameNStart = frameN # exact frame index + insructRight_keyResp.tStart = t # local t and not account for scr refresh + insructRight_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(insructRight_keyResp, 'tStartRefresh') # time at next scr refresh + insructRight_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(insructRight_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(insructRight_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if insructRight_keyResp.status == STARTED and not waitOnFlip: + theseKeys = insructRight_keyResp.getKeys(keyList=['k'], waitRelease=False) + _insructRight_keyResp_allKeys.extend(theseKeys) + if len(_insructRight_keyResp_allKeys): + insructRight_keyResp.keys = _insructRight_keyResp_allKeys[-1].name # just the last key pressed + insructRight_keyResp.rt = _insructRight_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in instructRightComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "instructRight" --- +for thisComponent in instructRightComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "instructRight" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "instructLeft" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +instructLeft_keyResp.keys = [] +instructLeft_keyResp.rt = [] +_instructLeft_keyResp_allKeys = [] +# keep track of which components have finished +instructLeftComponents = [instructLeft_text, instructLeft_centerImg, instructLeft_rightImg1, instructLeft_leftImg1, instructLeft_rightImg2, instructLeft_leftImg2, instructLeft_keyResp] +for thisComponent in instructLeftComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "instructLeft" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instructLeft_text* updates + if instructLeft_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_text.frameNStart = frameN # exact frame index + instructLeft_text.tStart = t # local t and not account for scr refresh + instructLeft_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_text, 'tStartRefresh') # time at next scr refresh + instructLeft_text.setAutoDraw(True) + + # *instructLeft_centerImg* updates + if instructLeft_centerImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_centerImg.frameNStart = frameN # exact frame index + instructLeft_centerImg.tStart = t # local t and not account for scr refresh + instructLeft_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_centerImg, 'tStartRefresh') # time at next scr refresh + instructLeft_centerImg.setAutoDraw(True) + + # *instructLeft_rightImg1* updates + if instructLeft_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_rightImg1.frameNStart = frameN # exact frame index + instructLeft_rightImg1.tStart = t # local t and not account for scr refresh + instructLeft_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_rightImg1, 'tStartRefresh') # time at next scr refresh + instructLeft_rightImg1.setAutoDraw(True) + + # *instructLeft_leftImg1* updates + if instructLeft_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_leftImg1.frameNStart = frameN # exact frame index + instructLeft_leftImg1.tStart = t # local t and not account for scr refresh + instructLeft_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_leftImg1, 'tStartRefresh') # time at next scr refresh + instructLeft_leftImg1.setAutoDraw(True) + + # *instructLeft_rightImg2* updates + if instructLeft_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_rightImg2.frameNStart = frameN # exact frame index + instructLeft_rightImg2.tStart = t # local t and not account for scr refresh + instructLeft_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_rightImg2, 'tStartRefresh') # time at next scr refresh + instructLeft_rightImg2.setAutoDraw(True) + + # *instructLeft_leftImg2* updates + if instructLeft_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_leftImg2.frameNStart = frameN # exact frame index + instructLeft_leftImg2.tStart = t # local t and not account for scr refresh + instructLeft_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_leftImg2, 'tStartRefresh') # time at next scr refresh + instructLeft_leftImg2.setAutoDraw(True) + + # *instructLeft_keyResp* updates + waitOnFlip = False + if instructLeft_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_keyResp.frameNStart = frameN # exact frame index + instructLeft_keyResp.tStart = t # local t and not account for scr refresh + instructLeft_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_keyResp, 'tStartRefresh') # time at next scr refresh + instructLeft_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(instructLeft_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(instructLeft_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if instructLeft_keyResp.status == STARTED and not waitOnFlip: + theseKeys = instructLeft_keyResp.getKeys(keyList=['s'], waitRelease=False) + _instructLeft_keyResp_allKeys.extend(theseKeys) + if len(_instructLeft_keyResp_allKeys): + instructLeft_keyResp.keys = _instructLeft_keyResp_allKeys[-1].name # just the last key pressed + instructLeft_keyResp.rt = _instructLeft_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in instructLeftComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "instructLeft" --- +for thisComponent in instructLeftComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "instructLeft" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "instructInconRight" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +insructInconRight_keyResp.keys = [] +insructInconRight_keyResp.rt = [] +_insructInconRight_keyResp_allKeys = [] +# keep track of which components have finished +instructInconRightComponents = [instructInconRight_text, instructIncon_centerImg, instructIncon_rightImg1, instructIncon_leftImg1, instructIncon_leftImg2, instructIncon_rightImg2, insructInconRight_keyResp] +for thisComponent in instructInconRightComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "instructInconRight" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instructInconRight_text* updates + if instructInconRight_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconRight_text.frameNStart = frameN # exact frame index + instructInconRight_text.tStart = t # local t and not account for scr refresh + instructInconRight_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconRight_text, 'tStartRefresh') # time at next scr refresh + instructInconRight_text.setAutoDraw(True) + + # *instructIncon_centerImg* updates + if instructIncon_centerImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_centerImg.frameNStart = frameN # exact frame index + instructIncon_centerImg.tStart = t # local t and not account for scr refresh + instructIncon_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_centerImg, 'tStartRefresh') # time at next scr refresh + instructIncon_centerImg.setAutoDraw(True) + + # *instructIncon_rightImg1* updates + if instructIncon_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_rightImg1.frameNStart = frameN # exact frame index + instructIncon_rightImg1.tStart = t # local t and not account for scr refresh + instructIncon_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_rightImg1, 'tStartRefresh') # time at next scr refresh + instructIncon_rightImg1.setAutoDraw(True) + + # *instructIncon_leftImg1* updates + if instructIncon_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_leftImg1.frameNStart = frameN # exact frame index + instructIncon_leftImg1.tStart = t # local t and not account for scr refresh + instructIncon_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_leftImg1, 'tStartRefresh') # time at next scr refresh + instructIncon_leftImg1.setAutoDraw(True) + + # *instructIncon_leftImg2* updates + if instructIncon_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_leftImg2.frameNStart = frameN # exact frame index + instructIncon_leftImg2.tStart = t # local t and not account for scr refresh + instructIncon_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_leftImg2, 'tStartRefresh') # time at next scr refresh + instructIncon_leftImg2.setAutoDraw(True) + + # *instructIncon_rightImg2* updates + if instructIncon_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_rightImg2.frameNStart = frameN # exact frame index + instructIncon_rightImg2.tStart = t # local t and not account for scr refresh + instructIncon_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_rightImg2, 'tStartRefresh') # time at next scr refresh + instructIncon_rightImg2.setAutoDraw(True) + + # *insructInconRight_keyResp* updates + waitOnFlip = False + if insructInconRight_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + insructInconRight_keyResp.frameNStart = frameN # exact frame index + insructInconRight_keyResp.tStart = t # local t and not account for scr refresh + insructInconRight_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(insructInconRight_keyResp, 'tStartRefresh') # time at next scr refresh + insructInconRight_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(insructInconRight_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(insructInconRight_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if insructInconRight_keyResp.status == STARTED and not waitOnFlip: + theseKeys = insructInconRight_keyResp.getKeys(keyList=['k'], waitRelease=False) + _insructInconRight_keyResp_allKeys.extend(theseKeys) + if len(_insructInconRight_keyResp_allKeys): + insructInconRight_keyResp.keys = _insructInconRight_keyResp_allKeys[-1].name # just the last key pressed + insructInconRight_keyResp.rt = _insructInconRight_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in instructInconRightComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "instructInconRight" --- +for thisComponent in instructInconRightComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "instructInconRight" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "instructInconLeft" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +instructInconLeft_keyResp.keys = [] +instructInconLeft_keyResp.rt = [] +_instructInconLeft_keyResp_allKeys = [] +# keep track of which components have finished +instructInconLeftComponents = [instructInconLeft_text, instructInconLeft_centerImg, instructInconLeft_rightImg1, instructInconLeft_leftImg1, instructInconLeft_rightImg2, instructInconLeft_leftImg2, instructInconLeft_keyResp] +for thisComponent in instructInconLeftComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "instructInconLeft" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instructInconLeft_text* updates + if instructInconLeft_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_text.frameNStart = frameN # exact frame index + instructInconLeft_text.tStart = t # local t and not account for scr refresh + instructInconLeft_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_text, 'tStartRefresh') # time at next scr refresh + instructInconLeft_text.setAutoDraw(True) + + # *instructInconLeft_centerImg* updates + if instructInconLeft_centerImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_centerImg.frameNStart = frameN # exact frame index + instructInconLeft_centerImg.tStart = t # local t and not account for scr refresh + instructInconLeft_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_centerImg, 'tStartRefresh') # time at next scr refresh + instructInconLeft_centerImg.setAutoDraw(True) + + # *instructInconLeft_rightImg1* updates + if instructInconLeft_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_rightImg1.frameNStart = frameN # exact frame index + instructInconLeft_rightImg1.tStart = t # local t and not account for scr refresh + instructInconLeft_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_rightImg1, 'tStartRefresh') # time at next scr refresh + instructInconLeft_rightImg1.setAutoDraw(True) + + # *instructInconLeft_leftImg1* updates + if instructInconLeft_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_leftImg1.frameNStart = frameN # exact frame index + instructInconLeft_leftImg1.tStart = t # local t and not account for scr refresh + instructInconLeft_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_leftImg1, 'tStartRefresh') # time at next scr refresh + instructInconLeft_leftImg1.setAutoDraw(True) + + # *instructInconLeft_rightImg2* updates + if instructInconLeft_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_rightImg2.frameNStart = frameN # exact frame index + instructInconLeft_rightImg2.tStart = t # local t and not account for scr refresh + instructInconLeft_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_rightImg2, 'tStartRefresh') # time at next scr refresh + instructInconLeft_rightImg2.setAutoDraw(True) + + # *instructInconLeft_leftImg2* updates + if instructInconLeft_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_leftImg2.frameNStart = frameN # exact frame index + instructInconLeft_leftImg2.tStart = t # local t and not account for scr refresh + instructInconLeft_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_leftImg2, 'tStartRefresh') # time at next scr refresh + instructInconLeft_leftImg2.setAutoDraw(True) + + # *instructInconLeft_keyResp* updates + waitOnFlip = False + if instructInconLeft_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_keyResp.frameNStart = frameN # exact frame index + instructInconLeft_keyResp.tStart = t # local t and not account for scr refresh + instructInconLeft_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_keyResp, 'tStartRefresh') # time at next scr refresh + instructInconLeft_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(instructInconLeft_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(instructInconLeft_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if instructInconLeft_keyResp.status == STARTED and not waitOnFlip: + theseKeys = instructInconLeft_keyResp.getKeys(keyList=['s'], waitRelease=False) + _instructInconLeft_keyResp_allKeys.extend(theseKeys) + if len(_instructInconLeft_keyResp_allKeys): + instructInconLeft_keyResp.keys = _instructInconLeft_keyResp_allKeys[-1].name # just the last key pressed + instructInconLeft_keyResp.rt = _instructInconLeft_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in instructInconLeftComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "instructInconLeft" --- +for thisComponent in instructInconLeftComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "instructInconLeft" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# set up handler to look after randomisation of conditions etc +prac_block_loop = data.TrialHandler(nReps=999, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions('blockSelect_practice.csv'), + seed=None, name='prac_block_loop') +thisExp.addLoop(prac_block_loop) # add the loop to the experiment +thisPrac_block_loop = prac_block_loop.trialList[0] # so we can initialise stimuli with some values +# abbreviate parameter names if possible (e.g. rgb = thisPrac_block_loop.rgb) +if thisPrac_block_loop != None: + for paramName in thisPrac_block_loop: + exec('{} = thisPrac_block_loop[paramName]'.format(paramName)) + +for thisPrac_block_loop in prac_block_loop: + currentLoop = prac_block_loop + # abbreviate parameter names if possible (e.g. rgb = thisPrac_block_loop.rgb) + if thisPrac_block_loop != None: + for paramName in thisPrac_block_loop: + exec('{} = thisPrac_block_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "prac_blockReminders" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + prac_reminder_keyResp.keys = [] + prac_reminder_keyResp.rt = [] + _prac_reminder_keyResp_allKeys = [] + # keep track of which components have finished + prac_blockRemindersComponents = [prac_blockText, prac_reminder_text, prac_reminder_keyResp] + for thisComponent in prac_blockRemindersComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "prac_blockReminders" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *prac_blockText* updates + if prac_blockText.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_blockText.frameNStart = frameN # exact frame index + prac_blockText.tStart = t # local t and not account for scr refresh + prac_blockText.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_blockText, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_blockText.started') + prac_blockText.setAutoDraw(True) + + # *prac_reminder_text* updates + if prac_reminder_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_reminder_text.frameNStart = frameN # exact frame index + prac_reminder_text.tStart = t # local t and not account for scr refresh + prac_reminder_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_reminder_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_reminder_text.started') + prac_reminder_text.setAutoDraw(True) + + # *prac_reminder_keyResp* updates + waitOnFlip = False + if prac_reminder_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_reminder_keyResp.frameNStart = frameN # exact frame index + prac_reminder_keyResp.tStart = t # local t and not account for scr refresh + prac_reminder_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_reminder_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_reminder_keyResp.started') + prac_reminder_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(prac_reminder_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(prac_reminder_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if prac_reminder_keyResp.status == STARTED and not waitOnFlip: + theseKeys = prac_reminder_keyResp.getKeys(keyList=['k'], waitRelease=False) + _prac_reminder_keyResp_allKeys.extend(theseKeys) + if len(_prac_reminder_keyResp_allKeys): + prac_reminder_keyResp.keys = _prac_reminder_keyResp_allKeys[-1].name # just the last key pressed + prac_reminder_keyResp.rt = _prac_reminder_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in prac_blockRemindersComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "prac_blockReminders" --- + for thisComponent in prac_blockRemindersComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if prac_reminder_keyResp.keys in ['', [], None]: # No response was made + prac_reminder_keyResp.keys = None + prac_block_loop.addData('prac_reminder_keyResp.keys',prac_reminder_keyResp.keys) + if prac_reminder_keyResp.keys != None: # we had a response + prac_block_loop.addData('prac_reminder_keyResp.rt', prac_reminder_keyResp.rt) + # the Routine "prac_blockReminders" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # --- Prepare to start Routine "initFixation" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + initFixation_img.setImage('img/transp_fixation.png') + # keep track of which components have finished + initFixationComponents = [initFixation_img] + for thisComponent in initFixationComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "initFixation" --- + while continueRoutine and routineTimer.getTime() < 2.0: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *initFixation_img* updates + if initFixation_img.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + initFixation_img.frameNStart = frameN # exact frame index + initFixation_img.tStart = t # local t and not account for scr refresh + initFixation_img.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(initFixation_img, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'initFixation_img.started') + initFixation_img.setAutoDraw(True) + if initFixation_img.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > initFixation_img.tStartRefresh + 2-frameTolerance: + # keep track of stop time/frame for later + initFixation_img.tStop = t # not accounting for scr refresh + initFixation_img.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'initFixation_img.stopped') + initFixation_img.setAutoDraw(False) + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in initFixationComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "initFixation" --- + for thisComponent in initFixationComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # using non-slip timing so subtract the expected duration of this Routine (unless ended on request) + if routineForceEnded: + routineTimer.reset() + else: + routineTimer.addTime(-2.000000) + + # set up handler to look after randomisation of conditions etc + prac_trial_loop = data.TrialHandler(nReps=1, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions(whichBlock), + seed=None, name='prac_trial_loop') + thisExp.addLoop(prac_trial_loop) # add the loop to the experiment + thisPrac_trial_loop = prac_trial_loop.trialList[0] # so we can initialise stimuli with some values + # abbreviate parameter names if possible (e.g. rgb = thisPrac_trial_loop.rgb) + if thisPrac_trial_loop != None: + for paramName in thisPrac_trial_loop: + exec('{} = thisPrac_trial_loop[paramName]'.format(paramName)) + + for thisPrac_trial_loop in prac_trial_loop: + currentLoop = prac_trial_loop + # abbreviate parameter names if possible (e.g. rgb = thisPrac_trial_loop.rgb) + if thisPrac_trial_loop != None: + for paramName in thisPrac_trial_loop: + exec('{} = thisPrac_trial_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "prac_stimRoutine" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from prac_isi_code + # pick the ISI for the next routine + # this code component is set to 'both' because we need to remove the 'np' + # at the start of np.linspace (this is a python library JS won't know what to call. + + # make range from a to b in n stepsizes + ISIRange = np.linspace(3500, 4000, 500) + + # picking from a shuffled array is easier for random selection in JS + shuffle(ISIRange) + thisISI = ISIRange[0]/1000 # the first item of the shuffled array + + # save this ISI to our output file + prac_trial_loop.addData('ISI', thisISI) + + + # show in console for debugging + #print('thisISI: ', thisISI) + bigFace.setImage(straightFace) + cover_background_2.setImage('img/cover_background.png') + prac_centerImg.setPos((0, 0)) + prac_centerImg.setSize([1.03, 1.03]) + prac_centerImg.setImage(middleStim) + prac_rightImg1.setPos((1.22, 0)) + prac_rightImg1.setSize([1.03, 1.03]) + prac_rightImg1.setImage(rightStim) + prac_rightImg2.setPos([2.44,0]) + prac_rightImg2.setSize([1.03, 1.03]) + prac_rightImg2.setImage(rightStim) + prac_leftImg1.setPos((-1.22, 0)) + prac_leftImg1.setSize([1.03, 1.03]) + prac_leftImg1.setImage(leftStim) + prac_leftImg2.setPos([-2.44,0]) + prac_leftImg2.setSize([1.03, 1.03]) + prac_leftImg2.setImage(leftStim) + prac_fixImg.setImage('img/transp_fixation.png') + prac_stim_keyResp.keys = [] + prac_stim_keyResp.rt = [] + _prac_stim_keyResp_allKeys = [] + # keep track of which components have finished + prac_stimRoutineComponents = [bigFace, cover_background_2, prac_centerImg, prac_rightImg1, prac_rightImg2, prac_leftImg1, prac_leftImg2, prac_fixImg, prac_stim_keyResp] + for thisComponent in prac_stimRoutineComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "prac_stimRoutine" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *bigFace* updates + if bigFace.status == NOT_STARTED and 0.0: + # keep track of start time/frame for later + bigFace.frameNStart = frameN # exact frame index + bigFace.tStart = t # local t and not account for scr refresh + bigFace.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bigFace, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bigFace.started') + bigFace.setAutoDraw(True) + if bigFace.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > bigFace.tStartRefresh + thisISI-frameTolerance: + # keep track of stop time/frame for later + bigFace.tStop = t # not accounting for scr refresh + bigFace.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bigFace.stopped') + bigFace.setAutoDraw(False) + + # *cover_background_2* updates + if cover_background_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + cover_background_2.frameNStart = frameN # exact frame index + cover_background_2.tStart = t # local t and not account for scr refresh + cover_background_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(cover_background_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'cover_background_2.started') + cover_background_2.setAutoDraw(True) + if cover_background_2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > cover_background_2.tStartRefresh + 0.35-frameTolerance: + # keep track of stop time/frame for later + cover_background_2.tStop = t # not accounting for scr refresh + cover_background_2.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'cover_background_2.stopped') + cover_background_2.setAutoDraw(False) + + # *prac_centerImg* updates + if prac_centerImg.status == NOT_STARTED and tThisFlip >= 0.15-frameTolerance: + # keep track of start time/frame for later + prac_centerImg.frameNStart = frameN # exact frame index + prac_centerImg.tStart = t # local t and not account for scr refresh + prac_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_centerImg, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_centerImg.started') + prac_centerImg.setAutoDraw(True) + if prac_centerImg.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_centerImg.tStartRefresh + .2-frameTolerance: + # keep track of stop time/frame for later + prac_centerImg.tStop = t # not accounting for scr refresh + prac_centerImg.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_centerImg.stopped') + prac_centerImg.setAutoDraw(False) + + # *prac_rightImg1* updates + if prac_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_rightImg1.frameNStart = frameN # exact frame index + prac_rightImg1.tStart = t # local t and not account for scr refresh + prac_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_rightImg1, 'tStartRefresh') # time at next scr refresh + prac_rightImg1.setAutoDraw(True) + if prac_rightImg1.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_rightImg1.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + prac_rightImg1.tStop = t # not accounting for scr refresh + prac_rightImg1.frameNStop = frameN # exact frame index + prac_rightImg1.setAutoDraw(False) + + # *prac_rightImg2* updates + if prac_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_rightImg2.frameNStart = frameN # exact frame index + prac_rightImg2.tStart = t # local t and not account for scr refresh + prac_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_rightImg2, 'tStartRefresh') # time at next scr refresh + prac_rightImg2.setAutoDraw(True) + if prac_rightImg2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_rightImg2.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + prac_rightImg2.tStop = t # not accounting for scr refresh + prac_rightImg2.frameNStop = frameN # exact frame index + prac_rightImg2.setAutoDraw(False) + + # *prac_leftImg1* updates + if prac_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_leftImg1.frameNStart = frameN # exact frame index + prac_leftImg1.tStart = t # local t and not account for scr refresh + prac_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_leftImg1, 'tStartRefresh') # time at next scr refresh + prac_leftImg1.setAutoDraw(True) + if prac_leftImg1.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_leftImg1.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + prac_leftImg1.tStop = t # not accounting for scr refresh + prac_leftImg1.frameNStop = frameN # exact frame index + prac_leftImg1.setAutoDraw(False) + + # *prac_leftImg2* updates + if prac_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_leftImg2.frameNStart = frameN # exact frame index + prac_leftImg2.tStart = t # local t and not account for scr refresh + prac_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_leftImg2, 'tStartRefresh') # time at next scr refresh + prac_leftImg2.setAutoDraw(True) + if prac_leftImg2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_leftImg2.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + prac_leftImg2.tStop = t # not accounting for scr refresh + prac_leftImg2.frameNStop = frameN # exact frame index + prac_leftImg2.setAutoDraw(False) + + # *prac_fixImg* updates + if prac_fixImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_fixImg.frameNStart = frameN # exact frame index + prac_fixImg.tStart = t # local t and not account for scr refresh + prac_fixImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_fixImg, 'tStartRefresh') # time at next scr refresh + prac_fixImg.setAutoDraw(True) + if prac_fixImg.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_fixImg.tStartRefresh + thisISI-frameTolerance: + # keep track of stop time/frame for later + prac_fixImg.tStop = t # not accounting for scr refresh + prac_fixImg.frameNStop = frameN # exact frame index + prac_fixImg.setAutoDraw(False) + + # *prac_stim_keyResp* updates + waitOnFlip = False + if prac_stim_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_stim_keyResp.frameNStart = frameN # exact frame index + prac_stim_keyResp.tStart = t # local t and not account for scr refresh + prac_stim_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_stim_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_stim_keyResp.started') + prac_stim_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(prac_stim_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(prac_stim_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if prac_stim_keyResp.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_stim_keyResp.tStartRefresh + thisISI-frameTolerance: + # keep track of stop time/frame for later + prac_stim_keyResp.tStop = t # not accounting for scr refresh + prac_stim_keyResp.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_stim_keyResp.stopped') + prac_stim_keyResp.status = FINISHED + if prac_stim_keyResp.status == STARTED and not waitOnFlip: + theseKeys = prac_stim_keyResp.getKeys(keyList=['s','k'], waitRelease=False) + _prac_stim_keyResp_allKeys.extend(theseKeys) + if len(_prac_stim_keyResp_allKeys): + prac_stim_keyResp.keys = [key.name for key in _prac_stim_keyResp_allKeys] # storing all keys + prac_stim_keyResp.rt = [key.rt for key in _prac_stim_keyResp_allKeys] + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in prac_stimRoutineComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "prac_stimRoutine" --- + for thisComponent in prac_stimRoutineComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if prac_stim_keyResp.keys in ['', [], None]: # No response was made + prac_stim_keyResp.keys = None + prac_trial_loop.addData('prac_stim_keyResp.keys',prac_stim_keyResp.keys) + if prac_stim_keyResp.keys != None: # we had a response + prac_trial_loop.addData('prac_stim_keyResp.rt', prac_stim_keyResp.rt) + # Run 'End Routine' code from prac_accuracy_code + trialNum = trialNum + 1 #iterate trial number for this block + + if prac_stim_keyResp.keys: #if at least one response was made this trial + if prac_stim_keyResp.keys[0] == 's': #if the FIRST button pressed was a '1' + if target == 'left': #if a left target stim was shown this trial + accuracy = 1 #mark this trial as correct + numCorr = numCorr +1 #iterate number of correct responses for this block + elif target == 'right': #if a right target stim was shown this trial + accuracy = 0 #mark this trial as an error + elif prac_stim_keyResp.keys[0] == 'k': #if the FIRST button pressed was a '8' + if target == 'right': #if a right target stim was shown this trial + accuracy = 1 #mark this trial as correct + numCorr = numCorr +1 #iterate number of correct responses for this block + elif target == 'left': #if a left target stim was shown this trial + accuracy = 0 #mark this trial as an error + + # save this trial's accuracy to our output file + prac_trial_loop.addData('accuracy', accuracy) + # the Routine "prac_stimRoutine" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + + # completed 1 repeats of 'prac_trial_loop' + + + # --- Prepare to start Routine "prac_blockFeed" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from prac_blockFeed_code + blockAcc = numCorr / trialNum #compute accuracy for this block + + if blockAcc >= .75: #if accuracy >= 75% then say practice is complete and end practice loop to continue to main exp + outPut = 'You have completed the practice' #feedback presented + prac_block_loop.finished = True #end practice loop to continue to main exp + elif blockAcc <= .75: #if accuracy < 75% then say that practice needs to be repeated and DO NOT end practice loop, instead, allow it to repeat + outPut = 'Please try the practice again' #feedback presented + prac_block_loop.finished = False #DO NOT end practice loop and allow to repeat + + #reset the following variables to zero before the next practice block starts + trialNum = 0 + numCorr = 0 + prac_blockFeed_text.setText(outPut) + prac_blockFeed_keyResp.keys = [] + prac_blockFeed_keyResp.rt = [] + _prac_blockFeed_keyResp_allKeys = [] + # keep track of which components have finished + prac_blockFeedComponents = [prac_blockFeed_text, prac_pressContinue, prac_blockFeed_keyResp] + for thisComponent in prac_blockFeedComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "prac_blockFeed" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *prac_blockFeed_text* updates + if prac_blockFeed_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_blockFeed_text.frameNStart = frameN # exact frame index + prac_blockFeed_text.tStart = t # local t and not account for scr refresh + prac_blockFeed_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_blockFeed_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_blockFeed_text.started') + prac_blockFeed_text.setAutoDraw(True) + + # *prac_pressContinue* updates + if prac_pressContinue.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_pressContinue.frameNStart = frameN # exact frame index + prac_pressContinue.tStart = t # local t and not account for scr refresh + prac_pressContinue.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_pressContinue, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_pressContinue.started') + prac_pressContinue.setAutoDraw(True) + + # *prac_blockFeed_keyResp* updates + waitOnFlip = False + if prac_blockFeed_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_blockFeed_keyResp.frameNStart = frameN # exact frame index + prac_blockFeed_keyResp.tStart = t # local t and not account for scr refresh + prac_blockFeed_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_blockFeed_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_blockFeed_keyResp.started') + prac_blockFeed_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(prac_blockFeed_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(prac_blockFeed_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if prac_blockFeed_keyResp.status == STARTED and not waitOnFlip: + theseKeys = prac_blockFeed_keyResp.getKeys(keyList=['k'], waitRelease=False) + _prac_blockFeed_keyResp_allKeys.extend(theseKeys) + if len(_prac_blockFeed_keyResp_allKeys): + prac_blockFeed_keyResp.keys = _prac_blockFeed_keyResp_allKeys[-1].name # just the last key pressed + prac_blockFeed_keyResp.rt = _prac_blockFeed_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in prac_blockFeedComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "prac_blockFeed" --- + for thisComponent in prac_blockFeedComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if prac_blockFeed_keyResp.keys in ['', [], None]: # No response was made + prac_blockFeed_keyResp.keys = None + prac_block_loop.addData('prac_blockFeed_keyResp.keys',prac_blockFeed_keyResp.keys) + if prac_blockFeed_keyResp.keys != None: # we had a response + prac_block_loop.addData('prac_blockFeed_keyResp.rt', prac_blockFeed_keyResp.rt) + # the Routine "prac_blockFeed" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + +# completed 999 repeats of 'prac_block_loop' + + +# --- Prepare to start Routine "ringBell" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +bellKey.keys = [] +bellKey.rt = [] +_bellKey_allKeys = [] +# keep track of which components have finished +ringBellComponents = [ringBell_text, bellKey] +for thisComponent in ringBellComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "ringBell" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *ringBell_text* updates + if ringBell_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + ringBell_text.frameNStart = frameN # exact frame index + ringBell_text.tStart = t # local t and not account for scr refresh + ringBell_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(ringBell_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'ringBell_text.started') + ringBell_text.setAutoDraw(True) + + # *bellKey* updates + waitOnFlip = False + if bellKey.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bellKey.frameNStart = frameN # exact frame index + bellKey.tStart = t # local t and not account for scr refresh + bellKey.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bellKey, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bellKey.started') + bellKey.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(bellKey.clock.reset) # t=0 on next screen flip + win.callOnFlip(bellKey.clearEvents, eventType='keyboard') # clear events on next screen flip + if bellKey.status == STARTED and not waitOnFlip: + theseKeys = bellKey.getKeys(keyList=['c'], waitRelease=False) + _bellKey_allKeys.extend(theseKeys) + if len(_bellKey_allKeys): + bellKey.keys = _bellKey_allKeys[-1].name # just the last key pressed + bellKey.rt = _bellKey_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in ringBellComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "ringBell" --- +for thisComponent in ringBellComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if bellKey.keys in ['', [], None]: # No response was made + bellKey.keys = None +thisExp.addData('bellKey.keys',bellKey.keys) +if bellKey.keys != None: # we had a response + thisExp.addData('bellKey.rt', bellKey.rt) +thisExp.nextEntry() +# the Routine "ringBell" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# set up handler to look after randomisation of conditions etc +task_block_loop = data.TrialHandler(nReps=1.0, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions('blockSelect.csv'), + seed=None, name='task_block_loop') +thisExp.addLoop(task_block_loop) # add the loop to the experiment +thisTask_block_loop = task_block_loop.trialList[0] # so we can initialise stimuli with some values +# abbreviate parameter names if possible (e.g. rgb = thisTask_block_loop.rgb) +if thisTask_block_loop != None: + for paramName in thisTask_block_loop: + exec('{} = thisTask_block_loop[paramName]'.format(paramName)) + +for thisTask_block_loop in task_block_loop: + currentLoop = task_block_loop + # abbreviate parameter names if possible (e.g. rgb = thisTask_block_loop.rgb) + if thisTask_block_loop != None: + for paramName in thisTask_block_loop: + exec('{} = thisTask_block_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "task_blockReminders" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from task_blockReminder_code + blockCounter = blockCounter +1 + + if blockCounter == 1: + blockNumText = 'Block 1 of 12' + elif blockCounter == 2: + blockNumText = 'Block 2 of 12' + elif blockCounter == 3: + blockNumText = 'Block 3 of 12' + elif blockCounter == 4: + blockNumText = 'Block 4 of 12' + elif blockCounter == 5: + blockNumText = 'Block 5 of 12' + elif blockCounter == 6: + blockNumText = 'Block 6 of 12' + elif blockCounter == 7: + blockNumText = 'Block 7 of 12' + elif blockCounter == 8: + blockNumText = 'Block 8 of 12' + elif blockCounter == 9: + blockNumText = 'Block 9 of 12' + elif blockCounter == 10: + blockNumText = 'Block 10 of 12' + elif blockCounter == 11: + blockNumText = 'Block 11 of 12' + elif blockCounter == 12: + blockNumText = 'Block 12 of 12' + + + + task_blockText.setText(blockNumText) + task_blockReminders_keyResp.keys = [] + task_blockReminders_keyResp.rt = [] + _task_blockReminders_keyResp_allKeys = [] + # keep track of which components have finished + task_blockRemindersComponents = [task_blockText, task_blockReminders_text, task_blockReminders_keyResp] + for thisComponent in task_blockRemindersComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "task_blockReminders" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *task_blockText* updates + if task_blockText.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockText.frameNStart = frameN # exact frame index + task_blockText.tStart = t # local t and not account for scr refresh + task_blockText.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockText, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockText.started') + task_blockText.setAutoDraw(True) + + # *task_blockReminders_text* updates + if task_blockReminders_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockReminders_text.frameNStart = frameN # exact frame index + task_blockReminders_text.tStart = t # local t and not account for scr refresh + task_blockReminders_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockReminders_text, 'tStartRefresh') # time at next scr refresh + task_blockReminders_text.setAutoDraw(True) + + # *task_blockReminders_keyResp* updates + waitOnFlip = False + if task_blockReminders_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockReminders_keyResp.frameNStart = frameN # exact frame index + task_blockReminders_keyResp.tStart = t # local t and not account for scr refresh + task_blockReminders_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockReminders_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockReminders_keyResp.started') + task_blockReminders_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(task_blockReminders_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(task_blockReminders_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if task_blockReminders_keyResp.status == STARTED and not waitOnFlip: + theseKeys = task_blockReminders_keyResp.getKeys(keyList=['k'], waitRelease=False) + _task_blockReminders_keyResp_allKeys.extend(theseKeys) + if len(_task_blockReminders_keyResp_allKeys): + task_blockReminders_keyResp.keys = _task_blockReminders_keyResp_allKeys[-1].name # just the last key pressed + task_blockReminders_keyResp.rt = _task_blockReminders_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in task_blockRemindersComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "task_blockReminders" --- + for thisComponent in task_blockRemindersComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if task_blockReminders_keyResp.keys in ['', [], None]: # No response was made + task_blockReminders_keyResp.keys = None + task_block_loop.addData('task_blockReminders_keyResp.keys',task_blockReminders_keyResp.keys) + if task_blockReminders_keyResp.keys != None: # we had a response + task_block_loop.addData('task_blockReminders_keyResp.rt', task_blockReminders_keyResp.rt) + # the Routine "task_blockReminders" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # --- Prepare to start Routine "initFixation" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + initFixation_img.setImage('img/transp_fixation.png') + # keep track of which components have finished + initFixationComponents = [initFixation_img] + for thisComponent in initFixationComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "initFixation" --- + while continueRoutine and routineTimer.getTime() < 2.0: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *initFixation_img* updates + if initFixation_img.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + initFixation_img.frameNStart = frameN # exact frame index + initFixation_img.tStart = t # local t and not account for scr refresh + initFixation_img.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(initFixation_img, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'initFixation_img.started') + initFixation_img.setAutoDraw(True) + if initFixation_img.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > initFixation_img.tStartRefresh + 2-frameTolerance: + # keep track of stop time/frame for later + initFixation_img.tStop = t # not accounting for scr refresh + initFixation_img.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'initFixation_img.stopped') + initFixation_img.setAutoDraw(False) + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in initFixationComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "initFixation" --- + for thisComponent in initFixationComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # using non-slip timing so subtract the expected duration of this Routine (unless ended on request) + if routineForceEnded: + routineTimer.reset() + else: + routineTimer.addTime(-2.000000) + + # set up handler to look after randomisation of conditions etc + task_trial_loop = data.TrialHandler(nReps=1.0, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions(whichBlock), + seed=None, name='task_trial_loop') + thisExp.addLoop(task_trial_loop) # add the loop to the experiment + thisTask_trial_loop = task_trial_loop.trialList[0] # so we can initialise stimuli with some values + # abbreviate parameter names if possible (e.g. rgb = thisTask_trial_loop.rgb) + if thisTask_trial_loop != None: + for paramName in thisTask_trial_loop: + exec('{} = thisTask_trial_loop[paramName]'.format(paramName)) + + for thisTask_trial_loop in task_trial_loop: + currentLoop = task_trial_loop + # abbreviate parameter names if possible (e.g. rgb = thisTask_trial_loop.rgb) + if thisTask_trial_loop != None: + for paramName in thisTask_trial_loop: + exec('{} = thisTask_trial_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "task_stimRoutine" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from task_isi_code + # pick the ISI for the next routine + # this code component is set to 'both' because we need to remove the 'np' + # at the start of np.linspace (this is a python library JS won't know what to call. + + # make range from a to b in n stepsizes + ISIRange = np.linspace(3500, 4000, 500) + + # picking from a shuffled array is easier for random selection in JS + shuffle(ISIRange) + thisISI = ISIRange[0]/1000 # the first item of the shuffled array + + # save this ISI to our output file + task_trial_loop.addData('ISI', thisISI) + + bigFace_2.setImage(straightFace) + task_centerImg.setPos((0, 0)) + task_centerImg.setSize([1.03, 1.03]) + task_centerImg.setImage(middleStim) + task_rightImg1.setPos((1.22, 0)) + task_rightImg1.setSize([1.03, 1.03]) + task_rightImg1.setImage(rightStim) + task_rightImg2.setPos([2.44,0]) + task_rightImg2.setSize([1.03, 1.03]) + task_rightImg2.setImage(rightStim) + task_leftImg1.setPos((-1.22, 0)) + task_leftImg1.setSize([1.03, 1.03]) + task_leftImg1.setImage(leftStim) + task_leftImg2.setPos([-2.44,0]) + task_leftImg2.setSize([1.03, 1.03]) + task_leftImg2.setImage(leftStim) + task_fixImg.setImage('img/transp_fixation.png') + task1_stim_keyResp.keys = [] + task1_stim_keyResp.rt = [] + _task1_stim_keyResp_allKeys = [] + # keep track of which components have finished + task_stimRoutineComponents = [bigFace_2, cover_background, task_centerImg, task_rightImg1, task_rightImg2, task_leftImg1, task_leftImg2, task_fixImg, task1_stim_keyResp] + for thisComponent in task_stimRoutineComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "task_stimRoutine" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *bigFace_2* updates + if bigFace_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bigFace_2.frameNStart = frameN # exact frame index + bigFace_2.tStart = t # local t and not account for scr refresh + bigFace_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bigFace_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bigFace_2.started') + bigFace_2.setAutoDraw(True) + if bigFace_2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > bigFace_2.tStartRefresh + thisISI-frameTolerance: + # keep track of stop time/frame for later + bigFace_2.tStop = t # not accounting for scr refresh + bigFace_2.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bigFace_2.stopped') + bigFace_2.setAutoDraw(False) + + # *cover_background* updates + if cover_background.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + cover_background.frameNStart = frameN # exact frame index + cover_background.tStart = t # local t and not account for scr refresh + cover_background.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(cover_background, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'cover_background.started') + cover_background.setAutoDraw(True) + if cover_background.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > cover_background.tStartRefresh + 0.35-frameTolerance: + # keep track of stop time/frame for later + cover_background.tStop = t # not accounting for scr refresh + cover_background.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'cover_background.stopped') + cover_background.setAutoDraw(False) + + # *task_centerImg* updates + if task_centerImg.status == NOT_STARTED and tThisFlip >= 0.15-frameTolerance: + # keep track of start time/frame for later + task_centerImg.frameNStart = frameN # exact frame index + task_centerImg.tStart = t # local t and not account for scr refresh + task_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_centerImg, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_centerImg.started') + task_centerImg.setAutoDraw(True) + if task_centerImg.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_centerImg.tStartRefresh + .2-frameTolerance: + # keep track of stop time/frame for later + task_centerImg.tStop = t # not accounting for scr refresh + task_centerImg.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_centerImg.stopped') + task_centerImg.setAutoDraw(False) + + # *task_rightImg1* updates + if task_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_rightImg1.frameNStart = frameN # exact frame index + task_rightImg1.tStart = t # local t and not account for scr refresh + task_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_rightImg1, 'tStartRefresh') # time at next scr refresh + task_rightImg1.setAutoDraw(True) + if task_rightImg1.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_rightImg1.tStartRefresh + .35-frameTolerance: + # keep track of stop time/frame for later + task_rightImg1.tStop = t # not accounting for scr refresh + task_rightImg1.frameNStop = frameN # exact frame index + task_rightImg1.setAutoDraw(False) + + # *task_rightImg2* updates + if task_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_rightImg2.frameNStart = frameN # exact frame index + task_rightImg2.tStart = t # local t and not account for scr refresh + task_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_rightImg2, 'tStartRefresh') # time at next scr refresh + task_rightImg2.setAutoDraw(True) + if task_rightImg2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_rightImg2.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + task_rightImg2.tStop = t # not accounting for scr refresh + task_rightImg2.frameNStop = frameN # exact frame index + task_rightImg2.setAutoDraw(False) + + # *task_leftImg1* updates + if task_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_leftImg1.frameNStart = frameN # exact frame index + task_leftImg1.tStart = t # local t and not account for scr refresh + task_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_leftImg1, 'tStartRefresh') # time at next scr refresh + task_leftImg1.setAutoDraw(True) + if task_leftImg1.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_leftImg1.tStartRefresh + .35-frameTolerance: + # keep track of stop time/frame for later + task_leftImg1.tStop = t # not accounting for scr refresh + task_leftImg1.frameNStop = frameN # exact frame index + task_leftImg1.setAutoDraw(False) + + # *task_leftImg2* updates + if task_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_leftImg2.frameNStart = frameN # exact frame index + task_leftImg2.tStart = t # local t and not account for scr refresh + task_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_leftImg2, 'tStartRefresh') # time at next scr refresh + task_leftImg2.setAutoDraw(True) + if task_leftImg2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_leftImg2.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + task_leftImg2.tStop = t # not accounting for scr refresh + task_leftImg2.frameNStop = frameN # exact frame index + task_leftImg2.setAutoDraw(False) + + # *task_fixImg* updates + if task_fixImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_fixImg.frameNStart = frameN # exact frame index + task_fixImg.tStart = t # local t and not account for scr refresh + task_fixImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_fixImg, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_fixImg.started') + task_fixImg.setAutoDraw(True) + if task_fixImg.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_fixImg.tStartRefresh + thisISI-frameTolerance: + # keep track of stop time/frame for later + task_fixImg.tStop = t # not accounting for scr refresh + task_fixImg.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_fixImg.stopped') + task_fixImg.setAutoDraw(False) + + # *task1_stim_keyResp* updates + waitOnFlip = False + if task1_stim_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task1_stim_keyResp.frameNStart = frameN # exact frame index + task1_stim_keyResp.tStart = t # local t and not account for scr refresh + task1_stim_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task1_stim_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task1_stim_keyResp.started') + task1_stim_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(task1_stim_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(task1_stim_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if task1_stim_keyResp.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task1_stim_keyResp.tStartRefresh + thisISI-frameTolerance: + # keep track of stop time/frame for later + task1_stim_keyResp.tStop = t # not accounting for scr refresh + task1_stim_keyResp.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task1_stim_keyResp.stopped') + task1_stim_keyResp.status = FINISHED + if task1_stim_keyResp.status == STARTED and not waitOnFlip: + theseKeys = task1_stim_keyResp.getKeys(keyList=['s','k'], waitRelease=False) + _task1_stim_keyResp_allKeys.extend(theseKeys) + if len(_task1_stim_keyResp_allKeys): + task1_stim_keyResp.keys = [key.name for key in _task1_stim_keyResp_allKeys] # storing all keys + task1_stim_keyResp.rt = [key.rt for key in _task1_stim_keyResp_allKeys] + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in task_stimRoutineComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "task_stimRoutine" --- + for thisComponent in task_stimRoutineComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if task1_stim_keyResp.keys in ['', [], None]: # No response was made + task1_stim_keyResp.keys = None + task_trial_loop.addData('task1_stim_keyResp.keys',task1_stim_keyResp.keys) + if task1_stim_keyResp.keys != None: # we had a response + task_trial_loop.addData('task1_stim_keyResp.rt', task1_stim_keyResp.rt) + # Run 'End Routine' code from task_accuracy_code + trialNum = trialNum + 1 #iterate trial number for this block + + if task1_stim_keyResp.keys: #if at least one response was made this trial + if task1_stim_keyResp.keys[0] == 's': #if the FIRST button pressed was a '1' + if target == 'left': #if a left target stim was shown this trial + accuracy = 1 #mark this trial as correct + numCorr = numCorr +1 #iterate number of correct responses for this block + elif target == 'right': #if a right target stim was shown this trial + accuracy = 0 #mark this trial as an error + elif task1_stim_keyResp.keys[0] == 'k': #if the FIRST button pressed was a '8' + if target == 'right': #if a right target stim was shown this trial + accuracy = 1 #mark this trial as correct + numCorr = numCorr +1 #iterate number of correct responses for this block + elif target == 'left': #if a left target stim was shown this trial + accuracy = 0 #mark this trial as an error + + # save this trial's accuracy to our output file + task_trial_loop.addData('accuracy', accuracy) + # the Routine "task_stimRoutine" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + + # completed 1.0 repeats of 'task_trial_loop' + + + # --- Prepare to start Routine "task_blockFeed" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from task_blockFeed_code + blockAcc = numCorr / trialNum #compute accuracy for this block + + if blockCounter < 10: + if blockAcc >= .75: + if blockAcc < .9: + blockFeed = 'Good job' + blockFeedCat = 1 + elif blockAcc >= .9: + blockFeed = 'Respond faster' + blockFeedCat = 2 + elif blockAcc < .75: + blockFeed = 'Respond more accurately' + blockFeedCat = 3 + elif blockCounter == 10: + 'You have completed all blocks' + + # save this block's feedback to our output file + task_trial_loop.addData('blockFeedCat', blockFeedCat) + + #reset the following variables to zero before next block starts + trialNum = 0 + numCorr = 0 + task_blockFeed_text.setText(blockFeed) + task_blockFeed_text2.setText("Press the 'K' key") + task_blockFeed_keyResp.keys = [] + task_blockFeed_keyResp.rt = [] + _task_blockFeed_keyResp_allKeys = [] + # keep track of which components have finished + task_blockFeedComponents = [task_blockFeed_text, task_blockFeed_text2, task_blockFeed_keyResp] + for thisComponent in task_blockFeedComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "task_blockFeed" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *task_blockFeed_text* updates + if task_blockFeed_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockFeed_text.frameNStart = frameN # exact frame index + task_blockFeed_text.tStart = t # local t and not account for scr refresh + task_blockFeed_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockFeed_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockFeed_text.started') + task_blockFeed_text.setAutoDraw(True) + + # *task_blockFeed_text2* updates + if task_blockFeed_text2.status == NOT_STARTED and tThisFlip >= 10-frameTolerance: + # keep track of start time/frame for later + task_blockFeed_text2.frameNStart = frameN # exact frame index + task_blockFeed_text2.tStart = t # local t and not account for scr refresh + task_blockFeed_text2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockFeed_text2, 'tStartRefresh') # time at next scr refresh + task_blockFeed_text2.setAutoDraw(True) + + # *task_blockFeed_keyResp* updates + waitOnFlip = False + if task_blockFeed_keyResp.status == NOT_STARTED and tThisFlip >= 10-frameTolerance: + # keep track of start time/frame for later + task_blockFeed_keyResp.frameNStart = frameN # exact frame index + task_blockFeed_keyResp.tStart = t # local t and not account for scr refresh + task_blockFeed_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockFeed_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockFeed_keyResp.started') + task_blockFeed_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(task_blockFeed_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(task_blockFeed_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if task_blockFeed_keyResp.status == STARTED and not waitOnFlip: + theseKeys = task_blockFeed_keyResp.getKeys(keyList=['k'], waitRelease=False) + _task_blockFeed_keyResp_allKeys.extend(theseKeys) + if len(_task_blockFeed_keyResp_allKeys): + task_blockFeed_keyResp.keys = _task_blockFeed_keyResp_allKeys[-1].name # just the last key pressed + task_blockFeed_keyResp.rt = _task_blockFeed_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in task_blockFeedComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "task_blockFeed" --- + for thisComponent in task_blockFeedComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if task_blockFeed_keyResp.keys in ['', [], None]: # No response was made + task_blockFeed_keyResp.keys = None + task_block_loop.addData('task_blockFeed_keyResp.keys',task_blockFeed_keyResp.keys) + if task_blockFeed_keyResp.keys != None: # we had a response + task_block_loop.addData('task_blockFeed_keyResp.rt', task_blockFeed_keyResp.rt) + # the Routine "task_blockFeed" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + +# completed 1.0 repeats of 'task_block_loop' + + +# --- Prepare to start Routine "ringBell2" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +bellKey_2.keys = [] +bellKey_2.rt = [] +_bellKey_2_allKeys = [] +# keep track of which components have finished +ringBell2Components = [ringBell_text_2, bellKey_2] +for thisComponent in ringBell2Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "ringBell2" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *ringBell_text_2* updates + if ringBell_text_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + ringBell_text_2.frameNStart = frameN # exact frame index + ringBell_text_2.tStart = t # local t and not account for scr refresh + ringBell_text_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(ringBell_text_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'ringBell_text_2.started') + ringBell_text_2.setAutoDraw(True) + + # *bellKey_2* updates + waitOnFlip = False + if bellKey_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bellKey_2.frameNStart = frameN # exact frame index + bellKey_2.tStart = t # local t and not account for scr refresh + bellKey_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bellKey_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bellKey_2.started') + bellKey_2.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(bellKey_2.clock.reset) # t=0 on next screen flip + win.callOnFlip(bellKey_2.clearEvents, eventType='keyboard') # clear events on next screen flip + if bellKey_2.status == STARTED and not waitOnFlip: + theseKeys = bellKey_2.getKeys(keyList=['c'], waitRelease=False) + _bellKey_2_allKeys.extend(theseKeys) + if len(_bellKey_2_allKeys): + bellKey_2.keys = _bellKey_2_allKeys[-1].name # just the last key pressed + bellKey_2.rt = _bellKey_2_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in ringBell2Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "ringBell2" --- +for thisComponent in ringBell2Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if bellKey_2.keys in ['', [], None]: # No response was made + bellKey_2.keys = None +thisExp.addData('bellKey_2.keys',bellKey_2.keys) +if bellKey_2.keys != None: # we had a response + thisExp.addData('bellKey_2.rt', bellKey_2.rt) +thisExp.nextEntry() +# the Routine "ringBell2" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "errorNumbers" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# Run 'Begin Routine' code from code +event.clearEvents() +errorNum_text_box.reset() +errorN_key_resp_2.keys = [] +errorN_key_resp_2.rt = [] +_errorN_key_resp_2_allKeys = [] +# keep track of which components have finished +errorNumbersComponents = [errorNumbers_text_2, errorNum_text_box, errorN_key_resp_2] +for thisComponent in errorNumbersComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "errorNumbers" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *errorNumbers_text_2* updates + if errorNumbers_text_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorNumbers_text_2.frameNStart = frameN # exact frame index + errorNumbers_text_2.tStart = t # local t and not account for scr refresh + errorNumbers_text_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorNumbers_text_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorNumbers_text_2.started') + errorNumbers_text_2.setAutoDraw(True) + + # *errorNum_text_box* updates + if errorNum_text_box.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorNum_text_box.frameNStart = frameN # exact frame index + errorNum_text_box.tStart = t # local t and not account for scr refresh + errorNum_text_box.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorNum_text_box, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorNum_text_box.started') + errorNum_text_box.setAutoDraw(True) + + # *errorN_key_resp_2* updates + waitOnFlip = False + if errorN_key_resp_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorN_key_resp_2.frameNStart = frameN # exact frame index + errorN_key_resp_2.tStart = t # local t and not account for scr refresh + errorN_key_resp_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorN_key_resp_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorN_key_resp_2.started') + errorN_key_resp_2.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(errorN_key_resp_2.clock.reset) # t=0 on next screen flip + win.callOnFlip(errorN_key_resp_2.clearEvents, eventType='keyboard') # clear events on next screen flip + if errorN_key_resp_2.status == STARTED and not waitOnFlip: + theseKeys = errorN_key_resp_2.getKeys(keyList=['space'], waitRelease=False) + _errorN_key_resp_2_allKeys.extend(theseKeys) + if len(_errorN_key_resp_2_allKeys): + errorN_key_resp_2.keys = _errorN_key_resp_2_allKeys[-1].name # just the last key pressed + errorN_key_resp_2.rt = _errorN_key_resp_2_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in errorNumbersComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "errorNumbers" --- +for thisComponent in errorNumbersComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +thisExp.addData('errorNum_text_box.text',errorNum_text_box.text) +# check responses +if errorN_key_resp_2.keys in ['', [], None]: # No response was made + errorN_key_resp_2.keys = None +thisExp.addData('errorN_key_resp_2.keys',errorN_key_resp_2.keys) +if errorN_key_resp_2.keys != None: # we had a response + thisExp.addData('errorN_key_resp_2.rt', errorN_key_resp_2.rt) +thisExp.nextEntry() +# the Routine "errorNumbers" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "errorPercentage" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# Run 'Begin Routine' code from code_4 +event.clearEvents() +errorPercent_text_box.reset() +errorN_key_resp_3.keys = [] +errorN_key_resp_3.rt = [] +_errorN_key_resp_3_allKeys = [] +# keep track of which components have finished +errorPercentageComponents = [errorNumbers_text_3, errorPercent_text_box, errorN_key_resp_3] +for thisComponent in errorPercentageComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "errorPercentage" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *errorNumbers_text_3* updates + if errorNumbers_text_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorNumbers_text_3.frameNStart = frameN # exact frame index + errorNumbers_text_3.tStart = t # local t and not account for scr refresh + errorNumbers_text_3.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorNumbers_text_3, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorNumbers_text_3.started') + errorNumbers_text_3.setAutoDraw(True) + + # *errorPercent_text_box* updates + if errorPercent_text_box.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorPercent_text_box.frameNStart = frameN # exact frame index + errorPercent_text_box.tStart = t # local t and not account for scr refresh + errorPercent_text_box.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorPercent_text_box, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorPercent_text_box.started') + errorPercent_text_box.setAutoDraw(True) + + # *errorN_key_resp_3* updates + waitOnFlip = False + if errorN_key_resp_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorN_key_resp_3.frameNStart = frameN # exact frame index + errorN_key_resp_3.tStart = t # local t and not account for scr refresh + errorN_key_resp_3.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorN_key_resp_3, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorN_key_resp_3.started') + errorN_key_resp_3.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(errorN_key_resp_3.clock.reset) # t=0 on next screen flip + win.callOnFlip(errorN_key_resp_3.clearEvents, eventType='keyboard') # clear events on next screen flip + if errorN_key_resp_3.status == STARTED and not waitOnFlip: + theseKeys = errorN_key_resp_3.getKeys(keyList=['space'], waitRelease=False) + _errorN_key_resp_3_allKeys.extend(theseKeys) + if len(_errorN_key_resp_3_allKeys): + errorN_key_resp_3.keys = _errorN_key_resp_3_allKeys[-1].name # just the last key pressed + errorN_key_resp_3.rt = _errorN_key_resp_3_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in errorPercentageComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "errorPercentage" --- +for thisComponent in errorPercentageComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +thisExp.addData('errorPercent_text_box.text',errorPercent_text_box.text) +# check responses +if errorN_key_resp_3.keys in ['', [], None]: # No response was made + errorN_key_resp_3.keys = None +thisExp.addData('errorN_key_resp_3.keys',errorN_key_resp_3.keys) +if errorN_key_resp_3.keys != None: # we had a response + thisExp.addData('errorN_key_resp_3.rt', errorN_key_resp_3.rt) +thisExp.nextEntry() +# the Routine "errorPercentage" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "botherRate" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# Run 'Begin Routine' code from code_3 +event.clearEvents() +bother_text_box.reset() +botherRate_key_resp.keys = [] +botherRate_key_resp.rt = [] +_botherRate_key_resp_allKeys = [] +# keep track of which components have finished +botherRateComponents = [botherRate_text, bother_text_box, botherRate_key_resp] +for thisComponent in botherRateComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "botherRate" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *botherRate_text* updates + if botherRate_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + botherRate_text.frameNStart = frameN # exact frame index + botherRate_text.tStart = t # local t and not account for scr refresh + botherRate_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(botherRate_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'botherRate_text.started') + botherRate_text.setAutoDraw(True) + + # *bother_text_box* updates + if bother_text_box.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bother_text_box.frameNStart = frameN # exact frame index + bother_text_box.tStart = t # local t and not account for scr refresh + bother_text_box.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bother_text_box, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bother_text_box.started') + bother_text_box.setAutoDraw(True) + + # *botherRate_key_resp* updates + waitOnFlip = False + if botherRate_key_resp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + botherRate_key_resp.frameNStart = frameN # exact frame index + botherRate_key_resp.tStart = t # local t and not account for scr refresh + botherRate_key_resp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(botherRate_key_resp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'botherRate_key_resp.started') + botherRate_key_resp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(botherRate_key_resp.clock.reset) # t=0 on next screen flip + win.callOnFlip(botherRate_key_resp.clearEvents, eventType='keyboard') # clear events on next screen flip + if botherRate_key_resp.status == STARTED and not waitOnFlip: + theseKeys = botherRate_key_resp.getKeys(keyList=['space'], waitRelease=False) + _botherRate_key_resp_allKeys.extend(theseKeys) + if len(_botherRate_key_resp_allKeys): + botherRate_key_resp.keys = _botherRate_key_resp_allKeys[-1].name # just the last key pressed + botherRate_key_resp.rt = _botherRate_key_resp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in botherRateComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "botherRate" --- +for thisComponent in botherRateComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +thisExp.addData('bother_text_box.text',bother_text_box.text) +# check responses +if botherRate_key_resp.keys in ['', [], None]: # No response was made + botherRate_key_resp.keys = None +thisExp.addData('botherRate_key_resp.keys',botherRate_key_resp.keys) +if botherRate_key_resp.keys != None: # we had a response + thisExp.addData('botherRate_key_resp.rt', botherRate_key_resp.rt) +thisExp.nextEntry() +# the Routine "botherRate" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "ringBell3" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +bellKey_3.keys = [] +bellKey_3.rt = [] +_bellKey_3_allKeys = [] +# keep track of which components have finished +ringBell3Components = [ringBell_text_3, bellKey_3] +for thisComponent in ringBell3Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "ringBell3" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *ringBell_text_3* updates + if ringBell_text_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + ringBell_text_3.frameNStart = frameN # exact frame index + ringBell_text_3.tStart = t # local t and not account for scr refresh + ringBell_text_3.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(ringBell_text_3, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'ringBell_text_3.started') + ringBell_text_3.setAutoDraw(True) + + # *bellKey_3* updates + waitOnFlip = False + if bellKey_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bellKey_3.frameNStart = frameN # exact frame index + bellKey_3.tStart = t # local t and not account for scr refresh + bellKey_3.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bellKey_3, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bellKey_3.started') + bellKey_3.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(bellKey_3.clock.reset) # t=0 on next screen flip + win.callOnFlip(bellKey_3.clearEvents, eventType='keyboard') # clear events on next screen flip + if bellKey_3.status == STARTED and not waitOnFlip: + theseKeys = bellKey_3.getKeys(keyList=['c'], waitRelease=False) + _bellKey_3_allKeys.extend(theseKeys) + if len(_bellKey_3_allKeys): + bellKey_3.keys = _bellKey_3_allKeys[-1].name # just the last key pressed + bellKey_3.rt = _bellKey_3_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in ringBell3Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "ringBell3" --- +for thisComponent in ringBell3Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if bellKey_3.keys in ['', [], None]: # No response was made + bellKey_3.keys = None +thisExp.addData('bellKey_3.keys',bellKey_3.keys) +if bellKey_3.keys != None: # we had a response + thisExp.addData('bellKey_3.rt', bellKey_3.rt) +thisExp.nextEntry() +# the Routine "ringBell3" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "surpriseInstruct" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +instruct_surp1_key_resp.keys = [] +instruct_surp1_key_resp.rt = [] +_instruct_surp1_key_resp_allKeys = [] +# keep track of which components have finished +surpriseInstructComponents = [instruct_surprise1, instruct_surp1_key_resp] +for thisComponent in surpriseInstructComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "surpriseInstruct" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instruct_surprise1* updates + if instruct_surprise1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instruct_surprise1.frameNStart = frameN # exact frame index + instruct_surprise1.tStart = t # local t and not account for scr refresh + instruct_surprise1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instruct_surprise1, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'instruct_surprise1.started') + instruct_surprise1.setAutoDraw(True) + + # *instruct_surp1_key_resp* updates + waitOnFlip = False + if instruct_surp1_key_resp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instruct_surp1_key_resp.frameNStart = frameN # exact frame index + instruct_surp1_key_resp.tStart = t # local t and not account for scr refresh + instruct_surp1_key_resp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instruct_surp1_key_resp, 'tStartRefresh') # time at next scr refresh + instruct_surp1_key_resp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(instruct_surp1_key_resp.clock.reset) # t=0 on next screen flip + win.callOnFlip(instruct_surp1_key_resp.clearEvents, eventType='keyboard') # clear events on next screen flip + if instruct_surp1_key_resp.status == STARTED and not waitOnFlip: + theseKeys = instruct_surp1_key_resp.getKeys(keyList=['k'], waitRelease=False) + _instruct_surp1_key_resp_allKeys.extend(theseKeys) + if len(_instruct_surp1_key_resp_allKeys): + instruct_surp1_key_resp.keys = _instruct_surp1_key_resp_allKeys[-1].name # just the last key pressed + instruct_surp1_key_resp.rt = _instruct_surp1_key_resp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in surpriseInstructComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "surpriseInstruct" --- +for thisComponent in surpriseInstructComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if instruct_surp1_key_resp.keys in ['', [], None]: # No response was made + instruct_surp1_key_resp.keys = None +thisExp.addData('instruct_surp1_key_resp.keys',instruct_surp1_key_resp.keys) +if instruct_surp1_key_resp.keys != None: # we had a response + thisExp.addData('instruct_surp1_key_resp.rt', instruct_surp1_key_resp.rt) +thisExp.nextEntry() +# the Routine "surpriseInstruct" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# set up handler to look after randomisation of conditions etc +surprise_block_loop = data.TrialHandler(nReps=1.0, method='sequential', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions('surpriseBlock_select_A.xlsx'), + seed=None, name='surprise_block_loop') +thisExp.addLoop(surprise_block_loop) # add the loop to the experiment +thisSurprise_block_loop = surprise_block_loop.trialList[0] # so we can initialise stimuli with some values +# abbreviate parameter names if possible (e.g. rgb = thisSurprise_block_loop.rgb) +if thisSurprise_block_loop != None: + for paramName in thisSurprise_block_loop: + exec('{} = thisSurprise_block_loop[paramName]'.format(paramName)) + +for thisSurprise_block_loop in surprise_block_loop: + currentLoop = surprise_block_loop + # abbreviate parameter names if possible (e.g. rgb = thisSurprise_block_loop.rgb) + if thisSurprise_block_loop != None: + for paramName in thisSurprise_block_loop: + exec('{} = thisSurprise_block_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "surp_taskReminders" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from task_blockReminder_code_2 + + + blockCounterZ1 = blockCounterZ1 + 1 + + if blockCounterZ1 == 1: + blockNumText = 'Block 1 of 8' + elif blockCounterZ1 == 2: + blockNumText = 'Block 2 of 8' + elif blockCounterZ1 == 3: + blockNumText = 'Block 3 of 8' + elif blockCounterZ1 == 4: + blockNumText = 'Block 4 of 8' + elif blockCounterZ1 == 5: + blockNumText = 'Block 5 of 8' + elif blockCounterZ1 == 6: + blockNumText = 'Block 6 of 8' + elif blockCounterZ1 == 7: + blockNumText = 'Block 7 of 8' + elif blockCounterZ1 == 8: + blockNumText = 'Block 8 of 8' + + + text_2.setText(blockNumText) + task_blockText_2.setText('Remember that you need to choose the face you think you have seen in the Arrow game. \n\nPress K for the right image, or press S for the left image.\n\nPress the "K" key when you are ready to begin.\n') + task_blockReminders_keyResp_2.keys = [] + task_blockReminders_keyResp_2.rt = [] + _task_blockReminders_keyResp_2_allKeys = [] + # keep track of which components have finished + surp_taskRemindersComponents = [text_2, task_blockText_2, task_blockReminders_keyResp_2] + for thisComponent in surp_taskRemindersComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "surp_taskReminders" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *text_2* updates + if text_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + text_2.frameNStart = frameN # exact frame index + text_2.tStart = t # local t and not account for scr refresh + text_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(text_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'text_2.started') + text_2.setAutoDraw(True) + + # *task_blockText_2* updates + if task_blockText_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockText_2.frameNStart = frameN # exact frame index + task_blockText_2.tStart = t # local t and not account for scr refresh + task_blockText_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockText_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockText_2.started') + task_blockText_2.setAutoDraw(True) + + # *task_blockReminders_keyResp_2* updates + waitOnFlip = False + if task_blockReminders_keyResp_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockReminders_keyResp_2.frameNStart = frameN # exact frame index + task_blockReminders_keyResp_2.tStart = t # local t and not account for scr refresh + task_blockReminders_keyResp_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockReminders_keyResp_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockReminders_keyResp_2.started') + task_blockReminders_keyResp_2.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(task_blockReminders_keyResp_2.clock.reset) # t=0 on next screen flip + win.callOnFlip(task_blockReminders_keyResp_2.clearEvents, eventType='keyboard') # clear events on next screen flip + if task_blockReminders_keyResp_2.status == STARTED and not waitOnFlip: + theseKeys = task_blockReminders_keyResp_2.getKeys(keyList=['k'], waitRelease=False) + _task_blockReminders_keyResp_2_allKeys.extend(theseKeys) + if len(_task_blockReminders_keyResp_2_allKeys): + task_blockReminders_keyResp_2.keys = _task_blockReminders_keyResp_2_allKeys[-1].name # just the last key pressed + task_blockReminders_keyResp_2.rt = _task_blockReminders_keyResp_2_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in surp_taskRemindersComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "surp_taskReminders" --- + for thisComponent in surp_taskRemindersComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if task_blockReminders_keyResp_2.keys in ['', [], None]: # No response was made + task_blockReminders_keyResp_2.keys = None + surprise_block_loop.addData('task_blockReminders_keyResp_2.keys',task_blockReminders_keyResp_2.keys) + if task_blockReminders_keyResp_2.keys != None: # we had a response + surprise_block_loop.addData('task_blockReminders_keyResp_2.rt', task_blockReminders_keyResp_2.rt) + # the Routine "surp_taskReminders" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # --- Prepare to start Routine "fixation2" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from code_5 + + # make range from a to b in n stepsizes + ISIRange3 = np.linspace(800, 1200, 400) + + # picking from a shuffled array is easier for random selection in JS + shuffle(ISIRange3) + thisISI3 = ISIRange3[0]/1000 # the first item of the shuffled array + surprise_block_loop.addData('thisISI3', thisISI3) + # keep track of which components have finished + fixation2Components = [polygon] + for thisComponent in fixation2Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "fixation2" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *polygon* updates + if polygon.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + polygon.frameNStart = frameN # exact frame index + polygon.tStart = t # local t and not account for scr refresh + polygon.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(polygon, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'polygon.started') + polygon.setAutoDraw(True) + if polygon.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > polygon.tStartRefresh + thisISI3-frameTolerance: + # keep track of stop time/frame for later + polygon.tStop = t # not accounting for scr refresh + polygon.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'polygon.stopped') + polygon.setAutoDraw(False) + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in fixation2Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "fixation2" --- + for thisComponent in fixation2Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # the Routine "fixation2" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # set up handler to look after randomisation of conditions etc + trials = data.TrialHandler(nReps=1.0, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions(whichSurpriseBlock), + seed=None, name='trials') + thisExp.addLoop(trials) # add the loop to the experiment + thisTrial = trials.trialList[0] # so we can initialise stimuli with some values + # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb) + if thisTrial != None: + for paramName in thisTrial: + exec('{} = thisTrial[paramName]'.format(paramName)) + + for thisTrial in trials: + currentLoop = trials + # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb) + if thisTrial != None: + for paramName in thisTrial: + exec('{} = thisTrial[paramName]'.format(paramName)) + + # --- Prepare to start Routine "surpriseTask" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from code_6 + + if which_side_old_face_displayed == 'right': + old_img_position = [13.3, 1] + new_img_position = [-13.3, 1] + elif which_side_old_face_displayed == 'left': + old_img_position = [-13.3, 1] + new_img_position = [13.3, 1] + + old_face_image.setPos(old_img_position) + old_face_image.setImage(old_face_in_surp) + new_face_image.setPos(new_img_position) + new_face_image.setImage(new_face_in_surp) + instructsurpA1_right.setPos((13.3, -5)) + instructsurpA1_right.setText("Right - 'K' Key") + instructsurpA2_left.setText("Left - 'S' Key") + surprise_key_resp.keys = [] + surprise_key_resp.rt = [] + _surprise_key_resp_allKeys = [] + # keep track of which components have finished + surpriseTaskComponents = [text, old_face_image, new_face_image, instructsurpA1_right, instructsurpA2_left, surprise_key_resp] + for thisComponent in surpriseTaskComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "surpriseTask" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *text* updates + if text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + text.frameNStart = frameN # exact frame index + text.tStart = t # local t and not account for scr refresh + text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'text.started') + text.setAutoDraw(True) + + # *old_face_image* updates + if old_face_image.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + old_face_image.frameNStart = frameN # exact frame index + old_face_image.tStart = t # local t and not account for scr refresh + old_face_image.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(old_face_image, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'old_face_image.started') + old_face_image.setAutoDraw(True) + + # *new_face_image* updates + if new_face_image.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + new_face_image.frameNStart = frameN # exact frame index + new_face_image.tStart = t # local t and not account for scr refresh + new_face_image.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(new_face_image, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'new_face_image.started') + new_face_image.setAutoDraw(True) + + # *instructsurpA1_right* updates + if instructsurpA1_right.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructsurpA1_right.frameNStart = frameN # exact frame index + instructsurpA1_right.tStart = t # local t and not account for scr refresh + instructsurpA1_right.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructsurpA1_right, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'instructsurpA1_right.started') + instructsurpA1_right.setAutoDraw(True) + + # *instructsurpA2_left* updates + if instructsurpA2_left.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructsurpA2_left.frameNStart = frameN # exact frame index + instructsurpA2_left.tStart = t # local t and not account for scr refresh + instructsurpA2_left.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructsurpA2_left, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'instructsurpA2_left.started') + instructsurpA2_left.setAutoDraw(True) + + # *surprise_key_resp* updates + waitOnFlip = False + if surprise_key_resp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + surprise_key_resp.frameNStart = frameN # exact frame index + surprise_key_resp.tStart = t # local t and not account for scr refresh + surprise_key_resp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(surprise_key_resp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'surprise_key_resp.started') + surprise_key_resp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(surprise_key_resp.clock.reset) # t=0 on next screen flip + win.callOnFlip(surprise_key_resp.clearEvents, eventType='keyboard') # clear events on next screen flip + if surprise_key_resp.status == STARTED and not waitOnFlip: + theseKeys = surprise_key_resp.getKeys(keyList=['s','k'], waitRelease=False) + _surprise_key_resp_allKeys.extend(theseKeys) + if len(_surprise_key_resp_allKeys): + surprise_key_resp.keys = _surprise_key_resp_allKeys[-1].name # just the last key pressed + surprise_key_resp.rt = _surprise_key_resp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in surpriseTaskComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "surpriseTask" --- + for thisComponent in surpriseTaskComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if surprise_key_resp.keys in ['', [], None]: # No response was made + surprise_key_resp.keys = None + trials.addData('surprise_key_resp.keys',surprise_key_resp.keys) + if surprise_key_resp.keys != None: # we had a response + trials.addData('surprise_key_resp.rt', surprise_key_resp.rt) + # the Routine "surpriseTask" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # --- Prepare to start Routine "fixation2" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from code_5 + + # make range from a to b in n stepsizes + ISIRange3 = np.linspace(800, 1200, 400) + + # picking from a shuffled array is easier for random selection in JS + shuffle(ISIRange3) + thisISI3 = ISIRange3[0]/1000 # the first item of the shuffled array + surprise_block_loop.addData('thisISI3', thisISI3) + # keep track of which components have finished + fixation2Components = [polygon] + for thisComponent in fixation2Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "fixation2" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *polygon* updates + if polygon.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + polygon.frameNStart = frameN # exact frame index + polygon.tStart = t # local t and not account for scr refresh + polygon.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(polygon, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'polygon.started') + polygon.setAutoDraw(True) + if polygon.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > polygon.tStartRefresh + thisISI3-frameTolerance: + # keep track of stop time/frame for later + polygon.tStop = t # not accounting for scr refresh + polygon.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'polygon.stopped') + polygon.setAutoDraw(False) + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in fixation2Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "fixation2" --- + for thisComponent in fixation2Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # the Routine "fixation2" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + + # completed 1.0 repeats of 'trials' + + thisExp.nextEntry() + +# completed 1.0 repeats of 'surprise_block_loop' + + +# --- Prepare to start Routine "ringBell4" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +bellKey_4.keys = [] +bellKey_4.rt = [] +_bellKey_4_allKeys = [] +# keep track of which components have finished +ringBell4Components = [ringBell_text_4, bellKey_4] +for thisComponent in ringBell4Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "ringBell4" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *ringBell_text_4* updates + if ringBell_text_4.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + ringBell_text_4.frameNStart = frameN # exact frame index + ringBell_text_4.tStart = t # local t and not account for scr refresh + ringBell_text_4.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(ringBell_text_4, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'ringBell_text_4.started') + ringBell_text_4.setAutoDraw(True) + + # *bellKey_4* updates + waitOnFlip = False + if bellKey_4.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bellKey_4.frameNStart = frameN # exact frame index + bellKey_4.tStart = t # local t and not account for scr refresh + bellKey_4.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bellKey_4, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bellKey_4.started') + bellKey_4.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(bellKey_4.clock.reset) # t=0 on next screen flip + win.callOnFlip(bellKey_4.clearEvents, eventType='keyboard') # clear events on next screen flip + if bellKey_4.status == STARTED and not waitOnFlip: + theseKeys = bellKey_4.getKeys(keyList=['c'], waitRelease=False) + _bellKey_4_allKeys.extend(theseKeys) + if len(_bellKey_4_allKeys): + bellKey_4.keys = _bellKey_4_allKeys[-1].name # just the last key pressed + bellKey_4.rt = _bellKey_4_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in ringBell4Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "ringBell4" --- +for thisComponent in ringBell4Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if bellKey_4.keys in ['', [], None]: # No response was made + bellKey_4.keys = None +thisExp.addData('bellKey_4.keys',bellKey_4.keys) +if bellKey_4.keys != None: # we had a response + thisExp.addData('bellKey_4.rt', bellKey_4.rt) +thisExp.nextEntry() +# the Routine "ringBell4" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "finishMessage" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# keep track of which components have finished +finishMessageComponents = [finishMessage_text] +for thisComponent in finishMessageComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "finishMessage" --- +while continueRoutine and routineTimer.getTime() < 3.0: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *finishMessage_text* updates + if finishMessage_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + finishMessage_text.frameNStart = frameN # exact frame index + finishMessage_text.tStart = t # local t and not account for scr refresh + finishMessage_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(finishMessage_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'finishMessage_text.started') + finishMessage_text.setAutoDraw(True) + if finishMessage_text.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > finishMessage_text.tStartRefresh + 3-frameTolerance: + # keep track of stop time/frame for later + finishMessage_text.tStop = t # not accounting for scr refresh + finishMessage_text.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'finishMessage_text.stopped') + finishMessage_text.setAutoDraw(False) + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in finishMessageComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "finishMessage" --- +for thisComponent in finishMessageComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# using non-slip timing so subtract the expected duration of this Routine (unless ended on request) +if routineForceEnded: + routineTimer.reset() +else: + routineTimer.addTime(-3.000000) +# Run 'End Experiment' code from setup_code +win.mouseVisible = True #make the mouse cursor visable again + + +# --- End experiment --- +# Flip one final time so any remaining win.callOnFlip() +# and win.timeOnFlip() tasks get executed before quitting +win.flip() + +# these shouldn't be strictly necessary (should auto-save) +thisExp.saveAsWideText(filename+'.csv', delim='auto') +thisExp.saveAsPickle(filename) +logging.flush() +# make sure everything is closed down +if eyetracker: + eyetracker.setConnectionState(False) +thisExp.abort() # or data files will save again on exit +win.close() +core.quit() diff --git a/materials/mfe_e/mfe_e_lastrun.py b/materials/mfe_e/mfe_e_lastrun.py new file mode 100644 index 0000000..8004daf --- /dev/null +++ b/materials/mfe_e/mfe_e_lastrun.py @@ -0,0 +1,4587 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +This experiment was created using PsychoPy3 Experiment Builder (v2022.2.4), + on Wed Oct 23 09:02:59 2024 +If you publish work using this script the most relevant publication is: + + Peirce J, Gray JR, Simpson S, MacAskill M, Höchenberger R, Sogo H, Kastman E, Lindeløv JK. (2019) + PsychoPy2: Experiments in behavior made easy Behav Res 51: 195. + https://doi.org/10.3758/s13428-018-01193-y + +""" + +# --- Import packages --- +from psychopy import locale_setup +from psychopy import prefs +from psychopy import sound, gui, visual, core, data, event, logging, clock, colors, layout +from psychopy.constants import (NOT_STARTED, STARTED, PLAYING, PAUSED, + STOPPED, FINISHED, PRESSED, RELEASED, FOREVER) + +import numpy as np # whole numpy lib is available, prepend 'np.' +from numpy import (sin, cos, tan, log, log10, pi, average, + sqrt, std, deg2rad, rad2deg, linspace, asarray) +from numpy.random import random, randint, normal, shuffle, choice as randchoice +import os # handy system and path functions +import sys # to get file system encoding + +import psychopy.iohub as io +from psychopy.hardware import keyboard + +# Run 'Before Experiment' code from code_6 +# This code will load 8 surprise csv files and then randomly shuffle contents of each column and then saves them. +import os +import numpy as np +import pandas as pd +import pathlib + +# Make a list of files that we need to load +# get the current working directory +current_working_directory = os.getcwd() +input_path = pathlib.Path(current_working_directory) +# input_path = pathlib.Path("/Users/kihossei/Documents/GitHub/mfe_c_face/materials/PsychopyTask/mfe_c_face") +files_list = list(input_path.glob("orig_surp_table*")) +i = 0 # counter that will be used for saved file names + +for item in files_list: + csvFile = pd.read_csv(item) + csvFile['old_face_in_surp'] = np.random.permutation(csvFile['old_face_in_surp'].values) # shuffles rows in this column randomly + csvFile['new_face_in_surp'] = np.random.permutation(csvFile['new_face_in_surp'].values) # shuffles rows in this column randomly + csvFile['which_side_old_face_displayed'] = np.random.permutation(csvFile['which_side_old_face_displayed'].values) # shuffles rows in this column randomly + # saving the dataframe without row number + # Get the current name of the file + current_name = item.name + # Get the new name of the file + i = i + 1 + new_name = "surp_table{0}.csv".format(i) + # Rename the file + new_item = pathlib.Path.joinpath(item.parent, new_name) + csvFile.to_csv(new_item, index = False) + + + + +# Ensure that relative paths start from the same directory as this script +_thisDir = os.path.dirname(os.path.abspath(__file__)) +os.chdir(_thisDir) +# Store info about the experiment session +psychopyVersion = '2022.2.4' +expName = 'mfe_e' # from the Builder filename that created this script +expInfo = { + 'id': '', +} +# --- Show participant info dialog -- +dlg = gui.DlgFromDict(dictionary=expInfo, sortKeys=False, title=expName) +if dlg.OK == False: + core.quit() # user pressed cancel +expInfo['date'] = data.getDateStr() # add a simple timestamp +expInfo['expName'] = expName +expInfo['psychopyVersion'] = psychopyVersion + +# Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc +filename = _thisDir + os.sep + u'data/%s_%s_%s' % (expInfo['id'], expName, expInfo['date']) + +# An ExperimentHandler isn't essential but helps with data saving +thisExp = data.ExperimentHandler(name=expName, version='', + extraInfo=expInfo, runtimeInfo=None, + originPath='/Users/kihossei/Library/CloudStorage/GoogleDrive-hosseinikianoosh@gmail.com/My Drive/My Digital Life/Professional/Github_Repos/mfe-e-dataset/materials/mfe_e/mfe_e_lastrun.py', + savePickle=True, saveWideText=True, + dataFileName=filename) +# save a log file for detail verbose info +logFile = logging.LogFile(filename+'.log', level=logging.DEBUG) +logging.console.setLevel(logging.WARNING) # this outputs to the screen, not a file + +endExpNow = False # flag for 'escape' or other condition => quit the exp +frameTolerance = 0.001 # how close to onset before 'same' frame + +# Start Code - component code to be run after the window creation + +# --- Setup the Window --- +win = visual.Window( + size=[1920, 1080], fullscr=True, screen=0, + winType='pyglet', allowStencil=False, + monitor='dm_200a', color='0.5000, 0.5000, 0.5000', colorSpace='rgb', + blendMode='avg', useFBO=True, + units='height') +win.mouseVisible = False +# store frame rate of monitor if we can measure it +expInfo['frameRate'] = win.getActualFrameRate() +if expInfo['frameRate'] != None: + frameDur = 1.0 / round(expInfo['frameRate']) +else: + frameDur = 1.0 / 60.0 # could not measure, so guess +# --- Setup input devices --- +ioConfig = {} + +# Setup iohub keyboard +ioConfig['Keyboard'] = dict(use_keymap='psychopy') + +ioSession = '1' +if 'session' in expInfo: + ioSession = str(expInfo['session']) +ioServer = io.launchHubServer(window=win, **ioConfig) +eyetracker = None + +# create a default keyboard (e.g. to check for escape) +defaultKeyboard = keyboard.Keyboard(backend='iohub') + +# --- Initialize components for Routine "JS_code" --- + +# --- Initialize components for Routine "setup" --- +# Run 'Begin Experiment' code from setup_code + + +win.mouseVisible = False #hide mouse cursor + + +# --- Initialize components for Routine "welcome" --- +welcome_text = visual.TextStim(win=win, name='welcome_text', + text="Arrow Game\n\nWelcome to the arrow game. In this game, arrows will be quickly flashed on the screen. Your goal is to respond to the direction of the MIDDLE arrow, and to respond as quickly as you can without making mistakes. \n\nIf the MIDDLE arrow is pointing to the right, use your right hand to press the 'K' key on your keyboard. If the MIDDLE arrow is pointing to the left, use your left hand to press the 'S' key on your keyboard. \n\nPress the 'K' key to continue\n", + font='Arial', + units='height', pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +welcome_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "instructRight" --- +instructRight_text = visual.TextStim(win=win, name='instructRight_text', + text="Below, the MIDDLE arrow is pointing to the right, so you would respond by pressing the 'K' key on your keyboard with your right hand.\n\nPress the 'K' key to continue", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +instructRight_centerImg = visual.ImageStim( + win=win, + name='instructRight_centerImg', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(0, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-1.0) +instructRight_rightImg1 = visual.ImageStim( + win=win, + name='instructRight_rightImg1', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +instructRight_leftImg1 = visual.ImageStim( + win=win, + name='instructRight_leftImg1', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(-.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +instructRight_rightImg2 = visual.ImageStim( + win=win, + name='instructRight_rightImg2', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +instructRight_leftImg2 = visual.ImageStim( + win=win, + name='instructRight_leftImg2', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(-.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +insructRight_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "instructLeft" --- +instructLeft_text = visual.TextStim(win=win, name='instructLeft_text', + text="Below, the MIDDLE arrow is pointing to the left, so you would respond by pressing the 'S' key on your keyboard with your left hand.\n\nPress the 'S' key to continue", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +instructLeft_centerImg = visual.ImageStim( + win=win, + name='instructLeft_centerImg', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(0, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-1.0) +instructLeft_rightImg1 = visual.ImageStim( + win=win, + name='instructLeft_rightImg1', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +instructLeft_leftImg1 = visual.ImageStim( + win=win, + name='instructLeft_leftImg1', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(-.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +instructLeft_rightImg2 = visual.ImageStim( + win=win, + name='instructLeft_rightImg2', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +instructLeft_leftImg2 = visual.ImageStim( + win=win, + name='instructLeft_leftImg2', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(-.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +instructLeft_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "instructInconRight" --- +instructInconRight_text = visual.TextStim(win=win, name='instructInconRight_text', + text="Sometimes the MIDDLE arrow will point in a different direction from the other arrows. However, your goal is to always respond based on the direction of the MIDDLE arrow.\n\nBelow, the MIDDLE arrow is pointing to the right, so you would respond by pressing the 'K' key on your keyboard with your right hand.\n\nPress the 'K' key to continue", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +instructIncon_centerImg = visual.ImageStim( + win=win, + name='instructIncon_centerImg', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(0, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-1.0) +instructIncon_rightImg1 = visual.ImageStim( + win=win, + name='instructIncon_rightImg1', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +instructIncon_leftImg1 = visual.ImageStim( + win=win, + name='instructIncon_leftImg1', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(-.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +instructIncon_leftImg2 = visual.ImageStim( + win=win, + name='instructIncon_leftImg2', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(-.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +instructIncon_rightImg2 = visual.ImageStim( + win=win, + name='instructIncon_rightImg2', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +insructInconRight_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "instructInconLeft" --- +instructInconLeft_text = visual.TextStim(win=win, name='instructInconLeft_text', + text="Below, the MIDDLE arrow is pointing to the left, so you would respond by pressing the 'S' key on your keyboard with your left hand.\n\n\nPress the 'S' key to continue", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); +instructInconLeft_centerImg = visual.ImageStim( + win=win, + name='instructInconLeft_centerImg', + image='img/leftArrow.png', mask=None, anchor='center', + ori=0, pos=(0, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-1.0) +instructInconLeft_rightImg1 = visual.ImageStim( + win=win, + name='instructInconLeft_rightImg1', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +instructInconLeft_leftImg1 = visual.ImageStim( + win=win, + name='instructInconLeft_leftImg1', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(-.03, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +instructInconLeft_rightImg2 = visual.ImageStim( + win=win, + name='instructInconLeft_rightImg2', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +instructInconLeft_leftImg2 = visual.ImageStim( + win=win, + name='instructInconLeft_leftImg2', + image='img/rightArrow.png', mask=None, anchor='center', + ori=0, pos=(-.06, -.3), size=(.02, .02), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +instructInconLeft_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "prac_blockReminders" --- +# Run 'Begin Experiment' code from prac_initAcc_code +#initialize the following variables at the start of experiment +trialNum = 0 +accuracy = 0 +numCorr = 0 +blockAcc = 0 +prac_blockText = visual.TextStim(win=win, name='prac_blockText', + text='Practice', + font='Arial', + pos=(0, .3), height=0.06, wrapWidth=1.3, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +prac_reminder_text = visual.TextStim(win=win, name='prac_reminder_text', + text="You will now practice responding to the arrows. Remember to always respond to the direction of the MIDDLE arrow.\n\nRespond as quickly as you can without making mistakes.\n\nTo get ready, rest your right and left index fingers on the 'K' and 'S' keys of your keyboard, then press the 'K' key when you are ready to begin.\n", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-2.0); +prac_reminder_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "initFixation" --- +initFixation_img = visual.ImageStim( + win=win, + name='initFixation_img', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=0.0) +static_preloader = clock.StaticPeriod(win=win, screenHz=expInfo['frameRate'], name='static_preloader') + +# --- Initialize components for Routine "prac_stimRoutine" --- +# Run 'Begin Experiment' code from prac_isi_code +#initialize the thisISI variable +this_faceDuration = 0 +prac_cover_background = visual.ImageStim( + win=win, + name='prac_cover_background', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=None, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-1.0) +prac_centerImg = visual.ImageStim( + win=win, + name='prac_centerImg', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +prac_rightImg1 = visual.ImageStim( + win=win, + name='prac_rightImg1', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +prac_rightImg2 = visual.ImageStim( + win=win, + name='prac_rightImg2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +prac_leftImg1 = visual.ImageStim( + win=win, + name='prac_leftImg1', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +prac_leftImg2 = visual.ImageStim( + win=win, + name='prac_leftImg2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-6.0) +prac_fixImg = visual.ImageStim( + win=win, + name='prac_fixImg', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-7.0) +prac_stim_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "prac_face_disp" --- +# Run 'Begin Experiment' code from prac_remaining_isi_code +# face_delay is the delay between participant response and the appearance of the face image. +# I create the list below and will pick random numbers from during the face_disp routines. +# The delay is between 0 and 1000 ms in steps of 33. +face_delay = [i / 1000 for i in list(range(0, 1001, 33))] +prac_delayed_face = visual.ImageStim( + win=win, + name='prac_delayed_face', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=(0., 0.0), size=(13.59, 9.55), + color=[1,1,1], colorSpace='rgb', opacity=0.85, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-1.0) +prac_fixImg_2 = visual.ImageStim( + win=win, + name='prac_fixImg_2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +prac_stim_keyResp2 = keyboard.Keyboard() + +# --- Initialize components for Routine "prac_blockFeed" --- +prac_blockFeed_text = visual.TextStim(win=win, name='prac_blockFeed_text', + text='', + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-1.0); +prac_pressContinue = visual.TextStim(win=win, name='prac_pressContinue', + text="Press the 'K' key", + font='Arial', + pos=(0, -.3), height=0.04, wrapWidth=1.3, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-2.0); +prac_blockFeed_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "ringBell" --- +ringBell_text = visual.TextStim(win=win, name='ringBell_text', + text='Ring the bell to let the experimenter know that you finished the practice.', + font='Open Sans', + pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +bellKey = keyboard.Keyboard() + +# --- Initialize components for Routine "task_blockReminders" --- +# Run 'Begin Experiment' code from task_blockReminder_code +#initialize the following variables at the start of experiment +blockCounter = 0 + +#note that we do not need to initialize the accuracy and numCorr vars here +#because they were already initialilzed in the code snippet of the practice loop +task_blockText = visual.TextStim(win=win, name='task_blockText', + text='', + font='Arial', + pos=(0, .3), height=0.06, wrapWidth=1.3, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +task_blockReminders_text = visual.TextStim(win=win, name='task_blockReminders_text', + text="Remember to always respond to the direction of the MIDDLE arrow.\n\nRespond as quickly as you can without making mistakes.\n\nTo get ready, rest your right and left index fingers on the 'K' and 'S' keys of your keyboard, then press the 'K' key when you are ready to begin.\n\n", + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-2.0); +task_blockReminders_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "initFixation" --- +initFixation_img = visual.ImageStim( + win=win, + name='initFixation_img', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=0.0) +static_preloader = clock.StaticPeriod(win=win, screenHz=expInfo['frameRate'], name='static_preloader') + +# --- Initialize components for Routine "task_stimRoutine" --- +# Run 'Begin Experiment' code from task_isi_code +#no need to initialize this_faceDuration, as already done in practice code snippit +cover_background = visual.ImageStim( + win=win, + name='cover_background', units='deg', + image='img/cover_background.png', mask=None, anchor='center', + ori=0.0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=None, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-1.0) +task_centerImg = visual.ImageStim( + win=win, + name='task_centerImg', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +task_rightImg1 = visual.ImageStim( + win=win, + name='task_rightImg1', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-3.0) +task_rightImg2 = visual.ImageStim( + win=win, + name='task_rightImg2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-4.0) +task_leftImg1 = visual.ImageStim( + win=win, + name='task_leftImg1', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-5.0) +task_leftImg2 = visual.ImageStim( + win=win, + name='task_leftImg2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=[0,0], size=1.0, + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-6.0) +task_fixImg = visual.ImageStim( + win=win, + name='task_fixImg', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-7.0) +task1_stim_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "task_face_disp" --- +task_delayed_face = visual.ImageStim( + win=win, + name='task_delayed_face', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=(0., 0.0), size=(13.59, 9.55), + color=[1,1,1], colorSpace='rgb', opacity=0.85, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-1.0) +task_fixImg_2 = visual.ImageStim( + win=win, + name='task_fixImg_2', units='deg', + image='sin', mask=None, anchor='center', + ori=0, pos=(0, -.45), size=(8.29, 6.534), + color=[1,1,1], colorSpace='rgb', opacity=1, + flipHoriz=False, flipVert=False, + texRes=512, interpolate=True, depth=-2.0) +task_stim_keyResp2 = keyboard.Keyboard() + +# --- Initialize components for Routine "task_blockFeed" --- +task_blockFeed_text = visual.TextStim(win=win, name='task_blockFeed_text', + text='', + font='Arial', + pos=(0, 0.1), height=0.12, wrapWidth=1.8, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-1.0); +task_blockFeed_text2 = visual.TextStim(win=win, name='task_blockFeed_text2', + text='', + font='Arial', + pos=(0, -0.3), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=-2.0); +task_blockFeed_keyResp = keyboard.Keyboard() + +# --- Initialize components for Routine "ringBell2" --- +ringBell_text_2 = visual.TextStim(win=win, name='ringBell_text_2', + text='Please ring the bell to let the experimenter know you finished the game.', + font='Open Sans', + pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +bellKey_2 = keyboard.Keyboard() + +# --- Initialize components for Routine "errorNumbers" --- +errorNumbers_text_2 = visual.TextStim(win=win, name='errorNumbers_text_2', + text="Excluding the practice, How many errors do you think you made in this game?\n\nPlease provide a number as your best estimate.\n\n\nPlease enter your answer using the keyboard. \nAfter entering your answer, press the 'Space' key to continue", + font='Open Sans', + pos=(0, 0.12), height=0.03, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +errorNum_text_box = visual.TextBox2( + win, text=None, font='Open Sans', + pos=(0, -0.3), letterHeight=0.05, + size=(0.2, 0.2), borderWidth=2.0, + color=[-1.0000, -1.0000, -1.0000], colorSpace='rgb', + opacity=None, + bold=True, italic=False, + lineSpacing=1.0, + padding=0.0, alignment='center', + anchor='bottom-center', + fillColor=[1.0000, 1.0000, 1.0000], borderColor=[-1.0000, -1.0000, -1.0000], + flipHoriz=False, flipVert=False, languageStyle='LTR', + editable=True, + name='errorNum_text_box', + autoLog=True, +) +errorN_key_resp_2 = keyboard.Keyboard() + +# --- Initialize components for Routine "errorPercentage" --- +errorNumbers_text_3 = visual.TextStim(win=win, name='errorNumbers_text_3', + text="Excluding the practice, what percentage of your responses do you think were errors during the arrow game? \n\nPlease provide a number as your best estimate.\n\nPlease enter your answer using the keyboard. \nAfter entering your answer, press the 'Space' key to continue", + font='Open Sans', + pos=(0, 0.12), height=0.03, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +errorPercent_text_box = visual.TextBox2( + win, text=None, font='Open Sans', + pos=(0, -0.3), letterHeight=0.05, + size=(0.2, 0.2), borderWidth=2.0, + color=[-1.0000, -1.0000, -1.0000], colorSpace='rgb', + opacity=None, + bold=True, italic=False, + lineSpacing=1.0, + padding=0.0, alignment='center', + anchor='bottom-center', + fillColor=[1.0000, 1.0000, 1.0000], borderColor=[-1.0000, -1.0000, -1.0000], + flipHoriz=False, flipVert=False, languageStyle='LTR', + editable=True, + name='errorPercent_text_box', + autoLog=True, +) +errorN_key_resp_3 = keyboard.Keyboard() + +# --- Initialize components for Routine "botherRate" --- +botherRate_text = visual.TextStim(win=win, name='botherRate_text', + text="How much did it bother you when you made an error during the arrow game? \n\nYour answer should be on a scale from 0 (not at all) to 10 (very much). \n\n\nPlease enter your answer using the keyboard. \nAfter entering your answer, press the 'Space' key to continue", + font='Open Sans', + pos=(0, 0.12), height=0.03, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +bother_text_box = visual.TextBox2( + win, text=None, font='Open Sans', + pos=(0, -0.3), letterHeight=0.05, + size=(0.2, 0.2), borderWidth=2.0, + color=[-1.0000, -1.0000, -1.0000], colorSpace='rgb', + opacity=None, + bold=True, italic=False, + lineSpacing=1.0, + padding=0.0, alignment='center', + anchor='bottom-center', + fillColor=[1.0000, 1.0000, 1.0000], borderColor=[-1.0000, -1.0000, -1.0000], + flipHoriz=False, flipVert=False, languageStyle='LTR', + editable=True, + name='bother_text_box', + autoLog=True, +) +botherRate_key_resp = keyboard.Keyboard() + +# --- Initialize components for Routine "ringBell3" --- +ringBell_text_3 = visual.TextStim(win=win, name='ringBell_text_3', + text='Ring the bell to let the experimenter know when you complete answering the surveys.', + font='Open Sans', + pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +bellKey_3 = keyboard.Keyboard() + +# --- Initialize components for Routine "surpriseInstruct" --- +instruct_surprise1 = visual.TextStim(win=win, name='instruct_surprise1', + text='You will now begin a task in which you will be shown two images of faces. Then, you need to choose the face image that you think you have seen in the previous Arrow game (old face).\n\nFor example:\n\nIf the face image on the right side is the one you think you have seen in the Arrow game, press the K key.\n\nIf the face image on the left side is the one you think you have seen in the Arrow game, press the S key.\n\nPlease press the K key to continue.', + font='Open Sans', + pos=(0, 0), height=0.04, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +instruct_surp1_key_resp = keyboard.Keyboard() + +# --- Initialize components for Routine "surp_taskReminders" --- +# Run 'Begin Experiment' code from task_blockReminder_code_2 +#initialize the following variables at the start of experiment +blockCounterZ1 = 0 +blockNumText = "" + +text_2 = visual.TextStim(win=win, name='text_2', + text='', + font='Open Sans', + pos=(0, .3), height=0.06, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +task_blockText_2 = visual.TextStim(win=win, name='task_blockText_2', + text='', + font='Open Sans', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-2.0); +task_blockReminders_keyResp_2 = keyboard.Keyboard() + +# --- Initialize components for Routine "fixation2" --- +polygon = visual.ShapeStim( + win=win, name='polygon', vertices='cross', + size=(0.05, 0.05), + ori=0.0, pos=(0, 0), anchor='center', + lineWidth=1.0, colorSpace='rgb', lineColor='white', fillColor='white', + opacity=None, depth=-1.0, interpolate=True) + +# --- Initialize components for Routine "surpriseTask" --- +# Run 'Begin Experiment' code from code_6 +old_img_position = [0, 0] +new_img_position = [0, 0] +text = visual.TextStim(win=win, name='text', + text='Choose the face you have seen before (old)', + font='Open Sans', + units='deg', pos=(0, 10), height=1.5, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-1.0); +old_face_image = visual.ImageStim( + win=win, + name='old_face_image', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=[0,0], size=(13.59, 9.55), + color=[1,1,1], colorSpace='rgb', opacity=None, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-2.0) +new_face_image = visual.ImageStim( + win=win, + name='new_face_image', units='deg', + image='sin', mask=None, anchor='center', + ori=0.0, pos=[0,0], size=(13.59, 9.55), + color=[1,1,1], colorSpace='rgb', opacity=None, + flipHoriz=False, flipVert=False, + texRes=128.0, interpolate=True, depth=-3.0) +instructsurpA1_right = visual.TextStim(win=win, name='instructsurpA1_right', + text='', + font='Open Sans', + units='deg', pos=[0,0], height=1.2, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-4.0); +instructsurpA2_left = visual.TextStim(win=win, name='instructsurpA2_left', + text='', + font='Open Sans', + units='deg', pos=(-13.3, -5), height=1.2, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=-5.0); +surprise_key_resp = keyboard.Keyboard() + +# --- Initialize components for Routine "fixation2" --- +polygon = visual.ShapeStim( + win=win, name='polygon', vertices='cross', + size=(0.05, 0.05), + ori=0.0, pos=(0, 0), anchor='center', + lineWidth=1.0, colorSpace='rgb', lineColor='white', fillColor='white', + opacity=None, depth=-1.0, interpolate=True) + +# --- Initialize components for Routine "ringBell4" --- +ringBell_text_4 = visual.TextStim(win=win, name='ringBell_text_4', + text='Ring the bell to let the experimenter know you completed the game.', + font='Open Sans', + pos=(0, 0), height=0.05, wrapWidth=None, ori=0.0, + color='white', colorSpace='rgb', opacity=None, + languageStyle='LTR', + depth=0.0); +bellKey_4 = keyboard.Keyboard() + +# --- Initialize components for Routine "finishMessage" --- +finishMessage_text = visual.TextStim(win=win, name='finishMessage_text', + text='Thank you for your participation!', + font='Arial', + pos=(0, 0), height=0.04, wrapWidth=1.3, ori=0, + color='white', colorSpace='rgb', opacity=1, + languageStyle='LTR', + depth=0.0); + +# Create some handy timers +globalClock = core.Clock() # to track the time since experiment started +routineTimer = core.Clock() # to track time remaining of each (possibly non-slip) routine + +# --- Prepare to start Routine "JS_code" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# keep track of which components have finished +JS_codeComponents = [] +for thisComponent in JS_codeComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "JS_code" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in JS_codeComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "JS_code" --- +for thisComponent in JS_codeComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "JS_code" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "setup" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# keep track of which components have finished +setupComponents = [] +for thisComponent in setupComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "setup" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in setupComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "setup" --- +for thisComponent in setupComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "setup" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "welcome" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +welcome_keyResp.keys = [] +welcome_keyResp.rt = [] +_welcome_keyResp_allKeys = [] +# keep track of which components have finished +welcomeComponents = [welcome_text, welcome_keyResp] +for thisComponent in welcomeComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "welcome" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *welcome_text* updates + if welcome_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + welcome_text.frameNStart = frameN # exact frame index + welcome_text.tStart = t # local t and not account for scr refresh + welcome_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(welcome_text, 'tStartRefresh') # time at next scr refresh + welcome_text.setAutoDraw(True) + + # *welcome_keyResp* updates + waitOnFlip = False + if welcome_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + welcome_keyResp.frameNStart = frameN # exact frame index + welcome_keyResp.tStart = t # local t and not account for scr refresh + welcome_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(welcome_keyResp, 'tStartRefresh') # time at next scr refresh + welcome_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(welcome_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(welcome_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if welcome_keyResp.status == STARTED and not waitOnFlip: + theseKeys = welcome_keyResp.getKeys(keyList=['k'], waitRelease=False) + _welcome_keyResp_allKeys.extend(theseKeys) + if len(_welcome_keyResp_allKeys): + welcome_keyResp.keys = _welcome_keyResp_allKeys[-1].name # just the last key pressed + welcome_keyResp.rt = _welcome_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in welcomeComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "welcome" --- +for thisComponent in welcomeComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "welcome" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "instructRight" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +insructRight_keyResp.keys = [] +insructRight_keyResp.rt = [] +_insructRight_keyResp_allKeys = [] +# keep track of which components have finished +instructRightComponents = [instructRight_text, instructRight_centerImg, instructRight_rightImg1, instructRight_leftImg1, instructRight_rightImg2, instructRight_leftImg2, insructRight_keyResp] +for thisComponent in instructRightComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "instructRight" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instructRight_text* updates + if instructRight_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_text.frameNStart = frameN # exact frame index + instructRight_text.tStart = t # local t and not account for scr refresh + instructRight_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_text, 'tStartRefresh') # time at next scr refresh + instructRight_text.setAutoDraw(True) + + # *instructRight_centerImg* updates + if instructRight_centerImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_centerImg.frameNStart = frameN # exact frame index + instructRight_centerImg.tStart = t # local t and not account for scr refresh + instructRight_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_centerImg, 'tStartRefresh') # time at next scr refresh + instructRight_centerImg.setAutoDraw(True) + + # *instructRight_rightImg1* updates + if instructRight_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_rightImg1.frameNStart = frameN # exact frame index + instructRight_rightImg1.tStart = t # local t and not account for scr refresh + instructRight_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_rightImg1, 'tStartRefresh') # time at next scr refresh + instructRight_rightImg1.setAutoDraw(True) + + # *instructRight_leftImg1* updates + if instructRight_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_leftImg1.frameNStart = frameN # exact frame index + instructRight_leftImg1.tStart = t # local t and not account for scr refresh + instructRight_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_leftImg1, 'tStartRefresh') # time at next scr refresh + instructRight_leftImg1.setAutoDraw(True) + + # *instructRight_rightImg2* updates + if instructRight_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_rightImg2.frameNStart = frameN # exact frame index + instructRight_rightImg2.tStart = t # local t and not account for scr refresh + instructRight_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_rightImg2, 'tStartRefresh') # time at next scr refresh + instructRight_rightImg2.setAutoDraw(True) + + # *instructRight_leftImg2* updates + if instructRight_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructRight_leftImg2.frameNStart = frameN # exact frame index + instructRight_leftImg2.tStart = t # local t and not account for scr refresh + instructRight_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructRight_leftImg2, 'tStartRefresh') # time at next scr refresh + instructRight_leftImg2.setAutoDraw(True) + + # *insructRight_keyResp* updates + waitOnFlip = False + if insructRight_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + insructRight_keyResp.frameNStart = frameN # exact frame index + insructRight_keyResp.tStart = t # local t and not account for scr refresh + insructRight_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(insructRight_keyResp, 'tStartRefresh') # time at next scr refresh + insructRight_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(insructRight_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(insructRight_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if insructRight_keyResp.status == STARTED and not waitOnFlip: + theseKeys = insructRight_keyResp.getKeys(keyList=['k'], waitRelease=False) + _insructRight_keyResp_allKeys.extend(theseKeys) + if len(_insructRight_keyResp_allKeys): + insructRight_keyResp.keys = _insructRight_keyResp_allKeys[-1].name # just the last key pressed + insructRight_keyResp.rt = _insructRight_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in instructRightComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "instructRight" --- +for thisComponent in instructRightComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "instructRight" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "instructLeft" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +instructLeft_keyResp.keys = [] +instructLeft_keyResp.rt = [] +_instructLeft_keyResp_allKeys = [] +# keep track of which components have finished +instructLeftComponents = [instructLeft_text, instructLeft_centerImg, instructLeft_rightImg1, instructLeft_leftImg1, instructLeft_rightImg2, instructLeft_leftImg2, instructLeft_keyResp] +for thisComponent in instructLeftComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "instructLeft" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instructLeft_text* updates + if instructLeft_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_text.frameNStart = frameN # exact frame index + instructLeft_text.tStart = t # local t and not account for scr refresh + instructLeft_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_text, 'tStartRefresh') # time at next scr refresh + instructLeft_text.setAutoDraw(True) + + # *instructLeft_centerImg* updates + if instructLeft_centerImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_centerImg.frameNStart = frameN # exact frame index + instructLeft_centerImg.tStart = t # local t and not account for scr refresh + instructLeft_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_centerImg, 'tStartRefresh') # time at next scr refresh + instructLeft_centerImg.setAutoDraw(True) + + # *instructLeft_rightImg1* updates + if instructLeft_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_rightImg1.frameNStart = frameN # exact frame index + instructLeft_rightImg1.tStart = t # local t and not account for scr refresh + instructLeft_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_rightImg1, 'tStartRefresh') # time at next scr refresh + instructLeft_rightImg1.setAutoDraw(True) + + # *instructLeft_leftImg1* updates + if instructLeft_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_leftImg1.frameNStart = frameN # exact frame index + instructLeft_leftImg1.tStart = t # local t and not account for scr refresh + instructLeft_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_leftImg1, 'tStartRefresh') # time at next scr refresh + instructLeft_leftImg1.setAutoDraw(True) + + # *instructLeft_rightImg2* updates + if instructLeft_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_rightImg2.frameNStart = frameN # exact frame index + instructLeft_rightImg2.tStart = t # local t and not account for scr refresh + instructLeft_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_rightImg2, 'tStartRefresh') # time at next scr refresh + instructLeft_rightImg2.setAutoDraw(True) + + # *instructLeft_leftImg2* updates + if instructLeft_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_leftImg2.frameNStart = frameN # exact frame index + instructLeft_leftImg2.tStart = t # local t and not account for scr refresh + instructLeft_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_leftImg2, 'tStartRefresh') # time at next scr refresh + instructLeft_leftImg2.setAutoDraw(True) + + # *instructLeft_keyResp* updates + waitOnFlip = False + if instructLeft_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructLeft_keyResp.frameNStart = frameN # exact frame index + instructLeft_keyResp.tStart = t # local t and not account for scr refresh + instructLeft_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructLeft_keyResp, 'tStartRefresh') # time at next scr refresh + instructLeft_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(instructLeft_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(instructLeft_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if instructLeft_keyResp.status == STARTED and not waitOnFlip: + theseKeys = instructLeft_keyResp.getKeys(keyList=['s'], waitRelease=False) + _instructLeft_keyResp_allKeys.extend(theseKeys) + if len(_instructLeft_keyResp_allKeys): + instructLeft_keyResp.keys = _instructLeft_keyResp_allKeys[-1].name # just the last key pressed + instructLeft_keyResp.rt = _instructLeft_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in instructLeftComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "instructLeft" --- +for thisComponent in instructLeftComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "instructLeft" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "instructInconRight" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +insructInconRight_keyResp.keys = [] +insructInconRight_keyResp.rt = [] +_insructInconRight_keyResp_allKeys = [] +# keep track of which components have finished +instructInconRightComponents = [instructInconRight_text, instructIncon_centerImg, instructIncon_rightImg1, instructIncon_leftImg1, instructIncon_leftImg2, instructIncon_rightImg2, insructInconRight_keyResp] +for thisComponent in instructInconRightComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "instructInconRight" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instructInconRight_text* updates + if instructInconRight_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconRight_text.frameNStart = frameN # exact frame index + instructInconRight_text.tStart = t # local t and not account for scr refresh + instructInconRight_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconRight_text, 'tStartRefresh') # time at next scr refresh + instructInconRight_text.setAutoDraw(True) + + # *instructIncon_centerImg* updates + if instructIncon_centerImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_centerImg.frameNStart = frameN # exact frame index + instructIncon_centerImg.tStart = t # local t and not account for scr refresh + instructIncon_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_centerImg, 'tStartRefresh') # time at next scr refresh + instructIncon_centerImg.setAutoDraw(True) + + # *instructIncon_rightImg1* updates + if instructIncon_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_rightImg1.frameNStart = frameN # exact frame index + instructIncon_rightImg1.tStart = t # local t and not account for scr refresh + instructIncon_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_rightImg1, 'tStartRefresh') # time at next scr refresh + instructIncon_rightImg1.setAutoDraw(True) + + # *instructIncon_leftImg1* updates + if instructIncon_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_leftImg1.frameNStart = frameN # exact frame index + instructIncon_leftImg1.tStart = t # local t and not account for scr refresh + instructIncon_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_leftImg1, 'tStartRefresh') # time at next scr refresh + instructIncon_leftImg1.setAutoDraw(True) + + # *instructIncon_leftImg2* updates + if instructIncon_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_leftImg2.frameNStart = frameN # exact frame index + instructIncon_leftImg2.tStart = t # local t and not account for scr refresh + instructIncon_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_leftImg2, 'tStartRefresh') # time at next scr refresh + instructIncon_leftImg2.setAutoDraw(True) + + # *instructIncon_rightImg2* updates + if instructIncon_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructIncon_rightImg2.frameNStart = frameN # exact frame index + instructIncon_rightImg2.tStart = t # local t and not account for scr refresh + instructIncon_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructIncon_rightImg2, 'tStartRefresh') # time at next scr refresh + instructIncon_rightImg2.setAutoDraw(True) + + # *insructInconRight_keyResp* updates + waitOnFlip = False + if insructInconRight_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + insructInconRight_keyResp.frameNStart = frameN # exact frame index + insructInconRight_keyResp.tStart = t # local t and not account for scr refresh + insructInconRight_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(insructInconRight_keyResp, 'tStartRefresh') # time at next scr refresh + insructInconRight_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(insructInconRight_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(insructInconRight_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if insructInconRight_keyResp.status == STARTED and not waitOnFlip: + theseKeys = insructInconRight_keyResp.getKeys(keyList=['k'], waitRelease=False) + _insructInconRight_keyResp_allKeys.extend(theseKeys) + if len(_insructInconRight_keyResp_allKeys): + insructInconRight_keyResp.keys = _insructInconRight_keyResp_allKeys[-1].name # just the last key pressed + insructInconRight_keyResp.rt = _insructInconRight_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in instructInconRightComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "instructInconRight" --- +for thisComponent in instructInconRightComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "instructInconRight" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "instructInconLeft" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +instructInconLeft_keyResp.keys = [] +instructInconLeft_keyResp.rt = [] +_instructInconLeft_keyResp_allKeys = [] +# keep track of which components have finished +instructInconLeftComponents = [instructInconLeft_text, instructInconLeft_centerImg, instructInconLeft_rightImg1, instructInconLeft_leftImg1, instructInconLeft_rightImg2, instructInconLeft_leftImg2, instructInconLeft_keyResp] +for thisComponent in instructInconLeftComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "instructInconLeft" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instructInconLeft_text* updates + if instructInconLeft_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_text.frameNStart = frameN # exact frame index + instructInconLeft_text.tStart = t # local t and not account for scr refresh + instructInconLeft_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_text, 'tStartRefresh') # time at next scr refresh + instructInconLeft_text.setAutoDraw(True) + + # *instructInconLeft_centerImg* updates + if instructInconLeft_centerImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_centerImg.frameNStart = frameN # exact frame index + instructInconLeft_centerImg.tStart = t # local t and not account for scr refresh + instructInconLeft_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_centerImg, 'tStartRefresh') # time at next scr refresh + instructInconLeft_centerImg.setAutoDraw(True) + + # *instructInconLeft_rightImg1* updates + if instructInconLeft_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_rightImg1.frameNStart = frameN # exact frame index + instructInconLeft_rightImg1.tStart = t # local t and not account for scr refresh + instructInconLeft_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_rightImg1, 'tStartRefresh') # time at next scr refresh + instructInconLeft_rightImg1.setAutoDraw(True) + + # *instructInconLeft_leftImg1* updates + if instructInconLeft_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_leftImg1.frameNStart = frameN # exact frame index + instructInconLeft_leftImg1.tStart = t # local t and not account for scr refresh + instructInconLeft_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_leftImg1, 'tStartRefresh') # time at next scr refresh + instructInconLeft_leftImg1.setAutoDraw(True) + + # *instructInconLeft_rightImg2* updates + if instructInconLeft_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_rightImg2.frameNStart = frameN # exact frame index + instructInconLeft_rightImg2.tStart = t # local t and not account for scr refresh + instructInconLeft_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_rightImg2, 'tStartRefresh') # time at next scr refresh + instructInconLeft_rightImg2.setAutoDraw(True) + + # *instructInconLeft_leftImg2* updates + if instructInconLeft_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_leftImg2.frameNStart = frameN # exact frame index + instructInconLeft_leftImg2.tStart = t # local t and not account for scr refresh + instructInconLeft_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_leftImg2, 'tStartRefresh') # time at next scr refresh + instructInconLeft_leftImg2.setAutoDraw(True) + + # *instructInconLeft_keyResp* updates + waitOnFlip = False + if instructInconLeft_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructInconLeft_keyResp.frameNStart = frameN # exact frame index + instructInconLeft_keyResp.tStart = t # local t and not account for scr refresh + instructInconLeft_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructInconLeft_keyResp, 'tStartRefresh') # time at next scr refresh + instructInconLeft_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(instructInconLeft_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(instructInconLeft_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if instructInconLeft_keyResp.status == STARTED and not waitOnFlip: + theseKeys = instructInconLeft_keyResp.getKeys(keyList=['s'], waitRelease=False) + _instructInconLeft_keyResp_allKeys.extend(theseKeys) + if len(_instructInconLeft_keyResp_allKeys): + instructInconLeft_keyResp.keys = _instructInconLeft_keyResp_allKeys[-1].name # just the last key pressed + instructInconLeft_keyResp.rt = _instructInconLeft_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in instructInconLeftComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "instructInconLeft" --- +for thisComponent in instructInconLeftComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# the Routine "instructInconLeft" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# set up handler to look after randomisation of conditions etc +prac_block_loop = data.TrialHandler(nReps=999, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions('blockSelect_practice.csv'), + seed=None, name='prac_block_loop') +thisExp.addLoop(prac_block_loop) # add the loop to the experiment +thisPrac_block_loop = prac_block_loop.trialList[0] # so we can initialise stimuli with some values +# abbreviate parameter names if possible (e.g. rgb = thisPrac_block_loop.rgb) +if thisPrac_block_loop != None: + for paramName in thisPrac_block_loop: + exec('{} = thisPrac_block_loop[paramName]'.format(paramName)) + +for thisPrac_block_loop in prac_block_loop: + currentLoop = prac_block_loop + # abbreviate parameter names if possible (e.g. rgb = thisPrac_block_loop.rgb) + if thisPrac_block_loop != None: + for paramName in thisPrac_block_loop: + exec('{} = thisPrac_block_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "prac_blockReminders" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + prac_reminder_keyResp.keys = [] + prac_reminder_keyResp.rt = [] + _prac_reminder_keyResp_allKeys = [] + # keep track of which components have finished + prac_blockRemindersComponents = [prac_blockText, prac_reminder_text, prac_reminder_keyResp] + for thisComponent in prac_blockRemindersComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "prac_blockReminders" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *prac_blockText* updates + if prac_blockText.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_blockText.frameNStart = frameN # exact frame index + prac_blockText.tStart = t # local t and not account for scr refresh + prac_blockText.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_blockText, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_blockText.started') + prac_blockText.setAutoDraw(True) + + # *prac_reminder_text* updates + if prac_reminder_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_reminder_text.frameNStart = frameN # exact frame index + prac_reminder_text.tStart = t # local t and not account for scr refresh + prac_reminder_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_reminder_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_reminder_text.started') + prac_reminder_text.setAutoDraw(True) + + # *prac_reminder_keyResp* updates + waitOnFlip = False + if prac_reminder_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_reminder_keyResp.frameNStart = frameN # exact frame index + prac_reminder_keyResp.tStart = t # local t and not account for scr refresh + prac_reminder_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_reminder_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_reminder_keyResp.started') + prac_reminder_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(prac_reminder_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(prac_reminder_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if prac_reminder_keyResp.status == STARTED and not waitOnFlip: + theseKeys = prac_reminder_keyResp.getKeys(keyList=['k'], waitRelease=False) + _prac_reminder_keyResp_allKeys.extend(theseKeys) + if len(_prac_reminder_keyResp_allKeys): + prac_reminder_keyResp.keys = _prac_reminder_keyResp_allKeys[-1].name # just the last key pressed + prac_reminder_keyResp.rt = _prac_reminder_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in prac_blockRemindersComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "prac_blockReminders" --- + for thisComponent in prac_blockRemindersComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if prac_reminder_keyResp.keys in ['', [], None]: # No response was made + prac_reminder_keyResp.keys = None + prac_block_loop.addData('prac_reminder_keyResp.keys',prac_reminder_keyResp.keys) + if prac_reminder_keyResp.keys != None: # we had a response + prac_block_loop.addData('prac_reminder_keyResp.rt', prac_reminder_keyResp.rt) + # the Routine "prac_blockReminders" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # --- Prepare to start Routine "initFixation" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + initFixation_img.setImage('img/transp_fixation.png') + # keep track of which components have finished + initFixationComponents = [initFixation_img, static_preloader] + for thisComponent in initFixationComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "initFixation" --- + while continueRoutine and routineTimer.getTime() < 2.0: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *initFixation_img* updates + if initFixation_img.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + initFixation_img.frameNStart = frameN # exact frame index + initFixation_img.tStart = t # local t and not account for scr refresh + initFixation_img.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(initFixation_img, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'initFixation_img.started') + initFixation_img.setAutoDraw(True) + if initFixation_img.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > initFixation_img.tStartRefresh + 2-frameTolerance: + # keep track of stop time/frame for later + initFixation_img.tStop = t # not accounting for scr refresh + initFixation_img.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'initFixation_img.stopped') + initFixation_img.setAutoDraw(False) + # *static_preloader* period + if static_preloader.status == NOT_STARTED and t >= 0-frameTolerance: + # keep track of start time/frame for later + static_preloader.frameNStart = frameN # exact frame index + static_preloader.tStart = t # local t and not account for scr refresh + static_preloader.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(static_preloader, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.addData('static_preloader.started', t) + static_preloader.start(2) + elif static_preloader.status == STARTED: # one frame should pass before updating params and completing + static_preloader.complete() # finish the static period + static_preloader.tStop = static_preloader.tStart + 2 # record stop time + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in initFixationComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "initFixation" --- + for thisComponent in initFixationComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # using non-slip timing so subtract the expected duration of this Routine (unless ended on request) + if routineForceEnded: + routineTimer.reset() + else: + routineTimer.addTime(-2.000000) + + # set up handler to look after randomisation of conditions etc + prac_trial_loop = data.TrialHandler(nReps=1, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions(whichBlock), + seed=None, name='prac_trial_loop') + thisExp.addLoop(prac_trial_loop) # add the loop to the experiment + thisPrac_trial_loop = prac_trial_loop.trialList[0] # so we can initialise stimuli with some values + # abbreviate parameter names if possible (e.g. rgb = thisPrac_trial_loop.rgb) + if thisPrac_trial_loop != None: + for paramName in thisPrac_trial_loop: + exec('{} = thisPrac_trial_loop[paramName]'.format(paramName)) + + for thisPrac_trial_loop in prac_trial_loop: + currentLoop = prac_trial_loop + # abbreviate parameter names if possible (e.g. rgb = thisPrac_trial_loop.rgb) + if thisPrac_trial_loop != None: + for paramName in thisPrac_trial_loop: + exec('{} = thisPrac_trial_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "prac_stimRoutine" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from prac_isi_code + # pick the faceDuration (the amount the face will stay on the screen) for the next routine + # this code component is set to 'both' because we need to remove the 'np' + # at the start of np.linspace (this is a python library JS won't know what to call. + + # make range from a to b in n stepsizes + faceDuration_range = np.linspace(2750, 3250, 500) + + # picking from a shuffled array is easier for random selection in JS + shuffle(faceDuration_range) + this_faceDuration = faceDuration_range[0]/1000 # the first item of the shuffled array + + # save this this_faceDuration to our output file + prac_trial_loop.addData('faceDuration', this_faceDuration) + + + # Timer to know how long it takes this flanker routine + # This timer data will be used later to know how long the face should be displayed. + routine_timer = core.Clock() + + + + prac_cover_background.setImage('img/cover_background.png') + prac_centerImg.setPos((0, 0)) + prac_centerImg.setSize([1.03, 1.03]) + prac_centerImg.setImage(middleStim) + prac_rightImg1.setPos((1.22, 0)) + prac_rightImg1.setSize([1.03, 1.03]) + prac_rightImg1.setImage(rightStim) + prac_rightImg2.setPos([2.44,0]) + prac_rightImg2.setSize([1.03, 1.03]) + prac_rightImg2.setImage(rightStim) + prac_leftImg1.setPos((-1.22, 0)) + prac_leftImg1.setSize([1.03, 1.03]) + prac_leftImg1.setImage(leftStim) + prac_leftImg2.setPos([-2.44,0]) + prac_leftImg2.setSize([1.03, 1.03]) + prac_leftImg2.setImage(leftStim) + prac_fixImg.setImage('img/transp_fixation.png') + prac_stim_keyResp.keys = [] + prac_stim_keyResp.rt = [] + _prac_stim_keyResp_allKeys = [] + # keep track of which components have finished + prac_stimRoutineComponents = [prac_cover_background, prac_centerImg, prac_rightImg1, prac_rightImg2, prac_leftImg1, prac_leftImg2, prac_fixImg, prac_stim_keyResp] + for thisComponent in prac_stimRoutineComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "prac_stimRoutine" --- + while continueRoutine and routineTimer.getTime() < 1.0: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *prac_cover_background* updates + if prac_cover_background.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_cover_background.frameNStart = frameN # exact frame index + prac_cover_background.tStart = t # local t and not account for scr refresh + prac_cover_background.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_cover_background, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_cover_background.started') + prac_cover_background.setAutoDraw(True) + if prac_cover_background.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_cover_background.tStartRefresh + 0.35-frameTolerance: + # keep track of stop time/frame for later + prac_cover_background.tStop = t # not accounting for scr refresh + prac_cover_background.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_cover_background.stopped') + prac_cover_background.setAutoDraw(False) + + # *prac_centerImg* updates + if prac_centerImg.status == NOT_STARTED and tThisFlip >= 0.15-frameTolerance: + # keep track of start time/frame for later + prac_centerImg.frameNStart = frameN # exact frame index + prac_centerImg.tStart = t # local t and not account for scr refresh + prac_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_centerImg, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_centerImg.started') + prac_centerImg.setAutoDraw(True) + if prac_centerImg.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_centerImg.tStartRefresh + .2-frameTolerance: + # keep track of stop time/frame for later + prac_centerImg.tStop = t # not accounting for scr refresh + prac_centerImg.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_centerImg.stopped') + prac_centerImg.setAutoDraw(False) + + # *prac_rightImg1* updates + if prac_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_rightImg1.frameNStart = frameN # exact frame index + prac_rightImg1.tStart = t # local t and not account for scr refresh + prac_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_rightImg1, 'tStartRefresh') # time at next scr refresh + prac_rightImg1.setAutoDraw(True) + if prac_rightImg1.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_rightImg1.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + prac_rightImg1.tStop = t # not accounting for scr refresh + prac_rightImg1.frameNStop = frameN # exact frame index + prac_rightImg1.setAutoDraw(False) + + # *prac_rightImg2* updates + if prac_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_rightImg2.frameNStart = frameN # exact frame index + prac_rightImg2.tStart = t # local t and not account for scr refresh + prac_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_rightImg2, 'tStartRefresh') # time at next scr refresh + prac_rightImg2.setAutoDraw(True) + if prac_rightImg2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_rightImg2.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + prac_rightImg2.tStop = t # not accounting for scr refresh + prac_rightImg2.frameNStop = frameN # exact frame index + prac_rightImg2.setAutoDraw(False) + + # *prac_leftImg1* updates + if prac_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_leftImg1.frameNStart = frameN # exact frame index + prac_leftImg1.tStart = t # local t and not account for scr refresh + prac_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_leftImg1, 'tStartRefresh') # time at next scr refresh + prac_leftImg1.setAutoDraw(True) + if prac_leftImg1.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_leftImg1.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + prac_leftImg1.tStop = t # not accounting for scr refresh + prac_leftImg1.frameNStop = frameN # exact frame index + prac_leftImg1.setAutoDraw(False) + + # *prac_leftImg2* updates + if prac_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_leftImg2.frameNStart = frameN # exact frame index + prac_leftImg2.tStart = t # local t and not account for scr refresh + prac_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_leftImg2, 'tStartRefresh') # time at next scr refresh + prac_leftImg2.setAutoDraw(True) + if prac_leftImg2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_leftImg2.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + prac_leftImg2.tStop = t # not accounting for scr refresh + prac_leftImg2.frameNStop = frameN # exact frame index + prac_leftImg2.setAutoDraw(False) + + # *prac_fixImg* updates + if prac_fixImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_fixImg.frameNStart = frameN # exact frame index + prac_fixImg.tStart = t # local t and not account for scr refresh + prac_fixImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_fixImg, 'tStartRefresh') # time at next scr refresh + prac_fixImg.setAutoDraw(True) + if prac_fixImg.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_fixImg.tStartRefresh + 1-frameTolerance: + # keep track of stop time/frame for later + prac_fixImg.tStop = t # not accounting for scr refresh + prac_fixImg.frameNStop = frameN # exact frame index + prac_fixImg.setAutoDraw(False) + + # *prac_stim_keyResp* updates + waitOnFlip = False + if prac_stim_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_stim_keyResp.frameNStart = frameN # exact frame index + prac_stim_keyResp.tStart = t # local t and not account for scr refresh + prac_stim_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_stim_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_stim_keyResp.started') + prac_stim_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(prac_stim_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(prac_stim_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if prac_stim_keyResp.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_stim_keyResp.tStartRefresh + 1-frameTolerance: + # keep track of stop time/frame for later + prac_stim_keyResp.tStop = t # not accounting for scr refresh + prac_stim_keyResp.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_stim_keyResp.stopped') + prac_stim_keyResp.status = FINISHED + if prac_stim_keyResp.status == STARTED and not waitOnFlip: + theseKeys = prac_stim_keyResp.getKeys(keyList=['s','k'], waitRelease=False) + _prac_stim_keyResp_allKeys.extend(theseKeys) + if len(_prac_stim_keyResp_allKeys): + prac_stim_keyResp.keys = [key.name for key in _prac_stim_keyResp_allKeys] # storing all keys + prac_stim_keyResp.rt = [key.rt for key in _prac_stim_keyResp_allKeys] + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in prac_stimRoutineComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "prac_stimRoutine" --- + for thisComponent in prac_stimRoutineComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # Run 'End Routine' code from prac_isi_code + first_flanker_routine_time = routine_timer.getTime() + routine_timer.reset() + + + # save this to our output file + prac_trial_loop.addData('first_flanker_routine_time', first_flanker_routine_time) + + # check responses + if prac_stim_keyResp.keys in ['', [], None]: # No response was made + prac_stim_keyResp.keys = None + prac_trial_loop.addData('prac_stim_keyResp.keys',prac_stim_keyResp.keys) + if prac_stim_keyResp.keys != None: # we had a response + prac_trial_loop.addData('prac_stim_keyResp.rt', prac_stim_keyResp.rt) + # Run 'End Routine' code from prac_accuracy_code + trialNum = trialNum + 1 #iterate trial number for this block + + if prac_stim_keyResp.keys: #if at least one response was made this trial + if prac_stim_keyResp.keys[0] == 's': #if the FIRST button pressed was a '1' + if target == 'left': #if a left target stim was shown this trial + accuracy = 1 #mark this trial as correct + numCorr = numCorr +1 #iterate number of correct responses for this block + elif target == 'right': #if a right target stim was shown this trial + accuracy = 0 #mark this trial as an error + elif prac_stim_keyResp.keys[0] == 'k': #if the FIRST button pressed was a '8' + if target == 'right': #if a right target stim was shown this trial + accuracy = 1 #mark this trial as correct + numCorr = numCorr +1 #iterate number of correct responses for this block + elif target == 'left': #if a left target stim was shown this trial + accuracy = 0 #mark this trial as an error + + # save this trial's accuracy to our output file + prac_trial_loop.addData('accuracy', accuracy) + # using non-slip timing so subtract the expected duration of this Routine (unless ended on request) + if routineForceEnded: + routineTimer.reset() + else: + routineTimer.addTime(-1.000000) + + # --- Prepare to start Routine "prac_face_disp" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from prac_remaining_isi_code + + face_delay_time = np.random.choice(face_delay) + faceDuration_plus_faceDelay_time = this_faceDuration + face_delay_time # This is to know when this routine needs to be ended. + + # save this to our output file + prac_trial_loop.addData('face_delay_time', face_delay_time) + prac_trial_loop.addData('faceDuration_plus_faceDelay_time', faceDuration_plus_faceDelay_time) + + # Timer to know how long it takes this flanker routine + # This timer data will be used later to know how long the face should be displayed. + routine_timer = core.Clock() + prac_delayed_face.setImage(straightFace) + prac_fixImg_2.setImage('img/transp_fixation.png') + prac_stim_keyResp2.keys = [] + prac_stim_keyResp2.rt = [] + _prac_stim_keyResp2_allKeys = [] + # keep track of which components have finished + prac_face_dispComponents = [prac_delayed_face, prac_fixImg_2, prac_stim_keyResp2] + for thisComponent in prac_face_dispComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "prac_face_disp" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *prac_delayed_face* updates + if prac_delayed_face.status == NOT_STARTED and tThisFlip >= face_delay_time-frameTolerance: + # keep track of start time/frame for later + prac_delayed_face.frameNStart = frameN # exact frame index + prac_delayed_face.tStart = t # local t and not account for scr refresh + prac_delayed_face.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_delayed_face, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_delayed_face.started') + prac_delayed_face.setAutoDraw(True) + if prac_delayed_face.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_delayed_face.tStartRefresh + this_faceDuration-frameTolerance: + # keep track of stop time/frame for later + prac_delayed_face.tStop = t # not accounting for scr refresh + prac_delayed_face.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_delayed_face.stopped') + prac_delayed_face.setAutoDraw(False) + + # *prac_fixImg_2* updates + if prac_fixImg_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_fixImg_2.frameNStart = frameN # exact frame index + prac_fixImg_2.tStart = t # local t and not account for scr refresh + prac_fixImg_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_fixImg_2, 'tStartRefresh') # time at next scr refresh + prac_fixImg_2.setAutoDraw(True) + if prac_fixImg_2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_fixImg_2.tStartRefresh + this_faceDuration-frameTolerance: + # keep track of stop time/frame for later + prac_fixImg_2.tStop = t # not accounting for scr refresh + prac_fixImg_2.frameNStop = frameN # exact frame index + prac_fixImg_2.setAutoDraw(False) + + # *prac_stim_keyResp2* updates + waitOnFlip = False + if prac_stim_keyResp2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_stim_keyResp2.frameNStart = frameN # exact frame index + prac_stim_keyResp2.tStart = t # local t and not account for scr refresh + prac_stim_keyResp2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_stim_keyResp2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_stim_keyResp2.started') + prac_stim_keyResp2.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(prac_stim_keyResp2.clock.reset) # t=0 on next screen flip + win.callOnFlip(prac_stim_keyResp2.clearEvents, eventType='keyboard') # clear events on next screen flip + if prac_stim_keyResp2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > prac_stim_keyResp2.tStartRefresh + faceDuration_plus_faceDelay_time-frameTolerance: + # keep track of stop time/frame for later + prac_stim_keyResp2.tStop = t # not accounting for scr refresh + prac_stim_keyResp2.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_stim_keyResp2.stopped') + prac_stim_keyResp2.status = FINISHED + if prac_stim_keyResp2.status == STARTED and not waitOnFlip: + theseKeys = prac_stim_keyResp2.getKeys(keyList=['s','k'], waitRelease=False) + _prac_stim_keyResp2_allKeys.extend(theseKeys) + if len(_prac_stim_keyResp2_allKeys): + prac_stim_keyResp2.keys = [key.name for key in _prac_stim_keyResp2_allKeys] # storing all keys + prac_stim_keyResp2.rt = [key.rt for key in _prac_stim_keyResp2_allKeys] + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in prac_face_dispComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "prac_face_disp" --- + for thisComponent in prac_face_dispComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # Run 'End Routine' code from prac_remaining_isi_code + second_flanker_routine_time = routine_timer.getTime() + routine_timer.reset() + + + # save this to our output file + prac_trial_loop.addData('second_flanker_routine_time', second_flanker_routine_time) + + # check responses + if prac_stim_keyResp2.keys in ['', [], None]: # No response was made + prac_stim_keyResp2.keys = None + prac_trial_loop.addData('prac_stim_keyResp2.keys',prac_stim_keyResp2.keys) + if prac_stim_keyResp2.keys != None: # we had a response + prac_trial_loop.addData('prac_stim_keyResp2.rt', prac_stim_keyResp2.rt) + # the Routine "prac_face_disp" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + + # completed 1 repeats of 'prac_trial_loop' + + + # --- Prepare to start Routine "prac_blockFeed" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from prac_blockFeed_code + blockAcc = numCorr / trialNum #compute accuracy for this block + + if blockAcc >= .75: #if accuracy >= 75% then say practice is complete and end practice loop to continue to main exp + outPut = 'You have completed the practice' #feedback presented + prac_block_loop.finished = True #end practice loop to continue to main exp + elif blockAcc <= .75: #if accuracy < 75% then say that practice needs to be repeated and DO NOT end practice loop, instead, allow it to repeat + outPut = 'Please try the practice again' #feedback presented + prac_block_loop.finished = False #DO NOT end practice loop and allow to repeat + + #reset the following variables to zero before the next practice block starts + trialNum = 0 + numCorr = 0 + prac_blockFeed_text.setText(outPut) + prac_blockFeed_keyResp.keys = [] + prac_blockFeed_keyResp.rt = [] + _prac_blockFeed_keyResp_allKeys = [] + # keep track of which components have finished + prac_blockFeedComponents = [prac_blockFeed_text, prac_pressContinue, prac_blockFeed_keyResp] + for thisComponent in prac_blockFeedComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "prac_blockFeed" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *prac_blockFeed_text* updates + if prac_blockFeed_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_blockFeed_text.frameNStart = frameN # exact frame index + prac_blockFeed_text.tStart = t # local t and not account for scr refresh + prac_blockFeed_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_blockFeed_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_blockFeed_text.started') + prac_blockFeed_text.setAutoDraw(True) + + # *prac_pressContinue* updates + if prac_pressContinue.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_pressContinue.frameNStart = frameN # exact frame index + prac_pressContinue.tStart = t # local t and not account for scr refresh + prac_pressContinue.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_pressContinue, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_pressContinue.started') + prac_pressContinue.setAutoDraw(True) + + # *prac_blockFeed_keyResp* updates + waitOnFlip = False + if prac_blockFeed_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + prac_blockFeed_keyResp.frameNStart = frameN # exact frame index + prac_blockFeed_keyResp.tStart = t # local t and not account for scr refresh + prac_blockFeed_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(prac_blockFeed_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'prac_blockFeed_keyResp.started') + prac_blockFeed_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(prac_blockFeed_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(prac_blockFeed_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if prac_blockFeed_keyResp.status == STARTED and not waitOnFlip: + theseKeys = prac_blockFeed_keyResp.getKeys(keyList=['k'], waitRelease=False) + _prac_blockFeed_keyResp_allKeys.extend(theseKeys) + if len(_prac_blockFeed_keyResp_allKeys): + prac_blockFeed_keyResp.keys = _prac_blockFeed_keyResp_allKeys[-1].name # just the last key pressed + prac_blockFeed_keyResp.rt = _prac_blockFeed_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in prac_blockFeedComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "prac_blockFeed" --- + for thisComponent in prac_blockFeedComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if prac_blockFeed_keyResp.keys in ['', [], None]: # No response was made + prac_blockFeed_keyResp.keys = None + prac_block_loop.addData('prac_blockFeed_keyResp.keys',prac_blockFeed_keyResp.keys) + if prac_blockFeed_keyResp.keys != None: # we had a response + prac_block_loop.addData('prac_blockFeed_keyResp.rt', prac_blockFeed_keyResp.rt) + # the Routine "prac_blockFeed" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + +# completed 999 repeats of 'prac_block_loop' + + +# --- Prepare to start Routine "ringBell" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +bellKey.keys = [] +bellKey.rt = [] +_bellKey_allKeys = [] +# keep track of which components have finished +ringBellComponents = [ringBell_text, bellKey] +for thisComponent in ringBellComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "ringBell" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *ringBell_text* updates + if ringBell_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + ringBell_text.frameNStart = frameN # exact frame index + ringBell_text.tStart = t # local t and not account for scr refresh + ringBell_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(ringBell_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'ringBell_text.started') + ringBell_text.setAutoDraw(True) + + # *bellKey* updates + waitOnFlip = False + if bellKey.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bellKey.frameNStart = frameN # exact frame index + bellKey.tStart = t # local t and not account for scr refresh + bellKey.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bellKey, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bellKey.started') + bellKey.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(bellKey.clock.reset) # t=0 on next screen flip + win.callOnFlip(bellKey.clearEvents, eventType='keyboard') # clear events on next screen flip + if bellKey.status == STARTED and not waitOnFlip: + theseKeys = bellKey.getKeys(keyList=['c'], waitRelease=False) + _bellKey_allKeys.extend(theseKeys) + if len(_bellKey_allKeys): + bellKey.keys = _bellKey_allKeys[-1].name # just the last key pressed + bellKey.rt = _bellKey_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in ringBellComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "ringBell" --- +for thisComponent in ringBellComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if bellKey.keys in ['', [], None]: # No response was made + bellKey.keys = None +thisExp.addData('bellKey.keys',bellKey.keys) +if bellKey.keys != None: # we had a response + thisExp.addData('bellKey.rt', bellKey.rt) +thisExp.nextEntry() +# the Routine "ringBell" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# set up handler to look after randomisation of conditions etc +task_block_loop = data.TrialHandler(nReps=1.0, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions('blockSelect.csv'), + seed=None, name='task_block_loop') +thisExp.addLoop(task_block_loop) # add the loop to the experiment +thisTask_block_loop = task_block_loop.trialList[0] # so we can initialise stimuli with some values +# abbreviate parameter names if possible (e.g. rgb = thisTask_block_loop.rgb) +if thisTask_block_loop != None: + for paramName in thisTask_block_loop: + exec('{} = thisTask_block_loop[paramName]'.format(paramName)) + +for thisTask_block_loop in task_block_loop: + currentLoop = task_block_loop + # abbreviate parameter names if possible (e.g. rgb = thisTask_block_loop.rgb) + if thisTask_block_loop != None: + for paramName in thisTask_block_loop: + exec('{} = thisTask_block_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "task_blockReminders" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from task_blockReminder_code + blockCounter = blockCounter +1 + + if blockCounter == 1: + blockNumText = 'Block 1 of 12' + elif blockCounter == 2: + blockNumText = 'Block 2 of 12' + elif blockCounter == 3: + blockNumText = 'Block 3 of 12' + elif blockCounter == 4: + blockNumText = 'Block 4 of 12' + elif blockCounter == 5: + blockNumText = 'Block 5 of 12' + elif blockCounter == 6: + blockNumText = 'Block 6 of 12' + elif blockCounter == 7: + blockNumText = 'Block 7 of 12' + elif blockCounter == 8: + blockNumText = 'Block 8 of 12' + elif blockCounter == 9: + blockNumText = 'Block 9 of 12' + elif blockCounter == 10: + blockNumText = 'Block 10 of 12' + elif blockCounter == 11: + blockNumText = 'Block 11 of 12' + elif blockCounter == 12: + blockNumText = 'Block 12 of 12' + + + + task_blockText.setText(blockNumText) + task_blockReminders_keyResp.keys = [] + task_blockReminders_keyResp.rt = [] + _task_blockReminders_keyResp_allKeys = [] + # keep track of which components have finished + task_blockRemindersComponents = [task_blockText, task_blockReminders_text, task_blockReminders_keyResp] + for thisComponent in task_blockRemindersComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "task_blockReminders" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *task_blockText* updates + if task_blockText.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockText.frameNStart = frameN # exact frame index + task_blockText.tStart = t # local t and not account for scr refresh + task_blockText.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockText, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockText.started') + task_blockText.setAutoDraw(True) + + # *task_blockReminders_text* updates + if task_blockReminders_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockReminders_text.frameNStart = frameN # exact frame index + task_blockReminders_text.tStart = t # local t and not account for scr refresh + task_blockReminders_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockReminders_text, 'tStartRefresh') # time at next scr refresh + task_blockReminders_text.setAutoDraw(True) + + # *task_blockReminders_keyResp* updates + waitOnFlip = False + if task_blockReminders_keyResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockReminders_keyResp.frameNStart = frameN # exact frame index + task_blockReminders_keyResp.tStart = t # local t and not account for scr refresh + task_blockReminders_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockReminders_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockReminders_keyResp.started') + task_blockReminders_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(task_blockReminders_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(task_blockReminders_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if task_blockReminders_keyResp.status == STARTED and not waitOnFlip: + theseKeys = task_blockReminders_keyResp.getKeys(keyList=['k'], waitRelease=False) + _task_blockReminders_keyResp_allKeys.extend(theseKeys) + if len(_task_blockReminders_keyResp_allKeys): + task_blockReminders_keyResp.keys = _task_blockReminders_keyResp_allKeys[-1].name # just the last key pressed + task_blockReminders_keyResp.rt = _task_blockReminders_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in task_blockRemindersComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "task_blockReminders" --- + for thisComponent in task_blockRemindersComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if task_blockReminders_keyResp.keys in ['', [], None]: # No response was made + task_blockReminders_keyResp.keys = None + task_block_loop.addData('task_blockReminders_keyResp.keys',task_blockReminders_keyResp.keys) + if task_blockReminders_keyResp.keys != None: # we had a response + task_block_loop.addData('task_blockReminders_keyResp.rt', task_blockReminders_keyResp.rt) + # the Routine "task_blockReminders" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # --- Prepare to start Routine "initFixation" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + initFixation_img.setImage('img/transp_fixation.png') + # keep track of which components have finished + initFixationComponents = [initFixation_img, static_preloader] + for thisComponent in initFixationComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "initFixation" --- + while continueRoutine and routineTimer.getTime() < 2.0: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *initFixation_img* updates + if initFixation_img.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + initFixation_img.frameNStart = frameN # exact frame index + initFixation_img.tStart = t # local t and not account for scr refresh + initFixation_img.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(initFixation_img, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'initFixation_img.started') + initFixation_img.setAutoDraw(True) + if initFixation_img.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > initFixation_img.tStartRefresh + 2-frameTolerance: + # keep track of stop time/frame for later + initFixation_img.tStop = t # not accounting for scr refresh + initFixation_img.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'initFixation_img.stopped') + initFixation_img.setAutoDraw(False) + # *static_preloader* period + if static_preloader.status == NOT_STARTED and t >= 0-frameTolerance: + # keep track of start time/frame for later + static_preloader.frameNStart = frameN # exact frame index + static_preloader.tStart = t # local t and not account for scr refresh + static_preloader.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(static_preloader, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.addData('static_preloader.started', t) + static_preloader.start(2) + elif static_preloader.status == STARTED: # one frame should pass before updating params and completing + static_preloader.complete() # finish the static period + static_preloader.tStop = static_preloader.tStart + 2 # record stop time + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in initFixationComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "initFixation" --- + for thisComponent in initFixationComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # using non-slip timing so subtract the expected duration of this Routine (unless ended on request) + if routineForceEnded: + routineTimer.reset() + else: + routineTimer.addTime(-2.000000) + + # set up handler to look after randomisation of conditions etc + task_trial_loop = data.TrialHandler(nReps=1.0, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions(whichBlock), + seed=None, name='task_trial_loop') + thisExp.addLoop(task_trial_loop) # add the loop to the experiment + thisTask_trial_loop = task_trial_loop.trialList[0] # so we can initialise stimuli with some values + # abbreviate parameter names if possible (e.g. rgb = thisTask_trial_loop.rgb) + if thisTask_trial_loop != None: + for paramName in thisTask_trial_loop: + exec('{} = thisTask_trial_loop[paramName]'.format(paramName)) + + for thisTask_trial_loop in task_trial_loop: + currentLoop = task_trial_loop + # abbreviate parameter names if possible (e.g. rgb = thisTask_trial_loop.rgb) + if thisTask_trial_loop != None: + for paramName in thisTask_trial_loop: + exec('{} = thisTask_trial_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "task_stimRoutine" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from task_isi_code + # pick the faceDuration (the amount the face will stay on the screen) for the next routine + # this code component is set to 'both' because we need to remove the 'np' + # at the start of np.linspace (this is a python library JS won't know what to call. + + # make range from a to b in n stepsizes + faceDuration_range = np.linspace(2750, 3250, 500) + + # picking from a shuffled array is easier for random selection in JS + shuffle(faceDuration_range) + this_faceDuration = faceDuration_range[0]/1000 # the first item of the shuffled array + + # save this this_faceDuration to our output file + task_trial_loop.addData('faceDuration', this_faceDuration) + + # Timer to know how long it takes this flanker routine + # This timer data will be used later to know how long the face should be displayed. + routine_timer = core.Clock() + task_centerImg.setPos((0, 0)) + task_centerImg.setSize([1.03, 1.03]) + task_centerImg.setImage(middleStim) + task_rightImg1.setPos((1.22, 0)) + task_rightImg1.setSize([1.03, 1.03]) + task_rightImg1.setImage(rightStim) + task_rightImg2.setPos([2.44,0]) + task_rightImg2.setSize([1.03, 1.03]) + task_rightImg2.setImage(rightStim) + task_leftImg1.setPos((-1.22, 0)) + task_leftImg1.setSize([1.03, 1.03]) + task_leftImg1.setImage(leftStim) + task_leftImg2.setPos([-2.44,0]) + task_leftImg2.setSize([1.03, 1.03]) + task_leftImg2.setImage(leftStim) + task_fixImg.setImage('img/transp_fixation.png') + task1_stim_keyResp.keys = [] + task1_stim_keyResp.rt = [] + _task1_stim_keyResp_allKeys = [] + # keep track of which components have finished + task_stimRoutineComponents = [cover_background, task_centerImg, task_rightImg1, task_rightImg2, task_leftImg1, task_leftImg2, task_fixImg, task1_stim_keyResp] + for thisComponent in task_stimRoutineComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "task_stimRoutine" --- + while continueRoutine and routineTimer.getTime() < 1.0: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *cover_background* updates + if cover_background.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + cover_background.frameNStart = frameN # exact frame index + cover_background.tStart = t # local t and not account for scr refresh + cover_background.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(cover_background, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'cover_background.started') + cover_background.setAutoDraw(True) + if cover_background.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > cover_background.tStartRefresh + 0.35-frameTolerance: + # keep track of stop time/frame for later + cover_background.tStop = t # not accounting for scr refresh + cover_background.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'cover_background.stopped') + cover_background.setAutoDraw(False) + + # *task_centerImg* updates + if task_centerImg.status == NOT_STARTED and tThisFlip >= 0.15-frameTolerance: + # keep track of start time/frame for later + task_centerImg.frameNStart = frameN # exact frame index + task_centerImg.tStart = t # local t and not account for scr refresh + task_centerImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_centerImg, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_centerImg.started') + task_centerImg.setAutoDraw(True) + if task_centerImg.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_centerImg.tStartRefresh + .2-frameTolerance: + # keep track of stop time/frame for later + task_centerImg.tStop = t # not accounting for scr refresh + task_centerImg.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_centerImg.stopped') + task_centerImg.setAutoDraw(False) + + # *task_rightImg1* updates + if task_rightImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_rightImg1.frameNStart = frameN # exact frame index + task_rightImg1.tStart = t # local t and not account for scr refresh + task_rightImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_rightImg1, 'tStartRefresh') # time at next scr refresh + task_rightImg1.setAutoDraw(True) + if task_rightImg1.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_rightImg1.tStartRefresh + .35-frameTolerance: + # keep track of stop time/frame for later + task_rightImg1.tStop = t # not accounting for scr refresh + task_rightImg1.frameNStop = frameN # exact frame index + task_rightImg1.setAutoDraw(False) + + # *task_rightImg2* updates + if task_rightImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_rightImg2.frameNStart = frameN # exact frame index + task_rightImg2.tStart = t # local t and not account for scr refresh + task_rightImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_rightImg2, 'tStartRefresh') # time at next scr refresh + task_rightImg2.setAutoDraw(True) + if task_rightImg2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_rightImg2.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + task_rightImg2.tStop = t # not accounting for scr refresh + task_rightImg2.frameNStop = frameN # exact frame index + task_rightImg2.setAutoDraw(False) + + # *task_leftImg1* updates + if task_leftImg1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_leftImg1.frameNStart = frameN # exact frame index + task_leftImg1.tStart = t # local t and not account for scr refresh + task_leftImg1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_leftImg1, 'tStartRefresh') # time at next scr refresh + task_leftImg1.setAutoDraw(True) + if task_leftImg1.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_leftImg1.tStartRefresh + .35-frameTolerance: + # keep track of stop time/frame for later + task_leftImg1.tStop = t # not accounting for scr refresh + task_leftImg1.frameNStop = frameN # exact frame index + task_leftImg1.setAutoDraw(False) + + # *task_leftImg2* updates + if task_leftImg2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_leftImg2.frameNStart = frameN # exact frame index + task_leftImg2.tStart = t # local t and not account for scr refresh + task_leftImg2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_leftImg2, 'tStartRefresh') # time at next scr refresh + task_leftImg2.setAutoDraw(True) + if task_leftImg2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_leftImg2.tStartRefresh + .350-frameTolerance: + # keep track of stop time/frame for later + task_leftImg2.tStop = t # not accounting for scr refresh + task_leftImg2.frameNStop = frameN # exact frame index + task_leftImg2.setAutoDraw(False) + + # *task_fixImg* updates + if task_fixImg.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_fixImg.frameNStart = frameN # exact frame index + task_fixImg.tStart = t # local t and not account for scr refresh + task_fixImg.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_fixImg, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_fixImg.started') + task_fixImg.setAutoDraw(True) + if task_fixImg.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_fixImg.tStartRefresh + 1-frameTolerance: + # keep track of stop time/frame for later + task_fixImg.tStop = t # not accounting for scr refresh + task_fixImg.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_fixImg.stopped') + task_fixImg.setAutoDraw(False) + + # *task1_stim_keyResp* updates + waitOnFlip = False + if task1_stim_keyResp.status == NOT_STARTED and tThisFlip >= 0.1-frameTolerance: + # keep track of start time/frame for later + task1_stim_keyResp.frameNStart = frameN # exact frame index + task1_stim_keyResp.tStart = t # local t and not account for scr refresh + task1_stim_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task1_stim_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task1_stim_keyResp.started') + task1_stim_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(task1_stim_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(task1_stim_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if task1_stim_keyResp.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task1_stim_keyResp.tStartRefresh + 0.9-frameTolerance: + # keep track of stop time/frame for later + task1_stim_keyResp.tStop = t # not accounting for scr refresh + task1_stim_keyResp.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task1_stim_keyResp.stopped') + task1_stim_keyResp.status = FINISHED + if task1_stim_keyResp.status == STARTED and not waitOnFlip: + theseKeys = task1_stim_keyResp.getKeys(keyList=['s','k'], waitRelease=False) + _task1_stim_keyResp_allKeys.extend(theseKeys) + if len(_task1_stim_keyResp_allKeys): + task1_stim_keyResp.keys = [key.name for key in _task1_stim_keyResp_allKeys] # storing all keys + task1_stim_keyResp.rt = [key.rt for key in _task1_stim_keyResp_allKeys] + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in task_stimRoutineComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "task_stimRoutine" --- + for thisComponent in task_stimRoutineComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # Run 'End Routine' code from task_isi_code + current_flanker_routine_time = routine_timer.getTime() + routine_timer.reset() + + + # save this to our output file + task_trial_loop.addData('current_flanker_routine_time', current_flanker_routine_time) + + # check responses + if task1_stim_keyResp.keys in ['', [], None]: # No response was made + task1_stim_keyResp.keys = None + task_trial_loop.addData('task1_stim_keyResp.keys',task1_stim_keyResp.keys) + if task1_stim_keyResp.keys != None: # we had a response + task_trial_loop.addData('task1_stim_keyResp.rt', task1_stim_keyResp.rt) + # Run 'End Routine' code from task_accuracy_code + trialNum = trialNum + 1 #iterate trial number for this block + + if task1_stim_keyResp.keys: #if at least one response was made this trial + if task1_stim_keyResp.keys[0] == 's': #if the FIRST button pressed was a '1' + if target == 'left': #if a left target stim was shown this trial + accuracy = 1 #mark this trial as correct + numCorr = numCorr +1 #iterate number of correct responses for this block + elif target == 'right': #if a right target stim was shown this trial + accuracy = 0 #mark this trial as an error + elif task1_stim_keyResp.keys[0] == 'k': #if the FIRST button pressed was a '8' + if target == 'right': #if a right target stim was shown this trial + accuracy = 1 #mark this trial as correct + numCorr = numCorr +1 #iterate number of correct responses for this block + elif target == 'left': #if a left target stim was shown this trial + accuracy = 0 #mark this trial as an error + + # save this trial's accuracy to our output file + task_trial_loop.addData('accuracy', accuracy) + # using non-slip timing so subtract the expected duration of this Routine (unless ended on request) + if routineForceEnded: + routineTimer.reset() + else: + routineTimer.addTime(-1.000000) + + # --- Prepare to start Routine "task_face_disp" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from task_remaining_isi_code + + face_delay_time = np.random.choice(face_delay) + faceDuration_plus_faceDelay_time = this_faceDuration + face_delay_time # This is to know when this routine needs to be ended. + + # save this to our output file + task_trial_loop.addData('face_delay_time', face_delay_time) + task_trial_loop.addData('faceDuration_plus_faceDelay_time', faceDuration_plus_faceDelay_time) + + # Timer to know how long it takes this flanker routine + # This timer data will be used later to know how long the face should be displayed. + routine_timer = core.Clock() + task_delayed_face.setImage(straightFace) + task_fixImg_2.setImage('img/transp_fixation.png') + task_stim_keyResp2.keys = [] + task_stim_keyResp2.rt = [] + _task_stim_keyResp2_allKeys = [] + # keep track of which components have finished + task_face_dispComponents = [task_delayed_face, task_fixImg_2, task_stim_keyResp2] + for thisComponent in task_face_dispComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "task_face_disp" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *task_delayed_face* updates + if task_delayed_face.status == NOT_STARTED and tThisFlip >= face_delay_time-frameTolerance: + # keep track of start time/frame for later + task_delayed_face.frameNStart = frameN # exact frame index + task_delayed_face.tStart = t # local t and not account for scr refresh + task_delayed_face.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_delayed_face, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_delayed_face.started') + task_delayed_face.setAutoDraw(True) + if task_delayed_face.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_delayed_face.tStartRefresh + this_faceDuration-frameTolerance: + # keep track of stop time/frame for later + task_delayed_face.tStop = t # not accounting for scr refresh + task_delayed_face.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_delayed_face.stopped') + task_delayed_face.setAutoDraw(False) + + # *task_fixImg_2* updates + if task_fixImg_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_fixImg_2.frameNStart = frameN # exact frame index + task_fixImg_2.tStart = t # local t and not account for scr refresh + task_fixImg_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_fixImg_2, 'tStartRefresh') # time at next scr refresh + task_fixImg_2.setAutoDraw(True) + if task_fixImg_2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_fixImg_2.tStartRefresh + this_faceDuration-frameTolerance: + # keep track of stop time/frame for later + task_fixImg_2.tStop = t # not accounting for scr refresh + task_fixImg_2.frameNStop = frameN # exact frame index + task_fixImg_2.setAutoDraw(False) + + # *task_stim_keyResp2* updates + waitOnFlip = False + if task_stim_keyResp2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_stim_keyResp2.frameNStart = frameN # exact frame index + task_stim_keyResp2.tStart = t # local t and not account for scr refresh + task_stim_keyResp2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_stim_keyResp2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_stim_keyResp2.started') + task_stim_keyResp2.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(task_stim_keyResp2.clock.reset) # t=0 on next screen flip + win.callOnFlip(task_stim_keyResp2.clearEvents, eventType='keyboard') # clear events on next screen flip + if task_stim_keyResp2.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > task_stim_keyResp2.tStartRefresh + faceDuration_plus_faceDelay_time-frameTolerance: + # keep track of stop time/frame for later + task_stim_keyResp2.tStop = t # not accounting for scr refresh + task_stim_keyResp2.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_stim_keyResp2.stopped') + task_stim_keyResp2.status = FINISHED + if task_stim_keyResp2.status == STARTED and not waitOnFlip: + theseKeys = task_stim_keyResp2.getKeys(keyList=['s','k'], waitRelease=False) + _task_stim_keyResp2_allKeys.extend(theseKeys) + if len(_task_stim_keyResp2_allKeys): + task_stim_keyResp2.keys = [key.name for key in _task_stim_keyResp2_allKeys] # storing all keys + task_stim_keyResp2.rt = [key.rt for key in _task_stim_keyResp2_allKeys] + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in task_face_dispComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "task_face_disp" --- + for thisComponent in task_face_dispComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # Run 'End Routine' code from task_remaining_isi_code + second_flanker_routine_time = routine_timer.getTime() + routine_timer.reset() + + + # save this to our output file + task_trial_loop.addData('second_flanker_routine_time', second_flanker_routine_time) + + # check responses + if task_stim_keyResp2.keys in ['', [], None]: # No response was made + task_stim_keyResp2.keys = None + task_trial_loop.addData('task_stim_keyResp2.keys',task_stim_keyResp2.keys) + if task_stim_keyResp2.keys != None: # we had a response + task_trial_loop.addData('task_stim_keyResp2.rt', task_stim_keyResp2.rt) + # the Routine "task_face_disp" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + + # completed 1.0 repeats of 'task_trial_loop' + + + # --- Prepare to start Routine "task_blockFeed" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from task_blockFeed_code + blockAcc = numCorr / trialNum #compute accuracy for this block + + if blockCounter < 10: + if blockAcc >= .75: + if blockAcc < .9: + blockFeed = 'Good job' + blockFeedCat = 1 + elif blockAcc >= .9: + blockFeed = 'Respond faster' + blockFeedCat = 2 + elif blockAcc < .75: + blockFeed = 'Respond more accurately' + blockFeedCat = 3 + elif blockCounter == 10: + 'You have completed all blocks' + + # save this block's feedback to our output file + task_trial_loop.addData('blockFeedCat', blockFeedCat) + + #reset the following variables to zero before next block starts + trialNum = 0 + numCorr = 0 + task_blockFeed_text.setText(blockFeed) + task_blockFeed_text2.setText("Press the 'K' key") + task_blockFeed_keyResp.keys = [] + task_blockFeed_keyResp.rt = [] + _task_blockFeed_keyResp_allKeys = [] + # keep track of which components have finished + task_blockFeedComponents = [task_blockFeed_text, task_blockFeed_text2, task_blockFeed_keyResp] + for thisComponent in task_blockFeedComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "task_blockFeed" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *task_blockFeed_text* updates + if task_blockFeed_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockFeed_text.frameNStart = frameN # exact frame index + task_blockFeed_text.tStart = t # local t and not account for scr refresh + task_blockFeed_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockFeed_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockFeed_text.started') + task_blockFeed_text.setAutoDraw(True) + + # *task_blockFeed_text2* updates + if task_blockFeed_text2.status == NOT_STARTED and tThisFlip >= 10-frameTolerance: + # keep track of start time/frame for later + task_blockFeed_text2.frameNStart = frameN # exact frame index + task_blockFeed_text2.tStart = t # local t and not account for scr refresh + task_blockFeed_text2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockFeed_text2, 'tStartRefresh') # time at next scr refresh + task_blockFeed_text2.setAutoDraw(True) + + # *task_blockFeed_keyResp* updates + waitOnFlip = False + if task_blockFeed_keyResp.status == NOT_STARTED and tThisFlip >= 10-frameTolerance: + # keep track of start time/frame for later + task_blockFeed_keyResp.frameNStart = frameN # exact frame index + task_blockFeed_keyResp.tStart = t # local t and not account for scr refresh + task_blockFeed_keyResp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockFeed_keyResp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockFeed_keyResp.started') + task_blockFeed_keyResp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(task_blockFeed_keyResp.clock.reset) # t=0 on next screen flip + win.callOnFlip(task_blockFeed_keyResp.clearEvents, eventType='keyboard') # clear events on next screen flip + if task_blockFeed_keyResp.status == STARTED and not waitOnFlip: + theseKeys = task_blockFeed_keyResp.getKeys(keyList=['k'], waitRelease=False) + _task_blockFeed_keyResp_allKeys.extend(theseKeys) + if len(_task_blockFeed_keyResp_allKeys): + task_blockFeed_keyResp.keys = _task_blockFeed_keyResp_allKeys[-1].name # just the last key pressed + task_blockFeed_keyResp.rt = _task_blockFeed_keyResp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in task_blockFeedComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "task_blockFeed" --- + for thisComponent in task_blockFeedComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if task_blockFeed_keyResp.keys in ['', [], None]: # No response was made + task_blockFeed_keyResp.keys = None + task_block_loop.addData('task_blockFeed_keyResp.keys',task_blockFeed_keyResp.keys) + if task_blockFeed_keyResp.keys != None: # we had a response + task_block_loop.addData('task_blockFeed_keyResp.rt', task_blockFeed_keyResp.rt) + # the Routine "task_blockFeed" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + +# completed 1.0 repeats of 'task_block_loop' + + +# --- Prepare to start Routine "ringBell2" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +bellKey_2.keys = [] +bellKey_2.rt = [] +_bellKey_2_allKeys = [] +# keep track of which components have finished +ringBell2Components = [ringBell_text_2, bellKey_2] +for thisComponent in ringBell2Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "ringBell2" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *ringBell_text_2* updates + if ringBell_text_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + ringBell_text_2.frameNStart = frameN # exact frame index + ringBell_text_2.tStart = t # local t and not account for scr refresh + ringBell_text_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(ringBell_text_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'ringBell_text_2.started') + ringBell_text_2.setAutoDraw(True) + + # *bellKey_2* updates + waitOnFlip = False + if bellKey_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bellKey_2.frameNStart = frameN # exact frame index + bellKey_2.tStart = t # local t and not account for scr refresh + bellKey_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bellKey_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bellKey_2.started') + bellKey_2.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(bellKey_2.clock.reset) # t=0 on next screen flip + win.callOnFlip(bellKey_2.clearEvents, eventType='keyboard') # clear events on next screen flip + if bellKey_2.status == STARTED and not waitOnFlip: + theseKeys = bellKey_2.getKeys(keyList=['c'], waitRelease=False) + _bellKey_2_allKeys.extend(theseKeys) + if len(_bellKey_2_allKeys): + bellKey_2.keys = _bellKey_2_allKeys[-1].name # just the last key pressed + bellKey_2.rt = _bellKey_2_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in ringBell2Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "ringBell2" --- +for thisComponent in ringBell2Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if bellKey_2.keys in ['', [], None]: # No response was made + bellKey_2.keys = None +thisExp.addData('bellKey_2.keys',bellKey_2.keys) +if bellKey_2.keys != None: # we had a response + thisExp.addData('bellKey_2.rt', bellKey_2.rt) +thisExp.nextEntry() +# the Routine "ringBell2" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "errorNumbers" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# Run 'Begin Routine' code from code +event.clearEvents() +errorNum_text_box.reset() +errorN_key_resp_2.keys = [] +errorN_key_resp_2.rt = [] +_errorN_key_resp_2_allKeys = [] +# keep track of which components have finished +errorNumbersComponents = [errorNumbers_text_2, errorNum_text_box, errorN_key_resp_2] +for thisComponent in errorNumbersComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "errorNumbers" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *errorNumbers_text_2* updates + if errorNumbers_text_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorNumbers_text_2.frameNStart = frameN # exact frame index + errorNumbers_text_2.tStart = t # local t and not account for scr refresh + errorNumbers_text_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorNumbers_text_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorNumbers_text_2.started') + errorNumbers_text_2.setAutoDraw(True) + + # *errorNum_text_box* updates + if errorNum_text_box.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorNum_text_box.frameNStart = frameN # exact frame index + errorNum_text_box.tStart = t # local t and not account for scr refresh + errorNum_text_box.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorNum_text_box, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorNum_text_box.started') + errorNum_text_box.setAutoDraw(True) + + # *errorN_key_resp_2* updates + waitOnFlip = False + if errorN_key_resp_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorN_key_resp_2.frameNStart = frameN # exact frame index + errorN_key_resp_2.tStart = t # local t and not account for scr refresh + errorN_key_resp_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorN_key_resp_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorN_key_resp_2.started') + errorN_key_resp_2.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(errorN_key_resp_2.clock.reset) # t=0 on next screen flip + win.callOnFlip(errorN_key_resp_2.clearEvents, eventType='keyboard') # clear events on next screen flip + if errorN_key_resp_2.status == STARTED and not waitOnFlip: + theseKeys = errorN_key_resp_2.getKeys(keyList=['space'], waitRelease=False) + _errorN_key_resp_2_allKeys.extend(theseKeys) + if len(_errorN_key_resp_2_allKeys): + errorN_key_resp_2.keys = _errorN_key_resp_2_allKeys[-1].name # just the last key pressed + errorN_key_resp_2.rt = _errorN_key_resp_2_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in errorNumbersComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "errorNumbers" --- +for thisComponent in errorNumbersComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +thisExp.addData('errorNum_text_box.text',errorNum_text_box.text) +# check responses +if errorN_key_resp_2.keys in ['', [], None]: # No response was made + errorN_key_resp_2.keys = None +thisExp.addData('errorN_key_resp_2.keys',errorN_key_resp_2.keys) +if errorN_key_resp_2.keys != None: # we had a response + thisExp.addData('errorN_key_resp_2.rt', errorN_key_resp_2.rt) +thisExp.nextEntry() +# the Routine "errorNumbers" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "errorPercentage" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# Run 'Begin Routine' code from code_4 +event.clearEvents() +errorPercent_text_box.reset() +errorN_key_resp_3.keys = [] +errorN_key_resp_3.rt = [] +_errorN_key_resp_3_allKeys = [] +# keep track of which components have finished +errorPercentageComponents = [errorNumbers_text_3, errorPercent_text_box, errorN_key_resp_3] +for thisComponent in errorPercentageComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "errorPercentage" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *errorNumbers_text_3* updates + if errorNumbers_text_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorNumbers_text_3.frameNStart = frameN # exact frame index + errorNumbers_text_3.tStart = t # local t and not account for scr refresh + errorNumbers_text_3.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorNumbers_text_3, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorNumbers_text_3.started') + errorNumbers_text_3.setAutoDraw(True) + + # *errorPercent_text_box* updates + if errorPercent_text_box.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorPercent_text_box.frameNStart = frameN # exact frame index + errorPercent_text_box.tStart = t # local t and not account for scr refresh + errorPercent_text_box.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorPercent_text_box, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorPercent_text_box.started') + errorPercent_text_box.setAutoDraw(True) + + # *errorN_key_resp_3* updates + waitOnFlip = False + if errorN_key_resp_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + errorN_key_resp_3.frameNStart = frameN # exact frame index + errorN_key_resp_3.tStart = t # local t and not account for scr refresh + errorN_key_resp_3.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(errorN_key_resp_3, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'errorN_key_resp_3.started') + errorN_key_resp_3.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(errorN_key_resp_3.clock.reset) # t=0 on next screen flip + win.callOnFlip(errorN_key_resp_3.clearEvents, eventType='keyboard') # clear events on next screen flip + if errorN_key_resp_3.status == STARTED and not waitOnFlip: + theseKeys = errorN_key_resp_3.getKeys(keyList=['space'], waitRelease=False) + _errorN_key_resp_3_allKeys.extend(theseKeys) + if len(_errorN_key_resp_3_allKeys): + errorN_key_resp_3.keys = _errorN_key_resp_3_allKeys[-1].name # just the last key pressed + errorN_key_resp_3.rt = _errorN_key_resp_3_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in errorPercentageComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "errorPercentage" --- +for thisComponent in errorPercentageComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +thisExp.addData('errorPercent_text_box.text',errorPercent_text_box.text) +# check responses +if errorN_key_resp_3.keys in ['', [], None]: # No response was made + errorN_key_resp_3.keys = None +thisExp.addData('errorN_key_resp_3.keys',errorN_key_resp_3.keys) +if errorN_key_resp_3.keys != None: # we had a response + thisExp.addData('errorN_key_resp_3.rt', errorN_key_resp_3.rt) +thisExp.nextEntry() +# the Routine "errorPercentage" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "botherRate" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# Run 'Begin Routine' code from code_3 +event.clearEvents() +bother_text_box.reset() +botherRate_key_resp.keys = [] +botherRate_key_resp.rt = [] +_botherRate_key_resp_allKeys = [] +# keep track of which components have finished +botherRateComponents = [botherRate_text, bother_text_box, botherRate_key_resp] +for thisComponent in botherRateComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "botherRate" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *botherRate_text* updates + if botherRate_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + botherRate_text.frameNStart = frameN # exact frame index + botherRate_text.tStart = t # local t and not account for scr refresh + botherRate_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(botherRate_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'botherRate_text.started') + botherRate_text.setAutoDraw(True) + + # *bother_text_box* updates + if bother_text_box.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bother_text_box.frameNStart = frameN # exact frame index + bother_text_box.tStart = t # local t and not account for scr refresh + bother_text_box.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bother_text_box, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bother_text_box.started') + bother_text_box.setAutoDraw(True) + + # *botherRate_key_resp* updates + waitOnFlip = False + if botherRate_key_resp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + botherRate_key_resp.frameNStart = frameN # exact frame index + botherRate_key_resp.tStart = t # local t and not account for scr refresh + botherRate_key_resp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(botherRate_key_resp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'botherRate_key_resp.started') + botherRate_key_resp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(botherRate_key_resp.clock.reset) # t=0 on next screen flip + win.callOnFlip(botherRate_key_resp.clearEvents, eventType='keyboard') # clear events on next screen flip + if botherRate_key_resp.status == STARTED and not waitOnFlip: + theseKeys = botherRate_key_resp.getKeys(keyList=['space'], waitRelease=False) + _botherRate_key_resp_allKeys.extend(theseKeys) + if len(_botherRate_key_resp_allKeys): + botherRate_key_resp.keys = _botherRate_key_resp_allKeys[-1].name # just the last key pressed + botherRate_key_resp.rt = _botherRate_key_resp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in botherRateComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "botherRate" --- +for thisComponent in botherRateComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +thisExp.addData('bother_text_box.text',bother_text_box.text) +# check responses +if botherRate_key_resp.keys in ['', [], None]: # No response was made + botherRate_key_resp.keys = None +thisExp.addData('botherRate_key_resp.keys',botherRate_key_resp.keys) +if botherRate_key_resp.keys != None: # we had a response + thisExp.addData('botherRate_key_resp.rt', botherRate_key_resp.rt) +thisExp.nextEntry() +# the Routine "botherRate" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "ringBell3" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +bellKey_3.keys = [] +bellKey_3.rt = [] +_bellKey_3_allKeys = [] +# keep track of which components have finished +ringBell3Components = [ringBell_text_3, bellKey_3] +for thisComponent in ringBell3Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "ringBell3" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *ringBell_text_3* updates + if ringBell_text_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + ringBell_text_3.frameNStart = frameN # exact frame index + ringBell_text_3.tStart = t # local t and not account for scr refresh + ringBell_text_3.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(ringBell_text_3, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'ringBell_text_3.started') + ringBell_text_3.setAutoDraw(True) + + # *bellKey_3* updates + waitOnFlip = False + if bellKey_3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bellKey_3.frameNStart = frameN # exact frame index + bellKey_3.tStart = t # local t and not account for scr refresh + bellKey_3.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bellKey_3, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bellKey_3.started') + bellKey_3.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(bellKey_3.clock.reset) # t=0 on next screen flip + win.callOnFlip(bellKey_3.clearEvents, eventType='keyboard') # clear events on next screen flip + if bellKey_3.status == STARTED and not waitOnFlip: + theseKeys = bellKey_3.getKeys(keyList=['c'], waitRelease=False) + _bellKey_3_allKeys.extend(theseKeys) + if len(_bellKey_3_allKeys): + bellKey_3.keys = _bellKey_3_allKeys[-1].name # just the last key pressed + bellKey_3.rt = _bellKey_3_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in ringBell3Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "ringBell3" --- +for thisComponent in ringBell3Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if bellKey_3.keys in ['', [], None]: # No response was made + bellKey_3.keys = None +thisExp.addData('bellKey_3.keys',bellKey_3.keys) +if bellKey_3.keys != None: # we had a response + thisExp.addData('bellKey_3.rt', bellKey_3.rt) +thisExp.nextEntry() +# the Routine "ringBell3" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "surpriseInstruct" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +instruct_surp1_key_resp.keys = [] +instruct_surp1_key_resp.rt = [] +_instruct_surp1_key_resp_allKeys = [] +# keep track of which components have finished +surpriseInstructComponents = [instruct_surprise1, instruct_surp1_key_resp] +for thisComponent in surpriseInstructComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "surpriseInstruct" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *instruct_surprise1* updates + if instruct_surprise1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instruct_surprise1.frameNStart = frameN # exact frame index + instruct_surprise1.tStart = t # local t and not account for scr refresh + instruct_surprise1.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instruct_surprise1, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'instruct_surprise1.started') + instruct_surprise1.setAutoDraw(True) + + # *instruct_surp1_key_resp* updates + waitOnFlip = False + if instruct_surp1_key_resp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instruct_surp1_key_resp.frameNStart = frameN # exact frame index + instruct_surp1_key_resp.tStart = t # local t and not account for scr refresh + instruct_surp1_key_resp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instruct_surp1_key_resp, 'tStartRefresh') # time at next scr refresh + instruct_surp1_key_resp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(instruct_surp1_key_resp.clock.reset) # t=0 on next screen flip + win.callOnFlip(instruct_surp1_key_resp.clearEvents, eventType='keyboard') # clear events on next screen flip + if instruct_surp1_key_resp.status == STARTED and not waitOnFlip: + theseKeys = instruct_surp1_key_resp.getKeys(keyList=['k'], waitRelease=False) + _instruct_surp1_key_resp_allKeys.extend(theseKeys) + if len(_instruct_surp1_key_resp_allKeys): + instruct_surp1_key_resp.keys = _instruct_surp1_key_resp_allKeys[-1].name # just the last key pressed + instruct_surp1_key_resp.rt = _instruct_surp1_key_resp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in surpriseInstructComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "surpriseInstruct" --- +for thisComponent in surpriseInstructComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if instruct_surp1_key_resp.keys in ['', [], None]: # No response was made + instruct_surp1_key_resp.keys = None +thisExp.addData('instruct_surp1_key_resp.keys',instruct_surp1_key_resp.keys) +if instruct_surp1_key_resp.keys != None: # we had a response + thisExp.addData('instruct_surp1_key_resp.rt', instruct_surp1_key_resp.rt) +thisExp.nextEntry() +# the Routine "surpriseInstruct" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# set up handler to look after randomisation of conditions etc +surprise_block_loop = data.TrialHandler(nReps=1.0, method='sequential', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions('surpriseBlock_select_A.xlsx'), + seed=None, name='surprise_block_loop') +thisExp.addLoop(surprise_block_loop) # add the loop to the experiment +thisSurprise_block_loop = surprise_block_loop.trialList[0] # so we can initialise stimuli with some values +# abbreviate parameter names if possible (e.g. rgb = thisSurprise_block_loop.rgb) +if thisSurprise_block_loop != None: + for paramName in thisSurprise_block_loop: + exec('{} = thisSurprise_block_loop[paramName]'.format(paramName)) + +for thisSurprise_block_loop in surprise_block_loop: + currentLoop = surprise_block_loop + # abbreviate parameter names if possible (e.g. rgb = thisSurprise_block_loop.rgb) + if thisSurprise_block_loop != None: + for paramName in thisSurprise_block_loop: + exec('{} = thisSurprise_block_loop[paramName]'.format(paramName)) + + # --- Prepare to start Routine "surp_taskReminders" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from task_blockReminder_code_2 + + + blockCounterZ1 = blockCounterZ1 + 1 + + if blockCounterZ1 == 1: + blockNumText = 'Block 1 of 8' + elif blockCounterZ1 == 2: + blockNumText = 'Block 2 of 8' + elif blockCounterZ1 == 3: + blockNumText = 'Block 3 of 8' + elif blockCounterZ1 == 4: + blockNumText = 'Block 4 of 8' + elif blockCounterZ1 == 5: + blockNumText = 'Block 5 of 8' + elif blockCounterZ1 == 6: + blockNumText = 'Block 6 of 8' + elif blockCounterZ1 == 7: + blockNumText = 'Block 7 of 8' + elif blockCounterZ1 == 8: + blockNumText = 'Block 8 of 8' + + + text_2.setText(blockNumText) + task_blockText_2.setText('Remember that you need to choose the face you think you have seen in the Arrow game. \n\nPress K for the right image, or press S for the left image.\n\nPress the "K" key when you are ready to begin.\n') + task_blockReminders_keyResp_2.keys = [] + task_blockReminders_keyResp_2.rt = [] + _task_blockReminders_keyResp_2_allKeys = [] + # keep track of which components have finished + surp_taskRemindersComponents = [text_2, task_blockText_2, task_blockReminders_keyResp_2] + for thisComponent in surp_taskRemindersComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "surp_taskReminders" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *text_2* updates + if text_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + text_2.frameNStart = frameN # exact frame index + text_2.tStart = t # local t and not account for scr refresh + text_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(text_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'text_2.started') + text_2.setAutoDraw(True) + + # *task_blockText_2* updates + if task_blockText_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockText_2.frameNStart = frameN # exact frame index + task_blockText_2.tStart = t # local t and not account for scr refresh + task_blockText_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockText_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockText_2.started') + task_blockText_2.setAutoDraw(True) + + # *task_blockReminders_keyResp_2* updates + waitOnFlip = False + if task_blockReminders_keyResp_2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + task_blockReminders_keyResp_2.frameNStart = frameN # exact frame index + task_blockReminders_keyResp_2.tStart = t # local t and not account for scr refresh + task_blockReminders_keyResp_2.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(task_blockReminders_keyResp_2, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'task_blockReminders_keyResp_2.started') + task_blockReminders_keyResp_2.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(task_blockReminders_keyResp_2.clock.reset) # t=0 on next screen flip + win.callOnFlip(task_blockReminders_keyResp_2.clearEvents, eventType='keyboard') # clear events on next screen flip + if task_blockReminders_keyResp_2.status == STARTED and not waitOnFlip: + theseKeys = task_blockReminders_keyResp_2.getKeys(keyList=['k'], waitRelease=False) + _task_blockReminders_keyResp_2_allKeys.extend(theseKeys) + if len(_task_blockReminders_keyResp_2_allKeys): + task_blockReminders_keyResp_2.keys = _task_blockReminders_keyResp_2_allKeys[-1].name # just the last key pressed + task_blockReminders_keyResp_2.rt = _task_blockReminders_keyResp_2_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in surp_taskRemindersComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "surp_taskReminders" --- + for thisComponent in surp_taskRemindersComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if task_blockReminders_keyResp_2.keys in ['', [], None]: # No response was made + task_blockReminders_keyResp_2.keys = None + surprise_block_loop.addData('task_blockReminders_keyResp_2.keys',task_blockReminders_keyResp_2.keys) + if task_blockReminders_keyResp_2.keys != None: # we had a response + surprise_block_loop.addData('task_blockReminders_keyResp_2.rt', task_blockReminders_keyResp_2.rt) + # the Routine "surp_taskReminders" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # --- Prepare to start Routine "fixation2" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from code_5 + + # make range from a to b in n stepsizes + ISIRange3 = np.linspace(800, 1200, 400) + + # picking from a shuffled array is easier for random selection in JS + shuffle(ISIRange3) + thisISI3 = ISIRange3[0]/1000 # the first item of the shuffled array + surprise_block_loop.addData('thisISI3', thisISI3) + # keep track of which components have finished + fixation2Components = [polygon] + for thisComponent in fixation2Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "fixation2" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *polygon* updates + if polygon.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + polygon.frameNStart = frameN # exact frame index + polygon.tStart = t # local t and not account for scr refresh + polygon.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(polygon, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'polygon.started') + polygon.setAutoDraw(True) + if polygon.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > polygon.tStartRefresh + thisISI3-frameTolerance: + # keep track of stop time/frame for later + polygon.tStop = t # not accounting for scr refresh + polygon.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'polygon.stopped') + polygon.setAutoDraw(False) + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in fixation2Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "fixation2" --- + for thisComponent in fixation2Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # the Routine "fixation2" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # set up handler to look after randomisation of conditions etc + trials = data.TrialHandler(nReps=1.0, method='random', + extraInfo=expInfo, originPath=-1, + trialList=data.importConditions(whichSurpriseBlock), + seed=None, name='trials') + thisExp.addLoop(trials) # add the loop to the experiment + thisTrial = trials.trialList[0] # so we can initialise stimuli with some values + # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb) + if thisTrial != None: + for paramName in thisTrial: + exec('{} = thisTrial[paramName]'.format(paramName)) + + for thisTrial in trials: + currentLoop = trials + # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb) + if thisTrial != None: + for paramName in thisTrial: + exec('{} = thisTrial[paramName]'.format(paramName)) + + # --- Prepare to start Routine "surpriseTask" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from code_6 + + if which_side_old_face_displayed == 'right': + old_img_position = [13.3, 1] + new_img_position = [-13.3, 1] + elif which_side_old_face_displayed == 'left': + old_img_position = [-13.3, 1] + new_img_position = [13.3, 1] + + old_face_image.setPos(old_img_position) + old_face_image.setImage(old_face_in_surp) + new_face_image.setPos(new_img_position) + new_face_image.setImage(new_face_in_surp) + instructsurpA1_right.setPos((13.3, -5)) + instructsurpA1_right.setText("Right - 'K' Key") + instructsurpA2_left.setText("Left - 'S' Key") + surprise_key_resp.keys = [] + surprise_key_resp.rt = [] + _surprise_key_resp_allKeys = [] + # keep track of which components have finished + surpriseTaskComponents = [text, old_face_image, new_face_image, instructsurpA1_right, instructsurpA2_left, surprise_key_resp] + for thisComponent in surpriseTaskComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "surpriseTask" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *text* updates + if text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + text.frameNStart = frameN # exact frame index + text.tStart = t # local t and not account for scr refresh + text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'text.started') + text.setAutoDraw(True) + + # *old_face_image* updates + if old_face_image.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + old_face_image.frameNStart = frameN # exact frame index + old_face_image.tStart = t # local t and not account for scr refresh + old_face_image.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(old_face_image, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'old_face_image.started') + old_face_image.setAutoDraw(True) + + # *new_face_image* updates + if new_face_image.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + new_face_image.frameNStart = frameN # exact frame index + new_face_image.tStart = t # local t and not account for scr refresh + new_face_image.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(new_face_image, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'new_face_image.started') + new_face_image.setAutoDraw(True) + + # *instructsurpA1_right* updates + if instructsurpA1_right.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructsurpA1_right.frameNStart = frameN # exact frame index + instructsurpA1_right.tStart = t # local t and not account for scr refresh + instructsurpA1_right.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructsurpA1_right, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'instructsurpA1_right.started') + instructsurpA1_right.setAutoDraw(True) + + # *instructsurpA2_left* updates + if instructsurpA2_left.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + instructsurpA2_left.frameNStart = frameN # exact frame index + instructsurpA2_left.tStart = t # local t and not account for scr refresh + instructsurpA2_left.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(instructsurpA2_left, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'instructsurpA2_left.started') + instructsurpA2_left.setAutoDraw(True) + + # *surprise_key_resp* updates + waitOnFlip = False + if surprise_key_resp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + surprise_key_resp.frameNStart = frameN # exact frame index + surprise_key_resp.tStart = t # local t and not account for scr refresh + surprise_key_resp.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(surprise_key_resp, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'surprise_key_resp.started') + surprise_key_resp.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(surprise_key_resp.clock.reset) # t=0 on next screen flip + win.callOnFlip(surprise_key_resp.clearEvents, eventType='keyboard') # clear events on next screen flip + if surprise_key_resp.status == STARTED and not waitOnFlip: + theseKeys = surprise_key_resp.getKeys(keyList=['s','k'], waitRelease=False) + _surprise_key_resp_allKeys.extend(theseKeys) + if len(_surprise_key_resp_allKeys): + surprise_key_resp.keys = _surprise_key_resp_allKeys[-1].name # just the last key pressed + surprise_key_resp.rt = _surprise_key_resp_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in surpriseTaskComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "surpriseTask" --- + for thisComponent in surpriseTaskComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # check responses + if surprise_key_resp.keys in ['', [], None]: # No response was made + surprise_key_resp.keys = None + trials.addData('surprise_key_resp.keys',surprise_key_resp.keys) + if surprise_key_resp.keys != None: # we had a response + trials.addData('surprise_key_resp.rt', surprise_key_resp.rt) + # the Routine "surpriseTask" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + + # --- Prepare to start Routine "fixation2" --- + continueRoutine = True + routineForceEnded = False + # update component parameters for each repeat + # Run 'Begin Routine' code from code_5 + + # make range from a to b in n stepsizes + ISIRange3 = np.linspace(800, 1200, 400) + + # picking from a shuffled array is easier for random selection in JS + shuffle(ISIRange3) + thisISI3 = ISIRange3[0]/1000 # the first item of the shuffled array + surprise_block_loop.addData('thisISI3', thisISI3) + # keep track of which components have finished + fixation2Components = [polygon] + for thisComponent in fixation2Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED + # reset timers + t = 0 + _timeToFirstFrame = win.getFutureFlipTime(clock="now") + frameN = -1 + + # --- Run Routine "fixation2" --- + while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *polygon* updates + if polygon.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + polygon.frameNStart = frameN # exact frame index + polygon.tStart = t # local t and not account for scr refresh + polygon.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(polygon, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'polygon.started') + polygon.setAutoDraw(True) + if polygon.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > polygon.tStartRefresh + thisISI3-frameTolerance: + # keep track of stop time/frame for later + polygon.tStop = t # not accounting for scr refresh + polygon.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'polygon.stopped') + polygon.setAutoDraw(False) + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in fixation2Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + + # --- Ending Routine "fixation2" --- + for thisComponent in fixation2Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) + # the Routine "fixation2" was not non-slip safe, so reset the non-slip timer + routineTimer.reset() + thisExp.nextEntry() + + # completed 1.0 repeats of 'trials' + + thisExp.nextEntry() + +# completed 1.0 repeats of 'surprise_block_loop' + + +# --- Prepare to start Routine "ringBell4" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +bellKey_4.keys = [] +bellKey_4.rt = [] +_bellKey_4_allKeys = [] +# keep track of which components have finished +ringBell4Components = [ringBell_text_4, bellKey_4] +for thisComponent in ringBell4Components: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "ringBell4" --- +while continueRoutine: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *ringBell_text_4* updates + if ringBell_text_4.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + ringBell_text_4.frameNStart = frameN # exact frame index + ringBell_text_4.tStart = t # local t and not account for scr refresh + ringBell_text_4.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(ringBell_text_4, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'ringBell_text_4.started') + ringBell_text_4.setAutoDraw(True) + + # *bellKey_4* updates + waitOnFlip = False + if bellKey_4.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + bellKey_4.frameNStart = frameN # exact frame index + bellKey_4.tStart = t # local t and not account for scr refresh + bellKey_4.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(bellKey_4, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'bellKey_4.started') + bellKey_4.status = STARTED + # keyboard checking is just starting + waitOnFlip = True + win.callOnFlip(bellKey_4.clock.reset) # t=0 on next screen flip + win.callOnFlip(bellKey_4.clearEvents, eventType='keyboard') # clear events on next screen flip + if bellKey_4.status == STARTED and not waitOnFlip: + theseKeys = bellKey_4.getKeys(keyList=['c'], waitRelease=False) + _bellKey_4_allKeys.extend(theseKeys) + if len(_bellKey_4_allKeys): + bellKey_4.keys = _bellKey_4_allKeys[-1].name # just the last key pressed + bellKey_4.rt = _bellKey_4_allKeys[-1].rt + # a response ends the routine + continueRoutine = False + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in ringBell4Components: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "ringBell4" --- +for thisComponent in ringBell4Components: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# check responses +if bellKey_4.keys in ['', [], None]: # No response was made + bellKey_4.keys = None +thisExp.addData('bellKey_4.keys',bellKey_4.keys) +if bellKey_4.keys != None: # we had a response + thisExp.addData('bellKey_4.rt', bellKey_4.rt) +thisExp.nextEntry() +# the Routine "ringBell4" was not non-slip safe, so reset the non-slip timer +routineTimer.reset() + +# --- Prepare to start Routine "finishMessage" --- +continueRoutine = True +routineForceEnded = False +# update component parameters for each repeat +# keep track of which components have finished +finishMessageComponents = [finishMessage_text] +for thisComponent in finishMessageComponents: + thisComponent.tStart = None + thisComponent.tStop = None + thisComponent.tStartRefresh = None + thisComponent.tStopRefresh = None + if hasattr(thisComponent, 'status'): + thisComponent.status = NOT_STARTED +# reset timers +t = 0 +_timeToFirstFrame = win.getFutureFlipTime(clock="now") +frameN = -1 + +# --- Run Routine "finishMessage" --- +while continueRoutine and routineTimer.getTime() < 3.0: + # get current time + t = routineTimer.getTime() + tThisFlip = win.getFutureFlipTime(clock=routineTimer) + tThisFlipGlobal = win.getFutureFlipTime(clock=None) + frameN = frameN + 1 # number of completed frames (so 0 is the first frame) + # update/draw components on each frame + + # *finishMessage_text* updates + if finishMessage_text.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance: + # keep track of start time/frame for later + finishMessage_text.frameNStart = frameN # exact frame index + finishMessage_text.tStart = t # local t and not account for scr refresh + finishMessage_text.tStartRefresh = tThisFlipGlobal # on global time + win.timeOnFlip(finishMessage_text, 'tStartRefresh') # time at next scr refresh + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'finishMessage_text.started') + finishMessage_text.setAutoDraw(True) + if finishMessage_text.status == STARTED: + # is it time to stop? (based on global clock, using actual start) + if tThisFlipGlobal > finishMessage_text.tStartRefresh + 3-frameTolerance: + # keep track of stop time/frame for later + finishMessage_text.tStop = t # not accounting for scr refresh + finishMessage_text.frameNStop = frameN # exact frame index + # add timestamp to datafile + thisExp.timestampOnFlip(win, 'finishMessage_text.stopped') + finishMessage_text.setAutoDraw(False) + + # check for quit (typically the Esc key) + if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]): + core.quit() + + # check if all components have finished + if not continueRoutine: # a component has requested a forced-end of Routine + routineForceEnded = True + break + continueRoutine = False # will revert to True if at least one component still running + for thisComponent in finishMessageComponents: + if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: + continueRoutine = True + break # at least one component has not yet finished + + # refresh the screen + if continueRoutine: # don't flip if this routine is over or we'll get a blank screen + win.flip() + +# --- Ending Routine "finishMessage" --- +for thisComponent in finishMessageComponents: + if hasattr(thisComponent, "setAutoDraw"): + thisComponent.setAutoDraw(False) +# using non-slip timing so subtract the expected duration of this Routine (unless ended on request) +if routineForceEnded: + routineTimer.reset() +else: + routineTimer.addTime(-3.000000) +# Run 'End Experiment' code from setup_code +win.mouseVisible = True #make the mouse cursor visable again + + +# --- End experiment --- +# Flip one final time so any remaining win.callOnFlip() +# and win.timeOnFlip() tasks get executed before quitting +win.flip() + +# these shouldn't be strictly necessary (should auto-save) +thisExp.saveAsWideText(filename+'.csv', delim='auto') +thisExp.saveAsPickle(filename) +logging.flush() +# make sure everything is closed down +if eyetracker: + eyetracker.setConnectionState(False) +thisExp.abort() # or data files will save again on exit +win.close() +core.quit() diff --git a/materials/mfe_e/orig_surp_table1.csv b/materials/mfe_e/orig_surp_table1.csv new file mode 100644 index 0000000..5167ee4 --- /dev/null +++ b/materials/mfe_e/orig_surp_table1.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-IM-671-601-N.jpg,img/neutralC/CFD-MM-323-053-N.jpg,left +img/neutralC/CFD-IF-660-464-N.jpg,img/neutralC/CFD-AF-236-145-N.jpg,right +img/neutralC/CFD-IM-674-281-N.jpg,img/neutralC/CFD-MF-319-016-N.jpg,right +img/neutralC/CFD-AM-233-236-N.jpg,img/neutralC/CFD-BM-034-031-N.jpg,left +img/neutralC/CFD-BF-205-141-N.jpg,img/neutralC/CFD-BF-241-222-N.jpg,right +img/neutralC/CFD-BM-253-004-N.jpg,img/neutralC/CFD-IM-663-230-N.jpg,left +img/neutralC/CFD-WF-001-003-N.jpg,img/neutralC/CFD-IF-668-009-N.jpg,right +img/neutralC/CFD-WM-033-025-N.jpg,img/neutralC/CFD-AM-204-122-N.jpg,left +img/neutralC/CFD-BM-238-242-N.jpg,img/neutralC/CFD-IF-609-408-N.jpg,left +img/neutralC/CFD-WM-227-099-N.jpg,img/neutralC/CFD-BF-007-001-N.jpg,left +img/neutralC/CFD-IF-744-114-N.jpg,img/neutralC/CFD-AF-230-193-N.jpg,right +img/neutralC/CFD-AF-246-242-N.jpg,img/neutralC/CFD-MF-317-002-N.jpg,left +img/neutralC/CFD-WF-244-163-N.jpg,img/neutralC/CFD-MF-350-029-N.jpg,left +img/neutralC/CFD-WM-012-001-N.jpg,img/neutralC/CFD-IM-712-005-N.jpg,left +img/neutralC/CFD-WM-023-001-N.jpg,img/neutralC/CFD-IM-603-305-N.jpg,left +img/neutralC/CFD-BF-012-001-N.jpg,img/neutralC/CFD-IM-666-372-N.jpg,left +img/neutralC/CFD-MM-304-002-N.jpg,img/neutralC/CFD-IM-682-019-N.jpg,right +img/neutralC/CFD-WF-234-086-N.jpg,img/neutralC/CFD-WF-232-161-N.jpg,left +img/neutralC/CFD-LF-245-166-N.jpg,img/neutralC/CFD-AM-239-147-N.jpg,right +img/neutralC/CFD-WM-004-010-N.jpg,img/neutralC/CFD-WF-237-067-N.jpg,left +img/neutralC/CFD-IM-700-009-N.jpg,img/neutralC/CFD-MM-309-027-N.jpg,left +img/neutralC/CFD-IM-617-174-N.jpg,img/neutralC/CFD-AF-256-160-N.jpg,right +img/neutralC/CFD-BM-239-136-N.jpg,img/neutralC/CFD-MF-344-012-N.jpg,left +img/neutralC/CFD-WM-215-041-N.jpg,img/neutralC/CFD-AM-209-048-N.jpg,right +img/neutralC/CFD-BM-020-001-N.jpg,img/neutralC/CFD-BM-229-209-N.jpg,right +img/neutralC/CFD-IM-632-097-N.jpg,img/neutralC/CFD-IM-613-169-N.jpg,left +img/neutralC/CFD-LM-247-095-N.jpg,img/neutralC/CFD-WM-239-128-N.jpg,left +img/neutralC/CFD-BM-009-002-N.jpg,img/neutralC/CFD-WM-208-068-N.jpg,left +img/neutralC/CFD-IM-657-308-N.jpg,img/neutralC/CFD-IF-734-108-N.jpg,left +img/neutralC/CFD-WF-213-031-N.jpg,img/neutralC/CFD-BF-005-001-N.jpg,right +img/neutralC/CFD-WF-250-167-N.jpg,img/neutralC/CFD-WF-019-005-N.jpg,left +img/neutralC/CFD-BM-227-191-N.jpg,img/neutralC/CFD-LM-211-128-N.jpg,left +img/neutralC/CFD-WM-028-003-N.jpg,img/neutralC/CFD-IF-644-306-1-N.jpg,left +img/neutralC/CFD-MF-305-014-N.jpg,img/neutralC/CFD-AF-249-092-N.jpg,right +img/neutralC/CFD-AM-219-101-N.jpg,img/neutralC/CFD-LF-240-199-N.jpg,left +img/neutralC/CFD-BM-004-002-N.jpg,img/neutralC/CFD-WF-038-021-N.jpg,left +img/neutralC/CFD-IM-707-105-N.jpg,img/neutralC/CFD-BM-242-233-N.jpg,right +img/neutralC/CFD-MF-307-002-N.jpg,img/neutralC/CFD-BM-226-276-N.jpg,left +img/neutralC/CFD-WF-030-002-N.jpg,img/neutralC/CFD-MF-320-002-N.jpg,right +img/neutralC/CFD-LF-204-133-N.jpg,img/neutralC/CFD-WM-230-131-N.jpg,left +img/neutralC/CFD-WF-233-112-N.jpg,img/neutralC/CFD-WM-214-026-N.jpg,right +img/neutralC/CFD-AF-253-130-N.jpg,img/neutralC/CFD-WF-230-158-N.jpg,right +img/neutralC/CFD-BM-213-134-N.jpg,img/neutralC/CFD-BM-045-004-N.jpg,right +img/neutralC/CFD-LF-225-164-N.jpg,img/neutralC/CFD-AF-228-173-N.jpg,left +img/neutralC/CFD-WM-020-001-N.jpg,img/neutralC/CFD-LF-248-160-N.jpg,right +img/neutralC/CFD-WM-034-030-N.jpg,img/neutralC/CFD-IF-741-040-N.jpg,right +img/neutralC/CFD-MF-300-002-N.jpg,img/neutralC/CFD-AM-214-168-N.jpg,left +img/neutralC/CFD-WM-212-097-N.jpg,img/neutralC/CFD-BF-037-022-N.jpg,right diff --git a/materials/mfe_e/orig_surp_table2.csv b/materials/mfe_e/orig_surp_table2.csv new file mode 100644 index 0000000..b8adb69 --- /dev/null +++ b/materials/mfe_e/orig_surp_table2.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-IM-689-263-N.jpg,img/neutralC/CFD-BM-214-075-N.jpg,right +img/neutralC/CFD-MF-313-002-N.jpg,img/neutralC/CFD-LF-229-164-N.jpg,right +img/neutralC/CFD-BM-003-003-N.jpg,img/neutralC/CFD-LF-252-172-N.jpg,right +img/neutralC/CFD-BM-207-024-N.jpg,img/neutralC/CFD-BM-201-077-N.jpg,left +img/neutralC/CFD-IF-718-001-N.jpg,img/neutralC/CFD-AM-237-154-N.jpg,right +img/neutralC/CFD-WF-208-068-N.jpg,img/neutralC/CFD-WF-206-147-N.jpg,right +img/neutralC/CFD-WM-015-002-N.jpg,img/neutralC/CFD-WM-222-057-N.jpg,right +img/neutralC/CFD-BM-015-015-N.jpg,img/neutralC/CFD-WF-242-001-N.jpg,right +img/neutralC/CFD-WF-023-003-N.jpg,img/neutralC/CFD-MM-318-003-N.jpg,left +img/neutralC/CFD-IM-669-111-N.jpg,img/neutralC/CFD-MF-356-017-N.jpg,left +img/neutralC/CFD-LM-241-125-N.jpg,img/neutralC/CFD-BF-249-091-N.jpg,left +img/neutralC/CFD-IF-693-172-N.jpg,img/neutralC/CFD-IF-730-410-N.jpg,left +img/neutralC/CFD-WM-248-036-N.jpg,img/neutralC/CFD-LM-209-111-N.jpg,left +img/neutralC/CFD-BM-036-003-N.jpg,img/neutralC/CFD-LM-227-103-N.jpg,right +img/neutralC/CFD-WM-219-008-N.jpg,img/neutralC/CFD-LF-244-096-N.jpg,right +img/neutralC/CFD-WM-009-002-N.jpg,img/neutralC/CFD-AF-218-157-N.jpg,left +img/neutralC/CFD-AM-211-052-N.jpg,img/neutralC/CFD-LM-220-329-N.jpg,right +img/neutralC/CFD-BM-217-082-N.jpg,img/neutralC/CFD-BF-240-179-N.jpg,left +img/neutralC/CFD-LM-213-061-N.jpg,img/neutralC/CFD-LF-254-125-N.jpg,right +img/neutralC/CFD-AF-250-200-N.jpg,img/neutralC/CFD-LF-251-057-N.jpg,right +img/neutralC/CFD-WM-242-011-N.jpg,img/neutralC/CFD-IM-694-297-N.jpg,right +img/neutralC/CFD-IM-627-178-N.jpg,img/neutralC/CFD-IM-739-012-N.jpg,right +img/neutralC/CFD-IF-665-015-N.jpg,img/neutralC/CFD-WF-231-099-N.jpg,left +img/neutralC/CFD-WM-228-065-N.jpg,img/neutralC/CFD-BF-008-001-N.jpg,right +img/neutralC/CFD-MF-321-003-N.jpg,img/neutralC/CFD-WF-249-126-N.jpg,left +img/neutralC/CFD-WM-017-002-N.jpg,img/neutralC/CFD-WF-251-014-N.jpg,left +img/neutralC/CFD-MM-306-010-N.jpg,img/neutralC/CFD-BM-246-192-N.jpg,left +img/neutralC/CFD-WF-240-083-N.jpg,img/neutralC/CFD-IF-618-212-N.jpg,left +img/neutralC/CFD-IM-667-369-N.jpg,img/neutralC/CFD-LM-251-073-N.jpg,left +img/neutralC/CFD-BM-026-002-N.jpg,img/neutralC/CFD-BF-211-168-N.jpg,left +img/neutralC/CFD-BF-218-207-N.jpg,img/neutralC/CFD-WF-205-006-N.jpg,right +img/neutralC/CFD-BM-030-003-N.jpg,img/neutralC/CFD-BF-246-170-N.jpg,right +img/neutralC/CFD-IF-672-305-N.jpg,img/neutralC/CFD-BM-209-088-N.jpg,left +img/neutralC/CFD-BM-023-029-N.jpg,img/neutralC/CFD-WM-001-014-N.jpg,left +img/neutralC/CFD-MM-319-052-N.jpg,img/neutralC/CFD-AM-207-108-N.jpg,right +img/neutralC/CFD-AF-239-171-N.jpg,img/neutralC/CFD-LM-234-176-N.jpg,right +img/neutralC/CFD-BF-051-035-N.jpg,img/neutralC/CFD-BF-034-002-N.jpg,left +img/neutralC/CFD-WF-033-002-N.jpg,img/neutralC/CFD-AM-208-143-N.jpg,left +img/neutralC/CFD-LF-224-176-N.jpg,img/neutralC/CFD-IF-737-104-N.jpg,left +img/neutralC/CFD-LM-237-264-N.jpg,img/neutralC/CFD-WF-028-023-N.jpg,left +img/neutralC/CFD-IF-710-016-N.jpg,img/neutralC/CFD-WM-029-023-N.jpg,left +img/neutralC/CFD-BF-044-034-N.jpg,img/neutralC/CFD-AF-217-155-N.jpg,left +img/neutralC/CFD-BF-043-003-N.jpg,img/neutralC/CFD-AM-250-149-N.jpg,left +img/neutralC/CFD-WF-200-099-N.jpg,img/neutralC/CFD-MM-313-002-N.jpg,left +img/neutralC/CFD-IF-634-382-N.jpg,img/neutralC/CFD-MF-351-017-N.jpg,right +img/neutralC/CFD-IM-651-308-N.jpg,img/neutralC/CFD-IF-733-110-N.jpg,right +img/neutralC/CFD-IM-664-651-N.jpg,img/neutralC/CFD-LF-234-139-N.jpg,right +img/neutralC/CFD-WM-019-003-N.jpg,img/neutralC/CFD-WM-203-023-N.jpg,left diff --git a/materials/mfe_e/orig_surp_table3.csv b/materials/mfe_e/orig_surp_table3.csv new file mode 100644 index 0000000..fa42f52 --- /dev/null +++ b/materials/mfe_e/orig_surp_table3.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-WF-008-002-N.jpg,img/neutralC/CFD-AF-224-026-N.jpg,right +img/neutralC/CFD-IF-677-452-1-N.jpg,img/neutralC/CFD-LF-233-277-N.jpg,left +img/neutralC/CFD-BF-208-266-N.jpg,img/neutralC/CFD-AF-219-106-N.jpg,left +img/neutralC/CFD-AF-213-126-N.jpg,img/neutralC/CFD-BF-215-177-N.jpg,left +img/neutralC/CFD-WM-038-003-N.jpg,img/neutralC/CFD-WM-204-031-N.jpg,right +img/neutralC/CFD-AM-212-050-N.jpg,img/neutralC/CFD-IM-692-011-N.jpg,left +img/neutralC/CFD-AM-251-124-N.jpg,img/neutralC/CFD-BM-221-198-N.jpg,right +img/neutralC/CFD-WF-026-002-N.jpg,img/neutralC/CFD-WM-037-025-N.jpg,left +img/neutralC/CFD-LF-206-078-N.jpg,img/neutralC/CFD-IM-656-273-N.jpg,left +img/neutralC/CFD-LF-255-088-N.jpg,img/neutralC/CFD-IM-699-002-N.jpg,right +img/neutralC/CFD-LM-217-162-N.jpg,img/neutralC/CFD-AF-247-278-N.jpg,left +img/neutralC/CFD-LM-216-082-N.jpg,img/neutralC/CFD-WM-010-001-N.jpg,left +img/neutralC/CFD-IM-659-359-N.jpg,img/neutralC/CFD-AF-243-170-N.jpg,right +img/neutralC/CFD-WM-209-038-N.jpg,img/neutralC/CFD-AF-212-097-N.jpg,right +img/neutralC/CFD-BF-025-002-N.jpg,img/neutralC/CFD-MF-324-031-N.jpg,left +img/neutralC/CFD-BF-045-003-N.jpg,img/neutralC/CFD-MM-315-013-N.jpg,right +img/neutralC/CFD-IM-639-263-N.jpg,img/neutralC/CFD-IF-704-125-N.jpg,left +img/neutralC/CFD-BM-251-013-N.jpg,img/neutralC/CFD-MM-302-002-N.jpg,left +img/neutralC/CFD-BF-255-140-N.jpg,img/neutralC/CFD-AM-226-234-N.jpg,left +img/neutralC/CFD-AF-232-078-N.jpg,img/neutralC/CFD-LF-221-002-N.jpg,right +img/neutralC/CFD-WM-213-076-N.jpg,img/neutralC/CFD-IF-723-255-N.jpg,left +img/neutralC/CFD-BF-033-028-N.jpg,img/neutralC/CFD-BM-218-132-N.jpg,right +img/neutralC/CFD-AF-244-168-N.jpg,img/neutralC/CFD-IM-621-136-N.jpg,right +img/neutralC/CFD-MM-321-021-N.jpg,img/neutralC/CFD-IM-708-362-N.jpg,left +img/neutralC/CFD-IM-738-191-N.jpg,img/neutralC/CFD-AF-207-023-N.jpg,right +img/neutralC/CFD-AM-242-176-N.jpg,img/neutralC/CFD-WF-025-019-N.jpg,left +img/neutralC/CFD-BF-038-037-N.jpg,img/neutralC/CFD-WF-229-004-N.jpg,right +img/neutralC/CFD-BF-004-014-N.jpg,img/neutralC/CFD-MM-301-011-N.jpg,left +img/neutralC/CFD-WM-202-107-N.jpg,img/neutralC/CFD-WM-231-112-N.jpg,right +img/neutralC/CFD-IM-680-369-N.jpg,img/neutralC/CFD-AM-227-184-N.jpg,left +img/neutralC/CFD-BM-005-003-N.jpg,img/neutralC/CFD-LM-222-239-N.jpg,left +img/neutralC/CFD-BM-039-029-N.jpg,img/neutralC/CFD-WM-243-107-N.jpg,left +img/neutralC/CFD-BF-018-039-N.jpg,img/neutralC/CFD-MM-322-002-N.jpg,right +img/neutralC/CFD-LM-204-001-N.jpg,img/neutralC/CFD-MF-310-027-N.jpg,right +img/neutralC/CFD-IM-701-312-N.jpg,img/neutralC/CFD-IF-602-134-N.jpg,right +img/neutralC/CFD-WF-036-023-N.jpg,img/neutralC/CFD-MF-349-036-N.jpg,right +img/neutralC/CFD-BF-003-003-N.jpg,img/neutralC/CFD-AF-245-143-N.jpg,right +img/neutralC/CFD-WM-254-152-N.jpg,img/neutralC/CFD-BF-013-001-N.jpg,right +img/neutralC/CFD-AF-227-207-N.jpg,img/neutralC/CFD-MF-332-014-N.jpg,right +img/neutralC/CFD-LF-241-188-N.jpg,img/neutralC/CFD-LF-253-003-N.jpg,left +img/neutralC/CFD-BF-027-002-N.jpg,img/neutralC/CFD-MF-325-002-N.jpg,left +img/neutralC/CFD-BF-238-190-N.jpg,img/neutralC/CFD-WF-220-101-N.jpg,right +img/neutralC/CFD-MM-316-156-N.jpg,img/neutralC/CFD-AF-220-107-N.jpg,left +img/neutralC/CFD-WM-258-125-N.jpg,img/neutralC/CFD-MF-339-002-N.jpg,left +img/neutralC/CFD-IF-673-389-N.jpg,img/neutralC/CFD-MM-312-002-N.jpg,right +img/neutralC/CFD-WM-014-002-N.jpg,img/neutralC/CFD-LF-213-079-N.jpg,left +img/neutralC/CFD-AM-225-102-N.jpg,img/neutralC/CFD-MM-307-002-N.jpg,right +img/neutralC/CFD-WM-255-219-N.jpg,img/neutralC/CFD-IM-720-014-N.jpg,right diff --git a/materials/mfe_e/orig_surp_table4.csv b/materials/mfe_e/orig_surp_table4.csv new file mode 100644 index 0000000..446abde --- /dev/null +++ b/materials/mfe_e/orig_surp_table4.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-AF-215-70-N.jpg,img/neutralC/CFD-AM-206-086-N.jpg,right +img/neutralC/CFD-WF-209-052-N.jpg,img/neutralC/CFD-LM-231-214-N.jpg,left +img/neutralC/CFD-LM-226-175-N.jpg,img/neutralC/CFD-WM-206-045-N.jpg,left +img/neutralC/CFD-WF-238-023-N.jpg,img/neutralC/CFD-WM-205-007-N.jpg,right +img/neutralC/CFD-BF-002-001-N.jpg,img/neutralC/CFD-LF-202-065-N.jpg,right +img/neutralC/CFD-LF-214-090-N.jpg,img/neutralC/CFD-LM-248-089-N.jpg,right +img/neutralC/CFD-WF-007-001-N.jpg,img/neutralC/CFD-BF-233-116-N.jpg,right +img/neutralC/CFD-AM-230-150-N.jpg,img/neutralC/CFD-AF-211-066-N.jpg,right +img/neutralC/CFD-LM-218-183-N.jpg,img/neutralC/CFD-MF-360-106-N.jpg,left +img/neutralC/CFD-BF-020-002-N.jpg,img/neutralC/CFD-BM-240-207-N.jpg,right +img/neutralC/CFD-BM-018-001-N.jpg,img/neutralC/CFD-LM-230-202-N.jpg,right +img/neutralC/CFD-WF-006-002-N.jpg,img/neutralC/CFD-BM-210-148-N.jpg,left +img/neutralC/CFD-AM-245-111-N.jpg,img/neutralC/CFD-IM-607-018-N.jpg,right +img/neutralC/CFD-MF-318-022-N.jpg,img/neutralC/CFD-AM-229-224-N.jpg,right +img/neutralC/CFD-IM-675-015-N.jpg,img/neutralC/CFD-IF-735-353-N.jpg,left +img/neutralC/CFD-LM-243-075-N.jpg,img/neutralC/CFD-IM-711-011-N.jpg,right +img/neutralC/CFD-MF-335-002-N.jpg,img/neutralC/CFD-LM-242-002-N.jpg,right +img/neutralC/CFD-LM-238-129-N.jpg,img/neutralC/CFD-BF-200-080-N.jpg,right +img/neutralC/CFD-LF-222-147-N.jpg,img/neutralC/CFD-MF-353-204-N.jpg,left +img/neutralC/CFD-IM-696-001-N.jpg,img/neutralC/CFD-AF-209-006-N.jpg,left +img/neutralC/CFD-AF-221-147-N.jpg,img/neutralC/CFD-LF-219-223-N.jpg,right +img/neutralC/CFD-BF-226-119-N.jpg,img/neutralC/CFD-IM-715-013-N.jpg,right +img/neutralC/CFD-WF-226-095-N.jpg,img/neutralC/CFD-IF-622-096-N.jpg,left +img/neutralC/CFD-BF-010-001-N.jpg,img/neutralC/CFD-LM-208-110-N.jpg,left +img/neutralC/CFD-BF-232-187-N.jpg,img/neutralC/CFD-LF-231-260-N.jpg,right +img/neutralC/CFD-BM-250-170-N.jpg,img/neutralC/CFD-IF-713-170-N.jpg,right +img/neutralC/CFD-WM-006-002-N.jpg,img/neutralC/CFD-MF-355-022-N.jpg,right +img/neutralC/CFD-MF-309-002-N.jpg,img/neutralC/CFD-MM-311-001-N.jpg,left +img/neutralC/CFD-AF-229-160-N.jpg,img/neutralC/CFD-WF-024-003-N.jpg,left +img/neutralC/CFD-LF-212-066-N.jpg,img/neutralC/CFD-LF-249-132-N.jpg,left +img/neutralC/CFD-BM-247-240-N.jpg,img/neutralC/CFD-BM-206-114-N.jpg,left +img/neutralC/CFD-BM-001-014-N.jpg,img/neutralC/CFD-IM-695-001-N.jpg,left +img/neutralC/CFD-BF-039-031-N.jpg,img/neutralC/CFD-BF-230-189-N.jpg,left +img/neutralC/CFD-BF-028-001-N.jpg,img/neutralC/CFD-AF-222-134-N.jpg,left +img/neutralC/CFD-AF-237-223-N.jpg,img/neutralC/CFD-MF-354-067-N.jpg,left +img/neutralC/CFD-BF-212-315-N.jpg,img/neutralC/CFD-WM-207-048-N.jpg,left +img/neutralC/CFD-WM-018-002-N.jpg,img/neutralC/CFD-WF-247-065-N.jpg,left +img/neutralC/CFD-WM-253-119-N.jpg,img/neutralC/CFD-BF-242-154-N.jpg,left +img/neutralC/CFD-WF-235-121-N.jpg,img/neutralC/CFD-BM-017-021-N.jpg,right +img/neutralC/CFD-MF-301-024-N.jpg,img/neutralC/CFD-BF-245-178-N.jpg,left +img/neutralC/CFD-LM-200-045-N.jpg,img/neutralC/CFD-LM-207-004-N.jpg,right +img/neutralC/CFD-LF-208-127-N.jpg,img/neutralC/CFD-BM-044-001-N.jpg,left +img/neutralC/CFD-IM-703-182-N.jpg,img/neutralC/CFD-IF-691-007-N.jpg,right +img/neutralC/CFD-AM-235-241-N.jpg,img/neutralC/CFD-IM-647-548-N.jpg,left +img/neutralC/CFD-AM-247-165-N.jpg,img/neutralC/CFD-BF-030-002-N.jpg,right +img/neutralC/CFD-LM-219-295-N.jpg,img/neutralC/CFD-WM-216-061-N.jpg,left +img/neutralC/CFD-WM-024-015-N.jpg,img/neutralC/CFD-WF-225-101-N.jpg,right +img/neutralC/CFD-BM-013-002-N.jpg,img/neutralC/CFD-WF-015-006-N.jpg,right diff --git a/materials/mfe_e/orig_surp_table5.csv b/materials/mfe_e/orig_surp_table5.csv new file mode 100644 index 0000000..d79f67a --- /dev/null +++ b/materials/mfe_e/orig_surp_table5.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-IF-642-295-N.jpg,img/neutralC/CFD-LF-207-198-N.jpg,left +img/neutralC/CFD-BF-217-189-N.jpg,img/neutralC/CFD-WM-036-031-N.jpg,left +img/neutralC/CFD-IM-635-010-N.jpg,img/neutralC/CFD-IM-655-234-N.jpg,right +img/neutralC/CFD-IM-684-008-N.jpg,img/neutralC/CFD-MF-346-008-N.jpg,left +img/neutralC/CFD-BF-237-172-N.jpg,img/neutralC/CFD-BF-209-172-N.jpg,left +img/neutralC/CFD-WM-221-091-N.jpg,img/neutralC/CFD-WM-240-125-N.jpg,left +img/neutralC/CFD-BM-029-024-N.jpg,img/neutralC/CFD-BM-252-161-N.jpg,left +img/neutralC/CFD-WF-221-005-N.jpg,img/neutralC/CFD-WM-238-020-N.jpg,left +img/neutralC/CFD-BF-202-109-N.jpg,img/neutralC/CFD-IM-630-134-N.jpg,left +img/neutralC/CFD-IF-625-225-N.jpg,img/neutralC/CFD-WM-256-138-N.jpg,right +img/neutralC/CFD-IM-743-006-N.jpg,img/neutralC/CFD-WM-236-072-N.jpg,left +img/neutralC/CFD-BF-207-004-N.jpg,img/neutralC/CFD-LM-229-187-N.jpg,right +img/neutralC/CFD-LF-211-003-N.jpg,img/neutralC/CFD-LM-239-075-N.jpg,left +img/neutralC/CFD-AF-205-155-N.jpg,img/neutralC/CFD-BM-249-235-N.jpg,right +img/neutralC/CFD-WM-225-127-N.jpg,img/neutralC/CFD-BF-009-002-N.jpg,right +img/neutralC/CFD-BM-027-001-N.jpg,img/neutralC/CFD-IM-654-417-N.jpg,right +img/neutralC/CFD-MF-340-026-N.jpg,img/neutralC/CFD-IM-725-142-N.jpg,right +img/neutralC/CFD-BF-014-002-N.jpg,img/neutralC/CFD-LF-246-129-N.jpg,right +img/neutralC/CFD-BF-236-177-N.jpg,img/neutralC/CFD-LM-210-156-N.jpg,right +img/neutralC/CFD-AM-236-090-N.jpg,img/neutralC/CFD-BM-236-248-N.jpg,right +img/neutralC/CFD-WM-249-239-N.jpg,img/neutralC/CFD-LM-236-163-N.jpg,right +img/neutralC/CFD-BM-010-003-N.jpg,img/neutralC/CFD-IF-631-363-N.jpg,right +img/neutralC/CFD-LF-239-148-N.jpg,img/neutralC/CFD-LM-235-231-N.jpg,right +img/neutralC/CFD-BF-201-080-N.jpg,img/neutralC/CFD-IM-688-322-N.jpg,left +img/neutralC/CFD-BF-041-001-N.jpg,img/neutralC/CFD-WM-035-032-N.jpg,right +img/neutralC/CFD-WF-228-196-N.jpg,img/neutralC/CFD-MM-300-035-N.jpg,left +img/neutralC/CFD-WF-027-003-N.jpg,img/neutralC/CFD-WM-223-056-N.jpg,left +img/neutralC/CFD-AF-254-167-N.jpg,img/neutralC/CFD-AM-241-287-N.jpg,left +img/neutralC/CFD-MF-328-020-N.jpg,img/neutralC/CFD-IM-658-284-N.jpg,right +img/neutralC/CFD-AM-220-134-N.jpg,img/neutralC/CFD-LF-200-058-N.jpg,right +img/neutralC/CFD-IM-638-250-1-N.jpg,img/neutralC/CFD-WM-217-070-N.jpg,left +img/neutralC/CFD-WF-029-002-N.jpg,img/neutralC/CFD-MF-347-001-N.jpg,left +img/neutralC/CFD-LM-252-076-N.jpg,img/neutralC/CFD-WM-233-106-N.jpg,right +img/neutralC/CFD-LF-242-121-N.jpg,img/neutralC/CFD-WF-218-087-N.jpg,right +img/neutralC/CFD-LM-244-068-N.jpg,img/neutralC/CFD-BF-035-001-N.jpg,right +img/neutralC/CFD-WF-005-010-N.jpg,img/neutralC/CFD-AM-234-355-N.jpg,left +img/neutralC/CFD-WF-207-014-N.jpg,img/neutralC/CFD-IM-679-069-N.jpg,left +img/neutralC/CFD-WF-243-148-N.jpg,img/neutralC/CFD-AM-246-184-N.jpg,right +img/neutralC/CFD-AF-233-190-N.jpg,img/neutralC/CFD-IF-612-149-N.jpg,right +img/neutralC/CFD-AM-221-184-N.jpg,img/neutralC/CFD-MF-314-001-N.jpg,left +img/neutralC/CFD-MF-336-016-N.jpg,img/neutralC/CFD-IM-690-282-N.jpg,left +img/neutralC/CFD-IM-606-008-N.jpg,img/neutralC/CFD-WM-251-002-N.jpg,right +img/neutralC/CFD-LF-203-066-N.jpg,img/neutralC/CFD-AM-252-114-N.jpg,left +img/neutralC/CFD-AF-240-206-N.jpg,img/neutralC/CFD-WF-013-003-N.jpg,left +img/neutralC/CFD-WF-224-099-N.jpg,img/neutralC/CFD-BF-048-002-N.jpg,left +img/neutralC/CFD-WM-021-001-N.jpg,img/neutralC/CFD-BF-239-180-N.jpg,left +img/neutralC/CFD-WF-002-004-N.jpg,img/neutralC/CFD-MM-314-062-N.jpg,left +img/neutralC/CFD-WF-245-084-N.jpg,img/neutralC/CFD-WM-031-003-N.jpg,right diff --git a/materials/mfe_e/orig_surp_table6.csv b/materials/mfe_e/orig_surp_table6.csv new file mode 100644 index 0000000..05e32ba --- /dev/null +++ b/materials/mfe_e/orig_surp_table6.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-IM-615-167-N.jpg,img/neutralC/CFD-LF-209-072-N.jpg,right +img/neutralC/CFD-LF-238-154-N.jpg,img/neutralC/CFD-AF-201-060-N.jpg,left +img/neutralC/CFD-MF-343-001-N.jpg,img/neutralC/CFD-BM-224-073-N.jpg,right +img/neutralC/CFD-BF-254-201-N.jpg,img/neutralC/CFD-BF-220-161-N.jpg,right +img/neutralC/CFD-LM-233-171-N.jpg,img/neutralC/CFD-MF-334-002-N.jpg,right +img/neutralC/CFD-AF-202-122-N.jpg,img/neutralC/CFD-AF-214-139-N.jpg,left +img/neutralC/CFD-WF-222-092-N.jpg,img/neutralC/CFD-WF-216-079-N.jpg,left +img/neutralC/CFD-IF-676-017-N.jpg,img/neutralC/CFD-WM-245-123-N.jpg,right +img/neutralC/CFD-LF-210-220-N.jpg,img/neutralC/CFD-WF-039-025-N.jpg,right +img/neutralC/CFD-IM-616-214-N.jpg,img/neutralC/CFD-IM-698-011-N.jpg,right +img/neutralC/CFD-BM-241-235-N.jpg,img/neutralC/CFD-AF-203-077-N.jpg,right +img/neutralC/CFD-LF-230-203-N.jpg,img/neutralC/CFD-WF-236-107-N.jpg,left +img/neutralC/CFD-IM-646-023-N.jpg,img/neutralC/CFD-LF-227-054-N.jpg,right +img/neutralC/CFD-BF-006-017-N.jpg,img/neutralC/CFD-BM-022-022-N.jpg,right +img/neutralC/CFD-BM-243-218-N.jpg,img/neutralC/CFD-BF-050-003-N.jpg,right +img/neutralC/CFD-IM-697-015-N.jpg,img/neutralC/CFD-WF-204-038-N.jpg,left +img/neutralC/CFD-IF-629-234-N.jpg,img/neutralC/CFD-IF-601-519-N.jpg,right +img/neutralC/CFD-LM-214-165-N.jpg,img/neutralC/CFD-WF-203-229-N.jpg,left +img/neutralC/CFD-IF-608-390-N.jpg,img/neutralC/CFD-BF-016-017-N.jpg,right +img/neutralC/CFD-WM-237-052-N.jpg,img/neutralC/CFD-BF-248-149-N.jpg,left +img/neutralC/CFD-BF-222-240-N.jpg,img/neutralC/CFD-BM-245-164-N.jpg,left +img/neutralC/CFD-LM-253-075-N.jpg,img/neutralC/CFD-MF-311-001-N.jpg,left +img/neutralC/CFD-BM-225-154-N.jpg,img/neutralC/CFD-AF-208-003-N.jpg,left +img/neutralC/CFD-BM-019-002-N.jpg,img/neutralC/CFD-IF-605-066-N.jpg,left +img/neutralC/CFD-BF-042-026-N.jpg,img/neutralC/CFD-WF-035-024-N.jpg,right +img/neutralC/CFD-MF-337-026-N.jpg,img/neutralC/CFD-MF-330-001-N.jpg,left +img/neutralC/CFD-LF-236-221-N.jpg,img/neutralC/CFD-BF-219-137-N.jpg,right +img/neutralC/CFD-IM-604-014-N.jpg,img/neutralC/CFD-MF-331-010-N.jpg,left +img/neutralC/CFD-AF-206-079-N.jpg,img/neutralC/CFD-BM-216-088-N.jpg,left +img/neutralC/CFD-BF-214-308-N.jpg,img/neutralC/CFD-WM-241-072-N.jpg,left +img/neutralC/CFD-IM-702-101-N.jpg,img/neutralC/CFD-BM-024-001-N.jpg,left +img/neutralC/CFD-IM-719-221-N.jpg,img/neutralC/CFD-MF-322-020-N.jpg,right +img/neutralC/CFD-LM-215-247-N.jpg,img/neutralC/CFD-IM-661-254-N.jpg,left +img/neutralC/CFD-WM-041-021-N.jpg,img/neutralC/CFD-BM-223-171-N.jpg,right +img/neutralC/CFD-LF-247-051-N.jpg,img/neutralC/CFD-IF-614-107-N.jpg,right +img/neutralC/CFD-MF-302-027-N.jpg,img/neutralC/CFD-AM-238-269-N.jpg,right +img/neutralC/CFD-AM-244-222-N.jpg,img/neutralC/CFD-BM-230-232-N.jpg,left +img/neutralC/CFD-BF-253-202-N.jpg,img/neutralC/CFD-WF-211-001-N.jpg,right +img/neutralC/CFD-WM-002-009-N.jpg,img/neutralC/CFD-AM-248-104-N.jpg,right +img/neutralC/CFD-LF-250-169-N.jpg,img/neutralC/CFD-LF-228-125-N.jpg,left +img/neutralC/CFD-IF-620-218-N.jpg,img/neutralC/CFD-BM-222-173-N.jpg,right +img/neutralC/CFD-LF-218-072-N.jpg,img/neutralC/CFD-BM-038-001-N.jpg,left +img/neutralC/CFD-WF-223-133-N.jpg,img/neutralC/CFD-AM-232-251-N.jpg,right +img/neutralC/CFD-WF-018-017-N.jpg,img/neutralC/CFD-WM-244-003-N.jpg,right +img/neutralC/CFD-IM-637-007-N.jpg,img/neutralC/CFD-AF-226-251-N.jpg,left +img/neutralC/CFD-BM-215-155-N.jpg,img/neutralC/CFD-WF-020-002-N.jpg,left +img/neutralC/CFD-WF-241-210-N.jpg,img/neutralC/CFD-WF-014-002-N.jpg,right +img/neutralC/CFD-BM-021-021-N.jpg,img/neutralC/CFD-WF-201-156-N.jpg,right diff --git a/materials/mfe_e/orig_surp_table7.csv b/materials/mfe_e/orig_surp_table7.csv new file mode 100644 index 0000000..bd61393 --- /dev/null +++ b/materials/mfe_e/orig_surp_table7.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-MF-342-022-N.jpg,img/neutralC/CFD-BF-032-038-N.jpg,right +img/neutralC/CFD-WF-009-001-N.jpg,img/neutralC/CFD-IF-705-196-N.jpg,right +img/neutralC/CFD-WF-210-086-N.jpg,img/neutralC/CFD-BF-221-223-N.jpg,left +img/neutralC/CFD-IF-729-393-N.jpg,img/neutralC/CFD-WF-227-002-N.jpg,right +img/neutralC/CFD-LF-205-100-N.jpg,img/neutralC/CFD-BM-025-035-N.jpg,left +img/neutralC/CFD-MF-303-013-N.jpg,img/neutralC/CFD-AM-253-161-N.jpg,right +img/neutralC/CFD-WM-040-022-N.jpg,img/neutralC/CFD-IM-628-176-N.jpg,right +img/neutralC/CFD-WM-026-001-N.jpg,img/neutralC/CFD-IF-633-012-N.jpg,right +img/neutralC/CFD-BM-248-128-N.jpg,img/neutralC/CFD-AF-252-135-N.jpg,left +img/neutralC/CFD-WM-257-161-N.jpg,img/neutralC/CFD-BF-021-013-N.jpg,right +img/neutralC/CFD-BM-204-003-N.jpg,img/neutralC/CFD-AM-210-035-N.jpg,left +img/neutralC/CFD-BM-211-174-N.jpg,img/neutralC/CFD-BF-223-250-N.jpg,right +img/neutralC/CFD-LM-225-130-N.jpg,img/neutralC/CFD-MF-304-018-N.jpg,right +img/neutralC/CFD-MF-329-001-N.jpg,img/neutralC/CFD-IM-683-231-N.jpg,right +img/neutralC/CFD-MF-327-002-N.jpg,img/neutralC/CFD-AM-202-079-N.jpg,right +img/neutralC/CFD-LF-220-120-N.jpg,img/neutralC/CFD-AM-228-214-N.jpg,right +img/neutralC/CFD-IF-742-103-N.jpg,img/neutralC/CFD-BF-243-164-N.jpg,right +img/neutralC/CFD-MF-316-001-N.jpg,img/neutralC/CFD-LM-250-077-N.jpg,left +img/neutralC/CFD-WM-232-070-N.jpg,img/neutralC/CFD-BF-017-003-N.jpg,right +img/neutralC/CFD-MF-357-002-N.jpg,img/neutralC/CFD-LM-203-026-N.jpg,right +img/neutralC/CFD-IM-648-337-N.jpg,img/neutralC/CFD-AF-248-148-N.jpg,right +img/neutralC/CFD-WF-248-129-N.jpg,img/neutralC/CFD-WM-224-197-N.jpg,left +img/neutralC/CFD-IM-685-004-N.jpg,img/neutralC/CFD-BF-231-202-N.jpg,left +img/neutralC/CFD-AM-201-076-N.jpg,img/neutralC/CFD-MF-315-002-N.jpg,left +img/neutralC/CFD-LF-226-174-N.jpg,img/neutralC/CFD-AF-251-093-N.jpg,right +img/neutralC/CFD-BF-224-002-N.jpg,img/neutralC/CFD-LM-202-072-N.jpg,right +img/neutralC/CFD-IF-732-260-N.jpg,img/neutralC/CFD-AF-200-228-N.jpg,right +img/neutralC/CFD-IM-706-002-N.jpg,img/neutralC/CFD-IF-641-504-N.jpg,left +img/neutralC/CFD-BM-212-117-N.jpg,img/neutralC/CFD-WM-200-034-N.jpg,right +img/neutralC/CFD-BF-213-188-N.jpg,img/neutralC/CFD-MF-326-016-N.jpg,left +img/neutralC/CFD-AM-249-163-N.jpg,img/neutralC/CFD-WM-250-157-N.jpg,left +img/neutralC/CFD-IM-727-195-N.jpg,img/neutralC/CFD-IM-681-253-N.jpg,right +img/neutralC/CFD-IM-721-341-N.jpg,img/neutralC/CFD-AF-204-067-N.jpg,right +img/neutralC/CFD-AF-241-141-N.jpg,img/neutralC/CFD-BM-202-063-N.jpg,right +img/neutralC/CFD-BF-029-031-N.jpg,img/neutralC/CFD-WM-210-057-N.jpg,right +img/neutralC/CFD-IF-650-315-N.jpg,img/neutralC/CFD-WM-229-129-N.jpg,right +img/neutralC/CFD-BM-033-003-N.jpg,img/neutralC/CFD-BM-016-036-N.jpg,left +img/neutralC/CFD-WF-214-122-N.jpg,img/neutralC/CFD-WF-246-087-N.jpg,left +img/neutralC/CFD-AM-243-212-N.jpg,img/neutralC/CFD-LM-223-175-N.jpg,right +img/neutralC/CFD-IM-653-008-N.jpg,img/neutralC/CFD-WM-022-001-N.jpg,right +img/neutralC/CFD-WM-025-002-N.jpg,img/neutralC/CFD-WF-037-029-N.jpg,right +img/neutralC/CFD-BF-206-143-N.jpg,img/neutralC/CFD-WF-003-003-N.jpg,right +img/neutralC/CFD-AM-205-153-N.jpg,img/neutralC/CFD-BF-225-192-N.jpg,right +img/neutralC/CFD-MF-312-002-N.jpg,img/neutralC/CFD-IM-611-306-N.jpg,right +img/neutralC/CFD-AF-210-050-N.jpg,img/neutralC/CFD-AF-238-185-N.jpg,left +img/neutralC/CFD-IM-709-103-N.jpg,img/neutralC/CFD-BM-012-018-N.jpg,right +img/neutralC/CFD-BM-200-046-N.jpg,img/neutralC/CFD-LM-224-162-N.jpg,left +img/neutralC/CFD-WF-012-002-N.jpg,img/neutralC/CFD-BF-250-121-N.jpg,right diff --git a/materials/mfe_e/orig_surp_table8.csv b/materials/mfe_e/orig_surp_table8.csv new file mode 100644 index 0000000..3ccc801 --- /dev/null +++ b/materials/mfe_e/orig_surp_table8.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-BF-229-179-N.jpg,img/neutralC/CFD-AF-255-209-N.jpg,left +img/neutralC/CFD-WM-235-147-N.jpg,img/neutralC/CFD-WF-016-015-N.jpg,right +img/neutralC/CFD-BF-235-168-N.jpg,img/neutralC/CFD-LF-223-064-N.jpg,left +img/neutralC/CFD-WM-218-074-N.jpg,img/neutralC/CFD-BM-046-006-N.jpg,right +img/neutralC/CFD-BF-036-027-N.jpg,img/neutralC/CFD-WM-032-001-N.jpg,right +img/neutralC/CFD-BF-040-003-N.jpg,img/neutralC/CFD-MM-308-001-N.jpg,right +img/neutralC/CFD-LF-201-035-N.jpg,img/neutralC/CFD-AM-223-138-N.jpg,right +img/neutralC/CFD-BM-205-001-N.jpg,img/neutralC/CFD-MF-345-025-N.jpg,left +img/neutralC/CFD-IM-726-248-N.jpg,img/neutralC/CFD-WF-011-002-N.jpg,left +img/neutralC/CFD-MF-352-054-N.jpg,img/neutralC/CFD-AF-235-170-N.jpg,left +img/neutralC/CFD-AF-234-208-N.jpg,img/neutralC/CFD-BF-234-167-N.jpg,right +img/neutralC/CFD-BM-043-071-N.jpg,img/neutralC/CFD-WF-202-056-N.jpg,right +img/neutralC/CFD-LM-201-057-N.jpg,img/neutralC/CFD-MF-341-018-N.jpg,left +img/neutralC/CFD-MM-317-061-N.jpg,img/neutralC/CFD-IF-610-766-N.jpg,right +img/neutralC/CFD-LM-228-188-N.jpg,img/neutralC/CFD-BM-232-213-N.jpg,right +img/neutralC/CFD-MM-324-069-N.jpg,img/neutralC/CFD-AM-218-085-N.jpg,left +img/neutralC/CFD-BF-228-212-N.jpg,img/neutralC/CFD-LF-217-082-N.jpg,left +img/neutralC/CFD-IM-645-001-N.jpg,img/neutralC/CFD-MF-306-003-N.jpg,right +img/neutralC/CFD-IM-678-482-N.jpg,img/neutralC/CFD-BM-037-033-N.jpg,left +img/neutralC/CFD-BM-028-002-N.jpg,img/neutralC/CFD-BM-244-197-N.jpg,right +img/neutralC/CFD-BF-204-189-N.jpg,img/neutralC/CFD-WM-211-054-N.jpg,left +img/neutralC/CFD-AM-217-085-N.jpg,img/neutralC/CFD-MF-338-001-N.jpg,right +img/neutralC/CFD-IF-626-375-N.jpg,img/neutralC/CFD-BF-203-184-N.jpg,left +img/neutralC/CFD-LM-240-013-N.jpg,img/neutralC/CFD-BF-210-130-N.jpg,right +img/neutralC/CFD-BF-011-002-N.jpg,img/neutralC/CFD-WF-219-038-N.jpg,left +img/neutralC/CFD-WF-017-003-N.jpg,img/neutralC/CFD-MF-361-006-N.jpg,left +img/neutralC/CFD-MF-333-012-N.jpg,img/neutralC/CFD-IM-724-010-N.jpg,left +img/neutralC/CFD-IF-636-011-N.jpg,img/neutralC/CFD-AM-231-136-N.jpg,left +img/neutralC/CFD-WM-011-002-N.jpg,img/neutralC/CFD-BM-031-003-N.jpg,left +img/neutralC/CFD-WM-013-001-N.jpg,img/neutralC/CFD-MF-308-001-N.jpg,right +img/neutralC/CFD-IM-686-097-N.jpg,img/neutralC/CFD-IM-716-316-N.jpg,left +img/neutralC/CFD-LF-215-157-N.jpg,img/neutralC/CFD-BM-219-141-N.jpg,right +img/neutralC/CFD-MF-359-019-N.jpg,img/neutralC/CFD-WM-016-001-N.jpg,left +img/neutralC/CFD-BF-023-010-N.jpg,img/neutralC/CFD-BM-234-172-N.jpg,left +img/neutralC/CFD-WM-201-063-N.jpg,img/neutralC/CFD-BF-024-002-N.jpg,right +img/neutralC/CFD-AM-215-120-N.jpg,img/neutralC/CFD-BM-203-001-N.jpg,left +img/neutralC/CFD-WF-022-017-N.jpg,img/neutralC/CFD-MF-348-018-N.jpg,left +img/neutralC/CFD-BM-041-035-N.jpg,img/neutralC/CFD-BF-227-137-N.jpg,right +img/neutralC/CFD-IM-728-041-N.jpg,img/neutralC/CFD-AM-216-114-N.jpg,left +img/neutralC/CFD-IF-623-129-N.jpg,img/neutralC/CFD-AF-223-183-N.jpg,left +img/neutralC/CFD-BM-231-155-N.jpg,img/neutralC/CFD-LM-206-204-N.jpg,left +img/neutralC/CFD-IF-619-197-N.jpg,img/neutralC/CFD-BM-002-013-N.jpg,left +img/neutralC/CFD-AF-231-357-N.jpg,img/neutralC/CFD-BM-040-002-N.jpg,left +img/neutralC/CFD-WF-212-050-N.jpg,img/neutralC/CFD-MM-320-124-N.jpg,right +img/neutralC/CFD-LF-216-121-N.jpg,img/neutralC/CFD-BF-001-025-N.jpg,left +img/neutralC/CFD-BF-247-179-N.jpg,img/neutralC/CFD-IM-731-223-N.jpg,right +img/neutralC/CFD-BF-244-231-N.jpg,img/neutralC/CFD-BF-047-003-N.jpg,right +img/neutralC/CFD-WF-217-085-N.jpg,img/neutralC/CFD-IM-662-171-N.jpg,left diff --git a/materials/task1/protocol.md b/materials/mfe_e/readme.md similarity index 100% rename from materials/task1/protocol.md rename to materials/mfe_e/readme.md diff --git a/materials/mfe_e/readme.txt b/materials/mfe_e/readme.txt new file mode 100644 index 0000000..179456e --- /dev/null +++ b/materials/mfe_e/readme.txt @@ -0,0 +1,3 @@ +There is a MATLAB script that can generate 13 CSV files for the trials of the face Flanker task. +404 faces are randomly selected from the faces loacted in the img/renders folder. After that it randomly create 13 CSV files. +Please read the notes of that script to fully understand how it works. It is stored in the img folder and called "trial_csv_creator.m"! diff --git a/materials/mfe_e/surp_table1.csv b/materials/mfe_e/surp_table1.csv new file mode 100644 index 0000000..83e7964 --- /dev/null +++ b/materials/mfe_e/surp_table1.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-BF-201-080-N.jpg,img/neutralC/CFD-LF-200-058-N.jpg,left +img/neutralC/CFD-WM-021-001-N.jpg,img/neutralC/CFD-LM-235-231-N.jpg,right +img/neutralC/CFD-WF-224-099-N.jpg,img/neutralC/CFD-BF-239-180-N.jpg,right +img/neutralC/CFD-WF-027-003-N.jpg,img/neutralC/CFD-IM-630-134-N.jpg,left +img/neutralC/CFD-BF-041-001-N.jpg,img/neutralC/CFD-BM-249-235-N.jpg,right +img/neutralC/CFD-WM-249-239-N.jpg,img/neutralC/CFD-BF-048-002-N.jpg,left +img/neutralC/CFD-AF-205-155-N.jpg,img/neutralC/CFD-IF-631-363-N.jpg,right +img/neutralC/CFD-IM-606-008-N.jpg,img/neutralC/CFD-LM-236-163-N.jpg,left +img/neutralC/CFD-WF-207-014-N.jpg,img/neutralC/CFD-WM-217-070-N.jpg,left +img/neutralC/CFD-WF-228-196-N.jpg,img/neutralC/CFD-IM-690-282-N.jpg,left +img/neutralC/CFD-AM-236-090-N.jpg,img/neutralC/CFD-WM-036-031-N.jpg,left +img/neutralC/CFD-WM-221-091-N.jpg,img/neutralC/CFD-MM-300-035-N.jpg,left +img/neutralC/CFD-WF-243-148-N.jpg,img/neutralC/CFD-WF-013-003-N.jpg,right +img/neutralC/CFD-WF-002-004-N.jpg,img/neutralC/CFD-WM-240-125-N.jpg,right +img/neutralC/CFD-BF-202-109-N.jpg,img/neutralC/CFD-WM-256-138-N.jpg,right +img/neutralC/CFD-WM-225-127-N.jpg,img/neutralC/CFD-LM-229-187-N.jpg,right +img/neutralC/CFD-WF-005-010-N.jpg,img/neutralC/CFD-IM-725-142-N.jpg,right +img/neutralC/CFD-MF-340-026-N.jpg,img/neutralC/CFD-IM-679-069-N.jpg,left +img/neutralC/CFD-WF-029-002-N.jpg,img/neutralC/CFD-LF-246-129-N.jpg,left +img/neutralC/CFD-MF-328-020-N.jpg,img/neutralC/CFD-AM-241-287-N.jpg,right +img/neutralC/CFD-LM-244-068-N.jpg,img/neutralC/CFD-MF-346-008-N.jpg,left +img/neutralC/CFD-IF-642-295-N.jpg,img/neutralC/CFD-IM-655-234-N.jpg,left +img/neutralC/CFD-MF-336-016-N.jpg,img/neutralC/CFD-IM-654-417-N.jpg,left +img/neutralC/CFD-BF-014-002-N.jpg,img/neutralC/CFD-BF-035-001-N.jpg,right +img/neutralC/CFD-IM-684-008-N.jpg,img/neutralC/CFD-IF-612-149-N.jpg,right +img/neutralC/CFD-BF-236-177-N.jpg,img/neutralC/CFD-MF-347-001-N.jpg,left +img/neutralC/CFD-BM-029-024-N.jpg,img/neutralC/CFD-IM-688-322-N.jpg,right +img/neutralC/CFD-AM-221-184-N.jpg,img/neutralC/CFD-MF-314-001-N.jpg,right +img/neutralC/CFD-LF-239-148-N.jpg,img/neutralC/CFD-LF-207-198-N.jpg,right +img/neutralC/CFD-AM-220-134-N.jpg,img/neutralC/CFD-AM-252-114-N.jpg,left +img/neutralC/CFD-IM-638-250-1-N.jpg,img/neutralC/CFD-AM-246-184-N.jpg,right +img/neutralC/CFD-LF-203-066-N.jpg,img/neutralC/CFD-LM-210-156-N.jpg,right +img/neutralC/CFD-BF-237-172-N.jpg,img/neutralC/CFD-BF-009-002-N.jpg,left +img/neutralC/CFD-LM-252-076-N.jpg,img/neutralC/CFD-WM-223-056-N.jpg,left +img/neutralC/CFD-BF-217-189-N.jpg,img/neutralC/CFD-WM-031-003-N.jpg,right +img/neutralC/CFD-AF-254-167-N.jpg,img/neutralC/CFD-WF-218-087-N.jpg,left +img/neutralC/CFD-BM-027-001-N.jpg,img/neutralC/CFD-BM-252-161-N.jpg,left +img/neutralC/CFD-AF-233-190-N.jpg,img/neutralC/CFD-WM-251-002-N.jpg,right +img/neutralC/CFD-LF-242-121-N.jpg,img/neutralC/CFD-WM-233-106-N.jpg,right +img/neutralC/CFD-IM-743-006-N.jpg,img/neutralC/CFD-IM-658-284-N.jpg,left +img/neutralC/CFD-IM-635-010-N.jpg,img/neutralC/CFD-WM-035-032-N.jpg,left +img/neutralC/CFD-BM-010-003-N.jpg,img/neutralC/CFD-MM-314-062-N.jpg,left +img/neutralC/CFD-WF-221-005-N.jpg,img/neutralC/CFD-AM-234-355-N.jpg,left +img/neutralC/CFD-IF-625-225-N.jpg,img/neutralC/CFD-BM-236-248-N.jpg,right +img/neutralC/CFD-AF-240-206-N.jpg,img/neutralC/CFD-LM-239-075-N.jpg,left +img/neutralC/CFD-LF-211-003-N.jpg,img/neutralC/CFD-BF-209-172-N.jpg,left +img/neutralC/CFD-BF-207-004-N.jpg,img/neutralC/CFD-WM-238-020-N.jpg,right +img/neutralC/CFD-WF-245-084-N.jpg,img/neutralC/CFD-WM-236-072-N.jpg,right diff --git a/materials/mfe_e/surp_table2.csv b/materials/mfe_e/surp_table2.csv new file mode 100644 index 0000000..5a84997 --- /dev/null +++ b/materials/mfe_e/surp_table2.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-LM-243-075-N.jpg,img/neutralC/CFD-WM-207-048-N.jpg,right +img/neutralC/CFD-WM-018-002-N.jpg,img/neutralC/CFD-LF-202-065-N.jpg,left +img/neutralC/CFD-LM-219-295-N.jpg,img/neutralC/CFD-WM-216-061-N.jpg,left +img/neutralC/CFD-LF-214-090-N.jpg,img/neutralC/CFD-IF-622-096-N.jpg,right +img/neutralC/CFD-BF-212-315-N.jpg,img/neutralC/CFD-BM-044-001-N.jpg,left +img/neutralC/CFD-WF-226-095-N.jpg,img/neutralC/CFD-MF-354-067-N.jpg,right +img/neutralC/CFD-AF-221-147-N.jpg,img/neutralC/CFD-AF-211-066-N.jpg,left +img/neutralC/CFD-AM-230-150-N.jpg,img/neutralC/CFD-BF-242-154-N.jpg,right +img/neutralC/CFD-LM-218-183-N.jpg,img/neutralC/CFD-WM-205-007-N.jpg,left +img/neutralC/CFD-WF-209-052-N.jpg,img/neutralC/CFD-IM-647-548-N.jpg,left +img/neutralC/CFD-IM-703-182-N.jpg,img/neutralC/CFD-IF-691-007-N.jpg,right +img/neutralC/CFD-BM-247-240-N.jpg,img/neutralC/CFD-BF-233-116-N.jpg,left +img/neutralC/CFD-IM-696-001-N.jpg,img/neutralC/CFD-MF-355-022-N.jpg,left +img/neutralC/CFD-WM-006-002-N.jpg,img/neutralC/CFD-LM-231-214-N.jpg,left +img/neutralC/CFD-LF-208-127-N.jpg,img/neutralC/CFD-LM-242-002-N.jpg,right +img/neutralC/CFD-MF-318-022-N.jpg,img/neutralC/CFD-LM-230-202-N.jpg,left +img/neutralC/CFD-WF-007-001-N.jpg,img/neutralC/CFD-LF-249-132-N.jpg,right +img/neutralC/CFD-MF-301-024-N.jpg,img/neutralC/CFD-IM-715-013-N.jpg,left +img/neutralC/CFD-LF-222-147-N.jpg,img/neutralC/CFD-BM-206-114-N.jpg,left +img/neutralC/CFD-BF-028-001-N.jpg,img/neutralC/CFD-WF-247-065-N.jpg,right +img/neutralC/CFD-LM-200-045-N.jpg,img/neutralC/CFD-IM-607-018-N.jpg,left +img/neutralC/CFD-WF-235-121-N.jpg,img/neutralC/CFD-AF-222-134-N.jpg,left +img/neutralC/CFD-AM-247-165-N.jpg,img/neutralC/CFD-WF-015-006-N.jpg,right +img/neutralC/CFD-BF-020-002-N.jpg,img/neutralC/CFD-MF-353-204-N.jpg,right +img/neutralC/CFD-AM-245-111-N.jpg,img/neutralC/CFD-LM-248-089-N.jpg,right +img/neutralC/CFD-AM-235-241-N.jpg,img/neutralC/CFD-MM-311-001-N.jpg,right +img/neutralC/CFD-BM-013-002-N.jpg,img/neutralC/CFD-IM-711-011-N.jpg,left +img/neutralC/CFD-BF-226-119-N.jpg,img/neutralC/CFD-IF-735-353-N.jpg,right +img/neutralC/CFD-BM-001-014-N.jpg,img/neutralC/CFD-AF-209-006-N.jpg,right +img/neutralC/CFD-WM-253-119-N.jpg,img/neutralC/CFD-BM-210-148-N.jpg,right +img/neutralC/CFD-MF-309-002-N.jpg,img/neutralC/CFD-WF-225-101-N.jpg,right +img/neutralC/CFD-AF-215-70-N.jpg,img/neutralC/CFD-IF-713-170-N.jpg,left +img/neutralC/CFD-BF-010-001-N.jpg,img/neutralC/CFD-BM-240-207-N.jpg,left +img/neutralC/CFD-BM-250-170-N.jpg,img/neutralC/CFD-BF-030-002-N.jpg,right +img/neutralC/CFD-MF-335-002-N.jpg,img/neutralC/CFD-LF-231-260-N.jpg,right +img/neutralC/CFD-BF-039-031-N.jpg,img/neutralC/CFD-WF-024-003-N.jpg,left +img/neutralC/CFD-IM-675-015-N.jpg,img/neutralC/CFD-LM-207-004-N.jpg,left +img/neutralC/CFD-LF-212-066-N.jpg,img/neutralC/CFD-MF-360-106-N.jpg,right +img/neutralC/CFD-AF-229-160-N.jpg,img/neutralC/CFD-BF-245-178-N.jpg,right +img/neutralC/CFD-BF-002-001-N.jpg,img/neutralC/CFD-WM-206-045-N.jpg,left +img/neutralC/CFD-AF-237-223-N.jpg,img/neutralC/CFD-LF-219-223-N.jpg,right +img/neutralC/CFD-BM-018-001-N.jpg,img/neutralC/CFD-IM-695-001-N.jpg,right +img/neutralC/CFD-WF-006-002-N.jpg,img/neutralC/CFD-AM-229-224-N.jpg,left +img/neutralC/CFD-WM-024-015-N.jpg,img/neutralC/CFD-LM-208-110-N.jpg,left +img/neutralC/CFD-LM-226-175-N.jpg,img/neutralC/CFD-BF-230-189-N.jpg,right +img/neutralC/CFD-LM-238-129-N.jpg,img/neutralC/CFD-BF-200-080-N.jpg,right +img/neutralC/CFD-BF-232-187-N.jpg,img/neutralC/CFD-BM-017-021-N.jpg,left +img/neutralC/CFD-WF-238-023-N.jpg,img/neutralC/CFD-AM-206-086-N.jpg,left diff --git a/materials/mfe_e/surp_table3.csv b/materials/mfe_e/surp_table3.csv new file mode 100644 index 0000000..1c42cf0 --- /dev/null +++ b/materials/mfe_e/surp_table3.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-MF-343-001-N.jpg,img/neutralC/CFD-MF-322-020-N.jpg,right +img/neutralC/CFD-BF-042-026-N.jpg,img/neutralC/CFD-WF-014-002-N.jpg,right +img/neutralC/CFD-BF-006-017-N.jpg,img/neutralC/CFD-WF-201-156-N.jpg,right +img/neutralC/CFD-WF-222-092-N.jpg,img/neutralC/CFD-MF-334-002-N.jpg,left +img/neutralC/CFD-IM-646-023-N.jpg,img/neutralC/CFD-AM-232-251-N.jpg,left +img/neutralC/CFD-LM-214-165-N.jpg,img/neutralC/CFD-BM-224-073-N.jpg,right +img/neutralC/CFD-IM-697-015-N.jpg,img/neutralC/CFD-IF-605-066-N.jpg,right +img/neutralC/CFD-LM-233-171-N.jpg,img/neutralC/CFD-BM-245-164-N.jpg,left +img/neutralC/CFD-WF-241-210-N.jpg,img/neutralC/CFD-AF-226-251-N.jpg,left +img/neutralC/CFD-LF-247-051-N.jpg,img/neutralC/CFD-AF-203-077-N.jpg,right +img/neutralC/CFD-LF-218-072-N.jpg,img/neutralC/CFD-WF-236-107-N.jpg,left +img/neutralC/CFD-IM-702-101-N.jpg,img/neutralC/CFD-BF-219-137-N.jpg,left +img/neutralC/CFD-BM-243-218-N.jpg,img/neutralC/CFD-IM-698-011-N.jpg,left +img/neutralC/CFD-WF-223-133-N.jpg,img/neutralC/CFD-BM-024-001-N.jpg,right +img/neutralC/CFD-IF-676-017-N.jpg,img/neutralC/CFD-WF-216-079-N.jpg,left +img/neutralC/CFD-BF-253-202-N.jpg,img/neutralC/CFD-MF-330-001-N.jpg,left +img/neutralC/CFD-LM-253-075-N.jpg,img/neutralC/CFD-LF-209-072-N.jpg,right +img/neutralC/CFD-LF-236-221-N.jpg,img/neutralC/CFD-WM-245-123-N.jpg,left +img/neutralC/CFD-IF-620-218-N.jpg,img/neutralC/CFD-AF-201-060-N.jpg,left +img/neutralC/CFD-BM-241-235-N.jpg,img/neutralC/CFD-WF-211-001-N.jpg,right +img/neutralC/CFD-AM-244-222-N.jpg,img/neutralC/CFD-LF-228-125-N.jpg,left +img/neutralC/CFD-BF-214-308-N.jpg,img/neutralC/CFD-IF-614-107-N.jpg,right +img/neutralC/CFD-IF-629-234-N.jpg,img/neutralC/CFD-BM-216-088-N.jpg,left +img/neutralC/CFD-LF-238-154-N.jpg,img/neutralC/CFD-BF-248-149-N.jpg,right +img/neutralC/CFD-BM-021-021-N.jpg,img/neutralC/CFD-WM-244-003-N.jpg,right +img/neutralC/CFD-IM-719-221-N.jpg,img/neutralC/CFD-LF-227-054-N.jpg,left +img/neutralC/CFD-MF-337-026-N.jpg,img/neutralC/CFD-AF-214-139-N.jpg,right +img/neutralC/CFD-BF-254-201-N.jpg,img/neutralC/CFD-BF-016-017-N.jpg,right +img/neutralC/CFD-IM-637-007-N.jpg,img/neutralC/CFD-AM-248-104-N.jpg,right +img/neutralC/CFD-LM-215-247-N.jpg,img/neutralC/CFD-AF-208-003-N.jpg,right +img/neutralC/CFD-WM-237-052-N.jpg,img/neutralC/CFD-BM-222-173-N.jpg,right +img/neutralC/CFD-IM-604-014-N.jpg,img/neutralC/CFD-MF-331-010-N.jpg,left +img/neutralC/CFD-WM-041-021-N.jpg,img/neutralC/CFD-BF-220-161-N.jpg,left +img/neutralC/CFD-BF-222-240-N.jpg,img/neutralC/CFD-WM-241-072-N.jpg,right +img/neutralC/CFD-BM-019-002-N.jpg,img/neutralC/CFD-BM-223-171-N.jpg,left +img/neutralC/CFD-BM-215-155-N.jpg,img/neutralC/CFD-WF-035-024-N.jpg,left +img/neutralC/CFD-WM-002-009-N.jpg,img/neutralC/CFD-IF-601-519-N.jpg,left +img/neutralC/CFD-LF-250-169-N.jpg,img/neutralC/CFD-BM-230-232-N.jpg,right +img/neutralC/CFD-LF-230-203-N.jpg,img/neutralC/CFD-WF-204-038-N.jpg,right +img/neutralC/CFD-LF-210-220-N.jpg,img/neutralC/CFD-WF-203-229-N.jpg,right +img/neutralC/CFD-AF-202-122-N.jpg,img/neutralC/CFD-BF-050-003-N.jpg,left +img/neutralC/CFD-IF-608-390-N.jpg,img/neutralC/CFD-IM-661-254-N.jpg,right +img/neutralC/CFD-IM-615-167-N.jpg,img/neutralC/CFD-WF-039-025-N.jpg,right +img/neutralC/CFD-WF-018-017-N.jpg,img/neutralC/CFD-AM-238-269-N.jpg,right +img/neutralC/CFD-IM-616-214-N.jpg,img/neutralC/CFD-MF-311-001-N.jpg,left +img/neutralC/CFD-AF-206-079-N.jpg,img/neutralC/CFD-WF-020-002-N.jpg,right +img/neutralC/CFD-BM-225-154-N.jpg,img/neutralC/CFD-BM-038-001-N.jpg,left +img/neutralC/CFD-MF-302-027-N.jpg,img/neutralC/CFD-BM-022-022-N.jpg,right diff --git a/materials/mfe_e/surp_table4.csv b/materials/mfe_e/surp_table4.csv new file mode 100644 index 0000000..1096a37 --- /dev/null +++ b/materials/mfe_e/surp_table4.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-IM-685-004-N.jpg,img/neutralC/CFD-IF-641-504-N.jpg,right +img/neutralC/CFD-MF-303-013-N.jpg,img/neutralC/CFD-BF-250-121-N.jpg,right +img/neutralC/CFD-AM-201-076-N.jpg,img/neutralC/CFD-BF-231-202-N.jpg,right +img/neutralC/CFD-BM-212-117-N.jpg,img/neutralC/CFD-WF-246-087-N.jpg,left +img/neutralC/CFD-IF-729-393-N.jpg,img/neutralC/CFD-BM-202-063-N.jpg,right +img/neutralC/CFD-WF-210-086-N.jpg,img/neutralC/CFD-IF-705-196-N.jpg,left +img/neutralC/CFD-WM-232-070-N.jpg,img/neutralC/CFD-AM-210-035-N.jpg,right +img/neutralC/CFD-BM-033-003-N.jpg,img/neutralC/CFD-WM-229-129-N.jpg,right +img/neutralC/CFD-WF-248-129-N.jpg,img/neutralC/CFD-AF-252-135-N.jpg,right +img/neutralC/CFD-MF-329-001-N.jpg,img/neutralC/CFD-BM-012-018-N.jpg,right +img/neutralC/CFD-BF-206-143-N.jpg,img/neutralC/CFD-AF-204-067-N.jpg,left +img/neutralC/CFD-IM-721-341-N.jpg,img/neutralC/CFD-WF-037-029-N.jpg,left +img/neutralC/CFD-AF-241-141-N.jpg,img/neutralC/CFD-LM-223-175-N.jpg,right +img/neutralC/CFD-IM-709-103-N.jpg,img/neutralC/CFD-BF-223-250-N.jpg,left +img/neutralC/CFD-WM-257-161-N.jpg,img/neutralC/CFD-WM-022-001-N.jpg,right +img/neutralC/CFD-AM-249-163-N.jpg,img/neutralC/CFD-BF-021-013-N.jpg,left +img/neutralC/CFD-LF-226-174-N.jpg,img/neutralC/CFD-AF-248-148-N.jpg,left +img/neutralC/CFD-MF-342-022-N.jpg,img/neutralC/CFD-IM-681-253-N.jpg,right +img/neutralC/CFD-WF-009-001-N.jpg,img/neutralC/CFD-BF-221-223-N.jpg,right +img/neutralC/CFD-IM-648-337-N.jpg,img/neutralC/CFD-MF-304-018-N.jpg,right +img/neutralC/CFD-IM-727-195-N.jpg,img/neutralC/CFD-AF-251-093-N.jpg,right +img/neutralC/CFD-BM-211-174-N.jpg,img/neutralC/CFD-AM-253-161-N.jpg,left +img/neutralC/CFD-LM-225-130-N.jpg,img/neutralC/CFD-LM-203-026-N.jpg,right +img/neutralC/CFD-IF-650-315-N.jpg,img/neutralC/CFD-IF-633-012-N.jpg,right +img/neutralC/CFD-IM-653-008-N.jpg,img/neutralC/CFD-BF-017-003-N.jpg,right +img/neutralC/CFD-BM-204-003-N.jpg,img/neutralC/CFD-IM-611-306-N.jpg,right +img/neutralC/CFD-BF-224-002-N.jpg,img/neutralC/CFD-IM-628-176-N.jpg,right +img/neutralC/CFD-WF-214-122-N.jpg,img/neutralC/CFD-WM-200-034-N.jpg,left +img/neutralC/CFD-IF-732-260-N.jpg,img/neutralC/CFD-WM-210-057-N.jpg,right +img/neutralC/CFD-AM-205-153-N.jpg,img/neutralC/CFD-LM-202-072-N.jpg,right +img/neutralC/CFD-WM-025-002-N.jpg,img/neutralC/CFD-AM-202-079-N.jpg,left +img/neutralC/CFD-BF-213-188-N.jpg,img/neutralC/CFD-WM-224-197-N.jpg,left +img/neutralC/CFD-LF-205-100-N.jpg,img/neutralC/CFD-AF-200-228-N.jpg,right +img/neutralC/CFD-MF-316-001-N.jpg,img/neutralC/CFD-AM-228-214-N.jpg,right +img/neutralC/CFD-AF-210-050-N.jpg,img/neutralC/CFD-BF-032-038-N.jpg,left +img/neutralC/CFD-WM-040-022-N.jpg,img/neutralC/CFD-WF-227-002-N.jpg,right +img/neutralC/CFD-BM-200-046-N.jpg,img/neutralC/CFD-LM-250-077-N.jpg,right +img/neutralC/CFD-MF-357-002-N.jpg,img/neutralC/CFD-MF-315-002-N.jpg,right +img/neutralC/CFD-MF-327-002-N.jpg,img/neutralC/CFD-BM-025-035-N.jpg,left +img/neutralC/CFD-BM-248-128-N.jpg,img/neutralC/CFD-BM-016-036-N.jpg,right +img/neutralC/CFD-MF-312-002-N.jpg,img/neutralC/CFD-WM-250-157-N.jpg,right +img/neutralC/CFD-LF-220-120-N.jpg,img/neutralC/CFD-WF-003-003-N.jpg,left +img/neutralC/CFD-BF-029-031-N.jpg,img/neutralC/CFD-BF-243-164-N.jpg,right +img/neutralC/CFD-AM-243-212-N.jpg,img/neutralC/CFD-BF-225-192-N.jpg,right +img/neutralC/CFD-IF-742-103-N.jpg,img/neutralC/CFD-MF-326-016-N.jpg,right +img/neutralC/CFD-WM-026-001-N.jpg,img/neutralC/CFD-IM-683-231-N.jpg,right +img/neutralC/CFD-IM-706-002-N.jpg,img/neutralC/CFD-LM-224-162-N.jpg,right +img/neutralC/CFD-WF-012-002-N.jpg,img/neutralC/CFD-AF-238-185-N.jpg,left diff --git a/materials/mfe_e/surp_table5.csv b/materials/mfe_e/surp_table5.csv new file mode 100644 index 0000000..d85cd92 --- /dev/null +++ b/materials/mfe_e/surp_table5.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-BF-025-002-N.jpg,img/neutralC/CFD-AM-226-234-N.jpg,right +img/neutralC/CFD-BF-033-028-N.jpg,img/neutralC/CFD-WM-204-031-N.jpg,left +img/neutralC/CFD-AF-213-126-N.jpg,img/neutralC/CFD-IM-656-273-N.jpg,right +img/neutralC/CFD-WM-258-125-N.jpg,img/neutralC/CFD-MM-315-013-N.jpg,left +img/neutralC/CFD-BF-018-039-N.jpg,img/neutralC/CFD-AF-224-026-N.jpg,right +img/neutralC/CFD-IM-738-191-N.jpg,img/neutralC/CFD-MF-332-014-N.jpg,right +img/neutralC/CFD-LF-206-078-N.jpg,img/neutralC/CFD-BM-218-132-N.jpg,left +img/neutralC/CFD-BF-208-266-N.jpg,img/neutralC/CFD-LF-221-002-N.jpg,left +img/neutralC/CFD-IM-680-369-N.jpg,img/neutralC/CFD-MM-302-002-N.jpg,left +img/neutralC/CFD-BM-251-013-N.jpg,img/neutralC/CFD-LF-233-277-N.jpg,right +img/neutralC/CFD-BF-038-037-N.jpg,img/neutralC/CFD-MM-312-002-N.jpg,right +img/neutralC/CFD-WM-209-038-N.jpg,img/neutralC/CFD-MF-324-031-N.jpg,right +img/neutralC/CFD-AM-242-176-N.jpg,img/neutralC/CFD-AF-243-170-N.jpg,right +img/neutralC/CFD-BF-255-140-N.jpg,img/neutralC/CFD-LF-213-079-N.jpg,right +img/neutralC/CFD-WF-036-023-N.jpg,img/neutralC/CFD-WM-010-001-N.jpg,right +img/neutralC/CFD-WM-255-219-N.jpg,img/neutralC/CFD-AF-245-143-N.jpg,right +img/neutralC/CFD-BF-004-014-N.jpg,img/neutralC/CFD-LF-253-003-N.jpg,left +img/neutralC/CFD-WM-202-107-N.jpg,img/neutralC/CFD-AF-220-107-N.jpg,left +img/neutralC/CFD-AM-251-124-N.jpg,img/neutralC/CFD-AF-247-278-N.jpg,left +img/neutralC/CFD-BM-005-003-N.jpg,img/neutralC/CFD-MF-310-027-N.jpg,right +img/neutralC/CFD-WF-026-002-N.jpg,img/neutralC/CFD-IM-692-011-N.jpg,left +img/neutralC/CFD-AF-232-078-N.jpg,img/neutralC/CFD-WM-243-107-N.jpg,left +img/neutralC/CFD-BF-045-003-N.jpg,img/neutralC/CFD-MF-339-002-N.jpg,right +img/neutralC/CFD-LM-216-082-N.jpg,img/neutralC/CFD-IM-720-014-N.jpg,right +img/neutralC/CFD-WM-213-076-N.jpg,img/neutralC/CFD-MM-307-002-N.jpg,right +img/neutralC/CFD-WM-254-152-N.jpg,img/neutralC/CFD-WF-229-004-N.jpg,right +img/neutralC/CFD-BM-039-029-N.jpg,img/neutralC/CFD-AF-207-023-N.jpg,left +img/neutralC/CFD-LM-204-001-N.jpg,img/neutralC/CFD-WM-231-112-N.jpg,left +img/neutralC/CFD-WM-038-003-N.jpg,img/neutralC/CFD-MF-325-002-N.jpg,left +img/neutralC/CFD-IF-673-389-N.jpg,img/neutralC/CFD-IM-699-002-N.jpg,left +img/neutralC/CFD-AF-227-207-N.jpg,img/neutralC/CFD-BF-013-001-N.jpg,left +img/neutralC/CFD-LF-255-088-N.jpg,img/neutralC/CFD-WM-037-025-N.jpg,left +img/neutralC/CFD-IM-659-359-N.jpg,img/neutralC/CFD-AF-212-097-N.jpg,right +img/neutralC/CFD-IM-639-263-N.jpg,img/neutralC/CFD-IM-621-136-N.jpg,right +img/neutralC/CFD-IF-677-452-1-N.jpg,img/neutralC/CFD-IF-602-134-N.jpg,right +img/neutralC/CFD-IM-701-312-N.jpg,img/neutralC/CFD-IM-708-362-N.jpg,right +img/neutralC/CFD-WM-014-002-N.jpg,img/neutralC/CFD-LM-222-239-N.jpg,left +img/neutralC/CFD-AM-212-050-N.jpg,img/neutralC/CFD-MF-349-036-N.jpg,left +img/neutralC/CFD-BF-238-190-N.jpg,img/neutralC/CFD-WF-025-019-N.jpg,right +img/neutralC/CFD-LF-241-188-N.jpg,img/neutralC/CFD-AM-227-184-N.jpg,right +img/neutralC/CFD-AF-244-168-N.jpg,img/neutralC/CFD-BM-221-198-N.jpg,right +img/neutralC/CFD-BF-003-003-N.jpg,img/neutralC/CFD-IF-704-125-N.jpg,left +img/neutralC/CFD-WF-008-002-N.jpg,img/neutralC/CFD-WF-220-101-N.jpg,left +img/neutralC/CFD-MM-321-021-N.jpg,img/neutralC/CFD-IF-723-255-N.jpg,right +img/neutralC/CFD-BF-027-002-N.jpg,img/neutralC/CFD-AF-219-106-N.jpg,left +img/neutralC/CFD-AM-225-102-N.jpg,img/neutralC/CFD-MM-301-011-N.jpg,left +img/neutralC/CFD-LM-217-162-N.jpg,img/neutralC/CFD-BF-215-177-N.jpg,left +img/neutralC/CFD-MM-316-156-N.jpg,img/neutralC/CFD-MM-322-002-N.jpg,left diff --git a/materials/mfe_e/surp_table6.csv b/materials/mfe_e/surp_table6.csv new file mode 100644 index 0000000..1063189 --- /dev/null +++ b/materials/mfe_e/surp_table6.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-AF-239-171-N.jpg,img/neutralC/CFD-WF-206-147-N.jpg,right +img/neutralC/CFD-IF-672-305-N.jpg,img/neutralC/CFD-WF-242-001-N.jpg,left +img/neutralC/CFD-WM-219-008-N.jpg,img/neutralC/CFD-WF-249-126-N.jpg,right +img/neutralC/CFD-MM-319-052-N.jpg,img/neutralC/CFD-LF-254-125-N.jpg,right +img/neutralC/CFD-AM-211-052-N.jpg,img/neutralC/CFD-LM-209-111-N.jpg,right +img/neutralC/CFD-BF-051-035-N.jpg,img/neutralC/CFD-WM-203-023-N.jpg,left +img/neutralC/CFD-WM-017-002-N.jpg,img/neutralC/CFD-AM-207-108-N.jpg,right +img/neutralC/CFD-WF-033-002-N.jpg,img/neutralC/CFD-WF-028-023-N.jpg,right +img/neutralC/CFD-BM-207-024-N.jpg,img/neutralC/CFD-IM-739-012-N.jpg,right +img/neutralC/CFD-IM-667-369-N.jpg,img/neutralC/CFD-WF-251-014-N.jpg,left +img/neutralC/CFD-WF-208-068-N.jpg,img/neutralC/CFD-AF-217-155-N.jpg,left +img/neutralC/CFD-LF-224-176-N.jpg,img/neutralC/CFD-LF-244-096-N.jpg,right +img/neutralC/CFD-MM-306-010-N.jpg,img/neutralC/CFD-MM-313-002-N.jpg,right +img/neutralC/CFD-MF-313-002-N.jpg,img/neutralC/CFD-LM-234-176-N.jpg,left +img/neutralC/CFD-WF-023-003-N.jpg,img/neutralC/CFD-WF-231-099-N.jpg,left +img/neutralC/CFD-BM-026-002-N.jpg,img/neutralC/CFD-BF-008-001-N.jpg,left +img/neutralC/CFD-BF-043-003-N.jpg,img/neutralC/CFD-MF-351-017-N.jpg,right +img/neutralC/CFD-IF-718-001-N.jpg,img/neutralC/CFD-WM-029-023-N.jpg,left +img/neutralC/CFD-AF-250-200-N.jpg,img/neutralC/CFD-LF-251-057-N.jpg,right +img/neutralC/CFD-WM-248-036-N.jpg,img/neutralC/CFD-AM-250-149-N.jpg,left +img/neutralC/CFD-BM-023-029-N.jpg,img/neutralC/CFD-AM-237-154-N.jpg,left +img/neutralC/CFD-IF-634-382-N.jpg,img/neutralC/CFD-BM-214-075-N.jpg,right +img/neutralC/CFD-MF-321-003-N.jpg,img/neutralC/CFD-LM-227-103-N.jpg,left +img/neutralC/CFD-IM-627-178-N.jpg,img/neutralC/CFD-BF-249-091-N.jpg,left +img/neutralC/CFD-WM-009-002-N.jpg,img/neutralC/CFD-LF-252-172-N.jpg,left +img/neutralC/CFD-WM-228-065-N.jpg,img/neutralC/CFD-BM-201-077-N.jpg,left +img/neutralC/CFD-IM-689-263-N.jpg,img/neutralC/CFD-WF-205-006-N.jpg,right +img/neutralC/CFD-LM-213-061-N.jpg,img/neutralC/CFD-BF-246-170-N.jpg,left +img/neutralC/CFD-BM-003-003-N.jpg,img/neutralC/CFD-BM-246-192-N.jpg,left +img/neutralC/CFD-WM-019-003-N.jpg,img/neutralC/CFD-BF-240-179-N.jpg,right +img/neutralC/CFD-IM-664-651-N.jpg,img/neutralC/CFD-LM-251-073-N.jpg,left +img/neutralC/CFD-IF-693-172-N.jpg,img/neutralC/CFD-MM-318-003-N.jpg,right +img/neutralC/CFD-IF-710-016-N.jpg,img/neutralC/CFD-MF-356-017-N.jpg,left +img/neutralC/CFD-BM-030-003-N.jpg,img/neutralC/CFD-WM-001-014-N.jpg,right +img/neutralC/CFD-BM-036-003-N.jpg,img/neutralC/CFD-BF-211-168-N.jpg,left +img/neutralC/CFD-BM-015-015-N.jpg,img/neutralC/CFD-WM-222-057-N.jpg,left +img/neutralC/CFD-IM-669-111-N.jpg,img/neutralC/CFD-AM-208-143-N.jpg,right +img/neutralC/CFD-WM-015-002-N.jpg,img/neutralC/CFD-IF-618-212-N.jpg,left +img/neutralC/CFD-LM-237-264-N.jpg,img/neutralC/CFD-BF-034-002-N.jpg,left +img/neutralC/CFD-WF-240-083-N.jpg,img/neutralC/CFD-IF-737-104-N.jpg,left +img/neutralC/CFD-BM-217-082-N.jpg,img/neutralC/CFD-LM-220-329-N.jpg,left +img/neutralC/CFD-WM-242-011-N.jpg,img/neutralC/CFD-IF-730-410-N.jpg,left +img/neutralC/CFD-WF-200-099-N.jpg,img/neutralC/CFD-IF-733-110-N.jpg,right +img/neutralC/CFD-LM-241-125-N.jpg,img/neutralC/CFD-BM-209-088-N.jpg,right +img/neutralC/CFD-IF-665-015-N.jpg,img/neutralC/CFD-AF-218-157-N.jpg,right +img/neutralC/CFD-IM-651-308-N.jpg,img/neutralC/CFD-LF-234-139-N.jpg,left +img/neutralC/CFD-BF-044-034-N.jpg,img/neutralC/CFD-LF-229-164-N.jpg,right +img/neutralC/CFD-BF-218-207-N.jpg,img/neutralC/CFD-IM-694-297-N.jpg,right diff --git a/materials/mfe_e/surp_table7.csv b/materials/mfe_e/surp_table7.csv new file mode 100644 index 0000000..593c764 --- /dev/null +++ b/materials/mfe_e/surp_table7.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-AF-246-242-N.jpg,img/neutralC/CFD-IM-712-005-N.jpg,left +img/neutralC/CFD-WF-244-163-N.jpg,img/neutralC/CFD-IF-734-108-N.jpg,right +img/neutralC/CFD-WF-213-031-N.jpg,img/neutralC/CFD-IF-609-408-N.jpg,left +img/neutralC/CFD-WM-028-003-N.jpg,img/neutralC/CFD-WM-230-131-N.jpg,left +img/neutralC/CFD-MF-307-002-N.jpg,img/neutralC/CFD-WF-230-158-N.jpg,right +img/neutralC/CFD-WF-233-112-N.jpg,img/neutralC/CFD-IF-741-040-N.jpg,left +img/neutralC/CFD-IM-617-174-N.jpg,img/neutralC/CFD-AF-230-193-N.jpg,left +img/neutralC/CFD-WF-030-002-N.jpg,img/neutralC/CFD-BM-226-276-N.jpg,right +img/neutralC/CFD-WM-212-097-N.jpg,img/neutralC/CFD-BM-045-004-N.jpg,right +img/neutralC/CFD-BM-004-002-N.jpg,img/neutralC/CFD-MM-309-027-N.jpg,left +img/neutralC/CFD-LF-225-164-N.jpg,img/neutralC/CFD-IM-613-169-N.jpg,right +img/neutralC/CFD-WM-215-041-N.jpg,img/neutralC/CFD-WF-038-021-N.jpg,left +img/neutralC/CFD-IM-707-105-N.jpg,img/neutralC/CFD-WF-232-161-N.jpg,left +img/neutralC/CFD-BM-239-136-N.jpg,img/neutralC/CFD-IF-668-009-N.jpg,right +img/neutralC/CFD-WM-033-025-N.jpg,img/neutralC/CFD-MF-344-012-N.jpg,left +img/neutralC/CFD-WM-034-030-N.jpg,img/neutralC/CFD-IM-603-305-N.jpg,left +img/neutralC/CFD-IF-744-114-N.jpg,img/neutralC/CFD-BF-005-001-N.jpg,right +img/neutralC/CFD-WM-227-099-N.jpg,img/neutralC/CFD-IF-644-306-1-N.jpg,left +img/neutralC/CFD-BM-253-004-N.jpg,img/neutralC/CFD-MF-317-002-N.jpg,left +img/neutralC/CFD-MF-305-014-N.jpg,img/neutralC/CFD-IM-666-372-N.jpg,right +img/neutralC/CFD-LF-204-133-N.jpg,img/neutralC/CFD-LF-248-160-N.jpg,left +img/neutralC/CFD-LF-245-166-N.jpg,img/neutralC/CFD-WM-208-068-N.jpg,left +img/neutralC/CFD-WF-001-003-N.jpg,img/neutralC/CFD-BF-037-022-N.jpg,right +img/neutralC/CFD-IF-660-464-N.jpg,img/neutralC/CFD-AM-204-122-N.jpg,left +img/neutralC/CFD-BM-227-191-N.jpg,img/neutralC/CFD-LF-240-199-N.jpg,left +img/neutralC/CFD-WM-020-001-N.jpg,img/neutralC/CFD-WF-019-005-N.jpg,right +img/neutralC/CFD-BF-012-001-N.jpg,img/neutralC/CFD-AF-249-092-N.jpg,left +img/neutralC/CFD-BF-205-141-N.jpg,img/neutralC/CFD-BF-241-222-N.jpg,left +img/neutralC/CFD-WF-234-086-N.jpg,img/neutralC/CFD-BM-242-233-N.jpg,right +img/neutralC/CFD-IM-674-281-N.jpg,img/neutralC/CFD-IM-663-230-N.jpg,right +img/neutralC/CFD-AF-253-130-N.jpg,img/neutralC/CFD-WF-237-067-N.jpg,right +img/neutralC/CFD-IM-657-308-N.jpg,img/neutralC/CFD-AF-236-145-N.jpg,left +img/neutralC/CFD-IM-700-009-N.jpg,img/neutralC/CFD-AF-256-160-N.jpg,left +img/neutralC/CFD-BM-020-001-N.jpg,img/neutralC/CFD-AM-239-147-N.jpg,left +img/neutralC/CFD-BM-009-002-N.jpg,img/neutralC/CFD-AF-228-173-N.jpg,right +img/neutralC/CFD-WM-023-001-N.jpg,img/neutralC/CFD-MF-350-029-N.jpg,left +img/neutralC/CFD-AM-219-101-N.jpg,img/neutralC/CFD-BF-007-001-N.jpg,left +img/neutralC/CFD-WM-004-010-N.jpg,img/neutralC/CFD-AM-214-168-N.jpg,left +img/neutralC/CFD-AM-233-236-N.jpg,img/neutralC/CFD-WM-214-026-N.jpg,right +img/neutralC/CFD-WM-012-001-N.jpg,img/neutralC/CFD-BM-229-209-N.jpg,right +img/neutralC/CFD-BM-213-134-N.jpg,img/neutralC/CFD-IM-682-019-N.jpg,left +img/neutralC/CFD-WF-250-167-N.jpg,img/neutralC/CFD-MF-319-016-N.jpg,left +img/neutralC/CFD-IM-671-601-N.jpg,img/neutralC/CFD-MM-323-053-N.jpg,right +img/neutralC/CFD-BM-238-242-N.jpg,img/neutralC/CFD-AM-209-048-N.jpg,right +img/neutralC/CFD-IM-632-097-N.jpg,img/neutralC/CFD-BM-034-031-N.jpg,right +img/neutralC/CFD-MF-300-002-N.jpg,img/neutralC/CFD-LM-211-128-N.jpg,right +img/neutralC/CFD-MM-304-002-N.jpg,img/neutralC/CFD-MF-320-002-N.jpg,left +img/neutralC/CFD-LM-247-095-N.jpg,img/neutralC/CFD-WM-239-128-N.jpg,left diff --git a/materials/mfe_e/surp_table8.csv b/materials/mfe_e/surp_table8.csv new file mode 100644 index 0000000..9f0a6e3 --- /dev/null +++ b/materials/mfe_e/surp_table8.csv @@ -0,0 +1,49 @@ +old_face_in_surp,new_face_in_surp,which_side_old_face_displayed +img/neutralC/CFD-LM-228-188-N.jpg,img/neutralC/CFD-MM-320-124-N.jpg,right +img/neutralC/CFD-MF-333-012-N.jpg,img/neutralC/CFD-AF-255-209-N.jpg,right +img/neutralC/CFD-BF-235-168-N.jpg,img/neutralC/CFD-BF-210-130-N.jpg,left +img/neutralC/CFD-BF-244-231-N.jpg,img/neutralC/CFD-LF-217-082-N.jpg,left +img/neutralC/CFD-WM-218-074-N.jpg,img/neutralC/CFD-AM-223-138-N.jpg,left +img/neutralC/CFD-MM-317-061-N.jpg,img/neutralC/CFD-MF-338-001-N.jpg,left +img/neutralC/CFD-AM-215-120-N.jpg,img/neutralC/CFD-AF-235-170-N.jpg,right +img/neutralC/CFD-IF-626-375-N.jpg,img/neutralC/CFD-BM-002-013-N.jpg,left +img/neutralC/CFD-BF-247-179-N.jpg,img/neutralC/CFD-MF-348-018-N.jpg,right +img/neutralC/CFD-WM-201-063-N.jpg,img/neutralC/CFD-LF-223-064-N.jpg,left +img/neutralC/CFD-LF-216-121-N.jpg,img/neutralC/CFD-AM-216-114-N.jpg,right +img/neutralC/CFD-WF-017-003-N.jpg,img/neutralC/CFD-MF-306-003-N.jpg,left +img/neutralC/CFD-BF-229-179-N.jpg,img/neutralC/CFD-BM-037-033-N.jpg,left +img/neutralC/CFD-BM-205-001-N.jpg,img/neutralC/CFD-MM-308-001-N.jpg,right +img/neutralC/CFD-MF-359-019-N.jpg,img/neutralC/CFD-LM-206-204-N.jpg,left +img/neutralC/CFD-BM-041-035-N.jpg,img/neutralC/CFD-MF-308-001-N.jpg,left +img/neutralC/CFD-BF-011-002-N.jpg,img/neutralC/CFD-WF-219-038-N.jpg,left +img/neutralC/CFD-IM-678-482-N.jpg,img/neutralC/CFD-WM-032-001-N.jpg,right +img/neutralC/CFD-WM-011-002-N.jpg,img/neutralC/CFD-BM-219-141-N.jpg,left +img/neutralC/CFD-WF-212-050-N.jpg,img/neutralC/CFD-BF-001-025-N.jpg,left +img/neutralC/CFD-WM-013-001-N.jpg,img/neutralC/CFD-WM-016-001-N.jpg,left +img/neutralC/CFD-LM-201-057-N.jpg,img/neutralC/CFD-AM-231-136-N.jpg,right +img/neutralC/CFD-BF-023-010-N.jpg,img/neutralC/CFD-BF-203-184-N.jpg,left +img/neutralC/CFD-BM-231-155-N.jpg,img/neutralC/CFD-BM-234-172-N.jpg,left +img/neutralC/CFD-IF-623-129-N.jpg,img/neutralC/CFD-BF-047-003-N.jpg,left +img/neutralC/CFD-BF-036-027-N.jpg,img/neutralC/CFD-IM-662-171-N.jpg,right +img/neutralC/CFD-IM-645-001-N.jpg,img/neutralC/CFD-AM-218-085-N.jpg,left +img/neutralC/CFD-IM-726-248-N.jpg,img/neutralC/CFD-IM-731-223-N.jpg,right +img/neutralC/CFD-BF-228-212-N.jpg,img/neutralC/CFD-IM-724-010-N.jpg,left +img/neutralC/CFD-AM-217-085-N.jpg,img/neutralC/CFD-IF-610-766-N.jpg,right +img/neutralC/CFD-MM-324-069-N.jpg,img/neutralC/CFD-BM-203-001-N.jpg,left +img/neutralC/CFD-BF-040-003-N.jpg,img/neutralC/CFD-AF-223-183-N.jpg,right +img/neutralC/CFD-LF-215-157-N.jpg,img/neutralC/CFD-WF-202-056-N.jpg,left +img/neutralC/CFD-WF-022-017-N.jpg,img/neutralC/CFD-BF-234-167-N.jpg,right +img/neutralC/CFD-IF-636-011-N.jpg,img/neutralC/CFD-BM-244-197-N.jpg,left +img/neutralC/CFD-WF-217-085-N.jpg,img/neutralC/CFD-IM-716-316-N.jpg,right +img/neutralC/CFD-IF-619-197-N.jpg,img/neutralC/CFD-BF-024-002-N.jpg,right +img/neutralC/CFD-IM-686-097-N.jpg,img/neutralC/CFD-BM-232-213-N.jpg,right +img/neutralC/CFD-LF-201-035-N.jpg,img/neutralC/CFD-BM-031-003-N.jpg,right +img/neutralC/CFD-AF-234-208-N.jpg,img/neutralC/CFD-MF-341-018-N.jpg,left +img/neutralC/CFD-IM-728-041-N.jpg,img/neutralC/CFD-WF-011-002-N.jpg,right +img/neutralC/CFD-MF-352-054-N.jpg,img/neutralC/CFD-BM-046-006-N.jpg,left +img/neutralC/CFD-AF-231-357-N.jpg,img/neutralC/CFD-BM-040-002-N.jpg,left +img/neutralC/CFD-WM-235-147-N.jpg,img/neutralC/CFD-WM-211-054-N.jpg,left +img/neutralC/CFD-BM-028-002-N.jpg,img/neutralC/CFD-BF-227-137-N.jpg,left +img/neutralC/CFD-BM-043-071-N.jpg,img/neutralC/CFD-MF-361-006-N.jpg,right +img/neutralC/CFD-BF-204-189-N.jpg,img/neutralC/CFD-MF-345-025-N.jpg,left +img/neutralC/CFD-LM-240-013-N.jpg,img/neutralC/CFD-WF-016-015-N.jpg,right diff --git a/materials/mfe_e/surpriseBlock_select_A.xlsx b/materials/mfe_e/surpriseBlock_select_A.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..36729691c28e66bc2292ad54fef32749f0ca2c1b GIT binary patch literal 8987 zcmeHNg;!k3(jVLj4#7PT9D-}m;1)a#4ui|!!AXz+0S1CwaJS&@?h@Pr1b3IfH`#sf z?QV9zzu>)|b8ekEeXDNwy;c3I{#C2U!@=VL5CO;l0DuZ$e3%LX!TW@-7D7J7#z{u$qjw*qH$@h#`cFsRbbwk9B?r%??(%)hTq z14zQl*4?{L*Gl*l;-sr{lz~Sg#_`m^Ai_KuklYU*BdX-R)&vZ=PI`i zJoq337QHkvf2x3qS%8XlSQSADr`@P`mneRg!r*ZS<NI*a;_`vbx#@|U3q_4gq07m1BOgT9dlXpj&C zkYU_y*nW=_H+v^*V|#n+pXl}Pn1O*p7}UytcPmy?l<#84YDRkqW_L?=#mAm=W~1KM z*n5K9U&XjUPsQbPzC!Z6L0|i;JR6*SkjK$*uj>^z<~KOpi*}~`4><6ixHdEg z!*IyP2PNbIG6=Xh`@4HZ2WXf{VBC5UNFQ?=9^dzC2D+!gS-I4b=k*goFRVt`T{x}4 zV`KwRpBb#$@VkAdzF!hhRa;A$#Av?xSTC_~iI^VXK{0;z6h&4D!viqBJw?TI-7a;B zeA;wxuIMph-JW%ezDZgnPhQ9^>=oop8QdpB;mZgCZ)PSoY8H zZ}j(0uRy=_-(5yi3Bf8D4glzYWaT|hv#iz`3Q5O6oG;zrYHjg zNtHXux8gc5+3;i31bnHn#L+lA0xOEoD`^(lSQJem-Z}AYErW+Q<8Aeyvb}!QlN=h# zW;2IMjXZOuKz)xCfNUeZJ{FOOf zNodn5i>+baY9>9ZT{jn`B!f1dE~l_G%49*L5XE{(Se$mGeO0QRGwHOr$TI7aGC)%j z##^US6BFd(iup#dtHHV?e1=7=Si5_w6p1@RAgnZ+}m|%4OkBcS)|$g~(WIIx#XzNNBw}Csa3R#4ki^7>YyaXQ)Fb z;!=}!e&(jrzpxb0cX1cu=1QN}d`5w;$eBt9Z#geNXYiQBsY09CUgai7Y$Td-WH*X5<# zw$4i-d0`=nyjfXKo^7(!hb{!&A2u(%i8{wiw?x`=si=QoI;O6-_;s2*E#TZn z6~6F?sYz9l87pasE=+HaQkVoE?95{752i&34PuD*qAo_8(An({HJvc0c6-~N6Vlv@ zjtsZ3Wv;1b>%>Xszo(od7BRf43JHbhIzWI~xiU3j3$ZN^+Z;JrbaDjgIqo;c#gE7= z6Xo>}C0o-R^jqC@KT|FNTqvt&3T%UxhJJWw_ud#?)M@V%V!GUpxs7`lp82@nuE0`= zc}tC=r-`OLP4H^eUrc-YmP?O0{reW8vi-WVXNb&W0@;+7a%A(?n95mE`aj0(F|zh~ z4s?lEgJwz?zsD@t*~7*R{BwEF*08l+V8?n8nf1lGJsfadXGWTM+P~=!hcCVAr4ljiXq$}Sn+Q;%Zv-nvNDuO~A zKvu?6i6)TcJL<@doN>*WLsW;*Qfpvkyz`c+639auc4LN03I%07Y+mq8E*pizrnlLP zPuaR8MJmVc6C8(szJ2>Qot>k?msW!_e9|;i?5Z+5 z;yL|N&>8Yf#f5Hn9yJXN-MH0Cn6n$pIMJ{Ac-KJUR7l`95*~8ja2~_frvxq+bRv`= zK?YGGIWoW_bl=MvjkXO^%CUyc4#x|m4nG~2ErNGIn5{D4N{Twcwq&=}JnEJ6ZNl1@ zAE6pepH3Ke(N-*HBuuYuMBQ^T3r5=ot_+Qu45doeo<4Zg-m@Dl;XAUU#eXq$8ip9A zF>Af#tk*Bq>=p{|TrkK&TE&=Y^({NaWBuBJ>P|cKc~&Ac(!wA}CfVOdG)wI5kTWaYC9%aAE2AFVq;abK=GAg<~hg;4qrc zBT;Cpb|}W54bRe)Y|b}h}fXjc=d$IRJx3y*>4+iui;8SkRtiawUyC@?JmD}mh zjao+$qFOi&t$yzEf1nVZ&;N=D|^W(@}@I5)jZE)ZzcoJK(BK~{s5>_ zdv2{FDeF`h#QMJ4%B_AL-?U@1u@q=*Lp!MN+ z_k?$6>e)$0SL^-FV0`Q2iNHnqw?%xm7Vp#3ofyIu?~5(vNV53_QnG|&s?dt#(lwJK z`Y@h*rM_O@&O;b0#uP>*uA!=?P7V}Vq=2cb!*)q1Xh;-sGTV`7p}BnR z6Y8xM65(V;jS?Z7Gs2wT6v{)-53$MuLni4YoDAvISgRzALk2s{DBsPW4lmo5b>>@7 z3wxQ;7(vIu?h{h5*)s@YRoz$Pm*n6kYY8*m;B@kBm!U6Zqm}ghz<73R!u(GDyFl;- z@yk|J^mWWTa{VqIh`iJGM12?$SG2I}Y=nvscwPb0*X2WxNhKBS7AQ;T6*(s;DJ(&% zQpvGci&E3^!<@PfVZ$mZ_F2fS*$7!hQ+Q%C1)+05d6?O}P|a-ha446cz*)hk`9>mj z=kOk)x3wZ*?J*;+!L9mnEo#G0WczZ(OnoC77b%7?W{^VbuZ&Ld$V_HeC$YBW7WR$- z?gR{>*elsL#F9&L`h1%yuRT*gVk)k3!){V+giSKeAZ)Wk8e3)eB9L_~;ynotz4RTJ zeC)sU8X7DMAGE+f^|E?Od0BfojHPNFAY>GTjEYXU6cB>{@J2GVNY~~tHhDIg=LsC1 zv}QAI%tl1_XlUiLd$$2{HyAJ?LZsfwU93PdgV~m({}+@i3TA6hP}*Xf1Ed)I)k6ae zoW6d%D>R=3ij`KRVq`Q*Nr*jwDKZ#&8uR!l)RtaZyG(tIst!dRVzw7B)*|v(SV)e~Dn9U=JW%V-_5ayVL1u zNDQ9hRIWF!CvoE1jd+4>Ek*sT&YzxMeXL8+?xxxbx%N5D3+o%)ZKBQ@cf@*{DLukW z^*Yz5vT1hLZborW2`hsoV+G#CC=DQTL?^tB?P4)t@%@DHVw^P7mPyMGOGI})NsNgi z*%8ZGu+N>doyIa~iAXg~iNb$Pz0~2MuzQ89n0Ah|qnRQivKdZbix)dvTbqpu>0_v0 zSfJDHFo%C~Iezr!joUZF0nkj-hY9}Jk2C^dDz2FcrfD7Ap`}CP%1jhQ%5zEWpZ8dW z5(?oio0XS%DW(U&h?d_ia=V}JPC3Wy1Pg9p6rD;;RX)$L`=P|*RBFvykBKwwA=k7v zZiBJe8`W=3MZUMm{Gc#u}+i&7G3{HvBiJWK0>Rn;F5Y+a0<^~&zTtvsb+oBL}Jo-D7X{`Ezp8-#gZ?lrzHWAOUW{R7zJ)kSkGt+vN>A9!DD{wQxuIGGtrUlv6qQl>3yMWV zLF|OIbdLl&Ef!IuKyL#-_SNAc<% z(Z6k1Oh$G2h0_B`WnPj>Gtx1Y+c65z(s|jZY7(vyeiduKyud5IKcR?ybf;%ayKZsM zE#R%^0_{JH(S0Cs(QVQxEqi_nbFB0D#3_9s8~cg`erft_>++S35- z#)C>IX95NpIhmQNJ3Cq0S^TyQ^BQYbg5$t~UnLK9E3et|LcxNqBtxME0`j9zY>m+# zNtc@e_L10`8Eu=}$(GUwB5HUt#dvaG%Za7267&?{ONJ_7%B?H%Y`a89lO@h6b6K}?qHn91n>dAW}6nIRrN|_V6-vnwq zx$7Mt@{&lkGw>XV@I97K)gyK+XfGB)Y+~=frXzBDncv|!a`Op1jP8k~U)^Mm#(OWH z-xQ86v@$PTeMkGJ*^iJA!dXCP?gw2mu%RTQslADclf46&&BWfx>|f=v|8a{@xA1}( zD0fogb+0JiW4^n>99Vok;S!o;nHfg!I({AG(1@)E0xVq~0nURfum_cjO@MHk)Kd&Kj}Jjl5b3%|)aCVJ)Y`pt~p89f8u*{Nb<>ghyl3nM+BMQp`8Oh_!jPShlL zB*@-2A?t?c@q6a7^lkdA^0rxr_DiIc)Dsaw%0qxh{N45F#y|6!9Y7uAD5!UmKsimU zKYOQHr7VD>!JS*$AHG#-63_fu>QPf>*BkdJL8|o5I;01^;J7B-8sf|hX9=-#n z7)O{EEsblHG8w|*8qK#uLDj4l)|YKcpwP{cV!c(-JU*xz6$oB4WcT0b;r}*LDRH}O zLwO<^5)b|sZS*bGp$2Z{1$cy4gkSl#^DS8e@?5N_!|QYZaUFY-N*k_J7Hj1plI^X z#}NMg)&4F2;ZTB#{9g_HwP5;h#h)@B8XA8ppZ==&*CNuN6`P=A{r^i!zuNh=vhatc zBWSJRmpa3*%D+;ae<)|6{|>nSAv}Lo{gqAnLlq1ya6q5?E4TEkfnW3CKMb4_{Ab{Q z%Z`7w@@tathZP#)-)Hb^%J8d&zXI(a`p{D@J literal 0 HcmV?d00001 diff --git a/materials/task1/readme.md b/materials/task1/readme.md deleted file mode 100644 index 3e44aa0..0000000 --- a/materials/task1/readme.md +++ /dev/null @@ -1,9 +0,0 @@ -# Task1 - -### Instructions -This folder contains the protocols, scripts, and stimuli used to create this experimental task. Replace "Task1" in the header above with a descriptive name for the task; rename the "task1" folder in like manner. - -The protocol.md file may contain the protocol itself or be a link to a Google Doc with the protocol. - - -### Project Notes diff --git a/materials/task1/scripts/readme.md b/materials/task1/scripts/readme.md deleted file mode 100644 index 3d34bbb..0000000 --- a/materials/task1/scripts/readme.md +++ /dev/null @@ -1,7 +0,0 @@ -# Task1 Scripts - -### Instructions -This folder contains the scripts used to create the task. Replace "Task1" in the header above with a descriptive name for the task; provide project-specific notes below. - - -### Project Notes diff --git a/materials/task1/stimuli/readme.md b/materials/task1/stimuli/readme.md deleted file mode 100644 index a9747d8..0000000 --- a/materials/task1/stimuli/readme.md +++ /dev/null @@ -1,7 +0,0 @@ -# Task1 Stimuli - -### Instructions -This folder contains the stimuli used to create the task. Replace "Task1" in the header above with a descriptive name for the task; provide project-specific notes below. - - -### Project Notes diff --git a/sourcedata/.DS_Store b/sourcedata/.DS_Store index 816e948e71e2f129319d4df7f88454cb555c61f0..fc05c1f4ac9ab94c528226fadc9330fb036c977b 100644 GIT binary patch delta 77 zcmZoMXfc@J&&ahgU^gQp*JK{1$^=k~Y