Today we will begin lab exercise concerned with EEG and ERP recording and analysis. In today's lab, you will learn how to carry out an ERP analysis.

• none

• none

Our primary goal today is to learn how to analyze EEG/ERP data using time domain signal averaging. You will become familiar with the concepts of signal averaging, time-voltage waveforms, and voltage-space plots (topographies). You will then explore how scalp ERP fields can be modeled to visualize the brain regions that likely generate those scalp-recorded voltage-space plots.

There are two parts to today's lab:

1. Use a simple Matlab script to observe signal averaging of an 'oddball' task (described below).
2. Learn to analyze ERP data using ERPLAB

We will use the analysis programs below for today's lab.

• EEGLab - a comprehensive toolbox of Matlab routines for analyzing EEG/ERP data.
• ERPLab - an ERP analysis toolbox that is integrated into EEGLab.

• For Part 1, we will be using data that were acquired in the Human Neuroscience Laboratory at Yale University.
  • ~/Desktop/eeg/oddball
• For Part 2, we will be using data made available as part of the ERPLAB tutorial (described in more detail below.
  • ~/Desktop/eeg/Test_Data

One of the unfortunate aspects of modern analysis programs is that all of the interesting stuff happens inside the code and is unobservable to the operator. I want you to understand what is happening when we signal average data. We will therefore 'manually' create event-related averages from a simple “Oddball” experiment.

This section of the lab should help you appreciate how/why signal-averaging helps to reveal the underlying components that make-up the event-related potential.

The data we will look at were collected in an “oddball paradigm” composed of two visual stimuli (letter strings) that were rapidly presented in random order. The XXXXX stimuli were presented at 80% probability while the OOOOO stimuli were presented at the complementary 20% probability. The participant's task was to covertly count each time a OOOOO target stimulus was presented. This task is sometimes referred to as an oddball task due to the low probability and irregular appearance of the target stimulus. The oddball stimulus usually evokes a large P300 ERP that, for simple visual stimuli, occurs 400-500 ms after the onset of the oddball. The frequent standard stimuli do not evoke a large P300, so comparing the target and standard will reveal the P300. The P300 is one of the first ERPs recognized to represent a cognitive process that was independent of the physical characteristics of the stimulus.

You will use two .mat (the Matlab file format) datasets that are in ~/Desktop/input/eeg/oddball; one contains all of the standard trials, and the other contains all of the target trials.

We will use a very simple Matlab demo script (written by Greg McCarthy) named disp_single_trials_2020.m. This program can be used to observe graphically the effects of signal processing.

1. Open Matlab and enter the following

edit '~/Desktop/scripts/disp_single_trials_2020.m'

The Matlab editor should open and you should see the code.

The code progresses through the following stages:

• A file containing a series of single trials (either the standard or the target trials) is opened.
• Each single trial is read from the file and added to a summing array.
• An average is created by dividing the summing array by the current number of trials summed
  • Stop and think about this for a second.
    • All we are doing is calculating the mean of the single trials.
    • We took the sum of all the single trials and divided by the total number of single trials.
    • As we add a new trial, we update the mean.
• The average is thus updated and displayed as each new trial is added.
• A separate .mat is written for the frequent (standard) and rare (oddball, aka targets) conditions.
  • The file names that include XXXXX contain the single peri-event epochs for standards
  • The file names that include OOOOO contain single peri-event epochs for targets.
    • “peri-event” simply means that the epoch was chose to include some time before (100 ms) and after (1000 ms) each event.
• The program first averages all of the frequent XXXXX stimuli, and then immediately starts averaging the rare oddball OOOOO stimuli.

When you start the program (don't run it yet though) you will see a window similar to the one below.

UPPER LEFT WINDOW: a raw single trial epoch. This single trial contains the small time-locked ERP signal as well as the large EEG signal that is not time-locked to the stimulus event.

UPPER RIGHT WINDOW: contains the same single trial epoch as the upper left plot except that the average ERP has been subtracted from this trial. Thus, it represents an EEG residual that should contain no time-locked ERP 'signal'. Instead, it should display only the 'noise'.

LOWER LEFT WINDOW: contains the running average of the single trial epochs that appear in the upper left plot as the program advances.

LOWER RIGHT WINDOW: contains the running average of the single trial residual epochs that appear in the upper right plot as the program advances.

1. To start the program, press the run button to get the program/script going:
   
   1. (READ THE NEXT PART, Average Across More Trials, BEFORE RUNNING THE SCRIPT)
      

To advance the program and look at more than 1 trial, hit any key (e.g., spacebar) in the main Matlab window. Your plot will advance a given number of trials & update the signal average as it does so.

As the program advances, it adds the current single trial epoch to the average epoch below it. With increasing numbers of trials added (and averaged) the ERP signal should becoming increasingly clear in the lower left plot.

The program is set to stop at the squares of 1 through 12 trials (i.e., 1,4,9,16,25,36,49,64,81,100,121,144). Because the Signal-to-Noise ratio improves by the square root of the number of trials averaged, this allows you to observe your signal after SNR improvements of 1, 2, 3, 4, etc.

Just hit any key (e.g., spacebar) to advance to the next integer squared. After trial 144, pressing any key will result in the program running all remaining trails.

The program will run automatically through the frequent (XXXXX) and rare oddball (OOOOO) data sets. At its conclusion, the program will create a new plot that shows the overlay of the final signal averages (ERPs) for the frequent XXXXXs (blue line) and rare oddball OOOOOs (red line). In this final plot, a more sensitive Y-axis microvolt scale will be used, so the ERPs will be plotted larger and more detail will be apparent.

EEGLab is a non-commercial, comprehensive EEG/ERP analysis program created at UC San Diego. EEGLab is a powerful program with many advanced features. Because EEGLab is written in Matlab and has an extensive function library, it is very easy to write Matlab scripts that call EEGLab functions. This allows labs to automate their procedures and simplifies the use of EEGLab.

ERPLAB Toolbox is a free, open-source Matlab package for analyzing ERP data. It is tightly integrated with EEGLAB Toolbox, extending EEGLAB’s capabilities to provide robust, industrial-strength tools for ERP processing, visualization, and analysis. A graphical user interface makes it easy for beginners to learn, and Matlab scripting provides enormous power for intermediate and advanced users.

In other words, once you've installed ERPLAB it basically works as if you've added extra features to EEGLAB. The goal is to give you an easy graphical interface to analyze ERP data.

This tutorial takes you step by step through the analysis of a set of ERP data from a subset of the subjects in a published experiment (Luck et al., 2009, Psychophysiology, 46: 776-786). It focuses on giving you experience with the specific steps involved in analyzing a simple prototypical ERP experiment. For details of the functions used here, see the ERPLAB Toolbox User's Manual.

The initial examples come from a published experiment. In this section, we will provide a basic overview of the experiment, along with a few of the details you will need to know to analyze it. For a complete description of the experimental paradigm, see the publication Luck et al., 2009, Psychophysiology, 46: 776-786.

This study examines the P3 wave and the lateralized readiness potential (LRP) in a group of schizophrenia patients and a group of matched control subjects. This tutorial focuses on the data from 6 of the control subjects (in the folders named S1 – S6). All subject identity information has been stripped from the data files.

In this experiment, a letter or digit was presented every 1300-1700 ms. Subjects were instructed to press a button with one hand for digits and with the other hand for letters. For a given trial block, either the letters or the digits were rare (20%) and the other category was frequent (80%). Thus, the stimulus category and the probability were counterbalanced. The probability manipulation was designed to isolate the probability-sensitive P3b component.

Different event codes were used for

• the digits when they were rare
• the digits when they were frequent
• the letters when they were rare
• the letters when they were frequent
• (The experiment also included a condition in which the two categories were equiprobable, but that condition is not included in this tutorial.)

The experiment was also designed to isolate the LRP by counterbalancing the stimulus category and probability with the left and right hand responses. That is, subjects responded to letters with the left hand and digits with the right hand for half of the experiment, and they responded to digits with the left hand and letters with the right hand for the other half. This is also indicated by the event codes for each stimulus (i.e., the event code for the stimulus also indicates the appropriate response for that stimulus).

ERPLAB Toolbox makes no distinction between stimulus event codes (i.e., the code sent concurrently with a stimulus) and response event codes (i.e, the code recorded concurrently with a participant's response). This gives the user more power, but it also gives the user responsibility for using the event codes in a sensible way. The event codes for responses in this example experiment indicated whether the response was correct (event code = 9) or incorrect (event code = 8) rather than directly indicating whether a left-hand or right-hand response was made. However, the combination of the stimulus event code and the response event code makes it possible to determine whether the subject pressed the left button or the right button.

Here is a table showing the stimulus event codes.

Letters and digits were presented in an unpredictable order within each trial block, but separate blocks were used for each combination of probability response assignment. That is, there were separate trial blocks for: (1) 80% letters (left-hand response) and 20% digits (right-hand response); (2) 20% letters (left-hand response) and 80% digits (right-hand response); (3) 80% letters (right-hand response) and 20% digits (left-hand response); (4) 20% letters (right-hand response) and 80% digits (left-hand response). Each block was originally recorded in a separate file.

Recordings were also obtained from a vertical electrooculogram (VEOG) electrode located beneath the left eye and from an electrode on the left earlobe (both referenced to the right earlobe). A horizontal electrooculogram (HEOG) signal was recorded as the potential between electrodes located just lateral to each eye.

1. Start EEGLAB

• Open Matlab.
• Navigate the current directory to the ~/Desktop/input/eeg/Test_Data/S1 folder.
• This is where the data from the first subject we will be processing is located.
• Enter the following into the command window

  • cd ~/Desktop/input/eeg/Test_Data/S1

• In the Matlab command window, type the following (each line followed by the return/enter key):

clear all
eeglab

This will start you with a fresh EEGLAB and ERPLAB session.

2. In the EEGLAB menu bar, select File → Load existing dataset

• Select the file S1_EEG.set and click the Open button.
  • Make sure EEGLAB is looking in the correct directory!

This will load the S1's data set into EEGLAB. The S1_EEG.set file is what EEGLAB calls a “dataset.” The associated file, S1_EEG.fdt, contains the actual EEG data points and must be present (but it is accessed indirectly). The dataset contains a large amount of information, and EEGLAB may take several seconds to load the dataset.

3. Confirm that the dataset has finished loading, by selecting the Datasets menu, as shown in the following screenshot:

Further confirmation that the S1_EEG.set has loaded can be found in the Matlab Command Window, EEGLAB will print an update on its current processing status. When the file has finished it will print “Done” (Both EEGLAB and ERPLAB print useful information such as this in the command window. Get in the habit of keeping an eye on this window.)

View the EEG data for the file you just loaded.

1. In EEGLAB, select Plot → Channel data (scroll) (See the EEGLAB documentation for information on the Channel data (scroll) function).

2. Click the » button twice to scroll forward in time (10 seconds each click).

• Event codes (aka stimulus markers, trigger codes) will appear in the EEG plot as vertical lines with their corresponding numbers:

3. Take a minute or two to get comfortable with the Scroll channel activities window. I often open this view before applying a routine, and then again afterward so that I can see what has been done to the data.

• What's on the x-axis?
• What's on the y-axis?
• Figure out how to change the axes. (the scale on x, and the scale on y)
• Note the values at the bottom of the screen that update as you hover the cursor in different locations.
• Etc.

    % Load S1_EEG.set
    % Filename is S1_EEG.set
    % Note that you will need to replace the path with the actual location in your file system
    % Make sure that your file names and folder names do not contain spaces or other special characters
    % Note that the dataset will not appear in the Datasets menu in the EEGLAB GUI
    EEG = pop_loadset('filename', 'S1_EEG.set', 'filepath',  '../Test_Data/S1/');
 
    %The following version will look for the file in Matlab's Current Folder
    EEG = pop_loadset('filename', 'S1_EEG.set');
 
    % To view the EEG data enter the following command:
    pop_eegplot(EEG);
 

Before we start using ERPLAB's functions, we'll use one of EEGLAB's functions that will prove useful at a later stage. Specifically, we will add location coordinates for each electrode site (see the EEGLAB documentation for more information). Our original data file contained electrode labels conforming to the International 10/20 System, and EEGLAB can automatically determine standard coordinates on the basis of these labels. These coordinates are not guaranteed to be exact, but they are a reasonable approximation for simple procedures such as plotting scalp maps.

1. To add coordinates based on the electrode labels, select Edit → Channel locations, which will bring up the window shown here:

2. Click Ok, and you will see the window shown here:

    %Adding Channel Locations to Dataset
    %Make sure that you change the path to indicate the location of eeglab within your file system
    EEG=pop_chanedit(EEG,'lookup',
    '/Users/etfoo/Documents/MATLAB/eeglab9_0_2_3b/plugins/dipfit2.2/standard_BESA/standard-10-5-cap385.elp');

3. For simple data files such as the one used in this tutorial, you can accept all of the default values and simply click OK. This will add the coordinates to the current dataset.

4. Test that channel locations have been successfully added. EEGLAB and ERPLAB require electrode coordinates for plotting topographic maps; you will get an error message if you try to plot a topographic map before you've added the coordinates. You can verify that the coordinates have been added by running a routine that plots topographic maps. For example, if you select Plot → Channel spectra and maps and select the default parameters in the window that appears, as shown in the screenshot below:

5. Click OK and you will see the following plot:

  <code matlab>
  %Plot Channel Spectra and maps
  figure; pop_spectopo(EEG, 1, [0  2139038], 'EEG' , 'percent', 15, 'freq', [6 10 22], 'freqrange',[2
  25],'electrodes','off');
  </code>

6. Later parts of this tutorial will make use of this dataset, so you should save it to disk. First, however, you should change the name of the dataset to S1_Chan so that you can differentiate between this version and the original version.

• Select Edit → Dataset info. This will bring up the window shown below.
• Enter S1_Chan in the Dataset name field.
• Click OK.
• Look in the Datasets menu. You should now see that it is named S1_Chan.

7. You can now save the modified dataset by selecting File → Save current dataset as. We recommend that you give the file the same name as the dataset, but with a .set extension (e.g., S1_Chan.set).

    %Setname is S1_Chan
    %Filename is S1_Chan.set
    %Path is /Users/etfoo/Desktop/tutorial_script/
    %Note that you will need to replace the path with the actual location in your file system
 
    EEG.setname='S1_Chan';
 
    EEG=pop_saveset(EEG, 'filename', 'S1_Chan.set', 'filepath', '/Users/etfoo/Desktop/tutorial_script/');
 
    %Alternatively, the following version will put the file in Matlab's Current Folder
 
    EEG.setname='S1_Chan';
 
    EEG=pop_saveset(EEG, 'filename', 'S1_Chan.set');

There are a few key concepts you need to understand before we go any further.

EEGLAB stores a set of EEG data in something called a dataset. A dataset typically stores the data from a single subject, either a single block of trials or an entire session. A dataset is maintained in memory inside EEGLAB, and it can also be saved on disk. Whenever you run a routine that changes the data in a dataset, a new dataset is created. You can see the currently available datasets in the Datasets menu. One dataset is currently active, and any routines that you run will typically be applied to the current dataset. When a new dataset is created, it becomes the current dataset, but you can make a different dataset active by selecting it in the Datasets menu. This provides a very convenient workflow.

ERPLAB defines an analogous structure called an ERPset, which stores a set of ERP waveforms. They can be active inside ERPLAB and/or saved to disk. The ERPsets menu can be used to see which ERPsets are currently loaded into ERPLAB and to change which ERPset is active.

A bin is a set of averaged ERP waveforms, one for each electrode site, which were created by averaging together a specific set of EEG epochs. A simple oddball experiment, for example, might have one bin for the infrequent targets and another bin for the frequent standards. However, a sophisticated experiment might have dozens of different bins, with a given bin being something like “Digits preceded by letters followed by a correct response between 200 and 1000 ms, in a condition in which digits are rare and letters are frequent.” In many ERP analysis systems, a bin would be equivalent to a single averaged ERP file. However, this can lead to a huge number of different files for each subject, making it difficult to keep track of everything. In ERPLAB, an ERPset can contain an unlimited number of bins), and each data processing operation is typically applied to all of the bins in the currently active ERPset. This saves time and reduces errors.

We are now ready to get into the ERPLAB functions. We will begin with some housekeeping, then do artifact rejection, and finally averaging.

When you create an EventList, you can add some additional information using the ADVANCED button in the Create EventList window (see screenshot below). The ADVANCED tools are important if you have complex text-based event labels (or want to create them) or if you have a very simple scheme that links event codes to bins. Most people won't use the ADVANCED button, but it is important for the present tutorial.

The ADVANCED button allows you to define a text label for each numeric event code (or vice versa), which helps to avoid the errors that often occur in experiments with many different event codes. It also allows you to define the bins that you will use to sort your EEG epochs for averaging.

1. Make sure that S1_Chan is selected as the active dataset in the Datasets menu (because we are going to re-create the eventless).

• Select ERPLAB → EventList → Create EEG EventList.
• You might get a yellow warning window about numeric codes. If so, just click Continue.

2. Click the Advanced button to open the Create Advanced EventList window.

The Create Advanced EventList panel allows you to define a set of events for the experiment. Each event contains a numeric event code and text-based event label, as well as an optional bin number and bin label.

3. Define this information for a single trial block from our example experiment. Enter the following information into the Event Info area (upper right corner) of the Create Advanced EventList window:

4. Click the Update Line button to add the event information to the Currently edited eventcodes list (left pane).

• For each event, the Event Info area defines the event codes, event labels, bin numbers, and bin descriptions for each event.
• In our experiment, letters were rare (event code 12) and numbers were frequent (event code 22).

5. Next, define the rare letter event. Click on the new line entry in the Currently edited eventcodes pane. Enter the following information for the rare letter event:

It will still be useful to define labels for the response codes so that we will not have to remember that code 9 denotes a correct response and code 8 denotes an incorrect response. The table below shows how to define these events.

6. Save the event code equation list in the Equation List pane (bottom-left)

• Click on the Save list button
• Navigate to your save directory and type in the filename: elist_equations.txt
• Click the Save button. The save file name and path should now appear in the Equation List pane.

7. Save the EventList in a text file (to look at it later) Locate the Write resulting EVENTLIST pane in the bottom-right corner

• Check the box labeled Text File
• Click the Browse button to save the file as elist.txt. (The .txt extension is not required, but it's a good idea)
• Check the box labeled Transfer EVENTLIST info to EEG.event if it's not already checked.

EEGLAB keeps track of event information in the EEG.event structure, but EEGLAB doesn't automatically “know” anything about ERPLAB's EventList. Moreover, the EEG.event structure can store either a numeric event code or a text-based event label for a given event, but not both. By checking this box, you will have the opportunity to transfer your newly created labels into EEG.event so that they will be available for use by EEGLAB functions (such as the function for plotting the EEG data).

9. Apply the EventListClick the APPLY button to create the EventList and add it to the current ERP dataset.

The information about event mapping must be stored in a file. Therefore, if you have made any changes in this information, the following window will appear:

10. Click on the Save and Continue button to create the EventList. Because we have checked the Transfer EVENTLIST info to EEG.event box), the following window will appear:

This window allows you to choose whether to store the events as event codes, event labels, or bin numbers in the EEG.event structure). The default is Code Labels, and selecting this will allow you to see the labels for each event code when you look at the EEG using EEGLAB's Plot → Channel data (scroll) routine. Keep the default Code Labels setting and click the APPLY button.

ERPLAB will then attach the EVENTLIST structure that you just created to the current dataset to produce a new dataset. Any operation that creates a new dataset will put up the save dataset window shown in the next screenshot.

% The first step is to create a file named elist_equations.txt with the following contents:
%   22 "Frequent_Digit"     1     "Frequent Category (Digit)"
%   12 "Rare_Letter"        2     "Rare Category (Letter)"  
%    9 "Corr_Resp"          []    ""      
%    8 "Err_Resp"           []    ""
%
% The following command creates the event list using these equations, using a fully specified path
% A text file with the event list saved in elist.txt in the same path
EEG = pop_editeventlist(EEG,'/Users/etfoo/Desktop/tutorial_script/elist_equations.txt', 'elist.txt', {'boundary'}, {-99});
% The following command uses Matlab's Current Folder
EEG = pop_editeventlist(EEG,'elist_equations.txt', 'elist.txt', {'boundary'}, {-99});
% Copy event labels into the EEG structure
EEG = pop_overwritevent( EEG, 'codelabel');

11. Specify a name and save your new dataset

• Check the Save it as file box
• Click the Browse button and select a save directory
• Specify the filename S1_Chan_elist
  • click the Save button

This name will be stored inside the dataset, and it will be shown in the Datasets menu.

The dataset will then be saved to disk. You can also choose to either keep the previous dataset in the Datasets menu (this is the default) or overwrite the previous dataset in this menu.

12. You should save the new dataset to a file, named S1_Chan_elist.set, but don't overwrite the old dataset. Click OK, and the new dataset will be created (this may take a few seconds). Once the new dataset has been created (you will see “Done” printed in the Matlab command window), you will be able to see it in the Datasets menu, as shown in the next screenshot.

% Saving after Eventlist
% Setname is S1_Chan_elist
% Filename is S1_Chan_elist.set
% Path is /Users/etfoo/Desktop/tutorial_script/
% Note that you will need to replace the path with the actual location in your file system
EEG.setname='S1_Chan_elist';
EEG=pop_saveset(EEG, 'filename', 'S1_Chan_elist.set', 'filepath', '/Users/etfoo/Desktop/tutorial_script/');
 
% The following command uses Matlab's Current Folder
EEG.setname='S1_Chan_elist';
EEG=pop_saveset(EEG, 'filename', 'S1_Chan_elist.set');

1. You will now be able to see that the previous event code numbers have now been replaced by their event labelsIn EEGLAB, select Plot → Channel data (scroll) and scroll ahead to the period starting at 10 seconds (hit the » button twice)

The standard EEGLAB routine only provides room for about 10 characters, so some of the labels are truncated.

2 Optional: You can modify the number of characters shown in the plotting function.

• Within the plotting window, select Settings > Events > Events String Length
  • Note: Do this within the plotting window and not from the main EEGLAB window
• Enter a width of 20 characters to make the plot will look like this:

3. View the data.

• Scroll through the data for a while.
• You might want to change Settings → Time range to display to 30 seconds (within the plotting window).
• Eventually (around 120 seconds) you will see a period with no event codes and lots of artifacts. This is a short rest break about ¼ of the way through the trial block. You'll see another period like this at 255 seconds and 390 seconds.
• The trial block ended at approximately 525 seconds and the file ended at 535 seconds. You will see a boundary event label at this point, which is where the second trial block was appended after the first trial block.

If you're interested, you can take a look at the text version of the EventList that you created. Simply open this file with the Matlab text editor. For details on the contents and format of this file, see the ERPLAB User's Manual. Later on we will show how you can edit this file and import it back into your EEG data.

The next step after creating the EventList is usually to sort the events into different bins (in preparation for averaging). However, we already did this by assigning bins for the rare and frequent stimuli when we created the EventList using the Advanced button.

Once the events have been assigned to bins, the next step is to divide the continuous EEG into a set of fixed-length epochs (aka segments or sweeps), each of which is time-locked to an event that has been assigned to a bin. In the present example, we will extract the EEG during a period that begins 200 ms prior to the onset of a stimulus and ends at 800 ms after the onset of the stimulus. This will be done for each event code that has been assigned to a bin (which is, in the present example, the frequent letters and rare digits, but not the responses).

1. In ERPLAB, select ERPLAB → Extract Bin-based Epochs. This will open the Extract Bin Epochs window:

    % Create Bin-Based EEG Epochs
    % Extracts bin-based epoch from -200 ms to +800 ms
    % 'pre' means use the prestimulus period for baseline correction
    % Use 'post' to use the poststimulus period for baseline correction
    % Use 'all' to use the poststimulus period for baseline correction
    % Use two numbers in quotes (e.g., '-150 +50') to specify a custom interval for baseline correction
    EEG = pop_epochbin( EEG , [-200.0  800.0], 'pre')
 

The Extract Bin Epochs window allows you to select the time period for the epoch (relative to the event code). Baseline correction will be enabled by default (see box below), and you will almost always want to do this. The prestimulus period (Pre) is usually the period used for baseline correction. Alternatively, you can use the poststimulus interval (Post), the entire interval (Whole), or some time range of your choice (Custom).

2. For this example, leave Pre as selected.

• Click the RUN button
• A new dataset with the epoched data will be created (it will take a few seconds). The standard window for saving a new dataset will appear.

3. By default the new dataset will be namedS1_EEG_elist_be (“be” stands for bin-epoched).

• Click the checkbox next to Save it as a file and then click Browse
• Enter the filename S1_EEG_elist_be
• Click Ok

    % Saving after Epoching
    % Setname is S1_EEG_elist_be
    % Filename is S1_EEG_elist_be.set
    % Path is /Users/etfoo/Desktop/tutorial_script/
    % Note that you will need to replace the path with the actual location in your file system
    EEG.setname='S1_EEG_elist_be'
    EEG=pop_saveset(EEG, 'filename', 'S1_EEG_elist_be.set', 'filepath', '/Users/etfoo/Desktop/tutorial_script/');
 
    % The following command uses Matlab's Current Folder
    EEG.setname='S1_EEG_elist_be';
 
    EEG=pop_saveset(EEG, 'filename', 'S1_EEG_elist_be.set') 
 

4. Make sure that this new dataset is the active dataset (by looking in the Datasets menu).

• Select Plot ⇒ Channel data (scroll).

The following screen shows what it should look like. There should still be continuous EEG data, but if you look more closely you will see a vertical dashed line 800 ms after (and 200 ms before) each event. This dashed line marks the end of one epoch and the beginning of the next. If you find this disconcerting, you can simply change Settings → Time range to display to a period of 1 second (in the plotting window).

Because the epoch length in this experiment is shorter than the interval between consecutive stimuli, the epoched data will now be missing a period of time between the end of one epoch and the beginning of the next epoch. If, however, we used a 2000-ms epoch length, the last part of one epoch would contain the same EEG data as the beginning part of the next epoch.

The next step after epoching is usually artifact detection. ERPLAB makes a distinction between artifact detection and artifact rejection.

• Artifact detection is the process of marking epochs that contain artifacts.
• Artifact rejection is the process of excluding trials containing artifacts.

The ERPLAB artifact detection routines do not throw out any data; epochs with artifacts are merely marked. Artifact rejection occurs during averaging; marked epochs are simply excluded from the averaging process.

There are lots of different ways to define artifacts. Some require expert eyeballs manually reviewing the data, whereas others rely on automatic algorithms. Below, we'll try a couple such algorithms.

We will start with moving window peak-to-peak threshold.

1. Make sure that your epoched dataset is active (“S1_EEG_elist_be”)

2. Select ERPLAB → Artifact detection in epoched data → Moving window peak-to-peak threshold.

• You will see the window shown in the screenshot below.

This routine finds the maximum peak-to-peak voltage within a moving window that slides across the epoch (see the ERPLAB User's Manual for details). You select the Test period, which is by default the entire epoch. However, sometimes you will want to search for artifacts only during a portion of the epoch.

You must also choose a Voltage threshold. An epoch will be rejected if the peak-to-peak voltage (the difference between the largest and smallest values) exceeds this value. The appropriate value will depend on the nature of the artifact you are trying to reject and how large it is in a given subject (see Chapter 4 in An Introduction to the Event-Related Potential Technique for an overview of artifact detection).

You will then choose the length of the Moving window and the Window step. This routine finds the peak-to-peak voltage within a window of the length specified in the Moving window field. It then shifts the window by the amount specified in the Window step field and finds the peak-to-peak voltage within this new window. This is repeated until the end of the Test period, and the largest of these peak-to-peak amplitudes is compared with the Voltage threshold. This is an excellent way to find artifacts in which the voltage changes rapidly within a relatively short period of time (e.g., blinks, which usually peak and then subside within 200-300 ms) and not be fooled by relatively slow voltage changes.

By default, artifacts will be detected in all channels. However, you can specify a subset of channels to be tested in the Channel(s) field.

3. Set all of the fields as shown in the screenshot above (including ensuring the Open viewer box is checked)

• Click on Mark Flag 4
• Click Accept

ERPLAB will then scan the active dataset for artifacts (which may take some time). The total percentage of trials with artifacts detected (i.e., the total percentage marked for rejection, including epochs that had been marked previously) will be shown in the Matlab command window:

pop_artmwppth() rejected a 29.7 % of total trials. 

At this point, the ERPLAB artifact rejection routines automatically bring up the scrolling EEG data viewer window, as shown in the screenshot below.

4. Scroll through the data to make sure that the parameters you entered have actually caused epochs containing artifacts to be detected without accidentally marking a large number of epochs without true artifacts.

• For example, you may need to increase the threshold if epochs without real artifacts are being marked for rejection, and you may need to decrease the threshold if epochs with clear artifacts are not being marked.
• Each epoch that has been marked is shown with a yellow background, and the channels within the epoch that exceeded the rejection threshold are drawn in red (see screenshot below).
• Artifact rejection is all-or-none; the entire epoch is discarded if an artifact is detected in one or more channels in that epoch.

The window for saving the newly created dataset is also brought up at this point. The idea is that you will scan through the dataset, and either save it (if everything looks OK) or click on CANCEL (if you want to change the parameters and try again).

5. Once you have finished looking at the data, click OK in the window for saving the dataset if you are satisfied with the artifacts that were detected (it will be named “S1_EEG_elist_be_ar”).

    % Artifact Detection with Moving window peak to peak threshold
    % Test period [-200 798]. Voltage threshold 100uV
    % Moving window width: 200 ms. Window step: 50. Channels 1:16
    % Mark flags 1 and 4 (you must always mark flag 1
     EEG = pop_artmwppth( EEG, 'Channel' , 1:16, 'Flag' , [1 2]. 'Threshold', 100 ...
                   , 'Twindow', [-200798], 'Windowsize' , 200, ' Windowstep' , 50);
    % The script-based routine does not show you the data. To see the data, do this:
    pop_eegplot(EEG);
 
    % Now we will save the dataset
    % Setname is S1_EEG_elist_be_ar
    % Filename is S1_EEG_elist_be_ar.set
    % Path is /Users/etfoo/Desktop/tutorial_script/
    % Note that you will need to replace the path with the actual location in your file system
    EEG.setname='S1_EEG_elist_be_ar';
    EEG=pop_saveset(EEG, 'filename', 'S1_EEG_elist_be_ar.set', 'filepath', '/Users/etfoo/Desktop/tutorial_script/');
 
    %The following command uses Matlab's Current Folder
    EEG.setname='S1_EEG_elist_be_ar';
    EEG=pop_saveset(EEG, 'filename', 'S1_EEG_elist_be_ar.set');  

If, at some later time, you want to see how many trials have been marked for rejection in a given dataset, you can select ERPLAB → Summarize artifact detection → Summarize EEG artifacts in a table. This will print a table of the number of trials marked for rejection in each bin, along with the number of occurrences of each flag (which ordinarily corresponds to different types of artifacts). In our example, it should look like this if you print the table in the command window:

You can also get this information after averaging with ERPLAB → Summarize artifact detection → Summarize ERP artifacts in a table.

We are now (finally!) ready to create a set of averaged ERP waveforms.

1. Make sure that the correct dataset is active, S1_EEG_elist_be_ar, which has been epoched and scanned for artifacts with the Moving Window peak-to-peak threshold artifact detection function).

    % Load S1_EEG_elist_be_ar.set
    EEG = pop_loadset( 'filename', 'S1_EEG_elist_be_ar.set', 'filepath', '/Users/etfoo/Desktop/tutorial_script/');
 
    % The following command uses Matlab's Current Folder
    EEG = pop_loadset('filename', 'S1_EEG_elist_be_ar.set');  

2. select ERPLAB → Compute Averaged ERP. This will bring up the very simple window shown below.

You will normally average the data in the current dataset, which is listed by default in the Dataset(s) field. You also can specify multiple datasets and average across them as if all the epochs were stored in a single dataset. In this tutorial, we will just average the epochs from a single dataset

3. Click RUN

    % Compute Averaged ERP
    % To average the data from dataset 5, whether or not it is selected, use the following:
    ERP = pop_averager( ALLEEG , 'Criterion', 1, 'DSindex',  5, 'Stdev', 'on');
 
    % To average the data from datasets 3-5, use the following:
    ERP = pop_averager( ALLEEG , 'Criterion', 1, 'DSindex', 3:5, 'Stdev', 'on');
 
    % In all of these examples, the 'Criterion' argument specifies how artifacts should be treated:
    %             1 – Exclude trials with artifacts (as in these examples)
    %             0 – Include all trials (ignore artifact flags)
    %             2 – Include ONLY trials with artifacts </WRAP>

The averaging routine will print some useful information in the Matlab command window, as shown in the screenshot below. Specifically, it will show the percentage of trials that were excluded because of artifacts and because of invalid trials (e.g., epochs with boundary events within them; invalid trials should be rare). This information is provided both collapsed across bins and separately for each bin.

When the averaging routine is finished, it will display the window shown below, which allows you to name and save the ERPset that was created. This window is shown every time an ERPLAB function modifies or creates an ERPset. If one or more ERPsets were already loaded, you would have the option of overwriting the previously active ERPset or creating a new ERPset (you will usually want to create a new one – ERPsets are usually much smaller than datasets, and you will not usually run out of RAM because of ERPsets). In this case, however, no other ERPsets are present, so you will be creating a new ERPset.

4. You should name the ERPset “S1_ERPs”.

• This is the name that will be shown in the ERPsets menu.
• You will usually want to save the results of averaging in a file on disk, so select the Save ERP as button and give the file the same name as the ERPset name. You can do this easily by clicking the same as erpname button.
  • The file will be saved in Matlab's current directory unless you either specify an alternative path or use the Browse button.
• You can click the OK button once you have set up the window as shown in the screenshot below.

You can now see the newly created ERPset in the ERPsets menu, as shown in the screenshot below.

    % Setname  is S1_ERPs
    % Filename is S1_ERPs.erp
    % Path is /Users/etfoo/Desktop/tutorial_script/S1_ERPs.erp
    % Note that you will need to replace the path with the actual location in your file system
    ERP = pop_savemyerp( ERP, 'erpname', 'S1_ERPs.set','filename', 'S1_ERPs.erp' ...
                   , 'pathname', '/Users/etfoo/Desktop/tutorial_script/');
 
    % The following command uses Matlab's Current Folder
    ERP = pop_savemyerp( ERP, 'erpname', 'S1_ERPs.set', 'filename', 'S1_ERPs.erp');

Now that you have created an ERPset, you can look at its contents by plotting it.

1. Select ERPLAB → Plot ERP → Plot ERP Waveforms, which brings up the window shown in the next screenshot.

• The top half of the window allows you to specify what information to plot (bins, channels, etc.)
• the bottom half allows you to control the details of the plotting (vertical scale, line width, font size, etc.).
• The window will remember the settings from the last time you used it, but you can revert to the default settings by clicking the RESET VALUES button.

2. Click the PLOT button with the default values, and you should see the following window pop up:

    % Plotting Averaged ERP Waveform
    % Bins to plot [1,2], Channels to plot [1:16],
    % Pre Baseline Correction, Rows 4, Columns 4, Channels 10, Legends 10
    % Line width 1, Time range [-200 798],
    pop_ploterps( ERP, [ 1, 2],1:16 , 'AutoYlim', 'on', 'Axsize', [ 0.05 0.08], 'BinNum', 'on'                ...
            , 'Blc', 'pre', 'Box', [ 4 4], 'ChLabel', 'on', 'FontSizeChan',10, 'FontSizeLeg',10           ...
            , 'LegPos', 'bottom', 'Linespec', {'k-' , 'r-' }, 'LineWidth',1, 'Maximize', 'on'             ...
            , 'Position', [ 102.833 9.375 108.667 35.125], 'Style', 'Matlab'                              ...
            , 'xscale', [ -200.0 798.0 -100:170:750], 'YDir', 'normal', 'yscale', [ -10.0 10.0 -10:5:10]  );
 
    % Note that an ellipsis (...) can be used to break a long function call across multiple lines
    pop_ploterps( ERP, [ 1, 2],1:16);  

Note that in the plotting window, ERPLAB provides a custom toolbar that provides a set of buttons to ERPLAB functions. Play around with it and you should be able to figure out how it works.

Perhaps the most useful tool is the Data cursor (the icon with the small plus mark), which allows you to click on the waveform and see the X and Y values (time and voltage) at that point on the waveform.

If you click on one of the panels (e.g., the panel for the Cz electrode site), a new window will open showing an expanded version of that panel, as shown in the screenshot below. (NOTE: this won't work if the Data cursor button is depressed)

There are many things you can do with the Plotting Waveform GUI. For example, you could plot a single column with multiple channels. For example, set Channels to plot to 1:4, set Row(s) to 4, and set Column(s) to 1. You will see something like this:

ERPLAB contains a set of filters that can be applied to continuous EEG, to segmented EEG, and to averaged ERPs. Separate routines are used for filtering EEG (ERPLAB → Filter & Frequency Tools → Filters for EEG data) and for filtering ERPs (ERPLAB → Filter & Frequency Tools → Filters for ERP data). The routines are nearly identical, except for a few options. We will start by discussing the filtering of averaged ERPs.

1. Make sure that “S1_ERPs” is selected in the ERPsets menu, and then select ERPLAB → Filter & Frequency Tools → Filters for ERP data.

• You will see a window similar to the screenshot below. This window allows you to set various properties of the filter.
• First, you can determine whether to apply a low-pass filter (filtering out high frequencies) and/or a high-pass filter (filtering out low frequencies).
  • For each of these, you can select the 50% amplitude cutoff point by typing a number in the corresponding text field or by adjusting the sliders.
  • You can also adjust the slope of the filter's roll-off in the Roll-off & filter order panel in units of decibels per octave (dB/oct) or in units decibels per decade (dB/dec) or in terms of the filter's order (if you change one, the others will automatically change).

You can see the frequency response function of the resulting filter (the extent to which each frequency is passed by the filter) in the graph at the top of the window (assuming that the Plot panel is set to Frequency response). Try playing around with the various filter parameters to see how it changes the frequency response function.

2. As an example, select ERPLAB → Filter & Frequency Tools → Filters for ERP data and set up the filter as shown in the screenshot above

• no high-pass filter
• a low-pass half-amplitude cutoff at 30 Hz
• a roll-of of 12 dB/octave
• a Butterworth filter type
• all 16 channels being filtered.

3. Click APPLY.

After the filtered data have been created, the standard window for saving new ERPsets will appear, and you should name the new ERPset “S1_ERPs_30Hz” (it's a good idea to save the ERPset to disk, because we will need this file for another example later). This will now be the active ERPset. If you plot it with ERPLAB → Plot ERP Waveforms, the result will look like the following screenshots (you should also plot the unfiltered data for comparison).

%Basic Filtering for ERP
    %Channels [1:16], High pass 0, Low pass 30, Order 2, IIR Butterworth
    ERP = pop_filterp( ERP,1:16 , 'Cutoff',30, 'Design', 'butter', 'Filter', 'lowpass', 'Order',2 );
    %Setname is S1_ERPs_30Hz.set
    %Filename is S1_ERPs_30Hz.erp
    %Path is /Users/etfoo/Desktop/tutorial_script/S1_ERPs_30Hz.erp
    ERP = pop_savemyerp(ERP,
    'erpname',
    'S1_ERPs_30Hz.set',
    'filename',
     'S1_ERPs_30Hz.erp',
     'pathname',
     '/Users/etfoo/Desktop/tutorial_script/',
     'warning',
     'on');
    %The following command uses Matlab's Current Folder pop_savemyerp(ERP, 'erpname', 'S1_ERPs_30Hz.set', 'filename', ' S1_ERPs_30Hz.erp')  

Now let's try filtering continuous EEG data.

1. Make “S1_Chan” the active Dataset (loading it with File → Load existing dataset if necessary). Select ERPLAB → Filter & Frequency Tools → Filters for EEG data and set the parameters as shown in the screenshot below.

• high-pass filter with a cutoff at 0.1 Hz
• low-pass filter with a cutoff at 30 Hz.
  • You should check the boxes for applying the filter to segments defined by boundary events (which you should always check unless you really know what you're doing) and for removing the mean value (which you should always do with DC recordings and which won't hurt for non-DC recordings). The ERPLAB User's Manual provides more details.

2. Once you've set the parameters, click APPLY. The filtering will take a little while.

3. Once it prints Done in the Matlab command window, use Plot → Channel data (scroll) to see the filtered data, which should look like the screenshot below.

%Load S1_Chan from the current folder
    EEG = pop_loadset( 'filename', 'S1_Chan.set');
    %Basic Filtering for EEG with High pass
    %Channels 1:16, High-Pass 0.1, Low-Pass 30, Order 2,
    %IIR Butterworth, Apply filter to segments defined by boundary events
    %Boundary event code 'boundary'
    EEG  = pop_basicfilter( EEG,  1:16 , 'Boundary', 'boundary', 'Cutoff', [ 0.1 30], ...
    'Design', 'butter', 'Filter', 'bandpass', 'Order',  2, 'RemoveDC', 'on' );

Another way we can look at our results is by plotting scalp voltage maps (aka topgographic or topo maps). These maps show the responses across the entire scalp at a single point in time or the average over a window of time. As with the ERP waveforms, ERPLAB makes it easy to plot these scalp maps.

1. Select ERPLAB → Plot ERP → Plot ERP scalp maps, which brings up the window shown in the next screenshot.

• The top half of the window allows you to specify what information to plot (bins, channels, etc.)
• the bottom half allows you to control the details of the plotting (vertical scale, line width, font size, etc.).
• The window will remember the settings from the last time you used it, but you can revert to the default settings by clicking the RESET VALUES button.

To plot a set of topographic maps, you start by selecting what kinds of values to plot. The options are:

• Instantaneous amplitude - The amplitude at a single time point (e.g., 300 ms)
• Mean amplitude between two fixed latencies - The mean voltage in a time period (e.g., 300-400 ms)
• Instantaneous amplitude Laplacian - Surface Laplacian plot of instantaneous amplitude
• Mean amplitude Laplacian - Surface Laplacian plot of mean amplitude
• Root mean square value - This is the RMS voltage over a specified time range

For instantaneous amplitude, you provide a set of one or more latencies in the Latencies to plot text box (e.g., “100 150 200 250 300” or equivalently “100:50:300”). For mean or RMS amplitude, you provide one or more sets of time periods. For example, you would specify 300 450 to plot the scalp distribution of the mean voltage between 300 and 450 ms. You can also specify multiple time periods, separated by semicolons (e.g., “200 300 ; 300 400; 400 500” to plot maps of mean amplitude from 200-300, 300-400, and 400-500).

There are several options for determining the scale of the maps. If you select Max-Min, the routine automatically chooses a scale for each bin on the basis of the minimum and maximum voltages found in that bin (e.g., the chosen scale might go from -4 µV to +9 µV). If you select Abs Max, the routine finds the minimum and maximum values, and creates a symmetrical scale depending on which has a greater absolute value (e.g., the chosen scale might go from -9 µV to +9 µV). For these two options, each bin is scaled separately. A third option is Custom, which allows you to specify the minimum and maximum values (e.g., you might put -5 +5 in the text box). In this case, the scale is the same for each bin. There are a variety of additional plotting options (e.g., turning on or off electrode markers) that are accessed with the Options button.

2. If you go back and look at the waveforms you plotted, you'll notice that the P3 was largest roughly between 300 and 600 ms post-stimulus. So …

• set Bin(s) to plot to 1 2
  • Here we saying to plot topo maps of the frequent bin and the rare bin
• set Value to plot to mean amplitude between two fixed latencies
• set Latency(ies) to plot in ms to 300 600
• set Color bar scale to Custom -6 6
  • I've chosen these values because I know what the results look like. Obviously, in reality that wouldn't be the case and you'd have to explore which scales best display the results.
• click PLOT and you should get something like the figure below

You can also choose between 2D maps (which always use a top viewpoint) and 3D maps (which allow you to specify the viewpoint). If you want to try it …

• set Bin(s) to plot to 1 2
• set Value to plot to mean amplitude between two fixed latencies
• set Latency(ies) to plot in ms to 300 600
• set Color bar scale to Custom -6 6
• change Map type to 3D
  • click on spline
  • click on Create new spline file and save it as
    • In this text box just enter spline (or whatever, really)
  • click OK
• click PLOT and you should get something like the figure below

Cool, right?