{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 4: Muti-population recurrent network (with BioNet) \n",
    "\n",
    "Here we will create a heterogenous yet relatively small network consisting of hundreds of cells recurrently connected. All cells will belong to one of four \"cell-types\". Two of these cell types will be biophysically detailed cells, i.e. containing a full morphology and somatic and dendritic channels and receptors. The other two will be point-neuron models, which lack a full morphology or channels but still act to provide inhibitory and excitory dynamics.\n",
    "\n",
    "As input to drive the simulation, we will also create an external network of \"virtual cells\" that synapse directly onto our internal cells and provide spike trains stimulus\n",
    "\n",
    "**Note** - scripts and files for running this tutorial can be found in the directory [sources/chapter04/](sources/chapter04)\n",
    "\n",
    "requirements:\n",
    "* bmtk\n",
    "* NEURON 7.4+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Building the network\n",
    "\n",
    "#### cells\n",
    "\n",
    "This network will loosely resemble the mouse V1 cortical column. Along the center of the column will be a population of 50 biophysically detailed neurons: 40 excitatory Scnn1a cells and 10 inhibitory PV cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from bmtk.builder.networks import NetworkBuilder\n",
    "from bmtk.builder.auxi.node_params import positions_columinar, xiter_random\n",
    "\n",
    "net = NetworkBuilder(\"V1\")\n",
    "net.add_nodes(N=80, pop_name='Scnn1a',\n",
    "              positions=positions_columinar(N=80, center=[0, 50.0, 0], max_radius=30.0, height=100.0),\n",
    "              rotation_angle_yaxis=xiter_random(N=80, min_x=0.0, max_x=2*np.pi),\n",
    "              rotation_angle_zaxis=xiter_random(N=80, min_x=0.0, max_x=2*np.pi),\n",
    "              tuning_angle=np.linspace(start=0.0, stop=360.0, num=80, endpoint=False),\n",
    "              location='VisL4',\n",
    "              ei='e',\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",
    "\n",
    "net.add_nodes(N=20, pop_name='PV',\n",
    "              positions=positions_columinar(N=20, center=[0, 50.0, 0], max_radius=30.0, height=100.0),\n",
    "              rotation_angle_yaxis=xiter_random(N=20, min_x=0.0, max_x=2*np.pi),\n",
    "              rotation_angle_zaxis=xiter_random(N=20, min_x=0.0, max_x=2*np.pi),\n",
    "              location='VisL4',\n",
    "              ei='i',\n",
    "              model_type='biophysical',\n",
    "              model_template='ctdb:Biophys1.hoc',\n",
    "              model_processing='aibs_perisomatic',\n",
    "              dynamics_params='472912177_fit.json',\n",
    "              morphology='Pvalb_470522102_m.swc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To set the position and rotation of each cell, we use the built in function positions_columinar and xiter_random, which returns a list of values given the parameters. A user could set the values themselves using a list (or function that returns a list) of size N. The parameters like location, ei (potential), params_file, etc. are cell-type parameters, and will be used for all N cells of that type.\n",
    "\n",
    "The excitory cells are also given a tuning_angle parameter. An instrinsic \"tuning angle\" is a property found in some cells in the visual cortex. In this model, we will use this property to determine number of strenght of connections between subsets of cells by using custom functions. But in general most models will not have or use a tuning angle, but they may require some other parameter. In general, users can assign whatever custom parameters they want to cells and cell-types and use them as properties for creating connections and running simulations.\n",
    "\n",
    "Next we continue to create our point (integrate-and-fire) neurons. Notice they don't have properities like y/z rotation or morphology, as they wouldn't apply to point neurons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.add_nodes(N=200, pop_name='LIF_exc',\n",
    "              positions=positions_columinar(N=200, center=[0, 50.0, 0], min_radius=30.0, max_radius=60.0, height=100.0),\n",
    "              tuning_angle=np.linspace(start=0.0, stop=360.0, num=200, endpoint=False),\n",
    "              location='VisL4',\n",
    "              ei='e',\n",
    "              model_type='point_process',\n",
    "              model_template='nrn:IntFire1',\n",
    "              dynamics_params='IntFire1_exc_1.json')\n",
    "\n",
    "net.add_nodes(N=100, pop_name='LIF_inh',\n",
    "              positions=positions_columinar(N=100, center=[0, 50.0, 0], min_radius=30.0, max_radius=60.0, height=100.0),\n",
    "              location='VisL4',\n",
    "              ei='i',\n",
    "              model_type='point_process',\n",
    "              model_template='nrn:IntFire1',\n",
    "              dynamics_params='IntFire1_inh_1.json')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### connections\n",
    "\n",
    "Now we want to create connections between the cells. Depending on the model type, and whether or not the presynpatic \"source\" cell is excitory or inhibitory, we will have different synpatic model and parameters. Using the source and target filter parameters, we can create different connection types.\n",
    "\n",
    "To determine excitory-to-excitory connection matrix we want to use distance and tuning_angle property. To do this we create a customized function \"dist_tuning_connector\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import math\n",
    "\n",
    "def dist_tuning_connector(source, target, d_weight_min, d_weight_max, d_max, t_weight_min, t_weight_max, nsyn_min,\n",
    "                          nsyn_max):\n",
    "    if source['node_id'] == target['node_id']:\n",
    "        # Avoid self-connections.n_nodes\n",
    "        return None\n",
    "\n",
    "    r = np.linalg.norm(np.array(source['positions']) - np.array(target['positions']))\n",
    "    if r > d_max:\n",
    "        dw = 0.0\n",
    "    else:\n",
    "        t = r / d_max\n",
    "        dw = d_weight_max * (1.0 - t) + d_weight_min * t\n",
    "\n",
    "    if dw <= 0:\n",
    "        # drop the connection if the weight is too low\n",
    "        return None\n",
    "\n",
    "    # next create weights by orientation tuning [ aligned, misaligned ] --> [ 1, 0 ], Check that the orientation\n",
    "    # tuning property exists for both cells; otherwise, ignore the orientation tuning.\n",
    "    if 'tuning_angel' in source and 'tuning_angle' in target:\n",
    "\n",
    "        # 0-180 is the same as 180-360, so just modulo by 180\n",
    "        delta_tuning = math.fmod(abs(source['tuning_angle'] - target['tuning_angle']), 180.0)\n",
    "\n",
    "        # 90-180 needs to be flipped, then normalize to 0-1\n",
    "        delta_tuning = delta_tuning if delta_tuning < 90.0 else 180.0 - delta_tuning\n",
    "\n",
    "        t = delta_tuning / 90.0\n",
    "        tw = t_weight_max * (1.0 - t) + t_weight_min * t\n",
    "    else:\n",
    "        tw = dw\n",
    "\n",
    "    # drop the connection if the weight is too low\n",
    "    if tw <= 0:\n",
    "        return None\n",
    "\n",
    "    # filter out nodes by treating the weight as a probability of connection\n",
    "    if random.random() > tw:\n",
    "        return None\n",
    "\n",
    "    # Add the number of synapses for every connection.\n",
    "    # It is probably very useful to take this out into a separate function.\n",
    "    return random.randint(nsyn_min, nsyn_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This first two parameters of this function is \"source\" and \"target\" and are required for all custom connector functions. These are node objects which gives a representation of a single source and target cell, with properties that can be accessed like a python dictionary. When The Network Builder is creating the connection matrix, it will call this function for all possible source-target pairs. The user doesn't call this function directly.\n",
    "\n",
    "The remaining parameters are optional. Using these parameters, plus the distance and angles between source and target cells, this function determines the number of connections between each given source and target cell. If there are none you can return either None or 0.\n",
    "\n",
    "To create these connections we call add_edges method of the builder. We use the source and target parameter to filter out only excitory-to-excitory connections. We must also take into consideration the model type (biophysical or integrate-and-fire) of the target when setting parameters. We pass in the function throught the connection_rule parameter, and the function parameters (except source and target) through connection_params. (If our dist_tuning_connector function didn't have any parameters other than source and target, we could just not set connection_params)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bmtk.builder.connection_map.ConnectionMap at 0x7f4a8c95da10>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.add_edges(source={'ei': 'e'}, target={'pop_name': 'Scnn1a'},\n",
    "              connection_rule=dist_tuning_connector,\n",
    "              connection_params={'d_weight_min': 0.0, 'd_weight_max': 0.34, 'd_max': 300.0, 't_weight_min': 0.5,\n",
    "                                 't_weight_max': 1.0, 'nsyn_min': 3, 'nsyn_max': 7},\n",
    "              syn_weight=6.4e-05,\n",
    "              weight_function='gaussianLL',\n",
    "              weight_sigma=50.0,\n",
    "              distance_range=[30.0, 150.0],\n",
    "              target_sections=['basal', 'apical'],\n",
    "              delay=2.0,\n",
    "              dynamics_params='AMPA_ExcToExc.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "net.add_edges(source={'ei': 'e'}, target={'pop_name': 'LIF_exc'},\n",
    "              connection_rule=dist_tuning_connector,\n",
    "              connection_params={'d_weight_min': 0.0, 'd_weight_max': 0.34, 'd_max': 300.0, 't_weight_min': 0.5,\n",
    "                                 't_weight_max': 1.0, 'nsyn_min': 3, 'nsyn_max': 7},\n",
    "              syn_weight=0.0019,\n",
    "              weight_function='gaussianLL',\n",
    "              weight_sigma=50.0,\n",
    "              delay=2.0,\n",
    "              dynamics_params='instanteneousExc.json',\n",
    "              model_template='exp2syn')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly we create the other types of connections. But since either the source, target, or both cells will not have the tuning_angle parameter, we don't want to use dist_tuning_connector. Instead we can use the built-in distance_connector function which just creates connections determined by distance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bmtk.builder.connection_map.ConnectionMap at 0x7f4a8b3a3750>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from bmtk.builder.auxi.edge_connectors import distance_connector\n",
    "\n",
    "### Generating I-to-I connections\n",
    "net.add_edges(source={'ei': 'i'}, target={'ei': 'i', 'model_type': 'biophysical'},\n",
    "              connection_rule=distance_connector,\n",
    "              connection_params={'d_weight_min': 0.0, 'd_weight_max': 1.0, 'd_max': 160.0, 'nsyn_min': 3, 'nsyn_max': 7},\n",
    "              syn_weight=0.0002,\n",
    "              weight_function='wmax',\n",
    "              distance_range=[0.0, 1e+20],\n",
    "              target_sections=['somatic', 'basal'],\n",
    "              delay=2.0,\n",
    "              dynamics_params='GABA_InhToInh.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "net.add_edges(source={'ei': 'i'}, target={'ei': 'i', 'model_type': 'point_process'},\n",
    "              connection_rule=distance_connector,\n",
    "              connection_params={'d_weight_min': 0.0, 'd_weight_max': 1.0, 'd_max': 160.0, 'nsyn_min': 3, 'nsyn_max': 7},\n",
    "              syn_weight=0.00225,\n",
    "              weight_function='wmax',\n",
    "              delay=2.0,\n",
    "              dynamics_params='instanteneousInh.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "### Generating I-to-E connections\n",
    "net.add_edges(source={'ei': 'i'}, target={'ei': 'e', 'model_type': 'biophysical'},\n",
    "              connection_rule=distance_connector,\n",
    "              connection_params={'d_weight_min': 0.0, 'd_weight_max': 1.0, 'd_max': 160.0, 'nsyn_min': 3, 'nsyn_max': 7},\n",
    "              syn_weight=0.00018,\n",
    "              weight_function='wmax',\n",
    "              distance_range=[0.0, 50.0],\n",
    "              target_sections=['somatic', 'basal', 'apical'],\n",
    "              delay=2.0,\n",
    "              dynamics_params='GABA_InhToExc.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "net.add_edges(source={'ei': 'i'}, target={'ei': 'e', 'model_type': 'point_process'},\n",
    "              connection_rule=distance_connector,\n",
    "              connection_params={'d_weight_min': 0.0, 'd_weight_max': 1.0, 'd_max': 160.0, 'nsyn_min': 3, 'nsyn_max': 7},\n",
    "              syn_weight=0.009,\n",
    "              weight_function='wmax',\n",
    "              delay=2.0,\n",
    "              dynamics_params='instanteneousInh.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "### Generating E-to-I connections\n",
    "net.add_edges(source={'ei': 'e'}, target={'pop_name': 'PV'},\n",
    "              connection_rule=distance_connector,\n",
    "              connection_params={'d_weight_min': 0.0, 'd_weight_max': 0.26, 'd_max': 300.0, 'nsyn_min': 3, 'nsyn_max': 7},\n",
    "              syn_weight=0.00035,\n",
    "              weight_function='wmax',\n",
    "              distance_range=[0.0, 1e+20],\n",
    "              target_sections=['somatic', 'basal'],\n",
    "              delay=2.0,\n",
    "              dynamics_params='AMPA_ExcToInh.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "\n",
    "net.add_edges(source={'ei': 'e'}, target={'pop_name': 'LIF_inh'},\n",
    "              connection_rule=distance_connector,\n",
    "              connection_params={'d_weight_min': 0.0, 'd_weight_max': 0.26, 'd_max': 300.0, 'nsyn_min': 3, 'nsyn_max': 7},\n",
    "              syn_weight=0.0043,\n",
    "              weight_function='wmax',\n",
    "              delay=2.0,\n",
    "              dynamics_params='instanteneousExc.json',\n",
    "              model_template='exp2syn')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we build the network (this may take a bit of time since it's essentially iterating over all 400x400 possible connection combinations), and save the nodes and edges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.build()\n",
    "net.save_nodes(output_dir='sim_ch04/network')\n",
    "net.save_edges(output_dir='sim_ch04/network')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building external network\n",
    "\n",
    "Next we want to create an external network consisting of virtual cells that form a feedforward network onto our V1, which will provide input during the simulation. We will call this LGN, since the LGN is the primary input the layer 4 cells of the V1 (if we wanted to we could also create multiple external networks and run simulations on any number of them). \n",
    "\n",
    "First we build our LGN nodes. Then we must import the V1 network nodes, and create connections between LGN --> V1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bmtk.builder.networks import NetworkBuilder\n",
    "\n",
    "lgn = NetworkBuilder('LGN')\n",
    "lgn.add_nodes(N=500,\n",
    "              pop_name='tON',\n",
    "              potential='exc',\n",
    "              model_type='virtual')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, we will use a customized function to determine the number of connections between each source and target pair, however this time our connection_rule is a bit different\n",
    "\n",
    "In the previous example, our connection_rule function's first two arguments were the presynaptic and postsynaptic cells, which allowed us to choose how many synaptic connections between the pairs existed based on individual properties:\n",
    "```python\n",
    "def connection_fnc(source, target, ...):\n",
    "    source['param'] # presynaptic cell params\n",
    "    target['param'] # postsynaptic cell params\n",
    "    ...\n",
    "    return nsyns # number of connections between pair\n",
    "```\n",
    "\n",
    "But for our LGN --> V1 connection, we do things a bit differently. We want to make sure that for every source cell, there are a limited number of presynaptic targets. This is a not really possible with a function that iterates on a one-to-one basis. So instead we have a connector function who's first parameter is a list of all N source cell, and the second parameter is a single target cell. We return an array of integers, size N; which each index representing the number of synaptics between sources and the target. \n",
    "\n",
    "To tell the builder to use this schema, we must set iterator='all_to_one' in the add_edges method. (By default this is set to 'one_to_one'. You can also use 'one_to_all' iterator which will pass in a single source and all possible targets)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_source_cells(sources, target, nsources_min=10, nsources_max=30, nsyns_min=3, nsyns_max=12):\n",
    "    total_sources = len(sources)\n",
    "    nsources = np.random.randint(nsources_min, nsources_max)\n",
    "    selected_sources = np.random.choice(total_sources, nsources, replace=False)\n",
    "    syns = np.zeros(total_sources)\n",
    "    syns[selected_sources] = np.random.randint(nsyns_min, nsyns_max, size=nsources)\n",
    "    return syns\n",
    "\n",
    "lgn.add_edges(source=lgn.nodes(), target=net.nodes(pop_name='Scnn1a'),\n",
    "              iterator='all_to_one',\n",
    "              connection_rule=select_source_cells,\n",
    "              connection_params={'nsources_min': 10, 'nsources_max': 25},\n",
    "              syn_weight=4e-03,\n",
    "              weight_function='wmax',\n",
    "              distance_range=[0.0, 150.0],\n",
    "              target_sections=['basal', 'apical'],\n",
    "              delay=2.0,\n",
    "              dynamics_params='AMPA_ExcToExc.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "lgn.add_edges(source=lgn.nodes(), target=net.nodes(pop_name='PV1'),\n",
    "              connection_rule=select_source_cells,\n",
    "              connection_params={'nsources_min': 15, 'nsources_max': 30},\n",
    "              iterator='all_to_one',\n",
    "              syn_weight=0.001,\n",
    "              weight_function='wmax',\n",
    "              distance_range=[0.0, 1.0e+20],\n",
    "              target_sections=['somatic', 'basal'],\n",
    "              delay=2.0,\n",
    "              dynamics_params='AMPA_ExcToInh.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "lgn.add_edges(source=lgn.nodes(),  target=net.nodes(pop_name='LIF_exc'),\n",
    "              connection_rule=select_source_cells,\n",
    "              connection_params={'nsources_min': 10, 'nsources_max': 25},\n",
    "              iterator='all_to_one',\n",
    "              syn_weight= 0.045,\n",
    "              weight_function='wmax',\n",
    "              delay=2.0,\n",
    "              dynamics_params='instanteneousExc.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "lgn.add_edges(source=lgn.nodes(),  target=net.nodes(pop_name='LIF_inh'),\n",
    "              connection_rule=select_source_cells,\n",
    "              connection_params={'nsources_min': 15, 'nsources_max': 30},\n",
    "              iterator='all_to_one',\n",
    "              syn_weight=0.02,\n",
    "              weight_function='wmax',\n",
    "              delay=2.0,\n",
    "              dynamics_params='instanteneousExc.json',\n",
    "              model_template='exp2syn')\n",
    "\n",
    "\n",
    "lgn.build()\n",
    "lgn.save_nodes(output_dir='sim_ch04/network')\n",
    "lgn.save_edges(output_dir='sim_ch04/network')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Setting up BioNet\n",
    "\n",
    "#### file structure.\n",
    "\n",
    "Before running a simulation, we will need to create the runtime environment, including parameter files, run-script and configuration files. You can copy the files from an existing simuatlion, execute the following command:\n",
    "\n",
    "```bash\n",
    "$ python -m bmtk.utils.sim_setup  \\\n",
    "   --report-vars v                \\\n",
    "   --report-nodes 10,80           \\\n",
    "   --network sim_ch04/network     \\\n",
    "   --dt 0.1                       \\\n",
    "   --tstop 3000.0                 \\  \n",
    "   --include-examples             \\\n",
    "   --compile-mechanisms           \\ \n",
    "   bionet sim_ch04\n",
    "```\n",
    "\n",
    "$ python -m bmtk.utils.sim_setup --report-vars v --report-nodes 0,80,100,300 --network sim_ch04/network --dt 0.1 --tstop 3000.0  --include-examples --compile-mechanisms bionet sim_ch04\n",
    "\n",
    "or run it directly in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bmtk.utils.sim_setup import build_env_bionet\n",
    "\n",
    "build_env_bionet(base_dir='sim_ch04',      \n",
    "                 network_dir='sim_ch04/network',\n",
    "                 tstop=3000.0, dt=0.1,\n",
    "                 report_vars=['v'],     # Record membrane potential (default soma)\n",
    "                 include_examples=True,    # Copies components files\n",
    "                 compile_mechanisms=True   # Will try to compile NEURON mechanisms\n",
    "                )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will fill out the **sim_ch04** with all the files we need to get started to run the simulation. Of interest includes\n",
    "\n",
    "* **circuit_config.json** - A configuration file that contains the location of the network files we created above. Plus location of neuron and synpatic models, templates, morphologies and mechanisms required to build our 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). And in the _reports_ section we define the variables (soma membrane potential and calcium) that will be recorded during the simulation \n",
    "\n",
    "\n",
    "* **run_bionent.py** - A script for running our simulation. Usually this file doesn't need to be modified.\n",
    "\n",
    "\n",
    "* **components/biophysical_neuron_models/** - The parameter file for the cells we're modeling. Originally [downloaded from the Allen Cell Types Database](http://celltypes.brain-map.org/neuronal_model/download/482934212). These files were automatically copies over when we used the _include-examples_ directive. If using a differrent or extended set of cell models place them here\n",
    "\n",
    "\n",
    "* **components/biophysical_neuron_models/** - The morphology file for our cells. Originally [downloaded from the Allen Cell Types Database](http://celltypes.brain-map.org/neuronal_model/download/482934212) and copied over using the _include_examples_.\n",
    "\n",
    "\n",
    "* **components/point_neuron_models/** - The parameter file for our LIF_exc and LIF_inh cells.\n",
    "\n",
    "\n",
    "* **components/synaptic_models/** - Parameter files used to create different types of synapses.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### lgn input\n",
    "\n",
    "We need to provide our LGN external network cells with spike-trains so they can activate our recurrent network. Previously we showed how to do this by generating csv files. We can also use NWB files, which are a common format for saving electrophysiological data in neuroscience.\n",
    "\n",
    "We can use any NWB file generated experimentally or computationally, but for this example we will use a preexsting one. First download the file:\n",
    "```bash\n",
    " $ wget https://github.com/AllenInstitute/bmtk/raw/develop/docs/examples/NWB_files/lgn_spikes.nwb\n",
    "```\n",
    "or copy from [here](https://github.com/AllenInstitute/bmtk/tree/develop/docs/examples/spikes_inputs/lgn_spikes.nwb).\n",
    "\n",
    "\n",
    "Then we must edit the **simulation_config.json** file to tell the simulator to find the nwb file and which network to associate it with.\n",
    "\n",
    "```json\n",
    "\n",
    "\"inputs\": {\n",
    "    \"LGN_spikes\": {\n",
    "        \"input_type\": \"spikes\",\n",
    "        \"module\": \"nwb\",\n",
    "        \"input_file\": \"$BASE_DIR/lgn_spikes.nwb\",\n",
    "        \"node_set\": \"LGN\",\n",
    "        \"trial\": \"trial_0\"\n",
    "    }\n",
    "},\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Running the simulation\n",
    "\n",
    "\n",
    "We are close to running our simulation, however unlike in previous chapters we need a little more programming before we can begin. \n",
    "\n",
    "For most of the connections we added the parameter weight_function='wmax'. This is a built-in function that tells the simulator when creating a connection between two cells, just use the 'weight_max' value assigned to that given edge-type. \n",
    "\n",
    "However, when creating excitatory-to-excitatory connections we used weight_function='gaussianLL'. This is because we want to use the tuning_angle parameter, when avaiable, to determine the synaptic strength between two connections. First we create the function which takes in target, source and connection properties (which are just the edge-type and properties set in the add_edges method). Then we must register the function with the BioNet simulator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "from bmtk.simulator.bionet.pyfunction_cache import add_weight_function\n",
    "\n",
    "def gaussianLL(edge_props, source, target):\n",
    "    src_tuning = source['tuning_angle']\n",
    "    tar_tuning = target['tuning_angle']\n",
    "    w0 = edge_props[\"syn_weight\"]\n",
    "    sigma = edge_props[\"weight_sigma\"]\n",
    "\n",
    "    delta_tuning = abs(abs(abs(180.0 - abs(float(tar_tuning) - float(src_tuning)) % 360.0) - 90.0) - 90.0)\n",
    "    return w0 * math.exp(-(delta_tuning / sigma) ** 2)\n",
    "\n",
    "add_weight_function(gaussianLL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The weights will be adjusted before each simulation, and the function can be changed between different runs.. Simply opening the edge_types.csv file with a text editor and altering the weight_function column allows users to take an existing network and readjust weights on-the-fly.\n",
    "\n",
    "Finally we are ready to run the simulation. Note that because this is a 400 cell simulation, this may be computationally intensive for some older computers and may take anywhere between a few minutes to half-an-hour to complete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-07-22 11:16:00,779 [INFO] Created log file\n",
      "2019-07-22 11:16:00,903 [INFO] Building cells.\n",
      "2019-07-22 11:16:08,357 [INFO] Building recurrent connections\n",
      "2019-07-22 11:16:42,482 [INFO] Building virtual cell stimulations for LGN_spikes\n",
      "2019-07-22 11:16:47,653 [INFO] Running simulation for 3000.000 ms with the time step 0.100 ms\n",
      "2019-07-22 11:16:47,654 [INFO] Starting timestep: 0 at t_sim: 0.000 ms\n",
      "2019-07-22 11:16:47,655 [INFO] Block save every 5000 steps\n",
      "2019-07-22 11:17:22,433 [INFO]     step:5000 t_sim:500.00 ms\n",
      "2019-07-22 11:17:57,501 [INFO]     step:10000 t_sim:1000.00 ms\n",
      "2019-07-22 11:18:34,555 [INFO]     step:15000 t_sim:1500.00 ms\n",
      "2019-07-22 11:19:13,002 [INFO]     step:20000 t_sim:2000.00 ms\n",
      "2019-07-22 11:19:51,995 [INFO]     step:25000 t_sim:2500.00 ms\n",
      "2019-07-22 11:20:34,736 [INFO]     step:30000 t_sim:3000.00 ms\n",
      "2019-07-22 11:20:38,667 [INFO] Simulation completed in 3.0 minutes, 51.01 seconds \n"
     ]
    }
   ],
   "source": [
    "from bmtk.simulator import bionet\n",
    "\n",
    "\n",
    "conf = bionet.Config.from_json('sim_ch04/simulation_config.json')\n",
    "conf.build_env()\n",
    "net = bionet.BioNetwork.from_config(conf)\n",
    "sim = bionet.BioSimulator.from_config(conf, network=net)\n",
    "sim.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Analyzing results\n",
    "\n",
    "Results of the simulation, as specified in the config, are saved into the output directory. Using the analyzer functions, we can do things like plot the raster plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from bmtk.analyzer.spike_trains import plot_raster, plot_rates\n",
    "\n",
    "plot_raster(config_file='sim_ch04/simulation_config.json')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and the rates of each node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAELCAYAAADURYGZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xl8XHW5+PHPk2SSyTLZ96VNutM1bUPZEcqOCqioeBUVvaKyuF9Br1f0p97rxkW9ekEUhKuAKKAsIjuUtZS2dN/3Jk2z78tk+/7+OGfSJE0mk2RmziR53q9XXp05c2bm6Wkzz3y35yvGGJRSSk1fUU4HoJRSylmaCJRSaprTRKCUUtOcJgKllJrmNBEopdQ0p4lAKaWmOU0ESik1zWkiUEqpaU4TgVJKTXMxTgcQiMzMTFNcXOx0GEopNals2LCh1hiTNdp5kyIRFBcXs379eqfDUEqpSUVEDgdynnYNKaXUNKeJQCmlpjlNBEopNc1NijECpZSa7rq7uykvL6ezs/Okx9xuN4WFhbhcrnG9tiYCpZSaBMrLy/F4PBQXFyMi/ceNMdTV1VFeXk5JScm4Xlu7hpRSahLo7OwkIyNjUBIAEBEyMjKGbSkEShOBUkpNEkOTwGjHA6WJQKlpYtfxZo7UtTsdhopAOkag1DRx6S9eA+DQj9/rcCQq0miLQKkpzhijLYEpwhgzpuOB0kSg1BT31JZKzv3Zy/3327w9DkajxsvtdlNXV3fSh75v1pDb7R73a2vXkFJT3M7K5kH399e0srQw1aFo1HgVFhZSXl5OTU3NSY/51hGMlyYCpaa49q7eQff3VWsimIxcLte41wmMRruGlJrijjV2kO2J459fPoeYKGFfdavTIakIo4lAqSmusqmTU/KSOSUvmeLMRE0E6iSaCJSa4iqbOshPtQYS52Qlsa9GE4EaTBOBUlNYZ3cvta1d5KXEAzAnO4nDde20enu46cGNPLTuiMMRqkgQskQgIm4RWScim0Vku4h83z5+n4gcFJFN9k9pqGJQarrbfLQRgFlZiYCVCHr7DF99eBNPbankW49tZZN9jpq+Qtki8AKrjTHLgFLgUhE53X7s34wxpfbPphDGoNS09siGchJjo1m9IBuAM+dkkBAbzfM7qjhrTgYAu4ZML1XTT8gSgbH4OiNd9s/Elr8ppcbkpV3VXLQwh4RYa6Z4tsfNty8/haWFKfz6YyuIjhLKGzocjlI5LaRjBCISLSKbgGrgeWPM2/ZDPxKRLSJyh4jEhTIGpaar2lYvdW1dLC5IGXT8E6fP5ImbziYtMZa8FDflDVp+YroLaSIwxvQaY0qBQmCViCwGvgUsAE4F0oFbhnuuiFwvIutFZP1wK+mUUv7tqWoBYH6uZ8RzCtPitUWgwjNryBjTCLwCXGqMqbS7jbzAH4BVIzznbmNMmTGmLCsrKxxhKjWl7K2yembn5fhLBAmaCFRIZw1liUiqfTseuBDYJSJ59jEBrgK2hSoGpYLtnUP13PjgRnr7In+4a9fxFpLdMWR7Ru59LUyLp6qlk87u3hHPUVNfKFsEecDLIrIFeAdrjOAp4AER2QpsBTKBH4YwBqWC6pP3rOMfWyqpbIr8b9GbjzaytDDV7+5VJZmJGANH63WcYDoLWdE5Y8wWYPkwx1eH6j2VCrUO+5tzRUMHhWkJDkczslZvD7uON3PT6rl+zyvJtNYX7K9pY66fLiQ1tenKYhU0vX2Gmx7cyIbDDU6HEnIVjaFrEfT09vG3d8vp7u0b1/NrWrwsvu1Z+gysnJnm91xfIjhQq2UnpjNNBCpoKho6eGpLJR+6802+/+R2p8M5yd6qFv65tXLcuzk1tnf13/YNsPaFYKzgrjX7+erDm3li07FxPf9QXVv/7dESgcftItsTx4GaNr/nqalNE4EKmoHfkv/wxiFaI2gnrObObi6641W++MBGNh4ZucWyv6aV2lbvCI+d+LCsaOjg2e3HWXTbs35fbzwe21jRH/N41LdZCeupm88mKW703t9ZWYnstaeaqulJE4EKmqHdJRURNC1x9/ETH3SH/ezfe8Htazjrxy8N+1hVcycAblcURxvaeWLTMTq6e7n10S1Bi7O9q4cDtVbCqWzqHNdr+BJBemJsQOefNTuTzeVNIe3uUpFNE4EKmqEf/PtrWkPSdTIeuwYkgoqGDowx/GntYf77ud39XUXenl77zz7+95V9J8VebSeC8+Zl8+6RRl7fVwtYLYXx9ucPdaj2RJIabyL1JYK0hMASwZWlBQA8sekYlU0d7DimtYemG00EasI6u3t5YUcVFY3tZHviePvbFwBwwwMbuf353Q5HZ9l9vBmPO4bMpFgqGjt4fV8t3/n7Nn710r7+/v5jjSe+gf/0md3sGFKMrbrFS0yU8NlzSujo7qWpo5vSolR6+0zQpl8etFsD6Ymx4/6G3tDWRbwrmvjY6IDOn5GRwKzMRLaUN3LuT1/m8l+9Nq73VZOXJgIVsFf31PDB/33jpG+/f3zrMP/6f+v5y/pyCtLiyUo6sYDpgbcH17u/9/WDfP0vm8MSr09fn2Hj4UYW5HooSI2norGDdQfr+x/fbn8D9n2Yz81OAqwtHutavdzyyBbqWr1Ut3jJ8sRRNjONSxbl8OGVhfzbJfOBwQO047XhcAM3PrgRgDNmZ3BsnImgvr0r4G4hn1lZSRyoaaO712oFNXWMb3xCTU6aCFTAvvnIFjYeaTypj71lwKDwkoIUoqJOLGDKTXb33+7tM/y/p3bw6MbyQX32ofbQO0fYUdnM1SsLKUiLp6Khg3cO1TM3O4kogR2Vzby1v45P3rsOgNs/sgywavU8ufkYD68/yhf+tIGq5k6yPXGICL+9toyffXgZC+w6PgO7dMajuqWT2544sch+bnYS1S3e/u6qQG0/1sTLu6rHnAhmZyWye8CAsW5nOb1oIlABS7M/XHzdFz4Ndp90SryLr144D4DLFucCcLz5RHfLwG/hj2w4GtJYB3pjXy0z0hP4SFmRVVunsYNNRxs5e24ms7KS2HGsiTue39N//sK8ZGKjo/j5c3v43pM7AHjnUAN7q1rJ8rgHvXZ6Yiwedwz7J7D9Y5u3h1U/epFtFVbLZElBCjMzrMVqY+ly2ny0kff+6nUa2rsDmi000OyspEH391XrLKLpRBOBClhaggvgpA+9quZO5mYn8fa3L+hPFnd+YiXfvnwBje3d/fPvN5dbO2HNz/Gw6Wgj7V094+7+GItDte3MykpERJiTnURXTx+d3X0sKUjh9FnpvLCzmnWHrCSV7I4hJjqKJPfJH6THmzvJTh5ct0dEOK0knRd2Vo2p/lB3bx9PbTlGU0f3oBbW1SsLeej605mVaX0wj2V+/11r9vff9l3rQPl2MAOIjhL2VGmLYDrRRKAC1mP3H++vPjkR5KXG43YNHpwszrA+XA7ZH3SVjR144mIoK05j1/EWPnb3Ws788UvjXuAVCGMMR+rb+2NZmJfc/9iC3GRuOG8OrmirK+u3167kzW9ZA92+mTdgdZv4+MYPBrp6ZSFVzV5e2xtYuXRjDJ+9fz03PfguX/zThkEtrMX5ySTFxVBsr/gd2voaSUNbFy/srOLTZxYD8PlzZwf0PJ9lRancvHoOr99yPqcWp3HP6wcp++ELg66DmrpCVmtITT319jf7PUMSwfHmzmFr3i/ItT50t1Y0UVqUyrGmTvJS3SzI9fDA2z1sLm8CrHn9vg++YKtr66LV29Pf1TLHHheIEmF2diJxMdE8cdPZiJyId6iePsOVpflUNnbyidNnnvT4+QuySYqL4ZltxzlvfvaoMW062sire2oozkjgzf11g1oESwqtTWRS4l1kJsUGnAie3HKM7l7DR8qKuO39C/0WmhuOKzqKr19sDXx/cEUhaw/UU9vqZU9VC6fPyhjTa6nJR1sEKmC+b4fbK5po8/ZQ3dzJruPN1LR4Bw0K+xSlx5OTHMc79thAZVMHeSnxzB/ygbu1oikk8XZ29/LJe6wBYF8icLuimZWVxOysJOJirBbMKXnJJyWBP332ND643Jpfnxrv4pfXLOfhz5+OK/rkX5m4mGjeMz+LF3ZWB7Ru4v/eOkxSXAxPfekczpmbSUVjB65oYe23LmDlzPT+82ZlJo069lDe0M5TW47x6MYKTslLZmF+8piTwFDvXZJHQWo8YE2ZVVOfJgIVkN4+Q2N7F6VFqfT0GV7eXc2q/3yRS3/xGn0GclPiT3qOiHBqcTrrDtZjjKGysZP8VDeLC5Ipm5nGh1cWIhK6RPDrl/b1rwUY+EF/66UL+Oal8/0+9+y5mdz+kWV867IF/M/HVvT/fUZyyaJcalu9vHWgbtDxquZOLv3Fq3ztL5vo6zPUtnr5x5ZKrl5ZSFJcDN+wv4V39xpyUwYn01PyPOw41ux37OGrD2/ipgffZfPRRj60osDv3ylQiXExPP3lc6z4x7m6WU0umghUQJo6uukzcNHCHFzRwk0Pvjvo8XPmZg77vBUz0jje3ElFYwd1bV3kpcSTEBvDI188k599eBllM9N4YUdV0Fcg76tu4bev7ueDywvYfNvF5KeeSFQXLszhglNyRn0NEeHz75nNjIzRy01fvDCH1AQXD7x9eNDxt/bXset4C49trGBvdSvPbDtOV28fHz9tBmD1zV+8MIcvX3ByuejlM9Jo6+r1O9W2pdOauhslcEVp/qhxBirZHUO8K3rQrC9/2rt6+NE/dnDET/kOFbk0EaiA+LqFCtPi+0sSrCo50Y1RlD78h2WJPdD61n7rm3LekG+9155RzIHaNl7aVR3UeO9acwB3TDTffu8ppMS7gvraw3G7ormqtIAXdlYPmvu/8/iJ1cnvHKpnl73Cec6AQee7P1nGVy+ad9JrrphhVQ699p632TZCq8m3s9iVpQVke07unhsvESE3xd1fX2k0X314E7977SB/WR++acEqeDQRqIA0tJ+oX3PLpQs4b34WP7xqMb+9diVP3Xz2iM8rsWfrvLzb+qAvGTIofPniXFLiXfzqpb384Y2DQYt3b1ULpTNSyUwaeZvGYDutJJ2unr7+Wj33vH6Q3645wCl5yWR54thw2FqLMC/HE1A/flF6PLOyEqlr6+JDd75JdcvgD+Xu3j6ONnRww3mzueOjpUH/+2R74kZNBI3tXfzn0zt5dnsVoPsaTFaaCFRABla0zPLEcd91q5iX4+GSRbksLkgZ8XmFafHERAkv7LQSwZwh0y9joqM4Y1YGW8qb+P6TO2jvmnjpamMMB2rbTko6obbCrv3/4s5qjDH84ClrMZonLoZVJem8ub+WPVUtw05BHY6I8NxXzuXRL56Jt6ePdw4OLndd3tBBb58J2Yyr3BT3qF1Dv3xxL3e/egCAFTNStWDdJBXKzevdIrJORDaLyHYR+b59vERE3haRvSLysIiMbS28ckTDGEsb+8RER1GYFk9XTx+ZSbGkDlMR0zdlEuBo/ckLzNYeqGPtkEFYf+raumjp7GFWmBNBTrKb/BQ3v355H79/7SAJdtG3L5w3i/PnZ1PV7KWhvXtMW0LGREextDAFtyuKdw7VD3rsoP3tO1QJryQzkYqGjhHrDvX2Gf6xpRKAH1y5iPPnZ3Oorj2i9qFQgQlli8ALrDbGLANKgUtF5HTgJ8Adxpi5QAPw2RDGoIKkvn1spY0HmpNtffBlJA7fTfOJ02Zymj3ecGRISYX/enon19y9tn8aaCB8c+9LsgL75h1Mv/zYctITY/nVS3tp7+rlaxfNY/WCHM6bn9V/zkgD6yNxRUexvCiN1/bWDCr451v9Oy87NHsNnz4rgz4Dr++t5Y9rD/fPXurrMzS0dbGnqoXqFi93fHQZ155RzCn2Yr3HNpYHvP5BRYaQJQJj8XUYuuwfA6wGHrGP3w9cFaoYVPA0tHXhdkUFXNp4oK9caM2IWZA3/AdWSoKLuz6xEoD73zzUX/ffmvlzYMzv5yuYFu4WAcCpxenc8dHS/tk8OXZJisykOH7yoSX89QtnMG8cm8Rfe8ZM9te0cdcrVhmJ2lYv6w81kJvsJiUhNIPhy2ekEhcTxY0PbuQ//r6Np7dWsr+mlZ89t5vlP3ierfaCwKI0a6LAwnwrEXz38e2c//NXQhKTCo2QjhGISLSIbAKqgeeB/UCjMcbXdiwHhp38LCLXi8h6EVlfUxPY0n0VOvVt3aSPozUAsLgghWe/ci7fv2LRiOek2h9mr++r5buPW/sd+7qJzp2XRVdvX0C1fB7bWM5D646QmuCiMO3ktQ3hUFqY2n87Z8BCu4+eOoNTi9OHe8qoLl+Sx7LCFNYerKO+rYuyH77ACzurmJsTulZPXEw0pw1YVVzb6uWC29dwp52MfvrsLgCyPFayGzojTE0eIU0ExpheY0wpUAisAk4Z7rQRnnu3MabMGFOWlZU13CkqjBrau/oLyo3H/FzPsOMDPgNn0bTZA8a+rRrn2x92LaPs4dvbZ/jaXzazpbyJlTPSJrzCdrwGfkPPGWbF9XjNzkriYE0bv3zhRKXUofWdgs1XRRbgzf2Dx2lqW63uQt/MLKeut5q4sMwaMsY0Aq8ApwOpIuKrcVQIHAtHDGpiGsax2clY/fn604mNjuJgbRsv7arieFMHUXKiRHJzh/9ByMqmEwPNI61rCLdgJoKSzESONXXy0LqjvHdpHp8+s7i/7HeoXLLoRCJ4dY/VMv/yBXP5wnusonaxMVEkDih5/dmzS4CxTypQzgrlrKEsEUm1b8cDFwI7gZeBq+3TPgU8HqoYVPA0tHWNa6B4LE6flcGHywopb+jgM/etZ/3hBrI8cf0fKs2jtAh8q1rTElxcd1ZxSGMdzb/YK4fTgth/71uc19XbxzWnFvG9Kxb198uHSnpiLFu+dzGrF2Tj7bEGqj9x+sz+iqxdPYN3q/uP9y3khvNm09TRHdKqsiq4QtkiyANeFpEtwDvA88aYp4BbgK+JyD4gA7gnhDGoIKlv6wrqh9pICtNOfJN/c38ducluku2Vwc1+tk/cU9XSv83jkzefzcyM8A8UD/TDKxez6weXBrW7pHjA3+ms2WObeTQRyW7XoIH3zKTYQfsXDJWWEEtvn9FppJNIyMpQG2O2AMuHOX4Aa7xATRLdvX00d/ZMaIwgUEPLQWR53CS77UTgp0Xw02d209BuPZ43TAG8cIuKEtxRwe2/n5/r4WOrivjUmcWDtgMNhw+XFfH7162V3yIyKCkN5RsjaWzvxuMO/ZcHNXG6H4EaVaP9ARuOft9VJdbq3PfMy2LNnhrm5SSRHG/9N/U3RhDnOtG4jQ7zh2S4uKKj+K8PLnXkvefnerjz4yuIjbGus+//wnBrIlLtZN7U0U1R+EJUE6CJQI2qYQKLycZqTraHQz9+LwDHmzpJTXD1L6Ly1yI43tSJJy6Gez59ashjnK4uW5LXf1tEWP+dC4fdG9k3O8z3BUJFPk0EalT14ywvMVG++vyx0VFEif8xgqP17Vy6OHdQRVQVWiMV9POtCWns0G0uJwstOqdG5aszFI4WwXCiogSP20Vz5/BdQ53dvVS3eAcNNCvnDOwaUpODJgI1qoYwjhGMJDXBNeJG6scarfUDRenODxIrq2soOkr6/11U5NNEoEblGyNIDcP00ZHkpbhH/GApb7COa4sgMsTGRFGSmdhfFE9FPk0EalT1bV0kxEaHvJyBP/mp8QEkAm0RRIr5OR72VI28xaaKLJoI1KjCsap4NIWp8Rxv7qSnt++kx8ob2omJkqCWc1ATMz/Xw5H69qBsNKRCTxOBGlV9GOoMjSY/NZ4+A1UtXjq7eweVNihv6CA/NX7Krh+YjObleDAG9mr30KSg00fVqGpbvWHd+3c4+alWt09FQwcf+M0b5KW4+enVyzhU10Z5Q7t2C0WY+bnWngu7q1pYVpQ6ytnKaZoI1KiON3WyxM++xOHgSwSbjzZS3eKlusXLJb94FQCPO2ZQuWTlvBnpCbhdUew5ruMEk4F2DSm/vD291LZ2kZvs7DfuksxEFuR6+NHTO096rKWzhxkRUnZaWaKjhLnZHnbrgPGkoIlA+VXd7AWc330qOkr4rw8u6b//3qV5g3Y8W5Ab2nLMauzm5XjYpS2CSUG7hpRfx+39g3MjYBvC5TPS+O21K9lxrJmvXjSPVm8Ptz1hbWt5Sojr8quxm5GeQE2Ll66evv5idSoyaSJQfvm2i3S6ReBzyaLc/l2zBhY8y4+Q+NQJaYknSk349jVWkUnTtPLruL39YyS0CIaTmuAi2R2j++VGoJT+mkNafC7SBdQiEJE0IB/oAA4ZY05e1aOmpJoWL/Gu6IjdYOSNW1Y7HYIagW8RYoOWo454I7YIRCRFRL4tIluBtcBvgb8Ah0XkryJyvr8XFpEiEXlZRHaKyHYR+bJ9/HsiUiEim+yfy4P5F1LB1dDeHZYtKscrMS5m0ObpKnKkDtipTEU2f79BjwD/B5xjjGkc+ICIrASuFZFZxpiR9hzuAb5ujNkoIh5gg4g8bz92hzHm5xMNXoVeY3tX/0YjSo1FarxvgxrtGop0IyYCY8xFfh7bAGzw98LGmEqg0r7dIiI7gYJxxqkc0tje7WjVUTV5pSbqvgSTxaiDxSLy4tDuGxG5eyxvIiLFWBvZv20fuklEtojIvfb4g4pQDe3OF5xTk5MnLoboKOkvY64iVyCzhkqAW0TktgHHygJ9AxFJAh4FvmKMaQbuBGYDpVgthttHeN71IrJeRNbX1NQE+nYqyJo6uknRFoEaBxEhJd6lYwSTQCCJoBG4AMgRkSdFJOCiMyLiwkoCDxhjHgMwxlQZY3rtmUe/A1YN91xjzN3GmDJjTFlWVlagb6mCyBhDY4QPFqvIlprgolG7hiJeIIlAjDE9xpgbsD7UXweyR32SNbH7HmCnMea/BxzPG3DaB4BtYwtZhUuLt4eePqNdQ2rcUuNdNGmLIOIFMu/uLt8NY8x99nTSGwN43lnAtcBWEdlkH/s28DERKQUMcAj4/JgiVmHj+wX2LQxSaqxSE2KpssuUqMg1YiIQkXT75l8H3AY4CHxjtBc2xrwODLfc8+kxRagc4xvk0xaBGq/UBBe7tfBcxPPXItiA9a1dgDzgGCc+2A0wK7ShKaf5VoTq9FE1XqnxsTp9dBLwt46gxHdbRN41xiwPT0gqUtS1WiWond6dTE1eqQkuWr09WoE0wgX6L2NCGoWKSLW+RKCVI9U4+WacaasgsmmKViOqafHidkWRGBvtdChqkkqxx5e0Amlk8zdY/LUBd7OH3GfglFA1NdW2dpGZFKclntW4pcZr4bnJwN9gsWfA7d8Nua+mgdpWr24ooibEN9FAS1FHNn+Dxd8PZyAq8tS0eCnSTeHVBPimHmsF0sjmbz+C7/grCCciq0XkfaEJS0WC2lavzhhSE5Kig8WTgr+uoa3AUyLSCWwEagA3MBerYNwLwH+GPELliN4+Q31bl3YNqQnxxMXgihZqW7VFEMn8dQ09DjwuInOxykXkAc3An4DrjTEd4QlROaG+rYs+A1lJuqpYjZ+IkJcST0WjflxEslFrDRlj9gJ7wxCLiiA1LbqYTAVHUXo8R+vbnQ5D+aHrCNSwdDGZCpaitATKGzQRRDJNBGpYvkSQpS0CNUFF6QnUtnbR3tXjdChqBJoI1LC0RaCCpTAtHoDyBh0niFSB7Fk8z963eJt9f6mIfCf0oSknaXkJFSy+tSg6ThC5AmkR/A74FtANYIzZAlwTyqCU82pbramjWl5CTVRRmiaCSBdIIkgwxqwbckw7+6Y4XUymgiUzKZZ4VzRHtWsoYgWSCGpFZDZ2KWoRuRqoDGlUynE1LZoIVHCICIVpOoU0kgWSCG4EfgssEJEK4CvAF0Z7kogUicjLIrJTRLaLyJft4+ki8ryI7LX/HLGMhXKOtghUMBWlJ2iLIIIFkgiMMeZCIAtYYIw5O8Dn9QBfN8acApwO3CgiC4FbgReNMXOBF+37KoJoeQkVbEVp8ZTXt2OM7nEViQL5QH8UwBjTZozx7UL9yGhPMsZUGmM22rdbgJ1AAXAlcL992v3AVWMNWoWWlpdQwVaQFk+Lt4dWrw4vRiJ/G9MsABYBKSLywQEPJWMVnwuYiBQDy4G3gRxjTCVYyUJEskd4zvXA9QAzZswYy9upCdLyEirYTpSj7sbjdjkcjRrKX62h+cD7gFTg/QOOtwCfC/QNRCQJq1XxFWNMc6DTEY0xdwN3A5SVlWl7Mox0MZkKNl8iaGjv0j0uIlAg1UfPMMa8NZ4XFxEXVhJ4wBjzmH24SkTy7NZAHlA9ntdWoaPlJVSw6U5lkW3U6qPAuyJyI1Y3UX+XkDHmM/6eJNZX/3uAnUP2N34C+BTwY/vPx8catAotbRGoYEvVncoiWiCDxX8EcoFLgDVAIVb30GjOAq4FVovIJvvncqwEcJGI7AUusu+rCKLlJVSwpflaBG2aCCJRIC2COcaYD4vIlcaY+0XkQeDZ0Z5kjHkdGGlA4IKxBKnCS8tLqGBLideuoUgWSIvA9y/XKCKLgRSgOGQRKcfpYjIVbDHRUSS7Y7RrKEIF0iK42179+x2s/v0k4LshjUo5qqbFqzM7VNClJcZqiyBCBbJV5e/tm68Cs0IbjooEta1els/Qyh8quFITYmnQFkFE8ts1JCLRIpI54H6siHxORHaGPjTlBC0voUIlPcFFo7YIItKIiUBErgHqgS0iskZEzgcOAJcDHw9TfCrMtLyECpXMpLj+VesqsvjrGvoOsNIYs09EVgBvAdcYY/4WntCUE7S8hAqVnGQ3Na1eevsM0VE6Iy2S+Osa6jLG7AOwi8cd1CQw9fWvKtauIRVkOclx/V2PKrL4axFki8jXBtxPGnh/yGphNUUca7Rqxuckj6muoFKjyrb/T1U1d+oXjQjjLxH8DvD4ua+moF3HW0iIjaYgNd7pUNQUk21/+Fe3dGItR1KRwl/Rue+HMxAVGXYfb2Fejoco7cNVQZbT3yLQAeNIE8jKYjVNGGPYXdXCglxt+Kng83UHVTV3OhyJGkoTgepX3eKlvq2L+ZoIVAi4oqPISIylWqeQRhxNBKrfhsMNAJQWpTociZqq0hNjqW/VWUORZtQSE0NmDvk0ARuMMZuCH5JyyjuH6nG7oliUrwMwL5TTAAAeA0lEQVR5KjTSE2N1+mgECqRFUAZ8AWvj+QKsfYTPA34nIt8MXWgq3DYcbmBZYSqxMdpQVKGRkRRLXZt2DUWaQH7jM4AVxpivG2O+jpUYsoBzgU+HMDYVZuUNHczJTnI6DDWFaYsgMgWSCGYAA//luoGZxpgOQFP7FNHXZ2hs7+rfZFypUMhIjKOhvZue3j6nQ1EDBJIIHgTWishtInIb8AbwkIgkAjtGepKI3Csi1SKybcCx74lIxZCtK1UEaO3qoc+c2GRcqVDIsIsZ6r4EkWXURGCM+QHWuEAj1iDxF4wx/88Y02aM8VeF9D7g0mGO32GMKbV/nh5P0Cr4GtusX0zfloJKhUJ6opUItHsosgSyQxnAu8Ax3/kiMsMYc8TfE4wxr4pI8YSiU2HT2GH9YmrXkAolXyKoa/WiFWsiRyDTR28GbgOqgF6sDekNsHSc73mTiHwSWA983RjTMM7XUUHk2zBEu4ZUKPnKm9dqiyCiBDJG8GVgvjFmkTFmqTFmiTFmvEngTmA2UApUArePdKKIXC8i60VkfU1NzTjfTgWqsUMTgQq9LDsR6AY1kSWQRHAUa2xgwowxVcaYXmNMH1Y101V+zr3bGFNmjCnLysoKxtsrPxrtvWRT4rVrSIVOaoKL2OgouwKpihSBjBEcAF4RkX8wYLroePYjEJE8Y0ylffcDwDZ/56vw0a4hFQ4iQpYnjmqtQBpRAkkER+yfWPsnICLyENYK5EwRKccaZzhPREqxxhgOAZ8fY7whY4zhj2sPc/mSvGm5TWNjezdJcTG4onVVsQqt7OQ4bRFEmFETwXj3JTDGfGyYw/eM57XCYdPRRr77+HYe2VDOEzed7XQ4YdfQ3qVTR1VYZHviOFDT5nQYaoARE4GI/MIY8xUReRLrG/wgxpgrQhpZmL25vw6ALeVNlDe0U5iW4HBE4XWkvp3CNN2VTIVetsfN2gP1ToehBvDXIvij/efPwxGIk7p6+nh+RxXxrmg6unt5fkcV151V0v/44bo2bnxwIzUtXtb82/m4XdEORhsah2rbuGhhjtNhqGkg2xNHU0c3nd29U/J3aTIasUPYGLNBRKKBzxlj1gz9CWOMIfefT+9k09FGvnnpfOZmJ/Hs9uP9j/3gqR2852evsK2imapmL3urWh2MNDSaO7upa+uiODPR6VDUNOArbPjMtuOjnKnCxe/IoDGmF8gSkSk9p/DVvTWsXpDNdWeVcNXyAtYeqO//T/rk5mOkxLu477pTAdh+LCgzaSPKoVqrv7Y4QxOBCr2LF+WyuCCZ37y8z+lQlC2QKSKHgDdE5D9E5Gu+nxDHFTZN7d0cqGljxQxrV67PnTOLhXnJ/OCpHVQ2dVDd4uXm1XM4d24WcTFR3PrYVjYdbXQ46uA6aCeCEm0RqDCIjhJOLU7neJPOHIoUgSSCY8BT9rmeAT9TwuZy60O9tCgNgNiYKG65bAEVjR1c94d3AFiYn0xUlJCfag2mXnvP2+w+3uJMwCHg20w8P9XtcCRqukhPiKXF24O3p9fpUBQhnD46Waw9UEd0lLCs6MT2jOfOzeTjp83ggbetunoL85IB+M2/rOCVPdX8z4v7uOyXr3L3tWVcOAUGWOtau4iLiSIpLtAahEpNTJpdfK6xvZucZB0wdtq0nz768u4aymam4XGfmEMvIvzwqsWsKkmnutlLql2Rc2F+Mgvzk/loWRHX3rOO257YPiUSQW1rF5lJcYiI06GoaSJjQDnqnGRtiTptWk8frW7uZGdlM7dcuuCkx0SEK0sLhn1eRlIcVy3P5z+f3kV9W1d/ad1Q21PVwr7qVi5fkhfU161t9fZvGKJUOPhaBA1ahTQi+BsjqAEYburoVJk+urncmgG0qiRtzM9dlG91JYVyFtETm49x6o9eoKXTqgN08R2vcsMDG+noCm6/al2bt/8bmlLh0L8vgSaCiOAvEfzdd0NEHg1DLGG341gzIrAgN3nMz12Ubz1n+7HmYIfV70sPvUtNi5fNR5vYWXnifTYeCe4WDnWtXWRMw/pKyjm+RNDQrokgEvjrGhrYYTwr1IE4YUdlEyWZiSSOY5A0NSGWovR41h9qgPcMfuxofTt3rtlPUlwMX75g7rhe/0DNiYVr//H4tv4pngBvH6jjrDmZY37N4RhjqLPHCJQKl1S7rpVuWRkZ/H1CmRFuTwnGGLaWN7Fi5ti7hXwuWJDDQ+uO0N7VQ0JsDNuPNfHmvjr+95V9/ZtzLy1M4X1L88f82lsrTnQ5+ZLATefP4Y39tby0u5qvXTx/3HEP1OLtoau3j0wdI1BhFBMdRUq8SxNBhPDXNbRMRJpFpAVYat9uFpEWEQldf0gY9PT28ZNndnOsqZPVC7LH/TqXLMrF29PHq3tqOFTbxpW/foMfPb2TLE8cz331XKKjZNzrDXZUNuOKFkqLrIVuf/j0qXz5wrm8f2k+2yqa2VcdnHUMda3WL2K4BryV8slNdlPR0OF0GAo/LQJjzKSf3GuM4a41ByjJTOTSxbmAVVfnv57exUPrjjA7K5Erlo3927rPyplpuKKFd482svZAPQZ4+Rvn9a/QnZWZyM7KkT+we3r7uOXRrXzyjJkssz/wfXZWtjAn28N9151KS2cPRelWNdT3L8vnR0/v5G/vVvBvl5w822ms6tusDUJ0jECF24I8D+8c1CqkkWBK70Ly8+d285NndvHtv20FoLu3j7N+/BIPrTvChafk8OgXzyRmAhuxxMZEMS/Hw2/XHOC+Nw9xxbL8QWUaFuQls+t4M3WtXm55ZAtb7VlKxlg9besO1fPoxnL+4/HBG7V1dveytbyRU/I89ljEiZLYWZ44zp6Tyd/fPUZf38R77OrbrC6s9ARtEajwOiUvmWNNnf3bpCrnTOlEsKokA7AGpG54YAMbDjfQ0tlDUlwMP/7Qkv6FYhPhm3F0ztxMfnr10kGPLcxLpryhg8/cv56H1x/lg3e+wW2Pb2P17Wt4assxXtxZDYA75kTja82eGq69520a2ru5ekXhsO951fJ8Kho7eDcINY98LYJ0HSNQYXaKvWLfX6tZhceUrinwnnlZ/PCqxXzn79t4euvx/gHYv37hjKDNkslOtl7nqtKCk7Z59K1P2Hy0kU+eMZOKhg7uf+swADc9+G7/ecearH7SNXtq+NS960h2x/C5c0o4c4SZQefNy0YEXttbw8oJDHaDtgiUc+bnWCXL9lW3cMbsDIejmd5ClghE5F7gfUC1MWaxfSwdeBgoxqpq+hFjTHAnxQ+xIPdEfbyj9dYH7uyspKC9/hfPm022J44rS08ea1hScKLf/zNnlZCT7OYD//sGOcluktwxrJiRRnlDO3944xBN7d38+qW95KW4efkb5/ndsCMtMZYlBSm8vreWr1w4b0Lx17d5iXdFEx876YeE1CST5YkjOkqo0o3sHRfKrqH7gEuHHLsVeNEYMxd40b4fUvPtROArHAdW336wJLtdXHdWybBjDbExURRnWP37xZmJxMdG848vncN9153Kb/5lBZ89u4TTStIBWH37K7xzqIGbVs8JaNemM2dnsuloI53dE1tlXN/WrTOGlCOio4SspLj+6rfKOSFrERhjXhWR4iGHrwTOs2/fD7wC3BKqGAA8bhebv3sxyfEx/GX9URJiw9sb9uTNZ9M7YFA3OmpwYTffwrC6ti5uOn8OHz9tZkCvuyg/mZ4+w/6a1v5yF+NR3+bVRKAck5McR1WLtgicFu7B4hxjTCWA/eeIk/hF5HoRWS8i62tqaib0pikJLkSEj546g/dPYLroeHjcLr+D0h63i8vsqa3XnVUc8Ov6urwmui9CfXt3fwEwpcItO9lNtbYIHBexs4aMMXcbY8qMMWVZWVlOhxNSd3y0lNe+ef6Y5vIXZyYSGx014UTQ0NZFeoJr9BOVCoGcZO0aigThTgRVIpIHYP9ZHeb3j0huV/SgtQKBcEVHMSc7iTf31w3qehorq4y2LiZTzsjxuGlo79adyhwW7kTwBPAp+/angMfD/P5TynVnFbO1oomH1h0Z1/O9Pb20entIT9QWgXKGb1Oaap055KiQJQIReQh4C5gvIuUi8lngx8BFIrIXuMi+r8bp6pWFzM1O4p/bKsf1/AbfGgJtESiH+NbhVLdo95CTQjlr6GMjPHRBqN5zuhERzpufxf1vHu6vgDoWvsqP2iJQTvG1CHQtgbMidrBYBeacuVl09fax4fDY1+X5EkGaripWDjmRCLRF4CRNBJPcQnuntL1VraOcebJ6u9iX7lesnJKW4MIVrauLnaaJYJLLSIwlJd7F/pqxJ4IGbREoh4kI2R5dS+A0TQSTnIgwOytxXImgrq0LEYJShVWp8bJWF2sicJImgilgdlYS+2vaRj9xiIa2LlLjXSeVvVAqnHKS3do15DBNBFPA3Jwkalq81LaO7Zepvq1Ly0sox2V74rRryGGaCKaAlTOtCqbrD41t27/6ti4yNBEoh6UmxNLc2TOhFfJqYjQRTAFLClJwu6J4e4z7v9a3delAsXJcml3rqqmj2+FIpi9NBFNAbEwUpUWpY15LUN/epVNHleN8kxV072LnaCKYIhbmpbC3qjXgDe2NMTRoi0BFgFS7RdDQri0Cp2gimCLm5iTR0d1LRWNHQOc3d/bQ02d0UxrlOF+LoKlDWwRO0UQwRczLsfZh3lMV2P4EDf11hjQRKGelxtstgjZtEThFE8EUMSfb2rFsb3VgC8vqfKuKNREoh/m6Jxt1sNgxmgimiJR4F/kpbrZVNAV0vq9FoNNHldM87hiiBJp0sNgxmgimkOUz0nj3SGNA52rlURUpoqKElHiXDhY7SBPBFLJ8RioVjR0BrdL0VR7VMQIVCVITYmnQFoFjNBFMIStmpgGwLoAVxs0d3URHCQmx0aEOS6lRZXt0E3snOZIIROSQiGwVkU0ist6JGKaipQUpZCTG8sy246Oe29LZQ7I7BhEtOKecV5yRyKG6dqfDmLacbBGcb4wpNcaUORjDlBITHcUli3N5aVc1nd29fs9t7uzG49YtKlVkmJmZQE2LlzZvj9OhTEvaNTTFvGdeFu1dveyobPZ7XktnD8nxIduyWqkxKc5IBOCwtgoc4VQiMMBzIrJBRK53KIYpaUlBCgDbR5lG2tLZjSdOWwQqMsxITwDgcN3Y99VQE+fUV8KzjDHHRCQbeF5EdhljXh14gp0grgeYMWOGEzFOSnkpbtITY9lW4b9F0NzRw8yMhDBFpZR/vv+LOk7gDEdaBMaYY/af1cDfgFXDnHO3MabMGFOWlZUV7hAnLRFhUX4yWwNoESTHa4tARQaP20VmUqy2CBwS9kQgIoki4vHdBi4GtoU7jqlsSUEKe6pa8PaMPGDc3NmDx61jBCpyzMxI5JAmAkc40SLIAV4Xkc3AOuAfxphnHIhjylpckEJPn2HP8eHrDvX2GVq9PSTrrCEVQWZmJOhgsUPC/pXQGHMAWBbu951OFudbA8ZbK5pYUphy0uOt9hQ9bRGoSFKckchjGyvo7O7F7dKFjuGk00enoKL0eJLdMWw7Nvw4QbNd5VFbBCqS+AaMj9RrqyDcNBFMQSLC4oKUEaeQtnRaLQJdR6AiSWFaPEDAmyup4NFEMEUtLkhh5/EWunv7Tnqs0d4JSlsEKpLkJLsBAiqaqIJLE8EUtSg/ma6ePvZWnTxgXNtqJYJMT1y4w1JqRNkeKxEcb/I6HIlzOrp6Mcbad/y1vTX85JldHAnDALr2DUxRSwtTAfjbu+UszF846LHaFusXLTNJE4GKHLExUWQkxnJ8ircI+voMIlYX7tsH6vj3v2/j8sW5NHZ08+d1R/nUmTPJTIrjv/65C4BVxenMCPHiT00EU1RJZiIfLSvid68d5OOnzaQ4M7H/sdpWL9FR0r9XrFKRIifZPWLXUENbF/XtXczOSgpzVMHR22d4cWcVtz2xnStK8/nS6rl8/k8baGzv5lcv7SMuJoqu3j5+99pBADKTYnnxa+eRkhD631NNBFPYJ06fycPrj7LrePOgRFDX2kVGYixRUVqCWkWWnOS4YVsEnd29XPKLV6lu8fL8V89lbo4nbDFVN3cSFxNNSoKLg7Vt1LV6KS1KZeORRnZXtZDtiePihTn9Jd3/9m45f3mnnPcvy+djq4oQEbp6+rjhgY28sLMKgN+uOcCuyhYa27t55AtnkOSOoTgjkfq2Ln7+7G6Wz0hlVUlGWJIAaCKY0mZnWx/++4ZsaF/b6tVuIRWRcpLdvLy7hs/e9w7LilLx9vSy6Wgjb+yr6z/n/b9+nevOKuHrF80jJnrkYc4Nh+v5t79uISZaWFWSzr+ePav/C1Fvn+H5HcfZX9PGh1cWkm0PVIO1ziYpzvpoPFrfzkV3rKGzu4+STGvls92FP0hKvAsRKC1K5e0D9XR09/LWgTr+uPYw159bwgs7q3lhZxXfee8pXLEsn0/eu441e2p4/7J8yorT+18nPzWe//5o6UQv45hpIpjCEmJjKEiNHz4R6ECxikBlxen8Y2slR+rbeXFXNdFRwpysJK4/dxaritOZn+vh9ud2c+cr+4l3RfOlC+YO+zobDtdz04Pv0tTRTWlRKn95p5yntx7nM2cVc/GiXJ7Zdpz/fn4PYA3KnlaSwZ6qFqKihH9sqSQjMRa3K3rQVNY+Y/jA8gJS42O5942D3Lx6DtesmsFn/vAOu6tayE9xs2ZPDZ64GJ68+Vy2VjTx43/u4qsPbwbgwysL+ddzZgHw1M1nU93iJT81PsRXNDCaCKa4WVmJ7KsZmggmbz+rmtquXlnI1SsLAWjq6CYpLoboIV2Yv7hmOX0GfvXiXs6fn82SwhSMMeyvaeXH/9zNa3tr8Pb0ER0l/OZfVnDp4lwO1LTylYc38fPn9vDXDeW0d/VyztxMzpufzQ+e2sHaA4O3d61rs2bW5aW4uesTKylMiycl3tXfArnh/Nn9rerffHwFf1p7mG9eOr+/dIvbFc2cbA/vmZfN5qON5Ka4WZB7ojsrJjoqYpIAaCKY8pbPSON/XtrLy7urOX9+NsYYbRGoSSHFz2SGH1y5mHUH6/nGXzfzow8s5jt/38au4y144mK4qrSA+bkerizNJ8P+sJ6VlcTjN57Fw+8c5dbHtgLw/SsWcfHCHNq9PeypbuXWyxbQ1N7NKXkeunsN97x+kPcvy6Mw7eQZOwO7VudkJ/G9KxYBVit8oPTEWM5fkD3haxFqmgimuBvOm83jmyr4/WsHOH9+Nu1dvXh7+khPjHU6NKXGLSXBxfevXMTn/7iBq+96i4LUeL59+QLetzR/xG/aIsJHyoo4VNdOQaqbyxbnIiLcPKB7qcB+bmyM8MXzZofl7xIJNBFMcW5XNKuK03l5dw0ADe1WkzctTLMRlAqVixfm8MtrSjlS1861Z8wkNWH0LzdRUcKtly0IQ3STiyaCaWB+roe/biinrtVLY7tVcC6QXxqlIpmIcGVpgdNhTAmaCKaB+fYg1e6qFnp6rblv2jWklPLRWkPTwHx78c2uyhbtGlJKnUQTwTSQ5YkjyxPHtmNN2jWklDqJJoJpQERYVpjClvKm/haB1hlSSvk4kghE5FIR2S0i+0TkVidimG6WFKSyv6aVo/UdJLtj/C7NV0pNL2H/NBCRaOA3wGXAQuBjIrLQ/7PURJUVp2EMPLqxnDQdKFZKDeDE18JVwD5jzAFjTBfwZ+BKB+KYVs6cncHps6ziVi5tDSilBnBi+mgBcHTA/XLgtKEnicj1wPUAM2bMCE9kU5iI8KtrlvM/L+1jSUGK0+EopSKIE4lguCL4JxV2NcbcDdwNUFZWNkzhVzVW2clufnDVYqfDUEpFGCf6CMqBogH3C4FjDsShlFIKZxLBO8BcESkRkVjgGuAJB+JQSimFA11DxpgeEbkJeBaIBu41xmwPdxxKKaUsjtQaMsY8DTztxHsrpZQaTOcRKqXUNKeJQCmlpjlNBEopNc1pIlBKqWlOjIn8tVoiUgMcHufTM4HaIIYTLJEaF0RubBrX2ERqXBC5sU21uGYaY7JGO2lSJIKJEJH1xpgyp+MYKlLjgsiNTeMam0iNCyI3tukal3YNKaXUNKeJQCmlprnpkAjudjqAEURqXBC5sWlcYxOpcUHkxjYt45ryYwRKKaX8mw4tAqWUUn5M6UQQSXsji8ghEdkqIptEZL19LF1EnheRvfafaWGI414RqRaRbQOODRuHWH5lX78tIrLCgdi+JyIV9nXbJCKXD3jsW3Zsu0XkkhDFVCQiL4vIThHZLiJfto87fs38xOb0NXOLyDoR2WzH9X37eImIvG1fs4ft6sOISJx9f5/9eHGY47pPRA4OuF6l9vFw//+PFpF3ReQp+374rpcxZkr+YFU23Q/MAmKBzcBCB+M5BGQOOfZT4Fb79q3AT8IQx7nACmDbaHEAlwP/xNpM6HTgbQdi+x7wjWHOXWj/m8YBJfa/dXQIYsoDVti3PcAe+70dv2Z+YnP6mgmQZN92AW/b1+IvwDX28buAL9q3bwDusm9fAzwcous1Ulz3AVcPc364//9/DXgQeMq+H7brNZVbBJNhb+Qrgfvt2/cDV4X6DY0xrwL1AcZxJfB/xrIWSBWRvDDHNpIrgT8bY7zGmIPAPqx/82DHVGmM2WjfbgF2Ym236vg18xPbSMJ1zYwxptW+67J/DLAaeMQ+PvSa+a7lI8AFIjLcToahimskYfu3FJFC4L3A7+37Qhiv11ROBMPtjezvlyTUDPCciGwQaz9mgBxjTCVYv9RAtkOxjRRHpFzDm+ym+b0Dus/CHpvdBF+O9U0yoq7ZkNjA4Wtmd3NsAqqB57FaH43GmJ5h3rs/LvvxJiAjHHEZY3zX60f29bpDROKGxjVMzMH2C+CbQJ99P4MwXq+pnAgC2hs5jM4yxqwALgNuFJFzHYwlUJFwDe8EZgOlQCVwu308rLGJSBLwKPAVY0yzv1OHORbSazZMbI5fM2NMrzGmFGsr2lXAKX7e27G4RGQx8C1gAXAqkA7cEs64ROR9QLUxZsPAw37eO+hxTeVEEFF7Ixtjjtl/VgN/w/rlqPI1Ne0/qx0Kb6Q4HL+Gxpgq+5e3D/gdJ7oywhabiLiwPmgfMMY8Zh+OiGs2XGyRcM18jDGNwCtYfeypIuLbDGvge/fHZT+eQuBdhBON61K7i80YY7zAHwj/9ToLuEJEDmF1Ya/GaiGE7XpN5UQQMXsji0iiiHh8t4GLgW12PJ+yT/sU8LgT8fmJ4wngk/bsidOBJl93SLgM6ZP9ANZ188V2jT2DogSYC6wLwfsLcA+w0xjz3wMecvyajRRbBFyzLBFJtW/HAxdijV+8DFxtnzb0mvmu5dXAS8YeCQ1DXLsGJHTB6ocfeL1C/m9pjPmWMabQGFOM9Tn1kjHm44TzegVz1DvSfrBG/fdg9U/+u4NxzMKarbEZ2O6LBatf70Vgr/1nehhieQiru6Ab65vFZ0eKA6sJ+hv7+m0FyhyI7Y/2e2+xfwHyBpz/73Zsu4HLQhTT2VjN7i3AJvvn8ki4Zn5ic/qaLQXetd9/G/DdAb8H67AGqf8KxNnH3fb9ffbjs8Ic10v29doG/IkTM4vC+v/ffs/zODFrKGzXS1cWK6XUNDeVu4aUUkoFQBOBUkpNc5oIlFJqmtNEoJRS05wmAqWUmuY0ESil1DSniUCpMRKRYhlQKnsMz8sXkUdGeOwVEYm4TdPV9BAz+ilKqWAwVpmRq0c9Uakw0xaBmpbsb/U7ReR39iYlz4lIvIiUishauxLl3+TEhjMrxdrQ5C3gxgGvEy0iPxORd+znfH6U99xm344XkT/bz3kYiA/131mpkWgiUNPZXOA3xphFQCPwIeD/gFuMMUuxygrcZp/7B+BLxpgzhrzGZ7Fq0JyKVb3yc3Ydn9F8EWi33+dHwMoJ/22UGidNBGo6O2iM2WTf3oBVujnVGLPGPnY/cK6IpAw5/scBr3ExVmGyTVh7AWRgJZjRnItV1wZjzBas+jdKOULHCNR05h1wuxdIHeE8YeR67wLcbIx5dhzvr4W+VETQFoFSJzQBDSJyjn3/WmCNsWrXN4nI2fbxjw94zrPAF+19ARCReXap8dG86nsde3OUpcH4Cyg1HtoiUGqwTwF3iUgCcAC4zj5+HXCviLRjffj7/B4oBjba9exrCGzv6TuBP4iIr4R00PcFUCpQWoZaKaWmOe0aUkqpaU67hpQKMhFZwuCZRQBeY8xpTsSj1Gi0a0gppaY57RpSSqlpThOBUkpNc5oIlFJqmtNEoJRS05wmAqWUmub+P/3h7TbWU7PIAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_rates(config_file='sim_ch04/simulation_config.json')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our config file we used the cell_vars and node_id_selections parameters to save the calcium influx and membrane potential of selected cells. We can also use the analyzer to display these traces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "from bmtk.analyzer.cell_vars import plot_report\n",
    "\n",
    "plot_report(config_file='sim_ch03/simulation_config.json', node_ids=[0, 80])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
