eegdash 0.0.1__py3-none-any.whl

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/intan/ReadIntanSpikeFile.py

@@ -0,0 +1,140 @@
+import os, struct
+
+import tkinter as tk
+from tkinter import filedialog
+
+import matplotlib.pyplot as plt
+
+# Version 3.0, 11 February 2021
+
+# Reads spike.dat files generated by Intan Technologies RHX data acqusition
+# software.  Data are parsed and placed into variables within the Python workspace.
+# Therefore, it is recommended to add either saving these variables to disk or
+# any plotting or processing of the data at the end of readIntanSpikeFile, before
+# those variables are removed when execution completes
+
+# Spike data from N channels are loaded into an N x M list named
+# 'spikes', where M = 5 if spike snapshots were saved, otherwise M = 4.
+# The first column of spikes contains native channel names.  The second
+# column contains custom channel names.  The third column contains spike
+# timestamps.  The fourth column contains spike ID numbers (128 = likely
+# artifact due to amplitude exceeding threshold set in Spike Scope).  All
+# normal spikes have a spike ID of 1.  Future versions of the RHX software
+# may support realtime spike sorting, and in this case spike ID will
+# denote different identified spikes (1, 2, 3, etc.).  If spike snapshots
+# were saved then they are contained in the fifth column.
+
+def readString(fid):
+    resultStr = ""
+    ch, = struct.unpack('<c', fid.read(1))
+    while ch != b'\0':
+        resultStr = resultStr + str(ch, "utf-8")
+        ch, = struct.unpack('<c', fid.read(1))
+    return resultStr
+
+def readIntanSpikeFile(option):
+
+    noArtifacts = 0
+    if option == "noartifacts":
+        noArtifacts = 1
+
+    print("Select a Spike Data File")
+    root = tk.Tk()
+    root.withdraw()
+    fullFileName = filedialog.askopenfilename()
+    if not fullFileName:
+        print("Canceled")
+        return
+
+    # Open data file
+    fid = open(fullFileName, 'rb')
+    filesize = os.path.getsize(fullFileName)
+
+    # Check 'magic number' at beginning of file to make sure this is an Intan
+    # Technologies spike data file.
+    multichannel = 0
+    magicNumber, = struct.unpack('<I', fid.read(4))
+    if magicNumber == int('18f8474b', 16):
+        multichannel = 1
+    elif magicNumber == int('18f88c00', 16):
+        multichannel = 0
+    else:
+        raise Exception('Unrecognized file type.')
+
+    spikeFileVersionNumber, = struct.unpack('<H', fid.read(2))
+
+    if (spikeFileVersionNumber > 1):
+        print("Warning: This spike file version is not supported by this file reader.")
+        print("Check the Intan Technologies website for a more recent version.")
+
+    filename = readString(fid)
+    channelList = readString(fid).split(",")
+    customChannelList = readString(fid).split(",")
+
+    sampleRate, = struct.unpack('<f', fid.read(4))
+
+    samplesPreDetect, = struct.unpack('<I', fid.read(4))
+    samplesPostDetect, = struct.unpack('<I', fid.read(4))
+    nSamples = samplesPreDetect + samplesPostDetect
+
+    if nSamples == 0:
+        snapshotsPresent = 0
+    else:
+        snapshotsPresent = 1
+
+    N = len(channelList)
+
+    spikes = [[] for _ in range(N)]
+    for i in range(N):
+        spikes[i].append(channelList[i]) # 0: native channel name
+        spikes[i].append(customChannelList[i]) # 1: custom channel name
+        spikes[i].append([]) # 2: single-float timestamp
+        spikes[i].append([]) # 3: uint8 spike ID
+        if snapshotsPresent:
+            spikes[i].append([]) # 4: single-float snapshot
+
+    while (filesize - fid.tell() > 0):
+        if multichannel:
+            channelName = ""
+            for charIndex in range(5):
+                thisChar, = struct.unpack('<c', fid.read(1))
+                channelName = channelName + str(thisChar, "utf-8")
+            for i in range(N):
+                if spikes[i][0] == channelName:
+                    index = i
+                    break
+        else:
+            index = 1
+
+        timestamp, = struct.unpack('<i', fid.read(4))
+        spikeID, = struct.unpack('<B', fid.read(1))
+
+        if (snapshotsPresent):
+            snapshot = list(struct.unpack("<%dH" % nSamples, fid.read(2 * nSamples)))
+
+        if spikeID == 128 and noArtifacts:
+            continue
+
+        timestampSeconds = timestamp / sampleRate
+
+        spikes[index][2].append(timestampSeconds)
+        spikes[index][3].append(spikeID)
+        if snapshotsPresent:
+            snapshotMicroVolts = [0.195 * (float(snapshotSample) - 32768.0) for snapshotSample in snapshot]
+            spikes[i][4].append(snapshotMicroVolts)
+
+    # Close data file
+    fid.close()
+
+    if snapshotsPresent:
+        tSnapshot = [(sample - samplesPreDetect) / sampleRate for sample in range(nSamples)]
+
+    # Just for demonstration, take the plot the 2nd (N = 1) channel's list of snapshots (snapshots are always
+    # in the fifth column M = 4). Grab the 6th snapshot present (list index = 5) and plot it
+    secondChannelSnapshots = spikes[1][4]
+    plt.plot(tSnapshot, secondChannelSnapshots[5])
+    plt.show()
+
+# If the function is called with the "noartifacts" parameter, all spikes with spike ID = 128 are ignored.
+readIntanSpikeFile("artifacts")
+#readIntanSpikeFile("noartifacts")

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/intan/intan_read_adapter.py

