def __init__(self,
autocollect=True,
label_positions='brunel-py-pos',
**kwargs):
'''
Parameters
----------
autocollect : bool
whether or not to automatically gather gdf file output
label_positions : str
file prefix of position txt files
**kwargs :
parameters for parent class hybridLFPy.CachedNetwork
'''
#initialize parent class
CachedNetwork.__init__(self, autocollect=autocollect, **kwargs)
#set class attributes
self.label_positions = label_positions
#load positions and set them as attributes
self.positions = {}
for X in self.X:
fname = os.path.join(self.spike_output_path, 'all_positions.h5')
if os.path.isfile(fname):
f = h5py.File(fname)
#set positions, units from mm to mum !!!!!!!!!!!!!!!!!!!!!!!!!!!
self.positions[X] = f[X].value[:, 1:] * 1E3
f.close()
else:
fnames = glob(
os.path.join(self.spike_output_path,
label_positions + '*{0}*txt'.format(X)))
for i, fname in enumerate(fnames):
if i == 0:
tmp_pos = np.loadtxt(fname, dtype=object)
else:
tmp_pos = np.vstack(
(tmp_pos, np.loadtxt(fname, dtype=object)))
#sorting array
argsort = np.argsort(tmp_pos[:, 0].astype(int))
#set positions
self.positions[X] = tmp_pos[argsort, 1:].astype(float)
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 = file(os.path.join(params.savefolder, 'data_analysis',
'meanInpCurrents.pickle'), 'wb')
pickle.dump(meanInpCurrents, f)
f.close()
else:
f = file(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 = file(os.path.join(params.savefolder, 'data_analysis',
'meanVoltages.pickle'), 'wb')
pickle.dump(meanVoltages, f)
f.close()
else:
f = file(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.iteritems():
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(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(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')
import analysis_params
from hybridLFPy import CachedNetwork
if __name__ == '__main__':
params = multicompartment_params()
ana_params = analysis_params.params()
ana_params.set_PLOS_2column_fig_style(ratio=0.5)
params.figures_path = os.path.join(params.savefolder, 'figures')
params.spike_output_path = os.path.join(params.savefolder,
'processed_nest_output')
params.networkSimParams['spike_output_path'] = params.spike_output_path
#load spike as database
networkSim = CachedNetwork(**params.networkSimParams)
if analysis_params.bw:
networkSim.colors = phlp.get_colors(len(networkSim.X))
transient = 200
T = [890, 920]
show_ax_labels = True
show_images = True
# show_images = False if analysis_params.bw else True
gs = gridspec.GridSpec(9, 4)
fig = plt.figure()
fig.subplots_adjust(left=0.06,
right=0.94,
if properrun:
#initiate nest simulation with only the point neuron network parameter class
networkParams = point_neuron_network_params()
sli_run(parameters=networkParams,
fname='microcircuit.sli',
verbosity='M_WARNING')
#preprocess the gdf files containing spiking output, voltages, weighted and
#spatial input spikes and currents:
merge_gdf(networkParams,
raw_label=networkParams.spike_detector_label,
file_type='gdf',
fileprefix=params.networkSimParams['label'])
#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 #####################################################
if properrun:
#iterate over each cell type, run single-cell simulations and create
#population object
for i, y in enumerate(params.y):
#create population:
pop = Population(
#parent class parameters
cellParams=params.yCellParams[y],
rand_rot_axis=params.rand_rot_axis[y],
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)
from hybridLFPy import CachedNetwork
if __name__ == '__main__':
params = multicompartment_params()
ana_params = analysis_params.params()
ana_params.set_PLOS_2column_fig_style(ratio=0.5)
params.figures_path = os.path.join(params.savefolder, 'figures')
params.spike_output_path = os.path.join(params.savefolder,
'processed_nest_output')
params.networkSimParams['spike_output_path'] = params.spike_output_path
#load spike as database
networkSim = CachedNetwork(**params.networkSimParams)
if analysis_params.bw:
networkSim.colors = phlp.get_colors(len(networkSim.X))
transient=200
T=[890, 920]
show_ax_labels = True
show_images = True
# show_images = False if analysis_params.bw else True
gs = gridspec.GridSpec(9,4)
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
def fig_kernel_lfp(savefolders, params, transient=200, T=[800., 1000.], X='L5E',
lags=[20, 20], channels=[0,3,7,11,13]):
'''
This function calculates the STA of LFP, extracts kernels and recontructs the LFP from kernels.
Arguments
::
transient : the time in milliseconds, after which the analysis should begin
so as to avoid any starting transients
X : id of presynaptic trigger population
'''
# Electrode geometry
zvec = np.r_[params.electrodeParams['z']]
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ana_params.set_PLOS_2column_fig_style(ratio=1)
# Start the figure
fig = plt.figure()
fig.subplots_adjust(left=0.06, right=0.95, bottom=0.05, top=0.95, hspace=0.23, wspace=0.55)
# create grid_spec
gs = gridspec.GridSpec(2*len(channels)+1, 7)
###########################################################################
# spikegen "network" activity
############################################################################
# path to simulation files
params.savefolder = os.path.join(os.path.split(params.savefolder)[0],
'simulation_output_spikegen')
params.figures_path = os.path.join(params.savefolder, 'figures')
params.spike_output_path = os.path.join(params.savefolder,
'processed_nest_output')
params.networkSimParams['spike_output_path'] = params.spike_output_path
# Get the spikegen LFP:
f = h5py.File(os.path.join(params.savefolder, 'LFPsum.h5'))
srate = f['srate'].value
tvec = np.arange(f['data'].shape[1]) * 1000. / srate
# slice
inds = (tvec < params.tstop) & (tvec >= transient)
data_sg_raw = f['data'].value.astype(float)
data_sg = data_sg_raw[:, inds]
f.close()
# kernel width
kwidth = 20
# create some dummy spike times
activationtimes = np.array([x*100 for x in range(3,11)] + [200])
networkSimSpikegen = CachedNetwork(**params.networkSimParams)
x, y = networkSimSpikegen.get_xy([transient, params.tstop])
###########################################################################
# Part A: spatiotemporal kernels, all presynaptic populations
############################################################################
titles = ['TC',
'L23E/I',
'LFP kernels \n L4E/I',
'L5E/I',
'L6E/I',
]
COUNTER = 0
for i, X__ in enumerate(([['TC']]) + zip(params.X[1::2], params.X[2::2])):
ax = fig.add_subplot(gs[:len(channels), i])
if i == 0:
phlp.annotate_subplot(ax, ncols=7, nrows=4, letter=alphabet[0], linear_offset=0.02)
for j, X_ in enumerate(X__):
# create spikegen histogram for population Y
cinds = np.arange(activationtimes[np.arange(-1, 8)][COUNTER]-kwidth,
activationtimes[np.arange(-1, 8)][COUNTER]+kwidth+2)
x0_sg = np.histogram(x[X_], bins=cinds)[0].astype(float)
if X_ == ('TC'):
color='k' if analysis_params.bw else analysis_params.colorE
# lw = plt.rcParams['lines.linewidth']
# zorder=1
else:
color=('k' if analysis_params.bw else analysis_params.colorE,
'gray' if analysis_params.bw else analysis_params.colorI)[j]
lw = 0.75 if color in ['gray', 'r', 'b'] else plt.rcParams['lines.linewidth']
zorder = 0 if 'I' in X_ else 1
# plot kernel as correlation of spikegen LFP signal with delta spike train
xcorr, vlimround = plotting_correlation(params,
x0_sg/x0_sg.sum()**2,
data_sg_raw[:, cinds[:-1]]*1E3,
ax, normalize=False,
lag=kwidth,
color=color,
scalebar=False,
lw=lw, zorder=zorder)
if i > 0:
ax.set_yticklabels([])
## Create scale bar
ax.plot([kwidth, kwidth],
[-1500 + j*3*100, -1400 + j*3*100], lw=2, color=color,
clip_on=False)
ax.text(kwidth*1.08, -1450 + j*3*100, '%.1f $\mu$V' % vlimround,
rotation='vertical', va='center')
ax.set_xlim((-5, kwidth))
ax.set_xticks([-20, 0, 20])
ax.set_xticklabels([-20, 0, 20])
COUNTER += 1
ax.set_title(titles[i])
################################################
# Iterate over savefolders
################################################
for i, (savefolder, lag) in enumerate(zip(savefolders, lags)):
# path to simulation files
params.savefolder = os.path.join(os.path.split(params.savefolder)[0],
savefolder)
params.figures_path = os.path.join(params.savefolder, 'figures')
params.spike_output_path = os.path.join(params.savefolder,
'processed_nest_output')
params.networkSimParams['spike_output_path'] = params.spike_output_path
#load spike as database inside function to avoid buggy behaviour
networkSim = CachedNetwork(**params.networkSimParams)
# Get the Compound LFP: LFPsum : data[nchannels, timepoints ]
f = h5py.File(os.path.join(params.savefolder, 'LFPsum.h5'))
data_raw = f['data'].value
srate = f['srate'].value
tvec = np.arange(data_raw.shape[1]) * 1000. / srate
# slice
inds = (tvec < params.tstop) & (tvec >= transient)
data = data_raw[:, inds]
# subtract mean
dataT = data.T - data.mean(axis=1)
data = dataT.T
f.close()
# Get the spikegen LFP:
f = h5py.File(os.path.join(os.path.split(params.savefolder)[0], 'simulation_output_spikegen', 'LFPsum.h5'))
data_sg_raw = f['data'].value
f.close()
########################################################################
# Part B: STA LFP
########################################################################
titles = ['stLFP(%s)\n(spont.)' % X, 'stLFP(%s)\n(AC. mod.)' % X]
ax = fig.add_subplot(gs[:len(channels), 5 + i])
if i == 0:
phlp.annotate_subplot(ax, ncols=15, nrows=4, letter=alphabet[i+1],
linear_offset=0.02)
#collect the spikes x is the times, y is the id of the cell.
x, y = networkSim.get_xy([0,params.tstop])
# Get the spikes for the population of interest given as 'Y'
bins = np.arange(0, params.tstop+2) + 0.5
x0_raw = np.histogram(x[X], bins=bins)[0]
x0 = x0_raw[inds].astype(float)
# correlation between firing rate and LFP deviation
# from mean normalized by the number of spikes
xcorr, vlimround = plotting_correlation(params,
x0/x0.sum(),
data*1E3,
ax, normalize=False,
#unit='%.3f mV',
lag=lag,
scalebar=False,
color='k',
title=titles[i],
)
# Create scale bar
ax.plot([lag, lag],
[-1500, -1400], lw=2, color='k',
clip_on=False)
ax.text(lag*1.08, -1450, '%.1f $\mu$V' % vlimround,
rotation='vertical', va='center')
[Xind] = np.where(np.array(networkSim.X) == X)[0]
# create spikegen histogram for population Y
x0_sg = np.zeros(x0.shape, dtype=float)
x0_sg[activationtimes[Xind]] += params.N_X[Xind]
ax.set_yticklabels([])
ax.set_xticks([-lag, 0, lag])
ax.set_xticklabels([-lag, 0, lag])
###########################################################################
# Part C, F: LFP and reconstructed LFP
############################################################################
# create grid_spec
gsb = gridspec.GridSpec(2*len(channels)+1, 8)
ax = fig.add_subplot(gsb[1+len(channels):, (i*4):(i*4+2)])
phlp.annotate_subplot(ax, ncols=8/2., nrows=4, letter=alphabet[i*3+2],
linear_offset=0.02)
# extract kernels, force negative lags to be zero
kernels = np.zeros((len(params.N_X), 16, kwidth*2))
for j in range(len(params.X)):
kernels[j, :, kwidth:] = data_sg_raw[:, (j+2)*100:kwidth+(j+2)*100]/params.N_X[j]
LFP_reconst_raw = np.zeros(data_raw.shape)
for j, pop in enumerate(params.X):
x0_raw = np.histogram(x[pop], bins=bins)[0].astype(float)
for ch in range(kernels.shape[1]):
LFP_reconst_raw[ch] += np.convolve(x0_raw, kernels[j, ch],
'same')
# slice
LFP_reconst = LFP_reconst_raw[:, inds]
# subtract mean
LFP_reconstT = LFP_reconst.T - LFP_reconst.mean(axis=1)
LFP_reconst = LFP_reconstT.T
vlimround = plot_signal_sum(ax, params,
fname=os.path.join(params.savefolder,
'LFPsum.h5'),
unit='mV', scalebar=True,
T=T, ylim=[-1550, 50],
color='k', label='$real$',
rasterized=False,
zorder=1)
plot_signal_sum(ax, params, fname=LFP_reconst_raw,
unit='mV', scaling_factor= 1., scalebar=False,
vlimround=vlimround,
T=T, ylim=[-1550, 50],
color='gray' if analysis_params.bw else analysis_params.colorP,
label='$reconstr$',
rasterized=False,
lw=1, zorder=0)
ax.set_title('LFP & population \n rate predictor')
if i > 0:
ax.set_yticklabels([])
###########################################################################
# Part D,G: Correlation coefficient
############################################################################
ax = fig.add_subplot(gsb[1+len(channels):, i*4+2:i*4+3])
phlp.remove_axis_junk(ax)
phlp.annotate_subplot(ax, ncols=8./1, nrows=4, letter=alphabet[i*3+3],
linear_offset=0.02)
cc = np.zeros(len(zvec))
for ch in np.arange(len(zvec)):
cc[ch] = np.corrcoef(data[ch], LFP_reconst[ch])[1, 0]
ax.barh(zvec, cc, height=80, align='center', color='0.5', linewidth=0.5)
# superimpose the chance level, obtained by mixing one input vector n times
# while keeping the other fixed. We show boxes drawn left to right where
# these denote mean +/- two standard deviations.
N = 1000
method = 'randphase' #or 'permute'
chance = np.zeros((cc.size, N))
for ch in np.arange(len(zvec)):
x1 = LFP_reconst[ch]
x1 -= x1.mean()
if method == 'randphase':
x0 = data[ch]
x0 -= x0.mean()
X00 = np.fft.fft(x0)
for n in range(N):
if method == 'permute':
x0 = np.random.permutation(datas[ch])
elif method == 'randphase':
X0 = np.copy(X00)
#random phase information such that spectra is preserved
theta = np.random.uniform(0, 2*np.pi, size=X0.size // 2-1)
#half-sided real and imaginary component
real = abs(X0[1:X0.size // 2])*np.cos(theta)
imag = abs(X0[1:X0.size // 2])*np.sin(theta)
#account for the antisymmetric phase values
X0.imag[1:imag.size+1] = imag
X0.imag[imag.size+2:] = -imag[::-1]
X0.real[1:real.size+1] = real
X0.real[real.size+2:] = real[::-1]
x0 = np.fft.ifft(X0).real
chance[ch, n] = np.corrcoef(x0, x1)[1, 0]
# p-values, compute the fraction of chance correlations > cc at each channel
p = []
for h, x in enumerate(cc):
p += [(chance[h, ] >= x).sum() / float(N)]
print('p-values:', p)
#compute the 99% percentile of the chance data
right = np.percentile(chance, 99, axis=-1)
ax.plot(right, zvec, ':', color='k', lw=1.)
ax.set_ylim([-1550, 50])
ax.set_yticklabels([])
ax.set_yticks(zvec)
ax.set_xlim([0, 1.])
ax.set_xticks([0.0, 0.5, 1])
ax.yaxis.tick_left()
ax.set_xlabel('$cc$ (-)', labelpad=0.1)
ax.set_title('corr. \n coef.')
print 'correlation coefficients:'
print cc
###########################################################################
# Part E,H: Power spectra
############################################################################
#compute PSDs ratio between ground truth and estimate
freqs, PSD_data = calc_signal_power(params, fname=data,
transient=transient, Df=None,
mlab=True,
NFFT=256, noverlap=128,
window=plt.mlab.window_hanning)
freqs, PSD_LFP_reconst = calc_signal_power(params, fname=LFP_reconst,
transient=transient, Df=None,
mlab=True,
NFFT=256, noverlap=128,
window=plt.mlab.window_hanning)
zv = np.r_[params.electrodeParams['z']]
zv = np.r_[zv, zv[-1] + np.diff(zv)[-1]]
inds = freqs >= 1 # frequencies greater than 1 Hz
for j, ch in enumerate(channels):
ax = fig.add_subplot(gsb[1+len(channels)+j, (i*4+3):(i*4+4)])
if j == 0:
phlp.annotate_subplot(ax, ncols=8./1, nrows=4.5*len(channels),
letter=alphabet[i*3+4], linear_offset=0.02)
ax.set_title('PSD')
phlp.remove_axis_junk(ax)
ax.loglog(freqs[inds], PSD_data[ch, inds], 'k', label='LFP',
clip_on=True, zorder=1)
ax.loglog(freqs[inds], PSD_LFP_reconst[ch, inds],
'gray' if analysis_params.bw else analysis_params.colorP,
label='predictor', clip_on=True, lw=1, zorder=0)
ax.set_xlim([4E0,4E2])
ax.set_ylim([1E-8, 1E-4])
ax.tick_params(axis='y', which='major', pad=0)
ax.set_yticks([1E-8,1E-6,1E-4])
ax.yaxis.set_minor_locator(plt.NullLocator())
ax.text(0.8, 0.9, 'ch. %i' % (ch+1),
horizontalalignment='left',
verticalalignment='center',
fontsize=6,
transform=ax.transAxes)
if j == 0:
ax.set_ylabel('(mV$^2$/Hz)', labelpad=0.)
if j > 0:
ax.set_yticklabels([])
if j == len(channels)-1:
ax.set_xlabel(r'$f$ (Hz)', labelpad=0.)
else:
ax.set_xticklabels([])
return fig, PSD_LFP_reconst, PSD_data
def fig_kernel_lfp_EITN_II(savefolders, params, transient=200, T=[800., 1000.], X='L5E',
lags=[20, 20], channels=[0,3,7,11,13]):
'''
This function calculates the STA of LFP, extracts kernels and recontructs the LFP from kernels.
Arguments
::
transient : the time in milliseconds, after which the analysis should begin
so as to avoid any starting transients
X : id of presynaptic trigger population
'''
# Electrode geometry
zvec = np.r_[params.electrodeParams['z']]
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ana_params.set_PLOS_2column_fig_style(ratio=0.5)
# Start the figure
fig = plt.figure()
fig.subplots_adjust(left=0.06, right=0.95, bottom=0.08, top=0.9, hspace=0.23, wspace=0.55)
# create grid_spec
gs = gridspec.GridSpec(len(channels), 7)
###########################################################################
# spikegen "network" activity
############################################################################
# path to simulation files
savefolder = 'simulation_output_spikegen'
params.savefolder = os.path.join(os.path.split(params.savefolder)[0],
savefolder)
params.figures_path = os.path.join(params.savefolder, 'figures')
params.spike_output_path = os.path.join(params.savefolder,
'processed_nest_output')
params.networkSimParams['spike_output_path'] = params.spike_output_path
# Get the spikegen LFP:
f = h5py.File(os.path.join('simulation_output_spikegen', 'LFPsum.h5'))
srate = f['srate'].value
tvec = np.arange(f['data'].shape[1]) * 1000. / srate
# slice
inds = (tvec < params.tstop) & (tvec >= transient)
data_sg_raw = f['data'].value.astype(float)
data_sg = data_sg_raw[:, inds]
f.close()
# kernel width
kwidth = 20
# create some dummy spike times
activationtimes = np.array([x*100 for x in range(3,11)] + [200])
networkSimSpikegen = CachedNetwork(**params.networkSimParams)
x, y = networkSimSpikegen.get_xy([transient, params.tstop])
############################################################################
## Part A: spatiotemporal kernels, all presynaptic populations
#############################################################################
#
#titles = ['TC',
# 'L23E/I',
# 'LFP kernels \n L4E/I',
# 'L5E/I',
# 'L6E/I',
# ]
#
#COUNTER = 0
#for i, X__ in enumerate(([['TC']]) + zip(params.X[1::2], params.X[2::2])):
# ax = fig.add_subplot(gs[:len(channels), i])
# if i == 0:
# phlp.annotate_subplot(ax, ncols=7, nrows=4, letter=alphabet[0], linear_offset=0.02)
#
# for j, X_ in enumerate(X__):
# # create spikegen histogram for population Y
# cinds = np.arange(activationtimes[np.arange(-1, 8)][COUNTER]-kwidth,
# activationtimes[np.arange(-1, 8)][COUNTER]+kwidth+2)
# x0_sg = np.histogram(x[X_], bins=cinds)[0].astype(float)
#
# if X_ == ('TC'):
# color='r'
# else:
# color=('r', 'b')[j]
#
#
# # plot kernel as correlation of spikegen LFP signal with delta spike train
# xcorr, vlimround = plotting_correlation(params,
# x0_sg/x0_sg.sum()**2,
# data_sg_raw[:, cinds[:-1]]*1E3,
# ax, normalize=False,
# lag=kwidth,
# color=color,
# scalebar=False)
# if i > 0:
# ax.set_yticklabels([])
#
# ## Create scale bar
# ax.plot([kwidth, kwidth],
# [-1500 + j*3*100, -1400 + j*3*100], lw=2, color=color,
# clip_on=False)
# ax.text(kwidth*1.08, -1450 + j*3*100, '%.1f $\mu$V' % vlimround,
# rotation='vertical', va='center')
#
# ax.set_xlim((-5, kwidth))
# ax.set_xticks([-20, 0, 20])
# ax.set_xticklabels([-20, 0, 20])
#
# COUNTER += 1
#
# ax.set_title(titles[i])
################################################
# Iterate over savefolders
################################################
for i, (savefolder, lag) in enumerate(zip(savefolders, lags)):
# path to simulation files
params.savefolder = os.path.join(os.path.split(params.savefolder)[0],
savefolder)
params.figures_path = os.path.join(params.savefolder, 'figures')
params.spike_output_path = os.path.join(params.savefolder,
'processed_nest_output')
params.networkSimParams['spike_output_path'] = params.spike_output_path
#load spike as database inside function to avoid buggy behaviour
networkSim = CachedNetwork(**params.networkSimParams)
# Get the Compound LFP: LFPsum : data[nchannels, timepoints ]
f = h5py.File(os.path.join(params.savefolder, 'LFPsum.h5'))
data_raw = f['data'].value
srate = f['srate'].value
tvec = np.arange(data_raw.shape[1]) * 1000. / srate
# slice
inds = (tvec < params.tstop) & (tvec >= transient)
data = data_raw[:, inds]
# subtract mean
dataT = data.T - data.mean(axis=1)
data = dataT.T
f.close()
# Get the spikegen LFP:
f = h5py.File(os.path.join('simulation_output_spikegen', 'LFPsum.h5'))
data_sg_raw = f['data'].value
f.close()
#
#
#
#
#########################################################################
## Part B: STA LFP
#########################################################################
#
#titles = ['staLFP(%s)\n(spont.)' % X, 'staLFP(%s)\n(AC. mod.)' % X]
#ax = fig.add_subplot(gs[:len(channels), 5 + i])
#if i == 0:
# phlp.annotate_subplot(ax, ncols=15, nrows=4, letter=alphabet[i+1],
# linear_offset=0.02)
#
#collect the spikes x is the times, y is the id of the cell.
x, y = networkSim.get_xy([0,params.tstop])
#
## Get the spikes for the population of interest given as 'Y'
bins = np.arange(0, params.tstop+2) + 0.5
x0_raw = np.histogram(x[X], bins=bins)[0]
x0 = x0_raw[inds].astype(float)
#
## correlation between firing rate and LFP deviation
## from mean normalized by the number of spikes
#xcorr, vlimround = plotting_correlation(params,
# x0/x0.sum(),
# data*1E3,
# ax, normalize=False,
# #unit='%.3f mV',
# lag=lag,
# scalebar=False,
# color='k',
# title=titles[i],
# )
#
## Create scale bar
#ax.plot([lag, lag],
# [-1500, -1400], lw=2, color='k',
# clip_on=False)
#ax.text(lag*1.08, -1450, '%.1f $\mu$V' % vlimround,
# rotation='vertical', va='center')
#
#
#[Xind] = np.where(np.array(networkSim.X) == X)[0]
#
## create spikegen histogram for population Y
#x0_sg = np.zeros(x0.shape, dtype=float)
#x0_sg[activationtimes[Xind]] += params.N_X[Xind]
#
#
#ax.set_yticklabels([])
#ax.set_xticks([-lag, 0, lag])
#ax.set_xticklabels([-lag, 0, lag])
###########################################################################
# Part C, F: LFP and reconstructed LFP
############################################################################
# create grid_spec
gsb = gridspec.GridSpec(len(channels), 8)
ax = fig.add_subplot(gsb[:, (i*4):(i*4+2)])
phlp.annotate_subplot(ax, ncols=8/2., nrows=4, letter=alphabet[i*3+2],
linear_offset=0.02)
# extract kernels, force negative lags to be zero
kernels = np.zeros((len(params.N_X), 16, kwidth*2))
for j in range(len(params.X)):
kernels[j, :, kwidth:] = data_sg_raw[:, (j+2)*100:kwidth+(j+2)*100]/params.N_X[j]
LFP_reconst_raw = np.zeros(data_raw.shape)
for j, pop in enumerate(params.X):
x0_raw = np.histogram(x[pop], bins=bins)[0].astype(float)
for ch in range(kernels.shape[1]):
LFP_reconst_raw[ch] += np.convolve(x0_raw, kernels[j, ch],
'same')
# slice
LFP_reconst = LFP_reconst_raw[:, inds]
# subtract mean
LFP_reconstT = LFP_reconst.T - LFP_reconst.mean(axis=1)
LFP_reconst = LFP_reconstT.T
vlimround = plot_signal_sum(ax, params,
fname=os.path.join(params.savefolder,
'LFPsum.h5'),
unit='mV', scalebar=True,
T=T, ylim=[-1550, 50],
color='k', label='$real$',
rasterized=False)
plot_signal_sum(ax, params, fname=LFP_reconst_raw,
unit='mV', scaling_factor= 1., scalebar=False,
vlimround=vlimround,
T=T, ylim=[-1550, 50],
color='r', label='$reconstr$',
rasterized=False)
ax.set_title('LFP & population \n rate predictor')
if i > 0:
ax.set_yticklabels([])
###########################################################################
# Part D,G: Correlation coefficient
############################################################################
ax = fig.add_subplot(gsb[:, i*4+2:i*4+3])
phlp.remove_axis_junk(ax)
phlp.annotate_subplot(ax, ncols=8./1, nrows=4, letter=alphabet[i*3+3],
linear_offset=0.02)
cc = np.zeros(len(zvec))
for ch in np.arange(len(zvec)):
cc[ch] = np.corrcoef(data[ch], LFP_reconst[ch])[1, 0]
ax.barh(zvec, cc, height=90, align='center', color='1', linewidth=0.5)
ax.set_ylim([-1550, 50])
ax.set_yticklabels([])
ax.set_yticks(zvec)
ax.set_xlim([0.0, 1.])
ax.set_xticks([0.0, 0.5, 1])
ax.yaxis.tick_left()
ax.set_xlabel('$cc$ (-)', labelpad=0.1)
ax.set_title('corr. \n coef.')
print 'correlation coefficients:'
print cc
###########################################################################
# Part E,H: Power spectra
############################################################################
#compute PSDs ratio between ground truth and estimate
freqs, PSD_data = calc_signal_power(params, fname=data,
transient=transient, Df=None, mlab=True,
NFFT=256, noverlap=128,
window=plt.mlab.window_hanning)
freqs, PSD_LFP_reconst = calc_signal_power(params, fname=LFP_reconst,
transient=transient, Df=None, mlab=True,
NFFT=256, noverlap=128,
window=plt.mlab.window_hanning)
zv = np.r_[params.electrodeParams['z']]
zv = np.r_[zv, zv[-1] + np.diff(zv)[-1]]
inds = freqs >= 1 # frequencies greater than 1 Hz
for j, ch in enumerate(channels):
ax = fig.add_subplot(gsb[j, (i*4+3):(i*4+4)])
if j == 0:
phlp.annotate_subplot(ax, ncols=8./1, nrows=4.5*len(channels),
letter=alphabet[i*3+4], linear_offset=0.02)
ax.set_title('PSD')
phlp.remove_axis_junk(ax)
ax.loglog(freqs[inds], PSD_data[ch, inds], 'k', label='LFP', clip_on=True)
ax.loglog(freqs[inds], PSD_LFP_reconst[ch, inds], 'r', label='predictor', clip_on=True)
ax.set_xlim([4E0,4E2])
ax.set_ylim([1E-8, 1E-4])
ax.tick_params(axis='y', which='major', pad=0)
ax.set_yticks([1E-8,1E-6,1E-4])
ax.yaxis.set_minor_locator(plt.NullLocator())
ax.text(0.8, 0.9, 'ch. %i' % (ch+1),
horizontalalignment='left',
verticalalignment='center',
fontsize=6,
transform=ax.transAxes)
if j == 0:
ax.set_ylabel('(mV$^2$/Hz)', labelpad=0.)
if j > 0:
ax.set_yticklabels([])
if j == len(channels)-1:
ax.set_xlabel(r'$f$ (Hz)', labelpad=0.)
else:
ax.set_xticklabels([])
return fig, PSD_LFP_reconst, PSD_data
#initiate nest simulation with only the point neuron network parameter class
networkParams = point_neuron_network_params()
sli_run(parameters=networkParams,
fname='microcircuit.sli',
verbosity='M_WARNING')
#preprocess the gdf files containing spiking output, voltages, weighted and
#spatial input spikes and currents:
merge_gdf(networkParams,
raw_label=networkParams.spike_detector_label,
file_type='gdf',
fileprefix=params.networkSimParams['label'])
#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 #####################################################
if properrun:
#iterate over each cell type, run single-cell simulations and create
#population object
for i, y in enumerate(params.y):
#create population:
pop = Population(
#parent class parameters
def fig_kernel_lfp_EITN_I(savefolders, params, transient=200, T=[800., 1000.], X='L5E',
lags=[20, 20], channels=[0,3,7,11,13]):
'''
This function calculates the STA of LFP, extracts kernels and recontructs the LFP from kernels.
Arguments
::
transient : the time in milliseconds, after which the analysis should begin
so as to avoid any starting transients
X : id of presynaptic trigger population
'''
# Electrode geometry
zvec = np.r_[params.electrodeParams['z']]
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ana_params.set_PLOS_2column_fig_style(ratio=0.5)
# Start the figure
fig = plt.figure()
fig.subplots_adjust(left=0.06, right=0.95, bottom=0.08, top=0.90, hspace=0.23, wspace=0.55)
# create grid_spec
gs = gridspec.GridSpec(1, 7)
###########################################################################
# spikegen "network" activity
############################################################################
# path to simulation files
params.savefolder = os.path.join(os.path.split(params.savefolder)[0],
'simulation_output_spikegen')
params.figures_path = os.path.join(params.savefolder, 'figures')
params.spike_output_path = os.path.join(params.savefolder,
'processed_nest_output')
params.networkSimParams['spike_output_path'] = params.spike_output_path
# Get the spikegen LFP:
f = h5py.File(os.path.join('simulation_output_spikegen', 'LFPsum.h5'))
srate = f['srate'].value
tvec = np.arange(f['data'].shape[1]) * 1000. / srate
# slice
inds = (tvec < params.tstop) & (tvec >= transient)
data_sg_raw = f['data'].value.astype(float)
data_sg = data_sg_raw[:, inds]
f.close()
# kernel width
kwidth = 20
# create some dummy spike times
activationtimes = np.array([x*100 for x in range(3,11)] + [200])
networkSimSpikegen = CachedNetwork(**params.networkSimParams)
x, y = networkSimSpikegen.get_xy([transient, params.tstop])
###########################################################################
# Part A: spatiotemporal kernels, all presynaptic populations
############################################################################
titles = ['TC',
'L23E/I',
'LFP kernels \n L4E/I',
'L5E/I',
'L6E/I',
]
COUNTER = 0
for i, X__ in enumerate(([['TC']]) + zip(params.X[1::2], params.X[2::2])):
ax = fig.add_subplot(gs[0, i])
if i == 0:
phlp.annotate_subplot(ax, ncols=7, nrows=4, letter=alphabet[0], linear_offset=0.02)
for j, X_ in enumerate(X__):
# create spikegen histogram for population Y
cinds = np.arange(activationtimes[np.arange(-1, 8)][COUNTER]-kwidth,
activationtimes[np.arange(-1, 8)][COUNTER]+kwidth+2)
x0_sg = np.histogram(x[X_], bins=cinds)[0].astype(float)
if X_ == ('TC'):
color='r'
else:
color=('r', 'b')[j]
# plot kernel as correlation of spikegen LFP signal with delta spike train
xcorr, vlimround = plotting_correlation(params,
x0_sg/x0_sg.sum()**2,
data_sg_raw[:, cinds[:-1]]*1E3,
ax, normalize=False,
lag=kwidth,
color=color,
scalebar=False)
if i > 0:
ax.set_yticklabels([])
## Create scale bar
ax.plot([kwidth, kwidth],
[-1500 + j*3*100, -1400 + j*3*100], lw=2, color=color,
clip_on=False)
ax.text(kwidth*1.08, -1450 + j*3*100, '%.1f $\mu$V' % vlimround,
rotation='vertical', va='center')
ax.set_xlim((-5, kwidth))
ax.set_xticks([-20, 0, 20])
ax.set_xticklabels([-20, 0, 20])
COUNTER += 1
ax.set_title(titles[i])
################################################
# Iterate over savefolders
################################################
for i, (savefolder, lag) in enumerate(zip(savefolders, lags)):
# path to simulation files
params.savefolder = os.path.join(os.path.split(params.savefolder)[0],
savefolder)
params.figures_path = os.path.join(params.savefolder, 'figures')
params.spike_output_path = os.path.join(params.savefolder,
'processed_nest_output')
params.networkSimParams['spike_output_path'] = params.spike_output_path
#load spike as database inside function to avoid buggy behaviour
networkSim = CachedNetwork(**params.networkSimParams)
# Get the Compound LFP: LFPsum : data[nchannels, timepoints ]
f = h5py.File(os.path.join(params.savefolder, 'LFPsum.h5'))
data_raw = f['data'].value
srate = f['srate'].value
tvec = np.arange(data_raw.shape[1]) * 1000. / srate
# slice
inds = (tvec < params.tstop) & (tvec >= transient)
data = data_raw[:, inds]
# subtract mean
dataT = data.T - data.mean(axis=1)
data = dataT.T
f.close()
# Get the spikegen LFP:
f = h5py.File(os.path.join('simulation_output_spikegen', 'LFPsum.h5'))
data_sg_raw = f['data'].value
f.close()
########################################################################
# Part B: STA LFP
########################################################################
titles = ['stLFP(%s)\n(spont.)' % X, 'stLFP(%s)\n(AC. mod.)' % X]
ax = fig.add_subplot(gs[0, 5 + i])
if i == 0:
phlp.annotate_subplot(ax, ncols=15, nrows=4, letter=alphabet[i+1],
linear_offset=0.02)
#collect the spikes x is the times, y is the id of the cell.
x, y = networkSim.get_xy([0,params.tstop])
# Get the spikes for the population of interest given as 'Y'
bins = np.arange(0, params.tstop+2) + 0.5
x0_raw = np.histogram(x[X], bins=bins)[0]
x0 = x0_raw[inds].astype(float)
# correlation between firing rate and LFP deviation
# from mean normalized by the number of spikes
xcorr, vlimround = plotting_correlation(params,
x0/x0.sum(),
data*1E3,
ax, normalize=False,
#unit='%.3f mV',
lag=lag,
scalebar=False,
color='k',
title=titles[i],
)
# Create scale bar
ax.plot([lag, lag],
[-1500, -1400], lw=2, color='k',
clip_on=False)
ax.text(lag*1.08, -1450, '%.1f $\mu$V' % vlimround,
rotation='vertical', va='center')
[Xind] = np.where(np.array(networkSim.X) == X)[0]
# create spikegen histogram for population Y
x0_sg = np.zeros(x0.shape, dtype=float)
x0_sg[activationtimes[Xind]] += params.N_X[Xind]
ax.set_yticklabels([])
ax.set_xticks([-lag, 0, lag])
ax.set_xticklabels([-lag, 0, lag])
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)
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],
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
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 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