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 setUp(self):
self.e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
# ---------------- NEW STYLE PTSA -------------------
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_2_old():
import time
start = time.time()
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(event_file=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False)
base_e_reader.read()
base_events = base_e_reader.get_output()
base_events = base_events[base_events.type == 'WORD']
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
tal_reader = TalReader(tal_filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
print 'bipolar_pairs=', bipolar_pairs
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events, start_time=0.0,
end_time=1.6, buffer_time=1.0, keep_buffer=True)
base_eegs = time_series_reader.read(channels=monopolar_channels)
# base_eegs = base_eegs[:, 0:10, :]
# bipolar_pairs = bipolar_pairs[0:10]
wf = MorletWaveletFilter(time_series=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 2),
# freqs=np.array([3.]),
output='power',
# resamplerate=50.0
)
pow_wavelet, phase_wavelet = wf.filter()
print 'total time = ', time.time() - start
res_start = time.time()
# from ptsa.data.filters.ResampleFilter import ResampleFilter
# rsf = ResampleFilter (resamplerate=50.0)
# rsf.set_input(pow_wavelet)
# pow_wavelet = rsf.filter()
print 'resample_time=', time.time() - res_start
return pow_wavelet
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 test_2():
import time
start = time.time()
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(filename=e_path)
base_events = base_e_reader.read()
base_events = base_events[base_events.type == 'WORD']
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
print 'bipolar_pairs=', bipolar_pairs
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events,
start_time=0.0,
end_time=1.6,
buffer_time=1.0,
keep_buffer=True)
base_eegs = time_series_reader.read(channels=monopolar_channels)
# base_eegs = base_eegs[:, 0:10, :]
# bipolar_pairs = bipolar_pairs[0:10]
wf = MorletWaveletFilter(
time_series=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 2),
# freqs=np.array([3.]),
output='power',
)
pow_wavelet, phase_wavelet = wf.filter()
print 'total time = ', time.time() - start
res_start = time.time()
# from ptsa.data.filters.ResampleFilter import ResampleFilter
# rsf = ResampleFilter (resamplerate=50.0)
# rsf.set_input(pow_wavelet)
# pow_wavelet = rsf.filter()
print 'resample_time=', time.time() - res_start
return pow_wavelet
def main_fcn():
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(filename=e_path, eliminate_events_with_no_eeg=True)
base_events = base_e_reader.read()
base_events = base_events[base_events.type == 'WORD']
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
print('bipolar_pairs=', bipolar_pairs)
from ptsa.data.readers.EEGReader import EEGReader
sessions = np.unique(base_events.session)
dataroot = base_events[0].eegfile
session_reader = EEGReader(session_dataroot=dataroot, channels=monopolar_channels)
session_eegs = session_reader.read()
m2b = MonopolarToBipolarMapper(time_series=session_eegs, bipolar_pairs=bipolar_pairs)
session_bp_eegs = m2b.filter()
time_series_reader = EEGReader(events=base_events, channels=monopolar_channels, start_time=0.0,
end_time=1.6, buffer_time=1.0)
base_eegs = time_series_reader.read()
m2b = MonopolarToBipolarMapper(time_series=base_eegs, bipolar_pairs=bipolar_pairs)
ts_filtered = m2b.filter()
del base_eegs
del time_series_reader
print()
pass
def setUp(self):
self.event_range = range(0, 30, 1)
self.e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
self.tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
if sys.platform.startswith('win'):
self.e_path = 'D:/data/events/RAM_FR1/R1060M_events.mat'
self.tal_path = 'D:/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
# --------------- TAL STRUCTS READ
tal_reader = TalReader(filename=self.tal_path)
self.monopolar_channels = tal_reader.get_monopolar_channels()
# ---------------- ORIG PTSA -------------------
e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True)
events = e_reader.read()
events = events[events.type == 'WORD']
events = events[self.event_range]
ev_order = np.argsort(events, order=('session','list','mstime'))
self.events = events[ev_order]
# self.events = self.read_ptsa_events()
# in case fancy indexing looses Eventness of events we need to create Events object explicitely
if not isinstance(self.events, Events):
self.events = Events(self.events)
start_time = 0.0
end_time = 1.6
buffer_time = 1.0
self.eegs = self.events.get_data(channels=['002', '003'], start_time=start_time, end_time=end_time,
buffer_time=buffer_time, eoffset='eegoffset', keep_buffer=True,
eoffset_in_time=False, verbose=True)
# ---------------- NEW STYLE PTSA -------------------
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'))
base_events = base_events[base_ev_order]
self.base_events = base_events[self.event_range]
# self.base_events = self.read_base_events()
eeg_reader = EEGReader(events=self.base_events, channels=np.array(['002', '003']),
start_time=start_time, end_time=end_time, buffer_time=buffer_time)
self.base_eegs = eeg_reader.read()
def test_1():
import time
start = time.time()
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(filename=e_path,
eliminate_events_with_no_eeg=True,
use_ptsa_events_class=False)
base_events = base_e_reader.read()
base_events = base_events[base_events.type == 'WORD']
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
dataroot = base_events[0].eegfile
from ptsa.data.readers import EEGReader
session_reader = EEGReader(session_dataroot=dataroot,
channels=monopolar_channels)
session_eegs = session_reader.read()
wavelet_start = time.time()
wf = MorletWaveletFilterSimple(
time_series=session_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 2),
# freqs=np.array([3.]),
output='power',
# resamplerate=50.0
)
pow_wavelet, phase_wavelet = wf.filter()
print('wavelet total time = ', time.time() - wavelet_start)
# return pow_wavelet
from ptsa.data.filters import EventDataChopper
sedc = EventDataChopper(events=base_events,
session_data=pow_wavelet,
start_time=0.0,
end_time=1.6,
buffer_time=1.0)
chopped_wavelets = sedc.filter()
print('total time = ', time.time() - start)
return chopped_wavelets
def main_fcn():
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(filename=e_path,
eliminate_events_with_no_eeg=True)
base_events = base_e_reader.read()
base_events = base_events[base_events.type == 'WORD']
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
print 'bipolar_pairs=', bipolar_pairs
from ptsa.data.readers.EEGReader import EEGReader
sessions = np.unique(base_events.session)
dataroot = base_events[0].eegfile
session_reader = EEGReader(session_dataroot=dataroot,
channels=monopolar_channels)
session_eegs = session_reader.read()
m2b = MonopolarToBipolarMapper(time_series=session_eegs,
bipolar_pairs=bipolar_pairs)
session_bp_eegs = m2b.filter()
time_series_reader = EEGReader(events=base_events,
channels=monopolar_channels,
start_time=0.0,
end_time=1.6,
buffer_time=1.0)
base_eegs = time_series_reader.read()
m2b = MonopolarToBipolarMapper(time_series=base_eegs,
bipolar_pairs=bipolar_pairs)
ts_filtered = m2b.filter()
del base_eegs
del time_series_reader
print
pass
def read_electrode_info(self, subject):
tal_path = join(self.prefix, 'data/eeg/%s/tal/%s_talLocs_database_bipol.mat' % (subject, subject))
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
tal_struct = tal_reader.read()
return tal_struct, monopolar_channels, bipolar_pairs
def test_1():
import time
start = time.time()
e_path = "/Users/m/data/events/RAM_FR1/R1060M_events.mat"
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(filename=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False)
base_events = base_e_reader.read()
base_events = base_events[base_events.type == "WORD"]
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = "/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat"
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
dataroot = base_events[0].eegfile
from ptsa.data.readers import EEGReader
session_reader = EEGReader(session_dataroot=dataroot, channels=monopolar_channels)
session_eegs = session_reader.read()
wavelet_start = time.time()
wf = MorletWaveletFilterSimple(
time_series=session_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 2),
# freqs=np.array([3.]),
output="power",
# resamplerate=50.0
)
pow_wavelet, phase_wavelet = wf.filter()
print "wavelet total time = ", time.time() - wavelet_start
# return pow_wavelet
from ptsa.data.filters import EventDataChopper
sedc = EventDataChopper(events=base_events, session_data=pow_wavelet, start_time=0.0, end_time=1.6, buffer_time=1.0)
chopped_wavelets = sedc.filter()
print "total time = ", time.time() - start
return chopped_wavelets
def setUp(self):
self.event_range = range(0, 30, 1)
self.e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
self.tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
# --------------- TAL STRUCTS READ
tal_reader = TalReader(filename=self.tal_path)
self.monopolar_channels = tal_reader.get_monopolar_channels()
# ---------------- ORIG PTSA -------------------
e_reader = PTSAEventReader(filename=self.e_path, eliminate_events_with_no_eeg=True)
events = e_reader.read()
events = events[events.type == 'WORD']
events = events[self.event_range]
ev_order = np.argsort(events, order=('session','list','mstime'))
self.events = events[ev_order]
# self.events = self.read_ptsa_events()
# in case fancy indexing looses Eventness of events we need to create Events object explicitely
if not isinstance(self.events, Events):
self.events = Events(self.events)
start_time = 0.0
end_time = 1.6
buffer_time = 1.0
self.eegs = self.events.get_data(channels=['002', '003'], start_time=start_time, end_time=end_time,
buffer_time=buffer_time, eoffset='eegoffset', keep_buffer=True,
eoffset_in_time=False, verbose=True)
# ---------------- NEW STYLE PTSA -------------------
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'))
base_events = base_events[base_ev_order]
self.base_events = base_events[self.event_range]
# self.base_events = self.read_base_events()
eeg_reader = EEGReader(events=self.base_events, channels=np.array(['002', '003']),
start_time=start_time, end_time=end_time, buffer_time=buffer_time)
self.base_eegs = eeg_reader.read()
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.start_time = -0.5
self.end_time = 1.6
self.buffer_time = 0.5
self.event_range = range(0, 30, 1)
self.e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
tal_path = '/Users/m/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()
# ---------------- NEW STYLE PTSA -------------------
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]
# self.base_events = base_events[self.event_range]
# self.base_events = self.read_base_events()
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()
from ptsa.data.events import Events
e_path = '/Volumes/rhino_root/data/events/RAM_PS/R1108J_1_events.mat'
e_path = '/Volumes/rhino_root/data/events/RAM_PS/R1108J_1_events.mat'
# e_path ='/Users/m/data/events/RAM_FR1/R1056M_events.mat'
e_reader = BaseEventReader(filename=e_path,
eliminate_events_with_no_eeg=True)
events = e_reader.read()
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Volumes/rhino_root/data/eeg/R1108J_1/tal/R1108J_1_talLocs_database_bipol.mat'
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
# ---------------- NEW STYLE PTSA -------------------
base_e_reader = BaseEventReader(filename=e_path,
eliminate_events_with_no_eeg=True)
base_events = base_e_reader.read()
base_events = base_events[(base_events.type == 'STIMULATING')]
base_events = base_events[base_events.session == 2]
from ptsa.data.readers.EEGReader import EEGReader
eeg_reader = EEGReader(events=base_events,
channels=monopolar_channels[0:3],
start_time=-1.1,
def test_1_old():
import time
start = time.time()
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(event_file=e_path,
eliminate_events_with_no_eeg=True,
use_ptsa_events_class=False)
base_e_reader.read()
base_events = base_e_reader.get_output()
base_events = base_events[base_events.type == 'WORD']
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
tal_reader = TalReader(tal_filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
print('bipolar_pairs=', bipolar_pairs)
from ptsa.data.experimental.TimeSeriesSessionEEGReader import TimeSeriesSessionEEGReader
# time_series_reader = TimeSeriesSessionEEGReader(events=base_events, channels = ['002', '003', '004', '005'])
time_series_reader = TimeSeriesSessionEEGReader(
events=base_events, channels=monopolar_channels)
ts_dict = time_series_reader.read()
first_session_data = list(ts_dict.items())[0][1]
print(first_session_data)
wavelet_start = time.time()
wf = MorletWaveletFilterSimple(
time_series=first_session_data,
freqs=np.logspace(np.log10(3), np.log10(180), 2),
# freqs=np.array([3.]),
output='power',
# resamplerate=50.0
)
pow_wavelet, phase_wavelet = wf.filter()
print('wavelet total time = ', time.time() - wavelet_start)
# return pow_wavelet
from ptsa.data.experimental.EventDataChopper import EventDataChopper
edcw = EventDataChopper(events=base_events,
event_duration=1.6,
buffer=1.0,
data_dict={base_events[0].eegfile: pow_wavelet})
chopped_wavelets = edcw.filter()
chopped_wavelets = list(chopped_wavelets.items())[0][
1] # getting first item of return dictionary
print('total time = ', time.time() - start)
#
# from ptsa.data.filters.ResampleFilter import ResampleFilter
# rsf = ResampleFilter (resamplerate=50.0)
# rsf.set_input(chopped_wavelets)
# chopped_wavelets_resampled = rsf.filter()
#
# return chopped_wavelets_resampled
return chopped_wavelets
from ptsa.data.events import Events
e_path = '/Volumes/rhino_root/data/events/RAM_PS/R1108J_1_events.mat'
e_path = '/Volumes/rhino_root/data/events/RAM_PS/R1108J_1_events.mat'
# e_path ='/Users/m/data/events/RAM_FR1/R1056M_events.mat'
e_reader = BaseEventReader(filename=e_path, eliminate_events_with_no_eeg=True)
events = e_reader.read()
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Volumes/rhino_root/data/eeg/R1108J_1/tal/R1108J_1_talLocs_database_bipol.mat'
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
# ---------------- NEW STYLE PTSA -------------------
base_e_reader = BaseEventReader(filename=e_path, eliminate_events_with_no_eeg=True)
base_events = base_e_reader.read()
base_events = base_events[(base_events.type == 'STIMULATING') ]
base_events = base_events[base_events.session == 2]
from ptsa.data.readers.EEGReader import EEGReader
eeg_reader = EEGReader(events=base_events, channels=monopolar_channels[0:3],
start_time=-1.1, end_time=-0.1, buffer_time=1.0)
def test_1_old():
import time
start = time.time()
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(event_file=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False)
base_e_reader.read()
base_events = base_e_reader.get_output()
base_events = base_events[base_events.type == 'WORD']
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
tal_reader = TalReader(tal_filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
print 'bipolar_pairs=', bipolar_pairs
from ptsa.data.experimental.TimeSeriesSessionEEGReader import TimeSeriesSessionEEGReader
# time_series_reader = TimeSeriesSessionEEGReader(events=base_events, channels = ['002', '003', '004', '005'])
time_series_reader = TimeSeriesSessionEEGReader(events=base_events, channels=monopolar_channels)
ts_dict = time_series_reader.read()
first_session_data = ts_dict.items()[0][1]
print first_session_data
wavelet_start = time.time()
wf = MorletWaveletFilter(time_series=first_session_data,
freqs=np.logspace(np.log10(3), np.log10(180), 2),
# freqs=np.array([3.]),
output='power',
# resamplerate=50.0
)
pow_wavelet, phase_wavelet = wf.filter()
print 'wavelet total time = ', time.time() - wavelet_start
# return pow_wavelet
from ptsa.data.experimental.EventDataChopper import EventDataChopper
edcw = EventDataChopper(events=base_events, event_duration=1.6, buffer=1.0,
data_dict={base_events[0].eegfile: pow_wavelet})
chopped_wavelets = edcw.filter()
chopped_wavelets = chopped_wavelets.items()[0][1] # getting first item of return dictionary
print 'total time = ', time.time() - start
#
# from ptsa.data.filters.ResampleFilter import ResampleFilter
# rsf = ResampleFilter (resamplerate=50.0)
# rsf.set_input(chopped_wavelets)
# chopped_wavelets_resampled = rsf.filter()
#
# return chopped_wavelets_resampled
return chopped_wavelets
def get_monopolar_and_bipolar_electrodes():
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
return monopolar_channels, bipolar_pairs