def initialize_MFE(self):
self.trhov = self.post_population.curr_rhov
vT = 1.0
value_kick = vT - self.weights
# get v
Vedges = util.get_v_edges(self.v_min, self.v_max, self.dv)
Vbins = 0.5 * (Vedges[0:-1] + Vedges[1:])
idx_vT = len(Vedges) - 1 # len(Vbins)
Ind_k1 = np.where(Vedges > value_kick)
if np.shape(Ind_k1)[1] > 0:
idx_kick = Ind_k1[0][0]
else:
idx_kick = idx_vT
self.idx_kick = idx_kick
self.idx_vT = idx_vT
self.V_sample_post = self.post_population.curr_V_sample
self.ei_pop_post = self.post_population.ei_pop
def initialize_edges(self):
# initialize discreted voltage bins
self.edges = util.get_v_edges(self.v_min, self.v_max, self.dv)
def initialize(self, t0=0.0):
"""
initialize by hand, first put all sub-population and connection-pair
!!! put them on the same platform!!! simulationBridge
"""
''' initialize P_MFE '''
''' at first, we only use NHYP as NPATCH '''
self.iteration_max = self.ntt + 100
iteration_max = self.iteration_max
self.tbin_tmp = 0 # initial
self.tbinsize = 1.0
dtperbin = int(self.tbinsize / self.dt)
self.dtperbin = dtperbin
iteration_bin = int(iteration_max / dtperbin)
NPATCH = self.Net_settings['nmax']
NE, NI = self.NE, self.NI
NPHA = 4
self.VE, self.VI = np.zeros((NE, NPHA * NPATCH)), np.zeros(
(NI, NPHA * NPATCH))
# DTBIN_RECORD_FLAG
self.tbin_ra = np.zeros((iteration_max, 1))
self.mE_ra = np.zeros((iteration_max, NPHA * NPATCH))
self.mI_ra = np.zeros((iteration_max, NPHA * NPATCH))
self.mEbin_ra = np.zeros((iteration_bin, NPHA * NPATCH))
self.mIbin_ra = np.zeros_like(self.mEbin_ra)
self.xEbin_ra = np.zeros_like(self.mEbin_ra)
self.xIbin_ra = np.zeros_like(self.xEbin_ra)
self.nEbin_ra = np.zeros_like(self.xEbin_ra)
self.nIbin_ra = np.zeros_like(self.xEbin_ra)
self.VEavgbin_ra = np.zeros((iteration_bin, NPHA * NPATCH))
self.VIavgbin_ra = np.zeros_like(self.VEavgbin_ra)
self.VEstdbin_ra = np.zeros_like(self.VIavgbin_ra)
self.VIstdbin_ra = np.zeros_like(self.VEstdbin_ra)
self.VEavg_ra = np.zeros((iteration_max, NPHA * NPATCH))
self.VIavg_ra = np.zeros_like(self.VEavg_ra)
self.VEstd_ra = np.zeros_like(self.VIavg_ra)
self.VIstd_ra = np.zeros_like(self.VEstd_ra)
self.rE, self.rI = None, None
self.NPATCH = NPATCH
self.NPHA = NPHA
dv = self.Net_settings['dv']
self.Vedges = util.get_v_edges(-1.0, 1.0, dv)
''' bins = edges - 1'''
# in internal , rhov length len(self.Vbins), len(Vedges)-1
self.Vbins = 0.5 * (self.Vedges[0:-1] + self.Vedges[1:])
Vedges = self.Vedges
Vbins = self.Vbins
self.rE = np.zeros((len(self.Vbins), self.NPATCH * self.NPHA))
self.rI = np.zeros_like(self.rE)
# An connection_distribution_list (store unique connection(defined by weight,syn,prob))
self.connection_distribution_collection = ConnectionDistributionCollection(
) # this is
self.t = t0
# Matrix to record
numCGPatch = self.Net_settings['nmax'] * 2 # excitatory and inhibitory
# 2 * numCGPatch = External Population and Recurrent Population
# set Matrix to record only Internal Population
self.m_record = np.zeros((NPHA * (numCGPatch + 1), self.ntt + 10))
self.v_record = np.zeros_like(self.m_record)
# put all subpopulation and all connections into the same platform
for subpop in self.population_list:
subpop.simulation = self # .simulation = self(self is what we called 'simulation')
for connpair in self.connection_list:
connpair.simulation = self
# initialize population_list, calculate
for p in self.population_list:
p.initialize() # 2
for c in self.connection_list:
#print 'initialize population'
c.initialize() # 1
def initialize(self,t0=0.0):
"""
initialize by hand, first put all sub-population and connection-pair
"""
''' initialize P_MFE '''
''' at first, we only use NHYP as NPATCH '''
self.iteration_max = self.ntt+100
iteration_max = self.iteration_max
self.tbin_tmp = 0 # initial
self.tbinsize = 1.0
dtperbin = int(self.tbinsize/self.dt)
self.dtperbin = dtperbin
iteration_bin = int(iteration_max/dtperbin)
NPATCH = self.Net_settings['nmax']
NE,NI = self.NE,self.NI
self.VE,self.VI = np.zeros((NE,NPATCH)),np.zeros((NI,NPATCH))
# DTBIN_RECORD_FLAG
self.tbin_ra = np.zeros((iteration_max,1))
self.mEbin_ra = np.zeros((iteration_bin,NPATCH))
self.mIbin_ra = np.zeros_like(self.mEbin_ra)
self.xEbin_ra = np.zeros_like(self.mEbin_ra)
self.xIbin_ra = np.zeros_like(self.xEbin_ra)
self.nEbin_ra = np.zeros_like(self.xEbin_ra)
self.nIbin_ra = np.zeros_like(self.xEbin_ra)
''' also recording possible MFE as well as effective MFE'''
# possible MFE-prob and index
self.P_MFEbin_ra = np.zeros_like(self.xIbin_ra)
self.P_MFE_ra = np.zeros((iteration_max,1))
self.idx_MFE_ra = np.zeros((iteration_max,1))
# effective MFE-prob and index
self.P_MFE_eff = np.zeros((iteration_max,1))
self.idx_MFE_eff = np.zeros((iteration_max,1))
self.rEbin_ra = np.zeros((NPATCH,2000,iteration_bin))
self.rIbin_ra = np.zeros_like(self.rEbin_ra)
self.VEavgbin_ra = np.zeros_like(self.P_MFEbin_ra)
self.VIavgbin_ra = np.zeros_like(self.VEavgbin_ra)
self.VEstdbin_ra = np.zeros_like(self.VIavgbin_ra)
self.VIstdbin_ra = np.zeros_like(self.VEstdbin_ra)
self.rE,self.rI = None,None
self.NPATCH = NPATCH
self.LE_ra = np.zeros((iteration_max,NPATCH))
self.LI_ra = np.zeros_like(self.LE_ra)
DEE,DIE,DEI,DII = self.DEE,self.DIE,self.DEI,self.DII
vT = 1.0
dv = self.Net_settings['dv']
self.Vedges = util.get_v_edges(-1.0,1.0,dv)
''' bins = edges - 1'''
# in internal , rhov length len(self.Vbins), len(Vedges)-1
self.Vbins = 0.5*(self.Vedges[0:-1] + self.Vedges[1:])
Vedges = self.Vedges
Vbins = self.Vbins
idx_vT = len(Vedges)-1 #len(Vbins)
idx_kickE,idx_kickI = np.zeros((NPATCH,NPATCH),dtype=int),np.zeros((NPATCH,NPATCH),dtype=int)
for it in range(self.NPATCH):
for js in range(self.NPATCH):
value_kickE = vT - DEE[it,js]
value_kickI = vT - DIE[it,js]
Ind_k1 = np.where(Vedges>value_kickE)
IndI_k1 = np.where(Vedges>value_kickI)
if np.shape(Ind_k1)[1]>0:
idx_kickE[it,js] = Ind_k1[0][0]
else:
idx_kickE[it,js] = idx_vT
if np.shape(IndI_k1)[1]>0:
idx_kickI[it,js] = IndI_k1[0][0]
else:
idx_kickI[it,js] = idx_vT
self.idx_kickE,self.idx_kickI = idx_kickE,idx_kickI
self.idx_vT = idx_vT
self.MFE_pevent = np.zeros(self.NPATCH)
self.p_single = np.zeros(self.NPATCH)
self.rE = np.zeros((len(self.Vbins),self.NPATCH))
self.rI = np.zeros_like(self.rE)
# An connection_distribution_list (store unique connection(defined by weight,syn,prob))
self.connection_distribution_collection = ConnectionDistributionCollection() # this is
self.t = t0
# Matrix to record
numCGPatch = self.Net_settings['nmax'] * 2 # excitatory and inhibitory
# 2 * numCGPatch = External Population and Recurrent Population
# set Matrix to record only Internal Population
self.m_record = np.zeros((numCGPatch+1, self.ntt + 10))
self.v_record = np.zeros_like(self.m_record)
# put all subpopulation and all connections into the same platform
for subpop in self.population_list:
subpop.simulation = self # .simulation = self(self is what we called 'simulation')
for connpair in self.connection_list:
connpair.simulation = self
# initialize population_list, calculate
for p in self.population_list:
p.initialize() # 2
for c in self.connection_list:
c.initialize() # 1
"""
"""
simulation = Simulation(population_list,
connection_list,
Net_settings,
Cell_type_num,
verbose=True)
mEbin_ra, mIbin_ra, xEbin_ra, xIbin_ra, VEavg_ra, VIavg_ra, VEstd_ra, VIstd_ra, rEbin_ra, rIbin_ra, P_MFEbin_ra = simulation.update(
t0=t0, dt=dt, tf=tf)
'''
if plot_flag == 1 and dtbin_record_flag == 1
means that figures should be plotted and time-bin recording rather than tiny
time interval is used as minimum recording time step
'''
# for figure 2
Vedges = util.get_v_edges(-1, 1.0, dv)
Vbins = 0.5 * (Vedges[:-1] + Vedges[1:])
plt.figure()
for idx_pop in range(NPATCH):
# POPULATION ipop
plt.subplot(2, 1, idx_pop + 1)
rEpop, rIpop = np.squeeze(rEbin_ra[idx_pop, :, :]), np.squeeze(
rIbin_ra[idx_pop, :, :])
mEpop, mIpop = np.squeeze(mEbin_ra[:,
idx_pop]), np.squeeze(mIbin_ra[:,
idx_pop])
xEpop, xIpop = np.squeeze(xEbin_ra[:,
idx_pop]), np.squeeze(xIbin_ra[:,
idx_pop])
VEavgpop, VIavgpop = np.squeeze(VEavg_ra[:, idx_pop]), np.squeeze(
def initialize(self, t0=0.0):
"""
The Most Important Issue in This File is, Both Populations and Connections Are within One Shared Plantform Called Simulation, Thus all Personal Variables and Settings Could be Effective Connectted and Have Easier Access to
"""
self.iteration_max = self.ntt + 100
iteration_max = self.iteration_max
self.tbin_tmp = 0 # initial
self.tbinsize = 1.0
dtperbin = int(self.tbinsize / self.dt)
self.dtperbin = dtperbin
# >>>>>>>>>>> Different Time Scale >>>>>>>>>>>>>>
# Record per dt, Record per dtbin
iteration_bin = int(iteration_max / dtperbin)
NPATCH = self.Net_settings['hyp_num']
NE, NI = self.NE, self.NI
self.VE, self.VI = np.zeros((NE, NPATCH)), np.zeros((NI, NPATCH))
# DTBIN_RECORD_FLAG
self.tbin_ra = np.zeros((iteration_max, 1))
# each dt !!!
'''
# each dt
self.mE_ra = np.zeros((iteration_max,NPATCH))
self.mI_ra = np.zeros((iteration_max,NPATCH))
self.NMDAE_ra = np.zeros((iteration_max,NPATCH))
self.NMDAI_ra = np.zeros((iteration_max,NPATCH))
'''
# >>> >>> >>> Remain Each dt >>> >>> >>>
self.P_MFE_ra = np.zeros((iteration_max, NPATCH))
# each tbin
self.mEbin_ra = np.zeros((iteration_bin, NPATCH))
self.mIbin_ra = np.zeros_like(self.mEbin_ra)
self.xEbin_ra = np.zeros_like(self.mEbin_ra)
self.xIbin_ra = np.zeros_like(self.xEbin_ra)
''' long-range '''
self.NMDAEbin_ra = np.zeros_like(self.xEbin_ra)
self.NMDAIbin_ra = np.zeros_like(self.xIbin_ra)
self.tau_NMDA = np.zeros((2, 1))
''' >>>>>>> Possible MFE and inhence Effective MFE >>>>>>>>'''
# >>>>>>>>>> Possible MFE(probability value) and Index >>>>>>>>>>>
self.P_MFEbin_ra = np.zeros_like(self.xIbin_ra)
# >>>>>>>>>> Possible MFE Time (dt)>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.idx_MFE_ra = np.zeros((iteration_max, 1))
# >>>>>>>>>>>>>> Effective/Successful MFE(VALUE), Index and Time >>>>>>>>
self.P_MFE_eff = np.zeros((iteration_max, 1))
# >>>>>>>>>>>>>> Index and Time >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.idx_MFE_eff = np.zeros((iteration_max, 2))
# >>>>>>>>>>>> Normal Voltage Distribution >>>>>>>>>>>>>>>>>>>
self.rEbin_ra = np.zeros((NPATCH, 2000, iteration_bin))
self.rIbin_ra = np.zeros_like(self.rEbin_ra)
# FOR DATA ANALYSIS
# self.rEbinp_ra = np.zeros((NPATCH,2000,5000))
# self.rIbinp_ra = np.zeros_like(self.rEbinp_ra)
self.VEbinp_ra = np.zeros((NPATCH, 652, 12000)) # + time + LE/LI
self.VIbinp_ra = np.zeros_like(self.VEbinp_ra)
self.rhovc = 0
self.VEavgbin_ra = np.zeros_like(self.P_MFEbin_ra)
self.VIavgbin_ra = np.zeros_like(self.VEavgbin_ra)
self.VEstdbin_ra = np.zeros_like(self.VIavgbin_ra)
self.VIstdbin_ra = np.zeros_like(self.VEstdbin_ra)
self.VEmubin_ra = np.zeros_like(self.VIavgbin_ra)
self.VImubin_ra = np.zeros_like(self.VEstdbin_ra)
self.VEsigbin_ra = np.zeros_like(self.VIavgbin_ra)
self.VIsigbin_ra = np.zeros_like(self.VEstdbin_ra)
# each dt !!!
'''
self.VEavg_ra = np.zeros((iteration_max,NPATCH))
self.VIavg_ra = np.zeros_like(self.VEavg_ra)
self.VEstd_ra = np.zeros_like(self.VIavg_ra)
self.VIstd_ra = np.zeros_like(self.VEstd_ra)
'''
# >>>>>>>>>>>>>>>> Instant Recording Rhov >>>>>>>>>>>>
self.rE, self.rI = None, None
self.NPATCH = NPATCH
# why _ra for each dt
self.LE_ra = np.zeros((iteration_max, NPATCH))
self.LI_ra = np.zeros_like(self.LE_ra)
# >>>>>>>>>>>>>>>>>>>> Extract Instant Synaptic Connections from self.structure, Prepare for MFE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DEE, DIE, DEI, DII = self.DEE, self.DIE, self.DEI, self.DII
vT = 1.0
dv = self.Net_settings['dv']
# >>>>>>>>>>>>>>> Vedges --> Node = (max-min)/dv + 1, Vbins --> Bin-central Value >>>>>>>>>
self.Vedges = util.get_v_edges(-1.0, 1.0, dv)
self.Vbins = 0.5 * (self.Vedges[0:-1] + self.Vedges[1:])
Vedges = self.Vedges
Vbins = self.Vbins
idx_vT = len(Vedges) - 1 # or len(Vbins)
idx_kickE, idx_kickI = np.zeros((NPATCH, NPATCH), dtype=int), np.zeros(
(NPATCH, NPATCH), dtype=int)
for it in range(self.NPATCH):
for js in range(self.NPATCH):
value_kickE = vT - DEE[it, js]
value_kickI = vT - DIE[it, js]
Ind_k1 = np.where(Vedges > value_kickE)
IndI_k1 = np.where(Vedges > value_kickI)
if np.shape(Ind_k1)[1] > 0:
idx_kickE[it, js] = Ind_k1[0][0]
else:
idx_kickE[it, js] = idx_vT
if np.shape(IndI_k1)[1] > 0:
idx_kickI[it, js] = IndI_k1[0][0]
else:
idx_kickI[it, js] = idx_vT
self.idx_kickE, self.idx_kickI, self.idx_vT = idx_kickE, idx_kickI, idx_vT
self.MFE_pevent = np.zeros(self.NPATCH)
self.p_single = np.zeros(self.NPATCH)
self.rE = np.zeros((len(self.Vbins), self.NPATCH))
self.rI = np.zeros_like(self.rE)
print('kick!>>', idx_kickE)
print('kick!>>', idx_kickI)
# >>> An connection_distribution_list (store unique connection(defined by weight,syn,prob)) >>>
self.connection_distribution_collection = ConnectionDistributionCollection(
) # this is
self.t = t0 # zero
# >>>>> Number of Internal Populations, Excitatory and Inhibitory Populations Included >>>>
numCGPatch = self.Net_settings['nmax'] * 2
'''
# >>>>>>>>>>>>>>>>> The Most Improtant Issue, Populations as well as Connections Should be
'''
for subpop in self.population_list:
subpop.simulation = self # .simulation = self(self is what we called 'simulation')
for connpair in self.connection_list:
connpair.simulation = self
''' simulation is a platform, both populations and connections could have access to it '''
# >>>>>>>>>>>>> Preparation Finished, Initialize Populations and Connections >>>>>>
for p in self.population_list:
p.initialize() # 2
for c in self.connection_list:
c.initialize() # 1
def initialize(self, t0=0.0):
"""
initialize by hand, first put all sub-population and connection-pair
!!! put them on the same platform!!! simulationBridge
"""
''' initialize P_MFE '''
''' at first, we only use NHYP as NPATCH '''
self.iteration_max = self.ntt + 100
iteration_max = self.iteration_max
self.tbin_tmp = 0 # initial
self.tbinsize = 1.0
dtperbin = int(self.tbinsize / self.dt)
self.dtperbin = dtperbin
# iteration_max for number of dt per tfinal
# dtperbin for number of dt per tbinsize
# iteration_bin for number of tbin per tfinal
iteration_bin = int(iteration_max / dtperbin)
NPATCH = self.Net_settings['hyp_num']
NE, NI = self.NE, self.NI
self.VE, self.VI = np.zeros((NE, NPATCH)), np.zeros((NI, NPATCH))
# DTBIN_RECORD_FLAG
self.tbin_ra = np.zeros((iteration_max, 1))
# each dt !!!
'''
# each dt
self.mE_ra = np.zeros((iteration_max,NPATCH))
self.mI_ra = np.zeros((iteration_max,NPATCH))
self.NMDAE_ra = np.zeros((iteration_max,NPATCH))
self.NMDAI_ra = np.zeros((iteration_max,NPATCH))
'''
# each tbin
self.mEbin_ra = np.zeros((iteration_bin, NPATCH))
self.mIbin_ra = np.zeros_like(self.mEbin_ra)
self.xEbin_ra = np.zeros_like(self.mEbin_ra)
self.xIbin_ra = np.zeros_like(self.xEbin_ra)
''' long-range '''
self.HNMDAEbin_ra = np.zeros_like(self.xEbin_ra)
self.HNMDAIbin_ra = np.zeros_like(self.xEbin_ra)
self.NMDAEbin_ra = np.zeros_like(self.xEbin_ra)
self.NMDAIbin_ra = np.zeros_like(self.xEbin_ra)
self.tau_NMDA = np.zeros((2, 1))
''' also recording possible MFE as well as effective MFE'''
# possible MFE-prob and index
self.P_MFEbin_ra = np.zeros_like(self.xIbin_ra)
# each dt !!!
'''
self.P_MFE_ra = np.zeros((iteration_max,1))
'''
self.idx_MFE_ra = np.zeros((iteration_max, 1))
# effective MFE-prob and index
self.P_MFE_eff = np.zeros((iteration_max, 1))
self.idx_MFE_eff = np.zeros((iteration_max, 1))
# voltage distribution
self.rEbin_ra = np.zeros((NPATCH, 2000, iteration_bin))
self.rIbin_ra = np.zeros_like(self.rEbin_ra)
self.VEavgbin_ra = np.zeros_like(self.P_MFEbin_ra)
self.VIavgbin_ra = np.zeros_like(self.VEavgbin_ra)
self.VEstdbin_ra = np.zeros_like(self.VIavgbin_ra)
self.VIstdbin_ra = np.zeros_like(self.VEstdbin_ra)
# each dt !!!
'''
self.VEavg_ra = np.zeros((iteration_max,NPATCH))
self.VIavg_ra = np.zeros_like(self.VEavg_ra)
self.VEstd_ra = np.zeros_like(self.VIavg_ra)
self.VIstd_ra = np.zeros_like(self.VEstd_ra)
'''
self.rE, self.rI = None, None
self.NPATCH = NPATCH
# why _ra for each dt
self.LE_ra = np.zeros((iteration_max, NPATCH))
self.LI_ra = np.zeros_like(self.LE_ra)
''' IDX '''
# get v
''' COMMON PARAMETERS '''
DEE, DIE, DEI, DII = self.DEE, self.DIE, self.DEI, self.DII
vT = 1.0
dv = self.Net_settings['dv']
self.Vedges = util.get_v_edges(-1.0, 1.0, dv)
''' bins = edges - 1'''
# in internal , rhov length len(self.Vbins), len(Vedges)-1
self.Vbins = 0.5 * (self.Vedges[0:-1] + self.Vedges[1:])
''' notice that Number of BINS is less than Number of EDGES '''
Vedges = self.Vedges
Vbins = self.Vbins
idx_vT = len(Vedges) - 1 # is equal to len(Vbins)
idx_kickE, idx_kickI = np.zeros((NPATCH, NPATCH), dtype=int), np.zeros(
(NPATCH, NPATCH), dtype=int)
for it in range(self.NPATCH):
for js in range(self.NPATCH):
value_kickE = vT - DEE[it, js]
value_kickI = vT - DIE[it, js]
Ind_k1 = np.where(Vedges > value_kickE)
IndI_k1 = np.where(Vedges > value_kickI)
if np.shape(Ind_k1)[1] > 0:
idx_kickE[it, js] = Ind_k1[0][0]
else:
idx_kickE[it, js] = idx_vT
if np.shape(IndI_k1)[1] > 0:
idx_kickI[it, js] = IndI_k1[0][0]
else:
idx_kickI[it, js] = idx_vT
self.idx_kickE, self.idx_kickI = idx_kickE, idx_kickI
self.idx_vT = idx_vT
self.MFE_pevent = np.zeros(self.NPATCH)
self.p_single = np.zeros(self.NPATCH)
self.rE = np.zeros((len(self.Vbins), self.NPATCH))
self.rI = np.zeros_like(self.rE)
# An connection_distribution_list (store unique connection(defined by weight,syn,prob))
self.connection_distribution_collection = ConnectionDistributionCollection(
) # this is
self.t = t0 # zero
# Matrix to record
numCGPatch = self.Net_settings[
'nmax'] * 2 # both excitatory and inhibitory
# 2 * numCGPatch = External Population and Recurrent Population
# set Matrix to record only Internal Population
# put all subpopulation and all connections into the same platform
for subpop in self.population_list:
subpop.simulation = self # .simulation = self(self is what we called 'simulation')
for connpair in self.connection_list:
connpair.simulation = self
''' simulation is a platform, both populations and connections could have access to it '''
# initialize population_list, calculate
for p in self.population_list:
p.initialize() # 2
for c in self.connection_list:
#print 'initialize population'
c.initialize() # 1