criticality_avalanche_startn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'3.7.6 (default, Jan  8 2020, 13:42:34) \\n[Clang 4.0.1 (tags/RELEASE_401/final)]'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Import packages\n",
    "#---------------------------------------\n",
    "import sys\n",
    "import os\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=RuntimeWarning) \n",
    "\n",
    "#Import your modules\n",
    "#---------------------------------------\n",
    "import admin_functions as adfn\n",
    "import criticality as crfn\n",
    "import IS as isfn\n",
    "\n",
    "import trace_analyse as tfn\n",
    "# Define paths\n",
    "#----------------------------------------------------------------------\n",
    "Fcode = '/Users/dominicburrows/Dropbox/PhD/Analysis/my_scripts/GitHub/'\n",
    "Fdata = '/Users/dominicburrows/Dropbox/PhD/analysis/Project/'\n",
    "Fdoc = '/Users/dominicburrows/Documents/'\n",
    "F10t = '/Volumes/Dominic 10tb/'\n",
    "F10t2 = '/Volumes/Dominic 10tb2/'\n",
    "Ftm = '/Volumes/Dominic Time Machine/'\n",
    "Ffig = '/Users/dominicburrows/Dropbox/PhD/figures/'\n",
    "\n",
    "%load_ext autoreload\n",
    "sys.version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Process data\n",
    "- calculate avalanche statistics over a range of avalanche initiation threshold (2,3,4) sizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_0.16nnb.npy\n",
      "Done PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_0.16nnb.npy\n",
      "Done PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_0.16nnb.npy\n",
      "Done PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_0.16nnb.npy\n",
      "Done PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_0.16nnb.npy\n",
      "Done PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_0.16nnb.npy\n",
      "Done PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_0.16nnb.npy\n",
      "Done PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_0.16nnb.npy\n",
      "Done PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_0.16nnb.npy\n",
      "Done PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_0.16nnb.npy\n"
     ]
    }
   ],
   "source": [
    "# Calculate avalanches with different minimum avalanche initiation sizes\n",
    "for i in range(len(nnb_l)):\n",
    "    nnb = nnb_l[i]\n",
    "    bind = bind_l[i]\n",
    "    av2 = avalanche2(np.load(nnb), np.load(bind))[0]\n",
    "    av4 = avalanche4(np.load(nnb), np.load(bind))[0]\n",
    "    name = nnb\n",
    "    np.save(Fdata + experiment +'/' + adfn.save_name(name) +  '_av-2.npy', av2)\n",
    "    np.save(Fdata + experiment +'/' + adfn.save_name(name) + '_' +'_av-4.npy', av4)\n",
    "\n",
    "    print('Done '+ nnb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-2_exp.npy',\n",
       " 'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-3_exp.npy',\n",
       " 'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-4_exp.npy']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create lists of coord data\n",
    "#---------------------------------------------------------------------------\n",
    "import glob\n",
    "\n",
    "experiment = 'PTZ-WILDTYPE'\n",
    "os.chdir(Fdata + experiment)\n",
    "\n",
    "av_l = sorted(glob.glob('*_av-*exp*'))\n",
    "av_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       " 'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-4_exp.npy']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_list = ['2', '3', '4']\n",
    "fish_list = ['02', '04', '05', '06', '07', '08', '09', '10', '11', '12']\n",
    "\n",
    "for num in num_list:\n",
    "    curr_l = sorted(glob.glob('*_av-' + num + '_exp*'))\n",
    "    for \n",
    "curr_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Avalanche size by fish and avalanche initiation size\n",
    "\n",
    "num_list = ['2', '3', '4']\n",
    "fish_list = ['k', 'blue', 'green']\n",
    "\n",
    "choose = 0\n",
    "\n",
    "fig = plt.figure(figsize = (10,5))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "\n",
    "for y,num in enumerate(num_list):\n",
    "    curr_l = sorted(glob.glob('*_av-' + num + '_exp*'))\n",
    "    fill_me = np.zeros(10)\n",
    "    \n",
    "    for x,curr in enumerate(curr_l):\n",
    "        fill_me[x] = np.load(curr)[choose]\n",
    "    plt.scatter(np.arange(10), fill_me, c = fish_list[y], s = 5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Avalanche duration by fish and avalanche initiation size\n",
    "\n",
    "\n",
    "num_list = ['2', '3', '4']\n",
    "fish_list = ['k', 'blue', 'green']\n",
    "\n",
    "choose = 1\n",
    "\n",
    "fig = plt.figure(figsize = (10,5))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "\n",
    "for y,num in enumerate(num_list):\n",
    "    curr_l = sorted(glob.glob('*_av-' + num + '_exp*'))\n",
    "    fill_me = np.zeros(10)\n",
    "    \n",
    "    for x,curr in enumerate(curr_l):\n",
    "        fill_me[x] = np.load(curr)[choose]\n",
    "    plt.scatter(np.arange(10), fill_me, c = fish_list[y], s = 5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       " 'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       " 'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       " 'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       " 'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       " 'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       " 'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       " 'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       " 'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       " 'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-4_llr.npy']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_list = ['2', '3', '4']\n",
    "fish_list = ['02', '04', '05', '06', '07', '08', '09', '10', '11', '12']\n",
    "\n",
    "\n",
    "for num in num_list:\n",
    "    curr_l = sorted(glob.glob('*_av-' + num + '_llr*'))\n",
    "curr_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Loglikelihood ratio for avalanche size by fish and avalanche initiation size\n",
    "\n",
    "\n",
    "num_list = ['2', '3', '4']\n",
    "fish_list = ['k', 'blue', 'green']\n",
    "\n",
    "choose = 0\n",
    "\n",
    "fig = plt.figure(figsize = (10,5))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "\n",
    "for y,num in enumerate(num_list):\n",
    "    curr_l = sorted(glob.glob('*_av-' + num + '_llr*'))\n",
    "    fill_me = np.zeros(10)\n",
    "    \n",
    "    for x,curr in enumerate(curr_l):\n",
    "        fill_me[x] = np.load(curr)[choose]\n",
    "    plt.scatter(np.arange(10), fill_me, c = fish_list[y], s = 5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Loglikelihood ratio for avalanche duration by fish and avalanche initiation size\n",
    "\n",
    "num_list = ['2', '3', '4']\n",
    "fish_list = ['k', 'blue', 'green']\n",
    "\n",
    "choose = 1\n",
    "\n",
    "fig = plt.figure(figsize = (10,5))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "\n",
    "for y,num in enumerate(num_list):\n",
    "    curr_l = sorted(glob.glob('*_av-' + num + '_llr*'))\n",
    "    fill_me = np.zeros(10)\n",
    "    \n",
    "    for x,curr in enumerate(curr_l):\n",
    "        fill_me[x] = np.load(curr)[choose]\n",
    "    plt.scatter(np.arange(10), fill_me, c = fish_list[y], s = 5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       "  'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       "  'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       "  'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       "  'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       "  'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       "  'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       "  'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       "  'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-2_exp.npy',\n",
       "  'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-2_exp.npy'],\n",
       " ['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       "  'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       "  'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       "  'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       "  'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       "  'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       "  'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       "  'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       "  'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-3_exp.npy',\n",
       "  'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-3_exp.npy'],\n",
       " ['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       "  'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       "  'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       "  'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       "  'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       "  'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       "  'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       "  'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       "  'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-4_exp.npy',\n",
       "  'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-4_exp.npy'])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "two_l = sorted(glob.glob('*_av-2*_exp*'))\n",
    "three_l = sorted(glob.glob('*_av-3*_exp*'))\n",
    "four_l = sorted(glob.glob('*_av-4*_exp*'))\n",
    "\n",
    "two_l, three_l, four_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "#avsize exponent by avalanche initiation size\n",
    "\n",
    "dcc = np.zeros((30))\n",
    "dcc_list = [two, three, four]\n",
    "    \n",
    "choose = 0\n",
    "count=0\n",
    "for i in range(len(dcc_list)):\n",
    "    for y in range(10):\n",
    "        dcc[count] = dcc_list[i][y][choose]\n",
    "        count+=1\n",
    "dcc_df = pd.DataFrame({\"lrr\":dcc , \"Labels\":  np.append(adfn.repeat_list('2',10),np.append(adfn.repeat_list('3',10),adfn.repeat_list('4',10)))})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.collections import PathCollection\n",
    "import seaborn as sns\n",
    "from matplotlib import cm\n",
    "colors2 = ['black','blue','green']\n",
    "fig, ax = plt.subplots(figsize = (4,5))\n",
    "ax = sns.pointplot(x=\"Labels\", y=\"lrr\", data = dcc_df, hue = 'Labels', palette = colors2, join=True, ci=0, scale=6, markers = '_')\n",
    "for artist in ax.lines:\n",
    "    artist.set_zorder(10)\n",
    "for artist in ax.findobj(PathCollection):\n",
    "    artist.set_zorder(11)\n",
    "#ax = sns.pointplot(x=\"Labels\", y=\"DCC\", data=dcc_df, color = 'grey', linestyles = [\"--\"], ci = 0, scale=0.6)\n",
    "ax = sns.stripplot(x=\"Labels\", y=\"lrr\", data=dcc_df, hue = 'Labels', palette = colors2, size = 15, jitter = True ,alpha = 0.5)\n",
    "plt.yticks(size = 20)\n",
    "\n",
    "points = ax.collections\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.set_xlabel(' ', size = '13')\n",
    "ax.set_ylabel('DCC', size = '18')\n",
    "#ax.set_xticklabels(['Baseline', 'Focal', 'Generalised'], size = 15)\n",
    "ax.legend_.remove()\n",
    "plt.savefig(Ffig + 'exps_avstart.svg', transparent = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "#avdur exponent by avalanche initiation size\n",
    "\n",
    "\n",
    "dcc = np.zeros((30))\n",
    "dcc_list = [two, three, four]\n",
    "    \n",
    "choose = 1\n",
    "count=0\n",
    "for i in range(len(dcc_list)):\n",
    "    for y in range(10):\n",
    "        dcc[count] = dcc_list[i][y][choose]\n",
    "        count+=1\n",
    "dcc_df = pd.DataFrame({\"lrr\":dcc , \"Labels\":  np.append(adfn.repeat_list('2',10),np.append(adfn.repeat_list('3',10),adfn.repeat_list('4',10)))})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.collections import PathCollection\n",
    "import seaborn as sns\n",
    "from matplotlib import cm\n",
    "colors2 = ['black','blue','green']\n",
    "fig, ax = plt.subplots(figsize = (4,5))\n",
    "ax = sns.pointplot(x=\"Labels\", y=\"lrr\", data = dcc_df, hue = 'Labels', palette = colors2, join=True, ci=0, scale=6, markers = '_')\n",
    "for artist in ax.lines:\n",
    "    artist.set_zorder(10)\n",
    "for artist in ax.findobj(PathCollection):\n",
    "    artist.set_zorder(11)\n",
    "#ax = sns.pointplot(x=\"Labels\", y=\"DCC\", data=dcc_df, color = 'grey', linestyles = [\"--\"], ci = 0, scale=0.6)\n",
    "ax = sns.stripplot(x=\"Labels\", y=\"lrr\", data=dcc_df, hue = 'Labels', palette = colors2, size = 15, jitter = True ,alpha = 0.5)\n",
    "plt.yticks(size = 20)\n",
    "\n",
    "points = ax.collections\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.set_xlabel(' ', size = '13')\n",
    "ax.set_ylabel('DCC', size = '18')\n",
    "#ax.set_xticklabels(['Baseline', 'Focal', 'Generalised'], size = 15)\n",
    "ax.legend_.remove()\n",
    "plt.savefig(Ffig + 'expd_avstart.svg', transparent = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-2_llr.npy',\n",
       "  'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-2_llr.npy',\n",
       "  'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-2_llr.npy',\n",
       "  'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-2_llr.npy',\n",
       "  'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-2_llr.npy',\n",
       "  'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-2_llr.npy',\n",
       "  'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-2_llr.npy',\n",
       "  'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-2_llr.npy',\n",
       "  'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-2_llr.npy',\n",
       "  'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-2_llr.npy'],\n",
       " ['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-3_llr.npy',\n",
       "  'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-3_llr.npy',\n",
       "  'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-3_llr.npy',\n",
       "  'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-3_llr.npy',\n",
       "  'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-3_llr.npy',\n",
       "  'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-3_llr.npy',\n",
       "  'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-3_llr.npy',\n",
       "  'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-3_llr.npy',\n",
       "  'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-3_llr.npy',\n",
       "  'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-3_llr.npy'],\n",
       " ['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       "  'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       "  'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       "  'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       "  'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       "  'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       "  'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       "  'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       "  'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-4_llr.npy',\n",
       "  'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-4_llr.npy'])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "two_l = sorted(glob.glob('*_av-2*_llr*'))\n",
    "three_l = sorted(glob.glob('*_av-3*_llr*'))\n",
    "four_l = sorted(glob.glob('*_av-4*_llr*'))\n",
    "\n",
    "two_l, three_l, four_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "two = dome(two_l)\n",
    "three = dome(three_l)\n",
    "four = dome(four_l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "#LLR for av size by avalanche initiation size\n",
    "\n",
    "\n",
    "dcc = np.zeros((30))\n",
    "dcc_list = [two, three, four]\n",
    "    \n",
    "choose = 0\n",
    "count=0\n",
    "for i in range(len(dcc_list)):\n",
    "    for y in range(10):\n",
    "        dcc[count] = dcc_list[i][y][choose]\n",
    "        count+=1\n",
    "dcc_df = pd.DataFrame({\"lrr\":dcc , \"Labels\":  np.append(adfn.repeat_list('2',10),np.append(adfn.repeat_list('3',10),adfn.repeat_list('4',10)))})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.collections import PathCollection\n",
    "import seaborn as sns\n",
    "from matplotlib import cm\n",
    "colors2 = ['black','blue','green']\n",
    "fig, ax = plt.subplots(figsize = (4,5))\n",
    "ax = sns.pointplot(x=\"Labels\", y=\"lrr\", data = dcc_df, hue = 'Labels', palette = colors2, join=True, ci=0, scale=6, markers = '_')\n",
    "for artist in ax.lines:\n",
    "    artist.set_zorder(10)\n",
    "for artist in ax.findobj(PathCollection):\n",
    "    artist.set_zorder(11)\n",
    "#ax = sns.pointplot(x=\"Labels\", y=\"DCC\", data=dcc_df, color = 'grey', linestyles = [\"--\"], ci = 0, scale=0.6)\n",
    "ax = sns.stripplot(x=\"Labels\", y=\"lrr\", data=dcc_df, hue = 'Labels', palette = colors2, size = 15, jitter = True ,alpha = 0.5)\n",
    "plt.yticks(size = 20)\n",
    "\n",
    "points = ax.collections\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.set_xlabel(' ', size = '13')\n",
    "ax.set_ylabel('DCC', size = '18')\n",
    "#ax.set_xticklabels(['Baseline', 'Focal', 'Generalised'], size = 15)\n",
    "ax.legend_.remove()\n",
    "plt.savefig(Ffig + 'llrs_avstart.svg', transparent = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "#llr for avdur by avalanche initiation size\n",
    "\n",
    "\n",
    "dcc = np.zeros((30))\n",
    "dcc_list = [two, three, four]\n",
    "    \n",
    "choose = 1\n",
    "count=0\n",
    "for i in range(len(dcc_list)):\n",
    "    for y in range(10):\n",
    "        dcc[count] = dcc_list[i][y][choose]\n",
    "        count+=1\n",
    "dcc_df = pd.DataFrame({\"lrr\":dcc , \"Labels\":  np.append(adfn.repeat_list('2',10),np.append(adfn.repeat_list('3',10),adfn.repeat_list('4',10)))})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.collections import PathCollection\n",
    "import seaborn as sns\n",
    "from matplotlib import cm\n",
    "colors2 = ['black','blue','green']\n",
    "fig, ax = plt.subplots(figsize = (4,5))\n",
    "ax = sns.pointplot(x=\"Labels\", y=\"lrr\", data = dcc_df, hue = 'Labels', palette = colors2, join=True, ci=0, scale=6, markers = '_')\n",
    "for artist in ax.lines:\n",
    "    artist.set_zorder(10)\n",
    "for artist in ax.findobj(PathCollection):\n",
    "    artist.set_zorder(11)\n",
    "#ax = sns.pointplot(x=\"Labels\", y=\"DCC\", data=dcc_df, color = 'grey', linestyles = [\"--\"], ci = 0, scale=0.6)\n",
    "ax = sns.stripplot(x=\"Labels\", y=\"lrr\", data=dcc_df, hue = 'Labels', palette = colors2, size = 15, jitter = True ,alpha = 0.5)\n",
    "plt.yticks(size = 20)\n",
    "\n",
    "points = ax.collections\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.set_xlabel(' ', size = '13')\n",
    "ax.set_ylabel('DCC', size = '18')\n",
    "#ax.set_xticklabels(['Baseline', 'Focal', 'Generalised'], size = 15)\n",
    "ax.legend_.remove()\n",
    "plt.savefig(Ffig + 'llrd_avstart.svg', transparent = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-2_dcc.npy',\n",
       "  'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-2_dcc.npy',\n",
       "  'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-2_dcc.npy',\n",
       "  'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-2_dcc.npy',\n",
       "  'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-2_dcc.npy',\n",
       "  'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-2_dcc.npy',\n",
       "  'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-2_dcc.npy',\n",
       "  'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-2_dcc.npy',\n",
       "  'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-2_dcc.npy',\n",
       "  'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-2_dcc.npy'],\n",
       " ['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-3_dcc.npy',\n",
       "  'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-3_dcc.npy',\n",
       "  'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-3_dcc.npy',\n",
       "  'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-3_dcc.npy',\n",
       "  'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-3_dcc.npy',\n",
       "  'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-3_dcc.npy',\n",
       "  'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-3_dcc.npy',\n",
       "  'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-3_dcc.npy',\n",
       "  'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-3_dcc.npy',\n",
       "  'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-3_dcc.npy'],\n",
       " ['PTZ-WILDTYPE-02_2photon_sess-01-6dpf_BLN_run-01_av-4_dcc.npy',\n",
       "  'PTZ-WILDTYPE-04_2photon_sess-01-6dpf_BLN_run-01_av-4_dcc.npy',\n",
       "  'PTZ-WILDTYPE-05_2photon_sess-01-6dpf_BLN_run-01_av-4_dcc.npy',\n",
       "  'PTZ-WILDTYPE-06_2photon_sess-01-6dpf_BLN_run-01_av-4_dcc.npy',\n",
       "  'PTZ-WILDTYPE-07_2photon_sess-01-6dpf_BLN_run-01_av-4_dcc.npy',\n",
       "  'PTZ-WILDTYPE-08_2photon_sess-01-6dpf_BLN_run-01_av-4_dcc.npy',\n",
       "  'PTZ-WILDTYPE-09_2photon_sess-01-6dpf_BLN_run-01_av-4_dcc.npy',\n",
       "  'PTZ-WILDTYPE-10_2photon_sess-01-6dpf_BLN_run-01_av-4_dcc.npy',\n",
       "  'PTZ-WILDTYPE-11_2photon_sess-01-6dpf_BLN_run-01_av-4_dcc.npy',\n",
       "  'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-4_dcc.npy'])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "two_l = sorted(glob.glob('*_av-2*_dcc*'))\n",
    "three_l = sorted(glob.glob('*_av-3*_dcc*'))\n",
    "four_l = sorted(glob.glob('*_av-4*_dcc*'))\n",
    "\n",
    "two_l, three_l, four_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dome(data_l):\n",
    "    inp_l = list(range(len(data_l)))\n",
    "    for i in range(len(data_l)):\n",
    "        inp_l[i] = np.load(data_l[i])\n",
    "    return(inp_l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "two = dome(two_l)\n",
    "three = dome(three_l)\n",
    "four = dome(four_l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.1271703301477746, 0.13232724919524247, 0.19600353958761302)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(two), np.mean(three), np.mean(four)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "#DCC by avalanche initiation size\n",
    "\n",
    "dcc = np.zeros((30))\n",
    "dcc_list = [two, three, four]\n",
    "    \n",
    "count=0\n",
    "for i in range(len(dcc_list)):\n",
    "    for y in range(10):\n",
    "        dcc[count] = dcc_list[i][y]\n",
    "        count+=1\n",
    "dcc_df = pd.DataFrame({\"dcc\":dcc , \"Labels\":  np.append(adfn.repeat_list('2',10),np.append(adfn.repeat_list('3',10),adfn.repeat_list('4',10)))})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.collections import PathCollection\n",
    "import seaborn as sns\n",
    "from matplotlib import cm\n",
    "colors2 = ['black','blue','green']\n",
    "fig, ax = plt.subplots(figsize = (4,5))\n",
    "ax = sns.pointplot(x=\"Labels\", y=\"dcc\", data = dcc_df, hue = 'Labels', palette = colors2, join=True, ci=0, scale=6, markers = '_')\n",
    "for artist in ax.lines:\n",
    "    artist.set_zorder(10)\n",
    "for artist in ax.findobj(PathCollection):\n",
    "    artist.set_zorder(11)\n",
    "#ax = sns.pointplot(x=\"Labels\", y=\"DCC\", data=dcc_df, color = 'grey', linestyles = [\"--\"], ci = 0, scale=0.6)\n",
    "ax = sns.stripplot(x=\"Labels\", y=\"dcc\", data=dcc_df, hue = 'Labels', palette = colors2, size = 15, jitter = True ,alpha = 0.5)\n",
    "plt.yticks(size = 20)\n",
    "\n",
    "points = ax.collections\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.set_xlabel(' ', size = '13')\n",
    "ax.set_ylabel('DCC', size = '18')\n",
    "#ax.set_xticklabels(['Baseline', 'Focal', 'Generalised'], size = 15)\n",
    "ax.legend_.remove()\n",
    "plt.savefig(Ffig + 'dcc_avstart.svg', transparent = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-2_dcc.npy',\n",
       " 'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-3_dcc.npy',\n",
       " 'PTZ-WILDTYPE-12_2photon_sess-01-6dpf_BLN_run-09_av-4_dcc.npy']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_list = ['02', '04', '05', '06', '07', '08', '09', '10', '11', '12']\n",
    "\n",
    "\n",
    "for num in num_list:\n",
    "    curr_l = sorted(glob.glob('*E-' + num +  '*_av-*_dcc*'))\n",
    "curr_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2]), array([0.13066925, 0.14294668, 0.06713108]))"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3), fill_me"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_list = ['02', '04', '05', '06', '07', '08', '09', '10', '11', '12']\n",
    "fish_list = ['k', 'blue', 'green']\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize = (10,5))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "\n",
    "for y,num in enumerate(num_list):\n",
    "    curr_l = sorted(glob.glob('*E-' + num +  '*_av-*_dcc*'))\n",
    "    fill_me = np.zeros(3)\n",
    "    \n",
    "    for x,curr in enumerate(curr_l):\n",
    "        fill_me[x] = np.load(curr)\n",
    "    plt.scatter(np.arange(3), fill_me, s = 5)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}