def get_contrastLR(session_path, save=False, data=False):
"""
Get left and right contrasts from raw datafile
**Optional:** save _ibl_trials.contrastLeft.npy and
_ibl_trials.contrastRight.npy to alf folder.
Uses signed_contrast to create left and right contrast vectors.
:param session_path: absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:type save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
contrastLeft = np.array([t['signed_contrast'] for t in data])
contrastRight = contrastLeft.copy()
contrastLeft[contrastLeft > 0] = np.nan
contrastLeft = np.abs(contrastLeft)
contrastRight[contrastRight < 0] = np.nan
# save if needed
check_alf_folder(session_path)
if raw.save_bool(save, '_ibl_trials.contrastLeft.npy'):
lpath = os.path.join(session_path, 'alf',
'_ibl_trials.contrastLeft.npy')
np.save(lpath, contrastLeft)
if raw.save_bool(save, '_ibl_trials.contrastRight.npy'):
rpath = os.path.join(session_path, 'alf',
'_ibl_trials.contrastRight.npy')
np.save(rpath, contrastRight)
return (contrastLeft, contrastRight)
def get_wheel_data(session_path, save=False):
"""
Get wheel data from raw files and converts positions into centimeters and
timestamps into seconds.
**Optional:** saves _ibl_wheel.times.npy and _ibl_wheel.position.npy
Times:
Gets Rotary Encoder timestamps (ms) for each position and converts to times.
Uses time_converter to extract and convert timstamps (ms) to times (s).
Positions:
Positions are in (cm) of RE perimeter relative to 0. The 0 resets every trial.
cmtick = radius (cm) * 2 * pi / n_ticks
cmtick = 3.1 * 2 * np.pi / 1024
:param session_path: absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:type save: bool, optional
:return: Numpy structured array.
:rtype: numpy.ndarray
"""
df = raw.load_encoder_positions(session_path)
names = df.columns.tolist()
data = structarr(names, shape=(df.index.max() + 1, ))
data['re_ts'] = df.re_ts.values
data['re_pos'] = df.re_pos.values
data['bns_ts'] = df.bns_ts.values
# ticks to cm factor
cmtick = 3.1 * 2 * np.pi / 1024
# Convert position and timestamps to cm and seconds respectively
data['re_ts'] = data['re_ts'] / 1000.
data['re_pos'] = data['re_pos'] * cmtick
# Find timestamps that are repeated
rep_idx = np.where(np.diff(data['re_ts']) == 0)[0]
# Change the value of the repeated position
data['re_pos'][rep_idx] = (data['re_pos'][rep_idx] +
data['re_pos'][rep_idx + 1]) / 2
# get the converter function to translate re_ts into behavior times
convtime = time_converter_session(session_path, kind='re2b')
data['re_ts'] = convtime(data['re_ts'])
# Now remove the repeted times that are rep_idx + 1
data = np.delete(data, rep_idx + 1)
check_alf_folder(session_path)
if raw.save_bool(save, '_ibl_wheel.timestamps.npy'):
tpath = os.path.join(session_path, 'alf', '_ibl_wheel.timestamps.npy')
np.save(tpath, data['re_ts'])
if raw.save_bool(save, '_ibl_wheel.position.npy'):
ppath = os.path.join(session_path, 'alf', '_ibl_wheel.position.npy')
np.save(ppath, data['re_pos'])
return data
def get_feedback_times(session_path, save=False, data=False, settings=False):
"""
Get the times the water or error tone was delivered to the animal.
**Optional:** saves _ibl_trials.feedback_times.npy
Gets reward and error state init times vectors,
checks if theintersection of nans is empty, then
merges the 2 vectors.
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
# Version check
if version.ge(settings['IBLRIG_VERSION_TAG'], '5.0.0'):
merge = get_feedback_times_ge5(session_path, data=data)
else:
merge = get_feedback_times_lt5(session_path, data=data)
if raw.save_bool(save, '_ibl_trials.feedback_times.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf', '_ibl_trials.feedback_times.npy')
np.save(fpath, merge)
return np.array(merge)
def get_velocity(session_path, save=False, data_wheel=None):
"""
Compute velocity from non-uniformly acquired positions and timestamps.
**Optional:** save _ibl_trials.velocity.npy
Uses signed_contrast to create left and right contrast vectors.
:param session_path: absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:type save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not isinstance(data_wheel, np.ndarray):
data_wheel = get_wheel_data(session_path, save=False)
dp = np.diff(data_wheel['re_pos'])
dt = np.diff(data_wheel['re_ts'])
# Compute raw velocity
vel = dp / dt
# Compute velocity time scale
td = data_wheel['re_ts'][:-1] + dt / 2
# Get the true velocity function
velocity = interpolate.interp1d(td, vel, fill_value="extrapolate")
if raw.save_bool(save, '_ibl_wheel.velocity.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf', '_ibl_wheel.velocity.npy')
np.save(fpath, velocity(data_wheel['re_ts']))
return velocity(data_wheel['re_ts'])
def get_rewardVolume(session_path, save=False, data=False):
"""
Load reward volume delivered for each trial.
**Optional:** saves _ibl_trials.rewardVolume.npy
Uses reward_current to accumulate the amount of
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: numpy.ndarray
:rtype: dtype('int64')
"""
if not data:
data = raw.load_data(session_path)
trial_volume = [
x['reward_amount'] if x['trial_correct'] else 0 for x in data
]
rewardVolume = np.array(trial_volume).astype(np.float64)
assert len(rewardVolume) == len(data)
if raw.save_bool(save, '_ibl_trials.rewardVolume.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf',
'_ibl_trials.rewardVolume.npy')
np.save(fpath, rewardVolume)
return rewardVolume
def get_velocity(session_path, save=False, data_wheel=None):
"""
Compute velocity from non-uniformly acquired positions and timestamps.
**Optional:** save _ibl_trials.velocity.npy
Uses signed_contrast to create left and right contrast vectors.
:param session_path: absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:type save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not isinstance(data_wheel, np.ndarray):
data_wheel = get_wheel_data(session_path, save=False)
if data_wheel is None:
logger_.error('No wheel data for ' + str(session_path))
return None
velocity = wheel.velocity(data_wheel['re_ts'], data_wheel['re_pos'])
if raw.save_bool(save, '_ibl_wheel.velocity.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf',
'_ibl_wheel.velocity.npy')
np.save(fpath, velocity)
return velocity
def get_intervals(session_path, save=False, data=False):
"""
Trial start to trial end. Trial end includes 1 or 2 seconds of iti depending
on if the trial was correct or not.
TODO: Nick suggested the that the iti be removed from this. In this case the
end of a trial would be the same as the response time.
Also consider adding _ibl_trials.iti and _ibl_trials.deadTime
**Optional:** saves _ibl_trials.intervals.npy
Uses the corrected Trial start and Trial end timpestamp values form PyBpod.
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: 2D numpy.ndarray (col0 = start, col1 = end)
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
starts = [t['behavior_data']['Trial start timestamp'] for t in data]
ends = [t['behavior_data']['Trial end timestamp'] for t in data]
intervals = np.array([starts, ends]).T
if raw.save_bool(save, '_ibl_trials.intervals.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf', '_ibl_trials.intervals.npy')
np.save(fpath, intervals)
return intervals
def get_deadTime(session_path, save=False, data=False):
"""
Get the time between state machine exit and restart of next trial.
Uses the corrected Trial start and Trial end timpestamp values form PyBpod.
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
starts = [t['behavior_data']['Trial start timestamp'] for t in data]
ends = [t['behavior_data']['Trial end timestamp'] for t in data]
# trial_len = np.array(ends) - np.array(starts)
deadTime = np.array(starts)[1:] - np.array(ends)[:-1]
deadTime = np.append(np.array([0]), deadTime)
if raw.save_bool(save, '_ibl_trials.deadTime.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf', '_ibl_trials.deadTime.npy')
np.save(fpath, deadTime)
return deadTime
def get_iti_duration(session_path, save=False, data=False):
"""
Calculate duration of iti from state timestamps.
**Optional:** saves _ibl_trials.iti_duration.npy
Uses Trial end timestamp and get_response_times to calculate iti.
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
rt = get_response_times(session_path, save=False, data=False)
ends = np.array([t['behavior_data']['Trial end timestamp'] for t in data])
iti_dur = ends - rt
if raw.save_bool(save, '_ibl_trials.itiDuration.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf',
'_ibl_trials.itiDuration.npy')
np.save(fpath, iti_dur)
return iti_dur
def get_stimOn_times(session_path, save=False, data=False, settings=False):
"""
Find the time of the statemachine command to turn on hte stim
(state stim_on start or rotary_encoder_event2)
Find the next frame change from the photodiodeafter that TS.
Screen is not displaying anything until then.
(Frame changes are in BNC1High and BNC1Low)
"""
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
# Version check
if version.ge(settings['IBLRIG_VERSION_TAG'], '5.0.0'):
stimOn_times = get_stimOn_times_ge5(session_path, data=data)
else:
stimOn_times = get_stimOn_times_lt5(session_path, data=data)
if raw.save_bool(save, '_ibl_trials.stimOn_times.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf',
'_ibl_trials.stimOn_times.npy')
np.save(fpath, np.array(stimOn_times))
return np.array(stimOn_times)
def get_intervals(session_path, save=False, data=False, settings=False):
"""
Trial start to trial end. Trial end includes 1 or 2 seconds after feedback,
(depending on the feedback) and 0.5 seconds of iti.
**Optional:** saves _ibl_trials.intervals.npy
Uses the corrected Trial start and Trial end timpestamp values form PyBpod.
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: 2D numpy.ndarray (col0 = start, col1 = end)
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
starts = [t['behavior_data']['Trial start timestamp'] for t in data]
ends = [t['behavior_data']['Trial end timestamp'] for t in data]
intervals = np.array([starts, ends]).T
if raw.save_bool(save, '_ibl_trials.intervals.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf', '_ibl_trials.intervals.npy')
np.save(fpath, intervals)
return intervals
def get_response_times(session_path, save=False, data=False):
"""
Time (in absolute seconds from session start) when a response was recorded.
**Optional:** saves _ibl_trials.response_times.npy
Uses the timestamp of the end of the closed_loop state.
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
rt = np.array([
tr['behavior_data']['States timestamps']['closed_loop'][0][1]
for tr in data
])
if raw.save_bool(save, '_ibl_trials.response_times.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf',
'_ibl_trials.response_times.npy')
np.save(fpath, rt)
return rt
def get_goCueOnset_times(session_path, save=False, data=False):
"""
Get trigger times of goCue from state machine.
Current software solution for triggering sounds uses PyBpod soft codes.
Delays can be in the order of 10's of ms. This is the time when the command
to play the sound was executed. To measure accurate time, either getting the
sound onset from the future microphone OR the new xonar soundcard and
setup developed by Sanworks guarantees a set latency (in testing).
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
goCue = np.array([
tr['behavior_data']['States timestamps']['closed_loop'][0][0]
for tr in data
])
if raw.save_bool(save, '_ibl_trials.goCue_times.npy'):
check_alf_folder(session_path)
fpath = Path(session_path).joinpath('alf',
'_ibl_trials.goCue_times.npy')
np.save(fpath, goCue)
return goCue
def get_choice(session_path, save=False, data=False):
"""
Get the subject's choice in every trial.
**Optional:** saves _ibl_trials.choice.npy to alf folder.
Uses signed_contrast and trial_correct.
-1 is a CCW turn (towards the left)
+1 is a CW turn (towards the right)
0 is a no_go trial
If a trial is correct the choice of the animal was the inverse of the sign
of the contrast.
>>> choice[t] = -np.sign(signed_contrast[t]) if trial_correct[t]
:param session_path: absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:type save: bool, optional
:return: numpy.ndarray
:rtype: dtype('int64')
"""
if not data:
data = raw.load_data(session_path)
sitm_side = np.array([np.sign(t['signed_contrast']) for t in data])
trial_correct = np.array([t['trial_correct'] for t in data])
choice = sitm_side.copy()
choice[trial_correct] = -choice[trial_correct]
choice = choice.astype(int)
if raw.save_bool(save, '_ibl_trials.choice.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf', '_ibl_trials.choice.npy')
np.save(fpath, choice)
return choice
def get_probabilityLeft(session_path, save=False, data=False, settings=False):
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None:
settings = {"IBLRIG_VERSION_TAG": "100.0.0"}
elif settings["IBLRIG_VERSION_TAG"] == "":
settings.update({"IBLRIG_VERSION_TAG": "100.0.0"})
num = settings.get("PRELOADED_SESSION_NUM", None)
if num is None:
num = settings.get("PREGENERATED_SESSION_NUM", None)
if num is None:
fn = settings.get('SESSION_LOADED_FILE_PATH', None)
fn = PureWindowsPath(fn).name
num = ''.join([d for d in fn if d.isdigit()])
if num == '':
raise ValueError("Can't extract left probability behaviour.")
# Load the pregenerated file
sessions_folder = Path(raw.__file__).parent.joinpath(
'extractors', 'ephys_sessions')
fname = f"session_{num}_ephys_pcqs.npy"
pcqsp = np.load(sessions_folder.joinpath(fname))
pLeft = pcqsp[:, 4]
pLeft = pLeft[:len(data)]
if raw.save_bool(save, "_ibl_trials.probabilityLeft.npy"):
lpath = Path(session_path).joinpath("alf",
"_ibl_trials.probabilityLeft.npy")
np.save(lpath, pLeft)
return pLeft
def get_goCueOnset_times(session_path, save=False, data=False, settings=False):
"""
Get trigger times of goCue from state machine.
Current software solution for triggering sounds uses PyBpod soft codes.
Delays can be in the order of 10's of ms. This is the time when the command
to play the sound was executed. To measure accurate time, either getting the
sound onset from the future microphone OR the new xonar soundcard and
setup developed by Sanworks guarantees a set latency (in testing).
:param session_path: Absolute path of session folder
:type session_path: str
:param save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
go_cue_times = np.zeros([
len(data),
])
for ind, tr in enumerate(data):
if get_port_events(tr, 'BNC2'):
bnchigh = tr['behavior_data']['Events timestamps'].get(
'BNC2High', None)
if bnchigh:
go_cue_times[ind] = bnchigh[0]
continue
bnclow = tr['behavior_data']['Events timestamps'].get(
'BNC2Low', None)
if bnclow:
go_cue_times[ind] = bnclow[0] - 0.1
continue
go_cue_times[ind] = np.nan
else:
go_cue_times[ind] = np.nan
nmissing = np.sum(np.isnan(go_cue_times))
# Check if all stim_syncs have failed to be detected
if np.all(np.isnan(go_cue_times)):
logger_.error(
f'{session_path}: Missing ALL BNC2 stimulus ({nmissing} trials')
# Check if any stim_sync has failed be detected for every trial
if np.any(np.isnan(go_cue_times)):
logger_.warning(
f'{session_path}: Missing BNC2 stimulus on {nmissing} trials')
if raw.save_bool(save, '_ibl_trials.goCue_times.npy'):
check_alf_folder(session_path)
fpath = Path(session_path).joinpath('alf',
'_ibl_trials.goCue_times.npy')
np.save(fpath, go_cue_times)
return go_cue_times
def get_laser(session_path, save=False, data=False):
if not data:
data = raw.load_data(session_path)
laser_on = np.array([t['laser_on'] for t in data])
if raw.save_bool(save, '_ibl_trials.laseron.npy'):
lpath = Path(session_path).joinpath('alf', '_ibl_trials.laseron.npy')
np.save(lpath, laser_on)
return laser_on
def get_stimOn_times(session_path, save=False, data=False):
"""
Find the time of the statemachine command to turn on hte stim
(state stim_on start or rotary_encoder_event2)
Find the next frame change from the photodiodeafter that TS.
Screen is not displaying anything until then.
(Frame changes are in BNC1High and BNC1Low)
"""
if not data:
data = raw.load_data(session_path)
stim_on = []
bnc_h = []
bnc_l = []
for tr in data:
stim_on.append(
tr['behavior_data']['States timestamps']['stim_on'][0][0])
if 'BNC1High' in tr['behavior_data']['Events timestamps'].keys():
bnc_h.append(
np.array(tr['behavior_data']['Events timestamps']['BNC1High']))
else:
bnc_h.append(np.array([np.NINF]))
if 'BNC1Low' in tr['behavior_data']['Events timestamps'].keys():
bnc_l.append(
np.array(tr['behavior_data']['Events timestamps']['BNC1Low']))
else:
bnc_l.append(np.array([np.NINF]))
stim_on = np.array(stim_on)
bnc_h = np.array(bnc_h)
bnc_l = np.array(bnc_l)
count_missing = 0
stimOn_times = np.zeros_like(stim_on)
for i in range(len(stim_on)):
hl = np.sort(np.concatenate([bnc_h[i], bnc_l[i]]))
stot = hl[hl > stim_on[i]]
if np.size(stot) == 0:
stot = np.array([np.nan])
count_missing += 1
stimOn_times[i] = stot[0]
if np.all(np.isnan(stimOn_times)):
logger_.error(
f'{session_path}: Missing ALL BNC1 stimulus ({count_missing}: trials'
)
return None
if count_missing > 0:
logger_.warning(
f'{session_path}: Missing BNC1 stimulus on {count_missing} trials')
if raw.save_bool(save, '_ibl_trials.stimOn_times.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf',
'_ibl_trials.stimOn_times.npy')
np.save(fpath, np.array(stimOn_times))
return np.array(stimOn_times)
def get_included_trials(session_path, save=False, data=False):
if not data:
data = raw.load_data(session_path)
trials_included = np.array(
[t['contrast']['type'] != "RepeatContrast" for t in data])
if raw.save_bool(save, '_ibl_trials.included'):
fpath = Path(session_path).joinpath('alf', '_ibl_trials.included.npy')
np.save(fpath, trials_included)
return trials_included
def get_feedbackType(session_path, save=False, data=False):
"""
Get the feedback that was delivered to subject.
**Optional:** saves _ibl_trials.feedbackType.npy
Checks in raw datafile for error and reward state.
Will raise an error if more than one of the mutually exclusive states have
been triggered.
Sets feedbackType to -1 if error state was trigered
Sets feedbackType to -2 if correct_unreward state was triggered
Sets feedbackType to +1 if correct_reward state was triggered
Sets feedbackType to 0 if no_go state was triggered
:param session_path: absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:type save: bool, optional
:return: numpy.ndarray
:rtype: dtype('int64')
"""
if not data:
data = raw.load_data(session_path)
feedbackType = np.empty(len(data))
feedbackType.fill(np.nan)
correct_rewarded = []
correct_unrewarded = []
error = []
no_go = []
for t in data:
correct_rewarded.append(~np.isnan(
t['behavior_data']['States timestamps']['correct_rewarded'][0][0]))
correct_unrewarded.append(
~np.isnan(t['behavior_data']['States timestamps']
['correct_unrewarded'][0][0]))
error.append(
~np.isnan(t['behavior_data']['States timestamps']['error'][0][0]))
no_go.append(
~np.isnan(t['behavior_data']['States timestamps']['no_go'][0][0]))
if not all(
np.sum([correct_rewarded, correct_unrewarded, error, no_go],
axis=0) == np.ones(len(data))):
raise ValueError
feedbackType[correct_rewarded] = 1
feedbackType[correct_unrewarded] = -2
feedbackType[error] = -1
feedbackType[no_go] = 0
feedbackType = feedbackType.astype('int64')
if raw.save_bool(save, '_ibl_trials.feedbackType.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf',
'_ibl_trials.feedbackType.npy')
np.save(fpath, feedbackType)
return feedbackType
def get_rew_probaLR(session_path, save=False, data=False):
if not data:
data = raw.load_data(session_path)
p_rew_Left = np.array([t['rew_probability_left'] for t in data])
p_rew_Right = np.array( [1 if x == 0.7 else 0.5 if x==0.5 else 0.7 for x in p_rew_Left])
if raw.save_bool(save, '_ibl_trials.rewprobabilityLeft.npy'):
lpath = Path(session_path).joinpath('alf', '_ibl_trials.rewprobabilityLeft.npy')
np.save(lpath, p_rew_Left)
return p_rew_Left, p_rew_Right
def get_contrastLR(session_path, save=False, data=False, settings=False):
"""
Get left and right contrasts from raw datafile. Optionally, saves
_ibl_trials.contrastLeft.npy and _ibl_trials.contrastRight.npy to alf folder.
Uses signed_contrast to create left and right contrast vectors.
:param session_path: absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:type save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
contrastLeft = np.array([
t['contrast']['value'] if np.sign(t['position']) < 0 else np.nan
for t in data
])
contrastRight = np.array([
t['contrast']['value'] if np.sign(t['position']) > 0 else np.nan
for t in data
])
# save if needed
check_alf_folder(session_path)
if raw.save_bool(save, '_ibl_trials.contrastLeft.npy'):
lpath = os.path.join(session_path, 'alf',
'_ibl_trials.contrastLeft.npy')
np.save(lpath, contrastLeft)
if raw.save_bool(save, '_ibl_trials.contrastRight.npy'):
rpath = os.path.join(session_path, 'alf',
'_ibl_trials.contrastRight.npy')
np.save(rpath, contrastRight)
return (contrastLeft, contrastRight)
def get_probaLR(session_path, save=False, data=False):
if not data:
data = raw.load_data(session_path)
pLeft = np.array([t['stim_probability_left'] for t in data])
pRight = 1 - pLeft
if raw.save_bool(save, '_ibl_trials.probabilityLeft.npy'):
lpath = Path(session_path).joinpath('alf',
'_ibl_trials.probabilityLeft.npy')
np.save(lpath, pLeft)
return pLeft, pRight
def get_probabilityLeft(session_path, save=False, data=False, settings=False):
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
pLeft = np.array([t['stim_probability_left'] for t in data])
if raw.save_bool(save, '_ibl_trials.probabilityLeft.npy'):
lpath = Path(session_path).joinpath('alf', '_ibl_trials.probabilityLeft.npy')
np.save(lpath, pLeft)
return pLeft
def get_opto(session_path, save=False, data=False, settings=False):
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
opto_probability_left = np.array([t['opto_probability_left'] for t in data])
if raw.save_bool(save, '_ibl_trials.opto_probability_left.npy'):
lpath = Path(session_path).joinpath('alf', '_ibl_trials.opto_probability_left.npy')
np.save(lpath, opto_probability_left)
opto = fix_opto(Path(session_path).joinpath('alf'))
# opto = np.array([t['opto'] for t in data]) - old before stable opto protocol
if raw.save_bool(save, '_ibl_trials.opto.npy'):
lpath = Path(session_path).joinpath('alf', '_ibl_trials.opto.npy')
np.save(lpath, opto)
dummy_opto = np.array([t['opto'] for t in data]) #Same as opto but not buffer saved
if raw.save_bool(save, '_ibl_trials.dummy_opto.npy'):
lpath = Path(session_path).joinpath('alf', '_ibl_trials.opto_dummy.npy')
np.save(lpath, dummy_opto)
return opto,opto_probability_left, dummy_opto
def get_feedback_times(session_path, save=False, data=False):
"""
Get the times the water or error tone was delivered to the animal.
**Optional:** saves _ibl_trials.feedback_times.npy
Gets reward and error state init times vectors,
checks if theintersection of nans is empty, then
merges the 2 vectors.
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
c_rw_times = [
tr['behavior_data']['States timestamps']['correct_rewarded'][0][0]
for tr in data
]
c_urw_times = [
tr['behavior_data']['States timestamps']['correct_unrewarded'][0][0]
for tr in data
]
err_times = [
tr['behavior_data']['States timestamps']['error'][0][0] for tr in data
]
nogo_times = [
tr['behavior_data']['States timestamps']['no_go'][0][0] for tr in data
]
assert sum(
np.isnan(c_rw_times) & np.isnan(c_urw_times) & np.isnan(err_times)
& np.isnan(nogo_times)) == 0
merge = np.array([
np.array(times)[~np.isnan(times)]
for times in zip(c_rw_times, c_urw_times, err_times, nogo_times)
]).squeeze()
if raw.save_bool(save, '_ibl_trials.feedback_times.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf',
'_ibl_trials.feedback_times.npy')
np.save(fpath, merge)
return np.array(merge)
def get_included_trials(session_path, save=False, data=False, settings=False):
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
if version.ge(settings['IBLRIG_VERSION_TAG'], '5.0.0'):
trials_included = get_included_trials_ge5(session_path, data=data, settings=settings)
else:
trials_included = get_included_trials_lt5(session_path, data=data)
if raw.save_bool(save, '_ibl_trials.included'):
fpath = Path(session_path).joinpath('alf', '_ibl_trials.included.npy')
np.save(fpath, trials_included)
return trials_included
def get_goCueTrigger_times(session_path,
save=False,
data=False,
settings=False):
"""
Get trigger times of goCue from state machine.
Current software solution for triggering sounds uses PyBpod soft codes.
Delays can be in the order of 10's of ms. This is the time when the command
to play the sound was executed. To measure accurate time, either getting the
sound onset from xonar soundcard sync pulse (latencies may vary).
:param session_path: Absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:param save: bool, optional
:return: numpy.ndarray
:rtype: dtype('float64')
"""
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
# Version check
if version.ge(settings['IBLRIG_VERSION_TAG'], '5.0.0'):
goCue = np.array([
tr['behavior_data']['States timestamps']['play_tone'][0][0]
for tr in data
])
else:
goCue = np.array([
tr['behavior_data']['States timestamps']['closed_loop'][0][0]
for tr in data
])
if raw.save_bool(save, '_ibl_trials.goCue_times.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf',
'_ibl_trials.goCueTrigger_times.npy')
np.save(fpath, goCue)
return goCue
def get_stimOnTrigger_times(session_path, save=False, data=False, settings=False):
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
# Get the stim_on_state that triggers the onset of the stim
stim_on_state = np.array([tr['behavior_data']['States timestamps']
['stim_on'][0] for tr in data])
stimOnTrigger_times = stim_on_state[:, 0].T
if raw.save_bool(save, '_ibl_trials.stimOnTrigger_times.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf', '_ibl_trials.stimOnTrigger_times.npy')
np.save(fpath, np.array(stimOnTrigger_times))
return stimOnTrigger_times
def get_choice(session_path, save=False, data=False, settings=False):
"""
Get the subject's choice in every trial.
**Optional:** saves _ibl_trials.choice.npy to alf folder.
Uses signed_contrast and trial_correct.
-1 is a CCW turn (towards the left)
+1 is a CW turn (towards the right)
0 is a no_go trial
If a trial is correct the choice of the animal was the inverse of the sign
of the position.
>>> choice[t] = -np.sign(position[t]) if trial_correct[t]
:param session_path: absolute path of session folder
:type session_path: str
:param save: wether to save the corresponding alf file
to the alf folder, defaults to False
:type save: bool, optional
:return: numpy.ndarray
:rtype: dtype('int64')
"""
if not data:
data = raw.load_data(session_path)
if not settings:
settings = raw.load_settings(session_path)
if settings is None or settings['IBLRIG_VERSION_TAG'] == '':
settings = {'IBLRIG_VERSION_TAG': '100.0.0'}
sitm_side = np.array([np.sign(t['position']) for t in data])
trial_correct = np.array([t['trial_correct'] for t in data])
trial_nogo = np.array([
~np.isnan(t['behavior_data']['States timestamps']['no_go'][0][0])
for t in data
])
choice = sitm_side.copy()
choice[trial_correct] = -choice[trial_correct]
choice[trial_nogo] = 0
choice = choice.astype(int)
if raw.save_bool(save, '_ibl_trials.choice.npy'):
check_alf_folder(session_path)
fpath = os.path.join(session_path, 'alf', '_ibl_trials.choice.npy')
np.save(fpath, choice)
return choice