def query_sessions(task='all', stable=False, as_dataframe=False,
force_cutoff=False, criterion='biased'):
"""
Query all sessions for analysis of behavioral data
Parameters
----------
task: string indicating sessions of which task to return, can be trianing or biased
default is all
stable: boolean if True only return sessions with stable hardware, which means
sessions after particular date (default is False)
as_dataframe: boolean if True returns a pandas dataframe (default is False)
force_cutoff: whether the animal had to reach the criterion by the 30th of Nov. Only
applies to biased and ready for ephys criterion
criterion: what criterion by the 30th of November - trained (includes
a and b), biased, ready (includes ready4ephysrig, ready4delay and
ready4recording)
"""
from ibl_pipeline import acquisition
# Query sessions
if force_cutoff is True:
use_subjects = query_subjects(criterion=criterion).proj('subject_uuid')
else:
use_subjects = query_subjects().proj('subject_uuid')
# Query all sessions or only training or biased if required
if task == 'all':
sessions = acquisition.Session * use_subjects & 'task_protocol NOT LIKE "%habituation%"'
elif task == 'training':
sessions = acquisition.Session * use_subjects & 'task_protocol LIKE "%training%"'
elif task == 'biased':
sessions = acquisition.Session * use_subjects & 'task_protocol LIKE "%biased%"'
elif task == 'ephys':
sessions = acquisition.Session * use_subjects & 'task_protocol LIKE "%ephys%"'
else:
raise ValueError('task must be "all", "training" or "biased"')
# Only use sessions up until the end of December
sessions = sessions & 'date(session_start_time) <= "%s"' % CUTOFF_DATE
# Exclude weird sessions
sessions = sessions & dj.Not([{'session_uuid': u_id} for u_id in EXCLUDED_SESSIONS])
# If required only output sessions with stable hardware
if stable is True:
sessions = sessions & 'date(session_start_time) > "%s"' % STABLE_HW_DATE
# Transform into pandas Dataframe if requested
if as_dataframe is True:
sessions = sessions.fetch(
order_by='institution_short, subject_nickname, session_start_time', format='frame')
sessions = sessions.reset_index()
return sessions
def query_sessions_around_criterion(criterion='trained', days_from_criterion=(2, 0),
as_dataframe=False, force_cutoff=False):
"""
Query all sessions for analysis of behavioral data
Parameters
----------
criterion: string indicating which criterion to use: trained, biased or ephys
days_from_criterion: two-element array which indicates which training days around the day
the mouse reached criterium to return, e.g. [3, 2] returns three days
before criterium reached up until 2 days after (default: [2, 0])
as_dataframe: return sessions as a pandas dataframe
force_cutoff: whether the animal had to reach the criterion by the 30th of Nov. Only
applies to biased and ready for ephys criterion
Returns
---------
sessions: The sessions around the criterion day, works in conjunction with
any table that has session_start_time as primary key (such as
behavior.TrialSet.Trial)
days: The training days around the criterion day. Can be used in conjunction
with tables that have session_date as primary key (such as
behavior_analysis.BehavioralSummaryByDate)
"""
from ibl_pipeline import subject, acquisition
from ibl_pipeline.analyses import behavior as behavior_analysis
# Query all included subjects
if force_cutoff is True:
use_subjects = query_subjects(criterion=criterion).proj('subject_uuid')
else:
use_subjects = query_subjects().proj('subject_uuid')
# Query per subject the date at which the criterion is reached
sessions = acquisition.Session * behavior_analysis.SessionTrainingStatus
if criterion == 'trained':
restriction = 'training_status="trained_1a" OR training_status="trained_1b"'
elif criterion == 'biased':
restriction = 'task_protocol LIKE "%biased%"'
elif criterion == 'ephys':
restriction = 'training_status LIKE "ready%"'
else:
raise ValueError('criterion must be "trained", "biased" or "ephys"')
subj_crit = (subject.Subject * use_subjects).aggr(
sessions & restriction, 'subject_nickname', date_criterion='min(date(session_start_time))')
# Query the training day at which criterion is reached
subj_crit_day = (dj.U('subject_uuid', 'day_of_crit')
& (behavior_analysis.BehavioralSummaryByDate * subj_crit
& 'session_date=date_criterion').proj(day_of_crit='training_day'))
# Query days around the day at which criterion is reached
days = (behavior_analysis.BehavioralSummaryByDate * subject.Subject * subj_crit_day
& ('training_day - day_of_crit between %d and %d'
% (-days_from_criterion[0], days_from_criterion[1]))).proj(
'subject_uuid', 'subject_nickname', 'session_date')
# Use dates to query sessions
ses_query = acquisition.Session.aggr(
days, from_date='min(session_date)', to_date='max(session_date)')
sessions = (acquisition.Session * ses_query & 'date(session_start_time) >= from_date'
& 'date(session_start_time) <= to_date')
# Exclude weird sessions
sessions = sessions & dj.Not([{'session_uuid': u_id} for u_id in EXCLUDED_SESSIONS])
# Transform to pandas dataframe if necessary
if as_dataframe is True:
sessions = sessions.fetch(format='frame').reset_index()
days = days.fetch(format='frame').reset_index()
return sessions, days
class NeuronEvenRate(dj.Computed):
definition = """
# Aligned neuron single-trial firing rates for even trials.
-> NeuronSpikeRaster
-> pacman_processing.FilterParams
---
neuron_rate: longblob # neuron trial-aligned firing rate (spikes/s)
"""
# process per neuron/condition
key_source = processing.Neuron \
* pacman_acquisition.Behavior.Condition \
* pacman_processing.FilterParams \
& NeuronSpikeRaster & (pacman_acquisition.Behavior.Trial & dj.Not('trial % 2'))
def make(self, key):
# fetch behavior and ephys sample rates
fs_beh = int((acquisition.BehaviorRecording
& key).fetch1('behavior_recording_sample_rate'))
fs_ephys = int((acquisition.EphysRecording
& key).fetch1('ephys_recording_sample_rate'))
# fetch condition time (behavior time base)
t_beh = (pacman_acquisition.Behavior.Condition
& key).fetch1('condition_time')
n_samples = len(t_beh)
# make condition time in ephys time base
t_ephys, _ = pacman_acquisition.ConditionParams.target_force_profile(
key['condition_id'], fs_ephys)
# fetch spike rasters (ephys time base)
spike_raster_keys = (NeuronSpikeRaster & key).fetch(as_dict=True)
# rebin spike raster to behavior time base
time_bin_edges = np.append(
t_beh, t_beh[-1] + (1 + np.arange(2)) / fs_beh) - 1 / (2 * fs_beh)
spike_bins = [np.digitize(t_ephys[spike_raster_key['neuron_spike_raster']], time_bin_edges) - 1 \
for spike_raster_key in spike_raster_keys]
spike_bins = [b[(b >= 0) & (b < len(t_beh))] for b in spike_bins]
for spike_raster_key, spk_bins in zip(spike_raster_keys, spike_bins):
spike_raster_key['neuron_spike_raster'] = np.zeros(n_samples,
dtype=bool)
spike_raster_key['neuron_spike_raster'][spk_bins] = 1
# get filter kernel
filter_key = (processing.Filter &
(pacman_processing.FilterParams & key)).fetch1('KEY')
filter_parts = datajointutils.get_parts(processing.Filter,
context=inspect.currentframe())
filter_rel = next(part for part in filter_parts if part & filter_key)
# filter rebinned spike raster
neuron_rate_keys = spike_raster_keys.copy()
[
neuron_rate_key.update(
filter_params_id=key['filter_params_id'],
neuron_rate=fs_beh * (filter_rel & filter_key).filt(
neuron_rate_key['neuron_spike_raster'], fs_beh))
for neuron_rate_key in neuron_rate_keys
]
# remove spike rasters
[
neuron_rate_key.pop('neuron_spike_raster')
for neuron_rate_key in neuron_rate_keys
]
# insert neuron rates
self.insert(neuron_rate_keys, skip_duplicates=True)