@@ -0,0 +1,29 @@
+from signalstore.operations.importers.adapters.abstract_read_adapter import AbstractReadAdapter
+
+
+class IntanReadAdapter(AbstractReadAdapter):
+    def __init__(self, path):
+        self.path = path
+
+    def read(self):
+        """Reads a set of Intan files (RHD, RHS, Spike) and converts each data object into an xarray.DataArray with the appropriate dimensions, coordinates and metadata attributes for the Neuroscikit data model.
+        """
+        pass
+
+
+# ================================================================================
+# RHD read helper functions
+# ================================================================================
+
+
+
+# ================================================================================
+# RHS helper functions
+# ================================================================================
+
+
+
+# ================================================================================
+# Spike File helper functions
+# ================================================================================
+

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/intan/load_intan_rhd_format/intanutil/data_to_result.py

@@ -0,0 +1,62 @@
+#! /bin/env python
+#
+# Michael Gibson 27 April 2015
+# Modified Adrian Foy Sep 2018
+
+def data_to_result(header, data, data_present):
+    """Moves the header and data (if present) into a common object."""
+    
+    result = {}
+    if header['num_amplifier_channels'] > 0 and data_present:
+        result['t_amplifier'] = data['t_amplifier']
+    if header['num_aux_input_channels'] > 0 and data_present:
+        result['t_aux_input'] = data['t_aux_input']
+    if header['num_supply_voltage_channels'] > 0 and data_present:
+        result['t_supply_voltage'] = data['t_supply_voltage']
+    if header['num_board_adc_channels'] > 0 and data_present:
+        result['t_board_adc'] = data['t_board_adc']
+    if (header['num_board_dig_in_channels'] > 0 or header['num_board_dig_out_channels'] > 0) and data_present:
+        result['t_dig'] = data['t_dig']
+    if header['num_temp_sensor_channels'] > 0 and data_present:
+        result['t_temp_sensor'] = data['t_temp_sensor']
+        
+    if header['num_amplifier_channels'] > 0:
+        result['spike_triggers'] = header['spike_triggers']
+        
+    result['notes'] = header['notes']
+    result['frequency_parameters'] = header['frequency_parameters']
+    
+    if header['version']['major'] > 1:
+        result['reference_channel'] = header['reference_channel']
+    
+    if header['num_amplifier_channels'] > 0:
+        result['amplifier_channels'] = header['amplifier_channels']
+        if data_present:
+            result['amplifier_data'] = data['amplifier_data']
+            
+    if header['num_aux_input_channels'] > 0:
+        result['aux_input_channels'] = header['aux_input_channels']
+        if data_present:
+            result['aux_input_data'] = data['aux_input_data']
+            
+    if header['num_supply_voltage_channels'] > 0:
+        result['supply_voltage_channels'] = header['supply_voltage_channels']
+        if data_present:
+            result['supply_voltage_data'] = data['supply_voltage_data']
+    
+    if header['num_board_adc_channels'] > 0:
+        result['board_adc_channels'] = header['board_adc_channels']
+        if data_present:
+            result['board_adc_data'] = data['board_adc_data']
+            
+    if header['num_board_dig_in_channels'] > 0:
+        result['board_dig_in_channels'] = header['board_dig_in_channels']
+        if data_present:
+            result['board_dig_in_data'] = data['board_dig_in_data']
+            
+    if header['num_board_dig_out_channels'] > 0:
+        result['board_dig_out_channels'] = header['board_dig_out_channels']
+        if data_present:
+            result['board_dig_out_data'] = data['board_dig_out_data']
+    
+    return result

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/intan/load_intan_rhd_format/intanutil/get_bytes_per_data_block.py

