Data_analysis_pt2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Analysis of Olivocerebellar Model\n",
    "\n",
    "## Table of Contents\n",
    "\n",
    "1. Import All\n",
    "    1. Import packages\n",
    "    1. Import data of simulations\n",
    "2. Clean up Data\n",
    "3. Connectivity Graph\n",
    "4. Raster Plots\n",
    "    1. Single Loop (1PC - 10DCN- 1 IO)\n",
    "    2. Entire Circuitry (10PC - 10DCN - 20IO)\n",
    "5. Purkinje Cell\n",
    "    1. Input Current\n",
    "    2. Seperate Input Current\n",
    "6. Inferior Olive\n",
    "    1. Spike Time Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.1) Import packages\n",
    "import numpy as np\n",
    "from importlib import reload\n",
    "from brian2 import*\n",
    "import pickle\n",
    "import NeuroTools as nt\n",
    "from NeuroTools import signals, analysis\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import find_peaks\n",
    "import scipy.io as sio\n",
    "import seaborn as sns\n",
    "import matplotlib.patches as mpatches\n",
    "import h5py\n",
    "#import plotpy.express as px\n",
    "%matplotlib notebook\n",
    "\n",
    "# Import and reload my helpers module for iterative development\n",
    "import helpers\n",
    "reload(helpers)\n",
    "from helpers.Function_DataAnalysis import *\n",
    "#from helpers.bin import *\n",
    "\n",
    "# default dict. to assign values\n",
    "from collections import defaultdict\n",
    "\n",
    "# Open File , NOTE: Always close the file (last cell in the notebook!)\n",
    "\n",
    "All_data = h5py.File('Single_frequencyInput_1to20.hdf5','a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<KeysViewHDF5 ['adapted', 'initial', 'plasticity']>\n",
      "<KeysViewHDF5 ['Input', 'PV', 'Population_rate', 'Spikes', 'Voltage_Cells']>\n",
      "<KeysViewHDF5 ['DCN_coupled', 'DCN_uncoupled', 'IO_coupled', 'IO_uncoupled', 'PC_coupled', 'PC_uncoupled']>\n",
      "[ 0.         -0.04151822 -0.03733359 ... -0.07044976 -0.07042505\n",
      " -0.07037051]\n",
      "[ 0.         -0.04151836 -0.03733412 ... -0.06249391 -0.06230598\n",
      " -0.0620979 ]\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(All_data['2and2Hz'].keys())\n",
    "print(All_data['2and2Hz']['plasticity'].keys())\n",
    "print(All_data['1and1Hz']['adapted']['Spikes'].keys())\n",
    "print(All_data['2and2Hz']['plasticity']['Voltage_Cells']['IOsoma_coupled'][0])\n",
    "print(All_data['2and2Hz']['plasticity']['Voltage_Cells']['IOsoma_uncoupled'][0])\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(All_data['2and2Hz']['plasticity']['Voltage_Cells']['IOsoma_coupled'][0])\n",
    "plt.plot(All_data['2and2Hz']['plasticity']['Voltage_Cells']['IOsoma_uncoupled'][0])\n",
    "plt.show()\n",
    "#print(All_data['2Hz']['plasticity']['Spikes'].keys())\n",
    "#long_term_20Hz = All_data['20Hz']['plasticity']['PV']['Long_term_.f_coupled'][1]\n",
    "#long_term_2Hz = All_data['2Hz']['plasticity']['PV']['Long_term_f_coupled'][1]\n",
    "#names= All_data['2Hz'].create_dataset('test',data=(10,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Clean up Data\n",
    "### The first 5 seconds, no input is given to the system. This is not of interest for the analysis and is therefore removed from the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n",
      "11and11Hz plasticity\n",
      "18and18Hz plasticity\n",
      "4and4Hz plasticity\n",
      "6and6Hz plasticity\n",
      "8and8Hz plasticity\n"
     ]
    }
   ],
   "source": [
    "start = 5000 # remove first second of data due to transient behavior\n",
    "sP = All_data['2and2Hz']['plasticity']['Input']\n",
    "\n",
    "t_beforeAdaptation = int(len(sP['I'][1])/2)\n",
    "print(t_beforeAdaptation)\n",
    "\n",
    "\n",
    "# Get properties of the circuitry\n",
    "#sP = All_data['2and2Hz']['plasticity']['Input']\n",
    "#vP = All_data['2and2Hz']['plasticity']['Voltage_Cells']\n",
    "#print(sP.keys())\n",
    "#print(sP['Ir'])\n",
    "\n",
    "nrIO=20\n",
    "nrPC=10\n",
    "nrDCN=20\n",
    "#print('nr PC',nrPC, 'nrDCN',nrDCN, 'nrIO=',nrIO)\n",
    "\n",
    "#lengthSim =len(All_data['1Hz']['adapted']['Voltage_Cells']['PC_coupled'][0])\n",
    "#print(lengthSim)\n",
    "# Find the peaks for IO spikes\n",
    "#print(All_data['2Hz/plasticity/Spikes/IO_coupled'][0])\n",
    "dt_type = h5py.vlen_dtype(np.dtype('float64'))\n",
    "\n",
    "# the slicing of data only needs to happen once\n",
    "# after that set SlicingDone to 'yes'\n",
    "SlicingDone = 'no'\n",
    "FindSpikes = 'yes'\n",
    "SliceData = 'no'\n",
    "SliceSpikes = 'no'\n",
    "# Checklist\n",
    "# 1. FindSpikes =='yes'\n",
    "    # find IO spikes from the trace \n",
    "# 2. SliceData == 'yes'\n",
    "    # Slice data from 5second on\n",
    "    # Add 'r' to the name of the label\n",
    "# 3. SliceSpikes == 'yes'\n",
    "    # Cut the spikes >5\n",
    "if SlicingDone == 'no':\n",
    "    for i in All_data.keys():\n",
    "        #print(i)\n",
    "        for j in All_data[i].keys():\n",
    "            #print(j)\n",
    "            vP = All_data[i][j]['Voltage_Cells']\n",
    "            sT = All_data[i][j]['Spikes']\n",
    "            pR = All_data[i][j]['Population_rate']\n",
    "            iP = All_data[i][j]['Input']\n",
    "            #print(sT.keys())\n",
    "            # create new dataset to write new values to\n",
    "            if FindSpikes=='yes':\n",
    "                sIOc = {}\n",
    "                sIOu = {}\n",
    "                for k in range(0,nrIO):\n",
    "                    spikeio_BAc, _ = find_peaks(vP['IOsoma_coupled'][k], height=0.0, distance = 10) \n",
    "                    spikeio_BAuc, _ = find_peaks(vP['IOsoma_uncoupled'][k], height=0.0, distance = 10) \n",
    "                    spikeio_BAc = spikeio_BAc/1000\n",
    "                    spikeio_BAuc = spikeio_BAuc/1000\n",
    "                    \n",
    "                    sIOc[k] = spikeio_BAc\n",
    "                    sIOu[k] = spikeio_BAuc\n",
    "\n",
    "                #print(sIOc)\n",
    "                sIOc = list(sIOc.values())\n",
    "                sIOu = list(sIOu.values())\n",
    "                #print('spike times coupled',sIOc[1])\n",
    "                #print('spike times uncoupled',sIOu[1])\n",
    "                \n",
    "                \n",
    "                #sT_nu = sT.create_dataset('IO_uncoupled_no',data=sIOu,dtype=dt_type)\n",
    "                try:\n",
    "                    sT_nc = sT.create_dataset('IO_coupled_pir',data=sIOc,dtype=dt_type)\n",
    "                    #print('nothing wrong',sIOc)\n",
    "                except TypeError:\n",
    "                    print(i,j)\n",
    "                    #print('smth wrong',sIOc)\n",
    "                    #print('smth right',sIOu)\n",
    "                  #  break\n",
    "\n",
    "            #print(sT_nc)\n",
    "            # Slicing Spikes\n",
    "            #print(len(SpikeTimes_AA['PC_coupled'][1]),SpikeTimes_AA['PC_coupled'][1])\n",
    "            #All_data[i][j]['Spikes'] = SlicingSpikes(All_data[i][j]['Spikes'], t_start = start/1e3)\n",
    "\n",
    "            if SliceData=='yes':\n",
    "                print('slicing data')\n",
    "                vP = Slicing(vP,t_start=start)\n",
    "                pR = Slicing(pR,t_start=start)\n",
    "                iP = Slicing(iP,t_start=start)\n",
    "                #print(len(vP['PC_coupled'][0]))\n",
    "                \n",
    "\n",
    "            if SliceSpikes=='yes':\n",
    "                \n",
    "                #del sT['IO_uncoupled']\n",
    "                #del sT['IO_coupled']\n",
    "                try:\n",
    "                    sT = SlicingSpikes(sT,t_start=start/1e3)\n",
    "                    #sT = All_data[i][j]['Spikes']\n",
    "                    #del sT['DCN_coupledq']\n",
    "                    #del sT['DCN_coupledr']\n",
    "                    #del sT['DCN_coupledrr']\n",
    "                    #del sT['DCN_uncoupledq']\n",
    "                    #del sT['DCN_uncoupledr']\n",
    "                    #del sT['DCN_uncoupledrr']\n",
    "                    #del sT['PC_coupledq']\n",
    "                    #del sT['PC_coupledr']\n",
    "                    #del sT['PC_coupledrr']\n",
    "                    #del sT['PC_uncoupledq']\n",
    "                    #del sT['PC_uncoupledr']\n",
    "                    #del sT['PC_uncoupledrr']\n",
    "                    #del sT['IO_coupledq']\n",
    "                    #del sT['IO_coupledr']\n",
    "                    #del sT['IO_coupledrr']\n",
    "                    #del sT['IO_uncoupledq']\n",
    "                    #del sT['IO_uncoupledr']\n",
    "                    #del sT['IO_uncoupledrr']\n",
    "                    #del iP['Ir']\n",
    "                    #del iP['I_InputPC_coupledr']\n",
    "                    #del iP['I_InputPC_uncoupledr']\n",
    "                    #del iP['weightr']\n",
    "                    #del pR['PC_coupledr']\n",
    "                    #del pR['PC_uncoupledr']\n",
    "                    #del pR['DCN_coupledr']\n",
    "                    #del pR['DCN_uncoupledr']\n",
    "                    #del pR['IO_coupledr']\n",
    "                    #del pR['IO_uncoupledr']\n",
    "                    #del sT['PC_coupledrr']\n",
    "                    #del sT['PC_uncoupledrr']\n",
    "                    #del sT['DCN_uncoupledrr']\n",
    "                    #del sT['DCN_coupledrr']\n",
    "                    #del sT['IO_uncoupledrerr']\n",
    "                    #del sT['IO_coupledrerr']\n",
    "                    print('treid')\n",
    "                except KeyError:\n",
    "                    print('KeyError occured')\n",
    "                    continue\n",
    "\n",
    "            #sT = SlicingSpikes(sT,t_start=start/1e3)\n",
    "            \n",
    "            \n",
    "            #sT = SlicingSpikes(sT)\n",
    "\n",
    "        #sT = SlicingSpikes(sT,t_start=start/1e3)\n",
    "        #print(sT)\n",
    "        #for label in vP.keys():\n",
    "        #    nrCell = len(vP[label])\n",
    "        #    if nrCell > 1000:\n",
    "        #        vP[label][...] = vP[label][int(t_start/0.025):t_end]\n",
    "        #    else:\n",
    "        #        vP[label][...] = [vP[label][k][t_start:t_end] for k in range(0,nrCell)]\n",
    "\n",
    "        #print(len(vP['PC_coupled'][0]))\n",
    "        #print(x)\n",
    "        #print(x.)\n",
    "        #All_data[i][j]['Voltage_Cells'] = x\n",
    "        #iP = Slicing(iP,t_start=start)\n",
    "\n",
    "#lengthSim =len(All_data['1Hz']['adapted']['Voltage_Cells']['PC_coupledr'][0])\n",
    "#print(lengthSim)\n",
    "\n",
    "# Usefull parameters \n",
    "#nrInputs = len(sP['Ir'])\n",
    "#nrPC = len(vP['PC_coupledr'])\n",
    "#nrDCN = len(vP['DCN_coupledr'])\n",
    "#nrIO = len(vP['IOsoma_coupledr'])\n",
    "#nrDummy = nrPC*nrInputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<KeysViewHDF5 ['DCN_coupled', 'DCN_uncoupled', 'IO_coupled', 'IO_coupled_pfr', 'IO_coupled_plpr', 'IO_coupled_ppr', 'IO_coupled_yyr', 'IO_uncoupled', 'IO_uncoupled_n', 'IO_uncoupled_no', 'PC_coupled', 'PC_uncoupled']>\n",
      "<KeysViewHDF5 ['DCN_coupled', 'DCN_uncoupled', 'IOsoma_coupled', 'IOsoma_uncoupled', 'PC_coupled', 'PC_uncoupled']>\n",
      "<class 'list'>\n",
      "<class 'list'>\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "Operation not defined for data type class (operation not defined for data type class)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32mh5py\\_proxy.pyx\u001b[0m in \u001b[0;36mh5py._proxy.needs_bkg_buffer\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'Conversion function not found (no appropriate function for conversion path)'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-54-bb2a2b2dab32>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     31\u001b[0m \u001b[1;31m#sT_nu = sT.create_dataset('IO_uncoupled_no',data=sIOu,dtype=dt_type)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     32\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 33\u001b[1;33m \u001b[0msT_nc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msT\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcreate_dataset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'IO_coupled_plpr'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msIOc\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdt_type\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     34\u001b[0m     \u001b[1;31m#print('nothing wrong',sIOc)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\brian\\lib\\site-packages\\h5py\\_hl\\group.py\u001b[0m in \u001b[0;36mcreate_dataset\u001b[1;34m(self, name, shape, dtype, data, **kwds)\u001b[0m\n\u001b[0;32m    134\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    135\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mphil\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 136\u001b[1;33m             \u001b[0mdsid\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdataset\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmake_new_dset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    137\u001b[0m             \u001b[0mdset\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdataset\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mDataset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdsid\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    138\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\brian\\lib\\site-packages\\h5py\\_hl\\dataset.py\u001b[0m in \u001b[0;36mmake_new_dset\u001b[1;34m(parent, shape, dtype, data, chunks, compression, shuffle, fletcher32, maxshape, compression_opts, fillvalue, scaleoffset, track_times, external, track_order, dcpl)\u001b[0m\n\u001b[0;32m    168\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    169\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mEmpty\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 170\u001b[1;33m         \u001b[0mdset_id\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mh5s\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mALL\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mh5s\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mALL\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    171\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    172\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mdset_id\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mh5py\\_objects.pyx\u001b[0m in \u001b[0;36mh5py._objects.with_phil.wrapper\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mh5py\\_objects.pyx\u001b[0m in \u001b[0;36mh5py._objects.with_phil.wrapper\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mh5py\\h5d.pyx\u001b[0m in \u001b[0;36mh5py.h5d.DatasetID.write\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mh5py\\_proxy.pyx\u001b[0m in \u001b[0;36mh5py._proxy.dset_rw\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mh5py\\_proxy.pyx\u001b[0m in \u001b[0;36mh5py._proxy.needs_bkg_buffer\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: Operation not defined for data type class (operation not defined for data type class)"
     ]
    }
   ],
   "source": [
    "vP = All_data['11and11Hz/plasticity/Voltage_Cells']\n",
    "sT = All_data['11and11Hz/plasticity/Spikes']\n",
    "print(sT.keys())\n",
    "print(vP.keys())\n",
    "sIOc = {}\n",
    "dt_type = h5py.vlen_dtype(np.dtype('float64'))\n",
    "\n",
    "sIOu = {}\n",
    "for k in range(0,nrIO):\n",
    "\n",
    "    spikeio_BAc, _ = find_peaks(vP['IOsoma_coupled'][k], height=0.0, distance = 10) \n",
    "    spikeio_BAuc, _ = find_peaks(vP['IOsoma_uncoupled'][k], height=0.0, distance = 10) \n",
    "    #print(spikeio_BAc)\n",
    "    spikeio_BAc = spikeio_BAc/1000\n",
    "    spikeio_BAuc = spikeio_BAuc/1000\n",
    "\n",
    "    sIOc[k] = spikeio_BAc\n",
    "    sIOu[k] = spikeio_BAuc\n",
    "#print(sIOc)\n",
    "#print(sIOu)\n",
    "#print(sIOc)\n",
    "sIOc = list(sIOc.values())\n",
    "sIOu = list(sIOu.values())\n",
    "print(type(sIOc))\n",
    "print(type(sIOu))\n",
    "#print(sIOu)\n",
    "#print('spike times coupled',sIOc[1])\n",
    "#print('spike times uncoupled',sIOu[1])\n",
    "\n",
    "\n",
    "#sT_nu = sT.create_dataset('IO_uncoupled_no',data=sIOu,dtype=dt_type)\n",
    "\n",
    "sT_nc = sT.create_dataset('IO_coupled_plpr',data=sIOc,dtype=dt_type)\n",
    "    #print('nothing wrong',sIOc)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nrInputs = len(sP['Ir'])\n",
    "nrPC = len(vP['PC_coupledr'])\n",
    "nrDCN = len(vP['DCN_coupledr'])\n",
    "nrIO = len(vP['IOsoma_coupledr'])\n",
    "nrDummy = nrPC*nrInputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(All_data['2and2Hz/plasticity/Spikes'].keys())\n",
    "#print(All_data['2and2Hz/plasticity/Voltage_Cells'].keys())\n",
    "\n",
    "print(len(All_data['2and2Hz/plasticity/Population_rate/PC_coupledr']))\n",
    "print(len(All_data['2and2Hz/plasticity/Population_rate/DCN_coupledr']))\n",
    "print(All_data['2and2Hz/plasticity/Spikes/DCN_coupledr'][7])\n",
    "print(All_data['2and2Hz/plasticity/Spikes/IO_coupled_nr'][7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Connectivity Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "if nrInputs == 5 :\n",
    "    # Input - Dummy\n",
    "    i_ind = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]\n",
    "    j_ind = np.arange(nrDummy)\n",
    "    Connectivity(i_ind,j_ind,'Input','Dummy')\n",
    "\n",
    "    # Dummy-PC\n",
    "    i_dPC = np.arange(nrInputs*nrPC)\n",
    "    j_dPC = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "    Connectivity(j_dPC,i_dPC,'PC','Dummy')\n",
    "    # IO - dummy \n",
    "    i_IOd = [9, 10, 18, 17, 0, 6, 5, 12, 16, 11, 9, 10, 18, 17, 0, 6, 5, 12, 16, 11, 9, 10, 18, 17, 0, 6, 5, 12, 16, 11, 9, 10, 18, 17, 0, 6, 5, 12, 16, 11, 9, 10, 18, 17, 0, 6, 5, 12, 16, 11]\n",
    "    j_IOd=np.arange(nrInputs*nrPC)\n",
    "    Connectivity(i_IOd,j_IOd,'IO','Dummy')\n",
    "    # IO - PC\n",
    "    i_IOPC = [9,10, 18, 17, 0, 6, 5, 12, 16, 11]\n",
    "    j_IOPC = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "    Connectivity(j_IOPC,i_IOPC,'PC','IO')\n",
    "    # DCN - IO\n",
    "    i_DCNIO = [0, 0 ,0, 0 ,0,0 ,0, 0,0,0,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,9,9 ,10 ,10 ,10 ,10 ,10 ,10 ,10 ,10 ,10 ,10 ,11 ,11 ,11 ,11 ,11 ,11 ,11 ,11 ,11 ,11 ,12 ,12 ,12 ,12 ,12 ,12 ,12 ,12 ,12 ,12 ,13 ,13 ,13 ,13 ,13 ,13 ,13 ,13 ,13 ,13 ,14 ,14 ,14 ,14,14 ,14 ,14 ,14 ,14 ,14 ,15 ,15 ,15 ,15 ,15 ,15 ,15 ,15 ,15 ,15 ,16 ,16 ,16 ,16 ,16 ,16 ,16 ,16 ,16 ,16 ,17 ,17 ,17 ,17 ,17 ,17 ,17 ,17 ,17 ,17 ,18 ,18 ,18 ,18 ,18 ,18 ,18 ,18 ,18 ,18 ,19 ,19,19 ,19 ,19 ,19 ,19 ,19 ,19 ,19]\n",
    "    j_DCNIO = [5 ,7, 10, 15 ,4 ,6 ,9 ,3 ,1, 11 ,8 ,4 ,11, 17, 14 ,9 ,3 ,2 ,0, 15 ,0 ,3 ,7 ,2 ,9 ,10, 19, 17 ,4 ,14 ,2 ,8, 16 ,3 ,5, 19, 12 ,0, 18, 17, 12 ,9 ,6, 10, 13 ,3 ,4 ,2, 15, 18 ,2, 14, 19, 18, 16, 17 ,5 ,8 ,4 ,9, 14 ,6 ,8, 16, 12, 19 ,4 ,5 ,0 ,3, 16 ,9,13 ,1, 17 ,0 ,8, 14 ,7, 10, 10 ,6, 13 ,1 ,4, 18 ,8, 12, 17 ,0 ,7, 11 ,3 ,1 ,9, 10,6, 17, 13, 18 ,8, 16 ,7 ,1 ,6, 12, 10, 19, 15 ,4, 12 ,2 ,4 ,1, 19, 13, 17, 16 ,8 ,9, 12 ,4 ,3 ,1 ,0 ,8 ,2, 11, 14, 13, 10, 17, 12, 13, 16, 11 ,4 ,2 ,8 ,5, 15, 17, 13, 19, 14 ,1 ,4, 16 ,6 ,3 ,5, 16 ,0, 19 ,2 ,9, 18 ,6 ,4 ,1, 10 ,8, 15 ,3 ,0 ,1 ,4, 13, 19 ,7 ,3 ,9, 14, 18, 16, 17 ,5, 19, 11, 10, 11 ,6, 15, 10 ,5, 12, 17 ,4 ,8, 16, 14 ,8,\n",
    "     10, 15, 4, 11 ,2 ,7 ,5, 18]\n",
    "    Connectivity(i_DCNIO,j_DCNIO,'DCN','IO')\n",
    "\n",
    "    # PC - DCN\n",
    "    i_PCDCN = [0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,2 ,2 ,2 ,2 ,2 ,2 ,2 ,2 ,2 ,2 ,3 ,3 ,3 ,3 ,3 ,3 ,3\n",
    "     ,3 ,3 ,3 ,4 ,4 ,4 ,4 ,4 ,4 ,4 ,4 ,4 ,4 ,5 ,5 ,5 ,5 ,5 ,5 ,5 ,5 ,5 ,5 ,6 ,6 ,6 ,6 ,6 ,6 ,6 ,6 ,6 ,6 ,7 ,7 ,7 ,7\n",
    "     ,7 ,7 ,7 ,7 ,7 ,7 ,8 ,8 ,8 ,8 ,8 ,8 ,8 ,8 ,8 ,8 ,9 ,9 ,9 ,9 ,9 ,9 ,9 ,9 ,9 ,9]\n",
    "    j_PCDCN = [15, 10, 18 ,3 ,8 ,7 ,1 ,4, 16 ,2 ,4, 14, 12, 10 ,2, 13 ,3 ,0, 15, 16 ,5 ,9 ,0, 13,14, 11, 15, 17, 16, 10, 16 ,1, 13, 17 ,9 ,3 ,5, 10, 12, 18 ,4, 12, 18 ,2 ,5, 13, 15 ,7 ,1 ,6 ,8, 16, 17 ,1, 13, 12, 15 ,7 ,4 ,2, 17 ,0, 14 ,7 ,3, 19 ,4 ,9 ,5 ,2, 18 ,4 ,0, 11, 15 ,3 ,9 ,1 ,8 ,2 ,19 ,1 ,11, 10 ,6 ,0 ,9, 17, 12 ,3 ,7, 11, 17 ,1 ,2, 14,5 ,4, 12 ,0]\n",
    "    Connectivity(i_PCDCN,j_PCDCN,'PC','DCN')\n",
    "elif nrInputs == 2:\n",
    "    # Input-dummy\n",
    "    i_ind = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n",
    "    j_ind = np.arange(nrInputs*nrPC)\n",
    "    Connectivity(i_ind,j_ind,'Input','Dummy')\n",
    "    # dummy-PC\n",
    "    i_dPC = np.arange(nrInputs*nrPC)\n",
    "    j_dPC = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "    Connectivity(j_dPC,i_dPC,'PC','Dummy')\n",
    "\n",
    "    # IO - dummy\n",
    "    i_IOd = [9,10, 18, 17, 0, 6, 5, 12, 16, 11, 9,10, 18, 17, 0, 6, 5, 12, 16, 11]\n",
    "    j_IOd=np.arange(nrInputs*nrPC)\n",
    "    Connectivity(i_IOd,j_IOd,'IO','Dummy')\n",
    "\n",
    "    # IO - PC\n",
    "    i_IOPC = [9,10, 18, 17, 0, 6, 5, 12, 16, 11]\n",
    "    j_IOPC = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "    Connectivity(j_IOPC,i_IOPC,'PC','IO')\n",
    "\n",
    "    # DCN - IO\n",
    "    i_DCNIO = [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,16,16,16,16,16,16,16,16,16,16,17,17,17,17,17,17,17,17,17,17,18,18,18,18,18,18,18,18,18,18,19,19,19,19,19,19,19,19,19,19]\n",
    "\n",
    "    j_DCNIO =[8 , 19 , 10 ,  3 , 12 , 17 ,  11 ,  5 , 13 ,  14 , 11 ,  0 , 13 ,7 , 10 , 12 , 17 ,  9 ,  8 ,  3 ,  4 , 11 ,  7 ,  0 ,  6 ,  9 ,8 , 12 , 19 , 14 ,  4 ,  3 , 16 ,  0 ,  7 ,  1 , 14 ,  5 , 18 ,17 , 19 , 18 ,  1 , 15 ,  2 , 14 ,  8 ,  7 ,  0 ,  3 , 16 , 13 ,11 ,  5 ,  2 , 10 ,  8 ,  0 ,  7 , 18 , 16 , 11 ,  7 ,  0 ,  6 ,5 ,  9 , 18 , 13 ,  4 , 15 ,  0 , 17 ,  6 ,  8 ,  7 , 14 ,  9 ,18 ,  4 , 17 ,  7 , 14 , 13 ,  3 ,  1 ,  2 ,  8 , 16 ,  9 , 10 ,13 ,  1 ,  5 , 11 , 12 ,  4 , 15 ,  8 , 14 ,  7 ,  1 , 19 , 15 ,2 ,  6 , 14 ,  4 , 16 , 12 , 15 ,  2 ,  5 ,  0 , 17 , 14 , 19 ,13 , 16 ,  6 , 10 ,  9 , 18 , 12 ,  1 ,  6 ,  4 ,  2 , 19 ,  5 ,8 , 17 ,  5 , 15 , 14 , 18 , 10 , 16 ,  3 , 12 ,  3 , 10 , 12 ,13 , 15 ,  9 , 19 , 16 ,  1 ,  2 ,  2 , 11 ,  1 , 10 ,  4 , 17 ,16 , 15 ,  6 , 18 ,  6 , 13 ,  1 ,  9 ,  5 ,  3 ,  4 , 17 , 18 ,10 , 18 , 17 ,  9 , 10 , 19 ,  6 , 12 , 11 , 15 , 13 ,  0 ,  2 ,16 ,  1 ,  3 ,  4 , 19 , 15 , 11 ,  5 , 12 ,  9 ,  7 , 11 ,  8 ,0 ,  2 ,  6 ,  3 , 19]\n",
    "    #[11,4,8,9,14,10,1,7,17,6,9,18,1,0,5,3,6,4,13,2,17,15,4,2,10,16,18,13,19,8,10,4,8,6,3,17,2,19,16,11,19,11,15,2,7,8,4,17,10,1,16,12,15,13,3,0,4,11,1,18,11,8,18,17,12,15,2,5,0,6,15,9,6,8,14,4,18,3,19,12,19,4,14,3,1,11,13,8,15,17,14,16,8,9,11,1,17,2,18,19,12,18,19,10,7,2,13,14,4,5,2,8,5,7,0,13,15,18,6,10,16,3,8,15,1,12,4,7,9,2,10,2,8,5,12,19,16,14,15,4,10,17,13,5,0,18,8,15,4,11,5,12,6,4,2,17,19,14,10,3,17,10,1,15,3,4,7,13,5,16,9,3,15,11,12,0,4,5,7,18,18,2,0,3,9,15,13,1,17,8,14,18,17,3,7,8,9,6,5,13]\n",
    "    Connectivity(i_DCNIO,j_DCNIO,'DCN','IO')\n",
    "\n",
    "    # PC - DCN\n",
    "    i_PCDCN = [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,9,9]\n",
    "    j_PCDCN = [8,17,13,9,11,14,4,16,1,0,17,5,13,2,3,19,4,7,6,8,15,18,2,8,7,11,0,10,16,17,4,16,19,11,18,7,10,8,5,0,0,17,11,13,3,6,1,8,5,10,19,17,12,15,14,4,8,10,18,11,8,6,1,4,16,5,18,3,2,9,3,9,18,11,14,15,4,17,19,10,6,15,10,5,0,11,9,17,12,2,18,0,3,7,2,16,19,10,5,13]\n",
    "    Connectivity(i_PCDCN,j_PCDCN,'PC','DCN')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Raster Plots\n",
    "\n",
    "1. Before Adaptation\n",
    "    1. Coupled\n",
    "    2. Uncoupled\n",
    "    3. Single Loop Coupled\n",
    "    4. Sinlge Loop Uncoupled\n",
    "1. After Adaptation\n",
    "    1. Coupled\n",
    "    2. Uncoupled\n",
    "    3. Single Loop Coupled\n",
    "    4. Single Loop Uncoupled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Set up the parameters for the visualisation\n",
    "\n",
    "Frequency = '20and20Hz'  # the input frequency\n",
    "typeRun = 'adapted'  # choose from: initial (run with no plasticity)\n",
    "                        # plasticity (run with plasticity and change of weights)\n",
    "                        # adapted (run with no plasticity, final weights of 'plasticity'-run)\n",
    "DataSelect = All_data[Frequency][typeRun]\n",
    "\n",
    "## BEFORE ADAPTATION ##\n",
    "# Coupled\n",
    "PopRate = DataSelect['Population_rate']\n",
    "SpikeTimes = DataSelect['Spikes']\n",
    "Input = DataSelect['Input']\n",
    "print(PopRate.keys())\n",
    "t=np.linspace(5,20,num=int(len(PopRate['DCN_coupledr']))) # time \n",
    "print(t)\n",
    "fig, axs = plt.subplots(6, 1,figsize=(15,15))\n",
    "\n",
    "# subplot 1: population frequency PC\n",
    "ax1= plt.subplot(6,1,1)\n",
    "plt.title('coupled')\n",
    "plt.plot(t,PopRate['PC_coupledr'])\n",
    "plt.ylabel('PC population f')\n",
    "# subplot 2: population frequency DCN\n",
    "ax2 = plt.subplot(612, sharex=ax1)\n",
    "plt.plot(t,PopRate['DCN_coupledr'])\n",
    "plt.ylabel('DCN population f')\n",
    "\n",
    "# subplot 3: population frequency IO\n",
    "ax3 = plt.subplot(613,sharex = ax1)\n",
    "plt.plot(t,PopRate['IO_coupledr'])\n",
    "plt.ylabel('IO population f')\n",
    "plt.show()\n",
    "\n",
    "# Raster plot PC\n",
    "for i in range(0,nrPC):\n",
    "    ax3 = plt.subplot(6,1,4, sharex=ax1)\n",
    "    ax3.set_ylabel('PC Index [-]')\n",
    "    neu = SpikeTimes['PC_coupledr'][i]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "\n",
    "# Raster Plot DCN\n",
    "for i in range(0,nrDCN):\n",
    "    ax4 = plt.subplot(6,1,5, sharex=ax1)\n",
    "    ax4.set_ylabel('DCN Index [-]')\n",
    "    neu = SpikeTimes['DCN_coupledr'][i]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "\n",
    "# Raster Plot IO\n",
    "for i in range(0,nrIO):\n",
    "    ax5 = plt.subplot(6,1,6, sharex=ax1)\n",
    "    ax5.set_ylabel('IO Index [-]')\n",
    "    neu = SpikeTimes['IO_coupled_nr'][i]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "    \n",
    "## BEFORE ADAPTATION ##\n",
    "# Uncoupled\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(6, 1,figsize=(15,15))\n",
    "\n",
    "# subplot 1: population frequency PC\n",
    "ax1= plt.subplot(6,1,1)\n",
    "plt.title('uncoupled')\n",
    "plt.plot(t,PopRate['PC_uncoupledr'])\n",
    "plt.ylabel('PC population f')\n",
    "# subplot 2: population frequency DCN\n",
    "ax2 = plt.subplot(612, sharex=ax1)\n",
    "plt.plot(t,PopRate['DCN_uncoupledr'])\n",
    "plt.ylabel('DCN population f')\n",
    "\n",
    "# subplot 3: population frequency IO\n",
    "ax3 = plt.subplot(613,sharex = ax1)\n",
    "plt.plot(t,PopRate['IO_uncoupledr'])\n",
    "plt.ylabel('IO population f')\n",
    "\n",
    "# Raster plot PC\n",
    "for i in range(0,nrPC):\n",
    "    ax3 = plt.subplot(6,1,4, sharex=ax1)\n",
    "    ax3.set_ylabel('PC Index [-]')\n",
    "    neu = SpikeTimes['PC_uncoupledr'][i]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "\n",
    "# Raster Plot DCN\n",
    "for i in range(0,nrDCN):\n",
    "    ax4 = plt.subplot(6,1,5, sharex=ax1)\n",
    "    ax4.set_ylabel('DCN Index [-]')\n",
    "    neu = SpikeTimes['DCN_uncoupledr'][i]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "\n",
    "# Raster Plot IO\n",
    "for i in range(0,nrIO):\n",
    "    ax5 = plt.subplot(6,1,6, sharex=ax1)\n",
    "    ax5.set_ylabel('IO Index [-]')\n",
    "    neu = SpikeTimes['IO_uncoupled_nr'][i]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Raster Plot Single Loop \n",
    "print(Input.keys())\n",
    "lengthSim = len(All_data['2Hz']['plasticity']['Voltage_Cells']['PC_coupledr'][0])\n",
    "RasterPlot(SpikeTimes['IO_coupled'][9],SpikeTimes['PC_coupled'][0],SpikeTimes['DCN_coupled'],\n",
    "           'yes',int(lengthSim), Input['I_InputPC_coupledr'][0])\n",
    "RasterPlot(SpikeTimes['IO_uncoupled'][9],SpikeTimes['PC_uncoupled'][0],SpikeTimes['DCN_uncoupled'],\n",
    "           'yes',int(lengthSim), Input['I_InputPC_uncoupledr'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "build='yes'\n",
    "\n",
    "freqstr = [str(i)+'and'+str(i)+'Hz' for i in range(1,21)]\n",
    "#print(freqstr)\n",
    "xpos = np.arange(20)+1\n",
    "#print(xpos)\n",
    "\n",
    "# total empty allocation\n",
    "ch_c = np.zeros((20,10))\n",
    "ch_uc = np.zeros((20,10))\n",
    "\n",
    "# mean empty allocation\n",
    "pp_c = np.zeros((20,))\n",
    "pp_u = np.zeros((20,))\n",
    "std_c = np.zeros((20,))\n",
    "std_uc = np.zeros((20,))\n",
    "\n",
    "lo=0\n",
    "for k in freqstr:\n",
    "    fwc = All_data[k]['plasticity/PV']['final_weights_coupled']\n",
    "    fwu = All_data[k]['plasticity/PV']['final_weights_uncoupled']\n",
    "    pp_c[lo] = np.mean(fwc)/0.5\n",
    "    pp_u[lo] = np.mean(fwu)/0.5\n",
    "\n",
    "    ch_c[lo,:] = np.asarray(fwc[0:10])/0.5\n",
    "    ch_uc[lo,:] = np.asarray(fwu[0:10])/0.5\n",
    "\n",
    "    std_c[lo] = np.std(fwc)\n",
    "    std_uc[lo] = np.std(fwu)\n",
    "    lo = lo+1\n",
    "#print(ch_c)\n",
    "# Build the plot\n",
    "if build == 'yes':\n",
    "    fig, ax = plt.subplots()\n",
    "    w=0.3\n",
    "    ax.bar(xpos+w/2, pp_c, yerr=std_c, align='center', alpha=1, ecolor='black', capsize=10, width=w, color='r')\n",
    "    ax.bar(xpos-w/2, pp_u, yerr=std_uc, align='center', alpha=0.5, ecolor='black', capsize=10, width=w, color='g')\n",
    "    ax.set_ylabel('Normalized changed of weight ($-$)')\n",
    "    #ax.autoscale(tight=True)\n",
    "    ax.set_xticks(xpos)\n",
    "    ax.set_xlabel('Input frequency [Hz]')\n",
    "    ax.set_ylim([0.8,1.2])\n",
    "    #ax.set_xticklabels(materials)\n",
    "    ax.set_title('Mean change of weight PC-PF synapse - Coupled vs Uncoupled')\n",
    "    ax.yaxis.grid(True)\n",
    "    ax.legend(['Coupled','Uncoupled'])\n",
    "\n",
    "    plt.figure()\n",
    "    plt.scatter(xpos,std_uc, color='g')\n",
    "    plt.scatter(xpos,std_c, color='r')\n",
    "    plt.legend(['Uncoupled','Coupled'])\n",
    "    plt.xlabel('Input frequency [Hz]')\n",
    "    plt.ylabel('Standard deviation [-]')\n",
    "    plt.show()\n",
    "elif build == 'heatmap':\n",
    "    plt.figure()\n",
    "    plt.title('Relative weight change - Coupled')\n",
    "    nf = sns.heatmap(ch_c,center=1, cmap='jet', linewidths=.5,\n",
    "                  annot=False)\n",
    "    plt.ylabel('Input frequency [Hz]')\n",
    "    plt.xlabel('PC index [-]')\n",
    "\n",
    "    plt.figure()\n",
    "    plt.title('Relative weight change - Uncoupled')\n",
    "    nfu = sns.heatmap(ch_uc,center=1, cmap='jet', linewidths=.5,\n",
    "                 annot=False)\n",
    "    plt.ylabel('Input frequency [Hz]')\n",
    "    plt.xlabel('PC index [-]')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## x. Purkinje Cell Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "InputCurrentPC={}\n",
    "InputCurrentPC_BA_coupled={}\n",
    "InputCurrentPC_BA_uncoupled={}\n",
    "\n",
    "InputCurrentPC_AA_coupled={}\n",
    "#print(size(Input_AA['nweight'],0))\n",
    "for i in range(0,nrPC):\n",
    "    # Create names for the inputs\n",
    "    name = 'PC'+str(i)\n",
    "    nameBA_coupled = 'PC'+str(i) + 'BA_coupled'\n",
    "    nameBA_uncoupled = 'PC'+str(i) + 'BA_uncoupled'\n",
    "    \n",
    "    nameAA_coupled = 'PC'+str(i)+'AA_coupled'\n",
    "    \n",
    "    weightBA_coupled = 'WeightPC'+str(i)+'BA_coupled'\n",
    "    weightBA_uncoupled = 'WeightPC'+str(i)+'BA_uncoupled'\n",
    "    \n",
    "    weightAA_coupled=  'WeightPC'+str(i)+'AA_coupled'\n",
    "    \n",
    "    tot = name + 'total'\n",
    "    totBA_coupled = nameBA_coupled + 'total'\n",
    "    totBA_uncoupled = nameBA_uncoupled + 'total'\n",
    "    \n",
    "    totAA_coupled = nameAA_coupled+'total'\n",
    "    \n",
    "    # Connectivity between PC-dummy\n",
    "    steps =np.arange(i,nrDummy,nrPC)\n",
    "    #print(steps)\n",
    "    # Multiply the current times the weight\n",
    "    #current = [Input['I'][k]*Input['nweight'][steps[k]] for k in range(0,len(steps))]\n",
    "    #currentBA = [Input_BA['I'][k]*Input_BA['nweight'][steps[k]] for k in range(0,len(steps))]\n",
    "    weight_BA_coupled = [InputPC_BA['nweight'][steps[k]] for k in range(0,len(steps))]\n",
    "    weight_BA_uncoupled = [InputPC_BA['nweight'][steps[k]] for k in range(0,len(steps))]\n",
    "\n",
    "    weight_AA_coupled = [InputPC_AA['nweight'][steps[k]] for k in range(0,len(steps))]\n",
    "\n",
    "    currentBA_coupled = [InputPC_BA['I'][k]*InputPC_BA['nweight'][steps[k]] for k in range(0,len(steps))]\n",
    "    currentBA_uncoupled = [InputPC_BA['I'][k]*InputPC_BA['nweight'][steps[k]] for k in range(0,len(steps))]\n",
    "    \n",
    "    currentAA_coupled = [InputPC_AA['I'][k]*InputPC_AA['nweight'][steps[k]] for k in range(0,len(steps))]\n",
    "\n",
    "    #[Input_s.nweight_BA[steps[k]]*Input_s.I_BA[k] for k in range(0,len(steps))]\n",
    "    #print(steps[1])\n",
    "    #print(size(Input_s.nweight_BA[0]))\n",
    "    #print(size(current))\n",
    "    # Sum over the column to get the total amount of current\n",
    "    #summedcurrent = sum(current,axis=0)\n",
    "    summedcurrentBA_coupled = sum(currentBA_coupled, axis=0)\n",
    "    summedcurrentBA_uncoupled = sum(currentBA_uncoupled, axis=0)\n",
    "    \n",
    "    summedcurrentAA_coupled = sum(currentAA_coupled, axis=0)\n",
    "    \n",
    "    #InputCurrentPC[name] = current\n",
    "    InputCurrentPC_BA_coupled[nameBA_coupled] = currentBA_coupled\n",
    "    InputCurrentPC_BA_uncoupled[nameBA_uncoupled] = currentBA_uncoupled\n",
    "    \n",
    "    InputCurrentPC_AA_coupled[nameAA_coupled] = currentAA_coupled\n",
    "\n",
    "    # weights seperate\n",
    "    InputCurrentPC_BA_coupled[weightBA_coupled] = weight_BA_coupled\n",
    "    InputCurrentPC_BA_uncoupled[weightBA_uncoupled] = weight_BA_uncoupled\n",
    "    \n",
    "    InputCurrentPC_AA_coupled[weightAA_coupled] = weight_AA_coupled\n",
    "\n",
    "    #InputCurrentPC[tot] = summedcurrent\n",
    "    InputCurrentPC_BA_coupled[totBA_coupled] = summedcurrentBA_coupled\n",
    "    InputCurrentPC_BA_uncoupled[totBA_uncoupled] = summedcurrentBA_uncoupled\n",
    "    \n",
    "    InputCurrentPC_AA_coupled[totAA_coupled] = summedcurrentAA_coupled\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import elephant.conversion as conv\n",
    "import elephant.spike_train_correlation as spiketrain\n",
    "import neo as n\n",
    "import quantities as pq\n",
    "#print(All_data['2Hz/plasticity/Spikes'].keys())\n",
    "freq = [str(i)+'and'+str(i)+'Hz' for i in range(1,2)]\n",
    "\n",
    "types = ['initial','plasticity','adapted']\n",
    "coupling =['IO_coupled', 'IO_uncoupled']\n",
    "#SD = All_data['2Hz/plasticity/Spikes/IO_coupledq']\n",
    "binsiz = 0.1\n",
    "#1/4/10\n",
    "l=0\n",
    "\n",
    "qq = 1\n",
    "\n",
    "for tt in freq:\n",
    "    for kk in coupling:\n",
    "        fig, axs = plt.subplots(1,3, figsize=(12,4),sharex=True,sharey=True)\n",
    "        fig.suptitle('Sum Xcorr IO cells - Input = ' + str(qq) + 'Hz - ' + ' '+ kk)\n",
    "    \n",
    "        y=0\n",
    "        \n",
    "        for nn in types:\n",
    "\n",
    "            #print(All_data[freq][nn].keys())\n",
    "            #print(All_data[freq][nn]['Spikes'].keys())\n",
    "            SD = All_data[tt][nn]['Spikes'][kk+'_nr']\n",
    "            print('spike time IO'+kk+ str(SD[1][5]))\n",
    "            corrl = int(15/binsiz)*2-1\n",
    "            st={}\n",
    "            delay=np.empty((20,20))\n",
    "            total_corr = np.empty((size(types)*size(coupling)*size(freq),corrl))\n",
    "            #print(total_corr)\n",
    "            pp = np.zeros((corrl,1))\n",
    "            for p in range(0,20):\n",
    "                x = n.SpikeTrain(SD[p]*pq.s,t_stop=20.0*pq.s)\n",
    "                st[str(p)] = conv.BinnedSpikeTrain(x,binsize=binsiz*pq.s,t_start=5*pq.s)\n",
    "            for ii in range(0,1):\n",
    "                for k in range(0,1):\n",
    "                    crosscorr = spiketrain.cross_correlation_histogram(st[str(ii)],st[str(k)])\n",
    "                    #print(crosscorr)\n",
    "                    pp += crosscorr[0]\n",
    "                    #plt.figure()\n",
    "                    #plt.plot(crosscorr[0])\n",
    "                    #plt.show()\n",
    "                    #print(crosscorr)\n",
    "                    delay[ii,k] = np.argmax(crosscorr[0])\n",
    "            ppp =np.reshape(pp,(int(15/binsiz)*2-1,))\n",
    "            total_corr[l,:]= ppp\n",
    "            delay = (delay-((15)/binsiz))*binsiz\n",
    "            #plt.figure()\n",
    "            #plt.title('Delay of IO cells with respect to other IO cells -' + nn)\n",
    "            #plt.xlabel('IO index [-]')\n",
    "            #plt.ylabel('IO index [-]')\n",
    "            #sns.heatmap(delay,center = 0, cmap='jet')\n",
    "            #plt.show()\n",
    "            #plt.figure()\n",
    "            #plt.title('Sum of Xcorr for all IO cell w.r.t eachother - '+kk+ nn +\n",
    "            #         'Input being :' + tt)\n",
    "            #plt.xlabel('Data bins [-]')\n",
    "            #plt.ylabel('Correlation [-]')\n",
    "            \n",
    "            \n",
    "            axs[y].plot(total_corr[l,:])\n",
    "            axs[y].title.set_text(nn)\n",
    "            #plt.ylim([0,400])\n",
    "            #plt.xlim([])\n",
    "            #plt.xlim(delay-20*corrl,delay+20*corrl)\n",
    "            #plt.show()\n",
    "\n",
    "            y += 1\n",
    "            l += 1\n",
    "        plt.savefig(tt+'correlation_'+kk+'_'+nn)\n",
    "    qq += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(All_data['3and3Hz/adapted/Spikes/IO_coupled_nr'][1])\n",
    "print(All_data['3and3Hz/adapted/Spikes/IO_uncoupled_nr'][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#6.1 Input Current Purkinje Cell\n",
    "# Get the current that the Purkinje cell sees 1000 ms before and 1000 ms after\n",
    "# a complex spike of the connected Inferior Olive\n",
    "\n",
    "# Select which frequency you want analyzed\n",
    "freq = '2and2Hz'\n",
    "\n",
    "InputBA = All_data[freq]['initial/Input']\n",
    "InputAA = All_data[freq]['adapted/Input']\n",
    "VoltBA = All_data[freq]['initial/Voltage_Cells']\n",
    "VoltAA = All_data[freq]['adapted/Voltage_Cells']\n",
    "SpikesBA = All_data[freq]['initial/Spikes']\n",
    "SpikesAA = All_data[freq]['adapted/Spikes']\n",
    "\n",
    "# The IO cells that are connected to the Purkinje cells.\n",
    "# Position 1 of the vector corresponds to PC1, 2 to PC2 etc.\n",
    "connectionVectorIO = [9,10, 18, 17, 0, 6, 5, 12, 16, 11]\n",
    "\n",
    "time_before_spike = 1000e-3\n",
    "time_after_spike = 1000e-3\n",
    "CS_currentPC=defaultdict(dict)\n",
    "duration = int((time_before_spike+time_after_spike)*1e3)\n",
    "\n",
    "# Create empty arrays to fill the mean current before and after the CS\n",
    "meancur_BA_coupled=np.zeros((nrPC,duration))\n",
    "meancur_BA_uncoupled=np.zeros((nrPC,duration))\n",
    "meancur_AA_coupled=np.zeros((nrPC,duration))\n",
    "meancur_AA_uncoupled=np.zeros((nrPC,duration))\n",
    "\n",
    "#sep_curBA_coupled=np.zeros((nrPC*2,duration))\n",
    "#sep_curAA_coupled=np.zeros((nrPC*2,duration))\n",
    "\n",
    "# Empty arrays of voltage cells of IOs\n",
    "mean_voltIO_AA_coupled = np.zeros((nrPC,duration))\n",
    "mean_voltIO_BA_coupled = np.zeros((nrPC,duration))\n",
    "mean_voltIO_AA_uncoupled = np.zeros((nrPC,duration))\n",
    "mean_voltIO_BA_uncoupled = np.zeros((nrPC,duration))\n",
    "\n",
    "#weight_BA_coupled = np.zeros((nrInputs*nrPC,duration))\n",
    "#weight_AA_coupled = np.zeros((nrInputs*nrPC,duration))\n",
    "\n",
    "### !! FOR NOW COUPLED AND UNCOUPLED ARE THE SAME INPUT (BOTH SAME FREQ) !! ###\n",
    "InpPCBA_coupled = InputBA['I_InputPC_coupled']\n",
    "InpPCBA_uncoupled = InputBA['I_InputPC_uncoupled']\n",
    "\n",
    "InpPCAA_coupled = InputAA['I_InputPC_coupled']\n",
    "InpPCAA_uncoupled = InputAA['I_InputPC_uncoupled']\n",
    "\n",
    "for jj in range(0,nrPC):\n",
    "    strp = str(connectionVectorIO[jj])\n",
    "    #pcnr = 'PC'+str(jj)+'BA_coupled'\n",
    "    #pcnr2 = 'PC'+str(jj)+'AA_coupled'\n",
    "    #w_pcnr = 'WeightPC'+str(jj)+'BA_coupled'\n",
    "    #w2_pcnr = 'WeightPC'+str(jj)+'AA_coupled'\n",
    "\n",
    "    # Input current I_Noise to PC\n",
    "    InputCurrBA = InpPCBA_coupled[jj]\n",
    "    InputCurrAA = InpPCAA_coupled[jj]\n",
    "\n",
    "    # Seperate Inputs (after weight multiplication)\n",
    "    #sep_inpba=InputCurrentPC_BA_coupled[pcnr]\n",
    "    #sep_inpaa=InputCurrentPC_AA_coupled[pcnr2]\n",
    "\n",
    "    # Get weights\n",
    "    #sep_wBA =InputCurrentPC_BA_coupled[w_pcnr]\n",
    "    #sep_wAA = InputCurrentPC_AA_coupled[w2_pcnr]\n",
    "\n",
    "    # Membrane potential of IO cells\n",
    "    voltIO_BA_coupled = VoltBA['IOsoma_coupled'][connectionVectorIO[jj]]\n",
    "    voltIO_BA_uncoupled = VoltBA['IOsoma_uncoupled'][connectionVectorIO[jj]]\n",
    "\n",
    "    voltIO_AA_coupled = VoltAA['IOsoma_coupled'][connectionVectorIO[jj]]\n",
    "    voltIO_AA_uncoupled = VoltAA['IOsoma_uncoupled'][connectionVectorIO[jj]]\n",
    "\n",
    "    # The complex spikes times\n",
    "    CS_BA_coupled= SpikesBA['IO_coupled'][connectionVectorIO[jj]]\n",
    "    CS_BA_uncoupled = SpikesBA['IO_uncoupled'][connectionVectorIO[jj]]\n",
    "    CS_AA_coupled = SpikesAA['IO_coupled'][connectionVectorIO[jj]]\n",
    "    CS_AA_uncoupled = SpikesAA['IO_uncoupled'][connectionVectorIO[jj]]\n",
    "\n",
    "    # initialization of empty array which are assigned in the loop below\n",
    "    I_BA_coupled = np.zeros((len(CS_BA_coupled),duration))\n",
    "    I_BA_uncoupled = np.zeros((len(CS_BA_uncoupled),duration))\n",
    "    I_AA_coupled =np.zeros((len(CS_AA_coupled),duration))\n",
    "    I_AA_uncoupled =np.zeros((len(CS_AA_uncoupled),duration))\n",
    "\n",
    "    empt_curBA_coupled =np.zeros((len(CS_BA_coupled)*nrInputs,duration))\n",
    "    empt_curBA_uncoupled =np.zeros((len(CS_BA_uncoupled)*nrInputs,duration))\n",
    "\n",
    "    empt_curAA_coupled =np.zeros((len(CS_AA_coupled)*nrInputs,duration))\n",
    "    empt_curAA_uncoupled =np.zeros((len(CS_AA_uncoupled)*nrInputs,duration))\n",
    "\n",
    "    empt_membIO_BA_coupled = np.zeros((len(CS_BA_coupled),duration))\n",
    "    empt_membIO_BA_uncoupled = np.zeros((len(CS_BA_uncoupled),duration))\n",
    "\n",
    "    empt_membIO_AA_coupled = np.zeros((len(CS_AA_coupled),duration))\n",
    "    empt_membIO_AA_uncoupled = np.zeros((len(CS_AA_uncoupled),duration))\n",
    "    #empt_membIO_AA = np.zeros((len(CS_AA),duration))\n",
    "\n",
    "    #empt_wAA = np.zeros((len(CS_AA)*nrInputs,duration))\n",
    "    #empt_wBA = np.zeros((len(CS_BA)*nrInputs,duration))\n",
    "\n",
    "    k=0\n",
    "    #plt.figure()\n",
    "    #plt.title('Before adapation')\n",
    "    for ii in range(0,len(CS_BA_coupled)):\n",
    "        begin_analysis = max(int(((CS_BA_coupled[ii]-time_before_spike)/1e-3)),CS_BA_coupled[0]*1000)-start\n",
    "        end_analysis = (int((min((CS_BA_coupled[ii]+time_after_spike)/1e-3,\n",
    "                        CS_BA_coupled[-1]*1000))))-start\n",
    "        if end_analysis-begin_analysis==duration-1 :\n",
    "            end_analysis=end_analysis+1\n",
    "        elif end_analysis-begin_analysis==duration+1 :\n",
    "            end_analysis=end_analysis-1\n",
    "        #print('begin analysis',begin_analysis, 'end analysis = ', end_analysis, 'length = ',end_analysis-begin_analysis)\n",
    "        if (end_analysis-abs(begin_analysis))==duration :\n",
    "            #CS_currentPC[ionr][ii] = InputCurr[begin_analysis:end_analysis]\n",
    "            I_BA_coupled[ii]= InputCurrBA[begin_analysis:end_analysis]\n",
    "\n",
    "            # Individual inputs to the PC\n",
    "            #for t in range(0,nrInputs):\n",
    "            #    empt_wBA[ii*2+t] = sep_wBA[t][begin_analysis:end_analysis]\n",
    "            #    empt_curBA[ii*2+t]=sep_inpba[t][begin_analysis:end_analysis]\n",
    "\n",
    "            # IO membrane potential\n",
    "            empt_membIO_BA_coupled[ii] = voltIO_BA_coupled[begin_analysis:end_analysis]\n",
    "\n",
    "    for kk in range(0,len(CS_BA_uncoupled)):\n",
    "        begin_analysis_unc = max(int(((CS_BA_uncoupled[kk]-time_before_spike)/1e-3)),CS_BA_uncoupled[0]*1000)-start\n",
    "        end_analysis_unc = (int((min((CS_BA_uncoupled[kk]+time_after_spike)/1e-3,\n",
    "                        CS_BA_uncoupled[-1]*1000))))-start\n",
    "        if end_analysis_unc-begin_analysis_unc==duration-1 :\n",
    "            end_analysis_unc=end_analysis_unc+1\n",
    "        elif end_analysis_unc-begin_analysis_unc==duration+1 :\n",
    "            end_analysis_unc=end_analysis_unc-1\n",
    "        #print('begin analysis',begin_analysis, 'end analysis = ', end_analysis, 'length = ',end_analysis-begin_analysis)\n",
    "        if (end_analysis_unc-abs(begin_analysis_unc))==duration :\n",
    "            #CS_currentPC[ionr][ii] = InputCurr[begin_analysis:end_analysis]\n",
    "            I_BA_uncoupled[kk]= InputCurrBA[begin_analysis_unc:end_analysis_unc]\n",
    "\n",
    "            # Individual inputs to the PC\n",
    "            #for t in range(0,nrInputs):\n",
    "            #    empt_wBA[ii*2+t] = sep_wBA[t][begin_analysis:end_analysis]\n",
    "            #    empt_curBA[ii*2+t]=sep_inpba[t][begin_analysis:end_analysis]\n",
    "\n",
    "            # IO membrane potential\n",
    "            empt_membIO_BA_uncoupled[kk] = voltIO_BA_uncoupled[begin_analysis_unc:end_analysis_unc]\n",
    "    #plt.figure()\n",
    "    for pp in range(0,len(CS_AA_coupled)):\n",
    "        begin_analysis = max(int(((CS_AA_coupled[pp]-time_before_spike)/1e-3)),CS_AA_coupled[0]*1000)-start\n",
    "        end_analysis = (int((min((CS_AA_coupled[pp]+time_after_spike)/1e-3,\n",
    "                        CS_AA_coupled[-1]*1000))))-start\n",
    "        if end_analysis-begin_analysis==duration-1 :\n",
    "            end_analysis=end_analysis+1\n",
    "        elif end_analysis-begin_analysis==duration+1 :\n",
    "            end_analysis=end_analysis-1\n",
    "        #print('begin analysis',begin_analysis, 'end analysis = ', end_analysis, 'length = ',end_analysis-begin_analysis)\n",
    "        if (end_analysis-abs(begin_analysis))==duration :\n",
    "            #CS_currentPC[ionr][ii] = InputCurr[begin_analysis:end_analysis]\n",
    "            I_AA_coupled[pp]= InputCurrAA[begin_analysis:end_analysis]\n",
    "            #plt.plot(I_AA_coupled[pp])\n",
    "            # Individual inputs to the PC\n",
    "            #for t in range(0,nrInputs):\n",
    "            #    empt_wBA[ii*2+t] = sep_wBA[t][begin_analysis:end_analysis]\n",
    "            #    empt_curBA[ii*2+t]=sep_inpba[t][begin_analysis:end_analysis]\n",
    "\n",
    "            # IO membrane potential\n",
    "            empt_membIO_AA_coupled[pp] = voltIO_AA_coupled[begin_analysis:end_analysis]\n",
    "    #plt.show()\n",
    "    for ll in range(0,len(CS_AA_uncoupled)):\n",
    "        begin_analysis_unc = max(int(((CS_AA_uncoupled[ll]-time_before_spike)/1e-3)),CS_AA_uncoupled[0]*1000)-start\n",
    "        end_analysis_unc = (int((min((CS_AA_uncoupled[ll]+time_after_spike)/1e-3,\n",
    "                        CS_AA_uncoupled[-1]*1000))))-start\n",
    "        if end_analysis_unc-begin_analysis_unc==duration-1 :\n",
    "            end_analysis_unc=end_analysis_unc+1\n",
    "        elif end_analysis_unc-begin_analysis_unc==duration+1 :\n",
    "            end_analysis_unc=end_analysis_unc-1\n",
    "        #print('begin analysis',begin_analysis, 'end analysis = ', end_analysis, 'length = ',end_analysis-begin_analysis)\n",
    "        if (end_analysis_unc-abs(begin_analysis_unc))==duration :\n",
    "            #CS_currentPC[ionr][ii] = InputCurr[begin_analysis:end_analysis]\n",
    "            I_AA_uncoupled[ll]= InputCurrAA[begin_analysis_unc:end_analysis_unc]\n",
    "\n",
    "            # Individual inputs to the PC\n",
    "            #for t in range(0,nrInputs):\n",
    "            #    empt_wBA[ii*2+t] = sep_wBA[t][begin_analysis:end_analysis]\n",
    "            #    empt_curBA[ii*2+t]=sep_inpba[t][begin_analysis:end_analysis]\n",
    "\n",
    "            # IO membrane potential\n",
    "            empt_membIO_AA_uncoupled[ll] = voltIO_AA_uncoupled[begin_analysis_unc:end_analysis_unc]\n",
    "    I_AA_uncoupled = I_AA_uncoupled[~all(I_AA_uncoupled==0,axis=1)]\n",
    "    I_AA_coupled = I_AA_coupled[~all(I_AA_coupled==0,axis=1)]\n",
    "    I_BA_uncoupled = I_BA_uncoupled[~all(I_BA_uncoupled==0,axis=1)]\n",
    "    I_BA_coupled = I_BA_coupled[~all(I_BA_coupled==0,axis=1)]\n",
    "\n",
    "    mean_voltIO_AA_coupled[jj] = np.mean(empt_membIO_AA_coupled,axis=0)\n",
    "    mean_voltIO_AA_uncoupled[jj] = np.mean(empt_membIO_AA_uncoupled,axis=0)\n",
    "    mean_voltIO_BA_coupled[jj] = np.mean(empt_membIO_BA_coupled,axis=0)\n",
    "    mean_voltIO_BA_uncoupled[jj] = np.mean(empt_membIO_BA_uncoupled,axis=0)\n",
    "\n",
    "    meancur_BA_coupled[jj]=np.mean(I_BA_coupled,axis=0)\n",
    "    meancur_BA_uncoupled[jj]=np.mean(I_BA_uncoupled,axis=0)\n",
    "    meancur_AA_coupled[jj]=np.mean(I_AA_coupled,axis=0)\n",
    "    meancur_AA_uncoupled[jj]=np.mean(I_AA_uncoupled,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig, axs = subplots(5, 2,figsize=(20,10))\n",
    "fig.suptitle('Kernel of Input for CS - Coupled')\n",
    "p=q=0\n",
    "#figure(figsize=(20,20))\n",
    "#fig(figsize=(20,10))\n",
    "#print(meancur_BA_coupled)\n",
    "time = linspace(start=-time_before_spike*1e3,stop=time_after_spike*1e3,num=duration)\n",
    "for i in range(0,len(meancur_BA_coupled)):\n",
    "    #subplot(5,2,i+1)\n",
    "    axs[p,q].plot(time,meancur_BA_coupled[i], color='cyan')\n",
    "    axs[p,q].plot(time,meancur_AA_coupled[i], color='black')\n",
    "\n",
    "    axs[p,q].axvline(0, linewidth=2,color='r')\n",
    "    axs[p,q].set_title('Mean input current to PC' + str(i))\n",
    "    p=p+1\n",
    "    if i==4:\n",
    "        q=q+1\n",
    "        p=0\n",
    "    for ax in axs.flat:\n",
    "        ax.set(xlabel='time [ms]', ylabel='current [A]')\n",
    "    for ax in axs.flat:\n",
    "        ax.label_outer()\n",
    "    #axs.figsize((20,10))\n",
    "legend(['before','after','cs'], loc='lower left')\n",
    "show()\n",
    "savefig(freq+'kernel_coupled')\n",
    "\n",
    "fig, axs = subplots(5, 2,figsize=(20,10))\n",
    "fig.suptitle('Kernel of Input for CS - Uncoupled')\n",
    "p=q=0\n",
    "#figure(figsize=(20,20))\n",
    "#fig(figsize=(20,10))\n",
    "#print(meancur_BA_coupled)\n",
    "time = linspace(start=-time_before_spike*1e3,stop=time_after_spike*1e3,num=duration)\n",
    "for i in range(0,len(meancur_BA_coupled)):\n",
    "    #subplot(5,2,i+1)\n",
    "    axs[p,q].plot(time,meancur_BA_uncoupled[i], color='cyan')\n",
    "    axs[p,q].plot(time,meancur_AA_uncoupled[i], color='black')\n",
    "\n",
    "    axs[p,q].axvline(0, linewidth=2,color='r')\n",
    "    axs[p,q].set_title('Mean input current to PC' + str(i))\n",
    "    p=p+1\n",
    "    if i==4:\n",
    "        q=q+1\n",
    "        p=0\n",
    "    for ax in axs.flat:\n",
    "        ax.set(xlabel='time [ms]', ylabel='current [A]')\n",
    "    for ax in axs.flat:\n",
    "        ax.label_outer()\n",
    "    #axs.figsize((20,10))\n",
    "legend(['before','after','cs'], loc='lower left')\n",
    "show()\n",
    "savefig(freq+'kernel_uncoupled')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## x. CS analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#6.1 Input Current Purkinje Cell\n",
    "# Get the current that the Purkinje cell sees 150 ms before and 50 ms after\n",
    "# a complex spike of the connected Inferior Olive\n",
    "\n",
    "# The IO cells that are connected to the Purkinje cells. \n",
    "# Position 1 of the vector corresponds to PC1, 2 to PC2 etc.\n",
    "connectionVectorIO = [9,10, 18, 17, 0, 6, 5, 12, 16, 11]\n",
    "\n",
    "time_before_spike = 1000e-3\n",
    "time_after_spike = 1000e-3\n",
    "CS_currentPC=defaultdict(dict)\n",
    "duration = int((time_before_spike+time_after_spike)*1e3)\n",
    "\n",
    "# Create empty arrays to fill the mean current before and after the CS\n",
    "meancur_BA_coupled=np.zeros((nrPC,duration))\n",
    "meancur_BA_uncoupled=np.zeros((nrPC,duration))\n",
    "meancur_AA_coupled=np.zeros((nrPC,duration))\n",
    "meancur_AA_uncoupled=np.zeros((nrPC,duration))\n",
    "\n",
    "#sep_curBA_coupled=np.zeros((nrPC*2,duration))\n",
    "#sep_curAA_coupled=np.zeros((nrPC*2,duration))\n",
    "\n",
    "# Empty arrays of voltage cells of IOs\n",
    "mean_voltIO_AA_coupled = np.zeros((nrPC,duration))\n",
    "mean_voltIO_BA_coupled = np.zeros((nrPC,duration))\n",
    "mean_voltIO_AA_uncoupled = np.zeros((nrPC,duration))\n",
    "mean_voltIO_BA_uncoupled = np.zeros((nrPC,duration))\n",
    "\n",
    "#weight_BA_coupled = np.zeros((nrInputs*nrPC,duration))\n",
    "#weight_AA_coupled = np.zeros((nrInputs*nrPC,duration))\n",
    "\n",
    "### !! FOR NOW COUPLED AND UNCOUPLED ARE THE SAME INPUT (BOTH SAME FREQ) !! ###\n",
    "InpPCBA_coupled = InputPC_BA['I_InputPC']\n",
    "InpPCAA_coupled = InputPC_AA['I_InputPC']\n",
    "\n",
    "for jj in range(0,nrPC):\n",
    "    strp = str(connectionVectorIO[jj])\n",
    "    #pcnr = 'PC'+str(jj)+'BA_coupled'\n",
    "    #pcnr2 = 'PC'+str(jj)+'AA_coupled'\n",
    "    #w_pcnr = 'WeightPC'+str(jj)+'BA_coupled'\n",
    "    #w2_pcnr = 'WeightPC'+str(jj)+'AA_coupled'\n",
    "    \n",
    "    # Input current I_Noise to PC\n",
    "    InputCurrBA = InputPC_BA['I_InputPC'][jj]\n",
    "    InputCurrAA = InputPC_AA['I_InputPC'][jj]\n",
    " \n",
    "    # Seperate Inputs (after weight multiplication)\n",
    "    #sep_inpba=InputCurrentPC_BA_coupled[pcnr]\n",
    "    #sep_inpaa=InputCurrentPC_AA_coupled[pcnr2]\n",
    "    \n",
    "    # Get weights \n",
    "    #sep_wBA =InputCurrentPC_BA_coupled[w_pcnr]\n",
    "    #sep_wAA = InputCurrentPC_AA_coupled[w2_pcnr]\n",
    "    \n",
    "    # Membrane potential of IO cells\n",
    "    voltIO_BA_coupled = VoltCells_BA['IOsoma_coupled'][connectionVectorIO[jj]]\n",
    "    voltIO_BA_uncoupled = VoltCells_BA['IOsoma_uncoupled'][connectionVectorIO[jj]]\n",
    "\n",
    "    voltIO_AA_coupled = VoltCells_AA['IOsoma_coupled'][connectionVectorIO[jj]]\n",
    "    voltIO_AA_uncoupled = VoltCells_AA['IOsoma_uncoupled'][connectionVectorIO[jj]]\n",
    "    \n",
    "    # The complex spikes times\n",
    "    CS_BA_coupled= SpikeTimes_BA['IO_coupled'][connectionVectorIO[jj]]\n",
    "    CS_BA_uncoupled = SpikeTimes_BA['IO_uncoupled'][connectionVectorIO[jj]]\n",
    "    CS_AA_coupled = SpikeTimes_AA['IO_coupled'][connectionVectorIO[jj]]\n",
    "    CS_AA_uncoupled = SpikeTimes_AA['IO_uncoupled'][connectionVectorIO[jj]]\n",
    "   \n",
    "    # initialization of empty array which are assigned in the loop below\n",
    "    I_BA_coupled = np.zeros((len(CS_BA_coupled),duration))\n",
    "    I_BA_uncoupled = np.zeros((len(CS_BA_uncoupled),duration))\n",
    "    I_AA_coupled =np.zeros((len(CS_AA_coupled),duration))\n",
    "    I_AA_uncoupled =np.zeros((len(CS_AA_uncoupled),duration))\n",
    "\n",
    "    empt_curBA_coupled =np.zeros((len(CS_BA_coupled)*nrInputs,duration))\n",
    "    empt_curBA_uncoupled =np.zeros((len(CS_BA_uncoupled)*nrInputs,duration))\n",
    "\n",
    "    empt_curAA_coupled =np.zeros((len(CS_AA_coupled)*nrInputs,duration))\n",
    "    empt_curAA_uncoupled =np.zeros((len(CS_AA_uncoupled)*nrInputs,duration))\n",
    "\n",
    "    empt_membIO_BA_coupled = np.zeros((len(CS_BA_coupled),duration))\n",
    "    empt_membIO_BA_uncoupled = np.zeros((len(CS_BA_uncoupled),duration))\n",
    "\n",
    "    empt_membIO_AA_coupled = np.zeros((len(CS_AA_coupled),duration))\n",
    "    empt_membIO_AA_uncoupled = np.zeros((len(CS_AA_uncoupled),duration))\n",
    "    #empt_membIO_AA = np.zeros((len(CS_AA),duration))\n",
    "    \n",
    "    #empt_wAA = np.zeros((len(CS_AA)*nrInputs,duration))\n",
    "    #empt_wBA = np.zeros((len(CS_BA)*nrInputs,duration))\n",
    "\n",
    "    k=0\n",
    "    #plt.figure()\n",
    "    #plt.title('Before adapation')\n",
    "    for ii in range(0,len(CS_BA_coupled)):\n",
    "        begin_analysis = max(int(((CS_BA_coupled[ii]-time_before_spike)/1e-3)),CS_BA_coupled[0]*1000)-start\n",
    "        end_analysis = (int((min((CS_BA_coupled[ii]+time_after_spike)/1e-3,\n",
    "                        CS_BA_coupled[-1]*1000))))-start\n",
    "        if end_analysis-begin_analysis==duration-1 : \n",
    "            end_analysis=end_analysis+1\n",
    "        elif end_analysis-begin_analysis==duration+1 : \n",
    "            end_analysis=end_analysis-1        \n",
    "        #print('begin analysis',begin_analysis, 'end analysis = ', end_analysis, 'length = ',end_analysis-begin_analysis)\n",
    "        if (end_analysis-abs(begin_analysis))==duration :\n",
    "            #CS_currentPC[ionr][ii] = InputCurr[begin_analysis:end_analysis]\n",
    "            I_BA_coupled[ii]= InputCurrBA[begin_analysis:end_analysis]\n",
    "           \n",
    "            # Individual inputs to the PC\n",
    "            #for t in range(0,nrInputs):\n",
    "            #    empt_wBA[ii*2+t] = sep_wBA[t][begin_analysis:end_analysis]\n",
    "            #    empt_curBA[ii*2+t]=sep_inpba[t][begin_analysis:end_analysis]\n",
    "\n",
    "            # IO membrane potential \n",
    "            empt_membIO_BA_coupled[ii] = voltIO_BA_coupled[begin_analysis:end_analysis]\n",
    "           \n",
    "    for kk in range(0,len(CS_BA_uncoupled)):\n",
    "        begin_analysis_unc = max(int(((CS_BA_uncoupled[kk]-time_before_spike)/1e-3)),CS_BA_uncoupled[0]*1000)-start\n",
    "        end_analysis_unc = (int((min((CS_BA_uncoupled[kk]+time_after_spike)/1e-3,\n",
    "                        CS_BA_uncoupled[-1]*1000))))-start\n",
    "        if end_analysis_unc-begin_analysis_unc==duration-1 : \n",
    "            end_analysis_unc=end_analysis_unc+1\n",
    "        elif end_analysis_unc-begin_analysis_unc==duration+1 : \n",
    "            end_analysis_unc=end_analysis_unc-1        \n",
    "        #print('begin analysis',begin_analysis, 'end analysis = ', end_analysis, 'length = ',end_analysis-begin_analysis)\n",
    "        if (end_analysis_unc-abs(begin_analysis_unc))==duration :\n",
    "            #CS_currentPC[ionr][ii] = InputCurr[begin_analysis:end_analysis]\n",
    "            I_BA_uncoupled[kk]= InputCurrBA[begin_analysis_unc:end_analysis_unc]\n",
    "           \n",
    "            # Individual inputs to the PC\n",
    "            #for t in range(0,nrInputs):\n",
    "            #    empt_wBA[ii*2+t] = sep_wBA[t][begin_analysis:end_analysis]\n",
    "            #    empt_curBA[ii*2+t]=sep_inpba[t][begin_analysis:end_analysis]\n",
    "\n",
    "            # IO membrane potential \n",
    "            empt_membIO_BA_uncoupled[kk] = voltIO_BA_uncoupled[begin_analysis_unc:end_analysis_unc]           \n",
    "    #plt.figure()\n",
    "    for pp in range(0,len(CS_AA_coupled)):\n",
    "        begin_analysis = max(int(((CS_AA_coupled[pp]-time_before_spike)/1e-3)),CS_AA_coupled[0]*1000)-start\n",
    "        end_analysis = (int((min((CS_AA_coupled[pp]+time_after_spike)/1e-3,\n",
    "                        CS_AA_coupled[-1]*1000))))-start\n",
    "        if end_analysis-begin_analysis==duration-1 : \n",
    "            end_analysis=end_analysis+1\n",
    "        elif end_analysis-begin_analysis==duration+1 : \n",
    "            end_analysis=end_analysis-1        \n",
    "        #print('begin analysis',begin_analysis, 'end analysis = ', end_analysis, 'length = ',end_analysis-begin_analysis)\n",
    "        if (end_analysis-abs(begin_analysis))==duration :\n",
    "            #CS_currentPC[ionr][ii] = InputCurr[begin_analysis:end_analysis]\n",
    "            I_AA_coupled[pp]= InputCurrAA[begin_analysis:end_analysis]\n",
    "            #plt.plot(I_AA_coupled[pp])\n",
    "            # Individual inputs to the PC\n",
    "            #for t in range(0,nrInputs):\n",
    "            #    empt_wBA[ii*2+t] = sep_wBA[t][begin_analysis:end_analysis]\n",
    "            #    empt_curBA[ii*2+t]=sep_inpba[t][begin_analysis:end_analysis]\n",
    "\n",
    "            # IO membrane potential \n",
    "            empt_membIO_AA_coupled[pp] = voltIO_AA_coupled[begin_analysis:end_analysis]\n",
    "    #plt.show()      \n",
    "    for ll in range(0,len(CS_AA_uncoupled)):\n",
    "        begin_analysis_unc = max(int(((CS_AA_uncoupled[ll]-time_before_spike)/1e-3)),CS_AA_uncoupled[0]*1000)-start\n",
    "        end_analysis_unc = (int((min((CS_AA_uncoupled[ll]+time_after_spike)/1e-3,\n",
    "                        CS_AA_uncoupled[-1]*1000))))-start\n",
    "        if end_analysis_unc-begin_analysis_unc==duration-1 : \n",
    "            end_analysis_unc=end_analysis_unc+1\n",
    "        elif end_analysis_unc-begin_analysis_unc==duration+1 : \n",
    "            end_analysis_unc=end_analysis_unc-1        \n",
    "        #print('begin analysis',begin_analysis, 'end analysis = ', end_analysis, 'length = ',end_analysis-begin_analysis)\n",
    "        if (end_analysis_unc-abs(begin_analysis_unc))==duration :\n",
    "            #CS_currentPC[ionr][ii] = InputCurr[begin_analysis:end_analysis]\n",
    "            I_AA_uncoupled[ll]= InputCurrAA[begin_analysis_unc:end_analysis_unc]\n",
    "           \n",
    "            # Individual inputs to the PC\n",
    "            #for t in range(0,nrInputs):\n",
    "            #    empt_wBA[ii*2+t] = sep_wBA[t][begin_analysis:end_analysis]\n",
    "            #    empt_curBA[ii*2+t]=sep_inpba[t][begin_analysis:end_analysis]\n",
    "\n",
    "            # IO membrane potential \n",
    "            empt_membIO_AA_uncoupled[ll] = voltIO_AA_uncoupled[begin_analysis_unc:end_analysis_unc]    \n",
    "    I_AA_uncoupled = I_AA_uncoupled[~all(I_AA_uncoupled==0,axis=1)]\n",
    "    I_AA_coupled = I_AA_coupled[~all(I_AA_coupled==0,axis=1)]\n",
    "    I_BA_uncoupled = I_BA_uncoupled[~all(I_BA_uncoupled==0,axis=1)]\n",
    "    I_BA_coupled = I_BA_coupled[~all(I_BA_coupled==0,axis=1)]\n",
    "\n",
    "    mean_voltIO_AA_coupled[jj] = np.mean(empt_membIO_AA_coupled,axis=0)\n",
    "    mean_voltIO_AA_uncoupled[jj] = np.mean(empt_membIO_AA_uncoupled,axis=0)\n",
    "    mean_voltIO_BA_coupled[jj] = np.mean(empt_membIO_BA_coupled,axis=0)\n",
    "    mean_voltIO_BA_uncoupled[jj] = np.mean(empt_membIO_BA_uncoupled,axis=0)\n",
    "\n",
    "    meancur_BA_coupled[jj]=np.mean(I_BA_coupled,axis=0)\n",
    "    meancur_BA_uncoupled[jj]=np.mean(I_BA_uncoupled,axis=0)\n",
    "    meancur_AA_coupled[jj]=np.mean(I_AA_coupled,axis=0)\n",
    "    meancur_AA_uncoupled[jj]=np.mean(I_AA_uncoupled,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig, axs = subplots(5, 2,figsize=(20,10))\n",
    "p=q=0\n",
    "#figure(figsize=(20,20))\n",
    "#fig(figsize=(20,10))\n",
    "#print(meancur_BA_coupled)\n",
    "time = linspace(start=-time_before_spike*1e3,stop=time_after_spike*1e3,num=duration)\n",
    "for i in range(0,len(meancur_BA_coupled)):\n",
    "    #subplot(5,2,i+1)\n",
    "    axs[p,q].plot(time,meancur_BA_coupled[i], color='cyan')\n",
    "    axs[p,q].plot(time,meancur_AA_coupled[i], color='black')\n",
    "\n",
    "    axs[p,q].axvline(0, linewidth=2,color='r')\n",
    "    axs[p,q].set_title('Mean input current to PC' + str(i))\n",
    "    p=p+1\n",
    "    if i==4:\n",
    "        q=q+1\n",
    "        p=0\n",
    "    for ax in axs.flat:\n",
    "        ax.set(xlabel='time [ms]', ylabel='current [A]')\n",
    "    for ax in axs.flat:\n",
    "        ax.label_outer()\n",
    "    #axs.figsize((20,10))\n",
    "legend(['before','after','cs'], loc='lower left')\n",
    "show()\n",
    "\n",
    "fig, axs = subplots(5, 2,figsize=(20,10))\n",
    "p=q=0\n",
    "#figure(figsize=(20,20))\n",
    "#fig(figsize=(20,10))\n",
    "#print(meancur_BA_coupled)\n",
    "time = linspace(start=-time_before_spike*1e3,stop=time_after_spike*1e3,num=duration)\n",
    "for i in range(0,len(meancur_BA_coupled)):\n",
    "    #subplot(5,2,i+1)\n",
    "    axs[p,q].plot(time,meancur_BA_uncoupled[i], color='cyan')\n",
    "    axs[p,q].plot(time,meancur_AA_uncoupled[i], color='black')\n",
    "\n",
    "    axs[p,q].axvline(0, linewidth=2,color='r')\n",
    "    axs[p,q].set_title('Mean input current to PC' + str(i))\n",
    "    p=p+1\n",
    "    if i==4:\n",
    "        q=q+1\n",
    "        p=0\n",
    "    for ax in axs.flat:\n",
    "        ax.set(xlabel='time [ms]', ylabel='current [A]')\n",
    "    for ax in axs.flat:\n",
    "        ax.label_outer()\n",
    "    #axs.figsize((20,10))\n",
    "legend(['before','after','cs'], loc='lower left')\n",
    "show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# x.2 Plot the average membrane potential of the IO cells around the CS\n",
    "time = linspace(start=-time_before_spike*1e3,stop=time_after_spike*1e3,num=duration)\n",
    "\n",
    "big_picture='yes'\n",
    "for i in range(0,nrPC):\n",
    "    \n",
    "    if big_picture=='yes':\n",
    "        plt.figure()\n",
    "        #for k in range(0,2):\n",
    "        #subplot(2,1,1)\n",
    "        plt.title('Average Membrane Potential IO coupled'+str(connectionVectorIO[i])+' BA (top) AA(botom)')\n",
    "        plt.plot(time,mean_voltIO_BA_coupled[i])\n",
    "        #subplot(2,1,2)\n",
    "        #title('Average Membrane Potential IO'+str(connectionVectorIO[i])+' AA')\n",
    "        plt.plot(time,mean_voltIO_AA_coupled[i])\n",
    "        plt.xlabel('times [ms] - CS at 0')\n",
    "        plt.ylabel('membrane potential [V]')\n",
    "        #plt.ylim([-0.075,-0.04])\n",
    "        plt.legend(['before adaptation', 'after adaptation'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# x.2 Plot the average membrane potential of the IO cells around the CS\n",
    "time = linspace(start=-time_before_spike*1e3,stop=time_after_spike*1e3,num=duration)\n",
    "\n",
    "big_picture='yes'\n",
    "for i in range(0,nrPC):\n",
    "    \n",
    "    if big_picture=='yes':\n",
    "        plt.figure()\n",
    "        #for k in range(0,2):\n",
    "        #subplot(2,1,1)\n",
    "        plt.title('Average Membrane Potential IO uncoupled'+str(connectionVectorIO[i])+' BA (top) AA(botom)')\n",
    "        plt.plot(time,mean_voltIO_BA_uncoupled[i])\n",
    "        #subplot(2,1,2)\n",
    "        #title('Average Membrane Potential IO'+str(connectionVectorIO[i])+' AA')\n",
    "        plt.plot(time,mean_voltIO_AA_uncoupled[i])\n",
    "        plt.xlabel('times [ms] - CS at 0')\n",
    "        plt.ylabel('membrane potential [V]')\n",
    "        #plt.ylim([-0.075,-0.04])\n",
    "        plt.legend(['before adaptation', 'after adaptation'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "#print(y)\n",
    "y_post = np.append(np.zeros(1000),np.ones(49000))\n",
    "print(y_post)\n",
    "\n",
    "x=np.linspace(0,len(y_post),len(y_post))\n",
    "print(x)\n",
    "plt.subplots(3,1)\n",
    "#plt.title('distribution uncoupled')\n",
    "\n",
    "for k in range(1,2):\n",
    "    x=PV.freq_dep_PC[k]\n",
    "    x2 = PV.freq_dep_IO[k]\n",
    "    ax= plt.subplot(311)\n",
    "    plt.plot(x)\n",
    "    plt.plot(x2)\n",
    "    plt.subplot(312,sharex=ax)\n",
    "    plt.plot(PV.f_lt_PC_coupled[k],color='red')\n",
    "\n",
    "    plt.plot(PV.f_st_PC_coupled[k],color='black')\n",
    "    plt.ylim([80,110])\n",
    "    plt.xlim([10000,12000])\n",
    "    conn = [9,10, 18, 17, 0, 6, 5, 12, 16, 11]\n",
    "    plt.subplot(313,sharex=ax)\n",
    "    neu = SpikeTimes_STDP['PC_coupled'][conn[k]]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "    \n",
    "print(sum(PV.freq_dep_PC[0]))\n",
    "print(sum(P .freq_dep_IO[0]))\n",
    "#plt.xlim([0,30000])    \n",
    "#plt.legend(['w io coupled', 'w pc coupled'])\n",
    "plt.show()\n",
    "print('mean x',np.nanmean(x))\n",
    "print('std x',np.nanstd(x))\n",
    "plt.figure()\n",
    "#plt.title('distribution uncoupled')\n",
    "\n",
    "\n",
    "#plt.legend(['long term', 'short term'])\n",
    "plt.figure()\n",
    "plt.plot(PV.weight_IO[k],color='black')\n",
    "plt.plot(PV.weight_PC[k],color='red')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# figure 2 : COUPLED\n",
    "f, a = plt.subplots(6, 1,figsize=(15,15))\n",
    "\n",
    "# subplot 1: population frequency PC\n",
    "\n",
    "\n",
    "# subplot 3: population frequency IO\n",
    "\n",
    "# Raster plot PC\n",
    "for i in range(0,nrPC):\n",
    "    ax3 = plt.subplot(6,1,4)\n",
    "    ax3.set_ylabel('PC Index [-]')\n",
    "    neu = SpikeTimes_STDP['PC_coupled'][i]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "\n",
    "# Raster Plot DCN\n",
    "for i in range(0,nrDCN):\n",
    "    ax4 = plt.subplot(6,1,5, sharex=ax3)\n",
    "    ax4.set_ylabel('DCN Index [-]')\n",
    "    neu = SpikeTimes_STDP['DCN_coupled'][i]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "\n",
    "# Raster Plot IO\n",
    "for i in range(0,nrIO):\n",
    "    ax5 = plt.subplot(6,1,6, sharex=ax3)\n",
    "    ax5.set_ylabel('IO Index [-]')\n",
    "    neu = SpikeTimes_STDP['IO_coupled'][i]\n",
    "    lensim = len(neu)\n",
    "    yPC=np.ones((lensim,1))*i\n",
    "    plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "con=[9,10, 18, 17, 0, 6, 5, 12, 16, 11]\n",
    "for i in range(0,nrPC):\n",
    "    print('nr PC spikes', len(SpikeTimes_STDP['PC_uncoupled'][i]))\n",
    "    print('nr IO spikes connected to PC', len(SpikeTimes_STDP['IO_uncoupled'][con[i]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# LTP Coupled/Uncoupled\n",
    "ls = int(max(SpikeTimes_STDP['IO_coupled'][0]))+1\n",
    "static_w=0.52631579\n",
    "\n",
    "time = np.linspace(0,ls,lengthSim)\n",
    "fltp, altp = plt.subplots(4,1,figsize=(10,10))\n",
    "\n",
    "ax1 = plt.subplot(411)\n",
    "plt.title('LTP coupled')\n",
    "plt.plot(time,Input_STDP['I'][0]*static_w)\n",
    "#plt.xlabel('time [ms]')\n",
    "#ax1 = plt.subplot(422,sharex=ax1)\n",
    "#plt.plot(time,Input_STDP['I'][1]*0.47368421)\n",
    "\n",
    "ax3 = plt.subplot(4,1,2, sharex=ax1)\n",
    "ax3.set_ylabel('PC Index [-]')\n",
    "neu = SpikeTimes_STDP['PC_coupled'][0]\n",
    "lensim = len(neu)\n",
    "yPC=np.ones((lensim,1))*1\n",
    "plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "ax3 = plt.subplot(413, sharex=ax1)\n",
    "plt.plot(time,PV['weight_PC_coupled'][0])\n",
    "ax2 = plt.subplot(414, sharex=ax1)\n",
    "plt.plot(time,PV['weight_PC_coupled'][0])\n",
    "plt.plot(time,0.3*static_w*(newt)/60)\n",
    "plt.show()\n",
    "\n",
    "fltpu, altpu = plt.subplots(4,1,figsize=(10,10))\n",
    "\n",
    "ax1 = plt.subplot(411)\n",
    "plt.title('LTP uncoupled')\n",
    "plt.plot(time,Input_STDP['I'][0]*static_w)\n",
    "#plt.xlabel('time [ms]')\n",
    "#ax1 = plt.subplot(422,sharex=ax1)\n",
    "#plt.plot(time,Input_STDP['I'][1]*0.47368421)\n",
    "\n",
    "ax3 = plt.subplot(4,1,2, sharex=ax1)\n",
    "ax3.set_ylabel('PC Index [-]')\n",
    "neu = SpikeTimes_STDP['PC_uncoupled'][0]\n",
    "lensim = len(neu)\n",
    "yPC=np.ones((lensim,1))*1\n",
    "plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "\n",
    "ax3 = plt.subplot(413, sharex=ax1)\n",
    "plt.plot(time,PV['a_PC_uncoupled'][0])\n",
    "ax2 = plt.subplot(414, sharex=ax1)\n",
    "plt.plot(time,PV['weight_PC_uncoupled'][0])\n",
    "plt.plot(time,0.2*static_w*(time)/60)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "for p in range(0,nrIO):\n",
    "    freq=1/stat.isi(SpikeTimes_STDP['IO_coupled'][p])\n",
    "    plt.plot(SpikeTimes_STDP['IO_coupled'][p][1:],freq)\n",
    "\n",
    "plt.figure()   \n",
    "for p in range(0,nrIO):\n",
    "    freq=1/stat.isi(SpikeTimes_STDP['IO_uncoupled'][p])\n",
    "    plt.plot(SpikeTimes_STDP['IO_uncoupled'][p][1:],freq) \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# LTD \n",
    "fltd, altd = plt.subplots(4,1,figsize=(10,10))\n",
    "\n",
    "ax1 = plt.subplot(411)\n",
    "plt.title('LTD coupled')\n",
    "plt.plot(time,Input_STDP['I'][0]*static_w)\n",
    "for k in SpikeTimes_STDP['IO_coupled'][9]:\n",
    "    plt.axvline(x=k, color='r', linestyle='--')\n",
    "#plt.xlabel('time [ms]')\n",
    "#ax1 = plt.subplot(422,sharex=ax1)\n",
    "#plt.plot(time,Input_STDP['I'][1]*0.47368421)\n",
    "\n",
    "ax2 = plt.subplot(4,1,2, sharex=ax1)\n",
    "ax2.set_ylabel('IO Index [-]')\n",
    "neu = SpikeTimes_STDP['IO_coupled'][9]\n",
    "lensim = len(neu)\n",
    "yPC=np.ones((lensim,1))*1\n",
    "plt.scatter(x=neu,y=yPC,marker='|', color='black')\n",
    "\n",
    "\n",
    "ax3 = plt.subplot(413, sharex=ax1)\n",
    "plt.plot(time,PV['a_IO_coupled'][0])\n",
    "  \n",
    "\n",
    "ax4 = plt.subplot(414, sharex=ax1)\n",
    "plt.plot(time,PV['weight_IO_coupled'][0])\n",
    "plt.plot(time,-0.2*static_w*(time)/60)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ff, aa = plt.subplots(2,1, figsize=(10,10))\n",
    "#intr= [2.02, 1.94, 2.08, 1.98, 2.04, 1.96, 2.,   2.06, 1.9,  1.92]\n",
    "static_weights= [0.52631579, 0.47368421, 0.47058824, 0.46666667, 0.46153846, 0.45454545,\n",
    " 0.44444444, 0.42857143, 0.4, 0.33333333, 0.47368421, 0.52631579,0.52941176, 0.53333333, 0.53846154, 0.54545455, 0.55555556,\n",
    "                 0.57142857,0.6,0.66666667]\n",
    "labelsname_lf = ['PC' + str(p) + 'and static weight =' + str(static_weights[p]) for p in\n",
    "             range(0,nrPC)]\n",
    "labelsname_hf = ['PC' + str(p) + 'and static weight =' + str(static_weights[p+10]) for p in\n",
    "             range(0,nrPC)]\n",
    "for p in range(0,nrPC):\n",
    "    ax4 = plt.subplot(211)\n",
    "    plt.plot(time,PV['delta_weight_coupled'][p])\n",
    "    \n",
    "plt.legend(labelsname_lf)\n",
    "plt.title('low frequency')\n",
    "  \n",
    "for p in range(0,nrPC):\n",
    "    ax1 = plt.subplot(212)\n",
    "    plt.plot(time,PV['delta_weight_coupled'][p+10])\n",
    "plt.title('high freq')\n",
    "plt.legend(labelsname_hf)\n",
    "plt.show()\n",
    "labels = ['PC'+str(p) for p in range(0,nrPC)]\n",
    "#for i in range(0,nrPC):\n",
    "#    plt.figure()\n",
    "    #plt.title(labels[i])\n",
    "#    plt.plot(time,PV['delta_weight_uncoupled'][i], label='low freq')\n",
    "#    plt.plot(time,PV['delta_weight_uncoupled'][i+10], label='high freq')\n",
    "#    plt.legend(['2 Hz','20Hz'])\n",
    "#    plt.show()\n",
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "f, a = plt.subplots(4,1, figsize=(10,10))\n",
    "f.canvas.set_window_title('')\n",
    "static_weights= [0.52631579, 0.47368421, 0.47058824, 0.46666667, 0.46153846, 0.45454545,\n",
    " 0.44444444, 0.42857143, 0.4, 0.33333333, 0.47368421, 0.52631579,0.52941176, 0.53333333, 0.53846154, 0.54545455, 0.55555556,\n",
    "                 0.57142857,0.6,0.66666667]\n",
    "for i in range(0,nrIO):\n",
    "    ax1= plt.subplot(411)\n",
    "    plt.plot(time,PV['a_IO_coupled'][i])\n",
    "\n",
    "    ax2= plt.subplot(412,sharex=ax1)\n",
    "    plt.plot(time,PV['a_PC_coupled'][i])\n",
    "\n",
    "    ax3 = plt.subplot(413,sharex=ax1)\n",
    "    plt.plot(time,PV['a_IO_coupled'][i]+PV['a_PC_coupled'][i])\n",
    "    \n",
    "    ax4 = plt.subplot(414,sharex=ax1)\n",
    "    plt.plot(time, np.ones(len(time))*static_weights[i]+PV['a_IO_coupled'][i]+PV['a_PC_coupled'][i])\n",
    "ax1.title.set_text('aPC and aIO -uncoupled')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "All_data.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}