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 get_sensitivity_measure(calcAna, calcAnaAll, mode='gamma', eig_index=None):
print 'Calculate sensitivity measure.'
if calcAna or calcAnaAll:
if mode == 'gamma' or mode == 'low':
fmax = 100.0
elif mode == 'high_gamma':
fmax = 400.0
circ = circuit.Circuit('microcircuit',
circuit_params,
fmax=fmax,
from_file=not calcAnaAll)
freqs, eigs = circ.create_eigenvalue_spectra('MH')
if mode == 'gamma':
fmax = freqs[np.argmin(abs(eigs[eig_index] - 1))]
Z = circ.get_sensitivity_measure(fmax)
eigc = eigs[eig_index][np.argmin(abs(eigs[eig_index] - 1))]
elif mode == 'high_gamma':
eigs = eigs[eig_index][np.where(freqs > 150.)]
freqs = freqs[np.where(freqs > 150.)]
fmax = freqs[np.argmin(abs(eigs - 1.0))]
fmax_index = np.argmin(abs(freqs - fmax))
eigc = eigs[fmax_index]
Z = circ.get_sensitivity_measure(fmax, index=eig_index)
elif mode == 'low':
eigs = eigs[eig_index]
fmax = 0.0
eigc = eigs[0]
Z = circ.get_sensitivity_measure(fmax)
k = np.asarray([1, 0]) - np.asarray([eigc.real, eigc.imag])
k /= np.sqrt(np.dot(k, k))
k_per = np.asarray([-k[1], k[0]])
k_per /= np.sqrt(np.dot(k_per, k_per))
Z_amp = Z.real * k[0] + Z.imag * k[1]
Z_freq = Z.real * k_per[0] + Z.imag * k_per[1]
label = mode + str(eig_index)
h5.add_to_h5('results.h5', {
'sensitivity_measure': {
label: {
'f_peak': fmax,
'Z': Z,
'Z_amp': Z_amp,
'Z_freq': Z_freq,
'k': k,
'k_per': k_per,
'eigc': eigc
}
}
},
'a',
overwrite_dataset=True)
else:
path_base = 'sensitivity_measure/' + mode + str(eig_index)
fmax = h5.load_h5('results.h5', path_base + '/f_peak')
Z = h5.load_h5('results.h5', path_base + '/Z')
Z_amp = h5.load_h5('results.h5', path_base + '/Z_amp')
Z_freq = h5.load_h5('results.h5', path_base + '/Z_freq')
k = h5.load_h5('results.h5', path_base + '/k')
k_per = h5.load_h5('results.h5', path_base + '/k_per')
eigc = h5.load_h5('results.h5', path_base + '/eigc')
return fmax, Z, Z_amp, Z_freq, k, k_per, eigc
def get_spec_sim(calcData, nr_window, bin_size):
print 'Get power spectra from simulation.'
power_sim = []
if calcData:
for pop in range(8):
psim = 0
dt = (10000.0-300.0)/nr_window
Ts = [300.0+i*dt for i in range(nr_window)]
for n,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))
power_sim.append(psim)
label = 'power' + str(pop)
h5.add_to_h5('results.h5',{'fig_microcircuit':{
str(nr_window):{label: psim}}},'a',
overwrite_dataset=True)
freq_sim = np.asarray(fsim)
h5.add_to_h5('results.h5',{'fig_microcircuit':{
str(nr_window):{'freq_sim': fsim}}},'a',
overwrite_dataset=True)
else:
for pop in range(8):
label = 'power' + str(pop)
power_sim.append(h5.load_h5('results.h5',
'fig_microcircuit/' + str(nr_window) + '/' + label))
freq_sim = h5.load_h5('results.h5',
'fig_microcircuit/' + str(nr_window) + '/freq_sim')
return power_sim, freq_sim
def get_sim_data_rate(calcData, a, conn, pop):
print 'Get instantaneous firing rates 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 True: #calcData:
bin_size = 15.
dt = [2000, 5000]
time, rate = rs.get_inst_rate(folder,
pop,
dt[1],
dt[0],
bin_size=bin_size)
rate = rate[0].real
h5.add_to_h5('results.h5', {
'Z_validation': {
label: {
'time_sim': time,
'inst_rate_sim': rate
}
}
},
'a',
overwrite_dataset=True)
else:
path_base = 'Z_validation/' + label
time = h5.load_h5('results.h5', path_base + '/time_sim')
rate = h5.load_h5('results.h5', path_base + '/inst_rate_sim')
return time, rate
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 get_diffapprox_Next_for_pSE_array(params, rE, rI, rS, pSE_array,
calc_Next=False):
folder = get_folder(params)
label_Next = 'Next_betas_pSE_array_' + folder + str(rE) + str(rI)
circuit_params = set_circuit_params(params)
if calc_Next:
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 = np.zeros((len(pSE_array), 3))
betas = np.zeros((len(pSE_array), 3))
initial_Next = get_Next(params)
for i,pSE in enumerate(pSE_array):
target_rates = np.array([rE, rI, rS])
circ.Next = initial_Next
params['pSE'] = pSE
circ.alter_default_params({'p': get_connection_probabilities(params)})
Next[i], betas[i] = circ.get_external_input(target_rates)
h5.add_to_h5('results.h5', {label_Next:{'Next': Next, 'betas': betas,
'M': M}}, 'a', overwrite_dataset=True)
else:
Next = h5.load_h5('results.h5', label_Next + '/Next')
betas = h5.load_h5('results.h5', label_Next + '/betas')
M = h5.load_h5('results.h5', label_Next + '/M')
return Next, betas, M
def get_diffapprox_gain(rates0, params, Kstim, calc=False, read_old_results=False):
folder = get_folder(params)
label = 'plot_rates_gain' + 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
circuit_params = set_circuit_params(params)
circuit_params['Next'] += np.array([Kstim,Kstim,0])
if calc:
circ = circuit.Circuit('3dcircuit',
circuit_params,
analysis_type='stationary',
from_file='False')
rates = circ.th_rates
# divide by 8 since this is the external firing rate in simulation
g = (rates[0]-rates0[0])/(Kstim*8.)
M = circ.ana.I*circ.ana.W
dI = [M[0][i]*(rates[i]-rates0[i]) for i in range(3)]
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 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 get_dotplot(calcData, a, conn, pop):
print 'Get data for dot plot.'
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)
times = []
gids = []
dt = [1995, 2030]
if calcData:
for pop in range(8):
spikes, this_gids, gid_min, gid_max = rs.get_data_dotplot(
folder, pop, dt[0], dt[1])
times.append(np.asarray(spikes) - dt[0])
gids.append(abs(np.asarray(this_gids) - 77169))
h5.add_to_h5(
'results.h5',
{'Z_validation': {
label: {
'times_dot_plot': times,
'gids': gids
}
}},
'a',
overwrite_dataset=True)
else:
path_base = 'Z_validation/' + label
times = h5.load_h5('results.h5', path_base + '/times_dot_plot')
gids = h5.load_h5('results.h5', path_base + '/gids')
return times, gids
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 get_diffapprox_Next_for_rE_rI_grid(params, rE_array, rI_array, rS,
calc_Next=False):
folder = get_folder(params)
label_Next = 'Next_betas_matrix_' + folder
circuit_params = set_circuit_params(params)
if calc_Next:
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 = np.zeros((len(rE_array), len(rI_array), 3))
betas = np.zeros((len(rE_array), len(rI_array), 3))
initial_Next = get_Next(params)
for i,re in enumerate(rE_array):
for j,ri in enumerate(rI_array):
target_rates = np.array([re, ri, rS])
circ.Next = initial_Next
Next[i][j], betas[i][j] = circ.get_external_input(target_rates)
h5.add_to_h5('results.h5', {label_Next:{'Next': Next, 'betas': betas,
'M': M}}, 'a', overwrite_dataset=True)
else:
Next = h5.load_h5('results.h5', label_Next + '/Next')
betas = h5.load_h5('results.h5', label_Next + '/betas')
M = h5.load_h5('results.h5', label_Next + '/M')
return Next, betas, M
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 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()
res = h5w.load_h5(fn,label)
for key,val in zip(simpledata_str,simpledata_val):
assert(res[key] == val)
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 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 check_for_node(label=''):
res = {'a':1,'test1':{'b':2},'test2':{'test3':{'c':3}}}
h5w.add_to_h5(fn,res,write_mode='w',dict_label=label)
if label != '':
assert(h5w.node_exists(fn,label) == True)
assert(h5w.node_exists(fn,label+'/a') == True)
assert(h5w.node_exists(fn,label+'/nota') == False)
assert(h5w.node_exists(fn,label+'/test1/b') == True)
assert(h5w.node_exists(fn,label+'/test1/notb') == False)
assert(h5w.node_exists(fn,label+'/test2/test3/c') == True)
assert(h5w.node_exists(fn,label+'/test2/test3/notc') == False)
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 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 get_spec_ana(calcAna, calcAnaAll):
print 'Calculate power spectra.'
if calcAna or calcAnaAll:
circ = circuit.Circuit('microcircuit', circuit_params, fmax=500.0,
from_file=not calcAnaAll)
freq_ana, power_ana = circ.create_power_spectra()
h5.add_to_h5('results.h5',{'fig_microcircuit':{
'freq_ana': freq_ana,'power_ana': power_ana}},
'a',overwrite_dataset=True)
else:
freq_ana = h5.load_h5('results.h5','fig_microcircuit/freq_ana')
power_ana = h5.load_h5('results.h5','fig_microcircuit/power_ana')
return freq_ana, power_ana
def get_spectra(calcAna, calcAnaAll, a, conn):
print 'Calculate power spectra and eigenvalues.'
label = str(a) + str(conn[0]) + str(conn[1])
if calcAna or calcAnaAll:
circ = circuit.Circuit('microcircuit',
circuit_params,
analysis_type='stationary',
from_file=not calcAnaAll)
I_new = circ.I.copy()
Next_new = circ.Next.copy()
I_new[conn[0]][conn[1]] = np.round(circ.I[conn[0]][conn[1]] *
(1.0 + a))
# missing rate
r = circ.th_rates[conn[1]] * circ.I[conn[0]][conn[1]] * abs(a)
# source inhibitory
# a pos: more inh. input -> add ext. input
# a neg: less inh. input -> rem. ext. input
if conn[1] % 2 == 1:
Next_add = np.sign(a) * 4 * int(r / circ.v_ext)
# source excitatory
# a pos: more exc. input -> rem. ext. input
# a neg: less exc. input -> add ext. input
else:
Next_add = -np.sign(a) * int(r / circ.v_ext)
Next_new[conn[0]] = circ.Next[conn[0]] + Next_add
circ.alter_default_params({
'analysis_type': 'dynamical',
'I': I_new,
'Next': Next_new
})
freqs, power = circ.create_power_spectra()
freqs, eigs = circ.create_eigenvalue_spectra('MH')
rates = circ.th_rates
h5.add_to_h5('results.h5', {
'Z_validation': {
label: {
'freqs': freqs,
'power': power,
'eigs': eigs,
'rates': rates
}
}
},
'a',
overwrite_dataset=True)
else:
freqs = h5.load_h5('results.h5', 'Z_validation/' + label + '/freqs')
power = h5.load_h5('results.h5', 'Z_validation/' + label + '/power')
eigs = h5.load_h5('results.h5', 'Z_validation/' + label + '/eigs')
rates = h5.load_h5('results.h5', 'Z_validation/' + label + '/rates')
return freqs, power, eigs, rates
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(calcAna, calcAnaAll):
print('Calculate eigenvalues.')
if calcAna or calcAnaAll:
circ = circuit.Circuit('microcircuit', circuit_params,
fmax=400.0, from_file=not calcAnaAll)
freqs, eigs = circ.create_eigenvalue_spectra('MH')
eigs = np.transpose(eigs)
h5.add_to_h5('results.h5', {'eigenvalue_trajectories': {
'freqs': freqs, 'eigs': eigs}},
'a', overwrite_dataset=True)
else:
freqs = h5.load_h5('results.h5', 'eigenvalue_trajectories/freqs')
eigs = h5.load_h5('results.h5', 'eigenvalue_trajectories/eigs')
return freqs, eigs
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_spectra(panel, calcAna, calcAnaAll):
print 'Calculate power spectra.'
eig_index = 4
if calcAna or calcAnaAll:
circ = circuit.Circuit('microcircuit',
circuit_params,
fmax=100.0,
from_file=not calcAnaAll)
freqs, power = circ.create_power_spectra()
h5.add_to_h5(
'results.h5',
{'oscillation_origin': {
panel: {
'freqs': freqs,
'power': power
}
}},
'a',
overwrite_dataset=True)
if panel == 'A':
Mred = np.zeros((8, 8))
Mred[0, 0:4] = 1
Mred[1, 0:2] = 1
Mred[2:4, 2:4] = 1
Mred[3, 0] = 1
elif panel == 'B':
Mred = np.ones((8, 8))
Mred[3, 0] = 0
circ.reduce_connectivity(Mred)
freqs_sub, power_sub = circ.create_power_spectra()
h5.add_to_h5('results.h5', {
'oscillation_origin': {
panel: {
'power_sub': power_sub,
'Mred': Mred
}
}
},
'a',
overwrite_dataset=True)
else:
path_base = 'oscillation_origin/' + panel
freqs = h5.load_h5('results.h5', path_base + '/freqs')
power = h5.load_h5('results.h5', path_base + '/power')
power_sub = h5.load_h5('results.h5', path_base + '/power_sub')
Mred = h5.load_h5('results.h5', path_base + '/Mred')
return freqs, power, power_sub, Mred
def get_dotplot(calcData, folder=folder):
print 'Get data for dot plot.'
times = []
gids = []
dt = [2000,2050]
if calcData:
for pop in range(8):
spikes, this_gids, gid_min, gid_max = rs.get_data_dotplot(
folder, pop, dt[0], dt[1])
times.append(np.asarray(spikes)-dt[0])
gids.append(abs(np.asarray(this_gids)-77169))
h5.add_to_h5('results.h5',{'fig_microcircuit':{
'times': times, 'gids': gids}},'a', overwrite_dataset=True)
else:
times = h5.load_h5('results.h5','fig_microcircuit/times')
gids = h5.load_h5('results.h5','fig_microcircuit/gids')
return times, gids
def get_diffapprox_rates_betas(params, calc=False):
folder = get_folder(params)
label = 'plot_rates_betas' + folder
circuit_params = set_circuit_params(params)
if calc:
circ = circuit.Circuit('3dcircuit',
circuit_params,
analysis_type='stationary',
from_file='False')
rates = circ.th_rates
betas = circ.ana.create_H0_mu()[:,0]
h5.add_to_h5('results.h5',{label:{'rates_calc': rates, 'betas': betas}},
'a', overwrite_dataset=True)
else:
rates = h5.load_h5('results.h5', label + '/rates_calc')
betas = h5.load_h5('results.h5', label + '/betas')
return rates, betas
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 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()
h5.add_to_h5('results.h5',
{'fig_eigenmodes': {
'freqs': freqs,
'power': power
}},
'a',
overwrite_dataset=True)
else:
freqs = h5.load_h5('results.h5', 'fig_eigenmodes/freqs')
power = h5.load_h5('results.h5', 'fig_eigenmodes/power')
return freqs, power
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_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_spectra_sim(panel, calcData):
print 'Get power spectra from simulation.'
folder = 'data_iso_panel' + panel
T = 10000.0
tmin = 300.0
nr_windows = 20
bin_size = 1.0
power_sim = []
power_sim_av = []
if calcData:
for pop in range(4):
freq_sim, p_sim = rs.get_spec(folder,
pop,
T,
tmin,
fmax=100.0,
bin_size=bin_size)
power_sim.append(p_sim)
label = 'power' + str(pop) + '_sim'
h5.add_to_h5('results.h5',
{'oscillation_origin': {
panel: {
label: p_sim
}
}},
'a',
overwrite_dataset=True)
psim, fsim = get_spectra_sim_av(folder, pop, nr_windows, bin_size)
freq_sim_av = fsim
power_sim_av.append(psim)
h5.add_to_h5(
'results.h5',
{'oscillation_origin': {
panel: {
label + '_av': psim
}
}},
'a',
overwrite_dataset=True)
h5.add_to_h5('results.h5', {
'oscillation_origin': {
panel: {
'freq_sim': freq_sim,
'freq_sim_av': fsim
}
}
},
'a',
overwrite_dataset=True)
else:
path_base = 'oscillation_origin/' + panel
freq_sim = h5.load_h5('results.h5', path_base + '/freq_sim')
freq_sim_av = h5.load_h5('results.h5', path_base + '/freq_sim_av')
for pop in range(4):
label = '/power' + str(pop) + '_sim'
power_sim.append(h5.load_h5('results.h5', path_base + label))
power_sim_av.append(
h5.load_h5('results.h5', path_base + label + '_av'))
return freq_sim, power_sim, freq_sim_av, power_sim_av
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_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 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_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_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 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 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_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_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 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 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 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)
def add_to_file(self, dic):
'''Adds data to h5 file, with data and path specified in dict.'''
self.file_base = os.getcwd()+'/'+self.params['datafile']
h5.add_to_h5(self.file_base, {self.param_hash: dic},
'a', overwrite_dataset=True)