@@ -0,0 +1,36 @@
+#! /bin/env python
+#
+# Michael Gibson 23 April 2015
+# Modified Adrian Foy Sep 2018
+
+
+def get_bytes_per_data_block(header):
+    """Calculates the number of bytes in each 60 or 128 sample datablock."""
+
+    # Each data block contains 60 or 128 amplifier samples.
+    bytes_per_block = header['num_samples_per_data_block'] * 4  # timestamp data
+    bytes_per_block = bytes_per_block + header['num_samples_per_data_block'] * 2 * header['num_amplifier_channels']
+
+    # Auxiliary inputs are sampled 4x slower than amplifiers
+    bytes_per_block = bytes_per_block + (header['num_samples_per_data_block'] / 4) * 2 * header['num_aux_input_channels']
+
+    # Supply voltage is sampled 60 or 128x slower than amplifiers
+    bytes_per_block = bytes_per_block + 1 * 2 * header['num_supply_voltage_channels']
+
+    # Board analog inputs are sampled at same rate as amplifiers
+    bytes_per_block = bytes_per_block + header['num_samples_per_data_block'] * 2 * header['num_board_adc_channels']
+
+    # Board digital inputs are sampled at same rate as amplifiers
+    if header['num_board_dig_in_channels'] > 0:
+        bytes_per_block = bytes_per_block + header['num_samples_per_data_block'] * 2
+
+    # Board digital outputs are sampled at same rate as amplifiers
+    if header['num_board_dig_out_channels'] > 0:
+        bytes_per_block = bytes_per_block + header['num_samples_per_data_block'] * 2
+
+    # Temp sensor is sampled 60 or 128x slower than amplifiers
+    if header['num_temp_sensor_channels'] > 0:
+        bytes_per_block = bytes_per_block + 1 * 2 * header['num_temp_sensor_channels']
+
+    return bytes_per_block
+  

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/intan/load_intan_rhd_format/intanutil/notch_filter.py

@@ -0,0 +1,50 @@
+#! /bin/env python
+#
+# Michael Gibson 27 April 2015
+
+import math
+import numpy as np
+
+def notch_filter(input, fSample, fNotch, Bandwidth):
+    """Implements a notch filter (e.g., for 50 or 60 Hz) on vector 'input'.
+
+    fSample = sample rate of data (input Hz or Samples/sec)
+    fNotch = filter notch frequency (input Hz)
+    Bandwidth = notch 3-dB bandwidth (input Hz).  A bandwidth of 10 Hz is
+    recommended for 50 or 60 Hz notch filters; narrower bandwidths lead to
+    poor time-domain properties with an extended ringing response to
+    transient disturbances.
+
+    Example:  If neural data was sampled at 30 kSamples/sec
+    and you wish to implement a 60 Hz notch filter:
+
+    out = notch_filter(input, 30000, 60, 10);
+    """
+
+    tstep = 1.0/fSample
+    Fc = fNotch*tstep
+
+    L = len(input)
+
+    # Calculate IIR filter parameters
+    d = math.exp(-2.0*math.pi*(Bandwidth/2.0)*tstep)
+    b = (1.0 + d*d) * math.cos(2.0*math.pi*Fc)
+    a0 = 1.0
+    a1 = -b
+    a2 = d*d
+    a = (1.0 + d*d)/2.0
+    b0 = 1.0
+    b1 = -2.0 * math.cos(2.0*math.pi*Fc)
+    b2 = 1.0
+
+    out = np.zeros(len(input))
+    out[0] = input[0]
+    out[1] = input[1]
+    # (If filtering a continuous data stream, change out[0:1] to the
+    #  previous final two values of out.)
+
+    # Run filter
+    for i in range(2,L):
+        out[i] = (a*b2*input[i-2] + a*b1*input[i-1] + a*b0*input[i] - a2*out[i-2] - a1*out[i-1])/a0
+
+    return out

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/intan/load_intan_rhd_format/intanutil/qstring.py

