def load_nspikes(self):
fn = self.params['exc_spiketimes_fn_merged'] + '.ras'
try:
self.nspikes_exc = utils.get_nspikes(fn, n_cells=self.params['n_exc'])
except:
self.nspikes_exc = np.zeros(self.params['n_exc'])
print 'No spikes found in ', fn
self.no_spikes = True
return
try:
self.nspikes_inh = utils.get_nspikes(fn, n_cells=self.params['n_inh'])
except:
self.nspikes_inh = np.zeros(self.params['n_inh'])
def plot_response(self, title, connectivity=None):
"""
Plots the cell's membrane potential and output spikes in response to the
stimulus alone (that's why you need to simulate without connectivity before),
and the response with connectivity.
"""
volt_fn = self.params['exc_volt_fn_base'] + '.v'
print 'Loading membrane potentials from:', volt_fn
volt_data = np.loadtxt(volt_fn)
spike_fn = self.params['exc_spiketimes_fn_merged'] + '%d.ras' % 0
nspikes, spiketimes = utils.get_nspikes(spike_fn, self.params['n_exc'], get_spiketrains=True)
if connectivity == False:
self.spiketrains_without_connectivity = spiketimes
else:
self.spiketrains_with_connectivity = spiketimes
ax = self.fig.add_subplot(self.n_fig_y, self.n_fig_x, self.fig_cnt)
self.fig_cnt += 1
ax2 = self.fig.add_subplot(self.n_fig_y, self.n_fig_x, self.fig_cnt)
self.fig_cnt += 1
y_min, y_max = -70, -45
for i_, gid in enumerate(self.gids_to_plot):
time_axis, volt = utils.extract_trace(volt_data, gid)
ax.plot(time_axis, volt, lw=1, label='nspikes[%d]=%d' % (gid, nspikes[gid]), color=self.color_dict[gid])
# self.plot_spikes(ax, spiketimes[gid], gid, y_min, y_max, lw=2)
self.plot_spike_histogram(ax2, gid, i_, spiketimes[gid])
ax.legend()
ax.set_ylim((y_min, y_max))
ax.set_ylabel('Membrane voltage [mV]', fontsize=14)
ax.set_title(title, fontsize=14)
self.plot_blank(ax, txt='Blank')
def plot_output_spikes_sorted_in_space(ax, cell_type, shift=0., m='o', c='g', sort_idx=0, ms=2):
n_cells = params['n_%s' % cell_type]
fn = params['%s_spiketimes_fn_merged' % cell_type] + '.ras'
nspikes, spiketimes = utils.get_nspikes(fn, n_cells, get_spiketrains=True)
sorted_idx = tp[:, sort_idx].argsort()
if sort_idx == 0:
ylim = (0, 1)
else:
crop = .8
ylim = (crop * tp[:, sort_idx].min(), crop * tp[:, sort_idx].max())
ylen = (abs(ylim[0] - ylim[1]))
print '\n', 'sort_idx', sort_idx, ylim,
for i in xrange(n_cells):
cell = sorted_idx[i]
if sort_idx == 0:
y_pos = (tp[cell, sort_idx] % 1.) / ylen * (abs(ylim[0] - ylim[1]))
else:
y_pos = (tp[cell, sort_idx]) / ylen * (abs(ylim[0] - ylim[1]))
ax.plot(spiketimes[cell], y_pos * np.ones(nspikes[cell]), 'o', color='k', markersize=ms)
def plot_rasterplot(self, cell_type, fig_cnt=1):
if cell_type == 'inh':
fn = self.params['inh_spiketimes_fn_merged'] + '.ras'
n_cells = self.params['n_inh']
elif cell_type == 'exc':
fn = self.params['exc_spiketimes_fn_merged'] + '.ras'
n_cells = self.params['n_exc']
try:
nspikes, spiketimes = utils.get_nspikes(fn, n_cells, get_spiketrains=True)
except:
print 'Problem loading spiketimes from', fn
spiketimes = []
ax = self.fig.add_subplot(self.n_fig_y, self.n_fig_x, fig_cnt)
print 'debug', n_cells
for cell in xrange(n_cells):
ax.plot(spiketimes[cell], cell * np.ones(nspikes[cell]), 'o', color='k', markersize=1)
ax.set_xlim(0, self.params['t_sim'])
ax.set_title('Rasterplot of %s neurons' % cell_type)
ax.set_xlabel('Time [ms]')
ax.set_ylabel('Neuron GID')
def plot_spikes(ax, fn, n_cells):
nspikes, spiketimes = utils.get_nspikes(fn, n_cells, get_spiketrains=True)
for cell in xrange(int(len(spiketimes))):
ax.plot(spiketimes[cell], cell * np.ones(nspikes[cell]), 'o', color='k', markersize=2)
import utils
import pylab
import matplotlib
import sys
from matplotlib import cm
# load simulation parameters
PS = simulation_parameters.parameter_storage()
params = PS.load_params() # params stores cell numbers, etc as a dictionary
n_cells = params['n_gids_to_record']
d = np.loadtxt(params['exc_spiketimes_fn_merged'] + '.ras')
if d.size > 0:
nspikes = utils.get_nspikes(params['exc_spiketimes_fn_merged'] + '.ras', n_cells=params['n_exc'])
spiking_cells = np.nonzero(nspikes)[0]
fired_spikes = nspikes[spiking_cells]
print 'Number of spikes (sum, max, mean, std):\t%d\t%d\t%.2f\t%.2f' % (nspikes.sum(), nspikes.max(), nspikes.mean(), nspikes.std())
print '\nspiking cells', len(spiking_cells), spiking_cells, '\n fraction of spiking cells', float(len(spiking_cells)) / params['n_exc']
print 'fired_spikes mean %.2f +- %.2f' % (fired_spikes.mean(), fired_spikes.std()), fired_spikes
else:
print 'NO SPIKES'
exit(1)
def calculate_input_cond():
input_cond = np.zeros(params['n_exc'])
for cell in xrange(params['n_exc']):
else:
print "\nPlotting the default parameters given in simulation_parameters.py\n"
import simulation_parameters
network_params = (
simulation_parameters.parameter_storage()
) # network_params class containing the simulation parameters
params = network_params.load_params() # params stores cell numbers, etc as a dictionary
tp = np.loadtxt(params["tuning_prop_means_fn"])
n_cells = params["n_gids_to_record"]
idx, dist = utils.sort_cells_by_distance_to_stimulus(n_cells, verbose=False)
d = np.loadtxt(params["exc_spiketimes_fn_merged"] + ".ras")
if d.size > 0:
nspikes = utils.get_nspikes(params["exc_spiketimes_fn_merged"] + ".ras", n_cells=params["n_exc"])
spiking_cells = np.nonzero(nspikes)[0]
fired_spikes = nspikes[spiking_cells]
print "tnspikes\tGID\tmin_dist_to_stim\ttp"
for i in xrange(n_cells):
gid = idx[i]
print nspikes[gid], "\t", gid, "\t", dist[i], tp[gid, :]
print "Number of spikes (sum, max, mean, std):\t%d\t%d\t%.2f\t%.2f" % (
nspikes.sum(),
nspikes.max(),
nspikes.mean(),
nspikes.std(),
)
print "\nspiking cells", len(spiking_cells), spiking_cells, "\n fraction of spiking cells", float(
param_fn += '/Parameters/simulation_parameters.json'
print 'Loading parameters from', param_fn
f = file(param_fn, 'r')
params = json.load(f)
else:
import simulation_parameters
ps = simulation_parameters.parameter_storage()
params = ps.params
tp = np.loadtxt(params['tuning_prop_means_fn'])
AQP = ActivityQuiverPlot(params)
sim_cnt = 0
# you can also plot the input but do this before:
# os.system('python merge_input_spikefiles.py')
# spikes_fn = params['input_folder'] + 'merged_input.dat'
# if not os.path.exists(spikes_fn):
# os.system('python merge_input_spikefiles.py %s' % (params['folder_name']))
spikes_fn = 'InputSpikeTrains_bX1.50e-01_bV1.50e-01_fstim5.0e+03_tsim3000_tblank200_tbeforeblank600_15520nrns/merged_input_800-1200.dat'
# spikes_fn = params['exc_spiketimes_fn_merged'] + '.ras'
print 'Loading ', spikes_fn
# the spikes_fn should store the raw spike trains with spike times in column 0, and gids in column 1
nspikes = utils.get_nspikes(spikes_fn, n_cells = params['n_exc'])
print 'nspikes', nspikes.shape
AQP.set_network_activity(nspikes)
AQP.plot_activity_as_quiver(tuning_prop=tp)
def get_nspikes(self):
spiketimes_fn_merged = self.params['exc_spiketimes_fn_merged'] + str(self.sim_cnt) + '.ras'
print "Loading nspikes", spiketimes_fn_merged
self.nspikes = utils.get_nspikes(spiketimes_fn_merged, self.params['n_exc'])
params = network_params.load_params() # params stores cell numbers, etc as a dictionary
output_fn_base = params['spatial_readout_fn_base'] + 'sim%d_' % sim_cnt
output_fn_movie = params['spatial_readout_movie']
bg_color = 'k'
# parameters
n_frames = 50 # number of output figures
n_bins_x, n_bins_y = 20, 20
output_arrays = [np.zeros((n_bins_x, n_bins_y)) for i in xrange(n_frames)]
time_grid = np.linspace(0, params['t_sim'], n_frames+1, endpoint=True)
# load tuning properties and activity
tuning_prop = np.loadtxt(params['tuning_prop_means_fn'])
n_cells = tuning_prop[:,0].size # = params['n_exc']
fn = params['exc_spiketimes_fn_merged'] + '%d.ras' % (sim_cnt)
nspikes, spiketrains = utils.get_nspikes(fn, n_cells, get_spiketrains=True)
nspikes_normalized = nspikes / nspikes.sum()
print "nspikes", nspikes
print "N_RF_X: %d\tN_RF_Y:%d\tn_exc: %d\tn_inh: %d\tn_cells:%d" % (params['N_RF_X'], params['N_RF_Y'], params['n_exc'], params['n_inh'], params['n_cells'])
#particles = np.vstack((tuning_prop.transpose(), nspikes_normalized))
# parametrize the spatial layout
H, x_edges, y_edges = np.histogram2d(tuning_prop[:,0], tuning_prop[:, 1], bins=(n_bins_x, n_bins_y))
print "x_edges", x_edges, x_edges.size
print "y_edges", y_edges, y_edges.size
z_max = 0
for gid in xrange(n_cells):
binned_spikes, time_bins = np.histogram(spiketrains[gid], time_grid)
import utils
import sys
import simulation_parameters
PS = simulation_parameters.parameter_storage()
params = PS.load_params() # params stores cell numbers, etc as a dictionary
try:
cell_type = sys.argv[1]
except:
cell_type = 'exc'
spike_fn = params['%s_spiketimes_fn_merged' % cell_type] + '.ras'
print 'Loading ', spike_fn
#np.loadtxt(spike_fn)
nspikes = utils.get_nspikes(spike_fn, params['n_%s' % cell_type])
n_cells = nspikes.nonzero()[0].size
idx = np.argsort(nspikes)
print 'GID\tnspikes'
print '----------------'
#for i in xrange(1, int(round(.2 *(n_cells + 1)))):
for i in xrange(1, n_cells + 1):
print '%d\t%d' % (idx[-i], nspikes[idx[-i]])
fig = pylab.figure(figsize=(16, 10))
ax = fig.add_subplot(111)
x_axis = range(params['n_%s' % cell_type])
ax.bar(x_axis, nspikes)
ax.set_xlabel('Cell idx %s' % cell_type)
rate_post = np.load(params['input_rate_fn_base'] + str(gid_post) + '.npy')
input_spikes_post = np.load(params['input_st_fn_base'] + '%d.npy' % gid_post)
# compute input without blank
rate_post_noblank = np.zeros(params['t_sim'] / params['dt_rate'])
time = np.arange(0, params['t_sim'], params['dt_rate'])
tp_ = np.zeros((1, 4))
tp_[0, :] = tp_exc[gid_post, :]
for i_, t in enumerate(time):
rate_post_noblank[i_] = utils.get_input(tp_, params, t / params['t_stimulus'])
rate_post_noblank *= params['f_max_stim']
np.save('debug_rate_post_noblank.npy', rate_post_noblank)
# load output spikes from the network simulation (only response to stimulus)
spikes_fn = params['exc_spiketimes_fn_merged'] + '.ras'
nspikes, spiketrains = utils.get_nspikes(spikes_fn, params['n_exc'], get_spiketrains=True)
# only response to stimulus
output_st_pre = spiketrains[gid_pre]
output_st_post = spiketrains[gid_post]
t_max_input_pre = utils.get_time_of_max_stim(tp_exc[gid_pre, :], mp) * params['t_stimulus']
t_max_input_post = utils.get_time_of_max_stim(tp_exc[gid_post, :], mp) * params['t_stimulus']
t_diff_max = params['t_stimulus'] * (mp[2] * (tp_exc[gid_post, 0] - tp_exc[gid_pre, 0]) + mp[3] * (tp_exc[gid_post, 1] - tp_exc[gid_pre, 1])) / (mp[2]**2 + mp[3]**2)
print 't_max_input_pre (x=%.2f y=%.2f) = %.2f' % (tp_exc[gid_pre, 0], tp_exc[gid_pre, 1], t_max_input_pre)
print 't_max_input_post (x=%.2f y=%.2f) = %.2f' % (tp_exc[gid_post, 0], tp_exc[gid_post, 1], t_max_input_post)
print 'diff = ', t_max_input_post - t_max_input_pre, 't_diff_max = ', t_diff_max
t_max_response_pre, t_max_response_pre_std = utils.get_time_of_max_response(output_st_pre, range=(0, params['t_sim']), n_binsizes=20)
t_max_response_post, t_max_response_post_std = utils.get_time_of_max_response(output_st_post, range=(0, params['t_sim']), n_binsizes=20)