humam_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1868164b",
   "metadata": {},
   "source": [
    "# Multi-Scale Spiking Network Model of Human Cerebral Cortex"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1df3ec9f",
   "metadata": {},
   "source": [
    "**Model overview**: The model comprises all 34 areas of the Desikan-Killiany parcellation in one hemisphere of human cerebral cortex. Each area is modeled by a column with $\\mathrm{1\\mathrm{mm^{2}}}$ cortical surface. Within each column, the full number of neurons and synapses based on anatomical data is included. In total, this leads to 3.47 million neurons and 42.8 billion synapses. Both the intrinsic and the cortico-cortical connectivity are layer- and population-specific."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edec8345-aec1-419e-b9e3-7f612aff8262",
   "metadata": {},
   "source": [
    "<img src=\"./figures/model_overview.png\" alt=\"Model overview\" width=\"1000\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8379187e",
   "metadata": {},
   "source": [
    "# Down-scaled human multi-area model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4a649cc-3b68-49e4-b2b6-6f29f13a6d9c",
   "metadata": {},
   "source": [
    "This code in this notebook implements the down-scaled version of the multi-scale, spiking network model of human cortex developed at the Institute of Advanced Simulation (IAS-6), Research Center Jülich. The model has been documented in the following publication:\n",
    "\n",
    "- <a id=\"mainRef\"></a>[1] Pronold, J., Meegen, A. van, Shimoura, R. O., Vollenbröker, H., Senden, M., Hilgetag, C. C., Bakker, R., & Albada, S. J. (2024). Multi-scale spiking network model of human cerebral cortex. Cerebral Cortex. [https://doi.org/10.1093/cercor/bhae409](https://doi.org/10.1093/cercor/bhae409)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b952d0ea",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Notebook Outline <a class=\"anchor\" id=\"toc\"></a>\n",
    "* [S0. Configuration](#section_0)\n",
    "* [S1. Parameterization](#section_1)\n",
    "    * [1.1. Parameters to tune](#section_1_1)\n",
    "* [S2. Model Configuration, Instantiation and Simulation](#section_2)\n",
    "    * [2.1. Configuring model parameters](#section_2_1)\n",
    "    * [2.2. Instantiate a multi-area model](#section_2_2)\n",
    "    * [2.3. Predict firing rates from theory](#section_2_3)\n",
    "    * [2.4. Extract and visualize inter-areal connectivity](#section_2_3)\n",
    "    * [2.5. Run a simulation](#section_2_5)\n",
    "* [S3. Visualization of Network Dynamics](#section_3) \n",
    "    * [3.1. Mean firing rate over simulated populations](#section_3_1)\n",
    "    * [3.2. Instantaneous firing rate over simulated areas](#section_3_2)\n",
    "    * [3.3. Time-averaged firing rate over all populations](#section_3_3)\n",
    "    * [3.4. Network dynamics](#section_3_4)\n",
    "    * [3.5. Functional connectivity](#section_3_5)\n",
    "* [Additional Notes](#section_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d782e527",
   "metadata": {
    "tags": []
   },
   "source": [
    "## S0. Configuration <a class=\"anchor\" id=\"section_0\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96517739",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import importlib.util\n",
    "\n",
    "# Add the source directory to the system path\n",
    "sys.path.append('./src/')\n",
    "\n",
    "# Local application imports\n",
    "from helpers.snakemake import nested_dict_update, get_git_revision_hash\n",
    "from default_net_params import params as net_params\n",
    "from data_preprocessing.cytoarchitecture import NeuronNumbers\n",
    "from data_preprocessing.connectivity import SynapseNumbers\n",
    "from network import Network, networkDictFromDump\n",
    "from default_sim_params import params as sim_params\n",
    "from simulation import Simulation\n",
    "from simulation import simulationDictFromDump\n",
    "from analysis import Analysis\n",
    "from default_ana_params import params as ana_params\n",
    "\n",
    "# Configure Matplotlib to render plots inline\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c59710b5",
   "metadata": {},
   "source": [
    "**Note**: if needed, additional python packages can be installed via `!pip install <package_name>` and then imported in this section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85d30b75",
   "metadata": {},
   "outputs": [],
   "source": [
    "# If using the Kernel EBRAINS-24.04, install the following missing packages. Otherwise, comment out the following line.\n",
    "!pip install dicthash nnmt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27160ba8",
   "metadata": {},
   "source": [
    "Go back to [Notebook Outline](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df83f5ea-1c4b-44d3-9926-01786aa46e14",
   "metadata": {
    "tags": []
   },
   "source": [
    "## S1. Parameterization <a class=\"anchor\" id=\"section_1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30655817",
   "metadata": {},
   "source": [
    "### 1.1. Parameters to tune <a class=\"anchor\" id=\"section_1_1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9daf88e5-0d45-4529-a228-70c33900b05e",
   "metadata": {},
   "source": [
    "The values assigned for the following parameters are kept the same as in the paper except for the `scaling_factor`, which is set to 0.004 to enable the simulation of a down-scaled multi-area model with 2GB RAM. By default, it is set to 1.0 for simulating the full-scale model.\n",
    "\n",
    "The `scaling_factor` scales the number of neurons and synapses. The code first calculates the full-scale values from the methods described in [[1]](https://doi.org/10.1093/cercor/bhae409), then these values are adjusted accordingly with the factor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3367970c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set scaling parameters\n",
    "# value range/options: (0, 1.], change it to 1. to simulate the full-scale network\n",
    "scaling_factor = 0.004\n",
    "\n",
    "# Scaling factor for cortico-cortical connections (Chi_E) to excitatory neurons.\n",
    "# Chi = 0.0 removes long-range cortico-cortical connections.\n",
    "# Chi = 1.0 produces base version results in Pronold et al. (2024).\n",
    "# Chi = 2.5 produces best fit version results in Pronold et al. (2024).\n",
    "# obs: Chi to inhibitory neurons is set to 2.0 times the scaling factor for excitatory neurons.\n",
    "net_params['cc_scalingEtoE'] = 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68a3d0f9",
   "metadata": {},
   "source": [
    "**Note 1**: `cc_scalingEtoE` plays a crucial role in transitioning the network activity from the base to the best-fit version.  In the full-scale network, the base and best-fit versions activities are achieved when this parameter is set to `1.0` and `2.5`, respectively.\n",
    "\n",
    "* Base version: In this configuration, the inter-areal synaptic strengths are equal to the local synaptic strengths, representing a baseline level of connectivity.\n",
    "* Best-fit version: This configuration results in network activity that closely matches experimental data, achieved by increasing the inter-areal synaptic strengths relative to the local ones.\n",
    "\n",
    "**Note 2**: When the network is downscaled, the code will increase synaptic weights to compensate for the reduced number of synapses. Additionally, a DC current is added based on predicted firing rates from the base version."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1472e9c5",
   "metadata": {},
   "source": [
    "Go back to [Notebook Outline](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de4a6703",
   "metadata": {
    "tags": []
   },
   "source": [
    "## S2. Model Configuration, Instantiation and Simulation <a class=\"anchor\" id=\"section_2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9608b6d9-c7e4-4b2d-9c2b-0d43c6415b48",
   "metadata": {},
   "source": [
    "### 2.1. Configuring model parameters <a class=\"anchor\" id=\"section_2_1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56e2b6f6-d67a-4a74-973b-c8507a975bf8",
   "metadata": {},
   "source": [
    "We try our best not to confuse users with too many parameters. So, the few parameters tunned will be automatically assigned in this section to properly run the simulation. \n",
    "\n",
    "However, if you want to explore the model, you can alter other parameters related to the network or simulation configuration by passing them in the `net_params` and `sim_params` dictionaries below. If this is not the case, you can execute the cell the way it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9af04cb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get path to the output directory\n",
    "net_params['outpath'] = os.path.join(os.getcwd(), 'out', 'downscaled'+str(scaling_factor))\n",
    "outpath = net_params['outpath']\n",
    "\n",
    "# Get base path\n",
    "base_path = os.getcwd()\n",
    "\n",
    "# Set the scaling factor for the number of neurons and synapses\n",
    "net_params['N_scaling'] = scaling_factor\n",
    "net_params['K_scaling'] = scaling_factor\n",
    "\n",
    "# Mean fullscale firing rate to scale the firing rates of the neurons\n",
    "net_params['fullscale_rates'] = './simulated_data/base_theory_rates.pkl'\n",
    "\n",
    "# Scaling factor for cortico-cortical connections (Chi) to inhibitory neurons.\n",
    "# it is set to 2.0 times the scaling factor for excitatory neurons.\n",
    "# This keeps the stability of the network.\n",
    "net_params['cc_scalingEtoI'] = net_params['cc_scalingEtoE']*2.0\n",
    "\n",
    "# Set simulation parameters\n",
    "sim_params['t_sim'] = 2000.0        # Simulation time in ms\n",
    "sim_params['master_seed'] = 2903    # Seed for the random number generator\n",
    "num_threads = int(4)                # Number of threads to use for the simulation \n",
    "\n",
    "# Set plotting parameters\n",
    "ana_params['plotRasterArea']['low'] = 1600      # Lower bound of the area to plot the raster plot\n",
    "ana_params['plotRasterArea']['high'] = 2000     # Upper bound of the area to plot the raster plot\n",
    "ana_params['plotRasterArea']['fraction'] = 1.0  # Fraction of neurons to plot in the raster plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3b5f634-284d-4b7b-88f6-17d26fb7743c",
   "metadata": {},
   "source": [
    "Go back to [Notebook Outline](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fd58841",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 2.2. Generate connectivity matrix and define neuron numbers <a class=\"anchor\" id=\"section_2_2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9affb19d",
   "metadata": {},
   "source": [
    "In this section, we generate the connectivity matrix and define the neuron numbers for the down-scaled multi-area model of the human cerebral cortex. The `NeuronNumbers` class is used to calculate the number of neurons in the network based on the provided surface area and cytoarchitecture parameters. Similarly, the `SynapseNumbers` class calculates the number of synapses in the network using the neuron numbers and predictive connectomic parameters.\n",
    "\n",
    "The `Network` class is then instantiated with the neuron and synapse numbers, and the network configuration is saved to the output directory. The network hash is also generated for further reference.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d35078f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check if the network has already been created\n",
    "if os.path.exists(os.path.join(outpath, 'network_hash.txt')):\n",
    "\twith open(os.path.join(outpath, 'network_hash.txt'), 'r') as f:\n",
    "\t\tnet_hash = f.read()\n",
    "else:\n",
    "\t# Create NeuroNumbers class\n",
    "\t# This class calculates the number of neurons in the network\n",
    "\tNeuronNumberClass = NeuronNumbers(\n",
    "\t\tsurface_area=net_params['surface_area'],\n",
    "\t\t**net_params['cytoarchitecture_params']\n",
    "\t)\n",
    "\t# Create SynapseNumbers class\n",
    "\t# This class calculates the number of synapses in the network\n",
    "\tSynapseNumberClass = SynapseNumbers(\n",
    "\t\tNN=NeuronNumberClass,\n",
    "\t\t**net_params['predictive_connectomic_params']\n",
    "\t)\n",
    "\n",
    "\t# Get the number of neurons and synapses in the full-scale network for further reference\n",
    "\tfullscale_NN_SN = {\n",
    "\t\t'NN': NeuronNumberClass.getNeuronNumbers(),\n",
    "\t\t'SN': SynapseNumberClass.getSynapseNumbers()\n",
    "\t}\n",
    "\n",
    "\t# Create Network\n",
    "\t# This class prepares the network for simulation, including the initialization of the neurons and synapses\n",
    "\t# and the creation of the connectivity matrix. The scaling factors are applied here.\n",
    "\thumam = Network(NeuronNumberClass, SynapseNumberClass, net_params)\n",
    "\t# Extract the network dictionary\n",
    "\thumam.dump(outpath)\n",
    "\t# Get the network hash for further reference\n",
    "\tnet_hash = humam.getHash()\n",
    "\n",
    "\t# Save network hash to a file\n",
    "\twith open(os.path.join(outpath, 'network_hash.txt'), 'w') as f:\n",
    "\t\tf.write(net_hash)\n",
    "\n",
    "# Load the network dictionary\n",
    "net_folder = os.path.join(outpath, net_hash)\n",
    "net_dict = networkDictFromDump(net_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e2a4e42",
   "metadata": {},
   "source": [
    "**Note**: You may get messages about layers being dropped. This is part of the calculation of the full-scale numbers. The scaling factor is applied after this calculation, so these messages can be ignored."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91649c30",
   "metadata": {},
   "source": [
    "### 2.3. Predict firing rates from theory <a class=\"anchor\" id=\"section_2_3\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07cc84bf-dbcf-4ac3-b76e-ebe0886b4012",
   "metadata": {},
   "source": [
    "Note: the prediction may differ from the simulation results, especially in the presence of synchrony."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95be7398",
   "metadata": {},
   "outputs": [],
   "source": [
    "from figure_theory import meanfield_rate\n",
    "theo_rates = meanfield_rate(outpath, net_hash)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c361fa92-4f50-4519-9592-60a39888a12b",
   "metadata": {},
   "source": [
    "Go back to [Notebook Outline](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2062ddf3",
   "metadata": {},
   "source": [
    "### 2.4. Extract and visualize inter-areal connectivity <a class=\"anchor\" id=\"section_2_4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a7c09e0",
   "metadata": {},
   "source": [
    "The connectivity and neuron numbers are stored in the attributes of the model class. \n",
    "- Neuron numbers of all populations in each area are stored in `humam.net['neuron_numbers']` as a multi-index Pandas Series. The index is hierarchically organized as Area, Layer, Population.\n",
    "\n",
    "- Number of synapses can be accessed via `humam['synapses_internal']`.\n",
    "  Number of synapses that target neurons (rows) receive from source neurons (columns), organized as a multi-index Pandas DataFrame. The index is hierarchically organized as Area, Layer, Population."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b473f0e-ceca-47e1-9563-a613574497c4",
   "metadata": {},
   "source": [
    "The figure below shows the inter-areal connectivity of the model expressed as the total indegrees of each target area. It calculates the indegrees by dividing the number of synapses by the number of neurons and groups \n",
    "the subpopulations together by summing the indegrees for each area."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2750fb39",
   "metadata": {},
   "outputs": [],
   "source": [
    "from figure_connectivity_matrices import plot_connectivity_matrices\n",
    "try:\n",
    "\tplot_connectivity_matrices(net_dict, fullscale_NN_SN)\n",
    "except NameError:\n",
    "\tplot_connectivity_matrices(net_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e67f37e9-ec8d-4bb1-bd21-45e966f47ab6",
   "metadata": {},
   "source": [
    "Go back to [Notebook Outline](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c1cad59-81d0-4e24-ac33-13c4ca8c6dec",
   "metadata": {},
   "source": [
    "### 2.5. Run a simulation <a class=\"anchor\" id=\"section_2_5\"></a>\n",
    "\n",
    "Run the simulation, depending on the model parameter and downscale ratio, the running time varies largely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d8ae2b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check if the simulation has already run\n",
    "if os.path.exists(os.path.join(outpath, net_hash, 'sim_hash.txt')):\n",
    "\twith open(os.path.join(outpath, net_hash, 'sim_hash.txt'), 'r') as f:\n",
    "\t\tsim_hash = f.read()\n",
    "else:\n",
    "\t# Create Simulation class\n",
    "\tsim = Simulation(sim_params, net_dict)\n",
    "\t# Extract the simulation dictionary\n",
    "\tsim.dump(net_folder)\n",
    "\t# Get the simulation hash\n",
    "\tsim_hash = sim.getHash()\n",
    "\n",
    "\t# Set output directory according to hashes\n",
    "\t# and run the simulation\n",
    "\tdata_path = os.path.join(outpath, net_hash, sim_hash)\n",
    "\tsim.setup(data_path, num_threads)\n",
    "\tsim.simulate()\n",
    "\n",
    "\t# Save simulation hash to a file\n",
    "\twith open(os.path.join(outpath, net_hash, 'sim_hash.txt'), 'w') as f:\n",
    "\t\tf.write(sim_hash)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72a89aeb-78b9-4642-be0d-6de4d6c8f817",
   "metadata": {},
   "source": [
    "**Reminder**: The spike trains of simulated results are saved to the folder with path `./out/<net_hash>/<sim_hash>/spikes/`, where `<net_hash>` and `<sim_hash>` are generated in 2.2 and in this section respectively. All statistics describing network dynamics are computed from the saved spike trains."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd6e3232",
   "metadata": {},
   "source": [
    "Go back to [Notebook Outline](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb71c922",
   "metadata": {
    "tags": []
   },
   "source": [
    "## S3. Visualization of Network Dynamics <a class=\"anchor\" id=\"section_3\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21210e55",
   "metadata": {},
   "source": [
    "**Important**: As cited in [Section 1.1](#11-parameters-to-tune), the `cc_scalingEtoE` parameter is critical for shifting network activity between the base and best-fit versions. In the full-scale model, setting this parameter to `1.0` produces the base activity, while `2.5` yields the best-fit activity. However, in the downscaled version, the network dynamics may differ, and these specific parameter values may not achieve the same results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e41ac4de",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read simulation dict\n",
    "sim_folder = os.path.join(outpath, net_hash, sim_hash)\n",
    "sim_dict = simulationDictFromDump(sim_folder)\n",
    "\n",
    "# Create Analysis class and export it\n",
    "ana = Analysis(ana_params, net_dict, sim_dict, sim_folder, base_path)\n",
    "ana.dump(sim_folder)\n",
    "\n",
    "# Run the full analysis\n",
    "# ana.fullAnalysis()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38ddd973",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 3.1. Mean firing rate over simulated populations <a class=\"anchor\" id=\"section_3_1\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bea30fc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the mean firing rate over simulated populations\n",
    "mean_rates_per_pop = ana.meanFiringRate()\n",
    "print(\"Average firing rate: {:.2f} spikes/s\".format(mean_rates_per_pop.mean()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8aeb05fe",
   "metadata": {},
   "source": [
    "**Note**: In the downscaled model, the mean firing rate may differ from the full-scale version due to altered network dynamics. Downscaling can lead to higher firing rates and more synchronized activity. While the full-scale model typically has firing rates below 10 spikes per second, the downscaled version may exhibit higher rates due to fewer neurons and synapses and increased synaptic weights, affecting the balance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2714fd2b-df6e-45b9-a7f4-f240a8c65ecf",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 3.2. Instantaneous firing rate over simulated areas <a class=\"anchor\" id=\"section_3_2\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8c003a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "ana.plot_instantaneous_firing_rate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de0317c8-1fcd-405c-b0c9-36336aa1f3ad",
   "metadata": {},
   "source": [
    "### 3.3. Time-averaged firing rate over simulated populations <a class=\"anchor\" id=\"section_3_3\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6746ea4-91bd-44f5-acb6-83df15b05480",
   "metadata": {},
   "source": [
    "An overview of time-averaged firing rate over simulated populations encoded in colors with areas along the horizontal axis and populations along the vertical axis. Layers that are not present in the model for specific areas are represented by the \"X\" mark."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e72d781d",
   "metadata": {},
   "outputs": [],
   "source": [
    "ana.plot_average_rate_per_pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e91c436e-db94-4cd7-a531-29c032efeeae",
   "metadata": {},
   "source": [
    "### 3.4. Network dynamics <a class=\"anchor\" id=\"section_3_4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ab1e9e5-3eb8-40b2-a4e9-2e749978878d",
   "metadata": {},
   "source": [
    "Comparable figures in our publications: <br>\n",
    "1. Pronold, J., Meegen, A. van, Shimoura, R. O., Vollenbröker, H., Senden, M., Hilgetag, C. C., Bakker, R., & Albada, S. J. (2024). Multi-scale spiking network model of human cerebral cortex. Cerebral Cortex. [https://doi.org/10.1093/cercor/bhae409](https://doi.org/10.1093/cercor/bhae409).<br>\n",
    "   -**Fig 4.  Base version of the model.** <br>\n",
    "   -**Fig 6.  Resting state of the model with $\\chi = 2.5$ (best-fit state).**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad316b3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Areas in the network:\")\n",
    "for area in ana.net_dict['area_list']:\n",
    "    print(f\"- {area}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae19bcc3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set THREE areas to plot\n",
    "areas_to_plot = ['caudalanteriorcingulate', 'pericalcarine', 'fusiform']\n",
    "\n",
    "# Plot the raster plot for the selected areas\n",
    "ana.plot_raster_statistics(raster_areas=areas_to_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7bc8504",
   "metadata": {},
   "source": [
    "This figure displays neural activity and statistical summaries for selected cortical areas.\n",
    "\n",
    "Raster Plots (A, B, C): Show spiking activity in the selected areas. Each dot represents a spike, with blue for excitatory neurons and red for inhibitory neurons. The x-axis represents time (s), and the y-axis represents neuron populations.\n",
    "\n",
    "Box Plots (D, E, F): Summarize firing rates, CV of interspike intervals, and correlation coefficients . The x-axis shows the respective measure, and the y-axis lists neuron populations. Boxes represent the interquartile range, with whiskers indicating data range within 1.5 times the interquartile range."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b53058b5-c0bd-4837-8289-9226872317cc",
   "metadata": {},
   "source": [
    "### 3.5. Functional connectivity <a class=\"anchor\" id=\"section_3_5\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "013adaf8-af8b-470e-94f0-b69121d1ca2c",
   "metadata": {},
   "source": [
    "Comparison of area-level functional connectivity (FC) between the down-scaled HuMAM and human experimental data. (Left) FC of human resting-state fMRI (see Materials and methods in [\\[1\\]](https://doi.org/10.1093/cercor/bhae409)). (Right)  Simulated FC measured by the zero-time-lag correlation coefficient of synaptic input currents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4b25621-618d-4594-8cf7-9b9002837d69",
   "metadata": {},
   "outputs": [],
   "source": [
    "ana.plot_functional_connectivity()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef74ca3e-98dc-49c9-a4a0-2c640e29b1d9",
   "metadata": {},
   "source": [
    "Go back to [Notebook Outline](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb4bdea1-384f-41b3-8d8c-7bd568ae1537",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Additional Notes <a class=\"anchor\" id=\"section_4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd25cb76-31eb-4c06-9bf8-a0407967b141",
   "metadata": {},
   "source": [
    "1. Simulation data <br>\n",
    "The spike data of all simulated populations for all simulations are saved, by default, in `./out/<network_hash>/<simulation_hash>/spikes` where `<network_hash>` and `<simulation_hash>` can be accessed in the output of Sections [2.2](#22-generate-connectivity-matrix-and-define-neuron-numbers) and [2.5](#25-run-a-simulation) respectively.\n",
    "\n",
    "2. Statistics <br>\n",
    "The statistics of network dynamics computed from the spike trains can be found in `./out/<network_hash>/<simulation_hash>/<analysis_hash>`. You may calculate more statistics from the functions defined in `./src/analysis.py` to explore more about network dynamics."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae940386-f9ec-4556-93bb-f63c7053cbd3",
   "metadata": {},
   "source": [
    "Go back to [Notebook Outline](#toc)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "humam_nest3",
   "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}