OSCR

A NEST-based framework unlocks massively parallel simulation of networks of multi-compartment neurons with customizable subcellular dynamics.

Code ↔ Paper

5 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 5 matches
  1. [1] § Methods › Simulation details › Winner-take-all network ↔ prepare_nest_parameters.py, lines 46 to 109 · score 0.79 · Poisson noise, excitatory populations, Poisson generators, inhibitory neurons, stimulated, recurrently · Report a mismatch
  2. [2] § Methods › Simulation details › Benchmarking and scaling experiments ↔ nest_reset_create_connect_simulate.py, lines 187 to 225 · score 0.70 · inh connections, inh exc, inhibitory neurons, excitatory neurons, synapses, weight · Report a mismatch
  3. [3] § Results › Toolchain overview ↔ cm_neuron.py, lines 25 to 68 · score 0.63 · reversal potential, coupling conductance, leak conductance, capacitance · Report a mismatch
  4. [4] § Results › Toolchain overview ↔ cm_neuron_nestml.py, lines 37 to 107 · score 0.63 · reversal potential, coupling conductance, leak conductance, capacitance · Report a mismatch
  5. [5] § Methods › Simulation details › Winner-take-all network ↔ nest_reset_create_connect_simulate.py, lines 12 to 69 · score 0.53 · Ca AdEx, excitatory neurons, plastic, populations, connected, NESTML · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 637 lines · 32 KB · no license · 2 matches

  1. import nest
  2. from cm_neuron import create_cm_neuron
  3. from cm_neuron_nestml import create_nestml_neuron, create_receptor_mapping
  4. from synaptic_io import *
  6. # 2024-1002
  7. # List of receptors used in Ca-AdEx neuron
  8. # It should be moved in a different file (eg. Ca-AdEx_neural_params.yaml)
  9. GABA_soma, AMPA_soma, GABA_dist, AMPA_dist, REFRACT_soma, ADAPT_soma, BETA_dist, NMDA_soma, AMPA_NMDA_soma, ALPHAexc_soma, ALPHAinh_soma, ALPHAexc_dist, ALPHAinh_dist, NMDA_dist, AMPA_NMDA_dist = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
  12. def nest_reset_create_connect_simulate(nest_pms, num_threads, verbose):
  14. sim_completed=False
  15. sim_pms=nest_pms["sim_pms"]
  16. use_nestml=nest_pms["use_nestml"]
  17. nest.ResetKernel()
  18. nest.local_num_threads = 4
  19. if use_nestml:
  20. nest.Install("ca_adex_2expsyn_module")
  22. nest.SetKernelStatus({"resolution": sim_pms["resolution_ms"]})
  23. nest.SetKernelStatus({'local_num_threads':num_threads})
  25. num_exc_neu_per_pop = nest_pms["network"]["num_exc_neu_per_pop"]
  26. num_exc_pop = nest_pms["network"]["num_exc_pop"]
  27. conn_rule = nest_pms["network"]["conn_rule"]
  28. p_conn_exc = nest_pms["network"]["p_conn_exc"]
  29. p_conn_inh = nest_pms["network"]["p_conn_exc"]
  30. default_plasticity = nest_pms["network"]["default_plasticity"]
  32. use_single_compartment_environment = nest_pms["use_single_compartment_environment"]
  34. print("IN nest_reset_create_connect_simulate: use_single_compartment_environment =", use_single_compartment_environment)
  35. print("IN nest_reset_create_connect_simulate: use_nestml =", use_nestml)
  36. exc_neu_params=nest_pms['exc_neu_params']
  37. if not use_nestml:
  38. if use_single_compartment_environment:
  39. # Create excitatory neuron populations
  40. params=exc_neu_params['equation_params']
  41. params["tau_minus"]={}
  42. params["tau_minus"]=20.0
  43. #nest.Create("iaf_psc_alpha", params={"tau_minus": 20.0})
  44. neurons = [
  45. nest.Create(
  46. "aeif_cond_alpha",
  47. num_exc_neu_per_pop,
  48. params=params
  49. )
  50. for _ in range(num_exc_pop)
  51. ]
  52. else:
  53. # Create excitatory Ca-AdEx neuron populations
  54. nest.CopyModel('static_synapse', 'REFRACT_syn')
  55. nest.CopyModel('static_synapse', 'ADAPT_syn')
  56. nest.CopyModel('static_synapse', 'BAP_syn')
  58. neurons = [
  59. create_cm_neuron(num_exc_neu_per_pop, params=exc_neu_params['equation_params']) for _ in range(num_exc_pop)
  60. ]
  61. else:
  62. neurons = [
  63. create_nestml_neuron(
  64. num_exc_neu_per_pop,
  65. params=exc_neu_params['equation_params'],
  66. multi_comp=not(use_single_compartment_environment)
  67. ) for _ in range(num_exc_pop)
  68. ]
  69. ri = create_receptor_mapping(multi_comp=not(use_single_compartment_environment))
  71. # Create inhibitory neurons
  72. inh_neu_params = nest_pms["inh_neu_params"]
  73. num_inh_neu = nest_pms["network"]["num_inh_neu"]
  74. inh_neurons = nest.Create(
  75. "aeif_cond_alpha",
  76. num_inh_neu,
  77. params=inh_neu_params,
  78. )
  80. # Spike recorders for excitatory and inhibitory populations
  81. recording_pms=nest_pms["recording_pms"]
  82. spike_recorders = [nest.Create("spike_recorder",
  83. {"start": recording_pms["start_ms"], "stop": recording_pms["stop_ms"]})
  84. for _ in range(num_exc_pop)]
  85. inh_spike_recorder = nest.Create("spike_recorder",
  86. {"start": recording_pms["start_ms"], "stop": recording_pms["stop_ms"]})
  88. # Connect spike detectors
  89. for i in range(num_exc_pop):
  90. nest.Connect(neurons[i], spike_recorders[i])
  91. nest.Connect(inh_neurons, inh_spike_recorder)
  94. # 2024-1002
  95. # Added multimeter on Ca-AdEx only (temporary solution)
  96. # Target pop and neu and all the parameters to be specified in a yaml
  97. if not use_nestml:
  98. if use_single_compartment_environment:
  99. multimeter = nest.Create('multimeter', 1, {'record_from': ['V_m'], 'interval': .1,
  100. 'start': recording_pms['start_ms'], 'stop': recording_pms['stop_ms']})
  101. pop = 0
  102. neu = 0
  103. # nest.Connect(multimeter, neurons[pop])
  104. nest.Connect(multimeter, neurons[pop][neu])
  105. else:
  106. # create multimeter to record compartment voltages and various state variables
  107. rec_list = ['v_comp0', 'v_comp1', 'w_5','m_Ca_1','h_Ca_1','i_AMPA_9']
  108. pop = 0
  109. neu = 0
  110. multimeter = nest.Create('multimeter', 1, {'record_from': rec_list, 'interval': .1,
  111. 'start': recording_pms['start_ms'], 'stop': recording_pms['stop_ms']})
  112. # nest.Connect(multimeter, neurons[pop])
  113. nest.Connect(multimeter, neurons[pop][neu])
  114. else:
  115. # create multimeter to record compartment voltages and various state variables
  116. rec_list = ['v_comp0', f'syn_2exp{ri.ALPHAexc_soma}']
  117. if not use_single_compartment_environment:
  118. rec_list.append('v_comp1')
  119. pop = 0
  120. neu = 0
  121. multimeter = nest.Create('multimeter', 1, {'record_from': rec_list, 'interval': .1,
  122. 'start': recording_pms['start_ms'], 'stop': recording_pms['stop_ms']})
  123. # nest.Connect(multimeter, neurons[pop])
  124. nest.Connect(multimeter, neurons[pop][neu])
  128. # Connection specifications
  129. exc_t_ref_ms=nest_pms["exc_t_ref_ms"]
  130. min_syn_delay_ms=nest_pms["network"]["min_syn_delay_ms"]
  131. use_recurrency=nest_pms["network"]["use_exc_recurrency"]
  132. recurrent_weight = nest_pms["network"]["weights"]["exc_to_exc"]
  133. inh_to_exc_weight = nest_pms["network"]["weights"]["inh_to_exc_weight"]
  134. exc_to_inh_weight = nest_pms["network"]["weights"]["exc_to_inh_weight"]
  135. inh_to_inh_weight = nest_pms["network"]["weights"]["inh_to_inh_weight"]
  138. exc_to_exc_delay_ms = min_syn_delay_ms + 1.
  139. inh_to_inh_delay_ms = min_syn_delay_ms + exc_t_ref_ms + 1.0
  140. assert(conn_rule == 'pairwise_bernoulli')
  141. conn_spec_dict_exc = {"rule": conn_rule, "p": p_conn_exc}
  142. conn_spec_dict_inh = {"rule": conn_rule, "p": p_conn_inh}
  143. conn_spec_dict_exc = {"rule": 'all_to_all', "allow_autapses":False}
  144. conn_spec_dict_inh = {"rule": 'all_to_all', "allow_autapses":False}
  146. #set to false the book-keeping of intra-pop and inter pop syn types
  147. present_exc_conn={}
  148. for i in range(num_exc_pop):
  149. present_exc_conn[i]={}
  150. for j in range(num_exc_pop):
  151. present_exc_conn[i][j] = {'synapse_model': False}
  153. #set initial intra-pop connections
  154. for i in range(num_exc_pop):
  155. static_synapse_i_i='static_synapse_'+str(i)+'_'+str(i)
  156. nest.CopyModel('static_synapse',static_synapse_i_i)
  157. syn_spec={"synapse_model": static_synapse_i_i, "weight": recurrent_weight, "delay": exc_to_exc_delay_ms}
  158. if not use_nestml:
  159. if(not use_single_compartment_environment):
  160. syn_spec.update({'receptor_type': ALPHAexc_soma})
  161. else:
  162. syn_spec.update({'receptor_type': ri.ALPHAexc_soma})
  164. nest.Connect(neurons[i], neurons[i], conn_spec=conn_spec_dict_exc, syn_spec=syn_spec)
  165. present_exc_conn[i][i] = {'synapse_model': static_synapse_i_i}
  167. #inter assemblies connections: initial set-up
  168. if nest_pms["network"]["inter_pop_conn"] == True:
  170. inter_pop_weight = nest_pms["network"]["weights"]["inter_pop_weight"]
  172. for i in range(num_exc_pop):
  173. for j in range(num_exc_pop):
  174. if i != j:
  175. static_synapse_i_j='static_synapse_'+str(i)+'_'+str(j)
  176. nest.CopyModel('static_synapse',static_synapse_i_j)
  177. syn_spec={"synapse_model":static_synapse_i_j,"weight": inter_pop_weight * cf_mc, "delay": exc_to_exc_delay_ms}
  178. if not use_nestml:
  179. if(not use_single_compartment_environment):
  180. syn_spec.update({'receptor_type': ALPHAexc_soma})
  181. else:
  182. syn_spec_dict.update({'receptor_type': ri.ALPHAexc_soma})
  184. nest.Connect(neurons[i], neurons[j], conn_spec=conn_spec_dict_exc, syn_spec=syn_spec)
  185. present_exc_conn[i][j]['synapse_model'] = static_synapse_i_j
  187. #inh to inh connections: initial setup
  188. nest.CopyModel('static_synapse','static_synapse_inh_inh')
  189. nest.Connect(inh_neurons, inh_neurons, conn_spec=conn_spec_dict_inh,\
  190. syn_spec={"synapse_model": 'static_synapse_inh_inh', "weight": inh_to_inh_weight, "delay": inh_to_inh_delay_ms})
  192. # Connect inhibitory neurons to all excitatory neurons and vice versa
  193. #before 2024-1006 (QUESTA NON ROMPE IL KERNEL)
  194. inh_to_exc_delay_ms = min_syn_delay_ms + exc_t_ref_ms + 0.55
  195. exc_to_inh_delay_ms = min_syn_delay_ms + 0.5
  197. #IN PROVA QUESTA DOPO FUNZIONA ANCORA
  198. #inh_to_exc_delay_ms = min_syn_delay_ms + 0.55
  199. #exc_to_inh_delay_ms = min_syn_delay_ms + 0.5
  201. #IN PROVA
  202. #inh_to_exc_delay_ms = min_syn_delay_ms + 0.1
  203. #exc_to_inh_delay_ms = min_syn_delay_ms + 0.1
  205. #QUESTA CONFIGURAZIONE FA CRASHARE IL KERNEL
  206. #inh_to_exc_delay_ms = min_syn_delay_ms
  207. #exc_to_inh_delay_ms = min_syn_delay_ms
  209. for i in range(num_exc_pop):
  211. # inh to exc(i)
  212. new_syn_model_inh_exc_n = 'static_synapse_inh_exc_'+str(i)
  213. nest.CopyModel('static_synapse', new_syn_model_inh_exc_n)
  214. syn_spec={"synapse_model": new_syn_model_inh_exc_n, "weight": inh_to_exc_weight, "delay": inh_to_exc_delay_ms}
  216. if not use_nestml:
  217. if(not use_single_compartment_environment):
  218. syn_spec.update({"weight": -inh_to_exc_weight, 'receptor_type': ALPHAinh_soma})
  219. else:
  220. syn_spec.update({
  221. "weight": -inh_to_exc_weight,
  222. "receptor_type": ri.ALPHAinh_soma,
  223. })
  225. nest.Connect(inh_neurons, neurons[i], conn_spec=conn_spec_dict_inh, syn_spec=syn_spec)
  227. # exc(i) to inh
  228. new_syn_model_exc_n_inh = 'static_synapse_exc_' + str(i) + '_inh'
  229. nest.CopyModel('static_synapse', new_syn_model_exc_n_inh)
  230. syn_spec={"synapse_model": new_syn_model_exc_n_inh, "weight": exc_to_inh_weight, "delay": exc_to_inh_delay_ms}
  231. nest.Connect(neurons[i], inh_neurons, conn_spec=conn_spec_dict_exc, syn_spec=syn_spec)
  233. # Create and connect Poisson generators if enabled
  234. use_poisson_generators=nest_pms["network"]["use_poisson_generators"]
  235. if use_poisson_generators:
  236. num_poisson_generators=nest_pms["network"]["num_poisson_generators"]
  237. poisson_rate=nest_pms["poisson"]["poisson_rate"]
  238. pgs = nest.Create("poisson_generator", num_poisson_generators, params={"rate": poisson_rate, 'start': 200.})
  239. poisson_weight=nest_pms["poisson"]["poisson_weight"]
  241. syn_spec={"weight": poisson_weight, "delay": 1.0}
  242. for i in range(num_exc_pop):
  243. if not use_nestml:
  244. if not use_single_compartment_environment:
  245. syn_spec.update({'receptor_type': ALPHAexc_soma})
  246. else:
  247. syn_spec.update({'receptor_type': ri.ALPHAexc_soma})
  248. nest.Connect(pgs, neurons[i], syn_spec=syn_spec)
  250. # Add contextual poisson signal if configured
  251. if 'contextual_poisson' in nest_pms and \
  252. nest_pms['brain_state'] in nest_pms['contextual_poisson']:
  253. # Extract the upper-level configuration parameters
  254. contextual_poisson_config = nest_pms['contextual_poisson'][nest_pms['brain_state']]
  256. # Ensure all required keys are present in the configuration
  257. if all(key in contextual_poisson_config for key in ['events', 'spreading_factor', 'basic_rate', 'poisson_weight']):
  258. events = contextual_poisson_config['events']
  259. spreading_factor = contextual_poisson_config['spreading_factor']
  260. basic_rate = contextual_poisson_config['basic_rate']
  261. poisson_weight = contextual_poisson_config['poisson_weight']
  263. # Iterate through each event in the events list
  264. for event in events:
  265. target_pop = event['target_population']
  266. start_time = event['start_time_ms']
  267. stop_time = event['stop_time_ms']
  269. # Create a Poisson generator for the event
  270. contextual_poisson_gen = nest.Create('poisson_generator', 1, {'rate': basic_rate})
  272. # Set the start and stop times for the generator
  273. nest.SetStatus(contextual_poisson_gen, {'start': start_time, 'stop': stop_time})
  275. # Define the synapse specifications
  276. syn_spec = {'weight': poisson_weight * spreading_factor, "delay": 1.0}
  278. # Connect the generator to the target population
  279. if not use_nestml:
  280. if not use_single_compartment_environment:
  281. syn_spec.update({'receptor_type': AMPA_NMDA_dist})
  282. else:
  283. # if use_single_compartment_environment:
  284. # syn_spec.update({'receptor_type': ri.AMPA_NMDA_soma})
  285. # else:
  286. # syn_spec.update({'receptor_type': ri.AMPA_NMDA_dist})
  287. syn_spec.update({'receptor_type': ri.PSC_context})
  289. nest.Connect(contextual_poisson_gen, neurons[target_pop], syn_spec=syn_spec)
  291. # Add contextual inhibiton signal if configured
  292. if 'contextual_inhibition' in nest_pms and \
  293. nest_pms['brain_state'] in nest_pms['contextual_inhibition']:
  294. # Extract the upper-level configuration parameters
  295. contextual_poisson_config = nest_pms['contextual_inhibition'][nest_pms['brain_state']]
  297. # Ensure all required keys are present in the configuration
  298. if all(key in contextual_poisson_config for key in ['events', 'spreading_factor', 'basic_rate', 'poisson_weight']):
  299. events = contextual_poisson_config['events']
  300. spreading_factor = contextual_poisson_config['spreading_factor']
  301. basic_rate = contextual_poisson_config['basic_rate']
  302. poisson_weight = contextual_poisson_config['poisson_weight']
  304. # Iterate through each event in the events list
  305. for event in events:
  306. target_pop = event['target_population']
  307. start_time = event['start_time_ms']
  308. stop_time = event['stop_time_ms']
  310. # Create a Poisson generator for the event
  311. contextual_poisson_gen = nest.Create('poisson_generator', 1, {'rate': basic_rate})
  313. # Set the start and stop times for the generator
  314. nest.SetStatus(contextual_poisson_gen, {'start': start_time, 'stop': stop_time})
  316. # Define the synapse specifications
  317. syn_spec = {'weight': poisson_weight * spreading_factor, "delay": 1.0}
  319. # Connect the generator to the target population
  320. if not use_nestml:
  321. if not use_single_compartment_environment:
  322. syn_spec.update({'receptor_type': AMPA_NMDA_dist})
  323. else:
  324. # @Willem, please modify the code in the comment towards your nestml specifics
  325. # assert False, "use_nestml option not yet supported: under construction"
  326. if use_single_compartment_environment:
  327. syn_spec.update({'receptor_type': ri.ALPHAinh_soma})
  328. else:
  329. syn_spec.update({'receptor_type': ri.ALPHAinh_dist})
  331. nest.Connect(contextual_poisson_gen, neurons[target_pop], syn_spec=syn_spec)
  333. # DC current injection for all neurons if enabled
  334. use_dc_exc_injectors=nest_pms["use_dc_exc_injectors"]
  335. if use_dc_exc_injectors:
  336. dc_exc_start_ms=nest_pms["dc_exc"]["start_ms"]
  337. dc_exc_stop_ms=nest_pms["dc_exc"]["stop_ms"]
  338. dc_exc_amplitudes=nest_pms["dc_exc"]["dc_exc_amplitudes"]
  339. dc_exc_weight=nest_pms["dc_exc"]["dc_exc_weight"]
  340. dc_exc_delay_ms=nest_pms["dc_exc"]["dc_exc_delay_ms"]
  341. dcgs = [nest.Create("dc_generator", 1,\
  342. {"start": dc_exc_start_ms, "stop": dc_exc_stop_ms, "amplitude": amp})\
  343. for amp in dc_exc_amplitudes]
  344. for i in range(num_exc_pop):
  345. if use_single_compartment_environment:
  346. nest.Connect(dcgs[i], neurons[i],\
  347. syn_spec={'weight': dc_exc_weight, 'delay': dc_exc_delay_ms})
  348. else:
  349. #assert("MC neuron not yet implemented")
  350. nest.Connect(dcgs[i], neurons[i], syn_spec={'weight': dc_exc_weight, 'delay': dc_exc_delay, 'receptor_type': 0})
  352. # Specific DC current injection for inhibitory neurons
  353. use_dc_inh_injector=nest_pms["use_dc_inh_injector"]
  354. if use_dc_inh_injector:
  355. dc_inh_start_ms = nest_pms["dc_inh"]["start_ms"]
  356. dc_inh_stop_ms = nest_pms["dc_inh"]["stop_ms"]
  357. dc_inh_amplitude = nest_pms["dc_inh"]["dc_inh_amplitude"]
  358. dc_inh_weight = nest_pms["dc_inh"]["weight"]
  359. dc_inh_delay_ms = nest_pms["dc_inh"]["delay_ms"]
  361. dc_inh_generator = nest.Create("dc_generator", 1,\
  362. {"start": dc_inh_start_ms, "stop": dc_inh_stop_ms,
  363. "amplitude": dc_inh_amplitude})
  364. nest.Connect(dc_inh_generator, inh_neurons,\
  365. syn_spec={'weight': dc_inh_weight, 'delay': dc_inh_delay_ms})
  367. def make_plastic_conn(source_exc_pop, target_exc_pop, Wmax, verbose):
  368. if verbose:
  369. print("in make_plastic_conn: source and target pops", source_exc_pop, target_exc_pop)
  370. assert(source_exc_pop >= 0 and source_exc_pop < num_exc_pop)
  371. assert(target_exc_pop >= 0 and target_exc_pop < num_exc_pop)
  372. new_syn_model = default_plasticity['synapse_model']+'_'+str(source_exc_pop)+'_'+str(target_exc_pop)
  373. if verbose:
  374. print("in make_plastic_conn: new_syn_model = ", new_syn_model)
  376. if new_syn_model not in nest.Models(mtype='synapses'):
  377. if verbose:
  378. print("in make_plastic_conn: new_syn_model not already among Models")
  379. if present_exc_conn[source_exc_pop][target_exc_pop]['synapse_model'] != False:
  380. if verbose:
  381. print("in make_plastic_conn: present_exc_conn =",present_exc_conn[source_exc_pop][target_exc_pop]['synapse_model'])
  382. print("in make_plastic_conn: before GetConnections (old set)")
  383. existing_conns = nest.GetConnections(neurons[source_exc_pop],
  384. neurons[target_exc_pop],
  385. synapse_model=present_exc_conn[source_exc_pop][target_exc_pop]['synapse_model'])
  386. if verbose:
  387. print("in make_plastic_conn: before Disconnect (old set)")
  388. nest.Disconnect(existing_conns)
  389. if verbose:
  390. print("in make_plastic_conn: after Disconnect (old set)")
  391. present_exc_conn[source_exc_pop][target_exc_pop] = {'synapse_model': False}
  393. conn_spec_dict = conn_spec_dict_exc
  394. nest.CopyModel(default_plasticity['synapse_model'],new_syn_model)
  395. syn_spec_dict = {"synapse_model": new_syn_model,
  396. "Wmax": Wmax,
  397. "tau_plus": default_plasticity['tau_plus'],
  398. "lambda": default_plasticity['lambda'],
  399. "alpha": default_plasticity['alpha'],
  400. "mu_plus": default_plasticity['mu_plus'],
  401. "mu_minus": default_plasticity['mu_minus'],
  402. "weight": default_plasticity['weight'],
  403. "delay": exc_to_exc_delay_ms}
  404. if not use_nestml:
  405. if not use_single_compartment_environment:
  406. syn_spec_dict.update({'receptor_type': ALPHAexc_soma})
  407. else:
  408. syn_spec_dict.update({'receptor_type': ri.ALPHAexc_soma})
  410. if verbose:
  411. print("in make_plastic_conn: before connecting ",new_syn_model)
  412. nest.Connect(neurons[source_exc_pop], neurons[target_exc_pop],
  413. conn_spec=conn_spec_dict, syn_spec=syn_spec_dict)
  414. if verbose:
  415. print("in make_plastic_conn: after connecting ",new_syn_model)
  416. present_exc_conn[source_exc_pop][target_exc_pop] = {'synapse_model': new_syn_model}
  417. if verbose:
  418. print("Wmax =", Wmax, "initial_weight", default_plasticity['weight'])
  419. return
  421. def disconnect_conn(source_exc_pop, target_exc_pop, verbose):
  422. if verbose:
  423. print("in disconnect_conn: source_exc_pop -> target_exc_pop",source_exc_pop, target_exc_pop)
  424. assert(source_exc_pop >= 0 and source_exc_pop < num_exc_pop)
  425. assert(target_exc_pop >= 0 and target_exc_pop < num_exc_pop)
  426. if present_exc_conn[source_exc_pop][target_exc_pop]['synapse_model'] != False:
  427. synapse_model = present_exc_conn[source_exc_pop][target_exc_pop]['synapse_model']
  428. existing_conns = nest.GetConnections(neurons[source_exc_pop],
  429. neurons[target_exc_pop], synapse_model=synapse_model)
  430. nest.Disconnect(existing_conns)
  431. present_exc_conn[source_exc_pop][target_exc_pop] = {'synapse_model': False}
  432. # Next lines reconnect with zero values
  433. conn_spec_dict = conn_spec_dict_exc
  434. new_disconnected_static_syn_model = \
  435. 'static_synapse_weight_zero_'+str(source_exc_pop)+'_'+str(target_exc_pop)
  436. nest.CopyModel('static_synapse',new_disconnected_static_syn_model)
  437. syn_spec_dict = {"synapse_model":new_disconnected_static_syn_model,"weight": 0.0, "delay": exc_to_exc_delay_ms}
  438. if not use_nestml:
  439. if not use_single_compartment_environment:
  440. syn_spec_dict.update({'receptor_type': ALPHAexc_soma})
  441. else:
  442. syn_spec_dict.update({'receptor_type': ri.ALPHAexc_soma})
  444. nest.Connect(neurons[source_exc_pop], neurons[target_exc_pop],
  445. conn_spec=conn_spec_dict, syn_spec=syn_spec_dict)
  446. present_exc_conn[source_exc_pop][target_exc_pop] = {'synapse_model': new_disconnected_static_syn_model, 'weight': 0.0}
  447. return
  449. def perform_event_action(requested_action, tot_simulated_time_ms, verbose):
  450. if verbose:
  451. print("in perform_event_action: requested action:", requested_action, "at time (ms)", tot_simulated_time_ms)
  452. if requested_action['kind']=='store_syn':
  453. #STORE SYN MATRIX
  454. store_syn(requested_action['syn_file_name'], tot_simulated_time_ms, verbose)
  455. elif requested_action['kind']=='disconnect_exc_pop_syn':
  456. #DISCONNECT (several options to select target intra and inter pops)
  458. #can be an integer, a list of integers, or a string
  459. target_exc_pop = requested_action['target_exc_pop']
  460. if isinstance(target_exc_pop, int):
  461. # Perform actions for integer value
  462. disconnect_conn(target_exc_pop, target_exc_pop, verbose)
  463. elif isinstance(target_exc_pop, list):
  464. # The value is a list
  465. # Check that all elements in the list are integers
  466. if all(isinstance(item, int) for item in target_exc_pop):
  467. # Perform actions for list of integers
  468. for item in target_exc_pop:
  469. disconnect_conn(item, item, verbose)
  470. else:
  471. raise TypeError("All items in 'target_exc_pop' list must be integers.")
  472. elif isinstance(target_exc_pop, str):
  473. # The value is a string
  474. # Perform actions for string value
  475. if target_exc_pop == 'all_intra_exc':
  476. for index_target_pop in range(0,num_exc_pop):
  477. disconnect_conn(index_target_pop, index_target_pop, verbose)
  478. elif target_exc_pop == 'all_inter_exc':
  479. for index_source_pop in range(0,num_exc_pop):
  480. for index_target_pop in range(0,num_exc_pop):
  481. if index_source_pop!=index_target_pop:
  482. disconnect_conn(index_source_pop, index_target_pop, verbose)
  483. elif target_exc_pop == 'all_intra_inter_exc':
  484. for index_source_pop in range(0,num_exc_pop):
  485. for index_target_pop in range(0,num_exc_pop):
  486. disconnect_conn(index_source_pop, index_target_pop, verbose)
  487. else:
  488. print("unrecognized command in set plastic synapses")
  489. assert(False)
  490. else:
  491. # Handle unexpected types
  492. raise TypeError(f"Invalid type for 'target_exc_pop': {type(target_exc_pop)}")
  494. elif requested_action['kind']=='exc_plasticity_ON':
  495. #make PLASTIC exc synapses (several options to select target intra and inter pops)
  497. Wmax = recurrent_weight * requested_action['W_max_factor']
  499. #can be an integer, a list of integers, or a string
  500. target_exc_pop = requested_action['target_exc_pop']
  502. if isinstance(target_exc_pop, int):
  503. # Perform actions for integer value
  504. make_plastic_conn(target_exc_pop, target_exc_pop, Wmax, verbose)
  505. elif isinstance(target_exc_pop, list):
  506. # The value is a list
  507. # Check that all elements in the list are integers
  508. if all(isinstance(item, int) for item in target_exc_pop):
  509. # Perform actions for list of integers
  510. for item in target_exc_pop:
  511. make_plastic_conn(item, item, Wmax, verbose)
  512. else:
  513. raise TypeError("All items in 'target_exc_pop' list must be integers.")
  514. elif isinstance(target_exc_pop, str):
  515. # The value is a string
  516. # Perform actions for string value
  517. if target_exc_pop == 'all_intra_exc':
  518. for index_target_pop in range(0,num_exc_pop):
  519. make_plastic_conn(index_target_pop, index_target_pop, Wmax, verbose)
  520. elif target_exc_pop == 'all_inter_exc':
  521. for index_source_pop in range(0,num_exc_pop):
  522. for index_target_pop in range(0,num_exc_pop):
  523. if index_source_pop!=index_target_pop:
  524. make_plastic_conn(index_source_pop, index_target_pop, Wmax, verbose)
  525. elif target_exc_pop == 'all_intra_inter_exc':
  526. for index_source_pop in range(0,num_exc_pop):
  527. for index_target_pop in range(0,num_exc_pop):
  528. make_plastic_conn(index_source_pop, index_target_pop, Wmax, verbose)
  529. else:
  530. print("unrecognized command in set plastic synapses")
  531. assert(False)
  532. else:
  533. # Handle unexpected types
  534. raise TypeError(f"Invalid type for 'target_exc_pop': {type(target_exc_pop)}")
  535. elif requested_action['kind']=='set_learning':
  536. # Set learning rate
  537. learning_rate = default_plasticity['lambda']
  538. alpha = default_plasticity['alpha']
  539. if 'lambda' in requested_action:
  540. learning_rate = requested_action['lambda']
  541. if 'alpha' in requested_action:
  542. alpha = requested_action['alpha']
  543. target_exc_pop = requested_action['target_exc_pop']
  544. assert(target_exc_pop >= 0 and target_exc_pop < num_exc_pop)
  545. # add check if target_exc_pop is in the list of plastic populations (issue #34)
  546. existing_conns_plastic = nest.GetConnections(neurons[target_exc_pop],
  547. neurons[target_exc_pop], synapse_model='stdp_synapse')
  548. nest.SetStatus(existing_conns_plastic, {'lambda': learning_rate, 'alpha': alpha})
  549. print('Set lambda =', learning_rate, 'alpha =', alpha, 'in population', target_exc_pop)
  550. else:
  551. #UNRECOGNIZED
  552. print("in perform_event_action: requested action:",requested_action['kind'],"NOT SUPPORTED")
  553. assert False
  554. return
  556. list_of_syn_matrix_file_names=[]
  558. def store_syn(file_name, tot_simulated_time_ms, verbose):
  559. if(verbose):
  560. print("in store_syn:")
  561. print("will save to file:", file_name)
  562. print("at time (ms):", tot_simulated_time_ms)
  563. array_of_dicts = []
  564. for i in range(num_exc_pop):
  566. synapse_model = present_exc_conn[i][i]['synapse_model']
  567. array_of_dicts.append(\
  568. {"time (ms)": tot_simulated_time_ms,\
  569. "conn_index": i,\
  570. "synapse_model":present_exc_conn[i][i]['synapse_model'],\
  571. "connections": nest.GetConnections(source=neurons[i],target=neurons[i],
  572. synapse_model=synapse_model).get(("source", "target", "weight"), output="pandas")})
  573. with open(file_name, "wb") as f:
  574. pickle.dump(array_of_dicts, f, pickle.HIGHEST_PROTOCOL)
  575. list_of_syn_matrix_file_names.append(file_name)
  576. return
  578. def simulate(verbose):
  579. # Run the simulation
  580. if verbose:
  581. print("in nest_..._simulate: LIST OF PLANNED ACTIONS")
  582. for item in nest_pms['events_pms']:
  583. if 'action' in item:
  584. print("ACTION",item['action'])
  585. if 'sim_period_ms' in item:
  586. if verbose:
  587. print("expected NEXT SIM PERIOD ms",item['sim_period_ms'])
  588. print("in nest_..._simulate: JUST BEFORE ACTUAL EXECUTION")
  590. tot_simulated_time_ms=0.0
  591. if 'events_pms' in nest_pms:
  592. for item in nest_pms['events_pms']:
  593. if 'action' in item:
  594. if verbose:
  595. print("ACTION",item['action'])
  596. #performing the action
  597. perform_event_action(item['action'], tot_simulated_time_ms, verbose)
  598. if 'sim_period_ms' in item:
  599. if verbose:
  600. print("expected NEXT SIM PERIOD ms",item['sim_period_ms'])
  601. next_sim_period_ms = item['sim_period_ms']
  602. else:
  603. next_sim_period_ms = 0.0
  604. if next_sim_period_ms + tot_simulated_time_ms > sim_pms["stop_ms"]:
  605. next_sim_period_ms = sim_pms["stop_ms"] - tot_simulated_time_ms
  606. store_syn('syn_matrix-end_of_sim',sim_pms["stop_ms"],verbose)
  607. if verbose:
  608. print("reduced last sim time ms to", next_sim_period_ms)
  609. print("launching next period of ", next_sim_period_ms, "ms of simulation")
  610. #launching simulation period
  611. if next_sim_period_ms > 0:
  612. nest.Simulate(next_sim_period_ms)
  613. tot_simulated_time_ms += next_sim_period_ms
  614. if verbose:
  615. print("performed until now:",tot_simulated_time_ms, "TOTAL ms of simulation")
  617. if tot_simulated_time_ms < sim_pms["stop_ms"]:
  618. next_sim_period_ms = sim_pms["stop_ms"] - tot_simulated_time_ms
  619. if verbose:
  620. print("ADDING ", next_sim_period_ms, "ms sim to complete expected" ,sim_pms["stop_ms"], "TOTAL ms of simulation")
  621. #possible last simulation period
  622. assert(next_sim_period_ms>0)
  623. nest.Simulate(next_sim_period_ms)
  624. tot_simulated_time_ms += next_sim_period_ms
  625. store_syn('syn_matrix-end_of_sim', tot_simulated_time_ms, verbose)
  626. if verbose:
  627. print("performed until now:",tot_simulated_time_ms, "TOTAL ms of simulation")
  628. assert(tot_simulated_time_ms==sim_pms["stop_ms"])
  630. return
  632. #HERE IS THE SIMULATION
  633. verbose=True
  634. simulate(verbose)
  635. sim_completed=True
  637. return sim_completed, spike_recorders, inh_spike_recorder, multimeter, list_of_syn_matrix_file_names

