MultiTaskBattery 1.3.0__py3-none-any.whl

MultiTaskBattery/task_blocks.py

@@ -0,0 +1,1703 @@
+# Task Class definitions
+# March 2021: First version: Ladan Shahshahani  - Maedbh King - Suzanne Witt,
+# Revised 2023: Bassel Arafat, Jorn Diedrichsen, Incé Husain
+# Revised 2024: Caroline Nettekoven
+
+from pathlib import Path
+import pandas as pd
+import numpy as np
+import random
+from psychopy import prefs
+prefs.hardware['audioLib'] = ['sounddevice']
+from psychopy import visual, sound, core, event
+from psychopy.tools.monitorunittools import deg2pix
+from pyglet.window import key
+import MultiTaskBattery.utils as ut
+from ast import literal_eval
+from copy import deepcopy
+from moviepy.audio.io.AudioFileClip import AudioFileClip
+import gc
+import math
+import json
+
+
+class Task:
+    """
+    Task: takes in inputs from run_experiment.py and methods
+    some methods are universal across all tasks. Those methods are included in the super class Task.
+    There are methods like display_instructions which are the same across most of the tasks.
+    There are, however, some tasks that have different instructions from the rest (like fingerSequence).
+    For those tasks, a display_instructions method is defined within the corresponding class which overrides
+    the universal display_instruction method.
+    Each of other classes runs a unique task given input from target files and from the Task class
+    (VisualSearch, SemanticPrediction, NBack, SocialPrediction, ActionObservation).
+    """
+
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+
+        # Pointers to Screen and experimental constants
+        self.screen             = screen
+        self.window             = screen.window # Shortcut to window
+        self.const              = const
+        self.ttl_clock          = ttl_clock  # This is a reference to the clock of the run
+        self.name               = info['task_name']
+        self.descriptive_name   = info['descriptive_name']
+        self.code               = info['task_code']
+        self.task_file          = info['task_file']
+        self.feedback_type      = 'none'
+
+        # Set the instruction text height to a value defined in the constants, or use default - useful for smaller screens
+        self.const.instruction_text_height = getattr(self.const, 'instruction_text_height', None) or 1
+
+        # Width the instruction text wraps at, in degrees. PsychoPy's own default is
+        # narrow enough to break short lines such as "Left - Press [1]  Right - Press [2]".
+        self.const.instruction_wrap_width = getattr(self.const, 'instruction_wrap_width', None) or 30
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        self.trial_info = pd.read_csv(self.const.task_dir / self.name / self.task_file, sep='\t')
+
+    def display_instructions(self):
+        """
+        Displays the descriptive name of the task.
+        then instruction to press response key 1 for true and response key 2 for false.
+        Tasks with different instructions implement a new version to overwrite this default version
+        """
+        true_str = f"if True press {self.const.response_keys[1]}"
+        false_str = f"if False press {self.const.response_keys[2]}"
+
+        self.instruction_text = f"{self.descriptive_name} Task\n\n {true_str} \n {false_str}"
+
+        # 3.2 display the instruction text
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        # instr.size = 0.8
+        instr_visual.draw()
+        self.window.flip()
+
+    def run(self):
+        """Loop over trials in the task object and collects data
+        Data will be stored in self.trial_data
+
+        Returns:
+            acc (float): Mean accuracy in proportion correct
+            rt (float): Mean reaction time in s
+        """
+        self.trial_data = [] # an empty list which will be appended with the responses from each trial
+
+        for i,trial in self.trial_info.iterrows():
+            t_data = trial.copy()
+            # Wait for the the start of next trial
+            t_data['real_start_time'],t_data['start_ttl'],t_data['start_ttl_time'] = self.ttl_clock.wait_until(self.start_time + trial.start_time )
+            # Run the trial
+            t_data = self.run_trial(t_data)
+            # Append the trial data
+            self.trial_data.append(t_data)
+        self.trial_data = pd.DataFrame(self.trial_data)
+        # Calculate the feedback for the run
+        acc = None
+        rt = None
+        if self.feedback_type[:3] == 'acc':
+            acc = self.trial_data['correct'].mean()
+        if self.feedback_type[-2:] == 'rt':
+            rt = self.trial_data['rt'].mean()
+        return acc,rt
+
+
+    def show_progress(self, seconds_left, show_last_seconds=5, height=1, width=10, x_pos=-5, y_pos=8):
+        """ Displays a progress bar for the Picture Sequence task
+
+        Args:
+            seconds_left (float):
+                The number of seconds remaining in the current trial.
+                If this value is greater than `show_last_seconds`, the progress bar is not shown.
+
+            show_last_seconds (float, optional):
+                The duration (in seconds) over which to display the progress bar at the end of a trial.
+                Default is 5 seconds. When `seconds_left` is less than this value, the progress bar appears.
+
+            height (float, optional):
+                The vertical size of the progress bar in PsychoPy window units. Default is 1.
+
+            width (float, optional):
+                The horizontal size of the progress bar in PsychoPy window units. Default is 10.
+
+            x_pos (float, optional):
+                The horizontal position of the center of the progress bar in window coordinates.
+                Negative values move it leftward. Default is -5.
+
+            y_pos (float, optional):
+                The vertical position of the center of the progress bar in window coordinates.
+                Positive values move it upward. Default is 8.
+        """
+        # If we are in the last five seconds of the trial, display the remaining time
+        if seconds_left < show_last_seconds:
+            progress = visual.Progress(
+                win=self.window,
+                progress=1-(seconds_left/show_last_seconds),
+                size=(width, height),
+                pos=(x_pos, y_pos),
+                backColor='blue',
+                barColor='black',
+                borderColor='black',
+                lineWidth=5,
+            )
+            progress.draw()
+
+    def wait_response(self, start_time, max_wait_time, show_last_seconds=None, current_stimuli=None):
+        """
+        waits for a response to be made and then returns the response
+
+        Args:
+            start_time (float): the time the RT-period started
+            max_wait_time (float): How long to wait maximally
+            show_last_seconds (float or None): If set, show a progress bar
+                during the final *show_last_seconds* of the response window.
+                Requires *current_stimuli* to be set so the display can be
+                redrawn each frame.
+            current_stimuli (optional): A single PsychoPy stimulus or a list of stimuli
+                to redraw each frame when the progress bar is active.
+        Returns:
+            key (str): the key that was pressed (1-4) (0 if no key was pressed)
+            rt (float): the reaction time (nan if no key was pressed)
+        """
+        response_made = False
+        key = 0
+        rt = np.nan
+
+        while (self.ttl_clock.get_time() - start_time <= max_wait_time) and not response_made:
+            self.ttl_clock.update()
+            if show_last_seconds is not None:
+                if isinstance(current_stimuli, (list, tuple)):
+                    for stim in current_stimuli:
+                        stim.draw()
+                else:
+                    current_stimuli.draw()
+                seconds_left = max_wait_time - (self.ttl_clock.get_time() - start_time)
+                self.show_progress(seconds_left,
+                                show_last_seconds=show_last_seconds,
+                                y_pos=6)
+                self.window.flip()
+            keys=event.getKeys(keyList= self.const.response_keys, timeStamped=self.ttl_clock.clock)
+            if len(keys)>0:
+                response_made = True
+                key_char = keys[0][0]
+                key = self.const.response_keys.index(key_char) + 1
+                rt = keys[0][1] - start_time
+        return key, rt
+
+    def display_trial_feedback(self, give_feedback,correct_response):
+        """
+        display the feedback for the current trial at the position of  fixation cross. Correct is a green check mark, incorrect a red cross.
+
+        Args:
+            give_feedback (bool):
+                If true, gives informative feedback - otherwise just shows fixation cross
+            correct_response (bool):
+                Response was correct?, False otherwise
+        """
+        if give_feedback:
+            if correct_response:
+                self.screen.check_mark('green')
+            else:
+                self.screen.error_cross('red')
+        else:
+            self.screen.fixation_cross('white')
+
+    def save_data(self, subj_id, run_num):
+        """Saves the data to the trial data file
+
+        Args:
+            subj_id (str): Subject id to determine name
+            run_num (int): Number of run - inserted as first column
+        """
+        self.trial_data.insert(0, 'run_num', [run_num]*len(self.trial_data))
+        trial_data_file = self.const.data_dir / subj_id / f"{subj_id}_task-{self.code}.tsv"
+        ut.append_data_to_file(trial_data_file, self.trial_data)
+
+    def screen_quit(self):
+        """ Checks for quit or escape key presses and quits the experiment if necessary """
+        keys = event.getKeys()
+        for key in keys:
+            if 'q' in key or 'esc' in key:
+                self.window.close()
+                core.quit()
+
+    def get_audio_from_movie(self, movie_path, sample_rate=48000):
+        """Seperates the audio from the movie file and returns the audio object (for better memory handling when playing movies with sound)
+
+        Args:
+            movie_path (str): Path and filename of the Movie file
+            sample_rate (int): Sampling rate of movie file, defaults to 48000.
+        Returns:
+            audio (sound.sound): Sound object
+        """
+
+        # Gets the movie audio
+        audio_clip = AudioFileClip(movie_path)
+        audio_array = audio_clip.to_soundarray(fps=sample_rate)
+        audio_clip.close()
+        audio = sound.Sound(audio_array,sampleRate=sample_rate, stereo=True)
+
+        return audio
+
+class NBack(Task):
+
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'acc+rt'
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        trial_info_file = self.const.task_dir / self.name / self.task_file
+        self.trial_info = pd.read_csv(trial_info_file, sep='\t')
+        self.stim = []
+        stim_width = self.trial_info['stim_width'].iloc[0] if 'stim_width' in self.trial_info.columns else 18.4
+        for stim in self.trial_info['stim']:
+            stim_path = ut.find_stim(self.const, self.name, stim)
+            img = visual.ImageStim(self.window, str(stim_path), size=(stim_width, None))  # width in deg
+            self.stim.append(img)
+        self.corr_key = [self.trial_info['key_nomatch'].iloc[0], self.trial_info['key_match'].iloc[0]]
+        self.n_back = self.infer_n_back()
+
+    def infer_n_back(self):
+        """ Derive the numeric n-back level (used only for the instruction text).
+
+        The level lives in the 'condition' column as an 'N-back' label (e.g.
+        '2-back'), so a hand-made task file only needs that one column. Defaults
+        to 2 if no usable 'condition' label is present.
+        """
+        if 'condition' in self.trial_info.columns:
+            head = str(self.trial_info['condition'].iloc[0]).split('-')[0].strip()
+            if head.isdigit():
+                return int(head)
+        return 2
+
+    def display_instructions(self):
+        """
+        displays the instruction for the task
+        """
+        str1 = f"Compare image to the one shown {self.n_back} previously"
+        str2 = f"if match, press {self.corr_key[1]}"
+        str3 = f"if no match, press {self.corr_key[0]}"
+        self.instruction_text = f"{self.descriptive_name} Task\n\n {str1} \n {str2} \n {str3}"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self,trial):
+        """Runs a single trial of the nback task (after it started)
+        Args:
+            trial (pd.Series):
+                Row of trial_info, with all information about the trial
+
+        Returns:
+            trial (pd.Series):
+                Row of trial_data with all response data added
+        """
+
+        # Flush any keys in buffer
+        event.clearEvents()
+
+        # display stimulus
+        self.stim[trial['trial_num']].draw()
+        self.window.flip()
+
+        # collect responses 0: no response 1-4: key pressed
+        trial['response'],trial['rt'] = self.wait_response(self.ttl_clock.get_time(), trial['trial_dur'])
+        trial['correct'] = (trial['response'] == self.corr_key[trial['trial_type']])
+
+        # display trial feedback
+        self.display_trial_feedback(trial['display_trial_feedback'], trial['correct'])
+        return trial
+
+class Rest(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.name          = 'rest'
+
+    def display_instructions(self): # overriding the display instruction routine from the parent
+        self.instruction_text = 'Rest: Fixate on the cross'
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        # instr.size = 0.8
+        instr_visual.draw()
+        self.window.flip()
+
+    def show_stim(self):
+        # show fixation cross
+        self.screen.fixation_cross()
+
+    def run_trial(self,trial):
+        # get current time (self.t0)
+        self.screen.fixation_cross()
+        self.ttl_clock.wait_until(self.start_time + trial['trial_dur'])
+        return trial
+
+class VerbGeneration(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        trial_info_file = self.const.task_dir / self.name / self.task_file
+        self.trial_info = pd.read_csv(trial_info_file, sep='\t')
+        self.trial_info['noun'] = self.trial_info['stim'].str.strip()
+
+    cue_labels = {'read': 'READ', 'generate': 'GENERATE'}
+    cue_colors = {'read': 'red',  'generate': 'green'}
+
+    def cue(self, condition):
+        """ Build the coloured condition label drawn just above the stimulus word. """
+        return visual.TextStim(self.window,
+                               text=self.cue_labels.get(condition, condition.upper()),
+                               pos=(0.0, 2.5), color=self.cue_colors.get(condition, 'black'),
+                               units='deg', height=1, bold=True)
+
+    def display_instructions(self):
+        str1 = "A label at the top of the screen tells you what to do for each word:"
+        str2 = f"{self.cue_labels['read']} - silently read the word"
+        str3 = f"{self.cue_labels['generate']} - silently think of a verb that goes with it"
+        self.instruction_text = f"{self.descriptive_name} Task\n\n {str1} \n {str2} \n {str3}"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def show_stim(self, noun, condition, text_height=2):
+        """ Display the condition cue (top) and the word for a fixed time. """
+        stim = visual.TextStim(self.window, text=noun, pos=(0.0, 0.0), color=(-1, -1, -1), units='deg', height=text_height)
+        self.cue(condition).draw()
+        stim.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Run a single trial of the VerbGeneration task. """
+
+        self.show_stim(trial['noun'], trial['condition'], trial.get('text_height', 2))
+
+        # wait for trial duration
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + trial['trial_dur'])
+
+        # ITI: blank the word but keep the cue on, so the context never disappears
+        self.cue(trial['condition']).draw()
+        self.screen.fixation_cross(flip=False)
+        self.window.flip()
+        return trial
+
+class TongueMovement(Task):
+    """
+    Tongue movement following Buckner et al., 2022! No particular feedback.
+    """
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+
+    def display_instructions(self):
+        self.instruction_text = f"{self.descriptive_name} Task \n\n Move your tongue left to right touching your upper premolar teeth"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Run a single trial of the tonguemovement task. """
+
+        # draw fixation cross without flipping
+        self.screen.fixation_cross(flip=False)
+
+        # Check the trial_type and display the corresponding stimulus
+        if trial['trial_type'] == 'right':
+            # If trial_type is 'right', show the black circle around the fixation cross
+            circle_visual = visual.Circle(self.window, size=6, edges= 100, lineWidth = 20, fillColor=None, lineColor='black')
+            circle_visual.draw()
+
+        self.window.flip()
+
+        # wait for trial duration
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + trial['trial_dur'])
+
+        # return to a plain fixation cross (no response, so no feedback)
+        self.screen.fixation_cross()
+
+        return trial
+
+class MotorLocalizer(Task):
+    """
+    General motor localizer. Each row shows a condition label (e.g. 'hand',
+    'foot', 'tongue') at the top of the screen in black, plus a central
+    fixation cross. A circle appears around the fixation when trial_type == 1
+    and is absent when trial_type == 0. The participant performs the movement
+    associated with the current condition.
+
+    The condition -> movement mapping (e.g. tongue = left-right, foot =
+    flex/extend) and the meaning of the circle appearing/disappearing are
+    explained to the participant during training and are deliberately NOT
+    encoded here: the code only reads the condition and trial_type and renders
+    them. No response is collected, so there is no feedback. Because the
+    condition can change within a block, a single block can localize several
+    body parts (e.g. tongue, hand and foot).
+    """
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'None'
+
+    def init_task(self):
+        self.trial_info = pd.read_csv(self.const.task_dir / self.name / self.task_file, sep='\t')
+
+    def display_instructions(self):
+        self.instruction_text = f"{self.descriptive_name} Task \n\n Move the indicated body part as instructed"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text,
+                                       height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Run a single row of the motor-localizer task. """
+        # Condition label (body part) at the top of the screen, in black
+        cond_visual = visual.TextStim(self.window, text=str(trial['condition']), pos=(0.0, trial.get('label_y', 6.0)),
+                                      color=(-1, -1, -1), units='deg', height=trial.get('text_height', 1.5))
+        cond_visual.draw()
+
+        # Central fixation cross (drawn without flipping yet)
+        self.screen.fixation_cross(flip=False)
+
+        # Circle around the fixation only when trial_type == 1
+        if int(trial['trial_type']) == 1:
+            circle_visual = visual.Circle(self.window, size=6, edges=100, lineWidth=20,
+                                          fillColor=None, lineColor='black')
+            circle_visual.draw()
+
+        self.window.flip()
+
+        # hold this row for its duration (no response, so no feedback)
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + trial['trial_dur'])
+        return trial
+
+class AuditoryNarrative(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+
+    def display_instructions(self):
+        self.instruction_text = f'{self.descriptive_name} Task\n\nListen to the narrative attentively.'
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Run a single trial of the AuditoryNarrative task. """
+        self.screen.fixation_cross()
+
+        # Load and play audio stimulus for the current trial
+        audio_path = ut.find_stim(self.const, self.name, trial['stim'])
+        audio_stim = sound.Sound(str(audio_path))
+        audio_stim.play()
+
+        trial_dur = audio_stim.getDuration()
+
+        # wait for trial duration (fixation cross stays on screen during playback)
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + trial['trial_dur'])
+
+        return trial
+
+
+class SpatialNavigation(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+
+    def init_task(self):
+        self.trial_info = pd.read_csv(self.const.task_dir / self.name / self.task_file, sep='\t')
+
+    def display_instructions(self):
+        start_location = self.trial_info.iloc[0]['location_1']
+        end_location = self.trial_info.iloc[0]['location_2']
+
+        self.instruction_text = (f"{self.descriptive_name} Task \n\n"
+                                    f"Imagine walking around your childhood home\n"
+                                    f"Start in the {start_location} – end in the {end_location}\n"
+                                    f"Focus on the fixation cross")
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self,trial):
+        # fixation cross stays on screen while the participant imagines the route (no response)
+        self.screen.fixation_cross()
+
+        # wait for trial duration
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + trial['trial_dur'])
+
+        return trial
+
+class TheoryOfMind(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'acc+rt'
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        self.trial_info = pd.read_csv(self.const.task_dir / self.name / self.task_file, sep='\t')
+        self.corr_key = [self.trial_info['key_false'].iloc[0],self.trial_info['key_true'].iloc[0]]
+
+
+    def display_instructions(self):
+        """
+        displays the instruction for the task
+        """
+        task_name = visual.TextStim(self.window, text=f'{self.descriptive_name.capitalize()}', height=self.const.instruction_text_height, color=[-1, -1, -1], bold=True, pos=(0, 3))
+        task_name.draw()
+        str1 = f"You will read a story and decide if the answer to the question is True or False."
+        str2 = f"if true, press {self.corr_key[1]}"
+        str3 = f"if false, press {self.corr_key[0]}"
+        self.instruction_text = f"\n\n {str1} \n\n {str2} \n {str3}"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Runs a single trial of the Theory of Mind task """
+
+        event.clearEvents()
+
+        height = trial.get('text_height', 1.25)
+        wrapWidth = trial.get('wrap_width', 25)
+
+        # Display story
+        story_clean = ' '.join(trial['story'].split('\n'))
+        story_formatted = '.\n'.join(story_clean.split('. '))
+        story_stim = visual.TextStim(self.window, text=story_formatted, alignHoriz='center', wrapWidth=wrapWidth, pos=(0.0, 0.0), color=(-1, -1, -1), units='deg', height=height)
+        story_stim.draw()
+        self.window.flip()
+
+        # wait until story duration
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + trial['story_dur'])
+
+        # Flush any keys in buffer
+        event.clearEvents()
+
+        # Display question
+        question_stim = visual.TextStim(self.window, text=trial['question'], pos=(0.0, 0.0), color=(-1, -1, -1), units='deg', height=height, wrapWidth=wrapWidth)
+        question_stim.draw()
+        self.window.flip()
+
+        # collect responses 0: no response 1-4: key pressed
+        trial['response'],trial['rt'] = self.wait_response(self.ttl_clock.get_time(), trial['question_dur'])
+        trial['correct'] = (trial['response'] == self.corr_key[trial['trial_type']])
+
+        # display trial feedback
+        self.display_trial_feedback(trial['display_trial_feedback'], trial['correct'])
+
+        return trial
+
+class PassageListening(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+
+    def display_instructions(self):
+        self.instruction_text = f'{self.descriptive_name} Task \n\nListen to the audio attentively.'
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Run a single trial of the task. """
+
+        self.screen.fixation_cross()
+
+        # Load and play audio stimulus for the current trial
+        audio_path = ut.find_stim(self.const, self.name, trial['stim'])
+        audio_stim = sound.Sound(str(audio_path))
+        audio_stim.play()
+
+        # wait for trial duration (fixation cross stays on screen during playback)
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + trial['trial_dur'])
+
+        return trial
+
+class ActionObservation(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+
+    def display_instructions(self): # overriding the display instruction from the parent class
+        self.instruction_text = f"{self.descriptive_name} Task \n\n Keep your head still while watching the two clips. \n\n Try and remember the knot shown."
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Runs a single trial of the ActionObservation task """
+        # Assuming that 'stim' column in trial contains the file name of the video clip
+        movie_file_name = trial['stim']
+
+        # Construct the movie file path
+        movie_path = ut.find_stim(self.const, self.name, 'clips', movie_file_name)
+
+        # Convert Path object to string for compatibility
+        movie_path_str = str(movie_path)
+
+        # Create a MovieStim3 object
+        # MovieStim sizes are in pixels, so convert the width (deg); height keeps the clip's aspect
+        movie_clip = visual.MovieStim(self.window, movie_path_str, loop=False,
+                                      size=(deg2pix(trial.get('stim_width', 18.4), self.window.monitor), None))
+
+        while movie_clip.isFinished == False:
+            movie_clip.play()
+            movie_clip.draw()
+            self.window.flip()
+            self.ttl_clock.update()
+
+        self.screen.fixation_cross()
+
+        # Flush memory: This is necessary for the script to be able to run more than 1 run. Presenting movies is very memory hungry, so do not remove!
+        movie_clip.unload()
+        gc.collect() # Collect garbarge
+
+        return trial
+
+class DemandGrid(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.square_size = 1.5
+        self.feedback_type = 'acc+rt'
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        trial_info_file = self.const.task_dir / self.name / self.task_file
+        self.trial_info = pd.read_csv(trial_info_file, sep='\t')
+        self.corr_key = [self.trial_info['key_left'].iloc[0],self.trial_info['key_right'].iloc[0]]
+
+    def display_instructions(self):
+        """
+        displays the instruction for the task
+        """
+        str1 = f"You will watch the sequence of boxes that light up and then choose the correct pattern"
+        str2 = f"if left, press {self.corr_key[0]}"
+        str3 = f"if right, press {self.corr_key[1]}"
+        self.instruction_text = f"{self.descriptive_name} Task\n\n {str1} \n {str2} \n {str3}"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def create_grid(self, sequence=None, position='center',grid_size=(3,4)):
+        """Creates the grid of squares for the DemandGrid task, lighting up specific squares blue if a sequence is given,
+        and positions the grid left, right, or center."""
+        # Calculate offsets based on the desired position
+        if position == 'left':
+            offset_x = -self.answer_offset
+        elif position == 'right':
+            offset_x = self.answer_offset
+        else:  # center
+            offset_x = 0
+
+        # Center the grid vertically
+        offset_y = 0
+
+        grid = []
+        # Create and draw the grid
+        for i in range(grid_size[0]):
+            row = []
+            for j in range(grid_size[1]):
+                # Calculate position with the offsets
+                # i runs over rows (grid_size[0]), j over columns (grid_size[1])
+                square_x = (j - grid_size[1] / 2 + 0.5) * self.square_size + offset_x
+                square_y = (grid_size[0] / 2 - i - 0.5) * self.square_size + offset_y
+
+                # Determine the fill color based on the sequence
+                fill_color = 'blue' if sequence and (i, j) in sequence else 'white'
+
+                rect = visual.Rect(self.window, width=self.square_size, height=self.square_size,
+                                   pos=(square_x, square_y), lineWidth=3,
+                                   lineColor='black', fillColor=fill_color)
+                rect.draw()
+                row.append(rect)
+            grid.append(row)
+
+        return grid
+
+    def run_trial(self, trial):
+        """Runs a single trial of the DemandGrid task with two boxes lighting up at a time"""
+        # Draw the entire grid in its initial state
+        if 'grid_size' in trial:
+            grid_size = literal_eval(trial['grid_size'])
+        else:
+            grid_size = (3,4)
+
+        # Make the code adaptable to old DemandGrid implementation
+        if 'num_steps' in trial:
+            num_steps = trial['num_steps']
+        else:
+            num_steps = 3
+
+        step_dur = trial['sequence_dur']/num_steps
+        self.square_size = trial.get('square_size', 1.5)
+        self.answer_offset = trial.get('answer_offset', 5)
+        self.grid = self.create_grid(grid_size=grid_size)
+
+        # Display the sequence in steps
+        if 'original_sequence' in trial:
+            original_sequence = literal_eval(trial['original_sequence'])
+        else:
+            original_sequence = literal_eval(trial['grid_sequence'])
+
+        if 'num_steps' in trial: # new implementation
+            for i in range(num_steps):
+                step_sequence_name = f'original_step_{i+1}'
+                step_sequence = literal_eval(trial[step_sequence_name])
+
+                for tuple in step_sequence:
+                    x, y = tuple
+                    self.grid[x][y].fillColor = 'blue'
+
+                for row in self.grid:
+                    for rect in row:
+                        rect.draw()
+                self.window.flip()
+                self.ttl_clock.wait_until(self.ttl_clock.get_time() + step_dur)
+
+                for tuple in step_sequence:
+                    x, y = tuple
+                    self.grid[x][y].fillColor = 'white'
+
+        else: # old implementation
+            for i in range(0, len(original_sequence), 2):  # Iterate in steps of 2
+                if i + 1 < len(original_sequence):
+                    pair = [original_sequence[i], original_sequence[i + 1]]
+                else:
+                    pair = [original_sequence[i]]  # Handle odd-length sequences
+
+                # Highlight positions in the current pair
+                for x, y in pair:
+                    self.grid[x][y].fillColor = 'blue'
+
+                # Draw and update the window
+                for row in self.grid:
+                    for rect in row:
+                        rect.draw()
+                self.window.flip()
+                self.ttl_clock.wait_until(self.ttl_clock.get_time() + step_dur)
+
+                # Reset colors after the pair
+                for x, y in pair:
+                    self.grid[x][y].fillColor = 'white'
+
+        # Flush any keys in buffer
+        event.clearEvents()
+
+        # Determine which side the correct sequence will be displayed
+        correct_side = trial['correct_side']
+
+
+        # # Display the original and modified sequence on the left or right side
+        modified_sequence = literal_eval(trial['modified_sequence'])
+
+        original_grid = self.create_grid(sequence=original_sequence, position=correct_side, grid_size=grid_size)
+        modified_grid = self.create_grid(sequence=modified_sequence, position='left' if correct_side == 'right' else 'right', grid_size=grid_size)
+        self.window.flip()
+
+        # collect responses 0: no response 1-4: key pressed
+        trial['response'],trial['rt'] = self.wait_response(self.ttl_clock.get_time(), trial['question_dur'])
+        trial['correct'] = (trial['response'] == self.corr_key[trial['trial_type']])
+
+        # Provide feedback if necessary
+        self.display_trial_feedback(trial['display_trial_feedback'], trial['correct'])
+
+        return trial
+
+class Reading(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+
+    def display_instructions(self):
+        self.instruction_text = f'{self.descriptive_name} Task \n\n Read the shown text and press a button when the image of a hand pressing a button is displayed'
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Run a single trial of the sentence reading task. """
+
+        # get sentence and split into words by space
+        sentence = trial['stim']
+        words = sentence.split()
+
+        #show words seqeuntially each for 450ms
+        for word in words:
+            word_stim = visual.TextStim(self.window, text=word, pos=(0.0, 0.0), color=(-1, -1, -1), units='deg', height=trial.get('text_height', 2))
+            word_stim.draw()
+            self.window.flip()
+            self.ttl_clock.wait_until(self.ttl_clock.get_time() + 0.45)
+
+        event.clearEvents()
+
+        # show press button image
+        button_stim = visual.ImageStim(self.window, image=str(ut.find_stim(self.const, self.name, 'hand_press_transparent.png')), size=(trial.get('stim_width', 14.4), None))
+        button_stim.draw()
+        self.window.flip()
+        trial['response'],trial['rt'] = self.wait_response(self.ttl_clock.get_time(), 0.4)
+
+        # show blank_transparent image
+        blank_stim = visual.ImageStim(self.window, image=str(ut.find_stim(self.const, self.name, 'blank_transparent.png')), size=(trial.get('stim_width', 14.4), None))
+        blank_stim.draw()
+        self.window.flip()
+
+        # flush any keys in buffer
+        event.clearEvents()
+
+        # not displaying crosshair to replicate the localizer
+
+        return trial
+
+class OddBall(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'acc+rt'
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        trial_info_file = self.const.task_dir / self.name / self.task_file
+        self.trial_info = pd.read_csv(trial_info_file, sep='\t')
+        self.press_key = self.trial_info['key_one'].iloc[0]
+
+    def display_instructions(self):
+        """
+        displays the instruction for the task
+        """
+        str1 = f"Press {self.press_key} when you see a red K"
+        self.instruction_text = f"{self.descriptive_name} Task\n\n {str1} \n"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Run a single trial of the oddball task. """
+
+        current_trial =  trial['stim']
+
+        # show stem
+        if current_trial == 'red_K':
+            word_stim = visual.TextStim(self.window, text='K', pos=(0.0, 0.0), color='red', units='deg', height=trial.get('text_height', 1.5))
+        elif current_trial == 'black_K':
+            word_stim = visual.TextStim(self.window, text='K', pos=(0.0, 0.0), color='black', units='deg', height=trial.get('text_height', 1.5))
+        elif current_trial == 'red_O':
+            word_stim = visual.TextStim(self.window, text='O', pos=(0.0, 0.0), color='red', units='deg', height=trial.get('text_height', 1.5))
+        elif current_trial == 'black_O':
+            word_stim = visual.TextStim(self.window, text='O', pos=(0.0, 0.0), color='black', units='deg', height=trial.get('text_height', 1.5))
+
+        word_stim.draw()
+        self.window.flip()
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + trial['trial_dur'])
+
+        # blank the letter to a fixation cross during the response window (no per-trial feedback)
+        self.screen.fixation_cross()
+
+        # Flush any keys in buffer
+        event.clearEvents()
+
+        # collect responses 0: no response 1-4: key pressed
+        trial['response'],trial['rt'] = self.wait_response(self.ttl_clock.get_time(), trial['iti_dur'])
+
+        # method 2 for accuracy for oddball
+        if trial['trial_type'] == 1:
+            trial['correct'] = True if trial['response']!= 0 else False
+        elif trial['trial_type'] == 0:
+            trial['correct'] = np.nan
+
+
+        return trial
+
+class FingerSequence(Task):
+    """
+    Finger sequence task
+    """
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'acc+rt'
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        trial_info_file = self.const.task_dir / self.name / self.task_file
+        self.trial_info = pd.read_csv(trial_info_file, sep='\t')
+
+
+    def display_instructions(self):
+        self.instruction_text = f"{self.descriptive_name} Task \n\n Using your four fingers, press the keys in the order shown on the screen\n Use all four fingers for this task"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+
+    def run_trial(self, trial):
+        """ Run a single trial of the finger sequence task. """
+        #clear buffer
+        event.clearEvents()
+
+        # Display the sequence
+        sequence = trial['stim'].split()
+
+        # Calculate the start position for the sequence and determine the spacing between numbers
+        num_items = len(sequence)
+        spacing = 2.0
+        start_x = -(num_items - 1) * spacing / 2
+
+        # Show the numbers in the sequence next to each other ( using the spacing and start_x calculated above)
+        for i, number in enumerate(sequence):
+            pos = (start_x + i * spacing, 0.0)  # Horizontal position is adjusted based on index
+            stim = visual.TextStim(self.window, text=number, pos=pos, color='black', units='deg', height=trial.get('text_height', 1.5))
+            stim.draw()
+
+        self.window.flip()
+
+
+        sequence_start_time = self.ttl_clock.get_time() # Needed for knowing when to stop looking for key presses
+        digit_start_time = sequence_start_time # Updated with each key press for calculating RT
+
+        rt_list = np.full(num_items,np.nan)
+        correct_list = np.zeros((num_items,)) # List of booleans indicating whether each press was correct needed for overall trial accuracy
+        num_presses =0
+        # Initialize the color for each digit in the sequence as black
+        digit_colors = ['black'] * num_items
+        while self.ttl_clock.get_time() - sequence_start_time < trial['trial_dur'] and num_presses < num_items:
+            self.ttl_clock.update()
+
+            keys = event.getKeys(keyList=self.const.response_keys, timeStamped=self.ttl_clock.clock)
+            if keys:
+                key_char, key_press_time = keys[0]
+                key = self.const.response_keys.index(key_char) + 1
+                rt = key_press_time - digit_start_time
+                rt_list[num_presses]=rt
+                digit_start_time = key_press_time
+
+                # Check if key pressed is correct
+                correct_list[num_presses] = key == int(sequence[num_presses])
+
+                # Update color based on correctness
+                digit_colors[num_presses] = 'green' if correct_list[num_presses] else 'red'
+
+                num_presses += 1
+            # Draw all digits with their adjusted colors
+            for i, (number, color) in enumerate(zip(sequence, digit_colors)):
+                pos = (start_x + i * spacing, 0.0)
+                stim = visual.TextStim(self.window, text=number, pos=pos, color=color, units='deg', height=trial.get('text_height', 1.5))
+                stim.draw()
+
+            self.window.flip()
+
+        else:
+            # If the sequence is completed, wait until the end of the trial
+            self.ttl_clock.wait_until(sequence_start_time + trial['trial_dur'])
+
+        # if any press is wrong trial['correct'] needs to be false, this is for post trial feedback
+        trial['correct'] = correct_list.sum()/num_items
+
+        if np.all(np.isnan(rt_list)):
+            # calculate mean rt across presses
+            trial['rt'] = np.nan
+
+        else:
+            trial['rt'] = np.nanmean(rt_list)
+
+        # display trial feedback (for whole trial)
+        self.display_trial_feedback(trial['display_trial_feedback'], trial['correct']== 1)
+
+        return trial
+
+class FlexionExtension(Task):
+    """
+    Flexion extension of toes! No particular feedback.
+    """
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'None'
+
+    def init_task(self):
+        self.trial_info = pd.read_csv(self.const.task_dir / self.name / self.task_file, sep='\t')
+
+    def display_instructions(self):
+        self.instruction_text = f"{self.descriptive_name} Task \n\n Flex and extend your right and left toes"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        # Show this phase's cue ('flexion' or 'extension') for its duration; no response.
+        stim = visual.TextStim(self.window, text=trial['stim'], pos=(0.0, 0.0),
+                               color=(-1, -1, -1), units='deg', height=trial.get('text_height', 1.5))
+        stim.draw()
+        self.window.flip()
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + trial['trial_dur'])
+        return trial
+
+class SemanticPrediction(Task):
+
+    """
+    Read a sentence and decide if the last word of the sentence makes sense. Click "3" if the last word makes sense; click "4" if not. Be as accurate and fast as possible.
+    """
+
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'acc+rt'
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        self.trial_info = pd.read_csv(self.const.task_dir / self.name / self.task_file, sep='\t')
+        self.corr_key = [self.trial_info['key_false'].iloc[0], self.trial_info['key_true'].iloc[0]]
+
+    def display_instructions(self):
+        """
+        displays the instruction for the task
+        """
+        str1 = f"You will read a sentence and decide if the last word makes sense."
+        str2 = f"If it makes sense, press {self.corr_key[1]}"
+        str3 = f"if it doesn't make sense, press {self.corr_key[0]}"
+        self.instruction_text = f"{self.descriptive_name} Task\n\n {str1} \n {str2} \n {str3}"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Runs a single trial of the semantic prediction task """
+
+        height_word = trial.get('text_height', 2)
+
+        event.clearEvents()
+
+        # get sentence and split into words by space
+        sentence = trial['sentence']
+        words = sentence.split('|')
+
+        #show words seqeuntially each for 800ms
+        for word in words:
+            word_stim = visual.TextStim(self.window, text=word, pos=(0.0, 0.0), color=(-1, -1, -1), units='deg', height=height_word)
+            word_stim.draw()
+            self.window.flip()
+            self.ttl_clock.wait_until(self.ttl_clock.get_time() + 0.8)
+
+        event.clearEvents()
+
+        # Fixation cross
+        self.screen.fixation_cross()
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + 0.5)
+        event.clearEvents()
+
+        # Display last word
+        last_word_stim = visual.TextStim(self.window, text=trial['last_word'], pos=(0.0, 0.0), color=(-1, -1, -1), units='deg', height= height_word, wrapWidth=30)
+        last_word_stim.draw()
+        self.window.flip()
+
+        event.clearEvents()
+
+        # collect responses 0: no response 1-4: key pressed
+        trial['response'],trial['rt'] = self.wait_response(self.ttl_clock.get_time(), trial['sentence_dur'])
+        trial['correct'] = (trial['response'] == self.corr_key[trial['trial_type']])
+
+        # display trial feedback
+        self.display_trial_feedback(trial['display_trial_feedback'], trial['correct'])
+
+        return trial
+
+
+class VisualSearch(Task):
+
+    """
+    Look at a screen filled with shapes and identify whether an "L" is present. Click "3" if the "L" is present; click "4" if not. Be as accurate and fast as possible.
+    """
+
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'acc'
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        trial_info_file = self.const.task_dir / self.name / self.task_file
+        self.trial_info = pd.read_csv(trial_info_file, sep='\t')
+
+        #counter initialized in order to read whether trial_type is true or not for each trial; used in generate_trial_stimuli
+        self.trial_counter = 0
+
+        # Search area in deg (default 28 x 20: the x extremity of a large window is 14, y is 10, found by trial and error)
+        screen_width = self.trial_info['search_width'].iloc[0] if 'search_width' in self.trial_info.columns else 28
+        screen_height = self.trial_info['search_height'].iloc[0] if 'search_height' in self.trial_info.columns else 20
+
+        #define number of rows + col to split screen into 24 apertures
+        num_rows = 4
+        num_cols = 6
+
+        #Define aperture sizes + positions
+        aperture_width = screen_width / num_cols
+        aperture_height = screen_height / num_rows
+
+        positions_x = np.linspace(-screen_width / 2 + aperture_width / 2, screen_width / 2 - aperture_width / 2, num_cols)
+        positions_y = np.linspace(-screen_height / 2 + aperture_height / 2, screen_height / 2 - aperture_height / 2, num_rows)
+
+        aperture_positions = []
+
+        for y in positions_y:
+            for x in positions_x:
+                aperture_positions.append((x, y))
+
+        self.apertures = []
+        for pos in aperture_positions:
+            apertures = visual.Aperture(self.window, size=40, shape = 'rectangle', pos=pos, units='norm')
+            self.apertures.append(apertures)
+
+    def generate_trial_stimuli(self, num_stimuli):
+
+        stim_images = ['90.png','180.png','270.png','360.png']
+
+        self.stim = []
+
+        is_target = True #determines whether target will appear on screen
+
+        if self.trial_info['trial_type'][self.trial_counter] == 0:
+            stim_images.remove('90.png') #sets a display with no target
+            is_target = False
+
+        self.trial_counter+=1
+
+        randomly_select_apertures = random.sample(self.apertures, num_stimuli)
+
+        for aperture in randomly_select_apertures:
+            if is_target:
+                stim_current = stim_images[0] #sets a display with at least one target
+                is_target = False
+            else:
+                stim_random_idx = random.randint(0, len(stim_images)-1)  #chooses random stimuli from stim_images list
+                stim_current = stim_images[stim_random_idx]
+
+            stim_path = ut.find_stim(self.const, self.name, stim_current)
+            stimulus = visual.ImageStim(self.window, str(stim_path), size=(0.8,0.8))
+            stimulus.setPos([aperture.pos[0], aperture.pos[1]]) #puts stimuli within apertures
+            self.stim.append(stimulus) #creates list of all randomly selected stimuli
+
+    def display_instructions(self):
+        """
+        displays the instruction for the task
+        """
+
+        self.corr_key = [self.trial_info['key_false'].iloc[0],self.trial_info['key_true'].iloc[0]]
+
+        str1 = f"You will survey a series of shapes and identify whether the letter ‘L’ is present."
+        str2 = f"If 'L' is present, press {self.corr_key[1]}"
+        str3 = f"if 'L' is not present, press {self.corr_key[0]}"
+        self.instruction_text = f"{self.descriptive_name} Task\n\n {str1} \n {str2} \n {str3}"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self,trial):
+        """Runs a single trial of visual search task
+        """
+
+        # Flush any keys in buffer
+        event.clearEvents()
+
+        # Set size (difficulty) is stored as the condition, e.g. '8-items'.
+        num_stimuli = int(str(trial['condition']).split('-')[0])
+
+        self.generate_trial_stimuli(num_stimuli)
+
+        self.screen.fixation_cross(flip=False)  #show fixation cross in center of screen
+
+        # Display stimuli
+        for stimulus in self.stim:
+            stimulus.draw()
+
+        self.window.flip()
+
+        # collect responses
+        trial['response'],trial['rt'] = self.wait_response(self.ttl_clock.get_time(), trial['trial_dur'])
+        trial['correct'] = (trial['response'] == self.corr_key[trial['trial_type']])
+
+        self.display_trial_feedback(trial['display_trial_feedback'], trial['correct'])
+
+        return trial
+
+
+class Movie(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.name = 'movie'
+
+    def display_instructions(self):
+        task_name = visual.TextStim(self.window, text=f'{self.descriptive_name.capitalize()}', height=self.const.instruction_text_height, color=[-1, -1, -1], bold=True, pos=(0, 3))
+        task_name.draw()
+
+        self.instruction_text = f"\n\n You will watch short clips from a movie. Please keep your head still and pay attention to the screen."
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width, pos=(0, 0))
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        start = self.ttl_clock.get_time()   # trial_dur counts from here, so loading the clip is included
+        stim_width = deg2pix(trial.get('stim_width', 22), self.window.monitor)  # MovieStim sizes are in pixels
+
+        # Get the file name
+        movie_file_name = trial['stim']
+
+        # Construct the movie file path
+        movie_path = ut.find_stim(self.const, self.name, 'clips', movie_file_name)
+
+        # Convert Path object to string for compatibility
+        movie_path_str = str(movie_path)
+
+        # Create a MovieStim3 object
+        movie_clip = visual.MovieStim(self.window, movie_path_str, loop=False, size=(stim_width, None), pos=(0, 0), noAudio=True)
+
+
+        movie_clip.play()
+        self.window.flip()
+
+        # play until the clip ends or trial_dur is up (so a shorter trial cuts a longer clip)
+        while not movie_clip.isFinished and self.ttl_clock.get_time() - start < trial['trial_dur']:
+            movie_clip.play()
+            movie_clip.draw()
+            self.window.flip()
+            self.ttl_clock.update()
+
+        # Flush memory: This is necessary for the script to be able to run more than 1 run. Presenting movies is very memory hungry, so do not remove!
+        movie_clip.unload()
+        gc.collect() # Collect garbarge
+
+        return trial
+
+
+class Affective(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'acc+rt'
+
+    def init_task(self):
+        """
+        Initialize task
+        """
+        trial_info_file = self.const.task_dir / self.name / self.task_file
+        self.trial_info = pd.read_csv(trial_info_file, sep='\t')
+
+        self.stim = []
+        stim_width = self.trial_info['stim_width'].iloc[0] if 'stim_width' in self.trial_info.columns else 18.4
+        for stim_file in self.trial_info['stim']:
+            stim_path = ut.find_stim(self.const, self.name, stim_file)
+            self.stim.append(visual.ImageStim(self.window, image=str(stim_path), size=(stim_width, None)))  # width in deg
+
+    def display_instructions(self):
+        """
+        Display instructions for the affective task.
+        """
+        key_pleasant = self.trial_info['key_pleasant'].iloc[0]
+        key_unpleasant = self.trial_info['key_unpleasant'].iloc[0]
+
+        self.instruction_text = (
+            f"{self.descriptive_name} Task\n\n"
+            f"Press {key_unpleasant} if the image is UNPLEASANT.\n"
+            f"Press {key_pleasant} if the image is PLEASANT."
+        )
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """
+        Run a single trial of the affective task.
+        """
+        event.clearEvents()
+
+        # Display image
+        self.stim[trial['trial_num']].draw()
+        self.window.flip()
+
+        # Wait for response
+        trial['response'], trial['rt'] = self.wait_response(self.ttl_clock.get_time(), trial['trial_dur'])
+
+        # Determine correct response
+        correct_key = trial['key_pleasant'] if trial['trial_type'] == 2 else trial['key_unpleasant']
+        trial['correct'] = (trial['response'] == correct_key)
+
+        # Show feedback
+        self.display_trial_feedback(trial['display_trial_feedback'], trial['correct'])
+
+        return trial
+
+class SerialReactionTime(Task):
+    """
+    Serial reaction time task
+    """
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+
+    def init_task(self):
+        """
+        Initialize task - default is to read the target information into the trial_info dataframe
+        """
+        trial_info_file = self.const.task_dir / self.name / self.task_file
+        self.trial_info = pd.read_csv(trial_info_file, sep='\t')
+
+
+    def display_instructions(self): # overriding the display instruction from the parent class
+        self.instruction_text = f"Press the buttons that match the green boxes"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width, pos=(0, 0.3))
+        instr_visual.draw()
+        self.window.flip()
+
+    def run(self):
+        """Override to show empty boxes during initial wait."""
+        box_positions = [(-5, 2), (-3, 2), (3, 2), (5, 2)]
+        self.boxes = [
+            visual.Rect(
+                self.window, width=2, height=2,
+                pos=pos, fillColor='white',
+                lineColor='black', units='deg'
+            )
+            for pos in box_positions
+        ]
+        for box in self.boxes:
+            box.draw()
+        self.window.flip()
+        return super().run()
+
+    def run_trial(self, trial):
+
+        event.clearEvents()
+
+        trial_stim = int(trial['stim'])
+        target_index = trial_stim - 1
+
+        # wait until absolute stimulus time
+        stim_onset = self.ttl_clock.get_time()
+
+        # show stimulus
+        for j, box in enumerate(self.boxes):
+            box.fillColor = 'green' if j == target_index else 'white'
+            box.draw()
+        self.window.flip()
+
+        # keep green on for trial_dur
+        self.ttl_clock.wait_until(stim_onset + trial['trial_dur'])
+
+        # back to white
+        for box in self.boxes:
+            box.fillColor = 'white'
+            box.draw()
+        self.window.flip()
+
+        # collect responses until absolute end_time
+        responses = []
+        while self.ttl_clock.get_time() < (stim_onset + trial['trial_dur'] + trial['iti_dur']):
+            keys = event.getKeys(
+                keyList=self.const.response_keys,
+                timeStamped=self.ttl_clock.clock
+            )
+            for key, timestamp in keys:
+                rt = timestamp - stim_onset
+                responses.append((key, rt))
+
+        trial['responses'] = responses
+        return trial
+
+class FingerRhythmic(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+
+    def init_task(self):
+        self.trial_info = pd.read_csv(self.const.task_dir / self.name / self.task_file, sep='\t')
+        self.corr_key = [self.trial_info['key_one'].iloc[0]]
+
+    def display_instructions(self):
+        """
+        displays the instruction for the task
+        """
+
+        str1 = f"Tap along to the tones using the {self.corr_key[0]} key."
+        str2 = f"Keep tapping at the same pace when the tones stop."
+        self.instruction_text = f"{self.descriptive_name} Task\n\n {str1} \n {str2}"
+        instr_visual = visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width)
+        instr_visual.draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        """ Runs a single trial of the Finger Rhythmic task """
+
+        event.clearEvents()
+        txt = (f"New trial starts now") # this text shows when a new trials starts
+        visual.TextStim(self.window, text=txt,height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width).draw()
+        self.window.flip()
+        self.ttl_clock.wait_until(self.ttl_clock.get_time() + 2)
+
+        self.screen.fixation_cross()
+        event.clearEvents()
+        clk = self.ttl_clock.clock
+        t0 = clk.getTime()                    # trial anchor (TTL)
+
+        # --- Play FIRST tone now, then use THIS time as the grid anchor
+        beep = sound.Sound(value=1000, secs=0.05, sampleRate=48000, stereo=True)
+        beep.play()
+        t_first = clk.getTime()               # when we triggered the first tone (TTL)
+        ioi = float(trial['ioi'])
+        expected = [(t_first - t0) + i*ioi for i in range(12)]  # expected, aligned to first tone
+
+        # Track beep times for timing verification (quiet by default)
+        beep_times = [t_first]
+
+        taps_rel = []
+
+        # --- Remaining 11 tones by absolute TTL deadlines; collect keys in-between
+        for i in range(1, 12):
+            deadline = t_first + i*ioi
+            while True:
+                now = clk.getTime()
+                if now >= deadline:
+                    # Create a new Sound object for each beep to ensure it plays
+                    beep = sound.Sound(value=1000, secs=0.05, sampleRate=48000, stereo=True)
+                    beep.play()
+                    beep_time = clk.getTime()
+                    beep_times.append(beep_time)
+                    break
+                res = event.waitKeys(maxWait=deadline - now,
+                                     keyList=self.const.response_keys,
+                                     timeStamped=clk)
+                if res:
+                    for _, ts in res:
+                        taps_rel.append(ts - t0)
+
+        # --- Silent phase: collect until absolute end_time
+        end_abs = self.start_time + float(trial['end_time'])
+        while True:
+            now = clk.getTime()
+            if now >= end_abs:
+                break
+            res = event.waitKeys(maxWait=end_abs - now,
+                                 keyList=self.const.response_keys,
+                                 timeStamped=clk)
+            if res:
+                for _, ts in res:
+                    taps_rel.append(ts - t0)
+
+        # --- Self-paced ISIs only (strictly after last tone onset)
+        last_tone_t = expected[-1]            # relative to t0
+        self_taps = [t for t in taps_rel if t > last_tone_t]
+        isis = np.diff(self_taps) if len(self_taps) > 1 else np.array([], float)
+        # Accept a window scaled to the trial's IOI: a fixed 300-900 ms window
+        # discards real taps and keeps implausible ones when ioi is not ~0.6.
+        isis = isis[(isis >= max(0.15, 0.2 * ioi)) & (isis <= 2.0 * ioi)]
+
+        trial['iri_ms_mean']         = float(np.mean(isis) * 1000.0) if isis.size else np.nan
+        trial['iri_ms_sd']           = float(np.std(isis)  * 1000.0) if isis.size else np.nan
+        trial['iris_ms_json']        = json.dumps((isis * 1000.0).tolist())
+        trial['expected_rel_s_json'] = json.dumps([e for e in expected])  # seconds rel to t0
+        trial['tap_rel_s_json']      = json.dumps(taps_rel)
+        # Save beep times relative to trial start (t0)
+        beep_times_rel = [bt - t0 for bt in beep_times]
+        trial['beep_times_rel_s_json'] = json.dumps(beep_times_rel)
+
+        return trial
+
+
+class TimePerception(Task):
+    def __init__(self, info, screen, ttl_clock, const, subj_id):
+        super().__init__(info, screen, ttl_clock, const, subj_id)
+        self.feedback_type = 'acc+rt'
+
+    def init_task(self):
+        self.trial_info = pd.read_csv(self.const.task_dir / self.name / self.task_file, sep='\t')
+        self.corr_key = [self.trial_info['key_one'].iloc[0], self.trial_info['key_two'].iloc[0]]
+        # one tone for both modalities
+        self.tone = sound.Sound(value=1000, secs=0.050, sampleRate=48000, stereo=True)  # 1000 Hz, 50 ms
+
+        # PEST state per side
+        mod = str(self.trial_info['modality'].iloc[0]).lower()
+        if mod == 'time':
+            # start ±120 ms from 400; step 40; min step 8; directions tracked
+            self.stair = {
+                'shorter': {'curr': 280.0, 'step': 40.0, 'min_step': 8.0,  'last_dir': 0, 'same_dir': 0},
+                'longer':  {'curr': 520.0, 'step': 40.0, 'min_step': 8.0,  'last_dir': 0, 'same_dir': 0},
+            }
+        else:  # 'volume' (quieter/louder)
+            # start ±1.62 dB from 73; step 1.08; min step 0.27
+            self.stair = {
+                'quieter': {'curr': 71.38, 'step': 1.08, 'min_step': 0.27, 'last_dir': 0, 'same_dir': 0},
+                'louder':  {'curr': 74.62, 'step': 1.08, 'min_step': 0.27, 'last_dir': 0, 'same_dir': 0},
+            }
+
+    def display_instructions(self):
+        mod = str(self.trial_info['modality'].iloc[0]).lower()
+        if mod == 'time':
+            str1 = f"You will hear two pairs of tones."
+            str2 = f"Press [{self.corr_key[0]}] if the SECOND interval is shorter."
+            str3 = f"Press [{self.corr_key[1]}] if the SECOND interval is longer."
+            str4 = "The first pair is always the same."
+            self.instruction_text = f"{self.descriptive_name} Task\n\n {str1} \n {str2} \n {str3} \n {str4}"
+
+        else:
+            str1 = f"You will hear two pairs of tones."
+            str2 = f"Press [{self.corr_key[0]}] if the SECOND interval is quieter."
+            str3 = f"Press [{self.corr_key[1]}] if the SECOND interval is louder."
+            str4 = "The first pair is always the same."
+            self.instruction_text = f"{self.descriptive_name} Task\n\n {str1} \n {str2} \n {str3} \n {str4}"
+        visual.TextStim(self.window, text=self.instruction_text, height=self.const.instruction_text_height, color=[-1, -1, -1], wrapWidth=self.const.instruction_wrap_width).draw()
+        self.window.flip()
+
+    def run_trial(self, trial):
+        event.clearEvents()
+        clk  = self.ttl_clock
+        mod  = str(trial['modality']).lower()
+        side = str(trial['side']).lower()
+
+        # fixation
+        self.screen.fixation_cross()
+
+        # --- Pair 1 (standard @ 0.7 amp, 400 ms gap) ---
+        self.tone.setVolume(0.7)
+        t1 = clk.get_time()
+        self.tone.play()
+        clk.wait_until(t1 + 0.050)
+        clk.wait_until(t1 + 0.050 + 0.400)
+        self.tone.play()
+        clk.wait_until(t1 + 2*0.050 + 0.400)
+
+        # inter-pair gap
+        clk.wait_until(clk.get_time() + 1.000)
+
+        # --- Pair 2 (comparison) ---
+        st = self.stair[side]  # PEST state for this side
+
+        if mod == 'time':
+            # snap to 8 ms grid within side range
+            if side == 'shorter':
+                comp_ms = max(160, min(392, int(round(st['curr'] / 8.0) * 8)))
+            else:
+                comp_ms = max(408, min(640, int(round(st['curr'] / 8.0) * 8)))
+
+            t2 = clk.get_time()
+            self.tone.setVolume(0.7)
+            self.tone.play()
+            clk.wait_until(t2 + 0.050)
+            clk.wait_until(t2 + 0.050 + (comp_ms / 1000.0))
+            self.tone.play()
+            clk.wait_until(t2 + 2*0.050 + (comp_ms / 1000.0))
+
+            trial['comparison_ms'] = float(comp_ms)
+            trial['stair_step_ms'] = float(st['step'])  # log step used this trial
+
+        else:  # volume (quieter/louder), grid 0.27 dB
+            if side == 'quieter':
+                comp_db = max(64.9, min(72.73, float(st['curr'])))
+            else:
+                comp_db = min(81.1, max(73.27, float(st['curr'])))
+
+            comp_amp = float(min(1.0, 0.7 * (10 ** ((comp_db - 73.0) / 20.0))))
+
+            t2 = clk.get_time()
+            self.tone.setVolume(comp_amp)
+            self.tone.play()
+            clk.wait_until(t2 + 0.050)
+            clk.wait_until(t2 + 0.050 + 0.400)
+            self.tone.setVolume(comp_amp)
+            self.tone.play()
+            clk.wait_until(t2 + 2*0.050 + 0.400)
+            self.tone.setVolume(1.0)
+
+            trial['comparison_dba']  = float(comp_db)
+            trial['stair_step_dba']  = float(st['step'])  # log step used this trial
+
+        # --- response window ---
+        trial['response'], trial['rt'] = self.wait_response(clk.get_time(), float(trial['question_dur']))
+        trial['correct'] = (trial['response'] == trial['trial_type'])
+
+        # --- PEST update (classic + border-safe): halve on reversal; double after two same-direction moves ---
+        # Define movement: toward standard if correct, away if incorrect.
+        # Use unified sign for direction comparison: toward = -1, away = +1.
+        move_dir = (-1 if trial['correct'] else +1)
+
+        # Store the old level so we can tell if we actually moved after clamping.
+        old_curr = st['curr']
+
+        # 1. Propose + clamp
+        if mod == 'time':
+            if side == 'shorter':
+                # correct => toward standard => make interval longer => +step
+                # incorrect => away => make interval even shorter => -step
+                st['curr'] += (+st['step'] if trial['correct'] else -st['step'])
+                # snap to 8 ms grid and clamp to that side's allowed range
+                st['curr']  = float(int(round(st['curr'] / 8.0) * 8))
+                if st['curr'] < 160.0:
+                    st['curr'] = 160.0
+                if st['curr'] > 392.0:
+                    st['curr'] = 392.0
+
+            else:  # side == 'longer'
+                # correct => toward standard => make interval shorter => -step
+                # incorrect => away => make interval even longer => +step
+                st['curr'] += (-st['step'] if trial['correct'] else +st['step'])
+                st['curr']  = float(int(round(st['curr'] / 8.0) * 8))
+                if st['curr'] < 408.0:
+                    st['curr'] = 408.0
+                if st['curr'] > 640.0:
+                    st['curr'] = 640.0
+
+        else:
+            # volume
+            if side == 'quieter':
+                # correct => toward standard (louder) => +step in dB toward 73
+                # incorrect => away (quieter) => -step
+                st['curr'] += (+st['step'] if trial['correct'] else -st['step'])
+                if st['curr'] < 64.9:
+                    st['curr'] = 64.9
+                if st['curr'] > 72.73:
+                    st['curr'] = 72.73
+
+            else:  # side == 'louder'
+                # correct => toward standard (quieter) => -step
+                # incorrect => away (louder) => +step
+                st['curr'] += (-st['step'] if trial['correct'] else +st['step'])
+                if st['curr'] < 73.27:
+                    st['curr'] = 73.27
+                if st['curr'] > 81.1:
+                    st['curr'] = 81.1
+
+        # 2. Did we actually move?
+        actually_moved = (st['curr'] != old_curr)
+
+        if actually_moved:
+            # Normal PESt adaptation only if we escaped the boundary.
+
+            if st['last_dir'] != 0 and move_dir != st['last_dir']:
+                # reversal -> halve step (but not below min_step), reset consecutive counter
+                st['step'] = max(st['min_step'], st['step'] / 2.0)
+                st['same_dir'] = 0
+
+            else:
+                # same direction as last (or first informative move)
+                if st['last_dir'] == 0 or move_dir == st['last_dir']:
+                    st['same_dir'] += 1
+                else:
+                    # new direction but last_dir was 0 should already be covered above,
+                    # but keep a safe fallback
+                    st['same_dir'] = 1
+
+                # after two same-direction moves -> double step
+                if st['same_dir'] >= 2:
+                    st['step'] = st['step'] * 2.0
+                    st['same_dir'] = 0  # require two more same-direction moves for next doubling
+
+            # update last_dir ONLY when a real move happened
+            st['last_dir'] = move_dir
+
+        else:
+            # We hit a border and got clamped. Do NOT adapt step. Do NOT change same_dir. Do NOT touch last_dir.
+            pass
+
+        self.stair[side] = st
+        self.display_trial_feedback(trial['display_trial_feedback'], trial['correct'])
+        return trial