def run(db_name, save_fig_name=None):
"""If save_fig_name is not None, should be ex. '~/test.png' """
# Load the raw data
db = OE.open_db(url=('sqlite:///%s' % db_name))
id_blocks, = OE.sql(
'SELECT block.id FROM block WHERE block.name="Raw Data"')
id_block = id_blocks[0]
id_recordingpoints, rp_names = OE.sql("SELECT \
recordingpoint.id, recordingpoint.name \
FROM recordingpoint \
WHERE recordingpoint.id_block = :id_block",
id_block=id_block)
f = plt.figure(figsize=(10, 10))
# Process each recording point separately
for n, (id_rp, tt) in enumerate(zip(id_recordingpoints[:16],
rp_names[:16])):
# Load all signals from all segments with this recording point
id_sigs, = OE.sql('SELECT analogsignal.id FROM analogsignal ' + \
'WHERE analogsignal.id_recordingpoint = :id_recordingpoint',
id_recordingpoint=id_rp)
# Average the signal
avgsig = np.zeros(OE.AnalogSignal().load(id_sigs[0]).signal.shape)
for id_sig in id_sigs:
sig = OE.AnalogSignal().load(id_sig)
avgsig = avgsig + sig.signal
avgsig = old_div(avgsig, len(id_sigs))
# Plot the average signal of this recording point
ax = f.add_subplot(4, 4, n + 1)
ax.plot(
old_div(np.arange(len(avgsig)), sig.sampling_rate) * 1000, avgsig)
#ax.set_ylim((-250, 250))
ax.set_title(tt)
if save_fig_name is None:
plt.show()
else:
plt.savefig(save_fig_name)
plt.close()
def select_segments_by_trial_number(id_block, trial_numbers):
# Load all segments from block
id_segs, info_segs = OE.sql('select segment.id, segment.info from segment \
where segment.id_block = %d' % id_block)
# Extract b_trial_numbers in more useful format by strippin leading 'B'
b_trial_numbers = info_segs.astype(int) #[int(info) for info in info_segs]
# Find id_segs that match these trials
return id_segs[np.in1d(b_trial_numbers, trial_numbers)]
def run(db_name, save_fig_name=None):
"""If save_fig_name is not None, should be ex. '~/test.png' """
# Load the raw data
db = OE.open_db(url=('sqlite:///%s' % db_name))
id_blocks, = OE.sql('SELECT block.id FROM block WHERE block.name="Raw Data"')
id_block = id_blocks[0]
id_recordingpoints, rp_names = OE.sql("SELECT \
recordingpoint.id, recordingpoint.name \
FROM recordingpoint \
WHERE recordingpoint.id_block = :id_block", id_block=id_block)
f = plt.figure(figsize=(10,10))
# Process each recording point separately
for n, (id_rp,tt) in enumerate(zip(id_recordingpoints[:16], rp_names[:16])):
# Load all signals from all segments with this recording point
id_sigs, = OE.sql('SELECT analogsignal.id FROM analogsignal ' + \
'WHERE analogsignal.id_recordingpoint = :id_recordingpoint',
id_recordingpoint=id_rp)
# Average the signal
avgsig = np.zeros(OE.AnalogSignal().load(id_sigs[0]).signal.shape)
for id_sig in id_sigs:
sig = OE.AnalogSignal().load(id_sig)
avgsig = avgsig + sig.signal
avgsig = avgsig / len(id_sigs)
# Plot the average signal of this recording point
ax = f.add_subplot(4,4,n+1)
ax.plot(np.arange(len(avgsig)) / sig.sampling_rate * 1000, avgsig)
#ax.set_ylim((-250, 250))
ax.set_title(tt)
if save_fig_name is None:
plt.show()
else:
plt.savefig(save_fig_name)
plt.close()
def select_audio_signals_by_stimulus_number(id_block, stim_num,
TRIALS_INFO, side='L'):
# Find trials with stimulus number stim_num
keep_id_segs = select_segments_by_trial_number(id_block,
trial_numbers=TRIALS_INFO['TRIAL_NUMBER'][\
TRIALS_INFO['STIM_NUMBER'] == stim_num])
# Load all analogsignals of this channel
id_sigs, id_segs = OE.sql('select analogsignal.id, analogsignal.id_segment \
from analogsignal where analogsignal.name like "' \
+ side + ' Speaker %"')
# Grab analog signals where id_segs matches keep_id_segs
keep_id_sigs = id_sigs[np.in1d(id_segs.astype(int),
keep_id_segs.astype(int))]
speaker_traces = [OE.AnalogSignal().load(id_sig).signal \
for id_sig in keep_id_sigs]
return np.array(speaker_traces)
def execute(control_params):
# Load TRIALS_INFO
bcl = bcontrol.Bcontrol_Loader(filename=control_params['behavior_filename'],
v2_behavior=True)
bcl.load()
TRIALS_INFO = bcl.data['TRIALS_INFO']
# Open database
OE.open_db('sqlite:///%s' % control_params['db_name'])
id_blocks, = OE.sql('select block.id from block where block.name = "Raw Data"')
id_block = id_blocks[0]
pre_stim_len = int(control_params['pre_slice'] * 30000.)
stim_len = int(.250 * 30000.)
f1 = plt.figure(); f2 = plt.figure();
l_sums = dict(); r_sums = dict();
for sn in np.unique(TRIALS_INFO['STIM_NUMBER']):
# Get all signals with certain stim number
l_speaker_traces = select_audio_signals_by_stimulus_number(id_block,
sn, TRIALS_INFO, 'L')
r_speaker_traces = select_audio_signals_by_stimulus_number(id_block,
sn, TRIALS_INFO, 'R')
if sn == 6:
return l_speaker_traces, r_speaker_traces
ax = f1.add_subplot(3, 4, sn)
ax.plot(l_speaker_traces[:, pre_stim_len + np.arange(-30, 30)].transpose())
ax.set_title('L %d' % sn)
ax = f2.add_subplot(3, 4, sn)
ax.plot(r_speaker_traces[:, pre_stim_len + np.arange(-30, 30)].transpose())
ax.set_title('R %d' % sn)
slices = l_speaker_traces[:, pre_stim_len:pre_stim_len+stim_len]
l_sums[sn] = 10*np.log10((slices.astype(np.float) ** 2).sum(axis=1))
slices = r_speaker_traces[:, pre_stim_len:pre_stim_len+stim_len]
r_sums[sn] = 10*np.log10((slices.astype(np.float) ** 2).sum(axis=1))
plt.show()
# Now plot powers
plt.figure()
plt.subplot(131)
for sn in [1,2,3,4]:
plt.plot(l_sums[sn], r_sums[sn], '.')
plt.xlabel('left'); plt.ylabel('right')
plt.legend(['lo', 'hi', 'le', 'ri'], loc='best')
plt.title('Pure')
plt.subplot(132)
for sn in [5,6,7,8]:
plt.plot(l_sums[sn], r_sums[sn], '.')
plt.xlabel('left'); plt.ylabel('right')
plt.legend(['le-hi', 'ri-hi', 'le-lo', 'ri-lo'], loc='best')
plt.title('PB')
plt.subplot(133)
for sn in [9,10,11,12]:
plt.plot(l_sums[sn], r_sums[sn], '.')
plt.xlabel('left'); plt.ylabel('right')
plt.legend(['le-hi', 'ri-hi', 'le-lo', 'ri-lo'], loc='best')
plt.title('LB')
plt.show()
# Grabs spike times from db that were calculated from within OE
import OpenElectrophy as OE
import numpy as np
import matplotlib.pyplot as plt
db_name = '/home/chris/Public/20110401_CR13A_audresp_data/0327_002/datafile_CR_CR13A_110327_002.db'
#db_name = '/home/chris/Public/20110401_CR13A_audresp_data/0403_002/datafile_CR_CR13A_110403_002.db'
#db_name = '/home/chris/Public/20110401_CR13A_audresp_data/0329_002/datafile_CR_CR13A_110329_002.db'
OE.open_db(url=('sqlite:///%s' % db_name))
# Load neurons
id_block = OE.sql('select block.id from block where block.name = \
"CAR Tetrode Data"')[0][0]
id_neurons, = OE.sql('select neuron.id from neuron where neuron.id_block = \
:id_block',
id_block=id_block)
plt.figure()
bigger_spiketimes = np.array([])
for id_neuron in id_neurons:
n = OE.Neuron().load(id_neuron)
# Grab spike times from all trials (segments)
big_spiketimes = np.concatenate(\
[spiketrain.spike_times - spiketrain.t_start \
for spiketrain in n._spiketrains])
bigger_spiketimes = np.concatenate([bigger_spiketimes, big_spiketimes])
# Compute histogram
nh, x = np.histogram(big_spiketimes, bins=100)
def run(db_name, CAR=True, smooth_spikes=True):
"""Filters the data for spike extraction.
db_name: Name of the OpenElectrophy db file
CAR: If True, subtract the common-average of every channel.
smooth_spikes: If True, add an additional low-pass filtering step to
the spike filter.
"""
# Open connection to the database
OE.open_db(url=("sqlite:///%s" % db_name))
# Check that I haven't already run
id_blocks, = OE.sql("SELECT block.id FROM block WHERE block.name='CAR Tetrode Data'")
if len(id_blocks) > 0:
print "CAR Tetrode Data already exists, no need to recompute"
return
# Find the block
id_blocks, = OE.sql("SELECT block.id FROM block WHERE block.name='Raw Data'")
assert len(id_blocks) == 1
id_block = id_blocks[0]
raw_block = OE.Block().load(id_block)
# Define spike filter
# TODO: fix so that doesn't assume all sampling rates the same!
fixed_sampling_rate = OE.AnalogSignal().load(1).sampling_rate
FILTER_B, FILTER_A = define_spike_filter(fixed_sampling_rate)
# If requested, define second spike filter
if smooth_spikes is True:
FILTER_B2, FILTER_A2 = define_spike_filter_2(fixed_sampling_rate)
# Find TETRODE_CHANNELS file in data directory of db
data_dir = path.split(db_name)[0]
TETRODE_CHANNELS = get_tetrode_channels(path.join(data_dir, "TETRODE_CHANNELS"))
N_TET = len(TETRODE_CHANNELS)
# For convenience, flatten TETRODE_CHANNELS to just get worthwhile channels
GOOD_CHANNELS = [item for sublist in TETRODE_CHANNELS for item in sublist]
# Create a new block for referenced data, and save to db.
car_block = OE.Block(
name="CAR Tetrode Data", info="Raw neural data, now referenced and ordered by tetrode", fileOrigin=db_name
)
id_car_block = car_block.save()
# Make RecordingPoint for each channel, linked to tetrode number with `group`
# Also keep track of link between channel and RP with ch2rpid dict
ch2rpid = dict()
for tn, ch_list in enumerate(TETRODE_CHANNELS):
for ch in ch_list:
rp = OE.RecordingPoint(
name=("RP%d" % ch), id_block=id_car_block, trodness=len(ch_list), channel=float(ch), group=tn
)
rp_id = rp.save()
ch2rpid[ch] = rp_id
# Find all segments in the block of raw data
id_segments, = OE.sql("SELECT segment.id FROM segment " + "WHERE segment.id_block = :id_block", id_block=id_block)
# For each segment in this block, load each AnalogSignal listed in
# TETRODE channels and average
# to compute CAR. Then subtract from each AnalogSignal.
for id_segment in id_segments:
# Create a new segment in the new block with the same name
old_seg = OE.Segment().load(id_segment)
car_seg = OE.Segment(name=old_seg.name, id_block=id_car_block)
id_car_seg = car_seg.save()
# Find all AnalogSignals in this segment
id_sigs, = OE.sql(
"SELECT analogsignal.id FROM analogsignal " + "WHERE analogsignal.id_segment = :id_segment",
id_segment=id_segment,
)
# Compute average of each
running_car = 0
n_summed = 0
for id_sig in id_sigs:
sig = OE.AnalogSignal().load(id_sig)
if sig.channel not in GOOD_CHANNELS:
continue
running_car = running_car + sig.signal
n_summed = n_summed + 1
# Zero out CAR if CAR is not wanted
# TODO: eliminate the actual calculation of CAR above in this case
# For now, just want to avoid weird bugs
if CAR is False:
running_car = np.zeros(running_car.shape)
# Put the CAR into the new block
# not assigning channel, t_start, sample_rate, maybe more?
car_sig = OE.AnalogSignal(
name="CAR",
signal=running_car / n_summed,
info="CAR calculated from good channels for this segment",
id_segment=id_segment,
)
car_sig.save()
# Put all the substractions in id_car_seg
for id_sig in id_sigs:
# Load the raw signal (skip bad channels)
sig = OE.AnalogSignal().load(id_sig)
if sig.channel not in GOOD_CHANNELS:
continue
# Subtract the CAR
referenced_signal = sig.signal - car_sig.signal
# Filter!
filtered_signal = scipy.signal.filtfilt(FILTER_B, FILTER_A, referenced_signal)
if smooth_spikes is True:
filtered_signal = scipy.signal.filtfilt(FILTER_B2, FILTER_A2, filtered_signal)
# Check for infs or nans
if np.isnan(filtered_signal).any():
print "ERROR: Filtered signal contains NaN!"
if np.isinf(filtered_signal).any():
print "ERROR: Filtered signal contains Inf!"
# Store in db
new_sig = OE.AnalogSignal(
name=sig.name,
signal=filtered_signal,
info="CAR has been subtracted",
id_segment=id_car_seg,
id_recordingpoint=ch2rpid[sig.channel],
channel=sig.channel,
t_start=sig.t_start,
sampling_rate=sig.sampling_rate,
)
new_sig.save()
# Finally, copy the audio channel over from the old block
id_audio_sigs, = OE.sql(
"SELECT analogsignal.id FROM analogsignal "
+ "WHERE analogsignal.id_segment = :id_segment AND "
+ "analogsignal.name LIKE '% Speaker %'",
id_segment=id_segment,
)
for id_audio_sig in id_audio_sigs:
old_sig = OE.AnalogSignal().load(id_audio_sig)
OE.AnalogSignal(
name=old_sig.name,
signal=old_sig.signal,
id_segment=id_car_seg,
channel=old_sig.channel,
t_start=old_sig.t_start,
sampling_rate=old_sig.sampling_rate,
).save()
def run(control_params, auto_validate=True, v2_behavior=False):
# Location of data
data_dir = control_params['data_dir']
# Location of the Bcontrol file
bdata_filename = control_params['behavior_filename']
# Location of TIMESTAMPS
timestamps_filename = os.path.join(data_dir, 'TIMESTAMPS')
# Location of OE db
db_filename = control_params['db_name']
# Load timestamps calculated from audio onsets in ns5 file
ns5_times = np.loadtxt(timestamps_filename, dtype=np.int)
# Load bcontrol data (will also validate)
bcl = bcontrol.Bcontrol_Loader(filename=bdata_filename,
auto_validate=auto_validate,
v2_behavior=v2_behavior)
bcl.load()
# Grab timestamps from behavior file
b_onsets = bcl.data['onsets']
# Try to convert this stuff into the format expected by the syncer
class fake_bcl(object):
def __init__(self, onsets):
self.audio_onsets = onsets
class fake_rdl(object):
def __init__(self, onsets):
self.audio_onsets = onsets
# Convert into desired format, also throwing away first behavior onset
# We need to correct for this later.
fb = fake_bcl(b_onsets[1:])
fr = fake_rdl(ns5_times)
# Sync. Will write CORR files to disk.
# Also produces bs.map_n_to_b_masked and vice versa for trial mapping
bs = DataSession.BehavingSyncer()
bs.sync(fb, fr, force_run=True)
# Put trial numbers into OE db
db = OE.open_db('sqlite:///%s' % db_filename)
# Each segment in the db is named trial%d, corresponding to the
# ordinal TIMESTAMP, which means neural trial time.
# We want to mark it with the behavioral trial number.
# For now, put the behavioral trial number into Segment.info
# TODO: Put the skip-1 behavior into the syncer so we don't have to
# use the trick. Then we can use map_n_to_b_masked without fear.
# Note that the 1010 data is NOT missing the first trial.
# Double check that the neural TIMESTAMP matches the value in peh.
# Also, add the check_audio_waveforms functionality here so that it's
# all done at once.
id_segs, name_segs = OE.sql('select segment.id, segment.name from segment')
for id_seg, name_seg in zip(id_segs, name_segs):
# Extract neural trial number from name_seg
n_trial = int(re.search('trial(\d+)', name_seg).group(1))
# Convert to behavioral trial number
# We use the 'trial_number' field of TRIALS_INFO
# IE the original Matlab numbering of the trial
# Here we correct for the dropped first trial.
try:
b_trial = bcl.data['TRIALS_INFO']['TRIAL_NUMBER'][\
bs.map_n_to_b_masked[n_trial] + 1]
except IndexError:
# masked trial
if n_trial == 0:
print("WARNING: Assuming this is the dropped first trial")
b_trial = bcl.data['TRIALS_INFO']['TRIAL_NUMBER'][0]
else:
print("WARNING: can't find trial")
b_trial = -99
# Store behavioral trial number in the info field
seg = OE.Segment().load(id_seg)
seg.info = '%d' % b_trial
seg.save()
def run(db_name, CAR=True, smooth_spikes=True):
"""Filters the data for spike extraction.
db_name: Name of the OpenElectrophy db file
CAR: If True, subtract the common-average of every channel.
smooth_spikes: If True, add an additional low-pass filtering step to
the spike filter.
"""
# Open connection to the database
OE.open_db(url=('sqlite:///%s' % db_name))
# Check that I haven't already run
id_blocks, = OE.sql(
"SELECT block.id FROM block WHERE block.name='CAR Tetrode Data'")
if len(id_blocks) > 0:
print("CAR Tetrode Data already exists, no need to recompute")
return
# Find the block
id_blocks, = OE.sql(
"SELECT block.id FROM block WHERE block.name='Raw Data'")
assert (len(id_blocks) == 1)
id_block = id_blocks[0]
raw_block = OE.Block().load(id_block)
# Define spike filter
# TODO: fix so that doesn't assume all sampling rates the same!
fixed_sampling_rate = OE.AnalogSignal().load(1).sampling_rate
FILTER_B, FILTER_A = define_spike_filter(fixed_sampling_rate)
# If requested, define second spike filter
if smooth_spikes is True:
FILTER_B2, FILTER_A2 = define_spike_filter_2(fixed_sampling_rate)
# Find TETRODE_CHANNELS file in data directory of db
data_dir = path.split(db_name)[0]
TETRODE_CHANNELS = get_tetrode_channels(
path.join(data_dir, 'TETRODE_CHANNELS'))
N_TET = len(TETRODE_CHANNELS)
# For convenience, flatten TETRODE_CHANNELS to just get worthwhile channels
GOOD_CHANNELS = [item for sublist in TETRODE_CHANNELS for item in sublist]
# Create a new block for referenced data, and save to db.
car_block = OE.Block(\
name='CAR Tetrode Data',
info='Raw neural data, now referenced and ordered by tetrode',
fileOrigin=db_name)
id_car_block = car_block.save()
# Make RecordingPoint for each channel, linked to tetrode number with `group`
# Also keep track of link between channel and RP with ch2rpid dict
ch2rpid = dict()
for tn, ch_list in enumerate(TETRODE_CHANNELS):
for ch in ch_list:
rp = OE.RecordingPoint(name=('RP%d' % ch),
id_block=id_car_block,
trodness=len(ch_list),
channel=float(ch),
group=tn)
rp_id = rp.save()
ch2rpid[ch] = rp_id
# Find all segments in the block of raw data
id_segments, = OE.sql('SELECT segment.id FROM segment ' + \
'WHERE segment.id_block = :id_block', id_block=id_block)
# For each segment in this block, load each AnalogSignal listed in
# TETRODE channels and average
# to compute CAR. Then subtract from each AnalogSignal.
for id_segment in id_segments:
# Create a new segment in the new block with the same name
old_seg = OE.Segment().load(id_segment)
car_seg = OE.Segment(
name=old_seg.name,
id_block=id_car_block,
)
id_car_seg = car_seg.save()
# Find all AnalogSignals in this segment
id_sigs, = OE.sql('SELECT analogsignal.id FROM analogsignal ' + \
'WHERE analogsignal.id_segment = :id_segment', id_segment=id_segment)
# Compute average of each
running_car = 0
n_summed = 0
for id_sig in id_sigs:
sig = OE.AnalogSignal().load(id_sig)
if sig.channel not in GOOD_CHANNELS:
continue
running_car = running_car + sig.signal
n_summed = n_summed + 1
# Zero out CAR if CAR is not wanted
# TODO: eliminate the actual calculation of CAR above in this case
# For now, just want to avoid weird bugs
if CAR is False:
running_car = np.zeros(running_car.shape)
# Put the CAR into the new block
# not assigning channel, t_start, sample_rate, maybe more?
car_sig = OE.AnalogSignal(
name='CAR',
signal=old_div(running_car, n_summed),
info='CAR calculated from good channels for this segment',
id_segment=id_segment)
car_sig.save()
# Put all the substractions in id_car_seg
for id_sig in id_sigs:
# Load the raw signal (skip bad channels)
sig = OE.AnalogSignal().load(id_sig)
if sig.channel not in GOOD_CHANNELS:
continue
# Subtract the CAR
referenced_signal = sig.signal - car_sig.signal
# Filter!
filtered_signal = scipy.signal.filtfilt(FILTER_B, FILTER_A,
referenced_signal)
if smooth_spikes is True:
filtered_signal = scipy.signal.filtfilt(
FILTER_B2, FILTER_A2, filtered_signal)
# Check for infs or nans
if np.isnan(filtered_signal).any():
print("ERROR: Filtered signal contains NaN!")
if np.isinf(filtered_signal).any():
print("ERROR: Filtered signal contains Inf!")
# Store in db
new_sig = OE.AnalogSignal(\
name=sig.name,
signal=filtered_signal,
info='CAR has been subtracted',
id_segment=id_car_seg,
id_recordingpoint=ch2rpid[sig.channel],
channel=sig.channel,
t_start=sig.t_start,
sampling_rate=sig.sampling_rate)
new_sig.save()
# Finally, copy the audio channel over from the old block
id_audio_sigs, = OE.sql('SELECT analogsignal.id FROM analogsignal ' + \
'WHERE analogsignal.id_segment = :id_segment AND ' + \
"analogsignal.name LIKE '% Speaker %'", id_segment=id_segment)
for id_audio_sig in id_audio_sigs:
old_sig = OE.AnalogSignal().load(id_audio_sig)
OE.AnalogSignal(\
name=old_sig.name,
signal=old_sig.signal,
id_segment=id_car_seg,
channel=old_sig.channel,
t_start=old_sig.t_start,
sampling_rate=old_sig.sampling_rate).save()
def get_tetrode_block_id():
id_blocks, = OE.sql('select block.id from block where \
block.name = "Spike-filtered Data"')
return id_blocks[0]
def get_tetrode_block_id():
id_blocks, = OE.sql('select block.id from block where \
block.name = "Spike-filtered Data"')
return id_blocks[0]
# Grabs spike times from db that were calculated from within OE
import OpenElectrophy as OE
import numpy as np
import matplotlib.pyplot as plt
db_name = '/home/chris/Public/20110401_CR13A_audresp_data/0327_002/datafile_CR_CR13A_110327_002.db'
#db_name = '/home/chris/Public/20110401_CR13A_audresp_data/0403_002/datafile_CR_CR13A_110403_002.db'
#db_name = '/home/chris/Public/20110401_CR13A_audresp_data/0329_002/datafile_CR_CR13A_110329_002.db'
OE.open_db(url=('sqlite:///%s' % db_name))
# Load neurons
id_block = OE.sql('select block.id from block where block.name = \
"CAR Tetrode Data"')[0][0]
id_neurons, = OE.sql('select neuron.id from neuron where neuron.id_block = \
:id_block', id_block=id_block)
plt.figure()
bigger_spiketimes = np.array([])
for id_neuron in id_neurons:
n = OE.Neuron().load(id_neuron)
# Grab spike times from all trials (segments)
big_spiketimes = np.concatenate(\
[spiketrain.spike_times - spiketrain.t_start \
for spiketrain in n._spiketrains])
bigger_spiketimes = np.concatenate([bigger_spiketimes, big_spiketimes])
# Compute histogram
nh, x = np.histogram(big_spiketimes, bins=100)
x = np.diff(x) + x[:-1]
def run(control_params, auto_validate=True, v2_behavior=False):
# Location of data
data_dir = control_params['data_dir']
# Location of the Bcontrol file
bdata_filename = control_params['behavior_filename']
# Location of TIMESTAMPS
timestamps_filename = os.path.join(data_dir, 'TIMESTAMPS')
# Location of OE db
db_filename = control_params['db_name']
# Load timestamps calculated from audio onsets in ns5 file
ns5_times = np.loadtxt(timestamps_filename, dtype=np.int)
# Load bcontrol data (will also validate)
bcl = bcontrol.Bcontrol_Loader(filename=bdata_filename,
auto_validate=auto_validate, v2_behavior=v2_behavior)
bcl.load()
# Grab timestamps from behavior file
b_onsets = bcl.data['onsets']
# Try to convert this stuff into the format expected by the syncer
class fake_bcl:
def __init__(self, onsets):
self.audio_onsets = onsets
class fake_rdl:
def __init__(self, onsets):
self.audio_onsets = onsets
# Convert into desired format, also throwing away first behavior onset
# We need to correct for this later.
fb = fake_bcl(b_onsets[1:])
fr = fake_rdl(ns5_times)
# Sync. Will write CORR files to disk.
# Also produces bs.map_n_to_b_masked and vice versa for trial mapping
bs = DataSession.BehavingSyncer()
bs.sync(fb, fr, force_run=True)
# Put trial numbers into OE db
db = OE.open_db('sqlite:///%s' % db_filename)
# Each segment in the db is named trial%d, corresponding to the
# ordinal TIMESTAMP, which means neural trial time.
# We want to mark it with the behavioral trial number.
# For now, put the behavioral trial number into Segment.info
# TODO: Put the skip-1 behavior into the syncer so we don't have to
# use the trick. Then we can use map_n_to_b_masked without fear.
# Note that the 1010 data is NOT missing the first trial.
# Double check that the neural TIMESTAMP matches the value in peh.
# Also, add the check_audio_waveforms functionality here so that it's
# all done at once.
id_segs, name_segs = OE.sql('select segment.id, segment.name from segment')
for id_seg, name_seg in zip(id_segs, name_segs):
# Extract neural trial number from name_seg
n_trial = int(re.search('trial(\d+)', name_seg).group(1))
# Convert to behavioral trial number
# We use the 'trial_number' field of TRIALS_INFO
# IE the original Matlab numbering of the trial
# Here we correct for the dropped first trial.
try:
b_trial = bcl.data['TRIALS_INFO']['TRIAL_NUMBER'][\
bs.map_n_to_b_masked[n_trial] + 1]
except IndexError:
# masked trial
if n_trial == 0:
print "WARNING: Assuming this is the dropped first trial"
b_trial = bcl.data['TRIALS_INFO']['TRIAL_NUMBER'][0]
else:
print "WARNING: can't find trial"
b_trial = -99
# Store behavioral trial number in the info field
seg = OE.Segment().load(id_seg)
seg.info = '%d' % b_trial
seg.save()
