def VSDI(sheet, folder, stimulus, parameter, num_stim=2, addon=""):
import matplotlib as ml
import quantities as pq
print inspect.stack()[0][3]
print "folder: ", folder
print "sheet: ", sheet
polarity = True # exc
c = 'red'
if "Inh" in sheet:
polarity = False
c = 'blue'
data_store = PickledDataStore(load=True,
parameters=ParameterSet({
'root_directory':
folder,
'store_stimuli':
False
}),
replace=True)
data_store.print_content(full_recordings=False)
segs = sorted(
param_filter_query(data_store, st_name=stimulus,
sheet_name=sheet).get_segments(),
key=lambda x: getattr(
MozaikParametrized.idd(x.annotations['stimulus']), parameter))
spont_segs = sorted(
param_filter_query(data_store, st_name=stimulus,
sheet_name=sheet).get_segments(
null=True), # Init 150ms with no stimulus
# param_filter_query(data_store, sheet_name=sheet, st_direct_stimulation_name="None", st_name='InternalStimulus').get_segments(),
# param_filter_query(data_store, direct_stimulation_name='None', sheet_name=sheet).get_segments(), # 1029ms NoStimulation
key=lambda x: getattr(
MozaikParametrized.idd(x.annotations['stimulus']), parameter))
# print segs
print "spont_trials:", len(spont_segs)
spont_trials = len(spont_segs) / num_stim
print "spont_trials:", spont_trials
trials = len(segs) / num_stim
print "trials:", trials
analog_ids = param_filter_query(
data_store, sheet_name=sheet,
st_name=stimulus).get_segments()[0].get_stored_vm_ids()
if analog_ids == None or len(analog_ids) < 1:
print "No Vm recorded.\n"
return
print "Recorded neurons:", len(analog_ids)
# 900 neurons over 6000 micrometers, 200 micrometers interval
# avg vm
sheet_indexes = data_store.get_sheet_indexes(sheet_name=sheet,
neuron_ids=analog_ids)
positions = data_store.get_neuron_postions()[sheet]
print positions.shape # all 10800
###############################
# # Vm PLOTS
###############################
# segs = spont_segs
# the cortical surface is going to be divided into annuli (beyond the current stimulus size)
# this mean vm composes a plot of each annulus (row) over time
# annulus_radius = 0.3
# start = 1.4
# stop = 3. - annulus_radius
# num = 5 # annuli
annulus_radius = 0.3
start = 0.0
stop = 1.6 - annulus_radius
num = 5 # annuli
# open image
fig = plt.figure(figsize=(8, 8))
gs = gridspec.GridSpec(num, 1, hspace=0.3)
arrival = []
for n, r in enumerate(numpy.linspace(start, stop, num=num)):
radius = [r, r + annulus_radius]
annulus_ids = select_ids_by_position(positions,
sheet_indexes,
radius=radius)
print "annulus: ", radius, "(radii) ", len(annulus_ids), "(#ids)"
# print len(annulus_ids), annulus_ids
trial_avg_prime_response = []
trial_avg_annulus_mean_vm = []
for s in segs:
dist = eval(s.annotations['stimulus'])
if dist['radius'] < 0.1:
continue
print "radius", dist['radius'], "trial", dist['trial']
s.load_full()
# print "s.analogsignalarrays", s.analogsignalarrays # if not pre-loaded, it results empty in loop
# print gs, n
ax = plt.subplot(gs[n])
for a in s.analogsignalarrays:
# print "a.name: ",a.name
if a.name == 'v':
# print "a",a.shape # (10291, 900) (vm instants t, cells)
# annulus population average
# print "annulus_ids",len(annulus_ids)
# print annulus_ids
# for aid in annulus_ids:
# print aid, numpy.nonzero(sheet_indexes == aid)[0][0]
# annulus_vms = numpy.array([a[:,numpy.nonzero(sheet_indexes == aid)[0]] for aid in annulus_ids])
annulus_mean_vm = numpy.array([
a[:, numpy.nonzero(sheet_indexes == aid)[0]]
for aid in annulus_ids
]).mean(axis=0)[0:2000, :]
# print "annulus_vms",annulus_vms.shape
# only annulus ids in the mean
# annulus_mean_vm = numpy.mean( annulus_vms, axis=0)[0:2000,:]
# print "annulus_mean_vm", annulus_mean_vm.shape
trial_avg_annulus_mean_vm.append(annulus_mean_vm)
# print "annulus_mean_vm", annulus_mean_vm
# threshold = annulus_mean_vm.max() - (annulus_mean_vm.max()-annulus_mean_vm.min())/10 # threshold at: 90% of the max-min interval
# prime_response = numpy.argmax(annulus_mean_vm > threshold)
# trial_avg_prime_response.append(prime_response)
plt.axvline(x=numpy.argmax(annulus_mean_vm),
color=c,
alpha=0.5)
ax.plot(annulus_mean_vm, color=c, alpha=0.5)
ax.set_ylim([-75., -50.])
# means
# trial_avg_prime_response = numpy.mean(trial_avg_prime_response)
trial_avg_annulus_mean_vm = numpy.mean(trial_avg_annulus_mean_vm,
axis=0)
from scipy.signal import argrelextrema
peaks = argrelextrema(trial_avg_annulus_mean_vm,
numpy.greater,
order=200)[0]
print peaks
for peak in peaks:
plt.axvline(x=peak, color=c, linewidth=3.) #, linestyle=linestyle)
ax.plot(trial_avg_annulus_mean_vm, color=c, linewidth=3.)
ax.set_ylim([-75., -50.])
fig.add_subplot(ax)
# s.release()
# close image
# title = "propagation velocity {:f} SD {:f} m/s".format((annulus_radius*.001)/(numpy.mean(arrival)*.0001), numpy.std(arrival)) #
plt.xlabel("time (0.1 ms) ") #+title)
plt.savefig(folder + "/VSDI_mean_vm_" + parameter + "_" + str(sheet) +
"_radius" + str(dist['radius']) + "_" + addon + ".svg",
dpi=300,
transparent=True)
plt.close()
gc.collect()
def trial_averaged_LFP_rate(sheet,
folder,
stimulus,
parameter,
start,
end,
xlabel="",
ylabel="",
color="black",
ylim=[0., 100.],
radius=None,
addon=""):
print inspect.stack()[0][3]
print "folder: ", folder
print "sheet: ", sheet
data_store = PickledDataStore(load=True,
parameters=ParameterSet({
'root_directory':
folder,
'store_stimuli':
False
}),
replace=True)
data_store.print_content(full_recordings=False)
neurons = []
neurons = param_filter_query(
data_store, sheet_name=sheet,
st_name=stimulus).get_segments()[0].get_stored_spike_train_ids()
print "Recorded neurons:", len(neurons)
### cascading requirements
if radius:
sheet_ids = data_store.get_sheet_indexes(sheet_name=sheet,
neuron_ids=neurons)
positions = data_store.get_neuron_postions()[sheet]
if radius:
ids1 = select_ids_by_position(positions, sheet_ids, radius=radius)
neurons = data_store.get_sheet_ids(sheet_name=sheet, indexes=ids1)
####
# if orientation:
# NeuronAnnotationsToPerNeuronValues(data_store,ParameterSet({})).analyse()
# l4_or = data_store.get_analysis_result(identifier='PerNeuronValue',value_name='LGNAfferentOrientation', sheet_name=sheet)
# l4_phase = data_store.get_analysis_result(identifier='PerNeuronValue',value_name='LGNAfferentPhase', sheet_name=sheet)
# # print "l4_phase", l4_phase
# neurons = numpy.array([neurons[numpy.argmin([circular_dist(o,numpy.pi/2,numpy.pi) for (o,p) in zip(l4_or[0].get_value_by_id(neurons),l4_phase[0].get_value_by_id(neurons))])] ])
print "Selected neurons:", len(neurons) #, neurons
if len(neurons) < 1:
return
SpikeCount(
param_filter_query(data_store, sheet_name=sheet, st_name=stimulus),
ParameterSet({
'bin_length': 5,
'neurons': list(neurons),
'null': False
})
# ParameterSet({'bin_length':bin, 'neurons':list(neurons), 'null':False})
).analyse()
# datastore.save()
TrialMean(
param_filter_query(data_store,
name='AnalogSignalList',
analysis_algorithm='SpikeCount'),
ParameterSet({
'vm': False,
'cond_exc': False,
'cond_inh': False
})).analyse()
dsvTM = param_filter_query(data_store,
sheet_name=sheet,
st_name=stimulus,
analysis_algorithm='TrialMean')
# dsvTM.print_content(full_recordings=False)
pnvsTM = [dsvTM.get_analysis_result()]
# print pnvsTM
# get stimuli from PerNeuronValues
st = [MozaikParametrized.idd(s.stimulus_id) for s in pnvsTM[-1]]
asl_id = numpy.array([z.get_asl_by_id(neurons) for z in pnvsTM[-1]])
print asl_id.shape
# Example:
# (8, 133, 1029)
# 8 stimuli
# 133 cells
# 1029 bins
dic = colapse_to_dictionary([z.get_asl_by_id(neurons) for z in pnvsTM[-1]],
st, parameter)
for k in dic:
(b, a) = dic[k]
par, val = zip(*sorted(zip(b, numpy.array(a))))
dic[k] = (par, numpy.array(val))
stimuli = dic.values()[0][0]
means = asl_id.mean(axis=1) # mean of
print means.shape
# print "means", means, "stimuli", stimuli
#plot the LFP for each stimulus
for s in range(0, len(means)):
# for each stimulus plot the average conductance per cell over time
matplotlib.rcParams.update({'font.size': 22})
fig, ax = plt.subplots()
ax.plot(range(0, len(means[s])), means[s], color=color, linewidth=3)
# ax.set_ylim([lfp.min(), lfp.max()])
# ax.set_ylim(ylim)
ax.set_ylabel("LFP (uV)")
ax.set_xlabel("Time (us)")
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
# text
plt.tight_layout()
plt.savefig(folder + "/TimecourseLFPrate_" + sheet + "_" + parameter +
"_" + str(s) + "_" + addon + ".svg",
dpi=200,
transparent=True)
fig.clf()
plt.close()
# garbage
gc.collect()
def trial_averaged_tuning_curve_errorbar(sheet,
folder,
stimulus,
parameter,
start,
end,
xlabel="",
ylabel="",
color="black",
percentile=False,
useXlog=False,
useYlog=False,
ylim=[0., 100.],
xlim=False,
opposite=False,
box=None,
radius=None,
addon="",
data=None,
data_curve=True):
print inspect.stack()[0][3]
print "folder: ", folder
print "sheet: ", sheet
data_store = PickledDataStore(load=True,
parameters=ParameterSet({
'root_directory':
folder,
'store_stimuli':
False
}),
replace=True)
data_store.print_content(full_recordings=False)
neurons = []
neurons = param_filter_query(
data_store, sheet_name=sheet,
st_name=stimulus).get_segments()[0].get_stored_spike_train_ids()
print "Recorded neurons:", len(neurons)
if radius:
sheet_ids = data_store.get_sheet_indexes(sheet_name=sheet,
neuron_ids=neurons)
positions = data_store.get_neuron_postions()[sheet]
if radius:
ids1 = select_ids_by_position(positions, sheet_ids, radius=radius)
neurons = data_store.get_sheet_ids(sheet_name=sheet, indexes=ids1)
NeuronAnnotationsToPerNeuronValues(data_store, ParameterSet({})).analyse()
l4_exc_or = data_store.get_analysis_result(
identifier='PerNeuronValue',
value_name='LGNAfferentOrientation',
sheet_name=sheet)[0]
l4_exc_or_many = numpy.array(neurons)[numpy.nonzero(
numpy.array([
circular_dist(l4_exc_or.get_value_by_id(i), 0, numpy.pi)
for i in neurons
]) < .1)[0]]
neurons = list(l4_exc_or_many)
print "Selected neurons:", len(neurons) #, neurons
if len(neurons) < 1:
return
TrialAveragedFiringRate(
param_filter_query(data_store, sheet_name=sheet, st_name=stimulus),
ParameterSet({'neurons': list(neurons)})).analyse()
PlotTuningCurve(
param_filter_query(data_store,
st_name=stimulus,
analysis_algorithm=['TrialAveragedFiringRate']),
ParameterSet({
'polar': False,
'pool': False,
'centered': False,
'percent': False,
'mean': True,
'parameter_name': parameter,
'neurons': list(neurons),
'sheet_name': sheet
}),
fig_param={
'dpi': 200
},
plot_file_name=folder + "/TrialAveragedSensitivityNew_" + stimulus +
"_" + parameter + "_" + str(sheet) + "_" + addon + "_mean.svg"
).plot({
# '*.y_lim':(0,30),
# '*.x_lim':(-10,100),
# '*.x_scale':'log', '*.x_scale_base':10,
'*.fontsize': 17
})
return
def LFP(sheet,
folder,
stimulus,
parameter,
tip=[.0, .0, .0],
sigma=0.300,
ylim=[0., -1.],
addon="",
color='black'):
import matplotlib as ml
import quantities as pq
print inspect.stack()[0][3]
print "folder: ", folder
print "sheet: ", sheet
data_store = PickledDataStore(load=True,
parameters=ParameterSet({
'root_directory':
folder,
'store_stimuli':
False
}),
replace=True)
data_store.print_content(full_recordings=False)
ids = param_filter_query(
data_store, sheet_name=sheet,
st_name=stimulus).get_segments()[0].get_stored_esyn_ids()
if ids == None or len(ids) < 1:
print "No gesyn recorded.\n"
return
print "Recorded gesyn:", len(ids), ids
ids = param_filter_query(
data_store, sheet_name=sheet,
st_name=stimulus).get_segments()[0].get_stored_vm_ids()
if ids == None or len(ids) < 1:
print "No Vm recorded.\n"
return
print "Recorded Vm:", len(ids), ids
NeuronAnnotationsToPerNeuronValues(data_store, ParameterSet({})).analyse()
l4_exc_or = data_store.get_analysis_result(
identifier='PerNeuronValue',
value_name='LGNAfferentOrientation',
sheet_name=sheet)[0]
l4_exc_or_many = numpy.array(ids)[numpy.nonzero(
numpy.array([
circular_dist(l4_exc_or.get_value_by_id(i), 0, numpy.pi)
for i in ids
]) < .1)[0]]
ids = list(l4_exc_or_many)
print "Recorded neurons:", len(ids), ids
# 900 neurons over 6000 micrometers, 200 micrometers interval
sheet_indexes = data_store.get_sheet_indexes(sheet_name=sheet,
neuron_ids=ids)
positions = data_store.get_neuron_postions()[sheet]
print positions.shape # all 10800
# take the positions of the ids
ids_positions = numpy.transpose(positions)[sheet_indexes, :]
print ids_positions.shape
print ids_positions
# Pre-compute distances from the LFP tip
distances = []
for i in range(len(ids)):
distances.append(
numpy.linalg.norm(
numpy.array(ids_positions[i][0]) - numpy.array(tip)))
distances = numpy.array(distances)
print "distances:", len(distances), distances
# ##############################
# LFP
# tip = [[x],[y],[.0]]
# For each recorded cell:
# Gaussianly weight it by its distance from tip
# produce the currents
# Divide the whole by the norm factor (area): 4 * numpy.pi * sigma
# 95% of the LFP signal is a result of all exc and inh cells conductances from 250um radius from the tip of the electrode (Katzner et al. 2009).
# Mostly excitatory neurons are relevant for the LFP (because of their geometry) Bartos
# Therefore we include all recorded cells but account for the distance-dependent contribution weighting currents /r^2
# We assume that the electrode has been placed in the cortical coordinates <tip>
# Given that the current V1 orientation map has a pixel for each 100 um, a reasonable way to look at a neighborhood is in a radius of 300 um
print "LFP electrode tip location (x,y) in degrees:", tip
# Gather vm and conductances
segs = sorted(
param_filter_query(data_store, st_name=stimulus,
sheet_name=sheet).get_segments(),
key=lambda x: getattr(
MozaikParametrized.idd(x.annotations['stimulus']), parameter))
ticks = set([])
for x in segs:
ticks.add(
getattr(MozaikParametrized.idd(x.annotations['stimulus']),
parameter))
ticks = sorted(ticks)
num_ticks = len(ticks)
print ticks
trials = len(segs) / num_ticks
print "trials:", trials
pop_vm = []
pop_gsyn_e = []
pop_gsyn_i = []
for n, idd in enumerate(ids):
print "idd", idd
full_vm = [s.get_vm(idd) for s in segs] # all segments
full_gsyn_es = [s.get_esyn(idd) for s in segs]
full_gsyn_is = [s.get_isyn(idd) for s in segs]
print "len full_gsyn_e", len(
full_gsyn_es) # segments = stimuli * trials
print "shape gsyn_e[0]", full_gsyn_es[0].shape # stimulus lenght
# mean input over trials
mean_full_vm = numpy.zeros((num_ticks, full_vm[0].shape[0])) # init
mean_full_gsyn_e = numpy.zeros(
(num_ticks, full_gsyn_es[0].shape[0])) # init
mean_full_gsyn_i = numpy.zeros((num_ticks, full_gsyn_es[0].shape[0]))
# print "shape mean_full_gsyn_e/i", mean_full_gsyn_e.shape
sampling_period = full_gsyn_es[0].sampling_period
t_stop = float(full_gsyn_es[0].t_stop - sampling_period) # 200.0
t_start = float(full_gsyn_es[0].t_start)
time_axis = numpy.arange(0, len(full_gsyn_es[0]), 1) / float(
len(full_gsyn_es[0])) * abs(t_start - t_stop) + t_start
# sum by size
t = 0
for v, e, i in zip(full_vm, full_gsyn_es, full_gsyn_is):
s = int(t / trials)
v = v.rescale(mozaik.tools.units.mV)
e = e.rescale(
mozaik.tools.units.nS) # NEST is in nS, PyNN is in uS
i = i.rescale(
mozaik.tools.units.nS) # NEST is in nS, PyNN is in uS
mean_full_vm[s] = mean_full_vm[s] + numpy.array(v.tolist())
mean_full_gsyn_e[s] = mean_full_gsyn_e[s] + numpy.array(e.tolist())
mean_full_gsyn_i[s] = mean_full_gsyn_i[s] + numpy.array(i.tolist())
t = t + 1
# average by trials
for st in range(num_ticks):
mean_full_vm[st] = mean_full_vm[st] / trials
mean_full_gsyn_e[st] = mean_full_gsyn_e[st] / trials
mean_full_gsyn_i[st] = mean_full_gsyn_i[st] / trials
pop_vm.append(mean_full_vm)
pop_gsyn_e.append(mean_full_gsyn_e)
pop_gsyn_i.append(mean_full_gsyn_i)
pop_v = numpy.array(pop_vm)
pop_e = numpy.array(pop_gsyn_e)
pop_i = numpy.array(pop_gsyn_i)
# Produce the current for each cell for this time interval, with the Ohm law:
# I = ge(V-Ee) + gi(V+Ei)
# where
# Ee is the equilibrium for exc, which is 0.0
# Ei is the equilibrium for inh, which is -80.0
i = pop_e * (pop_v - 0.0) + pop_i * (pop_v - 80.0)
# i = pop_e*(pop_v-0.0) + 0.3*pop_i*(pop_v-80.0)
# i = pop_e*(pop_v-0.0) # only exc
# the LFP is the result of cells' currents divided by the distance
sum_i = numpy.sum(i, axis=0)
lfp = sum_i / (4 * numpy.pi * sigma) #
lfp /= 1000. # from milli to micro
print "LFP:", lfp.shape, lfp.mean(), lfp.min(), lfp.max()
# print lfp
# lfp = np.convolve(lfp, np.ones((10,))/10, mode='valid') # moving avg or running mean implemented as a convolution over steps of 10, divided by 10
# lfp = np.convolve(lfp, np.ones((10,))/10, mode='valid') # moving avg or running mean implemented as a convolution over steps of 10, divided by 10
#plot the LFP for each stimulus
for s in range(num_ticks):
# for each stimulus plot the average conductance per cell over time
matplotlib.rcParams.update({'font.size': 22})
fig, ax = plt.subplots()
ax.plot(range(0, len(lfp[s])), lfp[s], color=color, linewidth=3)
# ax.set_ylim([lfp.min(), lfp.max()])
ax.set_ylim(ylim)
ax.set_ylabel("LFP (uV)")
ax.set_xlabel("Time (us)")
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.xaxis.set_ticks(ticks, ticks)
ax.yaxis.set_ticks_position('left')
# text
plt.tight_layout()
plt.savefig(folder + "/TimecourseLFP_" + sheet + "_" + parameter +
"_" + str(ticks[s]) + "_" + addon + ".svg",
dpi=200,
transparent=True)
fig.clf()
plt.close()
# garbage
gc.collect()
def trial_averaged_raster(sheet,
folder,
stimulus,
parameter,
opposite=False,
box=None,
radius=None,
addon=""):
print inspect.stack()[0][3]
print "folder: ", folder
print "sheet: ", sheet
data_store = PickledDataStore(load=True,
parameters=ParameterSet({
'root_directory':
folder,
'store_stimuli':
False
}),
replace=True)
data_store.print_content(full_recordings=False)
spike_ids = param_filter_query(
data_store,
sheet_name=sheet).get_segments()[0].get_stored_spike_train_ids()
if spike_ids == None:
print "No spikes recorded.\n"
return
print "Recorded neurons:", len(spike_ids)
if sheet == 'V1_Exc_L4' or sheet == 'V1_Inh_L4':
NeuronAnnotationsToPerNeuronValues(data_store,
ParameterSet({})).analyse()
l4_exc_or = data_store.get_analysis_result(
identifier='PerNeuronValue',
value_name='LGNAfferentOrientation',
sheet_name=sheet)[0]
if opposite:
addon = addon + "_opposite"
l4_exc_or_many = numpy.array(spike_ids)[numpy.nonzero(
numpy.array([
circular_dist(l4_exc_or.get_value_by_id(i), numpy.pi /
2, numpy.pi) for i in spike_ids
]) < .1)[0]]
else:
addon = addon + "_same"
l4_exc_or_many = numpy.array(spike_ids)[numpy.nonzero(
numpy.array([
circular_dist(l4_exc_or.get_value_by_id(i), 0, numpy.pi)
for i in spike_ids
]) < .1)[0]]
spike_ids = list(l4_exc_or_many)
if radius or box:
sheet_ids = data_store.get_sheet_indexes(sheet_name=sheet,
neuron_ids=spike_ids)
positions = data_store.get_neuron_postions()[sheet]
if box:
ids1 = select_ids_by_position(positions, sheet_ids, box=box)
if radius:
ids1 = select_ids_by_position(positions, sheet_ids, radius=radius)
spike_ids = data_store.get_sheet_ids(sheet_name=sheet, indexes=ids1)
print "Selected neurons:", len(spike_ids)
if len(spike_ids) < 1:
return
dsv = param_filter_query(data_store, sheet_name=sheet, st_name=stimulus)
dist = box if not radius else radius
# Raster + Histogram
RasterPlot(dsv,
ParameterSet({
'sheet_name': sheet,
'neurons': list(spike_ids),
'trial_averaged_histogram': True,
'spontaneous': True
}),
fig_param={
'dpi': 100,
'figsize': (100, 50)
},
plot_file_name=folder + "/HistRaster_" + parameter + "_" +
str(sheet) + "_radius" + str(dist) + "_" + addon + ".svg").plot(
{'SpikeRasterPlot.group_trials': True})
def trial_averaged_Vm(sheet,
folder,
stimulus,
parameter,
opposite=False,
box=None,
radius=None,
addon=""):
print inspect.stack()[0][3]
print "folder: ", folder
print "sheet: ", sheet
data_store = PickledDataStore(load=True,
parameters=ParameterSet({
'root_directory':
folder,
'store_stimuli':
False
}),
replace=True)
data_store.print_content(full_recordings=False)
analog_ids = param_filter_query(
data_store, sheet_name=sheet).get_segments()[0].get_stored_vm_ids()
if analog_ids == None:
print "No Vm recorded.\n"
return
print "Recorded neurons:", len(analog_ids)
if sheet == 'V1_Exc_L4' or sheet == 'V1_Inh_L4':
NeuronAnnotationsToPerNeuronValues(data_store,
ParameterSet({})).analyse()
l4_exc_or = data_store.get_analysis_result(
identifier='PerNeuronValue',
value_name='LGNAfferentOrientation',
sheet_name=sheet)[0]
if opposite:
addon = addon + "_opposite"
l4_exc_or_many = numpy.array(analog_ids)[numpy.nonzero(
numpy.array([
circular_dist(l4_exc_or.get_value_by_id(i), numpy.pi /
2, numpy.pi) for i in analog_ids
]) < .1)[0]]
else:
addon = addon + "_same"
l4_exc_or_many = numpy.array(analog_ids)[numpy.nonzero(
numpy.array([
circular_dist(l4_exc_or.get_value_by_id(i), 0, numpy.pi)
for i in analog_ids
]) < .1)[0]]
analog_ids = list(l4_exc_or_many)
if radius or box:
sheet_ids = data_store.get_sheet_indexes(sheet_name=sheet,
neuron_ids=analog_ids)
positions = data_store.get_neuron_postions()[sheet]
if box:
ids1 = select_ids_by_position(positions, sheet_ids, box=box)
if radius:
ids1 = select_ids_by_position(positions, sheet_ids, radius=radius)
analog_ids = data_store.get_sheet_ids(sheet_name=sheet, indexes=ids1)
print "Selected neurons:", len(analog_ids)
if len(analog_ids) < 1:
return
dsv = param_filter_query(data_store, sheet_name=sheet, st_name=stimulus)
dist = box if not radius else radius
for n in analog_ids:
VmPlot(
dsv,
ParameterSet({
'neuron': n,
'sheet_name': sheet,
'spontaneous': True,
}),
fig_param={
'dpi': 300,
'figsize': (40, 5)
},
# plot_file_name=folder+"/Vm_"+parameter+"_"+str(sheet)+"_"+str(dist)+"_"+str(n)+"_"+addon+".png"
plot_file_name=folder + "/Vm_" + parameter + "_" + str(sheet) +
"_radius" + str(dist) + "_" + str(n) + "_" + addon + ".svg"
).plot({
# '*.y_lim':(0,60),
# '*.x_scale':'log', '*.x_scale_base':2,
# '*.y_ticks':[5, 10, 25, 50, 60],
# # '*.y_scale':'linear',
# '*.y_scale':'log', '*.y_scale_base':2,
# '*.fontsize':24
})
def perform_comparison_size_tuning(sheet,
reference_position,
step,
sizes,
folder_full,
folder_inactive,
reverse=False,
Ismaller=[2, 3],
Iequal=[4, 5],
Ilarger=[6, 8],
box=[],
csvfile=None):
print folder_full
data_store_full = PickledDataStore(load=True,
parameters=ParameterSet({
'root_directory':
folder_full,
'store_stimuli':
False
}),
replace=True)
data_store_full.print_content(full_recordings=False)
print folder_inactive
data_store_inac = PickledDataStore(load=True,
parameters=ParameterSet({
'root_directory':
folder_inactive,
'store_stimuli':
False
}),
replace=True)
data_store_inac.print_content(full_recordings=False)
print "Checking data..."
# Full
dsv1 = queries.param_filter_query(data_store_full,
identifier='PerNeuronValue',
sheet_name=sheet)
# dsv1.print_content(full_recordings=False)
pnvs1 = [dsv1.get_analysis_result()]
# get stimuli
st1 = [MozaikParametrized.idd(s.stimulus_id) for s in pnvs1[-1]]
# print st1
# Inactivated
dsv2 = queries.param_filter_query(data_store_inac,
identifier='PerNeuronValue',
sheet_name=sheet)
pnvs2 = [dsv2.get_analysis_result()]
# get stimuli
st2 = [MozaikParametrized.idd(s.stimulus_id) for s in pnvs2[-1]]
# rings analysis
neurons_full = []
neurons_inac = []
rowplots = 0
max_size = 0.6
# GET RECORDINGS BY POSITION (either step or box. In case of using box, inefficiently repetition of box-ing step times!)
slice_ranges = numpy.arange(step, max_size + step, step)
print "slice_ranges:", slice_ranges
for col, cur_range in enumerate(slice_ranges):
radius = [cur_range - step, cur_range]
print col
# get the list of all recorded neurons in X_ON
# Full
spike_ids1 = param_filter_query(
data_store_full,
sheet_name=sheet).get_segments()[0].get_stored_spike_train_ids()
positions1 = data_store_full.get_neuron_postions()[sheet]
# print numpy.min(positions1), numpy.max(positions1)
sheet_ids1 = data_store_full.get_sheet_indexes(sheet_name=sheet,
neuron_ids=spike_ids1)
radius_ids1 = select_ids_by_position(reference_position, radius,
sheet_ids1, positions1, reverse,
box)
neurons1 = data_store_full.get_sheet_ids(sheet_name=sheet,
indexes=radius_ids1)
# Inactivated
spike_ids2 = param_filter_query(
data_store_inac,
sheet_name=sheet).get_segments()[0].get_stored_spike_train_ids()
positions2 = data_store_inac.get_neuron_postions()[sheet]
sheet_ids2 = data_store_inac.get_sheet_indexes(sheet_name=sheet,
neuron_ids=spike_ids2)
radius_ids2 = select_ids_by_position(reference_position, radius,
sheet_ids2, positions2, reverse,
box)
neurons2 = data_store_inac.get_sheet_ids(sheet_name=sheet,
indexes=radius_ids2)
print neurons1
print neurons2
if not set(neurons1) == set(neurons2):
neurons1 = numpy.intersect1d(neurons1, neurons2)
neurons2 = neurons1
if len(neurons1) > rowplots:
rowplots = len(neurons1)
neurons_full.append(neurons1)
neurons_inac.append(neurons2)
print "radius_ids", radius_ids2
print "neurons_full:", len(neurons_full[col]), neurons_full[col]
print "neurons_inac:", len(neurons_inac[col]), neurons_inac[col]
assert len(neurons_full[col]
) > 0, "ERROR: the number of recorded neurons is 0"
# subplot figure creation
plotOnlyPop = False
print 'rowplots', rowplots
print "Starting plotting ..."
print "slice_ranges:", len(slice_ranges), slice_ranges
if len(slice_ranges) > 1:
fig, axes = plt.subplots(nrows=len(slice_ranges),
ncols=rowplots + 1,
figsize=(3 * rowplots, 3 * len(slice_ranges)),
sharey=False)
else:
fig, axes = plt.subplots(nrows=2, ncols=2, sharey=False)
plotOnlyPop = True
print axes.shape
p_significance = .02
for col, cur_range in enumerate(slice_ranges):
radius = [cur_range - step, cur_range]
print col
interval = str(radius[0]) + " - " + str(radius[1]) + " deg radius"
print interval
axes[col, 0].set_ylabel(interval + "\n\nResponse change (%)")
print "range:", col
if len(neurons_full[col]) < 1:
continue
tc_dict1 = []
tc_dict2 = []
# Full
# group values
dic = colapse_to_dictionary(
[z.get_value_by_id(neurons_full[col]) for z in pnvs1[-1]], st1,
'radius')
for k in dic:
(b, a) = dic[k]
par, val = zip(*sorted(zip(b, numpy.array(a))))
dic[k] = (par, numpy.array(val))
tc_dict1.append(dic)
# Inactivated
# group values
dic = colapse_to_dictionary(
[z.get_value_by_id(neurons_inac[col]) for z in pnvs2[-1]], st2,
'radius')
for k in dic:
(b, a) = dic[k]
par, val = zip(*sorted(zip(b, numpy.array(a))))
dic[k] = (par, numpy.array(val))
tc_dict2.append(dic)
print "(stimulus conditions, cells):", tc_dict1[0].values()[0][
1].shape # ex. (10, 32) firing rate for each stimulus condition (10) and each cell (32)
# Population histogram
diff_full_inac = []
sem_full_inac = []
num_cells = tc_dict1[0].values()[0][1].shape[1]
smaller_pvalue = 0.
equal_pvalue = 0.
larger_pvalue = 0.
# 1. SELECT ONLY CHANGING UNITS
all_open_values = tc_dict2[0].values()[0][1]
all_closed_values = tc_dict1[0].values()[0][1]
# 1.1 Search for the units that are NOT changing (within a certain absolute tolerance)
unchanged_units = numpy.isclose(all_closed_values,
all_open_values,
rtol=0.,
atol=4.)
# print unchanged_units.shape
# 1.2 Reverse them into those that are changing
changed_units = numpy.invert(unchanged_units)
# print numpy.nonzero(changed_units)
# 1.3 Get the indexes of all units that are changing
changing_idxs = []
for i in numpy.nonzero(changed_units)[0]:
for j in numpy.nonzero(changed_units)[1]:
if j not in changing_idxs:
changing_idxs.append(j)
# print sorted(changing_idxs)
# 1.4 Get the changing units
open_values = [x[changing_idxs] for x in all_open_values]
open_values = numpy.array(open_values)
closed_values = [x[changing_idxs] for x in all_closed_values]
closed_values = numpy.array(closed_values)
print "chosen open units:", open_values.shape
print "chosen closed units:", closed_values.shape
num_cells = closed_values.shape[1]
# 2. AUTOMATIC SEARCH FOR INTERVALS
# peak = max(numpy.argmax(closed_values, axis=0 ))
peaks = numpy.argmax(closed_values, axis=0)
# peak = int( numpy.argmax( closed_values ) / closed_values.shape[1] ) # the returned single value is from the flattened array
# print "numpy.argmax( closed_values ):", numpy.argmax( closed_values )
print "peaks:", peaks
# minimum = int( numpy.argmin( closed_values ) / closed_values.shape[1] )
# minimum = min(numpy.argmin(closed_values, axis=0 ))
minimums = numpy.argmin(
closed_values,
axis=0) + 1 # +N to get the response out of the smallest
# print "numpy.argmin( closed_values ):", numpy.argmin( closed_values )
print "minimums:", minimums
# -------------------------------------
# DIFFERENCE BETWEEN INACTIVATED AND CONTROL
# We want to have a summary measure of the population of cells with and without inactivation.
# Our null-hypothesis is that the inactivation does not change the activity of cells.
# A different result will tell us that the inactivation DOES something.
# Therefore our null-hypothesis is the result obtained in the intact system.
# Procedure:
# We have several stimulus sizes
# We want to group them in three: smaller than optimal, optimal, larger than optimal
# We do the mean response for each cell for the grouped stimuli
# i.e. sum the responses for each cell across stimuli in the group, divided by the number of stimuli in the group
# We repeat for each group
# average of all trial-averaged response for each cell for grouped stimulus size
# we want the difference / normalized by the highest value * expressed as percentage
# print num_cells
# print "inac",numpy.sum(tc_dict2[0].values()[0][1][2:3], axis=0)
# print "full",numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0)
# print "diff",(numpy.sum(tc_dict2[0].values()[0][1][2:3], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0))
# print "diff_norm",((numpy.sum(tc_dict2[0].values()[0][1][2:3], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0)) / (numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0)))
# print "diff_norm_perc",((numpy.sum(tc_dict2[0].values()[0][1][2:3], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0)) / (numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0))) * 100
# USING PROVIDED INTERVALS
# diff_smaller = ((numpy.sum(open_values[Ismaller[0]:Ismaller[1]], axis=0) - numpy.sum(closed_values[Ismaller[0]:Ismaller[1]], axis=0)) / numpy.sum(closed_values[Ismaller[0]:Ismaller[1]], axis=0)) * 100
# diff_equal = ((numpy.sum(open_values[Iequal[0]:Iequal[1]], axis=0) - numpy.sum(closed_values[Iequal[0]:Iequal[1]], axis=0)) / numpy.sum(closed_values[Iequal[0]:Iequal[1]], axis=0)) * 100
# diff_larger = ((numpy.sum(open_values[Ilarger[0]:Ilarger[1]], axis=0) - numpy.sum(closed_values[Ilarger[0]:Ilarger[1]], axis=0)) / numpy.sum(closed_values[Ilarger[0]:Ilarger[1]], axis=0)) * 100
# USING AUTOMATIC SEARCH
# print "open"
# print open_values[minimums]
# print "closed"
# print closed_values[minimums]
# print open_values[peaks]
# print closed_values[peaks]
diff_smaller = ((numpy.sum(open_values[minimums], axis=0) -
numpy.sum(closed_values[minimums], axis=0)) /
numpy.sum(closed_values[minimums], axis=0)) * 100
diff_equal = ((numpy.sum(open_values[peaks], axis=0) -
numpy.sum(closed_values[peaks], axis=0)) /
numpy.sum(closed_values[peaks], axis=0)) * 100
diff_larger = (
(numpy.sum(open_values[Ilarger[0]:Ilarger[1]], axis=0) -
numpy.sum(closed_values[Ilarger[0]:Ilarger[1]], axis=0)) /
numpy.sum(closed_values[Ilarger[0]:Ilarger[1]], axis=0)) * 100
# print "diff_smaller", diff_smaller
# print "diff_equal", diff_smaller
# print "diff_larger", diff_smaller
# average of all cells
smaller = sum(diff_smaller) / num_cells
equal = sum(diff_equal) / num_cells
larger = sum(diff_larger) / num_cells
print "smaller", smaller
print "equal", equal
print "larger", larger
if csvfile:
csvfile.write("(" + str(smaller) + ", " + str(equal) + ", " +
str(larger) + "), ")
# 0/0
# Check using scipy
# and we want to compare the responses of full and inactivated
# smaller, smaller_pvalue = scipy.stats.ttest_rel( numpy.sum(tc_dict2[0].values()[0][1][0:3], axis=0)/3, numpy.sum(tc_dict1[0].values()[0][1][0:3], axis=0)/3 )
# equal, equal_pvalue = scipy.stats.ttest_rel( numpy.sum(tc_dict2[0].values()[0][1][3:5], axis=0)/2, numpy.sum(tc_dict1[0].values()[0][1][3:5], axis=0)/2 )
# larger, larger_pvalue = scipy.stats.ttest_rel( numpy.sum(tc_dict2[0].values()[0][1][5:], axis=0)/5, numpy.sum(tc_dict1[0].values()[0][1][5:], axis=0)/5 )
# print "smaller, smaller_pvalue:", smaller, smaller_pvalue
# print "equal, equal_pvalue:", equal, equal_pvalue
# print "larger, larger_pvalue:", larger, larger_pvalue
diff_full_inac.append(smaller)
diff_full_inac.append(equal)
diff_full_inac.append(larger)
# -------------------------------------
# Standard Error Mean calculated on the full sequence
sem_full_inac.append(scipy.stats.sem(diff_smaller))
sem_full_inac.append(scipy.stats.sem(diff_equal))
sem_full_inac.append(scipy.stats.sem(diff_larger))
# print diff_full_inac
# print sem_full_inac
barlist = axes[col, 0].bar([0.5, 1.5, 2.5],
diff_full_inac,
yerr=sem_full_inac,
width=0.8)
axes[col, 0].plot([0, 4], [0, 0], 'k-') # horizontal 0 line
for ba in barlist:
ba.set_color('white')
if smaller_pvalue < p_significance:
barlist[0].set_color('brown')
if equal_pvalue < p_significance:
barlist[1].set_color('darkgreen')
if larger_pvalue < p_significance:
barlist[2].set_color('blue')
# Plotting tuning curves
x_full = tc_dict1[0].values()[0][0]
x_inac = tc_dict2[0].values()[0][0]
# each cell couple
axes[col, 1].set_ylabel("Response (spikes/sec)", fontsize=10)
for j, nid in enumerate(neurons_full[col][changing_idxs]):
# print col,j,nid
if len(neurons_full[col][changing_idxs]
) > 1: # case with just one neuron in the group
y_full = closed_values[:, j]
y_inac = open_values[:, j]
else:
y_full = closed_values
y_inac = open_values
if not plotOnlyPop:
axes[col, j + 1].plot(x_full, y_full, linewidth=2, color='b')
axes[col, j + 1].plot(x_inac, y_inac, linewidth=2, color='r')
axes[col, j + 1].set_title(str(nid), fontsize=10)
axes[col, j + 1].set_xscale("log")
fig.subplots_adjust(hspace=0.4)
# fig.suptitle("All recorded cells grouped by circular distance", size='xx-large')
fig.text(0.5, 0.04, 'cells', ha='center', va='center')
fig.text(0.06,
0.5,
'ranges',
ha='center',
va='center',
rotation='vertical')
for ax in axes.flatten():
ax.set_ylim([0, 60])
ax.set_xticks(sizes)
ax.set_xticklabels([0.1, '', '', '', '', 1, '', 2, 4, 6])
# ax.set_xticklabels([0.1, '', '', '', '', '', '', '', '', '', '', 1, '', '', 2, '', '', '', 4, '', 6])
for col, _ in enumerate(slice_ranges):
# axes[col,0].set_ylim([-.8,.8])
axes[col, 0].set_ylim([-60, 60])
axes[col, 0].set_yticks([-60, -40, -20, 0., 20, 40, 60])
axes[col, 0].set_yticklabels([-60, -40, -20, 0, 20, 40, 60])
axes[col, 0].set_xlim([0, 4])
axes[col, 0].set_xticks([.9, 1.9, 2.9])
axes[col, 0].set_xticklabels(['small', 'equal', 'larger'])
axes[col, 0].spines['right'].set_visible(False)
axes[col, 0].spines['top'].set_visible(False)
axes[col, 0].spines['bottom'].set_visible(False)
# plt.show()
plt.savefig(folder_inactive + "/TrialAveragedSizeTuningComparison_" +
sheet + "_step" + str(step) + "_box" + str(box) + ".png",
dpi=100)
# plt.savefig( folder_full+"/TrialAveragedSizeTuningComparison_"+sheet+"_"+interval+".png", dpi=100 )
fig.clf()
plt.close()
# garbage
gc.collect()
def perform_comparison_size_tuning( sheet, reference_position, step, sizes, folder_full, folder_inactive, reverse=False, Ssmaller=3, Sequal=4, SequalStop=5, Slarger=6, box=[] ):
print folder_full
data_store_full = PickledDataStore(load=True, parameters=ParameterSet({'root_directory':folder_full, 'store_stimuli' : False}),replace=True)
data_store_full.print_content(full_recordings=False)
print folder_inactive
data_store_inac = PickledDataStore(load=True, parameters=ParameterSet({'root_directory':folder_inactive, 'store_stimuli' : False}),replace=True)
data_store_inac.print_content(full_recordings=False)
print "Checking data..."
# Full
dsv1 = queries.param_filter_query( data_store_full, identifier='PerNeuronValue', sheet_name=sheet )
# dsv1.print_content(full_recordings=False)
pnvs1 = [ dsv1.get_analysis_result() ]
# get stimuli
st1 = [MozaikParametrized.idd(s.stimulus_id) for s in pnvs1[-1]]
# print st1
# Inactivated
dsv2 = queries.param_filter_query( data_store_inac, identifier='PerNeuronValue', sheet_name=sheet )
pnvs2 = [ dsv2.get_analysis_result() ]
# get stimuli
st2 = [MozaikParametrized.idd(s.stimulus_id) for s in pnvs2[-1]]
# rings analysis
neurons_full = []
neurons_inac = []
rowplots = 0
max_size = 0.6
slice_ranges = numpy.arange(step, max_size+step, step)
for col,cur_range in enumerate(slice_ranges):
radius = [cur_range-step,cur_range]
print col
# get the list of all recorded neurons in X_ON
# Full
spike_ids1 = param_filter_query(data_store_full, sheet_name=sheet).get_segments()[0].get_stored_spike_train_ids()
positions1 = data_store_full.get_neuron_postions()[sheet]
# print numpy.min(positions1), numpy.max(positions1)
sheet_ids1 = data_store_full.get_sheet_indexes(sheet_name=sheet,neuron_ids=spike_ids1)
radius_ids1 = select_ids_by_position(reference_position, radius, sheet_ids1, positions1, reverse, box)
# 0/0
neurons1 = data_store_full.get_sheet_ids(sheet_name=sheet, indexes=radius_ids1)
if len(neurons1) > rowplots:
rowplots = len(neurons1)
neurons_full.append(neurons1)
# Inactivated
spike_ids2 = param_filter_query(data_store_inac, sheet_name=sheet).get_segments()[0].get_stored_spike_train_ids()
positions2 = data_store_inac.get_neuron_postions()[sheet]
sheet_ids2 = data_store_inac.get_sheet_indexes(sheet_name=sheet,neuron_ids=spike_ids2)
radius_ids2 = select_ids_by_position(reference_position, radius, sheet_ids2, positions2, reverse, box)
neurons2 = data_store_inac.get_sheet_ids(sheet_name=sheet, indexes=radius_ids2)
neurons_inac.append(neurons2)
print "radius_ids", radius_ids2
print "neurons_full", neurons_full
print "neurons_inac", neurons_inac
assert len(neurons_full[col]) == len(neurons_inac[col]) , "ERROR: the number of recorded neurons is different"
assert set(neurons_full[col]) == set(neurons_inac[col]) , "ERROR: the neurons in the two arrays are not the same"
# to analyse old simulation it is necessary to choose corresponding ids,
# do it by hand, running this script several times and noting them down here:
# neurons_full = [numpy.array([2912, 3205, 1867, 2731, 2248])]
# neurons_inac = [numpy.array([2912, 3205, 1867, 2731, 2248])]
# neurons_full =[numpy.array([10921, 10024, 13851, 9855, 11648, 13277])]
# neurons_inac =[numpy.array([10921, 10024, 13851, 9855, 11648, 13277])]
# subplot figure creation
print 'rowplots', rowplots
print "Starting plotting ..."
print len(slice_ranges), slice_ranges
fig, axes = plt.subplots(nrows=len(slice_ranges), ncols=rowplots+1, figsize=(3*rowplots, 3*len(slice_ranges)), sharey=False)
# fig, axes = plt.subplots(nrows=2, ncols=rowplots+1, figsize=(3*rowplots, 3*len(slice_ranges)), sharey=False)
print axes.shape
p_significance = .02
for col,cur_range in enumerate(slice_ranges):
radius = [cur_range-step,cur_range]
print col
interval = str(radius[0]) +" - "+ str(radius[1]) +" deg radius"
print interval
axes[col,0].set_ylabel(interval+"\n\nResponse change (%)")
print "range:",col
if len(neurons_full[col]) < 1:
continue
print "neurons_full:", len(neurons_full[col]), neurons_full[col]
print "neurons_inac:", len(neurons_inac[col]), neurons_inac[col]
tc_dict1 = []
tc_dict2 = []
# Full
# group values
dic = colapse_to_dictionary([z.get_value_by_id(neurons_full[col]) for z in pnvs1[-1]], st1, 'radius')
for k in dic:
(b, a) = dic[k]
par, val = zip( *sorted( zip(b, numpy.array(a)) ) )
dic[k] = (par,numpy.array(val))
tc_dict1.append(dic)
# Inactivated
# group values
dic = colapse_to_dictionary([z.get_value_by_id(neurons_inac[col]) for z in pnvs2[-1]], st2, 'radius')
for k in dic:
(b, a) = dic[k]
par, val = zip( *sorted( zip(b, numpy.array(a)) ) )
dic[k] = (par,numpy.array(val))
tc_dict2.append(dic)
# Plotting tuning curves
x_full = tc_dict1[0].values()[0][0]
x_inac = tc_dict2[0].values()[0][0]
# each cell couple
print "(stimulus conditions, cells):", tc_dict1[0].values()[0][1].shape # ex. (10, 32) firing rate for each stimulus condition (10) and each cell (32)
axes[col,1].set_ylabel("Response (spikes/sec)", fontsize=10)
for j,nid in enumerate(neurons_full[col]):
# print col,j,nid
if len(neurons_full[col])>1: # case with just one neuron in the group
y_full = tc_dict1[0].values()[0][1][:,j]
y_inac = tc_dict2[0].values()[0][1][:,j]
else:
y_full = tc_dict1[0].values()[0][1]
y_inac = tc_dict2[0].values()[0][1]
axes[col,j+1].plot(x_full, y_full, linewidth=2, color='b')
axes[col,j+1].plot(x_inac, y_inac, linewidth=2, color='r')
axes[col,j+1].set_title(str(nid), fontsize=10)
axes[col,j+1].set_xscale("log")
# Population histogram
diff_full_inac = []
sem_full_inac = []
num_cells = tc_dict1[0].values()[0][1].shape[1]
smaller_pvalue = 0.
equal_pvalue = 0.
larger_pvalue = 0.
# -------------------------------------
# NON-PARAMETRIC TWO-TAILED TEST ON THE DIFFERENCE BETWEEN INACTIVATED AND CONTROL
# We want to have a summary measure of the population of cells with and without inactivation.
# Our null-hypothesis is that the inactivation does not change the activity of cells.
# A different result will tell us that the inactivation DOES something.
# Therefore our null-hypothesis is the result obtained in the intact system.
# Procedure:
# We have several stimulus sizes
# We want to group them in three: smaller than optimal, optimal, larger than optimal
# We do the mean response for each cell for the grouped stimuli
# i.e. sum the responses for each cell across stimuli in the group, divided by the number of stimuli in the group
# We repeat for each group
# average of all trial-averaged response for each cell for grouped stimulus size
# we want the difference / normalized by the highest value * expressed as percentage
# print num_cells
# print "inac",numpy.sum(tc_dict2[0].values()[0][1][2:3], axis=0)
# print "full",numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0)
# print "diff",(numpy.sum(tc_dict2[0].values()[0][1][2:3], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0))
# print "diff_norm",((numpy.sum(tc_dict2[0].values()[0][1][2:3], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0)) / (numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0)))
# print "diff_norm_perc",((numpy.sum(tc_dict2[0].values()[0][1][2:3], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0)) / (numpy.sum(tc_dict1[0].values()[0][1][2:3], axis=0))) * 100
# diff_smaller = ((numpy.sum(tc_dict2[0].values()[0][1][1:3], axis=0)/2 - numpy.sum(tc_dict1[0].values()[0][1][1:3], axis=0)/2) / (numpy.sum(tc_dict1[0].values()[0][1][1:3], axis=0)/2)) * 100
# diff_equal = ((numpy.sum(tc_dict2[0].values()[0][1][3:5], axis=0)/2 - numpy.sum(tc_dict1[0].values()[0][1][3:5], axis=0)/2) / (numpy.sum(tc_dict1[0].values()[0][1][3:5], axis=0)/2)) * 100
# diff_larger = ((numpy.sum(tc_dict2[0].values()[0][1][5:], axis=0)/5 - numpy.sum(tc_dict1[0].values()[0][1][5:], axis=0)/5) / (numpy.sum(tc_dict1[0].values()[0][1][5:], axis=0)/5)) * 100
# diff_smaller = ((numpy.sum(tc_dict2[0].values()[0][1][1:3], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][1:3], axis=0)) / numpy.sum(tc_dict1[0].values()[0][1][1:3], axis=0)) * 100
diff_smaller = ((numpy.sum(tc_dict2[0].values()[0][1][Ssmaller:Sequal], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][Ssmaller:Sequal], axis=0)) / numpy.sum(tc_dict1[0].values()[0][1][Ssmaller:Sequal], axis=0)) * 100
diff_equal = ((numpy.sum(tc_dict2[0].values()[0][1][Sequal:SequalStop], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][Sequal:SequalStop], axis=0)) / numpy.sum(tc_dict1[0].values()[0][1][Sequal:SequalStop], axis=0)) * 100
diff_larger = ((numpy.sum(tc_dict2[0].values()[0][1][Slarger:], axis=0) - numpy.sum(tc_dict1[0].values()[0][1][Slarger:], axis=0)) / numpy.sum(tc_dict1[0].values()[0][1][Slarger:], axis=0)) * 100
# print "diff_smaller", diff_smaller
# average of all cells
smaller = sum(diff_smaller) / num_cells
equal = sum(diff_equal) / num_cells
larger = sum(diff_larger) / num_cells
# Check using scipy
# and we want to compare the responses of full and inactivated
# smaller, smaller_pvalue = scipy.stats.ttest_rel( numpy.sum(tc_dict2[0].values()[0][1][0:3], axis=0)/3, numpy.sum(tc_dict1[0].values()[0][1][0:3], axis=0)/3 )
# equal, equal_pvalue = scipy.stats.ttest_rel( numpy.sum(tc_dict2[0].values()[0][1][3:5], axis=0)/2, numpy.sum(tc_dict1[0].values()[0][1][3:5], axis=0)/2 )
# larger, larger_pvalue = scipy.stats.ttest_rel( numpy.sum(tc_dict2[0].values()[0][1][5:], axis=0)/5, numpy.sum(tc_dict1[0].values()[0][1][5:], axis=0)/5 )
# print "smaller, smaller_pvalue:", smaller, smaller_pvalue
# print "equal, equal_pvalue:", equal, equal_pvalue
# print "larger, larger_pvalue:", larger, larger_pvalue
diff_full_inac.append( smaller )
diff_full_inac.append( equal )
diff_full_inac.append( larger )
# -------------------------------------
# Standard Error Mean calculated on the full sequence
sem_full_inac.append( scipy.stats.sem(diff_smaller) )
sem_full_inac.append( scipy.stats.sem(diff_equal) )
sem_full_inac.append( scipy.stats.sem(diff_larger) )
# print diff_full_inac
# print sem_full_inac
barlist = axes[col,0].bar([0.5,1.5,2.5], diff_full_inac, width=0.8)
axes[col,0].plot([0,4], [0,0], 'k-') # horizontal 0 line
for ba in barlist:
ba.set_color('white')
if smaller_pvalue < p_significance:
barlist[0].set_color('brown')
if equal_pvalue < p_significance:
barlist[1].set_color('darkgreen')
if larger_pvalue < p_significance:
barlist[2].set_color('blue')
# colors = ['brown', 'darkgreen', 'blue']
# for patch, color in zip(bp['boxes'], colors):
# patch.set_facecolor(color)
fig.subplots_adjust(hspace=0.4)
# fig.suptitle("All recorded cells grouped by circular distance", size='xx-large')
fig.text(0.5, 0.04, 'cells', ha='center', va='center')
fig.text(0.06, 0.5, 'ranges', ha='center', va='center', rotation='vertical')
for ax in axes.flatten():
ax.set_ylim([0,60])
ax.set_xticks(sizes)
# ax.set_xticklabels([0.1, '', '', '', '', 1, '', 2, 4, 6])
ax.set_xticklabels([0.1, '', '', '', '', '', '', '', '', '', '', 1, '', '', 2, '', '', '', 4, '', 6])
for col,_ in enumerate(slice_ranges):
# axes[col,0].set_ylim([-.8,.8])
axes[col,0].set_ylim([-60,60])
axes[col,0].set_yticks([-60, -40, -20, 0., 20, 40, 60])
axes[col,0].set_yticklabels([-60, -40, -20, 0, 20, 40, 60])
axes[col,0].set_xlim([0,4])
axes[col,0].set_xticks([.9,1.9,2.9])
axes[col,0].set_xticklabels(['small', 'equal', 'larger'])
axes[col,0].spines['right'].set_visible(False)
axes[col,0].spines['top'].set_visible(False)
axes[col,0].spines['bottom'].set_visible(False)
# plt.show()
plt.savefig( folder_inactive+"/TrialAveragedSizeTuningComparison_"+sheet+"_step"+str(step)+"_box"+str(box)+".png", dpi=100 )
# plt.savefig( folder_full+"/TrialAveragedSizeTuningComparison_"+sheet+"_"+interval+".png", dpi=100 )
fig.clf()
plt.close()
# garbage
gc.collect()
