examples/example_of_extraction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extracting electrical features and plotting traces using BluePyEfe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook will show you how to use BluePyEfe to extract electrical features from experimental voltage traces. For this example we will use the rat somatosensory cortex data available at: http://microcircuits.epfl.ch/#/article/article_4_eph\n",
    "\n",
    "Author of this script: Tanguy Damart @ Blue Brain Project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pathlib\n",
    "from pprint import pprint\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import bluepyefe\n",
    "import bluepyefe.extract"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using BluePyEfe to extract data and plot traces for a single cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The low level class in BluePyEfe is called \"Cell\". It is instantiated as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bluepyefe.cell import Cell\n",
    "\n",
    "cell = Cell(name=\"MouseNeuron\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The recording_reader argument is used to pass a reader function that should match the format of the files. Here we will trust the automatic detection of the format that uses the extension of the file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Right now, the cell is empty. But it will become a recipient for the recording's data. For that let's use one of the data file present in the tests/exp_data directory. To read a data file, our cell also needs the metadata associated in the form of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "files_metadata = {\n",
    "    \"i_file\": \"../tests/exp_data/B95_Ch0_IDRest_107.ibw\",\n",
    "    \"v_file\": \"../tests/exp_data/B95_Ch3_IDRest_107.ibw\",\n",
    "    \"i_unit\": \"pA\",\n",
    "    \"v_unit\": \"mV\",\n",
    "    \"t_unit\": \"s\",\n",
    "    \"dt\": 0.00025,\n",
    "    \"ljp\": 14.\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The exact fields of this dictionary depend of the metadata already present in your file. Check the reader functions present in bluepyefe/reader.py to see which entries are needed.\n",
    "\n",
    "The units should be the ones in which the recording file is, not the units you want the output to be in. The output units will always be ms, nA, mV.\n",
    "\n",
    "Using this metadata the cell is able to read the data file. The data is now accessible through the \"recordings\" attribute. \"recordings\" is a list that contains as many element as recordings present in the data file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'amp': 0.037498171441257,\n",
      " 'amp_rel': None,\n",
      " 'auto_threshold': -51.27845764160156,\n",
      " 'config_data': {'dt': 0.00025,\n",
      "                 'i_file': '../tests/exp_data/B95_Ch0_IDRest_107.ibw',\n",
      "                 'i_unit': 'pA',\n",
      "                 'ljp': 14.0,\n",
      "                 'protocol_name': 'IDRest',\n",
      "                 't_unit': 's',\n",
      "                 'v_file': '../tests/exp_data/B95_Ch3_IDRest_107.ibw',\n",
      "                 'v_unit': 'mV'},\n",
      " 'current': array([-0.02812363, -0.03437332, -0.03124848, ..., -0.03749817,\n",
      "       -0.02812363, -0.02812363], dtype=float32),\n",
      " 'dt': 0.25,\n",
      " 'efeatures': {},\n",
      " 'export_attr': ['ton',\n",
      "                 'toff',\n",
      "                 'tend',\n",
      "                 'amp',\n",
      "                 'hypamp',\n",
      "                 'dt',\n",
      "                 'amp_rel',\n",
      "                 'hypamp_rel'],\n",
      " 'files': ['../tests/exp_data/B95_Ch0_IDRest_107.ibw',\n",
      "           '../tests/exp_data/B95_Ch3_IDRest_107.ibw'],\n",
      " 'hypamp': -0.03124847635626793,\n",
      " 'hypamp_rel': None,\n",
      " 'id': None,\n",
      " 'location': None,\n",
      " 'peak_time': array([ 781.7,  945.7, 1115.8, 1282.3, 1462.5, 1662. , 1931.2, 2146.5,\n",
      "       2618.3]),\n",
      " 'protocol_name': 'IDRest',\n",
      " 'reader_data': {'current': array([-28.123627, -34.37332 , -31.248474, ..., -37.49817 , -28.123627,\n",
      "       -28.123627], dtype=float32),\n",
      "                 'dt': 0.00025,\n",
      "                 'i_unit': 'pA',\n",
      "                 'v_unit': 'mV',\n",
      "                 'voltage': array([-68.5904  , -68.5904  , -68.55916 , ..., -70.152824, -70.090324,\n",
      "       -70.152824], dtype=float32)},\n",
      " 'repetition': None,\n",
      " 't': array([0.00000e+00, 2.50000e-01, 5.00000e-01, ..., 2.99925e+03,\n",
      "       2.99950e+03, 2.99975e+03]),\n",
      " 'tend': 3000.0,\n",
      " 'toff': 2700.0,\n",
      " 'ton': 700.25,\n",
      " 'voltage': array([-82.5904  , -82.5904  , -82.55916 , ..., -84.152824, -84.090324,\n",
      "       -84.152824], dtype=float32)}\n"
     ]
    }
   ],
   "source": [
    "cell.read_recordings(\n",
    "    protocol_data=[files_metadata], \n",
    "    protocol_name=\"IDRest\"\n",
    ")\n",
    "\n",
    "pprint(vars(cell.recordings[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's select the first trace and plot it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<AxesSubplot:title={'center':'Holding Amp = -0.031 nA\\nAmp = 0.037 nA'}, ylabel='Current (nA)'>,\n",
       " <AxesSubplot:xlabel='Time (ms)', ylabel='Voltage (mV)'>)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAFDCAYAAAC++ly0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABLcklEQVR4nO2dZ3gc1dmG71fNlmXZcpF7kTFuYGPihimmmN5L6ISEAAFSCSSAExLIFwg1oYZmeg+EUG0wYHDFNsYF27j33m3Jtqy2u+/3Y2allbSSdnZnd2elc1+XLu2emTnz7NmZZ8+c8h5RVQwGg8EQGWnJFmAwGAyphDFNg8FgcIAxTYPBYHCAMU2DwWBwgDFNg8FgcIAxTYPBYHCAMU1DzIjINSJyjv26v4j8rY793gt3nIjcJCK9ozjvEBFZLyLZUQl3fr6BIvKm/TewxrYrReR5EXlNRHJEZICIPCsi74nIL+19bhWReTWPred8t4jIf+PxWQzRk5FsAYbGiYhkAc8BRcAeVf17yLYHAAH6AS8AnYBs22xzAR+wTFVfFpHngR3A0cDvVPWHkNP8FLgLuAR4TUReATYAA4CpQA8gQ1VvEZFvgP8ChwN/U9XNUXysm4FfAwo8BNwYsu1CVb3E/vG4SFVfB24SkTTgNeAZVX1ERFqFKasCe5+PbX3XqjWAejiwSkR6qur6KPQa4oCpaRrc4lci8izwN/v9acBUVf090DNoFiLSGuikqncAM8Pk86697TQRGQRsUtU7gaWhO4lIc6A98CZwbsimZ4F7gV6qehvQ3U4vUdXHgKexzDaYT1sReazG36F1fMbWqlqoqkVY5h5KcJbIeqCbnfd5wHjg0zryC2Wxqv4T2AN0EpGRwDzgLeDaCI43JAhjmga3eFpVb6LKNIUqI6lJuf2/LMy24pDjQ6mZ14+xaqj/BvqKSF87fZ+d774a+wefqjLDnDOjxl/luUXkGNtITwCKRKS1/QOwP9wHw6rdbgJQ1Y9V9Uzgqjr2DSX4uSuAZsDPgSOxarbn2TVWgwcwj+eGePEF8KxdW9yoqvtEBFUtEpGtIvIH4FhgVV0ZqOoiEfmtiNwLDAYOhGz+MXCuqpaIyBHAdQ3oSRORfwB9gFtCzrEH+E09GmYAMwBEZDfwpL3pITvtdVW9GvhQRJ4BsoFfi8iJwEVYBvipve/PgHOAASJyr6ouquO0OUA7Vb3YPu53wBlEVmM1xBkxc88NXkZErsMyuub2o360+bwXNCGDIRaMaRoMBoMDzOO5IemIyBDgA6C/qpbE8TwPAC2Ag6o6JiQ9B6uDqByYrKpvisjtQF8gH6t98XCstskM4DBVPaaBc2VhdV5dbT/iGxoJpqZpSDoi8hgwH1BVjcvQIRHpAdysqn8QkYeBJ1R1o73taqBQVT8RkXdU9bKQ424BvlHV2fb7C4COqvpcyD6vACuBrsCHqvqFiFyC1cM+TFV/FW3ZGLyH6ZEzJJUEDh3qCmy0X2/AHhZk0y1km9/OL0tEngJOBlaE7Hsl1jCgmrwA3IHVQQVwIfAGkCMiNYcnGVIYY5qGZJOQoUPAZqqMsjv2sCCbTSHb0gBUtVxVf4016Px8qKytFqlquOFGxdjDhUSkOzAIeALoCFwR7oMbUhPTpmlINokaOrRBRCpE5BGgTFU3isitwCTgfeDfInI28AmAiDyI1f7ZBviDnc11wMsRfKafAzeo6kwRyQT+B4yN4DhDCmDaNA0phRk6ZEg2xjQNBoPBAaZN02AwGBxgTNNgMBgcYEzTYDAYHGBM02AwGByQlCFHIvIoMAyYp6o3h6QPxBrULMAvVXWhiDwHDMQKDfYrVV3YUP7t27fXgoKCuGg3GAyNn7lz5+5S1fxw2xJumvY845aqOkpEnhGR4ar6nb35HqyBwAGsGR/nAw+o6loR6QM8QNWMizopKChgzpw5cfoEBoOhsSMidUbKT8bj+UjgS/v1RKxlDIK0UdWN9nziPABVXWtvq8Ce4mYwGAzJIhmmmUfV1Lgi+32QUD01I3ffjzUtLSwicoOIzBGROTt37nRBpsFgMNQmGaZZBAQXl2oFFIZsCx1pHwi+EJHfA0tUdXpdmarqWFUdpqrD8vPDNkUYHOLzByjz1V259/kDlPsqvyZKylPvQcBNzSXlflSV0or4l0O0usMdl4rfWzJJhmnOxIocA3AKMCtk2x4R6SYiXbBroyJyGnAMVsQbQwJ5cMIyLnyq7lCQf/tkMVc+X/X1DbhrQiJkuUZphd9VzQPumsAH8zfHvRzmb9gb9TlqHrd4S1HKfW/JJuGmqarzgFIRmYbVRrlBRO60N98NvIMVL/EuO+1JoBcwye5JNySIbfvKWLe7uM7tWwtLWbf7YAIVuUsgDlOI9x6sIN4zkw+U+VzLq7jM1DKdkpQhR6HDjGz+YacvxFpsK3TffonSZahOzUblWtsb2sHjxMPcElEkkpCzGOrCDG43GFwkLQF+5uaPlQnY4xxjmoYmSzzsQhJQ/Tb1zORiTLOJcsmzM8K+Bnhq0ioKxozn4wVbOFjuZ96Gvfzp/UUc+fcvauWz60AZAH/874Ja23739nyOe/Bryn0Brnx+Fm99u4GCMeO56fW51c77+sx1fPS9tdTP/Z8tpWDMeJZsqQrY/umirbw0fS3frdtDwZjxFIwZT5nPz89ems34hVt5atIqZqzexb++WN7g5/7t2/MpGDOe/87ZWJkW1HHW49P42UuzAfhi8TYKxownEKiy1gp/gKPum8jt71V91snLd/DkVysr87j748UAFIwZH7a8gue79NmZlXouHzuTS56dgaoyd/0e7v90aWUeBWPG8926PQC8N3cTV7/4La/OXFepN7jPpc/N5PpX57C3uJwZq3bxyJfWCh3Xv/odH32/mX9/vbKWjsuem8llY62OvHfnbOTd7zZW237KI1P4xWtzePKrlUxZsZNPF23lxelrKRgznp37re/d5w9wxdhZjLzvK2595/tqxwf1vvLN2sq0W975no17Dta65lIJE7m9ifLdur1hXwO1zGfGql28PXtDvfm9N3dTrbSPF2wBrCEtM1bvZod9o01YvK3aeZ+ftpZubbI5/8iuPDdlDQCz1uzmsC7WyLT/zd3ED1uKuGRo98q8SysCTFmxE39AmbVmNz87poAXp6/lD6fV3wT+ia3pmSmrOWNgp2o6lmzdB1ut/cYttF74VUmz63Y+v7J9XxnvztnEQxcPtj7LD9v4Tw2zCVJ4sCJsemh5B/UEmbJiF89NXcOfzhpQlbZ8J8ML2vL6zHUs2FRUmb5ka9UPy+y1lrFuLSrliyXbeWXGOm49tS8Tl+5g14FyFm4q5Dej+1Q717f2MQCvzliHCFw6vKqMV+04wKodB/hyyXauGNGDHftKK8+/Yc9B8nObUe4PMHPNbgDen7+ZRy47svL4oN6V2w9wzbG9APhg/mbOHtS51jWXSpiapqEWGWnVLwu3mr3q662O5Byh7YXBp+B0O9FpW2JDu2ekSy1daWHuFnfbFwlbEMFyi3frY0MdTIqzz6uV/6srT/UORGOaTZCGGv/TI3Ygh1d/HacNdxOFT6tKDL6qMk1378TMcA6ZJCrNJ0rXjOSwSPJW1VrfeGTHRSAghfDOlWHwDG73AAdrGvXdOzVrI+EINcbg6zSxDNZpB4yI1HvGyppmyF7hb373CqsuPfEYTxqOhorQcU1Tq45rTDTKNYKGDRumJspRdXYfKOOujxczuFtrMtPT+L9PljCiV1uuGNGdW95ZQPuWzbh4aDdW7djPxKU7GszvyO55fL+xEIDbTu/Hw59b7aC983MY1SefLYUlfLFkOwB9O7ZkxfYD1Y7v3ymXZdv206ZFJnvttr/MdKHCX3U9XvijrjTLSAvbZpif26yyMyKUq47qwaw1u+mSl03r7Ew2F5awcvsBOrVuTo+2Lfh6WdVnO75vPlNXWHEKWjbLqBw0fubATnz2g9Xu2q9jLvm5zbh+VC+uefm7ymN75+fQrmWzyrbEuhjVpz3z1u/lhH75LNhYxN6D5Ry0py2O6tOeaSt3Ve57Ur98Ji239Azq2ppFm6vaL0PLqT5ystIptvM/ZUCHsN/lzSf34a3ZG8KW3+BurVm3+yAl5X7K/YFa20PpnZ/DMb3b8/qs6gGBRvfvQGmF1Y4dZFSf9gwvaFvZQQUwpEceV4zowSXDuuM1RGSuqg4Lu82YZtNg8P99QVFJwzedwZBo1j1wdrIl1KI+00za47mIPCoi00Tk8RrpA0Vkuoh8Y6+DjYjcKSJbRMTMP4+S0KEzBoMhepJimqGBiIEsERkesjkYiPhS+zXAC8BViVXZuEhPT/EuS4PBIySrpuk0EPF2Gl97ckLJSMT8PoOhCZAs08wjukDEdWKCENdP5MOIDAZDfSTLNB0HIm4IE4S4fmoOWDcYvMLqnQca3slDJOtOchSI2BA7pqZp8Cq7D5QnW4IjkmKaTgMRi8h1wL+Aq0TkqSRITnlMm6bBq6TatMqkBexwGIj4ReDFBElrlGSY3nODwRVMQ1cTwbRpGrxKqv2cm9BwTYTc5hmcl/YNQ9KsuIrv+0chKBemWwt8zg30ZVpgEL/P+B8AOzWPp/wXcGvGu7TCWgfoQd/lnJU2m0FpVvi2d/wnkUMJ56RbTdIzA4cxL9CHX2d8BMAWbcdY/7mMyXib5lhT9v7h+wk/Tp9Kf7FCzb3uP5UOUsjpadYUxamBI1ge6M4vMsYDsF478rL/TP6S8ToZ9rL3f/Ndw9XpX9BbrLBqL/nPpJds46S0+QB8FRjCRs3nmvTPAVilXXnDfwp/y3gVgAoy+IfvJ1yX/indxZpm+JzvXA5PW8dxaYsAmBAYwS5txU/SJwKwVHvygf84/pzxJgAHac5Dvsu5Kf1jOok1lfLfvgsZnraMo9KseJgf+4+hlCwuTZ8MwMLAIXweGM5tGe8AUERLHvVdzG/T36edWM33j/gu5sS0BU3me1oa6AkB99Y8SgTGNJsIp/fNZdy6fDb5rZEFmzQfQfnYfwwAu2hNCc0q35eRBcCX/mFkYl3UFWQwT/uw1m/FodyqbcnEX3nMDvLYT4vK9wdpDsBn/uGk2wMh/KTxXaAfK+gGWDf9fm3Bx2ods03bUkROZR4HyAZgvH8koSE2ZgUOYzEFAOzRXCo0g/1q7btF21FMdmUe+2gBUPk+GKtnemAgOZQCUEQOSwM92KO5leVTSmblMUXk4CO98r3ffkibEhhMtm00B2jOIu3Fdn8bADZoR3ykVR6zh1zKQvIst2+/rwNDaIbVGVJKMxZo7ybzPd2f+QJZpYOBDqQKZu55E+GzD99kzZwJPOy7PNlSDIZKns/8Fx2veJIjDjs82VKq4cm554ZE0/h+HA2pzxZti0pqPfA2qFZEugGXA6OALkAJ8AMwHvhMVSMegG5IHhUZOWzXNsmWYTBU427fz/lfi9SajFKvaYrIy0BXYBzwILADaA70Bc4A7hSRMao6Nd5CDbGxo/VgXvNnJVuGwVCNBzLGkll8CNA22VIipqGa5r9U9Ycw6T8A74tIFtDDfVkGt+my51t+lf41T/svSLYUg6GSNnKAVs1Sq5WwXrV1GCYi0l1EblPVclVdFR9pBjdJVx/Z0vB0NScBYQ/t0DIWSVHTOjszKedNVX55Yu9kS6gTRchMsYkXEVu8iOSLyK/sqY+TgY6xnNhhEOJaaYamS6pNu0s2Xp5B+4eKm/DndE62DEc01KaZC1wEXInVjvk+0EtVu8Vy0tAgxCLyjIgMV9XgAizBIMQB4Gng/DrSDA7Y1OYonvC1anjHFCDduKYj3F6p000uS59MWtkIIDfZUiKmoZrmDuBa4F7gEFX9A+BGSBJHQYjrSDM4IG//cs5Mm51sGa7gYQ/wJE5X6kwkw9OWIRUlyZbhiIZM809AM6za3Z9ExK3GkTycBSGOKjCxoYpc3x56p212Nc+jD2nnan6RcnL/mFqGHNO/k7Na0OFdYq/RD+1Z//Cwbm2yI87Lqf5EokhEyzd7iXofz1X1MeAxETkEa6zmh0AXEbkD+EBVV9RzeH04DULcYGBiEbkBuAGgRw/ToV+T7Ix0Tuybz80/bbijx0ln0D0XDASgYMx4fnPSofx70qrK41U1brWcB348KKa846mtPh6csIxnJq9O+AqMDZ0vWeXx0IuFDMxOzo9vtETUEaSqa1T1PlUdBAwDWgOfxnBep0GIGwxMbCK318+evIGs6XJOXM9R856L500Ya95efmRNBskqj2z/AVB/Us4dLY4HSKnqD6r6Z1U9NNqTOg1CXEeawQHp/mKaVRTG9RzGhhqmEYZ6iIlj940nvWRPsmU4IqJJnyJyEdaMoA5Y94YAqqpRN944DEJcK83gjNb7V9Nq72LMwAODITYinSn/EHCuqi6NpxhD/DA1HIMXWZRzNPlZyZkkES2RmuZ2Y5ipzYGcHpRJs7ieo2ubbD76tXkgMETOiuwfcWIjNc05IvIOVu95WTBRVd+PhyiD+5Q0a8/BtPhenCLC4O55cT1HqpNqw2vizUW7niF9Xzfo0HgCdgRpBRwETgtJU6wZQoYUIH/PHFoVLcca/GAweInU+iGJyDRV9efxFmKIP/Hu3Ta95wan7MzqSof01ApZWO+QIxH5i4jUWW8WkdEiEt/BfwZXKM9sTXHzTnE9hxn7aHDKJ+2vx58bUyiLhNNQTXMR8ImIlALzgJ1YQYj7AEdizRu/L54CDe6wo81QAnlDOCZO+Z99RGdXpg82do47tD1lFWaxgyBXbvsnGYV/hvYDky0lYhqaRvkR8JGI9MEaJ9kZa0bOG8ANqppaM+2bMF23T6LVgdUw8u9xyf+pK4fEJd/Gxqg++YzqY2asBWmmJSk3IyjSNs2VwMo4azHEEdEAaSl2cRoaP6nVBWSRWnHmDVGjZrCLwYO83mkMvrxDki3DEQk3TRHJFZFP7CjsPw2z/SoRmSEi40SklZ32kYgUisgpidbbWNjUcTRLet+QbBkGQzVOKPyAtOJtyZbhiIhMU0RqTfMIlxYhvwD+AxwPXG8vzhbMMxO4yd72OnCjvekm4LEoz2cA8vfOp+fWCcmWYTBUo0fpCtLKi5MtwxGR1jSfjDAtEkYCX6qqH1gA9A/Z1gdYpKo+QiK6q+rWKM9lsGlWtpuckk3JlmEwVENTcHRvQ2sEHQ0cA+SLyK0hm1oB6VGeM4+6o7bXt61eTBDihpEUvEANjZuJba/gypZdki3DEQ31nmcBLe39QmPm7wMuru9AEemE9RgeyjaqoraXUjtqe30R3etFVccCYwGGDRtm+jxqsKPtUArbDGJwsoUYDCHk+XYi/rKGd/QQDY3TnAJMEZFXVHW9k4xVdRtwYs10u8Z6soi8izVAflnI5hXAQBFJp3ZEd0MMZJUX0sK/P9kyDIZqDN33FeklI4HuyZYSMZEG7GgmImOBgtBjVHV0FOd8AXgL+C0wVlXLReQMIF1Vx4vI88A0YC/W0sGIyBPAOcB5IvKsXas0OCDvwCrySjYC5yVbisFQnRQL9hqpaf4XeBbL8GIaIa2q+7AMMDRtQsjr17F6zkO3/w74XSznbepIil2YhqbBopbH0ik7dcLCQeSm6VPVZ+KqxBBXClv2pqxFfAN2GAxO2disD4GMnGTLcESkQ44+EZFfiUhnEWkb/IurMoOrlGa1oSTbmKbBW5y15zUy9jnqLkk6kdY0f2b/vy0kTYHUmv/UhOm0ezaty7cBI5ItxWCoQWo1HUUasKNXvIUY4k1qXZiGpsH2rB50zshOtgxHRDqNsoUdkHis/b6PCT6cPIbdO9HxMSXN2lPcIrWCvRoaP1+2uwpf64Jky3BEpG2aLwPlUBnDdjNwb1wUGRpk1wHng4G3tx3Ops6nx0GNwRA9l237F1m7liRbhiMiNc3eqvoQUAGgqgcxS8KkFAVbPqPf6peSLcNgqEa6+ki1pqNITbNcRLKxP52I9CZkKV9DKqBg1vAxeA2RlBvcHqlp3g1MALqLyJvAV8DtcVNlcB2VNAIS6WAJgyExvNXpdsryU2d9IIjANEUkDWgDXARcA7wNDFPVydGc0GkQYnv/r0Rkqp2WGy7fWCg8WM73GwvDbpu/YS+FB8vDbivz+Zmxelfl+2krd+IPVP/V3FpUwvJtzuZ8r9tVzLpdxVb+q6ryn75yFz5/dItyre14OisPuTqqYw2GeDF6z7tkFK5l3oa9LNmyjxenr613/3fnbGTJln317gOwdOs+thWVuiWzGg2apqoGgNtVdbeqjlfVcaq6q6Hj6sFpEOIK4CeqejzwEZZxu8obs9ZzwVPfhN124dMzeHv2xrDbvlu7lyuf/7by/dUvzmbz3uprzd336TIufmaGIz2/eXsev3l7HvM3FHLlC1X5/+TFb1m/56CjvIJ03j2T7ls+i+pYgyFedCpfR1pFMRc9PYOznpjGPePq7xS6/b2FnPPktAbzPe/f03no82UN7hcNkT6eTxSRP4pIdxdmBDkKQqyqpSFBiCuIce57NNS1uk4gTFtMzX01ivaaeDTxZJfvIbt0p/sZGwweRDV+8WMjbeS6zP7/65C0aGcE5RFFEGIRaYlV8zwzXKbxDEJcl4mFNU0XDc/Nrzy1mtoNTYWJba/kqta9gN2u5qvEr9+zQdO02zTHqOo7TjJ2MwixiAjwEnCnqobuX0kyghCHM8hwRuoFNrc7ln3NhCOTLcRgCCG/fCNpFYfFJe94jRVp0DRVNSAitwGOTNPlIMR/B75R1a+daHCb4KO22D9h4R/P460huuNyyrbR0ucDY5sGDzHowDekFx/per7RNItFSqSP5xNF5I9Yxlm5dJyq7oninI6CEItIF+AOYIaIXAi8E68wdU9NWsXDny/n2Z8M4YyBnZm1xnpkePjz5Szbtp9PFmzhrEGdePqqoRSMGV953P7SCgb97QvAMrWCMeNZ98DZAIxbaDXHrt9dzAkPT25Qw3NXD2Wx3Tt42VjrNyP0XJ8u2lqZ1rl1c/p1yiVNhF7tc3hx+lreuv4olm3bz99DGtR/O/pQNk+dzJl9soFzoywdg8F91u8u5v435hLa0hd6vQPccPwhrNy+nykrrDZ5EWHs1NW8OH0t2/eVMfKQtsxaU2VFIw9pS0Dhv3OthQRX7TzAB7+KdvHc2iS8TTOKIMRFWGsVxZ01O63fgx37y6r9B5i3fi8AP2yuPdyh3Bc6DCj8L9z+Ul9EGhoaJrF9X9X2rUWl+AJKRppUDnXaeaCMDTV62NfsLKYZUFqR8D40g6FevggMZ7u2qXefVTsOsGTrPkJH863bfZDt+6z7c3GNe/LbtVUGumhzESt3HHBPMCbKUTWCPd/h2kKCj+IVYcZJSkiLc6xPBQ09VqTVaN1WVQSp1BdQDZvHQj2EXi1MCFSDt1ivHSmhWb37BK/x6mmR5Z8m4vqjekSmGW4QOoCqvuaqGo8gYbrdqkyz9hcQure/ji8o0p68hr7e9LTaF09N0w6Xx35twcGM1pGJMBgSxPXpn/KO/0QWau869wnfE173nRJ6C8ajBz3Sx/PhIa+bAycD84BGapq104KPBuFqmtX2i27CTsTU1BZQrTZ9t64f1VHpixiwbyVwWlz1GQyJINLKo4j7nbMSTdVVRPKA/6jqGS7rcYVhw4bpnDlzItp3w+6DHP/wpFrp/7xkMH/874Kwx9xz/uH89aPFYbf9qEce8zcUktssAwUOlEXWlhlvLk6fwvE9mnPejX9PthSDoZK77/wd0wKDWKNd4nqeYMdspIjIXFUdFm5btBEcioFG0c45c034GaF1GSZQp2ECzN9QCMB+j5hlkM3ant1ZrRre0WBIIK/5T0VTLMpkpG2an1BVy00DDgPejZeoRBKvqVZeY3agP71yTeR2g7f4e8Yr/M9/PN/rocmWEjGR1jT/GfLaB6xX1U1x0JN4moZnclH6NEbsyQGGJFuKwZDS1GuaInIo0FFVp9RIP1ZEmqnq6riqSwA1h/AYDIbEUUYmgRSruTQU5egxqgJohLLP3pbyrN9d3PBOjYByzaBUM5Mtw2Coxr2+q+sdbuRFGjLNjqq6qGainVYQzQmdBiG206aKyBQ7GHGHaM5bF09+vcrN7DzLR4Hj+DrbLKxm8BbXpY+nr4SPV+tVGjLNvHq2RbtYsdMgxAAnq+oJWONCfxbleZs0p6V9x9ADUxre0WBIID1kBy0paXhHD9GQac4RkV/UTBSR64G5UZ7TURBiAFWtsLdnA3WP9zHUSRs5QE6gKNkyDIZqpNpwI2i49/z3wAcichVVJjkMK4DGhVGeMw+HQYhFpAdWhKVckhCEuLGgAbfnRhgMsfGc71yKyEm2DEfUa5qquh04RkROAoJLxo2PJK6lm0GIVXUDcLSI/Bj4I3BzGK0JD0KcSnzmH87BnPaYpdUMXuKwtHUs1x4c1ObJlhIxkUY5mgTUnmtY/zGuBCG22zl9as333AfuN4B8kvVnAMrJ5Mfl/8cDGWM5PG0dALdU/IqRaUu5LN36+C/4zmKjduD/Ml8BYFbgMP7pu5T3sv4GwD7N4aqKO3k08ykOlc0A/KriZk5Pm8P56dbibU/5LqCIHP6c8SYAUwKDGes7mzez7gNgp+ZxbcXtPJ35GN1lBwDXld/GJelTOCN9NgCP+C5BEf6QYc0x+Nw/nHf8J/JS1sMAbNJ8fllxCy9mPkwH2ctBmvO+/w63i85giIl+spE7Mv7DnEA//uy7ng+y7iIDH37SuKD8Xu7NeJHBadbIxtsrbuTItFVcmf4VAK/6T2dFoBv/yHwRgDmBftzr+wkfZv0VgIM057LyuxiVthBwNo2yPqKaex7TCa0e8beAtlhBiF+pEYT4auCX2EGIgdZYnUIBoAy4xjbkOnEy97xmwNPGzPF983nt2hHJlmEwVJKo+88Lc8+jJsogxCckRl3jJtE/kAZDYyTSJXwNjQDjmQZD7BjTbEJ4daVMgyGVMKbZhMjKMF+3wRArTf4uGtHLvXVz0lwap/vTo3uGTW/TIpN+HXOjzveJK34U9bEGQzw5rHMrzj/SvUDEt53ez7W8atLkTbN5Zrpreb1x/VGO9h9zZv9aaRcN6crfz7eGxL50zTD6d6oyyfl3ncZnN4+KWl+r5iZgh8GbfHrzKB6/vPaPeqdWDY/fvPOsAbXSfn1S/OJzNnnTdKt2CJAehzBzNRd5M62SBkN16lrMMF40edN00+Yy0l3Ircb3n3ozcw2GxOJP8PTgJm+abgYhTk9zVpzhfiBrJtXM0oy1NBiqk+h7osmb5hUjqoJ7tM6uv81vVJ/2nH1E58r3eS0yK9slszLSwtYKf9Qjr878ju/bvlZa8AL4ycgeDOjcihuOtwK0njKgY9g8aq6DbjCkMl3zqkec/OPp/fjxkLrXtjq+bz4n9O3A0J5tImr/dIOEzwgSkVyqplE+p6qv1dh+FfBrYA9wpT2DCBEZghVpKdMOHecKJ/W3YhoHp1kNvedLdheXc/PJfXj8q5UAPHLpYG59dwGvX2d19Owr+ZY1O4v5ZsxoAG46wTK27zcWAvDiz4Zx3atzqk3dmvDDVm56Y15lWsGY8RzepTUXDenKuAVbWfGPM6tNKbv3gkEAnDc4m/MGV/Uqhv6mhub18jXD+fkr3zHzT6M5+v6vefYnQzljYCcKxoxn9p0nM+IfX7lSXgZDPAneU6FcPLQbWwpL2FxYwoY9B7nxhEP405nVO3/+98tjgPDTMk8Z4Grc8qTUNKMJQgzwK2Ce22JqVtQiqeiLSNhHgvoeE+raJAgactaGzt/QAHWfv/b2prLipqHxoiiVLWmOn8bdvf6TYZqOgxCLyOHAJmC/22Jq9k5HQpqA07bn+nYP9cGGmmca2u6rFFa1o1k7ztAY8MplnAzTzMNhEGKsYMj/jrcwiKxRWQhf4wumhDOpOmuaDmu6ddY07Xx8/kC95zMYUhHVkAqOQ/d0u9IQtzZNt4IQi0gfYJ+q7qqvVuhW5PY+HXKZvW4PnVpXNSq3zcmqtk/PdjmU+QK1js1tZhVn6+ysWtvqomteNv1CBrB3a1P/0kt19fYHO7GCg/XzWlRpyExv8v19hhSnoF0Ouc0zKfcFIu7wyUgTfAGlR9sWrmpJRjzNW4GtwLtYgY1PUdVye1sm8BVwEvBjrBUvV2HVNA8CI4D3VfX6+s7hJJ4mQIU/UGks/oDiDyiZ6UKZL0B6mpCZnlZtn0DAaoUM13Md3C90f4BxC7fwm7fmV3beBLcHAkpAlYz0NEor/GSlp5HWQI/47e8t4N05m2rlFfxfWuGvNM+69BgMXqDCfjJq6NoM3nOqSnqa1NmsFppfhT9Amlgt+g3dUzXxVDxN4AWs3vPfYgUhLq8RhPh5YBp2EGJVLQLeBxCRyVgdRa4S+oWlp0mlGYZOsQzdp74vILhfQxdBcHtamhAcrBTplM6a40FrnjOcbmOYBi8S6XVZdc/Vb36h+cXrmk+FIMSh+50YV3FxxN0KvWmwNBiShal+JAg3bc508hgMycOYZoIw0x8NhsZBMto0mySj+3fg5WuGu5LXb0YfyiXDuruSl8FgcIYxzQSR2zyzcspmrHRr04JubdwdRmEwGCLDPJ4bDAaDA4xpGgwGgwOMaRoMBoMDEj4jKBGIyE5gvYND2gO74iTHLVJBI6SGzlTQCKmhMxU0gnOdPVU1P9yGRmmaThGROXVNmfIKqaARUkNnKmiE1NCZChrBXZ3m8dxgMBgcYEzTYDAYHGBM02JssgVEQCpohNTQmQoaITV0poJGcFGnadM0GAwGB5iapsFgMDjAmKbBYDA4oMmbpog8KiLTRORxD2gpEJHtIjJZRL6w024Tkeki8qYd2T5sWoL0dRGReSJSKiIZdlqt8os0LREaw5WpvV/SylVEjhKRGfa5HnWiJ5HffR06i+yynCwibe20q+z9xolIq7rS4qRxoH2eaSLysljE9Zps0qZpr6XeUlVHAVki4k4Yotj4UlVPVNXTRKQDcJKqHgcsBC4Il5ZAbXuAk4FZEL78Ik1LlEabyjK1dSe7XNcDo+1zdRCREyLRk4TvvqbOQVirxZ5o/+2RMMtuh0uLo8blqnqMfW2BtSROXK/JJm2a2MsJ268rlwxOMifZv363AMOAyXZ6UF+4tISgqqWqujckKVz5RZqWKI1QvUwhyeWqqttUtdR+WwEcHqGehH73YXT6gQF2WT4gIkL4ZbfDLsUdJ40VIW/LsH4w43pNNnXTzKPu5YSTwVagL9bCcqdg3SQ19eWFSUsWeUSmL1xaoqhWpiJyhFc02lrysVZk9Ww5BnWq6hIsQzweaAOc6wWdInKeiPwAdAQyI9QTtcambpq1lgxOnhRQ1TJVLbZ/occBq6mtz0uaw2mJNC0hhCnTgV7QaLcH/hu4zoGehJdjDZ2o6h61xil+iEfKUlU/VtWBwCbAF6GeqDU2ddOciVWdB6tmN6uefeOOiOSGvD0Wa/niE+z3QX3fhUlLFuHKL9K0hBCmTFcTvgwTVq52J9obwB9VdZsDPQn97mvqFJEcEQkudRosyxXAQDs9qClcWrw0Ngt5uw9rOa64XpNN2jRVdR5QKiLTAL+qzk6ypFEiMldEZgCbVfVbYKqITAeOBD5U1R010xIlTkQyRWQiMBj4HOtRqFr5hSvTRJZzGI231izTcGWY4HK9BBgOPCTWstS9I9GThO++ps4jgO9EZCrQHXjPblMMLrv9M+C5cGlx1HiGiEwRkSlYj+cPEOdr0swIMhgMBgc06ZqmwWAwOMWYpsFgMDjAmKbBYDA4wJimwWAwOMCYpsFgMDjAmKbBYDA4wJimwWAwOMCYpsFgMDggI9kC4kH79u21oKAg2TIMBkOKMnfu3F11rXvuOdMUkaOAR4EA8J2q3iIitwHnY8X3u6ZGOKhaFBQUMGfOnPiLNRgMjRIRWV/XNi8+njcYoDWZ4gwGQ9PGc6YZYYBWg8FgSAqeM80gDQRoDbf/DSIyR0Tm7Ny5MyEaDQZD08OTphlBgNZaqOpYVR2mqsPy88O23xoMBkPMeM40IwzQanCZwvc/SMgxyTgu1mPdzCOe+cZLnxt4WZtTPGeaRBCgNWnKGjEVmzcn5JhkHBfrsW7mEc9846XPDbyszSmeG3Kkqm8Db9dIngk8mAQ5BoPBUA0v1jQNBoPBsxjTNBgMBgcY0zQYDAYHGNM0GAwGBxjTNBgMBgcY0zQYDAYHGNM0GAwGBxjTNACQ2bVrQo5JxnGxHutmHvHMN1763MDL2pwiqppsDa4zbNgwNfE0DQZDtIjIXFUdFm6bqWkaDAaDA4xpGgwGgwOMaRoorfDTGJtpDIZ4YEzTQP+/TmDS8h0JO19phT9h5zIY3CZlTFNEHhWRaSLyeLK1NEaKSupdq64WB8t9FIwZH9W5+v91guNjyn0BfthcFNX5fP4Auw6URXVskEnLdsTF7J+dspr7P10acz5z1+9lx/7ShndMAv/3yWJemLYm2TJcIyVMU0SGAC1VdRSQJSLDk62pqVPhS+zj/NQVOznnyelRHfv+vM0Mu3diTOf/+SvfRW3a9TF5+Q4+X7wt5nx+/MwMXpq+LnZBceDTRVuZvmpXsmW4RkqYJjAS+NJ+bRZX8wKS4NPFcL6D5T5XNHi91Vc9qlAQGlOTeaqYZh4NLK5mFlaLDa9f1LGYpsRycJwRxD2r8+h36OHij4pUMc0GF1czC6vFhudNM9FV2zB4vYy8iuBZP4+KVDHNmcDJ9muzuJrBEW7VdLw+LMur6kTE82XnBNdMU0RyRCTdrfxCUdV5QKmITAP8qjo7HucxRE7CH7mSX9H0PI3JmLxM1AuriUgacDlwFdbqkWVAMxHZBYwHnlPVVa6oBFT1ZrfyMtTG6e3WFD0zHpbk5o+Plz3Ty9qcEktNcxLW8rp/AjqpandV7QAch/X4/KCI/MQFjQZDTHjBcBOBV31JxLs9+9EQyxK+p6hqrRHRqroH+B/wPxHJjCF/g6ESL/eAx4pbtTCv1uZEvKstGmKpaX4oIleJSMu6dghnqgZv4vX2sJgs0yXD9XgReRYvjHxwk1hMcyxwDrBGRN4VkQtFJMslXYYEY/wgObjapunhb7Ex/eBEbZqq+pGqXgEUYD2O/xTYICIvi8ipLukzGABvDJD2simBd40prZG1acY85EhVD6rqO6p6IXAacCTgPCKDwVAPsTziecBv66UxGUo4rHGayVbhHjGbpoh0FJHfisg3wIfA58CQWPM1JBiHF3UjugciJ04f2q02Py+3S3tXmXNiGaf5C+AKoB/W4/ltqjrDLWEGQyixzT13T0c8cKum6VVjEvCuuCiIZcjR0cD9wFeqGnBJjyFFSHSlxuO+FzWNLQJQWBrZlxe1aarqtcHXInIEVodQRsj292NSZkgonm9X88CNF68ZQY19nCakwPXlgFhqmgCIyEvAEcBiIFjjVMCYZmMmhe6BxjZOsC68akxpjawjKGbTBEaq6mEu5GMw1IkXjC8eN76bEYC8akwmNFxtZoqIMc0Ux6s3XBAvdATFoybn5k+Bl79CL/fsO8UN03wNyziXi8hCEVkkIgujzcyOwD7L/rvSTssQkddFZLqIjHFBs6EGTi9prz4KpiJulaRXfckK2NF4cOPx/EXgamARVW2asfCFqo61g33MAt4CzgOWqerVIjJORDqpauyrURlShjQPjBuKz+O5d83OLbzQtOImbpjmTlX92IV8AFDVdfZLn/0H1sJq79mvJwEjANfOaXB+4yZ8yFEsj+fuyXAdd7V5130b0w+DG6Y5X0TeAj7BCkQMuDLk6CbgI/t1HhEsrAbcANCjR48YT930MI/byUFE3Bvc7tGv0Dye1yYbyyxPC0lrcMiRiHQC/lMjeZuqXi4iRwFnARfY6TUXVqsVEV5Vx2JFXmLYsGGN6TvyJIku4FhqZO51BLmPAAEXMvbyY754WVwUxGyaqvrzKI/bBpxYM11EugL/As5TVb+dHFxYbTZwEvB2VGINdeL1a9oDTZpx6QF2dXC7R+tzZsiRjYj8RUTa1rN9tIicE0XWdwEdgfdFZLKIZGM9+g8UkenATFXdGp1qQ1047j1PuMvGEuXIA45bJ+5oE7z9w+dlbU6Jpaa5CPhEREqBecBOoDnQBys83ETgPqeZquqNdWy6KjqZhojw+FUdU03TtSV83cknTM4x5+Dl5UDMGkE2qvoR8JGI9AGOBTpjdda8AdygqiXuSDQYvN0DHgtuPZ57+RHYw34eFW60aa4EVrqgxZBEnA9uTx3cume9PCPIy30tghDwqrgocGNGkKER4PVrOpbB7W49usZtcLsb+eDeHHa38bKhR4MxTUNUNMXB7XExTbdqYR5+BPZy00E0GNM0AN4PqBDTGkFeHqfp6pAj7+L168sJbqwR1FdEvhKRH+z3R4jIX2KXZkgkjTlgh2umGadxmm6QJh42pkbWE+RGTfN54E9ABYCqLgQudyFfg6GS2B7PXWrTdCWXMPm6YHZeHovqXWXR4YZptlDV2TXSfGH3NHiWRFdSElkr8nRNE3EvNJxL+biN6QiqzS4R6Y39nYnIxYCZsZNiOL6mY7wJGtNNFBMu9ZKIuDOHPR5YH9Gj4qLAjYAdv8YKlNFfRDYDa4GfuJCvIYEkuj0skWfz9JAj3Bpy5F3ErBFUHVVdA5wiIjlAmqruj12WobFjmXTkt7oXbrr49J67M77SzbWG4oF3lTnHjdUob63xHqxQbnNV9ftY8zd4k1hvgoTWNF3KJ141Tbfy8aoxWcFEvKrOOW60aQ7DChjc1f67ETgDeF5Ebnchf0MCSHxHUOLO5eWF1ax8XcDDz+dp4l5nlxdwwzS7AUNU9Q+q+gdgKNABOB64JtpMReQjEbnXfp0rIp+IyDci8lMXNBuSjFMDisWwXBty5PU1grzqTB429GhwwzQ7ELLMBdZ4zY52lKOy8IfUj4gcgRURPsgvsKK8Hw9cLyJZUWo11IFjE0uh3nNPzwjCnRqsFQHeq66Jdw09CtzoPX8T+FZEguv5nAu8ZXcMLYkyz98BT2M9+oO1sNpvVNUvIguA/kDUywQbapOo+y0ZbVvutWnGY0aQOz3Lno6nSaPyTFd6z+8RkQnAMXbSTao6x37tOHCwiPTHCmhcGJKch1lYLa4k+qJO5OqXHvYT94YceXgAuXh5imcUuFHTRFW/E5H1WJHbEZEeqrqhvmPqWlgNyxzvwqpNBgkurFZq/y8Mo8EsrBYDjk0sxls9sYOdvdum6drgdrw9gNy7ypzjxpCj87AWQusC7AB6AMuAw+s7rp6F1T4HXgHaAu1E5EvshdVE5F2spTSWxarbUJ1E3XBB4/Hq7JX6iE8QYpfWCPJwdTrNDG6vxT1YbY4TVfVHInISMcwIUtXTAUTkROAUVZ0iIvOBt4DfAmNVtTxm1YZqmLnnDRMvyU1h3fPGhBumWaGqu0UkTUTSVHWSiDwWa6aqOhmYbL/eB0SzsqXBoyRyeQ1PD253cY0gL9fevdx04BQ3TLNQRFoCU4E3RWQHUOxCvgYPE+2NHjwssUOOvBsazs2OIK9iLcWRbBXu4cY4zfOBg8AtwARgNaZWmHIkvHczkabpUj7xCkLsTr7eHdjj5Z79aHDDNO9S1YCq+lT1VVV9ArjDhXwNjRjng+ljmBHk6cHt7kwxbGzG5GXcMM1Tw6Sd6UK+hgTifMhRtOfRqM7nCTzepulVvB6BySlRt2mKyC+BXwGHiEjo7Jxc4JtYhRkSS8IHtyf4fG4QlyFHLrqdV8vUy4YeDbF0BL0FfAbcD4wJSd+vqntiUmVo9DiteXjBELxcWUoTl5YCjhPeVeacWEwzHWv2zq9rbhCRtsY4Uwvn0xpjnRGUOLy9RK5bg9tdySYuNLb21lhMcy5V11HNr0yBQ2LIO6HMnTuXuXPnMnr0aObOnUtRUREXXnghH3zwAYceeijZ2dksWrSI008/nWnTplFeXs4ZZ5zBuHHj6N/fmu25bNkyzjnnHCZMmEBWVhajRo3i888/Z9CgQZSUlLBq1arKPFu3bs3QoUP5+uuvGTp0KDt37mTDhg2V29u3b8+AAQOYNm0aI0eOZP369WzdurVye+fOnenZsyezZs1i1KhRLF26lF27dlVu79GjB/n5+RF/pgOLJzHLt4BLDrsm4s+0Ycde9n8/gZ07Rzj6TJOnTKF8h48Jn47nYOGuiD9TefM2lG3bwtixYx1/T+PffYvSjX6mTs2N+nsq21bC9zN2s//7Ule/p21ritj//XRWreoX07VXvq81K1ZM4o3MFZ679lZM/p7ybkMZO3Zs0u6niy66yD3DUNVG9zd06FA1RE7PO8bpI18sd3TMxj3F2vOOcRoIBBwdV+7za887xun2ohJHx81Zt0d73jHO0TFBvli8Lepjg/S8Y5y+MWtdTHmE48/vL4xZm6rq0fdN1Ktf/NYFRe7z85dn6/B7v0y2DEcAc7QOf3ElYIc9//x4++1kVR3nRr4G7xJ83FKN7tEwFZ/W4jUjyJ18vNtD7d0RpNER85AjEXkAuBkrduYS4GYRuS/WfA2JJeohRE731+r/U4l4jdNs7Jg2zdqcBRypqgEAEXkVmA/82YW8DYkiyqtaHa4qWXlcAmefu1YDi9OMILfy8a4xNa4fBjcGt0P1oMCtXcrTkAJEP8jdVRlNHhGvB8XwsjZnuFHTvB+YLyKTsH5Sjqf6uE1HiEga8BBW3My9qnqJiORijQttCzynqq/FrNpQjUSZX/DGTuiQI4/lE4p7S/h6tzbn7Vqwc2KZEfQU8Jaqvi0ik4Hh9qY71AowHC0XA0tV9Y8hacGF1f4DTBKR/6iJqekq0V7U0Q6o9mqnRX0E4hB7zc3gwV4tUtMRVMUK4J8isg4rwtFGVf04RsMEK0LS4SIyWUR+YaeNBL5UVT8QXFjNkMIkco2gpoCXa3ONbY2gqE1TVR9X1aOBE4DdwEsiskxE7haRvjFo6oi1nMUpwFUi0pEIF1YTkTkiMmfnzp0xnL5pEu0Svqlgfl6eEeRaR5A72cQFtyI5eQU3VqNcDzwIPCgiPwJewloYLb2+4+pZWK0ImKKqPhGZCRyKWVgt7kQfVDjax/PozpdM4hEZPc3FAMlenUrp5VpwNLgxTjNDRM4VkTexAngsBxqcs6Sq21T1xBp/lwMzgCPs3QYB66laWC0ds7BaXEhUR1CwDdRpW6g/Jsdy545Ni4MpuZVlhS9AejwEukBA1bPaoiFq0xSRU0XkJWATVkfNeKC3ql6uqh/FoOlF4AoR+QaYraqbgBew1lCfBrxkOoHcx+klfbDCBzi3o+Iyf1THHSjzOTyiiv2l0R8LUO4LAFDhD8SUTzg2F5aQnVnvQ1mDqCpbikrp1Kq5S6rcxR9QTzcfOCWWx/M/YQ0D+oOq7nVJD6q6nxo1VTULq8Udp4+J366xglg5rTFu2HMQcG5AS7ZYTdqBgJLmsNby9OTVjvavyeuz1nNEt9aUlLtrmgs3FfLZD9s4vEurmPJZsf0A/TvlxsXU3WDO+r30bNsi2TJcI5aOoNGq+oKbhmlIHrnNnf1+Tl6+g0Pa51BW4exG/X5jIQAl5X5Hx01btYve+TmU+pwdt3L7fopKKhjYtVVUQ4aWbNnHgxOW8dvRfSpr126wraiU8/79Df+96eiY2zVfm7mOkwd0oNThd5EIdh8oIyNNaB5jbdpLuDUjyJCiHCy3jMDJjbth90EmLd9J/865jsxPVbln3BIOyc+hpCLy4z6cv5kDpT66tmnh2GxPfXQqd597GM0z0inzOTOVnfvLOOuJadx0Qm/a5mRS6vDcdTF1xU5G3v8VFw/txvCCtjHN5Nm09yDjF23lwh91c/yDkggufW4m5x/ZlVIH37fXMabZxPlu3V66tG5OuYNHuz/+dwF/PK0vLbIyKC6PvPY19N6JAJw1sHPEN9GBMh/3jl/C45cfSfOMNEodGN87320A4LzBXcjOSnd0467eeYDh/5jIn8/qz62n9iU7M4ODMZpmaYWfhz9fxk9fms0jlw7mn5cMjik/VeW4Byfx57MG0LFVM08Z04EyH2c8NpXVO4v5y9kD8Dei7nNXQsMZUpc3Z63nnMFdKI6wo2X5tv2U+fzceEJv7h23pLKm2hCrdx5gT3E5M8aM5v15myK+wW98fQ4/PbqAPh1zyc5KpySC8+0pLucXr81hS2EJC+4+DREht3kGRSUVtMnJavD40go/l4+dxbXH9uKG43sD0LJZRlQdSsVlPn760mzmrrdasYb2bMOE34+if6eqdsxo/eTK57/llAEduXRYd3z+gONauFuU+wJkZaShqoyduoZJy3cwa80ezhzYifG/G+XqrCcvYEyzCbNp70G+WbWL60cdwqeLtja4f3GZj9veW8DDFw8mMz2N1tmZ7C2uaPC4Mp+fO95byLjfHkeXvGxaZWdSeLDh4x74bBkVPuV3J/cBoENuM3bsK+PQDrl1HuMPKEPu+ZKhPdsw6Y8nVraldW/Tgg17DlLQPqfec/6wuYhznpzOZcO6c9e5h1Wmd2rdnK37ShvUDFZnlQLPTlnNw58vB+Cxy47krEGdycqo/XDXPDOdknI/2VmRt/st2lTEgk2FzPnLKQBkpKcltDZXdLCCySt2MOZ/i2o1tZx/ZBdmjBlNl7zsyrRAwKoZNwYDNabZRFFVRv9zCj89uictm2U0WNPcsa+UEfd9xcMXH0G/TpZpFbTPYd3u4oiO+9OZ/RnY1QqA1aNtC75dW/8SUr97ez4fL9jCsnvOqEzr1qYFm/aW1HnM3uJyfnTPl5wyoCMv/GxYtW092rVgvd1zHw5/QLnqhVnMWrOH//3yaIb2bFtte1ZGGhW+QL03flFJBcfc/xXF5X5ErGFcz1w1hDMHda73s3Zs1Yzt+0obNPQgpRV+Hvp8GW9efxQtsqpu4XQRfP4AGenOWt0CAaUiECArPY2AEnZMpc8fQIFzn5zOsm37K9NbNstg2T1nUOYL4A8obeuoybfJsX4oI6npex1jmk2UmWt2M6BzLn855zC2FZWyY39Znfv+Z/YGxry/iN+cdCiXDOtemd47vyXfrtkQ9hhV5Q//XcD78zZzyoAO3HhC78ptvdrn8Pt3vueOM8KHEPh4wRY+XrCFz24eVa3XtWe7FsxcvTvsMfM27OWip2fw+1P68PtTas/iLWiXw6RlO8IeW1rh54rnZzF/QyGPXDq4lmEG6dG2BWt3FXNIfstan/WCp2ewYGMhXfOyWXD3iY6Mq0fbHNbuKm7QNFWVG16fy5dLtnPtsb04sntete3d27Zgza5i+nasuyYe5Ns1uyku93HtK3Pq3OeUAR2YuLR2mYX7IWiod7x7G+tHy5imISUJBJR/fr6cxy7/EVBV0wlXi/p00VbGvL+Iey4YyNUje1bbNqBzK37YUlQr/5JyPwPumgDAlNtOpGe76mbQo20LOuY2D3u+61+dw8Sl25l2+0l0rzG2b3C3vLBjLp+ZvJoHJyzjphN6hzVMgMO7tOLxiStrpW/ae5DjHpzESf3yWX3fWfXOXBl5SFu+WbWrmmluKyrltvcWsGBjIf+5YSQjD2lX5/F1MbRnG75bt4eT+ncIu/3zxdu4+6PFbNtXytCebVhw92m0zs6std9Rvdry7Zrd9Zrm7gNlXPH8LFZsP1CZNu+vp9KyWUZl08HaXcW8PnM9px7WkbvPPZz83GbsL/WRmS7ktYjO9A7v0opFm4tqGX0qYkyzCfLl0u0c3qU1veyajYhQ0C6H5dv3V3ZQ+PwBDr3zMwCm3nYSPdrVHpyclZFGh9xmrN1VXJnXl0u284vXrNrLyn+cSWaYGpeIMKhba75csp3TDu+EqvLAZ8uYvmoXW4tKWXbPGWFrLm1ysqzZL4UldMnLprTCz9lPTGP1zmIm3noCh3ZoWeuYIHktsthf5mPxliIO72I1E3y+eBs3vj437A9COM4+ogvD/zGRHw/tRoVPueL5WSzZuo/TD+/ImvvOcjzoPsiIXm259d3vub1Gzful6Wv5+7gltMvJ4qxBnbnz7AE0y0irs3ngqEPa8a8vlnP10QW1tq3eeYBrX/mO9butJor5fz21zlpfr/Y51dpzoeGaZEMcdUg7nvhqZUTl7HWMaTYxAgHlX18s59VrR1RLv3hoN/4xfimvX3cUhQfLOfLvXwKw9v6z6m28/9kxBdz36VIeu+xIHv1yBS9MX8tjlx3JBT/qWq+Oi4Z05crnv+WRSwezcFMR36zaxSOXHsmgbvUH/v/FqEO46oVvOXNgp8pa5+w/n0yHCKYQ3nP+4Zz9xHTOGtSJTxdZEQzfuv4ojjm0fYPHAuTnNgPgsLs+B+DsQZ15+efD6Rjj9MXW2ZkM6dGGeRv2MqRHG/aXVnDKI1No37IZ79wwkqMirL326dCSDXtKmLR8Byf168CUFTt5fOIK5m0oBCAjTXjz+qM4NsLP6yZ9OrRk3MKtPHxxVYdXuS/AhU9/w8vXDI/o+/MK0pji3AUZNmyYzplTd1tNU2bCD1u5Z9xSvhkzulp6aM0S4LhD2/P6dSMa7O1UVW56Yy7TVu7iYLmfl64Zxuj+HSPSct+nSxk7dQ0AS/5+erVOjfp4beY6Zq7ezS9P7M0R3fIiOibIF4u3MXf9Xqau3MXHvzk2bE24Ib5csp0uec0ra6xusGBjIec/9Q39OubaNf5cxv9ulONAFxN+2MZNb8ytlvb45Udy/pH1/4glgp+9NJspK3by9i9GMm/D3sqRBa9fN4JRffKTrK46IjJXVYeF3WZMs2lxxN8+5/1fHRN22I6q8p/vNnJUr7a1OjsM8efm/8znq6U7+PDX4b+fSPlu3R46tWpeq0042VT4A/z4mRks3FRE344tuemE3hSX+UhLE646yluP7fWZpnk8b0Ks21XMkJ5t6rwhRYQrRvRIsCpDkMftjrlYGV4Qvvc/2WSmp/Hxb46rljZ/w17enbMpSYqiw3PTKEXkMBH5xv67x07LFZFP7LSfJltjqvLxgi1c4IHHNIMhyIDOrfh+Y2FKLYfhOdMEbgL+pKrHAiNFJI+qhdWOB64XkdQf7JUEpq/cxUn9wg9rMRiSQfPMdA7v0qpymmkq4EXTXA60tqO0A5RhFlaLmUBAOVDmo3WL2uP7DIZkcvnw7tz10eKUqW160TS/BJ7AMs+ZqlqCWVgtZtbtLqagvbc6BgwGgGEFbVm/u5hef/qUN79dn2w5DZK0jqB6FlYT4FJgLvA/ESkgwQurqSrl/gAVfuWgXTs7UOqjXctm+ANKmri7XnXoebfvK2PG6l1MWr6TW0/tS6vmGeQ2zyQ9Tbjv06Us3FTIiu0H+OzmUXRu3RwRYe2uYt6ft4nZa/dw7XG9OFju4/g++bRpkcWsNbu5d/xSlmzdx6g+iR+fZzBEwg//dzrHPTiJOz/4gTs/+AGAnx9bwJkDOzOil7c6tpJmmvb66CfWTBeRd4E9qhoQkSIgl6qF1d7F5YXVPlu0lV++OY/cZhl0b9uCJVv3NXwQdsSdGvO1rzyqB299u4GT+uXTOjuTwpIK5qzbS+fWzfEFlLW7ihlR0JbZ6+oPVhHkkwVb6tx23INfV1sdMa+FFRChrkAYx/Rux+g6pukZDMlGRPhmzOjKYUlbi0pZteMAlz43E4DmmWmUVgQQgUFdW3Ni33wuGdY9KcOqPDdOU0SGAk8CfmCpqt4gIq2w1iNqC4xV1Vfqy8PJOE1VZfXOA/TOb4mIUOEP1DngubTCTzN7fu5Tk1axZmcxbXOyeGH6WgBeu3YEc9btYe3ug8xbv5dmmWn4/EqLrHSGFbQB4OhD2pOVkUaLrHS2FpXSIiudUw/riCphw4bVRyCglcGDG9NyAgZDEFXlm1W7rXgFrZvx0XwrmMv0VbsA6N42m+EFbenUqjkdWzWna14201ftIqBKXosslmzZx5CeefzyhN6Ong7N4HaDwdDo8AeUFdv3M2fdHv760eJa2/98Vn/mbyhk14Ey3r3xaNdM0wxuNxgMKUl6mjCgcysGdG4VNkhJvPBi77nBYDB4FmOaBoPB4ABjmgaDweAAY5oGg8HggEbZey4iOwEnUwvaA7viJMctUkEjpIbOVNAIqaEzFTSCc509VTVskM9GaZpOEZE5dQ0v8AqpoBFSQ2cqaITU0JkKGsFdnebx3GAwGBxgTNNgMBgcYEzTYmyyBURAKmiE1NCZChohNXSmgkZwUadp0zQYDAYHmJqmwWAwOKDJm6aIPCoi00TkcQ9oKRCR7SIyWUS+sNNuE5HpIvKmiGTWlZYgfV1EZJ6IlIpIhp1Wq/wiTUuExnBlau+XtHIVkaNEZIZ9rked6Enkd1+HziK7LCeLSFs77Sp7v3F2RLKwaXHSONA+zzQReVks4npNNmnTFJEhQEtVHQVkicjwZGvCWtbjRFU9TUQ6ACep6nHAQuCCcGkJ1LYHOBmYBeHLL9K0RGm0qSxTW3eyy3U9MNo+VwcROSESPUn47mvqHAQsssvyRFXdYxv3TVjrd70O3BguLY4al6vqMfa1BTCCOF+TTdo0sdcesl9PBI5OopYgJ9m/frcAw4DJdnpQX7i0hKCqpaoaugJWuPKLNC1RGqF6mUKSy1VVt6lqqf22Ajg8Qj0J/e7D6PQDA+yyfEBEBOiDZaS+EE3h0uKlsSLkbRnWD2Zcr8mmbpp5NLD2UILZCvQFTgJOwbpJaurLC5OWLPKITF+4tERRrUxF5AivaLS15GMt3+LZcgzqVNUlWIZ4PNAGONcLOkXkPBH5AegIZEaoJ2qNTd00g2sPQR1rDyUSVS1T1WL7F3ocsJra+rykOZyWSNMSQpgyHegFjXZ74L+B6xzoSXg51tCJqu5Ra8jNh3ikLFX1Y1UdCGwCfBHqiVpjUzfNmVjVebBqdrPq2TfuiEhuyNtjgVXACfb7oL7vwqQli3DlF2laQghTpqsJX4YJK1e7E+0N4I/2WlmR6knod19Tp4jkSNXS2sGyXAEMtNODmsKlxUtjs5C3+wAlztdkkzZNVZ0HlIrINMCvqrOTLGmUiMwVkRnAZlX9FpgqItOxFpT7UFV31ExLlDgRyRSRicBg4HOsR6Fq5ReuTBNZzmE03lqzTMOVYYLL9RJgOPCQiEwGekeiJwnffU2dRwDfichUoDvwnt2m+DwwDfgZ8Fy4tDhqPENEpojIFKzH8weI8zVpBrcbDAaDA5p0TdNgMBicYkzTYDAYHGBM02AwGBxgTNNgMBgcYEzTYDAYHGBM02AwGBxgTNPgKUSknYh8b/9tE5HN9usDIvJ0nM75exH5qQv5/EdE+rihyeBdzDhNg2cRkb8BB1T1n3E8RwYwDxhiT7WMJa8TgJ+o6i9cEWfwJKamaUgJROREERlnv/6biLxqR9tZLyIXichDIrJIRCZIVezJofZskbki8rmIdA6T9WhgXtAwxYoT+aiIzBGRpXYYsfdFZKWI3GvvkyMi40VkgYj8ICKX2XlNwwoKkhH/EjEkC2OahlSlN5bhnYc1P3qSqg4CSoCzbeN8ErhYVYcCLwH/CJPPscDcGmnl9nKvzwIfAb/GCk5xjYi0A84AtqjqYDtQxAQAVQ1gxQsY7OonNXgK84toSFU+U9UKEVkEpGMbF7AIKAD6YRndl1bYR9KxwsTVpDOwtEbaxyF5LVbVrQAisgZrzvUi4F8i8iAwTlWnhRy7A+hCbSM2NBKMaRpSlTKwanciUqFVjfMBrOtasAyvoeCyJUDzcHnbeZWFpAeADFVdYUf+Pgu4V0S+UtW/2/s0t/M0NFLM47mhsbIcyBeRo6Ey+tHhYfZbChzqJGMR6QIcVNU3gIeBISGb+wI/RCfZkAqYmqahUaKq5SJyMfCEiLTGutYfAxbX2PUzrHVsnDAIeFhEAljLQPwSQEQ6AiV2jExDI8UMOTI0eUTkA+B2VV0ZYz63APtU9UV3lBm8iHk8NxhgDFaHUKwUAq+6kI/Bw5iapsFgMDjA1DQNBoPBAcY0DQaDwQHGNA0Gg8EBxjQNBoPBAcY0DQaDwQH/D+DtDTmygR5QAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 352.8x345.6 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "recording = cell.recordings[0]\n",
    "recording.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we did not specify a starting time, finishing time, step amplitude and holding current in the metadata, we implicitly ask BluePyEfe to infer them from the current time series.\n",
    "BluePyEfe does so through two steps:\n",
    "- It tries to guess the shape of the current stimulus based on the name of the protocol. In the present case, IDRest is associated to the eCode \"Step\" which represent a simple current step.\n",
    "- It tried to find the beginning and end of the step \n",
    "To check if the eCode was interpreted correctly, we can compare above, the original current array (in blue) with an artificial one generated from the ecode_params (in orange).\n",
    "\n",
    "If you are unhappy with the results (for example the orange line does match with the actual current), you can set the eCode parameters by hand through the metadata. For a step current, the parameters are :'ton', 'toff', 'tend', 'dt', 'amp', and 'hypamp'. For example, if we want to specify the ton and toff by hand, we would do:\n",
    "\n",
    "    files_metadata = {\n",
    "        \"i_file\": \"../tests/exp_data/B95_Ch0_IDRest_107.ibw\",\n",
    "        \"v_file\": \"../tests/exp_data/B95_Ch3_IDRest_107.ibw\",\n",
    "        \"i_unit\": \"pA\",\n",
    "        \"v_unit\": \"mV\",\n",
    "        \"t_unit\": \"s\",\n",
    "        \"dt\": 0.00025,\n",
    "        \"ljp\": 14.,\n",
    "        \"ton\": 700., \n",
    "        \"toff\": 2700.\n",
    "    }\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have a voltage time series, we can get efeatures from it. A list of all the features available can be found in the documentation of the eFEL package (https://efel.readthedocs.io/en/latest/eFeatures.html and https://bluebrain.github.io/eFEL/efeature-documentation.pdf). For now, let's make a list with a few features and extract them from all the recordings labelled as \"IDRest\" protocols:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Threshold was not provided and was automatically set to -51.27845764160156\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'AP1_amp': 66.47175655411542,\n",
      " 'AP_width': 3.111111111108989,\n",
      " 'ISI_CV': 0.4542672780653756,\n",
      " 'Spikecount': 9.0,\n",
      " 'mean_frequency': 4.6922655822351}\n"
     ]
    }
   ],
   "source": [
    "interesting_efeatures = [\n",
    "    'Spikecount',\n",
    "    'mean_frequency',\n",
    "    'ISI_CV',\n",
    "    'AP1_amp',\n",
    "    'AP_width'\n",
    "]\n",
    "\n",
    "cell.extract_efeatures(\n",
    "    protocol_name='IDRest', \n",
    "    efeatures=interesting_efeatures\n",
    ")\n",
    "\n",
    "pprint(cell.recordings[0].efeatures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using BluePyEfe as a bulk efeatures extraction tool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saw how to read recordings and extract features for a single cell, however the true use of BluePyEfe is to do so for groups of cells.\n",
    "\n",
    "The first thing we will need to do so is to create a dictionary containing the metadata for all the files we want to use. For the current example on two cells, the structure of this dictionary will be as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'B6': {'IDRest': [{'i_file': '../tests/exp_data/B6/B6_Ch0_IDRest_181.ibw',\n",
       "    'v_file': '../tests/exp_data/B6/B6_Ch3_IDRest_181.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0},\n",
       "   {'i_file': '../tests/exp_data/B6/B6_Ch0_IDRest_183.ibw',\n",
       "    'v_file': '../tests/exp_data/B6/B6_Ch3_IDRest_183.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0},\n",
       "   {'i_file': '../tests/exp_data/B6/B6_Ch0_IDRest_182.ibw',\n",
       "    'v_file': '../tests/exp_data/B6/B6_Ch3_IDRest_182.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0},\n",
       "   {'i_file': '../tests/exp_data/B6/B6_Ch0_IDRest_185.ibw',\n",
       "    'v_file': '../tests/exp_data/B6/B6_Ch3_IDRest_185.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0},\n",
       "   {'i_file': '../tests/exp_data/B6/B6_Ch0_IDRest_184.ibw',\n",
       "    'v_file': '../tests/exp_data/B6/B6_Ch3_IDRest_184.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0}]},\n",
       " 'B8': {'IDRest': [{'i_file': '../tests/exp_data/B8/B8_Ch0_IDRest_148.ibw',\n",
       "    'v_file': '../tests/exp_data/B8/B8_Ch3_IDRest_148.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0},\n",
       "   {'i_file': '../tests/exp_data/B8/B8_Ch0_IDRest_149.ibw',\n",
       "    'v_file': '../tests/exp_data/B8/B8_Ch3_IDRest_149.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0},\n",
       "   {'i_file': '../tests/exp_data/B8/B8_Ch0_IDRest_147.ibw',\n",
       "    'v_file': '../tests/exp_data/B8/B8_Ch3_IDRest_147.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0},\n",
       "   {'i_file': '../tests/exp_data/B8/B8_Ch0_IDRest_146.ibw',\n",
       "    'v_file': '../tests/exp_data/B8/B8_Ch3_IDRest_146.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0},\n",
       "   {'i_file': '../tests/exp_data/B8/B8_Ch0_IDRest_145.ibw',\n",
       "    'v_file': '../tests/exp_data/B8/B8_Ch3_IDRest_145.ibw',\n",
       "    'i_unit': 'pA',\n",
       "    'v_unit': 'mV',\n",
       "    't_unit': 's',\n",
       "    'dt': 0.00025,\n",
       "    'ljp': 14.0}]}}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import glob\n",
    "\n",
    "files_metadata = {\"B6\": {\"IDRest\": []}, \"B8\": {\"IDRest\": []}}\n",
    "\n",
    "for cell in [\"B6\", \"B8\"]:\n",
    "    for file in glob.glob(f\"../tests/exp_data/{cell}/{cell}_Ch0_IDRest_*.ibw\"):\n",
    "\n",
    "        files_metadata[cell][\"IDRest\"].append({\n",
    "            \"i_file\": file,\n",
    "            \"v_file\": file.replace(\"Ch0\", \"Ch3\"),\n",
    "            \"i_unit\": \"pA\",\n",
    "            \"v_unit\": \"mV\",\n",
    "            \"t_unit\": \"s\",\n",
    "            \"dt\": 0.00025,\n",
    "            \"ljp\": 14.\n",
    "        })\n",
    "        \n",
    "files_metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now read these recordings. The result of this step is a list of Cells that contains the recordings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'amp': 0.11874420754611492,\n",
      " 'amp_rel': None,\n",
      " 'auto_threshold': -44.747528076171875,\n",
      " 'config_data': {'dt': 0.00025,\n",
      "                 'i_file': '../tests/exp_data/B6/B6_Ch0_IDRest_181.ibw',\n",
      "                 'i_unit': 'pA',\n",
      "                 'ljp': 14.0,\n",
      "                 'protocol_name': 'IDRest',\n",
      "                 't_unit': 's',\n",
      "                 'v_file': '../tests/exp_data/B6/B6_Ch3_IDRest_181.ibw',\n",
      "                 'v_unit': 'mV'},\n",
      " 'current': array([-0.00312485, -0.01562424, -0.00937454, ..., -0.00937454,\n",
      "       -0.01562424, -0.00937454], dtype=float32),\n",
      " 'dt': 0.25,\n",
      " 'efeatures': {},\n",
      " 'export_attr': ['ton',\n",
      "                 'toff',\n",
      "                 'tend',\n",
      "                 'amp',\n",
      "                 'hypamp',\n",
      "                 'dt',\n",
      "                 'amp_rel',\n",
      "                 'hypamp_rel'],\n",
      " 'files': ['../tests/exp_data/B6/B6_Ch0_IDRest_181.ibw',\n",
      "           '../tests/exp_data/B6/B6_Ch3_IDRest_181.ibw'],\n",
      " 'hypamp': -0.012499390169978142,\n",
      " 'hypamp_rel': None,\n",
      " 'id': None,\n",
      " 'location': None,\n",
      " 'peak_time': array([ 741.5,  824.5,  984.5, 1045.5, 1119. , 1180.3, 1244.8, 1319.5,\n",
      "       1381.3, 1456.3, 1525.2, 1598.8, 1666.3, 1735.5, 1808.8, 1882. ,\n",
      "       1961.5, 2041.5, 2116.5, 2190.8, 2265.8, 2335.5, 2418. , 2489. ,\n",
      "       2553.5, 2638. ]),\n",
      " 'protocol_name': 'IDRest',\n",
      " 'reader_data': {'current': array([ -3.1248474, -15.624237 ,  -9.374542 , ...,  -9.374542 ,\n",
      "       -15.624237 ,  -9.374542 ], dtype=float32),\n",
      "                 'dt': 0.00025,\n",
      "                 'i_unit': 'pA',\n",
      "                 'v_unit': 'mV',\n",
      "                 'voltage': array([-69.09038 , -69.09038 , -69.059135, ..., -71.590256, -71.52776 ,\n",
      "       -71.52776 ], dtype=float32)},\n",
      " 'repetition': None,\n",
      " 't': array([0.00000e+00, 2.50000e-01, 5.00000e-01, ..., 2.99925e+03,\n",
      "       2.99950e+03, 2.99975e+03]),\n",
      " 'tend': 3000.0,\n",
      " 'toff': 2700.0,\n",
      " 'ton': 700.25,\n",
      " 'voltage': array([-83.09038 , -83.09038 , -83.059135, ..., -85.590256, -85.52776 ,\n",
      "       -85.52776 ], dtype=float32)}\n"
     ]
    }
   ],
   "source": [
    "cells = bluepyefe.extract.read_recordings(files_metadata=files_metadata)\n",
    "\n",
    "pprint(vars(cells[0].recordings[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main purpose of BluePyEFe is to output efeatures and protocols that can then be used as input by BluePyOpt. To do so, the efeatures need to be averaged over the cells present in the dataset for different step current amplitude referred to as \"targets\". These targets need to be defined as percentages of the spiking threshold of the cells, here 150%, 200% and 250%.\n",
    "\n",
    "Therefore, the second requirement to be able to extract efeatures is a dictionary containing theses targets. They are defined as a combination of a protocol name, target amplitude and names of the efeatures:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "interesting_amplitudes = [150, 200, 250]\n",
    "\n",
    "targets = []\n",
    "for efeature in interesting_efeatures:\n",
    "    for amplitude in interesting_amplitudes:\n",
    "\n",
    "        target = {\n",
    "            \"efeature\": efeature,\n",
    "            \"protocol\": \"IDRest\",\n",
    "            \"amplitude\": amplitude,\n",
    "            \"tolerance\": 20.,\n",
    "        }\n",
    "\n",
    "        targets.append(target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now extract the efeatures for these targets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Threshold was not provided and was automatically set to -44.747528076171875\n",
      "Threshold was not provided and was automatically set to -40.21649169921875\n",
      "Threshold was not provided and was automatically set to -42.65387725830078\n",
      "Threshold was not provided and was automatically set to -36.35730743408203\n",
      "Threshold was not provided and was automatically set to -38.12284469604492\n",
      "Threshold was not provided and was automatically set to -38.87281036376953\n",
      "Threshold was not provided and was automatically set to -36.34168243408203\n",
      "Threshold was not provided and was automatically set to -41.87266159057617\n",
      "Threshold was not provided and was automatically set to -45.18499755859375\n",
      "Threshold was not provided and was automatically set to -47.247406005859375\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Cell B6 : \n",
      "{'AP1_amp': 59.778331750135465,\n",
      " 'AP_width': 2.2192307692290307,\n",
      " 'ISI_CV': 0.2524553695652191,\n",
      " 'Spikecount': 26.0,\n",
      " 'mean_frequency': 13.417623532456453}\n",
      "\n",
      "Cell B8 : \n",
      "{'AP1_amp': 69.2091239924128,\n",
      " 'AP_width': 2.755999999997989,\n",
      " 'ISI_CV': 0.08762231450204114,\n",
      " 'Spikecount': 75.0,\n",
      " 'mean_frequency': 37.92188092531959}\n"
     ]
    }
   ],
   "source": [
    "cells = bluepyefe.extract.extract_efeatures_at_targets(\n",
    "        cells=cells,\n",
    "        targets=targets\n",
    ")\n",
    "\n",
    "for cell in cells:\n",
    "    print(\"\\nCell \" + cell.name, \": \")\n",
    "    pprint(cell.recordings[0].efeatures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can plot all the recording for the cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/cell.py:266: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
      "  fig.show()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1512x360 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cell.plot_all_recordings(show=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The average efeatures for the dataset are a function of the relative amplitude of the step currents with respect to be the rheobase. To be able to compute these relative amplitudes for each cell, we would need for example \"IDThresh\" data which are often used to find the minimum step current that can induce a spike. In the case where you have data to compute the rheobase (for example IDThresh traces), you will have to pass the list of the protocol names you want to use for this task in protocols_rheobase, e.g:\n",
    "\n",
    "analyse_threshold(protocols_rheobase  = [\"IDThresh\", \"IV\"]).\n",
    "\n",
    "Since we do not have this data in this example, we are going to set the threshold current by hand for our cells and then ask BluePyEfe to compute the relative amplitude for all the traces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "for cell in cells:\n",
    "    cell.rheobase = 0.07\n",
    "    cell.compute_relative_amp()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now compute the mean efeatures for our dataset and output the efeatures and protocols files which will also be saved in the MouseCells directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Standard deviation for efeatures Spikecount stimulus IDRest is 0 andwill be set to 0.001\n",
      "Standard deviation for efeatures mean_frequency stimulus IDRest is 0 andwill be set to 0.001\n",
      "Standard deviation for efeatures ISI_CV stimulus IDRest is 0 andwill be set to 0.001\n",
      "Standard deviation for efeatures AP1_amp stimulus IDRest is 0 andwill be set to 0.001\n",
      "Standard deviation for efeatures AP_width stimulus IDRest is 0 andwill be set to 0.001\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'IDRest_150': {'soma': [{'efeature_name': 'Spikecount',\n",
      "                          'efel_settings': {'Threshold': -45.997467041015625},\n",
      "                          'feature': 'Spikecount',\n",
      "                          'n': 2,\n",
      "                          'val': [23.0, 3.0]},\n",
      "                         {'efeature_name': 'mean_frequency',\n",
      "                          'efel_settings': {'Threshold': -45.997467041015625},\n",
      "                          'feature': 'mean_frequency',\n",
      "                          'n': 2,\n",
      "                          'val': [11.774026404701962, 1.6435971277544912]},\n",
      "                         {'efeature_name': 'ISI_CV',\n",
      "                          'efel_settings': {'Threshold': -45.997467041015625},\n",
      "                          'feature': 'ISI_CV',\n",
      "                          'n': 2,\n",
      "                          'val': [0.23593477808268337, 0.016520591482535693]},\n",
      "                         {'efeature_name': 'AP1_amp',\n",
      "                          'efel_settings': {'Threshold': -45.997467041015625},\n",
      "                          'feature': 'AP1_amp',\n",
      "                          'n': 2,\n",
      "                          'val': [64.4187301591853, 4.640398409049837]},\n",
      "                         {'efeature_name': 'AP_width',\n",
      "                          'efel_settings': {'Threshold': -45.997467041015625},\n",
      "                          'feature': 'AP_width',\n",
      "                          'n': 2,\n",
      "                          'val': [2.362115384613638, 0.14288461538460706]}]},\n",
      " 'IDRest_200': {'soma': [{'efeature_name': 'Spikecount',\n",
      "                          'efel_settings': {'Threshold': -45.18499755859375},\n",
      "                          'feature': 'Spikecount',\n",
      "                          'n': 1,\n",
      "                          'val': [44.0, 0.001]},\n",
      "                         {'efeature_name': 'mean_frequency',\n",
      "                          'efel_settings': {'Threshold': -45.18499755859375},\n",
      "                          'feature': 'mean_frequency',\n",
      "                          'n': 1,\n",
      "                          'val': [22.38900903194492, 0.001]},\n",
      "                         {'efeature_name': 'ISI_CV',\n",
      "                          'efel_settings': {'Threshold': -45.18499755859375},\n",
      "                          'feature': 'ISI_CV',\n",
      "                          'n': 1,\n",
      "                          'val': [0.09441845869846707, 0.001]},\n",
      "                         {'efeature_name': 'AP1_amp',\n",
      "                          'efel_settings': {'Threshold': -45.18499755859375},\n",
      "                          'feature': 'AP1_amp',\n",
      "                          'n': 1,\n",
      "                          'val': [69.60285300920727, 0.001]},\n",
      "                         {'efeature_name': 'AP_width',\n",
      "                          'efel_settings': {'Threshold': -45.18499755859375},\n",
      "                          'feature': 'AP_width',\n",
      "                          'n': 1,\n",
      "                          'val': [2.6431818181799027, 0.001]}]},\n",
      " 'IDRest_250': {'soma': [{'efeature_name': 'Spikecount',\n",
      "                          'efel_settings': {'Threshold': -42.26326942443848},\n",
      "                          'feature': 'Spikecount',\n",
      "                          'n': 2,\n",
      "                          'val': [56.0, 6.0]},\n",
      "                         {'efeature_name': 'mean_frequency',\n",
      "                          'efel_settings': {'Threshold': -42.26326942443848},\n",
      "                          'feature': 'mean_frequency',\n",
      "                          'n': 2,\n",
      "                          'val': [28.33176388123112, 3.024918379505765]},\n",
      "                         {'efeature_name': 'ISI_CV',\n",
      "                          'efel_settings': {'Threshold': -42.26326942443848},\n",
      "                          'feature': 'ISI_CV',\n",
      "                          'n': 2,\n",
      "                          'val': [0.07393798105385893, 0.003492483658947214]},\n",
      "                         {'efeature_name': 'AP1_amp',\n",
      "                          'efel_settings': {'Threshold': -42.26326942443848},\n",
      "                          'feature': 'AP1_amp',\n",
      "                          'n': 2,\n",
      "                          'val': [65.06245221577123, 4.659150030882742]},\n",
      "                         {'efeature_name': 'AP_width',\n",
      "                          'efel_settings': {'Threshold': -42.26326942443848},\n",
      "                          'feature': 'AP_width',\n",
      "                          'n': 2,\n",
      "                          'val': [2.46596774193369, 0.22596774193530234]}]}}\n",
      "{'IDRest_150': {'holding': {'amp': -0.032810899429023266,\n",
      "                            'delay': 0.0,\n",
      "                            'duration': 3000.0,\n",
      "                            'totduration': 3000.0},\n",
      "                'step': {'amp': 0.1062448164448142,\n",
      "                         'delay': 700.25,\n",
      "                         'duration': 1999.75,\n",
      "                         'thresh_perc': 151.77830920687742,\n",
      "                         'totduration': 3000.0}},\n",
      " 'IDRest_200': {'holding': {'amp': -0.05312240868806839,\n",
      "                            'delay': 0.0,\n",
      "                            'duration': 3000.0,\n",
      "                            'totduration': 3000.0},\n",
      "                'step': {'amp': 0.14061813801527023,\n",
      "                         'delay': 700.25,\n",
      "                         'duration': 1999.75,\n",
      "                         'thresh_perc': 200.88305430752888,\n",
      "                         'totduration': 3000.0}},\n",
      " 'IDRest_250': {'holding': {'amp': -0.032810899429023266,\n",
      "                            'delay': 0.0,\n",
      "                            'duration': 3000.0,\n",
      "                            'totduration': 3000.0},\n",
      "                'step': {'amp': 0.17967873346060514,\n",
      "                         'delay': 700.25,\n",
      "                         'duration': 1999.75,\n",
      "                         'thresh_perc': 256.6839049437216,\n",
      "                         'totduration': 3000.0}}}\n",
      "{'all_holding_current': {'B6': -0.012499390169978142,\n",
      "                         'B8': -0.05312240868806839},\n",
      " 'all_threshold_current': {'B6': 0.07, 'B8': 0.07},\n",
      " 'holding_current': [-0.032810899429023266, 0.020311509259045124],\n",
      " 'threshold_current': [0.07, 0.001]}\n"
     ]
    }
   ],
   "source": [
    "protocols = bluepyefe.extract.group_efeatures(cells, targets)\n",
    "\n",
    "efeatures, protocol_definitions, currents = bluepyefe.extract.create_feature_protocol_files(\n",
    "    cells=cells,\n",
    "    protocols=protocols,\n",
    "    output_directory='MouseCells'\n",
    ")\n",
    "\n",
    "pprint(efeatures)\n",
    "pprint(protocol_definitions)\n",
    "pprint(currents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also plot the summary efeature plots for the cells which will also be saved as pdfs in the MouseCells directory. On these plots, to know which marker style corresponds to which cells, use the legend.pdf file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from bluepyefe.plotting import plot_individual_efeatures, plot_grouped_efeatures\n",
    "output_dir = 'MouseCells'\n",
    "\n",
    "plot_individual_efeatures(cells, protocols, output_dir, key_amp='amp_rel')\n",
    "plot_grouped_efeatures(cells, protocols, output_dir, key_amp=\"amp_rel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using BluePyEfe to extract efeatures and plot them in one line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following command performs all the operations detailed above. It is convenient when using BluePyEfe in other workflow or when interacting with the Extractor object is not needed:\n",
    "\n",
    "Note: this command will not produce any useful result in the present case as we do not have data to compute the rheobase of the cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "efel_settings is None. Default settings will be used\n",
      "Cannot compute the relative current amplitude for the recordings of cell B6 because its rheobase is None.\n",
      "Cannot compute the relative current amplitude for the recordings of cell B8 because its rheobase is None.\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/extract.py:410: RuntimeWarning: Mean of empty slice\n",
      "  global_rheobase = numpy.nanmean(\n",
      "Number of values < threshold_nvalue_save for efeature Spikecount stimulus IDRest_150. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature mean_frequency stimulus IDRest_150. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature ISI_CV stimulus IDRest_150. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature AP1_amp stimulus IDRest_150. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature AP_width stimulus IDRest_150. The efeature will be ignored\n",
      "No efeatures for stimulus IDRest_150. The protocol will not be created.\n",
      "Number of values < threshold_nvalue_save for efeature Spikecount stimulus IDRest_200. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature mean_frequency stimulus IDRest_200. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature ISI_CV stimulus IDRest_200. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature AP1_amp stimulus IDRest_200. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature AP_width stimulus IDRest_200. The efeature will be ignored\n",
      "No efeatures for stimulus IDRest_200. The protocol will not be created.\n",
      "Number of values < threshold_nvalue_save for efeature Spikecount stimulus IDRest_250. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature mean_frequency stimulus IDRest_250. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature ISI_CV stimulus IDRest_250. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature AP1_amp stimulus IDRest_250. The efeature will be ignored\n",
      "Number of values < threshold_nvalue_save for efeature AP_width stimulus IDRest_250. The efeature will be ignored\n",
      "No efeatures for stimulus IDRest_250. The protocol will not be created.\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/extract.py:473: RuntimeWarning: Mean of empty slice\n",
      "  numpy.nanmean(list(threshold.values())),\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3432: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/core/_methods.py:190: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/Users/damart/Desktop/BluePyEfe/bluepyefe/target.py:86: RuntimeWarning: Mean of empty slice\n",
      "  return numpy.nanmean(self._values)\n",
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1878: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "The output of the extraction is empty. Something went wrong. Please check that your targets, files_metadata and protocols_rheobase match the data you have available.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, _, current = bluepyefe.extract.extract_efeatures(\n",
    "    output_directory='MouseCells',\n",
    "    files_metadata=files_metadata,\n",
    "    targets=targets,\n",
    "    threshold_nvalue_save=1,\n",
    "    protocols_rheobase=[],\n",
    "    write_files=True,\n",
    "    plot=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert current[\"all_holding_current\"] == {\n",
    "    \"B6\": -0.012499390169978142,\n",
    "    \"B8\": -0.05312240868806839,\n",
    "}\n",
    "assert current[\"holding_current\"] == [-0.032810899429023266, 0.020311509259045124]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  },
  "vscode": {
   "interpreter": {
    "hash": "58168fb1302c2c75da8b5793a20ab6f2a9f7ece7beec039164847186ab82f21e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}