def voltage_correlation_from_blueconfig(sim_1,
sim_2,
t_start=0,
t_end=1500,
t_window=100,
dt_window=10):
"""
Sliding time window correlation for early preliminary analysis
"""
gids = bluepy.Simulation(sim_1).reports.soma.gids
if t_start == 0:
t_start = 0.00000000001
v_1 = bluepy.Simulation(sim_1).reports.soma.get_timeslice(t_start, t_end)
v_2 = bluepy.Simulation(sim_2).reports.soma.get_timeslice(t_start, t_end)
duration = t_end - t_start
v_dt = duration / float(v_1.shape[0])
n_bins = np.floor(
(duration - t_window + dt_window) / dt_window).astype(int)
correlations = np.zeros((gids.size, n_bins))
print correlations.shape
for i in range(n_bins):
print i
index_start = np.floor((i * dt_window) / v_dt).astype(int)
index_end = np.floor((i * dt_window + t_window) / v_dt).astype(int)
for j in range(gids.size):
correlations[j, i] = np.corrcoef(v_1[index_start:index_end, j],
v_2[index_start:index_end, j])[0,
1]
return correlations
def load_spike_times_spontaneous():
bcs = iaf.get_continue_bcs(n=40)
print bcs
sim = bluepy.Simulation(bcs[0])
gids = list(sim.get_circuit_target())
df = load_spike_times(bcs, gids)
return df
def get_spike_counts_experiment_25_original(n_classes=30, grouping_id=0, n=30):
bcs = get_exp_25_blueconfigs_original(n=30,
n_classes=n_classes,
grouping_id=grouping_id)
df = get_spike_times_multiple(bcs)
df = df[df['spike_time'] >= 1000]
df = df[df['spike_time'] < 6000]
sim = bluepy.Simulation(bcs[0])
gids = np.sort(np.array(list(sim.get_circuit_target())))
spikes_df = df.drop(columns=['spike_time'])
counts_all = np.zeros((gids.size, n), dtype=np.float64)
for i in range(n):
x = spikes_df[spikes_df['spike_trial'] == i]
counts_all[:, i] = np.bincount(np.array(x.index).astype(int),
minlength=gids.max() + 1)[-gids.size:]
means = counts_all.mean(axis=1)
vars = np.var(counts_all, ddof=1, axis=1)
ffs = vars / means
ffs[means == 0] = 0
#print means
spike_counts_df = pd.DataFrame({
'mean': means,
'variance': vars,
'ff': ffs
},
index=gids)
return spike_counts_df
def get_spike_counts_jitter_flick_control(n=30, bin_id=0):
file_path = '/gpfs/bbp.cscs.ch/project/proj9/nolte/spike_times_variability/jitter_counts_%d_flick_control_v2.pkl'
file_name = file_path % bin_id
times = np.arange(1000, 8500, 500)
if not os.path.isfile(file_name):
bcs = get_jitter_flick_control_blueconfigs(n=30)
df = get_spike_times_multiple(bcs)
df = df[df['spike_time'] >= times[bin_id]]
df = df[df['spike_time'] < times[bin_id + 1]]
sim = bluepy.Simulation(bcs[0])
gids = np.sort(np.array(list(sim.get_circuit_target())))
spikes_df = df.drop(columns=['spike_time'])
counts_all = np.zeros((gids.size, n), dtype=np.float64)
for i in range(n):
x = spikes_df[spikes_df['spike_trial'] == i]
counts_all[:,
i] = np.bincount(np.array(x.index).astype(int),
minlength=gids.max() + 1)[-gids.size:]
means = counts_all.mean(axis=1)
vars = np.var(counts_all, ddof=1, axis=1)
ffs = vars / means
ffs[means == 0] = 0
#print means
spike_counts_df = pd.DataFrame(
{
'mean': means,
'variance': vars,
'ff': ffs
}, index=gids)
spike_counts_df.to_pickle(file_name)
else:
spike_counts_df = pd.read_pickle(file_name)
return spike_counts_df
def get_spike_counts_experiment_25(n=30, ca='1p25', sim_type='control'):
file_path = '/gpfs/bbp.cscs.ch/project/proj9/nolte/spike_times_variability/shuffled_pandas_exp25_counts_%s_v2.pkl'
file_name = file_path % (sim_type + '_' + ca)
if not os.path.isfile(file_name):
bcs = get_exp_25_blueconfigs_cloud(n=30, ca=ca, sim_type=sim_type)
df = get_spike_times_multiple(bcs)
df = df[df['spike_time'] >= 1000]
df = df[df['spike_time'] < 6000]
sim = bluepy.Simulation(bcs[0])
gids = np.sort(np.array(list(sim.get_circuit_target())))
spikes_df = df.drop(columns=['spike_time'])
counts_all = np.zeros((gids.size, n), dtype=np.float64)
for i in range(n):
x = spikes_df[spikes_df['spike_trial'] == i]
counts_all[:,
i] = np.bincount(np.array(x.index).astype(int),
minlength=gids.max() + 1)[-gids.size:]
means = counts_all.mean(axis=1)
vars = np.var(counts_all, ddof=1, axis=1)
ffs = vars / means
ffs[means == 0] = 0
#print means
spike_counts_df = pd.DataFrame(
{
'mean': means,
'variance': vars,
'ff': ffs
}, index=gids)
spike_counts_df.to_pickle(file_name)
else:
spike_counts_df = pd.read_pickle(file_name)
return spike_counts_df
def plot_jittered_rasters():
path = "/gpfs/bbp.cscs.ch/project/proj9/simulations/nolte/variability/jittering/stimulusstim_a%d/seed%d/BlueConfig"
seeds = np.arange(10000, 10003, dtype=int)
sim = bluepy.Simulation(data_access_shuffling.get_spontaneous_blueconfigs_cloud(n=1)[0])
cells = sim.circuit.v2.cells({Cell.HYPERCOLUMN: 2})
ys = np.array(cells['y'])
gids = np.array(list(sim.get_circuit_target()))
sort_idx = np.argsort(ys)
sort_dict = dict(zip(sort_idx + gids.min(), np.arange(gids.size)))
stims = np.array([5, 0, 2, 4, 1, 3])
jitters = np.array([2, 50, 5, 200, 20, 0])[[5, 0, 2, 4, 1, 3]]
fig, axs = plt.subplots(18, figsize=(10, 30))
for j, stim in enumerate(stims):
for i, seed in enumerate(seeds):
ax = axs[j*3 + i]
bc = path % (stim, seed)
spike_times, spike_gids = data_access_shuffling.get_spike_times_sim(bc, t_start=1000)
print spike_times
spike_gids = np.vectorize(sort_dict.get)(spike_gids)
ax.vlines(spike_times, spike_gids, spike_gids + 100, rasterized=True, lw=0.1)
ax2 = ax.twinx()
ax2.hist(spike_times, bins=np.linspace(1000, 7000, 601), histtype='step',
weights=np.zeros(spike_times.size) + (1000 / 10.0) / gids.size)
ax2.set_ylabel('FR (Hz)')
ax.set_ylabel('Neurons')
ax.set_xlabel('t (ms)')
ax.set_ylim([0, gids.max() - gids.min()])
ax.set_xlim([1000, 7000])
#axs[i, j].set_title('S%db - %s' % (nclasses, labels[i]))
#break
plt.tight_layout()
plt.savefig('figures/raster_jitter.pdf', dpi=300)
def get_spike_times_sim(blueconfig, t_start=500):
"""
:param blueconfig:
:return:
"""
sim = bluepy.Simulation(blueconfig)
spikes = sim.v2.spikes.get(t_start=t_start)
spike_times = np.array(spikes.index)
spike_gids = np.array(spikes.values)
return spike_times, spike_gids
def get_differences(bcs_1, bcs_2, gids=None, bins=np.linspace(0, 100, 21)):
differences = np.zeros((len(bcs_1), bins.size -1))
for sign, bcs in zip([-1, 1], [bcs_1, bcs_2]):
for i, bc in enumerate(bcs):
print bc
sim = bluepy.Simulation(bc)
spikes = sim.v2.reports['spikes'].data(gids=gids)
spikes = np.array(spikes)
counts, _ = np.histogram(spikes, bins=bins)
differences[i, :] += sign * counts
return differences
def plot_count_variance():
"""
:return:
"""
circuit = bluepy.Simulation(iaf.get_continue_bcs(n=2)[0]).circuit
df_neurons = circuit.v2.cells({Cell.HYPERCOLUMN: 2})
fig, axs = plt.subplots(6, 4, figsize=(10, 12))
mean_fr = []
for i, n in enumerate([40, 20, 10, 4, 2, 1]):
df_counts = get_spike_counts_spontaneous_binned_concatenated(np.linspace(0, 2000, n+1))
df_counts_exc = df_counts[df_neurons['synapse_class'] == 'EXC']
df_counts_inh = df_counts[df_neurons['synapse_class'] == 'INH']
mean_fr.append(df_counts['mean'].loc[84815])
ax = axs[0 + i, 0]
ax.scatter(df_counts_exc['mean'], df_counts_exc['variance'], marker='.', color='red', s=3, rasterized=True)
xs = np.linspace(0, df_counts_exc['mean'].max(), 1000)
ax.plot(xs, xs, '--', color='black')
ax.plot(xs, (xs % 1) * (1 - (xs % 1)), '-', color='black')
ax.set_ylim([0, xs[-1]])
ax = axs[0 + i, 2]
ax.hist(df_counts_exc['ff'], bins=np.linspace(0, 2, 20), histtype='step', color='red')
#ax.set_xlim([0, 10])
ax = axs[0 + i, 1]
ax.scatter(df_counts_inh['mean'], df_counts_inh['variance'], marker='.', color='blue', s=3, rasterized=True)
xs = np.linspace(0, df_counts_inh['mean'].max(), 1000)
ax.plot(xs, xs, '--', color='black')
ax.plot(xs, (xs % 1) * (1 - (xs % 1)), '-', color='black')
ax.set_ylim([0, xs[-1]])
ax = axs[0 + i, 3]
ax.hist(df_counts_inh['ff'], bins=np.linspace(0, 2, 20), histtype='step', color='blue')
#ax.set_xlim([0, 80])
print mean_fr
for ax in axs[:, :2].flatten():
ax.set_xlabel('Spike count')
ax.set_ylabel('Variance')
for ax in axs[:, 2:].flatten():
ax.set_xlabel('Fano factor')
ax.set_ylabel('Neurons')
for k, ax in enumerate(axs[:, 0]):
ax.set_title(['50 ms', '100 ms', '200 ms', '500 ms', '1000 ms', '2000 ms'][k])
plt.tight_layout()
plt.savefig('figures_poisson/spont_variance_poisson.pdf', dpi=300)
def plot_count_variance_exp_25_summary():
bins = np.linspace(1000, 7000, 13)
print bins
circuit = bluepy.Simulation(iaf.get_continue_bcs(n=2)[0]).circuit
# df_neurons = circuit.v2.cells({Cell.HYPERCOLUMN: 2})
df_neurons = get_selected_L456_gids()
fig, axs = plt.subplots(5, len(bins) - 1, figsize=(20, 6))
for k, variable in enumerate([False, True]):
df_counts_list = [get_spike_counts_evoked(t_start=bins[j], t_end=bins[j + 1],
variable=variable) for j in range(len(bins) - 1)]
df_counts_exc_list = []
for i, df_counts in enumerate(df_counts_list):
df_counts_exc = df_counts.loc[df_neurons.index.unique()][df_neurons['synapse_class'] == 'EXC']
df_counts_exc_list.append(df_counts_exc)
df_counts_inh = df_counts.loc[df_neurons.index.unique()][df_neurons['synapse_class'] == 'INH']
ax = axs[0 + k * 2, i]
ax.scatter(df_counts_exc['mean'], df_counts_exc['variance'], marker='.', color='red', s=3, rasterized=True)
xs = np.linspace(0, df_counts_exc['mean'].max(), 1000)
ax.plot(xs, xs, '--', color='black')
ax.plot(xs, (xs % 1) * (1 - (xs % 1)), '-', color='black')
ax.set_xlim([0, xs.max()])
ax.set_ylim([0, xs.max()])
ax = axs[1 + k * 2, i]
ax.scatter(df_counts_inh['mean'], df_counts_inh['variance'], marker='.', color='blue', s=3, rasterized=True)
xs = np.linspace(0, df_counts_inh['mean'].max(), 1000)
ax.plot(xs, xs, '--', color='black')
ax.plot(xs, (xs % 1) * (1 - (xs % 1)), '-', color='black')
ax.set_xlim([0, xs.max()])
ax.set_ylim([0, xs.max()])
df_counts_list_vpm = [get_spike_counts_vpm(t_start=bins[j], t_end=bins[j + 1]) for j in range(2, len(bins) - 1)]
for i, df_counts in enumerate(df_counts_list_vpm):
ax = axs[-1, i+2]
ax.scatter(df_counts['mean'], df_counts['variance'], marker='.', color='green', s=3, rasterized=True)
xs = np.linspace(0, df_counts['mean'].max(), 1000)
ax.plot(xs, xs, '--', color='black')
ax.plot(xs, (xs % 1) * (1 - (xs % 1)), '-', color='black')
ax.set_xlim([0, xs.max()])
ax.set_ylim([0, xs.max()])
plt.savefig('figures_poisson/exp_25_variance_poisson_summary.pdf', dpi=300)
def compute_spike_counts(df, n=30, vpm=False):
bcs = iaf.get_continue_bcs(n=2)
sim = bluepy.Simulation(bcs[0])
if not vpm:
gids = np.sort(np.array(list(sim.get_circuit_target())))
else:
gids = np.arange(221042, 221042 + 310)
spikes_df = df.drop(columns=['time'])
counts_all = np.zeros((gids.size, n), dtype=np.float64)
for i in range(n):
x = spikes_df[spikes_df['trial'] == i]
counts_all[:, i] = np.bincount(np.array(x.index).astype(int), minlength=gids.max()+1)[-gids.size:]
means = counts_all.mean(axis=1)
vars = np.var(counts_all, ddof=1, axis=1)
ffs = vars/means
ffs[means == 0] = 0
#print means
df_counts = pd.DataFrame({'mean':means, 'variance':vars, 'ff':ffs}, index=gids)
return df_counts
def plot_spike_raster_example_evoked():
"""
plot for paper
:return:
"""
# params = [['exp_25', 'exp_25']]
# shifts = [50, 100] # 50
# n_seeds = [187, 189]
# middles = [False, True]
params = [['reyes_puerta', 'reyes_puerta']]
shifts = [0, 20] # 50
n_seeds = [188, 175]
middles = [False, False]
t_middle = 2000
t_window = 350
t_window_start = 150
fig, axs = plt.subplots(4, 2, figsize=(10, 6))
for k in range(2):
n_seed = n_seeds[k]
base_bc, continue_bc, change_bc = get_bcs_x(stimulus=params[0][k],
shift=shifts[k],
seed=n_seed,
middle=middles[k])
print base_bc
print continue_bc
print change_bc
circuit = bluepy.Simulation(base_bc).circuit
cells = circuit.v2.cells({Cell.HYPERCOLUMN: 2})
ys = np.array(cells['y'])
gids = np.array(list(bluepy.Simulation(base_bc).get_circuit_target()))
sort_idx = np.argsort(ys)
sort_dict = dict(zip(sort_idx + gids.min(), np.arange(gids.size)))
# sort_dict = dict(zip(np.arange(len(sort_idx), dtype=int), ys[::-1]))
ax = axs[0, k]
spikes = bluepy.Simulation(base_bc).v2.reports['spikes']
df = spikes.data(t_start=t_middle - t_window_start)
gids_spiking = np.array(df.axes[0])
print "-----"
print gids_spiking.max()
print gids_spiking.min()
times = np.array(df) - t_middle
print gids_spiking
gids_spiking = np.vectorize(sort_dict.get)(gids_spiking)
print gids_spiking
#times = np.vectorize(sort_dict.get)(times)
ax.vlines(times,
gids_spiking,
gids_spiking + 70,
rasterized=True,
lw=0.15)
ax2 = ax.twinx()
ax2.hist(times,
bins=np.linspace(-t_window_start, 0, 31),
histtype='step',
weights=np.zeros(times.size) + (1000.0 / 5.0) / gids.size)
ax2.set_ylabel('FR (Hz)')
spikes = bluepy.Simulation(continue_bc).v2.reports['spikes']
df = spikes.data(t_end=t_window + t_middle * middles[k])
gids_spiking = np.array(df.axes[0])
print gids_spiking
gids_spiking = np.vectorize(sort_dict.get)(gids_spiking)
print gids_spiking
times = np.array(df) - t_middle * middles[k]
ax.vlines(times,
gids_spiking,
gids_spiking + 70,
rasterized=True,
lw=0.15)
ax2.hist(times,
bins=np.linspace(0, t_window, 71),
histtype='step',
weights=np.zeros(times.size) + (1000.0 / 5.0) / gids.size)
ax = axs[1, k]
spikes = bluepy.Simulation(base_bc).v2.reports['spikes']
df = spikes.data(t_start=t_middle - t_window_start)
gids_spiking = np.array(df.axes[0])
gids_spiking = np.vectorize(sort_dict.get)(gids_spiking)
times = np.array(df) - t_middle
ax.vlines(times,
gids_spiking,
gids_spiking + 70,
rasterized=True,
lw=0.15)
ax2 = ax.twinx()
ax2.hist(times,
bins=np.linspace(-t_window_start, 0, 31),
histtype='step',
weights=np.zeros(times.size) + (1000.0 / 5.0) / gids.size)
ax2.set_ylabel('FR (Hz)')
spikes = bluepy.Simulation(change_bc).v2.reports['spikes']
df = spikes.data(t_end=t_window + t_middle * middles[k])
gids_spiking = np.array(df.axes[0])
gids_spiking = np.vectorize(sort_dict.get)(gids_spiking)
times = np.array(df) - t_middle * middles[k]
ax.vlines(times,
gids_spiking,
gids_spiking + 70,
rasterized=True,
lw=0.15)
ax2.hist(times,
bins=np.linspace(0, t_window, 71),
histtype='step',
weights=np.zeros(times.size) + (1000.0 / 5.0) / gids.size)
ax = axs[2, k]
bc = base_bc
soma = bluepy.Simulation(bc).v2.reports['soma']
time_range = soma.time_range[soma.time_range >= t_middle -
t_window] - t_middle
data = soma.data(t_start=t_middle - t_window)
ax.plot(time_range,
data.mean(axis=0),
linewidth=1,
alpha=0.5,
color='#1f77b4')
bc = continue_bc
soma = bluepy.Simulation(bc).v2.reports['soma']
time_range_cont = soma.time_range[soma.time_range < t_middle +
t_window] - t_middle
data_cont = soma.data(t_end=t_middle + t_window)
ax.plot(time_range_cont,
data_cont.mean(axis=0),
linewidth=1,
alpha=0.5,
color='#ff7f0e')
bc = change_bc
soma = bluepy.Simulation(bc).v2.reports['soma']
time_range_cont = soma.time_range[soma.time_range < t_middle +
t_window] - t_middle
data_cont = soma.data(t_end=t_middle + t_window)
ax.plot(time_range_cont,
data_cont.mean(axis=0),
linewidth=1,
alpha=0.5,
color='#ff7f0e')
for ax in axs[:2, :].flatten():
ax.set_xlabel('t (ms)')
ax.set_ylim([0, 31346])
ax.set_yticks([0, 10000, 20000, 30000])
ax.set_ylabel('Neuron')
ax.set_xlim([-t_window_start, t_window])
for ax in axs[2, :].flatten():
ax.set_xlabel('t (ms)')
#ax.set_ylim([-63, -60])
#ax.set_yticks([-63, -62, -61, -60])
ax.set_ylabel('V (mV)')
ax.set_xlim([-t_window_start, t_window])
plt.tight_layout()
plt.savefig('figures/raster_evoked.pdf', dpi=300)
cas_g = ['1p26', '1p28', '1p3', '1p32', '1p34', '1p36', '1p38', '1p4', '2p0']
cas_mvr = ['1p1', '1p15', '1p2', '1p21', '1p22', '1p23', '1p24', '1p25']
bcs_mvr = [
'/gpfs/bbp.cscs.ch/project/proj9/simulations/nolte/variability/ca_scan_mvr/Ca%s/BlueConfig'
% s for s in cas_mvr
]
bcs_g = [
'/gpfs/bbp.cscs.ch/project/proj9/simulations/nolte/variability/ca_scan_g/Ca%s/BlueConfig'
% s for s in cas_g
]
# bcs = ['/gpfs/bbp.cscs.ch/project/proj9/simulations/nolte/ei-balance/' \
# 'scan_layer5/Ca%s/BlueConfig' % s for s in cas]
sim = bluepy.Simulation(bcs_mvr[0])
gids = np.array(list(sim.get_circuit_target()))
gids_exc = np.random.permutation(
np.intersect1d(np.array(list(sim.circuit.get_target('Excitatory'))), gids))
gids_inh = np.random.permutation(
np.intersect1d(np.array(list(sim.circuit.get_target('Inhibitory'))), gids))
# bcs = bcs_0
names = ['MVR', 'det_syns']
for k, (bcs, cas) in enumerate(zip([bcs_mvr, bcs_g], [cas_mvr, cas_g])):
fig, axs = plt.subplots(len(bcs), 2, figsize=(14, 14))
for i, bc in enumerate(bcs):
print bc
sim = bluepy.Simulation(bc)
variances = [
'0p001', '0p01', '0p05', '0p1', '0p5', '1p0', '1p5', '2p0', '10p0'
]
bcs = [
'/gpfs/bbp.cscs.ch/project/proj9/simulations/nolte/variability/spontaneous/base_seeds_abcd_stim/seed170/variance%s/BlueConfig'
% s for s in variances[1:]
]
bcs = [
'/gpfs/bbp.cscs.ch/project/proj9/simulations/nolte/variability/spontaneous/base_seeds_abcd/seed170/BlueConfig'
] + bcs
# bcs = ['/gpfs/bbp.cscs.ch/project/proj9/simulations/nolte/ei-balance/' \
# 'scan_layer5/Ca%s/BlueConfig' % s for s in cas]
sim = bluepy.Simulation(bcs[0])
gids = np.array(list(sim.get_circuit_target()))
gids_exc = np.random.permutation(
np.intersect1d(np.array(list(sim.circuit.get_target('Excitatory'))), gids))
gids_inh = np.random.permutation(
np.intersect1d(np.array(list(sim.circuit.get_target('Inhibitory'))), gids))
# bcs = bcs_0
names = ['MVR', 'det_syns']
fig, axs = plt.subplots(len(bcs), 2, figsize=(14, 14))
for i, bc in enumerate(bcs):
print bc
sim = bluepy.Simulation(bc)
ax = axs[i, 0]
def get_soma_time_series(blueconfig, t_start=None, t_end=None, gids=None):
soma = bluepy.Simulation(blueconfig).v2.reports['soma']
data = soma.data(t_start=t_start, t_end=t_end,
gids=None) #, gids=np.arange(72788, 72800)) #
return data, data.axes[1] / 1000.0
def get_selected_L456_gids():
circuit = bluepy.Simulation(get_exp_25_blueconfigs_cloud(n=1)[0]).circuit
cells = circuit.v2.cells({Cell.MINICOLUMN: range(620, 650)})
print len(cells.index)
return cells[cells['layer'] > 3]
def get_mc_2_gids():
circuit = bluepy.Simulation(get_exp_25_blueconfigs_cloud(n=1)[0]).circuit
cells = circuit.v2.cells({Cell.HYPERCOLUMN: 2})
print len(cells.index)
return cells
import numpy as np
import bluepy
import pandas as pd
n_gids_perturbed = np.zeros(19)
n_additional_spikes = np.zeros(19)
t_additional_spikes = np.zeros(19)
maxs_hist = np.zeros((19, 6))
for j, s in enumerate(np.delete(np.arange(150, 170), 17)):
config_1 = '/gpfs/bbp.cscs.ch/project/proj9/simulations/nolte/variability/spontaneous_v2/continue_change_decouple_x/seed%d/BlueConfig' % s
config_2 = '/gpfs/bbp.cscs.ch/project/proj9/simulations/nolte/variability/spontaneous_v2/continue_change_decouple_g/seed%d/BlueConfig' % s
s1 = bluepy.Simulation(config_1)
s2 = bluepy.Simulation(config_2)
report1 = s1.v2.spikes.get()
report2 = s2.v2.spikes.get()
n_spikes = report1.values.size
spikes = pd.DataFrame({'time': report1.index, 'gid': report1.values}, index=np.zeros(report1.values.size, dtype=int))
spikes_pert = pd.DataFrame({'time': report2.index, 'gid': report2.values}, index=np.ones(report2.values.size, dtype=int))
gids = np.unique(np.hstack([spikes.index, spikes_pert.index]))
comb = pd.concat([spikes, spikes_pert])
duplicates = comb.drop_duplicates(keep=False)
perturbed_gids = np.unique(np.unique(duplicates.gid))
n_gids_perturbed[j] = perturbed_gids.size
def analyse_inititial_stim_fluctuations(plot_values=[10, 15, 18, 1, 3]):
variances_percent = np.array([
0.001, 1.0, 5.0, 10.0, 50.0, 100.0, 500.0, 1000.0, 1.5, 2.0, 0.0,
0.00001, 0.0001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.5
])
# variances = ['0p01 y', '0p05 y', '0p1 y', '0p5 y', '1p0 y', '1p5 n','2p0 n','10p0 y']
labels = variances_percent[plot_values]
labels[0] = variances_percent[0]
bcs_stim = iaf.get_change_bcs_decouple(params='dz') # 'ab'
bcs = iaf.get_change_bcs_decouple(params='x')
differences = {}
spike_differences = np.zeros(len(plot_values))
for j, i in enumerate(plot_values): # [0] + range(10, 19):
soma_stim, bins = iaf.get_soma_time_series(
bcs_stim[i], t_start=2500, t_end=3500) #, gids=[72890])
soma, bins = iaf.get_soma_time_series(bcs[i], t_start=2500,
t_end=3500) #, gids=[72890])
spikes_1 = np.array(
bluepy.Simulation(bcs_stim[i]).v2.reports['spikes'].data()).size
spikes_2 = np.array(
bluepy.Simulation(bcs[i]).v2.reports['spikes'].data()).size
print spikes_1
spike_differences[j] = (spikes_1 - spikes_2) / 31346.0 / 2.0
print soma.shape
differences[i] = (np.array(soma_stim) - np.array(soma)).T
fig, axs = plt.subplots(5, figsize=(10, 15))
ax = axs[0]
ax.plot(variances_percent[plot_values],
spike_differences,
marker='x',
lw=1.0)
ax.set_ylabel('dFR (Hz)')
ax.set_xlabel('variance in percent')
for j, i in enumerate(plot_values):
ax = axs[1]
ax.plot(bins[500:1000],
differences[i][500:1000, 15421],
lw=0.8,
label=variances_percent[i])
ax = axs[2]
ax.hist(differences[i].flatten(),
bins=np.linspace(-2, 2, 201),
label=" %.e" % variances_percent[i],
histtype='stepfilled',
alpha=0.6)
ax = axs[3]
ax.scatter(labels[j], [differences[i].flatten().std()])
ax.set_xlabel('percent variance')
ax.set_ylabel('soma fluctuations (mV)')
ax = axs[4]
ax.scatter([differences[i].flatten().std()], spike_differences[j])
ax.set_xlabel('soma fluctuations (mV)')
ax.set_ylabel('dFR (Hz)')
ax = axs[3]
print labels[1:4]
print fluctuation_variance(n=3)
ax.scatter(labels[1:4], fluctuation_variance(n=3))
# axs[3].set_xticks(np.arange(len(plot_values)))
# axs[3].set_xticklabels(variances_percent[plot_values])
ax.legend()
axs[1].legend()
plt.tight_layout()
plt.savefig('figures/stim_variance.pdf')