"""
netParams.py
High-level specifications for S1-thalamus network model using NetPyNE
Contributors: salvadordura@gmail.com, fernandodasilvaborges@gmail.com
"""
from netpyne import specs
import pickle, json
import os
import numpy as np
import pandas as pd
netParams = specs.NetParams() # object of class NetParams to store the network parameters
try:
from __main__ import cfg # import SimConfig object with params from parent module
except:
from cfg import cfg
#------------------------------------------------------------------------------
#
# NETWORK PARAMETERS
#
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
# General network parameters
#------------------------------------------------------------------------------
netParams.scale = cfg.scale # Scale factor for number of cells
netParams.sizeX = cfg.sizeX # x-dimension (horizontal length) size in um
netParams.sizeY = cfg.sizeY # y-dimension (vertical height or cortical depth) size in um
netParams.sizeZ = cfg.sizeZ # z-dimension (horizontal depth) size in um
netParams.shape = 'cylinder' # cylindrical (column-like) volume
# Layer height (um) height (norma) from to
# L1 165 0.079 0.000 0.079
# L2 149 0.072 0.079 0.151
# L3 353 0.170 0.151 0.320
# L4 190 0.091 0.320 0.412
# L5 525 0.252 0.412 0.664
# L6 700 0.336 0.664 1.000
# L23 502 0.241 0.079 0.320
# All 2082 1.000
cellModels = ['HH_full']
Epops = ['L23_PC', 'L4_PC', 'L4_SS', 'L4_SP',
'L5_TTPC1', 'L5_TTPC2', 'L5_STPC', 'L5_UTPC',
'L6_TPC_L1', 'L6_TPC_L4', 'L6_BPC', 'L6_IPC', 'L6_UTPC']
Ipops = []
for popName in cfg.S1pops:
if popName not in Epops:
Ipops.append(popName)
layer = {'1':[0.0, 0.079], '2': [0.079,0.151], '3': [0.151,0.320], '23': [0.079,0.320], '4':[0.320,0.412], '5': [0.412,0.664], '6': [0.664,1.0],
'longS1': [2.2,2.3], 'longS2': [2.3,2.4]} # normalized layer boundaries
#Th pop
ymin={'ss_RTN_o': 1000+1688, 'ss_RTN_m': 1000+1766, 'ss_RTN_i': 1000+1844, 'VPL_sTC': 1000+2000, 'VPM_sTC': 1000+2156, 'POm_sTC_s1': 1000+2312}
ymax={'ss_RTN_o': 1000+1766, 'ss_RTN_m': 1000+1844, 'ss_RTN_i': 1000+2000, 'VPL_sTC': 1000+2156, 'VPM_sTC': 1000+2312, 'POm_sTC_s1': 1000+2624}
#------------------------------------------------------------------------------
# General connectivity parameters
#------------------------------------------------------------------------------
netParams.defaultThreshold = -10.0 # spike threshold, 10 mV is NetCon default, lower it for all cells
netParams.defaultDelay = 0.1 # default conn delay (ms)
netParams.propVelocity = 300.0 # 300 μm/ms (Stuart et al., 1997)
netParams.scaleConnWeightNetStims = 0.001 # weight conversion factor (from nS to uS)
#------------------------------------------------------------------------------
# Population parameters
#------------------------------------------------------------------------------
## S1
for cellName in cfg.S1cells:
layernumber = cellName[1:2]
if layernumber == '2':
netParams.popParams[cellName] = {'cellType': cellName, 'cellModel': 'HH_full', 'ynormRange': layer['23'],
'numCells': int(np.ceil(cfg.scaleDensity*cfg.cellNumber[cellName])), 'diversity': True}
else:
netParams.popParams[cellName] = {'cellType': cellName, 'cellModel': 'HH_full', 'ynormRange': layer[layernumber],
'numCells': int(np.ceil(cfg.scaleDensity*cfg.cellNumber[cellName])), 'diversity': True}
## THALAMIC POPULATIONS (from prev model)
for popName in cfg.thalamicpops:
if 'RTN' in popName: # inhibitory - RTN
ThcellType = 'sRE_cell'
else: # excitatory
ThcellType = 'sTC_cell'
netParams.popParams[popName] = {'cellType': ThcellType, 'cellModel': 'HH_full', 'yRange': [ymin[popName], ymax[popName]],
'numCells': int(np.ceil(cfg.popNumber[popName])), 'diversity': False}
#------------------------------------------------------------------------------
# Cell parameters # L1 70 L23 215 L4 230 L5 260 L6 260 = 1035
#------------------------------------------------------------------------------
## S1 cell property rules
for cellName in cfg.S1cells:
if cfg.cellNumber[cellName] < 5:
morphoNumbers = cfg.cellNumber[cellName]
else:
morphoNumbers = 5
cellFraction = 1.0/morphoNumbers
for morphoNumber in range(morphoNumbers):
cellMe = cfg.cellLabel[cellName] + '_' + str(morphoNumber+1)
netParams.loadCellParamsRule(label = cellMe, fileName = 'cells/' + cellMe + '_cellParams.json')
cellRule = {'conds': {'cellType': cellName}, 'diversityFraction': cellFraction, 'secs': {}} # cell rule dict
cellRule['secs'] = netParams.cellParams[cellMe]['secs']
cellRule['conds'] = netParams.cellParams[cellMe]['conds']
cellRule['conds']['cellType'] = cellName
cellRule['globals'] = netParams.cellParams[cellMe]['globals']
cellRule['secLists'] = netParams.cellParams[cellMe]['secLists']
cellRule['secLists']['spiny'] = {}
cellRule['secLists']['spinyEE'] = {}
nonSpiny = ['axon_0', 'axon_1']
cellRule['secLists']['spiny'] = [sec for sec in cellRule['secLists']['all'] if sec not in nonSpiny]
nonSpinyEE = ['axon_0', 'axon_1', 'soma']
cellRule['secLists']['spinyEE'] = [sec for sec in cellRule['secLists']['all'] if sec not in nonSpinyEE]
netParams.cellParams[cellMe] = cellRule # add dict to list of cell params
#-----------------------------------------------------------------------------------#
if cfg.reducedtest:
cellRule = {'conds': {'cellType': cellName}, 'diversityFraction': cellFraction, 'secs': {}} # cell rule dict
cellRule['conds'] = netParams.cellParams[cellMe]['conds']
cellRule['secs'] = {}
cellRule['secs']['soma'] = netParams.cellParams[cellMe]['secs']['soma']
cellRule['secLists'] = {}
cellRule['secLists']['spiny'] = ['soma']
cellRule['secLists']['spinyEE'] = ['soma']
cellRule['secLists']['all'] = ['soma']
cellRule['secLists']['basal'] = ['soma']
cellRule['secLists']['apical'] = ['soma']
netParams.cellParams[cellMe] = cellRule # add dict to list of cell params
#-----------------------------------------------------------------------------------#
for section in netParams.cellParams[cellMe]['secLists']['all']:
if 'ions' in netParams.cellParams[cellMe]['secs'][section].keys():
if 'ca' in netParams.cellParams[cellMe]['secs'][section]['ions'].keys():
netParams.cellParams[cellMe]['secs'][section]['ions']['ca']['o'] = cfg.cao_secs
#-----------------------------------------------------------------------------------#
## Th cell property rules
# JSON FILES FROM A1 WITH UPDATED DYNAMICS
# # --- VL - Exc --- #
netParams.loadCellParamsRule(label='sTC_cell', fileName='cells/sTC_jv_00.json') # Load cellParams for each of the above cell subtype
netParams.cellParams['sTC_cell']['conds']={}
# --- RTN - Inh --- #
netParams.loadCellParamsRule(label='sRE_cell', fileName='cells/sRE_jv_00.json') # Load cellParams for each of the above cell subtype
netParams.cellParams['sRE_cell']['conds']={}
#------------------------------------------------------------------------------
# load data from S1 conn pre-processing file
#------------------------------------------------------------------------------
with open('conn/conn.pkl', 'rb') as fileObj: connData = pickle.load(fileObj)
lmat = connData['lmat']
a0mat = connData['a0mat']
d0 = connData['d0']
a0e = connData['a0mat_exp']
l0e = connData['lmat_exp']
d0e = connData['d0_exp']
a0g = connData['a0mat_gauss']
x0g = connData['x0_gauss']
l0g = connData['lmat_gauss']
d0g = connData['d0_gauss']
dfinal = connData['dfinal']
pmat = {}
pmat[12.5] = connData['pmat12um']
pmat[25] = connData['pmat25um']
pmat[50] = connData['pmat50um']
pmat[75] = connData['pmat75um']
pmat[100] = connData['pmat100um']
pmat[125] = connData['pmat125um']
pmat[150] = connData['pmat150um']
pmat[175] = connData['pmat175um']
pmat[200] = connData['pmat200um'] #max value for d0=200
synperconnNumber = connData['synperconnNumber']
connNumber = connData['connNumber']
decay = connData['decay']
gsyn = connData['gsyn']
use = connData['use']
ConnTypesNumber = connData['ConnTypesNumber']
ConnTypes = connData['ConnTypes']
connIEtype = connData['connIEtype']
connEItype = connData['connEItype']
parameters_syn = connData['parameters_syn']
physColumnNames = []
syntypes = []
for name,syntype in parameters_syn:
if name not in physColumnNames:
physColumnNames.append(name)
if syntype not in syntypes:
syntypes.append(syntype)
dfS6 = pd.DataFrame(index=syntypes, columns=physColumnNames)
for syntype in syntypes:
for name in physColumnNames:
dfS6.loc[syntype][name] = parameters_syn[name,syntype]
#------------------------------------------------------------------------------
# Synaptic mechanism parameters
#------------------------------------------------------------------------------
# mods from S1 BBP - deterministic version
for syntype in syntypes:
if syntype > 50: # Exc
netParams.synMechParams['S1_EE_STP_Det_' + str(syntype)] = {'mod': 'DetAMPANMDA',
'Use': dfS6['use'][syntype]*cfg.use_frac['EE'], # ± dfS6['useStd'][syntype]
'Dep': dfS6['dep'][syntype], # ± dfS6['depStd'][syntype]
'Fac': dfS6['fac'][syntype], # ± dfS6['facStd'][syntype]
'tau_d_AMPA': 1.74, # ± 0.18 ms
'tau_r_AMPA': 0.2,
'tau_r_NMDA': 0.29,
'tau_d_NMDA': 43,
'NMDA_ratio': 0.8, # ± 0.1 for EE -- experimentally measured for some path?
'mg':1.0, # 0.5mM where exceptionally specified?
}
netParams.synMechParams['S1_EIproximal_STP_Det_' + str(syntype)] = {'mod': 'DetAMPANMDA',
'Use': dfS6['use'][syntype]*cfg.use_frac['EIproximal'], # ± dfS6['useStd'][syntype]
'Dep': dfS6['dep'][syntype], # ± dfS6['depStd'][syntype]
'Fac': dfS6['fac'][syntype], # ± dfS6['facStd'][syntype]
'tau_d_AMPA': 1.74, # ± 0.18 ms
'tau_r_AMPA': 0.2,
'tau_r_NMDA': 0.29,
'tau_d_NMDA': 43,
'NMDA_ratio': 0.4, # ± 0.1 for EI -- experimentally measured for some path?
'mg':1.0, # 0.5mM where exceptionally specified?
}
netParams.synMechParams['S1_EIdistal_STP_Det_' + str(syntype)] = {'mod': 'DetAMPANMDA',
'Use': dfS6['use'][syntype]*cfg.use_frac['EIdistal'], # ± dfS6['useStd'][syntype]
'Dep': dfS6['dep'][syntype], # ± dfS6['depStd'][syntype]
'Fac': dfS6['fac'][syntype], # ± dfS6['facStd'][syntype]
'tau_d_AMPA': 1.74, # ± 0.18 ms
'tau_r_AMPA': 0.2,
'tau_r_NMDA': 0.29,
'tau_d_NMDA': 43,
'NMDA_ratio': 0.4, # ± 0.1 for EI -- experimentally measured for some path?
'mg':1.0, # 0.5mM where exceptionally specified?
}
else: # Inh
netParams.synMechParams['S1_II_STP_Det_' + str(syntype)] = {'mod': 'DetGABAAB',
'Use': dfS6['use'][syntype]*cfg.use_frac['Inh'], # ± dfS6['useStd'][syntype]
'Dep': dfS6['dep'][syntype], # ± dfS6['depStd'][syntype]
'Fac': dfS6['fac'][syntype], # ± dfS6['facStd'][syntype]
'tau_d_GABAA': dfS6['decay'][syntype], # ± dfS6['decayStd'][syntype]
'tau_r_GABAA': 0.2, #rng.lognormal(0.2, 0.1) in synapses.hoc
'tau_d_GABAB': 260.9,
'tau_r_GABAB': 3.5,
# 'GABAB_ratio': 1.0, #=0(1):The ratio of GABAB to GABAA ?
}
netParams.synMechParams['S1_IE_STP_Det_' + str(syntype)] = {'mod': 'DetGABAAB',
'Use': dfS6['use'][syntype]*cfg.use_frac['Inh'], # ± dfS6['useStd'][syntype]
'Dep': dfS6['dep'][syntype], # ± dfS6['depStd'][syntype]
'Fac': dfS6['fac'][syntype], # ± dfS6['facStd'][syntype]
'tau_d_GABAA': dfS6['decay'][syntype], # ± dfS6['decayStd'][syntype]
'tau_r_GABAA': 0.2, #rng.lognormal(0.2, 0.1) in synapses.hoc
'tau_d_GABAB': 260.9,
'tau_r_GABAB': 3.5,
# 'GABAB_ratio': 1.0, #=0(1):The ratio of GABAB to GABAA ?
}
# Th NEW
#E2 -> syn 134
netParams.synMechParams['TC:S1'] = {'mod': 'DetAMPANMDA',
'Dep': 227.0,
'Fac': 13.0,
'Use': 0.72,
'tau_r_AMPA': 0.2,
'tau_d_AMPA': 1.74,
'NMDA_ratio': 0.4,
'tau_r_NMDA': 0.29,
'tau_d_NMDA': 43.0}
# Spont and BG
netParams.synMechParams['AMPA'] = {'mod':'MyExp2SynBB', 'tau1': 0.2, 'tau2': 1.74, 'e': 0}
netParams.synMechParams['NMDA'] = {'mod': 'MyExp2SynNMDABB', 'tau1NMDA': 0.29, 'tau2NMDA': 43, 'e': 0}
netParams.synMechParams['GABAA'] = {'mod':'MyExp2SynBB', 'tau1': 0.2, 'tau2': 8.3, 'e': -80}
netParams.synMechParams['GABAB'] = {'mod':'MyExp2SynBB', 'tau1': 3.5, 'tau2': 260.9, 'e': -93}
ESynMech = ['AMPA', 'NMDA']
ISynMech = ['GABAA', 'GABAB']
# Th
netParams.synMechParams['NMDA_Th'] = {'mod': 'MyExp2SynNMDABB', 'tau1NMDA': 15, 'tau2NMDA': 150, 'e': 0}
netParams.synMechParams['AMPA_Th'] = {'mod': 'MyExp2SynBB', 'tau1': 0.05, 'tau2': 5.3, 'e': 0}
netParams.synMechParams['GABAB_Th'] = {'mod': 'MyExp2SynBB', 'tau1': 3.5, 'tau2': 260.9, 'e': -93}
netParams.synMechParams['GABAA_Th'] = {'mod': 'MyExp2SynBB', 'tau1': 0.07, 'tau2': 18.2, 'e': -80}
ESynMech_Th = ['AMPA_Th', 'NMDA_Th']
PVSynMech_Th = ['GABAA_Th']
NGFSynMech_Th = ['GABAA_Th', 'GABAB_Th']
#------------------------------------------------------------------------------
# S1 Local connectivity parameters
#------------------------------------------------------------------------------
contA = 0
if cfg.addConn:
for pre in Ipops+Epops:
for post in Ipops+Epops:
if float(connNumber[pre][post]) > 0:
# ------------------------------------------------------------------------------
# 2D distance prob rules
# ------------------------------------------------------------------------------
if int(float(d0[pre][post])) < 25: # single fit
if 'exp' in connData['best_fit'][pre][post]: # exponential
prob = '%s*exp(-dist_2D/%s)*(dist_2D<%s)' % (a0mat[pre][post],lmat[pre][post],dfinal[pre][post])
else: # gaussian
prob = '%s*exp(-(dist_2D-%s)**2/(2*%s**2))*(dist_2D<%s)' % (a0g[pre][post],x0g[pre][post],l0g[pre][post],dfinal[pre][post])
else:
if 'expl' in connData['best_fit'][pre][post]: # exponential + linear interpolation [25:d0]
if int(float(d0[pre][post])) == 25: #d0==25 -> exponential fit when dist_2D>25, else prob[0um:25um] = pmat[12.5]
prob = '%s*exp(-dist_2D/%s)*(dist_2D<%s) if dist_2D > %s else %f' % (a0mat[pre][post],lmat[pre][post],dfinal[pre][post],d0[pre][post],float(pmat[12.5][pre][post]))
else: #d0>25 -> exponential fit when dist_2D>d0, else prob[0um:d0] = linear interpolation [25:d0]
d01 = int(float(d0[pre][post]))
y1 = float(pmat[25][pre][post])
y2 = float(pmat[d01][pre][post])
x1 = 25
x2 = d01
angular = (y2 - y1)/(x2 - x1)
linear = y2 - x2*angular
prob = '%s*exp(-dist_2D/%s)*(dist_2D<%s) if dist_2D > %s else %f * dist_2D + %f' % (a0mat[pre][post],lmat[pre][post],dfinal[pre][post],d0[pre][post],angular,linear)
elif 'exp' in connData['best_fit'][pre][post]: # exponential
if float(pmat[12.5][pre][post]) > float(pmat[25][pre][post]):
prob = '%s*exp(-dist_2D/%s)*(dist_2D<%s)' % (a0e[pre][post],l0e[pre][post],dfinal[pre][post])
else:
prob = '%s*exp(-dist_2D/%s)*(dist_2D<%s) if dist_2D > %s else %f' % (a0e[pre][post],l0e[pre][post],dfinal[pre][post],d0e[pre][post],float(pmat[12.5][pre][post]))
else: # gaussian
prob = '%s*exp(-(dist_2D-%s)**2/(2*%s**2))*(dist_2D<%s)' % (a0g[pre][post],x0g[pre][post],l0g[pre][post],dfinal[pre][post])
# ------------------------------------------------------------------------------
# I -> I
# ------------------------------------------------------------------------------
if pre in Ipops:
if post in Ipops:
connID = ConnTypes[pre][post][0]
synMechType = 'S1_II_STP_Det_' + str(connID)
contA+= 1
netParams.connParams['II_' + pre + '_' + post] = {
'preConds': {'pop': cfg.popLabelEl[pre]},
'postConds': {'pop': cfg.popLabelEl[post]},
'synMech': synMechType,
'probability': prob,
'weight': parameters_syn['gsyn',connID] * cfg.IIGain,
'synMechWeightFactor': cfg.synWeightFractionII,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': int(synperconnNumber[pre][post]+0.5),
'sec': 'spiny'}
# ------------------------------------------------------------------------------
# I -> E # with ME conn diversity
# ------------------------------------------------------------------------------
if pre in Ipops:
if post in Epops:
cellpreList_A = []
cellpreList_B = []
cellpreList_C = []
connID_B = -1
connID_C = -1
if 'SBC' in pre or 'LBC' in pre or 'NBC' in pre:
cellpost = cfg.popLabelEl[post][0]
for npre,cellpre in enumerate(cfg.popLabelEl[pre]):
premtype = pre[-3:]
preetype = cellpre[-3:]
connID = connIEtype[premtype][preetype]
if connID == ConnTypes[pre][post][0]:
cellpreList_A.append(cellpre)
elif connID == ConnTypes[pre][post][1]:
cellpreList_B.append(cellpre)
connID_B = ConnTypes[pre][post][1]
elif connID == ConnTypes[pre][post][2]:
cellpreList_C.append(cellpre)
connID_C = ConnTypes[pre][post][2]
else:
print('ERROR')
else:
cellpreList_A = cfg.popLabelEl[pre]
connID = ConnTypes[pre][post][0]
synMechType = 'S1_IE_STP_Det_' + str(connID)
contA+= 1
netParams.connParams['IE_'+pre+'_'+post] = {
'preConds': {'pop': cellpreList_A},
'postConds': {'pop': cfg.popLabelEl[post]},
'synMech': synMechType,
'probability': prob,
'weight': parameters_syn['gsyn',connID] * cfg.IEGain,
'synMechWeightFactor': cfg.synWeightFractionIE,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': int(synperconnNumber[pre][post]+0.5),
'sec': 'spiny'}
if connID_B >= 0:
connID = connID_B
synMechType = 'S1_IE_STP_Det_' + str(connID)
netParams.connParams['IE_'+pre+'_'+post+'_B'] = {
'preConds': {'pop': cellpreList_B},
'postConds': {'pop': cfg.popLabelEl[post]},
'synMech': synMechType,
'probability': prob,
'weight': parameters_syn['gsyn',connID] * cfg.IEGain,
'synMechWeightFactor': cfg.synWeightFractionIE,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': int(synperconnNumber[pre][post]+0.5),
'sec': 'spiny'}
if connID_C >= 0:
connID = connID_C
synMechType = 'S1_IE_STP_Det_' + str(connID)
netParams.connParams['IE_'+pre+'_'+post+'_C'] = {
'preConds': {'pop': cellpreList_C},
'postConds': {'pop': cfg.popLabelEl[post]},
'synMech': synMechType,
'probability': prob,
'weight': parameters_syn['gsyn',connID] * cfg.IEGain,
'synMechWeightFactor': cfg.synWeightFractionIE,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': int(synperconnNumber[pre][post]+0.5),
'sec': 'spiny'}
#------------------------------------------------------------------------------
# E -> E
#------------------------------------------------------------------------------
if pre in Epops:
if post in Epops:
connID = ConnTypes[pre][post][0]
synMechType = 'S1_EE_STP_Det_' + str(connID)
contA+= 1
netParams.connParams['EE_'+pre+'_'+post] = {
'preConds': {'pop': cfg.popLabelEl[pre]},
'postConds': {'pop': cfg.popLabelEl[post]},
'synMech': synMechType,
'probability': prob,
'weight': parameters_syn['gsyn',connID] * cfg.EEGain,
'synMechWeightFactor': cfg.synWeightFractionEE,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': int(synperconnNumber[pre][post]+0.5),
'sec': 'spinyEE'}
#------------------------------------------------------------------------------
# E -> I with ME conn diversity
#------------------------------------------------------------------------------
if pre in Epops:
if post in Ipops:
cellpostList_A = []
cellpostList_B = []
connID_B = -1
if ConnTypes[pre][post][0] == 131 or ConnTypes[pre][post][0] == 132: # EXCEPTIONS -> L6_IPC:L6_(DBC-LBC-NBC-SBC) and L6_TPC_L:L6_(DBC-LBC-NBC-SBC)
cellpostList_A = cfg.popLabelEl[post]
elif 'LBC' in post or 'NBC' in post or 'BP' in post or 'DBC' in post or 'BTC' in post:
cellpre = cfg.popLabelEl[pre][0]
for npost,cellpost in enumerate(cfg.popLabelEl[post]):
postmtype = post[-3:]
postetype = cellpost[-3:]
if 'BP' in postmtype:
postmtype = post[-2:]
connID = connEItype[postmtype][postetype]
if connID == ConnTypes[pre][post][0]:
cellpostList_A.append(cellpost)
elif connID == ConnTypes[pre][post][1]:
cellpostList_B.append(cellpost)
connID_B = ConnTypes[pre][post][1]
else:
print('ERROR')
else:
cellpostList_A = cfg.popLabelEl[post]
connID = ConnTypes[pre][post][0]
if 'DBC' in post or 'BTC' in post or 'MC' in post or 'BP' in post: # steep Ca2+ dependence for connections between PC-distal targeting cell types (DBC, BTC, MC, BP)
synMechType = 'S1_EIdistal_STP_Det_' + str(connID)
else: # shallow dependence between PC-proximal targeting cell types (LBCs, NBCs, SBCs, ChC) + L1s and NGCs ????
synMechType = 'S1_EIproximal_STP_Det_' + str(connID)
contA+= 1
netParams.connParams['EI_'+pre+'_'+post] = {
'preConds': {'pop': cfg.popLabelEl[pre]},
'postConds': {'pop': cellpostList_A},
'synMech': synMechType,
'probability': prob,
'weight': parameters_syn['gsyn',connID] * cfg.EIGain,
'synMechWeightFactor': cfg.synWeightFractionEI,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': int(synperconnNumber[pre][post]+0.5),
'sec': 'spiny'}
if connID_B >= 0:
connID = connID_B
if 'DBC' in post or 'BTC' in post or 'MC' in post or 'BP' in post: # steep Ca2+ dependence for connections between PC-distal targeting cell types (DBC, BTC, MC, BP)
synMechType = 'S1_EIdistal_STP_Det_' + str(connID)
else: # shallow dependence between PC-proximal targeting cell types (LBCs, NBCs, SBCs, ChC) + L1s and NGCs ????
synMechType = 'S1_EIproximal_STP_Det_' + str(connID)
netParams.connParams['EI_'+pre+'_'+post+'_B'] = {
'preConds': {'pop': cfg.popLabelEl[pre]},
'postConds': {'pop': cellpostList_B},
'synMech': synMechType,
'probability': prob,
'weight': parameters_syn['gsyn',connID] * cfg.EIGain,
'synMechWeightFactor': cfg.synWeightFractionEI,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': int(synperconnNumber[pre][post]+0.5),
'sec': 'spiny'}
#------------------------------------------------------------------------------
# NetStim inputs to simulate Spontaneous synapses + background in S1 neurons - data from Rat
#------------------------------------------------------------------------------
SourcesNumber = 5 # for each post Mtype - sec distribution
synperNeuronStimI = connData['synperNeuronStimI']
synperNeuronStimE = connData['synperNeuronStimE']
GsynStimI = connData['GsynStimI']
GsynStimE = connData['GsynStimE']
if cfg.addStimSynS1:
for post in Ipops + Epops:
synperNeuron = synperNeuronStimI[post]
ratespontaneous = cfg.rateStimI
for qSnum in range(SourcesNumber):
ratesdifferentiation = (0.8 + 0.4*qSnum/(SourcesNumber-1)) * (synperNeuron*ratespontaneous)/SourcesNumber
netParams.stimSourceParams['StimSynS1_S_all_INH->' + post + '_' + str(qSnum)] = {'type': 'NetStim', 'rate': ratesdifferentiation, 'noise': 1.0}
synperNeuron = synperNeuronStimE[post]
ratespontaneous = cfg.rateStimE
for qSnum in range(SourcesNumber):
ratesdifferentiation = (0.8 + 0.4*qSnum/(SourcesNumber-1)) * (synperNeuron*ratespontaneous)/SourcesNumber
netParams.stimSourceParams['StimSynS1_S_all_EXC->' + post + '_' + str(qSnum)] = {'type': 'NetStim', 'rate': ratesdifferentiation, 'noise': 1.0}
#------------------------------------------------------------------------------
for post in Epops:
for qSnum in range(SourcesNumber):
netParams.stimTargetParams['StimSynS1_T_all_EXC->' + post + '_' + str(qSnum)] = {
'source': 'StimSynS1_S_all_EXC->' + post + '_' + str(qSnum),
'conds': {'cellType': cfg.popLabelEl[post]},
'synMech': 'AMPA',
'sec': 'spinyEE',
'weight': GsynStimE[post],
'delay': 0.1}
for post in Ipops:
for qSnum in range(SourcesNumber):
netParams.stimTargetParams['StimSynS1_T_all_EXC->' + post + '_' + str(qSnum)] = {
'source': 'StimSynS1_S_all_EXC->' + post + '_' + str(qSnum),
'synMech': 'AMPA',
'conds': {'cellType': cfg.popLabelEl[post]},
'sec': 'spiny',
'weight': GsynStimE[post],
'delay': 0.1}
for post in Epops+Ipops:
for qSnum in range(SourcesNumber):
netParams.stimTargetParams['StimSynS1_T_all_INH->' + post + '_' + str(qSnum)] = {
'source': 'StimSynS1_S_all_INH->' + post + '_' + str(qSnum),
'conds': {'cellType': cfg.popLabelEl[post]},
'synMech': 'GABAA',
'sec': 'spiny',
'weight': GsynStimI[post],
'delay': 0.1}
#------------------------------------------------------------------------------
# Th-Th connectivity parameters
#------------------------------------------------------------------------------
if cfg.connectTh:
## load data from conn pre-processing file
with open('conn/conn_Th.pkl', 'rb') as fileObj: connData = pickle.load(fileObj)
pmat = connData['pmat']
wmat = connData['wmat']
cmat = connData['cmat']
pops_TC = ['VPL_sTC','VPM_sTC', 'POm_sTC_s1']
pops_RTN = ['ss_RTN_o', 'ss_RTN_m', 'ss_RTN_i']
pops_FO = ['VPL_sTC','VPM_sTC']
pops_HO = ['POm_sTC_s1']
# Intrathalamic
if cfg.connect_RTN_RTN:
for pre in pops_RTN:
for post in pops_RTN:
if pre in pmat and post in pmat[pre]:
pmat[pre][post]=cfg.connProb_RTN_RTN
wmat[pre][post]=cfg.connWeight_RTN_RTN
l = cmat[pre][post]/4
syn = PVSynMech_Th # only GABA A
synWeightFactor = [1.0]
netParams.connParams['thal_'+pre+'_'+post] = {
'preConds': {'pop': pre},
'postConds': {'pop': post},
'synMech': syn,
'probability':' %f * exp(-dist_3D/%f)\
*(dist_2D<%f)\
*(dist_y<(%f/%f))\
' % (pmat[pre][post], l,
cmat[pre][post],
cmat[pre][post],cfg.yConnFactor),
'weight': wmat[pre][post] * cfg.intraThalamicGain,
'synMechWeightFactor': synWeightFactor,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': 1,
'sec': 'soma'}
if cfg.connect_TC_RTN:
for pre in pops_TC:
for post in pops_RTN:
if pre in pmat and post in pmat[pre]:
pmat[pre][post]=cfg.connProb_TC_RTN
wmat[pre][post]=cfg.connWeight_TC_RTN
l = cmat[pre][post]/4
y_thresh = cmat[pre][post]/5
syn = ['AMPA_Th'] # AMPA
synWeightFactor = [1.0]
if pre in pops_HO:
conn_method = 'divergence'
prob_rule = cfg.divergenceHO
else:
# topographycal connectivity
conn_method = 'probability'
prob_rule = '%f * exp(-dist_2D/%f)\
*(dist_2D<%f)\
*(abs(((((pre_y-%f)*(%f-%f))/(%f-%f))+%f)-post_y)<%f)\
\
' % (pmat[pre][post], l,
cmat[pre][post],
ymin[pre],ymax[post],ymin[post],ymax[pre],ymin[pre],ymin[post],y_thresh
)
netParams.connParams['thal_'+pre+'_'+post] = {
'preConds': {'pop': pre},
'postConds': {'pop': post},
'synMech': syn,
conn_method: prob_rule,
'weight': wmat[pre][post] * cfg.intraThalamicGain,
'synMechWeightFactor': synWeightFactor,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': 1,
'sec': 'soma'}
if cfg.connect_RTN_TC:
for pre in pops_RTN:
for post in pops_TC:
if pre in pmat and post in pmat[pre]:
pmat[pre][post]=cfg.connProb_RTN_TC
wmat[pre][post]=cfg.connWeight_RTN_TC
# l = cmat[pre][post]/4
l = cmat[pre][post]/1 ## Fernando changed to increase the FO conn
y_thresh = cmat[pre][post]/5
syn = NGFSynMech_Th # GABA A and GABA B
synWeightFactor = [0.6,0.4]
if post in pops_HO:
conn_method = 'divergence'
prob_rule = cfg.divergenceHO
else: # topographycal connectivity
conn_method = 'probability'
prob_rule = '%f * exp(-dist_2D/%f)\
*(dist_2D<%f)\
*(abs(((((pre_y-%f)*(%f-%f))/(%f-%f))+%f)-post_y)<%f)\
\
' % (pmat[pre][post], l,
cmat[pre][post],
ymin[pre],ymax[post],ymin[post],ymax[pre],ymin[pre],ymin[post],y_thresh
)
netParams.connParams['thal_'+pre+'_'+post] = {
'preConds': {'pop': pre},
'postConds': {'pop': post},
'synMech': syn,
conn_method: prob_rule,
'weight': wmat[pre][post] * cfg.intraThalamicGain,
'synMechWeightFactor': synWeightFactor,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': 1,
'sec': 'soma'}
#------------------------------------------------------------------------------
# Th->S1 connectivity parameters
#------------------------------------------------------------------------------
if cfg.connect_Th_S1:
# mtype VPM_sTC POm_sTC_s1 nameref
with open('conn/convergence_Th_S1.txt') as mtype_file:
mtype_content = mtype_file.read()
convergence_Th_S1 = {}
convergence_Th_S1['VPM_sTC'] = {}
convergence_Th_S1['VPL_sTC'] = {}
convergence_Th_S1['POm_sTC_s1'] = {}
for line in mtype_content.split('\n')[:-1]:
mtype, preFO, preHO, nameref = line.split()
convergence_Th_S1['VPL_sTC'][mtype] = int(cfg.frac_Th_S1*int(preFO)) # First Order
convergence_Th_S1['VPM_sTC'][mtype] = int(cfg.frac_Th_S1*int(preFO)) # First Order
convergence_Th_S1['POm_sTC_s1'][mtype] = int(cfg.frac_Th_S1*int(preHO)) # High Order
## Connectivity rules
radius_cilinder = netParams.sizeX/2.0
synapsesperconnection_Th_S1 = 9.0
radius2D_Th_S1 = 50.0
for pre in ['VPL_sTC', 'VPM_sTC', 'POm_sTC_s1']: #
if cfg.TC_S1[pre]:
for post in Epops+Ipops:
conn_convergence = np.ceil(convergence_Th_S1[pre][post]/synapsesperconnection_Th_S1)
prob_conv = 1.0*(conn_convergence/cfg.popNumber[pre])*((radius_cilinder**2)/(radius2D_Th_S1**2)) # prob*(AreaS1/Area_Th_syn)
probability_rule = '%f if dist_2D < %f else 0.0' % (prob_conv,radius2D_Th_S1)
netParams.connParams['thal_'+pre+'_'+post] = {
'preConds': {'pop': pre},
'postConds': {'pop': cfg.popLabelEl[post]},
'weight': 0.19, # synaptic weight
'sec': 'spinyEE', # target postsyn section
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': int(synapsesperconnection_Th_S1),
'synMech': 'TC:S1'}
if pre=='POm_sTC_s1':
netParams.connParams['thal_'+pre+'_'+post]['convergence'] = conn_convergence # non-topographycal connectivity
else:
netParams.connParams['thal_'+pre+'_'+post]['probability'] = probability_rule # FO (First Order)
#------------------------------------------------------------------------------
# S1-> connectivity parameters Th
#------------------------------------------------------------------------------
if cfg.connect_S1_Th:
## load data from conn pre-processing file
with open('conn/conn_Th.pkl', 'rb') as fileObj: connData = pickle.load(fileObj)
wmat = connData['wmat']
cmat = connData['cmat']
pops_TC = ['VPL_sTC','VPM_sTC', 'POm_sTC_s1']
pops_RTN = ['ss_RTN_o', 'ss_RTN_m', 'ss_RTN_i']
pops_FO = ['VPL_sTC','VPM_sTC']
pops_HO = ['POm_sTC_s1'],
pops_CT = ['L5_TTPC2', 'L6_TPC_L4']
radius2D_S1_RTN = 50.0
radius2D_S1_TC = 50.0
radius_cilinder = netParams.sizeX/2.0
if cfg.connect_S1_RTN:
for pre in pops_CT:
for post in pops_RTN:
syn = ['AMPA_Th'] # AMPA
synWeightFactor = [1.0]
conn_method = 'probability'
conn_convergence = cfg.convergence_S1_RTN
prob_conv = 1.0*(conn_convergence/cfg.popNumber[pre])*((radius_cilinder**2)/(radius2D_S1_RTN**2)) # prob*(AreaS1/Area_Th_syn)
prob_rule = '%f if dist_2D < %f else 0.0' % (prob_conv,radius2D_S1_RTN)
netParams.connParams['thal_'+pre+'_'+post] = {
'preConds': {'pop': cfg.popLabelEl[pre]},
'postConds': {'pop': post},
'synMech': syn,
conn_method: prob_rule,
'weight': cfg.connWeight_S1_RTN,
'synMechWeightFactor': synWeightFactor,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': 1,
'sec': 'soma'}
if cfg.connect_S1_TC:
for pre in pops_CT:
for post in pops_TC:
syn = ['AMPA_Th'] # AMPA
synWeightFactor = [1.0]
if post in pops_HO:
conn_method = 'divergence'
prob_rule = cfg.divergenceHO/2.0
else: # topographycal connectivity
conn_method = 'probability'
conn_convergence = cfg.convergence_S1_TC
prob_conv = 1.0*(conn_convergence/cfg.popNumber[pre])*((radius_cilinder**2)/(radius2D_S1_TC**2)) # prob*(AreaS1/Area_Th_syn)
prob_rule = '%f if dist_2D < %f else 0.0' % (prob_conv,radius2D_S1_TC)
netParams.connParams['thal_'+pre+'_'+post] = {
'preConds': {'pop': cfg.popLabelEl[pre]},
'postConds': {'pop': post},
'synMech': syn,
conn_method: prob_rule,
'weight': cfg.connWeight_S1_TC,
'synMechWeightFactor': synWeightFactor,
'delay': 'defaultDelay+dist_3D/propVelocity',
'synsPerConn': 1,
'sec': 'soma'}
#------------------------------------------------------------------------------
# Current inputs (IClamp)
#------------------------------------------------------------------------------
if cfg.addIClamp:
for j in range(cfg.IClampnumber):
key ='IClamp'
params = getattr(cfg, key, None)
key ='IClamp'+str(j+1)
params = params[j]
[pop,sec,loc,start,dur,amp] = [params[s] for s in ['pop','sec','loc','start','dur','amp']]
# add stim source
netParams.stimSourceParams[key] = {'type': 'IClamp', 'delay': start, 'dur': dur, 'amp': amp}
# connect stim source to target
netParams.stimTargetParams[key+'_'+pop] = {
'source': key,
'conds': {'pop': pop},
'sec': sec,
'loc': loc}
#------------------------------------------------------------------------------
# NetStim inputs - FROM CFG.PY
#------------------------------------------------------------------------------
if cfg.addNetStim:
for key in [k for k in dir(cfg) if k.startswith('NetStim')]:
params = getattr(cfg, key, None)
[pop, sec, loc, synMech, synMechWeightFactor, start, interval, noise, number, weight, delay] = \
[params[s] for s in ['pop', 'sec', 'loc', 'synMech', 'synMechWeightFactor', 'start', 'interval', 'noise', 'number', 'weight', 'delay']]
#cfg.analysis['plotTraces']['include'] = [(pop,0)]
if synMech == ESynMech:
wfrac = cfg.synWeightFractionEE
else:
wfrac = [1.0]
# add stim source
netParams.stimSourceParams[key] = { 'type': 'NetStim',
'start': cfg.startStimTime if cfg.startStimTime is not None else start,
'interval': cfg.interStimInterval if cfg.interStimInterval is not None else interval,
'noise': noise,
'number': cfg.numStims if cfg.numStims is not None else number}
# netParams.stimSourceParams[key] = {'type': 'NetStim', 'start': start, 'interval': interval, 'noise': noise, 'number': number}
# connect stim source to target
# for i, syn in enumerate(synMech):
netParams.stimTargetParams[key+'_'+pop] = {
'source': key,
'conds': {'pop': pop},
'sec': sec,
'loc': loc,
'synMech': synMech,
# 'weight': weight,
'weight': cfg.netWeight if cfg.netWeight is not None else weight,
'synMechWeightFactor': synMechWeightFactor,
'delay': delay}
#------------------------------------------------------------------------------
# Targeted NetStim inputs - FROM CFG.PY
#------------------------------------------------------------------------------
if cfg.addTargetedNetStim:
for key in [k for k in dir(cfg) if k.startswith('TargetedNetStim')]:
params = getattr(cfg, key, None)
[pop, sec, loc, synMech, synMechWeightFactor, start, interval, noise, number, weight, delay, targetCells] = \
[params[s] for s in ['pop', 'sec', 'loc', 'synMech', 'synMechWeightFactor', 'start', 'interval', 'noise', 'number', 'weight', 'delay', 'targetCells']]
#cfg.analysis['plotTraces']['include'] = [(pop,0)]
if synMech == ESynMech:
wfrac = cfg.synWeightFractionEE
else:
wfrac = [1.0]
# add stim source
netParams.stimSourceParams[key] = { 'type': 'NetStim',
'start': cfg.startStimTime if cfg.startStimTime is not None else start,
'interval': cfg.interStimInterval if cfg.interStimInterval is not None else interval,
'noise': noise,
'number': cfg.numStims if cfg.numStims is not None else number}
# netParams.stimSourceParams[key] = {'type': 'NetStim', 'start': start, 'interval': interval, 'noise': noise, 'number': number}
# connect stim source to target
# for i, syn in enumerate(synMech):
netParams.stimTargetParams[key+'_'+pop] = {
'source': key,
'conds': {'pop': cfg.stimPop if cfg.stimPop is not None else pop, 'cellList': targetCells},
'sec': sec,
'loc': loc,
'synMech': synMech,
# 'weight': weight,
'weight': cfg.netWeight if cfg.netWeight is not None else weight,
'synMechWeightFactor': synMechWeightFactor,
'delay': delay}
#------------------------------------------------------------------------------
# Description
#------------------------------------------------------------------------------
netParams.description = """
- Code based: M1 net, 6 layers, 7 cell types - v103
- v0 - insert cell diversity
- v1 - insert connection rules
- v2 - insert phys conn parameters
- v3 - ajust conn number
- v4 - NetStim inputs to simulate Spontaneous synapses + background in S1 neurons - data from Rat
- v5 - insert thalamic pops
- v6 - insert Short Term synaptic plasticity (STP) between S1 cells and projections S1->Th
- v7 - insert projections Th->S1
"""