{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measuremments with Representative"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, sys\n",
    "lib_path = os.path.abspath(os.path.join('..', '..', 'utils'))\n",
    "sys.path.append(lib_path)\n",
    "from GraphType import GraphStat\n",
    "from GraphType import GraphCollection\n",
    "from scipy import stats\n",
    "from ipywidgets import interact, fixed, interactive\n",
    "import readCSV as reader\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import numpy as np\n",
    "import constants\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Record the distances of different metrics using a representative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GraphDistanceWithRep:\n",
    "    #init with a graph stat and a collection of graph stats\n",
    "    def __init__(self, graphStat, rep):\n",
    "        self.graph = graphStat\n",
    "        self.rep = rep\n",
    "        self.out_d_distance, _ = stats.ks_2samp(graphStat.out_d, rep.out_d)\n",
    "        self.na_distance,_ = stats.ks_2samp(graphStat.na, rep.na)\n",
    "        self.mpc_distance,_ = stats.ks_2samp(graphStat.mpc, rep.mpc)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Find the median ks distance of the same number of nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_median(x, metric_distances):\n",
    "    distance_dic = {}\n",
    "    for index, num_of_nodes in enumerate(x):\n",
    "        if num_of_nodes[0] not in distance_dic:\n",
    "            distance_dic[num_of_nodes[0]] = []\n",
    "        distance_dic[num_of_nodes[0]].append(metric_distances[index])\n",
    "    median_x = []\n",
    "    y = []\n",
    "    for num_of_nodes, distances in distance_dic.items():\n",
    "        median_x.append(num_of_nodes)\n",
    "        y.append(np.median(distances))\n",
    "    order = np.argsort(median_x)\n",
    "    median_x = np.array(median_x)[order]\n",
    "    median_y = np.array(y)[order]\n",
    "    return median_x, median_y\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Plot Diagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# metric_selector: GraphDistance -> float\n",
    "def plot(infos, lines, id, metric_selector,colors, title, foldername):\n",
    "    metric_distances = retrive_info_from_list(metric_selector, list(infos.values()))\n",
    "    x = retrive_info_from_list(lambda a : a.graph.num_nodes, list(infos.values()))\n",
    "    graph = plt.figure(id,figsize=(18, 10))\n",
    "    plt.title(title)\n",
    "    plt.plot(x, metric_distances, color='red', linestyle='', marker='o',alpha=0.7)\n",
    "    #plot ks distance median\n",
    "    median_x, median_y = find_median(x, metric_distances)\n",
    "    plt.plot(median_x, median_y, color='black',marker='o')\n",
    "    for i in range(0, len(lines)):\n",
    "        line_infos = retrive_info_from_list(lambda a: infos[a], lines[i])\n",
    "        line_y = retrive_info_from_list(metric_selector, line_infos)\n",
    "        line_x = retrive_info_from_list(lambda a : a.graph.num_nodes, line_infos)\n",
    "        plt.plot(line_x, line_y, marker='o', color=colors[i])\n",
    "    mkdir_p(foldername)\n",
    "    plt.savefig(fname = foldername+title+'.jpg', dpi=150)\n",
    "    #graph.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Retrieve information from a list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def retrive_info_from_list(selector, distances):\n",
    "    return list(map(selector, distances))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readStats(path, numModels):\n",
    "    names =  reader.readmultiplefiles(path, numModels, False)\n",
    "    stats = []\n",
    "    for name in names:\n",
    "        stats.append(GraphStat(name))\n",
    "    return stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calDistanceDic(stats, rep):\n",
    "    dic = {}\n",
    "    for info in stats:\n",
    "        info = GraphDistanceWithRep(info, rep)\n",
    "        dic[info.graph.id] = info\n",
    "    return dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createRandomColors(size):\n",
    "    #generate random color for each line\n",
    "    colors = []\n",
    "\n",
    "    for i in range(0, size):\n",
    "        color = \"#%06x\" % random.randint(0, 0xFFFFFF)\n",
    "        colors.append(color)\n",
    "    return colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createSelectionWidge(options):\n",
    "    w = widgets.SelectMultiple(\n",
    "        options = options,\n",
    "        value = [],\n",
    "        description='Trajectory:',\n",
    "        disabled=False,\n",
    "    )\n",
    "    return w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mkdir_p(mypath):\n",
    "    '''Creates a directory. equivalent to using mkdir -p on the command line'''\n",
    "\n",
    "    from errno import EEXIST\n",
    "    from os import makedirs,path\n",
    "\n",
    "    try:\n",
    "        makedirs(mypath)\n",
    "    except OSError as exc: # Python >2.5\n",
    "        if exc.errno == EEXIST and path.isdir(mypath):\n",
    "            pass\n",
    "        else: raise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metrics During GenerationPlots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read Human Representatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Read Models\n",
    "#read representative\n",
    "human_rep = GraphStat(constants.HUMAN_OUT_D_REP)\n",
    "human_na = GraphStat(constants.HUMAN_NA_REP)\n",
    "human_mpc = GraphStat(constants.HUMAN_MPC_REP)\n",
    "\n",
    "# assign rep distributions to human_rep\n",
    "human_rep.na = human_na.na\n",
    "human_rep.mpc = human_mpc.mpc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Viatra No Constraint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read generated models\n",
    "viatra_no_con_stats = readStats('../input/viatra_nocon_output/', 5000)\n",
    "viatra_no_con_dic = calDistanceDic(viatra_no_con_stats, human_rep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "filenames = reader.readmultiplefiles('../input/viatra_nocon_output/trajectories/', 15, False)\n",
    "trajectories = {}\n",
    "for name in filenames:\n",
    "    trajectories[name] = reader.readTrajectory(name)\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a8471e4dd66a47ecb6abb2371be43321",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={'../input/viatra_nocon_output/traject…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(viatra_no_con_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out degree', '../output/viatra_no_constraints/')\n",
    "interact(plot_out_degree, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ad6e466cc3fe44d393d2c82d48244d83",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={'../input/viatra_nocon_output/traject…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_na(lines)>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_na(lines):\n",
    "    plot(viatra_no_con_dic, lines, 0, lambda a: a.na_distance, colors, 'node activity', '../output/viatra_no_constraints/')\n",
    "interact(plot_out_na, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d88ebc8e4062473a96ac35fe800028ef",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={'../input/viatra_nocon_output/traject…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_mpc(lines)>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_mpc(lines):\n",
    "    plot(viatra_no_con_dic, lines, 0, lambda a: a.mpc_distance, colors, 'MPC', '../output/viatra_no_constraints/')\n",
    "interact(plot_out_mpc, lines=w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Viatra with constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "viatra_con_stats = readStats('../input/viatra_con_output/',5000)\n",
    "viatra_con_dic = calDistanceDic(viatra_con_stats, human_rep)\n",
    "\n",
    "# trajectories and colors\n",
    "trajectories = {}\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1eb2ba5848a048389bca8d804fc8340a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(viatra_con_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out degree', '../output/viatra_constraints/')\n",
    "interact(plot_out_degree, lines=[[]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6e5840f7a5ad4515bce9080088b644f2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_na(lines)>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_na(lines):\n",
    "    plot(viatra_con_dic, lines, 0, lambda a: a.na_distance, colors, 'node activity', '../output/viatra_constraints/')\n",
    "interact(plot_na, lines=[[]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9e30f267b092491ba1ffe8f83c5f68ce",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_mpc(lines)>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_mpc(lines):\n",
    "    plot(viatra_con_dic, lines, 0, lambda a: a.mpc_distance, colors, 'MPC', '../output/viatra_constraints/')\n",
    "interact(plot_mpc, lines=[[]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Controlled RandomEMF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_emf_stats = readStats('../input/random_emf_output/',5000)\n",
    "random_emf_dic = calDistanceDic(random_emf_stats, human_rep)\n",
    "\n",
    "# trajectories and colors\n",
    "trajectories = {}\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cc1f64c92e814c32a81cd5ec5d4e50dc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(random_emf_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out degree', '../output/random_emf/')\n",
    "interact(plot_out_degree, lines=[[]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "75021f4f68db4a809ce7c86c0d25ef1b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_node_activity(lines)>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_node_activity(lines):\n",
    "    plot(random_emf_dic, lines, 0, lambda a: a.na_distance, colors, 'node activity', '../output/random_emf/')\n",
    "interact(plot_node_activity, lines=[[]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "86f5c376905a4759a7b44ad52804424d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_mpc(lines)>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_mpc(lines):\n",
    "    plot(random_emf_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/random_emf/')\n",
    "interact(plot_mpc, lines=[[]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Controlled Viatra with MPC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "con_viatra_stats = readStats('../input/controled_viatra_mpc/',5000)\n",
    "con_viatra_dic = calDistanceDic(con_viatra_stats, human_rep)\n",
    "\n",
    "# trajectories and colors\n",
    "trajectories = {}\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "57ba4d8443c145ad845fb862e3ef7519",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out_degree', '../output/controled_viatra_with_mpc/')\n",
    "interact(plot_out_degree, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c020ecb466c14f3ca1bfc0fd2fe03b7b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_na(lines)>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_na(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.na_distance, colors, 'Node Activity', '../output/controled_viatra_with_mpc/')\n",
    "interact(plot_na, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2165668057fd47ad92459e749ec68bad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_mpc(lines)>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_mpc(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/controled_viatra_with_mpc/')\n",
    "interact(plot_mpc, lines=w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Pseudo) Random EMF instantiator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_emf_stats = readStats('../input/real_random_output/',5000)\n",
    "random_emf_dic = calDistanceDic(random_emf_stats, human_rep)\n",
    "\n",
    "# trajectories and colors\n",
    "trajectories = {}\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "907d7824033b4dfe980c391db0da63eb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(random_emf_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out_degree', '../output/random_emf_instantiator/')\n",
    "interact(plot_out_degree, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "08a32c21d0b64217a556715caa8db7b5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_na(lines)>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_na(lines):\n",
    "    plot(random_emf_dic, lines, 0, lambda a: a.na_distance, colors, 'Node Activity', '../output/random_emf_instantiator/')\n",
    "interact(plot_na, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9dad041ff05d46ce969cfacb07c2ba98",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_mpc(lines)>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_mpc(lines):\n",
    "    plot(random_emf_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/random_emf_instantiator/')\n",
    "interact(plot_mpc, lines=w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Controlled Viatra with Out Degree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "con_viatra_stats = readStats('../input/controlled_viatra_out_degree/',10000)\n",
    "con_viatra_dic = calDistanceDic(con_viatra_stats, human_rep)\n",
    "\n",
    "# trajectories and colors\n",
    "trajectories = {}\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cd77560284d9419daec57192a64b75ec",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out_degree', '../output/controled_viatra_with_out_degree/')\n",
    "interact(plot_out_degree, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ab11afebf7674cebae8d7318c661cf3c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_na(lines)>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_na(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.na_distance, colors, 'Node Activity', '../output/controled_viatra_with_out_degree/')\n",
    "interact(plot_na, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c20b42abcba646c18d7caa6eeb54c403",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_mpc(lines)>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_mpc(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/controled_viatra_with_out_degree/')\n",
    "interact(plot_mpc, lines=w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Controlled Viatra with Node Activity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "con_viatra_stats = readStats('../input/controlled_viatra_out_degree_node_activity/',20000)\n",
    "con_viatra_dic = calDistanceDic(con_viatra_stats, human_rep)\n",
    "\n",
    "# trajectories and colors\n",
    "trajectories = {}\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "902b580a11fa4c8db9d03508ad629067",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out_degree', '../output/controled_viatra_with_node_activity/')\n",
    "interact(plot_out_degree, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "851b567e745940288b577d9bd27e6f08",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_na(lines)>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_na(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.na_distance, colors, 'Node Activity', '../output/controled_viatra_with_node_activity/')\n",
    "interact(plot_na, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7de173291f394b10b5113e3312b7b2e1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_mpc(lines)>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_mpc(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/controled_viatra_with_node_activity/')\n",
    "interact(plot_mpc, lines=w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random EMF With Normal(2,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_emf_stats = readStats('../input/random_emf_normal/',6000)\n",
    "random_emf_dic = calDistanceDic(random_emf_stats, human_rep)\n",
    "\n",
    "# trajectories and colors\n",
    "trajectories = {}\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6b9ee873d9ca41649cf05f3b713d9142",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(random_emf_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out degree', '../output/random_emf_normal/')\n",
    "interact(plot_out_degree, lines=[[]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "88f258a0b0ac4417aba320beca7508cf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_node_activity(lines)>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_node_activity(lines):\n",
    "    plot(random_emf_dic, lines, 0, lambda a: a.na_distance, colors, 'node activity', '../output/random_emf_normal/')\n",
    "interact(plot_node_activity, lines=[[]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d71cf26018184ee6953c50b74908f52d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_mpc(lines)>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_mpc(lines):\n",
    "    plot(random_emf_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/random_emf_normal/')\n",
    "interact(plot_mpc, lines=[[]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "con_viatra_stats = readStats('../input/controlled_viatra_all/',20000)\n",
    "con_viatra_dic = calDistanceDic(con_viatra_stats, human_rep)\n",
    "\n",
    "# trajectories and colors\n",
    "trajectories = {}\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "db15ac26aad84683b9da99fc54749850",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out_degree', '../output/controled_viatra_all/')\n",
    "interact(plot_out_degree, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "30bfaf8dd45d4b21b0b43afe5e9fdb8a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_na(lines)>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_na(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.na_distance, colors, 'Node Activity', '../output/controled_viatra_all/')\n",
    "interact(plot_na, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5636d37b4416474db5441fe47e7a8a30",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_mpc(lines)>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_mpc(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/controled_viatra_all/')\n",
    "interact(plot_mpc, lines=w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Viatra With Both metric and consistency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "con_viatra_stats = readStats('../input/viatra_control_all_with_consistency_1/',20000)\n",
    "con_viatra_dic = calDistanceDic(con_viatra_stats, human_rep)\n",
    "\n",
    "# trajectories and colors\n",
    "trajectories = {}\n",
    "w = createSelectionWidge(trajectories)\n",
    "colors = createRandomColors(len(trajectories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e5c7231686544d959527cff36c1f1a5e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_out_degree(lines)>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_out_degree(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out_degree', '../output/viatra_control_all_with_consistency_1/')\n",
    "interact(plot_out_degree, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e043705333bb474e89582ea9358c57c3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_na(lines)>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_na(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.na_distance, colors, 'Node Activity', '../output/viatra_control_all_with_consistency_1/')\n",
    "interact(plot_na, lines=w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ee4723b62293402e87e6a3f798019b36",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_mpc(lines)>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_mpc(lines):\n",
    "    plot(con_viatra_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/viatra_control_all_with_consistency_1/')\n",
    "interact(plot_mpc, lines=w)"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}