nest_reset_create_connect_simulate.py at commit 3331128, no license · at the source

Overview

Authors: Willem A M Wybo1, Leander Ewert2, Charl Linssen2,3,4, Pooja Babu3,4, Elena Pastorelli5, Pier Stanislao Paolucci5, Abigail Morrison2,4
ORCID iDs: Willem A M Wybo, Pooja Babu, Elena Pastorelli, Pier Stanislao Paolucci
  1. Peter Grünberg Institute 15 – Neuromorphic Software Ecosystems (PGI-15), Forschungszentrum Jülich, Aachen, Germany
  2. Institute for Advanced Simulation (IAS-6), Computational and Systems Neuroscience, Forschungszentrum Jülich, Jülich, Germany
  3. Simulation and Data Lab Neuroscience, Jülich Supercomputer Centre, Institute for Advanced Simulation, Jülich-Aachen Research Alliance, Forschungszentrum Jülich, Jülich, Germany
  4. Software Engineering, Faculty of Computer Science, RWTH Aachen University, Aachen, Germany
  5. Istituto Nazionale di Fisica Nucleare, Sezione di Roma, Rome, Italy
Institutions: Forschungszentrum Jülich (Germany); Jülich Aachen Research Alliance (Germany); Jülich Supercomputing Centre (Germany); RWTH Aachen University (Germany); Istituto Nazionale di Fisica Nucleare (Italy); Istituto Nazionale di Fisica Nucleare, Sezione di Roma I (Italy)
Journal: Communications biology, volume 9, issue 1, article 1411
Dates: received 11 September 2025; accepted 30 September 2026; published online 27 October 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s42003-026-11157-0 · PMID 42946780 · PMCID PMC13714284 · OpenAlex W7223976105
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: computational modeling (no new data) (modality), human (organism), computational (subfield)
Methods: Graphs, Single-unit activity, calcium imaging
Keywords: Biophysical models, Network models
MeSH: Computer Simulation*, Models, Neurological*, Nerve Net*, Neurons*, Software*, Animals, Dendrites, Humans (* major topic)
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Ministero dell'Istruzione, dell'Università e della Ricerca (Ministry of Education, University and Research) (CUP B51E22000150006, CUP I53C22001400006)
Citations: not cited yet (Europe PMC); 106 references in the paper

