{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Tutorial: Single Cell Simulation with Current Injection (with BioNet)\n", "\n", "In this example we will build a network consisting of a single biophysically detailed cell, run a short simulation with a current injection at the soma of the cell, and then look at the output of spikes, membrane potential and calcium flux.\n", "\n", "\n", "**Note** - scripts and files for running this tutorial can be found in the directory [sources/chapter01/](https://github.com/AllenInstitute/bmtk/tree/develop/docs/tutorial/sources/chapter01)\n", "\n", "**requirements:**\n", "* Python 2.7, 3.6+\n", "* bmtk\n", "* NEURON 7.4+\n", "\n", "For more information on the BioNet Simulator, please see the [BioNet Overview](https://alleninstitute.github.io/bmtk/bionet.html).\n", "\n", "For more information on BMTK and SONATA format, please see the [Overview of BMTK](https://alleninstitute.github.io/bmtk/user_guide.html) and [Network Builder](https://alleninstitute.github.io/bmtk/builder.html) pages." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Building the network\n", "\n", "The first step is to use the bmtk Network Builder to create and save the network. First we instantiate a network with a name of our choosing (since throughout this tutorial we will use cell models from the mouse cortex, let's call our network 'mcortex'). \n", "\n", "Once we have initialized a network object, we can add a single node by calling the `add_nodes` method." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from bmtk.builder.networks import NetworkBuilder\n", "\n", "net = NetworkBuilder('mcortex')\n", "net.add_nodes(\n", " cell_name='Scnn1a_473845048',\n", " potential='exc',\n", " model_type='biophysical',\n", " model_template='ctdb:Biophys1.hoc',\n", " model_processing='aibs_perisomatic',\n", " dynamics_params='472363762_fit.json',\n", " morphology='Scnn1a_473845048_m.swc'\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Some of the parameters used to create the node are optional and only for our benefit. Others are necessary for when we will eventually run a simulation:\n", "* *cell_name* (optional) - Name/type of cell we will be modeling.\n", "* *potential* (optional) - Use to indicate that it is an excitatory type cell.\n", "* *model_type* - Used by the simulator to indicate that we are using a biophysical cell.\n", "* *model template* - NEURON .hoc file, NeuroML file, or other template used in the creation of a cell/node object.\n", "* *model_processing* - A custom function used by the simulator to load the model into NEURON using Allen Cell Types files for perisomatic models.\n", "* *dynamics_params* - Model parameters. In the example used here, the file will be downloaded from the Allen Cell Types Database. \n", "* *morphology* - Model morphology. In the example used here, the file will be downloaded from the Allen Cell Types Database.\n", "\n", " \n", "### Building and saving\n", "The final thing to do is to build and save the network. If successful, we should see a combination of HDF5 and CSV files in the './network' directory. These files are used to describe the network and can be saved, stored and run at a later time.\n", "\n", "First, it's a good idea to remove any old files in the \"network\" folder so they don't interfere with the current simulation:\n", "\n", "```bash\n", "$ rm -r sim_ch01/network \n", "```\n", " \n", "If you get the output:\n", "\n", "```rm: cannot remove sim_ch01/network/*: No such file or directory```\n", "\n", "It's OK. Keep going." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "net.build()\n", "net.save_nodes(output_dir='sim_ch01/network')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Use the NetworkBuilder `nodes()` method to show that a node with our parameters was created:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'cell_name': 'Scnn1a_473845048', 'potential': 'exc', 'model_type': 'biophysical', 'model_template': 'ctdb:Biophys1.hoc', 'model_processing': 'aibs_perisomatic', 'dynamics_params': '472363762_fit.json', 'morphology': 'Scnn1a_473845048_m.swc', 'node_type_id': 100, 'node_id': 0}\n" ] } ], "source": [ "for node in net.nodes():\n", " print(node)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Setting up the simulator environment\n", "\n", "Now that the network has been built, we can use the BioNet simulator to setup and run it using NEURON as the backend. The easiest ways to do this is to copy and modify an [existing simulation setup](https://github.com/AllenInstitute/bmtk/tree/develop/docs/examples/bio_14cells), or use the ```bmtk.utils.sim_setup``` script which can be called from the command-line:\n", "\n", "```bash\n", "$ python -m bmtk.utils.sim_setup --report-vars v,cai \\\n", " --network sim_ch01/network/ \\\n", " --iclamp 0.12,500.0,1000.0 \\\n", " --dt 0.1 --tstop 2000.0 \\\n", " --include-examples \\\n", " --compile-mechanisms \\\n", " bionet sim_ch01\n", "```\n", "\n", "Or call the function directly in Python:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from bmtk.utils.sim_setup import build_env_bionet\n", "\n", "build_env_bionet(\n", " base_dir='sim_ch01', # Where to save the scripts and config files \n", " config_file='config.json', # Where main config will be saved.\n", " network_dir='network', # Location of directory containing network files\n", " tstop=2000.0, dt=0.1, # Run a simulation for 2000 ms at 0.1 ms intervals\n", " report_vars=['v', 'cai'], # Tells simulator we want to record membrane potential and calcium traces\n", " current_clamp={ # Creates a step current from 500.0 ms to 1500.0 ms \n", " 'amp': 0.120,\n", " 'delay': 500.0,\n", " 'duration': 1000.0\n", " },\n", " include_examples=True, # Copies components files for tutorial examples\n", " compile_mechanisms=True # Will try to compile NEURON mechanisms\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "**Warning**: You may see an error that it failed while trying to compile the NEURON mechanisms - especially if Jupyter is unable to find your NEURON environment path. If this happens you will need to manually compile the mechanisms: \n", "\n", "```\n", " cd sim_ch01/components/mechanisms \n", " nrnivmodl modfiles\n", "```\n", "
\n", "\n", "\n", "\n", "This will create the directory **sim_ch01** (feel free to give it a different name or set it to a different locations) with a number of new files and folders. Some of the more important ones include:\n", "* **circuit_config.json** - A configuration file that contains the location of the network files we created above, and the location of neuron and synaptic models, templates, morphologies and mechanisms required to build and instantiate individual cell models.\n", "\n", "\n", "* **simulation_config.json** - contains information about the simulation. Including initial conditions and run-time configuration (_run_ and _conditions_). In the _inputs_ section we define what external sources we will use to drive the network (in this case a current clamp). In the _reports_ section we define the variables (somatic membrane potential and calcium level) that will be recorded during the simulation. \n", "\n", "\n", "* **components/biophysical_neuron_models/472363762_fit.json** - The parameter file for the cell we're modeling. Originally [downloaded from the Allen Cell Types Database](http://celltypes.brain-map.org/neuronal_model/download/482934212)\n", "\n", "\n", "* **components/biophysical_neuron_models/Scnn1a_473845048_m.swc** - The morphology file for our cell. Originally [downloaded from the Allen Cell Types Database](http://celltypes.brain-map.org/neuronal_model/download/482934212)\n", "\n", "\n", "Modifying these files with a text editor, or swapping out different parameter or morphologies, allows for changing the simulation without extra programming." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Running the simulation\n", "\n", "Once our config file is setup we can run a simulation either through the command line:\n", "```bash\n", "$ cd sim_ch01\n", "$ python run_bionet.py config.json\n", "```\n", "\n", "or through the script:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:11,159 [INFO] Created log file\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Created log file\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "numprocs=1\n", "2022-07-28 12:16:11,226 [INFO] Building cells.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Building cells.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:11,393 [INFO] Building recurrent connections\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Building recurrent connections\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:11,402 [INFO] Running simulation for 2000.000 ms with the time step 0.100 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Running simulation for 2000.000 ms with the time step 0.100 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:11,403 [INFO] Starting timestep: 0 at t_sim: 0.000 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Starting timestep: 0 at t_sim: 0.000 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:11,404 [INFO] Block save every 5000 steps\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Block save every 5000 steps\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:11,692 [INFO] step:5000 t_sim:500.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:5000 t_sim:500.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:12,006 [INFO] step:10000 t_sim:1000.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:10000 t_sim:1000.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:12,299 [INFO] step:15000 t_sim:1500.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:15000 t_sim:1500.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:12,603 [INFO] step:20000 t_sim:2000.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:20000 t_sim:2000.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-07-28 12:16:12,627 [INFO] Simulation completed in 1.225 seconds \n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Simulation completed in 1.225 seconds \n" ] } ], "source": [ "from bmtk.simulator import bionet\n", "\n", "conf = bionet.Config.from_json('sim_ch01/config.json')\n", "conf.build_env()\n", "conf\n", "net = bionet.BioNetwork.from_config(conf)\n", "sim = bionet.BioSimulator.from_config(conf, network=net)\n", "sim.run()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "**Warning**: If you get the following error:\n", "\n", "\n", "```\n", " argument not a density mechanism name\n", "```\n", "\n", "you will need to compile the NEURON mechanisms:\n", "\n", "\n", "```\n", " cd sim_ch01/components/mechanisms\n", " nrnivmodl modfiles\n", " \n", "```\n", "
\n", "\n", "A quick breakdown of the script:\n", "```python\n", "conf = config.from_json('config.json')\n", "io.setup_output_dir(conf)\n", "nrn.load_neuron_modules(conf)\n", "```\n", "This section loads the configuration file. It sets up the output directory and files for writing during the simulation, and loads the NEURON mechanisms needed by the cell model(s) during the simulation.\n", "\n", "```python\n", "net = bionet.BioNetwork.from_config(conf)\n", "```\n", "Creates a NEURON representation of the network, including cell models that have been converted into their NEURON equivalents.\n", "\n", "```python\n", "sim = Simulation.from_config(conf, network=net)\n", "sim.run()\n", "```\n", "Sets up and runs the NEURON simulation. When finished, the outputs (e.g., spike times, membrane potential, and Ca2+ concentration) will be saved into the output directory as specified in the config.\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Analyzing the run\n", "\n", "The results of the simulation are placed into various files as specified in the \"output\" section of the config file. We can change this by editing the config file before run-time if required.\n", "\n", "All simulations will save the spike times of the network cells. These are saved in CSV format (**output/spikes.txt**) or HDF5 format (**output/spikes.h5**). To get the table of spike times for our single-cell network we can run the following method from the analyzer (node_id 0 corresponds to our single cell)." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
timestampsnode_idspopulation
0554.80mcortex
11379.50mcortex
21319.50mcortex
31259.50mcortex
41199.50mcortex
51139.70mcortex
61079.90mcortex
71020.40mcortex
8961.20mcortex
9902.60mcortex
10844.90mcortex
11788.70mcortex
12734.70mcortex
13683.90mcortex
14637.10mcortex
15594.40mcortex
161439.60mcortex
171499.70mcortex
\n", "
" ], "text/plain": [ " timestamps node_ids population\n", "0 554.8 0 mcortex\n", "1 1379.5 0 mcortex\n", "2 1319.5 0 mcortex\n", "3 1259.5 0 mcortex\n", "4 1199.5 0 mcortex\n", "5 1139.7 0 mcortex\n", "6 1079.9 0 mcortex\n", "7 1020.4 0 mcortex\n", "8 961.2 0 mcortex\n", "9 902.6 0 mcortex\n", "10 844.9 0 mcortex\n", "11 788.7 0 mcortex\n", "12 734.7 0 mcortex\n", "13 683.9 0 mcortex\n", "14 637.1 0 mcortex\n", "15 594.4 0 mcortex\n", "16 1439.6 0 mcortex\n", "17 1499.7 0 mcortex" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from bmtk.analyzer.spike_trains import to_dataframe\n", "\n", "to_dataframe(config_file='sim_ch01/config.json')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When setting up the environment and config file in section 2, \"Setting up the simulator environment\", we specified `cell_vars=['v', 'cai']`. This indicates to the simulator to also record membrane potential and Ca2+ level. Other variables can also be specified when building the simulator environment as long as they are supported in NEURON." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from bmtk.analyzer.compartment import plot_traces\n", "\n", "_ = plot_traces(config_file='sim_ch01/config.json', node_ids=[0], report_name='v_report')\n", "_ = plot_traces(config_file='sim_ch01/config.json', node_ids=[0], report_name='cai_report')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Additional information\n", "\n", "\n", "### Changing run-time parameters\n", "\n", "\n", "By making changes to the config file, we can change the conditions and simulation parameters without having to rebuild the network, modify parameter files or change our run_bionet script. In fact we can iteratively run multiple simulations without any extra coding, only a text editor to change the JSON file.\n", "\n", "The run section of the **config.json** file contains most of the parameters unique to the simulation:\n", "```json\n", "{\n", " \"run\": {\n", " \"dL\": 20,\n", " \"nsteps_block\": 5000, \n", " \"spike_threshold\": -15,\n", " \"tstop\": 2000.0, \n", " \"dt\": 0.1\n", " }\n", "}\n", "```\n", "* *tstop* - Simulation runtime in milliseconds.\n", "* *dt* - Time steps of the simulation. Decreasing dt should increase accuracy of firing dynamics, but also increase the time it takes to complete.\n", "* *spike_threshold* - Used to determine when to count an action potential.\n", "* *dL* - Length of segments in a section. The number of segments will be forced to an odd number so the actual length may vary by one.\n", "\n", "Through the conditions section we can adjust the simulation temperature (in degrees Celsius) and the initial membrane potential of the cells (in mV):\n", "```json\n", "{\n", " \"conditions\": {\n", " \"celsius\": 34.0, \n", " \"v_init\": -80\n", " }\n", "}\n", "```\n", "\n", "And lastly, the input section lets us control stimulus onto the network. There are a number of different options which will be explained in the following tutorials. But even with a simple current injection we can adjust the amplitude, delay and stimulation duration and measure the effect on the cell.\n", "```json\n", "{\n", " \"inputs\": {\n", " \"current_clamp\": {\n", " \"input_type\": \"current_clamp\",\n", " \"module\": \"IClamp\",\n", " \"node_set\": \"all\",\n", " \"amp\": 0.120,\n", " \"delay\": 500.0,\n", " \"duration\": 1000.0\n", " }\n", " }\n", "}\n", "```\n", "We can even add multiple injections:\n", "```json\n", "{\n", " \"inputs\": {\n", " \t\"cclamp1\": {\n", " \"input_type\": \"current_clamp\",\n", " \"module\": \"IClamp\",\n", " \"node_set\": \"all\",\n", " \"amp\": 0.150,\n", " \"delay\": 0.0,\n", " \"duration\": 400.0\n", " },\n", " \n", " \"cclamp2\": {\n", " \"input_type\": \"current_clamp\",\n", " \"module\": \"IClamp\",\n", " \"node_set\": \"all\",\n", " \"amp\": 0.300,\n", " \"delay\": 500.0,\n", " \"duration\": 400.0\n", " },\n", " \n", " \"cclamp3\": {\n", " \"input_type\": \"current_clamp\",\n", " \"module\": \"IClamp\",\n", " \"node_set\": \"all\",\n", " \"amp\": 0.450,\n", " \"delay\": 1000.0,\n", " \"duration\": 400.0\n", " }\n", " }\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Changing cell models\n", "When building the network we defined the cell model and morphology through the 'dynamics_params' and 'morphology_file' options. After building and saving the network, these values were saved in the node-types CSV file:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
node_type_idmodel_templatemorphologymodel_processingpotentialmodel_typedynamics_paramscell_name
0100ctdb:Biophys1.hocScnn1a_473845048_m.swcaibs_perisomaticexcbiophysical472363762_fit.jsonScnn1a_473845048
\n", "
" ], "text/plain": [ " node_type_id model_template morphology model_processing \\\n", "0 100 ctdb:Biophys1.hoc Scnn1a_473845048_m.swc aibs_perisomatic \n", "\n", " potential model_type dynamics_params cell_name \n", "0 exc biophysical 472363762_fit.json Scnn1a_473845048 " ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "pd.read_csv('sim_ch01/network/mcortex_node_types.csv', sep=' ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want to run the simulation on a different cell model, all we have to do is: \n", "1. Download new json parameters and swc morphology files into the \"components/biophysical_neuron_models\" and \"components/morphologies\" folders\n", "2. Open **mcortex_node_types.csv** in a text editor and update the 'morphology_file' and 'params_file' parameters accordingly.\n", "\n", "In our simple one-cell example, it is likely faster to just rebuild the network. However the advantage of the use of the node types becomes clear once we start dealing with a larger network. For example we may have a network of hundreds of thousands of individual cells with tens of thousands of Scnn1a type cells. The process of adjusting/changing the Scnn1a parameter in the CSV file then starting another simulation takes only seconds, whereas rebuilding the entire network may take hours." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "anaconda-cloud": {}, "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.10.13" } }, "nbformat": 4, "nbformat_minor": 4 }