OSCR

Linking functional and structural dendritic spine remodeling during fear learning and extinction in vivo.

Code ↔ Paper

2 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 2 matches
  1. [1] § MATERIALS AND METHODS › Simulation of the biophysically detailed neural network model › Basic setting of the simulation ↔ orig/netParams.py, lines 872–937 · score 0.57 · NetPyNE, cell models, Python, cortical, PV, spike
  2. [2] § MATERIALS AND METHODS › Simulation of the biophysically detailed neural network model › Basic setting of the simulation ↔ seed_search/netParams.py, lines 868–933 · score 0.57 · NetPyNE, cell models, Python, cortical, PV, spike

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 937 lines · 50 KB · no license · 1 match

  1. """
  2. netParams.py
  4. High-level specifications for M1 network model using NetPyNE
  6. Contributors: [email hidden]
  7. """
  9. from netpyne import specs, sim
  10. from neuron import h
  11. import pickle, json
  12. import random
  13. import numpy as np
  14. import math
  15. import os
  17. netParams = specs.NetParams() # object of class NetParams to store the network parameters
  19. netParams.version = 56
  21. try:
  22. from __main__ import cfg # import SimConfig object with params from parent module
  23. except:
  24. from cfg import cfg
  26. num_PT = 20
  27. num_PV = 10
  28. num_SOM = 10
  29. num_dict = {'PT': num_PT, 'PV': num_PV, 'SOM': num_SOM}
  30. seclist = {'PT': {'dend':[], 'all':[]}, 'PV': [], 'SOM': []} #'all' except axon
  35. #------------------------------------------------------------------------------
  36. #
  37. # Random sequence generation
  38. #
  39. #------------------------------------------------------------------------------
  40. class RandomSequenceNetParams:
  41. def __init__(self):
  42. self.randomlist = None
  44. def initializeRandomSequence(self, simConfig):
  45. from mpi4py import MPI
  46. comm = MPI.COMM_WORLD
  47. rank = comm.Get_rank()
  48. # Set random seeds consistently across nodes
  49. sd = 255
  50. random.seed(sd)
  51. if rank == 0:
  52. print(f'Using {sd} -- random seed for connection generation')
  53. # Initialize the randomlist structure based on population parameters
  54. self.randomlist = {
  55. 'EI': {k: [[[] for _ in range(num_PT)]
  56. for _ in range(num_dict[k])]
  57. for k in ['PV', 'SOM']},
  58. 'PVE': [[{'soma': []} for _ in range(num_dict['PV'])]
  59. for _ in range(num_PT)],
  60. 'SOME': [[{s: [] for s in ['Adend1', 'Adend2', 'Adend3', 'Bdend']}
  61. for _ in range(num_dict['SOM'])]
  62. for _ in range(num_PT)],
  63. 'II': {posttype: { pretype: [[[] for _ in range(num_dict[pretype] - 1 if pretype == posttype
  64. else num_dict[pretype])]
  65. for _ in range(num_dict[posttype])]
  66. for pretype in ['PV', 'SOM']}
  67. for posttype in ['PV', 'SOM']},
  68. 'LongE': {k: {sec: [[[] for _ in range(numCells_long)]
  69. for _ in range(num_PT)]
  70. for sec in ['Adend1', 'Adend2', 'Adend3', 'Bdend']}
  71. for k in ['S1_4K', 'S1_12K', 'OC']}
  72. }
  74. if rank == 0: # Only generate on master node
  75. # Generate weights and locations
  76. weights, seglocs = self._generate_random_values()
  77. # Process connections
  78. self._process_all_connections(weights, seglocs)
  81. # Broadcast fram rank 0 to all other ranks
  82. self.randomlist = comm.bcast(self.randomlist, root=0)
  84. def _generate_random_values(self):
  85. weights = {}
  86. seglocs = {}
  88. # Generate weights for each postsynaptic neuron (ipost)
  89. for celltype in ['PT', 'PV', 'SOM']:
  90. weights[celltype] = {}
  91. seglocs[celltype] = self._create_segment_locations(celltype)
  93. if celltype == 'PT':
  94. # For PT cells, generate weights for each compartment
  95. weights[celltype]['soma'] = []
  96. for ipost in range(num_PT):
  97. # Sample weights for this ipost
  98. weights[celltype]['soma'].append(
  99. self.sample_custom_distribution(
  100. self._calculate_total_synapses(celltype)['axosomatic'] // num_PT,
  101. 0.4, 3, 15
  102. )
  103. )
  104. for sec in seclist['PT']['dend']:
  105. weights[celltype][sec] = []
  106. for ipost in range(num_PT):
  107. weights[celltype][sec].append(
  108. self.sample_custom_distribution(
  109. self._calculate_total_synapses(celltype)['axodendritic'][sec] // num_PT,
  110. 0.4, 3, 15
  111. )
  112. )
  113. else:
  114. weights[celltype] = []
  115. for ipost in range(num_dict[celltype]):
  116. weights[celltype].append(
  117. self.sample_custom_distribution(
  118. self._calculate_total_synapses(celltype)['axosomatic'] // num_dict[celltype],
  119. 0.4, 3, 15
  120. )
  121. )
  123. return weights, seglocs
  125. def sample_custom_distribution(self, n_samples, prob, weight_threshold, maxweight=1.0):
  127. # Generate random numbers from a uniform distribution
  128. u = [random.uniform(0, 1) for _ in range(n_samples)]
  130. # Allocate samples as a list of zeros
  131. samples = [0.0] * n_samples
  132. for i, ui in enumerate(u):
  133. if ui <= prob: # prob in [0, weight]
  134. samples[i] = weight_threshold * (ui / prob) # Scale uniformly in [0, weight]
  135. else: # 1-prob in (weight, 1]
  136. samples[i] = weight_threshold + (ui - prob) * (maxweight-weight_threshold) / (1-prob) # Scale uniformly in (weight, 1]
  137. return samples
  139. def _calculate_total_synapses(self, celltype):
  140. # Calculate based on connection rules and population sizes
  141. total = {'axosomatic':0, 'axodendritic':{k: 0 for k in seclist['PT']['dend']}}
  142. if celltype == 'PT':
  143. total['axosomatic'] = (num_PT *
  144. num_PV) # PVE connections
  145. for sec in seclist['PT']['dend']:
  146. total['axodendritic'][sec] += math.ceil(nseg['PT'][sec]/numCells_long) * numCells_long * num_PT * 3 # LongE connections (3 types)
  147. total['axodendritic'][sec] += (num_PT *
  148. num_SOM) # SOME connections
  149. else: # PV or SOM
  150. total['axosomatic'] += (num_dict[celltype] *
  151. num_PT) # EI connections
  152. total['axosomatic'] += (num_dict[celltype] *
  153. (num_PV +
  154. num_SOM - 1)) # II connections
  155. return total
  157. def _create_segment_locations(self, celltype):
  158. seglocs = {}
  160. if celltype == 'PT':
  161. # For PT cells, generate segment locations for each compartment
  162. for sec in seclist['PT']['all']:
  163. seglocs[sec] = []
  164. for ipost in range(num_PT):
  165. # Generate segment locations for this ipost
  166. seglocs[sec].append(
  167. [1 / (2 * nseg[celltype][sec]) + i * 1 / nseg[celltype][sec]
  168. for i in range(math.ceil(nseg[celltype][sec]))]
  169. )
  170. if sec == 'soma':
  171. k = self._calculate_total_synapses(celltype)['axosomatic'] // num_PT - math.ceil(nseg[celltype][sec])
  172. else:
  173. k = self._calculate_total_synapses(celltype)['axodendritic'][sec] // num_PT - math.ceil(nseg[celltype][sec])
  174. seglocs[sec][ipost].extend(random.choices(seglocs[sec][ipost], k = k))
  175. random.shuffle(seglocs[sec][ipost])
  176. else:
  177. # For PV and SOM cells, generate segment locations for each ipost
  178. seglocs = []
  179. for ipost in range(num_dict[celltype]):
  180. seglocs.append(
  181. [1 / (2 * nseg[celltype]['soma']) + i * 1 / nseg[celltype]['soma']
  182. for i in range(math.ceil(nseg[celltype]['soma']))]
  183. )
  184. seglocs[ipost].extend(
  185. random.choices(seglocs[ipost],
  186. k=self._calculate_total_synapses(celltype)['axosomatic'] // num_dict[celltype] - math.ceil(nseg[celltype]['soma']))
  187. )
  188. random.shuffle(seglocs[ipost])
  190. return seglocs
  194. def _process_all_connections(self, weights, seglocs):
  195. for conntype in self.randomlist.keys():
  196. self._process_connections(conntype, weights, seglocs)
  198. def _process_connections(self, conntype, weights, seglocs):
  199. if conntype == 'LongE':
  200. synsperconn = {}
  201. for sec in seclist['PT']['all']:
  202. synsperconn[sec] = math.ceil(nseg['PT'][sec]/numCells_long)
  203. for ipost in range(num_PT):
  204. for pretype in ['S1_4K', 'S1_12K', 'OC']:
  205. for ipre in range(numCells_long):
  206. self._process_single_connection(conntype, 'PT', pretype,
  207. ipost, ipre, weights, seglocs, synsperconn)
  209. elif conntype in ['PVE', 'SOME']:
  210. if conntype == 'PVE':
  211. pretype = 'PV'
  212. else:
  213. pretype = 'SOM'
  214. for ipost in range(num_PT):
  215. for ipre in range(num_dict[pretype]):
  216. self._process_single_connection(conntype, 'PT', pretype,
  217. ipost, ipre, weights, seglocs, 1)
  219. elif conntype == 'EI':
  220. for posttype in ['PV', 'SOM']:
  221. for ipost in range(num_dict[posttype]):
  222. for ipre in range(num_PT):
  223. self._process_single_connection(conntype, posttype, None,
  224. ipost, ipre, weights, seglocs, 1)
  226. elif conntype == 'II':
  227. for posttype in ['PV', 'SOM']:
  228. for pretype in ['PV', 'SOM']:
  229. num_cells = num_dict[pretype]
  230. for ipost in range(num_dict[posttype]):
  231. for ipre in range(num_cells - (1 if posttype == pretype else 0)):
  232. self._process_single_connection(conntype, posttype, pretype,
  233. ipost, ipre, weights, seglocs, 1)
  235. def _process_single_connection(self, conntype, posttype, pretype, ipost, ipre, weights, seglocs, synsperconn):
  236. if posttype == 'PT':
  237. selected_weights = {}
  238. selected_locs = {}
  239. if conntype == 'LongE':
  240. for sec in seclist['PT']['dend']:
  241. selected_weights[sec] = [weights[posttype][sec][ipost].pop() for _ in range(synsperconn[sec])]
  242. selected_locs[sec] = [seglocs[posttype][sec][ipost].pop() for _ in range(synsperconn[sec])]
  243. else:
  244. if pretype == 'PV':
  245. selected_weights['soma'] = [weights[posttype]['soma'][ipost].pop() for _ in range(synsperconn)]
  246. selected_locs['soma'] = [seglocs[posttype]['soma'][ipost].pop() for _ in range(synsperconn)]
  247. else:
  248. for sec in seclist['PT']['dend']:
  249. selected_weights[sec] = [weights[posttype][sec][ipost].pop() for _ in range(synsperconn)]
  250. selected_locs[sec] = [seglocs[posttype][sec][ipost].pop() for _ in range(synsperconn)]
  251. else:
  252. selected_weights = [weights[posttype][ipost].pop() for _ in range(synsperconn)]
  253. selected_locs = [seglocs[posttype][ipost].pop() for _ in range(synsperconn)]
  255. # Store the weights and locations in randomlist
  256. if conntype == 'II':
  257. self.randomlist[conntype][posttype][pretype][ipost][ipre] = list(zip(selected_locs, selected_weights))
  258. elif conntype == 'EI':
  259. self.randomlist[conntype][posttype][ipost][ipre] = list(zip(selected_locs, selected_weights))
  260. elif conntype == 'LongE':
  261. for sec in seclist['PT']['dend']:
  262. self.randomlist[conntype][pretype][sec][ipost][ipre] = list(zip(selected_locs[sec], selected_weights[sec]))
  263. else:
  264. if pretype == 'SOM':
  265. for sec in seclist['PT']['dend']:
  266. self.randomlist[conntype][ipost][ipre][sec] = list(zip(selected_locs[sec], selected_weights[sec]))
  267. else:
  268. self.randomlist[conntype][ipost][ipre]['soma'] = list(zip(selected_locs['soma'], selected_weights['soma']))
  273. #------------------------------------------------------------------------------
  274. #
  275. # NETWORK PARAMETERS
  276. #
  277. #------------------------------------------------------------------------------
  279. #------------------------------------------------------------------------------
  280. # General network parameters
  281. #------------------------------------------------------------------------------
  282. netParams.scale = cfg.scale # Scale factor for number of cells
  283. netParams.sizeX = cfg.sizeX # x-dimension (horizontal length) size in um
  284. netParams.sizeY = cfg.sizeY # y-dimension (vertical height or cortical depth) size in um
  285. netParams.sizeZ = cfg.sizeZ # z-dimension (horizontal depth) size in um
  286. netParams.shape = 'cylinder' # cylindrical (column-like) volume
  288. #------------------------------------------------------------------------------
  289. # General connectivity parameters
  290. #------------------------------------------------------------------------------
  291. netParams.scaleConnWeight = 1.0 # Connection weight scale factor (default if no model specified)
  292. #netParams.scaleConnWeightModels = {'HH_full': 1.0} #scale conn weight factor for each cell model
  293. #netParams.scaleConnWeightNetStims = 1.0 #0.5 # scale conn weight factor for NetStims
  294. netParams.defaultThreshold = -5.0 # spike threshold, 10 mV is NetCon default, lower it for all cells
  295. netParams.defaultDelay = 2.0 # default conn delay (ms)
  296. netParams.propVelocity = 500.0 # propagation velocity (um/ms)
  297. netParams.probLambda = 100.0 # length constant (lambda) for connection probability decay (um)
  298. netParams.defineCellShapes = True # convert stylized geoms to 3d points
  301. # special condition to change Kgbar together with ih when running batch
  302. # note min Kgbar is assumed to be 0.5, so this is set here as an offset
  303. #if cfg.makeKgbarFactorEqualToNewFactor:
  304. # cfg.KgbarFactor = 0.5 + cfg.modifyMechs['newFactor']
  306. #------------------------------------------------------------------------------
  307. # Cell parameters
  308. #------------------------------------------------------------------------------
  309. #cellModels = ['HH_full']
  311. cellModels = ['HH_reduced']
  312. layer = {'1':[0.0, 0.1],'5B': [0.47,0.8],'longS1_4K': [2.2,2.3],'longS1_12K': [2.2,2.3], 'longOC': [2.2,2.3]} # normalized layer boundaries
  314. netParams.correctBorder = {'threshold': [cfg.correctBorderThreshold, cfg.correctBorderThreshold, cfg.correctBorderThreshold],
  315. 'yborders': [layer['1'][0], layer['5B'][0], layer['5B'][1]]} # correct conn border effect
  319. #------------------------------------------------------------------------------
  320. ## Load cell rules previously saved using netpyne format
  321. cellParamLabels = ['PV_simple', 'SOM_simple', 'PT5B_reduced']# ['VIP_reduced', 'NGF_simple','PT5B_full'] # # list of cell rules to load from file
  322. loadCellParams = cellParamLabels
  323. saveCellParams = False #True
  325. for ruleLabel in loadCellParams:
  326. netParams.loadCellParamsRule(label=ruleLabel, fileName='cells/'+ruleLabel+'_cellParams.pkl')
  328. # Adapt K gbar
  329. if ruleLabel in ['IT2_reduced', 'IT4_reduced', 'IT5A_reduced', 'IT5B_reduced', 'IT6_reduced', 'CT6_reduced', 'IT5A_full']:
  330. cellRule = netParams.cellParams[ruleLabel]
  331. for secName in cellRule['secs']:
  332. for kmech in [k for k in cellRule['secs'][secName]['mechs'].keys() if k.startswith('k') and k!='kBK']:
  333. cellRule['secs'][secName]['mechs'][kmech]['gbar'] *= cfg.KgbarFactor
  335. if ruleLabel in ['PT5B_reduced']:
  336. cellRule = netParams.cellParams[ruleLabel]
  337. seclist['PT']['dend'] = cellRule['secLists']['alldend']
  338. seclist['PT']['all'] = [sec for sec in cellRule['secs'] if sec not in ['axon']]
  339. secL_PT = {k: 0.0 for k in cellRule['secs']}
  340. for secName in cellRule['secs']:
  341. #cellRule['secs'][secName]['geom']['L'] = 5
  342. secL_PT[secName] = cellRule['secs'][secName]['geom']['L']
  343. cellRule['secs'][secName]['geom']['nseg'] = math.floor(cellRule['secs'][secName]['geom']['L'])
  344. cellRule['secs'][secName]['weightNorm'] = None
  345. elif ruleLabel in ['PV_simple']:
  346. cellRule = netParams.cellParams[ruleLabel]
  347. secL_PV = {'soma': 0.0, 'dend': 0.0, 'axon': 0.0}
  348. for secName in cellRule['secs']:
  349. #cellRule['secs'][secName]['geom']['L'] = 5
  350. secL_PV[secName] = cellRule['secs'][secName]['geom']['L']
  351. cellRule['secs'][secName]['geom']['nseg'] = math.floor(cellRule['secs'][secName]['geom']['L'])
  352. cellRule['secs'][secName]['weightNorm'] = None
  353. elif ruleLabel in ['SOM_simple']:
  354. cellRule = netParams.cellParams[ruleLabel]
  355. secL_SOM = {'soma': 0.0, 'dend': 0.0, 'axon': 0.0}
  356. for secName in cellRule['secs']:
  357. #cellRule['secs'][secName]['geom']['L'] = 5
  358. secL_SOM[secName] = cellRule['secs'][secName]['geom']['L']
  359. cellRule['secs'][secName]['geom']['nseg'] = math.floor(cellRule['secs'][secName]['geom']['L'])
  360. cellRule['secs'][secName]['weightNorm'] = None
  362. #print('sec length:', secL_PT, secL_PV, secL_SOM)
  363. #------------------------------------------------------------------------------
  364. ## PT5B full cell model params (700+ comps)
  365. if 'PT5B_full' not in loadCellParams:
  366. ihMod2str = {'harnett': 1, 'kole': 2, 'migliore': 3}
  367. cellRule = netParams.importCellParams(label='PT5B_full', conds={'cellType': 'PT', 'cellModel': 'HH_full'},
  368. fileName='cells/PTcell.hoc', cellName='PTcell', cellArgs=[ihMod2str[cfg.ihModel], cfg.ihSlope], somaAtOrigin=True)
  369. nonSpiny = ['apic_0', 'apic_1']
  370. netParams.addCellParamsSecList(label='PT5B_full', secListName='perisom', somaDist=[0, 50]) # sections within 50 um of soma
  371. netParams.addCellParamsSecList(label='PT5B_full', secListName='below_soma', somaDistY=[-600, 0]) # sections within 0-300 um of soma
  372. for sec in nonSpiny: cellRule['secLists']['perisom'].remove(sec)
  373. cellRule['secLists']['alldend'] = [sec for sec in cellRule.secs if ('dend' in sec or 'apic' in sec)] # basal+apical
  374. cellRule['secLists']['apicdend'] = [sec for sec in cellRule.secs if ('apic' in sec)] # apical
  375. cellRule['secLists']['spiny'] = [sec for sec in cellRule['secLists']['alldend'] if sec not in nonSpiny]
  376. # Adapt ih params based on cfg param
  377. for secName in cellRule['secs']:
  378. for mechName,mech in cellRule['secs'][secName]['mechs'].items():
  379. if mechName in ['ih','h','h15', 'hd']:
  380. mech['gbar'] = [g*cfg.ihGbar for g in mech['gbar']] if isinstance(mech['gbar'],list) else mech['gbar']*cfg.ihGbar
  381. if cfg.ihModel == 'migliore':
  382. mech['clk'] = cfg.ihlkc # migliore's shunt current factor
  383. mech['elk'] = cfg.ihlke # migliore's shunt current reversal potential
  384. if secName.startswith('dend'):
  385. mech['gbar'] *= cfg.ihGbarBasal # modify ih conductance in soma+basal dendrites
  386. mech['clk'] *= cfg.ihlkcBasal # modify ih conductance in soma+basal dendrites
  387. if secName in cellRule['secLists']['below_soma']: #secName.startswith('dend'):
  388. mech['clk'] *= cfg.ihlkcBelowSoma # modify ih conductance in soma+basal dendrites
  390. # Adapt K gbar
  391. for kmech in [k for k in cellRule['secs'][secName]['mechs'].keys() if k.startswith('k') and k!='kBK']:
  392. cellRule['secs'][secName]['mechs'][kmech]['gbar'] *= cfg.KgbarFactor
  394. # NOT Reduce dend Na to HAVE dend spikes
  395. for secName in cellRule['secLists']['alldend']:
  396. cellRule['secs'][secName]['mechs']['nax']['gbar'] = 0.0153130368342 * cfg.dendNa # 1
  399. cellRule['secs']['soma']['mechs']['nax']['gbar'] = 0.0153130368342 * cfg.somaNa # 5
  400. cellRule['secs']['axon']['mechs']['nax']['gbar'] = 0.0153130368342 * cfg.axonNa # 5
  401. cellRule['secs']['axon']['geom']['Ra'] = 137.494564931 * cfg.axonRa # 0.005
  402. # Remove Na (TTX)
  403. if cfg.removeNa:
  404. for secName in cellRule['secs']: cellRule['secs'][secName]['mechs']['nax']['gbar'] = 0.0
  405. #netParams.addCellParamsWeightNorm('PT5B_full', 'conn/PT5B_full_weightNorm.pkl', threshold=cfg.weightNormThreshold) # load weight norm
  406. if saveCellParams: netParams.saveCellParamsRule(label='PT5B_full', fileName='cells/PT5B_full_cellParams.pkl')
  409. #------------------------------------------------------------------------------
  410. # Reduced cell model params (6-comp)
  411. reducedCells = { # layer and cell type for reduced cell models
  412. #'PT5B_reduced': {'layer': '5B', 'cname': 'SPI6', 'carg': None}
  413. }
  415. reducedSecList = { # section Lists for reduced cell model
  416. 'alldend': ['Adend1', 'Adend2', 'Adend3', 'Bdend'],
  417. 'spiny': ['Adend1', 'Adend2', 'Adend3', 'Bdend'],
  418. 'apicdend': ['Adend1', 'Adend2', 'Adend3'],
  419. 'perisom': ['soma']}
  422. for label, p in reducedCells.items(): # create cell rules that were not loaded
  423. if label not in loadCellParams:
  424. cellRule = netParams.importCellParams(label=label, conds={'cellType': label[0], 'cellModel': 'HH_reduced', 'ynorm': layer[p['layer']]},
  425. fileName='cells/'+p['cname']+'.py', cellName=p['cname'], cellArgs={'params': p['carg']} if p['carg'] else None)
  426. dendL = (layer[p['layer']][0]+(layer[p['layer']][1]-layer[p['layer']][0])/2.0) * cfg.sizeY # adapt dend L based on layer
  427. for secName in ['Adend1', 'Adend2', 'Adend3', 'Bdend']:
  428. cellRule['secs'][secName]['geom']['L'] = dendL / 3.0
  429. for k,v in reducedSecList.items(): cellRule['secLists'][k] = v # add secLists
  430. netParams.addCellParamsWeightNorm('PT5B_reduced', 'conn/'+'PT5B_reduced'+'_weightNorm.pkl', threshold=cfg.weightNormThreshold) # add weightNorm
  431. if saveCellParams: netParams.saveCellParamsRule(label='PT5B_reduced', fileName='cells/'+'PT5B_reduced'+'_cellParams.pkl')
  434. # set 3d points
  435. offset, prevL = 0, 0
  436. somaL = netParams.cellParams[label]['secs']['soma']['geom']['L']
  437. for secName, sec in netParams.cellParams[label]['secs'].items():
  438. sec['geom']['pt3d'] = []
  439. if secName in ['soma', 'Adend1', 'Adend2', 'Adend3']: # set 3d geom of soma and Adends
  440. sec['geom']['pt3d'].append([offset+0, prevL, 0, sec['geom']['diam']])
  441. prevL = float(prevL + sec['geom']['L'])
  442. sec['geom']['pt3d'].append([offset+0, prevL, 0, sec['geom']['diam']])
  443. if secName in ['Bdend']: # set 3d geom of Bdend
  444. sec['geom']['pt3d'].append([offset+0, somaL, 0, sec['geom']['diam']])
  445. sec['geom']['pt3d'].append([offset+sec['geom']['L'], somaL, 0, sec['geom']['diam']])
  446. if secName in ['axon']: # set 3d geom of axon
  447. sec['geom']['pt3d'].append([offset+0, 0, 0, sec['geom']['diam']])
  448. sec['geom']['pt3d'].append([offset+0, -sec['geom']['L'], 0, sec['geom']['diam']])
  452. #------------------------------------------------------------------------------
  453. ## PV cell params (3-comp)
  454. if 'PV_simple' not in loadCellParams:
  455. cellRule = netParams.importCellParams(label='PV_simple', conds={'cellType':'PV', 'cellModel':'HH_simple'},
  456. fileName='cells/FS3.hoc', cellName='FScell1', cellInstance = True)
  457. cellRule['secLists']['spiny'] = ['soma', 'dend']
  458. #netParams.addCellParamsWeightNorm('PV_simple', 'conn/PV_simple_weightNorm.pkl', threshold=cfg.weightNormThreshold)
  459. if saveCellParams: netParams.saveCellParamsRule(label='PV_simple', fileName='cells/PV_simple_cellParams.pkl')
  462. #------------------------------------------------------------------------------
  463. ## SOM cell params (3-comp)
  464. if 'SOM_simple' not in loadCellParams:
  465. cellRule = netParams.importCellParams(label='SOM_simple', conds={'cellType':'SOM', 'cellModel':'HH_simple'},
  466. fileName='cells/LTS3.hoc', cellName='LTScell1', cellInstance = True)
  467. cellRule['secLists']['spiny'] = ['soma', 'dend']
  468. #netParams.addCellParamsWeightNorm('SOM_simple', 'conn/SOM_simple_weightNorm.pkl', threshold=cfg.weightNormThreshold)
  469. if saveCellParams: netParams.saveCellParamsRule(label='SOM_simple', fileName='cells/SOM_simple_cellParams.pkl')
  473. #------------------------------------------------------------------------------
  474. # Population parameters
  475. #------------------------------------------------------------------------------
  477. #------------------------------------------------------------------------------
  478. ## load densities
  479. with open('cells/cellDensity.pkl', 'rb') as fileObj: density = pickle.load(fileObj)['density']
  482. ## Local populations
  483. #netParams.popParams['PT5B'] = {'cellModel': cfg.cellmod['PT5B'], 'cellType': 'PT', 'ynormRange': layer['5B'], 'numCells': num_PT}
  484. netParams.popParams['PT5B_reduced'] = {'cellModel': 'HH_reduced', 'cellType': 'PT', 'ynormRange': layer['5B'], 'numCells': num_PT}
  485. netParams.popParams['SOM5B'] = {'cellModel': 'HH_simple', 'cellType': 'SOM','ynormRange': layer['5B'], 'numCells': num_SOM}
  486. netParams.popParams['PV5B'] = {'cellModel': 'HH_simple', 'cellType': 'PV', 'ynormRange': layer['5B'], 'numCells': num_PV}
  487. #netParams.popParams['rnd'] = {'cellModel': 'Randomizer', 'numCells': 1}
  490. if cfg.singleCellPops:
  491. for pop in netParams.popParams.values(): pop['numCells'] = 1
  493. #------------------------------------------------------------------------------
  494. ## Long-range input populations (VecStims)
  496. numCells_long = 20
  498. ''' spkTimes_4K = np.concatenate((np.arange(0, 20, 1), np.arange(cfg.t_HSP + 5*1000, cfg.t_HSP + 15*1000, 1/rate['4K']*1000) ,
  499. np.arange(ts['D1train'], ts['D1train'] + 10*1000, 1/rate['4K']*1000) ,
  500. np.arange(ts['D1train'] + 11*1000, ts['D1train'] + 21*1000, 1/rate['4K']*1000) ,
  501. np.arange(ts['D1train'] + 22*1000, ts['D1train'] + 32*1000, 1/rate['4K']*1000) ,
  502. np.arange(ts['D1test'] + 5*1000, ts['D1test'] + 15*1000, 1/rate['4K']*1000) ,
  503. np.arange(ts['D3test'] + 5*1000, ts['D3test'] + 15*1000, 1/rate['4K']*1000) ,
  504. np.arange(ts['D4extinct'], ts['D4extinct'] + 40*1000, 1/rate['4K']*1000) ,
  505. np.arange(ts['D4extinct'] + 41*1000, ts['D4extinct'] + 81*1000, 1/rate['4K']*1000) ,
  506. np.arange(ts['D4extinct'] + 82*1000, ts['D4extinct'] + 122*1000, 1/rate['4K']*1000) ,
  507. np.arange(ts['D4extinct'] + 123*1000, ts['D4extinct'] + 163*1000, 1/rate['4K']*1000) ,
  508. np.arange(ts['D4extinct'] + 164*1000, ts['D4extinct'] + 204*1000, 1/rate['4K']*1000) ,
  509. np.arange(ts['D4test'] + 5*1000, ts['D4test'] + 15*1000, 1/rate['4K']*1000) ,
  510. np.arange(ts['D5extinct'], ts['D5extinct'] + 40*1000, 1/rate['4K']*1000) ,
  511. np.arange(ts['D5extinct'] + 41*1000, ts['D5extinct'] + 81*1000, 1/rate['4K']*1000),
  512. np.arange(ts['D5extinct'] + 123*1000, ts['D5extinct'] + 163*1000, 1/rate['4K']*1000) ,
  513. np.arange(ts['D5extinct'] + 164*1000, ts['D5extinct'] + 204*1000, 1/rate['4K']*1000) ,
  514. np.arange(ts['D5test'] + 5*1000, ts['D5test'] + 15*1000, 1/rate['4K']*1000)))
  515. spkTimes_12K = np.concatenate((np.arange(cfg.t_HSP + 35*1000, cfg.t_HSP + 45*1000, 1/rate['12K']*1000),
  516. np.arange(ts['D1test'] + 35*1000, ts['D1test'] + 45*1000, 1/rate['12K']*1000) ,
  517. np.arange(ts['D3test'] + 35*1000, ts['D3test'] + 45*1000, 1/rate['12K']*1000),
  518. np.arange(ts['D4test'] + 35*1000, ts['D4test'] + 45*1000, 1/rate['12K']*1000),
  519. np.arange(ts['D5test'] + 35*1000, ts['D5test'] + 45*1000, 1/rate['12K']*1000)))
  520. spkTimes_shock = np.concatenate((np.arange(ts['D1train'] + 8*1000, ts['D1train'] + 10*1000, 1/rate['shock']*1000),
  521. np.arange(ts['D1train'] + 19*1000, ts['D1train'] + 21*1000, 1/rate['shock']*1000),
  522. np.arange(ts['D1train'] + 30*1000, ts['D1train'] + 32*1000, 1/rate['shock']*1000)))
  523. '''
  525. ts = cfg.tstart
  526. if cfg.addLongConn:
  527. # VecStims
  528. longPops = ['S1_4K','S1_12K', 'OC']
  529. # create list of pulses (each item is a dict with pulse params) #noise(0 = deterministic; 1 = completely random)
  530. rate = {'4K': 50, '12K': 50, 'shock': 100} #Hz
  531. hspRate = 5
  532. pulses_4K = [{'start': ts['HSPset0'], 'end': ts['HSPset0']+cfg.t_hspvtrg, 'rate': hspRate, 'noise': 0.25}, #HSP
  533. {'start': ts['HSPset1'], 'end': ts['HSPset1']+cfg.t_hspvtrg, 'rate': hspRate, 'noise': 0.25}, #HSP
  534. {'start': ts['HSP0'], 'end': ts['HSP0']+cfg.t_HSP, 'rate': hspRate, 'noise': 0.25}, #HSP
  535. {'start': ts['HSPset2'], 'end': ts['HSPset2']+cfg.t_hspvtrg, 'rate': hspRate, 'noise': 0.25}, #HSP
  536. {'start': ts['HSP1'], 'end': ts['HSP1']+cfg.t_HSP , 'rate': hspRate, 'noise': 0.25}, #HSP
  537. {'start': ts['Baseline'] + 5*1000, 'end': ts['Baseline'] + 15*1000, 'rate': rate['4K'], 'noise': 0}, #Baseline
  538. {'start': ts['D1train'], 'end': ts['D1train'] + 10*1000, 'rate': rate['4K'], 'noise': 0}, #D1 FC
  539. {'start': ts['D1train'] + 11*1000, 'end': ts['D1train'] + 21*1000, 'rate': rate['4K'], 'noise': 0}, #D1 FC
  540. {'start': ts['D1train'] + 22*1000, 'end': ts['D1train'] + 32*1000, 'rate': rate['4K'], 'noise': 0}, #D1 FC
  541. {'start': ts['D1test'] + 5*1000, 'end': ts['D1test'] + 15*1000, 'rate': rate['4K'], 'noise': 0}, #D1 test
  542. {'start': ts['D3test'] + 5*1000, 'end': ts['D3test'] + 15*1000, 'rate': rate['4K'], 'noise': 0}, #D3 test
  543. {'start': ts['D4extinct'], 'end': ts['D4extinct'] + 40*1000, 'rate': rate['4K'], 'noise': 0}, #D4 FC
  544. {'start': ts['D4extinct'] + 41*1000, 'end': ts['D4extinct'] + 81*1000, 'rate': rate['4K'], 'noise': 0}, #D4 FC
  545. {'start': ts['D4extinct'] + 82*1000, 'end': ts['D4extinct'] + 122*1000, 'rate': rate['4K'], 'noise': 0}, #D4 FC
  546. {'start': ts['D4extinct'] + 123*1000, 'end': ts['D4extinct'] + 163*1000, 'rate': rate['4K'], 'noise': 0}, #D4 FC
  547. {'start': ts['D4extinct'] + 164*1000, 'end': ts['D4extinct'] + 204*1000, 'rate': rate['4K'], 'noise': 0}, #D4 FC
  548. {'start': ts['D4test'] + 5*1000, 'end': ts['D4test'] + 15*1000, 'rate': rate['4K'], 'noise': 0}, #D4 test
  549. {'start': ts['D5extinct'], 'end': ts['D5extinct'] + 40*1000, 'rate': rate['4K'], 'noise': 0}, #D5 FC
  550. {'start': ts['D5extinct'] + 41*1000, 'end': ts['D5extinct'] + 81*1000, 'rate': rate['4K'], 'noise': 0}, #D5 FC
  551. {'start': ts['D5extinct'] + 82*1000, 'end': ts['D5extinct'] + 122*1000, 'rate': rate['4K'], 'noise': 0}, #D5 FC
  552. {'start': ts['D5extinct'] + 123*1000, 'end': ts['D5extinct'] + 163*1000, 'rate': rate['4K'], 'noise': 0}, #D5 FC
  553. {'start': ts['D5extinct'] + 164*1000, 'end': ts['D5extinct'] + 204*1000, 'rate': rate['4K'], 'noise': 0}, #D5 FC
  554. {'start': ts['D5test'] + 5*1000, 'end': ts['D5test'] + 15*1000, 'rate': rate['4K'], 'noise': 0} #D5 test
  555. ]
  557. pulses_12K = [
  558. {'start': ts['HSPset0'], 'end': ts['HSPset0']+cfg.t_hspvtrg, 'rate': hspRate, 'noise': 0.25}, #HSP
  559. {'start': ts['HSPset1'], 'end': ts['HSPset1']+cfg.t_hspvtrg, 'rate': hspRate, 'noise': 0.25}, #HSP
  560. {'start': ts['HSP0'], 'end': ts['HSP0']+cfg.t_HSP, 'rate': hspRate, 'noise': 0.25}, #HSP
  561. {'start': ts['HSPset2'], 'end': ts['HSPset2']+cfg.t_hspvtrg, 'rate': hspRate, 'noise': 0.25}, #HSP
  562. {'start': ts['HSP1'], 'end': ts['HSP1']+cfg.t_HSP , 'rate': hspRate, 'noise': 0.25}, #HSP
  563. {'start': ts['Baseline'] + 35*1000, 'end': ts['Baseline'] + 45*1000, 'rate': rate['12K'], 'noise': 0}, #Baseline
  564. {'start': ts['D1test'] + 35*1000, 'end': ts['D1test'] + 45*1000, 'rate': rate['12K'], 'noise': 0}, #D1 test
  565. {'start': ts['D3test'] + 35*1000, 'end': ts['D3test'] + 45*1000, 'rate': rate['12K'], 'noise': 0}, #D3 test
  566. {'start': ts['D4test'] + 35*1000, 'end': ts['D4test'] + 45*1000, 'rate': rate['12K'], 'noise': 0}, #D4 test
  567. {'start': ts['D5test'] + 35*1000, 'end': ts['D5test'] + 45*1000, 'rate': rate['12K'], 'noise': 0} #D5 test
  568. ]
  571. pulses_shock = [
  572. {'start': ts['HSPset0'], 'end': ts['HSPset0']+cfg.t_hspvtrg, 'rate': hspRate, 'noise': 0.25}, #HSP
  573. {'start': ts['HSPset1'], 'end': ts['HSPset1']+cfg.t_hspvtrg, 'rate': hspRate, 'noise': 0.25}, #HSP
  574. {'start': ts['HSP0'], 'end': ts['HSP0']+cfg.t_HSP, 'rate': hspRate, 'noise': 0.25}, #HSP
  575. {'start': ts['HSPset2'], 'end': ts['HSPset2']+cfg.t_hspvtrg, 'rate': hspRate, 'noise': 0.25}, #HSP
  576. {'start': ts['HSP1'], 'end': ts['HSP1']+cfg.t_HSP , 'rate': hspRate, 'noise': 0.25}, #HSP
  577. {'start': ts['D1train'] + 8*1000, 'end': ts['D1train'] + 10*1000, 'rate': rate['shock'], 'noise': 0}, #D1 FC
  578. {'start': ts['D1train'] + 19*1000, 'end': ts['D1train'] + 21*1000, 'rate': rate['shock'], 'noise': 0}, #D1 FC
  579. {'start': ts['D1train'] + 30*1000, 'end': ts['D1train'] + 32*1000, 'rate': rate['shock'], 'noise': 0} #D1 FC
  580. ]
  582. netParams.popParams['S1_4K'] = {'cellModel': 'VecStim', 'numCells': numCells_long,
  583. 'ynormRange': layer['longS1_4K'], 'spkTimes': [cfg.duration], 'pulses': pulses_4K}
  586. netParams.popParams['S1_12K'] = {'cellModel': 'VecStim', 'numCells': numCells_long,
  587. 'ynormRange': layer['longS1_12K'], 'spkTimes': [cfg.duration], 'pulses': pulses_12K}
  589. netParams.popParams['OC'] = {'cellModel': 'VecStim', 'numCells': numCells_long,
  590. 'ynormRange': layer['longOC'], 'spkTimes': [cfg.duration], 'pulses': pulses_shock}
  592. '''netParams.popParams['HSP1'] = {'cellModel': 'VecStim', 'numCells': 1,
  593. 'spikePattern': {'type': 'poisson', 'start': 0, 'stop': cfg.t_hspvtrg, 'frequency': 10}}
  594. netParams.popParams['HSP2'] = {'cellModel': 'VecStim', 'numCells': 1,
  595. 'spikePattern': {'type': 'poisson', 'start': ts['D1test'] + cfg.t_test +cfg.t_cool-20, 'stop': ts['D3test'], 'frequency': 10}}
  596. netParams.popParams['HSP3'] = {'cellModel': 'VecStim', 'numCells': 1,
  597. 'spikePattern': {'type': 'poisson', 'start': ts['D4test'] + cfg.t_test +cfg.t_cool-20, 'stop': ts['D5extinct'], 'frequency': 10}}
  598. '''
  601. #netParams.popParams['HSP'] = {'cellModel': 'VecStim', 'numCells': 1,
  602. # 'spkTimes': [ts['D1test'] + cfg.t_test +cfg.t_cool], 'pulses': pulses_HSP}
  604. #------------------------------------------------------------------------------
  605. # Synaptic mechanism parameters
  606. #------------------------------------------------------------------------------
  607. netParams.synMechParams['NMDA'] = {'mod': 'MyExp2SynNMDABB', 'tau1NMDA': 15, 'tau2NMDA': 150, 'e': 0}
  608. netParams.synMechParams['AMPA'] = {'mod':'MyExp2SynBB', 'tau1': 0.05, 'tau2': 5.3*cfg.AMPATau2Factor, 'e': 0}
  609. netParams.synMechParams['GABAB'] = {'mod':'MyExp2SynBB', 'tau1': 3.5, 'tau2': 260.9, 'e': -93}
  610. netParams.synMechParams['GABAA'] = {'mod':'MyExp2SynBB', 'tau1': 0.07, 'tau2': 18.2, 'e': -80}
  611. netParams.synMechParams['GABAASlow'] = {'mod': 'MyExp2SynBB','tau1': 2, 'tau2': 100, 'e': -80}
  612. netParams.synMechParams['GABAASlowSlow'] = {'mod': 'MyExp2SynBB', 'tau1': 200, 'tau2': 400, 'e': -80}
  618. ESynMech = ['AMPA', 'NMDA']
  619. SOMESynMech = ['GABAASlow','GABAB']
  620. SOMISynMech = ['GABAASlow']
  621. PVSynMech = ['GABAA']
  625. #------------------------------------------------------------------------------
  626. # Local connectivity parameters
  627. #------------------------------------------------------------------------------
  629. # Store the number of segments in a dictionary
  630. nseg = {'PV': {key: math.floor(value) for key, value in secL_PV.items()},
  631. 'SOM': {key: math.floor(value) for key, value in secL_SOM.items()},
  632. 'PT': {key: math.floor(value) for key, value in secL_PT.items()}} #highest possible spine density = 1/um
  635. # plasticity parameters
  636. STDPparams = {'hebbwt': .5, 'antiwt':-.5, 'wmax': 15, 'RLon': 0 , 'RLhebbwt': 0.1, 'RLantiwt': -0.100, \
  637. 'tauhebb': 10, 'RLwindhebb': 50, 'useRLexp': 0, 'softthresh': 1, 'verbose':0}
  639. randomlistgen = RandomSequenceNetParams()
  640. randomlistgen.initializeRandomSequence(cfg)
  642. # Use configurable data directory
  643. data_dir = os.environ.get('SIM_DATA_DIR', './data')
  644. randomlist_path = os.path.join(data_dir, f'seed{cfg.rdseed}', f'randomlistgen{cfg.rdseed}.txt')
  645. os.makedirs(os.path.dirname(randomlist_path), exist_ok=True)
  646. with open(randomlist_path, 'w') as f:
  647. f.write(json.dumps(randomlistgen.randomlist, indent=4))
  648. '''cell_types = ['PT', 'PV', 'SOM']
  649. total_synapses_all_cells = 0
  651. for celltype in cell_types:
  652. synapse_counts = randomlistgen._calculate_total_synapses(celltype)
  653. axosomatic_synapses = synapse_counts['axosomatic']
  654. axodendritic_synapses = sum(synapse_counts['axodendritic'].values())
  656. total_synapses = axosomatic_synapses + axodendritic_synapses
  657. total_synapses_all_cells += total_synapses
  659. print(total_synapses_all_cells)'''
  660. #------------------------------------------------------------------------------
  661. ## E -> I
  662. if cfg.EIGain: # Use IEGain if value set
  663. cfg.EPVGain = cfg.EIGain
  664. cfg.ESOMGain = cfg.EIGain
  665. else:
  666. cfg.EIGain = (cfg.EPVGain+cfg.ESOMGain)/2.0
  668. if cfg.addConn and (cfg.EPVGain > 0.0 or cfg.ESOMGain > 0.0):
  669. preTypes = ['PT']
  670. postTypes = ['PV', 'SOM']
  671. ESynMech = ['AMPA','NMDA']
  672. lGain = [cfg.EPVGain, cfg.ESOMGain] # E -> PV or E -> SOM
  673. for ipost, postType in enumerate(postTypes):
  674. weights = [
  675. randomlistgen.randomlist['EI'][postType][j][i][0][1]
  676. for i in range(num_PT)
  677. for j in range(num_dict[postType])
  678. ]
  679. weights_syns = [[x, x] for x in weights]
  680. locs = [
  681. randomlistgen.randomlist['EI'][postType][j][i][0][0]
  682. for i in range(num_PT)
  683. for j in range(num_dict[postType])
  684. ]
  685. locs_syns = [[x, x] for x in locs]
  686. ruleLabel = 'EI'+'_'+ postType
  687. netParams.connParams[ruleLabel] = {
  688. 'preConds': {'cellType': preTypes},#, 'ynorm': list(preBin)},
  689. 'postConds': {'cellType': postType},#, 'ynorm': list(postBin)},
  690. 'synMech': ESynMech,
  691. 'connList': [(i, j) for i in range(num_PT) for j in range(num_dict[postType])],
  692. 'weight': weights_syns,#lambda pre, post: randomlistgen.randomlist['EI'][postType][post.index][pre.index][0][1],
  693. 'loc': locs_syns, #lambda pre, post: randomlistgen.randomlist['EI'][postType][post.index][pre.index][0][0],
  694. #'delay': 'defaultDelay+dist_3D/propVelocity',
  695. 'sec': 'soma',
  696. 'synsPerConn': 1,
  697. 'plast': {'mech': 'STDP', 'params': STDPparams}} # simple I cells used right now only have soma
  698. #debug: line 695 in compartCell.py, conn['plast'] -> conn
  701. #------------------------------------------------------------------------------
  702. ## I -> all
  703. if cfg.addConn:
  704. preCellTypes = ['SOM', 'PV']
  705. ynorms = [[0,1]]*2 # <----not local, interneuron can connect to all layers
  706. postCellTypes = ['PT', 'PV', 'SOM']
  707. disynapticBias = None # default, used for I->I
  709. for i,(preCellType, ynorm) in enumerate(zip(preCellTypes, ynorms)):
  710. for ipost, postCellType in enumerate(postCellTypes):
  711. if postCellType == 'PV': # postsynaptic I cell
  712. sec = 'soma'
  713. synWeightFraction = [1]
  714. if preCellType == 'PV': # PV->PV
  715. # weight = IIweight * cfg.PVPVGain
  716. synMech = PVSynMech
  717. else: # SOM->PV
  718. # weight = IIweight * cfg.SOMPVGain
  719. synMech = SOMISynMech
  720. elif postCellType == 'SOM': # postsynaptic I cell
  721. sec = 'soma'
  722. synWeightFraction = [1]
  723. if preCellType == 'PV': # PV->SOM
  724. # weight = IIweight * cfg.PVSOMGain
  725. synMech = PVSynMech
  726. else: # SOM->SOM
  727. # weight = IIweight * cfg.SOMSOMGain
  728. synMech = SOMISynMech
  729. elif postCellType == 'PT': # postsynaptic PT cell
  730. #disynapticBias = IEdisynBias
  731. if preCellType == 'PV': # PV->E
  732. #weight = IEweight * cfg.IPTGain * cfg.PVEGain
  733. synMech = PVSynMech
  734. sec = 'perisom'
  735. else: # SOM->E
  736. #weight = IEweight * cfg.IPTGain * cfg.SOMEGain
  737. synMech = SOMESynMech
  738. sec = 'spiny'
  739. synWeightFraction = cfg.synWeightFractionSOME
  741. if postCellType == 'PT':
  742. numCell = num_PT
  743. else:
  744. numCell = num_dict[postCellType]
  745. if postCellType == 'PT':
  746. if sec in ['soma', 'perisom']:
  747. sec = 'soma'
  748. weights = [
  749. randomlistgen.randomlist[preCellType+'E'][j][i][sec][0][1]
  750. for i in range(num_dict[preCellType])
  751. for j in range(num_PT)
  752. ]
  753. locs = [
  754. randomlistgen.randomlist[preCellType+'E'][j][i][sec][0][0]
  755. for i in range(num_dict[preCellType])
  756. for j in range(num_PT)
  757. ]
  759. ruleLabel = preCellType +'_'+ postCellType
  760. netParams.connParams[ruleLabel] = {
  761. 'preConds': {'cellType': preCellType, 'ynorm': ynorm},
  762. 'postConds': {'cellType': postCellType, 'ynorm': ynorm},
  763. 'synMech': synMech,
  764. 'connList': [(i, j) for i in range(num_dict[preCellType]) for j in range(numCell)],
  765. 'weight': weights, #lambda pre, post: randomlistgen.randomlist[preCellType + 'E'][postCellType][post.index][pre.index][sec][0][1],
  766. 'loc': locs, #lambda pre, post: randomlistgen.randomlist[preCellType+'E'][postCellType][post.index][pre.index][sec][0][0],
  767. #'delay': 'defaultDelay+dist_3D/propVelocity',
  768. 'synsPerConn': 1,
  769. 'sec': sec,
  770. #'disynapticBias': disynapticBias,
  771. 'plast': {'mech': 'STDP', 'params': STDPparams}}
  772. else:
  774. for s in seclist['PT']['dend']:
  775. weights = [
  776. randomlistgen.randomlist[preCellType+'E'][j][i][s][0][1]
  777. for i in range(num_dict[preCellType])
  778. for j in range(num_PT)
  779. ]
  780. locs = [
  781. randomlistgen.randomlist[preCellType+'E'][j][i][s][0][0]
  782. for i in range(num_dict[preCellType])
  783. for j in range(num_PT)
  784. ]
  785. ruleLabel = preCellType +'_'+ postCellType + '_' + s
  786. netParams.connParams[ruleLabel] = {
  787. 'preConds': {'cellType': preCellType, 'ynorm': ynorm},
  788. 'postConds': {'cellType': postCellType, 'ynorm': ynorm},
  789. 'synMech': synMech,
  790. 'connList': [(i, j) for i in range(num_dict[preCellType]) for j in range(numCell)],
  791. 'weight': weights, #lambda pre, post: randomlistgen.randomlist[preCellType + 'E'][postCellType][post.index][pre.index][s][0][1],
  792. 'loc': locs, #lambda pre, post: randomlistgen.randomlist[preCellType + 'E'][postCellType][post.index][pre.index][s][0][0],
  793. #'delay': 'defaultDelay+dist_3D/propVelocity',
  794. 'synsPerConn': 1,
  795. 'sec': s,
  796. #'disynapticBias': disynapticBias,
  797. 'plast': {'mech': 'STDP', 'params': STDPparams}}
  798. else:
  799. if preCellType == postCellType:
  800. weights = [
  801. randomlistgen.randomlist['II'][postCellType][preCellType][j][i][0][1]
  802. for i in range(num_dict[preCellType]-1)
  803. for j in range(num_dict[postCellType])
  804. ]
  805. locs = [
  806. randomlistgen.randomlist['II'][postCellType][preCellType][j][i][0][0]
  807. for i in range(num_dict[preCellType]-1)
  808. for j in range(num_dict[postCellType])
  809. ]
  810. else:
  811. weights = [
  812. randomlistgen.randomlist['II'][postCellType][preCellType][j][i][0][1]
  813. for i in range(num_dict[preCellType])
  814. for j in range(num_dict[postCellType])
  815. ]
  816. locs = [
  817. randomlistgen.randomlist['II'][postCellType][preCellType][j][i][0][0]
  818. for i in range(num_dict[preCellType])
  819. for j in range(num_dict[postCellType])
  820. ]
  821. ruleLabel = preCellType + '_' + postCellType
  822. netParams.connParams[ruleLabel] = {
  823. 'preConds': {'cellType': preCellType, 'ynorm': ynorm},
  824. 'postConds': {'cellType': postCellType, 'ynorm': ynorm},
  825. 'synMech': synMech,
  826. 'connList': [(i, j) for i in range(num_dict[preCellType]-1) for j in range(numCell)],
  827. 'weight': weights, #lambda pre, post: randomlistgen.randomlist[preCellType + 'E'][postCellType][post.index][pre.index][sec][0][1],
  828. 'loc': locs, #lambda pre, post: randomlistgen.randomlist[preCellType+'E'][postCellType][post.index][pre.index][sec][0][0],
  829. #'delay': 'defaultDelay+dist_3D/propVelocity',
  830. 'synsPerConn': 1,
  831. 'sec': sec,
  832. #'disynapticBias': disynapticBias,
  833. 'plast': {'mech': 'STDP', 'params': STDPparams}}
  837. #------------------------------------------------------------------------------
  838. # Long-range connectivity parameters
  839. #------------------------------------------------------------------------------
  840. if cfg.addLongConn:
  842. longPops = ['S1_4K','S1_12K', 'OC']
  843. cellTypes = ['PT']
  844. for longPop in longPops:
  845. for secName in seclist['PT']['dend']:
  846. weights = [
  847. [syn[1] for syn in randomlistgen.randomlist['LongE'][longPop][secName][j][i]]
  848. for i in range(numCells_long)
  849. for j in range(num_PT)
  850. ]
  851. weights_syns = [[x, x] for x in weights]
  852. locs = [
  853. [syn[0] for syn in randomlistgen.randomlist['LongE'][longPop][secName][j][i]]
  854. for i in range(numCells_long)
  855. for j in range(num_PT)
  856. ]
  857. locs_syns = [[x, x] for x in locs]
  858. ruleLabel = longPop+'_'+secName
  859. netParams.connParams[ruleLabel] = {
  860. 'preConds': {'pop': longPop},
  861. 'postConds': {'cellType': 'PT'},
  862. 'synMech': ESynMech,
  863. 'connList': [(i, j) for i in range(numCells_long) for j in range(num_PT)],
  864. 'weight': weights_syns,
  865. 'loc': locs_syns,
  866. 'synsPerConn': math.ceil(nseg['PT'][secName]/numCells_long),
  867. 'delay': 'defaultDelay+dist_3D/propVelocity',
  868. 'sec': secName,
  869. 'plast': {'mech': 'STDP', 'params': STDPparams}}
  872. #------------------------------------------------------------------------------
  873. # Description
  874. #------------------------------------------------------------------------------
  875. netParams.description = """
  876. - M1 net, 6 layers, 7 cell types
  877. - NCD-based connectivity from Weiler et al. 2008; Anderson et al. 2010; Kiritani et al. 2012;
  878. Yamawaki & Shepherd 2015; Apicella et al. 2012
  879. - Parametrized version based on Sam's code
  880. - Updated cell models and mod files
  881. - Added parametrized current inputs
  882. - Fixed bug: prev was using cell models in /usr/site/nrniv/local/python/ instead of cells
  883. - Use 5 synsperconn for 5-comp cells (HH_reduced); and 1 for 1-comp cells (HH_simple)
  884. - Fixed bug: made global h params separate for each cell model
  885. - Fixed v_init for different cell models
  886. - New IT cell with same geom as PT
  887. - Cleaned cfg and moved background inputs here
  888. - Set EIGain and IEGain for each inh cell type
  889. - Added secLists for PT full
  890. - Fixed reduced CT (wrong vinit and file)
  891. - Added subcellular conn rules to distribute synapses
  892. - PT full model soma centered at 0,0,0
  893. - Set cfg seeds here to ensure they get updated
  894. - Added PVSOMGain and SOMPVGain
  895. - PT subcellular distribution as a cfg param
  896. - Cylindrical volume
  897. - DefaultDelay (for local conns) = 2ms
  898. - Added long range connections based on Yamawaki 2015a,b; Suter 2015; Hooks 2013; Meyer 2011
  899. - Updated cell densities based on Tsai 2009; Lefort 2009; Katz 2011; Wall 2016;
  900. - Separated PV and SOM of L5A vs L5B
  901. - Fixed bugs in local conn (PT, PV5, SOM5, L6)
  902. - Added perisom secList including all sections 50um from soma
  903. - Added subcellular conn rules (for both full and reduced models)
  904. - Improved cell models, including PV and SOM fI curves
  905. - Improved subcell conn rules based on data from Suter15, Hooks13 and others
  906. - Adapted Bdend L of reduced cell models
  907. - Made long pop rates a cfg param
  908. - Set threshold to 0.0 mV
  909. - Parametrized I->E/I layer weights
  910. - Added missing subconn rules (IT6->PT; S1,S2,cM1->IT/CT; long->SOM/PV)
  911. - Added threshold to weightNorm (PT threshold=10x)
  912. - weightNorm threshold as a cfg parameter
  913. - Separate PV->SOM, SOM->PV, SOM->SOM, PV->PV gains
  914. - Conn changes: reduced IT2->IT4, IT5B->CT6, IT5B,6->IT2,4,5A, IT2,4,5A,6->IT5B; increased CT->PV6+SOM6
  915. - Parametrized PT ih gbar
  916. - Added IFullGain parameter: I->E gain for full detailed cell models
  917. - Replace PT ih with Migliore 2012
  918. - Parametrized ihGbar, ihGbarBasal, dendNa, axonNa, axonRa, removeNa
  919. - Replaced cfg list params with dicts
  920. - Parametrized ihLkcBasal and AMPATau2Factor
  921. - Fixed synMechWeightFactor
  922. - Parametrized PT ih slope
  923. - Added disynapticBias to I->E (Yamawaki&Shepherd,2015)
  924. - Fixed E->CT bin 0.9-1.0
  925. - Replaced GABAB with exp2syn and adapted synMech ratios
  926. - Parametrized somaNa
  927. - Added ynorm condition to NetStims
  928. - Added option to play back recorded spikes into long-range inputs
  929. - Fixed Bdend pt3d y location
  930. - Added netParams.convertCellShapes = True to convert stylized geoms to 3d points
  931. - New layer boundaries, cell densities, conn, FS+SOM L4 grouped with L2/3, low cortical input to L4
  932. - Increased exc->L4 based on Yamawaki 2015 fig 5
  933. - v54: Moved from NetPyNE v0.7.9 to v0.9.1 (v54_batch1-6)
  934. - v54: Moved to NetPyNE v0.9.1 and py3 (v54_batch7 onwards)
  935. - v56: Reduced dt from 0.05 to 0.025 (note this version follows from v54, i.e. without new cell types; branch 'paper2019_py3')
  936. - v56: (included in prev version): Added cfg.KgbarFactor
  937. """

netParams.py at commit 8edb39e, no license · at the source

Overview

Authors: Xiaoyang Li1, Qiyu Zheng1,2, Kim Hoi Kin Wong1, Kenneth Kin Yip Wong2,3, Cora Sau Wan Lai1,2
ORCID iDs: Xiaoyang Li, Qiyu Zheng, Kim Hoi Kin Wong, Kenneth Kin Yip Wong, Cora Sau Wan Lai
  1. School of Biomedical Sciences, LKS Faculty of Medicine, The University of Hong Kong, Hong Kong, China
  2. Advanced Biomedical Instrumentation Centre, Hong Kong Science Park, Shatin, New Territories, Hong Kong, China
  3. Department of Electrical and Electronic Engineering, The University of Hong Kong, Hong Kong, China
Institutions: University of Hong Kong (Hong Kong SAR China); Hong Kong Science and Technology Parks Corporation (Hong Kong SAR China)
Journal: Science advances, volume 12, issue 29, article eaec3961
Dates: received 18 September 2025; accepted 2 June 2026; published online 17 July 2026; in print July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1126/sciadv.aec3961 · PMID 42467781 · PMCID PMC13378561 · OpenAlex W7169527484
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: histology / microscopy (modality), mouse (organism), cognitive (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Connectivity, fMRI & imaging, Single-unit activity, calcium imaging
MeSH: Dendritic Spines*, Extinction, Psychological*, Fear*, Learning*, Neuronal Plasticity*, Animals, Male, Mice (* major topic)
Topic: Neuroscience and Neuropharmacology Research (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: National Natural Science Foundation of China (N_HKU735/21); Research Grants Council, University Grants Committee (C1024-22GF, C7074-21G, 17103922, C7011-24GF, 17108821, C7026-25G, 17102525); Innovation and Technology Commission; Health and Medical Research Fund (09200966); Li Ka Shing Faculty of Medicine, University of Hong Kong
Citations: not cited yet (Europe PMC); 84 references in the paper

Abstract

Structural plasticity of dendritic spines has been observed during different learning paradigms, but how the functional dynamics of dendritic spines changes with memory processing and how these patterns relate to structural plasticity and dendritic integration remain unclear. Here, we perform longitudinal functional and structural in vivo imaging of the frontal association cortex in mice subject to fear conditioning and extinction over several days. We show that fear learning induced responsive spines that are more likely to be synchronous and clustered, which are consolidated over the following days but attenuated by extinction. We develop a causal inference model demonstrating that the active spine calcium signals during fear learning prevent the spines from being eliminated while promoting the elimination of neighboring spines after memory consolidation. Furthermore, the dendritic responsive signal reveals a learning-dependent tone discrimination pattern that is correlated to spines’ structural remodeling. Our findings provide in vivo evidence consistent with functional-structural link of dendritic spines in a bidirectional learning paradigm.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 2 matches between paragraphs and lines of code.

Zenodo 20301802

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data, code, and materials availability:”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
At the source: doi.org/10.5281/zenodo.20301802

4768/reversible_spine_model

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 8edb39e800efb9af9fc2a80421d0de4267bdbab8, 2 September 2025
Languages: NEURON (455), Python (80), C/C++ (7)
Size: 794 files, 542 scripts
Software Heritage: not archived
Found in: “Data, code, and materials availability:”
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NEURON (511 files), NumPy (43 files), NetPyNE (37 files), Matplotlib (33 files), SciPy (24 files), Pillow (7 files), pandas (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
543 files
At the source: github.com/4768/reversible_spine_model.git

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 542 scripts, each with its path and the digest of its content;
  • 2 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data, code, and materials availability

This study did not generate new materials. All data and code needed to evaluate and reproduce the results in the paper are present in the paper and/or the Supplemental Materials. The raw data files and simulation model codes have been deposited to Zenodo under the following accession DOI: https://doi.org/10.5281/zenodo.20301802. The simulation model codes used in this paper are also available in the following repository: https://github.com/4768/reversible_spine_model.git.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 2, 28 September 2026

  • Funding: added National Natural Science Foundation of China: N_HKU735/21; Research Grants Council, University Grants Committee: C1024-22GF, C7074-21G, 17103922, C7011-24GF, 17108821, C7026-25G, 17102525; Innovation and Technology Commission; Health and Medical Research Fund: 09200966; Li Ka Shing Faculty of Medicine, University of Hong Kong

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 8 MeSH terms, 84 references.

Cite

This paper

Li, X., Zheng, Q., Wong, K. H. K., Wong, K. K. Y., & Lai, C. S. W. (2026). Linking functional and structural dendritic spine remodeling during fear learning and extinction in vivo. Science advances, 12(29), eaec3961. https://doi.org/10.1126/sciadv.aec3961

BibTeX

@article{li2026linking,
author = {Li, Xiaoyang and Zheng, Qiyu and Wong, Kim Hoi Kin and Wong, Kenneth Kin Yip and Lai, Cora Sau Wan},
title = {{Linking functional and structural dendritic spine remodeling during fear learning and extinction in vivo}},
journal = {Science advances},
year = {2026},
month = jul,
volume = {12},
number = {29},
pages = {eaec3961},
publisher = {American Association for the Advancement of Science},
issn = {2375-2548},
doi = {10.1126/sciadv.aec3961},
url = {https://doi.org/10.1126/sciadv.aec3961},
pmid = {42467781},
pmcid = {PMC13378561}
}

RIS

TY - JOUR
AU - Li, Xiaoyang
AU - Zheng, Qiyu
AU - Wong, Kim Hoi Kin
AU - Wong, Kenneth Kin Yip
AU - Lai, Cora Sau Wan
TI - Linking functional and structural dendritic spine remodeling during fear learning and extinction in vivo
T2 - Science advances
J2 - Sci Adv
PY - 2026
DA - 2026/07/17
VL - 12
IS - 29
SP - eaec3961
SN - 2375-2548
PB - American Association for the Advancement of Science
DO - 10.1126/sciadv.aec3961
UR - https://doi.org/10.1126/sciadv.aec3961
LA - en
ER -

CSL-JSON

{
"id": "10.1126/sciadv.aec3961",
"type": "article-journal",
"title": "Linking functional and structural dendritic spine remodeling during fear learning and extinction in vivo",
"container-title": "Science advances",
"author": [
{
"family": "Li",
"given": "Xiaoyang"
},
{
"family": "Zheng",
"given": "Qiyu"
},
{
"family": "Wong",
"given": "Kim Hoi Kin"
},
{
"family": "Wong",
"given": "Kenneth Kin Yip"
},
{
"family": "Lai",
"given": "Cora Sau Wan"
}
],
"container-title-short": "Sci Adv",
"volume": "12",
"issue": "29",
"page": "eaec3961",
"DOI": "10.1126/sciadv.aec3961",
"PMID": "42467781",
"PMCID": "PMC13378561",
"ISSN": "2375-2548",
"publisher": "American Association for the Advancement of Science",
"URL": "https://doi.org/10.1126/sciadv.aec3961",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
17
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1016/j.celrep.2026.117793 [code]
Clustered inputs engage dendritic nonlinearities and calcium signaling to support efficient place-field formation in CA1 pyramidal neurons.
Journal: Cell reports
In common: NEURON, pandas, SciPy, 2 other tools, 14 references
[2] doi:10.1016/j.isci.2026.117010 [code]
Deep learning-assisted mapping of dendritic spines using sequential 2D two-photon calcium imaging.
Journal: iScience
In common: pandas, SciPy, Matplotlib, 1 other tool, histology / microscopy, 9 references
[3] doi:10.1038/s41467-026-77800-w [code]
Learning reorganizes dendritic and stabilizes axon initial segment inhibitory synapses in CA1 pyramidal neurons.
Journal: Nature communications
In common: mouse, 8 references
[4] doi:10.1126/sciadv.adz4123 [code]
Highly attenuated dendritic propagation of isolated synaptic potentials in vivo.
Journal: Science advances
In common: mouse, 8 references
[5] doi:10.7554/elife.108352 [code]
Analysis of dendritic input currents during place field dynamics.
Journal: eLife
In common: NEURON, pandas, Matplotlib, 1 other tool, 5 references
[6] doi:10.7554/elife.89629 [code]
Active dendrites enable robust spiking computations despite timing jitter.
Journal: eLife
In common: NEURON, pandas, Matplotlib, 1 other tool, 5 references
[7] doi:10.1073/pnas.2533168123 [code]
Dendritic morphology and synaptic nonlinearities enhance functional complexity in human cortical neurons.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: NEURON, pandas, SciPy, 2 other tools, 4 references
[8] doi:10.7554/elife.111876 [code]
Distinct sensorimotor encoding in tuft dendrites and somata associated with action, correction, and learning.
Journal: eLife
In common: Pillow, pandas, SciPy, 2 other tools, mouse, 3 references
[9] doi:10.7554/elife.95562 [code]
Spatially targeted inhibitory rhythms differentially affect neuronal integration.
Journal: eLife
In common: pandas, SciPy, Matplotlib, 1 other tool, 4 references
[10] doi: [code]
Going deeper with morphologically detailed neural networks by simulation-based gradient propagation
Journal: Frontiers in computational neuroscience
In common: NEURON, SciPy, Matplotlib, 1 other tool, 3 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.