Abstract

While subcellular mechanisms in the dendrites of neurons govern the implementation of learning and memory in the brain, large-scale network simulations featuring such processes remain challenging to achieve. This can be attributed to a lack of appropriate software tools, as neuroscientific simulators focus on the one hand on highly detailed models, and on the other hand on massive networks featuring point neurons. Here, we fill this gap by implementing a framework for the massively parallel simulation of simplified dendrite models with customizable subcellular dynamics. We leverage the NEural Simulation Tool (NEST), the neuroscientific reference with respect to efficient massively parallel simulations of point-neuron networks. By co-opting the model description language NESTML, we generate C++ code implementing user-configurable subcellular dynamics. We show that the generated models run efficiently, leading to scalable NEST network simulations. To showcase relevant functionalities, we provide a proof-of-concept demonstration that a key sensory computation – the association of top-down context arriving at distal dendrites in layer 1 and feedforward sensory input arriving perisomatically – can be achieved in a single-shot fashion through apical calcium dynamics. Our work thus unlocks the study of how dendritic processes shape network function and learning at scale.

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 5 matches between paragraphs and lines of code.

Zenodo 22878144

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

willemwybo/wta-states

License: none: the authors keep all their rights
State: the link answers, verified on 30 October 2026
Evidence: files inventoried
Commit: 33311287c43fb73cddacb163c4b66064c961787e, 30 June 2025
Languages: Python (14), Jupyter (1)
Size: 136 files, 15 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, 1 notebook
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (10 files), Matplotlib (8 files), NEST Simulator (6 files), SciPy (3 files)
Availability: 1 check, the latest on 30 October 2026: the link answers
  • 30 October 2026: the link answers
