fileprefix=params.networkSimParams['label'])
nest_output_processing.merge_gdf(networkParams,
raw_label=networkParams.voltmeter_label,
file_type='dat',
fileprefix='voltages')
nest_output_processing.merge_gdf(networkParams,
raw_label=networkParams.weighted_input_spikes_label,
file_type='dat',
fileprefix='population_input_spikes')
##spatial input currents
#nest_output_processing.create_spatial_input_spikes_hdf5(networkParams,
# fileprefix='depth_res_input_spikes-')
#Create an object representation of the simulation output that uses sqlite3
networkSim = CachedNetwork(**params.networkSimParams)
toc = time() - tic
print 'NEST simulation and gdf file processing done in %.3f seconds' % toc
####### Set up populations #####################################################
#iterate over each cell type, and create populationulation object
for i, y in enumerate(params.y):
#create population:
pop = Population(
#parent class
cellParams = params.yCellParams[y],
rand_rot_axis = params.rand_rot_axis[y],
if properrun:
#execute network simulation
BN.simulate()
#wait for the network simulation to finish, resync MPI threads
COMM.Barrier()
#Create an object representation containing the spiking activity of the network
#simulation output that uses sqlite3. Again, kwargs are derived from the brunel
#network instance.
networkSim = CachedNetwork(
simtime = BN.simtime,
dt = BN.dt,
spike_output_path = BN.spike_output_path,
label = BN.label,
ext = 'gdf',
GIDs = {'EX' : [1, BN.NE], 'IN' : [BN.NE+1, BN.NI]},
cmap='rainbow_r',
)
if RANK == 0:
toc = time() - tic
print('NEST simulation and gdf file processing done in %.3f seconds' % toc)
####### Set up populations #####################################################
if properrun:
#iterate over each cell type, and create populationulation object
def plot_multi_scale_output_a(fig):
#get the mean somatic currents and voltages,
#write pickles if they do not exist:
if not os.path.isfile(
os.path.join(params.savefolder, 'data_analysis',
'meanInpCurrents.pickle')):
meanInpCurrents = getMeanInpCurrents(
params, params.n_rec_input_spikes,
os.path.join(params.spike_output_path, 'population_input_spikes'))
f = open(
os.path.join(params.savefolder, 'data_analysis',
'meanInpCurrents.pickle'), 'wb')
pickle.dump(meanInpCurrents, f)
f.close()
else:
f = open(
os.path.join(params.savefolder, 'data_analysis',
'meanInpCurrents.pickle'), 'rb')
meanInpCurrents = pickle.load(f)
f.close()
if not os.path.isfile(
os.path.join(params.savefolder, 'data_analysis',
'meanVoltages.pickle')):
meanVoltages = getMeanVoltages(
params, params.n_rec_voltage,
os.path.join(params.spike_output_path, 'voltages'))
f = open(
os.path.join(params.savefolder, 'data_analysis',
'meanVoltages.pickle'), 'wb')
pickle.dump(meanVoltages, f)
f.close()
else:
f = open(
os.path.join(params.savefolder, 'data_analysis',
'meanVoltages.pickle'), 'rb')
meanVoltages = pickle.load(f)
f.close()
#load spike as database
networkSim = CachedNetwork(**params.networkSimParams)
if analysis_params.bw:
networkSim.colors = phlp.get_colors(len(networkSim.X))
show_ax_labels = True
show_insets = False
transient = 200
T = [800, 1000]
T_inset = [900, 920]
sep = 0.025 / 2 #0.017
left = 0.075
bottom = 0.55
top = 0.975
right = 0.95
axwidth = 0.16
numcols = 4
insetwidth = axwidth / 2
insetheight = 0.5
lefts = np.linspace(left, right - axwidth, numcols)
#fig = plt.figure()
############################################################################
# A part, plot spike rasters
############################################################################
ax1 = fig.add_axes([lefts[0], bottom, axwidth, top - bottom])
#fig.text(0.005,0.95,'a',fontsize=8, fontweight='demibold')
if show_ax_labels:
phlp.annotate_subplot(
ax1,
ncols=4,
nrows=1.02,
letter='A',
)
ax1.set_title('network activity')
plt.locator_params(nbins=4)
x, y = networkSim.get_xy(T, fraction=1)
networkSim.plot_raster(ax1,
T,
x,
y,
markersize=0.2,
marker='_',
alpha=1.,
legend=False,
pop_names=True,
rasterized=False)
phlp.remove_axis_junk(ax1)
ax1.set_xlabel(r'$t$ (ms)', labelpad=0.1)
ax1.set_ylabel('population', labelpad=0.1)
# Inset
if show_insets:
ax2 = fig.add_axes([
lefts[0] + axwidth - insetwidth, top - insetheight, insetwidth,
insetheight
])
plt.locator_params(nbins=4)
x, y = networkSim.get_xy(T_inset, fraction=0.4)
networkSim.plot_raster(ax2,
T_inset,
x,
y,
markersize=0.25,
alpha=1.,
legend=False)
phlp.remove_axis_junk(ax2)
ax2.set_xticks(T_inset)
ax2.set_yticks([])
ax2.set_yticklabels([])
ax2.set_ylabel('')
ax2.set_xlabel('')
############################################################################
# B part, plot firing rates
############################################################################
nrows = len(networkSim.X) - 1
high = top
low = bottom
thickn = (high - low) / nrows - sep
bottoms = np.linspace(low, high - thickn, nrows)[::-1]
x, y = networkSim.get_xy(T, fraction=1)
#dummy ax to put label in correct location
ax_ = fig.add_axes([lefts[1], bottom, axwidth, top - bottom])
ax_.axis('off')
if show_ax_labels:
phlp.annotate_subplot(ax_, ncols=4, nrows=1, letter='B')
for i, X in enumerate(networkSim.X[:-1]):
ax3 = fig.add_axes([lefts[1], bottoms[i], axwidth, thickn])
plt.locator_params(nbins=4)
phlp.remove_axis_junk(ax3)
networkSim.plot_f_rate(ax3,
X,
i,
T,
x,
y,
yscale='linear',
plottype='fill_between',
show_label=False,
rasterized=False)
ax3.yaxis.set_major_locator(plt.MaxNLocator(3))
if i != nrows - 1:
ax3.set_xticklabels([])
if i == 3:
ax3.set_ylabel(r'(s$^{-1}$)', labelpad=0.1)
if i == 0:
ax3.set_title(r'firing rates ')
ax3.text(0,
1,
X,
horizontalalignment='left',
verticalalignment='bottom',
transform=ax3.transAxes)
for loc, spine in ax3.spines.items():
if loc in ['right', 'top']:
spine.set_color('none')
ax3.xaxis.set_ticks_position('bottom')
ax3.yaxis.set_ticks_position('left')
ax3.set_xlabel(r'$t$ (ms)', labelpad=0.1)
############################################################################
# C part, plot somatic synapse input currents population resolved
############################################################################
#set up subplots
nrows = len(list(meanInpCurrents.keys()))
high = top
low = bottom
thickn = (high - low) / nrows - sep
bottoms = np.linspace(low, high - thickn, nrows)[::-1]
ax_ = fig.add_axes([lefts[2], bottom, axwidth, top - bottom])
ax_.axis('off')
if show_ax_labels:
phlp.annotate_subplot(ax_, ncols=4, nrows=1, letter='C')
for i, Y in enumerate(params.Y):
value = meanInpCurrents[Y]
tvec = value['tvec']
inds = (tvec <= T[1]) & (tvec >= T[0])
ax3 = fig.add_axes([lefts[2], bottoms[i], axwidth, thickn])
plt.locator_params(nbins=4)
if i == 0:
ax3.plot(
tvec[inds][::10],
helpers.decimate(value['E'][inds], 10),
'k' if analysis_params.bw else
analysis_params.colorE, #lw=0.75, #'r',
rasterized=False,
label='exc.')
ax3.plot(
tvec[inds][::10],
helpers.decimate(value['I'][inds], 10),
'gray' if analysis_params.bw else
analysis_params.colorI, #lw=0.75, #'b',
rasterized=False,
label='inh.')
ax3.plot(tvec[inds][::10],
helpers.decimate(value['E'][inds] + value['I'][inds], 10),
'k',
lw=1,
rasterized=False,
label='sum')
else:
ax3.plot(
tvec[inds][::10],
helpers.decimate(value['E'][inds], 10),
'k' if analysis_params.bw else
analysis_params.colorE, #lw=0.75, #'r',
rasterized=False)
ax3.plot(
tvec[inds][::10],
helpers.decimate(value['I'][inds], 10),
'gray' if analysis_params.bw else
analysis_params.colorI, #lw=0.75, #'b',
rasterized=False)
ax3.plot(tvec[inds][::10],
helpers.decimate(value['E'][inds] + value['I'][inds], 10),
'k',
lw=1,
rasterized=False)
phlp.remove_axis_junk(ax3)
ax3.axis(ax3.axis('tight'))
ax3.set_yticks([ax3.axis()[2], 0, ax3.axis()[3]])
ax3.set_yticklabels([
np.round((value['I'][inds]).min(), decimals=1), 0,
np.round((value['E'][inds]).max(), decimals=1)
])
ax3.text(0,
1,
Y,
horizontalalignment='left',
verticalalignment='bottom',
transform=ax3.transAxes)
if i == nrows - 1:
ax3.set_xlabel('$t$ (ms)', labelpad=0.1)
else:
ax3.set_xticklabels([])
if i == 3:
ax3.set_ylabel(r'(nA)', labelpad=0.1)
if i == 0:
ax3.set_title('input currents')
ax3.legend(loc=1, prop={'size': 4})
phlp.remove_axis_junk(ax3)
ax3.set_xlim(T)
############################################################################
# D part, plot membrane voltage population resolved
############################################################################
nrows = len(list(meanVoltages.keys()))
high = top
low = bottom
thickn = (high - low) / nrows - sep
bottoms = np.linspace(low, high - thickn, nrows)[::-1]
colors = phlp.get_colors(len(params.Y))
ax_ = fig.add_axes([lefts[3], bottom, axwidth, top - bottom])
ax_.axis('off')
if show_ax_labels:
phlp.annotate_subplot(ax_, ncols=4, nrows=1, letter='D')
for i, Y in enumerate(params.Y):
value = meanVoltages[Y]
tvec = value['tvec']
inds = (tvec <= T[1]) & (tvec >= T[0])
ax4 = fig.add_axes([lefts[3], bottoms[i], axwidth, thickn])
ax4.plot(tvec[inds][::10],
helpers.decimate(value['data'][inds], 10),
color=colors[i],
zorder=0,
rasterized=False)
phlp.remove_axis_junk(ax4)
plt.locator_params(nbins=4)
ax4.axis(ax4.axis('tight'))
ax4.yaxis.set_major_locator(plt.MaxNLocator(3))
ax4.text(0,
1,
Y,
horizontalalignment='left',
verticalalignment='bottom',
transform=ax4.transAxes)
if i == nrows - 1:
ax4.set_xlabel('$t$ (ms)', labelpad=0.1)
else:
ax4.set_xticklabels([])
if i == 3:
ax4.set_ylabel(r'(mV)', labelpad=0.1)
if i == 0:
ax4.set_title('voltages')
ax4.set_xlim(T)
def fig_network_input_structure(fig,
params,
bottom=0.1,
top=0.9,
transient=200,
T=[800, 1000],
Df=0.,
mlab=True,
NFFT=256,
srate=1000,
window=plt.mlab.window_hanning,
noverlap=256 * 3 / 4,
letters='abcde',
flim=(4, 400),
show_titles=True,
show_xlabels=True,
show_CSD=False):
'''
This figure is the top part for plotting a comparison between the PD-model
and the modified-PD model
'''
#load spike as database
networkSim = CachedNetwork(**params.networkSimParams)
if analysis_params.bw:
networkSim.colors = phlp.get_colors(len(networkSim.X))
# ana_params.set_PLOS_2column_fig_style(ratio=ratio)
# fig = plt.figure()
# fig.subplots_adjust(left=0.06, right=0.94, bottom=0.09, top=0.92, wspace=0.5, hspace=0.2)
#use gridspec to get nicely aligned subplots througout panel
gs1 = gridspec.GridSpec(5, 5, bottom=bottom, top=top)
############################################################################
# A part, full dot display
############################################################################
ax0 = fig.add_subplot(gs1[:, 0])
phlp.remove_axis_junk(ax0)
phlp.annotate_subplot(ax0,
ncols=5,
nrows=1,
letter=letters[0],
linear_offset=0.065)
x, y = networkSim.get_xy(T, fraction=1)
networkSim.plot_raster(ax0,
T,
x,
y,
markersize=0.2,
marker='_',
alpha=1.,
legend=False,
pop_names=True,
rasterized=False)
ax0.set_ylabel('population', labelpad=0.)
ax0.set_xticks([800, 900, 1000])
if show_titles:
ax0.set_title('spiking activity', va='center')
if show_xlabels:
ax0.set_xlabel(r'$t$ (ms)', labelpad=0.)
else:
ax0.set_xlabel('')
############################################################################
# B part, firing rate spectra
############################################################################
# Get the firing rate from Potjan Diesmann et al network activity
#collect the spikes x is the times, y is the id of the cell.
T_all = [transient, networkSim.simtime]
bins = np.arange(transient, networkSim.simtime + 1)
x, y = networkSim.get_xy(T_all, fraction=1)
# create invisible axes to position labels correctly
ax_ = fig.add_subplot(gs1[:, 1])
phlp.annotate_subplot(ax_,
ncols=5,
nrows=1,
letter=letters[1],
linear_offset=0.065)
if show_titles:
ax_.set_title('firing rate PSD', va='center')
ax_.axis('off')
colors = phlp.get_colors(len(params.Y)) + ['k']
COUNTER = 0
label_set = False
t**s = ['L23E/I', 'L4E/I', 'L5E/I', 'L6E/I', 'TC']
if x['TC'].size > 0:
TC = True
else:
TC = False
BAxes = []
for i, X in enumerate(networkSim.X):
if i % 2 == 0:
ax1 = fig.add_subplot(gs1[COUNTER, 1])
phlp.remove_axis_junk(ax1)
if x[X].size > 0:
ax1.text(0.05,
0.85,
t**s[COUNTER],
horizontalalignment='left',
verticalalignment='bottom',
transform=ax1.transAxes)
BAxes.append(ax1)
#firing rate histogram
hist = np.histogram(x[X], bins=bins)[0].astype(float)
hist -= hist.mean()
if mlab:
Pxx, freqs = plt.mlab.psd(hist,
NFFT=NFFT,
Fs=srate,
noverlap=noverlap,
window=window)
else:
[freqs, Pxx] = hlp.powerspec([hist],
tbin=1.,
Df=Df,
pointProcess=False)
mask = np.where(freqs >= 0.)
freqs = freqs[mask]
Pxx = Pxx.flatten()
Pxx = Pxx[mask]
Pxx = Pxx / (T_all[1] - T_all[0])**2
if x[X].size > 0:
ax1.loglog(freqs[1:],
Pxx[1:],
label=X,
color=colors[i],
clip_on=True)
ax1.axis(ax1.axis('tight'))
ax1.set_ylim([5E-4, 5E2])
ax1.set_yticks([1E-3, 1E-1, 1E1])
if label_set == False:
ax1.set_ylabel(r'(s$^{-2}$/Hz)', labelpad=0.)
label_set = True
if i > 1:
ax1.set_yticklabels([])
if i >= 6 and not TC and show_xlabels or X == 'TC' and TC and show_xlabels:
ax1.set_xlabel('$f$ (Hz)', labelpad=0.)
if TC and i < 8 or not TC and i < 6:
ax1.set_xticklabels([])
else:
ax1.axis('off')
ax1.set_xlim(flim)
if i % 2 == 0:
COUNTER += 1
ax1.yaxis.set_minor_locator(plt.NullLocator())
############################################################################
# c part, LFP traces and CSD color plots
############################################################################
ax2 = fig.add_subplot(gs1[:, 2])
phlp.annotate_subplot(ax2,
ncols=5,
nrows=1,
letter=letters[2],
linear_offset=0.065)
phlp.remove_axis_junk(ax2)
plot_signal_sum(ax2,
params,
fname=os.path.join(params.savefolder, 'LFPsum.h5'),
unit='mV',
T=T,
ylim=[-1600, 40],
rasterized=False)
# CSD background colorplot
if show_CSD:
im = plot_signal_sum_colorplot(ax2,
params,
os.path.join(params.savefolder,
'CSDsum.h5'),
unit=r'($\mu$Amm$^{-3}$)',
T=[800, 1000],
colorbar=False,
ylim=[-1600, 40],
fancy=False,
cmap=plt.cm.get_cmap('bwr_r', 21),
rasterized=False)
cb = phlp.colorbar(fig,
ax2,
im,
width=0.05,
height=0.4,
hoffset=-0.05,
voffset=0.3)
cb.set_label('($\mu$Amm$^{-3}$)', labelpad=0.1)
ax2.set_xticks([800, 900, 1000])
ax2.axis(ax2.axis('tight'))
if show_titles:
if show_CSD:
ax2.set_title('LFP & CSD', va='center')
else:
ax2.set_title('LFP', va='center')
if show_xlabels:
ax2.set_xlabel(r'$t$ (ms)', labelpad=0.)
else:
ax2.set_xlabel('')
############################################################################
# d part, LFP power trace for each layer
############################################################################
freqs, PSD = calc_signal_power(params,
fname=os.path.join(params.savefolder,
'LFPsum.h5'),
transient=transient,
Df=Df,
mlab=mlab,
NFFT=NFFT,
noverlap=noverlap,
window=window)
channels = [0, 3, 7, 11, 13]
# create invisible axes to position labels correctly
ax_ = fig.add_subplot(gs1[:, 3])
phlp.annotate_subplot(ax_,
ncols=5,
nrows=1,
letter=letters[3],
linear_offset=0.065)
if show_titles:
ax_.set_title('LFP PSD', va='center')
ax_.axis('off')
for i, ch in enumerate(channels):
ax = fig.add_subplot(gs1[i, 3])
phlp.remove_axis_junk(ax)
if i == 0:
ax.set_ylabel('(mV$^2$/Hz)', labelpad=0)
ax.loglog(freqs[1:], PSD[ch][1:], color='k')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
if i < 4:
ax.set_xticklabels([])
ax.text(0.75,
0.85,
'ch. %i' % (channels[i] + 1),
horizontalalignment='left',
verticalalignment='bottom',
fontsize=6,
transform=ax.transAxes)
ax.tick_params(axis='y', which='minor', bottom='off')
ax.axis(ax.axis('tight'))
ax.yaxis.set_minor_locator(plt.NullLocator())
ax.set_xlim(flim)
ax.set_ylim(1E-7, 2E-4)
if i != 0:
ax.set_yticklabels([])
if show_xlabels:
ax.set_xlabel('$f$ (Hz)', labelpad=0.)
############################################################################
# e part signal power
############################################################################
ax4 = fig.add_subplot(gs1[:, 4])
phlp.annotate_subplot(ax4,
ncols=5,
nrows=1,
letter=letters[4],
linear_offset=0.065)
fname = os.path.join(params.savefolder, 'LFPsum.h5')
im = plot_signal_power_colorplot(ax4,
params,
fname=fname,
transient=transient,
Df=Df,
mlab=mlab,
NFFT=NFFT,
window=window,
cmap=plt.cm.get_cmap('gray_r', 12),
vmin=1E-7,
vmax=1E-4)
phlp.remove_axis_junk(ax4)
ax4.set_xlim(flim)
cb = phlp.colorbar(fig,
ax4,
im,
width=0.05,
height=0.5,
hoffset=-0.05,
voffset=0.5)
cb.set_label('(mV$^2$/Hz)', labelpad=0.1)
if show_titles:
ax4.set_title('LFP PSD', va='center')
if show_xlabels:
ax4.set_xlabel(r'$f$ (Hz)', labelpad=0.)
else:
ax4.set_xlabel('')
return fig
# MAIN simulation procedure #
################################################################################
if __name__ == '__main__':
#tic toc
tic = time.time()
#Create an object representation containing the spiking activity of the network
#simulation output that uses sqlite3. Again, kwargs are derived from the brunel
#network instance.
networkSim = CachedNetwork(
simtime = PSET['simtime'],
dt = PSET['dt'],
spike_output_path = PSET['spike_output_path'],
label = 'brunel',
ext = 'gdf',
GIDs = {'EX' : [1, PSET['NE']], 'IN' : [PSET['NE']+1, PSET['NI']]},
X = ['EX', 'IN'],
cmap='rainbow_r',
)
####### Set up populations #####################################################
#iterate over each cell type, and create populationulation object
for i, Y in enumerate(PSET['X']):
#create population:
pop = Population(
cellParams = PSET['cellParams'][Y],
rand_rot_axis = PSET['rand_rot_axis'][Y],
simulationParams = PSET['simulationParams'],
def fig_intro(params,
ana_params,
T=[800, 1000],
fraction=0.05,
rasterized=False):
'''set up plot for introduction'''
ana_params.set_PLOS_2column_fig_style(ratio=0.5)
#load spike as database
networkSim = CachedNetwork(**params.networkSimParams)
if analysis_params.bw:
networkSim.colors = phlp.get_colors(len(networkSim.X))
#set up figure and subplots
fig = plt.figure()
gs = gridspec.GridSpec(3, 4)
fig.subplots_adjust(left=0.05, right=0.95, wspace=0.5, hspace=0.)
#network diagram
ax0_1 = fig.add_subplot(gs[:, 0], frameon=False)
ax0_1.set_title('point-neuron network', va='bottom')
network_sketch(ax0_1, yscaling=1.3)
ax0_1.xaxis.set_ticks([])
ax0_1.yaxis.set_ticks([])
phlp.annotate_subplot(ax0_1,
ncols=4,
nrows=1,
letter='A',
linear_offset=0.065)
#network raster
ax1 = fig.add_subplot(gs[:, 1], frameon=True)
phlp.remove_axis_junk(ax1)
phlp.annotate_subplot(ax1,
ncols=4,
nrows=1,
letter='B',
linear_offset=0.065)
x, y = networkSim.get_xy(T, fraction=fraction)
# networkSim.plot_raster(ax1, T, x, y, markersize=0.1, alpha=1.,legend=False, pop_names=True)
networkSim.plot_raster(ax1,
T,
x,
y,
markersize=0.2,
marker='_',
alpha=1.,
legend=False,
pop_names=True,
rasterized=rasterized)
ax1.set_ylabel('')
ax1.xaxis.set_major_locator(plt.MaxNLocator(4))
ax1.set_title('spiking activity', va='bottom')
a = ax1.axis()
ax1.vlines(x['TC'][0], a[2], a[3], 'k', lw=0.25)
#population
ax2 = fig.add_subplot(gs[:, 2], frameon=False)
ax2.xaxis.set_ticks([])
ax2.yaxis.set_ticks([])
plot_population(ax2,
params,
isometricangle=np.pi / 24,
plot_somas=False,
plot_morphos=True,
num_unitsE=1,
num_unitsI=1,
clip_dendrites=True,
main_pops=True,
title='',
rasterized=rasterized)
ax2.set_title('multicompartment\nneurons',
va='bottom',
fontweight='normal')
phlp.annotate_subplot(ax2,
ncols=4,
nrows=1,
letter='C',
linear_offset=0.065)
#LFP traces in all channels
ax3 = fig.add_subplot(gs[:, 3], frameon=True)
phlp.remove_axis_junk(ax3)
plot_signal_sum(ax3,
params,
fname=os.path.join(params.savefolder, 'LFPsum.h5'),
unit='mV',
vlimround=0.8,
T=T,
ylim=[ax2.axis()[2], ax2.axis()[3]],
rasterized=False)
ax3.set_title('LFP', va='bottom')
ax3.xaxis.set_major_locator(plt.MaxNLocator(4))
phlp.annotate_subplot(ax3,
ncols=4,
nrows=1,
letter='D',
linear_offset=0.065)
a = ax3.axis()
ax3.vlines(x['TC'][0], a[2], a[3], 'k', lw=0.25)
#draw some arrows:
ax = plt.gca()
ax.annotate(
"",
xy=(0.27, 0.5),
xytext=(.24, 0.5),
xycoords="figure fraction",
arrowprops=dict(facecolor='black', arrowstyle='simple'),
)
ax.annotate(
"",
xy=(0.52, 0.5),
xytext=(.49, 0.5),
xycoords="figure fraction",
arrowprops=dict(facecolor='black', arrowstyle='simple'),
)
ax.annotate(
"",
xy=(0.78, 0.5),
xytext=(.75, 0.5),
xycoords="figure fraction",
arrowprops=dict(facecolor='black', arrowstyle='simple'),
)
return fig
def fig_intro(params, fraction=0.05, rasterized=False):
'''set up plot for introduction'''
plt.close("all")
#load spike as database
networkSim = CachedNetwork(**params.networkSimParams)
# num_pops = 8
fig = plt.figure(figsize=[4.5, 3.5])
fig.subplots_adjust(left=0.03, right=0.98, wspace=0.5, hspace=0.)
ax_spikes = fig.add_axes([0.09, 0.4, 0.2, 0.55])
ax_morph = fig.add_axes([0.37, 0.3, 0.3, 0.75],
frameon=False,
aspect=1,
xticks=[],
yticks=[])
ax_lfp = fig.add_axes([0.73, 0.4, 0.23, 0.55], frameon=True)
ax_4s = fig.add_axes([0.42, 0.05, 0.25, 0.2],
frameon=False,
aspect=1,
title='head model',
xticks=[],
yticks=[])
ax_top_EEG = fig.add_axes([0.65, 0.02, 0.33, 0.32],
frameon=False,
xticks=[],
yticks=[],
ylim=[-0.5, .25])
dt = 1
t_idx = 875
T = [t_idx, t_idx + 75]
fig.text(0.55, 0.97, "multicompartment neurons", fontsize=6, ha="center")
ax_spikes.set_title("spiking activity", fontsize=6)
ax_lfp.set_title("LFP", fontsize=6)
#network raster
ax_spikes.xaxis.set_major_locator(plt.MaxNLocator(4))
phlp.remove_axis_junk(ax_spikes)
phlp.annotate_subplot(ax_spikes,
ncols=4,
nrows=1,
letter='A',
linear_offset=0.045)
x, y = networkSim.get_xy(T, fraction=fraction)
networkSim.plot_raster(ax_spikes,
T,
x,
y,
markersize=0.2,
marker='_',
alpha=1.,
legend=False,
pop_names=True,
rasterized=rasterized)
#population
plot_population(ax_morph,
params,
isometricangle=np.pi / 24,
plot_somas=False,
plot_morphos=True,
num_unitsE=1,
num_unitsI=1,
clip_dendrites=True,
main_pops=True,
title='',
rasterized=rasterized)
# ax_morph.set_title('multicompartment neurons', va='top')
phlp.annotate_subplot(ax_morph,
ncols=5,
nrows=1,
letter='B',
linear_offset=0.005)
phlp.remove_axis_junk(ax_lfp)
#ax_lfp.set_title('LFP', va='bottom')
ax_lfp.xaxis.set_major_locator(plt.MaxNLocator(4))
phlp.annotate_subplot(ax_lfp,
ncols=4,
nrows=2,
letter='C',
linear_offset=0.025)
#print(ax_morph.axis())
plot_signal_sum(ax_lfp,
params,
fname=join(params.savefolder, 'LFPsum.h5'),
unit='mV',
vlimround=0.8,
T=T,
ylim=[-1600, 100],
rasterized=False)
plot_cdms(fig, params, dt, T)
plot_foursphere_to_ax(ax_4s)
phlp.annotate_subplot(ax_4s,
ncols=3,
nrows=7,
letter='E',
linear_offset=0.05)
# Plot EEG at top of head
# ax_top_EEG.xaxis.set_major_locator(plt.MaxNLocator(4))
phlp.annotate_subplot(ax_top_EEG,
ncols=1,
nrows=1,
letter='F',
linear_offset=-0.08)
# ax_top_EEG.set_ylabel("$\mu$V", labelpad=-3)
summed_top_EEG = np.load(join(params.savefolder, "summed_EEG.npy"))
simple_EEG_single_pop = np.load(
join(params.savefolder, "simple_EEG_single_pop.npy"))
simple_EEG_pops_with_pos = np.load(
join(params.savefolder, "simple_EEG_pops_with_pos.npy"))
tvec = np.arange(len(summed_top_EEG)) * dt
# sub_pops = ["L5I", "L4I", "L6I", "L23I", "L5E", "L4E", "L6E", "L23E"]
pops = np.unique(next(zip(*params.mapping_Yy)))
colors = phlp.get_colors(np.unique(pops).size)
for p_idx, pop in enumerate(pops):
pop_eeg = np.load(join(params.savefolder, "EEG_{}.npy".format(pop)))
pop_eeg -= np.average(pop_eeg)
# pop_sum.append(pop_eeg)
ax_top_EEG.plot(pop_eeg, c=colors[p_idx], lw=1)
ax_top_EEG.plot([878, 878], [-0.1, -0.3], c='k', lw=1)
ax_top_EEG.plot([878, 888], [-0.3, -0.3], c='k', lw=1)
ax_top_EEG.text(879, -0.2, "0.2 $\mu$V", va="center")
ax_top_EEG.text(885, -0.32, "10 ms", va="top", ha="center")
y0 = summed_top_EEG - np.average(summed_top_EEG)
y1 = simple_EEG_single_pop - np.average(simple_EEG_single_pop)
y2 = simple_EEG_pops_with_pos - np.average(simple_EEG_pops_with_pos)
l3, = ax_top_EEG.plot(tvec, y0 - y2, lw=1.5, c='orange', ls='-')
l1, = ax_top_EEG.plot(tvec, y0, lw=1.5, c='k')
l2, = ax_top_EEG.plot(tvec, y2, lw=1.5, c='r', ls='--')
t0_plot_idx = np.argmin(np.abs(tvec - 875))
t1_plot_idx = np.argmin(np.abs(tvec - 950))
max_sig_idx = np.argmax(np.abs(y0[t0_plot_idx:])) + t0_plot_idx
EEG_error_at_max_1 = np.abs(y0[max_sig_idx] - y1[max_sig_idx]) / np.abs(
y0[max_sig_idx])
EEG_error_at_max_2 = np.abs(y0[max_sig_idx] - y2[max_sig_idx]) / np.abs(
y0[max_sig_idx])
max_EEG_error_1 = np.max(
np.abs(y0[t0_plot_idx:t1_plot_idx] - y1[t0_plot_idx:t1_plot_idx]) /
np.max(np.abs(y0[t0_plot_idx:t1_plot_idx])))
max_EEG_error_2 = np.max(
np.abs(y0[t0_plot_idx:t1_plot_idx] - y2[t0_plot_idx:t1_plot_idx]) /
np.max(np.abs(y0[t0_plot_idx:t1_plot_idx])))
print(
"Error with single pop at sig max (t={:1.3f} ms): {:1.4f}. Max relative error: {:1.4f}"
.format(tvec[max_sig_idx], EEG_error_at_max_1, max_EEG_error_1))
print(
"Error with multipop at sig max (t={:1.3f} ms): {:1.4f}. Max relative error: {:1.4f}"
.format(tvec[max_sig_idx], EEG_error_at_max_2, max_EEG_error_2))
ax_top_EEG.legend([l1, l2, l3], ["full sum", "pop. dipole", "difference"],
frameon=False,
loc=(0.5, 0.1))
# phlp.remove_axis_junk(ax_top_EEG)
ax_top_EEG.axvline(900, c='gray', ls='--')
ax_lfp.axvline(900, c='gray', ls='--')
ax_top_EEG.set_xlim(T)
fig.savefig(join("..", "figures", 'Figure6.png'), dpi=300)
fig.savefig(join("..", "figures", 'Figure6.pdf'), dpi=300)
