def store_and_load_custom_array(): a = [[1,2,3,4],[6,7]] h5w.add_to_h5(fn,{'a': a},overwrite_dataset=True) # loading the whole data res = h5w.load_h5(fn) for i in xrange(len(a)): assert(numpy.sum(a[i]-res['a'][i]) < 1e-12) # loading path directly res = h5w.load_h5(fn, path='a/') for i in xrange(len(a)): assert(numpy.sum(a[i]-res[i]) < 1e-12)
def old_store_and_load_simpledata(label=''): res = {} for key,val in zip(simpledata_str,simpledata_val): res[key] = val h5w.add_to_h5(fn,res,write_mode='w',dict_label=label) res.clear() if label == '': res = h5w.load_h5(fn) else: res = h5w.load_h5(fn)[label] for key,val in zip(simpledata_str,simpledata_val): assert(res[key] == val)
def handle_nonexisting_path(label=''): res = {} stest = 'this is a test' h5w.add_to_h5(fn,res,write_mode='w',dict_label=label) try: res = h5w.load_h5(fn,path='test/') raise Exception() # should not get until here except KeyError: res['test'] = stest h5w.add_to_h5(fn,res) res.clear() res = h5w.load_h5(fn,path='test/') assert(res == stest)
def overwrite_dataset(label=''): res = {'a':5} h5w.add_to_h5(fn,res,write_mode='w',dict_label=label) res.clear() res = {'a':6} h5w.add_to_h5(fn,res,write_mode='a',overwrite_dataset=False,dict_label=label) res.clear() res = h5w.load_h5(fn,label) assert(res['a'] == 5) # dataset should still contain old value res.clear() res = {'a':6} h5w.add_to_h5(fn,res,write_mode='a',overwrite_dataset=True,dict_label=label) res.clear() res = h5w.load_h5(fn,label) assert(res['a'] == 6) # dataset should contain new value
def write_empty_array(label=''): res = {'a':[],'b':numpy.array([])} h5w.add_to_h5(fn,res,write_mode='w',dict_label=label) res.clear() res = h5w.load_h5(fn,label) assert_array_equal(res['a'],[]) assert_array_equal(res['b'],[])
def read_empty_array_via_path(): res = {'a': numpy.array([[],[]])} h5w.add_to_h5(fn, res, dict_label='test_label') res.clear() res = h5w.load_h5(fn, path='test_label/a') assert_array_equal(res, [[],[]]) assert(numpy.shape(res) == (2,0))
def store_and_load_dataset_directly(label=''): res = {} for key,val in zip(simpledata_str,simpledata_val): res[key] = val h5w.add_to_h5(fn,res,write_mode='w',dict_label=label) for key,val in zip(simpledata_str,simpledata_val): assert(h5w.load_h5(fn,label+'/'+key) == val)
def store_and_load_quantities_array() : import quantities as pq data = {'times' : numpy.array([1,2,3])*pq.ms, 'positions' : numpy.array([1,2,3])*pq.cm} h5w.add_to_h5(fn, data, overwrite_dataset=True) # loading the whole data res = h5w.load_h5(fn) assert(res['times'].dimensionality == data['times'].dimensionality)
def store_and_test_key_types() : data = {'a' : 1, (1,2) : 2., 4. : 3.} h5w.add_to_h5(fn,data,write_mode='w', compression='gzip') res = h5w.load_h5(fn) keys = ['a',(1,2),4.] for k in keys : assert(k in res.keys())
def store_and_load_arraydata(label=''): res = {} for key,val in zip(arraydata_str,arraydata_val): res[key] = val h5w.add_to_h5(fn,res,write_mode='w',dict_label=label) res.clear() res = h5w.load_h5(fn,label) for key,val in zip(arraydata_str,arraydata_val): assert_array_equal(res[key],val)
def write_nested_empty_array(label=''): res = {'a':[[],[]],'b':numpy.array([[],[]])} h5w.add_to_h5(fn,res,write_mode='w',dict_label=label) res.clear() res = h5w.load_h5(fn,label) assert_array_equal(res['a'],[[],[]]) assert(numpy.shape(res['a']) == (2,0)) assert_array_equal(res['b'],[[],[]]) assert(numpy.shape(res['b']) == (2,0))
def testEmpiricalTransferFunction(self): params = {} params['tf_mode'] = 'empirical' params['tau_impulse'] = np.array([8.555, 5.611, 4.167, 4.381, 4.131, 3.715, 4.538, 3.003]) params['delta_f'] = np.array([0.0880, 0.458, 0.749, 0.884, 1.183, 1.671, 0.140, 1.710])/self.net.params['w'] net = circuit.Circuit('microcircuit', params) freqs, power = net.create_power_spectra() power_test = h5.load_h5(self.test_data, 'empirical/power') assert (np.allclose(power_test, power, rtol=self.rtol, atol=self.atol))
def testGetSensitivityMeasure(self): freq = 82.0 indices = [None] + [i for i in range(8)] for delay_dist in ['none','gaussian','truncated_gaussian']: self.net.alter_params({'delay_dist': delay_dist}) for i in indices: T = self.net.get_sensitivity_measure(freq, index=i) T_test = h5.load_h5(self.test_data, delay_dist + '/' + str(i) + '/T') assert (np.allclose(T_test, T, rtol=self.rtol, atol=self.atol))
def store_and_load_dictdata(label=''): res = {} for key,val in zip(dictdata_str,dictdata_val): res[key] = val h5w.add_to_h5(fn,res,write_mode='w',dict_label=label) res.clear() res = h5w.load_h5(fn,label) for dkey,dval in zip(dictdata_str,dictdata_val): for key,val in dval.items(): assert(res[dkey][key] == val)
def testGetSensitivityMeasure(self): freq = 82.0 indices = [None] + [i for i in range(8)] for delay_dist in ['none', 'gaussian', 'truncated_gaussian']: self.net.alter_params({'delay_dist': delay_dist}) for i in indices: T = self.net.get_sensitivity_measure(freq, index=i) T_test = h5.load_h5(self.test_data, delay_dist + '/' + str(i) + '/T') assert (np.allclose(T_test, T, rtol=self.rtol, atol=self.atol))
def get_rate_one_neuron_sim(params, pop, gid, T=10000.0, tmin=300.0, calc=False): folder = get_folder(params) label = 'plot_rate_one_neuron' + folder + 'gid' + str(gid) + 'pop' + str(pop) if calc: rate = rs.get_rate_one_neuron(folder, pop, gid, T, tmin) h5.add_to_h5('results.h5',{label:{'rate' : rate}}, 'a', overwrite_dataset=True) else: rate = h5.load_h5('results.h5', label + '/rate') return rate
def get_spectra_approx(calcAna, calcAnaAll): print('Calculate approximate spectra.') if calcAna or calcAnaAll: circ = circuit.Circuit('microcircuit', circuit_params, fmax=400.0, from_file=not calcAnaAll) freqs_approx, power_approx = circ.create_power_spectra_approx() h5.add_to_h5('results.h5', { 'fig_eigenmodes': { 'freqs_approx': freqs_approx, 'power_approx': power_approx } }, 'a', overwrite_dataset=True) else: freqs_approx = h5.load_h5('results.h5', 'fig_eigenmodes/freqs_approx') power_approx = h5.load_h5('results.h5', 'fig_eigenmodes/power_approx') return freqs_approx, power_approx
def get_eigenvalues(calcAna, calcAnaAll): print('Calculate eigenvalues.') if calcAna or calcAnaAll: circ = circuit.Circuit('microcircuit', circuit_params, fmax=400.0, from_file=not calcAnaAll) freq_ev, eigenvalues = circ.create_eigenvalue_spectra('MH') h5.add_to_h5('results.h5', { 'fig_eigenmodes': { 'freq_ev': freq_ev, 'eigenvalues': eigenvalues } }, 'a', overwrite_dataset=True) else: freq_ev = h5.load_h5('results.h5', 'fig_eigenmodes/freq_ev') eigenvalues = h5.load_h5('results.h5', 'fig_eigenmodes/eigenvalues') return freq_ev, eigenvalues
def testEmpiricalTransferFunction(self): params = {} params['tf_mode'] = 'empirical' params['tau_impulse'] = np.array( [8.555, 5.611, 4.167, 4.381, 4.131, 3.715, 4.538, 3.003]) params['delta_f'] = np.array([ 0.0880, 0.458, 0.749, 0.884, 1.183, 1.671, 0.140, 1.710 ]) / self.net.params['w'] net = circuit.Circuit('microcircuit', params) freqs, power = net.create_power_spectra() power_test = h5.load_h5(self.test_data, 'empirical/power') assert (np.allclose(power_test, power, rtol=self.rtol, atol=self.atol))
def get_sim_data_spec(calcData, a, conn, pop): print 'Get power spectra from simulation.' label = str(a) + str(conn[0]) + str(conn[1]) if conn == [3, 3]: folder_base = 'data_zval_L4IL4I' elif conn == [5, 4]: folder_base = 'data_zval_L5EL5I' folder = folder_base + str(1 + a) if calcData: nr_window = 10 bin_size = 1.0 dt = (10000.0 - 300.0) / nr_window Ts = [300.0 + i * dt for i in range(nr_window)] psim = 0 for k, T in enumerate(Ts): fsim, p_sim = rs.get_spec(folder, pop, T + dt, T, fmax=500.0, bin_size=bin_size) psim += np.asarray(p_sim) / float(len(Ts)) powers = psim freqs = np.asarray(fsim) h5.add_to_h5( 'results.h5', {'Z_validation': { label: { 'freqs_sim': freqs, 'p_sim': powers } }}, 'a', overwrite_dataset=True) else: path_base = 'Z_validation/' + label freqs = h5.load_h5('results.h5', path_base + '/freqs_sim') powers = h5.load_h5('results.h5', path_base + '/p_sim') return freqs, powers
def get_rates_sim(params, T=10000.0, tmin=300.0, calc=False, read_old_results=False): folder = get_folder(params) label = 'plot_rates' + folder if read_old_results: path = '/Users/bos/Documents/pittsburgh/disinhibitory_circuits/py/E-I-VIP/' rates_sim = h5.load_h5(path + 'results.h5', label + '/rates_sim') return rates_sim if calc: rates_sim = [] for pop in range(3): rate = rs.get_all_rates(folder, pop, T, tmin) rates_sim.append(np.mean(rate)) np.asarray(rates_sim) h5.add_to_h5('results.h5',{label:{ 'rates_sim': rates_sim}}, 'a', overwrite_dataset=True) rates_sim = h5.load_h5('results.h5', label + '/rates_sim') else: rates_sim = h5.load_h5('results.h5', label + '/rates_sim') return rates_sim
def get_diffapprox_gain_coefficient(params, calc=False): folder = get_folder(params) label = 'plot_gain_coefficient' + folder circuit_params = set_circuit_params(params) if calc: circ = circuit.Circuit('3dcircuit', circuit_params, analysis_type='stationary', from_file='False') rates_calc = circ.th_rates MH = circ.ana.create_MH0() P = np.linalg.inv(np.eye(3)-MH) betas = circ.ana.create_H0_mu()[:,0] factor = np.dot(P[:,:2], betas[:2]) h5.add_to_h5('results.h5',{label:{ 'rates_calc': rates_calc, 'factor': factor}}, 'a', overwrite_dataset=True) else: rates_calc = h5.load_h5('results.h5', label + '/rates_calc') factor = h5.load_h5('results.h5', label + '/factor') return rates_calc, factor
def get_diffapprox_rates(params, calc=False, read_old_results=False): folder = get_folder(params) label = 'plot_rates_' + folder if read_old_results: path = '/Users/bos/Documents/pittsburgh/disinhibitory_circuits/py/E-I-VIP/' rates = h5.load_h5(path + 'results.h5', label + '/rates_calc') return rates circuit_params = set_circuit_params(params) if calc: circ = circuit.Circuit('3dcircuit', circuit_params, analysis_type='stationary', from_file='False') rates = circ.th_rates h5.add_to_h5('results.h5',{label:{'rates_calc': rates}}, 'a', overwrite_dataset=True) else: rates = h5.load_h5('results.h5', label + '/rates_calc') return rates
def get_rates(calcData, calcAna, calcAnaAll, folder=folder): print 'Get data for firing rates.' tmin = 300.0 if calcData: rates_sim = [] for pop in range(8): mu = rs.get_mu_rate(folder, pop, T, tmin) rates_sim.append(mu) h5.add_to_h5('results.h5',{'fig_microcircuit':{ 'rates_sim': rates_sim}}, 'a', overwrite_dataset=True) else: rates_sim = h5.load_h5('results.h5', 'fig_microcircuit/rates_sim') if calcAna or calcAnaAll: circ = circuit.Circuit('microcircuit', circuit_params, analysis_type='stationary', from_file=not calcAnaAll) rates_calc = circ.th_rates h5.add_to_h5('results.h5',{'fig_microcircuit':{ 'rates_calc': rates_calc}}, 'a', overwrite_dataset=True) else: rates_calc = h5.load_h5('results.h5','fig_microcircuit/rates_calc') return np.asarray(rates_sim), rates_calc
def testFiringRatesSlow(self): circ = circuit.Circuit('microcircuit', analysis_type='stationary') params = circ.params xs_array = [0.1*i for i in range(10)] rates = [] for xs in xs_array: params['xs'] = np.ones((8,8))*xs params['xs_ext'] = np.ones(8)*xs circ = circuit.Circuit('microcircuit', params, analysis_type='stationary', from_file=False) rates.append(circ.th_rates) rates = np.transpose(np.asarray(rates)) rates_test = h5.load_h5(self.test_data, 'rates_slow') assert (np.allclose(rates_test, rates, rtol=self.rtol, atol=self.atol))
def get_gain_sim(rates0, params, Kstim, T=10000.0, tmin=300.0, calc=False, read_old_results=False): stim_params = params.copy() stim_params['KEext'] = params['KEext'] + Kstim stim_params['KIext'] = params['KIext'] + Kstim folder = get_folder(stim_params) label = 'plot_rates_gain_sim' + str(Kstim) + folder if read_old_results: path = '/Users/bos/Documents/pittsburgh/disinhibitory_circuits/py/E-I-VIP/' g = h5.load_h5(path + 'results.h5', label + '/g') return g if calc: rates_sim = [] rate = rs.get_all_rates(folder, 0, T, tmin) rate = np.mean(rate) # divide by 8 since this is the external firing rate in simulation g = (rate-rates0[0])/(Kstim*8.) h5.add_to_h5('results.h5',{label:{ 'g': g}}, 'a', overwrite_dataset=True) else: g = h5.load_h5('results.h5', label + '/g') return g
def test_store_and_rehash_h5py(self): d0 = { 'a': 'asd', 'b': 0.12, 'c': [3, 4, 5], 'd': np.array([[3, 4, 5], [3, 4, 5]]), 'e': True } hash0 = dicthash.generate_hash_from_dict(d0) h5w.add_to_h5('store_and_rehash_h5py.h5', {'d0': d0}, 'w') d1 = h5w.load_h5('store_and_rehash_h5py.h5', 'd0') hash1 = dicthash.generate_hash_from_dict(d1) self.assertEqual(hash0, hash1)
def get_diffapprox_Next(params, rates, calc=False): folder = get_folder(params) label = 'plot_rates_Next_' + folder + str(rates) if rates[2]>0: label += 'rS_' + str(rates[2]) circuit_params = set_circuit_params(params) if calc: print 'calculate Next' circ = circuit.Circuit('3dcircuit', circuit_params, analysis_type='stationary', from_file='False') rates_calc = circ.th_rates M = circ.I*circ.W Next, betas = circ.get_external_input(rates) h5.add_to_h5('results.h5', {label:{'Next': Next, 'betas': betas, 'M': M}}, 'a', overwrite_dataset=True) else: Next = h5.load_h5('results.h5', label + '/Next') betas = h5.load_h5('results.h5', label + '/betas') M = h5.load_h5('results.h5', label + '/M') return Next, betas, M
def get_eigenvalues_layers(calcAna, calcAnaAll): print('Calculate eigenvalues.') if calcAna or calcAnaAll: circ = circuit.Circuit('microcircuit', circuit_params, fmax=400.0, from_file=not calcAnaAll) eigs_layer = [] for i, layer in enumerate(ph.layers): M_red = np.zeros((8, 8)) M_red[2 * i: 2 * i + 2, 2 * i: 2 * i + 2] = np.ones((2, 2)) circ.reduce_connectivity(M_red) freqs, eigs = circ.create_eigenvalue_spectra('MH') eigs_layer.append(eigs[0]) eigs_layer.append(eigs[1]) circ.restore_full_connectivity() eigs_layer = np.transpose(np.asarray(eigs_layer)) h5.add_to_h5('results.h5', {'eigenvalue_trajectories': { 'freq_layer': freqs, 'eigs_layer': eigs_layer}}, 'a', overwrite_dataset=True) else: freqs = h5.load_h5('results.h5', 'eigenvalue_trajectories/freq_layer') eigs_layer = h5.load_h5('results.h5', 'eigenvalue_trajectories/eigs_layer') return freqs, eigs_layer
def get_spectra(calcAna, calcAnaAll): print('Calculate spectra.') if calcAna or calcAnaAll: circ = circuit.Circuit('microcircuit', circuit_params, fmax=400.0, from_file=not calcAnaAll) freqs, power = circ.create_power_spectra() power_layer = [] for i, layer in enumerate(ph.layers): M_red = np.zeros((8, 8)) M_red[2 * i: 2 * i + 2, 2 * i: 2 * i + 2] = np.ones((2, 2)) circ.reduce_connectivity(M_red) freqs, power_red = circ.create_power_spectra() power_layer.append([power_red[2 * i], power_red[2 * i + 1]]) circ.restore_full_connectivity() h5.add_to_h5('results.h5', {'eigenvalue_trajectories': { 'freqs_spec': freqs, 'power_layer': power_layer, 'power': power}}, 'a', overwrite_dataset=True) else: freqs = h5.load_h5('results.h5', 'eigenvalue_trajectories/freqs_spec') power_layer = h5.load_h5('results.h5', 'eigenvalue_trajectories/power_layer') power = h5.load_h5('results.h5', 'eigenvalue_trajectories/power') return freqs, power_layer, power
def get_dotplot(params, dt, calc=False, read_old_results=False): folder = get_folder(params) label = 'plot_rates_all_cvs_dt' + str(dt[0]) + str(dt[1]) + folder if read_old_results: path = '/Users/bos/Documents/pittsburgh/disinhibitory_circuits/py/E-I-VIP/' times = h5.load_h5(path + 'results.h5', label + '/times') gids = h5.load_h5(path + 'results.h5', label + '/gids') return times, gids times = [] gids = [] if calc: for pop in range(3): spikes, this_gids = rs.get_data_dotplot( folder, dt[0], dt[1], pop) times.append(np.asarray(spikes)-dt[0]) gids.append(abs(np.asarray(this_gids)-5170)) h5.add_to_h5('results.h5',{label:{ 'times': times, 'gids': gids}},'a', overwrite_dataset=True) else: times = h5.load_h5('results.h5', label + '/times') gids = h5.load_h5('results.h5', label + '/gids') return times, gids
def testFiringRatesSlow(self): circ = circuit.Circuit('microcircuit', analysis_type='stationary') params = circ.params xs_array = [0.1 * i for i in range(10)] rates = [] for xs in xs_array: params['xs'] = np.ones((8, 8)) * xs params['xs_ext'] = np.ones(8) * xs circ = circuit.Circuit('microcircuit', params, analysis_type='stationary', from_file=False) rates.append(circ.th_rates) rates = np.transpose(np.asarray(rates)) rates_test = h5.load_h5(self.test_data, 'rates_slow') assert (np.allclose(rates_test, rates, rtol=self.rtol, atol=self.atol))
def get_stability_matrix(params, rE_array, rI_array, rS, calc_Next=False, calc_dmin=False): folder = get_folder(params) label_dmin = 'stability_matrix_' + folder Next, betas, M = get_diffapprox_Next_for_rE_rI_grid(params, rE_array, rI_array, rS, calc_Next=calc_Next) if calc_dmin: dmin = np.zeros((len(rE_array), len(rI_array))) for i,re in enumerate(rE_array): for j,ri in enumerate(rI_array): dmin[i][j] = get_dmin(params, betas[i][j], M, calc=calc_dmin) h5.add_to_h5('results.h5', {label_dmin:{'dmin': dmin}}, 'a', overwrite_dataset=True) else: dmin = h5.load_h5('results.h5', label_dmin + '/dmin') return dmin
def get_eigs2d_matrix(params, rE_array, rI_array, rS, calc_Next=False, calc_eigs=False): folder = get_folder(params) label = 'eigs2d_matrix_' + folder Next, betas, M = get_diffapprox_Next_for_rE_rI_grid(params, rE_array, rI_array, rS, calc_Next=calc_Next) if calc_eigs: eigs = np.zeros((len(rE_array), len(rI_array),2), dtype=complex) for i,re in enumerate(rE_array): for j,ri in enumerate(rI_array): MH = np.dot(np.diag(betas[i][j][:2]),M[:2,:2]) eigs[i][j], _ = np.linalg.eig(MH) h5.add_to_h5('results.h5',{label:{'eigs': eigs}}, 'a', overwrite_dataset=True) else: eigs = h5.load_h5('results.h5', label + '/eigs') return eigs
def load_rejections(load_from): output = None filelist = glob.glob(load_from + '*.hdf5') if len(filelist) > 0: output = {} for filename in filelist: rej = h5py.load_h5(filename) output[rej['fsets']['filtername']] = \ {'Highcut': rej['fsets']['highcut'], 'Lowcut': rej['fsets']['lowcut'], 'Order': rej['fsets']['order'], 'RejElectrodes': rej['elrej']['bad_electrodes'] if len(rej['elrej']['bad_electrodes']) > 0 else [-1], 'RejTrials': rej['trrej']['bad_trials'] if len(rej['trrej']['bad_trials']) > 0 else [-1]} return output
def get_gain_matrix(params, rE_array, rI_array, rS, calc_Next=False, calc_gain=False): folder = get_folder(params) label = 'gain_matrix_' + folder Next, betas, M = get_diffapprox_Next_for_rE_rI_grid(params, rE_array, rI_array, rS, calc_Next=calc_Next) if calc_gain: gain = np.zeros((len(rE_array), len(rI_array))) for i,re in enumerate(rE_array): for j,ri in enumerate(rI_array): P = np.eye(3)-np.dot(np.diag(betas[i][j]),M) stim = betas[i][j] stim[2] = 0. gain[i][j] = np.dot(np.linalg.inv(P), np.array(stim))[0] h5.add_to_h5('results.h5',{label:{'gain': gain}}, 'a', overwrite_dataset=True) else: gain = h5.load_h5('results.h5', label + '/gain') return gain
def get_diffapprox_rates_Next_array(params, Next_array, calc=False): folder = get_folder(params) label = 'plot_rates_Next_array' + folder label += str(Next_array[0]) + str(Next_array[1]-Next_array[0]) label += str(Next_array[-1]) circuit_params = set_circuit_params(params) if calc: circ = circuit.Circuit('3dcircuit', circuit_params, analysis_type='stationary', from_file='False') rates = np.zeros_like(Next_array) for i in range(Next_array.shape[0]): circuit_params['Next']= Next_array[i] circ.alter_default_params(circuit_params) rates[i] = circ.th_rates h5.add_to_h5('results.h5',{label:{'rates_calc': rates}}, 'a', overwrite_dataset=True) else: rates = h5.load_h5('results.h5', label + '/rates_calc') return rates
def testPowerSpetraSlow(self): xs = 0.4 # fraction of slow currents in microcircuit xs_mode = 0.5 # fraction of slow currents from 4I to 4I dsd = 1.0 circ = circuit.Circuit('microcircuit', analysis_type=None) I_new = circ.I.copy() # reduce indegrees from 4I to 4E I_new[2][3] = np.round(circ.I[2][3]*(1.0-0.15)) Next_new = circ.Next.copy() # adjust external input to 4E Next_new[2] -= 300 Next_new[2] *= (1.0-0.011) new_params = {'de_sd': circ.de*dsd, 'di_sd': circ.di*dsd, 'I': I_new, 'Next': Next_new, 'delay_dist': 'truncated_gaussian'} params = circ.params params.update(new_params) params['xs'] = np.ones((8,8))*xs params['xs_ext'] = np.ones(8)*xs params['xs'][3][3] = xs_mode circ = circuit.Circuit('microcircuit', params, fmax=500.0) freqs, power = circ.create_power_spectra() power_test = h5.load_h5(self.test_data, 'power_slow') assert (np.allclose(power_test, power, rtol=self.rtol, atol=self.atol))
def get_dr_dIm_matrix(params, rE_array, rI_array, rS, pES, pIS, sign, calc_Next=False, calc_dr_dIm=False): folder = get_folder(params) label = 'dr_dIm_matrix_' + folder + str(pES) + str(pIS) + str(sign) Next, betas, M = get_diffapprox_Next_for_rE_rI_grid(params, rE_array, rI_array, rS, calc_Next=calc_Next) if calc_dr_dIm: dr_dIm_matrix = np.zeros((len(rE_array), len(rI_array), 2)) for i,re in enumerate(rE_array): for j,ri in enumerate(rI_array): betas[i][j][2] = 1. P = M.copy() P[0][2] = P[0][1]/0.1*pES P[1][2] = P[0][1]/0.1*pIS P = np.eye(3)-np.dot(np.diag(betas[i][j]),P) dr = np.dot(np.linalg.inv(P), np.array([0, 0, sign]))[0:2] dr_dIm_matrix[i][j] = dr/np.max(abs(dr)) h5.add_to_h5('results.h5',{label:{'dr_dIm_matrix': dr_dIm_matrix}}, 'a', overwrite_dataset=True) else: dr_dIm_matrix = h5.load_h5('results.h5', label + '/dr_dIm_matrix') return dr_dIm_matrix
def testFiringRates(self): firing_rates = h5.load_h5(self.test_data, 'firing_rates') assert (np.allclose(firing_rates, self.net_stat.th_rates, rtol=self.rtol, atol=self.atol))
# ============================================================================= # Result directory contains filename, filter and trial to overcome problems # with number of files in a directory pc = projctrl.ProjectControl( project_name='collab-waves', script_name='ms_figs/movs1_small/movie_%s_filter_%s_trialid_%i' % (selected_subsession_name, selected_filter, selected_trial_id), clear_data=True) # ============================================================================= # Set and save parameters # ============================================================================= param_prop = h5pyw.load_h5(pc.result_domain + '/calc_waveproperties/' + selected_subsession_name + '_filter_' + selected_filter + '_param.h5') param = {} param['trigger'] = 'TS' param['tpre'] = 200. * pq.ms param['tpost'] = 3400. * pq.ms param['trial_id'] = selected_trial_id param['step_size'] = 2 * pq.ms param['min_stat_duration'] = 5 mylabelsize = 14 myaxissize = 10 # =============================================================================
def calc_waveproperties(job_id, selected_subsession, selected_filter): """ Main function to perform the analysis on one subsession. Parameters ---------- job_id: integer Numeric job ID selected_subsession: string Filename of the selected subsession. selected_filter: string Parameter that specifies the filtering to be used. """ # ============================================================================= # Set and save parameters # ============================================================================= selected_subsession_name = selected_subsession[0] selected_subsession_cnd = selected_subsession[1] selected_monkey = wave_main.monkey_names[selected_subsession[0][0]] print( "Started job %i: %s - %s" % (job_id, selected_subsession[0], selected_filter)) # Get directories where files are stored data_dir, metadata_dir = wave_main.get_data_dir(selected_subsession_name) param = {} param['subsession'] = selected_subsession_name param['condition'] = selected_subsession_cnd param['monkey'] = selected_monkey param['filter'] = selected_filter # Extract frequencies from selected filter if 'lowcut' in wave_main.selected_filters[selected_filter]: # Generic filter band param['lowcut'] = wave_main.selected_filters[ selected_filter]['lowcut'] param['highcut'] = wave_main.selected_filters[ selected_filter]['highcut'] param['order'] = wave_main.selected_filters[ selected_filter]['order'] else: # Monkey specific filter band param['lowcut'] = wave_main.selected_filters[selected_filter][ selected_monkey]['lowcut'] param['highcut'] = wave_main.selected_filters[selected_filter][ selected_monkey]['highcut'] param['order'] = wave_main.selected_filters[selected_filter][ selected_monkey]['order'] param['frequency'] = (param['lowcut'] + param['highcut']) / 2. param['nextneighbor_distance'] = 2 param['alignment'] = 'Connector' # ============================================================================= # Load data # ============================================================================= print("Loading data - %s" % selected_subsession_name) subsessionobj = ReachGraspIO( os.path.join(data_dir, selected_subsession_name), metadata_dir=metadata_dir, print_diagnostic=True) # Read in data neo_block = subsessionobj.read_block( n_starts=[None], n_stops=[None], channel_list=range(1, 97), nsx=2, events=True) # ============================================================================= # Process data # ============================================================================= # Save various results and path location of frames in neo hdf5 results = {} # Open Neo hdf5 file for saving results framesfile = pc.result_path + selected_subsession_name + '_filter_' + \ selected_filter + '_neo_frames.h5' if os.path.exists(framesfile): os.remove(framesfile) ho = nh5.NeoHdf5IO(filename=framesfile) # Extract phase information using Elephant print("Filtering blocks - %s" % selected_subsession_name) pick.map_as( neo_block, elephant.signal_processing.butter, annotations=None, lowpass_freq=param['highcut'], highpass_freq=param['lowcut'], order=param['order']) print("z-scoring block - %s" % selected_subsession_name) pick.map_as( neo_block, elephant.signal_processing.zscore, annotations=None, inplace=False) print("Calculating the analytic - %s" % selected_subsession_name) pick.map_as( neo_block, elephant.signal_processing.hilbert, annotations=None) print("Determining connected, non-broken, non-rejected electrodes - %s" % selected_subsession_name) # This is a micro solution to obtain the broken electrodes if selected_monkey in ['Tanya', 'Nikos2', 'Lilou']: import h5py_wrapper.wrapper as h5py try: rej = h5py.load_h5(os.path.join( metadata_dir, "source", "rejections", "data", selected_subsession_name + "_lfp_el_rej_015Hz-030Hz-03o.hdf5")) list_of_rej_el = rej['bad_electrodes'] except: rej = h5py.load_h5(os.path.join( metadata_dir, "source", "rejections", "data", selected_subsession_name + "_rej_012Hz-040Hz-03o.hdf5")) list_of_rej_el = rej['elrej']['bad_electrodes'] print(list_of_rej_el) for asig in neo_block.segments[0].analogsignals: if asig.annotations['electrode_id'] in list_of_rej_el: asig.annotations['rejIFC'] = True else: asig.annotations['rejIFC'] = False if selected_monkey == 'Lilou': list_of_rej_el = [33, 83, 92] for asig in neo_block.segments[0].analogsignals: if asig.annotations['ca_id'] in list_of_rej_el: asig.annotations['rejIFC'] = True else: asig.annotations['rejIFC'] = False results['good_el'] = wave_main.calc_good_el(neo_block) # Check number of non-broken horizontal/vertical neighbors is large, # required to calculate meaningful gradients for i in range(1, 101): nns = wave_main.get_nn_nodiag(i, param['nextneighbor_distance']) if np.count_nonzero( np.array([results['good_el'][_ - 1] for _ in nns])) < 3 and \ results['good_el'][i - 1]: results['good_el'][i - 1] = False # Restart search, since we marked one electrode as bad i = 1 print("Calculating phase - %s" % selected_subsession_name) phase_frames = wave_main.calc_phases(neo_block) ho.save(phase_frames) results['phase_frames_path'] = phase_frames.hdf5_path print("Calculating amplitude frames - %s" % selected_subsession_name) amp_frames = wave_main.calc_amps(neo_block) ho.save(amp_frames) results['amp_frames_path'] = amp_frames.hdf5_path print("Calculating phase gradient frames - %s" % selected_subsession_name) phgr_frames = wave_main.calc_phgr( phase_frames, param['nextneighbor_distance'], results['good_el']) ho.save(phgr_frames) results['phgr_frames_path'] = phgr_frames.hdf5_path print("Calculating coherence phase gradient frames - %s" % selected_subsession_name) cohphgr_frames = wave_main.calc_cohphgr( phgr_frames, param['nextneighbor_distance'], results['good_el']) ho.save(cohphgr_frames) results['cohphgr_frames_path'] = cohphgr_frames.hdf5_path ho.close() # Write file containing the table of contents of the Neo hdf5 print("Saving info file - %s" % selected_subsession_name) h5pyw.add_to_h5( pc.result_path + selected_subsession_name + '_filter_' + selected_filter + '_info.h5', results, write_mode='w', overwrite_dataset=True) # Write parameters to disk print("Saving parameters - %s" % selected_subsession_name) h5pyw.add_to_h5( pc.result_path + selected_subsession_name + '_filter_' + selected_filter + '_param.h5', param, write_mode='w', overwrite_dataset=True)
def store_none(): res = {'a1':None} h5w.add_to_h5(fn,res,write_mode='w') res.clear() res = h5w.load_h5(fn) assert(res['a1'] == None)
def testFiringRates(self): firing_rates = h5.load_h5(self.test_data, 'firing_rates') assert(np.allclose(firing_rates, self.net_stat.th_rates, rtol=self.rtol, atol=self.atol))
def testTransferFunction(self): freqs, dtf = self.net.get_transfer_function() trans_func_test = h5.load_h5(self.test_data, '/dyn_trans_func') assert(np.allclose(dtf, trans_func_test, rtol=self.rtol, atol=self.atol))
def read_from_file(self, path): '''Reads data from h5 file at location path.''' self.file_base = os.getcwd()+'/'+self.params['datafile'] path_base = '/' + self.param_hash + '/' data = h5.load_h5(self.file_base, path_base + path) return data
def testCreatePowerSpectra(self): for delay_dist in ['none','gaussian','truncated_gaussian']: self.net.alter_params({'delay_dist': delay_dist}) freqs, power = self.net.create_power_spectra() power_test = h5.load_h5(self.test_data, delay_dist + '/power') assert (np.allclose(power_test, power, rtol=self.rtol, atol=self.atol))
def testCreateEigenvalueSpectra(self): for delay_dist in ['none','gaussian','truncated_gaussian']: self.net.alter_params({'delay_dist': delay_dist}) freqs, eigs = self.net.create_eigenvalue_spectra('MH') eigs_test = h5.load_h5(self.test_data, delay_dist + '/eigs_sum') assert (np.allclose(np.sum(eigs_test,axis=0), np.sum(eigs,axis=0), rtol=self.rtol, atol=self.atol))
def handle_nonexisting_file(): try: res = h5w.load_h5('asdasd.h5') raise Exception() # should not get until here except IOError: pass
def store_and_load_with_compression() : data = {'a':1,'test1':{'b':2},'test2':{'test3':{'c':numpy.array([1,2,3])}}} h5w.add_to_h5(fn,data,write_mode='w', compression='gzip') res = h5w.load_h5(fn)