16 files
At the source: github.com/WillemWybo/WTA-states/releases/tag/v1.0

jugit.fz-juelich.de/w.wybo/ca-adex

License: none: the authors keep all their rights
State: the link answers, verified on 30 October 2026
Evidence: the link answers
Software Heritage: not checked
Found in: “Code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 30 October 2026: the link answers (HTTP 200)
  • 30 October 2026: the link answers (HTTP 200)
At the source: jugit.fz-juelich.de/w.wybo/ca-adex/-/tree/paper-revision

Zenodo 10125416

License: GPL-2.0
State: the link answers, verified on 1 October 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 1 October 2026: the link answers (HTTP 200)
  • 1 October 2026: the link answers (HTTP 200)
At the source:

Zenodo 20757797

License: GPL-2.0
State: the link answers, verified on 30 October 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 30 October 2026: the link answers (HTTP 200)
  • 30 October 2026: the link answers (HTTP 200)
At the source:

Code availability

Code to reproduce the simulations in this paper is available at https://github.com/WillemWybo/WTA-states/releases/tag/v1.0 for the winner-take-all network and at https://jugit.fz-juelich.de/w.wybo/ca-adex/-/tree/paper-revision for all other simulations. A Zenodo archive is available at https://doi.org/10.5281/zenodo.22878144.

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

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:

  • 5 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 15 scripts, each with its path and the digest of its content;
  • 5 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 availability

