def test_talreader_on_database():
old_reader = TalReader(filename=osp.join(
utils.get_rhino_root(),
'data/eeg/R1234D/tal/R1234D_talLocs_database_bipol.mat'))
jr = JsonIndexReader(osp.join(utils.get_rhino_root(), 'protocols/r1.json'))
new_reader = TalReader(
filename=jr.get_value('pairs', subject='R1234D', experiment='FR1'))
assert (new_reader.get_bipolar_pairs() == old_reader.get_bipolar_pairs()
).all()
assert (new_reader.get_monopolar_channels() ==
old_reader.get_monopolar_channels()).all()
def setUp(self):
self.start_time = -0.5
self.end_time = 1.6
self.buffer_time = 0.5
self.event_range = range(0, 30, 1)
# here = osp.abspath(osp.dirname(__file__))
here = get_rhino_root()
self.e_path = osp.join(here, 'data', 'events', 'RAM_FR1', 'R1060M_events.mat')
tal_path = osp.join(here, 'data', 'eeg', 'R1060M', 'tal', 'R1060M_talLocs_database_bipol.mat')
tal_reader = TalReader(filename=tal_path)
self.monopolar_channels = tal_reader.get_monopolar_channels()
self.bipolar_pairs = tal_reader.get_bipolar_pairs()
base_e_reader = BaseEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True)
base_events = base_e_reader.read()
base_events = base_events[base_events.type == 'WORD']
base_ev_order = np.argsort(base_events, order=('session', 'list', 'mstime'))
self.base_events = base_events[base_ev_order]
# retaining first session
dataroot = self.base_events[0].eegfile
self.base_events = self.base_events[self.base_events.eegfile == dataroot]
self.base_events = self.base_events[self.event_range]
eeg_reader = EEGReader(events=self.base_events, channels=self.monopolar_channels,
start_time=self.start_time, end_time=self.end_time, buffer_time=self.buffer_time)
self.base_eegs = eeg_reader.read()
session_reader = EEGReader(session_dataroot=dataroot, channels=self.monopolar_channels)
self.session_eegs = session_reader.read()
def setUp(self):
root = get_rhino_root()
self.e_path = osp.join(root, 'data', 'events', 'RAM_FR1',
'R1060M_events.mat')
tal_path = osp.join(root, 'data', 'eeg', 'R1060M', 'tal',
'R1060M_talLocs_database_bipol.mat')
base_e_reader = BaseEventReader(filename=self.e_path,
eliminate_events_with_no_eeg=True)
self.base_events = base_e_reader.read()
tal_reader = TalReader(filename=tal_path)
self.monopolar_channels = tal_reader.get_monopolar_channels()
self.bipolar_pairs = tal_reader.get_bipolar_pairs()
self.base_events = self.base_events[self.base_events.type == 'WORD']
# retaining first session
dataroot = self.base_events[0].eegfile
self.base_events = self.base_events[self.base_events.eegfile == dataroot]
eeg_reader = EEGReader(events=self.base_events, channels=self.monopolar_channels,
start_time=0.0, end_time=1.6, buffer_time=1.0)
self.base_eegs = eeg_reader.read()
def test_eeg_reader(self, subject, session):
jr = JsonIndexReader(
osp.join(get_rhino_root(), 'protocols', 'ltp.json'))
events = BaseEventReader(filename=jr.get_value(
'task_events', subject=subject, session=session)).read()
# hack to make the scalp events work with Rhino mounted
events['eegfile'] = get_rhino_root() + events[0]['eegfile']
channels = np.array([0, 1])
eeg = EEGReader(events=events[:10],
channels=channels,
start_time=0.0,
end_time=0.1).read()
assert (eeg['channels'].values['index'] == channels).all()
assert (eeg['channels'].values['label'] == np.array(
['A1', 'A2'], dtype=bytes)).all()
def setup(cls):
root = get_rhino_root()
cls.bdf_file_template = osp.join(
root, 'protocols', 'ltp', 'subjects', '{subject:s}', 'experiments',
'ltpFR2', 'sessions', '{session:d}', 'ephys', 'current_processed',
'{subject:s}_session_{session:d}.bdf')
here = osp.realpath(osp.dirname(__file__))
cls.fname = osp.join(here, 'data', 'eeg.edf')
def test_with_events(self):
dataroot_format = osp.join(get_rhino_root(), 'scratch', 'ptsa_test',
'R1308T', 'experiments', 'FR1', 'sessions',
'3', 'behavioral', 'current_processed',
'task_events.json')
events = CMLEventReader(filename=dataroot_format).read()[:20]
EEGReader(events=events,
channels=np.array(['%.03d' % i for i in range(1, 10)]),
start_time=0.0,
end_time=0.5).read()
def test_h5reader_constructor(self):
dataroot = osp.join(get_rhino_root(), 'scratch', 'ptsa_test', 'R1308T',
'experiments', 'FR1', 'sessions', '3', 'ephys',
'current_processed', 'noreref',
'R1308T_FR1_3_13Jun17_1917.h5')
reader = H5RawReader(dataroot=dataroot,
channels=np.array(
['%.03d' % i for i in range(1, 10)]))
reader.read()
assert reader.channel_name == 'bipolar_pairs'
def reader(self):
from cmlreaders import CMLReader
from ptsa.test.utils import get_rhino_root
try:
rootdir = get_rhino_root()
except OSError:
rootdir = None
return CMLReader("R1111M", "FR1", 0, rootdir=rootdir)
def test_h5reader_empty_channels(self):
dataroot_format = osp.join(get_rhino_root(), 'scratch', 'ptsa_test',
'R1308T', 'experiments', 'FR1', 'sessions',
'3', 'behavioral', 'current_processed',
'task_events.json')
events = CMLEventReader(filename=dataroot_format).read()[:20]
eeg = EEGReader(events=events,
channels=np.array([]),
start_time=0.0,
end_time=0.5).read()
assert len(eeg.bipolar_pairs) > 0
def setUp(self):
root = get_rhino_root()
self.h5_dataroot = osp.join(root, 'data', 'eeg', 'R1275D',
'behavioral', 'FR1', 'session_0',
'host_pc', '20170531_170954',
'eeg_timeseries.h5')
self.raw_dataroot = osp.join(root, 'protocols', 'r1', 'subjects',
'R1275D', 'experiments', 'FR1',
'sessions', '0', 'ephys',
'current_processed', 'noreref',
'R1275D_FR1_0_31May17_2109')
self.channels = np.array(['%.03d' % i for i in range(1, 10)])
self.h5file = tables.open_file(self.h5_dataroot)
def _test_eeg_with_tal_struct(self, subject, experiment, session, struct_type='mono'):
from ptsa.data.readers import JsonIndexReader,TalReader,EEGReader,BaseEventReader
import os
tal_file = 'contacts' if struct_type=='mono' else 'pairs'
jr = JsonIndexReader(os.path.join(get_rhino_root(),'protocols','r1.json'))
events = BaseEventReader(filename=jr.get_value('task_events',subject=subject,experiment=experiment,session=session)).read()
tal_struct = TalReader(filename=jr.get_value(tal_file,subject=subject),struct_type=struct_type).read()
eeg_reader = EEGReader(events=events[:10],channels=tal_struct[:10],start_time=0.0,end_time=0.1)
eeg = eeg_reader.read()
print(eeg)
channel_name = eeg_reader.channel_name
for col in tal_struct.dtype.names:
if col != 'atlases': # Because I don't want to deal with NaNs at the moment
assert_array_equal(eeg[channel_name].data[col],tal_struct[:10][col])
def setup_class(cls):
root = get_rhino_root()
cls.eeg_path_template = osp.join(
root, 'data', 'eeg', '{subject:s}', 'behavioral', '{experiment:s}',
'session_{session:d}', 'host_pc', '{timestamp:s}',
'eeg_timeseries.h5'
)
cls.dataroot_template = osp.join(
root, 'protocols', 'r1', 'subjects', '{subject:s}', 'experiments',
'{experiment:s}', 'sessions', '{session:d}', 'ephys',
'current_processed', 'noreref', '{filename:s}'
)
cls.task_events_template = osp.join(
root, 'protocols', 'r1', 'subjects', '{subject:s}', 'experiments',
'{experiment:s}', 'sessions', '{session:d}', 'behavioral',
'current_processed', 'task_events.json'
)
# monopolar (old-format) HDF5 file
cls.monopolar_file = cls.eeg_path_template.format(
subject='R1275D',
experiment='FR1',
session=0,
timestamp='20170531_170954'
)
# bipolar (new-format) HDF5 file
cls.bipolar_file = cls.eeg_path_template.format(
subject='R1354E',
experiment='FR1',
session=0,
timestamp='20171026_160648'
)
cls.monopolar_dataroot = cls.dataroot_template.format(
subject='R1275D',
experiment='FR1',
session=0,
filename='R1275D_FR1_0_31May17_2109'
)
cls.channels = np.array(['%.03d' % i for i in range(1, 10)])
def setUp(self):
self.start_time = -0.5
self.end_time = 1.6
self.buffer_time = 0.5
self.event_range = range(0, 30, 1)
# here = osp.abspath(osp.dirname(__file__))
here = get_rhino_root()
self.e_path = osp.join(here, 'data', 'events', 'RAM_FR1',
'R1060M_events.mat')
tal_path = osp.join(here, 'data', 'eeg', 'R1060M', 'tal',
'R1060M_talLocs_database_bipol.mat')
tal_reader = TalReader(filename=tal_path)
self.monopolar_channels = tal_reader.get_monopolar_channels()
self.bipolar_pairs = tal_reader.get_bipolar_pairs()
base_e_reader = BaseEventReader(filename=self.e_path,
eliminate_events_with_no_eeg=True)
base_events = base_e_reader.read()
base_events = base_events[base_events.type == 'WORD']
base_ev_order = np.argsort(base_events,
order=('session', 'list', 'mstime'))
self.base_events = base_events[base_ev_order]
# retaining first session
dataroot = self.base_events[0].eegfile
self.base_events = self.base_events[self.base_events.eegfile ==
dataroot]
self.base_events = self.base_events[self.event_range]
eeg_reader = EEGReader(events=self.base_events,
channels=self.monopolar_channels,
start_time=self.start_time,
end_time=self.end_time,
buffer_time=self.buffer_time)
self.base_eegs = eeg_reader.read()
session_reader = EEGReader(session_dataroot=dataroot,
channels=self.monopolar_channels)
self.session_eegs = session_reader.read()
def setUp(self):
self.event_range = range(0, 30, 1)
root = get_rhino_root()
self.e_path = osp.join(root, 'data', 'events', 'RAM_FR1',
'R1060M_events.mat')
def setUp(self):
self.event_range = range(0, 30, 1)
root = get_rhino_root()
self.e_path = osp.join(root, 'data', 'events', 'RAM_FR1', 'R1060M_events.mat')
def test_as_dataframe(self):
index = osp.join(get_rhino_root(), "protocols", "r1.json")
reader = JsonIndexReader(index)
df = reader.as_dataframe()
assert isinstance(df, pd.DataFrame)
