{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from sys import argv\n",
    "rootdir = argv[1]\n",
    "\n",
    "#############################\n",
    "#      FOR NOTEBOOK USE     #\n",
    "#     SET DIRECTORY HERE    #\n",
    "#                           #\n",
    "#rootdir = \"shmem_plot\"\n",
    "#                           #\n",
    "#############################\n",
    "\n",
    "print(\"Using root directory: {}\".format(rootdir))\n",
    "\n",
    "# Get the subdirs with the different tests\n",
    "subdirs = sorted([ name for name in os.listdir('{}'.format(rootdir)) if os.path.isdir(os.path.join('{}'.format(rootdir), name)) ])\n",
    "print(\"Available subdirs: {}\".format(subdirs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from sys import exit\n",
    "\n",
    "with open(\"{}/settings.json\".format(rootdir)) as json_file:\n",
    "    settings = json.load(json_file)\n",
    "\n",
    "print(\"Succesfully loaded JSON file\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load all files\n",
    "A group that will be one line in the summarizing graph is a *node-type* + *mode* combination. This group contains the variable *rate*. See the following three groups as example:\n",
    "\n",
    "* InfiniBand (RC): 1KHz, 10KHz, 50KHz, 100KHz\n",
    "* InfiniBand (UD): 1KHz, 10KHz, 50KHz, 100KHz\n",
    "* MQTT (UDP): 1KHz, 10KHz, 50KHz\n",
    "\n",
    "## Save characteristics of tests\n",
    "All important settings are contained in the name of the file. We will save them in a separate array. The structure of the name is as follows:\n",
    "\n",
    "```bash\n",
    "root_dir/benchmarks_${DATE}/${ID}_${MODE}-${VALUES IN SMP}-${RATE}-${SENT SMPS}\n",
    "```\n",
    "\n",
    "Thus, we will structure it in the settings_array as follows:\n",
    "\n",
    "* `settings_array[*][0] = ID`\n",
    "* `settings_array[*][1] = MODE`\n",
    "* `settings_array[*][2] = VALUES IN SAMPLE`\n",
    "* `settings_array[*][3] = RATE`\n",
    "* `settings_array[*][4] = TOTAL NUMBER OF SAMPLES`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import re\n",
    "\n",
    "# First, source log\n",
    "\n",
    "# Initialize arrays\n",
    "input_dataset = []\n",
    "output_dataset = []\n",
    "settings_array = []\n",
    "\n",
    "\n",
    "for i, subdir in enumerate(subdirs):\n",
    "    input_dataset.append([])\n",
    "    output_dataset.append([])\n",
    "\n",
    "    # Acquire node type from the directory\n",
    "    matchObj = re.match(r'(\\w*)_[A-Z]', subdir, re.M|re.I)\n",
    "    \n",
    "    # Fill value to array\n",
    "    if matchObj:\n",
    "        node_type = matchObj[1]\n",
    "\n",
    "    # Acquire all tests in that subdirectory\n",
    "    for walk_subdir, dirs, files in sorted(os.walk(\"{}/{}\".format(rootdir, subdir))):\n",
    "        input_dataset.append([])\n",
    "        output_dataset.append([])\n",
    "        settings_array.append([])\n",
    "        \n",
    "        for file in sorted(files):\n",
    "            ############################\n",
    "            ###### SAVE SETTINGS #######\n",
    "            ############################\n",
    "            temp_settings = []\n",
    "            temp_settings.append(node_type)\n",
    "        \n",
    "            # Match settings, as described above\n",
    "            matchObj = re.match(r'.*?(\\d*)_(\\w*)-(\\d*)-(\\d*)-(\\d*)_output.csv', file, re.M|re.I)\n",
    "\n",
    "            # Fill values to array\n",
    "            if matchObj:\n",
    "                for j in range(0,5):\n",
    "                    temp_settings.append(matchObj.group(j + 1))\n",
    "    \n",
    "                # Append array to big array\n",
    "                settings_array[i].append(temp_settings)\n",
    "            \n",
    "            ############################\n",
    "            ######### LOAD DATA ########\n",
    "            ############################\n",
    "      \n",
    "            # Regex to match input files\n",
    "            if re.match(r'.*?_input.csv', file, re.M|re.I):\n",
    "                # Load file \n",
    "                input_dataset[i].append(np.genfromtxt(\"{}/{}/{}\".format(rootdir, subdir, file), delimiter=','))\n",
    "                \n",
    "                print(\"Loaded input dataset from: {}\".format(file))\n",
    "\n",
    "            # Regex to match output files files\n",
    "            elif re.match(r'.*?_output.csv', file, re.M|re.I):\n",
    "                output_dataset[i].append(np.genfromtxt(\"{}/{}/{}\".format(rootdir, subdir, file), delimiter=','))\n",
    "                \n",
    "                print(\"Loaded output dataset from: {}\".format(file))\n",
    "\n",
    "    print(\"Settings for this subdirectory: \")\n",
    "    print(settings_array[i])\n",
    "    print(\"\\n\")\n",
    "\n",
    "    # Small sanity check, are arrays of the same size?\n",
    "    if len(input_dataset[i]) != len(output_dataset[i]):\n",
    "        print(\"Error: There should be as many input files as there are output files!\")\n",
    "        exit();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get missed steps from source node\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of missing samples at receive side\n",
    "missed_send_arr = []\n",
    "# Percentage of missed samples\n",
    "perc_miss_send_arr = []\n",
    "\n",
    "# Generate real total and number of missing samples.\n",
    "# Print percentage of missed samples\n",
    "for i, subdir in enumerate(subdirs):\n",
    "    missed_send_arr.append([])\n",
    "    perc_miss_send_arr.append([])\n",
    "    \n",
    "    for (j, csv_vec) in enumerate(input_dataset[i]):\n",
    "        # Get number of missing samples\n",
    "        missed_send_arr[i].append(int(settings_array[i][j][5]) - len(csv_vec))\n",
    "\n",
    "        # Take percentage\n",
    "        perc_miss_send_arr[i].append(round(missed_send_arr[i][j] / int(settings_array[i][j][5]) * 100, 2))\n",
    "        \n",
    "        print(\"Test {} ({}) is missing {} ({}%) of {} in in-file.\"\n",
    "              .format(settings_array[i][j][0], settings_array[i][j][2], missed_send_arr[i][j], \n",
    "                      perc_miss_send_arr[i][j], settings_array[i][j][5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get missed steps from destination node\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of missing samples at receive side\n",
    "missed_recv_arr = []\n",
    "# Percentage of missed samples\n",
    "perc_miss_recv_arr = []\n",
    "\n",
    "# Generate real total and number of missing samples.\n",
    "# Print percentage of missed samples\n",
    "for i, subdir in enumerate(subdirs):\n",
    "    missed_recv_arr.append([])\n",
    "    perc_miss_recv_arr.append([])\n",
    "\n",
    "    for (j, csv_vec) in enumerate(output_dataset[i]):\n",
    "\n",
    "        # Get number of missing samples\n",
    "        missed_recv_arr[i].append(int(settings_array[i][j][5]) - len(csv_vec))\n",
    "\n",
    "        # Take percentage\n",
    "        perc_miss_recv_arr[i].append(round(missed_recv_arr[i][j] / int(settings_array[i][j][5]) * 100, 2))\n",
    "\n",
    "        print(\"Test {} ({}) is missing {} ({}%) of {} in out-file.\"\n",
    "              .format(settings_array[i][j][0], settings_array[i][j][2], missed_recv_arr[i][j], \n",
    "                      perc_miss_recv_arr[i][j], settings_array[i][j][5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check first and second sample from receive & destination node\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check first and second sample\n",
    "\n",
    "first_second_smp_input = []\n",
    "first_second_smp_output = []\n",
    "\n",
    "for i, subdir in enumerate(subdirs):\n",
    "    first_second_smp_input.append([])\n",
    "    first_second_smp_output.append([])\n",
    "    \n",
    "    for (j, csv_vec) in enumerate(input_dataset[i]):\n",
    "        first_second_smp_input[i].append([csv_vec[0][3], csv_vec[1][3]])\n",
    "        print(\"First and second sample of test {} ({}): {} and {}, respectively\".format(settings_array[i][j][0],\n",
    "                                                                                   settings_array[i][j][2],\n",
    "                                                                                   int(first_second_smp_input[i][j][0]),\n",
    "                                                                                   int(first_second_smp_input[i][j][1])))\n",
    "\n",
    "    for (j, csv_vec) in enumerate(output_dataset[i]):\n",
    "        first_second_smp_output[i].append([csv_vec[0][3], csv_vec[1][3]])\n",
    "        print(\"First and second sample of test {} ({}): {} and {}, respectively\".format(settings_array[i][j][0],\n",
    "                                                                                   settings_array[i][j][2],\n",
    "                                                                                   int(first_second_smp_output[i][j][0]),\n",
    "                                                                                   int(first_second_smp_output[i][j][1])))\n",
    "        \n",
    "    print(\"\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare input and output data sets\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "missing_seq = []\n",
    "\n",
    "never_trans_total_arr = []\n",
    "never_trans_after_arr = []\n",
    "\n",
    "perc_never_trans_total_arr = []\n",
    "perc_never_trans_after_arr = []\n",
    "\n",
    "# Loop through input_array, since this is always bigger or equal to output array\n",
    "for i, subdir in enumerate(subdirs):\n",
    "    never_trans_total_arr.append([])\n",
    "    never_trans_after_arr.append([])\n",
    "    \n",
    "    perc_never_trans_total_arr.append([])\n",
    "    perc_never_trans_after_arr.append([])\n",
    "    \n",
    "    missing_seq.append([])\n",
    "    \n",
    "    for (j, csv_vec) in enumerate(input_dataset[i]):    \n",
    "        l = 0\n",
    "        missing_seq[i].append([])\n",
    "        for (k, line) in enumerate(csv_vec):      \n",
    "            try:\n",
    "                if line[3] != output_dataset[i][j][l][3]:\n",
    "                    missing_seq[i][j].append(line[3])\n",
    "                else:\n",
    "                    l += 1\n",
    "\n",
    "            except IndexError:\n",
    "                pass\n",
    "\n",
    "        never_trans_total_arr[i].append(len(missing_seq[i][j]))\n",
    "\n",
    "        never_trans_after_arr[i].append(np.sum(missing_seq[i][j] > first_second_smp_output[i][j][0]))\n",
    "\n",
    "        # Take percentage\n",
    "        perc_never_trans_total_arr[i].append(round(never_trans_total_arr[i][j] / int(settings_array[i][j][4]) * 100, 2))\n",
    "        perc_never_trans_after_arr[i].append(round(never_trans_after_arr[i][j] / int(settings_array[i][j][4]) * 100, 2))\n",
    "\n",
    "        print(\"Test {} ({}): {} ({}%) samples were never transferred \".format(settings_array[i][j][0],\n",
    "                                                                              settings_array[i][j][2],\n",
    "                                                                              never_trans_total_arr[i][j],\n",
    "                                                                              perc_never_trans_total_arr[i][j]))\n",
    "        print(\"{} ({}%) of these after the first sample occured in out-file.\".format(never_trans_after_arr[i][j],\n",
    "                                                                                     perc_never_trans_after_arr[i][j]))\n",
    "\n",
    "        print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate medians"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "medians = []\n",
    "upper_limit = []\n",
    "lower_limit = []\n",
    "\n",
    "for i, subdir in enumerate(subdirs):\n",
    "    medians.append([])\n",
    "    upper_limit.append([])\n",
    "    lower_limit.append([])\n",
    "\n",
    "    for (j, csv_vec) in enumerate(output_dataset[i]):  \n",
    "        medians[i].append(np.median(csv_vec.transpose()[2]) * 1e6)\n",
    "\n",
    "        if settings['median_plot']['enabled']:\n",
    "            # np.sort(recv[i][j] - enq_send[i][j])[int(np.size(recv[i][j]]) / 2)] would be the approximately the median\n",
    "            # Calculate upper 10% and lower 10%\n",
    "            upper_limit[i].append(abs(medians[i][j] - 1e6 * np.sort(csv_vec.transpose()[2])[int(9 * np.size(csv_vec.transpose()[2]) / 10)]))\n",
    "            lower_limit[i].append(abs(medians[i][j] - 1e6 * np.sort(csv_vec.transpose()[2])[int(1 * np.size(csv_vec.transpose()[2]) / 10)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Plot data\n",
    "### First, define some functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Fancy Box function we use\n",
    "def plot_fancy_box(bottom, height, ax):\n",
    "    top = bottom + height\n",
    "    \n",
    "    p = FancyBboxPatch((left, bottom),\n",
    "                       width,\n",
    "                       height,\n",
    "                       boxstyle=\"round, pad=0.005\",\n",
    "                       \n",
    "                       ec=\"#dbdbdb\", \n",
    "                       fc=\"white\", \n",
    "                       alpha=0.85,\n",
    "                       transform=ax.transAxes\n",
    "                      )\n",
    "    ax.add_patch(p)\n",
    "    \n",
    "    \n",
    "# Define \"find nearest\" function\n",
    "def find_nearest(array, value):\n",
    "    array = np.asarray(array)\n",
    "    idx = (np.abs(array - value)).argmin()\n",
    "    return array[idx], idx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import all necessary libraries to plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.font_manager import FontProperties\n",
    "from matplotlib.patches import FancyBboxPatch\n",
    "from matplotlib.ticker import MultipleLocator\n",
    "import pylab    \n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n",
    "import matplotlib as mpl\n",
    "import matplotlib.legend as mlegend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Start with histograms if they are enabled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if settings['histograms']['enabled']:\n",
    "    for i, subdir in enumerate(subdirs):\n",
    "        for (j, csv_vec) in enumerate(output_dataset[i]):\n",
    "            # Create figure\n",
    "            fig = plt.figure(num=None, figsize=(12, 4), dpi=90, facecolor='w', edgecolor='k')\n",
    "\n",
    "            # Add plot and set title\n",
    "            ax = fig.add_subplot(111)\n",
    "\n",
    "            # Set grid\n",
    "            ax.set_axisbelow(True)\n",
    "            ax.grid(True, linestyle='--')\n",
    "\n",
    "            x_limit = 0.00005\n",
    "            bins = np.arange(0, 50, 50 / 100)\n",
    "\n",
    "            # Data in plot\n",
    "            # http://www.color-hex.com/color-palette/33602\n",
    "            csv_vec_t = csv_vec.transpose()\n",
    "\n",
    "            ax.hist(csv_vec_t[2] * 1e6, label=settings['histograms']['labels'][0],\n",
    "                    edgecolor='black',\n",
    "                    bins=bins,\n",
    "                    color='#00549f')\n",
    "            ax.axvline(medians[i][j], color='red', linestyle='-', linewidth=1, alpha=0.85)\n",
    "\n",
    "            # Set axis and calculate values above limit\n",
    "            plt.xlim([0,x_limit])\n",
    "\n",
    "            ###################################\n",
    "            # SET TICKS #######################\n",
    "            ###################################\n",
    "            ticks = np.arange(0, x_limit * 1e6 + 1, 2)\n",
    "\n",
    "            nearest, nearest_idx = find_nearest(ticks, medians[i][j])\n",
    "            \n",
    "            ticks = np.append(ticks, medians[i][j])\n",
    "\n",
    "            # Explicitly set labels\n",
    "            labels = []\n",
    "\n",
    "            for value in ticks:\n",
    "                if value == nearest and np.abs(nearest - medians[i][j]) < 200:\n",
    "                    labels.append(\"\")\n",
    "                elif value == (medians[i][j]):\n",
    "                    labels.append(value)\n",
    "                else:\n",
    "                    labels.append(str(int(value)))\n",
    "\n",
    "            plt.yticks(fontsize=10, family='monospace')\n",
    "            plt.xticks(ticks, labels, fontsize=10, family='monospace', rotation=30, horizontalalignment='right', rotation_mode=\"anchor\")\n",
    "\n",
    "            for value in ax.get_xticklabels():\n",
    "                try:\n",
    "                    if int(float(value.get_text())) == int(medians[i][j]):\n",
    "                        value.set_color('red')\n",
    "                except ValueError:\n",
    "                    # We got some empty values. Ignore them\n",
    "                    pass\n",
    "\n",
    "            minorLocator = MultipleLocator(1)\n",
    "            ax.xaxis.set_minor_locator(minorLocator)\n",
    "\n",
    "            ###################################\n",
    "            # CONFIGURE AXIS ##################\n",
    "            ###################################\n",
    "            # Set labels\n",
    "            ax.set_xlabel(settings['histograms']['axis_labels']['x'], fontsize=10, family='monospace', labelpad = 4)\n",
    "            ax.set_ylabel(settings['histograms']['axis_labels']['y'], fontsize=10, family='monospace', labelpad = 6)\n",
    "            \n",
    "            # Set scale\n",
    "            ax.set_yscale('log')\n",
    "\n",
    "            ###################################\n",
    "            # CREATE TEXTBOXES ################\n",
    "            ###################################\n",
    "            off_bigger_50us = round((np.size(csv_vec_t[2][csv_vec_t[2] > x_limit]) / np.size(csv_vec_t[2])) * 100, 2)\n",
    "\n",
    "            offset_text = '$\\mathtt{{t_{{lat}}>50µs: }}${0: >5.2f}% ($\\mathtt{{\\\\max\\\\,t_{{lat}}}}$: {1:>7.2f}µs)'.format(off_bigger_50us, round(np.max(csv_vec_t[2]) * 1e6, 2))\n",
    "\n",
    "            # Create text for missed steps\n",
    "            missed_text  = ' in: {0:6d} ({1:5.2f}%)\\n'.format(missed_send_arr[i][j], perc_miss_send_arr[i][j])\n",
    "            missed_text += 'out: {0:6d} ({1:5.2f}%)'.format(missed_recv_arr[i][j], perc_miss_recv_arr[i][j])\n",
    "\n",
    "            # Create text for missed steps\n",
    "            never_transferred_text  = 'total: {0:5d} ({1:5.2f}%)\\n'.format(never_trans_total_arr[i][j], perc_never_trans_total_arr[i][j])\n",
    "            never_transferred_text += 'while connected: {0:5d} ({1:5.2f}%)'.format(never_trans_after_arr[i][j], perc_never_trans_after_arr[i][j])\n",
    "\n",
    "            # Set font properties for headers and text\n",
    "            font_header = FontProperties()\n",
    "            font_header.set_family('monospace')\n",
    "            font_header.set_weight('bold')\n",
    "            font_header.set_size(9.5)\n",
    "\n",
    "            font_text = FontProperties()\n",
    "            font_text.set_size(9.5)\n",
    "            font_text.set_family('monospace')\n",
    "\n",
    "            # Set box constraints for wrapper and plot wrapper\n",
    "            left, width = .673, .33\n",
    "            right = left + width\n",
    "\n",
    "            plot_fancy_box(bottom = 0.46, height = 0.65, ax = ax)\n",
    "\n",
    "            # Set box constraints for text boxes\n",
    "            left, width = .685, .30\n",
    "            right = left + width\n",
    "\n",
    "            # Offset boxes\n",
    "            plot_fancy_box(bottom = 0.9085, height = 0.085, ax = ax)\n",
    "\n",
    "            ax.text(right, 0.975, offset_text,\n",
    "                    verticalalignment='top', horizontalalignment='right',\n",
    "                    transform=ax.transAxes,\n",
    "                    color='black', fontproperties = font_text)\n",
    "\n",
    "            # Missed steps\n",
    "            plot_fancy_box(bottom = 0.695, height = 0.18, ax = ax)\n",
    "\n",
    "            ax.text(right, 0.868, \"missing samples:\",\n",
    "                    verticalalignment='top', horizontalalignment='right',\n",
    "                    transform=ax.transAxes,\n",
    "                    color='black', fontproperties = font_header)\n",
    "            ax.text(right, 0.804, missed_text,\n",
    "                    verticalalignment='top', horizontalalignment='right',\n",
    "                    transform=ax.transAxes,\n",
    "                    color='black', fontproperties = font_text)\n",
    "\n",
    "            # Never transferred\n",
    "            plot_fancy_box(bottom = 0.487, height = 0.175, ax = ax)\n",
    "\n",
    "            ax.text(right, 0.657, \"samples not transmitted:\",\n",
    "                    verticalalignment='top', horizontalalignment='right',\n",
    "                    transform=ax.transAxes,\n",
    "                    color='black', fontproperties = font_header)\n",
    "            ax.text(right, 0.593, never_transferred_text,\n",
    "                    verticalalignment='top', \n",
    "                    horizontalalignment='right',\n",
    "                    transform=ax.transAxes,\n",
    "                    color='black', fontproperties = font_text)\n",
    "\n",
    "\n",
    "            ###################################\n",
    "            # SAVE PLOT #######################\n",
    "            ###################################\n",
    "            plt.minorticks_on()\n",
    "            plt.tight_layout()\n",
    "\n",
    "            fig.savefig('{}/{}_{}_{}i_{}j.pdf'.format(rootdir, \n",
    "                                                      settings_array[i][j][0], \n",
    "                                                      settings_array[i][j][2], i, j),\n",
    "                        format='pdf')        \n",
    "\n",
    "    ###################################\n",
    "    # CREATE HISTOGRAM LEGEND #########\n",
    "    ###################################\n",
    "    # create a second figure for the legend\n",
    "    figLegend = pylab.figure(figsize = settings['histograms']['dimensions']['legend'])\n",
    "\n",
    "    # produce a legend for the objects in the other figure\n",
    "    pylab.figlegend(*ax.get_legend_handles_labels(), loc = 'upper left',\n",
    "                    prop={'family':'monospace', 'size':'8'}, \n",
    "                    ncol=settings['histograms']['legend_columns'])\n",
    "    \n",
    "    figLegend.savefig(\"{}/legend_histogram.pdf\".format(rootdir), format='pdf')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if settings['median_plot']['enabled']:\n",
    "    # Create figure and axis\n",
    "    fig_median = plt.figure(num=None, figsize=(12, 4), dpi=90, facecolor='w', edgecolor='k')\n",
    "    ax_median = fig_median.add_subplot(111)\n",
    "\n",
    "    for i, subdir in enumerate(subdirs):\n",
    "\n",
    "        ###################################\n",
    "        # CREATE MEDIAN PLOT ##############\n",
    "        ###################################\n",
    "        x_data = np.array([])\n",
    "        for k in range(0, len(medians[i])):\n",
    "            x_data = np.append(x_data, k)\n",
    "\n",
    "        ax_median.errorbar(x_data, medians[i], yerr=[lower_limit[i], upper_limit[i]],\n",
    "                           capsize = 3.7, elinewidth = 1, markeredgewidth = 1, \n",
    "                           marker='v', zorder = 2 + i, color=settings['median_plot']['colors'][i],\n",
    "                           label=settings['median_plot']['labels'][i])\n",
    "\n",
    "        ###################################\n",
    "        # PRINT MISSED STEPS ##############\n",
    "        ###################################\n",
    "        if settings['median_plot']['print_missed_steps']:\n",
    "            for l, median in enumerate(medians[i]):\n",
    "                \n",
    "                p = FancyBboxPatch((x_data[l] + 0.07, median + 0.08), 0.345, 0.26, boxstyle=\"round, pad=0.005\",\n",
    "                                    ec=\"#dbdbdb\", fc=\"white\", alpha=0.85)\n",
    "                ax_median.add_patch(p)\n",
    "                \n",
    "                ax_median.text(x_data[l] + 0.1, median + 0.15, \"{: >4.2f}%\".format(perc_miss_recv_arr[i][l]))\n",
    "                \n",
    "            # Create bbox patch for legend\n",
    "            #p = FancyBboxPatch((0, 0), 5, 1, boxstyle=\"round, pad=0.5\", ec=\"#dbdbdb\", fc=\"white\", alpha=0.85)\n",
    "        \n",
    "            handles = []\n",
    "            handles.append(p)\n",
    "            text= '% of samples missed by signal generator'\n",
    "            leg2 = mlegend.Legend(ax_median, handles, labels=[text], loc = 'upper left', ncol=1,\n",
    "                                  prop={'family':'monospace', 'size':'8'})\n",
    "\n",
    "  \n",
    "        \n",
    "    ###################################\n",
    "    # SET AXIS OF MEDIAN PLOT #########\n",
    "    ###################################\n",
    "    ax_median.set_xticks(np.arange(0, len(settings['median_plot']['ticks']['x']), 1))\n",
    "    ax_median.set_xticklabels(settings['median_plot']['ticks']['x'])\n",
    "    \n",
    "    if settings['median_plot']['log_scale']:\n",
    "        ax_median.set_yscale('log')\n",
    "    else:\n",
    "        ax_median.set_ylim([settings['median_plot']['ticks']['y'][0], settings['median_plot']['ticks']['y'][-1]])\n",
    "        ax_median.set_yticks(settings['median_plot']['ticks']['y'])\n",
    "        \n",
    "    ax_median.set_xlabel(settings['median_plot']['axis_labels']['x'], fontsize=11, family='monospace', labelpad=6)\n",
    "    ax_median.set_ylabel(settings['median_plot']['axis_labels']['y'], fontsize=11, family='monospace', labelpad=6)\n",
    "    ax_median.set_axisbelow(True)\n",
    "    ax_median.grid(True, linestyle='--')\n",
    "\n",
    "    ax_median.yaxis.grid(True, linestyle='-', which='major', color='black', alpha=0.8)\n",
    "    ax_median.yaxis.grid(True, linestyle='--', which='minor', color='lightgrey', alpha=0.3)\n",
    "\n",
    "    ###################################\n",
    "    # EXPORT MEDIANS AND CREATE #######\n",
    "    # LEGEND OF MEDIAN TABLE ##########\n",
    "    ###################################\n",
    "    plt.tight_layout()\n",
    "    fig_median.savefig('{}/median_graph.pdf'.format(rootdir), dpi=600, format='pdf', bbox_inches='tight')\n",
    "\n",
    "    # create a second figure for the legend\n",
    "    figLegend = pylab.figure(figsize = settings['median_plot']['dimensions']['legend'])\n",
    "    \n",
    "\n",
    "    leg_temp = pylab.figlegend(*ax_median.get_legend_handles_labels(), loc = 'upper left', labelspacing=1.2,\n",
    "                    prop={'family':'monospace', 'size':'8'}, ncol=settings['median_plot']['legend_columns'])\n",
    "    \n",
    "    if settings['median_plot']['print_missed_steps']:\n",
    "        leg_temp._legend_box._children.append(leg2._legend_box._children[1])\n",
    "        leg_temp._legend_box.align=\"left\"\n",
    "        \n",
    "    figLegend.savefig(\"{}/legend_median_plot.pdf\".format(rootdir), format='pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create 3D-Plot if enabled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if settings['3d_plot']['enabled']:\n",
    "    for i, subdir in enumerate(subdirs):\n",
    "        fig_3d = plt.figure(num=None, figsize=(16, 7), dpi=90, facecolor='w', edgecolor='k')\n",
    "        ax_3d = fig_3d.gca(projection='3d')\n",
    "\n",
    "        # Make data.\n",
    "        X = np.array([])\n",
    "        for k in range(0, len(settings['3d_plot']['ticks']['x'])):\n",
    "            X = np.append(X, k)\n",
    "\n",
    "        Y = np.array([])\n",
    "        for k in range(0, len(settings['3d_plot']['ticks']['y'])):\n",
    "            Y = np.append(Y, k)\n",
    "\n",
    "        X, Y = np.meshgrid(X, Y)\n",
    "\n",
    "        Z = np.array([])\n",
    "        for k in range(0, len(settings['3d_plot']['ticks']['y'])):\n",
    "            for l in range(0, len(settings['3d_plot']['ticks']['x'])):\n",
    "                Z = np.append(Z, medians[i][k * len(settings['3d_plot']['ticks']['x']) + l])\n",
    "                \n",
    "        ###################################\n",
    "        # PRINT MISSED STEPS ##############\n",
    "        ###################################\n",
    "        \n",
    "        props = dict(boxstyle='round', facecolor='white', alpha=0.8)\n",
    "        \n",
    "        # if more than 5% of the samples were missed, print it to figure\n",
    "        for k in range(0, len(input_dataset[i])):\n",
    "            if perc_miss_send_arr[i][k] > 5:\n",
    "                x = k % (len(settings['3d_plot']['ticks']['x']))\n",
    "                y = np.floor(k / (len(settings['3d_plot']['ticks']['y'])))\n",
    "                z = Z[k]\n",
    "                \n",
    "                x_delta = 0.65\n",
    "                y_delta = 0.65\n",
    "                z_delta = 0.5 * (Z[k] - Z[k - len(settings['3d_plot']['ticks']['y'])])\n",
    "                ax_3d.text(x - x_delta, y - y_delta, z - z_delta, \"{: >4.2f}%\".format(perc_miss_send_arr[i][k]), \n",
    "                           fontsize=11, family='monospace', color='red', bbox=props)\n",
    "\n",
    "        Z = np.split(Z, len(settings['3d_plot']['ticks']['y']))\n",
    "\n",
    "        # Plot the surface.\n",
    "        surf = ax_3d.plot_surface(X, Y, Z, cmap=cm.Blues, linewidth=135,\n",
    "                                  antialiased=False, shade=True)\n",
    "        ax_3d.plot_wireframe(X, Y, Z, 10, lw=1, colors=\"k\", linestyles=\"solid\")\n",
    "\n",
    "        # Customize the z axis.\n",
    "        ax_3d.set_zlim(0, np.max(np.ceil(Z)))\n",
    "        ax_3d.zaxis.set_major_locator(LinearLocator(10))\n",
    "\n",
    "        ax_3d.set_xlabel(settings['3d_plot']['axis_labels']['x'], fontsize=11, family='monospace', labelpad=14)\n",
    "        ax_3d.set_ylabel(settings['3d_plot']['axis_labels']['y'], fontsize=11, family='monospace', labelpad=8)\n",
    "        ax_3d.set_zlabel(settings['3d_plot']['axis_labels']['z'], fontsize=11, family='monospace', labelpad=8)\n",
    "\n",
    "        ax_3d.set_xticks(np.arange(0, len(settings['3d_plot']['ticks']['x']), 1))\n",
    "        ax_3d.set_xticklabels(settings['3d_plot']['ticks']['x'])\n",
    "\n",
    "        ax_3d.set_yticklabels(settings['3d_plot']['ticks']['y'])\n",
    "        ax_3d.set_zticks(np.arange(0, len(settings['3d_plot']['ticks']['z']), 1))\n",
    "\n",
    "        x = np.argmin(Z) % (len(settings['3d_plot']['ticks']['x']))\n",
    "        y = np.floor(np.argmin(Z) / (len(settings['3d_plot']['ticks']['y'])))\n",
    "        z = np.min(Z)\n",
    "        \n",
    "        ax_3d.plot([x,x],[y,y],z, marker='v', color = 'green', markersize=15, label=\"Minimum: \"+str(z)+ \" µs\")\n",
    "\n",
    "        x = np.argmax(Z) % (len(settings['3d_plot']['ticks']['x']))\n",
    "        y = np.floor(np.argmax(Z) / (len(settings['3d_plot']['ticks']['y'])))\n",
    "        z = np.max(Z)\n",
    "        \n",
    "        ax_3d.plot([x,x],[y,y],z, marker='^', color = 'red', markersize=15, label=\"Maximum: \"+str(z)+ \" µs\")\n",
    "\n",
    "        norm = mpl.colors.Normalize(vmin=np.min(Z), vmax=np.max(Z))\n",
    "        cb = fig_3d.colorbar(surf, shrink=0.8, aspect=10, fraction=0.1, norm=norm)\n",
    "        cb.set_label(settings['3d_plot']['axis_labels']['z'], fontsize=11, family='monospace', labelpad=8)\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "        fig_3d.savefig('{}/median_3d_graph_{}.pdf'.format(rootdir, settings_array[i][0][2]), dpi=600, format='pdf')\n",
    "\n",
    "        \n",
    "        ###################################\n",
    "        # CREATE LEGEND ###################\n",
    "        ###################################\n",
    "        # create a second figure for the legend\n",
    "        figLegend = pylab.figure(figsize = settings['3d_plot']['dimensions']['legend'])\n",
    "\n",
    "        # The markers are too big, so lets create smaller markers\n",
    "        ax_custom = figLegend.add_subplot(111)\n",
    "        ax_custom.plot(0,0, marker='v', color = 'green', label=\"$\\\\min\\\\,\\\\tilde{t}_{lat}$: \"+str(np.min(Z))+ \" µs\", markersize=8, linestyle = 'None')\n",
    "        ax_custom.plot(0,0, marker='^', color = 'red', label=\"$\\\\max\\\\,\\\\tilde{t}_{lat}$: \"+str(np.max(Z))+ \" µs\", markersize=8, linestyle = 'None')\n",
    "        ax_custom.set_visible(False)\n",
    "\n",
    "        # Create bbox patch for legend\n",
    "        p = FancyBboxPatch((0, 0), 5, 1, boxstyle=\"round, pad=0.5\", ec=\"#dbdbdb\", fc=\"white\", alpha=0.85)\n",
    "        \n",
    "        handles = []\n",
    "        handles.append(p)\n",
    "        text= '% of samples missed by signal generator'\n",
    "        leg2 = mlegend.Legend(ax_custom, handles, labels=[text], loc = 'upper left', ncol=1,\n",
    "                              prop={'family':'monospace', 'size':'8'})\n",
    "\n",
    "        # Extract handles from pseudo plot\n",
    "        handles, labels = ax_custom.get_legend_handles_labels()\n",
    "\n",
    "        leg_temp = pylab.figlegend(handles, labels, loc = 'upper left', labelspacing=1.2,\n",
    "                        prop={'family':'monospace', 'size':'8'}, ncol=settings['3d_plot']['legend_columns'])\n",
    "        \n",
    "        # Concat handles\n",
    "        leg_temp._legend_box._children.append(leg2._legend_box._children[1])\n",
    "        leg_temp._legend_box.align=\"left\"\n",
    "        \n",
    "        # Save figure\n",
    "        figLegend.savefig(\"{}/legend_median_3d_plot_{}.pdf\".format(rootdir, settings_array[i][0][2]), format='pdf')"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
