def feature_vector_input():
TEST_DATA_PATH = os.path.join(os.path.dirname(__file__), 'data')
nwb_file_name = "Pvalb-IRES-Cre;Ai14-415796.02.01.01.nwb"
nwb_file_full_path = os.path.join(TEST_DATA_PATH, nwb_file_name)
if not os.path.exists(nwb_file_full_path):
download_file(nwb_file_name, nwb_file_full_path)
data_set = AibsDataSet(nwb_file=nwb_file_full_path, ontology=ontology)
lsq_sweep_numbers = [4, 5, 6, 16, 17, 18, 19, 20, 21]
lsq_sweeps = data_set.sweep_set(lsq_sweep_numbers)
lsq_sweeps.select_epoch("recording")
lsq_sweeps.align_to_start_of_epoch("experiment")
lsq_start, lsq_dur, _, _, _ = stf.get_stim_characteristics(lsq_sweeps.sweeps[0].i,
lsq_sweeps.sweeps[0].t)
lsq_end = lsq_start + lsq_dur
lsq_spx, lsq_spfx = dsf.extractors_for_sweeps(lsq_sweeps,
start=lsq_start,
end=lsq_end,
**dsf.detection_parameters(data_set.LONG_SQUARE))
lsq_an = spa.LongSquareAnalysis(lsq_spx, lsq_spfx, subthresh_min_amp=-100.)
lsq_features = lsq_an.analyze(lsq_sweeps)
return lsq_sweeps, lsq_features, lsq_start, lsq_end
def test_get_stimulus_code_ext(NWB_file):
default_ontology = StimulusOntology(
ju.read(StimulusOntology.DEFAULT_STIMULUS_ONTOLOGY_FILE))
dataset = AibsDataSet(nwb_file=NWB_file, ontology=default_ontology)
assert dataset.get_stimulus_code_ext("EXTPSMOKET180424",
0) == "EXTPSMOKET180424[0]"
def dataset_for_specimen_id(specimen_id, data_source, ontology):
# Find or retrieve NWB file and ancillary info and construct an AibsDataSet object
if data_source == "lims":
nwb_path, h5_path = lims_nwb_information(specimen_id)
if type(nwb_path) is dict and "error" in nwb_path:
logging.warning("Problem getting NWB file for specimen {:d} from LIMS".format(specimen_id))
return nwb_path
try:
data_set = AibsDataSet(
nwb_file=nwb_path, h5_file=h5_path, ontology=ontology)
except Exception as detail:
logging.warning("Exception when loading specimen {:d} from LIMS".format(specimen_id))
logging.warning(detail)
return {"error": {"type": "dataset", "details": traceback.format_exc(limit=None)}}
elif data_source == "sdk":
nwb_path, sweep_info = sdk_nwb_information(specimen_id)
try:
data_set = AibsDataSet(
nwb_file=nwb_path, sweep_info=sweep_info, ontology=ontology)
except Exception as detail:
logging.warning("Exception when loading specimen {:d} via Allen SDK".format(specimen_id))
logging.warning(detail)
return {"error": {"type": "dataset", "details": traceback.format_exc(limit=None)}}
else:
logging.error("invalid data source specified ({})".format(data_source))
return data_set
def feature_vector_input():
TEST_DATA_PATH = os.path.join(os.path.dirname(__file__), 'data')
nwb_file_name = "Pvalb-IRES-Cre;Ai14-415796.02.01.01.nwb"
nwb_file_full_path = os.path.join(TEST_DATA_PATH, nwb_file_name)
if not os.path.exists(nwb_file_full_path):
download_file(nwb_file_name, nwb_file_full_path)
data_set = AibsDataSet(nwb_file=nwb_file_full_path, ontology=ontology)
lsq_sweep_numbers = data_set.filtered_sweep_table(
clamp_mode=data_set.CURRENT_CLAMP,
stimuli=ontology.long_square_names).sweep_number.sort_values().values
lsq_sweeps = data_set.sweep_set(lsq_sweep_numbers)
lsq_start, lsq_dur, _, _, _ = stf.get_stim_characteristics(
lsq_sweeps.sweeps[0].i, lsq_sweeps.sweeps[0].t)
lsq_end = lsq_start + lsq_dur
lsq_spx, lsq_spfx = dsf.extractors_for_sweeps(lsq_sweeps,
start=lsq_start,
end=lsq_end,
**dsf.detection_parameters(
data_set.LONG_SQUARE))
lsq_an = spa.LongSquareAnalysis(lsq_spx, lsq_spfx, subthresh_min_amp=-100.)
lsq_features = lsq_an.analyze(lsq_sweeps)
return lsq_sweeps, lsq_features, lsq_start, lsq_end
def test_get_clamp_mode(NWB_file):
default_ontology = StimulusOntology(ju.read(StimulusOntology.DEFAULT_STIMULUS_ONTOLOGY_FILE))
dataset = AibsDataSet(nwb_file=NWB_file, ontology=default_ontology)
assert dataset.get_clamp_mode(0) == dataset.VOLTAGE_CLAMP
def create_data_set(sweep_info=None, nwb_file=None, ontology=None, api_sweeps=True, h5_file=None,validate_stim=True):
"""Create an appropriate EphysDataSet derived class for the given nwb_file
Parameters
----------
nwb_file: str file name
Returns
-------
EphysDataSet derived object
"""
if nwb_file is None:
raise ValueError("Can not decide which EphysDataSet class to create without nwb_file")
nwb_version = get_nwb_version(nwb_file)
if nwb_version["major"] == 2:
return HBGDataSet(sweep_info=sweep_info,
nwb_file=nwb_file,
ontology=ontology,
api_sweeps=api_sweeps,
validate_stim=validate_stim)
elif nwb_version["major"] == 1 or nwb_version["major"] == 0:
return AibsDataSet(sweep_info=sweep_info,
nwb_file=nwb_file,
ontology=ontology,
api_sweeps=api_sweeps,
h5_file=h5_file,
validate_stim=validate_stim)
else:
raise ValueError("Unsupported or unknown NWB major" +
"version {} ({})".format(nwb_version["major"], nwb_version["full"]))
def data_for_specimen_id(specimen_id, passed_only):
name, roi_id, specimen_id = lq.get_specimen_info_from_lims_by_id(specimen_id)
nwb_path = lq.get_nwb_path_from_lims(roi_id)
if len(nwb_path) == 0: # could not find an NWB file
logging.debug("No NWB file for {:d}".format(specimen_id))
return {"error": {"type": "no_nwb", "details": ""}}
# Check if NWB has lab notebook information, or if additional hdf5 file is needed
ontology = StimulusOntology(ju.read(StimulusOntology.DEFAULT_STIMULUS_ONTOLOGY_FILE))
h5_path = None
with h5py.File(nwb_path, "r") as h5:
if "general/labnotebook" not in h5:
h5_path = lq.get_igorh5_path_from_lims(roi_id)
try:
data_set = AibsDataSet(nwb_file=nwb_path, h5_file=h5_path, ontology=ontology)
except Exception as detail:
logging.warn("Exception when processing specimen {:d}".format(specimen_id))
logging.warn(detail)
# return {"error": {"type": "dataset", "details": traceback.format_exc(limit=1)}}
return {}
try:
lsq_sweep_numbers = categorize_iclamp_sweeps(data_set, ontology.long_square_names)
ssq_sweep_numbers = categorize_iclamp_sweeps(data_set, ontology.short_square_names)
ramp_sweep_numbers = categorize_iclamp_sweeps(data_set, ontology.ramp_names)
except Exception as detail:
logging.warn("Exception when processing specimen {:d}".format(specimen_id))
logging.warn(detail)
# return {"error": {"type": "sweep_table", "details": traceback.format_exc(limit=1)}}
return {}
try:
result = extract_features(data_set, ramp_sweep_numbers, ssq_sweep_numbers, lsq_sweep_numbers)
except Exception as detail:
logging.warn("Exception when processing specimen {:d}".format(specimen_id))
logging.warn(detail)
# return {"error": {"type": "processing", "details": traceback.format_exc(limit=1)}}
return {}
result["specimen_id"] = specimen_id
return result
def save_cell_data(self, acceptable_stimtypes, non_standard_nwb=False,
ephys_dir='preprocessed'):
bpopt_stimtype_map = utility.bpopt_stimtype_map
distinct_id_map = utility.aibs_stimname_map
# Note: may also need to provide h5 "lab notebok" and/or ontology
from ipfx.stimulus import StimulusOntology
from ipfx.epochs import get_recording_epoch
import allensdk.core.json_utilities as ju
ontology = StimulusOntology(
ju.read(StimulusOntology.DEFAULT_STIMULUS_ONTOLOGY_FILE))
dataset = AibsDataSet(nwb_file=self.nwb_path, ontology=ontology)
stim_map = defaultdict(list)
stim_sweep_map = {}
output_dir = os.path.join(os.getcwd(), ephys_dir)
utility.create_dirpath(output_dir)
# Note: are QC criteria appropriate for ramps + other stim?
passed_sweep_nums = get_passed_sweeps(dataset, self.cell_id)
for sweep_num in passed_sweep_nums:
record = dataset.get_sweep_record(sweep_num)
sweep_number = record[AibsDataSet.SWEEP_NUMBER]
stim_type = record[AibsDataSet.STIMULUS_NAME]
if stim_type in acceptable_stimtypes:
# TODO: use dataset.sweep to get full object, epochs
sweep = dataset.get_sweep_data(sweep_number)
stimulus_trace = sweep['stimulus']
response_trace = sweep['response']
sampling_rate = sweep['sampling_rate']
# remove missing data
# start, end = get_recording_epoch(stimulus_trace)
# stimulus_trace = stimulus_trace[:end]
# response_trace = response_trace[:end]
time = np.arange(0, len(stimulus_trace)) / sampling_rate
trace_name = '%s_%d' % (
distinct_id_map[stim_type], sweep_number)
if non_standard_nwb:
calc_stimparams_func = self.calc_stimparams_nonstandard
else:
calc_stimparams_func = self.calc_stimparams_ipfx
stim_start, stim_stop, stim_amp_start, stim_amp_end, \
tot_duration, hold_curr = calc_stimparams_func(
time, stimulus_trace, trace_name)
response_trace_short_filename = '%s.%s' % (trace_name, 'txt')
response_trace_filename = os.path.join(
output_dir, response_trace_short_filename)
time *= 1e3 # in ms
response_trace *= 1e3 # in mV
response_trace = utility.correct_junction_potential(response_trace,
self.junction_potential)
stimulus_trace *= 1e9
# downsampling
time, stimulus_trace, response_trace = utility.downsample_ephys_data(
time, stimulus_trace, response_trace)
# save current timeseries only when needed
if stim_type in utility.bpopt_current_play_stimtypes:
with open(response_trace_filename, 'wb') as response_trace_file:
np.savetxt(response_trace_file,
np.transpose([time, response_trace, stimulus_trace]))
else:
with open(response_trace_filename, 'wb') as response_trace_file:
np.savetxt(response_trace_file,
np.transpose([time, response_trace]))
stim_map[distinct_id_map[stim_type]].append([
trace_name,
bpopt_stimtype_map[stim_type],
hold_curr / 1e12,
stim_amp_start / 1e12,
stim_amp_end / 1e12,
stim_start * 1e3,
stim_stop * 1e3,
tot_duration * 1e3,
response_trace_short_filename])
stim_sweep_map[trace_name] = sweep_number
logger.debug('Writing stimmap.csv ...')
stim_reps_sweep_map, stimmap_filename = self.write_stimmap_csv(stim_map,
output_dir, stim_sweep_map)
self.write_provenance(
output_dir,
self.nwb_path,
stim_sweep_map,
stim_reps_sweep_map)
return output_dir, stimmap_filename
from allensdk.api.queries.cell_types_api import CellTypesApi
from ipfx.aibs_data_set import AibsDataSet
from ipfx.ephys_extractor import SpikeExtractor
# Download and access the experimental data
ct = CellTypesApi()
specimen_id = 595570553
nwb_file = "%d.nwb" % specimen_id
sweep_info = ct.get_ephys_sweeps(specimen_id)
if not os.path.exists(nwb_file):
ct.save_ephys_data(specimen_id, nwb_file)
# Get the data for the sweep into a format we can use
dataset = AibsDataSet(sweep_info=sweep_info, nwb_file=nwb_file)
sweep_number = 39
sweep = dataset.sweep(sweep_number)
# Extract information about the spikes
ext = SpikeExtractor()
results = ext.process(t=sweep.t, v=sweep.v, i=sweep.i)
# Plot the results, showing two features of the detected spikes
plt.plot(sweep.t, sweep.v)
plt.plot(results["peak_t"], results["peak_v"], 'r.')
plt.plot(results["threshold_t"], results["threshold_v"], 'k.')
# Set the plot limits to highlight where spikes are and set axis labels
plt.xlim(0.5, 2.5)
plt.xlabel("Time (s)")
from ipfx.aibs_data_set import AibsDataSet
from ipfx.ephys_extractor import SpikeExtractor, SpikeTrainFeatureExtractor
from ipfx.stimulus_protocol_analysis import ShortSquareAnalysis
import ipfx.ephys_features as ft
# download a specific experiment NWB file via AllenSDK
ct = CellTypesApi()
specimen_id = 595570553
nwb_file = "%d.nwb" % specimen_id
if not os.path.exists(nwb_file):
ct.save_ephys_data(specimen_id, nwb_file)
sweep_info = ct.get_ephys_sweeps(specimen_id)
# build a data set and find the short squares
data_set = AibsDataSet(sweep_info=sweep_info, nwb_file=nwb_file)
shsq_table = data_set.filtered_sweep_table(
stimuli=data_set.ontology.short_square_names)
shsq_sweep_set = data_set.sweep_set(shsq_table.sweep_number)
# Estimate the dv cutoff and threshold fraction (we know stimulus starts at 0.27s)
dv_cutoff, thresh_frac = ft.estimate_adjusted_detection_parameters(
shsq_sweep_set.v, shsq_sweep_set.t, 0.27, 0.271)
# Build the extractors
start = 0.27
spx = SpikeExtractor(start=start, dv_cutoff=dv_cutoff, thresh_frac=thresh_frac)
sptrx = SpikeTrainFeatureExtractor(start=start, end=None)
# Run the analysis
shsq_analysis = ShortSquareAnalysis(spx, sptrx)
results = shsq_analysis.analyze(shsq_sweep_set)
def test_get_stimulus_units(NWB_file):
default_ontology = StimulusOntology(
ju.read(StimulusOntology.DEFAULT_STIMULUS_ONTOLOGY_FILE))
dataset = AibsDataSet(nwb_file=NWB_file, ontology=default_ontology)
assert dataset.get_stimulus_units(0) == "Volts"
from allensdk.api.queries.cell_types_api import CellTypesApi
from ipfx.aibs_data_set import AibsDataSet
from ipfx.ephys_extractor import SpikeExtractor, SpikeTrainFeatureExtractor
from ipfx.stimulus_protocol_analysis import RampAnalysis
# download a specific experiment NWB file via AllenSDK
ct = CellTypesApi()
specimen_id = 595570553
nwb_file = "%d.nwb" % specimen_id
if not os.path.exists(nwb_file):
ct.save_ephys_data(specimen_id, nwb_file)
sweep_info = ct.get_ephys_sweeps(specimen_id)
# Build the data set and find the ramp sweeps
data_set = AibsDataSet(sweep_info=sweep_info, nwb_file=nwb_file)
ramp_table = data_set.filtered_sweep_table(
stimuli=data_set.ontology.ramp_names)
ramp_sweep_set = data_set.sweep_set(ramp_table.sweep_number)
# Build the extractors (we know stimulus starts at 0.27 s)
start = 0.27
spx = SpikeExtractor(start=start, end=None)
sptrx = SpikeTrainFeatureExtractor(start=start, end=None)
# Run the analysis
ramp_analysis = RampAnalysis(spx, sptrx)
results = ramp_analysis.analyze(ramp_sweep_set)
# Plot the sweeps and the latency to the first spike of each
sns.set_style("white")
def data_for_specimen_id(specimen_id,
sweep_qc_option,
data_source,
ap_window_length=0.005,
target_sampling_rate=50000):
logging.debug("specimen_id: {}".format(specimen_id))
# Find or retrieve NWB file and ancillary info and construct an AibsDataSet object
ontology = StimulusOntology(
ju.read(StimulusOntology.DEFAULT_STIMULUS_ONTOLOGY_FILE))
if data_source == "lims":
nwb_path, h5_path = lims_nwb_information(specimen_id)
if type(nwb_path) is dict and "error" in nwb_path:
logging.warning(
"Problem getting NWB file for specimen {:d} from LIMS".format(
specimen_id))
return nwb_path
try:
data_set = AibsDataSet(nwb_file=nwb_path,
h5_file=h5_path,
ontology=ontology)
except Exception as detail:
logging.warning(
"Exception when loading specimen {:d} from LIMS".format(
specimen_id))
logging.warning(detail)
return {
"error": {
"type": "dataset",
"details": traceback.format_exc(limit=None)
}
}
elif data_source == "sdk":
ctc = CellTypesCache()
morph = ctc.get_reconstruction(specimen_id)
morph_table = ctc.get_morphology_features(specimen_id)
morph_table.to_csv('cell_types\\specimen_' + str(specimen_id) + '\\' +
'morphology_features.csv')
print("morph dl failed")
nwb_path, sweep_info = sdk_nwb_information(specimen_id)
try:
data_set = AibsDataSet(nwb_file=nwb_path,
sweep_info=sweep_info,
ontology=ontology)
except Exception as detail:
logging.warning(
"Exception when loading specimen {:d} via Allen SDK".format(
specimen_id))
logging.warning(detail)
return {
"error": {
"type": "dataset",
"details": traceback.format_exc(limit=None)
}
}
else:
logging.error("invalid data source specified ({})".format(data_source))
# Identify and preprocess long square sweeps
try:
lsq_sweep_numbers = categorize_iclamp_sweeps(
data_set,
ontology.long_square_names,
sweep_qc_option=sweep_qc_option,
specimen_id=specimen_id)
(lsq_sweeps, lsq_features, lsq_start, lsq_end,
lsq_spx) = preprocess_long_square_sweeps(data_set, lsq_sweep_numbers)
except Exception as detail:
logging.warning(
"Exception when preprocessing long square sweeps from specimen {:d}"
.format(specimen_id))
logging.warning(detail)
return {
"error": {
"type": "sweep_table",
"details": traceback.format_exc(limit=None)
}
}
# Identify and preprocess short square sweeps
try:
ssq_sweep_numbers = categorize_iclamp_sweeps(
data_set,
ontology.short_square_names,
sweep_qc_option=sweep_qc_option,
specimen_id=specimen_id)
ssq_sweeps, ssq_features = preprocess_short_square_sweeps(
data_set, ssq_sweep_numbers)
except Exception as detail:
logging.warning(
"Exception when preprocessing short square sweeps from specimen {:d}"
.format(specimen_id))
logging.warning(detail)
return {
"error": {
"type": "sweep_table",
"details": traceback.format_exc(limit=None)
}
}
# Identify and preprocess ramp sweeps
try:
ramp_sweep_numbers = categorize_iclamp_sweeps(
data_set,
ontology.ramp_names,
sweep_qc_option=sweep_qc_option,
specimen_id=specimen_id)
ramp_sweeps, ramp_features = preprocess_ramp_sweeps(
data_set, ramp_sweep_numbers)
except Exception as detail:
logging.warning(
"Exception when preprocessing ramp sweeps from specimen {:d}".
format(specimen_id))
logging.warning(detail)
return {
"error": {
"type": "sweep_table",
"details": traceback.format_exc(limit=None)
}
}
# Calculate desired feature vectors
result = {}
(subthresh_hyperpol_dict, hyperpol_deflect_dict
) = fv.identify_subthreshold_hyperpol_with_amplitudes(
lsq_features, lsq_sweeps)
target_amps_for_step_subthresh = [-90, -70, -50, -30, -10]
result["step_subthresh"] = fv.step_subthreshold(
subthresh_hyperpol_dict,
target_amps_for_step_subthresh,
lsq_start,
lsq_end,
amp_tolerance=5)
result["subthresh_norm"] = fv.subthresh_norm(subthresh_hyperpol_dict,
hyperpol_deflect_dict,
lsq_start, lsq_end)
(subthresh_depol_dict,
depol_deflect_dict) = fv.identify_subthreshold_depol_with_amplitudes(
lsq_features, lsq_sweeps)
result["subthresh_depol_norm"] = fv.subthresh_depol_norm(
subthresh_depol_dict, depol_deflect_dict, lsq_start, lsq_end)
isi_sweep, isi_sweep_spike_info = fv.identify_sweep_for_isi_shape(
lsq_sweeps, lsq_features, lsq_end - lsq_start)
result["isi_shape"] = fv.isi_shape(isi_sweep, isi_sweep_spike_info,
lsq_end)
# Calculate waveforms from each type of sweep
spiking_ssq_sweep_list = [
ssq_sweeps.sweeps[swp_ind]
for swp_ind in ssq_features["common_amp_sweeps"].index
]
spiking_ssq_info_list = [
ssq_features["spikes_set"][swp_ind]
for swp_ind in ssq_features["common_amp_sweeps"].index
]
ssq_ap_v, ssq_ap_dv = fv.first_ap_vectors(
spiking_ssq_sweep_list,
spiking_ssq_info_list,
target_sampling_rate=target_sampling_rate,
window_length=ap_window_length,
skip_clipped=True)
rheo_ind = lsq_features["rheobase_sweep"].name
sweep = lsq_sweeps.sweeps[rheo_ind]
lsq_ap_v, lsq_ap_dv = fv.first_ap_vectors(
[sweep], [lsq_features["spikes_set"][rheo_ind]],
target_sampling_rate=target_sampling_rate,
window_length=ap_window_length)
spiking_ramp_sweep_list = [
ramp_sweeps.sweeps[swp_ind]
for swp_ind in ramp_features["spiking_sweeps"].index
]
spiking_ramp_info_list = [
ramp_features["spikes_set"][swp_ind]
for swp_ind in ramp_features["spiking_sweeps"].index
]
ramp_ap_v, ramp_ap_dv = fv.first_ap_vectors(
spiking_ramp_sweep_list,
spiking_ramp_info_list,
target_sampling_rate=target_sampling_rate,
window_length=ap_window_length,
skip_clipped=True)
# Combine so that differences can be assessed by analyses like sPCA
result["first_ap_v"] = np.hstack([ssq_ap_v, lsq_ap_v, ramp_ap_v])
result["first_ap_dv"] = np.hstack([ssq_ap_dv, lsq_ap_dv, ramp_ap_dv])
target_amplitudes = np.arange(0, 120, 20)
supra_info_list = fv.identify_suprathreshold_spike_info(lsq_features,
target_amplitudes,
shift=10)
result["psth"] = fv.psth_vector(supra_info_list, lsq_start, lsq_end)
result["inst_freq"] = fv.inst_freq_vector(supra_info_list, lsq_start,
lsq_end)
spike_feature_list = [
"upstroke_downstroke_ratio",
"peak_v",
"fast_trough_v",
"threshold_v",
"width",
]
for feature in spike_feature_list:
result["spiking_" + feature] = fv.spike_feature_vector(
feature, supra_info_list, lsq_start, lsq_end)
return result
Run all analyses on NWB file
"""
from __future__ import print_function
import os
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
from allensdk.api.queries.cell_types_api import CellTypesApi
from ipfx.aibs_data_set import AibsDataSet
from ipfx.data_set_features import extract_data_set_features
# download a specific experiment NWB file via AllenSDK
ct = CellTypesApi()
specimen_id = 595570553
nwb_file = "%d.nwb" % specimen_id
if not os.path.exists(nwb_file):
ct.save_ephys_data(specimen_id, nwb_file)
sweep_info = ct.get_ephys_sweeps(specimen_id)
data_set = AibsDataSet(
sweep_info=sweep_info,
nwb_file=nwb_file) # Download and access the experimental data
cell_features, sweep_features, cell_record, sweep_records = \
extract_data_set_features(data_set, subthresh_min_amp=-100.0)
print(cell_record)
def test_validate_required_sweep_info(NWB_file):
sweep_info = [{"sweep_number": 0}]
dataset = AibsDataSet(sweep_info, nwb_file=NWB_file, api_sweeps=False)
assert list(dataset.sweep_table).sort() == dataset.COLUMN_NAMES.sort()
def data_for_specimen_id(specimen_id, data_source, chirp_stimulus_codes):
logging.debug("specimen_id: {}".format(specimen_id))
# Manual edit ontology to identify chirp sweeps
ontology_data = ju.read(StimulusOntology.DEFAULT_STIMULUS_ONTOLOGY_FILE)
mask = []
for od in ontology_data:
mask_val = True
for tagset in od:
for c in chirp_stimulus_codes:
if c in tagset and "code" in tagset:
mask_val = False
break
mask.append(mask_val)
ontology_data = [od for od, m in zip(ontology_data, mask) if m is True]
ontology_data.append([
["code"] + chirp_stimulus_codes,
[
"name",
"Chirp",
],
[
"core",
"Core 2"
]
])
ontology = StimulusOntology(ontology_data)
# Find or retrieve NWB file and ancillary info and construct an AibsDataSet object
if data_source == "lims":
nwb_path, h5_path = lims_nwb_information(specimen_id)
if type(nwb_path) is dict and "error" in nwb_path:
logging.warning("Problem getting NWB file for specimen {:d} from LIMS".format(specimen_id))
return nwb_path
try:
data_set = AibsDataSet(
nwb_file=nwb_path, h5_file=h5_path, ontology=ontology)
except Exception as detail:
logging.warning("Exception when loading specimen {:d} from LIMS".format(specimen_id))
logging.warning(detail)
return {"error": {"type": "dataset", "details": traceback.format_exc(limit=None)}}
elif data_source == "sdk":
nwb_path, sweep_info = sdk_nwb_information(specimen_id)
try:
data_set = AibsDataSet(
nwb_file=nwb_path, sweep_info=sweep_info, ontology=ontology)
except Exception as detail:
logging.warning("Exception when loading specimen {:d} via Allen SDK".format(specimen_id))
logging.warning(detail)
return {"error": {"type": "dataset", "details": traceback.format_exc(limit=None)}}
else:
logging.error("invalid data source specified ({})".format(data_source))
# Identify chirp sweeps
try:
iclamp_st = data_set.filtered_sweep_table(clamp_mode=data_set.CURRENT_CLAMP)
iclamp_st = data_set.filtered_sweep_table(clamp_mode=data_set.CURRENT_CLAMP, stimuli=["Chirp"])
chirp_sweep_numbers = iclamp_st["sweep_number"].sort_values().values
except Exception as detail:
logging.warning("Exception when identifying sweeps from specimen {:d}".format(specimen_id))
logging.warning(detail)
return {"error": {"type": "sweep_table", "details": traceback.format_exc(limit=1)}}
if len(chirp_sweep_numbers) == 0:
logging.info("No chirp sweeps for {:d}".format(specimen_id))
return {"error": {"type": "processing", "details:": "no available chirp sweeps"}}
try:
result = chirp.extract_chirp_feature_vector(data_set, chirp_sweep_numbers)
except Exception as detail:
logging.warning("Exception when processing specimen {:d}".format(specimen_id))
logging.warning(detail)
return {"error": {"type": "processing", "details": traceback.format_exc(limit=1)}}
return result
"""
Sweep QC Features
=================
Estimate sweep QC features
"""
from __future__ import print_function
import os
import pandas as pd
from ipfx.aibs_data_set import AibsDataSet
import ipfx.qc_features as qcf
from allensdk.api.queries.cell_types_api import CellTypesApi
specimen_id = 595570553
nwb_file = '%d.nwb' % specimen_id
# download a specific experiment NWB file via AllenSDK
ct = CellTypesApi()
if not os.path.exists(nwb_file):
ct.save_ephys_data(specimen_id, nwb_file)
sweep_info = ct.get_ephys_sweeps(specimen_id)
data_set = AibsDataSet(sweep_info=sweep_info, nwb_file=nwb_file)
# run sweep QC
sweep_features = qcf.sweep_qc_features(data_set)
print(pd.DataFrame(sweep_features).head())
