examples/example-4-multimodel-intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "51e1113b",
   "metadata": {},
   "source": [
    "# `MultiModel` framework\n",
    "\n",
    "Here we showcase the `MultiModel` framework, a standalone framework within `neurolib` to create and simulate heterogeneous brain models. By heterogeneous, we mean that a brain network may consist of nodes with totally different dynamics coupled by a single variable. Imagine having a population model for the thalamus, a different model for the hippocampus, and a different model for the cortex. Of course, the parameters and the model dynamics, and the equations would be completely different. This is all possible and even relatively easy in `MultiModel`.\n",
    "\n",
    "## Implemented models\n",
    "To facilitate your heterogeneous experiments, the `MultiModel` comes with few population models predefined for you. We can mix these into a brain network in many ways. We provide:\n",
    "\n",
    "* `aln`: the adaptive linear-nonlinear population model, it is a mean-field approximation of delay-coupled network of excitatory and inhibitory adaptive exponential integrate-and-fire neurons (AdEx)\n",
    "* `fitzhugh_nagumo`: the FitzHugh-Nagumo model, a two-dimensional slow-fast system, is a simplified version of the famous 4D Hodgkin–Huxley model\n",
    "* `hopf`: the Hopf model (sometimes called a Stuart-Landau oscillator) is a 1D nonlinear model and serves as a normal form of Hopf bifurcation in dynamical systems\n",
    "* `thalamus`: a conductance-based population rate model of the thalamus, it is a Jansen-Rit like population model with current-based voltage evolution, includes adaptation (*K*-leak), calcium, and rectifying currents\n",
    "* `wilson_cowan`: the Wilson-Cowan neuronal model is a simple model of interacting interconnected neurons of excitatory and inhibitory subtypes\n",
    "* `wong_wang`: a Wong-Wang model, a model approximating a biophysically-based cortical network model. Our implementation comes in two flavors:\n",
    "    * original Wong-Wang model with excitatory and inhibitory subtypes\n",
    "    * reduced Wong-Wang model with simpler dynamics and no EXC/INH distinction\n",
    "    \n",
    "Moreover, the `MultiModel` framework is built in such a way that creating and connecting new models (e.g., Jansen-Rit) is easy and intuitive. An example of how to make a brand new model implementation in `MultiModel` is provided in the following example notebook (`example-4.1-create-new-model.ipynb`).\n",
    "\n",
    "## Modeling hierarchy\n",
    "The `MultiModel` relies on the modeling hierarchy, which is typically implicit in whole-brain modeling. This hierarchy has three levels:\n",
    "* `NeuralMass`: represents a single neural population (typically excitatory, inhibitory, or without a subtype) and is defined by a set of parameters and (possibly delayed) (possibly stochastic) differential equations\n",
    "* `Node`: represents a single brain node, and it is a set of connected neural masses (so, e.g., a single Wilson-Cowan node consists of one excitatory and one inhibitory Wilson-Cowan `NeuralMass`)\n",
    "* `Network`: represents a brain network, and it is a set of connected nodes (can be any type, as long as the coupling variables are the same)\n",
    "\n",
    "Although the magic happens at the level of `NeuralMass` (by magic, we mean the dynamics), users can only simulate (integrate) a `Node` or a `Network`. In other words, even for models without excitatory/inhibitory subtyping (e.g., Hopf or FitzHugh-Nagumo), we create a `Node` consisting of one `NeuralMass`. In the case of, e.g., Wilson-Cowan, ALN, or original Wong-Wang model, the `Node` consists of one excitatory and one inhibitory mass. More info on the modeling hierarchy and how it actually works is provided in the following example notebook (`example-4.1-create-new-model.ipynb`), where we need to subclass the base classes for this hierarchy to build a new model.\n",
    "\n",
    "## Basic usage in `neurolib`\n",
    "(In the following we expect the reader to be mildly familiar with how `neurolib` works, e.g. how to run a model, how to change it parameters, and how to get model results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "quiet-albert",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import stuff\n",
    "\n",
    "# try:\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from IPython.display import display\n",
    "\n",
    "# import ALN single node model and neurolib wrapper `MultiModel`\n",
    "from neurolib.models.multimodel import ALNNetwork, ALNNode, MultiModel\n",
    "\n",
    "# except ImportError:\n",
    "#     import sys\n",
    "#     !{sys.executable} -m pip install matplotlib\n",
    "#     import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "agreed-wells",
   "metadata": {},
   "source": [
    "## Simulating the node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "mature-brass",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/jitcdde/_jitcdde.py:1491: UserWarning: Your input past does not begin at t=0 but at t=1.0. Values before the beginning of the past will be extrapolated. You very likely do not want this.\n",
      "  warn(f\"Your input past does not begin at t=0 but at t={input[0].time}. Values before the beginning of the past will be extrapolated. You very likely do not want this.\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 7495.97it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Rate [kHz]')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create a model and wrap it to `MultiModel`\n",
    "aln = MultiModel.init_node(ALNNode())\n",
    "\n",
    "# 5 seconds run\n",
    "aln.params[\"duration\"] = 5.0 * 1000  # in ms\n",
    "# MultiModel offers two integration backends, be default we are using so-called `jitcdde` backend\n",
    "# `jitcdde` is a numerical backend employing adaptive dt scheme for DDEs, therefore we do not care about\n",
    "# actual dt (since it is adaptive), only about the sampling dt and this can be higher\n",
    "# more about this in example-4.2\n",
    "aln.params[\"sampling_dt\"] = 1.0  # in ms\n",
    "# parametrise ALN model in slow limit cycle\n",
    "aln.params[\"*EXC*input*mu\"] = 4.2\n",
    "aln.params[\"*INH*input*mu\"] = 1.8\n",
    "# run\n",
    "aln.run()\n",
    "\n",
    "# plot - default output is firing rates in kHz\n",
    "plt.plot(aln[\"t\"], aln[\"r_mean_EXC\"].T, lw=2, c=\"k\")\n",
    "plt.xlabel(\"t [ms]\")\n",
    "plt.ylabel(\"Rate [kHz]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "elegant-building",
   "metadata": {},
   "source": [
    "As you saw in the previous cell, the internal workings of `MultiModel` are very similar to the core `neurolib`. Therefore, for simple runs, you do care about the following:\n",
    "* `MultiModel`: a wrapper class for all models in MultiModel framework which gives model objects `neurolib` powers (meaning `.params` and `.run()`). `MultiModel` class is initialized as follows:\n",
    "    * when initialising with `Node`: `model = MultiModel.init_node(<init'd Node class>)`\n",
    "    * when initialising with `Network`: `model = MultiModel(<init'd Network class>)` (see later)\n",
    "    \n",
    "## `MultiModel` parameters and other accessible attributes\n",
    "Since `MultiModel` is able to simulate heterogeneous models, the internals of how parameters work is a bit more complex than in the core `neurolib`. Each mass has its own parameters, each node then gathers the parameters of each mass within that node, and finally, the network gathers all parameters from each node in the network, etc. So hierarchy again. To make it easier to navigate through `MultiModel` hierarchies, some attributes are implemented in all hierarchy levels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "tracked-plasma",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Brain network ALN neural mass network with 2 nodes\n",
      "Nodes: 2\n",
      "Network node: ALN neural mass node with 2 neural masses: ALN excitatory neural mass EXC, ALN inhibitory neural mass INH\n",
      "Network node: ALN neural mass node with 2 neural masses: ALN excitatory neural mass EXC, ALN inhibitory neural mass INH\n",
      "Masses in 1. node: 2\n",
      "Neural mass: ALN excitatory neural mass with 7 state variables: I_mu, I_A, I_syn_mu_exc, I_syn_mu_inh, I_syn_sigma_exc, I_syn_sigma_inh, r_mean\n",
      "Neural mass: ALN inhibitory neural mass with 6 state variables: I_mu, I_syn_mu_exc, I_syn_mu_inh, I_syn_sigma_exc, I_syn_sigma_inh, r_mean\n",
      "This network name: ALN neural mass network\n",
      "This network label: ALNNet\n",
      "1st node name: ALN neural mass node\n",
      "1st node label: ALNNode\n",
      "1st node index: 0\n",
      "1st mass in 1st node name: ALN excitatory neural mass\n",
      "1st mass in 1st node label: ALNMassEXC\n",
      "1st mass in 1st node index: 0\n",
      "ALN EXC num. vars: 7\n",
      "ALN INH num. vars: 6\n",
      "ALN node num. vars: 13\n",
      "This network num. vars: 26\n",
      "ALN EXC noise vars: 1\n",
      "ALN EXC state vars: ['I_mu', 'I_A', 'I_syn_mu_exc', 'I_syn_mu_inh', 'I_syn_sigma_exc', 'I_syn_sigma_inh', 'r_mean']\n",
      "ALN node state vars: [['I_mu_EXC', 'I_A_EXC', 'I_syn_mu_exc_EXC', 'I_syn_mu_inh_EXC', 'I_syn_sigma_exc_EXC', 'I_syn_sigma_inh_EXC', 'r_mean_EXC', 'I_mu_INH', 'I_syn_mu_exc_INH', 'I_syn_mu_inh_INH', 'I_syn_sigma_exc_INH', 'I_syn_sigma_inh_INH', 'r_mean_INH']]\n",
      "This network state vars: [['I_mu_EXC', 'I_A_EXC', 'I_syn_mu_exc_EXC', 'I_syn_mu_inh_EXC', 'I_syn_sigma_exc_EXC', 'I_syn_sigma_inh_EXC', 'r_mean_EXC', 'I_mu_INH', 'I_syn_mu_exc_INH', 'I_syn_mu_inh_INH', 'I_syn_sigma_exc_INH', 'I_syn_sigma_inh_INH', 'r_mean_INH'], ['I_mu_EXC', 'I_A_EXC', 'I_syn_mu_exc_EXC', 'I_syn_mu_inh_EXC', 'I_syn_sigma_exc_EXC', 'I_syn_sigma_inh_EXC', 'r_mean_EXC', 'I_mu_INH', 'I_syn_mu_exc_INH', 'I_syn_mu_inh_INH', 'I_syn_sigma_exc_INH', 'I_syn_sigma_inh_INH', 'r_mean_INH']]\n",
      "\n",
      "Mass `describe`:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'index': 0,\n",
       " 'name': 'ALN excitatory neural mass',\n",
       " 'mass_type': 'EXC',\n",
       " 'num_state_variables': 7,\n",
       " 'num_noise_variables': 1,\n",
       " 'state_variable_names': ['I_mu',\n",
       "  'I_A',\n",
       "  'I_syn_mu_exc',\n",
       "  'I_syn_mu_inh',\n",
       "  'I_syn_sigma_exc',\n",
       "  'I_syn_sigma_inh',\n",
       "  'r_mean'],\n",
       " 'params': {'Ke': 800.0,\n",
       "  'Ki': 200.0,\n",
       "  'c_gl': 0.4,\n",
       "  'Ke_gl': 250.0,\n",
       "  'tau_se': 2.0,\n",
       "  'tau_si': 5.0,\n",
       "  'sigmae_ext': 1.5,\n",
       "  'Jee_max': 2.43,\n",
       "  'Jei_max': -3.3,\n",
       "  'C': 200.0,\n",
       "  'gL': 10.0,\n",
       "  'ext_exc_current': 0.0,\n",
       "  'ext_exc_rate': 0.0,\n",
       "  'a': 15.0,\n",
       "  'b': 40.0,\n",
       "  'EA': -80.0,\n",
       "  'tauA': 200.0,\n",
       "  'lambda': 10.0,\n",
       "  'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "   'mu': 4.2,\n",
       "   'sigma': 0.0,\n",
       "   'tau': 5.0,\n",
       "   'n': 1,\n",
       "   'seed': None}},\n",
       " 'lin_nonlin_transfer_function_filename': '/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/neurolib/models/multimodel/builder/../../aln/aln-precalc/quantities_cascade.h5'}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Node `describe`:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'index': 0,\n",
       " 'name': 'ALN neural mass node',\n",
       " 'num_masses': 2,\n",
       " 'num_num_state_variables': 13,\n",
       " 'num_noise_variables': 2,\n",
       " 'masses': [{'index': 0,\n",
       "   'name': 'ALN excitatory neural mass',\n",
       "   'mass_type': 'EXC',\n",
       "   'num_state_variables': 7,\n",
       "   'num_noise_variables': 1,\n",
       "   'state_variable_names': ['I_mu',\n",
       "    'I_A',\n",
       "    'I_syn_mu_exc',\n",
       "    'I_syn_mu_inh',\n",
       "    'I_syn_sigma_exc',\n",
       "    'I_syn_sigma_inh',\n",
       "    'r_mean'],\n",
       "   'params': {'Ke': 800.0,\n",
       "    'Ki': 200.0,\n",
       "    'c_gl': 0.4,\n",
       "    'Ke_gl': 250.0,\n",
       "    'tau_se': 2.0,\n",
       "    'tau_si': 5.0,\n",
       "    'sigmae_ext': 1.5,\n",
       "    'Jee_max': 2.43,\n",
       "    'Jei_max': -3.3,\n",
       "    'C': 200.0,\n",
       "    'gL': 10.0,\n",
       "    'ext_exc_current': 0.0,\n",
       "    'ext_exc_rate': 0.0,\n",
       "    'a': 15.0,\n",
       "    'b': 40.0,\n",
       "    'EA': -80.0,\n",
       "    'tauA': 200.0,\n",
       "    'lambda': 10.0,\n",
       "    'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "     'mu': 4.2,\n",
       "     'sigma': 0.0,\n",
       "     'tau': 5.0,\n",
       "     'n': 1,\n",
       "     'seed': None}},\n",
       "   'lin_nonlin_transfer_function_filename': '/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/neurolib/models/multimodel/builder/../../aln/aln-precalc/quantities_cascade.h5'},\n",
       "  {'index': 1,\n",
       "   'name': 'ALN inhibitory neural mass',\n",
       "   'mass_type': 'INH',\n",
       "   'num_state_variables': 6,\n",
       "   'num_noise_variables': 1,\n",
       "   'state_variable_names': ['I_mu',\n",
       "    'I_syn_mu_exc',\n",
       "    'I_syn_mu_inh',\n",
       "    'I_syn_sigma_exc',\n",
       "    'I_syn_sigma_inh',\n",
       "    'r_mean'],\n",
       "   'params': {'Ke': 800.0,\n",
       "    'Ki': 200.0,\n",
       "    'c_gl': 0.4,\n",
       "    'Ke_gl': 250.0,\n",
       "    'tau_se': 2.0,\n",
       "    'tau_si': 5.0,\n",
       "    'sigmai_ext': 1.5,\n",
       "    'Jie_max': 2.6,\n",
       "    'Jii_max': -1.64,\n",
       "    'C': 200.0,\n",
       "    'gL': 10.0,\n",
       "    'ext_inh_current': 0.0,\n",
       "    'ext_inh_rate': 0.0,\n",
       "    'lambda': 10.0,\n",
       "    'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "     'mu': 1.8,\n",
       "     'sigma': 0.0,\n",
       "     'tau': 5.0,\n",
       "     'n': 1,\n",
       "     'seed': None}},\n",
       "   'lin_nonlin_transfer_function_filename': '/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/neurolib/models/multimodel/builder/../../aln/aln-precalc/quantities_cascade.h5'}],\n",
       " 'local_connectivity': array([[0.24691358, 0.75757576],\n",
       "        [0.23076923, 1.52439024]]),\n",
       " 'local_delays': array([[4., 2.],\n",
       "        [4., 2.]])}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Network `describe`:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'name': 'ALN neural mass network',\n",
       " 'num_nodes': 2,\n",
       " 'num_state_variables': 26,\n",
       " 'num_noise_variables': 4,\n",
       " 'nodes': [{'index': 0,\n",
       "   'name': 'ALN neural mass node',\n",
       "   'num_masses': 2,\n",
       "   'num_num_state_variables': 13,\n",
       "   'num_noise_variables': 2,\n",
       "   'masses': [{'index': 0,\n",
       "     'name': 'ALN excitatory neural mass',\n",
       "     'mass_type': 'EXC',\n",
       "     'num_state_variables': 7,\n",
       "     'num_noise_variables': 1,\n",
       "     'state_variable_names': ['I_mu',\n",
       "      'I_A',\n",
       "      'I_syn_mu_exc',\n",
       "      'I_syn_mu_inh',\n",
       "      'I_syn_sigma_exc',\n",
       "      'I_syn_sigma_inh',\n",
       "      'r_mean'],\n",
       "     'params': {'Ke': 800.0,\n",
       "      'Ki': 200.0,\n",
       "      'c_gl': 0.4,\n",
       "      'Ke_gl': 250.0,\n",
       "      'tau_se': 2.0,\n",
       "      'tau_si': 5.0,\n",
       "      'sigmae_ext': 1.5,\n",
       "      'Jee_max': 2.43,\n",
       "      'Jei_max': -3.3,\n",
       "      'C': 200.0,\n",
       "      'gL': 10.0,\n",
       "      'ext_exc_current': 0.0,\n",
       "      'ext_exc_rate': 0.0,\n",
       "      'a': 15.0,\n",
       "      'b': 40.0,\n",
       "      'EA': -80.0,\n",
       "      'tauA': 200.0,\n",
       "      'lambda': 10.0,\n",
       "      'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "       'mu': 4.2,\n",
       "       'sigma': 0.0,\n",
       "       'tau': 5.0,\n",
       "       'n': 1,\n",
       "       'seed': None}},\n",
       "     'lin_nonlin_transfer_function_filename': '/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/neurolib/models/multimodel/builder/../../aln/aln-precalc/quantities_cascade.h5'},\n",
       "    {'index': 1,\n",
       "     'name': 'ALN inhibitory neural mass',\n",
       "     'mass_type': 'INH',\n",
       "     'num_state_variables': 6,\n",
       "     'num_noise_variables': 1,\n",
       "     'state_variable_names': ['I_mu',\n",
       "      'I_syn_mu_exc',\n",
       "      'I_syn_mu_inh',\n",
       "      'I_syn_sigma_exc',\n",
       "      'I_syn_sigma_inh',\n",
       "      'r_mean'],\n",
       "     'params': {'Ke': 800.0,\n",
       "      'Ki': 200.0,\n",
       "      'c_gl': 0.4,\n",
       "      'Ke_gl': 250.0,\n",
       "      'tau_se': 2.0,\n",
       "      'tau_si': 5.0,\n",
       "      'sigmai_ext': 1.5,\n",
       "      'Jie_max': 2.6,\n",
       "      'Jii_max': -1.64,\n",
       "      'C': 200.0,\n",
       "      'gL': 10.0,\n",
       "      'ext_inh_current': 0.0,\n",
       "      'ext_inh_rate': 0.0,\n",
       "      'lambda': 10.0,\n",
       "      'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "       'mu': 1.8,\n",
       "       'sigma': 0.0,\n",
       "       'tau': 5.0,\n",
       "       'n': 1,\n",
       "       'seed': None}},\n",
       "     'lin_nonlin_transfer_function_filename': '/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/neurolib/models/multimodel/builder/../../aln/aln-precalc/quantities_cascade.h5'}],\n",
       "   'local_connectivity': array([[0.24691358, 0.75757576],\n",
       "          [0.23076923, 1.52439024]]),\n",
       "   'local_delays': array([[4., 2.],\n",
       "          [4., 2.]])},\n",
       "  {'index': 1,\n",
       "   'name': 'ALN neural mass node',\n",
       "   'num_masses': 2,\n",
       "   'num_num_state_variables': 13,\n",
       "   'num_noise_variables': 2,\n",
       "   'masses': [{'index': 0,\n",
       "     'name': 'ALN excitatory neural mass',\n",
       "     'mass_type': 'EXC',\n",
       "     'num_state_variables': 7,\n",
       "     'num_noise_variables': 1,\n",
       "     'state_variable_names': ['I_mu',\n",
       "      'I_A',\n",
       "      'I_syn_mu_exc',\n",
       "      'I_syn_mu_inh',\n",
       "      'I_syn_sigma_exc',\n",
       "      'I_syn_sigma_inh',\n",
       "      'r_mean'],\n",
       "     'params': {'Ke': 800.0,\n",
       "      'Ki': 200.0,\n",
       "      'c_gl': 0.4,\n",
       "      'Ke_gl': 250.0,\n",
       "      'tau_se': 2.0,\n",
       "      'tau_si': 5.0,\n",
       "      'sigmae_ext': 1.5,\n",
       "      'Jee_max': 2.43,\n",
       "      'Jei_max': -3.3,\n",
       "      'C': 200.0,\n",
       "      'gL': 10.0,\n",
       "      'ext_exc_current': 0.0,\n",
       "      'ext_exc_rate': 0.0,\n",
       "      'a': 15.0,\n",
       "      'b': 40.0,\n",
       "      'EA': -80.0,\n",
       "      'tauA': 200.0,\n",
       "      'lambda': 10.0,\n",
       "      'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "       'mu': 4.2,\n",
       "       'sigma': 0.0,\n",
       "       'tau': 5.0,\n",
       "       'n': 1,\n",
       "       'seed': None}},\n",
       "     'lin_nonlin_transfer_function_filename': '/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/neurolib/models/multimodel/builder/../../aln/aln-precalc/quantities_cascade.h5'},\n",
       "    {'index': 1,\n",
       "     'name': 'ALN inhibitory neural mass',\n",
       "     'mass_type': 'INH',\n",
       "     'num_state_variables': 6,\n",
       "     'num_noise_variables': 1,\n",
       "     'state_variable_names': ['I_mu',\n",
       "      'I_syn_mu_exc',\n",
       "      'I_syn_mu_inh',\n",
       "      'I_syn_sigma_exc',\n",
       "      'I_syn_sigma_inh',\n",
       "      'r_mean'],\n",
       "     'params': {'Ke': 800.0,\n",
       "      'Ki': 200.0,\n",
       "      'c_gl': 0.4,\n",
       "      'Ke_gl': 250.0,\n",
       "      'tau_se': 2.0,\n",
       "      'tau_si': 5.0,\n",
       "      'sigmai_ext': 1.5,\n",
       "      'Jie_max': 2.6,\n",
       "      'Jii_max': -1.64,\n",
       "      'C': 200.0,\n",
       "      'gL': 10.0,\n",
       "      'ext_inh_current': 0.0,\n",
       "      'ext_inh_rate': 0.0,\n",
       "      'lambda': 10.0,\n",
       "      'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "       'mu': 1.8,\n",
       "       'sigma': 0.0,\n",
       "       'tau': 5.0,\n",
       "       'n': 1,\n",
       "       'seed': None}},\n",
       "     'lin_nonlin_transfer_function_filename': '/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/neurolib/models/multimodel/builder/../../aln/aln-precalc/quantities_cascade.h5'}],\n",
       "   'local_connectivity': array([[0.24691358, 0.75757576],\n",
       "          [0.23076923, 1.52439024]]),\n",
       "   'local_delays': array([[4., 2.],\n",
       "          [4., 2.]])}],\n",
       " 'connectivity': array([[0., 1.],\n",
       "        [1., 0.]]),\n",
       " 'delays': array([[0., 0.],\n",
       "        [0., 0.]])}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dummy_sc = np.array([[0.0, 1.0], [1.0, 0.0]])\n",
    "# init MultiModelnetwork with 2 ALN nodes with dummy sc and no delays\n",
    "mm_net = ALNNetwork(connectivity_matrix=dummy_sc, delay_matrix=None)\n",
    "\n",
    "print(mm_net)\n",
    "# each network is an proper python iterator, i.e. len() is defined\n",
    "print(f\"Nodes: {len(mm_net)}\")\n",
    "# as well as __get_item__\n",
    "print(mm_net[0])\n",
    "print(mm_net[1])\n",
    "# similarly, each node is a python iterator, i.e.\n",
    "print(f\"Masses in 1. node: {len(mm_net[0])}\")\n",
    "print(mm_net[0][0])\n",
    "print(mm_net[0][1])\n",
    "\n",
    "# in order to navigate through the hierarchy, each mass, node and net\n",
    "# has its own name and label and index\n",
    "# index of a node is relative within the network\n",
    "# index of a mass is relative within the node\n",
    "print(f\"This network name: {mm_net.name}\")\n",
    "print(f\"This network label: {mm_net.label}\")\n",
    "print(f\"1st node name: {mm_net[0].name}\")\n",
    "print(f\"1st node label: {mm_net[0].label}\")\n",
    "print(f\"1st node index: {mm_net[0].index}\")\n",
    "print(f\"1st mass in 1st node name: {mm_net[0][0].name}\")\n",
    "print(f\"1st mass in 1st node label: {mm_net[0][0].label}\")\n",
    "print(f\"1st mass in 1st node index: {mm_net[0][0].index}\")\n",
    "\n",
    "# you can also check number of variables etc at all levels of hierarchy\n",
    "print(f\"ALN EXC num. vars: {mm_net[0][0].num_state_variables}\")\n",
    "print(f\"ALN INH num. vars: {mm_net[0][1].num_state_variables}\")\n",
    "print(f\"ALN node num. vars: {mm_net[0].num_state_variables}\")\n",
    "print(f\"This network num. vars: {mm_net.num_state_variables}\")\n",
    "# similarly you can check number of \"noise variables\", i.e. the number\n",
    "# of stochastic variables entering the simulation\n",
    "print(f\"ALN EXC noise vars: {mm_net[0][0].num_noise_variables}\")\n",
    "# etc\n",
    "\n",
    "# not sure what are the state variables? no problem!\n",
    "print(f\"ALN EXC state vars: {mm_net[0][0].state_variable_names}\")\n",
    "print(f\"ALN node state vars: {mm_net[0].state_variable_names}\")\n",
    "print(f\"This network state vars: {mm_net.state_variable_names}\")\n",
    "\n",
    "# if you are unsure what kind of a monster you build in MultiModel,\n",
    "# a function `describe()` is available at all three levels -\n",
    "# it returns a dictionary with basic info about the model object\n",
    "# this is describe of a `NeuralMass`\n",
    "print(\"\")\n",
    "print(\"Mass `describe`:\")\n",
    "display(mm_net[0][0].describe())\n",
    "# describe of a `Node` recursively describes all masses and some more\n",
    "print(\"\")\n",
    "print(\"Node `describe`:\")\n",
    "display(mm_net[0].describe())\n",
    "# and finally, describe of a `Network` gives you everything\n",
    "print(\"\")\n",
    "print(\"Network `describe`:\")\n",
    "display(mm_net.describe())\n",
    "\n",
    "# PRO tip: imagine highly heterogeneous network and some long simulation with it;\n",
    "# apart from the results you can dump `net.describe()` dictionary into json and\n",
    "# never forget what you've done!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "atomic-recording",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ALNNet.ALNNode_0.ALNMassEXC_0.Ke': 800.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.Ki': 200.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.c_gl': 0.4,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.Ke_gl': 250.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.sigmae_ext': 1.5,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.Jee_max': 2.43,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.Jei_max': -3.3,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.C': 200.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.gL': 10.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.ext_exc_current': 0.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.ext_exc_rate': 0.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.a': 15.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.b': 40.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.EA': -80.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.tauA': 200.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.lambda': 10.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.type': 'OrnsteinUhlenbeckProcess',\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.mu': 4.2,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.sigma': 0.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.n': 1,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.seed': None,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.Ke': 800.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.Ki': 200.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.c_gl': 0.4,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.Ke_gl': 250.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.sigmai_ext': 1.5,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.Jie_max': 2.6,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.Jii_max': -1.64,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.C': 200.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.gL': 10.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.ext_inh_current': 0.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.ext_inh_rate': 0.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.lambda': 10.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.type': 'OrnsteinUhlenbeckProcess',\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.mu': 1.8,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.sigma': 0.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.n': 1,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.seed': None,\n",
       " 'ALNNet.ALNNode_0.local_connectivity': array([[0.24691358, 0.75757576],\n",
       "        [0.23076923, 1.52439024]]),\n",
       " 'ALNNet.ALNNode_0.local_delays': array([[4., 2.],\n",
       "        [4., 2.]]),\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.Ke': 800.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.Ki': 200.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.c_gl': 0.4,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.Ke_gl': 250.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.sigmae_ext': 1.5,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.Jee_max': 2.43,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.Jei_max': -3.3,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.C': 200.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.gL': 10.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.ext_exc_current': 0.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.ext_exc_rate': 0.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.a': 15.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.b': 40.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.EA': -80.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.tauA': 200.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.lambda': 10.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.input_0.type': 'OrnsteinUhlenbeckProcess',\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.input_0.mu': 4.2,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.input_0.sigma': 0.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.input_0.n': 1,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.input_0.seed': None,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.Ke': 800.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.Ki': 200.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.c_gl': 0.4,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.Ke_gl': 250.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.sigmai_ext': 1.5,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.Jie_max': 2.6,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.Jii_max': -1.64,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.C': 200.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.gL': 10.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.ext_inh_current': 0.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.ext_inh_rate': 0.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.lambda': 10.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.input_0.type': 'OrnsteinUhlenbeckProcess',\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.input_0.mu': 1.8,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.input_0.sigma': 0.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.input_0.n': 1,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.input_0.seed': None,\n",
       " 'ALNNet.ALNNode_1.local_connectivity': array([[0.24691358, 0.75757576],\n",
       "        [0.23076923, 1.52439024]]),\n",
       " 'ALNNet.ALNNode_1.local_delays': array([[4., 2.],\n",
       "        [4., 2.]]),\n",
       " 'ALNNet.connectivity': array([[0., 1.],\n",
       "        [1., 0.]]),\n",
       " 'ALNNet.delays': array([[0., 0.],\n",
       "        [0., 0.]]),\n",
       " 'duration': 2000,\n",
       " 'dt': 0.1,\n",
       " 'seed': None,\n",
       " 'backend': 'jitcdde',\n",
       " 'name': 'ALNNet',\n",
       " 'description': 'ALN neural mass network',\n",
       " 'N': 2,\n",
       " 'Cmat': array([[0., 1.],\n",
       "        [1., 0.]]),\n",
       " 'sampling_dt': 0.1}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now let us check the parameters.. for this we initialise MultiModel in neurolib's fashion\n",
    "aln_net = MultiModel(mm_net)\n",
    "# parameters are accessible via .params\n",
    "aln_net.params\n",
    "# as you can see the parameters are flattened nested dictionary which follows this nomenclature\n",
    "# {\"<network label>.<node label>_index.<mass label>_index.<param name>: param value\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "atmospheric-favorite",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.input_0.tau': 5.0}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.input_0.tau': 5.0}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.tau': 5.0}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.tau': 13.2,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.tau': 13.2}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# as you can see there are a lot of parameters for simple 2-node network of ALN models\n",
    "# typically you want to change parameters of all nodes at the same time\n",
    "# fortunately, model.params is not your basic dictionary, it's a special one, we call it `star` dictionary,\n",
    "# because you can do this:\n",
    "display(aln_net.params[\"*tau\"])\n",
    "print(\"\")\n",
    "# so yes, star works as a glob identifier, so by selecting \"*tau\" I want all parameters named tau\n",
    "# (I dont care from which mass or node it comes)\n",
    "# what if I want to change taus only in EXC masses? easy:\n",
    "display(aln_net.params[\"*EXC*tau\"])\n",
    "print(\"\")\n",
    "# or maybe I want to change taus only in the first node?\n",
    "display(aln_net.params[\"*Node_0*tau\"])\n",
    "print(\"\")\n",
    "# of course, you can change a param value with this\n",
    "aln_net.params[\"*Node_0*tau\"] = 13.2\n",
    "display(aln_net.params[\"*Node_0*tau\"])\n",
    "aln_net.params[\"*Node_0*tau\"] = 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "efficient-gauge",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ALNNet.ALNNode_0.ALNMassEXC_0.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.tauA': 200.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.tauA': 200.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.input_0.tau': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.input_0.tau': 5.0}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNet.ALNNode_0.ALNMassEXC_0.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassEXC_0.tauA': 200.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_0.ALNMassINH_1.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.tau_si': 5.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassEXC_0.tauA': 200.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.tau_se': 2.0,\n",
       " 'ALNNet.ALNNode_1.ALNMassINH_1.tau_si': 5.0}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# case: I want to change all taus except \"noise\" taus\n",
    "# this gives all the taus, including \"noise\"\n",
    "display(aln_net.params[\"*tau*\"])\n",
    "print(\"\")\n",
    "# pipe symbol filters out unwanted keys - here we have only taus which key does NOT include \"input\"\n",
    "display(aln_net.params[\"*tau*|input\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "expressed-stuff",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.0}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/jitcdde/_jitcdde.py:1491: UserWarning: Your input past does not begin at t=0 but at t=1.0. Values before the beginning of the past will be extrapolated. You very likely do not want this.\n",
      "  warn(f\"Your input past does not begin at t=0 but at t={input[0].time}. Values before the beginning of the past will be extrapolated. You very likely do not want this.\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 12088.04it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.1}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 11923.41it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.2}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 11831.34it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.30000000000000004}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 11601.52it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.4}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 11838.99it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.5}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 11134.30it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.6000000000000001}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 4698.40it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.7000000000000001}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 3559.94it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.8}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 3242.48it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 0.9}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 3419.71it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.0}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 3356.80it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.1}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 3586.59it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.2000000000000002}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 4160.26it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.3}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 5574.75it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.4000000000000001}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 9851.36it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.5}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 10735.54it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.6}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 11248.32it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.7000000000000002}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 11078.22it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.8}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 11982.51it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 1.9000000000000001}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 12192.60it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'ALNNode_0.ALNMassEXC_0.input_0.mu': 2.0}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:00<00:00, 11837.18it/s]\n"
     ]
    }
   ],
   "source": [
    "max_rate_e = []\n",
    "min_rate_e = []\n",
    "\n",
    "# number low for testing:\n",
    "mue_inputs = np.linspace(0, 2, 2)\n",
    "# use: mue_inputs = np.linspace(0, 2, 20)\n",
    "\n",
    "# not let's match ALN parameters to those in example-0-aln-minimal and recreate\n",
    "# the 1D bif. diagram\n",
    "aln.params[\"*INH*input*mu\"] = 0.5\n",
    "aln.params[\"*b\"] = 0.0\n",
    "aln.params[\"ALNNode_0.ALNMassEXC_0.a\"] = 0.0\n",
    "for mue in mue_inputs:\n",
    "    aln.params[\"*EXC*input*mu\"] = mue\n",
    "    display(aln.params[\"*EXC*input*mu\"])\n",
    "    aln.run()\n",
    "    max_rate_e.append(np.max(aln.output[0, -int(1000 / aln.params[\"sampling_dt\"]) :]))\n",
    "    min_rate_e.append(np.min(aln.output[0, -int(1000 / aln.params[\"sampling_dt\"]) :]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "critical-smooth",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Min / max firing rate [kHz]')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(mue_inputs, max_rate_e, c=\"k\", lw=2)\n",
    "plt.plot(mue_inputs, min_rate_e, c=\"k\", lw=2)\n",
    "plt.title(\"Bifurcation diagram of the aln model\")\n",
    "plt.xlabel(\"Input to excitatory population\")\n",
    "plt.ylabel(\"Min / max firing rate [kHz]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coordinated-public",
   "metadata": {},
   "source": [
    "## Connecting two models\n",
    "So far, we only showed how to use `MultiModel` with a single dynamical model (ALN), and that is no fun. I mean, all this is already possible in core `neurolib`, and it the core, it is much faster.\n",
    "\n",
    "However, the real strength of `MultiModel` is combining different models into one network. Let us build a thalamocortical model using one node of the thalamic population model and one node of ALN, representing the cortex."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "specific-stake",
   "metadata": {},
   "outputs": [],
   "source": [
    "# first - imports\n",
    "from neurolib.models.multimodel import ALNNode, ThalamicNode\n",
    "from neurolib.models.multimodel.builder.base.constants import EXC, INH\n",
    "from neurolib.models.multimodel.builder.base.network import Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "turned-earthquake",
   "metadata": {},
   "outputs": [],
   "source": [
    "# let us start by subclassing the Network\n",
    "\n",
    "\n",
    "class ALNThalamusMiniNetwork(Network):\n",
    "    \"\"\"\n",
    "    Simple thalamocortical motif: 1 cortical node ALN + 1 NMM thalamus.\n",
    "    \"\"\"\n",
    "\n",
    "    # provide basic attributes as name and label\n",
    "    name = \"ALN 1 node + Thalamus\"\n",
    "    label = \"ALNThlmNet\"\n",
    "\n",
    "    # define which variables are used to sync, i.e. what coupling variables our nodes need\n",
    "    sync_variables = [\n",
    "        # both nodes are connected via excitatory synapses\n",
    "        \"network_exc_exc\",\n",
    "        # ALN requires also squared coupling\n",
    "        \"network_exc_exc_sq\",\n",
    "        # and INH mass in thalamus also receives excitatory coupling\n",
    "        \"network_inh_exc\",\n",
    "    ]\n",
    "\n",
    "    # lastly, we need to define what is default output of the network (this has to be the\n",
    "    #     variable present in all nodes)\n",
    "    # for us it is excitatory firing rates\n",
    "    default_output = f\"r_mean_{EXC}\"\n",
    "    # define all output vars of any interest to us - EXC and INH firing rates and adaptive current in ALN\n",
    "    output_vars = [f\"r_mean_{EXC}\", f\"r_mean_{INH}\", f\"I_A_{EXC}\"]\n",
    "\n",
    "    def __init__(self, connectivity_matrix, delay_matrix):\n",
    "        # self connections are resolved within nodes, so zeroes at the diagonal\n",
    "        assert np.all(np.diag(connectivity_matrix) == 0.0)\n",
    "\n",
    "        # init ALN node with index 0\n",
    "        aln_node = ALNNode()\n",
    "        aln_node.index = 0\n",
    "        # index where the state variables start - for first node it is always 0\n",
    "        aln_node.idx_state_var = 0\n",
    "        # set correct indices for noise input\n",
    "        for mass in aln_node:\n",
    "            mass.noise_input_idx = [mass.index]\n",
    "\n",
    "        # init thalamus node with index 1\n",
    "        thalamus = ThalamicNode()\n",
    "        thalamus.index = 1\n",
    "        # thalamic state variables start where ALN state variables end - easy\n",
    "        thalamus.idx_state_var = aln_node.num_state_variables\n",
    "        # set correct indices of noise input - one per mass, after ALN noise\n",
    "        # indices\n",
    "        for mass in thalamus:\n",
    "            mass.noise_input_idx = [aln_node.num_noise_variables + mass.index]\n",
    "\n",
    "        # now super.__init__ network with these two nodes:\n",
    "        super().__init__(\n",
    "            nodes=[aln_node, thalamus],\n",
    "            connectivity_matrix=connectivity_matrix,\n",
    "            delay_matrix=delay_matrix,\n",
    "        )\n",
    "\n",
    "    # done! the only other thing we need to do, is to set the coupling variables\n",
    "    # thalamus vs. ALN are coupled via their firing rates and here we setup the\n",
    "    # coupling matrices; the super class `Network` comes with some convenient\n",
    "    # functions for this\n",
    "\n",
    "    def _sync(self):\n",
    "        \"\"\"\n",
    "        Set coupling variables - the ones we defined in `sync_variables`\n",
    "        _sync returns a list of tuples where the first element in each tuple is the coupling \"symbol\"\n",
    "        and the second is the actual mathematical expression\n",
    "        for the ease of doing this, `Network` class contains convenience functions for this:\n",
    "            - _additive_coupling\n",
    "            - _diffusive_coupling\n",
    "            - _no_coupling\n",
    "        here we use additive coupling only\n",
    "        \"\"\"\n",
    "        # get indices of coupling variables from all nodes\n",
    "        exc_indices = [\n",
    "            next(\n",
    "                iter(\n",
    "                    node.all_couplings(\n",
    "                        mass_indices=node.excitatory_masses.tolist()\n",
    "                    )\n",
    "                )\n",
    "            )\n",
    "            for node in self\n",
    "        ]\n",
    "        assert len(exc_indices) == len(self)\n",
    "        return (\n",
    "            # basic EXC <-> EXC coupling\n",
    "            # within_node_idx is a list of len 2 (because we have two nodes)\n",
    "            # with indices of coupling variables within the respective state vectors\n",
    "            self._additive_coupling(\n",
    "                within_node_idx=exc_indices, symbol=\"network_exc_exc\"\n",
    "            )\n",
    "            # squared EXC <-> EXC coupling (only to ALN)\n",
    "            + self._additive_coupling(\n",
    "                within_node_idx=exc_indices,\n",
    "                symbol=\"network_exc_exc_sq\",\n",
    "                # square connectivity\n",
    "                connectivity=self.connectivity * self.connectivity,\n",
    "            )\n",
    "            # EXC -> INH coupling (only to thalamus)\n",
    "            + self._additive_coupling(\n",
    "                within_node_idx=exc_indices,\n",
    "                symbol=\"network_inh_exc\",\n",
    "                connectivity=self.connectivity,\n",
    "            )\n",
    "            + super()._sync()\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "entertaining-concentration",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'ALN 1 node + Thalamus',\n",
       " 'num_nodes': 2,\n",
       " 'num_state_variables': 30,\n",
       " 'num_noise_variables': 4,\n",
       " 'nodes': [{'index': 0,\n",
       "   'name': 'ALN neural mass node',\n",
       "   'num_masses': 2,\n",
       "   'num_num_state_variables': 13,\n",
       "   'num_noise_variables': 2,\n",
       "   'masses': [{'index': 0,\n",
       "     'name': 'ALN excitatory neural mass',\n",
       "     'mass_type': 'EXC',\n",
       "     'num_state_variables': 7,\n",
       "     'num_noise_variables': 1,\n",
       "     'state_variable_names': ['I_mu',\n",
       "      'I_A',\n",
       "      'I_syn_mu_exc',\n",
       "      'I_syn_mu_inh',\n",
       "      'I_syn_sigma_exc',\n",
       "      'I_syn_sigma_inh',\n",
       "      'r_mean'],\n",
       "     'params': {'Ke': 800.0,\n",
       "      'Ki': 200.0,\n",
       "      'c_gl': 0.4,\n",
       "      'Ke_gl': 250.0,\n",
       "      'tau_se': 2.0,\n",
       "      'tau_si': 5.0,\n",
       "      'sigmae_ext': 1.5,\n",
       "      'Jee_max': 2.43,\n",
       "      'Jei_max': -3.3,\n",
       "      'C': 200.0,\n",
       "      'gL': 10.0,\n",
       "      'ext_exc_current': 0.0,\n",
       "      'ext_exc_rate': 0.0,\n",
       "      'a': 15.0,\n",
       "      'b': 40.0,\n",
       "      'EA': -80.0,\n",
       "      'tauA': 200.0,\n",
       "      'lambda': 10.0,\n",
       "      'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "       'mu': 2.0,\n",
       "       'sigma': 0.0,\n",
       "       'tau': 5.0,\n",
       "       'n': 1,\n",
       "       'seed': None}},\n",
       "     'lin_nonlin_transfer_function_filename': '/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/neurolib/models/multimodel/builder/../../aln/aln-precalc/quantities_cascade.h5'},\n",
       "    {'index': 1,\n",
       "     'name': 'ALN inhibitory neural mass',\n",
       "     'mass_type': 'INH',\n",
       "     'num_state_variables': 6,\n",
       "     'num_noise_variables': 1,\n",
       "     'state_variable_names': ['I_mu',\n",
       "      'I_syn_mu_exc',\n",
       "      'I_syn_mu_inh',\n",
       "      'I_syn_sigma_exc',\n",
       "      'I_syn_sigma_inh',\n",
       "      'r_mean'],\n",
       "     'params': {'Ke': 800.0,\n",
       "      'Ki': 200.0,\n",
       "      'c_gl': 0.4,\n",
       "      'Ke_gl': 250.0,\n",
       "      'tau_se': 2.0,\n",
       "      'tau_si': 5.0,\n",
       "      'sigmai_ext': 1.5,\n",
       "      'Jie_max': 2.6,\n",
       "      'Jii_max': -1.64,\n",
       "      'C': 200.0,\n",
       "      'gL': 10.0,\n",
       "      'ext_inh_current': 0.0,\n",
       "      'ext_inh_rate': 0.0,\n",
       "      'lambda': 10.0,\n",
       "      'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "       'mu': 0.5,\n",
       "       'sigma': 0.0,\n",
       "       'tau': 5.0,\n",
       "       'n': 1,\n",
       "       'seed': None}},\n",
       "     'lin_nonlin_transfer_function_filename': '/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/neurolib/models/multimodel/builder/../../aln/aln-precalc/quantities_cascade.h5'}],\n",
       "   'local_connectivity': array([[0.24691358, 0.75757576],\n",
       "          [0.23076923, 1.52439024]]),\n",
       "   'local_delays': array([[4., 2.],\n",
       "          [4., 2.]])},\n",
       "  {'index': 1,\n",
       "   'name': 'Thalamic mass model node',\n",
       "   'num_masses': 2,\n",
       "   'num_num_state_variables': 17,\n",
       "   'num_noise_variables': 2,\n",
       "   'masses': [{'index': 0,\n",
       "     'name': 'Thalamocortical relay mass',\n",
       "     'mass_type': 'EXC',\n",
       "     'num_state_variables': 10,\n",
       "     'num_noise_variables': 1,\n",
       "     'state_variable_names': ['V',\n",
       "      'Ca',\n",
       "      'h_T',\n",
       "      'm_h1',\n",
       "      'm_h2',\n",
       "      's_e',\n",
       "      's_i',\n",
       "      'ds_e',\n",
       "      'ds_i',\n",
       "      'r_mean'],\n",
       "     'params': {'tau': 20.0,\n",
       "      'Q_max': 0.4,\n",
       "      'theta': -58.5,\n",
       "      'sigma': 6.0,\n",
       "      'C1': 1.8137993642,\n",
       "      'C_m': 1.0,\n",
       "      'gamma_e': 0.07,\n",
       "      'gamma_r': 0.1,\n",
       "      'g_L': 1.0,\n",
       "      'g_GABA': 1.0,\n",
       "      'g_AMPA': 1.0,\n",
       "      'g_LK': 0.018,\n",
       "      'g_T': 3.0,\n",
       "      'g_h': 0.062,\n",
       "      'E_AMPA': 0.0,\n",
       "      'E_GABA': -70.0,\n",
       "      'E_L': -70.0,\n",
       "      'E_K': -100.0,\n",
       "      'E_Ca': 120.0,\n",
       "      'E_h': -40.0,\n",
       "      'alpha_Ca': -5.18e-05,\n",
       "      'tau_Ca': 10.0,\n",
       "      'Ca_0': 0.00024,\n",
       "      'k1': 25000000.0,\n",
       "      'k2': 0.0004,\n",
       "      'k3': 0.1,\n",
       "      'k4': 0.001,\n",
       "      'n_P': 4.0,\n",
       "      'g_inc': 2.0,\n",
       "      'ext_current': 0.0,\n",
       "      'lambda': 10.0,\n",
       "      'input_0': {'type': 'OrnsteinUhlenbeckProcess',\n",
       "       'mu': 0.0,\n",
       "       'sigma': 0.0,\n",
       "       'tau': 5.0,\n",
       "       'n': 1,\n",
       "       'seed': None}}},\n",
       "    {'index': 1,\n",
       "     'name': 'Thalamic reticular nuclei mass',\n",
       "     'mass_type': 'INH',\n",
       "     'num_state_variables': 7,\n",
       "     'num_noise_variables': 1,\n",
       "     'state_variable_names': ['V',\n",
       "      'h_T',\n",
       "      's_e',\n",
       "      's_i',\n",
       "      'ds_e',\n",
       "      'ds_i',\n",
       "      'r_mean'],\n",
       "     'params': {'tau': 20.0,\n",
       "      'Q_max': 0.4,\n",
       "      'theta': -58.5,\n",
       "      'sigma': 6.0,\n",
       "      'C1': 1.8137993642,\n",
       "      'C_m': 1.0,\n",
       "      'gamma_e': 0.07,\n",
       "      'gamma_r': 0.1,\n",
       "      'g_L': 1.0,\n",
       "      'g_GABA': 1.0,\n",
       "      'g_AMPA': 1.0,\n",
       "      'g_LK': 0.018,\n",
       "      'g_T': 2.3,\n",
       "      'E_AMPA': 0.0,\n",
       "      'E_GABA': -70.0,\n",
       "      'E_L': -70.0,\n",
       "      'E_K': -100.0,\n",
       "      'E_Ca': 120.0,\n",
       "      'ext_current': 0.0,\n",
       "      'lambda': 10.0,\n",
       "      'input_0': {'type': 'ZeroInput', 'n': 1, 'seed': None}}}],\n",
       "   'local_connectivity': array([[ 0.,  5.],\n",
       "          [ 3., 25.]]),\n",
       "   'local_delays': array([[0., 0.],\n",
       "          [0., 0.]])}],\n",
       " 'connectivity': array([[0.  , 0.15],\n",
       "        [1.2 , 0.  ]]),\n",
       " 'delays': array([[ 0., 13.],\n",
       "        [13.,  0.]])}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# lets check what we have\n",
    "SC = np.array([[0.0, 0.15], [1.2, 0.0]])\n",
    "delays = np.array([[0.0, 13.0], [13.0, 0.0]]) # thalamocortical delay = 13ms\n",
    "thalamocortical = MultiModel(ALNThalamusMiniNetwork(connectivity_matrix=SC, delay_matrix=delays))\n",
    "# original `MultiModel` instance is always accessible as `MultiModel.model_instance`\n",
    "display(thalamocortical.model_instance.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "intended-salon",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nikola/.virtualenvs/neurolib/lib/python3.7/site-packages/jitcdde/_jitcdde.py:1491: UserWarning: Your input past does not begin at t=0 but at t=1.0. Values before the beginning of the past will be extrapolated. You very likely do not want this.\n",
      "  warn(f\"Your input past does not begin at t=0 but at t={input[0].time}. Values before the beginning of the past will be extrapolated. You very likely do not want this.\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default integration parameters.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2000/2000 [00:00<00:00, 2994.08it/s]\n"
     ]
    }
   ],
   "source": [
    "# fix parameters for interesting regime\n",
    "thalamocortical.params[\"*g_LK\"] = 0.032 # K-leak conductance in thalamus\n",
    "thalamocortical.params[\"ALNThlmNet.ALNNode_0.ALNMassEXC_0.a\"] = 0.0 # no firing rate adaptation\n",
    "thalamocortical.params[\"*b\"] = 15.0 # spike adaptation\n",
    "thalamocortical.params[\"*tauA\"] = 1000.0 # slow adaptation timescale\n",
    "thalamocortical.params[\"*EXC*mu\"] = 3.4 # background excitation to ALN\n",
    "thalamocortical.params[\"*INH*mu\"] = 3.5 # background inhibition to ALN\n",
    "thalamocortical.params[\"*ALNMass*input*sigma\"] = 0.05 # noise in ALN\n",
    "thalamocortical.params[\"*TCR*input*sigma\"] = 0.005 # noise in thalamus\n",
    "thalamocortical.params[\"*input*tau\"] = 5.0 # timescale of OU process\n",
    "\n",
    "# number low for testing:\n",
    "thalamocortical.params[\"duration\"] = 2000. \n",
    "# use: thalamocortical.params[\"duration\"] = 20000. # 20 seconds simulation\n",
    "thalamocortical.params[\"sampling_dt\"] = 1.0\n",
    "thalamocortical.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "confused-reaction",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'time [sec]')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, axs = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(12, 6))\n",
    "axs[0].plot(thalamocortical.t, thalamocortical.r_mean_EXC[0, :].T)\n",
    "axs[0].set_ylabel(\"ALN firing rate [kHz]\")\n",
    "axs[1].plot(thalamocortical.t, thalamocortical.r_mean_EXC[1, :].T, color=\"C1\")\n",
    "axs[1].set_ylabel(\"thalamus firing rate [kHz]\")\n",
    "axs[1].set_xlabel(\"time [sec]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "graphic-christianity",
   "metadata": {},
   "source": [
    "We can nicely see the interplay between cortical UP and DOWN states (with UP state being dominant and irregular DOWN state excursions) and thalamic spindles.\n",
    "\n",
    "Combining different models might seem hard at first, but it is actually kind of intuitive and works as you would connect models with pen and paper.\n",
    "The only necessary thing is to define and initialize individual nodes in the network (done in `__init__` function) and then specify the type of coupling between these nodes (in `_sync()` function). That's it!\n",
    "\n",
    "For more information on how to build a network and for a deeper understanding of how exactly `MultiModel` works, please check out our following example, where we will build the Jansen-Rit network from scratch!"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "6782b767ef25d51763971ef6ad1a9352effd271a7bead29d382d3d8cd90146d0"
  },
  "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}