diff --git a/examples/Example_Arbor_swc_hybridLFPy.ipynb b/examples/Example_Arbor_swc_hybridLFPy.ipynb
new file mode 100644
index 0000000..7322194
--- /dev/null
+++ b/examples/Example_Arbor_swc_hybridLFPy.ipynb
@@ -0,0 +1,1243 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Example: Arbor plus .swc morphology file\n",
+    "\n",
+    "Example utilizing the **`LFPykit`** module for predictions of extracellular potentials using \n",
+    "the line source approximation implementation `LineSourcePotential` with a passive neuron model set up in Arbor (https://arbor.readthedocs.io, https://github.com/arbor-sim/arbor). \n",
+    "\n",
+    "The neuron receives sinusoid synaptic current input in one arbitrary chosen control volume (CV). \n",
+    "Its morphology is defined in the file `single_cell.swc`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## arbor may be installed using pip:\n",
+    "#!pip install git+https://github.com/espenhgn/arbor.git@isyn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## if running on mybinder or similar, uncomment and run the following to install LFPykit. \n",
+    "## Then restart the kernel.\n",
+    "#!pip install .."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import modules\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import arbor\n",
+    "import lfpykit\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.gridspec import GridSpec\n",
+    "from matplotlib.collections import PolyCollection\n",
+    "import scipy.stats as st\n",
+    "from LFPy.alias_method import alias_method\n",
+    "from LFPy.inputgenerators import get_activation_times_from_distribution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_polygon(x, y, d):\n",
+    "    \"\"\"create a outline for each segment defined by 1D arrays `x`, `y`, `d`\n",
+    "    in x,y-plane which can be drawn using `plt.Polygon`\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    x: ndarray\n",
+    "    y: ndarray\n",
+    "    d: ndarray\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    x, y: nested list\n",
+    "    \"\"\"\n",
+    "    dx = np.diff(x)\n",
+    "    dy = np.diff(y)\n",
+    "    theta = np.arctan2(dy, dx)\n",
+    "\n",
+    "    xp = np.r_[(x + 0.5 * d * np.sin(theta)).ravel(), (x - 0.5 * d * np.sin(theta)).ravel()[::-1]]\n",
+    "    yp = np.r_[(y - 0.5 * d * np.cos(theta)).ravel(), (y + 0.5 * d * np.cos(theta)).ravel()[::-1]]\n",
+    "    \n",
+    "    return list(zip(xp, yp))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def colorbar(fig, ax, im,\n",
+    "             width=0.01,\n",
+    "             height=1.0,\n",
+    "             hoffset=0.01,\n",
+    "             voffset=0.0,\n",
+    "             orientation='vertical'):\n",
+    "    '''\n",
+    "    draw matplotlib colorbar without resizing the axes object\n",
+    "    '''\n",
+    "    rect = np.array(ax.get_position().bounds)\n",
+    "    rect = np.array(ax.get_position().bounds)\n",
+    "    caxrect = [0] * 4\n",
+    "    caxrect[0] = rect[0] + rect[2] + hoffset * rect[2]\n",
+    "    caxrect[1] = rect[1] + voffset * rect[3]\n",
+    "    caxrect[2] = rect[2] * width\n",
+    "    caxrect[3] = rect[3] * height\n",
+    "    cax = fig.add_axes(caxrect)\n",
+    "    cb = fig.colorbar(im, cax=cax, orientation=orientation)\n",
+    "    return cb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class BaseRecipe (arbor.recipe):\n",
+    "    def __init__(self, cell):\n",
+    "        super().__init__()\n",
+    "     \n",
+    "        self.the_cell = cell\n",
+    "\n",
+    "        self.vprobe_id = (0, 0)\n",
+    "        self.iprobe_id = (0, 1)\n",
+    "        self.cprobe_id = (0, 2)\n",
+    "\n",
+    "        self.the_props = arbor.neuron_cable_properties()\n",
+    "        self.the_cat = arbor.default_catalogue()\n",
+    "        self.the_props.register(self.the_cat)\n",
+    "       \n",
+    "    def num_cells(self):\n",
+    "        return 1\n",
+    "\n",
+    "    def num_sources(self, gid):\n",
+    "        return 0\n",
+    "\n",
+    "    def num_targets(self, gid):\n",
+    "        return 0\n",
+    "\n",
+    "    def connections_on(self, gid):\n",
+    "        return []\n",
+    "\n",
+    "    def event_generators(self, gid):\n",
+    "        return []\n",
+    "    \n",
+    "    def cell_kind(self, gid):\n",
+    "        return arbor.cell_kind.cable\n",
+    "\n",
+    "    def cell_description(self, gid):\n",
+    "        return self.the_cell\n",
+    "\n",
+    "    def global_properties(self, kind):\n",
+    "        return self.the_props\n",
+    "    \n",
+    "    def probes(self, gid):\n",
+    "        return [\n",
+    "            arbor.cable_probe_membrane_voltage_cell(),\n",
+    "            arbor.cable_probe_total_current_cell(),\n",
+    "            arbor.cable_probe_stimulus_current_cell()\n",
+    "        ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Recipe(BaseRecipe):\n",
+    "    def __init__(self, cell, times=[[1.]], weights=[1.]):\n",
+    "        super().__init__(cell)\n",
+    "        \n",
+    "        assert(len(times) == len(weights)), 'len(times) != len(weights)'\n",
+    "        self.times = times\n",
+    "        self.weights = weights\n",
+    "\n",
+    "    def num_targets(self, gid):\n",
+    "        return len(self.times)\n",
+    "        \n",
+    "    def event_generators(self, gid):\n",
+    "        events = []\n",
+    "        for i, (w, t) in enumerate(zip(self.weights, self.times)):\n",
+    "            events += [arbor.event_generator(f'{i}', w, \n",
+    "                                             arbor.explicit_schedule(t))]\n",
+    "        \n",
+    "        return events"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parameters, cell decor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Parameters\n",
+    "morphology_file = os.path.join('morphologies', 'ex.swc')\n",
+    "\n",
+    "# CV discretization\n",
+    "max_cv_length = 10  # µm, max length of CV.\n",
+    "\n",
+    "# simulation duration\n",
+    "tfinal = 500\n",
+    "\n",
+    "# number of synapses\n",
+    "n_syn = 20\n",
+    "\n",
+    "# synapse model and kwargs\n",
+    "synapse = 'expisyn'\n",
+    "synapse_params = {'tau': 5}\n",
+    "# synapse = 'alphaisyn'\n",
+    "# synapse_params = {'tau': 5}\n",
+    "\n",
+    "# synapse weight dist\n",
+    "weight_params = dict(loc=0, scale=1E-3)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# cell decor\n",
+    "decor = arbor.decor()\n",
+    "\n",
+    "# set initial voltage, temperature, axial resistivity, membrane capacitance\n",
+    "decor.set_property(\n",
+    "    Vm=-65,  # Initial membrane voltage [mV]\n",
+    "    tempK=300,  # Temperature [Kelvin]\n",
+    "    rL=10000,  # Axial resistivity [Ω cm]\n",
+    "    cm=0.01,  # Membrane capacitance [F/m**2]\n",
+    ")\n",
+    "\n",
+    "# set passive mechanism all over\n",
+    "pas = arbor.mechanism('pas/e=-65')  # passive mech w. leak reversal potential (mV)\n",
+    "pas.set('g', 0.0001)  # leak conductivity (S/cm2)\n",
+    "decor.paint('(all)', pas)\n",
+    "\n",
+    "# number of CVs per branch\n",
+    "policy = arbor.cv_policy_max_extent(max_cv_length)\n",
+    "decor.discretization(policy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define morphology (needed for arbor.place_pwlin etc.)\n",
+    "morphology = arbor.load_swc_arbor(morphology_file)\n",
+    "\n",
+    "# Label dictionary\n",
+    "defs = {\n",
+    "    'soma': '(tag 1)',\n",
+    "    'axon': '(tag 2)',\n",
+    "    'dend': '(tag 3)',\n",
+    "    'apic': '(tag 4)'\n",
+    "}\n",
+    "labels = arbor.label_dict(defs)\n",
+    "# labels['all'] = '(all)'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define isometry\n",
+    "iso = arbor.isometry()  # create isometry\n",
+    "iso_rot = iso.rotate(theta=np.pi/2, x=0, y=0, z=1)  # rotate isometry around axis\n",
+    "# iso_rot = iso.rotate(theta=np.pi/2, x=0, y=0, z=1)  # rotate isometry around axis\n",
+    "iso_trans = iso_rot.translate(x=0, y=0, z=0)  # translate isometry along axis\n",
+    "\n",
+    "p = arbor.place_pwlin(morphology, iso_rot * iso_trans)  # place with isometry"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "morphology.se"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### set up dummy cell to first find possible synapse locations (per CV)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create cell and set properties\n",
+    "cell = arbor.cable_cell(morphology, labels, decor)\n",
+    "\n",
+    "# instantiate recipe with cell\n",
+    "recipe = BaseRecipe(cell)\n",
+    "\n",
+    "# instantiate simulation\n",
+    "context = arbor.context()\n",
+    "domains = arbor.partition_load_balance(recipe, context)\n",
+    "sim = arbor.simulation(recipe, domains, context)\n",
+    "\n",
+    "# set up sampling on probes\n",
+    "schedule = arbor.regular_schedule(0.1)\n",
+    "i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)\n",
+    "\n",
+    "# need meta data locating each CV\n",
+    "_, I_m_meta = sim.samples(i_handle)[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "([(cable 0 0 0.5),\n",
+       "  (cable 0 0.5 1),\n",
+       "  (cable 3 0 0.025641),\n",
+       "  (cable 3 0.025641 0.0512821),\n",
+       "  (cable 3 0.0512821 0.0769231),\n",
+       "  (cable 3 0.0769231 0.102564),\n",
+       "  (cable 3 0.102564 0.128205),\n",
+       "  (cable 3 0.128205 0.153846),\n",
+       "  (cable 3 0.153846 0.179487),\n",
+       "  (cable 3 0.179487 0.205128),\n",
+       "  (cable 3 0.205128 0.230769),\n",
+       "  (cable 3 0.230769 0.25641),\n",
+       "  (cable 3 0.25641 0.282051),\n",
+       "  (cable 3 0.282051 0.307692),\n",
+       "  (cable 3 0.307692 0.333333),\n",
+       "  (cable 3 0.333333 0.358974),\n",
+       "  (cable 3 0.358974 0.384615),\n",
+       "  (cable 3 0.384615 0.410256),\n",
+       "  (cable 3 0.410256 0.435897),\n",
+       "  (cable 3 0.435897 0.461538),\n",
+       "  (cable 3 0.461538 0.487179),\n",
+       "  (cable 3 0.487179 0.512821),\n",
+       "  (cable 3 0.512821 0.538462),\n",
+       "  (cable 3 0.538462 0.564103),\n",
+       "  (cable 3 0.564103 0.589744),\n",
+       "  (cable 3 0.589744 0.615385),\n",
+       "  (cable 3 0.615385 0.641026),\n",
+       "  (cable 3 0.641026 0.666667),\n",
+       "  (cable 3 0.666667 0.692308),\n",
+       "  (cable 3 0.692308 0.717949),\n",
+       "  (cable 3 0.717949 0.74359),\n",
+       "  (cable 3 0.74359 0.769231),\n",
+       "  (cable 3 0.769231 0.794872),\n",
+       "  (cable 3 0.794872 0.820513),\n",
+       "  (cable 3 0.820513 0.846154),\n",
+       "  (cable 3 0.846154 0.871795),\n",
+       "  (cable 3 0.871795 0.897436),\n",
+       "  (cable 3 0.897436 0.923077),\n",
+       "  (cable 3 0.923077 0.948718),\n",
+       "  (cable 3 0.948718 0.974359),\n",
+       "  (cable 3 0.974359 1),\n",
+       "  (cable 4 0 0.0588235),\n",
+       "  (cable 4 0.0588235 0.117647),\n",
+       "  (cable 4 0.117647 0.176471),\n",
+       "  (cable 4 0.176471 0.235294),\n",
+       "  (cable 4 0.235294 0.294118),\n",
+       "  (cable 4 0.294118 0.352941),\n",
+       "  (cable 4 0.352941 0.411765),\n",
+       "  (cable 4 0.411765 0.470588),\n",
+       "  (cable 4 0.470588 0.529412),\n",
+       "  (cable 4 0.529412 0.588235),\n",
+       "  (cable 4 0.588235 0.647059),\n",
+       "  (cable 4 0.647059 0.705882),\n",
+       "  (cable 4 0.705882 0.764706),\n",
+       "  (cable 4 0.764706 0.823529),\n",
+       "  (cable 4 0.823529 0.882353),\n",
+       "  (cable 4 0.882353 0.941176),\n",
+       "  (cable 4 0.941176 1),\n",
+       "  (cable 5 0 0.0588235),\n",
+       "  (cable 5 0.0588235 0.117647),\n",
+       "  (cable 5 0.117647 0.176471),\n",
+       "  (cable 5 0.176471 0.235294),\n",
+       "  (cable 5 0.235294 0.294118),\n",
+       "  (cable 5 0.294118 0.352941),\n",
+       "  (cable 5 0.352941 0.411765),\n",
+       "  (cable 5 0.411765 0.470588),\n",
+       "  (cable 5 0.470588 0.529412),\n",
+       "  (cable 5 0.529412 0.588235),\n",
+       "  (cable 5 0.588235 0.647059),\n",
+       "  (cable 5 0.647059 0.705882),\n",
+       "  (cable 5 0.705882 0.764706),\n",
+       "  (cable 5 0.764706 0.823529),\n",
+       "  (cable 5 0.823529 0.882353),\n",
+       "  (cable 5 0.882353 0.941176),\n",
+       "  (cable 5 0.941176 1),\n",
+       "  (cable 1 0 0.0588235),\n",
+       "  (cable 1 0.0588235 0.117647),\n",
+       "  (cable 1 0.117647 0.176471),\n",
+       "  (cable 1 0.176471 0.235294),\n",
+       "  (cable 1 0.235294 0.294118),\n",
+       "  (cable 1 0.294118 0.352941),\n",
+       "  (cable 1 0.352941 0.411765),\n",
+       "  (cable 1 0.411765 0.470588),\n",
+       "  (cable 1 0.470588 0.529412),\n",
+       "  (cable 1 0.529412 0.588235),\n",
+       "  (cable 1 0.588235 0.647059),\n",
+       "  (cable 1 0.647059 0.705882),\n",
+       "  (cable 1 0.705882 0.764706),\n",
+       "  (cable 1 0.764706 0.823529),\n",
+       "  (cable 1 0.823529 0.882353),\n",
+       "  (cable 1 0.882353 0.941176),\n",
+       "  (cable 1 0.941176 1),\n",
+       "  (cable 2 0 0.0588235),\n",
+       "  (cable 2 0.0588235 0.117647),\n",
+       "  (cable 2 0.117647 0.176471),\n",
+       "  (cable 2 0.176471 0.235294),\n",
+       "  (cable 2 0.235294 0.294118),\n",
+       "  (cable 2 0.294118 0.352941),\n",
+       "  (cable 2 0.352941 0.411765),\n",
+       "  (cable 2 0.411765 0.470588),\n",
+       "  (cable 2 0.470588 0.529412),\n",
+       "  (cable 2 0.529412 0.588235),\n",
+       "  (cable 2 0.588235 0.647059),\n",
+       "  (cable 2 0.647059 0.705882),\n",
+       "  (cable 2 0.705882 0.764706),\n",
+       "  (cable 2 0.764706 0.823529),\n",
+       "  (cable 2 0.823529 0.882353),\n",
+       "  (cable 2 0.882353 0.941176),\n",
+       "  (cable 2 0.941176 1)],\n",
+       " (0, 1))"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "I_m_meta, recipe.iprobe_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# check samples w. probe handle (probe_recording_data, meta_data)\n",
+    "# sim.samples(i_handle)[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Gather geometry of CVs and assign segments to each CV, \n",
+    "# get segment geometries and mapping to CV indices\n",
+    "x, y, z, d = [np.array([], dtype=float).reshape((0, 2))] * 4\n",
+    "CV_ind = np.array([], dtype=int)  # tracks which CV owns segment\n",
+    "for i, m in enumerate(I_m_meta):\n",
+    "    segs = p.segments([m])\n",
+    "    for j, seg in enumerate(segs):\n",
+    "        x = np.row_stack([x, [seg.prox.x, seg.dist.x]])\n",
+    "        y = np.row_stack([y, [seg.prox.y, seg.dist.y]])\n",
+    "        z = np.row_stack([z, [seg.prox.z, seg.dist.z]])\n",
+    "        d = np.row_stack([d, [seg.prox.radius * 2, seg.dist.radius * 2]])\n",
+    "        CV_ind = np.r_[CV_ind, i]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define a list of loc_sets with relative location in between proximal and distal points of each CV\n",
+    "loc_sets = [\n",
+    "    '(location {} {})'.format(c.branch, np.mean([c.prox, c.dist])) for c in I_m_meta\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['(location 0 0.25)',\n",
+       " '(location 0 0.75)',\n",
+       " '(location 3 0.01282051282051282)',\n",
+       " '(location 3 0.038461538461538464)',\n",
+       " '(location 3 0.0641025641025641)',\n",
+       " '(location 3 0.08974358974358974)',\n",
+       " '(location 3 0.11538461538461538)',\n",
+       " '(location 3 0.14102564102564102)',\n",
+       " '(location 3 0.16666666666666669)',\n",
+       " '(location 3 0.1923076923076923)',\n",
+       " '(location 3 0.21794871794871795)',\n",
+       " '(location 3 0.24358974358974356)',\n",
+       " '(location 3 0.2692307692307692)',\n",
+       " '(location 3 0.2948717948717949)',\n",
+       " '(location 3 0.3205128205128205)',\n",
+       " '(location 3 0.34615384615384615)',\n",
+       " '(location 3 0.3717948717948718)',\n",
+       " '(location 3 0.3974358974358974)',\n",
+       " '(location 3 0.4230769230769231)',\n",
+       " '(location 3 0.4487179487179487)',\n",
+       " '(location 3 0.47435897435897434)',\n",
+       " '(location 3 0.5)',\n",
+       " '(location 3 0.5256410256410255)',\n",
+       " '(location 3 0.5512820512820513)',\n",
+       " '(location 3 0.5769230769230769)',\n",
+       " '(location 3 0.6025641025641026)',\n",
+       " '(location 3 0.6282051282051282)',\n",
+       " '(location 3 0.6538461538461537)',\n",
+       " '(location 3 0.6794871794871795)',\n",
+       " '(location 3 0.7051282051282051)',\n",
+       " '(location 3 0.7307692307692308)',\n",
+       " '(location 3 0.7564102564102564)',\n",
+       " '(location 3 0.7820512820512819)',\n",
+       " '(location 3 0.8076923076923077)',\n",
+       " '(location 3 0.8333333333333333)',\n",
+       " '(location 3 0.858974358974359)',\n",
+       " '(location 3 0.8846153846153846)',\n",
+       " '(location 3 0.9102564102564101)',\n",
+       " '(location 3 0.9358974358974359)',\n",
+       " '(location 3 0.9615384615384615)',\n",
+       " '(location 3 0.9871794871794872)',\n",
+       " '(location 4 0.029411764705882353)',\n",
+       " '(location 4 0.08823529411764705)',\n",
+       " '(location 4 0.14705882352941174)',\n",
+       " '(location 4 0.20588235294117646)',\n",
+       " '(location 4 0.2647058823529412)',\n",
+       " '(location 4 0.32352941176470584)',\n",
+       " '(location 4 0.38235294117647056)',\n",
+       " '(location 4 0.4411764705882353)',\n",
+       " '(location 4 0.5)',\n",
+       " '(location 4 0.5588235294117647)',\n",
+       " '(location 4 0.6176470588235294)',\n",
+       " '(location 4 0.6764705882352942)',\n",
+       " '(location 4 0.7352941176470588)',\n",
+       " '(location 4 0.7941176470588235)',\n",
+       " '(location 4 0.8529411764705882)',\n",
+       " '(location 4 0.9117647058823529)',\n",
+       " '(location 4 0.9705882352941176)',\n",
+       " '(location 5 0.029411764705882353)',\n",
+       " '(location 5 0.08823529411764705)',\n",
+       " '(location 5 0.14705882352941174)',\n",
+       " '(location 5 0.20588235294117646)',\n",
+       " '(location 5 0.2647058823529412)',\n",
+       " '(location 5 0.32352941176470584)',\n",
+       " '(location 5 0.38235294117647056)',\n",
+       " '(location 5 0.4411764705882353)',\n",
+       " '(location 5 0.5)',\n",
+       " '(location 5 0.5588235294117647)',\n",
+       " '(location 5 0.6176470588235294)',\n",
+       " '(location 5 0.6764705882352942)',\n",
+       " '(location 5 0.7352941176470588)',\n",
+       " '(location 5 0.7941176470588235)',\n",
+       " '(location 5 0.8529411764705882)',\n",
+       " '(location 5 0.9117647058823529)',\n",
+       " '(location 5 0.9705882352941176)',\n",
+       " '(location 1 0.029411764705882353)',\n",
+       " '(location 1 0.08823529411764705)',\n",
+       " '(location 1 0.14705882352941174)',\n",
+       " '(location 1 0.20588235294117646)',\n",
+       " '(location 1 0.2647058823529412)',\n",
+       " '(location 1 0.32352941176470584)',\n",
+       " '(location 1 0.38235294117647056)',\n",
+       " '(location 1 0.4411764705882353)',\n",
+       " '(location 1 0.5)',\n",
+       " '(location 1 0.5588235294117647)',\n",
+       " '(location 1 0.6176470588235294)',\n",
+       " '(location 1 0.6764705882352942)',\n",
+       " '(location 1 0.7352941176470588)',\n",
+       " '(location 1 0.7941176470588235)',\n",
+       " '(location 1 0.8529411764705882)',\n",
+       " '(location 1 0.9117647058823529)',\n",
+       " '(location 1 0.9705882352941176)',\n",
+       " '(location 2 0.029411764705882353)',\n",
+       " '(location 2 0.08823529411764705)',\n",
+       " '(location 2 0.14705882352941174)',\n",
+       " '(location 2 0.20588235294117646)',\n",
+       " '(location 2 0.2647058823529412)',\n",
+       " '(location 2 0.32352941176470584)',\n",
+       " '(location 2 0.38235294117647056)',\n",
+       " '(location 2 0.4411764705882353)',\n",
+       " '(location 2 0.5)',\n",
+       " '(location 2 0.5588235294117647)',\n",
+       " '(location 2 0.6176470588235294)',\n",
+       " '(location 2 0.6764705882352942)',\n",
+       " '(location 2 0.7352941176470588)',\n",
+       " '(location 2 0.7941176470588235)',\n",
+       " '(location 2 0.8529411764705882)',\n",
+       " '(location 2 0.9117647058823529)',\n",
+       " '(location 2 0.9705882352941176)']"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "loc_sets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(cable 1 0 1), (cable 2 0 1), (cable 4 0 1), (cable 5 0 1)]"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cell.cables('dend')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# CellGeometry object\n",
+    "cell_geometry = lfpykit.CellGeometry(\n",
+    "    x=x,\n",
+    "    y=y,\n",
+    "    z=z,\n",
+    "    d=d\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# compute areas per CV\n",
+    "areas = []\n",
+    "for i in range(len(loc_sets)):\n",
+    "    inds = CV_ind == i\n",
+    "    areas = np.r_[areas, cell_geometry.area[inds].sum()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# center of mass (COM) per segment -- https://mathworld.wolfram.com/ConicalFrustum.html gives geometric centroid as\n",
+    "# \\overline{z}} = h * (R1**2 + 2 * R1*R2 + 3 * R2**2) / (4 * (R1**2 + R1 * R2 + R2**2))\n",
+    "R = cell_geometry.d / 2\n",
+    "# relative COMs per segment\n",
+    "h_bar_seg = cell_geometry.length * (R[:, 0]**2 + 2 * R[:, 0] * R[:, 1] + 3 * R[:, 1]**2\n",
+    "                                    ) / (4 * (R[:, 0]**2 + R[:, 0] * R[:, 1] + R[:, 1]**2))\n",
+    "# carthesian coordinates\n",
+    "r_bar_seg =  np.c_[cell_geometry.x[:, 0] + h_bar_seg * (cell_geometry.x[:, 1] - cell_geometry.x[:, 0]\n",
+    "                                                        ) / cell_geometry.length,\n",
+    "                   cell_geometry.y[:, 0] + h_bar_seg * (cell_geometry.y[:, 1] - cell_geometry.y[:, 0]\n",
+    "                                                        ) / cell_geometry.length,\n",
+    "                   cell_geometry.z[:, 0] + h_bar_seg * (cell_geometry.z[:, 1] - cell_geometry.z[:, 0]\n",
+    "                                                        ) / cell_geometry.length]\n",
+    "# Volumes / mass\n",
+    "# V = 1 / 3 * π * h * (R1**2 + R1 * R2 + R2**2)\n",
+    "V_seg = np.pi * cell_geometry.length * (R[:, 0]**2 + R[:, 0] * R[:, 1] + R[:, 1]**2) / 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# COM per CV\n",
+    "r_bar = np.zeros((0, 3))\n",
+    "for i in range(len(loc_sets)):\n",
+    "    inds = CV_ind == i\n",
+    "    if inds.sum() <= 1:\n",
+    "        r_ = (r_bar_seg[inds, ] * V_seg[inds] / V_seg[inds].sum()).mean(axis=0)\n",
+    "    else:\n",
+    "        # compute mean position weighted by volume/mass (mass monopole location)\n",
+    "        r_ = (r_bar_seg[inds, ].T * V_seg[inds] / V_seg[inds].sum()).sum(axis=-1)\n",
+    "    r_bar = np.vstack((r_bar, r_))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x14a1c8760>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2400x2400 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# test morphology plot\n",
+    "fig, ax = plt.subplots(1, 1, figsize=(12, 12), dpi=200)\n",
+    "\n",
+    "\n",
+    "# add outline of each CV\n",
+    "zips = []\n",
+    "for i in range(len(loc_sets)):\n",
+    "    inds = CV_ind == i\n",
+    "    zips.append(create_polygon(x[inds, ], z[inds, ], d[inds, ]))\n",
+    "polycol = PolyCollection(zips,\n",
+    "                         edgecolors='gray',\n",
+    "                         facecolors='none',\n",
+    "                         linewidths=2, label='_nolabel_')    \n",
+    "ax.add_collection(polycol)\n",
+    "\n",
+    "\n",
+    "# outline of segments making up each CV:\n",
+    "if True:\n",
+    "    zips = []\n",
+    "    for x_, z_, d_ in zip(x, z, d):\n",
+    "        zips.append(create_polygon(x_, z_, d_))\n",
+    "    polycol = PolyCollection(zips,\n",
+    "                             edgecolors='k',\n",
+    "                             facecolors='none',\n",
+    "                             linewidths=0.25, label='_nolabel_')\n",
+    "    ax.add_collection(polycol)\n",
+    "\n",
+    "# plot COM of each CV (sanity test)\n",
+    "ax.plot(r_bar[:, 0], r_bar[:, 2], 'go', label='COM(CV)')\n",
+    "\n",
+    "# plot COM of each segment (sanity test)\n",
+    "ax.plot(r_bar_seg[:, 0], r_bar_seg[:, 2], 'r.', label='COM(seg)')\n",
+    "    \n",
+    "    \n",
+    "ax.set_xlabel(r'$x$ ($\\mu$m)')\n",
+    "ax.set_ylabel(r'$y$ ($\\mu$m)')\n",
+    "ax.set_aspect('equal')\n",
+    "ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# draw locsets accd to y-position weighted by area and some function of y\n",
+    "def get_rand_idx_area_and_distribution_norm(areas, \n",
+    "                                            depth,\n",
+    "                                            n_syn=1,\n",
+    "                                            fun=[st.norm], \n",
+    "                                            funargs=[dict(loc=200, scale=50)], \n",
+    "                                            funweights=[1.]):\n",
+    "    '''Return n_syn CV indices with random probability normalized by membrane area\n",
+    "    multiplied with the value of probability density function constructed as\n",
+    "    weigthed sum of `scipy.stats._continuous_dists` function instances\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    areas: 1D ndarray\n",
+    "        Area of each CV\n",
+    "    depth: 1D ndarray\n",
+    "        depth of each CV\n",
+    "    n_syn: int\n",
+    "        number of random indices\n",
+    "    fun: iterable of scipy.stats._continuous_distns.*_gen\n",
+    "        iterable of callable methods in scipy.stats module\n",
+    "    funargs: iterable of dicts\n",
+    "        keyword arguments to each element in `fun`\n",
+    "    funweights: list of floats\n",
+    "        scaling\n",
+    "        \n",
+    "    Returns\n",
+    "    -------\n",
+    "    ndarray\n",
+    "        random indices of size `n_syn` that can be \n",
+    "    '''\n",
+    "    # probabilities for connecting to CV \n",
+    "    p = areas.copy()\n",
+    "    mod = np.zeros(areas.size)\n",
+    "    for f, args, w in zip(fun, funargs, funweights):\n",
+    "        df = f(**args)\n",
+    "        mod += df.pdf(x=depth) * w\n",
+    "\n",
+    "    # multiply probs by spatial weighting factor\n",
+    "    p *= mod\n",
+    "    # normalize\n",
+    "    p /= p.sum()\n",
+    "    # find CV inds\n",
+    "    return alias_method(np.arange(areas.size), p, n_syn)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([12., 13., 12., 10.,  6., 11.,  8.,  8.,  7., 13.]),\n",
+       " array([205., 214., 223., 232., 241., 250., 259., 268., 277., 286., 295.]),\n",
+       " <BarContainer object of 10 artists>)"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "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": [
+    "# sanity check\n",
+    "'''\n",
+    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 2], n_syn=100, \n",
+    "                                               fun=[st.norm], \n",
+    "                                               funargs=[dict(loc=200, scale=50)], \n",
+    "                                               funweights=[1.])\n",
+    "'''\n",
+    "\n",
+    "# sanity check\n",
+    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 2], n_syn=100, \n",
+    "                                               fun=[st.uniform], \n",
+    "                                               funargs=[dict(loc=200, scale=100)], \n",
+    "                                               funweights=[1.])\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 2, sharey=True)\n",
+    "# areas per depth\n",
+    "axes[0].plot(areas, r_bar[:, 2], '.')\n",
+    "# num. synapses hist. across depth\n",
+    "axes[1].hist(r_bar[inds][:, 2], orientation='horizontal')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Proper cell simulation using cell instrumented with synapses distributed accd. to CV area and depth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# randomly chosen loc_sets\n",
+    "inds = get_rand_idx_area_and_distribution_norm(areas, r_bar[:, 2], n_syn=n_syn)\n",
+    "random_loc_sets = np.array(loc_sets)[inds]\n",
+    "\n",
+    "# create synapses at each loc_set\n",
+    "for i, loc_set in enumerate(random_loc_sets):\n",
+    "    decor.place(loc_set, arbor.mechanism(synapse, synapse_params), f'{i}')\n",
+    "\n",
+    "# synapse activation times (Poisson like)\n",
+    "times = get_activation_times_from_distribution(\n",
+    "    n_syn, tstart=0, tstop=tfinal, \n",
+    "    distribution=st.expon, rvs_args=dict(loc=0, scale=20))\n",
+    "\n",
+    "# synapse weights\n",
+    "weights = st.norm.rvs(size=n_syn, **weight_params)\n",
+    "    \n",
+    "# number of CVs per branch\n",
+    "policy = arbor.cv_policy_max_extent(max_cv_length)\n",
+    "decor.discretization(policy)\n",
+    "\n",
+    "# create cell and set properties\n",
+    "cell = arbor.cable_cell(morphology, labels, decor)\n",
+    "\n",
+    "# instantiate recipe with cell\n",
+    "recipe = Recipe(cell, weights=weights, times=times)\n",
+    "\n",
+    "# instantiate simulation\n",
+    "context = arbor.context()\n",
+    "domains = arbor.partition_load_balance(recipe, context)\n",
+    "sim = arbor.simulation(recipe, domains, context)\n",
+    "\n",
+    "# set up sampling on probes\n",
+    "schedule = arbor.regular_schedule(0.1)\n",
+    "v_handle = sim.sample(recipe.vprobe_id, schedule, arbor.sampling_policy.exact)\n",
+    "i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)\n",
+    "c_handle = sim.sample(recipe.cprobe_id, schedule, arbor.sampling_policy.exact)\n",
+    "\n",
+    "# run simulation for 500 ms of simulated activity and collect results.\n",
+    "sim.run(tfinal=tfinal)\n",
+    "\n",
+    "# extract time, V_m and I_m for each compartment\n",
+    "V_m_samples, V_m_meta = sim.samples(v_handle)[0]\n",
+    "I_m_samples, I_m_meta = sim.samples(i_handle)[0]\n",
+    "I_c_samples, I_c_meta = sim.samples(c_handle)[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# drop recorded V_m values and corresponding meta data of \n",
+    "# zero-sized CVs (branch-point potentials)\n",
+    "inds = np.array([m.dist != m.prox for m in V_m_meta])\n",
+    "V_m_samples = V_m_samples[:, np.r_[True, inds]]\n",
+    "V_m_meta = np.array(V_m_meta)[inds].tolist()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# note: the cables comprising the metadata for each probe\n",
+    "# should be the same, as well as the reported sample times.\n",
+    "assert V_m_meta==I_m_meta\n",
+    "assert (V_m_samples[:, 0]==I_m_samples[:, 0]).all()\n",
+    "\n",
+    "# prep recorded data for plotting\n",
+    "time = V_m_samples[:, 0]\n",
+    "V_m = V_m_samples[:, 1:].T\n",
+    "I_m = I_m_samples[:, 1:].T\n",
+    "I_c = I_c_samples[:, 1:].T"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "###############################################################################\n",
+    "# compute extracellular potential using segment information\n",
+    "###############################################################################\n",
+    "# membrane voltages, transmemrbane current and corresponding times\n",
+    "cell_geometry.V_m = V_m  # mV\n",
+    "cell_geometry.I_m = I_m + I_c  # nA, sum stimulation and transmembrane current to mimic sinusoid synapse\n",
+    "cell_geometry.time = time  # ms\n",
+    "\n",
+    "# locations where extracellular potential is predicted \n",
+    "dx = 1\n",
+    "dz = 1\n",
+    "axis = np.round([x.min()-50, x.max()+50, z.min()-10, z.max()+10])\n",
+    "# axis = np.round(axis)\n",
+    "X, Z = np.meshgrid(np.linspace(axis[0], axis[1], int(np.diff(axis[:2]) // dx) + 1), \n",
+    "                   np.linspace(axis[2], axis[3], int(np.diff(axis[2:]) // dz) + 1))\n",
+    "Y = np.zeros_like(X)\n",
+    "\n",
+    "# LineSourcePotential object, get mapping for all segments per CV\n",
+    "lsp = lfpykit.LineSourcePotential(cell=cell_geometry, \n",
+    "                                  x=X.flatten(), \n",
+    "                                  y=Y.flatten(), \n",
+    "                                  z=Z.flatten())\n",
+    "M_tmp = lsp.get_transformation_matrix()\n",
+    "\n",
+    "# Define response matrix from M with columns weighted by area of each frusta\n",
+    "M = np.zeros((lsp.x.size, I_m.shape[0]))\n",
+    "for i in range(I_m.shape[0]):\n",
+    "    inds = CV_ind == i\n",
+    "    M[:, i] = M_tmp[:, inds] @ (cell_geometry.area[inds] / cell_geometry.area[inds].sum())\n",
+    "\n",
+    "# Extracellular potential using segment information at last time step \n",
+    "# in x,z-plane coordinates   \n",
+    "V_e = M @ cell_geometry.I_m[:, -1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plotting\n",
+    "Plot the morphology and extracellular potential prediction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2400x3200 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 1, figsize=(12, 16), dpi=200)\n",
+    "\n",
+    "# plot pcolormesh plot of V_e\n",
+    "im_V_e = ax.pcolormesh(X, Z, V_e.reshape(X.shape), \n",
+    "                        shading='auto', cmap='RdBu', \n",
+    "                        vmin=-abs(V_e).max() / 2, vmax=abs(V_e).max() / 2)\n",
+    "cb = colorbar(fig, ax, im_V_e, height=0.45, voffset=0.55, width=0.02)\n",
+    "cb.set_label('$V_e$ (mV)')\n",
+    "\n",
+    "\n",
+    "# add outline of each CV\n",
+    "norm = plt.Normalize(vmin=-65.2, vmax=-64.8)\n",
+    "colors = [plt.cm.viridis(norm(v)) for v in cell_geometry.V_m[:, -1]]\n",
+    "zips = []\n",
+    "for i in range(I_m.shape[0]):\n",
+    "    inds = CV_ind == i\n",
+    "    zips.append(create_polygon(x[inds, ], z[inds, ], d[inds, ]))\n",
+    "polycol = PolyCollection(zips,\n",
+    "                         edgecolors='k',\n",
+    "                         facecolors=colors,\n",
+    "                         linewidths=0.25)    \n",
+    "im_V_m = ax.add_collection(polycol)\n",
+    "\n",
+    "cb2 = colorbar(fig, ax, im_V_m, height=0.45, width=0.02)\n",
+    "cb2.set_ticks([0, 0.5, 1])\n",
+    "cb2.set_ticklabels([-65.2, -65, -64.8])\n",
+    "cb2.set_label(r'$V_m$ (mV)')\n",
+    "\n",
+    "# outline of segments making up each CV:\n",
+    "if False:\n",
+    "    zips = []\n",
+    "    for x_, z_, d_ in zip(x, z, d):\n",
+    "        zips.append(create_polygon(x_, z_, d_))\n",
+    "    polycol = PolyCollection(zips,\n",
+    "                             edgecolors='k',\n",
+    "                             facecolors='none',\n",
+    "                             linewidths=0.5)\n",
+    "    ax.add_collection(polycol)\n",
+    "\n",
+    "    \n",
+    "ax.set_xlim(X.min(), X.max())\n",
+    "ax.set_ylim(Z.min(), Z.max())\n",
+    "ax.set_xlabel(r'$x$ ($\\mu$m)')\n",
+    "ax.set_ylabel(r'$y$ ($\\mu$m)')\n",
+    "ax.set_aspect('equal')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-0.5, 4999.5, 108.5, -0.5)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x144 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.matshow(cell_geometry.I_m)\n",
+    "plt.colorbar()\n",
+    "plt.axis('tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-0.5, 4999.5, 108.5, -0.5)"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x144 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.matshow(cell_geometry.V_m)\n",
+    "plt.colorbar()\n",
+    "plt.axis('tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.],\n",
+       "       ...,\n",
+       "       [0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.]])"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "I_c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.9.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/benchmarks/alphaisyn.mod b/examples/benchmarks/alphaisyn.mod
new file mode 100644
index 0000000..ff3f37d
--- /dev/null
+++ b/examples/benchmarks/alphaisyn.mod
@@ -0,0 +1,84 @@
+TITLE Alpha-function synaptic current, with NET_RECEIVE
+
+COMMENT
+This model works with variable time-step methods (although it may not
+be very accurate) but at the expense of having to maintain the queues
+of spike times and weights.
+
+Andrew P. Davison, UNIC, CNRS, May 2006
+ENDCOMMENT
+
+DEFINE MAX_SPIKES 1000
+DEFINE CUTOFF 20
+
+NEURON {
+	POINT_PROCESS AlphaISyn
+	RANGE tau, i, q
+	NONSPECIFIC_CURRENT i
+}
+
+UNITS {
+	(nA) = (nanoamp)
+}
+
+PARAMETER {
+	tau = 5 (ms) <1e-9,1e9>
+
+}
+
+ASSIGNED {
+	i (nA)
+	q
+	onset_times[MAX_SPIKES] (ms)
+	weight_list[MAX_SPIKES] (nA)
+}
+
+INITIAL {
+	i  = 0
+	q  = 0 : queue index
+}
+
+BREAKPOINT {
+	LOCAL k, expired_spikes, x
+	i = 0
+	expired_spikes = 0
+	FROM k=0 TO q-1 {
+		x = (t - onset_times[k])/tau
+		if (x > CUTOFF) {
+			expired_spikes = expired_spikes + 1
+		} else {
+			i = i - weight_list[k] * alpha(x)
+		}
+	}
+	update_queue(expired_spikes)
+}
+
+FUNCTION update_queue(n) {
+	LOCAL k
+	:if (n > 0) { printf("Queue changed. t = %4.2f onset_times=[",t) }
+	FROM k=0 TO q-n-1 {
+		onset_times[k] = onset_times[k+n]
+		weight_list[k] = weight_list[k+n]
+		:if (n > 0) { printf("%4.2f ",onset_times[k]) }
+	}
+	:if (n > 0) { printf("]\n") }
+	q = q-n
+}
+
+FUNCTION alpha(x) {
+	if (x < 0) {
+		alpha = 0
+	} else {
+		alpha = x * exp(1 - x)
+	}
+}
+
+NET_RECEIVE(weight (nA)) {
+	onset_times[q] = t
+	weight_list[q] = weight
+	if (q >= MAX_SPIKES-1) {
+		printf("Error in AlphaISyn. Spike queue is full\n")
+	} else {
+		q = q + 1
+	}
+}
diff --git a/examples/benchmarks/arbor_reproducer.py b/examples/benchmarks/arbor_reproducer.py
new file mode 100644
index 0000000..7b1d62b
--- /dev/null
+++ b/examples/benchmarks/arbor_reproducer.py
@@ -0,0 +1,343 @@
+#!/usr/bin/env python
+# coding: utf-8
+'''Record transmembrane currents from populations of neurons 
+in an embarrassengly trivial manner
+'''
+from mpi4py import MPI
+from time import time
+import os
+import sys
+import numpy as np
+import arbor
+import scipy.stats
+from parameters import ParameterSet
+
+#######################################
+# Capture command line values
+#######################################
+md5 = sys.argv[1]
+
+# load parameter file
+pset = ParameterSet(os.path.join('parameters', '{}.txt'.format(md5)))
+
+################# Initialization of MPI stuff ############################
+COMM = MPI.COMM_WORLD
+SIZE = COMM.Get_size()
+RANK = COMM.Get_rank()
+
+# set some seed values
+SEED = pset.GLOBALSEED
+np.random.seed(SEED)
+
+# some parameters
+tstop = 5000
+dt = 0.1
+cellParams = dict(
+            morphology='morphologies/ex.swc',
+            v_init=-65.,
+            cm=1.0,
+            Ra=150,
+            g_pas=1. / (10. * 1E3),  # assume cm=1
+            e_pas=-65,
+            max_cv_length=10,  # µm
+        )
+population_size = pset.POPULATION_SIZE * SIZE
+synapse_count = 500
+CPUs_per_task = pset.CPUS_PER_TASK
+
+
+def get_activation_times_from_distribution(n, tstart=0., tstop=1.E6,
+                                           distribution=scipy.stats.expon,
+                                           rvs_args=dict(loc=0, scale=1),
+                                           maxiter=1E6):
+    """
+    https://lfpy.readthedocs.io/en/latest/classes.html#LFPy.inputgenerators.get_activation_times_from_distribution
+    """
+    assert hasattr(distribution, 'rvs'), 'distribution={} must have the attribute "rvs"'.format(distribution)
+
+    times = []
+    if 'size' in rvs_args.keys():
+        for i in range(n):
+            times += [distribution.rvs(**rvs_args).cumsum() + tstart]
+    else:
+        for i in range(n):
+            values = distribution.rvs(size=1000, **rvs_args).cumsum() + tstart
+            iter = 0
+            while values[-1] < tstop and iter < maxiter:
+                values = np.r_[values, distribution.rvs(
+                    size=1000, **rvs_args).cumsum() + values[-1]]
+                iter += 1
+
+            if iter == maxiter:
+                raise StopIteration('maximum number of iterations reach. Con')
+
+            times += [values[values < tstop]]
+
+    return times
+
+
+class BaseRecipe (arbor.recipe):
+    def __init__(self, cell):
+        super().__init__()
+
+        self.the_cell = cell
+
+        self.iprobe_id = (0, 0)
+
+        self.the_props = arbor.neuron_cable_properties()
+
+    def num_cells(self):
+        return 1
+
+    def num_sources(self, gid):
+        return 0
+
+    def num_targets(self, gid):
+        return 0
+
+    def connections_on(self, gid):
+        return []
+
+    def event_generators(self, gid):
+        return []
+
+    def cell_kind(self, gid):
+        return arbor.cell_kind.cable
+
+    def cell_description(self, gid):
+        return self.the_cell
+
+    def global_properties(self, kind):
+        return self.the_props
+
+    def probes(self, gid):
+        return [
+            arbor.cable_probe_total_current_cell(),
+        ]
+
+
+class Recipe(BaseRecipe):
+    def __init__(self, cell, times=[[1.]], weights=[1.]):
+        super().__init__(cell)
+
+        assert(len(times) == len(weights)), 'len(times) != len(weights)'
+        self.times = times
+        self.weights = weights
+
+    def num_targets(self, gid):
+        return len(self.times)
+
+    def event_generators(self, gid):
+        events = []
+        for i, (w, t) in enumerate(zip(self.weights, self.times)):
+            events += [arbor.event_generator(f'{i}', w,
+                                             arbor.explicit_schedule(t))]
+
+        return events
+
+
+class DummyCell(object):
+    def __init__(self, loc_sets):
+        self.loc_sets = loc_sets
+
+
+class ArborPopulation(object):
+    def __init__(self, cellParams,
+                 dt=0.1, tstop=1000,
+                 population_size=1280,
+                 synapse_count=100,
+                 synapse_rate=20.):
+        self.cellParams=cellParams
+        self.dt = dt
+        self.tstop = tstop
+        self.population_size = population_size
+        self.synapse_count = synapse_count
+        self.synapse_rate = synapse_rate
+
+        self.cellindices = np.arange(self.population_size)
+        self.rank_cellindices = self.cellindices[self.cellindices % SIZE == RANK]
+        # just set all cell locations and rotations the same
+        self.cell_position = {'x': 1., 'y': 2., 'z': 3.}
+        self.cell_rotation = {'z': np.pi}
+
+        # cumulative sim time
+        self.cumul_sim_time = np.array(0.)
+
+    def cellsim(self, cellindex):
+        """
+
+        Parameters
+        ----------
+        cellindex : int
+            cell index between 0 and population size-1.
+
+        Returns
+        -------
+        None
+        """
+        tic = time()
+
+        # cell decor
+        decor = (
+                arbor.decor()
+                # set initial voltage, temperature, axial resistivity, membrane capacitance
+                .set_property(
+                    Vm=self.cellParams['v_init'],  # Initial membrane voltage (mV)
+                    tempK=300,  # Temperature (Kelvin)
+                    rL=self.cellParams['Ra'],  # Axial resistivity (Ω cm)
+                    cm=self.cellParams['cm'] * 1E-2,  # Membrane capacitance (F/m**2)
+                )
+                # set passive mechanism all over
+                # passive mech w. leak reversal potential (mV)
+                .paint("(all)", 
+                       arbor.density(f"pas/e={self.cellParams['e_pas']}", 
+                                     {"g": self.cellParams['g_pas']}))
+        )
+
+        # number of CVs per branch
+        policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
+        decor.discretization(policy)
+
+        # define morphology (needed for arbor.place_pwlin etc.)
+        morphology = arbor.load_swc_arbor(self.cellParams['morphology'])
+
+        # Label dictionary
+        defs = {}
+        labels = arbor.label_dict(defs)
+
+        # define isometry
+        iso = arbor.isometry()  # create isometry
+        for key, val in self.cell_rotation.items():
+            args = {
+                'theta': float(val),
+                'axis': tuple((np.array(['x', 'y', 'z']) == key).astype('float'))}
+            iso_rot = iso.rotate(**args)
+        iso_trans = iso.translate(**self.cell_position)
+
+        # place_pwlin
+        p = arbor.place_pwlin(morphology, iso_rot * iso_trans)  # place with isometry
+
+        # need dummycell geometry object
+        loc_sets = self.get_loc_sets(p, morphology, labels, decor)
+
+        # get transmembrane currents
+        return self.get_I_m(loc_sets, cellindex, decor, morphology, labels)
+
+    def instantiate_sim(self, recipe):
+        context = arbor.context(threads=1, gpu_id=None, mpi=None)
+        domains = arbor.partition_load_balance(recipe, context)
+        return arbor.simulation(recipe, context, domains)
+
+    def get_loc_sets(self, p, morphology, labels, decor):
+        # create cell and set properties
+        cable_cell = arbor.cable_cell(morphology, labels, decor)
+
+        # instantiate recipe with cell
+        recipe = BaseRecipe(cable_cell)
+
+        # instantiate simulation
+        sim = self.instantiate_sim(recipe)
+
+        # set up sampling on probes
+        schedule = arbor.regular_schedule(1.)
+        i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
+
+        # need meta data locating each CV
+        _, I_m_meta = sim.samples(i_handle)[0]
+
+        # define a list of loc_sets with relative location in between proximal and distal points of each CV
+        loc_sets = np.array([
+            '(location {} {})'.format(c.branch, np.mean([c.prox, c.dist])) for c in I_m_meta
+        ])
+
+        # clear
+        sim.reset()
+
+        return loc_sets
+
+    def get_I_m(self, loc_sets, cellindex, decor, morphology, labels):
+        # fetch synaptic activation times, synapse weights, and random locations
+        # corresponding to each CV midpoint.
+        times = get_activation_times_from_distribution(n=self.synapse_count,
+                                                       tstart=0.,
+                                                       tstop=self.tstop,
+                                                       distribution=scipy.stats.expon,
+                                                       rvs_args=dict(loc=0.,
+                                                                     scale=1000 / self.synapse_rate)
+                                                      )
+        weights = np.random.randn(self.synapse_count)
+        syn_loc_sets = np.random.choice(loc_sets, size=self.synapse_count)
+
+        # create synapses at each loc_set
+        synapse = 'expsyn_curr'
+        synapse_params = {'tau': 5.}
+        for i, loc_set in enumerate(syn_loc_sets):
+            decor.place(loc_set, arbor.synapse(synapse, synapse_params), f'{i}')
+
+        # number of CVs per branch
+        policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
+        decor.discretization(policy)
+
+        # create cell and set properties
+        cable_cell = arbor.cable_cell(morphology, labels, decor)
+
+        # instantiate recipe with cable_cell
+        recipe = Recipe(cable_cell, weights=weights, times=times)
+
+        # instantiate simulation
+        sim = self.instantiate_sim(recipe)
+
+        # set up sampling on probes
+        schedule = arbor.regular_schedule(1)
+        i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
+
+        # run simulation of transmembrane currents with timing
+        tic = time()
+        self._bench_sim_run(sim)
+        toc = time()
+        self.cumul_sim_time += toc - tic
+
+        # extract I_m for each CV
+        I_m_samples, _ = sim.samples(i_handle)[0]
+
+        # clear
+        sim.reset()
+
+        # transmembrane currents in nA
+        return I_m_samples[:, 1:]
+
+    def _bench_sim_run(self, sim):
+        sim.run(tfinal=self.tstop, dt=self.dt)
+
+    def run(self):
+        for cellindex in self.rank_cellindices:
+            _ = self.cellsim(cellindex)
+
+# create population
+pop = ArborPopulation(
+    cellParams=cellParams,
+    dt=dt,
+    tstop=tstop,
+    population_size=population_size,
+    synapse_count=synapse_count,
+)
+
+# run population simulation and collect the data
+pop.run()
+
+# compute mean time spent calling arbor.simulation.run() per MPI process
+if RANK == 0:
+    tocc_run = np.array(0.)
+else:
+    tocc_run = None
+
+COMM.Reduce(pop.cumul_sim_time, tocc_run, op=MPI.SUM, root=0)
+if RANK == 0:
+    tocc_run /= SIZE
+    with open(os.path.join('logs', f'NTASKS_{SIZE}_CPUS_PER_TASK_{CPUs_per_task}.txt'), 'w') as f:
+        f.write(f'{float(tocc_run)}')
+
+    print(SIZE, CPUs_per_task, tocc_run)
+
+# clean exit?
+COMM.Barrier()
diff --git a/examples/benchmarks/brunel_alpha_nest.py b/examples/benchmarks/brunel_alpha_nest.py
new file mode 100755
index 0000000..f85d1f3
--- /dev/null
+++ b/examples/benchmarks/brunel_alpha_nest.py
@@ -0,0 +1,438 @@
+#!/usr/env/bin python
+# -*- coding: utf-8 -*-
+#
+# brunel_alpha_nest.py
+#
+# This file is part of NEST.
+#
+# Copyright (C) 2004 The NEST Initiative
+#
+# NEST is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# NEST is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with NEST.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Modified as an example with hybridLFPy (https:/github.com/INM-6/hybridLFPy)
+# for calculating local field potentials from spiking point-neuron networks
+
+"""
+Random balanced network (alpha synapses) connected with NEST
+------------------------------------------------------------
+
+This script simulates an excitatory and an inhibitory population on
+the basis of the network used in
+
+Brunel N, Dynamics of Sparsely Connected Networks of Excitatory and
+Inhibitory Spiking Neurons, Journal of Computational Neuroscience 8,
+183-208 (2000).
+
+In contrast to brunel-alpha-numpy.py, this variant uses NEST's builtin
+connection routines to draw the random connections instead of NumPy.
+
+When connecting the network customary synapse models are used, which
+allow for querying the number of created synapses. Using spike
+detectors the average firing rates of the neurons in the populations
+are established. The building as well as the simulation time of the
+network are recorded.
+"""
+
+"""
+Importing all necessary modules for simulation, analysis and plotting.
+"""
+
+
+'''
+Definition of functions used in this example. First, define the
+Lambert W function implemented in SLI. The second function
+computes the maximum of the postsynaptic potential for a synaptic
+input current of unit amplitude (1 pA) using the Lambert W
+function. Thus function will later be used to calibrate the synaptic
+weights.
+'''
+
+
+
+
+from scipy.optimize import fsolve
+import nest
+import nest.raster_plot
+import os
+import time
+from numpy import exp, random
+def LambertWm1(x):
+    nest.ll_api.sli_push(x)
+    nest.ll_api.sli_run('LambertWm1')
+    y = nest.ll_api.sli_pop()
+    return y
+
+
+def ComputePSPnorm(tauMem, CMem, tauSyn):
+    a = (tauMem / tauSyn)
+    b = (1.0 / tauSyn - 1.0 / tauMem)
+
+    # time of maximum
+    t_max = 1.0 / b * (-LambertWm1(-exp(-1.0 / a) / a) - 1.0 / a)
+
+    # maximum of PSP for current of unit amplitude
+    return exp(1.0) / (tauSyn * CMem * b) * ((exp(-t_max / tauMem) - \
+               exp(-t_max / tauSyn)) / b - t_max * exp(-t_max / tauSyn))
+
+
+'''
+Assigning the current time to a variable in order to determine the
+build time of the network.
+'''
+
+startbuild = time.time()
+
+'''
+Assigning the simulation parameters to variables.
+'''
+
+dt = 0.1    # the resolution in ms
+simtime = 2000.0  # Simulation time in ms
+delay = 1.5    # synaptic delay in ms
+
+'''
+Definition of the parameters crucial for asynchronous irregular firing
+of the neurons.
+'''
+
+g = 6.0  # ratio inhibitory weight/excitatory weight
+eta = 2.0  # external rate relative to threshold rate
+epsilon = 0.1  # connection probability
+
+'''
+Definition of the number of neurons in the network and the number of
+neuron recorded from.
+
+Note: We record here all spike events.
+'''
+
+order = 512
+NE = 4 * order  # number of excitatory neurons
+NI = 1 * order  # number of inhibitory neurons
+N_neurons = NE + NI   # number of neurons in total
+
+'''
+flag for using Poisson or equivalent DC current external drive
+'''
+
+Poisson = False
+
+'''
+Definition of connectivity parameter
+'''
+
+CE = int(epsilon * NE)  # number of excitatory synapses per neuron
+CI = int(epsilon * NI)  # number of inhibitory synapses per neuron
+C_tot = int(CI + CE)      # total number of synapses per neuron
+
+'''
+Initialization of the parameters of the integrate and fire neuron and
+the synapses. The parameter of the neuron are stored in a dictionary.
+The synaptic currents are normalized such that the amplitude of the
+PSP is J.
+'''
+
+tauSyn = 0.5        # synaptic time constant in ms
+tauMem = 20.0       # time constant of membrane potential in ms
+CMem = 250.0        # capacitance of membrane in in pF
+theta = 20.0       # membrane threshold potential in mV
+J = 1.0 * 100 / order        # postsynaptic amplitude in mV + 1/K weight scaling
+J_unit = ComputePSPnorm(tauMem, CMem, tauSyn)
+J_ex = J / J_unit  # amplitude of excitatory postsynaptic current
+J_in = -g * J_ex    # amplitude of inhibitory postsynaptic current
+
+'''
+Definition of threshold rate, which is the external rate needed to fix
+the membrane potential around its threshold, the external firing rate
+and the rate of the poisson generator which is multiplied by the
+in-degree CE and converted to Hz by multiplication by 1000.
+'''
+
+nu_th = (theta * CMem) / (J_ex * CE * exp(1) * tauMem * tauSyn)
+nu_ex = eta * nu_th
+p_rate = 1000.0 * nu_ex * CE
+
+'''
+Adjust parameters accordingly if Poisson background input is used
+'''
+
+if Poisson:
+    # use zero dc input amplitude to the neurons
+    dc_amplitude = 0.
+else:
+    # compute equivalent DC current amplitude instead of Poisson input assuming
+    # alpha current synapse
+    factor = 0.4  # CHECK
+    dc_amplitude = p_rate * J_ex / 1000 / tauSyn * factor
+
+'''
+Parameters for "iaf_psc_alpha" cell model
+'''
+
+neuron_params = {"C_m": CMem,
+                 "tau_m": tauMem,
+                 "tau_syn_ex": tauSyn,
+                 "tau_syn_in": tauSyn,
+                 "t_ref": 2.0,
+                 "E_L": 0.0,
+                 "V_reset": 0.0,
+                 "V_th": 20.0,
+                 "V_m": 0.0,
+                 "V_th": theta,
+                 "I_e": dc_amplitude, }
+'''
+Destination of file output
+'''
+
+spike_output_path = os.path.join('simulation_output_example_brunel',
+                                 'spiking_output_path')
+
+'''
+File prefix for spike detectors
+'''
+
+label = 'brunel-py'
+
+'''
+Main simulation procedure function
+'''
+
+
+def simulate():
+    '''instantiate and execute network simulation'''
+    # separate model execution from parameters for safe import from other files
+    nest.ResetKernel()
+
+    '''
+    Configuration of the simulation kernel by the previously defined time
+    resolution used in the simulation. Setting "print_time" to True prints
+    the already processed simulation time as well as its percentage of the
+    total simulation time.
+    '''
+
+    nest.SetKernelStatus({"resolution": dt, "print_time": True,
+                          "overwrite_files": True})
+
+    print("Building network")
+
+    '''
+    Configuration of the model `iaf_psc_alpha` and `poisson_generator`
+    using SetDefaults(). This function expects the model to be the
+    inserted as a string and the parameter to be specified in a
+    dictionary. All instances of theses models created after this point
+    will have the properties specified in the dictionary by default.
+    '''
+
+    nest.SetDefaults("iaf_psc_alpha", neuron_params)
+    nest.SetDefaults("poisson_generator", {"rate": p_rate})
+
+    '''
+    Creation of the nodes using `Create`. We store the returned handles in
+    variables for later reference. Here the excitatory and inhibitory, as
+    well as the poisson generator and two spike detectors. The spike
+    detectors will later be used to record excitatory and inhibitory
+    spikes.
+    '''
+
+    nodes_ex = nest.Create("iaf_psc_alpha", NE)
+    nodes_in = nest.Create("iaf_psc_alpha", NI)
+    noise = nest.Create("poisson_generator")
+    espikes = nest.Create("spike_recorder")
+    ispikes = nest.Create("spike_recorder")
+
+    print("first exc node: {}".format(nodes_ex[0]))
+    print("first inh node: {}".format(nodes_in[0]))
+
+    '''
+    distribute membrane potentials
+    '''
+    nest.SetStatus(nodes_ex, "V_m",
+                   random.rand(len(nodes_ex)) * neuron_params["V_th"])
+    nest.SetStatus(nodes_in, "V_m",
+                   random.rand(len(nodes_in)) * neuron_params["V_th"])
+
+    '''
+    Configuration of the spike detectors recording excitatory and
+    inhibitory spikes using `SetStatus`, which expects a list of node
+    handles and a list of parameter dictionaries. Setting the variable
+    "to_file" to True ensures that the spikes will be recorded in a .gdf
+    file starting with the string assigned to label. Setting "withtime"
+    and "withgid" to True ensures that each spike is saved to file by
+    stating the gid of the spiking neuron and the spike time in one line.
+    '''
+
+    nest.SetStatus(espikes, [{
+        "label": os.path.join(spike_output_path, label + "-EX"),
+        "record_to": 'ascii',
+    }])
+
+    nest.SetStatus(ispikes, [{
+        "label": os.path.join(spike_output_path, label + "-IN"),
+        "record_to": 'ascii', }])
+
+    print("Connecting devices")
+
+    '''
+    Definition of a synapse using `CopyModel`, which expects the model
+    name of a pre-defined synapse, the name of the customary synapse and
+    an optional parameter dictionary. The parameters defined in the
+    dictionary will be the default parameter for the customary
+    synapse. Here we define one synapse for the excitatory and one for the
+    inhibitory connections giving the previously defined weights and equal
+    delays.
+    '''
+
+    nest.CopyModel(
+        "static_synapse", "excitatory", {
+            "weight": J_ex, "delay": delay})
+    nest.CopyModel(
+        "static_synapse", "inhibitory", {
+            "weight": J_in, "delay": delay})
+
+    '''
+    Connecting the previously defined poisson generator to the excitatory
+    and inhibitory neurons using the excitatory synapse. Since the poisson
+    generator is connected to all neurons in the population the default
+    rule ('all_to_all') of Connect() is used. The synaptic properties are
+    inserted via syn_spec which expects a dictionary when defining
+    multiple variables or a string when simply using a pre-defined
+    synapse.
+    '''
+
+    if Poisson:
+        nest.Connect(noise, nodes_ex, 'all_to_all', "excitatory")
+        nest.Connect(noise, nodes_in, 'all_to_all', "excitatory")
+
+    '''
+    Connecting the first N_neurons nodes of the excitatory and inhibitory
+    population to the associated spike detectors using excitatory
+    synapses. Here the same shortcut for the specification of the synapse
+    as defined above is used.
+    '''
+
+    nest.Connect(nodes_ex, espikes, 'all_to_all', "excitatory")
+    nest.Connect(nodes_in, ispikes, 'all_to_all', "excitatory")
+
+    print("Connecting network")
+
+    print("Excitatory connections")
+
+    '''
+    Connecting the excitatory population to all neurons using the
+    pre-defined excitatory synapse. Beforehand, the connection parameter
+    are defined in a dictionary. Here we use the connection rule
+    'fixed_indegree', which requires the definition of the indegree. Since
+    the synapse specification is reduced to assigning the pre-defined
+    excitatory synapse it suffices to insert a string.
+    '''
+
+    conn_params_ex = {'rule': 'fixed_indegree', 'indegree': CE}
+    nest.Connect(nodes_ex, nodes_ex + nodes_in, conn_params_ex, "excitatory")
+
+    print("Inhibitory connections")
+
+    '''
+    Connecting the inhibitory population to all neurons using the
+    pre-defined inhibitory synapse. The connection parameter as well as
+    the synapse paramtere are defined analogously to the connection from
+    the excitatory population defined above.
+    '''
+
+    conn_params_in = {'rule': 'fixed_indegree', 'indegree': CI}
+    nest.Connect(nodes_in, nodes_ex + nodes_in, conn_params_in, "inhibitory")
+
+    '''
+    Storage of the time point after the buildup of the network in a
+    variable.
+    '''
+
+    endbuild = time.time()
+
+    '''
+    Simulation of the network.
+    '''
+
+    print("Simulating")
+
+    nest.Simulate(simtime)
+
+    '''
+    Storage of the time point after the simulation of the network in a
+    variable.
+    '''
+
+    endsimulate = time.time()
+
+    '''
+    Reading out the total number of spikes received from the spike
+    detector connected to the excitatory population and the inhibitory
+    population.
+    '''
+
+    events_ex = nest.GetStatus(espikes, "n_events")[0]
+    events_in = nest.GetStatus(ispikes, "n_events")[0]
+
+    '''
+    Calculation of the average firing rate of the excitatory and the
+    inhibitory neurons by dividing the total number of recorded spikes by
+    the number of neurons recorded from and the simulation time. The
+    multiplication by 1000.0 converts the unit 1/ms to 1/s=Hz.
+    '''
+
+    rate_ex = events_ex / simtime * 1000.0 / N_neurons
+    rate_in = events_in / simtime * 1000.0 / N_neurons
+
+    '''
+    Reading out the number of connections established using the excitatory
+    and inhibitory synapse model. The numbers are summed up resulting in
+    the total number of synapses.
+    '''
+
+    num_synapses = nest.GetDefaults("excitatory")["num_connections"] +\
+        nest.GetDefaults("inhibitory")["num_connections"]
+
+    '''
+    Establishing the time it took to build and simulate the network by
+    taking the difference of the pre-defined time variables.
+    '''
+
+    build_time = endbuild - startbuild
+    sim_time = endsimulate - endbuild
+
+    '''
+    Printing the network properties, firing rates and building times.
+    '''
+
+    print("Brunel network simulation (Python)")
+    print("Number of neurons : {0}".format(N_neurons))
+    print("Number of synapses: {0}".format(num_synapses))
+    print("       Exitatory  : {0}".format(int(CE * N_neurons) + N_neurons))
+    print("       Inhibitory : {0}".format(int(CI * N_neurons)))
+    print("Excitatory rate   : %.2f Hz" % rate_ex)
+    print("Inhibitory rate   : %.2f Hz" % rate_in)
+    print("Building time     : %.2f s" % build_time)
+    print("Simulation time   : %.2f s" % sim_time)
+
+    '''
+    Plot a raster of the excitatory neurons and a histogram.
+    '''
+
+    if False:
+        nest.raster_plot.from_device(espikes, hist=True)
+        nest.raster_plot.from_device(ispikes, hist=True)
+        nest.raster_plot.show()
+
+
+if __name__ == '__main__':
+    simulate()
diff --git a/examples/benchmarks/example_brunel.py b/examples/benchmarks/example_brunel.py
new file mode 100644
index 0000000..61a7713
--- /dev/null
+++ b/examples/benchmarks/example_brunel.py
@@ -0,0 +1,462 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''
+Hybrid LFP scheme example script, applying the methodology with a model
+implementation similar to:
+
+Nicolas Brunel. "Dynamics of Sparsely Connected Networks of Excitatory and
+Inhibitory Spiking Neurons". J Comput Neurosci, May 2000, Volume 8,
+Issue 3, pp 183-208
+
+
+Synopsis of the main simulation procedure:
+1. Loading of parameterset
+    a. network parameters
+    b. parameters for hybrid scheme
+2. Set up file destinations for different simulation output
+3. network simulation
+    a. execute network simulation using NEST (www.nest-initiative.org)
+    b. merge network output (spikes, currents, voltages)
+4. Create a object-representation that uses sqlite3 of all the spiking output
+5. Iterate over post-synaptic populations:
+    a. Create Population object with appropriate parameters for
+       each specific population
+    b. Run all computations for populations
+    c. Postprocess simulation output of all cells in population
+6. Postprocess all cell- and population-specific output data
+7. Create a tarball for all non-redundant simulation output
+
+The full simulation can be evoked by issuing a mpirun call, such as
+mpirun -np 4 python example_brunel.py
+
+Not recommended, but running it serially should also work, e.g., calling
+python example_brunel.py
+
+'''
+# from example_plotting import *
+import brunel_alpha_nest as BN
+import lfpykit
+from mpi4py import MPI
+import h5py
+from parameters import ParameterSet
+from hybridLFPy import PostProcess, Population, CachedNetwork, setup_file_dest
+import nest  # import not used, but we load NEST anyway in order determine if
+import neuron  # NEURON compiled with MPI must be imported before NEST/mpi4py
+from time import time
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import os
+import sys
+import numpy as np
+if 'DISPLAY' not in os.environ:
+    import matplotlib
+    matplotlib.use('Agg')
+import matplotlib.style
+matplotlib.style.use('classic')
+# to avoid being aware of MPI
+# network is run in parallel
+
+
+########## matplotlib settings ###########################################
+plt.close('all')
+plt.rcParams.update({'figure.figsize': [10.0, 8.0]})
+
+#######################################
+# Capture command line values
+#######################################
+# load parameter file
+md5 = sys.argv[1]
+pset = ParameterSet(os.path.join('parameters', '{}.txt'.format(md5)))
+
+# set some seed values
+SEED = pset.GLOBALSEED
+SIMULATIONSEED = pset.GLOBALSEED + 1234
+np.random.seed(SEED)
+
+
+################# Initialization of MPI stuff ############################
+COMM = MPI.COMM_WORLD
+SIZE = COMM.Get_size()
+RANK = COMM.Get_rank()
+
+# if True, execute full model. If False, do only the plotting.
+# Simulation results must exist.
+properrun = True
+
+
+# check if mod file for synapse model specified in alphaisyn.mod is loaded
+if not hasattr(neuron.h, 'AlphaISyn'):
+    if RANK == 0:
+        os.system('nrnivmodl')
+    COMM.Barrier()
+    neuron.load_mechanisms('.')
+
+
+##########################################################################
+# PARAMETERS
+##########################################################################
+
+# Set up parameters using the NeuroTools.parameters.ParameterSet class.
+
+# Access parameters defined in example script implementing the network using
+# pynest, brunel_alpha_nest.py, adapted from the NEST v2.4.1 release. This will
+# not execute the network model, but see below.
+
+
+# set up file destinations differentiating between certain output
+savefolder = md5
+BN.spike_output_path = os.path.join(savefolder, 'spiking_output_path')
+PS = ParameterSet(dict(
+    # Main folder of simulation output
+    savefolder=savefolder,  # 'simulation_output_example_brunel',
+
+    # make a local copy of main files used in simulations
+    sim_scripts_path=os.path.join(savefolder, 'sim_scripts'),
+
+    # destination of single-cell output during simulation
+    cells_path=os.path.join(savefolder, 'cells'),
+
+    # destination of cell- and population-specific signals, i.e., compund LFPs,
+    # CSDs etc.
+    populations_path=os.path.join(savefolder, 'populations'),
+
+    # location of spike output from the network model
+    spike_output_path=BN.spike_output_path,
+
+    # destination of figure file output generated during model execution
+    figures_path=os.path.join(savefolder, 'figures')
+))
+
+
+# population (and cell type) specific parameters
+PS.update(dict(
+    # no cell type specificity within each E-I population
+    # hence X == x and Y == X
+    X=["EX", "IN"],
+
+    # population-specific LFPy.Cell parameters
+    cellParams=dict(
+        # excitory cells
+        EX=dict(
+            morphology='morphologies/ex.swc',
+            v_init=BN.neuron_params['E_L'],
+            cm=1.0,
+            Ra=150,
+            passive=True,
+            passive_parameters=dict(
+                g_pas=1. / (BN.neuron_params['tau_m'] * 1E3),  # assume cm=1
+                e_pas=BN.neuron_params['E_L']),
+            nsegs_method='fixed_length',  # 'lambda_f',
+            max_nsegs_length=10.,
+            # lambda_f=100,
+            dt=BN.dt,
+            tstart=0,
+            tstop=BN.simtime,
+            verbose=False,
+        ),
+        # inhibitory cells
+        IN=dict(
+            morphology='morphologies/in.swc',
+            v_init=BN.neuron_params['E_L'],
+            cm=1.0,
+            Ra=150,
+            passive=True,
+            passive_parameters=dict(
+                g_pas=1. / (BN.neuron_params['tau_m'] * 1E3),  # assume cm=1
+                e_pas=BN.neuron_params['E_L']),
+            nsegs_method='fixed_length',  # 'lambda_f',
+            max_nsegs_length=10.,
+            # lambda_f=100,
+            dt=BN.dt,
+            tstart=0,
+            tstop=BN.simtime,
+            verbose=False,
+        )),
+
+    # assuming excitatory cells are pyramidal
+    rand_rot_axis=dict(
+        EX=['z'],
+        IN=['x', 'y', 'z'],
+    ),
+
+
+    # kwargs passed to LFPy.Cell.simulate().
+    # It can be empty, but if `rec_imem=True`, the signal predictions will be
+    # performed using recorded transmembrane currents.
+    simulationParams=dict(rec_imem=True),
+
+    # set up parameters corresponding to cylindrical model populations
+    populationParams=dict(
+        EX=dict(
+            number=BN.NE,
+            radius=100,
+            z_min=-450,
+            z_max=-350,
+            min_cell_interdist=1.,
+            min_r=[[-1E199, -600, -550, 1E99], [0, 0, 10, 10]],
+        ),
+        IN=dict(
+            number=BN.NI,
+            radius=100,
+            z_min=-450,
+            z_max=-350,
+            min_cell_interdist=1.,
+            min_r=[[-1E199, -600, -550, 1E99], [0, 0, 10, 10]],
+        ),
+    ),
+
+    # set the boundaries between the "upper" and "lower" layer
+    layerBoundaries=[[0., -300],
+                     [-300, -500]],
+
+    # set the geometry of the virtual recording device
+    electrodeParams=dict(
+        # contact locations:
+        x=[0] * 6,
+        y=[0] * 6,
+        z=[x * -100. for x in range(6)],
+        # extracellular conductivity:
+        sigma=0.3,
+        # contact surface normals, radius, n-point averaging
+        N=[[1, 0, 0]] * 6,
+        r=5,
+        n=20,
+        seedvalue=None,
+        # dendrite line sources, soma as sphere source (Linden2014)
+        method='root_as_point',
+    ),
+
+    # parameters for LFPykit.LaminarCurrentSourceDensity
+    CSDParams=dict(
+        z=np.array([[-(i + 1) * 100, -i * 100] for i in range(6)]) + 50.,
+        r=np.ones(6) * 100  # same as population radius
+    ),
+
+    # runtime, cell-specific attributes and output that will be stored
+    savelist=[],
+
+    # time resolution of saved signals
+    dt_output=1.
+))
+
+
+# for each population, define layer- and population-specific connectivity
+# parameters
+PS.update(dict(
+    # number of connections from each presynaptic population onto each
+    # layer per postsynaptic population, preserving overall indegree
+    k_yXL=dict(
+        EX=[[int(0.5 * BN.CE), 0],
+            [int(0.5 * BN.CE), BN.CI]],
+        IN=[[0, 0],
+            [BN.CE, BN.CI]],
+    ),
+
+    # set up table of synapse weights from each possible presynaptic population
+    J_yX=dict(
+        EX=[BN.J_ex * 1E-3, BN.J_in * 1E-3],
+        IN=[BN.J_ex * 1E-3, BN.J_in * 1E-3],
+    ),
+
+    # set up synapse parameters as derived from the network
+    synParams=dict(
+        EX=dict(
+            section=['apic', 'dend', 'soma'],
+            # section=['apic', 'dend'],
+            # tau = [BN.tauSyn, BN.tauSyn],
+            syntype='AlphaISyn'
+        ),
+        IN=dict(
+            section=['apic', 'dend', 'soma'],
+            # section=['dend', 'soma'],
+            # tau = [BN.tauSyn, BN.tauSyn],
+            syntype='AlphaISyn'
+        ),
+    ),
+
+    # set up table of synapse time constants from each presynaptic populations
+    tau_yX=dict(
+        EX=[BN.tauSyn, BN.tauSyn],
+        IN=[BN.tauSyn, BN.tauSyn]
+    ),
+
+    # set up delays, here using fixed delays of network
+    synDelayLoc=dict(
+        EX=[BN.delay, BN.delay],
+        IN=[BN.delay, BN.delay],
+    ),
+    # no distribution of delays
+    synDelayScale=dict(
+        EX=[None, None],
+        IN=[None, None],
+    ),
+))
+
+
+# putative mappting between population type and cell type specificity,
+# but here all presynaptic senders are also postsynaptic targets
+PS.update(dict(
+    mapping_Yy=list(zip(PS.X, PS.X))
+))
+
+
+# In[2]:
+
+
+##########################################################################
+# MAIN simulation procedure                                              #
+##########################################################################
+
+# tic toc
+tic = time()
+
+######### Perform network simulation #####################################
+if properrun:
+    # set up the file destination, removing old results by default
+    setup_file_dest(PS, clearDestination=True)
+
+if properrun:
+    # execute network simulation
+    BN.simulate()
+
+# wait for the network simulation to finish, resync MPI threads
+COMM.Barrier()
+
+# Create an object representation containing the spiking activity of the network
+# simulation output that uses sqlite3. Again, kwargs are derived from the brunel
+# network instance.
+networkSim = CachedNetwork(
+    simtime=BN.simtime,
+    dt=BN.dt,
+    spike_output_path=BN.spike_output_path,
+    label=BN.label,
+    ext='dat',
+    GIDs={'EX': [1, BN.NE], 'IN': [BN.NE + 1, BN.NI]},
+    X=['EX', 'IN'],
+    cmap='rainbow_r',
+    skiprows=3,
+)
+
+
+if RANK == 0:
+    toc = time() - tic
+    print('NEST simulation and gdf file processing done in  %.3f seconds' % toc)
+
+
+# Set up LFPykit measurement probes for LFPs and CSDs
+if properrun:
+    probes = []
+    probes.append(lfpykit.RecExtElectrode(cell=None, **PS.electrodeParams))
+    probes.append(
+        lfpykit.LaminarCurrentSourceDensity(
+            cell=None, **PS.CSDParams))
+
+
+# In[3]:
+
+# measure population simulation times including setup etc.
+ticc = time()
+
+# arbor sim.run cumulative time
+ticc_run = np.array(0.)
+
+# %%prun -s cumulative -q -l 20 -T prun0
+####### Set up populations ###############################################
+if properrun:
+    # iterate over each cell type, and create populationulation object
+    for i, Y in enumerate(PS.X):
+        # create population:
+        pop = Population(
+            cellParams=PS.cellParams[Y],
+            rand_rot_axis=PS.rand_rot_axis[Y],
+            simulationParams=PS.simulationParams,
+            populationParams=PS.populationParams[Y],
+            y=Y,
+            layerBoundaries=PS.layerBoundaries,
+            savelist=PS.savelist,
+            savefolder=PS.savefolder,
+            probes=probes,
+            dt_output=PS.dt_output,
+            POPULATIONSEED=SIMULATIONSEED + i,
+            X=PS.X,
+            networkSim=networkSim,
+            k_yXL=PS.k_yXL[Y],
+            synParams=PS.synParams[Y],
+            synDelayLoc=PS.synDelayLoc[Y],
+            synDelayScale=PS.synDelayScale[Y],
+            J_yX=PS.J_yX[Y],
+            tau_yX=PS.tau_yX[Y],
+        )
+
+        # run population simulation and collect the data
+        pop.run()
+        pop.collect_data()
+
+        # arbor sim.run cumulative time
+        ticc_run += pop._cumulative_sim_time
+
+        # object no longer needed
+        del pop
+
+# tic toc
+tocc = time() - ticc
+if RANK == 0:
+    with open(os.path.join(savefolder, 'time_pop.txt'), 'w') as f:
+        f.write(f'{tocc}')
+
+if RANK == 0:
+    tocc_run = np.zeros_like(ticc_run)
+else:
+    tocc_run = None
+
+COMM.Reduce(ticc_run, tocc_run, op=MPI.SUM, root=0)
+if RANK == 0:
+    tocc_run /= SIZE
+    with open(os.path.join(savefolder, 'time_run.txt'), 'w') as f:
+        f.write(f'{float(tocc_run)}')
+
+# In[4]:
+
+
+# print(open('prun0', 'r').read())
+
+
+# In[5]:
+
+
+####### Postprocess the simulation output ################################
+
+
+# reset seed, but output should be deterministic from now on
+np.random.seed(SIMULATIONSEED)
+
+if properrun:
+    # do some postprocessing on the collected data, i.e., superposition
+    # of population LFPs, CSDs etc
+    postproc = PostProcess(y=PS.X,
+                           dt_output=PS.dt_output,
+                           savefolder=PS.savefolder,
+                           mapping_Yy=PS.mapping_Yy,
+                           savelist=PS.savelist,
+                           probes=probes,
+                           cells_subfolder=os.path.split(PS.cells_path)[-1],
+                           populations_subfolder=os.path.split(PS.populations_path)[-1],
+                           figures_subfolder=os.path.split(PS.figures_path)[-1])
+
+    # run through the procedure
+    postproc.run()
+
+    # create tar-archive with output for plotting, ssh-ing etc.
+    postproc.create_tar_archive()
+
+
+COMM.Barrier()
+
+# tic toc
+print('Execution time: %.3f seconds' % (time() - tic))
diff --git a/examples/benchmarks/example_brunel_arbor.py b/examples/benchmarks/example_brunel_arbor.py
new file mode 100644
index 0000000..cb2a301
--- /dev/null
+++ b/examples/benchmarks/example_brunel_arbor.py
@@ -0,0 +1,1024 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+# %matplotlib inline
+
+
+# Hybrid LFP scheme example script, applying the methodology with a model
+# implementation similar to:
+#
+# Nicolas Brunel. "Dynamics of Sparsely Connected Networks of Excitatory and
+# Inhibitory Spiking Neurons". J Comput Neurosci, May 2000, Volume 8,
+# Issue 3, pp 183-208
+#
+#
+# Synopsis of the main simulation procedure:
+#
+#     1. Loading of parameterset
+#         a. network parameters
+#         b. parameters for hybrid scheme
+#     2. Set up file destinations for different simulation output
+#     3. network simulation
+#         a. execute network simulation using NEST (www.nest-initiative.org)
+#         b. merge network output (spikes, currents, voltages)
+#     4. Create a object-representation that uses sqlite3 of all the spiking output
+#     5. Iterate over post-synaptic populations:
+#         a. Create Population object with appropriate parameters for each specific population
+#         b. Run all computations for populations
+#         c. Postprocess simulation output of all cells in population
+#     6. Postprocess all cell- and population-specific output data
+#     7. Create a tarball for all non-redundant simulation output
+#
+# The full simulation can be evoked by issuing a mpirun call, such as
+# mpirun -np 4 python example_brunel.py
+#
+# Not recommended, but running it serially should also work, e.g., calling
+# python example_brunel.py
+
+# In[2]:
+
+
+# from example_plotting import *
+import brunel_alpha_nest as BN
+import lfpykit
+from mpi4py import MPI
+import h5py
+from parameters import ParameterSet
+from hybridLFPy import PostProcess, Population, CachedNetwork, setup_file_dest
+import nest  # import not used, but we load NEST anyway in order determine if
+import neuron  # NEURON compiled with MPI must be imported before NEST/mpi4py
+from time import time
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import os
+import sys
+import numpy as np
+import scipy.stats as st
+import scipy.signal as ss
+from LFPy.alias_method import alias_method
+import arbor
+if 'DISPLAY' not in os.environ:
+    import matplotlib
+    matplotlib.use('Agg')
+import matplotlib.style
+matplotlib.style.use('classic')
+# to avoid being aware of MPI
+# network is run in parallel
+
+
+# In[3]:
+
+
+########## matplotlib settings ###########################################
+# plt.close('all')
+plt.rcParams.update({'figure.figsize': [10.0, 8.0]})
+
+#######################################
+# Capture command line values
+#######################################
+# load parameter file
+md5 = sys.argv[1]
+pset = ParameterSet(os.path.join('parameters', '{}.txt'.format(md5)))
+
+# set some seed values
+SEED = pset.GLOBALSEED
+SIMULATIONSEED = pset.GLOBALSEED + 1234
+np.random.seed(SEED)
+
+
+################# Initialization of MPI stuff ############################
+COMM = MPI.COMM_WORLD
+SIZE = COMM.Get_size()
+RANK = COMM.Get_rank()
+
+# if True, execute full model. If False, do only the plotting.
+# Simulation results must exist.
+properrun = True
+
+##########################################################################
+# PARAMETERS
+##########################################################################
+
+# Set up parameters using the NeuroTools.parameters.ParameterSet class.
+
+# Access parameters defined in example script implementing the network using
+# pynest, brunel_alpha_nest.py, adapted from the NEST v2.4.1 release. This will
+# not execute the network model, but see below.
+
+
+# set up file destinations differentiating between certain output
+savefolder = md5
+BN.spike_output_path = os.path.join(savefolder, 'spiking_output_path')
+PS = ParameterSet(dict(
+    # Main folder of simulation output
+    savefolder=savefolder,
+
+    # make a local copy of main files used in simulations
+    sim_scripts_path=os.path.join(savefolder,
+                                  'sim_scripts'),
+
+    # destination of single-cell output during simulation
+    cells_path=os.path.join(savefolder, 'cells'),
+
+    # destination of cell- and population-specific signals, i.e., compund LFPs,
+    # CSDs etc.
+    populations_path=os.path.join(savefolder,
+                                  'populations'),
+
+    # location of spike output from the network model
+    spike_output_path=BN.spike_output_path,
+
+    # destination of figure file output generated during model execution
+    figures_path=os.path.join(savefolder, 'figures')
+))
+
+
+# population (and cell type) specific parameters
+PS.update(dict(
+    # no cell type specificity within each E-I population
+    # hence X == x and Y == X
+    X=["EX", "IN"],
+
+    # population-specific LFPy.Cell parameters
+    cellParams=dict(
+        # excitory cells
+        EX=dict(
+            morphology='morphologies/ex.swc',
+            v_init=BN.neuron_params['E_L'],
+            cm=1.0,
+            Ra=150,
+            passive=True,
+            passive_parameters=dict(
+                g_pas=1. / (BN.neuron_params['tau_m'] * 1E3),  # assume cm=1
+                e_pas=BN.neuron_params['E_L']),
+            # nsegs_method='lambda_f',
+            # lambda_f=100,
+            max_cv_length=10,  # µm
+            dt=BN.dt,
+            tstart=0,
+            tstop=BN.simtime,
+            verbose=False,
+        ),
+        # inhibitory cells
+        IN=dict(
+            morphology='morphologies/in.swc',
+            v_init=BN.neuron_params['E_L'],
+            cm=1.0,
+            Ra=150,
+            passive=True,
+            passive_parameters=dict(
+                g_pas=1. / (BN.neuron_params['tau_m'] * 1E3),  # assume cm=1
+                e_pas=BN.neuron_params['E_L']),
+            # nsegs_method='lambda_f',
+            # lambda_f=100,
+            max_cv_length=10,  # µm
+            dt=BN.dt,
+            tstart=0,
+            tstop=BN.simtime,
+            verbose=False,
+        )),
+
+    # assuming excitatory cells are pyramidal
+    rand_rot_axis=dict(
+        EX=['z'],
+        IN=['x', 'y', 'z'],
+    ),
+
+
+    # kwargs passed to LFPy.Cell.simulate().
+    # It can be empty, but if `rec_imem=True`, the signal predictions will be
+    # performed using recorded transmembrane currents.
+    simulationParams=dict(rec_imem=True),
+
+    # set up parameters corresponding to cylindrical model populations
+    populationParams=dict(
+        EX=dict(
+            number=BN.NE,
+            radius=100,
+            z_min=-450,
+            z_max=-350,
+            min_cell_interdist=1.,
+            min_r=[[-1E199, -600, -550, 1E99], [0, 0, 10, 10]],
+        ),
+        IN=dict(
+            number=BN.NI,
+            radius=100,
+            z_min=-450,
+            z_max=-350,
+            min_cell_interdist=1.,
+            min_r=[[-1E199, -600, -550, 1E99], [0, 0, 10, 10]],
+        ),
+    ),
+
+    # set the boundaries between the "upper" and "lower" layer
+    layerBoundaries=[[0., -300],
+                     [-300, -500]],
+
+    # set the geometry of the virtual recording device
+    electrodeParams=dict(
+        # contact locations:
+        x=[0] * 6,
+        y=[0] * 6,
+        z=[x * -100. for x in range(6)],
+        # extracellular conductivity:
+        sigma=0.3,
+        # contact surface normals, radius, n-point averaging
+        N=[[1, 0, 0]] * 6,
+        r=5,
+        n=20,
+        seedvalue=None,
+        # dendrite line sources, soma as sphere source (Linden2014)
+        method='root_as_point',
+    ),
+
+    # parameters for LFPykit.LaminarCurrentSourceDensity
+    CSDParams=dict(
+        z=np.array([[-(i + 1) * 100, -i * 100] for i in range(6)]) + 50.,
+        r=np.ones(6) * 100  # same as population radius
+    ),
+
+    # runtime, cell-specific attributes and output that will be stored
+    savelist=[],
+
+    # time resolution of saved signals
+    dt_output=1.
+))
+
+
+# for each population, define layer- and population-specific connectivity
+# parameters
+PS.update(dict(
+    # number of connections from each presynaptic population onto each
+    # layer per postsynaptic population, preserving overall indegree
+    k_yXL=dict(
+        EX=[[int(0.5 * BN.CE), 0],
+            [int(0.5 * BN.CE), BN.CI]],
+        IN=[[0, 0],
+            [BN.CE, BN.CI]],
+    ),
+
+    # set up table of synapse weights from each possible presynaptic population
+    J_yX=dict(
+        EX=[BN.J_ex * 1E-3, BN.J_in * 1E-3],
+        IN=[BN.J_ex * 1E-3, BN.J_in * 1E-3],
+    ),
+
+    # set up synapse parameters as derived from the network
+    synParams=dict(
+        EX=dict(
+            section=['apic', 'dend', 'soma'],
+            # section=['apic', 'dend'],
+            # tau = [BN.tauSyn, BN.tauSyn],
+            syntype='AlphaISyn'
+        ),
+        IN=dict(
+            section=['apic', 'dend', 'soma'],
+            # section=['dend', 'soma'],
+            # tau = [BN.tauSyn, BN.tauSyn],
+            syntype='AlphaISyn'
+        ),
+    ),
+
+    # set up table of synapse time constants from each presynaptic populations
+    tau_yX=dict(
+        EX=[BN.tauSyn, BN.tauSyn],
+        IN=[BN.tauSyn, BN.tauSyn]
+    ),
+
+    # set up delays, here using fixed delays of network
+    synDelayLoc=dict(
+        EX=[BN.delay, BN.delay],
+        IN=[BN.delay, BN.delay],
+    ),
+    # no distribution of delays
+    synDelayScale=dict(
+        EX=[None, None],
+        IN=[None, None],
+    ),
+))
+
+
+# putative mappting between population type and cell type specificity,
+# but here all presynaptic senders are also postsynaptic targets
+PS.update(dict(
+    mapping_Yy=list(zip(PS.X, PS.X))
+))
+
+
+# In[4]:
+
+
+##########################################################################
+# MAIN simulation procedure                                              #
+##########################################################################
+
+# tic toc
+tic = time()
+
+######### Perform network simulation #####################################
+if properrun:
+    # set up the file destination, removing old results by default
+    setup_file_dest(PS, clearDestination=True)
+
+if properrun:
+    # execute network simulation
+    BN.simulate()
+
+# wait for the network simulation to finish, resync MPI threads
+COMM.Barrier()
+
+# Create an object representation containing the spiking activity of the network
+# simulation output that uses sqlite3. Again, kwargs are derived from the brunel
+# network instance.
+networkSim = CachedNetwork(
+    simtime=BN.simtime,
+    dt=BN.dt,
+    spike_output_path=BN.spike_output_path,
+    label=BN.label,
+    ext='dat',
+    GIDs={'EX': [1, BN.NE], 'IN': [BN.NE + 1, BN.NI]},
+    X=['EX', 'IN'],
+    cmap='rainbow_r',
+    skiprows=3,
+)
+
+
+# In[5]:
+
+
+if RANK == 0:
+    toc = time() - tic
+    print('NEST simulation and gdf file processing done in  %.3f seconds' % toc)
+
+
+# Set up LFPykit measurement probes for LFPs and CSDs
+if properrun:
+    probes = []
+    probes.append(lfpykit.RecExtElectrode(cell=None, **PS.electrodeParams))
+    probes.append(
+        lfpykit.LaminarCurrentSourceDensity(
+            cell=None, **PS.CSDParams))
+
+
+# In[6]:
+
+
+# draw locsets accd to y-position weighted by area and some function of y
+def get_rand_idx_area_and_distribution_norm(areas,
+                                            depth,
+                                            n_syn=1,
+                                            fun=[st.norm],
+                                            funargs=[dict(loc=200, scale=50)],
+                                            funweights=[1.]):
+    '''Return n_syn CV indices with random probability normalized by membrane area
+    multiplied with the value of probability density function constructed as
+    weigthed sum of `scipy.stats._continuous_dists` function instances
+
+    Parameters
+    ----------
+    areas: 1D ndarray
+        Area of each CV
+    depth: 1D ndarray
+        depth of each CV
+    n_syn: int
+        number of random indices
+    fun: iterable of scipy.stats._continuous_distns.*_gen
+        iterable of callable methods in scipy.stats module
+    funargs: iterable of dicts
+        keyword arguments to each element in `fun`
+    funweights: list of floats
+        scaling
+
+    Returns
+    -------
+    ndarray
+        random indices of size `n_syn` that can be
+    '''
+    # probabilities for connecting to CV
+    p = areas.copy()
+    mod = np.zeros(areas.size)
+    for f, args, w in zip(fun, funargs, funweights):
+        df = f(**args)
+        mod += df.pdf(x=depth) * w
+
+    # multiply probs by spatial weighting factor
+    p *= mod
+    # normalize
+    p /= p.sum()
+    # find CV inds
+    return alias_method(np.arange(areas.size), p, n_syn)
+
+
+# In[7]:
+
+
+class BaseRecipe (arbor.recipe):
+    def __init__(self, cell):
+        super().__init__()
+
+        self.the_cell = cell
+
+        self.iprobe_id = (0, 0)
+
+        self.the_props = arbor.neuron_cable_properties()
+        self.the_cat = arbor.default_catalogue()
+        self.the_props.register(self.the_cat)
+
+    def num_cells(self):
+        return 1
+
+    def num_sources(self, gid):
+        return 0
+
+    def num_targets(self, gid):
+        return 0
+
+    def connections_on(self, gid):
+        return []
+
+    def event_generators(self, gid):
+        return []
+
+    def cell_kind(self, gid):
+        return arbor.cell_kind.cable
+
+    def cell_description(self, gid):
+        return self.the_cell
+
+    def global_properties(self, kind):
+        return self.the_props
+
+    def probes(self, gid):
+        return [
+            arbor.cable_probe_total_current_cell(),
+        ]
+
+
+# In[8]:
+
+
+class Recipe(BaseRecipe):
+    def __init__(self, cell, times=[[1.]], weights=[1.]):
+        super().__init__(cell)
+
+        assert(len(times) == len(weights)), 'len(times) != len(weights)'
+        self.times = times
+        self.weights = weights
+
+    def num_targets(self, gid):
+        return len(self.times)
+
+    def event_generators(self, gid):
+        events = []
+        for i, (w, t) in enumerate(zip(self.weights, self.times)):
+            events += [arbor.event_generator(f'{i}', w,
+                                             arbor.explicit_schedule(t))]
+
+        return events
+
+
+# In[9]:
+
+
+class ArborPopulation(Population):
+    def __init__(self, **kwargs):
+        Population.__init__(self, **kwargs)
+
+    def get_synidx(self, cellindex):
+        """
+        Local function, draw and return synapse locations corresponding
+        to a single cell, using a random seed set as
+        `POPULATIONSEED` + `cellindex`.
+
+
+        Parameters
+        ----------
+        cellindex : int
+            Index of cell object.
+
+
+        Returns
+        -------
+        synidx : dict
+            `LFPy.Cell` compartment indices
+
+
+        See also
+        --------
+        Population.get_all_synIdx, Population.fetchSynIdxCell
+
+        """
+        # create a cell instance
+        cell = self.cellsim(cellindex, return_just_cell=True)
+
+        # compute areas and center of mass of each CV
+        CV_areas = []
+        for i in range(len(cell._loc_sets)):
+            inds = cell._CV_ind == i
+            CV_areas = np.r_[CV_areas, cell.area[inds].sum()]
+
+        # center of mass (COM) per segment -- https://mathworld.wolfram.com/ConicalFrustum.html
+        # gives geometric centroid as
+        # \overline{z}} = h * (R1**2 + 2 * R1*R2 + 3 * R2**2) / (4 * (R1**2 + R1 * R2 + R2**2))
+        R = cell.d / 2
+        # relative COMs per segment
+        h_bar_seg = cell.length * (R[:, 0]**2 + 2 * R[:, 0] * R[:, 1] + 3 * R[:, 1]**2
+                                   ) / (4 * (R[:, 0]**2 + R[:, 0] * R[:, 1] + R[:, 1]**2))
+        # carthesian coordinates
+        r_bar_seg =  np.c_[cell.x[:, 0] + h_bar_seg * (cell.x[:, 1] - cell.x[:, 0]
+                                                                ) / cell.length,
+                           cell.y[:, 0] + h_bar_seg * (cell.y[:, 1] - cell.y[:, 0]
+                                                                ) / cell.length,
+                           cell.z[:, 0] + h_bar_seg * (cell.z[:, 1] - cell.z[:, 0]
+                                                                ) / cell.length]
+        # Volumes / mass
+        # V = 1 / 3 * π * h * (R1**2 + R1 * R2 + R2**2)
+        V_seg = np.pi * cell.length * (R[:, 0]**2 + R[:, 0] * R[:, 1] + R[:, 1]**2) / 3
+
+        # Center of mass per CV
+        r_bar = np.zeros((0, 3))
+        for i in range(len(cell._loc_sets)):
+            inds = cell._CV_ind == i
+            if inds.sum() <= 1:
+                r_ = (r_bar_seg[inds, ] * V_seg[inds] / V_seg[inds].sum()).mean(axis=0)
+            else:
+                # compute mean position weighted by volume/mass (mass monopole location)
+                r_ = (r_bar_seg[inds, ].T * V_seg[inds] / V_seg[inds].sum()).sum(axis=-1)
+            r_bar = np.vstack((r_bar, r_))
+
+
+        # local containers
+        synidx = {}
+
+        # get synaptic placements and cells from the network,
+        # then set spike times,
+        for i, X in enumerate(self.X):
+            synidx[X] = self.fetchSynIdxCell(# cell=cell,
+                                             areas=CV_areas,
+                                             depth=r_bar[:, 2],
+                                             nidx=self.k_yXL[:, i],
+                                             synParams=self.synParams.copy())
+        # clean up hoc namespace
+        # cell.__del__()
+
+        return synidx
+
+    def fetchSynIdxCell(self,
+                        areas,
+                        depth,
+                        nidx, synParams):
+        """
+        Find possible synaptic placements for each cell
+        As synapses are placed within layers with bounds determined by
+        self.layerBoundaries, it will check this matrix accordingly, and
+        use the probabilities from `self.connProbLayer to distribute.
+
+        For each layer, the synapses are placed with probability normalized
+        by membrane area of each compartment
+
+
+        Parameters
+        ----------
+        areas:
+        depth:
+        nidx : numpy.ndarray
+            Numbers of synapses per presynaptic population X.
+        synParams : which `LFPy.Synapse` parameters to use.
+
+
+        Returns
+        -------
+        syn_idx : list
+            List of arrays of synapse placements per connection.
+
+
+        See also
+        --------
+        Population.get_all_synIdx, Population.get_synIdx, LFPy.Synapse
+
+        """
+        # segment indices in each layer is stored here, list of np.array
+        syn_idx = []
+        # loop over layer bounds, find synapse locations
+        for i, zz in enumerate(self.layerBoundaries):
+            if nidx[i] == 0:
+                syn_idx.append(np.array([], dtype=int))
+            else:
+                syn_idx.append(
+                    get_rand_idx_area_and_distribution_norm(
+                        areas, depth,
+                        n_syn=nidx[i],
+                        fun=[st.uniform],
+                        funargs=[dict(loc=zz.min(), scale=abs(zz.max()-zz.min()))],
+                        funweights=[1.],
+                    ).astype('int16'))
+
+        return syn_idx
+
+    def insert_all_synapses(self, **kwargs):
+        pass
+
+    def insert_synapses(self, **kwargs):
+        pass
+
+    def cellsim(self, cellindex, return_just_cell=False):
+        """
+        Do the actual simulations of LFP, using synaptic spike times from
+        network simulation.
+
+
+        Parameters
+        ----------
+        cellindex : int
+            cell index between 0 and population size-1.
+        return_just_cell : bool
+            If True, return only the `LFPy.Cell` object
+            if False, run full simulation, return None.
+
+
+        Returns
+        -------
+        None or `LFPy.Cell` object
+
+
+        See also
+        --------
+        hybridLFPy.csd, LFPy.Cell, LFPy.Synapse, LFPy.RecExtElectrode
+        """
+        tic = time()
+
+        '''
+        cell = LFPy.Cell(**self.cellParams)
+        cell.set_pos(**self.pop_soma_pos[cellindex])
+        cell.set_rotation(**self.rotations[cellindex])
+        '''
+
+        ##### ARBOR
+
+        # cell decor
+        decor = arbor.decor()
+
+        # set initial voltage, temperature, axial resistivity, membrane capacitance
+        decor.set_property(
+            Vm=self.cellParams['v_init'],  # Initial membrane voltage [mV]
+            tempK=300,  # Temperature [Kelvin]
+            rL=self.cellParams['Ra'],  # Axial resistivity [Ω cm]
+            cm=self.cellParams['cm'] * 1E-2,  # Membrane capacitance [F/m**2]
+        )
+
+        # set passive mechanism all over
+        pas = arbor.mechanism(
+            'pas/e={}'.format(self.cellParams['passive_parameters']['e_pas'])
+            )  # passive mech w. leak reversal potential (mV)
+        pas.set('g', self.cellParams['passive_parameters']['g_pas'])  # leak conductivity (S/cm2)
+        decor.paint('(all)', pas)
+
+        # number of CVs per branch
+        policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
+        decor.discretization(policy)
+
+        # define morphology (needed for arbor.place_pwlin etc.)
+        morphology = arbor.load_swc_arbor(self.cellParams['morphology'])
+
+        # Label dictionary
+        defs = {}
+        labels = arbor.label_dict(defs)
+
+        # define isometry
+        iso = arbor.isometry()  # create isometry
+        for key, val in self.rotations[cellindex].items():
+            args = {
+                'theta': float(val),
+                'axis': tuple((np.array(['x', 'y', 'z']) == key).astype('float'))}
+            iso_rot = iso.rotate(**args)
+        iso_trans = iso.translate(**self.pop_soma_pos[cellindex])
+
+        # place_pwlin
+        p = arbor.place_pwlin(morphology, iso_rot * iso_trans)  # place with isometry
+
+        # need cell geometry object
+        cell = self._get_cell(p, morphology, labels, decor)
+
+        if return_just_cell:
+            # return only the CellGeometry object (for plotting etc.)
+            return cell
+        else:
+            # proper simulation procedure inserting synapses, record transmembrane currents,
+            # make extracellular predictions
+
+            # get transmembrane currents
+            I_m = self._get_I_m(cell, cellindex, decor, morphology, labels)
+
+            # compute signal of each probe
+            for probe in self.probes:
+                probe.cell = cell
+
+                M = self._get_transformation_matrix_for_CV(cell, probe, I_m)
+
+                probe.data = M @ I_m
+
+            # downsample probe.data attribute and unset cell
+            for probe in self.probes:
+                probe.data = ss.decimate(probe.data,
+                                         q=self.decimatefrac
+                                         ).astype(np.float32)
+                probe.cell = None
+
+            # put all necessary cell output in output dict
+            for attrbt in self.savelist:
+                attr = getattr(cell, attrbt)
+                if isinstance(attr, np.ndarray):
+                    self.output[cellindex][attrbt] = attr.astype('float32')
+                else:
+                    try:
+                        self.output[cellindex][attrbt] = attr
+                    except BaseException:
+                        self.output[cellindex][attrbt] = str(attr)
+                self.output[cellindex]['srate'] = 1E3 / self.dt_output
+
+            # collect probe output
+            for probe in self.probes:
+                self.output[cellindex][probe.__class__.__name__] =                     probe.data.copy()
+
+            print('cell %s population %s in %.2f s' % (cellindex, self.y,
+                                                       time() - tic))
+
+    def _get_cell(self, p, morphology, labels, decor):
+        # create cell and set properties
+        cable_cell = arbor.cable_cell(morphology, labels, decor)
+
+        # instantiate recipe with cell
+        recipe = BaseRecipe(cable_cell)
+
+        # instantiate simulation
+        context = arbor.context(1, None)
+        domains = arbor.partition_load_balance(recipe, context)
+        sim = arbor.simulation(recipe, domains, context)
+
+        # set up sampling on probes
+        schedule = arbor.regular_schedule(self.dt)
+        i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
+
+        # need meta data locating each CV
+        _, I_m_meta = sim.samples(i_handle)[0]
+
+        # Gather geometry of CVs and assign segments to each CV,
+        # get segment geometries and mapping to CV indices
+        x, y, z, d = [np.array([], dtype=float).reshape((0, 2))] * 4
+        CV_ind = np.array([], dtype=int)  # tracks which CV owns segment
+        for i, m in enumerate(I_m_meta):
+            segs = p.segments([m])
+            for j, seg in enumerate(segs):
+                x = np.row_stack([x, [seg.prox.x, seg.dist.x]])
+                y = np.row_stack([y, [seg.prox.y, seg.dist.y]])
+                z = np.row_stack([z, [seg.prox.z, seg.dist.z]])
+                d = np.row_stack([d, [seg.prox.radius * 2, seg.dist.radius * 2]])
+                CV_ind = np.r_[CV_ind, i]
+
+        # define a list of loc_sets with relative location in between proximal and distal points of each CV
+        loc_sets = np.array([
+            '(location {} {})'.format(c.branch, np.mean([c.prox, c.dist])) for c in I_m_meta
+        ])
+
+        # CellGeometry object
+        cell = lfpykit.CellGeometry(
+            x=x,
+            y=y,
+            z=z,
+            d=d
+        )
+
+        # set some needed attributes:
+        cell._CV_ind = CV_ind
+        cell._loc_sets = loc_sets
+
+        return cell
+
+    def _get_times_weights_taus_CV_inds(self, cellindex):
+        times = np.array([])
+        weights = np.array([])
+        taus = np.array([])
+        CV_inds = np.array([], dtype=int)
+
+        # iterate over presynaptic network populations
+        for i, X in enumerate(self.X):
+            for j, idx in enumerate(self.synIdx[cellindex][X]):
+                weights = np.hstack((weights, np.ones(idx.size) * self.J_yX[i]))
+                taus = np.hstack((taus, np.ones(idx.size) * self.tau_yX[i]))
+                CV_inds = np.hstack((CV_inds, idx))
+
+                if self.synDelays is not None:
+                    synDelays = self.synDelays[cellindex][X][j]
+                else:
+                    synDelays = None
+
+
+                try:
+                    spikes = self.networkSim.dbs[X].select(self.SpCells[cellindex][X][j])
+                except AttributeError:
+                    raise AssertionError(
+                        'could not open CachedNetwork database objects')
+
+                # convert to object array for slicing
+                spikes = np.array(spikes, dtype=object)
+
+                # apply synaptic delays
+                if synDelays is not None and idx.size > 0:
+                    for k, delay in enumerate(synDelays):
+                        if spikes[k].size > 0:
+                            spikes[k] += delay
+
+                times = np.hstack((times, spikes))
+
+        # TODO: remove redundant synapses by combining spike trains
+        # where weights and taus and CV_inds are equal
+        times_ = []
+        weights_ = np.array([])
+        taus_ = np.array([])
+        CV_inds_ = np.array([], dtype=int)
+
+        for tau in np.unique(taus):
+            i_0 = taus == tau
+            for w in np.unique(weights):
+                i_1 = weights == w
+                for CV_i in np.unique(CV_inds):
+                    i_2 = CV_inds == CV_i
+                    i_3 = i_0 & i_1 & i_2
+                    if i_3.sum() > 0:
+                        st = np.concatenate(times[i_3])
+                        st.sort()
+                        times_.append(st)
+                        weights_ = np.r_[weights_, w]
+                        taus_ = np.r_[taus_, tau]
+                        CV_inds_ = np.r_[CV_inds_, CV_i]
+
+        times_ = np.array(times_, dtype=object)
+
+        return times_, weights_, taus_, CV_inds_
+
+    def _get_I_m(self, cell, cellindex, decor, morphology, labels):
+        # Recipe requires "flat" lists of times and weights for each "connection"
+        # plus time constants, CV indices
+        times, weights, taus, CV_inds = self._get_times_weights_taus_CV_inds(cellindex)
+
+        # synapse loc_sets (CV midpoints)
+        syn_loc_sets = cell._loc_sets[CV_inds]
+
+        # create synapses at each loc_set
+        if self.synParams['syntype'] == 'AlphaISyn':
+            synapse = 'alphaisyn'   # workaround
+            for i, (loc_set, tau) in enumerate(zip(syn_loc_sets, taus)):
+                synapse_params = {'tau': tau}
+                decor.place(loc_set, arbor.mechanism(synapse, synapse_params), f'{i}')
+        else:
+            raise NotImplementedError
+
+        # number of CVs per branch
+        policy = arbor.cv_policy_max_extent(self.cellParams['max_cv_length'])
+        decor.discretization(policy)
+
+        # create cell and set properties
+        cable_cell = arbor.cable_cell(morphology, labels, decor)
+
+        # instantiate recipe with cable_cell
+        recipe = Recipe(cable_cell, weights=weights, times=times)
+
+        # instantiate simulation
+        context = arbor.context(1, None)
+        domains = arbor.partition_load_balance(recipe, context)
+        sim = arbor.simulation(recipe, domains, context)
+
+        # set up sampling on probes
+        schedule = arbor.regular_schedule(self.dt)
+        i_handle = sim.sample(recipe.iprobe_id, schedule, arbor.sampling_policy.exact)
+
+        # run simulation and collect results.
+        # sim.run(tfinal=self.cellParams['tstop'])
+        self._bench_sim_run(sim)
+
+        # extract I_m for each CV
+        I_m_samples, _ = sim.samples(i_handle)[0]
+
+        # transmembrane currents in nA
+        return I_m_samples[:, 1:].T
+
+    def _bench_sim_run(self, sim):
+        tic = time()
+        sim.run(tfinal=self.cellParams['tstop'] + self.dt, dt=self.dt)
+        toc = time()
+        self._cumulative_sim_time += toc - tic
+
+    def _get_transformation_matrix_for_CV(self, cell, probe, I_m):
+        # mapping per segment (frusta)
+        M_tmp = probe.get_transformation_matrix()
+
+        # Define response matrix from M with columns weighted by area of each frusta
+        M = np.zeros((probe.z.shape[0], I_m.shape[0]))
+        for i in range(I_m.shape[0]):
+            inds = cell._CV_ind == i
+            M[:, i] = M_tmp[:, inds] @ (cell.area[inds] / cell.area[inds].sum())
+
+        return M
+
+
+# In[10]:
+
+
+# %%prun -s cumulative -q -l 20 -T prun0
+
+# measure population simulation times including setup etc.
+ticc = time()
+
+# arbor sim.run cumulative time
+ticc_run = np.array(0.)
+
+####### Set up populations ###############################################
+if properrun:
+    # iterate over each cell type, and create populationulation object
+    for i, Y in enumerate(PS.X):
+        # create population:
+        pop = ArborPopulation(
+            cellParams=PS.cellParams[Y],
+            rand_rot_axis=PS.rand_rot_axis[Y],
+            simulationParams=PS.simulationParams,
+            populationParams=PS.populationParams[Y],
+            y=Y,
+            layerBoundaries=PS.layerBoundaries,
+            savelist=PS.savelist,
+            savefolder=PS.savefolder,
+            probes=probes,
+            dt_output=PS.dt_output,
+            POPULATIONSEED=SIMULATIONSEED + i,
+            X=PS.X,
+            networkSim=networkSim,
+            k_yXL=PS.k_yXL[Y],
+            synParams=PS.synParams[Y],
+            synDelayLoc=PS.synDelayLoc[Y],
+            synDelayScale=PS.synDelayScale[Y],
+            J_yX=PS.J_yX[Y],
+            tau_yX=PS.tau_yX[Y],
+        )
+
+        # run population simulation and collect the data
+        pop.run()
+        pop.collect_data()
+
+        # arbor sim.run cumulative time
+        ticc_run += pop._cumulative_sim_time
+
+        # object no longer needed
+        del pop
+
+# tic toc
+tocc = time() - ticc
+if RANK == 0:
+    with open(os.path.join(savefolder, 'time_pop.txt'), 'w') as f:
+        f.write(f'{tocc}')
+
+if RANK == 0:
+    tocc_run = np.zeros_like(ticc_run)
+else:
+    tocc_run = None
+
+COMM.Reduce(ticc_run, tocc_run, op=MPI.SUM, root=0)
+if RANK == 0:
+    tocc_run /= SIZE
+    with open(os.path.join(savefolder, 'time_run.txt'), 'w') as f:
+        f.write(f'{float(tocc_run)}')
+
+
+# In[11]:
+
+
+####### Postprocess the simulation output ################################
+
+# reset seed, but output should be deterministic from now on
+np.random.seed(SIMULATIONSEED)
+
+if properrun:
+    # do some postprocessing on the collected data, i.e., superposition
+    # of population LFPs, CSDs etc
+    postproc = PostProcess(y=PS.X,
+                           dt_output=PS.dt_output,
+                           savefolder=PS.savefolder,
+                           mapping_Yy=PS.mapping_Yy,
+                           savelist=PS.savelist,
+                           probes=probes,
+                           cells_subfolder=os.path.split(PS.cells_path)[-1],
+                           populations_subfolder=os.path.split(PS.populations_path)[-1],
+                           figures_subfolder=os.path.split(PS.figures_path)[-1])
+
+    # run through the procedure
+    postproc.run()
+
+    # create tar-archive with output for plotting, ssh-ing etc.
+    postproc.create_tar_archive()
+
+
+COMM.Barrier()
+
+# tic toc
+print('Execution time: %.3f seconds' % (time() - tic))
diff --git a/examples/benchmarks/morphologies b/examples/benchmarks/morphologies
new file mode 120000
index 0000000..5afc3a0
--- /dev/null
+++ b/examples/benchmarks/morphologies
@@ -0,0 +1 @@
+../morphologies
\ No newline at end of file
diff --git a/examples/benchmarks/plot_arbor_reproducer.py b/examples/benchmarks/plot_arbor_reproducer.py
new file mode 100644
index 0000000..11a5498
--- /dev/null
+++ b/examples/benchmarks/plot_arbor_reproducer.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+import numpy as np
+import hashlib
+import json
+from parameters import ParameterSpace, ParameterSet
+import matplotlib.pyplot as plt
+
+
+PS_reproducer = ParameterSpace('PS_reproducer.txt')
+keys = PS_reproducer.range_keys()
+
+fig, ax = plt.subplots(1, 1, figsize=(8, 8))
+for h in ['HOST', 'HOSTNAME']:
+    if h in os.environ:
+        host = os.environ[h]
+        break
+
+for i, CPUS_PER_TASK in enumerate(PS_reproducer['CPUS_PER_TASK']):
+    times_run = []
+    NTASKS = []
+    for j, N in enumerate(PS_reproducer['NTASKS']):
+        NTASKS.append(N)
+        pset = ParameterSet(dict(NTASKS=N,
+                                 CPUS_PER_TASK=CPUS_PER_TASK,
+                                 GLOBALSEED=PS_reproducer['GLOBALSEED'],
+                                 POPULATION_SIZE=PS_reproducer['POPULATION_SIZE'],
+                                 ))
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        with open(os.path.join('logs', f'NTASKS_{N}_CPUS_PER_TASK_{CPUS_PER_TASK}.txt'), 'r') as f:
+            times_run.append(float(f.readline()))
+
+    label = f"CPUs per task: {CPUS_PER_TASK}"
+    ax.loglog(NTASKS, times_run, ':o', label=label, base=2)
+    ax.set_xticks(NTASKS)
+    ax.set_xticklabels([f'{n}' for n in NTASKS])
+
+ax.legend()
+ax.set_xlabel('# MPI tasks')
+ax.set_ylabel('time (ms)')
+
+fig.savefig('PS_reproducer.pdf')
+
+plt.show()
diff --git a/examples/benchmarks/plot_benchmarks.py b/examples/benchmarks/plot_benchmarks.py
new file mode 100644
index 0000000..e6f2cf8
--- /dev/null
+++ b/examples/benchmarks/plot_benchmarks.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+import numpy as np
+import hashlib
+import json
+from parameters import ParameterSpace, ParameterSet
+import matplotlib.pyplot as plt
+
+import brunel_alpha_nest as BN
+
+
+PS0 = ParameterSpace('PS0.txt')
+keys = PS0.range_keys()
+
+fig, ax = plt.subplots(1, 1, figsize=(8, 8))
+for h in ['HOST', 'HOSTNAME']:
+    if h in os.environ:
+        host = os.environ[h]
+        break
+
+ax.set_title(f"network size: {5 * BN.order}; host: {host}")
+
+for i, SIM_SCRIPT in enumerate(PS0['SIM_SCRIPT']):
+    times_pop = []
+    times_run = []
+    NTASKS = []
+    for j, N in enumerate(PS0['NTASKS']):
+        NTASKS.append(N)
+        pset = ParameterSet(dict(NTASKS=N,
+                                 SIM_SCRIPT=SIM_SCRIPT,
+                                 GLOBALSEED=PS0['GLOBALSEED']))
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        with open(os.path.join(md5, 'time_pop.txt'), 'r') as f:
+            times_pop.append(float(f.readline()))
+
+        with open(os.path.join(md5, 'time_run.txt'), 'r') as f:
+            times_run.append(float(f.readline()))
+
+    label = f"{'LFPy' if SIM_SCRIPT == 'example_brunel.py' else 'Arbor'} pop"
+    ax.loglog(NTASKS, times_pop, '-o', label=label, base=2)
+
+    label = f"{'LFPy' if SIM_SCRIPT == 'example_brunel.py' else 'Arbor'} run"
+    ax.loglog(NTASKS, times_run, ':o', label=label, base=2)
+
+ax.legend()
+ax.set_xlabel('NTASKS')
+ax.set_ylabel('time (ms)')
+
+fig.savefig('PS0.pdf')
+
+plt.show()
diff --git a/examples/benchmarks/requirements.txt b/examples/benchmarks/requirements.txt
new file mode 100644
index 0000000..e69de29
diff --git a/examples/benchmarks/run_arbor_reproducer.py b/examples/benchmarks/run_arbor_reproducer.py
new file mode 100644
index 0000000..34ac4ce
--- /dev/null
+++ b/examples/benchmarks/run_arbor_reproducer.py
@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''Define ParameterSpace for weak scaling with different MPI pools
+'''
+import os
+import numpy as np
+import hashlib
+import subprocess as sp
+import json
+from parameters import ParameterSpace, ParameterRange
+
+PSPACES = dict()
+
+# check scaling with MPI pool size
+PS_reproducer = ParameterSpace(dict(
+    # allow different seeds for different network iterations
+    GLOBALSEED=1234,
+
+    # number of neurons per MPI thread
+    POPULATION_SIZE=64,
+
+    # MPI pool size
+    NTASKS=ParameterRange([1, 2, 4, 8, 16, 32, 64, 128, 256, 512]),
+    
+    # number of cores per MPI thread
+    CPUS_PER_TASK=ParameterRange([1, 2, 4, 8]),
+
+    # simulation scripts:
+    SIM_SCRIPT='arbor_reproducer.py' 
+))
+
+PS_reproducer.save('PS_reproducer.txt')
+PSPACES.update(dict(PS_reproducer=PS_reproducer))
+
+job_script_hpc = """#!/bin/bash
+##################################################################
+#SBATCH --account {}
+#SBATCH --job-name {}
+#SBATCH --time {}
+#SBATCH -o logs/{}_stdout.txt
+#SBATCH -e logs/{}_error.txt
+#SBATCH --ntasks {}
+#SBATCH --cpus-per-task={}
+##################################################################
+srun --mpi=pmi2 python -u {} {}
+"""
+
+# create output directories, wipe if they exist
+for dir in ['jobs', 'parameters', 'logs', 'output']:
+    if not os.path.isdir(dir):
+        os.mkdir(dir)
+
+env = os.environ
+
+if 'HOSTNAME' in env.keys():
+    if env['HOSTNAME'].rfind('jr') >= 0 or env['HOSTNAME'].rfind('jusuf') >= 0:
+
+        # slurm job settings (shared)
+        ACCOUNT = 'jinb33' if env['HOSTNAME'].rfind('jr') >= 0 else 'icei-hbp-2020-0004'
+
+        # container for job IDs
+        jobIDs = []
+        for pset in PS_reproducer.iter_inner():
+            # sorted json dictionary
+            js = json.dumps(pset, sort_keys=True).encode()
+            md5 = hashlib.md5(js).hexdigest()
+
+            # walltime
+            wt = 300  # s
+            wt = '%i:%.2i:%.2i' % (wt // 3600,
+                                       (wt - wt // 3600 * 3600) // 60,
+                                       (wt - wt // 60 * 60))
+            TIME = wt
+
+            # save parameter file
+            pset.save(url=os.path.join('parameters', '{}.txt'.format(md5)))
+
+            # create job script
+            with open(os.path.join('jobs', '{}.job'.format(md5)), 'w') as f:
+                f.writelines(job_script_hpc.format(
+                    ACCOUNT,
+                    md5,
+                    TIME,
+                    md5,
+                    md5,
+                    pset.NTASKS,
+                    pset.CPUS_PER_TASK,
+                    pset.SIM_SCRIPT,
+                    md5
+                ))
+            cmd = ' '.join(['sbatch',
+                            '{}'.format(os.path.join('jobs',
+                                        '{}.job'.format(md5)))])
+            print(cmd)
+            output = sp.getoutput(cmd)
+            jobid = output.split(' ')[-1]
+            jobIDs.append((md5, jobid))
+    else:
+        raise NotImplementedError
+else:
+    for pset in PS_reproducer.iter_inner():
+        # sorted json dictionary
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        # save parameter file
+        pset.save(url=os.path.join('parameters', '{}.txt'.format(md5)))
+
+        # run model serially
+        cmd = 'mpirun -n {} python {} {}'.format(pset.NTASKS, pset.SIM_SCRIPT, md5)
+        print(cmd)
+        sp.run(cmd.split(' '))
diff --git a/examples/benchmarks/run_benchmarks.py b/examples/benchmarks/run_benchmarks.py
new file mode 100644
index 0000000..af90cef
--- /dev/null
+++ b/examples/benchmarks/run_benchmarks.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+'''Define ParameterSpace for benchmarking of scaling with different MPI pools
+'''
+import os
+import numpy as np
+import operator
+import pickle
+import hashlib
+# import parameters as ps
+import subprocess as sp
+import json
+from parameters import ParameterSpace, ParameterSet, ParameterRange
+import matplotlib.pyplot as plt
+
+PSPACES = dict()
+
+# check scaling with MPI pool size
+PS0 = ParameterSpace(dict(
+    # allow different seeds for different network iterations
+    GLOBALSEED=1234,
+
+    # MPI pool size
+    NTASKS=ParameterRange([4, 8, 16, 32, 64, 128, 256, 512]),
+
+    # population size scaling (multiplied with values in
+    # populationParams['POP_SIZE']):
+    # POPSCALING=ParameterRange([1.]),
+
+    # simulation scripts:
+    SIM_SCRIPT=ParameterRange(['example_brunel.py', 'example_brunel_arbor.py'])
+))
+
+PS0.save('PS0.txt')
+PSPACES.update(dict(PS0=PS0))
+
+jobscript_local = '''#!/bin/bash
+# from here on we can run whatever command we want
+unset DISPLAY # DISPLAY somehow problematic with Slurm
+mpirun -n {} python {} {}
+'''
+
+job_script_jusuf = """#!/bin/bash
+##################################################################
+#SBATCH --account {}
+#SBATCH --job-name {}
+#SBATCH --time {}
+#SBATCH -o logs/{}_stdout.txt
+#SBATCH -e logs/{}_error.txt
+###SBATCH -N {}
+#SBATCH --ntasks {}
+#SBATCH --cpus-per-task=2
+##################################################################
+# from here on we can run whatever command we want
+unset DISPLAY # DISPLAY somehow problematic with Slurm
+# export OMP_NUM_THREADS=2
+srun --mpi=pmi2 python -u {} {}
+"""
+
+# create output directories, wipe if they exist
+for dir in ['jobs', 'parameters', 'logs', 'output']:
+    if not os.path.isdir(dir):
+        os.mkdir(dir)
+
+
+env = os.environ
+
+if 'HOSTNAME' in env.keys() and \
+   env['HOSTNAME'].rfind('jr') >= 0 or \
+   env['HOSTNAME'].rfind('jusuf') >= 0:
+
+    # slurm job settings (shared)
+    ACCOUNT = 'jinb33' if env['HOSTNAME'].rfind('jr') >= 0 else 'icei-hbp-2020-0004'
+    #TIME = '00:10:00'
+    LNODES = 1
+    
+    # container for job IDs
+    jobIDs = []
+    for pset in PS0.iter_inner():
+        # sorted json dictionary
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        # walltime (360 seconds per 1 MPI threads and popscaling 1 and                                     
+        # neuron count 512*5)                                                                              
+        wt = 360 * 1. / pset.NTASKS + 240
+        wt = '%i:%.2i:%.2i' % (wt // 3600,
+                                   (wt - wt // 3600 * 3600) // 60,
+                                   (wt - wt // 60 * 60))
+        TIME = wt
+
+        # save parameter file
+        pset.save(url=os.path.join('parameters', '{}.txt'.format(md5)))
+
+        # create job script
+        with open(os.path.join('jobs', '{}.job'.format(md5)), 'w') as f:
+            f.writelines(job_script_jusuf.format(
+                ACCOUNT,
+                md5,
+                TIME,
+                md5,
+                md5,
+                LNODES,
+                pset.NTASKS,
+                pset.SIM_SCRIPT,
+                md5
+            ))
+        cmd = ' '.join(['sbatch',
+                        '{}'.format(os.path.join('jobs',
+                                    '{}.job'.format(md5)))])
+        print(cmd)
+        output = sp.getoutput(cmd)
+        # output = sp.getoutput(
+        #     'sbatch {}'.format(os.path.join('jobs', '{}.job'.format(md5))))
+        jobid = output.split(' ')[-1]
+        jobIDs.append((md5, jobid))
+else:
+    for pset in PS0.iter_inner():
+        # sorted json dictionary
+        js = json.dumps(pset, sort_keys=True).encode()
+        md5 = hashlib.md5(js).hexdigest()
+
+        # save parameter file
+        pset.save(url=os.path.join('parameters', '{}.txt'.format(md5)))
+
+        # run model serially
+        cmd = 'mpirun -n {} python {} {}'.format(pset.NTASKS, pset.SIM_SCRIPT, md5)
+        print(cmd)
+        sp.run(cmd.split(' '))
diff --git a/examples/morphologies/single_cell.swc b/examples/morphologies/single_cell.swc
new file mode 100644
index 0000000..cdbacf6
--- /dev/null
+++ b/examples/morphologies/single_cell.swc
@@ -0,0 +1,16 @@
+# id,  tag,      x,      y,      z,      r,    parent
+    1     1     0.0     0.0     0.0     2.0        -1  # seg0 prox / seg9 prox
+    2     1    40.0     0.0     0.0     2.0         1  # seg0 dist
+    3     3    40.0     0.0     0.0     0.8         2  # seg1 prox
+    4     3    80.0     0.0     0.0     0.8         3  # seg1 dist / seg2 prox
+    5     3   120.0    -5.     0.0     0.8         4  # seg2 dist / seg3 prox
+    6     3   200.0    40.0     0.0     0.4         5  # seg3 dist / seg4 prox
+    7     3   260.0    60.0     0.0     0.2         6  # seg4 dist
+    8     3   120.0    -5.     0.0     0.5         5  # seg5 prox
+    9     3   190.0   -30.0     0.0     0.5         8  # seg5 dist / seg6 prox / seg7 prox
+   10     4   240.0   -70.0     0.0     0.2         9  # seg6 dist
+   11     4   230.0   -10.0     0.0     0.2         9  # seg7 dist / seg8 prox
+   12     4   360.0   -20.0     0.0     0.2        11  # seg8 dist
+   13     2   -70.0     0.0     0.0     0.4         1  # seg9 dist / seg10 prox
+   14     2  -100.0     0.0     0.0     0.4        13  # seg10 dist
+   
\ No newline at end of file
diff --git a/hybridLFPy/population.py b/hybridLFPy/population.py
index e7d995c..e7739e0 100644
--- a/hybridLFPy/population.py
+++ b/hybridLFPy/population.py
@@ -934,6 +934,7 @@ def __init__(self,
         tic = time()
 
         PopulationSuper.__init__(self, **kwargs)
+
         # set some class attributes
         self.X = X
         self.networkSim = networkSim
@@ -946,6 +947,9 @@ def __init__(self,
         self.J_yX = J_yX
         self.tau_yX = tau_yX
 
+        # for computing the cumulative simulation times
+        self._cumulative_sim_time = 0.
+
         # Now loop over all cells in the population and assess
         # - number of synapses in each z-interval (from layerbounds)
         # - placement of synapses in each z-interval
@@ -954,13 +958,22 @@ def __init__(self,
         # - postsynaptic compartment indices
         # - presynaptic cell indices
         # - synapse delays per connection
-        self.synIdx = self.get_all_synIdx()
-        self.SpCells = self.get_all_SpCells()
-        self.synDelays = self.get_all_synDelays()
+        # self.synIdx = self.get_all_synIdx()
+        # self.SpCells = self.get_all_SpCells()
+        # self.synDelays = self.get_all_synDelays()
+        self._init_activations()
 
         if RANK == 0:
             print("population initialized in %.2f seconds" % (time() - tic))
 
+    def _init_activations(self):
+        """
+        private method for instantiating incoming events
+        """
+        self.synIdx = self.get_all_synIdx()
+        self.SpCells = self.get_all_SpCells()
+        self.synDelays = self.get_all_synDelays()
+
     def get_all_synIdx(self):
         """
         Auxilliary function to set up class attributes containing
@@ -1280,6 +1293,8 @@ def cellsim(self, cellindex, return_just_cell=False):
             for probe in self.probes:
                 probe.cell = cell
 
+
+            ticc = time()
             if 'rec_imem' in self.simulationParams.keys():
                 try:
                     assert self.simulationParams['rec_imem']
@@ -1293,6 +1308,9 @@ def cellsim(self, cellindex, return_just_cell=False):
             else:
                 cell.simulate(probes=self.probes, **self.simulationParams)
 
+            tocc = time()
+            self._cumulative_sim_time += tocc - ticc
+
             # make predictions
             # cell.simulate(probes=self.probes, **self.simulationParams)