Benchmarking results are available at https://jugit.fz-juelich.de/w.wybo/ca-adex/-/tree/paper-revision/data or in the Zenodo archive https://doi.org/10.5281/zenodo.22878144.

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 1, 30 October 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 2 keywords, 8 MeSH terms, 1 funder, 78 references.

Cite

This paper

Wybo, W. A. M., Ewert, L., Linssen, C., Babu, P., Pastorelli, E., Paolucci, P. S., & Morrison, A. (2026). A NEST-based framework unlocks massively parallel simulation of networks of multi-compartment neurons with customizable subcellular dynamics. Communications biology, 9(1), 1411. https://doi.org/10.1038/s42003-026-11157-0

BibTeX

@article{wybo2026nest,
author = {Wybo, Willem A M and Ewert, Leander and Linssen, Charl and Babu, Pooja and Pastorelli, Elena and Paolucci, Pier Stanislao and Morrison, Abigail},
title = {{A NEST-based framework unlocks massively parallel simulation of networks of multi-compartment neurons with customizable subcellular dynamics}},
journal = {Communications biology},
year = {2026},
month = oct,
volume = {9},
number = {1},
pages = {1411},
publisher = {Nature Publishing Group},
issn = {2399-3642},
doi = {10.1038/s42003-026-11157-0},
url = {https://doi.org/10.1038/s42003-026-11157-0},
pmid = {42946780},
pmcid = {PMC13714284}
}

RIS

TY - JOUR
AU - Wybo, Willem A M
AU - Ewert, Leander
AU - Linssen, Charl
AU - Babu, Pooja
AU - Pastorelli, Elena
AU - Paolucci, Pier Stanislao
AU - Morrison, Abigail
TI - A NEST-based framework unlocks massively parallel simulation of networks of multi-compartment neurons with customizable subcellular dynamics
T2 - Communications biology
J2 - Commun Biol
PY - 2026
DA - 2026/10/27
VL - 9
IS - 1
SP - 1411
SN - 2399-3642
PB - Nature Publishing Group
DO - 10.1038/s42003-026-11157-0
UR - https://doi.org/10.1038/s42003-026-11157-0
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s42003-026-11157-0",
"type": "article-journal",
"title": "A NEST-based framework unlocks massively parallel simulation of networks of multi-compartment neurons with customizable subcellular dynamics",
"container-title": "Communications biology",
"author": [
{
"family": "Wybo",
"given": "Willem A M"
},
{
"family": "Ewert",
"given": "Leander"
},
{
"family": "Linssen",
"given": "Charl"
},
{
"family": "Babu",
"given": "Pooja"
},
{
"family": "Pastorelli",
"given": "Elena"
},
{
"family": "Paolucci",
"given": "Pier Stanislao"
},
{
"family": "Morrison",
"given": "Abigail"
}
],
"container-title-short": "Commun Biol",
"volume": "9",
"issue": "1",
"page": "1411",
"DOI": "10.1038/s42003-026-11157-0",
"PMID": "42946780",
"PMCID": "PMC13714284",
"ISSN": "2399-3642",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s42003-026-11157-0",
"language": "en",
"issued": {
"date-parts": [
[
2026,
10,
27
]
]
}
}

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.3389/fncom.2025.1566196 [code]
Simplified two-compartment neuron with calcium dynamics capturing brain-state specific apical-amplification, -isolation and -drive.
Journal: Frontiers in computational neuroscience
In common: computational, 20 references, author Pier Stanislao Paolucci
[2] doi:10.3389/fninf.2022.883333 [code]
Fast Simulation of a Multi-Area Spiking Network Model of Macaque Cortex on an MPI-GPU Cluster.
Journal: Frontiers in neuroinformatics
In common: NEST Simulator, SciPy, Matplotlib, 1 other tool, computational, computational modeling (no new data), 10 references, author Pier Stanislao Paolucci
[3] doi:10.1007/s12021-025-09766-x [code]
The Neural Analysis Toolkit Unifies Semi-Analytical Techniques to Simplify, Understand, and Simulate Dendrites.
Journal: Neuroinformatics
In common: computational modeling (no new data), 14 references
[4] doi:10.3389/fninf.2023.941696 [code]
Efficient parameter calibration and real-time simulation of large-scale spiking neural networks with GeNN and NEST.
Journal: Frontiers in neuroinformatics
In common: NEST Simulator, SciPy, Matplotlib, 1 other tool, computational, computational modeling (no new data), 9 references
[5] doi:10.1038/s41467-023-41553-7 [code]
A GPU-based computational framework that bridges neuron simulation and artificial intelligence.
Journal: Nature communications
In common: SciPy, Matplotlib, NumPy, computational modeling (no new data), 12 references
[6] doi:10.7554/elife.79535 [code]
Ultrafast simulation of large-scale neocortical microcircuitry with biophysically realistic neurons.
Journal: eLife
In common: SciPy, Matplotlib, NumPy, computational, computational modeling (no new data), 11 references
[7] doi:10.1371/journal.pcbi.1013926 [code]
Plastic Arbor: A modern simulation framework for synaptic plasticity-From single synapses to networks of morphological neurons.
Journal: PLoS computational biology
In common: NEST Simulator, SciPy, Matplotlib, 1 other tool, computational modeling (no new data), 9 references
[8] doi:10.7554/elife.103324 [code]
DendroTweaks, an interactive approach for unraveling dendritic dynamics.
Journal: eLife
In common: SciPy, Matplotlib, NumPy, computational modeling (no new data), 11 references
[9] doi:10.1038/s41467-025-56297-9 [code]
Dendrites endow artificial neural networks with accurate, robust and parameter-efficient learning.
Journal: Nature communications
In common: SciPy, Matplotlib, NumPy, computational modeling (no new data), 10 references
[10] doi:10.1371/journal.pcbi.1010353 [code]
Brain signal predictions from multi-scale networks using a linearized framework.
Journal: PLoS computational biology
In common: NEST Simulator, SciPy, Matplotlib, 1 other tool, computational, computational modeling (no new data), 4 references, author Pooja Babu

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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1038/s42003-026-11157-0.svg)](https://openscicode.org/badge/doi/10.1038/s42003-026-11157-0)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1038/s42003-026-11157-0.svg
   :target: https://openscicode.org/badge/doi/10.1038/s42003-026-11157-0
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1038/s42003-026-11157-0"><img src="https://openscicode.org/badge/doi/10.1038/s42003-026-11157-0.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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