@@ -0,0 +1,41 @@
+#! /bin/env python
+#
+# Michael Gibson 23 April 2015
+
+
+import sys, struct, os
+
+def read_qstring(fid):
+    """Read Qt style QString.  
+
+    The first 32-bit unsigned number indicates the length of the string (in bytes).  
+    If this number equals 0xFFFFFFFF, the string is null.
+
+    Strings are stored as unicode.
+    """
+
+    length, = struct.unpack('<I', fid.read(4))
+    if length == int('ffffffff', 16): return ""
+
+    if length > (os.fstat(fid.fileno()).st_size - fid.tell() + 1) :
+        print(length)
+        raise Exception('Length too long.')
+
+    # convert length from bytes to 16-bit Unicode words
+    length = int(length / 2)
+
+    data = []
+    for i in range(0, length):
+        c, = struct.unpack('<H', fid.read(2))
+        data.append(c)
+
+    if sys.version_info >= (3,0):
+        a = ''.join([chr(c) for c in data])
+    else:
+        a = ''.join([unichr(c) for c in data])
+    
+    return a
+  
+if __name__ == '__main__':
+    a=read_qstring(open(sys.argv[1], 'rb'))
+    print(a)

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/intan/load_intan_rhd_format/intanutil/read_header.py

@@ -0,0 +1,135 @@
+#! /bin/env python
+#
+# Michael Gibson 23 April 2015
+# Modified Adrian Foy Sep 2018
+
+import sys, struct
+from intanutil.qstring import read_qstring
+
+def read_header(fid):
+    """Reads the Intan File Format header from the given file."""
+
+    # Check 'magic number' at beginning of file to make sure this is an Intan
+    # Technologies RHD2000 data file.
+    magic_number, = struct.unpack('<I', fid.read(4))
+    if magic_number != int('c6912702', 16): raise Exception('Unrecognized file type.')
+
+    header = {}
+    # Read version number.
+    version = {}
+    (version['major'], version['minor']) = struct.unpack('<hh', fid.read(4))
+    header['version'] = version
+
+    print('')
+    print('Reading Intan Technologies RHD2000 Data File, Version {}.{}'.format(version['major'], version['minor']))
+    print('')
+
+    freq = {}
+
+    # Read information of sampling rate and amplifier frequency settings.
+    header['sample_rate'], = struct.unpack('<f', fid.read(4))
+    (freq['dsp_enabled'], freq['actual_dsp_cutoff_frequency'], freq['actual_lower_bandwidth'], freq['actual_upper_bandwidth'],
+    freq['desired_dsp_cutoff_frequency'], freq['desired_lower_bandwidth'], freq['desired_upper_bandwidth']) = struct.unpack('<hffffff', fid.read(26))
+
+
+    # This tells us if a software 50/60 Hz notch filter was enabled during
+    # the data acquisition.
+    notch_filter_mode, = struct.unpack('<h', fid.read(2))
+    header['notch_filter_frequency'] = 0
+    if notch_filter_mode == 1:
+        header['notch_filter_frequency'] = 50
+    elif notch_filter_mode == 2:
+        header['notch_filter_frequency'] = 60
+    freq['notch_filter_frequency'] = header['notch_filter_frequency']
+
+    (freq['desired_impedance_test_frequency'], freq['actual_impedance_test_frequency']) = struct.unpack('<ff', fid.read(8))
+
+    note1 = read_qstring(fid)
+    note2 = read_qstring(fid)
+    note3 = read_qstring(fid)
+    header['notes'] = { 'note1' : note1, 'note2' : note2, 'note3' : note3}
+
+    # If data file is from GUI v1.1 or later, see if temperature sensor data was saved.
+    header['num_temp_sensor_channels'] = 0
+    if (version['major'] == 1 and version['minor'] >= 1) or (version['major'] > 1) :
+        header['num_temp_sensor_channels'], = struct.unpack('<h', fid.read(2))
+
+    # If data file is from GUI v1.3 or later, load eval board mode.
+    header['eval_board_mode'] = 0
+    if ((version['major'] == 1) and (version['minor'] >= 3)) or (version['major'] > 1) :
+        header['eval_board_mode'], = struct.unpack('<h', fid.read(2))
+
+
+    header['num_samples_per_data_block'] = 60
+    # If data file is from v2.0 or later (Intan Recording Controller), load name of digital reference channel
+    if (version['major'] > 1):
+        header['reference_channel'] = read_qstring(fid)
+        header['num_samples_per_data_block'] = 128
+
+    # Place frequency-related information in data structure. (Note: much of this structure is set above)
+    freq['amplifier_sample_rate'] = header['sample_rate']
+    freq['aux_input_sample_rate'] = header['sample_rate'] / 4
+    freq['supply_voltage_sample_rate'] = header['sample_rate'] / header['num_samples_per_data_block']
+    freq['board_adc_sample_rate'] = header['sample_rate']
+    freq['board_dig_in_sample_rate'] = header['sample_rate']
+
+    header['frequency_parameters'] = freq
+
+    # Create structure arrays for each type of data channel.
+    header['spike_triggers'] = []
+    header['amplifier_channels'] = []
+    header['aux_input_channels'] = []
+    header['supply_voltage_channels'] = []
+    header['board_adc_channels'] = []
+    header['board_dig_in_channels'] = []
+    header['board_dig_out_channels'] = []
+
+    # Read signal summary from data file header.
+
+    number_of_signal_groups, = struct.unpack('<h', fid.read(2))
+
+    for signal_group in range(1, number_of_signal_groups + 1):
+        signal_group_name = read_qstring(fid)
+        signal_group_prefix = read_qstring(fid)
+        (signal_group_enabled, signal_group_num_channels, signal_group_num_amp_channels) = struct.unpack('<hhh', fid.read(6))
+
+        if (signal_group_num_channels > 0) and (signal_group_enabled > 0):
+            for signal_channel in range(0, signal_group_num_channels):
+                new_channel = {'port_name' : signal_group_name, 'port_prefix' : signal_group_prefix, 'port_number' : signal_group}
+                new_channel['native_channel_name'] = read_qstring(fid)
+                new_channel['custom_channel_name'] = read_qstring(fid)
+                (new_channel['native_order'], new_channel['custom_order'], signal_type, channel_enabled, new_channel['chip_channel'], new_channel['board_stream']) = struct.unpack('<hhhhhh', fid.read(12))
+                new_trigger_channel = {}
+                (new_trigger_channel['voltage_trigger_mode'], new_trigger_channel['voltage_threshold'], new_trigger_channel['digital_trigger_channel'], new_trigger_channel['digital_edge_polarity'])  = struct.unpack('<hhhh', fid.read(8))
+                (new_channel['channel_impedance_magnitude'], new_channel['channel_impedance_phase']) = struct.unpack('<ff', fid.read(8))
+
+                if channel_enabled:
+                    if signal_type == 0:
+                        header['amplifier_channels'].append(new_channel)
+                        header['spike_triggers'].append(new_trigger_channel)
+                    elif signal_type == 1:
+                        header['aux_input_channels'].append(new_channel)
+                    elif signal_type == 2:
+                        header['supply_voltage_channels'].append(new_channel)
+                    elif signal_type == 3:
+                        header['board_adc_channels'].append(new_channel)
+                    elif signal_type == 4:
+                        header['board_dig_in_channels'].append(new_channel)
+                    elif signal_type == 5:
+                        header['board_dig_out_channels'].append(new_channel)
+                    else:
+                        raise Exception('Unknown channel type.')
+
+    # Summarize contents of data file.
+    header['num_amplifier_channels'] = len(header['amplifier_channels'])
+    header['num_aux_input_channels'] = len(header['aux_input_channels'])
+    header['num_supply_voltage_channels'] = len(header['supply_voltage_channels'])
+    header['num_board_adc_channels'] = len(header['board_adc_channels'])
+    header['num_board_dig_in_channels'] = len(header['board_dig_in_channels'])
+    header['num_board_dig_out_channels'] = len(header['board_dig_out_channels'])
+
+    return header
+
+if __name__ == '__main__':
+    h=read_header(open(sys.argv[1], 'rb'))
+    print(h)

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/intan/load_intan_rhd_format/intanutil/read_one_data_block.py

