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 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_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)
