def update_MFE(self):
vedges = self.edges
h = vedges[2] - vedges[1]
vedges = 0.5 * (vedges[0:-1] + vedges[1:])
rhov = self.rhov
NumCell = self.NumCell
self.V_sample = util.getsamples(vedges, rhov, NumCell)
local_pevent = 1.0
NE, NI = 0, 0
if self.ei_pop == 'e':
#print('inter target:')
for c in self.target_connection_list:
if (c.conn_type == 'ShortRange'):
#print(c.idx_kick)
idx_kick = c.idx_kick
idx_vT = c.idx_vT
trhov = c.curr_trhov
nsyn_post = c.nsyn_post
prob_event = (1.0 -
np.sum(np.squeeze(trhov[idx_kick:idx_vT])) *
h)**nsyn_post
local_pevent *= prob_event
else:
local_pevent *= 1.0
NE = self.NumCell
local_pevent = NE * self.curr_firing_rate * (
1 - local_pevent) * self.dt
self.local_pevent = local_pevent
else:
self.local_pevent = 0.0
def initialize_MFE(self):
# >>> Transfer Voltage-edge into Voltage-bn >>>
vedges = self.edges
h = vedges[2] - vedges[1]
vedges = 0.5 * (vedges[0:-1] + vedges[1:])
rhov = self.rhov
NumCell = self.NumCell
self.V_sample = util.getsamples(vedges, rhov, NumCell)
local_pevent = 1.0
NE, NI = 0, 0
if self.ei_pop == 'e':
for c in self.target_connection_list:
if (c.conn_type == 'ShortRange'):
# if already initialize connection_distribution or not
try:
idx_kick = c.idx_kick
idx_vT = c.idx_vT
trhov = c.trhov
nsyn_post = c.nsyn_post
prob_event = (
1.0 - np.sum(np.squeeze(trhov[idx_kick:idx_vT])) *
h)**nsyn_post
local_pevent *= prob_event
except:
c.initialize_connection_distribution()
idx_kick = c.idx_kick
idx_vT = c.idx_vT
trhov = c.trhov
nsyn_post = c.nsyn_post
prob_event = (
1.0 -
np.sum(trhov[idx_kick:idx_vT]) * h)**nsyn_post
local_pevent *= prob_event
else:
local_pevent = 1.0
NE = self.NumCell
local_pevent = NE * self.curr_firing_rate * (1 - local_pevent)
self.local_pevent = local_pevent
else:
self.local_pevent = local_pevent
def update(self,t0,dt,tf):
self.dt = dt
self.tf = tf
# initialize:
start_time = time.time()
self.initialize(t0)
self.initialize_time_period = time.time()-start_time
# start_running
start_time = time.time()
counter = 0
numCGPatch = self.Net_settings['nmax']*2
'''
First
'''
Vbins,Vedges,NPATCH = self.Vbins,self.Vedges,self.NPATCH
while self.t < self.tf:
# refresh current time as well as current time-step
self.t+=self.dt
self.tbin_tmp = int(np.floor(self.t/self.tbinsize))
#if self.verbose: print ('time: %s' % self.t)
ind_rec,idxE,idxI = 0,0,0 # start to accumulate index of hypercolumn
for p in self.population_list:
''' updating OP 2 modes: updating under Moment/updating under MFE '''
# updating under Moment- full
p.USUALorMFE = 1
ind_rec += 1
'''
Recording at first, before p.update(),
rE and rI purely from(after) MFE should be recorded in rE/I(bin)_ra, rather
than RvE from Moment
'''
# before Moment iteration
if(ind_rec>numCGPatch): # means internal-population, not external-population
if p.ei_pop == 'e':
''' Voltage distribution should be recorded each dt as well as each dtbin'''
# dtbin-recording
self.VEavgbin_ra[self.tbin_tmp,idxE] += p.v1*dt
self.VEstdbin_ra[self.tbin_tmp,idxE] += np.sqrt(p.v2-p.v1**2)*dt
self.rEbin_ra[idxE,:,self.tbin_tmp] += p.curr_rhov * self.dt
idxE +=1
else:
''' Voltage distribution should be recorded each dt as well as each dtbin'''
# dtbin-recording
self.VIavgbin_ra[self.tbin_tmp,idxI] += p.v1*dt
self.VIstdbin_ra[self.tbin_tmp,idxI] += np.sqrt(p.v2-p.v1**2)*dt
self.rIbin_ra[idxI,:,self.tbin_tmp] += p.curr_rhov * self.dt
idxI +=1
p.update()
'''
when using USUALorMFE==1
updating rhov as well as firing rate;
next, recording firing rate mE/I in mE/I(bin)_ra
[but not rE/I(bin)_ra]
and also, RvE/I were extracted out from p-list, which were used
to calculate MFE probability
'''
if(counter>0):
if(ind_rec>numCGPatch):
if p.ei_pop == 'e':
continue
ind_rec,idxE,idxI = 0,0,0
for p in self.population_list:
ind_rec += 1
if(counter>0):
if(ind_rec>numCGPatch):
if p.ei_pop == 'e':
'''
and also extract curr_rhov to calculate P_MFE
'''
self.rE[:,idxE] = p.curr_rhov
'''
here, recording new firing rate
mE/I_ra
and also extracting curr_rhov to calculate PMFE
'''
self.p_single[idxE] = p.curr_firing_rate * self.dt * p.NumCell
idxE += 1
else:
self.rI[:,idxI] = p.curr_rhov
idxI += 1
''' calculating P_MFE for each time step '''
''' vedges is new for calculate MFE '''
NE,NI = self.NE,self.NI
NPATCH = self.NPATCH
h = self.Vedges[1]- self.Vedges[0]
local_pevent = 1.0
for isource in range(self.NPATCH):
local_pevent = 1.0
for jt in range(self.NPATCH):
kickE,kickI = self.idx_kickE[jt,isource],self.idx_kickI[jt,isource]
idx_vT = self.idx_vT
''' Excitatory '''
trhov = np.squeeze(self.rE[:,jt])
if isource!=jt:
Nup = NE
else:
Nup = NE
prob_event = (1.0 - np.sum(np.squeeze(trhov[kickE:idx_vT])) * h) ** Nup
local_pevent *= prob_event
''' Inhibitory '''
trhov = np.squeeze(self.rI[:,jt])
Nup = NI
prob_event = (1.0 - np.sum(np.squeeze(trhov[kickI:idx_vT])) * h) ** Nup
local_pevent *= prob_event
self.MFE_pevent[isource] = self.p_single[isource] * (1-local_pevent)
''' then prepare for MFE '''
MFE_pevent_max = max(self.MFE_pevent) # choose the maximum-value from all possible
# trigger-pattern
''' recording MFE-probability '''
# dt-recording
self.P_MFE_ra[counter] = MFE_pevent_max
# dt-bin recording probability of MFE
self.P_MFEbin_ra[self.tbin_tmp,0] += MFE_pevent_max * dt
idx_pevent_max = np.argmax(self.MFE_pevent)
''' could also record which excitatory population appropriately trigger the MFE '''
self.idx_MFE_ra[counter] = idx_pevent_max
self.MFE_flag = 0
local_pevent_d = np.random.random()
if local_pevent_d < 0:#MFE_pevent_max:
self.MFE_flag = 1
self.MFE_num += 1
self.idx_MFE_eff[self.MFE_num] = idx_pevent_max
self.P_MFE_eff[self.MFE_num] = MFE_pevent_max
VE = np.zeros((self.NE,self.NPATCH))
VI = np.zeros((self.NI,self.NPATCH))
''' distribution sampling '''
for i in range(self.NPATCH):
V_sample = util.getsamples(np.squeeze(self.Vedges[1:]),np.squeeze(self.rE[:,i]),self.NE)
VE[:,i] = np.squeeze(V_sample)
V_sample = util.getsamples(np.squeeze(self.Vedges[1:]),np.squeeze(self.rI[:,i]),self.NI)
VI[:,i] = np.squeeze(V_sample)
''' trigger neuron '''
VE[0:2,idx_pevent_max] = 1.0
DEEu = self.DEE.copy()
DIEu = self.DIE.copy()
DEIu = self.DEI.copy()
DIIu = self.DII.copy()
pop_idx_E = np.zeros((self.NE,self.NPATCH),dtype=int)
pop_idx_I = np.zeros((self.NI,self.NPATCH),dtype=int)
for i in range(self.NPATCH):
pop_idx_E[:,i] = i
pop_idx_I[:,i] = i
(E_fired,I_fired,VE_pre,VI_pre,VE_pos,VI_pos) = util.getMFE_ifdyn(0,VE,VI,DEEu,DEIu,DIEu,DIIu,0,0,pop_idx_E,pop_idx_I)
E_fired_num,I_fired_num = np.zeros((NE*NPATCH,1)),np.zeros((NI*NPATCH,1))
E_fired_num[E_fired] = 1
I_fired_num[I_fired] = 1
E_fired_num = np.reshape(E_fired_num,(NE,NPATCH))
I_fired_num = np.reshape(I_fired_num,(NI,NPATCH))
E_ind_num = np.sum(E_fired_num,axis = 0)
I_ind_num = np.sum(I_fired_num,axis = 0)
for i in range(NPATCH):
self.LE_ra[self.MFE_num,i] = E_ind_num[i]
self.LI_ra[self.MFE_num,i] = I_ind_num[i]
VEpos,VIpos,VEpre,VIpre = VE_pos,VI_pos,VE_pre,VI_pre
Vedges = self.Vedges
Vbins = self.Vbins
h = Vbins[2]-Vbins[1]
rE,rI = np.zeros((len(Vbins),NPATCH)),np.zeros((len(Vbins),NPATCH))
'''
resample and produce new voltage distribution after MFE correction
'''
for i in range(NPATCH):
VEposu = np.squeeze(VEpos[:,i])
rE_tmp,Vedge = np.histogram(VEposu, Vedges)
# new rhov
rE[:,i] = rE_tmp/(self.NE * h)#(np.sum(rE_tmp)*h)
VIposu = np.squeeze(VIpos[:,i])
rI_tmp,Vedge = np.histogram(VIposu, Vedges)
# new rhov
rI[:,i] = rI_tmp/(self.NI *h) #(np.sum(rI_tmp)*h)
'''
refresh rhov for each population
'''
idxE,idxI = 0,0
ind_rec = 0
for p in self.population_list:
ind_rec +=1
if(counter>0):
if(ind_rec>numCGPatch):
if p.ei_pop == 'e':
''' rhovE[i]=0'''
p.rhov[:] = rE[:,idxE]
idxE += 1
else:
''' rhovI[i]=0'''
p.rhov[:] = rI[:,idxI]
idxI += 1
V1 = Vbins
V2 = V1*Vbins
V3 = V2*Vbins
V4 = V3*Vbins
h = Vbins[2] - Vbins[1]
vbarE = np.zeros(NPATCH)
wbarE,vbar3E,vbar4E = np.zeros_like(vbarE),np.zeros_like(vbarE),np.zeros_like(vbarE)
vbarI = np.zeros(NPATCH)
wbarI,vbar3I,vbar4I = np.zeros_like(vbarI),np.zeros_like(vbarI),np.zeros_like(vbarI)
for i in range(NPATCH):
rE_tmp = np.squeeze(rE[:,i])
rI_tmp = np.squeeze(rI[:,i])
vbarE[i] = np.sum(V1*rE_tmp ) * h
wbarE[i] = np.sum(V2*rE_tmp ) * h
vbar3E[i] = np.sum(V3*rE_tmp ) * h
vbar4E[i] = np.sum(V4*rE_tmp ) * h
vbarI[i] = np.sum(V1*rI_tmp ) * h
wbarI[i] = np.sum(V2*rI_tmp ) * h
vbar3I[i] = np.sum(V3*rI_tmp ) * h
vbar4I[i] = np.sum(V4*rI_tmp ) * h
''' refresh data in simulation '''
idxE,idxI = 0,0
ind_rec = 0
'''
set v1,v2,v3,v4 from outter
USUALorMFE == 0,only change
VE/Is,DE/I (total.....), notice that before update, mE/I = 0,
p.firing_rate = 0
also,La0/1 equal to zero
recalculate VE/Is DE/I
rhov_EQ(cause VE/Is and DE/I change)
do not change rhov E/I
rhov have resampled after MFE, but didn't give it to p.rhov
so, give it to p-list, and do not change anymore (USUALorMFE==0)
firing rate = 0 (USUALorMFE)
'''
for p in self.population_list:
ind_rec +=1
if(counter>0):
if(ind_rec>numCGPatch):
if p.ei_pop == 'e':
'''
print previous informatio, before MFE
'''
''' me[i]=0'''
p.firing_rate = 0.0
''' v1,v2,v3,v4 '''
p.v1,p.v2,p.v3,p.v4 = vbarE[idxE],wbarE[idxE],vbar3E[idxE],vbar4E[idxE]
''' la0/1 '''
md_La = np.transpose([1,p.v1,p.v2])
p.La0,p.La1 = np.zeros_like(md_La),np.zeros_like(md_La)
idxE += 1
else:
p.firing_rate = 0.0
p.v1,p.v2,p.v3,p.v4 = vbarI[idxI],wbarI[idxI],vbar3I[idxI],vbar4I[idxI]
md_La = np.transpose([1,p.v1,p.v2])
p.La0,p.La1 = np.zeros_like(md_La),np.zeros_like(md_La)
idxI += 1
''' after reset, calculate again'''
ind_rec = 0
for p in self.population_list:
ind_rec +=1
if(counter>0):
if(ind_rec>numCGPatch):
p.USUALorMFE = 0
p.update()
for c in self.connection_list:
c.update()
counter +=1
''' recording ! '''
# DTBIN_RECORD_FLAG
self.tbin_ra[counter] = np.floor(self.t/self.tbinsize)
tbin = int(np.floor(self.t/self.tbinsize))
ind_rec,idxE,idxI = 0,0,0
for p in self.population_list:
ind_rec +=1
if(counter>0):
if(ind_rec>numCGPatch):
if p.ei_pop == 'e':
self.mEbin_ra[tbin,idxE] += (1-self.MFE_flag) * p.curr_firing_rate * NE * dt + self.MFE_flag * self.LE_ra[self.MFE_num,idxE]
self.xEbin_ra[tbin,idxE] += (1-self.MFE_flag) * util.psample(p.curr_firing_rate * NE * dt) + self.MFE_flag * self.LE_ra[self.MFE_num,idxE]
self.nEbin_ra[tbin,idxE] += p.total_Inmda * NE * dt
idxE += 1
else:
self.mIbin_ra[tbin,idxI] += (1-self.MFE_flag) * p.curr_firing_rate * NE * dt + self.MFE_flag * self.LI_ra[self.MFE_num,idxI]
self.xIbin_ra[tbin,idxI] += (1-self.MFE_flag) * util.psample(p.curr_firing_rate * NE * dt) + self.MFE_flag * self.LI_ra[self.MFE_num,idxI]
self.nIbin_ra[tbin,idxI] += p.total_Inmda * NI * dt
idxI += 1
'''
# plotting the response curves
if np.mod(counter,50) < 1:
if np.mod(counter,50) == 0:
print("t_sum: ",counter * self.dt)
for i in range(6,NPATCH,12):
print('Excitatory pop %d :%.4f'%(i,self.mEbin_ra[tbin,i]))
print('Inhibitory pop %d :%.4f'%(i,self.mIbin_ra[tbin,i]))
ttt = np.arange(tbin) * 1.0
plt.figure(220)
if (i<18):
plt.plot(ttt,self.VEavgbin_ra[:tbin,i],'r')
if (i>=18)&(i<32):
plt.plot(ttt,self.VEavgbin_ra[:tbin,i],'m')
if (i>=32):
plt.plot(ttt,self.VEavgbin_ra[:tbin,i],'y')
plt.xlim([0,int(self.tf)])
plt.ylim([0,1.2])
plt.pause(0.1)
plt.figure(222)
if (i<18):
plt.plot(ttt,self.VIavgbin_ra[:tbin,i],'r')
if (i>=18)&(i<32):
plt.plot(ttt,self.VIavgbin_ra[:tbin,i],'m')
if (i>=32):
plt.plot(ttt,self.VIavgbin_ra[:tbin,i],'y')
plt.xlim([0,int(self.tf)])
plt.ylim([0,1.2])
plt.pause(0.1)
'''
''' recording sub-time '''
if np.mod(counter,500)==0:
print("t_sum: ",counter * self.dt)
icounter = np.ceil(counter/500)
ip = int((icounter-1)*50)
ic = int((icounter)*50)
ISOTIMEFORMAT='%Y%m%d%H'
filename=str(time.strftime(ISOTIMEFORMAT)) + str(icounter) + '.mat'
scio.savemat(filename,{'mEbin_ra':self.mEbin_ra[ip:ic],'mIbin_ra':self.mIbin_ra[ip:ic],'xEbin_ra':self.xEbin_ra[ip:ic],'xIbin_ra':self.xIbin_ra[ip:ic],'VEavgbin_ra':self.VEavgbin_ra[ip:ic],'VIavgbin_ra':self.VIavgbin_ra[ip:ic],'VEstdbin_ra':self.VEstdbin_ra[ip:ic],'VIstdbin_ra':self.VIstdbin_ra[ip:ic],'nEbin_ra':self.nEbin_ra[ip:ic],'nIbin_ra':self.nIbin_ra[ip:ic]})
return self.mEbin_ra,self.mIbin_ra,self.xEbin_ra,self.xIbin_ra,self.VEavgbin_ra,self.VIavgbin_ra,self.VEstdbin_ra,self.VIstdbin_ra,self.rEbin_ra,self.rIbin_ra,self.P_MFEbin_ra,self.nEbin_ra,self.nIbin_ra
def update(self, t0, dt, tf):
# >>>>>>>>>>>>>>>>>>> Initialize >>>>>>>>>>>>>>>>>>>>>>>>>>
self.dt = dt
self.tf = tf
self.initialize(t0)
# >>>>>>>>>>>>>>>>> Start Iteration >>>>>>>>>>>>>>>>>>>>
start_time = time.time()
self.initialize_time_period = time.time() - start_time
counter = 0
# >>>>>>>>>>>>>>>>> Basic Network Structure >>>>>>>>>>>>
Vbins, Vedges, NPATCH = self.Vbins, self.Vedges, self.NPATCH
numCGPatch = self.Net_settings['nmax'] * 2
print(
'Number of both Excitatory and Inhibitory populations(double of NPATCH): ',
self.Net_settings['nmax'] * 2)
LEE, LIE, LEI, LII = self.LEE, self.LIE, self.LEI, self.LII
while self.t < self.tf:
# >>>>>>>>>>>>>>>> Time Evolution >>>>>>>>>>>>>>>>>
self.t += self.dt
# >>>>>>>>>>>>>>>>> tbin_tmp for Recording >>>>>>>>>>>
self.tbin_tmp = int(np.floor(self.t / self.tbinsize))
# >>>>>>>>>>>>>>>>> If We Want Change Connection-strength(period of time), Comment Code below Could be Appropriate
'''
for c in self.connection_list:
if (self.t > 100.0) & (flagS <4):
print('current time',self.t)
if (c.conn_type == 'LongRange') & (c.ei_pop_post == 'e'):
flagS += 1
c.weights /= 1.2
c.weights *= 2.66#2.85#2.6#2.1#1.8
print('change e to e Long range, flag',flagS,' value:',c.weights)
if (c.conn_type == 'LongRange') & (c.ei_pop_post == 'i'):
flagS += 1
c.weights /= 1.2
c.weights *= 1.2#3.60#3.6
print('change e to i Long range, flag',flagS,' value:',c.weights)
if (self.t > 100.0) & (flagE <4):
print('current time',self.t)
if (c.conn_type == 'LongRange') & (c.ei_pop_post == 'e'):
flagE += 1
c.weights /= 2.66#2.85
c.weights *= 1.20#2.6#2.1#1.8
print('change e to e Long range, flag',flagE,' value:',c.weights)
if (c.conn_type == 'LongRange') & (c.ei_pop_post == 'i'):
flagE += 1
c.weights /= 1.2
c.weights *= 1.2#3.60#3.6
print('change e to i Long range, flag',flagE,' value:',c.weights)
'''
ind_rec, idxE, idxI = 0, 0, 0
for p in self.population_list:
p.USUALorMFE = 1
ind_rec += 1
'''
Recording at first, before p.update(),
rE and rI purely from(after) MFE should be recorded in rE/I(bin)_ra, rather
than RvE from Moment
'''
# before Moment iteration
if (ind_rec > numCGPatch
): # means internal-population, not external-population
if p.ei_pop == 'e':
# >>>>>> Per dtbin >>>>>>>>>>
self.VEavgbin_ra[self.tbin_tmp, idxE] += p.v1 * dt
self.VEstdbin_ra[self.tbin_tmp,
idxE] += np.sqrt(p.v2 - p.v1**2) * dt
self.VEmubin_ra[self.tbin_tmp,
idxE] += p.total_fp_vslave * dt
self.VEsigbin_ra[self.tbin_tmp,
idxE] += p.total_fp_sigv * dt
# self.rEbinp_ra[idxE,:,rhovc] = p.curr_rhov
idxE += 1
else:
# >>>>>> Per dt >>>>>>>>>>>>>
'''
self.VIavg_ra[counter,idxI] = p.v1
self.VIstd_ra[counter,idxI] = np.sqrt(p.v2-p.v1**2)
'''
# >>>>>> Per dtbin >>>>>>>>>>
self.VIavgbin_ra[self.tbin_tmp, idxI] += p.v1 * dt
self.VIstdbin_ra[self.tbin_tmp,
idxI] += np.sqrt(p.v2 - p.v1**2) * dt
self.VImubin_ra[self.tbin_tmp,
idxI] += p.total_fp_vslave * dt
self.VIsigbin_ra[self.tbin_tmp,
idxI] += p.total_fp_sigv * dt
# self.rIbinp_ra[idxI,:,rhovc] = p.curr_rhov
idxI += 1
p.update()
# add in 02/04/2020 refresh c.curr_Delay_firing rate, for p.firing_rate = 0.0
for c in self.connection_list:
c.update()
'''
when using USUALorMFE==1
updating rhov as well as firing rate
next, should record firing rate mE/I in mE/I(bin)_ra
[but not rE/I(bin)_ra]
and also, RvE/I were extracted out from p-list, which were used
to calculate MFE probability
'''
ind_rec, idxE, idxI = 0, 0, 0
for p in self.population_list:
ind_rec += 1
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
# >>>>>> Only Excitatory Population Could Trigger MFE
self.rE[:, idxE] = p.curr_rhov
# >>>>>>>>> Per dt >>>>>>>>>>>>
'''
self.mE_ra[counter,idxE] = p.curr_firing_rate
self.NMDAE_ra[counter,idxE] = p.acm_NMDA
'''
self.p_single[
idxE] = p.curr_firing_rate * self.dt * p.NumCell
idxE += 1
else:
# >>>>>>>>> Per dt >>>>>>>>>>>>
'''
self.mI_ra[counter,idxI] = p.curr_firing_rate
self.NMDAI_ra[counter,idxI] = p.acm_NMDA
'''
self.rI[:, idxI] = p.curr_rhov
idxI += 1
# >>>>>>>>>>>>>>>>>>>>>>>>> Probability to Generate MFE >>>>>>>>>>>>>>.
NE, NI = self.NE, self.NI
NPATCH = self.NPATCH
h = self.Vedges[1] - self.Vedges[0]
local_pevent = 1.0
for isource in range(self.NPATCH):
local_pevent = 1.0
for jt in range(self.NPATCH):
kickE, kickI = self.idx_kickE[jt, isource], self.idx_kickI[
jt, isource]
idx_vT = self.idx_vT
''' >>>>>>>>>>>> Excitatory Target Populations to Be Triggered >>>> '''
trhov = np.squeeze(self.rE[:, jt])
if isource != jt:
Nup = NE
else:
Nup = NE
prob_event = (
1.0 - np.sum(np.squeeze(trhov[kickE:idx_vT])) * h)**Nup
local_pevent *= prob_event
''' >>>>>>>>>>>> Inhibitory Target Populations to Be Triggered >>>> '''
trhov = np.squeeze(self.rI[:, jt])
Nup = NI
prob_event = (
1.0 - np.sum(np.squeeze(trhov[kickI:idx_vT])) * h)**Nup
local_pevent *= prob_event
self.MFE_pevent[isource] = self.p_single[isource] * (
1 - local_pevent)
''' >>>>> Prob MFE and Real MFE >>>>>>>>>>>> '''
self.P_MFE_ra[counter, :] = self.MFE_pevent[:]
if self.mfeflag == 1:
MFE_pevent_max = max(
self.MFE_pevent
) # choose the maximum-value from all possible
else:
MFE_pevent_max = max(self.MFE_pevent)
# >>>>>>>>> Per dt >>>>>>>>>>>>
self.P_MFEbin_ra[self.tbin_tmp, 0] += MFE_pevent_max * dt
idx_pevent_max = np.argwhere(self.MFE_pevent == np.amax(
self.MFE_pevent)) #np.argmax(self.MFE_pevent)
# print('idx_',idx_pevent_max)
if len(idx_pevent_max) > 1:
np.random.shuffle(np.squeeze(idx_pevent_max))
idx_pevent_max = idx_pevent_max[0]
self.idx_MFE_ra[counter] = idx_pevent_max
self.MFE_flag = 0
local_pevent_d = np.random.random()
# print('>>>>>>>>>>>>>>>>>check MFE:%.5f '% self.MFE_pevent[isource])
if local_pevent_d < MFE_pevent_max: #-1:#
# >>>>>>>>>>>>>>> Recording N-serie
self.MFE_flag = 1
self.MFE_num += 1
self.idx_MFE_eff[self.MFE_num, 0] = idx_pevent_max
self.idx_MFE_eff[self.MFE_num, 1] = self.t
self.P_MFE_eff[self.MFE_num] = MFE_pevent_max
# >>>>>> Voltage Distribution Sampling >>>>>>>>>>
VE = np.zeros((self.NE, self.NPATCH))
VI = np.zeros((self.NI, self.NPATCH))
for i in range(self.NPATCH):
V_sample = util.getsamples(np.squeeze(self.Vedges[1:]),
np.squeeze(self.rE[:, i]),
self.NE)
VE[:, i] = np.squeeze(V_sample)
V_sample = util.getsamples(np.squeeze(self.Vedges[1:]),
np.squeeze(self.rI[:, i]),
self.NI)
VI[:, i] = np.squeeze(V_sample)
# >>>>>> 2 Neurons Triggered >>>>>>>>>>>>>>>>>>>>>>>
VE[0:2, idx_pevent_max] = 1.0
DEEu = self.DEE.copy()
DIEu = self.DIE.copy()
DEIu = self.DEI.copy()
DIIu = self.DII.copy()
pop_idx_E = np.zeros((self.NE, self.NPATCH), dtype=int)
pop_idx_I = np.zeros((self.NI, self.NPATCH), dtype=int)
for i in range(self.NPATCH):
pop_idx_E[:, i] = i
pop_idx_I[:, i] = i
(E_fired, I_fired, VE_pre, VI_pre, VE_pos,
VI_pos) = util.getMFE_ifdyn(0, VE, VI, DEEu, DEIu, DIEu, DIIu,
0, 0, pop_idx_E, pop_idx_I)
self.mfeflag = 0
'''
# wrong E_fired_num arrangement!!!!!!!
E_fired_num,I_fired_num = np.zeros((NE*NPATCH,1)),np.zeros((NI*NPATCH,1))
E_fired_num[E_fired] = 1
I_fired_num[I_fired] = 1
E_fired_num = np.reshape(E_fired_num,(NE,NPATCH))
I_fired_num = np.reshape(I_fired_num,(NI,NPATCH))
E_ind_num = np.sum(E_fired_num,axis = 0)
I_ind_num = np.sum(I_fired_num,axis = 0)
'''
E_fired_num, I_fired_num = np.zeros(
(NE * NPATCH, 1)), np.zeros((NI * NPATCH, 1))
E_fired_num[E_fired] = 1
I_fired_num[I_fired] = 1
E_fired_num = np.reshape(E_fired_num, (NPATCH, NE))
E_fired_num = E_fired_num.T
I_fired_num = np.reshape(I_fired_num, (NPATCH, NI))
I_fired_num = I_fired_num.T
E_ind_num = np.sum(E_fired_num, axis=0)
self.VEbinp_ra[:, -1, self.rhovc] = E_ind_num
I_ind_num = np.sum(I_fired_num, axis=0)
self.VIbinp_ra[:, -1, self.rhovc] = I_ind_num
self.rhovc += 1
for i in range(NPATCH):
self.LE_ra[self.MFE_num, i] = E_ind_num[i]
print('E-fired: ', E_ind_num[i])
self.LI_ra[self.MFE_num, i] = I_ind_num[i]
VEpos, VIpos, VEpre, VIpre = VE_pos.copy(), VI_pos.copy(
), VE_pre.copy(), VI_pre.copy()
Vedges = self.Vedges
Vbins = self.Vbins
h = Vbins[2] - Vbins[1]
rE, rI = np.zeros((len(Vbins), NPATCH)), np.zeros(
(len(Vbins), NPATCH))
# >>>>>>>>>>>>>>> Re-sample Rhov after MFE >>>>>>>>>>>>
for i in range(NPATCH):
VEposu = np.squeeze(VEpos[:, i])
rE_tmp, Vedge = np.histogram(VEposu, Vedges)
# >>>>>>>>>> New Rhov-E >>>>>>>>>>>>>>>
rE[:, i] = rE_tmp / (self.NE * h)
self.rE[:, i] = rE[:, i]
VIposu = np.squeeze(VIpos[:, i])
rI_tmp, Vedge = np.histogram(VIposu, Vedges)
# >>>>>>>>>> New Rhov-I >>>>>>>>>>>>>>>>
rI[:, i] = rI_tmp / (self.NI * h)
self.rI[:, i] = rI[:, i]
# Refresh Network and Populations' Characters after MFE-event >>>>>
# 1st Refresh Fring-rate,NMDA,HNMDA,Rhov
idxE, idxI = 0, 0
ind_rec = 0
for p in self.population_list:
ind_rec += 1
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
p.rhov[:] = rE[:, idxE]
extract_NMDA = 0.0
for inmda in range(NPATCH):
if (inmda == idxE):
extract_NMDA = extract_NMDA
else:
extract_NMDA += E_ind_num[inmda] * LEE[
idxE, inmda]
extract_NMDA -= I_ind_num[inmda] * LEI[
idxE, inmda]
p.acm_NMDA = p.acm_NMDA + extract_NMDA * self.tau_m / self.tau_d
idxE += 1
else:
''' rhovI[i]=0'''
p.rhov[:] = rI[:, idxI]
# ACM_NMDA
extract_NMDA = 0.0
for inmda in range(NPATCH):
if (inmda == idxI):
extract_NMDA = extract_NMDA
else:
extract_NMDA += E_ind_num[inmda] * LIE[
idxI, inmda]
extract_NMDA -= I_ind_num[inmda] * LII[
idxI, inmda]
p.acm_NMDA = p.acm_NMDA + extract_NMDA * self.tau_m / self.tau_d
idxI += 1
# 2nd, Refresh Moments
V1 = Vbins
V2 = V1 * Vbins
V3 = V2 * Vbins
V4 = V3 * Vbins
h = Vbins[2] - Vbins[1]
vbarE = np.zeros(NPATCH)
wbarE, vbar3E, vbar4E = np.zeros_like(vbarE), np.zeros_like(
vbarE), np.zeros_like(vbarE)
vbarI = np.zeros(NPATCH)
wbarI, vbar3I, vbar4I = np.zeros_like(vbarI), np.zeros_like(
vbarI), np.zeros_like(vbarI)
for i in range(NPATCH):
rE_tmp = np.squeeze(rE[:, i])
rI_tmp = np.squeeze(rI[:, i])
vbarE[i] = np.sum(V1 * rE_tmp) * h
wbarE[i] = np.sum(V2 * rE_tmp) * h
vbar3E[i] = np.sum(V3 * rE_tmp) * h
vbar4E[i] = np.sum(V4 * rE_tmp) * h
vbarI[i] = np.sum(V1 * rI_tmp) * h
wbarI[i] = np.sum(V2 * rI_tmp) * h
vbar3I[i] = np.sum(V3 * rI_tmp) * h
vbar4I[i] = np.sum(V4 * rI_tmp) * h
idxE, idxI, ind_rec = 0, 0, 0
'''
set v1,v2,v3,v4 from outter
USUALorMFE == 0,only change
VE/Is,DE/I (total.....), notice that before update, mE/I = 0,
p.firing_rate = 0
also,La0/1 equal to zero
recalculate VE/Is DE/I
rhov_EQ(cause VE/Is and DE/I change)
do not change rhov E/I
rhov have resampled after MFE, but didn't give it to p.rhov
so, give it to p-list, and do not change anymore (USUALorMFE==0)
firing rate keep 0 (USUALorMFE)
'''
for p in self.population_list:
ind_rec += 1
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
'''
# >>>> Previous Info for Testing >>>
'''
# print('before MFE, Exc cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
''' >>>> Firing-rate was Forced to Be Zero >>>'''
p.firing_rate = 0.0
# ''' ALL RESET '''
# p.acm_HNMDA = 0.0
# p.acm_NMDA = 0.0
''' v1,v2,v3,v4 '''
p.v1, p.v2, p.v3, p.v4 = vbarE[idxE], wbarE[
idxE], vbar3E[idxE], vbar4E[idxE]
''' >>>> lambda was Forced to Be Zero >>>'''
md_La = np.transpose([1, p.v1, p.v2])
p.La0, p.La1 = np.zeros_like(md_La), np.zeros_like(
md_La)
idxE += 1
else:
''' >>>> Firing-rate was Forced to Be Zero >>>'''
p.firing_rate = 0.0
p.v1, p.v2, p.v3, p.v4 = vbarI[idxI], wbarI[
idxI], vbar3I[idxI], vbar4I[idxI]
''' >>>> lambda was Forced to Be Zero >>>'''
md_La = np.transpose([1, p.v1, p.v2])
p.La0, p.La1 = np.zeros_like(md_La), np.zeros_like(
md_La)
idxI += 1
# add in 02/04/2020 refresh c.curr_Delay_firing rate, for p.firing_rate = 0.0
for c in self.connection_list:
c.update()
# >>>>>>>>>>>>>>>>> Refresh,But Not Recalculate Firing-rate >>>>>>>
ind_rec = 0
for p in self.population_list:
ind_rec += 1
if (ind_rec > numCGPatch):
p.USUALorMFE = 0
p.update()
'''
# >> This Refresh(Re-update) is necessary, we shouldn't directly use VEpos/VIpos as rhov, because in VEpos/VIpos, We Only Consider Instant Synaptic Inputs, afterhence, We Refresh HNMDA and NMDA, So Refresh RhovEq and Vs Ds is necessary >>
'''
for c in self.connection_list:
c.update()
counter += 1
# >>>>>>>>>>>>>>>> Recording >>>>>>>>>>>>>>>>>>>>>>>>>>>.
self.tbin_ra[counter] = np.floor(self.t / self.tbinsize)
tbin = int(np.floor(self.t / self.tbinsize))
ind_rec, idxE, idxI = 0, 0, 0
for p in self.population_list:
ind_rec += 1
if (counter > -1):
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
self.tau_NMDA[0, 0] = p.tau_r
self.tau_NMDA[1, 0] = p.tau_d
self.mEbin_ra[tbin, idxE] += (
1 - self.MFE_flag
) * p.curr_firing_rate * NE * dt + self.MFE_flag * self.LE_ra[
self.MFE_num, idxE]
self.xEbin_ra[
tbin,
idxE] += (1 - self.MFE_flag) * util.psample(
p.curr_firing_rate * NE *
dt) + self.MFE_flag * self.LE_ra[
self.MFE_num, idxE]
self.rEbin_ra[idxE, :, self.tbin_tmp] += (
1 - self.MFE_flag
) * p.curr_rhov * dt + self.MFE_flag * self.rE[:,
idxE] * dt
''' Long range '''
self.NMDAEbin_ra[tbin,
idxE] += p.acm_NMDA * NE * dt
idxE += 1
else:
self.mIbin_ra[tbin, idxI] += (
1 - self.MFE_flag
) * p.curr_firing_rate * NI * dt + self.MFE_flag * self.LI_ra[
self.MFE_num, idxI]
self.xIbin_ra[
tbin,
idxI] += (1 - self.MFE_flag) * util.psample(
p.curr_firing_rate * NI *
dt) + self.MFE_flag * self.LI_ra[
self.MFE_num, idxI]
self.rIbin_ra[idxI, :, self.tbin_tmp] += (
1 - self.MFE_flag
) * p.curr_rhov * dt + self.MFE_flag * self.rI[:,
idxI] * dt
''' Long range '''
self.NMDAIbin_ra[tbin,
idxI] += p.acm_NMDA * NI * dt
idxI += 1
''' visualizing '''
if np.mod(counter, 500) < 1:
if np.mod(counter, 500) == 0:
print("t_sum: ", counter * self.dt)
for i in range(NPATCH):
idshown = np.floor(tbin / 2000)
idstart = np.int(idshown * 2000)
if idstart == tbin:
idstart = idstart - 1
idend = min((idshown + 1) * 2000, 4000)
print('Excitatory pop %d :%.4f' %
(i, self.mEbin_ra[tbin, i]))
print('Inhibitory pop %d :%.4f' %
(i, self.mIbin_ra[tbin, i]))
ttt = np.arange(idstart, tbin) * 1.0
plt.figure(10)
plt.subplot(NPATCH, 1, int(i) + 1)
plt.plot(ttt, self.mEbin_ra[idstart:tbin, i], 'r')
plt.xlim([ttt[0], ttt[0] + 2000])
plt.ylim([0, NE])
plt.pause(0.1)
plt.figure(11)
plt.subplot(NPATCH, 1, int(i) + 1)
plt.plot(ttt, self.mIbin_ra[idstart:tbin, i], 'b')
plt.xlim([ttt[0], ttt[0] + 2000])
# plt.xlim([0,int(self.tf)])
plt.ylim([0, NI])
plt.pause(0.1)
# if np.mod(counter,4999) == 0:
# icounter = np.ceil(counter/4999)
# intic,ip,ic = int(icounter),int((icounter-1)*500),int((icounter)*500)
#
# timeformat = '%Y%m%d%H'
# filename=str(time.strftime(timeformat)) + str(intic) +'.mat'
# scio.savemat(filename,{'mEbin_ra':self.mEbin_ra[ip:ic,:],'mIbin_ra':self.mIbin_ra[ip:ic,:],'xEbin_ra':self.xEbin_ra[ip:ic,:],'xIbin_ra':self.xIbin_ra[ip:ic,:],\
# 'VEavgbin_ra':self.VEavgbin_ra[ip:ic,:],'VIavgbin_ra':self.VIavgbin_ra[ip:ic,:],'VEstdbin_ra':self.VEstdbin_ra[ip:ic,:],'VIstdbin_ra':self.VIstdbin_ra[ip:ic,:],\
# 'rEbin_ra':self.rEbin_ra[:,:,ip:ic],'rIbin_ra':self.rIbin_ra[:,:,ip:ic],'P_MFEbin_ra':self.P_MFEbin_ra[ip:ic,:]})
# # filelrname=str(time.strftime(timeformat)) + str(intic) + '_LR.mat'
# # scio.savemat(filelrname, {'NMDAEbin_ra':self.NMDAEbin_ra[ip:ic,:],'NMDAIbin_ra':self.NMDAIbin_ra[ip:ic,:],\
# # 'HNMDAEbin_ra':self.HNMDAEbin_ra[ip:ic,:],'HNMDAI_ra':self.HNMDAIbin_ra[ip:ic,:],\
# # 'tau_NMDA':self.tau_NMDA})
# if np.mod(counter,10000)==0:
# indexc = np.floor(counter/10000)
# timeformat = '%Y%m%d%H'
# filename= 'rhovp.mat'
# scio.savemat(filename, {'rEbinp_ra': self.rEbinp_ra, 'rIbinp_ra': self.rIbinp_ra,'VEbinp_ra':self.VEbinp_ra,'VIbinp_ra':self.VIbinp_ra})
#
#
return self.mEbin_ra,self.mIbin_ra,self.rEbin_ra,self.rIbin_ra,self.P_MFEbin_ra,self.NMDAEbin_ra,self.NMDAIbin_ra,self.VEavgbin_ra,self.VIavgbin_ra,self.VEstdbin_ra,self.VIstdbin_ra,\
self.VEmubin_ra,self.VImubin_ra,self.VEsigbin_ra,self.VIsigbin_ra
def update(self, t0, dt, tf):
self.dt = dt
self.tf = tf
# initialize:
start_time = time.time()
self.initialize(t0)
self.initialize_time_period = time.time() - start_time
# start_running
start_time = time.time()
counter = 0
numCGPatch = self.Net_settings['nmax'] * 2
print(
'Number of both Excitatory and Inhibitory populations(double of NPATCH): ',
self.Net_settings['nmax'] * 2)
'''
at first
'''
Vbins, Vedges, NPATCH = self.Vbins, self.Vedges, self.NPATCH
LEE, LIE = self.LEE, self.LIE
# flagS,flagE = 0,0
while self.t < self.tf:
# refresh current time as well as current time-step
self.t += self.dt
''' tbinsize represents time for one time bin '''
self.tbin_tmp = int(np.floor(self.t / self.tbinsize))
'''
for c in self.connection_list:
# if (c.conn_type == 'LongRange') & ((self.tf-self.t)>2.0):
# print('changed weights:',c.weights)
if (self.t > 100.0) & (flagS <4):
print('current time',self.t)
if (c.conn_type == 'LongRange') & (c.ei_pop_post == 'e'):
flagS += 1
c.weights /= 1.2
c.weights *= 2.66#2.85#2.6#2.1#1.8
print('change e to e Long range, flag',flagS,' value:',c.weights)
if (c.conn_type == 'LongRange') & (c.ei_pop_post == 'i'):
flagS += 1
c.weights /= 1.2
c.weights *= 1.2#3.60#3.6
print('change e to i Long range, flag',flagS,' value:',c.weights)
if (self.t > 100.0) & (flagE <4):
print('current time',self.t)
if (c.conn_type == 'LongRange') & (c.ei_pop_post == 'e'):
flagE += 1
c.weights /= 2.66#2.85
c.weights *= 1.20#2.6#2.1#1.8
print('change e to e Long range, flag',flagE,' value:',c.weights)
if (c.conn_type == 'LongRange') & (c.ei_pop_post == 'i'):
flagE += 1
c.weights /= 1.2
c.weights *= 1.2#3.60#3.6
print('change e to i Long range, flag',flagE,' value:',c.weights)
'''
ind_rec, idxE, idxI = 0, 0, 0 # start to accumulate index of hypercolumn
for p in self.population_list:
''' updating OP 2 modes: updating under Moment/updating under MFE '''
# updating under Moment- full
p.USUALorMFE = 1
ind_rec += 1
'''
Recording at first, before p.update(),
rE and rI purely from(after) MFE should be recorded in rE/I(bin)_ra, rather
than RvE from Moment
'''
# before Moment iteration
if (ind_rec > numCGPatch
): # means internal-population, not external-population
if p.ei_pop == 'e':
''' Voltage distribution should be recorded each dt as well as each dtbin'''
# each dt !!!
'''
# dt-recording
self.VEavg_ra[counter,idxE] = p.v1
self.VEstd_ra[counter,idxE] = np.sqrt(p.v2-p.v1**2)
'''
# dtbin-recording
self.VEavgbin_ra[self.tbin_tmp, idxE] += p.v1 * dt
self.VEstdbin_ra[self.tbin_tmp,
idxE] += np.sqrt(p.v2 - p.v1**2) * dt
self.rEbin_ra[idxE, :,
self.tbin_tmp] += p.curr_rhov * self.dt
idxE += 1
else:
''' Voltage distribution should be recorded each dt as well as each dtbin'''
# dt-recording VE/Iavg
# each dt !!!
'''
self.VIavg_ra[counter,idxI] = p.v1
self.VIstd_ra[counter,idxI] = np.sqrt(p.v2-p.v1**2)
'''
# dtbin-recording
self.VIavgbin_ra[self.tbin_tmp, idxI] += p.v1 * dt
self.VIstdbin_ra[self.tbin_tmp,
idxI] += np.sqrt(p.v2 - p.v1**2) * dt
self.rIbin_ra[idxI, :,
self.tbin_tmp] += p.curr_rhov * self.dt
idxI += 1
p.update()
'''
when using USUALorMFE==1
updating rhov as well as firing rate
next, should record firing rate mE/I in mE/I(bin)_ra
[but not rE/I(bin)_ra]
and also, RvE/I were extracted out from p-list, which were used
to calculate MFE probability
'''
if (counter > -1):
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
continue
#print('excite : %.5f'%p.local_pevent)
ind_rec, idxE, idxI = 0, 0, 0
for p in self.population_list:
ind_rec += 1
if (counter > -1):
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
'''
and also extract curr_rhov to calculate PMFE
'''
self.rE[:, idxE] = p.curr_rhov
# print('pre: ',p.firing_rate)
# p.firing_rate = 0.0
# print('pos: ',p.curr_firing_rate)
'''
here, recording new firing rate
mE/I_ra
and also extract curr_rhov to calculate PMFE
'''
# each dt !!!
'''
self.mE_ra[counter,idxE] = p.curr_firing_rate
self.NMDAE_ra[counter,idxE] = p.acm_NMDA
'''
self.p_single[
idxE] = p.curr_firing_rate * self.dt * p.NumCell
idxE += 1
else:
# each dt !!!
'''
self.mI_ra[counter,idxI] = p.curr_firing_rate
self.NMDAI_ra[counter,idxI] = p.acm_NMDA
'''
self.rI[:, idxI] = p.curr_rhov
idxI += 1
''' start to calculate P_MFE for each time step '''
''' vedges is new for calculate MFE '''
NE, NI = self.NE, self.NI
NPATCH = self.NPATCH
h = self.Vedges[1] - self.Vedges[0]
local_pevent = 1.0
for isource in range(self.NPATCH):
#print('sim:')
local_pevent = 1.0
for jt in range(self.NPATCH):
#print(self.idx_kickE[jt,isource])
#print(self.idx_kickI[jt,isource])
kickE, kickI = self.idx_kickE[jt, isource], self.idx_kickI[
jt, isource]
idx_vT = self.idx_vT
''' Excitatory '''
trhov = np.squeeze(self.rE[:, jt])
if isource != jt:
Nup = NE
else:
Nup = NE
prob_event = (
1.0 - np.sum(np.squeeze(trhov[kickE:idx_vT])) * h)**Nup
local_pevent *= prob_event
''' Inhibitory '''
trhov = np.squeeze(self.rI[:, jt])
Nup = NI
prob_event = (
1.0 - np.sum(np.squeeze(trhov[kickI:idx_vT])) * h)**Nup
local_pevent *= prob_event
self.MFE_pevent[isource] = self.p_single[isource] * (
1 - local_pevent)
#print('check MFE:%.5f'% self.MFE_pevent[isource])
''' then prepare for MFE '''
MFE_pevent_max = max(
self.MFE_pevent) # choose the maximum-value from all possible
#print('MFE_max_value: ',MFE_pevent_max)
# trigger-pattern
''' recording MFE-probability '''
'''
# dt-recording
self.P_MFE_ra[counter] = MFE_pevent_max
'''
# dt-bin recording probability of MFE
self.P_MFEbin_ra[self.tbin_tmp, 0] += MFE_pevent_max * dt
idx_pevent_max = np.argmax(self.MFE_pevent)
''' could also record which excitatory population appropriately trigger the MFE '''
self.idx_MFE_ra[counter] = idx_pevent_max
self.MFE_flag = 0
local_pevent_d = np.random.random()
if local_pevent_d < MFE_pevent_max:
self.MFE_flag = 1
self.MFE_num += 1
self.idx_MFE_eff[self.MFE_num] = idx_pevent_max
self.P_MFE_eff[self.MFE_num] = MFE_pevent_max
VE = np.zeros((self.NE, self.NPATCH))
VI = np.zeros((self.NI, self.NPATCH))
''' distribution sampling '''
for i in range(self.NPATCH):
V_sample = util.getsamples(np.squeeze(self.Vedges[1:]),
np.squeeze(self.rE[:, i]),
self.NE)
VE[:, i] = np.squeeze(V_sample)
V_sample = util.getsamples(np.squeeze(self.Vedges[1:]),
np.squeeze(self.rI[:, i]),
self.NI)
VI[:, i] = np.squeeze(V_sample)
''' trigger neuron '''
VE[0:2, idx_pevent_max] = 1.0
DEEu = self.DEE.copy()
DIEu = self.DIE.copy()
DEIu = self.DEI.copy()
DIIu = self.DII.copy()
pop_idx_E = np.zeros((self.NE, self.NPATCH), dtype=int)
pop_idx_I = np.zeros((self.NI, self.NPATCH), dtype=int)
for i in range(self.NPATCH):
pop_idx_E[:, i] = i
pop_idx_I[:, i] = i
(E_fired, I_fired, VE_pre, VI_pre, VE_pos,
VI_pos) = util.getMFE_ifdyn(0, VE, VI, DEEu, DEIu, DIEu, DIIu,
0, 0, pop_idx_E, pop_idx_I)
'''
# wrong E_fired_num arrangement!!!!!!!
E_fired_num,I_fired_num = np.zeros((NE*NPATCH,1)),np.zeros((NI*NPATCH,1))
E_fired_num[E_fired] = 1
I_fired_num[I_fired] = 1
E_fired_num = np.reshape(E_fired_num,(NE,NPATCH))
I_fired_num = np.reshape(I_fired_num,(NI,NPATCH))
E_ind_num = np.sum(E_fired_num,axis = 0)
I_ind_num = np.sum(I_fired_num,axis = 0)
'''
E_fired_num, I_fired_num = np.zeros(
(NE * NPATCH, 1)), np.zeros((NI * NPATCH, 1))
E_fired_num[E_fired] = 1
I_fired_num[I_fired] = 1
E_fired_num = np.reshape(E_fired_num, (NPATCH, NE))
E_fired_num = E_fired_num.T
I_fired_num = np.reshape(I_fired_num, (NPATCH, NI))
I_fired_num = I_fired_num.T
E_ind_num = np.sum(E_fired_num, axis=0)
I_ind_num = np.sum(I_fired_num, axis=0)
#print('E_num ',E_ind_num,'; I_num ',I_ind_num)
#print('E_fired', E_fired_num)
for i in range(NPATCH):
self.LE_ra[self.MFE_num, i] = E_ind_num[i]
print('E-fired: ', E_ind_num[i])
self.LI_ra[self.MFE_num, i] = I_ind_num[i]
VEpos, VIpos, VEpre, VIpre = VE_pos.copy(), VI_pos.copy(
), VE_pre.copy(), VI_pre.copy()
Vedges = self.Vedges
Vbins = self.Vbins
h = Vbins[2] - Vbins[1]
rE, rI = np.zeros((len(Vbins), NPATCH)), np.zeros(
(len(Vbins), NPATCH))
'''
resample and produce new voltage distribution after MFE correction
'''
for i in range(NPATCH):
VEposu = np.squeeze(VEpos[:, i])
rE_tmp, Vedge = np.histogram(VEposu, Vedges)
# new rhov
rE[:, i] = rE_tmp / (self.NE * h) #(np.sum(rE_tmp)*h)
#print('sum',np.sum(rE_tmp))
VIposu = np.squeeze(VIpos[:, i])
rI_tmp, Vedge = np.histogram(VIposu, Vedges)
# new rhov
rI[:, i] = rI_tmp / (self.NI * h) #(np.sum(rI_tmp)*h)
'''
refresh rhov for each population
'''
idxE, idxI = 0, 0
ind_rec = 0
for p in self.population_list:
ind_rec += 1
if (counter > -1):
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
''' rhovE[i]=0'''
p.rhov[:] = rE[:, idxE]
# ACM_NMDA
extract_HNMDA = 0.0
for inmda in range(NPATCH):
if (inmda == idxE):
extract_HNMDA = extract_HNMDA
else:
extract_HNMDA += E_ind_num[
inmda] * LEE[idxE, inmda]
print('org E hnmda: ', p.acm_HNMDA)
p.acm_HNMDA = p.acm_HNMDA + extract_HNMDA * self.tau_m
# p.acm_NMDA = p.acm_NMDA *(1.0 - E_ind_num[idxE]/NE)
# p.acm_HNMDA = p.acm_HNMDA *(1.0 - E_ind_num[idxE]/NE)
print('new E nmda: ', p.acm_NMDA)
print('new E hnmda: ', p.acm_HNMDA)
print('extra E hnmda: ', extract_HNMDA)
#plt.plot(p.curr_rhov)
idxE += 1
else:
''' rhovI[i]=0'''
p.rhov[:] = rI[:, idxI]
# ACM_NMDA
extract_HNMDA = 0.0
for inmda in range(NPATCH):
if (inmda == idxI):
extract_HNMDA = extract_HNMDA
else:
extract_HNMDA += E_ind_num[
inmda] * LIE[idxI, inmda]
print('org I hnmda: ', p.acm_HNMDA)
p.acm_HNMDA = p.acm_HNMDA + extract_HNMDA * self.tau_m
# p.acm_NMDA = p.acm_NMDA *(1.0 - I_ind_num[idxI]/NI)
# p.acm_HNMDA = p.acm_HNMDA *(1.0 - I_ind_num[idxI]/NI)
print('new I nmda: ', p.acm_NMDA)
print('new I hnmda: ', p.acm_HNMDA)
print('extra I hnmda: ', extract_HNMDA)
idxI += 1
'''
accumulated_NMDA = self.acm_NMDA
accumulated_HNMDA = self.acm_HNMDA
tt_HNMDA = 0
for c in self.source_connection_list:
if(c.conn_type == 'ShortRange'):
self.total_fpmu_dict[c.connection_distribution] += c.curr_firing_rate * c.nsyn * c.weights
# print 'AMPA: ',c.curr_firing_rate * c.nsyn * c.weights
else:
# self.total_fpmu_dict[c.connection_distribution] += c.curr_Inmda * c.nsyn * c.weights
self.total_Inmda_dict[c.connection_distribution] += c.curr_Inmda * c.nsyn * c.weights
tt_HNMDA += c.curr_firing_rate * self.dt * c.nsyn * c.weights
# tt_HNMDA += self.LE_ra[self.MFE_num,idxE] * c.weights
accumulated_NMDA = accumulated_NMDA * etd + accumulated_HNMDA * cst
accumulated_HNMDA = accumulated_HNMDA * etr + tt_HNMDA * self.tau_m
self.acm_NMDA = accumulated_NMDA
self.acm_HNMDA = accumulated_HNMDA
self.mEbin_ra[tbin,idxE] += (1-self.MFE_flag) * p.curr_firing_rate * NE * dt + self.MFE_flag * self.LE_ra[self.MFE_num,idxE]
'''
V1 = Vbins
V2 = V1 * Vbins
V3 = V2 * Vbins
V4 = V3 * Vbins
h = Vbins[2] - Vbins[1]
vbarE = np.zeros(NPATCH)
wbarE, vbar3E, vbar4E = np.zeros_like(vbarE), np.zeros_like(
vbarE), np.zeros_like(vbarE)
vbarI = np.zeros(NPATCH)
wbarI, vbar3I, vbar4I = np.zeros_like(vbarI), np.zeros_like(
vbarI), np.zeros_like(vbarI)
for i in range(NPATCH):
rE_tmp = np.squeeze(rE[:, i])
rI_tmp = np.squeeze(rI[:, i])
vbarE[i] = np.sum(V1 * rE_tmp) * h
wbarE[i] = np.sum(V2 * rE_tmp) * h
vbar3E[i] = np.sum(V3 * rE_tmp) * h
vbar4E[i] = np.sum(V4 * rE_tmp) * h
vbarI[i] = np.sum(V1 * rI_tmp) * h
wbarI[i] = np.sum(V2 * rI_tmp) * h
vbar3I[i] = np.sum(V3 * rI_tmp) * h
vbar4I[i] = np.sum(V4 * rI_tmp) * h
#print('SHAPE',np.shape(V1),np.shape(rE_tmp))
''' refresh data in simulation '''
idxE, idxI = 0, 0
ind_rec = 0
'''
set v1,v2,v3,v4 from outter
USUALorMFE == 0,only change
VE/Is,DE/I (total.....), notice that before update, mE/I = 0,
p.firing_rate = 0
also,La0/1 equal to zero
recalculate VE/Is DE/I
rhov_EQ(cause VE/Is and DE/I change)
do not change rhov E/I
rhov have resampled after MFE, but didn't give it to p.rhov
so, give it to p-list, and do not change anymore (USUALorMFE==0)
firing rate keep 0 (USUALorMFE)
'''
for p in self.population_list:
ind_rec += 1
if (counter > -1):
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
'''
print previous informatio, before MFE
'''
# print('before MFE, Exc cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
''' me[i]=0'''
p.firing_rate = 0.0
''' v1,v2,v3,v4 '''
p.v1, p.v2, p.v3, p.v4 = vbarE[idxE], wbarE[
idxE], vbar3E[idxE], vbar4E[idxE]
''' la0/1 '''
md_La = np.transpose([1, p.v1, p.v2])
p.La0, p.La1 = np.zeros_like(
md_La), np.zeros_like(md_La)
# print('after MFE, Exc cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
idxE += 1
else:
# print('before MFE, Inh cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
p.firing_rate = 0.0
p.v1, p.v2, p.v3, p.v4 = vbarI[idxI], wbarI[
idxI], vbar3I[idxI], vbar4I[idxI]
md_La = np.transpose([1, p.v1, p.v2])
p.La0, p.La1 = np.zeros_like(
md_La), np.zeros_like(md_La)
# print('after MFE, Inh cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
idxI += 1
''' after reset, calculate again'''
ind_rec = 0
for p in self.population_list:
ind_rec += 1
if (counter > -1):
if (ind_rec > numCGPatch):
p.USUALorMFE = 0
p.update()
# if p.ei_pop == 'e':
# print('after RECALCULATE, Exc cell: ')
# else:
# print('after RECALCULATE, Inh cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
for c in self.connection_list:
c.update()
counter += 1
''' recording ! '''
# DTBIN_RECORD_FLAG
self.tbin_ra[counter] = np.floor(self.t / self.tbinsize)
tbin = int(np.floor(self.t / self.tbinsize))
ind_rec, idxE, idxI = 0, 0, 0
for p in self.population_list:
ind_rec += 1
if (counter > -1):
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
self.tau_NMDA[0, 0] = p.tau_r
self.tau_NMDA[1, 0] = p.tau_d
self.mEbin_ra[tbin, idxE] += (
1 - self.MFE_flag
) * p.curr_firing_rate * NE * dt + self.MFE_flag * self.LE_ra[
self.MFE_num, idxE]
self.xEbin_ra[
tbin,
idxE] += (1 - self.MFE_flag) * util.psample(
p.curr_firing_rate * NE *
dt) + self.MFE_flag * self.LE_ra[
self.MFE_num, idxE]
''' Long range '''
self.HNMDAEbin_ra[tbin,
idxE] += p.acm_HNMDA * NE * dt
self.NMDAEbin_ra[tbin,
idxE] += p.acm_NMDA * NE * dt
idxE += 1
else:
self.mIbin_ra[tbin, idxI] += (
1 - self.MFE_flag
) * p.curr_firing_rate * NI * dt + self.MFE_flag * self.LI_ra[
self.MFE_num, idxI]
self.xIbin_ra[
tbin,
idxI] += (1 - self.MFE_flag) * util.psample(
p.curr_firing_rate * NI *
dt) + self.MFE_flag * self.LI_ra[
self.MFE_num, idxI]
''' Long range '''
self.HNMDAIbin_ra[tbin,
idxI] += p.acm_HNMDA * NI * dt
self.NMDAIbin_ra[tbin,
idxI] += p.acm_NMDA * NI * dt
idxI += 1
''' visualizing '''
if np.mod(counter, 100) < 1:
if np.mod(counter, 100) == 0:
print("t_sum: ", counter * self.dt)
for i in range(NPATCH):
idshown = np.floor(tbin / 5000)
idstart = np.int(idshown * 5000)
if idstart == tbin:
idstart = idstart - 1
idend = min((idshown + 1) * 5000, 20000)
print('Excitatory pop %d :%.4f' %
(i, self.mEbin_ra[tbin, i]))
print('Inhibitory pop %d :%.4f' %
(i, self.mIbin_ra[tbin, i]))
ttt = np.arange(idstart, tbin) * 1.0
plt.figure(10)
plt.subplot(2, 1, int(i) + 1)
plt.plot(ttt, self.mEbin_ra[idstart:tbin, i], 'r')
plt.xlim([ttt[0], ttt[0] + 5000])
plt.ylim([0, 40])
plt.pause(0.1)
plt.figure(11)
plt.subplot(2, 1, int(i) + 1)
plt.plot(ttt, self.mIbin_ra[idstart:tbin, i], 'b')
plt.xlim([ttt[0], ttt[0] + 5000])
# plt.xlim([0,int(self.tf)])
plt.ylim([0, 40])
plt.pause(0.1)
if np.mod(counter, 50000) == 0:
icounter = np.ceil(counter / 50000)
intic, ip, ic = int(icounter), int((icounter - 1) * 5000), int(
(icounter) * 5000)
timeformat = '%Y%m%d%H'
filename = str(time.strftime(timeformat)) + str(intic) + '.mat'
scio.savemat(filename,{'mEbin_ra':self.mEbin_ra[ip:ic,:],'mIbin_ra':self.mIbin_ra[ip:ic,:],'xEbin_ra':self.xEbin_ra[ip:ic,:],'xIbin_ra':self.xIbin_ra[ip:ic,:],\
'VEavgbin_ra':self.VEavgbin_ra[ip:ic,:],'VIavgbin_ra':self.VIavgbin_ra[ip:ic,:],'VEstdbin_ra':self.VEstdbin_ra[ip:ic,:],'VIstdbin_ra':self.VIstdbin_ra[ip:ic,:],\
'rEbin_ra':self.rEbin_ra[:,:,ip:ic],'rIbin_ra':self.rIbin_ra[:,:,ip:ic],'P_MFEbin_ra':self.P_MFEbin_ra[ip:ic,:]})
filelrname = str(
time.strftime(timeformat)) + str(intic) + '_LR.mat'
scio.savemat(filelrname, {'NMDAEbin_ra':self.NMDAEbin_ra[ip:ic,:],'NMDAIbin_ra':self.NMDAIbin_ra[ip:ic,:],\
'HNMDAEbin_ra':self.HNMDAEbin_ra[ip:ic,:],'HNMDAI_ra':self.HNMDAIbin_ra[ip:ic,:],\
'tau_NMDA':self.tau_NMDA})
return self.mEbin_ra, self.mIbin_ra, self.xEbin_ra, self.xIbin_ra, self.rEbin_ra, self.rIbin_ra, self.P_MFEbin_ra, self.NMDAEbin_ra, self.NMDAIbin_ra, self.HNMDAEbin_ra, self.HNMDAIbin_ra, self.VEavgbin_ra, self.VIavgbin_ra, self.VEstdbin_ra, self.VIstdbin_ra
def update(self, t0=0.0, dt=1e-1, tf=200.0):
self.dt = dt
self.tf = tf
# initialize:
start_time = time.time()
self.initialize(t0)
self.initialize_time_period = time.time() - start_time
# start_running
start_time = time.time()
counter = 0
numCGPatch = self.Net_settings['nmax'] * 2
print('nET:', self.Net_settings['nmax'] * 2)
'''
at first
'''
Vbins, Vedges, NPATCH = self.Vbins, self.Vedges, self.NPATCH
while self.t < self.tf:
self.t += self.dt
self.tbin_tmp = int(np.floor(self.t / self.tbinsize * self.dt))
ind_rec = 0
#if self.verbose: print ('time: %s' % self.t)
idxE, idxI = 0, 0 # start to accumulate index of hypercolumn
for p in self.population_list:
p.USUALorMFE = 1
p.update()
ind_rec += 1
if (ind_rec > numCGPatch):
# print('num: ',numCGPatch,np.shape(self.v_record))
# print('ind_rec:',ind_rec,'numCG:',numCGPatch)
self.v_record[ind_rec - numCGPatch,
counter] = p.local_pevent #curr_firing_rate#
self.m_record[ind_rec - numCGPatch,
counter] = p.curr_firing_rate #
if (counter > 0):
if (ind_rec <= numCGPatch):
print('')
else: # pnly for interneuron, the MFE make sense
if p.ei_pop == 'e':
print('excite : %.5f' % p.local_pevent)
else:
print('ind : %.5f' % p.local_pevent)
ind_rec = 0
for p in self.population_list:
ind_rec += 1
if (counter > 0):
if (ind_rec <= numCGPatch):
print('')
else: # pnly for interneuron, the MFE make sense
if p.ei_pop == 'e':
self.rE[:, idxE] = p.curr_rhov
self.rEbin_ra[
idxE, :,
self.tbin_tmp] += p.curr_rhov * self.dt
# print('pre: ',p.firing_rate)
# p.firing_rate = 0.0
# print('pos: ',p.curr_firing_rate)
self.mE_ra[counter, idxE] = p.curr_firing_rate
self.p_single[
idxE] = p.curr_firing_rate * self.dt * p.NumCell
self.VEavg_ra[counter, idxE] = p.v1
self.VEstd_ra[counter,
idxE] = np.sqrt(p.v2 - p.v1**2)
self.VEavgbin_ra[self.tbin_tmp, idxE] += p.v1 * dt
self.VEstdbin_ra[self.tbin_tmp,
idxE] += np.sqrt(p.v2 -
p.v1**2) * dt
idxE += 1
else:
self.mI_ra[counter, idxI] = p.curr_firing_rate
self.rI[:, idxI] = p.curr_rhov
self.rIbin_ra[
idxI, :,
self.tbin_tmp] += p.curr_rhov * self.dt
self.VIavg_ra[counter, idxI] = p.v1
self.VIstd_ra[counter,
idxI] = np.sqrt(p.v2 - p.v1**2)
self.VIavgbin_ra[self.tbin_tmp, idxI] += p.v1 * dt
self.VIstdbin_ra[self.tbin_tmp,
idxI] += np.sqrt(p.v2 -
p.v1**2) * dt
idxI += 1
''' start to calculate P_MFE for each time step '''
''' vedges is new for calculate MFE '''
NE, NI = self.NE, self.NI
NPATCH = self.NPATCH
h = self.Vedges[1] - self.Vedges[0]
local_pevent = 1.0
for isource in range(self.NPATCH):
#print('sim:')
local_pevent = 1.0
for jt in range(self.NPATCH):
#print(self.idx_kickE[jt,isource])
#print(self.idx_kickI[jt,isource])
kickE, kickI = self.idx_kickE[jt, isource], self.idx_kickI[
jt, isource]
idx_vT = self.idx_vT
''' Excitatory '''
trhov = np.squeeze(self.rE[:, jt])
if isource != jt:
Nup = NE
else:
Nup = NE
prob_event = (
1.0 - np.sum(np.squeeze(trhov[kickE:idx_vT])) * h)**Nup
local_pevent *= prob_event
''' Inhibitory '''
trhov = np.squeeze(self.rI[:, jt])
Nup = NI
prob_event = (
1.0 - np.sum(np.squeeze(trhov[kickI:idx_vT])) * h)**Nup
local_pevent *= prob_event
self.MFE_pevent[isource] = self.p_single[isource] * (
1 - local_pevent)
print('check MFE:%.5f' % self.MFE_pevent[isource])
''' then prepare for MFE '''
MFE_pevent_max = max(self.MFE_pevent)
self.P_MFE_ra[counter, 0] = MFE_pevent_max
#print('wrong:',self.tbin_tmp)
self.P_MFEbin_ra[self.tbin_tmp] += MFE_pevent_max * dt
idx_pevent_max = np.argmax(self.MFE_pevent)
self.MFE_flag = 0
local_pevent_d = np.random.random()
if local_pevent_d < MFE_pevent_max:
self.MFE_flag = 1
self.MFE_num += 1
VE = np.zeros((self.NE, self.NPATCH))
VI = np.zeros((self.NI, self.NPATCH))
''' distribution sampling '''
for i in range(self.NPATCH):
V_sample = util.getsamples(np.squeeze(self.Vedges[1:]),
np.squeeze(self.rE[:, i]),
self.NE)
VE[:, i] = np.squeeze(V_sample)
V_sample = util.getsamples(np.squeeze(self.Vedges[1:]),
np.squeeze(self.rI[:, i]),
self.NI)
VI[:, i] = np.squeeze(V_sample)
''' trigger neuron '''
VE[0:2, idx_pevent_max] = 1.0
DEEu = self.DEE.copy()
DIEu = self.DIE.copy()
DEIu = self.DEI.copy()
DIIu = self.DII.copy()
pop_idx_E = np.zeros((self.NE, self.NPATCH), dtype=int)
pop_idx_I = np.zeros((self.NI, self.NPATCH), dtype=int)
for i in range(self.NPATCH):
pop_idx_E[:, i] = i
pop_idx_I[:, i] = i
(E_fired, I_fired, VE_pre, VI_pre, VE_pos,
VI_pos) = util.getMFE_ifdyn(0, VE, VI, DEEu, DEIu, DIEu, DIIu,
0, 0, pop_idx_E, pop_idx_I)
E_fired_num, I_fired_num = np.zeros(
(NE * NPATCH, 1)), np.zeros((NI * NPATCH, 1))
E_fired_num[E_fired] = 1
I_fired_num[I_fired] = 1
E_fired_num = np.reshape(E_fired_num, (NE, NPATCH))
I_fired_num = np.reshape(I_fired_num, (NI, NPATCH))
E_ind_num = np.sum(E_fired_num, axis=0)
I_ind_num = np.sum(I_fired_num, axis=0)
for i in range(NPATCH):
self.LE_ra[self.MFE_num, i] = E_ind_num[i]
self.LI_ra[self.MFE_num, i] = I_ind_num[i]
VEpos, VIpos, VEpre, VIpre = VE_pos, VI_pos, VE_pre, VI_pre
Vedges = self.Vedges
Vbins = self.Vbins
h = Vbins[2] - Vbins[1]
rE, rI = np.zeros((len(Vbins), NPATCH)), np.zeros(
(len(Vbins), NPATCH))
for i in range(NPATCH):
VEposu = np.squeeze(VEpos[:, i])
rE_tmp, Vedge = np.histogram(VEposu, Vedges)
rE[:, i] = rE_tmp / (np.sum(rE_tmp) * h)
#print('sum',np.sum(rE_tmp))
#plt.plot(rE[:,i])
VIposu = np.squeeze(VIpos[:, i])
rI_tmp, Vedge = np.histogram(VIposu, Vedges)
rI[:, i] = rI_tmp / (np.sum(rI_tmp) * h)
V1 = Vbins
V2 = V1 * Vbins
V3 = V2 * Vbins
V4 = V3 * Vbins
h = Vbins[2] - Vbins[1]
vbarE = np.zeros(NPATCH)
wbarE, vbar3E, vbar4E = np.zeros_like(vbarE), np.zeros_like(
vbarE), np.zeros_like(vbarE)
vbarI = np.zeros(NPATCH)
wbarI, vbar3I, vbar4I = np.zeros_like(vbarI), np.zeros_like(
vbarI), np.zeros_like(vbarI)
for i in range(NPATCH):
rE_tmp = np.squeeze(rE[:, i])
rI_tmp = np.squeeze(rI[:, i])
vbarE[i] = np.sum(V1 * rE_tmp) * h
wbarE[i] = np.sum(V2 * rE_tmp) * h
vbar3E[i] = np.sum(V3 * rE_tmp) * h
vbar4E[i] = np.sum(V4 * rE_tmp) * h
vbarI[i] = np.sum(V1 * rI_tmp) * h
wbarI[i] = np.sum(V2 * rI_tmp) * h
vbar3I[i] = np.sum(V3 * rI_tmp) * h
vbar4I[i] = np.sum(V4 * rI_tmp) * h
print('SHAPE', np.shape(V1), np.shape(rE_tmp))
''' refresh data in simulation '''
idxE, idxI = 0, 0
ind_rec = 0
for p in self.population_list:
ind_rec += 1
if (counter > 0):
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
'''
print previous informatio, before MFE
'''
# print('before MFE, Exc cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
''' me[i]=0'''
p.firing_rate = 0.0
''' v1,v2,v3,v4 '''
p.v1, p.v2, p.v3, p.v4 = vbarE[idxE], wbarE[
idxE], vbar3E[idxE], vbar4E[idxE]
''' la0/1 '''
md_La = np.zeros_like(p.La0)
p.La0, p.La1 = md_La, md_La
# print('after MFE, Exc cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
idxE += 1
else:
# print('before MFE, Inh cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
p.firing_rate = 0.0
p.v1, p.v2, p.v3, p.v4 = vbarI[idxI], wbarI[
idxI], vbar3I[idxI], vbar4I[idxI]
md_La = np.zeros_like(p.La0)
p.La0, p.La1 = md_La, md_La
# print('after MFE, Inh cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
idxI += 1
''' after reset, calculate again'''
ind_rec = 0
for p in self.population_list:
ind_rec += 1
if (counter > 0):
if (ind_rec > numCGPatch):
p.USUALorMFE = 0
p.update()
# if p.ei_pop == 'e':
# print('after RECALCULATE, Exc cell: ')
# else:
# print('after RECALCULATE, Inh cell: ')
# print('firing rate: ',p.curr_firing_rate)
# print('moment: v1 %.5f'%(p.v1))
# print('Lag-parame: ',p.La0)
for c in self.connection_list:
c.update()
counter += 1
''' recording ! '''
# DTBIN_RECORD_FLAG
self.tbin_ra[counter] = np.floor(self.t / self.tbinsize)
tbin = int(np.floor(self.t / self.tbinsize))
ind_rec, idxE, idxI = 0, 0, 0
for p in self.population_list:
ind_rec += 1
if (counter > 0):
if (ind_rec > numCGPatch):
if p.ei_pop == 'e':
self.mEbin_ra[tbin, idxE] += (
1 - self.MFE_flag
) * p.curr_firing_rate * NE * dt + self.MFE_flag * self.LE_ra[
self.MFE_num, idxE]
idxE += 1
else:
self.mIbin_ra[tbin, idxI] += (
1 - self.MFE_flag
) * p.curr_firing_rate * NE * dt + self.MFE_flag * self.LI_ra[
self.MFE_num, idxI]
idxI += 1
return self.mEbin_ra, self.mIbin_ra, self.VEavg_ra, self.VIavg_ra, self.VEstd_ra, self.VIstd_ra