@@ -0,0 +1,45 @@
+#! /bin/env python
+#
+# Michael Gibson 23 April 2015
+# Modified Adrian Foy Sep 2018
+
+import sys, struct
+import numpy as np
+
+def read_one_data_block(data, header, indices, fid):
+    """Reads one 60 or 128 sample data block from fid into data, at the location indicated by indices."""
+
+    # In version 1.2, we moved from saving timestamps as unsigned
+    # integers to signed integers to accommodate negative (adjusted)
+    # timestamps for pretrigger data['
+    if (header['version']['major'] == 1 and header['version']['minor'] >= 2) or (header['version']['major'] > 1):
+        data['t_amplifier'][indices['amplifier']:(indices['amplifier'] + header['num_samples_per_data_block'])] = np.array(struct.unpack('<' + 'i' * header['num_samples_per_data_block'], fid.read(4 * header['num_samples_per_data_block'])))
+    else:
+        data['t_amplifier'][indices['amplifier']:(indices['amplifier'] + header['num_samples_per_data_block'])] = np.array(struct.unpack('<' + 'I' * header['num_samples_per_data_block'], fid.read(4 * header['num_samples_per_data_block'])))
+
+    if header['num_amplifier_channels'] > 0:
+        tmp = np.fromfile(fid, dtype='uint16', count= header['num_samples_per_data_block'] * header['num_amplifier_channels'])
+        data['amplifier_data'][range(header['num_amplifier_channels']), (indices['amplifier']):(indices['amplifier']+ header['num_samples_per_data_block'])] = tmp.reshape(header['num_amplifier_channels'], header['num_samples_per_data_block'])
+
+    if header['num_aux_input_channels'] > 0:
+        tmp = np.fromfile(fid, dtype='uint16', count= int((header['num_samples_per_data_block'] / 4) * header['num_aux_input_channels']))
+        data['aux_input_data'][range(header['num_aux_input_channels']), indices['aux_input']:int(indices['aux_input']+ (header['num_samples_per_data_block']/4))] = tmp.reshape(header['num_aux_input_channels'], int(header['num_samples_per_data_block']/4))
+
+    if header['num_supply_voltage_channels'] > 0:
+        tmp = np.fromfile(fid, dtype='uint16', count=1 * header['num_supply_voltage_channels'])
+        data['supply_voltage_data'][range(header['num_supply_voltage_channels']), indices['supply_voltage']:(indices['supply_voltage']+1)] = tmp.reshape(header['num_supply_voltage_channels'], 1)
+
+    if header['num_temp_sensor_channels'] > 0:
+        tmp = np.fromfile(fid, dtype='uint16', count=1 * header['num_temp_sensor_channels'])
+        data['temp_sensor_data'][range(header['num_temp_sensor_channels']), indices['supply_voltage']:(indices['supply_voltage']+1)] = tmp.reshape(header['num_temp_sensor_channels'], 1)
+
+    if header['num_board_adc_channels'] > 0:
+        tmp = np.fromfile(fid, dtype='uint16', count= (header['num_samples_per_data_block']) * header['num_board_adc_channels'])
+        data['board_adc_data'][range(header['num_board_adc_channels']), indices['board_adc']:(indices['board_adc']+ header['num_samples_per_data_block'])] = tmp.reshape(header['num_board_adc_channels'], header['num_samples_per_data_block'])
+
+    if header['num_board_dig_in_channels'] > 0:
+        data['board_dig_in_raw'][indices['board_dig_in']:(indices['board_dig_in']+ header['num_samples_per_data_block'])] = np.array(struct.unpack('<' + 'H' * header['num_samples_per_data_block'], fid.read(2 * header['num_samples_per_data_block'])))
+
+    if header['num_board_dig_out_channels'] > 0:
+        data['board_dig_out_raw'][indices['board_dig_out']:(indices['board_dig_out']+ header['num_samples_per_data_block'])] = np.array(struct.unpack('<' + 'H' * header['num_samples_per_data_block'], fid.read(2 * header['num_samples_per_data_block'])))
+