////////////////////////
/* net_dd_vectors.hoc */
////////////////////////
objref lt_II, lt_IE, lt_EI, lt_EE, negexp_II, negexp_IE, tauvec_II, tauvec_IE, weight, tausum
weight = new Vector(nIN/2)
tausum = new Vector(nIN/2)
// ______________________________
// Auxiliary vectors for Synapses
// ------ II connections -------------------------------------------------------
// 1. Distance dependence in the network connectivity
lt_II = new Vector(nIN+1) // Storing the connection probability in dependence
lt_II_scale = Msyn_II / erf (max_ddcon_II / (sd_ddcon_II * sqrt(2)))
// scaling factor for the gaussian distribution of the connectivity rates
// to achieve the correct connectivity rates Msyn_II ultimately.
for i=0,max_ddcon_II { lt_II.x[i]=(lt_II_scale/(sqrt(2*PI)*sd_ddcon_II)) * exp(-(i*i)/(2*sd_ddcon_II*sd_ddcon_II)) }
// gaussian distribution of conn. prob. centered around the cell with sd_ddcon_IE,
// maximal distance of max_ddcon_II. The vector is automatically adjusted to a new Msyn_II value.
// !!! Attention!!! If Msyn_II becomes too high, then the the scaling factor lt_II_scale becomes too
// large and the connection probability for close presynaptic cells is larger than 1
// --> will result in a lower connectivity than wanted! To compensate for this either max_ddcon_II can
// be enlarged or ddcon_II_sd!
// 2. Distance dependence in the synaptic conductances
negexp_II = new Vector(nIN/2) // Storing a multiplicative factor for the synaptic strengths over distance.
for i=0,((nIN/2)-1) {
z = exp(-(a_ddg_II*SynADel)*i)
if (z >= ddg_II_low) {
negexp_II.x[i] = z
} else {
negexp_II.x[i] = ddg_II_low
}
}
// 3. Distance dependence in the decay time constants
func tau_II_average() {
// $1 is the Syn_II_decay_0 of interest
weight.fill(0)
tausum.fill(0)
for i = 0,max_ddcon_II-1 {
weight.x[i] = negexp_II.x[i]*lt_II.x[i]
}
weight = weight.div(weight.sum())
for i = 0,max_ddcon_II-1 {
syn_ID = int((i*Syn_II_N)/max_ddcon_II)
z = $1 + (syn_ID*b_ddtau_II*SynADel*(max_ddcon_II/Syn_II_N))
if (z <= Syn_II_decay_top) {
tausum.x[i] = z
} else {
tausum.x[i] = Syn_II_decay_top
}
}
tausum = tausum.mul(weight)
return tausum.sum()
}
proc tau_II_level() {
tau1 = tau_II_average(1)
tau2 = tau_II_average(2)
Syn_II_decay_0 = 2 - (((2-1)*(tau2-Syn_II_decay_standard))/(tau2-tau1))
if (Syn_II_decay_0 < Syn_II_decay_bottom) {
printf("Warning: Syn_II_decay could not be levelled! Instead of %f, Syn_II_decay_0 will be set to the default value %f\n",Syn_II_decay_0,Syn_II_decay_bottom)
Syn_II_decay_0 = Syn_II_decay_bottom
}
}
tau_II_level()
tauvec_II = new Vector(nIN/2) // Storing a certain ratio between fast and slow component of the inhibitory synapse.
tauvec_II.fill(Syn_II_decay_top)
for i=0,max_ddcon_II-1 {
syn_ID = int((i*Syn_II_N)/max_ddcon_II)
z = Syn_II_decay_0 + (b_ddtau_II*SynADel*(max_ddcon_II/Syn_II_N)*syn_ID)
if (z <= Syn_II_decay_top) {
tauvec_II.x[i] = z
} else {
tauvec_II.x[i] = Syn_II_decay_top
}
}
// ------ IE connections -------------------------------------------------------
// 1. Distance dependence in the network connectivity
lt_IE = new Vector(nIN+1) // Storing the connection probability in dependence
lt_IE_scale = Msyn_IE / erf (max_ddcon_IE / (sd_ddcon_IE * sqrt(2)))
for i=0,max_ddcon_IE { lt_IE.x[i]=(lt_IE_scale/(sqrt(2*PI)*sd_ddcon_IE)) * exp(-(i*i)/(2*sd_ddcon_IE*sd_ddcon_IE)) }
// 2. Distance dependence in the synaptic conductances
negexp_IE = new Vector(nIN/2) // Storing a multiplicative factor for the synaptic strengths over distance.
for i=0,((nIN/2)-1) {
z = exp(-(a_ddg_IE*SynADel)*i)
if (z >= ddg_IE_low) {
negexp_IE.x[i] = z
} else {
negexp_IE.x[i] = ddg_IE_low
}
}
// 3. Distance dependence in the decay time constants
func tau_IE_average() {
// $1 is the Syn_IE_decay_0 of interest
weight.fill(0)
tausum.fill(0)
for i = 0,max_ddcon_IE-1 {
weight.x[i] = negexp_IE.x[i]*lt_IE.x[i]
}
weight = weight.div(weight.sum())
for i = 0,max_ddcon_IE-1 {
syn_ID = int((i*Syn_IE_N)/max_ddcon_IE)
z = $1 + (syn_ID*b_ddtau_IE*SynADel*(max_ddcon_IE/Syn_IE_N))
if (z <= Syn_IE_decay_top) {
tausum.x[i] = z
} else {
tausum.x[i] = Syn_IE_decay_top
}
}
tausum = tausum.mul(weight)
return tausum.sum()
}
proc tau_IE_level() {
tau1 = tau_IE_average(1)
tau2 = tau_IE_average(2)
Syn_IE_decay_0 = 2 - (((2-1)*(tau2-Syn_IE_decay_standard))/(tau2-tau1))
if (Syn_IE_decay_0 < Syn_IE_decay_bottom) {
printf("Warning: Syn_IE_decay could not be levelled! Instead of %f, Syn_IE_decay_0 will be set to the default value %f\n",Syn_IE_decay_0,Syn_IE_decay_bottom)
Syn_IE_decay_0 = Syn_IE_decay_bottom
}
}
tau_IE_level()
tauvec_IE = new Vector(nIN/2) // Storing a certain ratio between fast and slow component of the inhibitory synapse.
tauvec_IE.fill(Syn_IE_decay_top)
for i=0,max_ddcon_IE-1 {
syn_ID = int((i*Syn_IE_N)/max_ddcon_IE)
z = Syn_IE_decay_0 + (b_ddtau_IE*SynADel*(max_ddcon_IE/Syn_IE_N)*syn_ID)
if (z <= Syn_IE_decay_top) {
tauvec_IE.x[i] = z
} else {
tauvec_IE.x[i] = Syn_IE_decay_top
}
}
// ------ EI connections -------------------------------------------------------
lt_EI = new Vector(nPN+1)
lt_EI_scale = Msyn_EI / erf (max_ddcon_EI / (sd_ddcon_EI * sqrt(2)))
for i=0,max_ddcon_EI { lt_EI.x[i]=(lt_EI_scale/(sqrt(2*PI)*sd_ddcon_EI)) * exp(-(i*i)/(2*sd_ddcon_EI*sd_ddcon_EI)) }
// ------ EE connections -------------------------------------------------------
lt_EE = new Vector(nPN+1)
lt_EE_scale = Msyn_EE / erf (max_ddcon_EE / (sd_ddcon_EE * sqrt(2)))
for i=0,max_ddcon_EE { lt_EE.x[i]=(lt_EE_scale/(sqrt(2*PI)*sd_ddcon_EE)) * exp(-(i*i)/(2*sd_ddcon_EE*sd_ddcon_EE)) }
// _____________________________________________________________________________
//
// _____________________________________________________________________________
// Calculation of the maximal conductance for the different DD modes based on
// the compound conductance of the noDD mode!
func compound_conductance_II() { local compcond,i,j,g,x
// $1 considering DD-vectors (1) or not for noDD-standard (0)
// $2 gmax
compcond = 0
if ($1 == 0) {
for i = 0,max_ddcon_II-1 {
g = $2
x = lt_II.x[i]
ind_compcond = 0
for j = 0,(100/dt)-1 {
ind_compcond = ind_compcond+(g*(exp(-(j*dt)/Syn_II_decay_standard)-exp(-(j*dt)/Syn_II_rise)))
}
compcond = compcond + (x*ind_compcond)
}
} else {
for i = 0,max_ddcon_II-1 {
g = $2*negexp_II.x[i]
x = lt_II.x[i]
ind_compcond = 0
for j = 0,(100/dt)-1 {
ind_compcond = ind_compcond+(g*(exp(-(j*dt)/tauvec_II.x[i])-exp(-(j*dt)/Syn_II_rise)))
}
compcond = compcond + (x*ind_compcond)
}
}
return compcond
}
func compound_conductance_IE() { local compcond,i,j,g,x
// $1 considering DD-vectors (1) or not for noDD-standard (0)
// $2 gmax
compcond = 0
if ($1 == 0) {
for i = 0,max_ddcon_IE-1 {
g = $2
x = lt_IE.x[i]
ind_compcond = 0
for j = 0,(100/dt)-1 {
ind_compcond = ind_compcond+(g*(exp(-(j*dt)/Syn_IE_decay_standard)-exp(-(j*dt)/Syn_IE_rise)))
}
compcond = compcond + (x*ind_compcond)
}
} else {
for i = 0,max_ddcon_IE-1 {
g = $2*negexp_IE.x[i]
x = lt_IE.x[i]
ind_compcond = 0
for j = 0,(100/dt)-1 {
ind_compcond = ind_compcond+(g*(exp(-(j*dt)/tauvec_IE.x[i])-exp(-(j*dt)/Syn_IE_rise)))
}
compcond = compcond + (x*ind_compcond)
}
}
return compcond
}
proc g_level() {
g_std = compound_conductance_II(0,g_standard_II)
g_lin1 = compound_conductance_II(1,0.05)
g_lin2 = compound_conductance_II(1,0.1)
SynG_II = 0.05+((0.1-0.05)*(g_std-g_lin1)/(g_lin2-g_lin1))
g_std = compound_conductance_IE(0,g_standard_IE)
g_lin1 = compound_conductance_IE(1,0.05)
g_lin2 = compound_conductance_IE(1,0.1)
SynG_IE = 0.05+((0.1-0.05)*(g_std-g_lin1)/(g_lin2-g_lin1))
}
// ______________________________________
// Auxiliary vectors for the shaped input
objref temvecIN_plt, temvecPN_plt, spavecIN_plt, spavecPN_plt
iinj_time = new Vector(tstop/inj_step)
// Interneurons ----------------------------------------------------------------
proc temshape_INinput() { local i,j,k
temiinj_IN = new Vector(tstop/inj_step)
for i = 0,((tINinj_on/inj_step)-1) { temiinj_IN.x[i] = 0 }
for j = (tINinj_on/inj_step),((tINinj_off/inj_step)-1) { temiinj_IN.x[j] = INinj_amp }
for k = (tINinj_off/inj_step),((tstop/inj_step)-1) { temiinj_IN.x[k] = 0 }
iinj_time.indgen(0,tstop,inj_step)
if (plotting == 1) {
temvecIN_plt = new Graph()
temvecIN_plt.size(0,tstop,0,1)
temvecIN_plt.label(0.05,0.95,"amp")
temvecIN_plt.label(0.95,0.05,"ms")
temvecIN_plt.color(2)
temvecIN_plt.label(0.95,0.95,"IN")
temiinj_IN.plot(temvecIN_plt,4,2)
}
}
proc spashape_INinput() { local i,d,d1,d2
spaiinj_IN = new Vector(nIN)
// Squared inputs
spaiinj_IN.fill(0.000000000001)
// Der erste input
for i = (spainjIN_M1-int(spainjIN_sd1/2)),(spainjIN_M1+int(spainjIN_sd1/2)) { spaiinj_IN.x[i] = 1 }
// Der zweite input
//for i = (spainjIN_M2-int(spainjIN_sd2/2)),(spainjIN_M2+int(spainjIN_sd2/2)) { spaiinj_IN.x[i] = spainjIN_ratio }
/*
// Gaussian (SD = spainjIN_sd1 and mean = spainjIN_M1)
for i = 0,(nIN-1) {
d = abs(i-spainjIN_M1) // Distance from cell position to Gaussian-Mean.
if (d > nIN/2) { d = nIN-d }
spaiinj_IN.x[i] = exp(-0.5*(d/spainjIN_sd1)*(d/spainjIN_sd1))
}
*/
/*
// 2 Gaussians (SD = spainjIN_sd1 and mean = spainjIN_M1 bzw. sd2 and M2)
for i = 0,(nIN-1) {
d1 = abs(i-spainjIN_M1)
if (d1 > nIN/2) { d1 = nIN-d1 }
d2 = abs(i-spainjIN_M2)
if (d2 > nIN/2) { d2 = nIN-d2 }
spaiinj_IN.x[i] = (exp(-0.5*(d1/spainjIN_sd1)*(d1/spainjIN_sd1))) + spainjIN_ratio*(exp(-0.5*(d2/spainjIN_sd2)*(d2/spainjIN_sd2)))
}
*/
if (plotting == 1) {
spavecIN_plt = new Graph()
spavecIN_plt.size(0,nIN,0,1)
spavecIN_plt.label(0.05,0.95,"rel. amp")
spavecIN_plt.label(0.95,0.05,"ind(IN)")
spaiinj_IN.plot(spavecIN_plt,2,2)
}
}
// Principal neurons ----------------------------------------------------------------
proc temshape_PNinput() { local i,j,k
temiinj_PN = new Vector(tstop/inj_step)
for i = 0,((tPNinj_on/inj_step)-1) { temiinj_PN.x[i] = 0 }
for j = (tPNinj_on/inj_step),((tPNinj_off/inj_step)-1) { temiinj_PN.x[j] = PNinj_amp }
for k = (tPNinj_off/inj_step),((tstop/inj_step)-1) { temiinj_PN.x[k] = 0 }
iinj_time.indgen(0,tstop,inj_step)
if (plotting == 1) {
temvecPN_plt = new Graph()
temvecPN_plt.size(0,tstop,0,1)
temvecPN_plt.label(0.05,0.95,"amp")
temvecPN_plt.label(0.95,0.05,"ms")
temvecPN_plt.color(2)
temvecPN_plt.label(0.95,0.95,"PN")
temiinj_PN.plot(temvecPN_plt,4,2)
}
}
proc spashape_PNinput() { local i,d,d1,d2
spaiinj_PN = new Vector(nPN)
// Squared inputs
spaiinj_PN.fill(0.000000000001)
// Der erste input
for i = (spainjPN_M1*(nPN/nIN)-int(spainjPN_sd1*(nPN/nIN)/2)),(spainjPN_M1*(nPN/nIN)+int(spainjPN_sd1*(nPN/nIN)/2)) { spaiinj_PN.x[i] = 1 }
// Der zweite input
//for i = (spainjPN_M2*(nPN/nIN)-int(spainjPN_sd2*(nPN/nIN)/2)),(spainjPN_M2*(nPN/nIN)+int(spainjPN_sd2*(nPN/nIN)/2)) { spaiinj_PN.x[i] = spainjPN_ratio }
/*
// Gaussian (SD = spainjPN_sd1*(nPN/nIN) and mean = spainjPN_M1*(nPN/nIN))
for i = 0,(nPN-1) {
d = abs(i-spainjPN_M1*(nPN/nIN)) // Distance from cell position to Gaussian-Mean.
if (d > nPN/2) { d = nPN-d }
spaiinj_PN.x[i] = exp(-0.5*(d/(spainjPN_sd1*(nPN/nIN)))*(d/(spainjPN_sd1*(nPN/nIN))))
}
*/
/*
// 2 Gaussians (SD = spainjPN_sd1*(nPN/nIN) and mean = spainjPN_M1*(nPN/nIN) bzw. sd2 and M2)
for i = 0,(nPN-1) {
d1 = abs(i-spainjPN_M1*(nPN/nIN))
if (d1 > nPN/2) { d1 = nPN-d1 }
d2 = abs(i-spainjPN_M2*(nPN/nIN))
if (d2 > nPN/2) { d2 = nPN-d2 }
spaiinj_PN.x[i] = (exp(-0.5*(d1/(spainjPN_sd1*(nPN/nIN)))*(d1/(spainjPN_sd1*(nPN/nIN))))) + spainjPN_ratio*(exp(-0.5*(d2/(spainjPN_sd2*(nPN/nIN)))*(d2/(spainjPN_sd2*(nPN/nIN)))))
}
*/
if (plotting == 1) {
spavecPN_plt = new Graph()
spavecPN_plt.size(0,nPN,0,1)
spavecPN_plt.label(0.05,0.95,"rel. amp")
spavecPN_plt.label(0.95,0.05,"ind(PN)")
spaiinj_PN.plot(spavecPN_plt,2,2)
}
}
// _____________________________________________________________________________
//
