def load_experiment(specimen): path, bath, breakin, end, giga, last_bias, mid_bias, SS_amp, spec_name = Find_Critical_Sweeps( specimen) ds = NwbDataSet(path) if bath is 'error': bath_peak = 9999999 bath_ss = 9999999 else: bath_sweep = ds.get_sweep(bath) bath_i = bath_sweep['response'] * 1e12 bath_peak, bath_ss = get_Reses(70, bath_i) if breakin is 'error': breakin_peak = 9999999 breakin_ss = 9999999 else: breakin_sweep = ds.get_sweep(breakin) breakin_i = breakin_sweep['response'] * 1e12 breakin_peak, breakin_ss = get_Reses(70, breakin_i) if end is 'error': end_peak = 9999999 end_ss = 9999999 end_leak = 9999999 else: end_sweep = ds.get_sweep(end) end_i = end_sweep['response'] * 1e12 end_peak, end_ss = get_Reses(70, end_i) end_leak = np.mean(end_i[0:100]) if giga is 'error': giga_peak = 9999999 giga_ss = 9999999 else: giga_sweep = ds.get_sweep(giga) giga_i = giga_sweep['response'] * 1e12 giga_peak, giga_ss = get_Reses(70, giga_i) features = [] features.append(spec_name) features.append(bath_ss) features.append(breakin_peak) features.append(breakin_ss) features.append(end_peak) features.append(end_ss) features.append(end_leak) features.append(giga_ss) features.append(last_bias) features.append(mid_bias) features.append(SS_amp) return features
def read_stimulus(self, stimulus_path, sweep=0): '''Load current values for a specific experiment sweep and setup simulation and stimulus sampling rates. NOTE: NEURON only allows simulation timestamps of multiples of 40KHz. To avoid aliasing, we set the simulation sampling rate to the least common multiple of the stimulus sampling rate and 40KHz. Parameters ---------- stimulus path : string NWB file name sweep : integer, optional sweep index ''' Utils._log.info("reading stimulus path: %s, sweep %s", stimulus_path, sweep) stimulus_data = NwbDataSet(stimulus_path) sweep_data = stimulus_data.get_sweep(sweep) # convert to nA for NEURON self.stim_curr = sweep_data['stimulus'] * 1.0e9 # convert from Hz hz = int(sweep_data['sampling_rate']) neuron_hz = Utils.nearest_neuron_sampling_rate(hz) self.simulation_sampling_rate = neuron_hz self.stimulus_sampling_rate = hz if hz != neuron_hz: Utils._log.debug( "changing sampling rate from %d to %d to avoid NEURON aliasing", hz, neuron_hz)
def read_stimulus(self, stimulus_path, sweep=0): '''Load current values for a specific experiment sweep and setup simulation and stimulus sampling rates. NOTE: NEURON only allows simulation timestamps of multiples of 40KHz. To avoid aliasing, we set the simulation sampling rate to the least common multiple of the stimulus sampling rate and 40KHz. Parameters ---------- stimulus path : string NWB file name sweep : integer, optional sweep index ''' Utils._log.info( "reading stimulus path: %s, sweep %s", stimulus_path, sweep) stimulus_data = NwbDataSet(stimulus_path) sweep_data = stimulus_data.get_sweep(sweep) # convert to nA for NEURON self.stim_curr = sweep_data['stimulus'] * 1.0e9 # convert from Hz hz = int(sweep_data['sampling_rate']) neuron_hz = Utils.nearest_neuron_sampling_rate(hz) self.simulation_sampling_rate = neuron_hz self.stimulus_sampling_rate = hz if hz != neuron_hz: Utils._log.debug("changing sampling rate from %d to %d to avoid NEURON aliasing", hz, neuron_hz)
def get_voltage(self, neuron_config, stim_name): ephys_sweeps = self.cfg.ephys_sweeps ephys_sweep = next(s for s in ephys_sweeps if s['stimulus_name'] == stim_name) ds = NwbDataSet(self.ephys_file_name) data = ds.get_sweep(ephys_sweep['sweep_number']) stimulus = data['stimulus'] stimulus = stimulus[stimulus != 0] stimulus = stimulus[:self.cfg.stimulus_allow] # initialize the neuron neuron = GlifNeuron.from_dict(neuron_config) # Set dt neuron.dt = 1.0 / data['sampling_rate'] # simulate the neuron output = neuron.run(stimulus) voltage = output['voltage'] * 1e3 voltage = voltage[~np.isnan(voltage)] voltage = voltage[:self.cfg.signal_allow] return output, voltage, neuron, stimulus
def load_sweep(file_name, sweep_number, desired_dt=None, cut=0, bessel=False): '''load a data sweep and do specified data processing. Inputs: file_name: string name of .nwb data file sweep_number: number specifying the sweep to be loaded desired_dt: the size of the time step the data should be subsampled to cut: indicie of which to start reporting data (i.e. cut off data before this indicie) bessel: dictionary contains parameters 'N' and 'Wn' to implement standard python bessel filtering Returns: dictionary containing voltage: array current: array dt: time step of the returned data start_idx: the index at which the first stimulus starts (excluding the test pulse) ''' ds = NwbDataSet(file_name) data = ds.get_sweep(sweep_number) data["dt"] = 1.0 / data["sampling_rate"] if cut > 0: data["response"] = data["response"][cut:] data["stimulus"] = data["stimulus"][cut:] if bessel: sample_freq = 1. / data["dt"] filt_coeff = (bessel["freq"]) / ( sample_freq / 2.) # filter fraction of Nyquist frequency b, a = signal.bessel(bessel["N"], filt_coeff, "low") data['response'] = signal.filtfilt(b, a, data['response'], axis=0) if desired_dt is not None: if data["dt"] != desired_dt: data["response"] = subsample_data(data["response"], "mean", data["dt"], desired_dt) data["stimulus"] = subsample_data(data["stimulus"], "mean", data["dt"], desired_dt) data["start_idx"] = int(data["index_range"][0] / (desired_dt / data["dt"])) data["dt"] = desired_dt if "start_idx" not in data: data["start_idx"] = data["index_range"][0] return { "voltage": data["response"], "current": data["stimulus"], "dt": data["dt"], "start_idx": data["start_idx"] }
def stimulus(neuron_config_file, ephys_sweeps_file): ephys_sweeps = json_utilities.read(ephys_sweeps_file) ephys_file_name = 'stimulus.nwb' # pull out the stimulus for the first sweep ephys_sweep = ephys_sweeps[0] ds = NwbDataSet(ephys_file_name) data = ds.get_sweep(ephys_sweep['sweep_number']) stimulus = data['stimulus'] return stimulus
def load_experiment(file_name, sweep_number): ds = NwbDataSet(file_name) sweep = ds.get_sweep(sweep_number) r = sweep['index_range'] v = sweep['response'] * 1e3 i = sweep['stimulus'] * 1e12 dt = 1.0 / sweep['sampling_rate'] t = np.arange(0, len(v)) * dt return (v, i, t, r, dt)
def stimulus(neuron_config_file, ephys_sweeps_file): neuron_config = json_utilities.read(neuron_config_file) ephys_sweeps = json_utilities.read(ephys_sweeps_file) ephys_file_name = 'stimulus.nwb' # pull out the stimulus for the first sweep ephys_sweep = ephys_sweeps[0] ds = NwbDataSet(ephys_file_name) data = ds.get_sweep(ephys_sweep['sweep_number']) stimulus = data['stimulus'] return stimulus
def from_electrophysiology( cell_id: int, ephys: NwbDataSet, duration=2.0) -> 'ProcessedAllenNeuronElectrophysiology': current_list = [] voltage_list = [] time_list = [] stim_amp_list = [] n_spikes_list = [] spike_features_list = [] for sweep_number in ephys.get_sweep_numbers(): sweep_metadata = ephys.get_sweep_metadata(sweep_number) if sweep_metadata['aibs_stimulus_name'] == 'Long Square': sweep_data = ephys.get_sweep(sweep_number) amp = sweep_metadata['aibs_stimulus_amplitude_pa'] index_range = sweep_data["index_range"] sampling_rate = sweep_data["sampling_rate"] current = sweep_data["stimulus"][ index_range[0]:index_range[1] + 1] voltage = sweep_data["response"][ index_range[0]:index_range[1] + 1] # truncate max_frames = int(duration * sampling_rate) assert max_frames < len(voltage) current = current[:max_frames] * 1e12 # in pA voltage = voltage[:max_frames] * 1e3 # in mV # extract featrures time = np.arange(0, max_frames, dtype=np.float) / sampling_rate # in seconds ext = EphysSweepFeatureExtractor(t=time, v=voltage, i=current) ext.process_spikes() spike_features = ext.spikes() n_spikes = len(spike_features) current_list.append(current) voltage_list.append(voltage) time_list.append(time) stim_amp_list.append(amp) n_spikes_list.append(n_spikes) spike_features_list.append(spike_features) return ProcessedAllenNeuronElectrophysiology( cell_id=cell_id, current_list=current_list, voltage_list=voltage_list, time_list=time_list, stim_amp_list=stim_amp_list, n_spikes_list=n_spikes_list, spike_features_list=spike_features_list)
def get_sweep_from_nwb(nwb_file, sweep_num): ''' Read a sweep from an NWB file and convert Volts -> mV and Amps -> pA. ''' ds = NwbDataSet(nwb_file) data = ds.get_sweep(sweep_num) v = data['response'] * 1e3 # convert to mV i = data['stimulus'] * 1e12 # convert to pA dt = 1.0 / data['sampling_rate'] t = np.arange(0,len(v)) * dt return (v, i, t)
def read_stimulus(self, stimulus_path, sweep=0): """load current values for a specific experiment sweep. Parameters ---------- stimulus path : string NWB file name sweep : integer, optional sweep index """ Utils._log.info("reading stimulus path: %s, sweep %s" % (stimulus_path, sweep)) stimulus_data = NwbDataSet(stimulus_path) sweep_data = stimulus_data.get_sweep(sweep) self.stim_curr = sweep_data["stimulus"] * 1.0e9 # convert to nA for NEURON self.sampling_rate = 1.0e3 / sweep_data["sampling_rate"] # convert from Hz
def get_sweep_data(nwb_file, sweep_number, time_scale=1e3, voltage_scale=1e3, stim_scale=1e12): """ Extract data and stim characteristics for a specific DC sweep from nwb file Parameters ---------- nwb_file : string File name of a pre-existing NWB file. sweep_number : integer time_scale : float Convert to ms scale voltage_scale : float Convert to mV scale stim_scale : float Convert to pA scale Returns ------- t : numpy array Sampled time points in ms v : numpy array Recorded voltage at the sampled time points in mV stim_start_time : float Stimulus start time in ms stim_end_time : float Stimulus end time in ms """ nwb = NwbDataSet(nwb_file) sweep = nwb.get_sweep(sweep_number) stim = sweep['stimulus'] * stim_scale # in pA stim_diff = np.diff(stim) stim_start = np.where(stim_diff != 0)[0][-2] stim_end = np.where(stim_diff != 0)[0][-1] # read v and t as numpy arrays v = sweep['response'] * voltage_scale # in mV dt = time_scale / sweep['sampling_rate'] # in ms num_samples = len(v) t = np.arange(num_samples) * dt stim_start_time = t[stim_start] stim_end_time = t[stim_end] return t, v, stim_start_time, stim_end_time
def extract_single_sweep_features(features, nwb_file, sweep_number): ''' Run feature extraction on a single sweep. Parameters ---------- features: EphysFeatureExtractor instance nwb_file: string File name of an NWB file sweep_numbers: int Sweep number in the NWB file ''' nwb = NwbDataSet(nwb_file) data = nwb.get_sweep(sweep_number) v = data['response'] curr = data['stimulus'] idx0 = data['index_range'][0] idx1 = data['index_range'][1] if idx0 >= idx1: logging.warning("Sweep %s stop index precedes start index, skipping spike identification" % sweep_number) return hz = data['sampling_rate'] dt = 1.0 / hz t = np.arange(0, len(v)) * dt features.process_instance(sweep_number, v*1e3, curr*1e12, t, dt*idx0, dt*(idx1-idx0-2), None) results = {} results["mean"] = features.feature_list[-1].mean results["stdev"] = features.feature_list[-1].stdev return results
def output(neuron_config_file, ephys_sweeps_file): neuron_config = json_utilities.read(neuron_config_file) ephys_sweeps = json_utilities.read(ephys_sweeps_file) ephys_file_name = 'stimulus.nwb' # pull out the stimulus for the first sweep ephys_sweep = ephys_sweeps[0] ds = NwbDataSet(ephys_file_name) data = ds.get_sweep(ephys_sweep['sweep_number']) stimulus = data['stimulus'] # initialize the neuron # important! update the neuron's dt for your stimulus neuron = GlifNeuron.from_dict(neuron_config) neuron.dt = 1.0 / data['sampling_rate'] # simulate the neuron truncate = 56041 output = neuron.run(stimulus[0:truncate]) return output
def read_stimulus(self, stimulus_path, sweep=0): '''load current values for a specific experiment sweep. Parameters ---------- stimulus path : string NWB file name sweep : integer, optional sweep index ''' Utils._log.info("reading stimulus path: %s, sweep %s", stimulus_path, sweep) stimulus_data = NwbDataSet(stimulus_path) sweep_data = stimulus_data.get_sweep(sweep) # convert to nA for NEURON self.stim_curr = sweep_data['stimulus'] * 1.0e9 # convert from Hz self.sampling_rate = 1.0e3 / sweep_data['sampling_rate']
def output(): neuron_config = json_utilities.read('neuron_config.json') ephys_sweeps = json_utilities.read('ephys_sweeps.json') ephys_file_name = 'stimulus.nwb' # pull out the stimulus for the first sweep ephys_sweep = ephys_sweeps[0] ds = NwbDataSet(ephys_file_name) data = ds.get_sweep(ephys_sweep['sweep_number']) stimulus = data['stimulus'] # initialize the neuron # important! update the neuron's dt for your stimulus neuron = GlifNeuron.from_dict(neuron_config) neuron.dt = 1.0 / data['sampling_rate'] # simulate the neuron truncate = 56041 output = neuron.run(stimulus[0:truncate]) return output
def save_cell_data_web(self, acceptable_stimtypes, non_standard_nwb=False, ephys_dir='preprocessed', **kwargs): bpopt_stimtype_map = utility.bpopt_stimtype_map distinct_id_map = utility.aibs_stimname_map nwb_file = NwbDataSet(self.nwb_path) stim_map = defaultdict(list) stim_sweep_map = {} output_dir = os.path.join(os.getcwd(), ephys_dir) utility.create_dirpath(output_dir) sweep_numbers = kwargs.get('sweep_numbers') or nwb_file.get_sweep_numbers() for sweep_number in sweep_numbers: sweep_data = nwb_file.get_sweep_metadata(sweep_number) stim_type = sweep_data['aibs_stimulus_name'] try: stim_type = stim_type.decode('UTF-8') except: pass if stim_type in acceptable_stimtypes: sweep = nwb_file.get_sweep(sweep_number) start_idx, stop_idx = sweep['index_range'] stimulus_trace = sweep['stimulus'][start_idx:stop_idx] response_trace = sweep['response'][start_idx:stop_idx] sampling_rate = sweep['sampling_rate'] 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 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) 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])) holding_current = hold_curr # sweep['bias_current'] stim_map[distinct_id_map[stim_type]].append([ trace_name, bpopt_stimtype_map[stim_type], holding_current/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
import allensdk.core.json_utilities as json_utilities from allensdk.model.glif.glif_neuron import GlifNeuron from allensdk.core.nwb_data_set import NwbDataSet neuron_config = json_utilities.read("neuron_config.json") ephys_sweeps = json_utilities.read("ephys_sweeps.json") ephys_file_name = "stimulus.nwb" # pull out the stimulus for the first sweep ephys_sweep = ephys_sweeps[0] ds = NwbDataSet(ephys_file_name) data = ds.get_sweep(ephys_sweep["sweep_number"]) stimulus = data["stimulus"] # initialize the neuron # important! update the neuron's dt for your stimulus neuron = GlifNeuron.from_dict(neuron_config) neuron.dt = 1.0 / data["sampling_rate"] # simulate the neuron output = neuron.run(stimulus) voltage = output["voltage"] threshold = output["threshold"] spike_times = output["interpolated_spike_times"]
neuron_config = cfg.neuron_config neuron_id = next(iter(neuron_config)) neuron_config = neuron_config[neuron_id] ephys_sweeps = cfg.ephys_sweeps stim_names = ["Noise 1"] params = create_param_dict(neuron_config) for stim in stim_names: sweeps = [s for s in ephys_sweeps if s['stimulus_name'] == stim] for sweep_id, ephys_sweep in enumerate(sweeps): ds = NwbDataSet(ephys_file_name) data = ds.get_sweep(ephys_sweep['sweep_number']) stimulus = data['stimulus'] stimulus = stimulus[stimulus != 0] stimulus = stimulus[:cfg.stimulus_allow] for param_id, param_dict in enumerate(params): train = {} # update neuron_config based on params neuron_config = param_dict # initialize the neuron neuron = GlifNeuron.from_dict(neuron_config) # Set dt neuron.dt = 1.0 / data['sampling_rate']
for child in morphology.children_of(soma): print(child['x'], child['y'], child['z'], child['radius']) #=============================================================================== # example 4 #=============================================================================== from allensdk.core.nwb_data_set import NwbDataSet # if you ran the examples above, you will have a NWB file here file_name = 'cell_types/specimen_485909730/ephys.nwb' data_set = NwbDataSet(file_name) sweep_numbers = data_set.get_sweep_numbers() sweep_number = sweep_numbers[0] sweep_data = data_set.get_sweep(sweep_number) # spike times are in seconds relative to the start of the sweep spike_times = data_set.get_spike_times(sweep_number) # stimulus is a numpy array in amps stimulus = sweep_data['stimulus'] # response is a numpy array in volts reponse = sweep_data['response'] # sampling rate is in Hz sampling_rate = sweep_data['sampling_rate'] # start/stop indices that exclude the experimental test pulse (if applicable) index_range = sweep_data['index_range']
# example 4 #=============================================================================== import allensdk.core.json_utilities as json_utilities from allensdk.model.glif.glif_neuron import GlifNeuron from allensdk.core.nwb_data_set import NwbDataSet neuron_config = json_utilities.read('neuron_config.json')['566302806'] ephys_sweeps = json_utilities.read('ephys_sweeps.json') ephys_file_name = 'stimulus.nwb' # pull out the stimulus for the current-clamp first sweep ephys_sweep = next( s for s in ephys_sweeps if s['stimulus_units'] == 'Amps' ) ds = NwbDataSet(ephys_file_name) data = ds.get_sweep(ephys_sweep['sweep_number']) stimulus = data['stimulus'] # initialize the neuron # important! update the neuron's dt for your stimulus neuron = GlifNeuron.from_dict(neuron_config) neuron.dt = 1.0 / data['sampling_rate'] # simulate the neuron output = neuron.run(stimulus) voltage = output['voltage'] threshold = output['threshold'] spike_times = output['interpolated_spike_times'] #===============================================================================
print('Loading data from: %s' % raw_ephys_file_name) from allensdk.core.nwb_data_set import NwbDataSet data_set = NwbDataSet(raw_ephys_file_name) import matplotlib.pyplot as plt import numpy as np fig = plt.figure() sweep_numbers = sweep_numbers_for_data[dataset_id] subset = {} for sweep_number in sweep_numbers: sweep_data = data_set.get_sweep(sweep_number) # start/stop indices that exclude the experimental test pulse (if applicable) index_range = sweep_data['index_range'] # stimulus is a numpy array in amps stimulus = sweep_data['stimulus'][index_range[0]:index_range[-1]] # response is a numpy array in volts response = sweep_data['response'][index_range[0]:index_range[-1]] * 1000 subset[sweep_number] = response # sampling rate is in Hz sampling_rate = sweep_data['sampling_rate'] # define some time points in seconds (i.e., convert to absolute time)
def noise1_response_comparison(ids, ve_paths, file_prefix): filename = 'Noise2' ids1 = find_cells_with_all_models(ids) colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k'] for specimen_id in ids1: data_set = expt_data_set(specimen_id) exp_sweeps = lims_utils.get_sweeps_of_type("C1NSSEED_2", specimen_id, passed_only=True) if len(exp_sweeps) == 0: continue fig, axes = plt.subplots(3, 1, sharex=True) plt.subplots_adjust(hspace=0.1, wspace=0.1) axes[2].set_xlim([0, 25]) sweep_data = data_set.get_sweep(exp_sweeps[0]) spike_times = data_set.get_spike_times(exp_sweeps[0]) index_range = sweep_data["index_range"] i = sweep_data["stimulus"][0:index_range[1] + 1] # in A v = sweep_data["response"][0:index_range[1] + 1] # in V i *= 1e12 # to pA v *= 1e3 # to mV sampling_rate = sweep_data["sampling_rate"] # in Hz t = np.arange(0, len(v)) * (1.0 / sampling_rate) axes[1].plot(t, v, color='k', linewidth=0.3) axes[0].scatter(spike_times, [10] * len(spike_times), color='k', s=100, marker="|", linewidth=0.3) axes[2].plot(t, i, color='k', linewidth=0.3) axes[1].set_ylabel("mV") axes[2].set_ylabel("pA") axes[2].set_xlabel("seconds") for model, label, color in zip(BASE_ORDER, LABELS, colors): ve_path = ve_paths[model][specimen_id] data_set = NwbDataSet(ve_path) exp_sweeps = lims_utils.get_sweeps_of_type("C1NSSEED_2", specimen_id, passed_only=True) sweep_data = data_set.get_sweep(exp_sweeps[0]) spike_times = data_set.get_spike_times(exp_sweeps[0]) index_range = sweep_data["index_range"] i = sweep_data["stimulus"][0:index_range[1] + 1] # in A v = sweep_data["response"][0:index_range[1] + 1] # in V i *= 1e12 # to pA v *= 1e3 # to mV sampling_rate = sweep_data["sampling_rate"] # in Hz t = np.arange(0, len(v)) * (1.0 / sampling_rate) axes[0].scatter(spike_times, [80 - (10 * BASE_ORDER.index(model))] * len(spike_times), color='k', s=100, marker="|", linewidth=0.3) axes[0].set_yticklabels([ "", 'Experimental Data', LABELS[6], LABELS[5], LABELS[4], LABELS[3], LABELS[2], LABELS[1], LABELS[0] ]) axes[0].set_ylabel("model type") axes[0].set_title("Spike Times") plt.subplots_adjust(hspace=0.1, wspace=0.1) plt.savefig(str(file_prefix + "_" + filename + "_" + str(specimen_id)), bbox_inches="tight") #plt.show() plt.close()
def extract_info_from_nwb_file(dataset_id, raw_ephys_file_name): info = {} import h5py import numpy as np h5f = h5py.File(raw_ephys_file_name, "r") metas = [ 'aibs_cre_line', 'aibs_dendrite_type', 'intracellular_ephys/Electrode 1/location' ] for m in metas: d = h5f.get('/general/%s' % m) print("%s = \t%s" % (m, d.value)) info[m.split('/')[-1]] = str(d.value) h5f.close() from allensdk.core.nwb_data_set import NwbDataSet data_set = NwbDataSet(raw_ephys_file_name) sweep_numbers = data_set.get_experiment_sweep_numbers() if test: sweep_numbers = [33, 45] sweep_numbers.sort() info[DH.DATASET] = dataset_id info[DH.COMMENT] = 'Data analysed on %s' % (time.ctime()) info[DH.PYELECTRO_VERSION] = pyel_ver info[DH.ALLENSDK_VERSION] = allensdk_ver info[DH.SWEEPS] = {} for sweep_number in sweep_numbers: sweep_data = data_set.get_sweep(sweep_number) if data_set.get_sweep_metadata( sweep_number)['aibs_stimulus_name'] == "Long Square": sweep_info = {} sweep_info[DH.METADATA] = data_set.get_sweep_metadata(sweep_number) info[DH.SWEEPS]['%i' % sweep_number] = sweep_info sweep_info[DH.SWEEP] = sweep_number # start/stop indices that exclude the experimental test pulse (if applicable) index_range = sweep_data['index_range'] # stimulus is a numpy array in amps stimulus = sweep_data['stimulus'][index_range[0]:index_range[-1]] # response is a numpy array in volts response = sweep_data['response'][ index_range[0]:index_range[-1]] * 1000 # sampling rate is in Hz sampling_rate = sweep_data['sampling_rate'] # define some time points in seconds (i.e., convert to absolute time) time_pts = np.arange(0, len(stimulus) / sampling_rate, 1. / sampling_rate) * 1000 comment = 'Sweep: %i in %i; %sms -> %sms; %sA -> %sA; %smV -> %smV' % ( sweep_number, dataset_id, time_pts[0], time_pts[-1], np.amin(stimulus), np.amax(stimulus), np.amin(response), np.amax(response)) print(comment) sweep_info[DH.COMMENT] = comment analysis = utils.simple_network_analysis( {sweep_number: response}, time_pts, extra_targets=[ '%s:value_280' % sweep_number, '%s:average_1000_1200' % sweep_number, '%s:average_100_200' % sweep_number ], end_analysis=1500, plot=plot, show_plot_already=False, verbose=True) sweep_info[DH.ICLAMP_ANALYSIS] = analysis analysis_file_name = '%s_analysis.json' % (dataset_id) analysis_file = open(analysis_file_name, 'w') pretty = pp.pformat(info) pretty = pretty.replace('\'', '"') pretty = pretty.replace('u"', '"') analysis_file.write(pretty) analysis_file.close() print('Written info to %s' % analysis_file_name)
def extract_info_from_nwb_file(dataset_id, raw_ephys_file_name): info = {} import h5py import numpy as np h5f = h5py.File(raw_ephys_file_name, "r") metas = ['aibs_cre_line','aibs_dendrite_type','intracellular_ephys/Electrode 1/location'] for m in metas: d = h5f.get('/general/%s'%m) print("%s = \t%s"%(m,d.value)) info[m.split('/')[-1]]=str(d.value) h5f.close() from allensdk.core.nwb_data_set import NwbDataSet data_set = NwbDataSet(raw_ephys_file_name) sweep_numbers = data_set.get_experiment_sweep_numbers() if test: sweep_numbers = [33,45] sweep_numbers.sort() info[DH.DATASET] = dataset_id info[DH.COMMENT] = 'Data analysed on %s'%(time.ctime()) info[DH.PYELECTRO_VERSION] = pyel_ver info[DH.ALLENSDK_VERSION] = allensdk_ver info[DH.SWEEPS] = {} for sweep_number in sweep_numbers: sweep_data = data_set.get_sweep(sweep_number) if data_set.get_sweep_metadata(sweep_number)['aibs_stimulus_name'] == "Long Square": sweep_info = {} sweep_info[DH.METADATA] = data_set.get_sweep_metadata(sweep_number) info[DH.SWEEPS]['%i'%sweep_number] = sweep_info sweep_info[DH.SWEEP] = sweep_number # start/stop indices that exclude the experimental test pulse (if applicable) index_range = sweep_data['index_range'] # stimulus is a numpy array in amps stimulus = sweep_data['stimulus'][index_range[0]:index_range[-1]] # response is a numpy array in volts response = sweep_data['response'][index_range[0]:index_range[-1]]*1000 # sampling rate is in Hz sampling_rate = sweep_data['sampling_rate'] # define some time points in seconds (i.e., convert to absolute time) time_pts = np.arange(0,len(stimulus)/sampling_rate,1./sampling_rate)*1000 comment = 'Sweep: %i in %i; %sms -> %sms; %sA -> %sA; %smV -> %smV'%(sweep_number, dataset_id, time_pts[0], time_pts[-1], np.amin(stimulus), np.amax(stimulus), np.amin(response), np.amax(response)) print(comment) sweep_info[DH.COMMENT] = comment analysis = utils.simple_network_analysis({sweep_number:response}, time_pts, extra_targets = ['%s:value_280'%sweep_number, '%s:average_1000_1200'%sweep_number, '%s:average_100_200'%sweep_number], end_analysis=1500, plot=plot, show_plot_already=False, verbose=True) sweep_info[DH.ICLAMP_ANALYSIS] = analysis analysis_file_name = '%s_analysis.json'%(dataset_id) analysis_file = open(analysis_file_name, 'w') pretty = pp.pformat(info) pretty = pretty.replace('\'', '"') pretty = pretty.replace('u"', '"') analysis_file.write(pretty) analysis_file.close() print('Written info to %s'%analysis_file_name)