def test_get_stimulus_table(detailed, just_stimulus_table_api,
raw_stimulus_table):
session = EcephysSession(api=just_stimulus_table_api)
obtained = session.get_stimulus_table(['a'],
include_detailed_parameters=detailed)
expected_columns = [
'start_time', 'stop_time', 'stimulus_name', 'stimulus_block', 'Color',
'Phase'
]
if detailed:
expected_columns.append("texRes")
expected = raw_stimulus_table.loc[:2, expected_columns]
expected['duration'] = expected['stop_time'] - expected['start_time']
expected["stimulus_condition_id"] = [0, 1, 2]
expected.rename(columns={"Color": "color", "Phase": "phase"}, inplace=True)
print(expected)
print(obtained)
pd.testing.assert_frame_equal(expected,
obtained,
check_like=True,
check_dtype=False)
def test_conditionwise_spike_statistics_using_rates(spike_times_api):
session = EcephysSession(api=spike_times_api)
obtained = session.conditionwise_spike_statistics(
stimulus_presentation_ids=[0, 1, 2], use_rates=True)
pd.set_option('display.max_columns', None)
assert np.allclose([0, 0, 6], obtained["spike_mean"].values)
def test_conditionwise_spike_statistics(spike_times_api):
session = EcephysSession(api=spike_times_api)
obtained = session.conditionwise_spike_statistics(stimulus_presentation_ids=[0, 1, 2])
pd.set_option('display.max_columns', None)
assert obtained.loc[(2, 2), "spike_count"] == 3
assert obtained.loc[(2, 2), "stimulus_presentation_count"] == 1
def test_empty_presentationwise_spike_times(spike_times_api):
# Test that when there are no spikes presentationwise_spike_times doesn't fail and instead returns a empty dataframe
spike_times_api.get_spike_times = types.MethodType(get_no_spikes_times, spike_times_api)
session = EcephysSession(api=spike_times_api)
obtained = session.presentationwise_spike_times(session.stimulus_presentations.index.values,
session.units.index.values)
assert(isinstance(obtained, pd.DataFrame))
assert(obtained.empty)
def test_get_invalid_times(valid_stimulus_table_api, raw_invalid_times_table):
expected = raw_invalid_times_table
session = EcephysSession(api=valid_stimulus_table_api)
obtained = session.get_invalid_times()
pd.testing.assert_frame_equal(expected, obtained, check_like=True, check_dtype=False)
def test_get_stimulus_parameter_values(just_stimulus_table_api):
session = EcephysSession(api=just_stimulus_table_api)
obtained = session.get_stimulus_parameter_values()
expected = {'color': [0, 5.5, 11, 16.5], 'phase': [0, 60, 120, 180]}
for k, v in expected.items():
assert np.allclose(v, obtained[k])
assert len(expected) == len(obtained)
def test_get_lfp(channels_table_api):
session = EcephysSession(api=channels_table_api)
obtained = session.get_lfp(0)
expected = xr.DataArray(data=np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]),
dims=['channel', 'time'],
coords=[[2, 1], np.linspace(0, 2, 5)])
xr.testing.assert_equal(expected, obtained)
def test_presentationwise_spike_times(spike_times_api):
session = EcephysSession(api=spike_times_api)
obtained = session.presentationwise_spike_times(session.stimulus_presentations.index.values, session.units.index.values)
expected = pd.DataFrame({
'unit_id': [2, 2, 2],
'stimulus_presentation_id': [2, 2, 2, ],
'time_since_stimulus_presentation_onset': [0.01, 0.02, 0.03]
}, index=pd.Index(name='spike_time', data=[1.01, 1.02, 1.03]))
pd.testing.assert_frame_equal(expected, obtained, check_like=True, check_dtype=False)
def test_presentationwise_spike_counts(spike_times_api):
session = EcephysSession(api=spike_times_api)
obtained = session.presentationwise_spike_counts(np.linspace(-.1, .1, 3), session.stimulus_presentations.index.values, session.units.index.values)
first = obtained.loc[{'unit_id': 2, 'stimulus_presentation_id': 2}]
assert np.allclose([0, 3], first)
second = obtained.loc[{'unit_id': 1, 'stimulus_presentation_id': 3}]
assert np.allclose([0, 0], second)
assert np.allclose([4, 2, 3], obtained.shape)
def test_get_lfp_mask_invalid(lfp_masking_api):
session = EcephysSession(api=lfp_masking_api)
obtained = session.get_lfp(0)
expected = xr.DataArray(data=np.array([[1, 2, 3, np.nan, np.nan],
[6, 7, 8, np.nan, np.nan]]),
dims=['channel', 'time'],
coords=[[2, 1], np.linspace(0, 2, 5)])
print(expected)
print(obtained)
xr.testing.assert_equal(expected, obtained)
def test_empty_conditionwise_spike_statistics(spike_times_api):
# special case when there are no spikes
spike_times_api.get_spike_times = types.MethodType(get_no_spikes_times, spike_times_api)
session = EcephysSession(api=spike_times_api)
obtained = session.conditionwise_spike_statistics(
stimulus_presentation_ids=session.stimulus_presentations.index.values,
unit_ids=session.units.index.values
)
assert(len(obtained) == 12)
assert(not np.any(obtained['spike_count'])) # check all spike_counts are 0
assert(not np.any(obtained['spike_mean'])) # spike_means are 0
assert(np.all(np.isnan(obtained['spike_std']))) # std/sem will be undefined
assert(np.all(np.isnan(obtained['spike_sem'])))
def test_get_inter_presentation_intervals_for_stimulus(just_stimulus_table_api):
session = EcephysSession(api=just_stimulus_table_api)
obtained = session.get_inter_presentation_intervals_for_stimulus('a')
expected = pd.DataFrame({
'interval': [0, 0]
}, index=pd.MultiIndex(
levels=[[0, 1], [1, 2]],
codes=[[0, 1], [0, 1]],
names=['from_presentation_id', 'to_presentation_id']
)
)
pd.testing.assert_frame_equal(expected, obtained, check_like=True, check_dtype=False)
def test_build_units_table(units_table_api):
session = EcephysSession(api=units_table_api)
obtained = session.units
assert 3 == session.num_units
assert np.allclose([10, 22, 33], obtained['probe_vertical_position'])
assert np.allclose([0, 1, 2], obtained.index.values)
def load_session_and_get_fr_df(self):
session = EcephysSession.from_nwb_path(self.nwb_path,
api_kwargs={
"amplitude_cutoff_maximum":
0.1,
"presence_ratio_minimum":
0.9,
"isi_violations_maximum":
0.5
})
self.units_df = session.units
self.stim_table = session.get_stimulus_table(self.stim_name)
stim_pres_ids = self.stim_table.index.values
tmp_binned_spt = session.presentationwise_spike_counts\
(bin_edges = self.bin_edges, stimulus_presentation_ids=stim_pres_ids, unit_ids = session.units.index.values)
num_pres, num_bins, num_cells = tmp_binned_spt.shape
print(num_pres, num_bins, num_cells)
tot_arr_fr_all = np.reshape(tmp_binned_spt.values,
(num_pres * num_bins, num_cells))
self.tot_fr_df = pd.DataFrame(tot_arr_fr_all.T,
index=session.units.index.values)
del tmp_binned_spt, session
def test_metrics(ecephys_api):
session = EcephysSession(api=ecephys_api)
rfm = ReceptiveFieldMapping(ecephys_session=session,
minimum_spike_count=1.0,
trial_duration=0.25,
mask_threshold=0.5)
assert (isinstance(rfm.metrics, pd.DataFrame))
assert (len(rfm.metrics) == 6)
assert (rfm.metrics.index.names == ['unit_id'])
# TODO: Methods are too sensitive and will have different values depending on the version of scipy
assert ('azimuth_rf' in rfm.metrics.columns)
assert ('elevation_rf' in rfm.metrics.columns)
assert ('width_rf' in rfm.metrics.columns)
assert ('height_rf' in rfm.metrics.columns)
# Different versions of scipy will return unit 1 as either a 0.0 or a nan
#assert(np.allclose(rfm.metrics['height_rf'].loc[[0, 1, 2, 3, 4, 5]],
# [np.nan, 0.0, 129.522395, np.nan, np.nan, np.nan], equal_nan=True))
assert ('area_rf' in rfm.metrics.columns)
assert (np.allclose(rfm.metrics['area_rf'].loc[[0, 1, 2, 3, 4, 5]],
[0.0, 0.0, 0.0, np.nan, 0.0, 0.0],
equal_nan=True))
assert ('p_value_rf' in rfm.metrics.columns)
assert ('on_screen_rf' in rfm.metrics.columns)
assert ('firing_rate_rf' in rfm.metrics.columns)
assert ('fano_rf' in rfm.metrics.columns)
assert ('time_to_peak_rf' in rfm.metrics.columns)
assert ('lifetime_sparseness_rf' in rfm.metrics.columns)
assert ('run_pval_rf' in rfm.metrics.columns)
assert ('run_mod_rf' in rfm.metrics.columns)
def test_receptive_fields(ecephys_api):
# Also test_response_by_stimulus_position()
session = EcephysSession(api=ecephys_api)
rfm = ReceptiveFieldMapping(ecephys_session=session)
assert (rfm.receptive_fields)
assert (type(rfm.receptive_fields))
assert ('spike_counts' in rfm.receptive_fields)
assert (rfm.receptive_fields['spike_counts'].shape == (9, 9, 6)
) # x, y, units
assert (set(rfm.receptive_fields['spike_counts'].coords) == {
'y_position', 'x_position', 'unit_id'
})
assert (np.all(rfm.receptive_fields['spike_counts'].coords['x_position'] ==
[-40.0, -30.0, -20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0]))
assert (np.all(rfm.receptive_fields['spike_counts'].coords['y_position'] ==
[0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0]))
# Some randomly sampled testing to make sure everything works like it should
assert (rfm.receptive_fields['spike_counts'][{
'unit_id': 0
}].values.sum() == 4)
assert (rfm.receptive_fields['spike_counts'][{
'unit_id': 3
}].values.sum() == 0)
assert (rfm.receptive_fields['spike_counts'][{
'unit_id': 2,
'x_position': 8,
'y_position': 3
}] == 3)
assert (np.all(rfm.receptive_fields['spike_counts'][{
'x_position': 2,
'y_position': 5
}] == [1, 0, 0, 0, 1, 1]))
def test_bad_col_key(ecephys_api):
with pytest.raises(KeyError):
session = EcephysSession(api=ecephys_api)
sg = StaticGratings(ecephys_session=session,
col_sf='spatial_frequency',
col_phase='esahp')
sg.phasevals
def test_metrics(ecephys_api):
session = EcephysSession(api=ecephys_api)
sg = StaticGratings(ecephys_session=session)
assert (isinstance(sg.metrics, pd.DataFrame))
assert (len(sg.metrics) == 6)
assert (sg.metrics.index.names == ['unit_id'])
assert ('pref_sf_sg' in sg.metrics.columns)
assert (np.all(
sg.metrics['pref_sf_sg'].loc[[0, 2, 4]] == [0.02, 0.02, 0.04]))
assert ('pref_ori_sg' in sg.metrics.columns)
assert (np.all(
sg.metrics['pref_ori_sg'].loc[[0, 2, 4]] == [0.0, 0.0, 0.0]))
assert ('pref_phase_sg' in sg.metrics.columns)
assert (np.all(sg.metrics['pref_phase_sg'].loc[[0, 1, 2, 3]] ==
[0.25, 0.75, 0.5, 0.0]))
assert ('g_osi_sg' in sg.metrics.columns)
assert ('time_to_peak_sg' in sg.metrics.columns)
assert ('firing_rate_sg' in sg.metrics.columns)
assert ('fano_sg' in sg.metrics.columns)
assert ('lifetime_sparseness_sg' in sg.metrics.columns)
assert ('run_pval_sg' in sg.metrics.columns)
assert ('run_mod_sg' in sg.metrics.columns)
def test_conditionwise_psth(ecephys_api):
session = EcephysSession(api=ecephys_api)
stim_analysis = StimulusAnalysis(ecephys_session=session,
stimulus_key='s0',
trial_duration=0.5,
psth_resolution=0.1)
assert (isinstance(stim_analysis.conditionwise_psth, xr.DataArray))
# assert(stim_analysis.conditionwise_psth.shape == (2, 4, 6))
assert (stim_analysis.conditionwise_psth.
coords['time_relative_to_stimulus_onset'].size == 4) # 0.5/0.1 - 1
assert (stim_analysis.conditionwise_psth.coords['unit_id'].size == 6)
assert (stim_analysis.conditionwise_psth.coords['stimulus_condition_id'].
size == 2)
assert (np.allclose(
stim_analysis.conditionwise_psth[{
'unit_id': 0,
'stimulus_condition_id': 1
}].values, np.array([1.0 / 3.0, 0.0, 0.0, 0.0])))
# Make sure psth doesn't fail even when all the condition_ids are unique.
stim_analysis = StimulusAnalysis(ecephys_session=session,
stimulus_key='s1',
trial_duration=0.5,
psth_resolution=0.1)
assert (stim_analysis.conditionwise_psth.
coords['time_relative_to_stimulus_onset'].size == 4)
assert (stim_analysis.conditionwise_psth.coords['unit_id'].size == 6)
assert (stim_analysis.conditionwise_psth.coords['stimulus_condition_id'].
size == 2)
def test_get_time_to_peak(ecephys_api):
session = EcephysSession(api=ecephys_api)
stim_analysis = StimulusAnalysis(ecephys_session=session,
stimulus_key='s0',
trial_duration=0.5)
assert (stim_analysis._get_time_to_peak(
1, stim_analysis._get_preferred_condition(1)) == 0.0005)
def test_get_preferred_condition(ecephys_api):
session = EcephysSession(api=ecephys_api)
stim_analysis = StimulusAnalysis(ecephys_session=session,
stimulus_key='s0')
assert (stim_analysis._get_preferred_condition(3) == 1)
with pytest.raises(KeyError):
stim_analysis._get_preferred_condition(10)
def test_spikes(ecephys_api):
session = EcephysSession(api=ecephys_api)
stim_analysis = StimulusAnalysis(ecephys_session=session,
stimulus_key='s0')
assert (isinstance(stim_analysis.spikes, dict))
assert (stim_analysis.spikes.keys() == set(range(6)))
assert (np.allclose(stim_analysis.spikes[0], [1, 2, 3, 4]))
assert (np.allclose(stim_analysis.spikes[4],
[0.01, 1.7, 2.13, 3.19, 4.25]))
assert (stim_analysis.spikes[3].size == 0)
# Check that spikes dict is filtering units
session = EcephysSession(api=ecephys_api)
stim_analysis = StimulusAnalysis(ecephys_session=session,
stimulus_key='s0',
filter=[0, 2])
assert (stim_analysis.spikes.keys() == {0, 2})
def test_contrast_stimulus(ecephys_api_w_contrast):
session = EcephysSession(api=ecephys_api_w_contrast)
dg = DriftingGratings(ecephys_session=session)
assert (len(dg.stim_table) == 40)
assert (len(dg.stim_table_contrast) == 36)
assert (len(dg.stimulus_conditions_contrast) == 36)
assert (len(dg.conditionwise_statistics_contrast) == 36 * 6)
def test_get_stimulus_epochs(just_stimulus_table_api):
expected = pd.DataFrame({
"start_time": [0, 3/2],
"stop_time": [3/2, 2],
"duration": [3/2, 1/2],
"stimulus_name": ["a", "a_movie"],
"stimulus_block": [0, 1]
})
session = EcephysSession(api=just_stimulus_table_api)
obtained = session.get_stimulus_epochs()
print(expected)
print(obtained)
pd.testing.assert_frame_equal(expected, obtained, check_like=True, check_dtype=False)
def test_check_multiple_preferred_conditions(ecephys_api):
session = EcephysSession(api=ecephys_api)
stim_analysis = StimulusAnalysis(ecephys_session=session,
stimulus_key='s0')
assert (stim_analysis._check_multiple_pref_conditions(
0, 'conditions', [0, 1]) is False)
assert (stim_analysis._check_multiple_pref_conditions(
3, 'conditions', [0, 1]) is True)
def test_stimulus(ecephys_api):
session = EcephysSession(api=ecephys_api)
fl = Flashes(ecephys_session=session)
assert (isinstance(fl.stim_table, pd.DataFrame))
assert (len(fl.stim_table) == 16)
assert (set(fl.stim_table.columns).issuperset(
{'color', 'start_time', 'stop_time'}))
assert (all(fl.colors == [-1.0, 1.0]))
assert (fl.number_colors == 2)
def test_load(ecephys_api):
session = EcephysSession(api=ecephys_api)
fl = Flashes(ecephys_session=session)
assert (fl.name == 'Flashes')
assert (set(fl.unit_ids) == set(range(6)))
assert (len(fl.conditionwise_statistics) == 2 * 6)
assert (fl.conditionwise_psth.shape == (2, 249, 6))
assert (not fl.presentationwise_spike_times.empty)
assert (len(fl.presentationwise_statistics) == 16 * 6)
assert (len(fl.stimulus_conditions) == 2)
def test_load(ecephys_api):
session = EcephysSession(api=ecephys_api)
rfm = ReceptiveFieldMapping(ecephys_session=session)
assert (rfm.name == 'Receptive Field Mapping')
assert (set(rfm.unit_ids) == set(range(6)))
assert (len(rfm.conditionwise_statistics) == 81 * 6)
assert (rfm.conditionwise_psth.shape == (81, 249, 6))
assert (not rfm.presentationwise_spike_times.empty)
assert (len(rfm.presentationwise_statistics) == 81 * 6)
assert (len(rfm.stimulus_conditions) == 81)
def test_load(ecephys_api):
session = EcephysSession(api=ecephys_api)
sg = StaticGratings(ecephys_session=session)
assert (sg.name == 'Static Gratings')
assert (set(sg.unit_ids) == set(range(6)))
assert (len(sg.conditionwise_statistics) == 120 * 6)
assert (sg.conditionwise_psth.shape == (120, 249, 6))
assert (not sg.presentationwise_spike_times.empty)
assert (len(sg.presentationwise_statistics) == 120 * 6)
assert (len(sg.stimulus_conditions) == 120)
def test_load(ecephys_api):
session = EcephysSession(api=ecephys_api)
ns = NaturalScenes(ecephys_session=session)
assert (ns.name == 'Natural Scenes')
assert (set(ns.unit_ids) == set(range(6)))
assert (len(ns.conditionwise_statistics) == 119 * 6)
assert (ns.conditionwise_psth.shape == (119, 249, 6))
assert (not ns.presentationwise_spike_times.empty)
assert (len(ns.presentationwise_statistics) == 119 * 6)
assert (len(ns.stimulus_conditions) == 119)