diff --git a/doc/tutorials/gl_model/gl_model_tutorial.ipynb b/doc/tutorials/gl_model/gl_model_tutorial.ipynb new file mode 100644 index 000000000..b0eb7ec61 --- /dev/null +++ b/doc/tutorials/gl_model/gl_model_tutorial.ipynb @@ -0,0 +1,1818 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Galves-Löcherbach Model in NESTML\n", + "\n", + "_In vivo_, neurons display variability in their spiking behavior: continuous fluctuations of the membrane potential can be observed, and they exhibit spontaneous firing and different responses to the same repeated input stimulus.\n", + "\n", + "To capture these phenomena, the Galves-Löcherbach (GL) model assumes that the firing of the neuron is a random event, whose probability of occurrence in any time step is a firing function $Φ(V_\\text{m})$ of membrane potential $V_\\text{m}$. By subsuming all sources of randomness into a single function, the GL neuron model simplifies the analysis and simulation of noisy spiking neural networks [1].\n", + "\n", + "By combining the GL neuron model with a synapse model featuring short term synaptic facilitation, we reproduce the results on short-term memory dynamics in state space from [2]. The synapse model is formally equivalent to the Tsodyks-Markram model [3] when set to no depression, only facilitation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Preliminaries\n", + "-------------" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.8.0-post0.dev0\n", + " Built: Sep 26 2024 22:44:51\n", + "\n", + " This program is provided AS IS and comes with\n", + " NO WARRANTY. See the file LICENSE for details.\n", + "\n", + " Problems or suggestions?\n", + " Visit https://www.nest-simulator.org\n", + "\n", + " Type 'nest.help()' to find out more about NEST.\n", + "\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "from typing import Dict, Optional\n", + "\n", + "import matplotlib as mpl\n", + "\n", + "mpl.rcParams['axes.grid'] = True\n", + "mpl.rcParams['grid.color'] = 'k'\n", + "mpl.rcParams['grid.linestyle'] = ':'\n", + "mpl.rcParams['grid.linewidth'] = 0.5\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import nest\n", + "import numpy as np\n", + "import os\n", + "import random\n", + "\n", + "from pynestml.codegeneration.nest_code_generator_utils import NESTCodeGeneratorUtils\n", + "\n", + "import logging\n", + "logging.getLogger('matplotlib.font_manager').disabled = True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "GL model with biophysical units\n", + "-------------------------------\n", + "\n", + "We formulate the GL model as a linear integrate-and-fire model with membrane time constant $\\tau_\\text{m}$, resting potential $V_\\text{r}$ and an instantaneous jump in the postsynaptic membrane potential upon receiving a spike (Dirac delta function postsynaptic kernel)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Neuron parameters\n", + "params = {\n", + " 'tau_m' : 10.0,\n", + " 't_ref' : 2.0,\n", + " 'C_m' : 250.0,\n", + " 'V_r' : -65.0,\n", + " 'V_reset' : -65.0,\n", + " 'a' : 1.2,\n", + " 'b' : 27.0,\n", + " 'V_b' : -51.3\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "nestml_gl_exp_model = \"\"\"\n", + "model gl_exp_neuron:\n", + " state:\n", + " refr_spikes_buffer mV = 0 mV\n", + " refr_tick integer = 0 # Counts number of tick during the refractory period\n", + " V_m mV = V_r # Membrane potential\n", + "\n", + " equations:\n", + " kernel G = delta(t)\n", + " V_m' = -(V_m - V_r) / tau_m + (mV / ms) * convolve(G, spikes) + (I_e + I_stim) / C_m\n", + "\n", + " parameters:\n", + " tau_m ms = 10 ms # Membrane time constant\n", + " C_m pF = 250 pF # Capacity of the membrane\n", + " t_ref ms = 2 ms # Duration of refractory period\n", + " tau_syn ms = 0.5 ms # Time constant of synaptic current\n", + " V_r mV = -65 mV # Resting membrane potential\n", + " V_reset mV = -65 mV # Reset potential of the membrane\n", + " b real = 27 # Parameter for the exponential curve\n", + " a mV = 5 mV # Parameter for the exponential curve\n", + " V_b mV = -51.3 mV # Membrane potential at which Phi(V)=1/b\n", + " reset_after_spike boolean = true\n", + "\n", + " # constant external input current\n", + " I_e pA = 0 pA\n", + "\n", + " internals:\n", + " RefractoryCounts integer = steps(t_ref) # refractory time in steps\n", + "\n", + " input:\n", + " spikes <- spike\n", + " I_stim pA <- continuous\n", + "\n", + " output:\n", + " spike\n", + "\n", + " function Phi(V_m mV) real:\n", + " return (1 / b) * exp((V_m - V_b) / a)\n", + "\n", + " update:\n", + " if refr_tick == 0: # neuron not refractory\n", + " integrate_odes()\n", + "\n", + " else: # neuron is absolute refractory\n", + " refr_tick -= 1\n", + " \n", + " if random_uniform(0, 1) <= 1E-3 * resolution() * Phi(V_m):\n", + " refr_tick = RefractoryCounts\n", + " if reset_after_spike:\n", + " V_m = V_reset\n", + "\n", + " emit_spike()\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.8.0-post0.dev0\n", + " Built: Sep 26 2024 22:44:51\n", + "\n", + " This program is provided AS IS and comes with\n", + " NO WARRANTY. See the file LICENSE for details.\n", + "\n", + " Problems or suggestions?\n", + " Visit https://www.nest-simulator.org\n", + "\n", + " Type 'nest.help()' to find out more about NEST.\n", + "\n", + "\n", + "Oct 10 14:43:49 NodeManager::add_node [Info]: \n", + " Neuron models emitting precisely timed spikes exist: the kernel property \n", + " off_grid_spiking has been set to true.\n", + " \n", + " NOTE: Mixing precise-spiking and normal neuron models may lead to inconsistent results.\n", + "CMake Warning (dev) at CMakeLists.txt:93 (project):\n", + " cmake_minimum_required() should be called prior to this top-level project()\n", + " call. Please see the cmake-commands(7) manual for usage documentation of\n", + " both commands.\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\n", + "-- The CXX compiler identification is GNU 12.3.0\n", + "-- Detecting CXX compiler ABI info\n", + "-- Detecting CXX compiler ABI info - done\n", + "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", + "-- Detecting CXX compile features\n", + "-- Detecting CXX compile features - done\n", + "\n", + "-------------------------------------------------------\n", + "nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module Configuration Summary\n", + "-------------------------------------------------------\n", + "\n", + "C++ compiler : /usr/bin/c++\n", + "Build static libs : OFF\n", + "C++ compiler flags : \n", + "NEST compiler flags : -std=c++17 -Wall -fopenmp -O2 -fdiagnostics-color=auto\n", + "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", + "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/12/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.a\n", + "\n", + "-------------------------------------------------------\n", + "\n", + "You can now build and install 'nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module' using\n", + " make\n", + " make install\n", + "\n", + "The library file libnestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module.so will be installed to\n", + " /tmp/nestml_target_ylwc6lqa\n", + "The module can be loaded into NEST using\n", + " (nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module) Install (in SLI)\n", + " nest.Install(nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module) (in PyNEST)\n", + "\n", + "CMake Warning (dev) in CMakeLists.txt:\n", + " No cmake_minimum_required command is present. A line of code such as\n", + "\n", + " cmake_minimum_required(VERSION 3.26)\n", + "\n", + " should be added at the top of the file. The version specified may be lower\n", + " if you wish to support older CMake versions for this project. For more\n", + " information run \"cmake --help-policy CMP0000\".\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\n", + "-- Configuring done (0.1s)\n", + "-- Generating done (0.0s)\n", + "-- Build files have been written to: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", + "[ 33%] Building CXX object CMakeFiles/nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module_module.dir/nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module.o\n", + "[ 66%] Building CXX object CMakeFiles/nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module_module.dir/gl_exp_neuron_nestml.o\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp: In member function ‘void gl_exp_neuron_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:178:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 178 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp: In member function ‘virtual void gl_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:288:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 288 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_exp_neuron_nestml.cpp:279:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 279 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "[100%] Linking CXX shared module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module.so\n", + "[100%] Built target nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module_module\n", + "[100%] Built target nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module_module\n", + "Install the project...\n", + "-- Install configuration: \"\"\n", + "-- Installing: /tmp/nestml_target_ylwc6lqa/nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module.so\n", + "\n", + "Oct 10 14:43:53 Install [Info]: \n", + " loaded module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module\n" + ] + } + ], + "source": [ + "module_name, neuron_model_name = NESTCodeGeneratorUtils.generate_code_for(\n", + " nestml_neuron_model=nestml_gl_exp_model,\n", + " logging_level=\"ERROR\" # try \"DEBUG\" for more debug information\n", + ")\n", + "\n", + "nest.Install(module_name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Firing rate\n", + "\n", + "This should correspond to the $\\Phi(V_\\text{m})$ function in the neuron (see plot below for the theoretical curve). Please note that in the literature, $\\Phi$ is sometimes defined as a probability of firing function with values between 0 and 1, but we here define it as giving the firing rate (in units of s${}^{-1}$)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def measure_numerical_Phi_function(neuron_model_name, module_name, V_min=0., V_max=10., neuron_model_params=None, neuron_membrane_potential_name=\"V_m\"):\n", + " nest.ResetKernel()\n", + " nest.Install(module_name)\n", + " nest.resolution = 1. # check that results are independent of resolution...\n", + "\n", + " t_stop = 25000.\n", + " \n", + " V_range = np.linspace(V_min, V_max, 12)\n", + " n_spikes = np.nan * np.ones_like(V_range)\n", + " for i, V_m in enumerate(V_range):\n", + " neuron = nest.Create(neuron_model_name)\n", + " if neuron_model_params:\n", + " neuron.set(neuron_model_params)\n", + " \n", + " neuron.set({neuron_membrane_potential_name: V_m})\n", + " \n", + " sr = nest.Create('spike_recorder')\n", + " nest.Connect(neuron, sr)\n", + " \n", + " assert neuron.get(neuron_membrane_potential_name) == V_m\n", + " nest.Simulate(t_stop)\n", + " assert neuron.get(neuron_membrane_potential_name) == V_m\n", + " \n", + " n_spikes[i] = len(sr.events[\"times\"])\n", + " \n", + " spike_rate = n_spikes / (t_stop / 1E3)\n", + "\n", + " return V_range, spike_rate" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Oct 10 14:43:53 Install [Info]: \n", + " loaded module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module\n", + "\n", + "Oct 10 14:43:53 correlation_detector [Info]: \n", + " Default for delta_tau changed from 0.5 to 5 ms\n", + "\n", + "Oct 10 14:43:53 correlomatrix_detector [Info]: \n", + " Default for delta_tau changed from 0.5 to 5 ms\n", + "\n", + "Oct 10 14:43:53 correlospinmatrix_detector [Info]: \n", + " Default for delta_tau changed from 0.1 to 1 ms\n", + "\n", + "Oct 10 14:43:53 gl_exp_neuron_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Oct 10 14:43:53 SimulationManager::set_status [Info]: \n", + " Temporal resolution changed from 0.1 to 1 ms.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 2 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 2\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 4 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 4\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 6 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 6\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 8 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 8\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 10 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 10\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 12 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 12\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 14 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 14\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 16 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 16\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 18 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 18\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 20 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 20\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 22 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 22\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 24 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 24\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Firing rate [Hz]')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# theoretical Phi vs V_m\n", + "V_range_theory = np.linspace(-60., -45., 100)\n", + "Phi_of_V_theory = (1 / params['b']) * np.exp((V_range_theory - params['V_b']) / params['a'])\n", + "\n", + "# numerical Phi vs V_m\n", + "V_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", + " module_name=module_name,\n", + " V_min=-60.,\n", + " V_max=-45.,\n", + " neuron_model_params={\"reset_after_spike\": False,\n", + " \"a\": params['a'],\n", + " \"b\": params['b'],\n", + " \"V_b\": params['V_b'],\n", + " \"tau_m\": 1E99})\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(V_range_theory, Phi_of_V_theory, label=\"theory\")\n", + "ax.plot(V_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n", + "ax.legend()\n", + "ax.set_xlabel(\"$U$\")\n", + "ax.set_ylabel(\"Firing rate [Hz]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Computing reliability of the single neuron model\n", + "\n", + "Here we plot the spike times for the neurons as a raster plot to study the stochastic behavior of the neuron model. First, we give the neurons a constant input current and then a Poissonian input.\n", + "\n", + "We observe that with the constant input current, the spike times across trials are highly variable, and the firing rate at the bottom is “flat” indicating that the spike times are not reliably reproduced over trials. With the Poissonian input, the corresponding firing rate panel shows several peaks indicating that the spike times tend to be more repeatable across trials." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def evaluate_neuron(neuron_name, module_name, nneurons=1, neuron_parms=None, stimulus_type=\"constant\", poisson_fr=0.0,\n", + " mu=500., sigma=0., t_sim=300., plot=False, rseed=1000, dt=0.1, input_freq=0.0):\n", + " \"\"\"\n", + " Run a simulation in NEST for the specified neuron. Inject a stepwise\n", + " current and plot the membrane potential dynamics and spikes generated.\n", + " \"\"\"\n", + " nest.ResetKernel()\n", + " nest.Install(module_name)\n", + " nest.SetKernelStatus({'rng_seed': rseed,\n", + " 'resolution': dt})\n", + " neuron = nest.Create(neuron_name, nneurons)\n", + " if neuron_parms:\n", + " for k, v in neuron_parms.items():\n", + " nest.SetStatus(neuron, k, v)\n", + " nest.SetStatus(neuron,{'V_m':np.random.uniform(-65.0, -50.0)})\n", + "\n", + " if stimulus_type == \"noise\":\n", + " # Create a noise generator\n", + " noise = nest.Create(\"noise_generator\")\n", + " # Set the parameters of the noise generator\n", + " noise_params = {\"mean\": mu, \n", + " \"std\": sigma, \n", + " \"dt\": dt,\n", + " \"frequency\":input_freq}\n", + " nest.SetStatus(noise, noise_params)\n", + " nest.Connect(noise, neuron)\n", + "\n", + " elif stimulus_type == \"poisson_spikes\":\n", + " # Create a Poisson generator device\n", + " poisson = nest.Create(\"poisson_generator\", params={\"rate\": poisson_fr})\n", + "\n", + " # Create a parrot neuron\n", + " parrot = nest.Create(\"parrot_neuron\")\n", + "\n", + " # Connect the Poisson generator to the parrot neuron\n", + " nest.Connect(poisson, parrot)\n", + "\n", + " # Connect the parrot neuron to each neuron\n", + " nest.Connect(parrot, neuron)\n", + " else:\n", + " assert stimulus_type == \"constant\"\n", + " nest.SetStatus(neuron, \"I_e\", mu)\n", + "\n", + " multimeter = nest.Create(\"multimeter\")\n", + " multimeter.set({\"record_from\": [\"V_m\"],\n", + " \"interval\": dt})\n", + " spike_recorder = nest.Create(\"spike_recorder\")\n", + " nest.Connect(multimeter, neuron)\n", + " nest.Connect(neuron, spike_recorder)\n", + "\n", + " nest.Simulate(t_sim)\n", + "\n", + " dmm = nest.GetStatus(multimeter)[0]\n", + " Voltages = dmm[\"events\"][\"V_m\"]\n", + " tv = dmm[\"events\"][\"times\"]\n", + " \n", + " dSD = nest.GetStatus(spike_recorder, keys='events')[0]\n", + " ns = dSD['senders']\n", + " ts = dSD[\"times\"]\n", + "\n", + " _idx = [np.argmin((tv - spike_time)**2) - 1 for spike_time in ts]\n", + " V_m_at_spike_times = Voltages[_idx]\n", + "\n", + " if plot:\n", + " fig, ax = plt.subplots()\n", + " ax.plot(tv, Voltages)\n", + " ax.scatter(ts, V_m_at_spike_times)\n", + " ax.set_xlabel(\"Time [ms]\")\n", + " ax.set_ylabel(\"V_m [mV]\")\n", + " ax.grid()\n", + "\n", + " return ts, ns" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Oct 10 14:43:53 Install [Info]: \n", + " loaded module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module\n", + "\n", + "Oct 10 14:43:53 gl_exp_neuron_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Oct 10 14:43:53 SimulationManager::set_status [Info]: \n", + " Temporal resolution changed from 0.1 to 0.1 ms.\n", + "\n", + "Oct 10 14:43:53 NodeManager::prepare_nodes [Info]: \n", + " Preparing 52 nodes for simulation.\n", + "\n", + "Oct 10 14:43:53 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 52\n", + " Simulation time (ms): 500\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:53 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:43:53 Install [Info]: \n", + " loaded module nestml_4fe882cb81004d09a22c6ff2d9fdeb4e_module\n", + "\n", + "Oct 10 14:43:53 gl_exp_neuron_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Oct 10 14:43:53 SimulationManager::set_status [Info]: \n", + " Temporal resolution changed from 0.1 to 0.1 ms.\n", + "\n", + "Oct 10 14:43:54 NodeManager::prepare_nodes [Info]: \n", + " Preparing 54 nodes for simulation.\n", + "\n", + "Oct 10 14:43:54 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 54\n", + " Simulation time (ms): 500\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:43:54 SimulationManager::run [Info]: \n", + " Simulation finished.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dt = 0.1\n", + "nneurons = 50\n", + "\n", + "ts_const, ns_const = evaluate_neuron(neuron_model_name,\n", + " module_name,\n", + " nneurons=nneurons,\n", + " neuron_parms=params,\n", + " stimulus_type='constant',\n", + " mu=550.,\n", + " t_sim=500.0,\n", + " dt=dt,\n", + " poisson_fr=0.0)\n", + "\n", + "ts_noise, ns_noise = evaluate_neuron(neuron_model_name,\n", + " module_name,\n", + " nneurons=nneurons,\n", + " neuron_parms=params,\n", + " stimulus_type='poisson_spikes',\n", + " t_sim=500.0,\n", + " poisson_fr=2000.0)\n", + "\n", + "# PSTH parameters\n", + "t_start = 0.0\n", + "t_stop = 500.0\n", + "t_step = 5.0\n", + "t_bins = np.arange(t_start, t_stop + t_step, t_step)\n", + "\n", + "# Calculate the PSTH\n", + "psth_const, _ = np.histogram(ts_const, bins=t_bins)\n", + "psth_const = psth_const / len(ts_const) / (dt*1e-3) # divide by number of trials and time bin size\n", + "\n", + "psth_noise, _ = np.histogram(ts_noise, bins=t_bins)\n", + "psth_noise = psth_noise / len(ts_noise) / (dt*1e-3) # divide by number of trials and time bin size\n", + "\n", + "plt.figure(figsize=(10,4))\n", + "# Raster plot\n", + "plt.subplot2grid((3,2),(0,0), rowspan=2)\n", + "plt.plot(ts_const, ns_const, '.')\n", + "plt.xlim(100, 500)\n", + "plt.ylabel('#Trial')\n", + "plt.title('Constant input current')\n", + "\n", + "plt.subplot2grid((3,2),(0,1), rowspan=2)\n", + "plt.plot(ts_noise, ns_noise, '.')\n", + "plt.xlim(100, 500)\n", + "plt.ylabel('#Trial')\n", + "plt.title('Poissonian input')\n", + "\n", + "# Plot the PSTH\n", + "plt.subplot2grid((3,2),(2,0), rowspan=1)\n", + "plt.plot(t_bins[:-1], psth_const)\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Firing rate (Hz)')\n", + "plt.xlim(100, 500)\n", + "\n", + "plt.subplot2grid((3,2),(2,1), rowspan=1)\n", + "plt.plot(t_bins[:-1], psth_noise)\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Firing rate (Hz)')\n", + "plt.xlim(100, 500)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Normalized model with calcium dynamics\n", + "--------------------------------------\n", + "\n", + "For convenience, we normalize the parameters and dynamical equations of the previous model with biophysical units, to make a model where all variables and parameters are scalars." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "nestml_gl_ca_neuron_model = '''\n", + "model gl_ca_neuron:\n", + " state:\n", + " U real = 0 # membrane potential\n", + "\n", + " parameters:\n", + " a real = 3.\n", + " alpha_over_N real = 1.0777744654743957 # synaptic strength\n", + " beta real = 50 # membrane potential leak\n", + " reset_after_spike boolean = true\n", + "\n", + " input:\n", + " incoming_spikes <- spike\n", + "\n", + " output:\n", + " spike\n", + "\n", + " function Phi(U real) real:\n", + " if U <= 0:\n", + " return 0\n", + "\n", + " return (4 * a) / (1 + exp(a - U)) - (4 * a) / (1 + exp(a))\n", + "\n", + " equations:\n", + " kernel K = delta(t)\n", + " \n", + " # R is presynaptic neuron's R and is passed as the spike weight by the synapse\n", + " U' = -U / (1E3 / beta) + alpha_over_N * convolve(K, incoming_spikes) / ms\n", + "\n", + " update:\n", + " # integrate spike input\n", + " integrate_odes()\n", + "\n", + " # emit spike?\n", + " if random_uniform(0, 1) <= 1E-3 * resolution() * Phi(U):\n", + " emit_spike()\n", + " if reset_after_spike:\n", + " U = 0 # reset membrane potential\n", + "'''" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now formulate the facilitating synapse model. The `R_pre` variable represents the calcium concentration of the presynaptic neuron. For convenience (and at the cost of some redundancy), we store it here in the NEST synapse object. The decay time constant of the calcium concentration is given by the `lmbda` parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "nestml_gl_ca_synapse_model = '''\n", + "model syn_gl_ca_synapse:\n", + " state:\n", + " R_pre real = 1.\n", + " w real = 1. # weight variable\n", + "\n", + " parameters:\n", + " d ms = 1 ms\n", + " lmbda real = 2.1555489309487914 # residual calcium decay rate\n", + "\n", + " onReceive(incoming_spikes):\n", + " w = R_pre\n", + " R_pre += 1\n", + " emit_spike(w, d)\n", + "\n", + " input:\n", + " incoming_spikes <- spike\n", + " \n", + " output:\n", + " spike\n", + " \n", + " update:\n", + " R_pre *= exp(-lmbda * 1E-3 * resolution()) # leakage\n", + "'''" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the neuron and synapse models defined, we generate the code and load the extension module into NEST:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.8.0-post0.dev0\n", + " Built: Sep 26 2024 22:44:51\n", + "\n", + " This program is provided AS IS and comes with\n", + " NO WARRANTY. See the file LICENSE for details.\n", + "\n", + " Problems or suggestions?\n", + " Visit https://www.nest-simulator.org\n", + "\n", + " Type 'nest.help()' to find out more about NEST.\n", + "\n", + "\n", + "Oct 10 14:43:54 NodeManager::add_node [Info]: \n", + " Neuron models emitting precisely timed spikes exist: the kernel property \n", + " off_grid_spiking has been set to true.\n", + " \n", + " NOTE: Mixing precise-spiking and normal neuron models may lead to inconsistent results.\n", + "CMake Warning (dev) at CMakeLists.txt:95 (project):\n", + " cmake_minimum_required() should be called prior to this top-level project()\n", + " call. Please see the cmake-commands(7) manual for usage documentation of\n", + " both commands.\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\n", + "-- The CXX compiler identification is GNU 12.3.0\n", + "-- Detecting CXX compiler ABI info\n", + "-- Detecting CXX compiler ABI info - done\n", + "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", + "-- Detecting CXX compile features\n", + "-- Detecting CXX compile features - done\n", + "\n", + "-------------------------------------------------------\n", + "nestml_5f96fafefab649e598c41c6b624997da_module Configuration Summary\n", + "-------------------------------------------------------\n", + "\n", + "C++ compiler : /usr/bin/c++\n", + "Build static libs : OFF\n", + "C++ compiler flags : \n", + "NEST compiler flags : -std=c++17 -Wall -fopenmp -O2 -fdiagnostics-color=auto\n", + "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/include -I/usr/include\n", + "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/lib/x86_64-linux-gnu/libgsl.so /usr/lib/x86_64-linux-gnu/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/12/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.a\n", + "\n", + "-------------------------------------------------------\n", + "\n", + "You can now build and install 'nestml_5f96fafefab649e598c41c6b624997da_module' using\n", + " make\n", + " make install\n", + "\n", + "The library file libnestml_5f96fafefab649e598c41c6b624997da_module.so will be installed to\n", + " /tmp/nestml_target_6h6g7acb\n", + "The module can be loaded into NEST using\n", + " (nestml_5f96fafefab649e598c41c6b624997da_module) Install (in SLI)\n", + " nest.Install(nestml_5f96fafefab649e598c41c6b624997da_module) (in PyNEST)\n", + "\n", + "CMake Warning (dev) in CMakeLists.txt:\n", + " No cmake_minimum_required command is present. A line of code such as\n", + "\n", + " cmake_minimum_required(VERSION 3.26)\n", + "\n", + " should be added at the top of the file. The version specified may be lower\n", + " if you wish to support older CMake versions for this project. For more\n", + " information run \"cmake --help-policy CMP0000\".\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\n", + "-- Configuring done (0.1s)\n", + "-- Generating done (0.0s)\n", + "-- Build files have been written to: /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target\n", + "[ 25%] Building CXX object CMakeFiles/nestml_5f96fafefab649e598c41c6b624997da_module_module.dir/nestml_5f96fafefab649e598c41c6b624997da_module.o\n", + "[ 50%] Building CXX object CMakeFiles/nestml_5f96fafefab649e598c41c6b624997da_module_module.dir/gl_ca_neuron_nestml.o\n", + "[ 75%] Building CXX object CMakeFiles/nestml_5f96fafefab649e598c41c6b624997da_module_module.dir/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.o\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp: In member function ‘void gl_ca_neuron_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:167:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 167 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp: In member function ‘virtual void gl_ca_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:265:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 265 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml.cpp:256:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 256 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp: In member function ‘void gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:172:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 172 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp: In member function ‘virtual void gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:276:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 276 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml.cpp:267:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 267 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "In file included from /home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/nestml_5f96fafefab649e598c41c6b624997da_module.cpp:36:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:481:88: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:576:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 576 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:582:3: required from ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:481:88: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:565:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 565 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:481:88: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:576:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 576 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:582:3: required from ‘nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:481:88: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:565:16: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 565 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:404:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 404 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:426:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 426 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:463:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 463 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:334:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 334 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:336:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 336 | auto get_thread = [tid]()\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:423:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", + " 423 | const double _tr_t = __t_spike - __dendritic_delay;\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:404:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 404 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:426:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 426 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:463:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 463 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:334:18: warning: unused variable ‘__resolution’ [-Wunused-variable]\n", + " 334 | const double __resolution = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the resolution() function\n", + " | ^~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:336:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 336 | auto get_thread = [tid]()\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:423:18: warning: unused variable ‘_tr_t’ [-Wunused-variable]\n", + " 423 | const double _tr_t = __t_spike - __dendritic_delay;\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::update_internal_state_(double, double, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:399:9: required from ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:622:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 622 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h: In instantiation of ‘void nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::update_internal_state_(double, double, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:399:9: required from ‘bool nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml::send(nest::Event&, size_t, const nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-gl-model/nestml/doc/tutorials/gl_model/target/syn_gl_ca_synapse_nestml__with_gl_ca_neuron_nestml.h:622:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "[100%] Linking CXX shared module nestml_5f96fafefab649e598c41c6b624997da_module.so\n", + "[100%] Built target nestml_5f96fafefab649e598c41c6b624997da_module_module\n", + "[100%] Built target nestml_5f96fafefab649e598c41c6b624997da_module_module\n", + "Install the project...\n", + "-- Install configuration: \"\"\n", + "-- Installing: /tmp/nestml_target_6h6g7acb/nestml_5f96fafefab649e598c41c6b624997da_module.so\n" + ] + } + ], + "source": [ + "module_name, neuron_model_name, synapse_model_name = NESTCodeGeneratorUtils.generate_code_for(\n", + " nestml_neuron_model=nestml_gl_ca_neuron_model,\n", + " nestml_synapse_model=nestml_gl_ca_synapse_model,\n", + " codegen_opts={\"delay_variable\": {\"syn_gl_ca_synapse\": \"d\"},\n", + " \"weight_variable\": {\"syn_gl_ca_synapse\": \"w\"}},\n", + " logging_level=\"ERROR\" # try \"DEBUG\" for more debug information\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Firing rate\n", + "\n", + "This should correspond to the `Phi(U)` function in the neuron (see plot below for the theoretical curve)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Oct 10 14:44:07 Install [Info]: \n", + " loaded module nestml_5f96fafefab649e598c41c6b624997da_module\n", + "\n", + "Oct 10 14:44:07 correlation_detector [Info]: \n", + " Default for delta_tau changed from 0.5 to 5 ms\n", + "\n", + "Oct 10 14:44:07 correlomatrix_detector [Info]: \n", + " Default for delta_tau changed from 0.5 to 5 ms\n", + "\n", + "Oct 10 14:44:07 correlospinmatrix_detector [Info]: \n", + " Default for delta_tau changed from 0.1 to 1 ms\n", + "\n", + "Oct 10 14:44:07 gl_ca_neuron_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Oct 10 14:44:07 gl_ca_neuron_nestml__with_syn_gl_ca_synapse_nestml [Warning]: \n", + " Simulation resolution has changed. Internal state and parameters of the \n", + " model have been reset!\n", + "\n", + "Oct 10 14:44:07 SimulationManager::set_status [Info]: \n", + " Temporal resolution changed from 0.1 to 1 ms.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 2 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 2\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 4 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 4\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 6 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 6\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 8 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 8\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 10 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 10\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 12 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 12\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 14 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 14\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 16 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 16\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 18 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 18\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 20 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 20\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 22 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 22\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n", + "\n", + "Oct 10 14:44:07 NodeManager::prepare_nodes [Info]: \n", + " Preparing 24 nodes for simulation.\n", + "\n", + "Oct 10 14:44:07 SimulationManager::start_updating_ [Info]: \n", + " Number of local nodes: 24\n", + " Simulation time (ms): 25000\n", + " Number of OpenMP threads: 1\n", + " Not using MPI\n", + "\n", + "Oct 10 14:44:07 SimulationManager::run [Info]: \n", + " Simulation finished.\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Firing rate [Hz]')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# theoretical Phi vs U\n", + "a = 3\n", + "U_range_theory = np.linspace(0., 10., 100)\n", + "Phi_of_U_theory = (4 * a) / (1 + np.exp(a - U_range_theory)) - (4 * a) / (1 + np.exp(a))\n", + "\n", + "# numerical Phi vs U\n", + "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n", + " module_name=module_name,\n", + " neuron_model_params={\"reset_after_spike\": False,\n", + " \"beta\": 1E-99, # a very low value, to prevent the membrane potential from decaying\n", + " \"a\": 3.},\n", + " neuron_membrane_potential_name=\"U\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n", + "ax.plot(U_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n", + "ax.legend()\n", + "ax.set_xlabel(\"$U$\")\n", + "ax.set_ylabel(\"Firing rate [Hz]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Postsynaptic response\n", + "\n", + "When a neuron spikes, it increases the potential of each postsynaptic partner by $\\alpha R/N$. Note that due to the residual calcium dynamics, the synapse is facilitating." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def run_simulation_in_chunks(sim_chunks, sim_time, syn_recordables, neurons):\n", + " sim_time_per_chunk = sim_time / sim_chunks\n", + "\n", + " # Init log to collect the values of all recordables\n", + " log = {}\n", + " log[\"t\"] = []\n", + "\n", + " # Initialize all the arrays\n", + " # Additional one entry is to store the trace value before the simulation begins\n", + " for rec in syn_recordables:\n", + " log[rec] = (sim_chunks + 1) * [[]]\n", + "\n", + " # Get the value of trace values before the simulation\n", + " syn = nest.GetConnections(target=neurons, synapse_model=synapse_model_name)\n", + " print(str(len(syn)) + \" synapses in the network\")\n", + " for rec in syn_recordables:\n", + " log[rec][0] = syn.get(rec)\n", + " \n", + " log[\"t\"].append(nest.GetKernelStatus(\"biological_time\"))\n", + "\n", + " # Run the simulation in chunks\n", + " for i in range(sim_chunks):\n", + " sim_start_time = i * sim_time_per_chunk\n", + " sim_end_time = sim_start_time + sim_time_per_chunk\n", + "\n", + " nest.Simulate(np.round(sim_time/sim_chunks))\n", + " \n", + " # log current values\n", + " log[\"t\"].append(nest.GetKernelStatus(\"biological_time\"))\n", + "\n", + " # Get the value of trace after the simulation\n", + " for rec in syn_recordables:\n", + " if isinstance(syn.get(rec), float):\n", + " log[rec][i + 1] = syn.get(rec)\n", + " else:\n", + " log[rec][i + 1] = syn.get(rec).copy()\n", + " \n", + " #nest.Cleanup()\n", + "\n", + " nest.Simulate(np.round(sim_time/sim_chunks)) # let the multimeters capture one more data point\n", + " \n", + " return log\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def measure_postsynaptic_response(neuron_model: str,\n", + " synapse_model: str,\n", + " module_name: str,\n", + " t_stop: float = 2250.,\n", + " V_m_specifier: str = \"V_m\",\n", + " custom_model_opts: Optional[Dict] = None):\n", + "\n", + " spike_times = np.array([50., 150., 250., 350., 2000.])\n", + " \n", + " nest.ResetKernel()\n", + " nest.Install(module_name)\n", + " nest.resolution = .1 # [ms]\n", + "\n", + " sim_time = 500. # [ms] (was 120 seconds in original paper)\n", + " chunk_length = 1. # [ms]\n", + " n_chunks = int(sim_time / chunk_length)\n", + " syn_recordables = [\"R_pre\"]\n", + " \n", + " neuron = nest.Create(neuron_model, params=custom_model_opts)\n", + " initial_V_m = neuron.get(V_m_specifier)\n", + " neuron.alpha_over_N = 1E-6 # a very low value, to prevent the neuron from spiking\n", + " spike_generator = nest.Create(\"spike_generator\", params={\"spike_times\": spike_times})\n", + " nest.Connect(spike_generator, neuron, syn_spec={'synapse_model': synapse_model})\n", + "\n", + " multimeter = nest.Create('multimeter')\n", + " nest.SetStatus(multimeter, {\"record_from\": [V_m_specifier], \"interval\": chunk_length})\n", + " nest.Connect(multimeter, neuron)\n", + "\n", + " sr = nest.Create('spike_recorder')\n", + " nest.Connect(neuron, sr) \n", + " \n", + " log = run_simulation_in_chunks(n_chunks, sim_time, syn_recordables, neuron)\n", + "\n", + " log[V_m_specifier] = np.hstack([initial_V_m, multimeter.events[V_m_specifier]])\n", + "\n", + " return log" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 synapses in the network\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'R_pre')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "log = measure_postsynaptic_response(neuron_model_name,\n", + " synapse_model_name,\n", + " module_name,\n", + " V_m_specifier=\"U\")\n", + "\n", + "fig, ax = plt.subplots(nrows=2)\n", + "ax[0].plot(log[\"t\"], log[\"U\"])\n", + "ax[1].plot(log[\"t\"], log[\"R_pre\"])\n", + "ax[-1].set_xlabel(\"$t$ [ms]\")\n", + "ax[0].set_ylabel(\"U\")\n", + "ax[1].set_ylabel(r\"R_pre\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Network dynamics\n", + "\n", + "We now set up the network with 100 neurons and check that it reaches a non-quiescent equilibrium state, following [4]." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "N = 100 # Number of neurons in network XXX: 1000 in the original paper\n", + "conn_prob = 1.\n", + "\n", + "a = 2.\n", + "\n", + "beta = 50.\n", + "lmbda = 10.\n", + "alpha = beta * lmbda\n", + "\n", + "U_0 = 1. #0.79555 # initial membrane potential\n", + "R_0 = .2 #1. # initial residual calcium\n", + "\n", + "U_range = .1 * U_0\n", + "R_range = .1 * R_0" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9900 synapses in the network\n" + ] + } + ], + "source": [ + "nest.ResetKernel()\n", + "nest.Install(module_name)\n", + "nest.resolution = .1 # [ms]\n", + "\n", + "sim_time = 1000. # [ms] (was 120 seconds in original paper)\n", + "chunk_length = 10. # [ms]\n", + "n_chunks = int(sim_time / chunk_length)\n", + "syn_recordables = [\"R_pre\"]\n", + "\n", + "pop = nest.Create(neuron_model_name, N)\n", + "pop.a = a\n", + "pop.alpha_over_N = alpha / N\n", + "pop.beta = beta\n", + "pop.U = [U_0 + U_range * (random.random() - .5) for _ in range(N)]\n", + "\n", + "conn_spec_dict = {'rule': 'pairwise_bernoulli', 'p': conn_prob, 'allow_autapses': False}\n", + "nest.Connect(pop, pop, conn_spec_dict, syn_spec={'synapse_model': synapse_model_name, 'lmbda': lmbda})\n", + "\n", + "syn = nest.GetConnections(target=pop, synapse_model=synapse_model_name)\n", + "N_syn = len(syn)\n", + "syn.R_pre = [R_0 + R_range * (random.random() - .5) for _ in range(N_syn)]\n", + "\n", + "multimeter = nest.Create(\"multimeter\")\n", + "multimeter.set({\"record_from\": [\"U\"], \"interval\": nest.resolution})\n", + "nest.Connect(multimeter, pop)\n", + "\n", + "sr = nest.Create('spike_recorder')\n", + "nest.Connect(pop, sr)\n", + "\n", + "log = run_simulation_in_chunks(n_chunks, sim_time, syn_recordables, pop)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'R')" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "times = log[\"t\"]\n", + "R_pre = np.array(log[\"R_pre\"])\n", + "R_pre_avg = np.mean(R_pre, axis=1)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(times, R_pre[:, ::N], alpha=.5) # XXX: plot only every N-th line\n", + "ax.set_xlim(0, sim_time)\n", + "ax.set_xlabel(\"Time [ms]\")\n", + "ax.plot(times, R_pre_avg, linewidth=4, linestyle=\"--\", c=\"black\", label=\"mean\")\n", + "ax.legend()\n", + "fig.suptitle(\"R\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Neuron')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.scatter(sr.events[\"times\"], sr.events[\"senders\"])\n", + "ax.set_ylim(0, N)\n", + "ax.set_xlim(0, sim_time)\n", + "ax.set_xlabel(\"Time [ms]\")\n", + "ax.set_ylabel(\"Neuron\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Network average firing rate: 7.16 Hz\n" + ] + } + ], + "source": [ + "avg_firing_rate = len(sr.events[\"times\"]) / N / (sim_time / 1E3)\n", + "print(\"Network average firing rate: \" + str(avg_firing_rate) + \" Hz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'U')" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "neuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "U_avg = np.zeros(len(np.unique(multimeter.get(\"events\")[\"times\"])))\n", + "for neuron_id in range(1, N+1):\n", + " idx = np.where(neuron_id == multimeter.get(\"events\")[\"senders\"])\n", + " times = multimeter.get(\"events\")[\"times\"][idx]\n", + " U = multimeter.get(\"events\")[\"U\"][idx]\n", + " \n", + " U_avg += U / N\n", + "\n", + " if neuron_id < 100:\n", + " ax.plot(times, U, label=\"U\")\n", + "\n", + "ax.plot(times, U_avg, linewidth=4, linestyle=\"--\", c=\"black\")\n", + "ax.set_ylabel(\"U\")\n", + "ax.set_xlabel(\"Time [ms]\")\n", + "fig.suptitle(\"U\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparison to theory\n", + "\n", + "We now check that the average neuron state in the network returns to the equilibrium position after an initial transient [2]." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.01, 6)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def Phi(x):\n", + " return (4 * a) / (1 + np.exp(a - x)) - (4 * a) / (1 + np.exp(a))\n", + "\n", + "def nullcline1(x):\n", + " return Phi(x) / lmbda\n", + "\n", + "def nullcline2(x):\n", + " return beta / alpha * x / Phi(x)\n", + "\n", + "U_vec = np.logspace(np.log10(.1), np.log10(150), 100)\n", + "\n", + "nullcline1_vec = nullcline1(U_vec)\n", + "nullcline2_vec = nullcline2(U_vec)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.loglog(U_vec, nullcline1_vec)\n", + "ax.loglog(U_vec, nullcline2_vec)\n", + "\n", + "U_avg_intrp = np.interp(np.linspace(0, len(U_avg), 100),\n", + " np.arange(len(U_avg)),\n", + " U_avg)\n", + "\n", + "R_pre_intrp = np.interp(np.linspace(0, len(R_pre_avg), 100),\n", + " np.arange(len(R_pre_avg)),\n", + " R_pre_avg)\n", + "\n", + "R_pre_intrp[ R_pre_intrp <= 1] = 1.000001\n", + "\n", + "ax.loglog(U_avg_intrp, R_pre_intrp - 1)\n", + "ax.loglog(U_avg[-1], R_pre_avg[-1] - 1, marker=\"o\")\n", + "\n", + "ax.set_xlabel('Membrane potential')\n", + "ax.set_ylabel('Residual calcium')\n", + "ax.set_xlim(np.amin(U_vec), np.amax(U_vec))\n", + "ax.set_ylim(.01, 6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Acknowledgements\n", + "\n", + "The authors would like to thank Renan Shimoura, Christophe Pouzat, Antonio Roque and Antonio Galves for their kind and helpful discussion and feedback.\n", + "\n", + "\n", + "## References\n", + "\n", + "[1] Brochini, L., de Andrade Costa, A., Abadi, M. et al. Phase transitions and self-organized criticality in networks of stochastic spiking neurons. Sci Rep 6, 35831 (2016). https://doi.org/10.1038/srep35831\n", + "\n", + "[2] Antonio Galves, Eva Löcherbach, Christophe Pouzat, Errico Presutti, \"A system of interacting neurons with short term synaptic facilitation\". arXiv:1903.01270v3 13 Sep 2019\n", + "\n", + "[3] Tsodyks MV, Markram H (1997). The neural code between neocortical pyramidal neurons depends on neurotransmitter release probability. PNAS, 94(2):719-23. DOI: https://doi.org/10.1073/pnas.94.2.719\n", + "\n", + "[4] Christophe Pouzat (2020). Spike Train Analysis and Modeling. (Syllabus) Latin-American School on Computational Neuroscience (LASCON) 2020, São Paulo, Brazil.\n", + "\n", + "[5] https://plmlab.math.cnrs.fr/xtof/interacting_neurons_with_stp\n", + "\n", + "\n", + "## Copyright\n", + "\n", + "This file is part of NEST.\n", + "\n", + "Copyright (C) 2004 The NEST Initiative\n", + "\n", + "NEST is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.\n", + "\n", + "NEST is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n", + "\n", + "You should have received a copy of the GNU General Public License along with NEST. If not, see .\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/tutorials/tutorials_list.rst b/doc/tutorials/tutorials_list.rst index 201749322..8e4bec00f 100644 --- a/doc/tutorials/tutorials_list.rst +++ b/doc/tutorials/tutorials_list.rst @@ -21,6 +21,10 @@ Creating neuron models Create a model that emits spikes according to an inhomogeneous Poisson distribution. +* :doc:`Galves-Löcherbach (GL) model ` + + In the GL model, firing of the neuron is a stochastic event, whose probability of occurrence is a function of the membrane potential. + Creating synapse models ----------------------- diff --git a/pynestml/utils/ast_utils.py b/pynestml/utils/ast_utils.py index d3d6f6ef5..41fb2f1f3 100644 --- a/pynestml/utils/ast_utils.py +++ b/pynestml/utils/ast_utils.py @@ -697,7 +697,8 @@ def get_post_ports_of_neuron_synapse_pair(cls, neuron, synapse, codegen_opts_pai for pair in codegen_opts_pairs: if pair["neuron"] == removesuffix(neuron.get_name().split("__with_")[0], FrontendConfiguration.suffix) \ and pair["synapse"] == removesuffix(synapse.get_name().split("__with_")[0], FrontendConfiguration.suffix) \ - and "post_ports" in pair.keys(): + and "post_ports" in pair.keys() \ + and pair["post_ports"]: return pair["post_ports"] return []