mas_transportation_detours_space_indexing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:30: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  method='lar', copy_X=True, eps=np.finfo(np.float).eps,\n",
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:167: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  method='lar', copy_X=True, eps=np.finfo(np.float).eps,\n",
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:284: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_Gram=True, verbose=0,\n",
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:862: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_X=True, fit_path=True,\n",
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1101: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_X=True, fit_path=True,\n",
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1127: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, positive=False):\n",
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1362: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  max_n_alphas=1000, n_jobs=None, eps=np.finfo(np.float).eps,\n",
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1602: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  max_n_alphas=1000, n_jobs=None, eps=np.finfo(np.float).eps,\n",
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1738: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_X=True, positive=False):\n",
      "/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/sklearn/decomposition/online_lda.py:29: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  EPS = np.finfo(np.float).eps\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style>.container { width:100% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "import osmnx as ox\n",
    "import requests\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.colors as colors\n",
    "import matplotlib.pyplot as plt\n",
    "import shapely\n",
    "import random\n",
    "import numpy as np\n",
    "from IPython.display import clear_output\n",
    "import math\n",
    "from mas_transportation_utils import *\n",
    "#from mas_transportation_utils import all_paths\n",
    "import rtree\n",
    "\n",
    "%matplotlib inline\n",
    "ox.config(log_console=True)\n",
    "ox.__version__\n",
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:100% !important; }</style>\"))\n",
    "\n",
    "ox.utils.config(bidirectional_network_types=['drive'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UNITES\n",
    "1 TICK = 1 SECONDE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gdf = ox.geocode_to_gdf('Piedmont, California, USA') \n",
    "# get the street network within this bounding box\n",
    "west, south, east, north = list(gdf.bounds.iloc[0])\n",
    "minx, miny, maxx, maxy = west, south, east, north\n",
    "over_box = (minx, miny, maxx, maxy)\n",
    "G = ox.graph_from_bbox(north, south, east, west, network_type='drive')\n",
    "fig, ax = ox.plot_graph(G, figsize=(20, 20),  node_size=20)\n",
    "# hwy_speeds = {'residential': 30,\n",
    "#               'secondary': 50,\n",
    "#               'tertiary': 70}\n",
    " hwy_speeds = {'residential': 50,\n",
    "                      'primary':50,\n",
    "                      'secondary':50,\n",
    "                      'tertiary': 50,\n",
    "                      'motorway': 50,\n",
    "                      'trunk': 50}\n",
    "\n",
    "G = ox.add_edge_speeds(G, hwy_speeds,  precision=0)\n",
    "#temps arrondis\n",
    "G = ox.add_edge_travel_times(G, precision=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "orig = list(G)[1]\n",
    "dest = list(G)[400]\n",
    "weight='length'\n",
    "#weight='travel_time'\n",
    "SP = ox.shortest_path(G,orig, dest, weight=weight)\n",
    "SPt = 0\n",
    "for i in range(len(SP)-1):\n",
    "    node1 = SP[i]\n",
    "    node2 = SP[i+1]\n",
    "    SPt += G.get_edge_data(node1,node2)[0]['travel_time']\n",
    "    \n",
    "    \n",
    "print(\"sptime\", SPt)\n",
    "#SP = list(nx.shortest_path(G, orig, dest, weight='length'))\n",
    "\n",
    "y1 = G.nodes[orig]['y']\n",
    "x1 = G.nodes[orig]['x']\n",
    "y2 = G.nodes[dest]['y']\n",
    "x2 = G.nodes[dest]['x']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "orig = list(G)[1]\n",
    "dest = list(G)[400]\n",
    "weight='travel_time'\n",
    "SP = ox.shortest_path(G,orig, dest, weight=weight)\n",
    "print(\"Spd=\",compute_shortest_path_distance(G, SP),\"m; Spt=\",compute_shortest_path_time(G, SP),\"s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.get_edge_data(SP[0],SP[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Quelques test bbox\n",
    "\n",
    "# def get_bbox_from_2_coords(y1,x1,y2,x2,coef=1):\n",
    "#     if y1>y2 :\n",
    "#         north = y1 + (1/2*ox.distance.euclidean_dist_vec(y1, x1, y2, x2)*coef)\n",
    "#         south = y2 - (1/2*ox.distance.euclidean_dist_vec(y1, x1, y2, x2)*coef)\n",
    "#     else :\n",
    "#         north = y1 -(1/2*ox.distance.euclidean_dist_vec(y1, x1, y2, x2)*coef)\n",
    "#         south = y2 + (1/2*ox.distance.euclidean_dist_vec(y1, x1, y2, x2)*coef)\n",
    "        \n",
    "#     if x1>x2:\n",
    "#         east = x2  \n",
    "#         west = x1\n",
    "#     else :\n",
    "#         east = x1 \n",
    "#         west = x2\n",
    "        \n",
    "#     return(north,south,east,west)\n",
    "\n",
    "# def get_bbox_2_0(y1,x1,y2,x2,coef=1):\n",
    "#     if y1>y2 :\n",
    "#         north = y1 + ((y1-y2)*coef)\n",
    "#         south = y2 - ((y1-y2)*coef)\n",
    "#     else :\n",
    "#         north = y1 - ((y2-y1)*coef)\n",
    "#         south = y2 + ((y2-y1)*coef)\n",
    "        \n",
    "#     if x1>x2:\n",
    "#         east = x2 + ((x2-x1)*coef) \n",
    "#         west = x1 - ((x2-x1)*coef) \n",
    "#     else :\n",
    "#         east = x1 + ((x1-x2)*coef)\n",
    "#         west = x2 - ((x1-x2)*coef)\n",
    "    \n",
    "#     return(north,south,east,west)\n",
    "\n",
    "# '''Ajouter pref ?'''\n",
    "def get_bbox_min_max(G, SP, coef=0):\n",
    "    min_lat = False\n",
    "    max_lat = False\n",
    "    min_lon = False\n",
    "    max_lon = False\n",
    "    for node in SP:\n",
    "        lat = G.nodes[node]['y']\n",
    "        lon = G.nodes[node]['x']\n",
    "        if lat < min_lat or not min_lat :\n",
    "            min_lat = lat\n",
    "        if lat > max_lat or not max_lat:\n",
    "            max_lat = lat\n",
    "        if lon < min_lon or not min_lon:\n",
    "            min_lon = lon\n",
    "        if lon > max_lon or not max_lon :\n",
    "            max_lon = lon\n",
    "            \n",
    "    min_lat = min_lat - ((max_lat-min_lat)*coef)\n",
    "    max_lat = max_lat + ((max_lat-min_lat)*coef)\n",
    "    \n",
    "    min_lon = min_lon - ((max_lon-min_lon)*coef)\n",
    "    max_lon = max_lon + ((max_lon-min_lon)*coef)\n",
    "    return min_lat, min_lon, max_lat, max_lon\n",
    "\n",
    "def get_bbox_idx(G, SP, slack_time, speed):\n",
    "    min_lat = False\n",
    "    max_lat = False\n",
    "    min_lon = False\n",
    "    max_lon = False\n",
    "    for node in SP:\n",
    "        lat = G.nodes[node]['y']\n",
    "        lon = G.nodes[node]['x']\n",
    "        if lat < min_lat or not min_lat :\n",
    "            min_lat = lat\n",
    "        if lat > max_lat or not max_lat:\n",
    "            max_lat = lat\n",
    "        if lon < min_lon or not min_lon:\n",
    "            min_lon = lon\n",
    "        if lon > max_lon or not max_lon :\n",
    "            max_lon = lon\n",
    "    \n",
    "    if slack_time > 0:\n",
    "        speed_mps = speed / 3.6\n",
    "        meters = speed_mps * slack_time\n",
    "        earth = 6378.137  #radius of the earth in kilometer\n",
    "        pi = math.pi \n",
    "        m = (1 / ((2 * pi / 360) * earth)) / 1000  #1 meter in degree\n",
    "        \n",
    "        min_lat = min_lat - (meters*m)\n",
    "        max_lat = max_lat + (meters*m)\n",
    "        min_lon = min_lon - (meters*m) / math.cos(min_lat * (pi / 180))\n",
    "        max_lon = max_lon + (meters*m) / math.cos(max_lat * (pi / 180))\n",
    "        \n",
    "        \n",
    "        #min_lat = max(min_lat, sma.min_lat)\n",
    "        #max_lat = min(max_lat, sma.max_lat)\n",
    "    \n",
    "        #min_lon = max(min_lon, sma.min_lon)\n",
    "        #max_lon = min(max_lon, sma.max_lon)\n",
    "    return min_lat, min_lon, max_lat, max_lon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = a /3.6\n",
    "c = 3 * b\n",
    "print(\"kmh\",a,\"mps\",b,\"d\",c,\"m\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#bbox1 = get_bbox_from_2_coords(y1,x1,y2,x2,coef=1)\n",
    "#bbox2 = get_bbox_2_0(y1,x1,y2,x2,coef=1)\n",
    "bbox3 = get_bbox_min_max(G, SP,0)\n",
    "bbox4 = get_bbox_idx(G, SP, 30, 50)\n",
    "#print(\"bbox1\", bbox1, \"\\nbbox2\", bbox2, \"\\nbbox3\", bbox3 )\n",
    "#idx.insert(1,bbox3,\"bbox d1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bbox3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bbox = bbox4\n",
    "g_bbox = ox.truncate.truncate_graph_bbox(G, bbox[2], bbox[0], bbox[3], bbox[1], truncate_by_edge=True, retain_all=False)\n",
    "#set(g_bbox.nodes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ox.plot_graph(G)\n",
    "bbox = bbox3\n",
    "print(bbox3)\n",
    "g_bbox = ox.truncate.truncate_graph_bbox(G, bbox[2], bbox[0], bbox[3], bbox[1], truncate_by_edge=True, retain_all=False)\n",
    "ox.plot_graph(g_bbox)\n",
    "print('orig in bbox ?',orig in g_bbox)\n",
    "print('dest in bbox ?',dest in g_bbox)\n",
    "ox.plot_graph_route(g_bbox, ox.shortest_path(g_bbox, orig, dest), route_color='y', route_linewidth=6, node_size=0)\n",
    "# #ox.plot_graph_route(G, ox.shortest_path(G, orig, dest), route_color='y', route_linewidth=6, node_size=6)\n",
    "# #routes = list(ox.k_shortest_paths(g_bbox, orig, dest, 50))\n",
    "# #ox.plot_graph_routes(g_bbox,routes)\n",
    "bbox = bbox4\n",
    "print(bbox4)\n",
    "g_bbox = ox.truncate.truncate_graph_bbox(G, bbox[2], bbox[0], bbox[3], bbox[1], truncate_by_edge=False, retain_all=False)\n",
    "ox.plot_graph(g_bbox)\n",
    "print('orig in bbox ?',orig in g_bbox)\n",
    "print('dest in bbox ?',dest in g_bbox)\n",
    "ox.plot_graph_route(g_bbox, ox.shortest_path(g_bbox, orig, dest), route_color='y', route_linewidth=6, node_size=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    def __init__(self, unique_id):\n",
    "        self.is_alive = True\n",
    "        self.unique_id = unique_id\n",
    "    \n",
    "    def update(self) -> None: \n",
    "        pass\n",
    "    \n",
    "    def decide(self) -> None:\n",
    "        pass\n",
    "    \n",
    "class UserAgent(Agent):\n",
    "    def __init__(self, unique_id, v_dep, v_arr):\n",
    "        super().__init__(unique_id)\n",
    "        self.v_dep = v_dep\n",
    "        self.v_r = v_dep\n",
    "        self.v_arr = v_arr\n",
    "        \n",
    "        #calcul de la longueur du plus court chemin à l'origine\n",
    "        ###self.SPL = nx.shortest_path_length(sma.G, source=self.v_dep, target=self.v_arr)\n",
    "        \n",
    "    def update(self) -> None:\n",
    "        pass\n",
    "    \n",
    "    def decide(self) -> None:\n",
    "        pass    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContinuousDriverAgent(UserAgent):\n",
    "    '''pref might be : \"length\" or \"travel_time\"'''\n",
    "    def __init__(self, unique_id, v_dep, v_arr, capacity=3, detour_factor=0, pref_weight='travel_time', test=False):\n",
    "        super().__init__(unique_id, v_dep, v_arr)\n",
    "        \n",
    "        self.dep_time = sma.tick\n",
    "        \n",
    "        self.pref_weight = pref_weight\n",
    "        self.detour_factor = detour_factor\n",
    "        self.SP = ox.shortest_path(sma.G, self.v_dep, self.v_arr, weight=pref_weight)\n",
    "        self.SPt = compute_shortest_path_time(sma.G, self.SP)\n",
    "        self.SPd = compute_shortest_path_distance(sma.G, self.SP)\n",
    "        self.detour_factor = detour_factor\n",
    "        \n",
    "        self.trip = self.SP\n",
    "        \n",
    "        \n",
    "        self.current_pos = dict()\n",
    "        self.current_pos['node1'] = self.v_dep\n",
    "        self.current_pos['node2'] = self.trip[1]\n",
    "        self.current_pos['edge_data'] = sma.G.get_edge_data(self.v_dep, self.trip[1])[0]\n",
    "        self.current_pos['time'] = 0\n",
    "        \n",
    "        self.total_distance=0\n",
    "        #self.total_distance=self.current_pos['edge_data']['length']\n",
    "        \n",
    "        self.c = capacity\n",
    "        self.l_arr_time = sma.tick + self.SPt + math.ceil(self.SPt*detour_factor) #'''arrondi ?'''\n",
    "        self.v_r = self.trip[1]\n",
    "        \n",
    "        #tableaux du scheduling S\n",
    "        self.arr = [sma.tick + self.current_pos['edge_data']['travel_time'], self.SPt] #tableau des premières arrivées\n",
    "        self.ddl = [self.arr[0], self.l_arr_time] #tableau des dernières arrivées\n",
    "        self.slk = [0, self.ddl[1]-self.arr[1]] #tableau de la marge de temps a chaque étape\n",
    "        \n",
    "        self.stops = [self.trip[1], v_arr] #tableau référençant les noeuds avec arrêts obligatoire \n",
    "                             #(noeuds de recup et de dépot des passagers et noeud d'arrivé du conducteur)\n",
    "        self.capacities = [capacity, capacity]\n",
    "        self.tag_event = False\n",
    "        \n",
    "        self.perceptions = [None] #les ellipses, la perception à chaque étape\n",
    "        self.perceptions.append(self.get_perception_idx(self.v_r, self.v_arr, 1))\n",
    "        sma.rtree.insert(self.unique_id, self.perceptions[1], (self.unique_id, 1))\n",
    "        \n",
    "        self.riders_distance = 0\n",
    "        #affichage de la progression sur une carte\n",
    "        self.test = test\n",
    "        if self.test :\n",
    "            fig, ax = ox.plot_graph_route(sma.G, self.trip, route_color='y', route_linewidth=6, node_size=0)\n",
    "\n",
    "    \n",
    "    def add_rider_to_scheduler(self, rider, r_v1, r_v2, dl_v1, dl_v2, idx1, idx2):\n",
    "        #on ajoute le passager au scheduler, on met a jour le trip et la capacité\n",
    "        \n",
    "        #########checks##############\n",
    "        if dl_v1 > self.ddl[-1] or dl_v2 > self.ddl[-1]:\n",
    "            raise Exception(\"Rider's deadline should be lower than driver's deadline\")\n",
    "            \n",
    "        if r_v1 == r_v2:\n",
    "            raise Exception(\"Driver\",self.unique_id,\"problème noeud égaux\")\n",
    "\n",
    "        if r_v2 in self.stops: #and (self.stops.index(r_v2) == idx2 or self.stops.index(r_v2) == 0):\n",
    "            if self.ddl[self.stops.index(r_v2)] < dl_v2:\n",
    "                self.ddl[self.stops.index(r_v2)] = dl_v2\n",
    "        else :\n",
    "            if idx1==idx2 and r_v1 in self.stops: #and self.stops.index(r_v1) == idx1:\n",
    "                self.stops.insert(idx2+1, r_v2)\n",
    "                self.ddl.insert(idx2+1, dl_v2)\n",
    "                self.capacities.insert(idx2+1, self.capacities[idx2])\n",
    "                                                     \n",
    "            else:\n",
    "                self.stops.insert(idx2, r_v2)\n",
    "                self.ddl.insert(idx2, dl_v2)\n",
    "                self.capacities.insert(idx2, self.capacities[idx2-1])\n",
    "            \n",
    "        if r_v1 in self.stops: #and (self.stops.index(r_v1) == idx1 or self.stops.index(r_v1) == 0):\n",
    "            if self.ddl[self.stops.index(r_v1)] < dl_v1:\n",
    "                self.ddl[self.stops.index(r_v1)] = dl_v1   \n",
    "            \n",
    "        else:\n",
    "            self.stops.insert(idx1, r_v1)\n",
    "            self.ddl.insert(idx1, dl_v1)\n",
    "            self.capacities.insert(idx1, self.capacities[idx1-1])\n",
    "            \n",
    "        for i in np.arange(idx1,idx2):\n",
    "            self.capacities[i]-=1        \n",
    "        #puis on recalcule le chemin le plus court et la marge (skl = slack time)\n",
    "        \n",
    "        #pour le premier on se base sur le noeud courant\n",
    "        self.arr = [self.arr[0]]\n",
    "        dif = [self.ddl[0] - self.arr[0]]#normalement = à 0\n",
    "        if self.ddl[0] - self.arr[0] < 0:\n",
    "            raise Exception(\"Problème insertion conducteur\",self.unique_id,\"avec ddl\",self.ddl[0],\"et arr\",self.arr[0],\"premiere indice tableau/position courrante\")\n",
    "        \n",
    "        #self.arr.append(sma.tick + (self.current_pos['edge_data']['travel_time'] - self.current_pos['time']) + compute_shortest_path_time(ox.shortest_path(sma.G, self.v_r, self.stops[0], weight=self.pref_weight)))\n",
    "        #dif.append(self.ddl[0] - self.arr[0])\n",
    "        \n",
    "        \n",
    "        for i in range(len(self.stops)-1):\n",
    "            self.arr.append(self.arr[i] + compute_shortest_path_time(sma.G,ox.shortest_path(sma.G, self.stops[i], self.stops[i+1], weight=self.pref_weight)))\n",
    "            dif.append(self.ddl[i+1] - self.arr[i+1])\n",
    "        \n",
    "        #calcul marge dépendante des marges suivantes\n",
    "        self.slk = []\n",
    "        for i in range(len(dif)):\n",
    "            self.slk.append(np.min(dif[i:]))\n",
    "        \n",
    "#         if rider != None:\n",
    "#             self.riders_distance+= rider.SPd\n",
    "        self.tag_event = True\n",
    "        self.update()\n",
    "    \n",
    "    def get_all_perceptions(self):\n",
    "        perceptions = []\n",
    "        perceptions.append(None)\n",
    "            \n",
    "        for i in range(len(self.stops)-1):\n",
    "            if self.slk[i+1]==0:\n",
    "                perceptions.append(None)\n",
    "            else:\n",
    "                perceptions.append(self.get_perception_idx(self.stops[i], self.stops[i+1], i+1))\n",
    "    \n",
    "        return perceptions\n",
    "                                    \n",
    "    def get_perception_idx(self, orig, dest, stop_idx):\n",
    "        slack_time = self.slk[stop_idx]\n",
    "        \n",
    "        SP = ox.shortest_path(sma.G, orig, dest, weight=self.pref_weight)\n",
    "        min_lat = False\n",
    "        max_lat = False\n",
    "        min_lon = False\n",
    "        max_lon = False\n",
    "        for node in SP:\n",
    "            lat = sma.G.nodes[node]['y']\n",
    "            lon = sma.G.nodes[node]['x']\n",
    "            if lat < min_lat or not min_lat :\n",
    "                min_lat = lat\n",
    "            if lat > max_lat or not max_lat:\n",
    "                max_lat = lat\n",
    "            if lon < min_lon or not min_lon:\n",
    "                min_lon = lon\n",
    "            if lon > max_lon or not max_lon :\n",
    "                max_lon = lon\n",
    "                \n",
    "        if slack_time > 0:\n",
    "            speed_mps = sma.speed / 3.6 #il faudra a terme faire une moyenne sur la vitesse par exemple\n",
    "            meters = speed_mps * slack_time\n",
    "            earth = 6378.137  #radius of the earth in kilometer\n",
    "            pi = math.pi \n",
    "            m = (1 / ((2 * pi / 360) * earth)) / 1000  #1 meter in degree\n",
    "\n",
    "\n",
    "            min_lat = min_lat - (meters*m) \n",
    "            max_lat = max_lat + (meters*m) \n",
    "            min_lon = min_lon - (meters*m) / math.cos(min_lat * (pi / 180))\n",
    "            max_lon = max_lon + (meters*m) / math.cos(max_lat * (pi / 180))\n",
    "        \n",
    "        #il ne faut pas dépasser les limites du graphe\n",
    "        min_lat = max(min_lat, sma.min_lat)\n",
    "        max_lat = min(max_lat, sma.max_lat)\n",
    "    \n",
    "        min_lon = max(min_lon, sma.min_lon)\n",
    "        max_lon = min(max_lon, sma.max_lon)\n",
    "\n",
    "        perception = (min_lon, min_lat, max_lon, max_lat)    \n",
    "        \n",
    "        return perception\n",
    "        \n",
    "        \n",
    "    def update_perception(self):\n",
    "        for p in self.perceptions:\n",
    "            if p != None:\n",
    "                sma.rtree.delete(self.unique_id, p)\n",
    "        if self.is_alive:    \n",
    "            new_perception=self.get_all_perceptions()\n",
    "            for p in new_perception:\n",
    "                if p != None:\n",
    "                    sma.rtree.insert(self.unique_id, p, obj=(self.unique_id, new_perception.index(p)))\n",
    "\n",
    "            self.perceptions = new_perception\n",
    "        \n",
    "                                    \n",
    "        \n",
    "                                    \n",
    "    \n",
    "#     def get_perception_set_node(self):\n",
    "#         return set([item for sublist in self.perceptions for item in sublist])\n",
    "    \n",
    "#     def algo_recu_percep(self, current_node, visited, perception, max_weight):\n",
    "#         for succ in G.neighbors(current_node):\n",
    "#             if succ not in visited :\n",
    "#                 visited.append(succ)\n",
    "#                 try: \n",
    "#                     if nx.shortest_path_length(sma.G, orig, succ, weight=self.pref_weight) + nx.shortest_path_length(sma.G, succ, dest, weight=self.pref_weight) <= max_weight:\n",
    "#                         perception.add(succ)\n",
    "#                         self.algo_recu_percep(succ, visited, perception, max_weight)\n",
    "#                 except (KeyError, nx.NetworkXNoPath):\n",
    "#                     pass\n",
    "            \n",
    "    def update(self): \n",
    "        #a terme, il faudra identifier dans quelles ellipses sont les modifs et modif uniquement là\n",
    "        if self.tag_event == True:\n",
    "            self.update_perception()\n",
    "            self.trip = ox.shortest_path(sma.G, self.v_r, self.stops[1], weight=self.pref_weight)\n",
    "            self.tag_event = False\n",
    "    \n",
    "    def decide(self):\n",
    "        current_time = self.current_pos['time'] + 1\n",
    "        if current_time < self.current_pos['edge_data']['travel_time']:\n",
    "            self.current_pos['time'] = current_time\n",
    "            \n",
    "        else :\n",
    "            reste = current_time - self.current_pos['edge_data']['travel_time']\n",
    "            self.current_pos = dict()\n",
    "            self.current_pos['node1'] = self.trip.pop(0)\n",
    "            self.current_pos['node2'] = self.trip[0]\n",
    "            #print(self.current_pos['node1'], self.current_pos['node2'])\n",
    "            #print(sma.G.get_edge_data(self.current_pos['node1'], self.current_pos['node2']))\n",
    "            self.current_pos['edge_data'] = sma.G.get_edge_data(self.current_pos['node1'], self.current_pos['node2'])[0]\n",
    "            self.current_pos['time'] = reste\n",
    "            self.v_r = self.current_pos['node2']\n",
    "            self.total_distance+=self.current_pos['edge_data']['length']\n",
    "            \n",
    "            if self.v_r == self.v_arr and self.stops[1]==self.v_arr:\n",
    "                if self.test :\n",
    "                    clear_output(wait=True)\n",
    "                    fig, ax = ox.plot_graph_route(sma.G, [self.trip[-1]], route_color='y', route_linewidth=6, node_size=0)\n",
    "                    \n",
    "                self.is_alive = False\n",
    "                self.update_perception()\n",
    "                \n",
    "                d_trip_time = sma.tick + self.current_pos['edge_data']['travel_time'] - self.current_pos['time'] - self.dep_time\n",
    "                d_trip_length = self.total_distance\n",
    "                sma.data['d_trip_time'].append(d_trip_time)\n",
    "                sma.data['d_trip_length'].append(d_trip_length)\n",
    "                sma.data['saved_distance']+=self.SPd-self.total_distance\n",
    "                \n",
    "                if sma.verbose == True:\n",
    "                    print(\"Driver\",self.unique_id,\"arrived\")\n",
    "                \n",
    "                \n",
    "            else :\n",
    "#                 if sma.verbose == True:\n",
    "#                     print(\"Driver\",self.unique_id,\"passing through node\",self.current_pos['node2'])\n",
    "                if self.test :\n",
    "                    clear_output(wait=True)\n",
    "                    fig, ax = ox.plot_graph_route(sma.G, self.trip, route_color='y', route_linewidth=6, node_size=0)\n",
    "                                                       \n",
    "                                    \n",
    "                #si le prochain noeud est un arret prévu                    \n",
    "                if self.current_pos['node2'] == self.stops[1]:\n",
    "                                    \n",
    "                    self.arr.pop(0) \n",
    "                    self.slk.pop(1)\n",
    "                    \n",
    "                                    \n",
    "                    self.ddl.pop(0)\n",
    "                    self.ddl[0]=self.arr[0]\n",
    "                    \n",
    "                    self.capacities.pop(0)\n",
    "                    \n",
    "#                     if self.perceptions[1] != None:\n",
    "#                         sma.rtree.delete(self.unique_id, self.perceptions[1])\n",
    "#                     self.perceptions.pop(1)\n",
    "                    \n",
    "                    #print(\"d passe par un stop ?\")\n",
    "                                    \n",
    "                    self.stops.pop(0)\n",
    "                    self.update_perception()\n",
    "                    \n",
    "                    if self.current_pos['node2'] != self.v_arr:\n",
    "                        self.trip = ox.shortest_path(sma.G, self.v_r, self.stops[1], weight=self.pref_weight)\n",
    "                        \n",
    "                    \n",
    "                    \n",
    "                else :\n",
    "                    self.arr[0]+= self.current_pos['edge_data']['travel_time'] - self.current_pos['time']\n",
    "                    self.ddl[0]=self.arr[0]\n",
    "                    self.stops[0]=self.v_r\n",
    "                    #self.trip = ox.shortest_path(sma.G, self.v_r, self.stops[1], weight=self.pref_weight)\n",
    "                \n",
    "                \n",
    "                \n",
    "                \n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SMA:\n",
    "    def __init__(self, verbose=False, verbose2=False, place='Piedmont, California, USA', speed=50, show_graph=False, hop='mhop'):\n",
    "        self.tick=0 #1 tick = 1 seconde\n",
    "        self.resetTicks()\n",
    "        \n",
    "        if hop in ['mhop','shop','nohop']:\n",
    "            self.hop = hop\n",
    "        else :\n",
    "            raise Exception(\"hop parameters is either : mhop, shop or nohop\")\n",
    "            \n",
    "        \n",
    "        if place=='grid':\n",
    "            north, south, east, west = 37.79, 37.78, -122.41, -122.43\n",
    "            self.min_lat, self.min_lon, self.max_lat, self.max_lon = south, west, north ,east \n",
    "            \n",
    "            \n",
    "        else:\n",
    "            gdf = ox.geocode_to_gdf(place) \n",
    "            # get the street network within this bounding box\n",
    "            west, south, east, north = list(gdf.bounds.iloc[0])\n",
    "            self.min_lat, self.min_lon, self.max_lat, self.max_lon = south, west, north ,east \n",
    "            #self.bbox = (self.min_lon, self.min_lat, self.max_lon, self.max_lat)\n",
    "            \n",
    "        self.G = ox.graph_from_bbox(north, south, east, west, network_type='drive')\n",
    "        \n",
    "#         #filter deadends\n",
    "#         deadends = []\n",
    "#         for node in list(self.G.nodes):\n",
    "#             if self.G.nodes[node]['street_count']==1:\n",
    "#                 deadends.append(node)\n",
    "#         print(deadends)\n",
    "#         self.G.remove_nodes_from(deadends)\n",
    "        \n",
    "        if show_graph:\n",
    "            fig, ax = ox.plot_graph(self.G, figsize=(20, 20),  node_size=20)\n",
    "        self.speed = speed\n",
    "        # hwy_speeds = {'residential': 30,\n",
    "        #               'secondary': 50,\n",
    "        #               'tertiary': 70}\n",
    "\n",
    "        hwy_speeds = {'residential': self.speed,\n",
    "                      'primary':self.speed,\n",
    "                      'secondary': self.speed,\n",
    "                      'tertiary': self.speed,\n",
    "                      'motorway': self.speed,\n",
    "                      'trunk': self.speed}\n",
    "\n",
    "        self.G = ox.add_edge_speeds(self.G, hwy_speeds, fallback=50, precision=0)\n",
    "        #temps arrondis\n",
    "        self.G = ox.add_edge_travel_times(self.G, precision=0)\n",
    "        \n",
    "        #dictionnaire des agents par type\n",
    "        self.agentTypeIdDict = {}\n",
    "        self.agentTypeIdDict[\"drivers\"] = []\n",
    "        self.agentTypeIdDict[\"riders\"] = []\n",
    "        self.agentTypeIdDict[\"tsas\"] = []\n",
    "        self.agentTypeIdDict[\"tgas\"] = []\n",
    "        \n",
    "        #dictionnaire des agents par id\n",
    "        self.agentDict = {}\n",
    "        \n",
    "        #arbre d'indexation spatiale R-TREE\n",
    "        self.rtree = rtree.index.Index()\n",
    "        \n",
    "        #self.G = None\n",
    "        self.verbose = verbose\n",
    "        self.verbose2 = verbose2\n",
    "        \n",
    "        \n",
    "        ####DATA####\n",
    "        self.data = dict()\n",
    "        self.data['d_trip_time'] = []\n",
    "        self.data['d_trip_length'] = []\n",
    "        self.data['r_waiting_time'] = []\n",
    "        self.data['r_nb_unmatched'] = 0\n",
    "        self.data['mhop_count'] = 0\n",
    "        self.data['shop_count'] = 0\n",
    "        self.data['saved_distance'] = 0\n",
    "    \n",
    "    def resetTicks(self):\n",
    "        self.tick=0\n",
    "          \n",
    "    def setRoadGraph(self,graph):\n",
    "        self.G = graph\n",
    "        \n",
    "    def addAgent(self,ag):\n",
    "        self.agentDict[ag.unique_id] = ag\n",
    "        if \"RiderAgent\" in ag.__class__.__name__:\n",
    "            self.agentTypeIdDict[\"riders\"].append(ag.unique_id)\n",
    "        elif \"DriverAgent\" in ag.__class__.__name__:\n",
    "            self.agentTypeIdDict[\"drivers\"].append(ag.unique_id)\n",
    "        elif \"TransportServiceAgent\" in ag.__class__.__name__:\n",
    "            self.agentTypeIdDict[\"tsas\"].append(ag.unique_id)\n",
    "        elif \"TransportGeneratorAgent\" in ag.__class__.__name__:\n",
    "            self.agentTypeIdDict[\"tgas\"].append(ag.unique_id)\n",
    "        else: raise Exception(ag.__class__.__name__,\"is a wrong type of agent.\")\n",
    "            \n",
    "            \n",
    "    def getAgentFromId(self, unique_id):\n",
    "        return self.agentDict[unique_id]\n",
    "    \n",
    "    def getRiders(self):\n",
    "        R = []\n",
    "        for r in self.agentTypeIdDict['riders']:\n",
    "            R.append(self.agentDict[r])\n",
    "        return R\n",
    "        \n",
    "    def getDrivers(self):\n",
    "        D = []\n",
    "        for d in self.agentTypeIdDict['drivers']:\n",
    "            D.append(self.agentDict[d])\n",
    "        return D\n",
    "        \n",
    "    def getTSAs(self):\n",
    "        TSA = []\n",
    "        for tsa in self.agentTypeIdDict['tsas']:\n",
    "            TSA.append(self.agentDict[tsa])\n",
    "        return TSA\n",
    "    \n",
    "    def getTGAs(self):\n",
    "        TGA = []\n",
    "        for tga in self.agentTypeIdDict['tgas']:\n",
    "            TGA.append(self.agentDict[tga])\n",
    "        return TGA\n",
    "\n",
    "    def run(self,rounds=None):\n",
    "        if rounds==None:\n",
    "            #on s'arrete si tout les passagers ou tout les conducteurs sont arrivés\n",
    "            self.runOnce()\n",
    "            while len([agent for agent in sma.agentDict.values() if (\"RiderAgent\" in agent.__class__.__name__)]) > 0 and len([agent for agent in sma.agentDict.values() if (\"DriverAgent\" in agent.__class__.__name__)]) > 0:\n",
    "                self.runOnce()\n",
    "            #print(\"Finished in\",self.tick,\"ticks\")\n",
    "        \n",
    "        else :\n",
    "            #génération classique\n",
    "            for i in range(0,rounds):\n",
    "                self.runOnce()\n",
    "\n",
    "    def runOnce(self):\n",
    "        self.tick+=1\n",
    "        #random.shuffle(self.agentList)\n",
    "        for ag in self.agentDict.values() :\n",
    "            #print(ag.unique_id)\n",
    "            ag.update()\n",
    "            ag.decide()\n",
    "        \n",
    "        #phase de nettoyage des agents morts\n",
    "        for ag in self.agentDict.copy().values():\n",
    "            if ag.is_alive == False:\n",
    "                if \"RiderAgent\" in ag.__class__.__name__:\n",
    "                    self.agentTypeIdDict[\"riders\"].remove(ag.unique_id)\n",
    "                elif \"DriverAgent\" in ag.__class__.__name__:\n",
    "                    self.agentTypeIdDict[\"drivers\"].remove(ag.unique_id)\n",
    "                elif \"TransportServiceAgent\" in ag.__class__.__name__:\n",
    "                    self.agentTypeIdDict[\"tsas\"].remove(ag.unique_id)\n",
    "                elif \"TransportGeneratorAgent\" in ag.__class__.__name__:\n",
    "                    self.agentTypeIdDict[\"tgas\"].remove(ag.unique_id)\n",
    "                else: raise Exception(ag.__class__.__name__,\"is a wrong type of agent, even if diying.\")\n",
    "                \n",
    "                self.agentDict.pop(ag.unique_id)\n",
    "                \n",
    "                \n",
    "        if self.verbose == True:      \n",
    "            print(\"tick\",str(self.tick),\"ended\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test 1: un conducteur va vers sa destination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounds = 500\n",
    "sma = SMA()\n",
    "G = sma.G\n",
    "sma.tick = 0\n",
    "orig = list(G)[1]\n",
    "dest = list(G)[120]\n",
    "#d1 = ContinuousDriverAgent(1, orig, dest, detour=0.5, pref_weight='length',test=True)\n",
    "d1 = ContinuousDriverAgent(2, orig, dest, detour_factor=0.5, pref_weight='travel_time',test=True)\n",
    "sma.addAgent(d1)\n",
    "for _ in range(rounds):\n",
    "    sma.runOnce()\n",
    "    #print(sma.rtree)\n",
    "    #print(list(sma.rtree.intersection(d1.perceptions[1],objects='raw')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test 2: un conducteur prends en charge une requete fictive (aucun test de faisabilité)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounds = 1000\n",
    "sma = SMA()\n",
    "G = sma.G\n",
    "sma.tick = 0\n",
    "orig = list(G)[1]\n",
    "dest = list(G)[120]\n",
    "#d1 = ContinuousDriverAgent(1, orig, dest, detour=0.5, pref_weight='length',test=True)\n",
    "d1 = ContinuousDriverAgent(2, orig, dest, detour_factor=0.5, pref_weight='travel_time',test=True)\n",
    "sma.addAgent(d1)\n",
    "for _ in range(30):\n",
    "    sma.runOnce()\n",
    "\n",
    "p_cs = d1.perceptions[1]\n",
    "p_node_cs = set(ox.truncate.truncate_graph_bbox(G, p_cs[3], p_cs[1], p_cs[2], p_cs[0], truncate_by_edge=False, retain_all=False).nodes)\n",
    "r1, r2 = random.sample(p_node_cs,2)\n",
    "d1.add_rider_to_scheduler(None, r1, r2, 60, 100, 1, 1)\n",
    "\n",
    "for _ in range(1000):\n",
    "    sma.runOnce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RiderAgent(UserAgent):\n",
    "    '''pref might be : \"length\" or \"travel_time\"'''\n",
    "    def __init__(self, unique_id, v_dep, v_arr, detour_factor=0, waiting_time=5, pref_weight='travel_time'):\n",
    "        super().__init__(unique_id, v_dep, v_arr)\n",
    "        self.max_wt = waiting_time * 60 #minutes vers secondes\n",
    "        self.v_dep = v_dep\n",
    "        self.v_arr = v_arr\n",
    "        self.pref_weight = pref_weight\n",
    "        self.detour_factor = detour_factor\n",
    "        self.SP = ox.shortest_path(sma.G, self.v_dep, self.v_arr, weight=pref_weight)\n",
    "        self.SPt = compute_shortest_path_time(sma.G, self.SP)\n",
    "        self.SPd = compute_shortest_path_distance(sma.G, self.SP)\n",
    "        self.detour_factor = detour_factor\n",
    "        self.arr = sma.tick + self.SPt\n",
    "        self.l_arr_time = sma.tick + self.max_wt + self.SPt + math.ceil(self.SPt*detour_factor) #'''arrondi ?'''\n",
    "        self.l_dep_time = sma.tick + self.max_wt\n",
    "        self.perception = None #les ellipses, la perception à chaque étape\n",
    "#         self.wt_perception = None\n",
    "        self.wt = 0\n",
    "        self.checked_couples = set() #on stock les couples de conducteurs déja vérifiés\n",
    "        self.checked_drivers = set()\n",
    "        self.v_dep_lat = sma.G.nodes[self.v_dep]['y']\n",
    "        self.v_dep_lon = sma.G.nodes[self.v_dep]['x']\n",
    "        self.v_arr_lat = sma.G.nodes[self.v_arr]['y']\n",
    "        self.v_arr_lon = sma.G.nodes[self.v_arr]['x']\n",
    "        \n",
    "        \n",
    "        self.served = False\n",
    "    \n",
    "    def get_perception_trip(self):\n",
    "        slack_time = self.l_arr_time - self.arr - self.wt\n",
    "        # ou \n",
    "        #slack_time = self.l_arr_time - self.max_wt #le wt n'est pas vraiment du détour ?\n",
    "        \n",
    "        SP = ox.shortest_path(sma.G, self.v_dep, self.v_arr, weight=self.pref_weight)\n",
    "        min_lat = False\n",
    "        max_lat = False\n",
    "        min_lon = False\n",
    "        max_lon = False\n",
    "        for node in SP:\n",
    "            lat = sma.G.nodes[node]['y']\n",
    "            lon = sma.G.nodes[node]['x']\n",
    "            if lat < min_lat or not min_lat :\n",
    "                min_lat = lat\n",
    "            if lat > max_lat or not max_lat:\n",
    "                max_lat = lat\n",
    "            if lon < min_lon or not min_lon:\n",
    "                min_lon = lon\n",
    "            if lon > max_lon or not max_lon :\n",
    "                max_lon = lon\n",
    "                \n",
    "        if slack_time > 0:\n",
    "            speed_mps = sma.speed / 3.6 #il faudra a terme faire une moyenne sur la vitesse par exemple\n",
    "            meters = speed_mps * slack_time\n",
    "            earth = 6378.137  #radius of the earth in kilometer\n",
    "            pi = math.pi \n",
    "            m = (1 / ((2 * pi / 360) * earth)) / 1000  #1 meter in degree\n",
    "\n",
    "\n",
    "            min_lat = min_lat - (meters*m) \n",
    "            max_lat = max_lat + (meters*m) \n",
    "            min_lon = min_lon - (meters*m) / math.cos(min_lat * (pi / 180))\n",
    "            max_lon = max_lon + (meters*m) / math.cos(max_lat * (pi / 180))\n",
    "            \n",
    "        #il ne faut pas dépasser les limites du graphe\n",
    "        min_lat = max(min_lat, sma.min_lat)\n",
    "        max_lat = min(max_lat, sma.max_lat)\n",
    "    \n",
    "        min_lon = max(min_lon, sma.min_lon)\n",
    "        max_lon = min(max_lon, sma.max_lon)\n",
    "\n",
    "        perception = (min_lon, min_lat, max_lon, max_lat)    \n",
    "        \n",
    "        return perception\n",
    "        \n",
    "#     def get_perception_wt(self):\n",
    "        \n",
    "#         min_lat, max_lat = self.lat\n",
    "#         min_lon, max_lon = self.lon\n",
    "        \n",
    "#         slack_time = self.wt\n",
    "#         if slack_time > 0:\n",
    "#             speed_mps = sma.speed / 3.6 #il faudra a terme faire une moyenne sur la vitesse par exemple\n",
    "#             meters = speed_mps * slack_time\n",
    "#             earth = 6378.137  #radius of the earth in kilometer\n",
    "#             pi = math.pi \n",
    "#             m = (1 / ((2 * pi / 360) * earth)) / 1000  #1 meter in degree\n",
    "\n",
    "\n",
    "#             min_lat = min_lat - (meters*m) \n",
    "#             max_lat = max_lat + (meters*m) \n",
    "#             min_lon = min_lon - (meters*m) / math.cos(min_lat * (pi / 180))\n",
    "#             max_lon = max_lon + (meters*m) / math.cos(max_lat * (pi / 180))\n",
    "        \n",
    "#         #il ne faut pas dépasser les limites du graphe\n",
    "#         min_lat = max(min_lat, sma.min_lat)\n",
    "#         max_lat = min(max_lat, sma.max_lat)\n",
    "    \n",
    "#         min_lon = max(min_lon, sma.min_lon)\n",
    "#         max_lon = min(max_lon, sma.max_lon)\n",
    "\n",
    "#         perception = (min_lat, min_lon, max_lat, max_lon)    \n",
    "        \n",
    "#         return perception\n",
    "        \n",
    "    \n",
    "        \n",
    "        \n",
    "        \n",
    "    def update(self):\n",
    "        if not self.served:\n",
    "#             if sma.verbose:\n",
    "#                 print(\"Rider\",self.unique_id,\"looking for a ride\")\n",
    "            self.perception = self.get_perception_trip()\n",
    "            #self.wt_perception = self.get_perception_wt()\n",
    "\n",
    "            #phase candidats approché\n",
    "            #set conducteur avec le noeud de départ dans leur perception\n",
    "            Q1 = list(sma.rtree.intersection((self.v_dep_lon,self.v_dep_lat,self.v_dep_lon,self.v_dep_lat),objects=\"raw\"))\n",
    "            #print(Q1)\n",
    "            \n",
    "            #si aucun, on ne pourra pas bouger de toute façon\n",
    "            if not Q1 :\n",
    "                return\n",
    "            \n",
    "            #set conducteur dont perception dans la zone d'attente\n",
    "            #d_on_wt = sma.rtree.intersection((self.wt_perception),objects=\"raw\")\n",
    "            \n",
    "            #set conducteur dont perception est dans perception passager\n",
    "            Q2 = list(sma.rtree.intersection((self.perception),objects=\"raw\"))\n",
    "            #print(Q2)\n",
    "            if not Q2 :\n",
    "                return\n",
    "            #set conducteur dont noeud d'arrivé est dans perception\n",
    "            Q3 = list(sma.rtree.intersection((self.v_arr_lon,self.v_arr_lat,self.v_arr_lon,self.v_arr_lat),objects=\"raw\"))\n",
    "            #print(Q3)\n",
    "            if not Q3 :\n",
    "                return\n",
    "            \n",
    "\n",
    "            \n",
    "            candidates_s = set()\n",
    "            cur_d_s = set()\n",
    "            for d1_id, idx1 in Q1:\n",
    "                for d2_id, idx2 in Q2:\n",
    "                    if d1_id == d2_id and idx1 <= idx2:\n",
    "                        d1 = sma.getAgentFromId(d1_id)\n",
    "                        candidates_s.add((d1,idx1,idx2))\n",
    "                        cur_d_s.add(d1_id)\n",
    "                              \n",
    "            \n",
    "            candidates_e = set()\n",
    "            cur_d_e = set()\n",
    "            for d2_id, idx2 in Q2:\n",
    "                for d3_id, idx3 in Q3:\n",
    "                    if d2_id == d3_id and idx2 <= idx3:\n",
    "                        d2 = sma.getAgentFromId(d2_id)\n",
    "                        candidates_e.add((d2,idx2,idx3))\n",
    "                        cur_d_e.add(d2_id)\n",
    "                        \n",
    "            if len(cur_d_s - self.checked_drivers) == 0 and len(cur_d_e - self.checked_drivers) == 0:\n",
    "                return\n",
    "#             if sma.verbose:\n",
    "#                 print(\"checking riders at start id:\",[cand[0].unique_id for cand in candidates_s])   \n",
    "#                 print(\"checking riders at end id:\",[cand[0].unique_id for cand in candidates_e])   \n",
    "\n",
    "            best_candidate = None\n",
    "            p_node_r = set(ox.truncate.truncate_graph_bbox(sma.G, self.perception[3], self.perception[1], self.perception[2], self.perception[0], truncate_by_edge=False, retain_all=False).nodes)\n",
    "            wt_transfert = 0\n",
    "            for cand_s in candidates_s:\n",
    "                self.checked_drivers.add(cand_s[0].unique_id)\n",
    "#                 if sma.verbose:\n",
    "#                     print(cand_s[0].unique_id)\n",
    "#                     print(cand_s[0].perceptions)\n",
    "#                     print(cand_s[2])\n",
    "                p_cs = cand_s[0].perceptions[cand_s[2]]\n",
    "                if p_cs[3]==p_cs[1] or p_cs[2]==p_cs[0]:\n",
    "                    print(\"oof\")\n",
    "                    continue\n",
    "                p_node_cs = set(ox.truncate.truncate_graph_bbox(sma.G, p_cs[3], p_cs[1], p_cs[2], p_cs[0], truncate_by_edge=False, retain_all=False).nodes)\n",
    "                Spt_ds_v1 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, cand_s[0].stops[cand_s[1]-1], self.v_dep, weight=cand_s[0].pref_weight))\n",
    "                    \n",
    "                #si le candidat au départ respecte le temps d'attente du passager et qu'il a de la place   \n",
    "                if Spt_ds_v1 + cand_s[0].arr[cand_s[1]-1] <= self.l_dep_time and cand_s[0].capacities[cand_s[1]-1]>0:  \n",
    "                    #print(\"time check ok\")\n",
    "                    for cand_e in candidates_e:\n",
    "                        \n",
    "                        self.checked_drivers.add(cand_e[0].unique_id)\n",
    "                        if (cand_s[0].unique_id, cand_s[0], cand_e[0].unique_id, cand_e[2]) in self.checked_couples:\n",
    "                            #print(\"coucou\")\n",
    "                            continue\n",
    "                        #print(\"coucou2\")\n",
    "                        self.checked_couples.add((cand_s[0].unique_id, cand_s[0], cand_e[0].unique_id, cand_e[2]))\n",
    "                        \n",
    "                        \n",
    "                        #single hop ?\n",
    "                        if cand_s[0].unique_id == cand_e[0].unique_id:\n",
    "                            \n",
    "                            #print(\"single hop ok\")\n",
    "                            #dans la meme bbox de perception?\n",
    "                            if cand_s[1] == cand_e[2]:\n",
    "                                #print(\"meme perception ok\")\n",
    "                                Spt_ds_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_dep, self.v_arr, weight=cand_s[0].pref_weight))\n",
    "                                Spt_ds_v3 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_arr, cand_s[0].stops[cand_s[1]], weight=cand_s[0].pref_weight))\n",
    "                                \n",
    "                                fitness = Spt_ds_v1 + Spt_ds_v2 + cand_s[0].arr[cand_s[1]-1]\n",
    "                                if (fitness <= self.l_arr_time) and (fitness+Spt_ds_v3 - cand_s[0].arr[cand_s[1]] <= cand_s[0].slk[cand_s[1]]) and cand_s[0].capacities[cand_s[1]-1]>0:\n",
    "                                    #print(\"grosse contrainte ok\")\n",
    "                                    \n",
    "                                    if best_candidate == None or best_candidate[2]>=fitness:\n",
    "                                        d1_data = (cand_s[0], self.v_dep, self.v_arr, Spt_ds_v1+cand_s[0].arr[cand_s[1]-1], fitness, cand_s[1],cand_s[1]) #r_v1, r_v2, dl_v1, dl_v2, idx1, idx2\n",
    "                                        d2_data = None\n",
    "                                        if sma.verbose2:\n",
    "                                            print(\"best_candidate was\",best_candidate)\n",
    "                                        best_candidate=(d1_data, d2_data, fitness) \n",
    "                                        if sma.verbose2:\n",
    "                                            print(\"best_candidate is\",best_candidate)\n",
    "\n",
    "\n",
    "\n",
    "                            else:\n",
    "                                #redondance avec plus bas\n",
    "                                Spt_ds_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_dep, cand_s[0].stops[cand_s[1]], weight=cand_s[0].pref_weight))\n",
    "                                Spt_ds_v3 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, cand_s[0].stops[cand_e[2]-1],self.v_arr, weight=cand_s[0].pref_weight))\n",
    "                                Spt_ds_v4 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_arr, cand_s[0].stops[cand_e[2]], weight=cand_s[0].pref_weight))\n",
    "                                #condition au départ\n",
    "                                new_arr_s = Spt_ds_v1+Spt_ds_v2+cand_s[0].arr[cand_s[1]-1]\n",
    "                                if new_arr_s - cand_s[0].arr[cand_s[1]] <= cand_s[0].slk[cand_s[1]] :\n",
    "                                    fitness = cand_s[0].arr[cand_e[2]-1]+(new_arr_s-cand_s[0].arr[cand_s[1]])+Spt_ds_v3\n",
    "                                    #condition a l'arrivée\n",
    "                                    if (fitness+Spt_ds_v4-cand_s[0].arr[cand_e[2]]<=cand_s[0].slk[cand_e[2]]) and\\\n",
    "                                    (fitness <= self.l_arr_time) and\\\n",
    "                                    all(cap > 0 for cap in cand_s[0].capacities[cand_s[1]:cand_e[2]]):\n",
    "                                        if best_candidate == None or best_candidate[2]>=fitness:\n",
    "                                            d1_data = (cand_s[0], self.v_dep, self.v_arr, Spt_ds_v1+cand_s[0].arr[cand_s[1]-1], fitness, cand_s[1],cand_e[2]) #d, r_v1, r_v2, dl_v1, dl_v2, idx1, idx2\n",
    "                                            d2_data = None\n",
    "                                        \n",
    "                                            if sma.verbose2:\n",
    "                                                print(\"best_candidate was\",best_candidate)\n",
    "                                            best_candidate=(d1_data, d2_data, fitness) \n",
    "                                            if sma.verbose2:\n",
    "                                                print(\"best_candidate is\",best_candidate)\n",
    "                                            \n",
    "                        #multihop?                    \n",
    "                        else:\n",
    "                            if sma.hop != 'mhop':\n",
    "                                continue\n",
    "                            p_ce = cand_e[0].perceptions[cand_e[1]]\n",
    "#                             if p_ce[3]==p_ce[1] or p_ce[2]==p_ce[0]:\n",
    "#                                 continue\n",
    "                            p_node_ce = set(ox.truncate.truncate_graph_bbox(sma.G, p_ce[3], p_ce[1], p_ce[2], p_ce[0], truncate_by_edge=False, retain_all=False).nodes)\n",
    "                            transfert_nodes = p_node_r.intersection(p_node_cs, p_node_ce)\n",
    "                            \n",
    "                                \n",
    "                            for t_node in transfert_nodes:\n",
    "                                if cand_s[1] == cand_s[2]:\n",
    "                                    #print(self.v_dep, t_node)\n",
    "                                    Spt_ds_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_dep, t_node, weight=cand_s[0].pref_weight))\n",
    "                                    arr_cs_t_node = cand_s[0].arr[cand_s[1]-1] +Spt_ds_v1 + Spt_ds_v2\n",
    "                                    Spt_de_v1 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, cand_e[0].stops[cand_e[1]-1], t_node, weight=cand_e[0].pref_weight))\n",
    "                                    arr_ce_t_node = cand_e[0].arr[cand_e[1]-1] + Spt_de_v1 \n",
    "                                    #si le premier conducteur arrive avant le second\n",
    "                                    if arr_cs_t_node <= arr_ce_t_node:\n",
    "                                        wt_transfert = arr_ce_t_node - arr_cs_t_node \n",
    "                                        Spt_ds_v3 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, t_node, cand_s[0].stops[cand_s[1]], weight=cand_s[0].pref_weight))\n",
    "                                        if arr_cs_t_node+Spt_ds_v3-cand_s[0].arr[cand_s[1]] <=cand_s[0].slk[cand_s[1]] and cand_s[0].capacities[cand_s[1]-1]>0:\n",
    "                                            if cand_e[1] == cand_e[2]:\n",
    "                                                Spt_de_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, t_node, self.v_arr, weight=cand_e[0].pref_weight))\n",
    "                                                Spt_de_v3 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_arr, cand_e[0].stops[cand_e[1]], weight=cand_e[0].pref_weight))\n",
    "                                                if arr_ce_t_node+Spt_de_v2+Spt_de_v3-cand_e[0].arr[cand_e[1]]<=cand_e[0].slk[cand_e[1]] and cand_e[0].capacities[cand_e[1]-1]>0:\n",
    "                                                    #fitness = arr_cs_t_node + wt_transfert + Spt_de_v2\n",
    "                                                    fitness =  arr_ce_t_node + Spt_de_v2\n",
    "                                                    \n",
    "                                                    if fitness <= self.l_arr_time:\n",
    "                                                        if best_candidate == None or best_candidate[2]>fitness:\n",
    "                                                            d1_data = (cand_s[0], self.v_dep, t_node, Spt_ds_v1+cand_s[0].arr[cand_s[1]-1],\\\n",
    "                                                                       arr_cs_t_node, cand_s[1],cand_s[2]) #d, r_v1, r_v2, dl_v1, dl_v2, idx1, idx2\n",
    "                                                            d2_data = (cand_e[0], t_node, self.v_arr, arr_ce_t_node,\\\n",
    "                                                                       fitness, cand_e[1],cand_e[2])\n",
    "                                                            if sma.verbose2:\n",
    "                                                                print(\"best_candidate was\",best_candidate)\n",
    "                                                            best_candidate=(d1_data, d2_data, fitness) \n",
    "                                                            if sma.verbose2:\n",
    "                                                                print(\"best_candidate is\",best_candidate)\n",
    "          \n",
    "                                            else: \n",
    "                                                #redondance avec plus haut\n",
    "                                                Spt_de_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, t_node, cand_e[0].stops[cand_e[1]], weight=cand_e[0].pref_weight))\n",
    "                                                \n",
    "                                                 #condition au départ\n",
    "                                                new_arr_e = Spt_de_v1+Spt_de_v2+cand_e[0].arr[cand_e[1]-1]\n",
    "                                                if new_arr_e - cand_e[0].arr[cand_e[1]]<= cand_e[0].slk[cand_e[1]] :\n",
    "                                                    #condition a l'arrivée\n",
    "                                                    Spt_de_v3 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, cand_e[0].stops[cand_e[2]-1], self.v_arr, weight=cand_e[0].pref_weight))\n",
    "                                                    Spt_de_v4 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_arr, cand_e[0].stops[cand_e[2]], weight=cand_e[0].pref_weight))\n",
    "                                                    fitness = cand_e[0].arr[cand_e[2]-1]+(new_arr_e-cand_e[0].arr[cand_e[1]])+Spt_de_v3\n",
    "                                                    \n",
    "                                                    if (fitness+Spt_de_v4-cand_e[0].arr[cand_e[2]]<=cand_e[0].slk[cand_e[2]]) and (fitness <= self.l_arr_time) and\\\n",
    "                                                    all(cap > 0 for cap in cand_e[0].capacities[cand_e[1]:cand_e[2]]):\n",
    "                \n",
    "                                                        if best_candidate == None or best_candidate[2]>fitness:\n",
    "                                                            d1_data = (cand_s[0], self.v_dep, t_node, Spt_ds_v1+cand_s[0].arr[cand_s[1]-1],\\\n",
    "                                                                       arr_cs_t_node, cand_s[1],cand_s[2]) #d, r_v1, r_v2, dl_v1, dl_v2, idx1, idx2\n",
    "                                                            d2_data = (cand_e[0], t_node, self.v_arr, arr_ce_t_node,\\\n",
    "                                                                       fitness, cand_e[1],cand_e[2])\n",
    "                                        \n",
    "                                                            if sma.verbose2:\n",
    "                                                                print(\"best_candidate was\",best_candidate)\n",
    "                                                            best_candidate=(d1_data, d2_data, fitness) \n",
    "                                                            if sma.verbose2:\n",
    "                                                                print(\"best_candidate is\",best_candidate)\n",
    "                                                               \n",
    "                                else:\n",
    "                                    Spt_ds_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_dep, cand_s[0].stops[cand_s[1]], weight=cand_s[0].pref_weight))\n",
    "                                    new_arr_s = Spt_ds_v1+Spt_ds_v2+cand_s[0].arr[cand_s[1]-1]\n",
    "                                    if new_arr_s - cand_s[0].arr[cand_s[1]] <= cand_s[0].slk[cand_s[1]] :\n",
    "                                        \n",
    "                                        Spt_ds_v3 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, cand_s[0].stops[cand_s[2]-1], t_node, weight=cand_e[0].pref_weight))\n",
    "                                        arr_cs_t_node = cand_s[0].arr[cand_s[2]-1]+(new_arr_s-cand_s[0].arr[cand_s[1]])+Spt_ds_v3\n",
    "                                        \n",
    "                                        Spt_de_v1 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, cand_e[0].stops[cand_e[1]-1], t_node, weight=cand_e[0].pref_weight))\n",
    "                                        arr_ce_t_node = cand_e[0].arr[cand_e[1]-1] + Spt_de_v1 \n",
    "                                        \n",
    "                                        #si le premier conducteur arrive avant le second\n",
    "                                        if arr_cs_t_node <= arr_ce_t_node:\n",
    "                                            wt_transfert =  arr_ce_t_node - arr_cs_t_node\n",
    "                                            #j'ai modif ici cand_s[0].stops[cand_s[2]] 2 a la place de 1\n",
    "                                            Spt_ds_v4 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, t_node, cand_s[0].stops[cand_s[2]], weight=cand_s[0].pref_weight))\n",
    "                                            if arr_cs_t_node + Spt_ds_v4 - cand_s[0].arr[cand_s[2]] <= cand_s[0].slk[cand_s[2]] and all(cap > 0 for cap in cand_s[0].capacities[cand_s[1]:cand_s[2]]):\n",
    "                                                #redondance avec plus haut\n",
    "                                                if cand_e[1] == cand_e[2]:\n",
    "                                                    Spt_de_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, t_node, self.v_arr, weight=cand_e[0].pref_weight))\n",
    "                                                    Spt_de_v3 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_arr, cand_e[0].stops[cand_e[1]], weight=cand_e[0].pref_weight))\n",
    "                                                    fitness = Spt_de_v1+Spt_de_v2+cand_e[0].arr[cand_e[1]-1]\n",
    "                                                    if fitness+Spt_de_v3-cand_e[0].arr[cand_e[1]]<=cand_e[0].slk[cand_e[1]] and cand_e[0].capacities[cand_e[1]-1]>0:\n",
    "                                                        if fitness <= self.l_arr_time:\n",
    "                                                            \n",
    "                                                            if best_candidate == None or best_candidate[2]>fitness:\n",
    "                                                                d1_data = (cand_s[0], self.v_dep, t_node, Spt_ds_v1+cand_s[0].arr[cand_s[1]-1],\\\n",
    "                                                                       arr_cs_t_node, cand_s[1],cand_s[2]) #d, r_v1, r_v2, dl_v1, dl_v2, idx1, idx2\n",
    "                                                                d2_data = (cand_e[0], t_node, self.v_arr, arr_ce_t_node,\\\n",
    "                                                                       fitness, cand_e[1],cand_e[2])\n",
    "                                        \n",
    "                                                                if sma.verbose2:\n",
    "                                                                    print(\"best_candidate was\",best_candidate)\n",
    "                                                                best_candidate=(d1_data, d2_data, fitness) \n",
    "                                                                if sma.verbose2:\n",
    "                                                                    print(\"best_candidate is\",best_candidate)\n",
    "                                                else: \n",
    "                                                    Spt_de_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, t_node, cand_e[0].stops[cand_e[1]], weight=cand_e[0].pref_weight))\n",
    "\n",
    "                                                    #condition au départ\n",
    "                                                    new_arr_e = Spt_de_v1+Spt_de_v2+cand_e[0].arr[cand_e[1]-1]\n",
    "                                                    if new_arr_e - cand_e[0].arr[cand_e[1]]<= cand_e[0].slk[cand_e[1]] :\n",
    "                                                        Spt_de_v3 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, cand_e[0].stops[cand_e[2]-1], self.v_arr, weight=cand_e[0].pref_weight))\n",
    "                                                        Spt_de_v4 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_arr, cand_e[0].stops[cand_e[2]], weight=cand_e[0].pref_weight))\n",
    "                                                        fitness = cand_e[0].arr[cand_e[2]-1]+(new_arr_e-cand_e[0].arr[cand_e[1]])+Spt_de_v3\n",
    "                                        \n",
    "                                                        if (fitness+Spt_de_v4-cand_e[0].arr[cand_e[2]]<=cand_e[0].slk[cand_e[2]]) and\\\n",
    "                                                        (fitness <= self.l_arr_time) and\\\n",
    "                                                        all(cap > 0 for cap in cand_e[0].capacities[cand_e[1]:cand_e[2]]):\n",
    "                                                            \n",
    "                                                            if best_candidate == None or best_candidate[2]>fitness:\n",
    "                                                                d1_data = (cand_s[0], self.v_dep, t_node, Spt_ds_v1+cand_s[0].arr[cand_s[1]-1],\\\n",
    "                                                                       arr_cs_t_node, cand_s[1],cand_s[2]) #d, r_v1, r_v2, dl_v1, dl_v2, idx1, idx2\n",
    "                                                                d2_data = (cand_e[0], t_node, self.v_arr, arr_ce_t_node,\\\n",
    "                                                                       fitness, cand_e[1],cand_e[2])\n",
    "                                        \n",
    "                                                                if sma.verbose2:\n",
    "                                                                    print(\"best_candidate was\",best_candidate)\n",
    "                                                                best_candidate=(d1_data, d2_data, fitness) \n",
    "                                                                if sma.verbose2:\n",
    "                                                                    print(\"best_candidate is\",best_candidate) \n",
    "                                                    \n",
    "                \n",
    "           \n",
    "                \n",
    "                        \n",
    "                    \n",
    "            if(best_candidate != None):\n",
    "                #pass bug\n",
    "                if best_candidate[0][1] == best_candidate[0][2]:\n",
    "                    print(best_candidate)\n",
    "                    best_candidate=(best_candidate[1],None,best_candidate[2])\n",
    "                  \n",
    "                d1 = best_candidate[0][0]\n",
    "                data1 = best_candidate[0][1:]\n",
    "                sma.getAgentFromId(d1.unique_id).add_rider_to_scheduler(self, data1[0], data1[1], data1[2], data1[3], data1[4], data1[5])\n",
    "                sma.getAgentFromId(d1.unique_id).perceptions\n",
    "                #check singlehop\n",
    "                if best_candidate[1] != None:\n",
    "                    d2 = best_candidate[1][0]\n",
    "                    data2 = best_candidate[1][1:]\n",
    "                    sma.getAgentFromId(d2.unique_id).add_rider_to_scheduler(self, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5])\n",
    "                    if sma.verbose:\n",
    "                        print(\"Rider\",self.unique_id,\"multihop with\",d1.unique_id,\"and\",d2.unique_id)\n",
    "                    sma.data['mhop_count']+=1\n",
    "                else:\n",
    "                    if sma.verbose:\n",
    "                        \n",
    "                        print(\"Rider\",self.unique_id,\"single hop with\",d1.unique_id)\n",
    "                    sma.data['shop_count']+=1\n",
    "                    \n",
    "                total_wt = self.wt + data1[2] - sma.tick + wt_transfert\n",
    "                sma.data['r_waiting_time'].append(abs(total_wt))\n",
    "                sma.data['saved_distance']+=self.SPd\n",
    "                self.served = True\n",
    "               \n",
    "                    \n",
    "                #ajoute meilleurs candidats\n",
    "                #notifier conducteur pour ajouter passager\n",
    "            \n",
    "        \n",
    "    \n",
    "    def decide(self):\n",
    "        if not self.served:\n",
    "            self.wt+= 1\n",
    "            if self.wt==self.max_wt:\n",
    "                self.is_alive = False\n",
    "                if sma.verbose:\n",
    "                    print(\"Rider\",self.unique_id,\"cancels.\")\n",
    "                sma.data['r_nb_unmatched'] += 1\n",
    "        else :\n",
    "            self.is_alive = False\n",
    "#             if sma.verbose:\n",
    "#                 print(\"Rider\",self.unique_id,\"found a trip.\")\n",
    "            \n",
    "            \n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ((1,1,3),(2,3,5),6)\n",
    "if a[0][0] == a[0][1]:\n",
    "    a = (a[1],None,a[2])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {1,2,3,6,7,9}\n",
    "b = {1,2,3}\n",
    "\n",
    "len(b-a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TEST 4 : ajout d'un vrai conducteur à un passager (sans verif faisabilité)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounds = 1000\n",
    "sma = SMA()\n",
    "G = sma.G\n",
    "sma.tick = 0\n",
    "orig = list(G)[1]\n",
    "dest = list(G)[120]\n",
    "#d1 = ContinuousDriverAgent(1, orig, dest, detour=0.5, pref_weight='length',test=True)\n",
    "d1 = ContinuousDriverAgent(2, orig, dest, detour_factor=5, pref_weight='travel_time',test=True)\n",
    "sma.addAgent(d1)\n",
    "for _ in range(30):\n",
    "    sma.runOnce()\n",
    "p_cs = d1.perceptions[1]\n",
    "p_node_cs = set(ox.truncate.truncate_graph_bbox(G, p_cs[3], p_cs[1], p_cs[2], p_cs[0], truncate_by_edge=False, retain_all=False).nodes)\n",
    "v1, v2 = random.sample(p_node_cs,2)\n",
    "r1 = RiderAgent(3, v1, v2, detour_factor=10, waiting_time=25, pref_weight='travel_time')\n",
    "sma.addAgent(r1)\n",
    "for _ in range(1000):\n",
    "    sma.runOnce()\n",
    "    #print(d1.stops)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sma.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TEST 5 : Plusieurs conducteurs avec plusieurs passager, test avec contraintes et verif faisabilité, MHOP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NB_RUN = 300\n",
    "MAX_NB_DRIVERS = 10\n",
    "MAX_NB_RIDERS = 10\n",
    "DET_FACTOR_D = 0.25\n",
    "DET_FACTOR_R = 0.5\n",
    "WT = 4\n",
    "#sma = SMA(place='Lille, France')\n",
    "sma = SMA(place='grid', show_graph=True, verbose=True, verbose2=True, hop='mhop')\n",
    "G = sma.G\n",
    "count_id = 1\n",
    "for i in range(MAX_NB_DRIVERS):\n",
    "    v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "    while not nx.has_path(sma.G, v1, v2):\n",
    "        v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "        \n",
    "    d = ContinuousDriverAgent(count_id, v1, v2, detour_factor=DET_FACTOR_D, pref_weight='travel_time',test=False)\n",
    "    sma.addAgent(d)\n",
    "    count_id+=1\n",
    "    \n",
    "for i in range(MAX_NB_RIDERS):\n",
    "    v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "    while not nx.has_path(sma.G, v1, v2):\n",
    "        v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "    r = RiderAgent(count_id, v1, v2, detour_factor=DET_FACTOR_R, waiting_time=WT, pref_weight='travel_time')\n",
    "    sma.addAgent(r)\n",
    "    count_id+=1\n",
    "\n",
    "for _ in range(NB_RUN):\n",
    "    print(\"tick:\",sma.tick)\n",
    "    sma.runOnce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sma.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sma.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "20*(50/3.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 1 tick = 1 secondes\n",
    "- temps : secondes dnas le système, temps d'attente en minutes\n",
    "- distances : metres\n",
    "- vitesse : km/h, converti pour les calculs en m/s\n",
    "\n",
    "### XP1 : Effet du détour conducteur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TIME_LIMIT = 1000 #secondes\n",
    "# SEED = 12\n",
    "\n",
    "# NB_RIDERS = 250\n",
    "# RIDER_FREQUENCY = NB_RIDERS/TIME_LIMIT #nombre de passagers par secondes\n",
    "# DET_FACTOR_R = 0.2\n",
    "# WT_R = 5\n",
    "\n",
    "# NB_DRIVERS = 250\n",
    "# DRIVER_FREQUENCY = NB_DRIVERS/TIME_LIMIT #nombre de conducteurs par secondes\n",
    "# DET_FACTOR_D = [0.2,0.4,0.6,0.8,1]\n",
    "\n",
    "# HOP = ['mhop','shop']\n",
    "# #SEED = [1,6,42,69,48,100,26,35,89,663,559,478,452,236,5789,555,666,777,888,999,111,222,333,444,555]\n",
    "# SEED = [1,6,42,69]\n",
    "# #creation conducteurs et passagers\n",
    "\n",
    "\n",
    "\n",
    "# for det_d in DET_FACTOR_D:\n",
    "#         #creation conducteurs\n",
    "#     for seed in SEED:\n",
    "#         random.seed(SEED)\n",
    "\n",
    "#         riders = []\n",
    "#         for i in range(NB_RIDERS):\n",
    "#             v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "#             while not nx.has_path(sma.G, v1, v2):\n",
    "#                 v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "#             r = RiderAgent(count_id, v1, v2, detour_factor=DET_FACTOR_R, waiting_time=WT, pref_weight='travel_time')\n",
    "#             riders.append(r)\n",
    "#             count_id+=1\n",
    "\n",
    "\n",
    "#         drivers = []\n",
    "#         for i in range(NB_DRIVERS):\n",
    "#             v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "#             while not nx.has_path(sma.G, v1, v2):\n",
    "#                 v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "\n",
    "#             d = ContinuousDriverAgent(count_id, v1, v2, detour_factor=DET_FACTOR_D, pref_weight='travel_time',test=False)\n",
    "#             drivers.append(d)\n",
    "#             count_id+=1\n",
    "\n",
    "\n",
    "\n",
    "#         for hop in HOP:\n",
    "#             sma = SMA(place='grid', show_graph=True, verbose=True, hop='mhop')\n",
    "#             #on ajoute 10% des utilisateurs au départ\n",
    "#             for _ in range(int(NB_DRIVERS/10)):\n",
    "#                 sma.addAgent(drivers.pop())\n",
    "#             for _ in range(int(NB_RIDERS/10)):\n",
    "#                 sma.addAgent(riders.pop())    \n",
    "#             driver_frequency = 0\n",
    "#             riders_frequency = 0\n",
    "\n",
    "#             for _ in range(TIME_LIMIT):\n",
    "#                 print(\"tick:\",sma.tick)\n",
    "\n",
    "#                 driver_frequency+=DRIVER_FREQUENCY\n",
    "#                 while driver_frequency>=1 and len(drivers)>0:\n",
    "#                     sma.addAgent(drivers.pop())\n",
    "#                     driver_frequency-=1\n",
    "\n",
    "#                 riders_frequency+=RIDER_FREQUENCY\n",
    "#                 while riders_frequency>=1 and len(riders)>0:\n",
    "#                     sma.addAgent(riders.pop())\n",
    "#                     driver_frequency-=1\n",
    "\n",
    "#                 sma.runOnce()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TIME_LIMIT = 500 #secondes\n",
    "\n",
    "NB_RIDERS = 75\n",
    "WT_R = 3\n",
    "RIDER_FREQUENCY = NB_RIDERS/(TIME_LIMIT-(WT_R*60)) #nombre de passagers par secondes\n",
    "print(\"Frequence d'apparition passager:\",RIDER_FREQUENCY,\"par secondes.\")\n",
    "DET_FACTOR_R = 0.5\n",
    "\n",
    "\n",
    "NB_DRIVERS = 100\n",
    "DRIVER_FREQUENCY = NB_DRIVERS/(TIME_LIMIT-(WT_R*60)) #nombre de conducteurs par secondes\n",
    "print(\"Frequence d'apparition conducteurs:\",DRIVER_FREQUENCY,\"par secondes.\")\n",
    "DET_FACTOR_D = [1,0.75,0.5,0.25]\n",
    "#DET_FACTOR_D = [0.5,0.25]\n",
    "#DET_FACTOR_D = [0.1,0.2]\n",
    "HOP = ['mhop','shop']\n",
    "#SEED = [1,6,42,69,48,100,26,35,89,663,559,478,452,236,5789,555,666,777,888,999,111,222,333,444,555]\n",
    "SEED = [1,42,36]\n",
    "#SEED = [3,6]\n",
    "\n",
    "# TIME_LIMIT = 1000 #secondes\n",
    "\n",
    "# NB_RIDERS = 30\n",
    "# RIDER_FREQUENCY = NB_RIDERS/TIME_LIMIT #nombre de passagers par secondes\n",
    "# DET_FACTOR_R = 0.2\n",
    "# WT_R = 5\n",
    "\n",
    "# NB_DRIVERS = 30\n",
    "# DRIVER_FREQUENCY = NB_DRIVERS/TIME_LIMIT #nombre de conducteurs par secondes\n",
    "# #DET_FACTOR_D = [0.2,0.4,0.6,0.8,1]\n",
    "# DET_FACTOR_D = [0.4,0.6]\n",
    "# HOP = ['mhop','shop']\n",
    "# #SEED = [1,6,42,69,48,100,26,35,89,663,559,478,452,236,5789,555,666,777,888,999,111,222,333,444,555]\n",
    "# #SEED = [1,6,42,69]\n",
    "# SEED = [3,6]\n",
    "\n",
    "\n",
    "results = []\n",
    "\n",
    "for hop in HOP:\n",
    "    \n",
    "    mean_nb_unmatched = []\n",
    "    mean_waiting_time = []\n",
    "    mean_trip_length = []\n",
    "    mean_trip_time = []\n",
    "    mean_nb_shop = []\n",
    "    mean_nb_mhop = []\n",
    "    mean_saved_distance = []\n",
    "    \n",
    "        \n",
    "    for det_d in DET_FACTOR_D:\n",
    "        local_mean_nb_unmatched = []\n",
    "        local_mean_waiting_time = []\n",
    "        local_mean_trip_length = []\n",
    "        local_mean_trip_time = []\n",
    "        local_mean_nb_shop = []\n",
    "        local_mean_nb_mhop = []\n",
    "        local_mean_saved_distance = []\n",
    "        \n",
    "        for seed in SEED:\n",
    "            random.seed(seed)\n",
    "            count_id = 0\n",
    "            sma = SMA(place='grid', show_graph=False, verbose=True, hop=hop)\n",
    "\n",
    "            riders_nodes = []\n",
    "            for _ in range(NB_RIDERS):\n",
    "                v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "                while not nx.has_path(sma.G, v1, v2):\n",
    "                    v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "                riders_nodes.append((v1, v2))\n",
    "\n",
    "\n",
    "            drivers_nodes = []\n",
    "            for _ in range(NB_DRIVERS):\n",
    "                v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "                while not nx.has_path(sma.G, v1, v2):\n",
    "                    v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "                drivers_nodes.append((v1,v2))\n",
    "               \n",
    "        \n",
    "            #on ajoute 10% des utilisateurs au départ\n",
    "            for _ in range(int(NB_DRIVERS/10)):\n",
    "                v1, v2 = drivers_nodes.pop()\n",
    "                d = ContinuousDriverAgent(count_id, v1, v2, detour_factor=det_d, pref_weight='travel_time',test=False)\n",
    "                sma.addAgent(d)\n",
    "                count_id+=1\n",
    "                \n",
    "            for _ in range(int(NB_RIDERS/10)):\n",
    "                v1, v2 = riders_nodes.pop()\n",
    "                r = RiderAgent(count_id, v1, v2, detour_factor=DET_FACTOR_R, waiting_time=WT_R, pref_weight='travel_time')\n",
    "                sma.addAgent(r)\n",
    "                count_id+=1  \n",
    "                \n",
    "                \n",
    "                \n",
    "            drivers_frequency = 0\n",
    "            riders_frequency = 0\n",
    "\n",
    "            for _ in range(TIME_LIMIT):\n",
    "                if sma.tick%int(TIME_LIMIT/10)==0:\n",
    "                    print(\"tick:\",sma.tick)\n",
    "\n",
    "                drivers_frequency+=DRIVER_FREQUENCY\n",
    "                while drivers_frequency>=1 and len(drivers_nodes)>0:\n",
    "                    v1, v2 = drivers_nodes.pop()\n",
    "                    d = ContinuousDriverAgent(count_id, v1, v2, detour_factor=det_d, pref_weight='travel_time',test=False)\n",
    "                    sma.addAgent(d)\n",
    "                    #print(\"new_d\")\n",
    "                    count_id+=1\n",
    "                    drivers_frequency-=1\n",
    "\n",
    "                riders_frequency+=RIDER_FREQUENCY\n",
    "                \n",
    "    \n",
    "                while riders_frequency>=1 and len(riders_nodes)>0:\n",
    "                    v1, v2 = riders_nodes.pop()\n",
    "                    r = RiderAgent(count_id, v1, v2, detour_factor=DET_FACTOR_R, waiting_time=WT_R, pref_weight='travel_time')\n",
    "                    sma.addAgent(r)\n",
    "                    #print(\"new_r\")\n",
    "                    count_id+=1  \n",
    "                    riders_frequency-=1\n",
    "                \n",
    "                sma.runOnce()\n",
    "                \n",
    "            #on récupère les données\n",
    "            local_mean_trip_time.append(np.mean(sma.data['d_trip_time']))\n",
    "            print(local_mean_trip_time)\n",
    "            local_mean_waiting_time.append(np.mean(sma.data['r_waiting_time']))\n",
    "            print(local_mean_waiting_time)\n",
    "            local_mean_trip_length.append(np.mean(sma.data['d_trip_length']))\n",
    "            print(local_mean_trip_length)\n",
    "            local_mean_nb_unmatched.append(sma.data['r_nb_unmatched'])\n",
    "            print(local_mean_nb_unmatched)\n",
    "            local_mean_nb_shop.append(sma.data['shop_count'])\n",
    "            print(local_mean_nb_shop)\n",
    "            local_mean_nb_mhop.append(sma.data['mhop_count'])\n",
    "            print(local_mean_nb_mhop)\n",
    "            local_mean_saved_distance.append(sma.data['saved_distance'])\n",
    "            print(local_mean_saved_distance)\n",
    "            \n",
    "\n",
    "        mean_trip_time.append((np.mean(local_mean_trip_time),np.std(local_mean_trip_time)))\n",
    "        mean_waiting_time.append((np.mean(local_mean_waiting_time),np.std(local_mean_waiting_time)))\n",
    "        mean_trip_length.append((np.mean(local_mean_trip_length),np.std(local_mean_trip_length)))\n",
    "        mean_nb_unmatched.append((np.mean(local_mean_nb_unmatched),np.std(local_mean_nb_unmatched)))\n",
    "        mean_nb_shop.append((np.mean(local_mean_nb_shop),np.std(local_mean_nb_shop)))\n",
    "        mean_nb_mhop.append((np.mean(local_mean_nb_mhop),np.std(local_mean_nb_mhop)))\n",
    "        mean_saved_distance.append((np.mean(local_mean_saved_distance),np.std(local_mean_saved_distance)))\n",
    "        print(hop, det_d, \"finished.\")  \n",
    "            \n",
    "    results.append([mean_trip_time, mean_waiting_time, mean_trip_length, mean_nb_unmatched, mean_saved_distance, mean_nb_shop, mean_nb_mhop])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### XP minimale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TIME_LIMIT = 500 #secondes\n",
    "\n",
    "NB_RIDERS = 10\n",
    "WT_R = 3\n",
    "DET_FACTOR_R = 0.2\n",
    "\n",
    "\n",
    "NB_DRIVERS = 15\n",
    "DET_FACTOR_D = [0.25,0.5,0.75,1]\n",
    "#DET_FACTOR_D = [0.1,0.2]\n",
    "HOP = ['mhop','shop']\n",
    "#SEED = [1,6,42,69,48,100,26,35,89,663,559,478,452,236,5789,555,666,777,888,999,111,222,333,444,555]\n",
    "SEED = [1,42,58,96,35,64,72]\n",
    "\n",
    "results = []\n",
    "\n",
    "for hop in HOP:\n",
    "    \n",
    "    mean_nb_unmatched = []\n",
    "    mean_waiting_time = []\n",
    "    mean_trip_length = []\n",
    "    mean_trip_time = []\n",
    "    mean_nb_shop = []\n",
    "    mean_nb_mhop = []\n",
    "    mean_saved_distance = []\n",
    "    \n",
    "        \n",
    "    for det_d in DET_FACTOR_D:\n",
    "        local_mean_nb_unmatched = []\n",
    "        local_mean_waiting_time = []\n",
    "        local_mean_trip_length = []\n",
    "        local_mean_trip_time = []\n",
    "        local_mean_nb_shop = []\n",
    "        local_mean_nb_mhop = []\n",
    "        local_mean_saved_distance = []\n",
    "        \n",
    "        for seed in SEED:\n",
    "            random.seed(seed)\n",
    "            count_id = 0\n",
    "            sma = SMA(place='grid',show_graph=False, verbose=True, hop=hop)\n",
    "\n",
    "           \n",
    "            for i in range(NB_RIDERS):\n",
    "                v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "                while not nx.has_path(sma.G, v1, v2):\n",
    "                    v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "                r = RiderAgent(count_id, v1, v2, detour_factor=DET_FACTOR_R, waiting_time=WT_R, pref_weight='travel_time')\n",
    "                sma.addAgent(r)\n",
    "                count_id+=1\n",
    "\n",
    "\n",
    "\n",
    "            for i in range(NB_DRIVERS):\n",
    "                v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "                while not nx.has_path(sma.G, v1, v2):\n",
    "                    v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "\n",
    "                d = ContinuousDriverAgent(count_id, v1, v2, detour_factor=det_d, pref_weight='travel_time',test=False)\n",
    "                sma.addAgent(d)\n",
    "                count_id+=1\n",
    "\n",
    "\n",
    "            for _ in range(TIME_LIMIT):\n",
    "                if sma.tick%int(TIME_LIMIT/10)==0:\n",
    "                    print(\"tick:\",sma.tick)             \n",
    "                sma.runOnce()\n",
    "\n",
    "            #on récupère les données\n",
    "            local_mean_trip_time.append(np.mean(sma.data['d_trip_time']))\n",
    "            print(local_mean_trip_time)\n",
    "            local_mean_waiting_time.append(np.mean(sma.data['r_waiting_time']))\n",
    "            print(local_mean_waiting_time)\n",
    "            local_mean_trip_length.append(np.mean(sma.data['d_trip_length']))\n",
    "            print(local_mean_trip_length)\n",
    "            local_mean_nb_unmatched.append(sma.data['r_nb_unmatched'])\n",
    "            print(local_mean_nb_unmatched)\n",
    "            local_mean_nb_shop.append(sma.data['shop_count'])\n",
    "            print(local_mean_nb_shop)\n",
    "            local_mean_nb_mhop.append(sma.data['mhop_count'])\n",
    "            print(local_mean_nb_mhop)\n",
    "            local_mean_saved_distance.append(sma.data['saved_distance'])\n",
    "            print(local_mean_saved_distance)\n",
    "            \n",
    "\n",
    "        mean_trip_time.append((np.mean(local_mean_trip_time),np.std(local_mean_trip_time)))\n",
    "        mean_waiting_time.append((np.mean(local_mean_waiting_time),np.std(local_mean_waiting_time)))\n",
    "        mean_trip_length.append((np.mean(local_mean_trip_length),np.std(local_mean_trip_length)))\n",
    "        mean_nb_unmatched.append((np.mean(local_mean_nb_unmatched),np.std(local_mean_nb_unmatched)))\n",
    "        mean_nb_shop.append((np.mean(local_mean_nb_shop),np.std(local_mean_nb_shop)))\n",
    "        mean_nb_mhop.append((np.mean(local_mean_nb_mhop),np.std(local_mean_nb_mhop)))\n",
    "        mean_saved_distance.append((np.mean(local_mean_saved_distance),np.std(local_mean_saved_distance)))\n",
    "\n",
    "        print(hop, det_d, \"finished.\")  \n",
    "            \n",
    "    results.append([mean_trip_time, mean_waiting_time, mean_trip_length, mean_nb_unmatched, mean_saved_distance, mean_nb_shop, mean_nb_mhop])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "entries = [\"Mean trip time of drivers (s)\", \"Mean waiting time of riders (s)\", \n",
    "           \"Mean trip length of drivers (meters)\", \"Number of unmatched riders\", \"Saved distance (meters)\"]\n",
    "\n",
    "for i in range(len(entries)) :\n",
    "    f = plt.figure(figsize=(15, 5))\n",
    "    for j in range(len(HOP)):\n",
    "        avg = [x for x,_ in results[j][i]]\n",
    "        std = [x for _,x in results[j][i]]\n",
    "        plt.plot(DET_FACTOR_D, avg, label = HOP[j])\n",
    "        plt.fill_between(DET_FACTOR_D, np.add(avg,std), np.subtract(avg,std), alpha=0.2)\n",
    "\n",
    "    plt.xlabel('Drivers detour')\n",
    "    plt.ylabel(entries[i])\n",
    "    plt.legend()\n",
    "    \n",
    "    #entry = entries[i].replace(' ','_').split(\"(\")[0]\n",
    "    #path = '/home/fevrec/Documents/These/these/smac_agents/img/paper_v3/xp2/raw/'+entry+'_max_d_'+str(MAX_NB_DRIVERS[-1])+'.pdf'\n",
    "    #plt.savefig(path)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiprocessing xp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting computations on 16 cores\n",
      "mhop 0.8 begins\n",
      "mhop 0.4 begins\n",
      "mhop 0.6 begins\n",
      "mhop 1 begins\n",
      "shop 1 begins\n",
      "shop 0.8 begins\n",
      "shop 0.4 begins\n",
      "mhop 0.2 begins\n",
      "shop 0.6 begins\n",
      "shop 0.2 begins\n",
      "mhop 0.8 tick: 0\n",
      "mhop 0.6 tick: 0\n",
      "shop 0.2 tick: 0\n",
      "shop 0.8 tick: 0\n",
      "shop 0.4 tick: 0\n",
      "shop 1 tick: 0\n",
      "mhop 1 tick: 0\n",
      "mhop 0.2 tick: 0\n",
      "mhop 0.4 tick: 0\n",
      "shop 0.6 tick: 0\n",
      "shop 1 tick: 175\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Process ForkPoolWorker-85:\n",
      "Process ForkPoolWorker-83:\n",
      "Process ForkPoolWorker-91:\n",
      "Process ForkPoolWorker-92:\n",
      "Traceback (most recent call last):\n",
      "Process ForkPoolWorker-90:\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 47, in starmapstar\n",
      "    return list(itertools.starmap(args[0], args[1]))\n",
      "  File \"<ipython-input-13-68f22ebd528a>\", line 95, in power\n",
      "    sma.runOnce()\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"<ipython-input-4-3aa320f1ecc3>\", line 144, in runOnce\n",
      "    ag.update()\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "Process ForkPoolWorker-81:\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n",
      "    task = get()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n",
      "    task = get()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 47, in starmapstar\n",
      "    return list(itertools.starmap(args[0], args[1]))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n",
      "    with self._rlock:\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "Process ForkPoolWorker-88:\n",
      "  File \"<ipython-input-5-b2fd8e053726>\", line 258, in update\n",
      "    Spt_ds_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_dep, t_node, weight=cand_s[0].pref_weight))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/osmnx/distance.py\", line 478, in shortest_path\n",
      "    path = nx.shortest_path(G, orig, dest, weight=weight)\n",
      "Process ForkPoolWorker-86:\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/generic.py\", line 162, in shortest_path\n",
      "    paths = nx.dijkstra_path(G, source, target, weight)\n",
      "  File \"<ipython-input-13-68f22ebd528a>\", line 95, in power\n",
      "    sma.runOnce()\n",
      "KeyboardInterrupt\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"<ipython-input-4-3aa320f1ecc3>\", line 144, in runOnce\n",
      "    ag.update()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/weighted.py\", line 157, in dijkstra_path\n",
      "    (length, path) = single_source_dijkstra(G, source, target=target, weight=weight)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/weighted.py\", line 465, in single_source_dijkstra\n",
      "    G, {source}, cutoff=cutoff, target=target, weight=weight\n",
      "Process ForkPoolWorker-82:\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "KeyboardInterrupt\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/weighted.py\", line 723, in multi_source_dijkstra\n",
      "    G, sources, weight, paths=paths, cutoff=cutoff, target=target\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 47, in starmapstar\n",
      "    return list(itertools.starmap(args[0], args[1]))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "Process ForkPoolWorker-84:\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/weighted.py\", line 821, in _dijkstra_multisource\n",
      "    cost = weight(v, u, e)\n",
      "  File \"<ipython-input-5-b2fd8e053726>\", line 258, in update\n",
      "    Spt_ds_v2 = compute_shortest_path_time(sma.G, ox.shortest_path(sma.G, self.v_dep, t_node, weight=cand_s[0].pref_weight))\n",
      "  File \"<ipython-input-13-68f22ebd528a>\", line 95, in power\n",
      "    sma.runOnce()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/osmnx/distance.py\", line 478, in shortest_path\n",
      "    path = nx.shortest_path(G, orig, dest, weight=weight)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/weighted.py\", line 77, in <lambda>\n",
      "    return lambda u, v, d: min(attr.get(weight, 1) for attr in d.values())\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 47, in starmapstar\n",
      "    return list(itertools.starmap(args[0], args[1]))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/generic.py\", line 162, in shortest_path\n",
      "    paths = nx.dijkstra_path(G, source, target, weight)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 47, in starmapstar\n",
      "    return list(itertools.starmap(args[0], args[1]))\n",
      "Traceback (most recent call last):\n",
      "Process ForkPoolWorker-89:\n",
      "  File \"<ipython-input-13-68f22ebd528a>\", line 95, in power\n",
      "    sma.runOnce()\n",
      "  File \"<ipython-input-13-68f22ebd528a>\", line 95, in power\n",
      "    sma.runOnce()\n",
      "KeyboardInterrupt\n",
      "  File \"<ipython-input-4-3aa320f1ecc3>\", line 144, in runOnce\n",
      "    ag.update()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"<ipython-input-4-3aa320f1ecc3>\", line 144, in runOnce\n",
      "    ag.update()\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Traceback (most recent call last):\n",
      "Process ForkPoolWorker-87:\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"<ipython-input-5-b2fd8e053726>\", line 180, in update\n",
      "    p_node_cs = set(ox.truncate.truncate_graph_bbox(sma.G, p_cs[3], p_cs[1], p_cs[2], p_cs[0], truncate_by_edge=False, retain_all=False).nodes)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/weighted.py\", line 157, in dijkstra_path\n",
      "    (length, path) = single_source_dijkstra(G, source, target=target, weight=weight)\n",
      "  File \"<ipython-input-5-b2fd8e053726>\", line 180, in update\n",
      "    p_node_cs = set(ox.truncate.truncate_graph_bbox(sma.G, p_cs[3], p_cs[1], p_cs[2], p_cs[0], truncate_by_edge=False, retain_all=False).nodes)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/osmnx/truncate.py\", line 113, in truncate_graph_bbox\n",
      "    min_num=min_num,\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/weighted.py\", line 465, in single_source_dijkstra\n",
      "    G, {source}, cutoff=cutoff, target=target, weight=weight\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/osmnx/truncate.py\", line 113, in truncate_graph_bbox\n",
      "    min_num=min_num,\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 47, in starmapstar\n",
      "    return list(itertools.starmap(args[0], args[1]))\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/networkx/algorithms/shortest_paths/weighted.py\", line 723, in multi_source_dijkstra\n",
      "    G, sources, weight, paths=paths, cutoff=cutoff, target=target\n",
      "  File \"<ipython-input-13-68f22ebd528a>\", line 95, in power\n",
      "    sma.runOnce()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/osmnx/truncate.py\", line 156, in truncate_graph_polygon\n",
      "    to_keep = utils_geo._intersect_index_quadrats(gs_nodes, polygon, quadrat_width, min_num)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/osmnx/truncate.py\", line 156, in truncate_graph_polygon\n",
      "    to_keep = utils_geo._intersect_index_quadrats(gs_nodes, polygon, quadrat_width, min_num)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/osmnx/utils_geo.py\", line 380, in _intersect_index_quadrats\n",
      "    possible_matches = geometries.iloc[list(possible_matches_iloc)]\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/osmnx/utils_geo.py\", line 381, in _intersect_index_quadrats\n",
      "    precise_matches = possible_matches[possible_matches.intersects(poly)]\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 47, in starmapstar\n",
      "    return list(itertools.starmap(args[0], args[1]))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/pandas/core/indexing.py\", line 895, in __getitem__\n",
      "    return self._getitem_axis(maybe_callable, axis=axis)\n",
      "  File \"<ipython-input-4-3aa320f1ecc3>\", line 144, in runOnce\n",
      "    ag.update()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/geopandas/geodataframe.py\", line 1299, in __getitem__\n",
      "    result = super(GeoDataFrame, self).__getitem__(key)\n",
      "  File \"<ipython-input-13-68f22ebd528a>\", line 95, in power\n",
      "    sma.runOnce()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/pandas/core/indexing.py\", line 1492, in _getitem_axis\n",
      "    return self._get_list_axis(key, axis=axis)\n",
      "  File \"<ipython-input-5-b2fd8e053726>\", line 180, in update\n",
      "    p_node_cs = set(ox.truncate.truncate_graph_bbox(sma.G, p_cs[3], p_cs[1], p_cs[2], p_cs[0], truncate_by_edge=False, retain_all=False).nodes)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/pandas/core/frame.py\", line 3015, in __getitem__\n",
      "    return self._getitem_bool_array(key)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/osmnx/truncate.py\", line 113, in truncate_graph_bbox\n",
      "    min_num=min_num,\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 47, in starmapstar\n",
      "    return list(itertools.starmap(args[0], args[1]))\n",
      "  File \"<ipython-input-4-3aa320f1ecc3>\", line 144, in runOnce\n",
      "    ag.update()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/pandas/core/indexing.py\", line 1474, in _get_list_axis\n",
      "    return self.obj._take_with_is_copy(key, axis=axis)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/pandas/core/frame.py\", line 3070, in _getitem_bool_array\n",
      "    return self._take_with_is_copy(indexer, axis=0)\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\", line 121, in worker\n",
      "    result = (True, func(*args, **kwds))\n",
      "  File \"<ipython-input-4-3aa320f1ecc3>\", line 144, in runOnce\n",
      "    ag.update()\n",
      "  File \"/home/fevrec/Applications/anaconda3/lib/python3.7/site-packages/pandas/core/generic.py\", line 3602, in _take_with_is_copy\n",
      "    if not result._get_axis(axis).equals(self._get_axis(axis)):\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-68f22ebd528a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m    151\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    152\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__name__\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'__main__'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 153\u001b[0;31m     \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-13-68f22ebd528a>\u001b[0m in \u001b[0;36mmain\u001b[0;34m()\u001b[0m\n\u001b[1;32m    143\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    144\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mPool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 145\u001b[0;31m         \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstarmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpower\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    146\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    147\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\u001b[0m in \u001b[0;36mstarmap\u001b[0;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[1;32m    274\u001b[0m         \u001b[0;31m`\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;31m`\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0mbecomes\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    275\u001b[0m         '''\n\u001b[0;32m--> 276\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_map_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstarmapstar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    277\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    278\u001b[0m     def starmap_async(self, func, iterable, chunksize=None, callback=None,\n",
      "\u001b[0;32m~/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    649\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    650\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 651\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    652\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mready\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    653\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Applications/anaconda3/lib/python3.7/multiprocessing/pool.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    646\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    647\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 648\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_event\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    649\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    650\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Applications/anaconda3/lib/python3.7/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    550\u001b[0m             \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    551\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 552\u001b[0;31m                 \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cond\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    553\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    554\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Applications/anaconda3/lib/python3.7/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    294\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m    \u001b[0;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    295\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 296\u001b[0;31m                 \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    297\u001b[0m                 \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    298\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import time\n",
    "from timeit import default_timer as timer\n",
    "from multiprocessing import Pool, cpu_count\n",
    "\n",
    "def power(hop, det_d):\n",
    "    print(hop,det_d,\"begins\")\n",
    "    TIME_LIMIT = 700 #secondes\n",
    "\n",
    "    NB_RIDERS = 75\n",
    "    WT_R = 3\n",
    "    RIDER_FREQUENCY = NB_RIDERS/(TIME_LIMIT-(WT_R*60)) #nombre de passagers par secondes\n",
    "    #print(\"Frequence d'apparition passager:\",RIDER_FREQUENCY,\"par secondes.\")\n",
    "    DET_FACTOR_R = 0.3\n",
    "\n",
    "\n",
    "    NB_DRIVERS = 100\n",
    "    DRIVER_FREQUENCY = NB_DRIVERS/(TIME_LIMIT-(WT_R*60)) #nombre de conducteurs par secondes\n",
    "    #print(\"Frequence d'apparition conducteurs:\",DRIVER_FREQUENCY,\"par secondes.\")\n",
    "    \n",
    "    \n",
    "    SEED = [1,150]\n",
    "    \n",
    "        \n",
    "\n",
    "    local_mean_nb_unmatched = []\n",
    "    local_mean_waiting_time = []\n",
    "    local_mean_trip_length = []\n",
    "    local_mean_trip_time = []\n",
    "    local_mean_nb_shop = []\n",
    "    local_mean_nb_mhop = []\n",
    "    local_mean_saved_distance = []\n",
    "        \n",
    "    for seed in SEED:\n",
    "        random.seed(seed)\n",
    "        count_id = 0\n",
    "        global sma\n",
    "        sma = SMA(place='grid', show_graph=False, verbose=False, hop=hop)\n",
    "\n",
    "        riders_nodes = []\n",
    "        for _ in range(NB_RIDERS):\n",
    "            v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "            while not nx.has_path(sma.G, v1, v2):\n",
    "                v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "            riders_nodes.append((v1, v2))\n",
    "\n",
    "\n",
    "        drivers_nodes = []\n",
    "        for _ in range(NB_DRIVERS):\n",
    "            v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "            while not nx.has_path(sma.G, v1, v2):\n",
    "                v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "            drivers_nodes.append((v1,v2))\n",
    "               \n",
    "        \n",
    "        #on ajoute 10% des utilisateurs au départ\n",
    "        for _ in range(int(NB_DRIVERS/10)):\n",
    "            v1, v2 = drivers_nodes.pop()\n",
    "            d = ContinuousDriverAgent(count_id, v1, v2, detour_factor=det_d, pref_weight='travel_time',test=False)\n",
    "            sma.addAgent(d)\n",
    "            count_id+=1\n",
    "                \n",
    "        for _ in range(int(NB_RIDERS/10)):\n",
    "            v1, v2 = riders_nodes.pop()\n",
    "            r = RiderAgent(count_id, v1, v2, detour_factor=DET_FACTOR_R, waiting_time=WT_R, pref_weight='travel_time')\n",
    "            sma.addAgent(r)\n",
    "            count_id+=1  \n",
    "                \n",
    "                \n",
    "                \n",
    "        drivers_frequency = 0\n",
    "        riders_frequency = 0\n",
    "\n",
    "        for _ in range(TIME_LIMIT):\n",
    "            if sma.tick%int(TIME_LIMIT/4)==0:\n",
    "                print(hop,det_d,\"tick:\",sma.tick)\n",
    "\n",
    "            drivers_frequency+=DRIVER_FREQUENCY\n",
    "            while drivers_frequency>=1 and len(drivers_nodes)>0:\n",
    "                v1, v2 = drivers_nodes.pop()\n",
    "                d = ContinuousDriverAgent(count_id, v1, v2, detour_factor=det_d, pref_weight='travel_time',test=False)\n",
    "                sma.addAgent(d)\n",
    "                    #print(\"new_d\")\n",
    "                count_id+=1\n",
    "                drivers_frequency-=1\n",
    "\n",
    "            riders_frequency+=RIDER_FREQUENCY\n",
    "            while riders_frequency>=1 and len(riders_nodes)>0:\n",
    "                v1, v2 = riders_nodes.pop()\n",
    "                r = RiderAgent(count_id, v1, v2, detour_factor=DET_FACTOR_R, waiting_time=WT_R, pref_weight='travel_time')\n",
    "                sma.addAgent(r)\n",
    "                #print(\"new_r\")\n",
    "                count_id+=1  \n",
    "                riders_frequency-=1\n",
    "                \n",
    "            sma.runOnce()\n",
    "            \n",
    "        #on récupère les données\n",
    "        local_mean_trip_time.append(np.mean(sma.data['d_trip_time']))\n",
    "#         print(local_mean_trip_time)\n",
    "        local_mean_waiting_time.append(np.mean(sma.data['r_waiting_time']))\n",
    "#         print(local_mean_waiting_time)\n",
    "        local_mean_trip_length.append(np.mean(sma.data['d_trip_length']))\n",
    "#         print(local_mean_trip_length)\n",
    "        local_mean_nb_unmatched.append(sma.data['r_nb_unmatched'])\n",
    "#         print(local_mean_nb_unmatched)\n",
    "        local_mean_nb_shop.append(sma.data['shop_count'])\n",
    "#         print(local_mean_nb_shop)\n",
    "        local_mean_nb_mhop.append(sma.data['mhop_count'])\n",
    "#         print(local_mean_nb_mhop)\n",
    "        local_mean_saved_distance.append(sma.data['saved_distance'])\n",
    "#         print(local_mean_saved_distance)\n",
    "        print(hop,det_d,seed,\"finished\")        \n",
    "\n",
    "            \n",
    "\n",
    "    mean_trip_time=((np.mean(local_mean_trip_time),np.std(local_mean_trip_time)))\n",
    "    mean_waiting_time=((np.mean(local_mean_waiting_time),np.std(local_mean_waiting_time)))\n",
    "    mean_trip_length=((np.mean(local_mean_trip_length),np.std(local_mean_trip_length)))\n",
    "    mean_nb_unmatched=((np.mean(local_mean_nb_unmatched),np.std(local_mean_nb_unmatched)))\n",
    "    mean_nb_shop=((np.mean(local_mean_nb_shop),np.std(local_mean_nb_shop)))\n",
    "    mean_nb_mhop=((np.mean(local_mean_nb_mhop),np.std(local_mean_nb_mhop)))\n",
    "    mean_saved_distance=((np.mean(local_mean_saved_distance),np.std(local_mean_saved_distance)))\n",
    "\n",
    "        \n",
    "    print(hop,det_d,\"finished\")        \n",
    "    \n",
    "    return [hop, det_d, mean_trip_time, mean_waiting_time, mean_trip_length, mean_nb_unmatched, mean_saved_distance, mean_nb_shop, mean_nb_mhop]\n",
    "\n",
    "\n",
    "def main():\n",
    "    DET_FACTOR_D = [1,0.8,0.6,0.4,0.2]\n",
    "    HOP = ['mhop','shop']\n",
    "    values = []\n",
    "    res = None\n",
    "    #DET_FACTOR_D = [0.1,0.2]\n",
    "    for hop in HOP:\n",
    "        for det_d in DET_FACTOR_D:\n",
    "            values.append((hop,det_d))\n",
    "   \n",
    "    start = timer()\n",
    "\n",
    "    print(f'starting computations on {cpu_count()} cores')\n",
    "\n",
    "    with Pool() as pool:\n",
    "        res = pool.starmap(power, values)\n",
    "        print(res)\n",
    "\n",
    "    end = timer()\n",
    "    print(f'elapsed time: {end - start}')\n",
    "    return res\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    res = main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting computations on 16 cores\n",
      "mhop 0.6 begins\n",
      "mhop 0.8 begins\n",
      "mhop 1 begins\n",
      "mhop 0.4 begins\n",
      "shop 1 begins\n",
      "shop 0.8 begins\n",
      "mhop 0.2 begins\n",
      "shop 0.6 begins\n",
      "shop 0.4 begins\n",
      "shop 0.2 begins\n",
      "shop 0.2 tick: 0\n",
      "shop 1 tick: 0\n",
      "mhop 1 tick: 0\n",
      "shop 0.4 tick: 0\n",
      "mhop 0.2 tick: 0\n",
      "shop 0.6 tick: 0\n",
      "mhop 0.6 tick: 0\n",
      "shop 0.8 tick: 0\n",
      "mhop 0.8 tick: 0\n",
      "mhop 0.4 tick: 0\n",
      "shop 1 tick: 162\n",
      "shop 0.6 tick: 162\n",
      "shop 0.8 tick: 162\n",
      "mhop 1 tick: 162\n",
      "mhop 0.8 tick: 162\n",
      "shop 0.4 tick: 162\n",
      "shop 1 tick: 324\n",
      "shop 0.2 tick: 162\n",
      "mhop 0.6 tick: 162\n",
      "shop 0.8 tick: 324\n",
      "shop 0.6 tick: 324\n",
      "mhop 0.4 tick: 162\n",
      "shop 1 tick: 486\n",
      "shop 1 tick: 648\n",
      "shop 1 finished\n",
      "mhop 1 tick: 324\n",
      "shop 0.8 tick: 486\n",
      "shop 0.8 tick: 648\n",
      "shop 0.8 finished\n",
      "shop 0.6 tick: 486\n",
      "shop 0.6 tick: 648\n",
      "shop 0.6 finished\n",
      "mhop 0.8 tick: 324\n",
      "shop 0.4 tick: 324\n",
      "mhop 1 tick: 486\n",
      "mhop 1 tick: 648\n",
      "mhop 1 finished\n",
      "shop 0.2 tick: 324\n",
      "mhop 0.2 tick: 162\n",
      "shop 0.4 tick: 486\n",
      "shop 0.4 tick: 648\n",
      "shop 0.4 finished\n",
      "mhop 0.6 tick: 324\n",
      "mhop 0.8 tick: 486\n",
      "mhop 0.8 tick: 648\n",
      "mhop 0.8 finished\n",
      "mhop 0.4 tick: 324\n",
      "shop 0.2 tick: 486\n",
      "shop 0.2 tick: 648\n",
      "shop 0.2 finished\n",
      "mhop 0.6 tick: 486\n",
      "mhop 0.6 tick: 648\n",
      "mhop 0.6 finished\n",
      "mhop 0.4 tick: 486\n",
      "mhop 0.4 tick: 648\n",
      "mhop 0.4 finished\n",
      "mhop 0.2 tick: 324\n",
      "mhop 0.2 tick: 486\n",
      "mhop 0.2 tick: 648\n",
      "mhop 0.2 finished\n",
      "[['mhop', 1, [35.0, 56.0, 44.0, 72.0, 86.0, 21.0, 89.0, 96.0, 110.0, 125.0, 44.0, 153.0, 150.0, 100.0, 32.0, 112.0, 176.0, 55.0, 22.0, 169.0, 148.0, 39.0, 11.0, 162.0, 108.0, 65.0, 190.0, 199.0, 226.0, 2.0, 57.0, 140.0, 54.0, 146.0, 130.0, 262.0, 217.0, 192.0, 189.0, 40.0, 116.0, 113.0, 87.0, 262.0, 138.0, 210.0, 167.0, 171.0, 93.0, 273.0, 236.0, 75.0, 24.0, 186.0, 62.0, 63.0, 79.0, 32.0, 146.0, 46.0, 153.0, 125.0, 84.0, 29.0, 300.0, 46.0, 279.0, 195.0, 103.0, 65.0, 78.0, 216.0, 39.0, 206.0, 179.0, 67.0, 208.0, 192.0, 155.0, 99.0, 54.0, 54.0, 49.0, 293.0, 133.0, 228.0, 78.0, 134.0, 139.0, 98.0, 204.0, 142.0, 257.0, 110.0, 200.0, 153.0, 288.0, 240.0, 275.0], [9.0, 9.0, 69.0, 45.0, 57.0, 93.0, 107.0, 123.0, 59.0, 40.0, 119.0, 58.0, 118.0, 141.0, 107.0, 140.0, 146.0, 159.0, 100.0, 128.0, 146.0, 38.0, 31.0, 77.0, 49.0, 71.0, 108.0, 42.0, 81.0, 105.0, 55.0, 101.0, 79.0, 111.0, 51.0, 76.0, 137.0, 65.0, 82.0, 43.0, 113.0, 104.0, 64.0, 56.0, 60.0, 112.0, 67.0, 218.0, 47.0, 77.0, 60.0, 60.0, 43.0, 65.0, 37.0, 91.0, 67.0, 141.0, 52.0, 126.0, 104.0, 56.0, 58.0, 109.0, 110.0, 34.0, 29.0, 61.0], [356.26099999999997, 648.886, 427.994, 829.4929999999999, 1057.127, 199.123, 1032.7319999999997, 1164.3700000000001, 1319.9, 1562.059, 292.653, 1877.5510000000004, 1821.5719999999997, 1195.501, 324.893, 1443.3380000000002, 2218.7230000000004, 600.6800000000001, 146.485, 2142.41, 1801.1890000000003, 427.68, 125.503, 1923.8680000000002, 1290.899, 729.1900000000002, 2412.286, 2557.055, 2803.1480000000006, 13.387, 611.73, 1677.098, 603.876, 1884.4909999999995, 1465.4409999999998, 3472.7280000000005, 2776.968, 2297.8, 2452.935, 421.796, 1368.3150000000003, 1151.5230000000001, 1046.745, 3426.542, 1672.457, 2410.815000000001, 2079.5, 2120.8600000000006, 916.2750000000001, 3451.4870000000005, 3053.778, 881.0650000000002, 210.236, 2515.5170000000003, 725.3469999999998, 733.687, 955.047, 314.78700000000003, 1841.7930000000001, 420.202, 1863.9889999999996, 1572.715, 944.109, 356.93499999999995, 3936.463, 502.896, 3524.8480000000004, 2476.901, 1277.637, 693.994, 909.4590000000001, 2868.43, 362.86699999999996, 2534.768, 2288.6719999999996, 733.7939999999999, 2786.799, 2453.6769999999997, 1898.0580000000002, 1247.4019999999998, 524.905, 585.407, 544.648, 3803.949, 1614.094, 2799.62, 948.197, 1560.587, 1541.7290000000003, 1276.5339999999999, 2700.0790000000006, 1704.4769999999999, 3029.9030000000007, 1366.6349999999998, 2512.6309999999994, 1858.503, 3771.7269999999994, 3192.7880000000005, 3606.997], 7, 7387.31799999999, 0, 0], ['mhop', 0.8, [35.0, 56.0, 56.0, 66.0, 44.0, 86.0, 21.0, 101.0, 110.0, 114.0, 64.0, 129.0, 138.0, 44.0, 64.0, 151.0, 97.0, 32.0, 176.0, 140.0, 55.0, 22.0, 45.0, 142.0, 39.0, 11.0, 79.0, 196.0, 180.0, 38.0, 184.0, 226.0, 65.0, 185.0, 78.0, 2.0, 135.0, 140.0, 54.0, 170.0, 109.0, 198.0, 40.0, 240.0, 231.0, 212.0, 87.0, 208.0, 164.0, 128.0, 93.0, 187.0, 230.0, 117.0, 24.0, 62.0, 153.0, 79.0, 97.0, 83.0, 32.0, 270.0, 136.0, 67.0, 46.0, 82.0, 84.0, 188.0, 29.0, 46.0, 143.0, 65.0, 196.0, 62.0, 117.0, 174.0, 49.0, 170.0, 48.0, 267.0, 84.0, 117.0, 147.0, 127.0, 58.0, 54.0, 49.0, 74.0, 63.0, 215.0, 253.0, 134.0, 168.0, 128.0, 141.0, 236.0, 116.0, 225.0, 246.0, 240.0], [8.0, 35.0, 47.0, 29.0, 123.0, 103.0, 154.0, 39.0, 40.0, 134.0, 38.0, 126.0, 197.0, 137.0, 88.0, 97.0, 65.0, 90.0, 100.0, 117.0, 75.0, 167.0, 39.0, 102.0, 29.0, 99.0, 56.0, 76.0, 66.0, 91.0, 153.0, 135.0, 111.0, 20.0, 82.0, 164.0, 133.0, 91.0, 63.0, 90.0, 42.0, 204.0, 95.0, 158.0, 98.0, 144.0, 65.0, 139.0, 64.0, 120.0, 45.0, 108.0, 124.0, 125.0, 51.0, 74.0, 143.0, 128.0, 178.0, 24.0, 89.0], [356.26099999999997, 648.886, 593.4300000000001, 656.511, 427.994, 1057.127, 199.123, 1193.597, 1319.9, 1459.102, 813.376, 1474.9020000000003, 1690.2859999999998, 292.653, 731.878, 1989.5619999999997, 1194.9759999999999, 324.893, 2218.7230000000004, 1695.3650000000002, 600.6800000000001, 146.485, 450.289, 1635.0059999999999, 427.68, 125.503, 900.101, 2566.7180000000003, 2282.4850000000006, 401.03600000000006, 2321.6639999999998, 2892.0580000000004, 738.467, 2162.6590000000006, 921.9010000000001, 13.387, 1718.6490000000003, 1677.098, 603.876, 2054.44, 1408.442, 2662.18, 421.796, 3133.9880000000003, 2907.3290000000006, 2790.3159999999993, 1046.745, 2662.3730000000014, 2136.7230000000004, 1552.7340000000002, 915.866, 2275.4740000000006, 2973.199, 1383.1670000000001, 210.236, 725.3469999999998, 1828.52, 955.047, 1173.596, 987.435, 314.78700000000003, 3507.863, 1652.3980000000001, 772.267, 420.202, 981.9320000000001, 944.109, 2303.1430000000005, 356.93499999999995, 502.896, 1759.2610000000004, 693.994, 2500.8269999999998, 753.9730000000001, 1409.3480000000002, 2309.562, 502.585, 2141.572, 440.888, 3392.6239999999993, 875.7960000000002, 1473.7189999999998, 1868.6270000000004, 1591.3990000000001, 760.2529999999999, 585.407, 544.648, 761.9870000000001, 808.0320000000003, 2558.3059999999996, 3204.6240000000003, 1560.587, 2010.142, 1623.8409999999997, 1762.4700000000003, 2975.066, 1339.463, 2900.87, 3018.149, 3025.9279999999994], 14, 17286.314000000006, 0, 0], ['mhop', 0.6, [35.0, 56.0, 59.0, 56.0, 66.0, 44.0, 72.0, 85.0, 88.0, 21.0, 93.0, 110.0, 64.0, 63.0, 124.0, 44.0, 157.0, 64.0, 125.0, 32.0, 124.0, 159.0, 55.0, 22.0, 45.0, 147.0, 39.0, 11.0, 89.0, 164.0, 111.0, 79.0, 208.0, 125.0, 172.0, 167.0, 38.0, 65.0, 120.0, 78.0, 2.0, 173.0, 54.0, 222.0, 179.0, 40.0, 152.0, 121.0, 146.0, 75.0, 89.0, 160.0, 111.0, 219.0, 238.0, 136.0, 24.0, 62.0, 80.0, 63.0, 79.0, 97.0, 32.0, 135.0, 57.0, 67.0, 46.0, 165.0, 29.0, 46.0, 143.0, 182.0, 152.0, 65.0, 228.0, 78.0, 62.0, 117.0, 49.0, 170.0, 84.0, 84.0, 67.0, 176.0, 117.0, 147.0, 54.0, 42.0, 54.0, 222.0, 49.0, 140.0, 88.0, 86.0, 90.0, 207.0, 104.0, 204.0, 221.0, 223.0], [27.0, 39.0, 36.0, 103.0, 50.0, 60.0, 34.0, 100.0, 60.0, 31.0, 80.0, 36.0, 60.0, 135.0, 60.0, 141.0, 79.0, 104.0, 74.0, 44.0, 172.0, 4.0, 68.0, 124.0, 64.0, 147.0, 99.0, 34.0, 159.0, 162.0, 90.0, 40.0, 110.0, 36.0, 81.0, 207.0, 149.0, 24.0, 106.0, 120.0, 102.0, 85.0, 157.0, 155.0, 123.0, 38.0, 67.0], [356.26099999999997, 648.886, 690.396, 593.4300000000001, 656.511, 427.994, 829.4929999999999, 1012.0239999999999, 1141.868, 199.123, 1135.89, 1319.9, 813.376, 774.937, 1459.5369999999998, 292.653, 1908.187, 731.878, 1550.0180000000003, 324.893, 1425.038, 1898.0249999999996, 600.6800000000001, 146.485, 450.289, 1913.8090000000002, 427.68, 125.503, 1068.6480000000001, 1926.214, 1374.414, 900.101, 2576.3490000000006, 1633.337, 2017.5950000000003, 2032.679, 401.03600000000006, 738.467, 1569.4479999999996, 921.9010000000001, 13.387, 2171.277, 603.876, 2882.982, 2290.292, 421.796, 1872.2579999999996, 1488.6630000000002, 1867.5340000000003, 748.016, 1068.769, 2085.3809999999994, 1361.732, 2761.702, 3042.3439999999996, 1618.6799999999998, 210.236, 725.3469999999998, 941.981, 733.687, 955.047, 1173.596, 314.78700000000003, 1833.7179999999998, 628.22, 772.267, 420.202, 1927.293, 356.93499999999995, 502.896, 1759.2610000000004, 2405.961, 1968.9719999999998, 693.994, 2874.654, 909.4590000000001, 753.9730000000001, 1409.3480000000002, 502.585, 2141.572, 875.7960000000002, 982.757, 733.7939999999999, 2119.9649999999997, 1473.7189999999998, 1868.6270000000004, 524.905, 528.6110000000001, 585.407, 2889.8420000000015, 544.648, 1641.65, 1059.551, 976.359, 1179.1499999999999, 2671.548, 1216.233, 2537.8419999999996, 2898.7209999999995, 2815.6229999999996], 28, 18253.521000000008, 0, 0], ['mhop', 0.4, [35.0, 56.0, 59.0, 56.0, 66.0, 44.0, 79.0, 85.0, 88.0, 21.0, 86.0, 93.0, 128.0, 68.0, 63.0, 95.0, 44.0, 154.0, 112.0, 140.0, 71.0, 146.0, 32.0, 55.0, 22.0, 139.0, 45.0, 76.0, 184.0, 39.0, 11.0, 89.0, 157.0, 79.0, 180.0, 38.0, 150.0, 65.0, 161.0, 148.0, 78.0, 189.0, 110.0, 2.0, 113.0, 54.0, 167.0, 88.0, 40.0, 185.0, 119.0, 73.0, 200.0, 89.0, 111.0, 97.0, 24.0, 139.0, 83.0, 145.0, 62.0, 175.0, 63.0, 79.0, 82.0, 32.0, 57.0, 67.0, 151.0, 46.0, 135.0, 29.0, 46.0, 65.0, 150.0, 101.0, 78.0, 160.0, 68.0, 180.0, 49.0, 96.0, 84.0, 84.0, 67.0, 176.0, 147.0, 54.0, 42.0, 58.0, 54.0, 49.0, 138.0, 96.0, 190.0, 74.0, 108.0, 193.0, 193.0, 185.0], [27.0, 39.0, 58.0, 58.0, 40.0, 69.0, 108.0, 120.0, 101.0, 107.0, 63.0, 156.0, 132.0, 55.0, 133.0, 120.0, 69.0, 82.0, 19.0, 78.0, 188.0, 271.0, 13.0, 89.0, 178.0, 59.0, 104.0, 130.0, 40.0, 216.0, 52.0, 171.0, 251.0, 137.0, 107.0, 44.0, 43.0, 103.0, 244.0, 135.0, 175.0, 89.0], [356.26099999999997, 648.886, 690.396, 593.4300000000001, 656.511, 427.994, 901.012, 1012.0239999999999, 1141.868, 199.123, 1012.1599999999999, 1135.89, 1525.5250000000003, 874.3599999999999, 774.937, 1151.248, 292.653, 1905.525, 1298.681, 1688.893, 802.3670000000001, 1926.1209999999996, 324.893, 600.6800000000001, 146.485, 1732.9049999999997, 450.289, 970.161, 2199.274, 427.68, 125.503, 1068.6480000000001, 1873.437, 900.101, 2363.2369999999996, 401.03600000000006, 1795.3260000000002, 738.467, 2079.7639999999997, 1799.726, 921.9010000000001, 2335.396, 1307.3270000000005, 13.387, 1432.4940000000001, 603.876, 2186.5980000000004, 1035.6090000000002, 421.796, 2475.733, 1513.8909999999996, 679.5970000000001, 2599.2880000000005, 1068.769, 1361.3870000000002, 1247.906, 210.236, 1715.615, 986.0760000000001, 1891.5200000000004, 725.3469999999998, 2208.3889999999997, 733.687, 955.047, 1035.029, 314.78700000000003, 628.22, 772.267, 1839.7500000000002, 420.202, 1794.0149999999996, 356.93499999999995, 502.896, 693.994, 1759.2890000000007, 1199.6020000000003, 909.4590000000001, 2017.5430000000001, 823.7930000000001, 2288.542, 502.585, 1167.3429999999998, 875.7960000000002, 982.757, 733.7939999999999, 2178.042, 1868.6270000000004, 524.905, 528.6110000000001, 760.2529999999999, 585.407, 544.648, 1717.0690000000002, 1132.9180000000001, 2377.51, 884.529, 1279.651, 2495.661, 2523.798, 2307.1259999999997], 33, 22557.441000000006, 0, 0], ['mhop', 0.2, [35.0, 56.0, 59.0, 56.0, 66.0, 44.0, 72.0, 72.0, 85.0, 21.0, 86.0, 101.0, 93.0, 110.0, 64.0, 63.0, 95.0, 113.0, 93.0, 129.0, 44.0, 149.0, 113.0, 64.0, 32.0, 123.0, 55.0, 22.0, 45.0, 76.0, 156.0, 39.0, 11.0, 89.0, 122.0, 132.0, 79.0, 156.0, 128.0, 127.0, 38.0, 65.0, 78.0, 92.0, 2.0, 121.0, 54.0, 173.0, 159.0, 88.0, 40.0, 122.0, 72.0, 95.0, 89.0, 95.0, 118.0, 128.0, 75.0, 24.0, 127.0, 62.0, 175.0, 63.0, 79.0, 82.0, 32.0, 108.0, 57.0, 67.0, 46.0, 122.0, 143.0, 29.0, 46.0, 145.0, 65.0, 90.0, 78.0, 75.0, 68.0, 116.0, 152.0, 49.0, 84.0, 84.0, 108.0, 67.0, 54.0, 42.0, 154.0, 58.0, 54.0, 49.0, 88.0, 96.0, 74.0, 145.0, 155.0, 151.0], [13.0, 58.0, 35.0, 53.0, 102.0, 68.0, 125.0, 145.0, 88.0, 184.0, 60.0, 32.0, 150.0, 56.0, 155.0, 130.0, 4.0, 97.0, 158.0, 56.0, 101.0, 159.0], [356.26099999999997, 648.886, 690.396, 593.4300000000001, 656.511, 427.994, 829.4929999999999, 932.3260000000001, 1012.0239999999999, 199.123, 1012.1599999999999, 1216.175, 1135.89, 1319.9, 813.376, 774.937, 1151.248, 1463.397, 1125.566, 1555.556, 292.653, 1758.7240000000004, 1380.7009999999998, 731.878, 324.893, 1466.551, 600.6800000000001, 146.485, 450.289, 970.161, 1922.3149999999998, 427.68, 125.503, 1068.6480000000001, 1591.848, 1651.725, 900.101, 2001.2929999999997, 1583.0049999999999, 1584.9980000000003, 401.03600000000006, 738.467, 921.9010000000001, 1237.72, 13.387, 1435.7690000000002, 603.876, 2245.828, 2096.614, 1035.6090000000002, 421.796, 1560.809, 657.624, 1152.036, 1068.769, 1214.8939999999998, 1484.6979999999999, 1560.9310000000003, 881.0650000000002, 210.236, 1645.309, 725.3469999999998, 2208.3889999999997, 733.687, 955.047, 1035.029, 314.78700000000003, 1469.2929999999997, 628.22, 772.267, 420.202, 1527.203, 1817.835, 356.93499999999995, 502.896, 1676.6660000000002, 693.994, 1094.565, 909.4590000000001, 887.7429999999999, 823.7930000000001, 1506.9539999999997, 1791.6050000000002, 502.585, 875.7960000000002, 982.757, 1319.9070000000002, 733.7939999999999, 524.905, 528.6110000000001, 1957.614, 760.2529999999999, 585.407, 544.648, 1059.551, 1132.9180000000001, 884.529, 1894.01, 1913.9560000000001, 1886.2039999999997], 53, 17541.626000000007, 0, 0], ['shop', 1, [35.0, 56.0, 59.0, 56.0, 66.0, 44.0, 72.0, 85.0, 88.0, 21.0, 86.0, 93.0, 110.0, 64.0, 44.0, 64.0, 97.0, 32.0, 124.0, 55.0, 22.0, 183.0, 148.0, 45.0, 39.0, 11.0, 111.0, 214.0, 125.0, 175.0, 38.0, 190.0, 65.0, 200.0, 78.0, 226.0, 199.0, 2.0, 135.0, 140.0, 54.0, 133.0, 40.0, 200.0, 87.0, 149.0, 218.0, 72.0, 269.0, 75.0, 158.0, 24.0, 208.0, 62.0, 192.0, 63.0, 153.0, 79.0, 83.0, 32.0, 57.0, 67.0, 46.0, 153.0, 156.0, 295.0, 29.0, 46.0, 195.0, 284.0, 65.0, 78.0, 75.0, 62.0, 117.0, 214.0, 184.0, 49.0, 84.0, 67.0, 214.0, 279.0, 147.0, 54.0, 42.0, 208.0, 58.0, 54.0, 49.0, 226.0, 139.0, 214.0, 142.0, 256.0, 104.0, 195.0, 145.0, 199.0, 249.0, 263.0], [8.0, 8.0, 46.0, 51.0, 103.0, 96.0, 149.0, 59.0, 91.0, 58.0, 52.0, 83.0, 113.0, 156.0, 34.0, 58.0, 108.0, 41.0, 129.0, 155.0, 52.0, 18.0, 163.0, 35.0, 74.0, 61.0, 1.0, 75.0, 4.0, 128.0, 63.0, 39.0, 60.0, 72.0, 141.0, 171.0, 98.0, 47.0, 72.0, 37.0, 157.0, 128.0, 66.0, 151.0, 70.0, 134.0, 73.0, 15.0, 159.0, 53.0, 152.0, 169.0, 135.0, 41.0, 144.0, 124.0, 100.0, 70.0, 32.0], [356.26099999999997, 648.886, 690.396, 593.4300000000001, 656.511, 427.994, 829.4929999999999, 1012.0239999999999, 1141.868, 199.123, 1012.1599999999999, 1135.89, 1319.9, 813.376, 292.653, 731.878, 1194.9759999999999, 324.893, 1425.038, 600.6800000000001, 146.485, 2225.127000000001, 1801.1890000000003, 450.289, 427.68, 125.503, 1374.414, 2821.1140000000005, 1633.337, 2019.2970000000003, 401.03600000000006, 2388.618, 738.467, 2584.9719999999998, 921.9010000000001, 2776.5229999999997, 2557.055, 13.387, 1718.6490000000003, 1677.098, 603.876, 1613.917, 421.796, 2643.5930000000003, 1046.745, 2018.153, 2850.8179999999998, 657.624, 3340.796, 881.0650000000002, 1893.6920000000002, 210.236, 2544.9690000000005, 725.3469999999998, 2508.863, 733.687, 1828.52, 955.047, 987.435, 314.78700000000003, 628.22, 772.267, 420.202, 1946.397, 1931.757, 3891.028000000001, 356.93499999999995, 502.896, 2476.901, 3489.9190000000003, 693.994, 909.4590000000001, 887.7429999999999, 753.9730000000001, 1409.3480000000002, 2578.3459999999995, 2407.635, 502.585, 982.757, 733.7939999999999, 2763.819, 3536.0750000000007, 1868.6270000000004, 524.905, 528.6110000000001, 2478.391, 760.2529999999999, 585.407, 544.648, 2886.226, 1541.7290000000003, 2691.6259999999997, 1788.1989999999998, 3193.1720000000005, 1216.233, 2421.526, 1803.8539999999998, 2498.9059999999995, 3123.3120000000004, 3082.7329999999997], 16, 15009.01099999999, 0, 0], ['shop', 0.8, [35.0, 56.0, 59.0, 56.0, 66.0, 44.0, 72.0, 85.0, 88.0, 21.0, 86.0, 93.0, 110.0, 64.0, 63.0, 44.0, 135.0, 162.0, 64.0, 125.0, 149.0, 32.0, 127.0, 55.0, 22.0, 45.0, 39.0, 11.0, 164.0, 79.0, 214.0, 125.0, 175.0, 38.0, 65.0, 200.0, 78.0, 2.0, 135.0, 140.0, 54.0, 170.0, 109.0, 88.0, 198.0, 40.0, 208.0, 235.0, 87.0, 149.0, 75.0, 183.0, 75.0, 247.0, 24.0, 146.0, 62.0, 80.0, 63.0, 153.0, 134.0, 32.0, 135.0, 57.0, 67.0, 257.0, 46.0, 29.0, 46.0, 120.0, 65.0, 78.0, 196.0, 75.0, 241.0, 62.0, 117.0, 177.0, 49.0, 84.0, 84.0, 67.0, 192.0, 176.0, 214.0, 147.0, 54.0, 42.0, 208.0, 58.0, 54.0, 49.0, 88.0, 180.0, 142.0, 104.0, 177.0, 239.0, 229.0, 227.0], [8.0, 8.0, 51.0, 96.0, 28.0, 55.0, 18.0, 55.0, 100.0, 52.0, 60.0, 124.0, 122.0, 19.0, 46.0, 93.0, 129.0, 159.0, 52.0, 18.0, 106.0, 12.0, 43.0, 61.0, 1.0, 75.0, 4.0, 128.0, 32.0, 91.0, 99.0, 32.0, 141.0, 85.0, 98.0, 12.0, 91.0, 53.0, 36.0, 66.0, 89.0, 157.0, 134.0, 73.0, 15.0, 26.0, 163.0, 154.0, 51.0, 144.0, 123.0, 116.0, 32.0], [356.26099999999997, 648.886, 690.396, 593.4300000000001, 656.511, 427.994, 829.4929999999999, 1012.0239999999999, 1141.868, 199.123, 1012.1599999999999, 1135.89, 1319.9, 813.376, 774.937, 292.653, 1739.721, 1982.334, 731.878, 1550.0180000000003, 1765.9249999999997, 324.893, 1504.5520000000004, 600.6800000000001, 146.485, 450.289, 427.68, 125.503, 1969.8249999999998, 900.101, 2821.1140000000005, 1633.337, 2019.2970000000003, 401.03600000000006, 738.467, 2584.9719999999998, 921.9010000000001, 13.387, 1718.6490000000003, 1677.098, 603.876, 2054.44, 1408.442, 1035.6090000000002, 2662.18, 421.796, 2724.7820000000006, 2858.0580000000004, 1046.745, 2018.153, 748.016, 2248.403000000001, 881.0650000000002, 3214.236, 210.236, 1780.3390000000002, 725.3469999999998, 941.981, 733.687, 1828.52, 1593.21, 314.78700000000003, 1833.7179999999998, 628.22, 772.267, 3255.1550000000007, 420.202, 356.93499999999995, 502.896, 1483.3899999999999, 693.994, 909.4590000000001, 2500.8269999999998, 887.7429999999999, 3111.726000000001, 753.9730000000001, 1409.3480000000002, 2307.4070000000006, 502.585, 875.7960000000002, 982.757, 733.7939999999999, 2434.0619999999994, 2119.9649999999997, 2763.819, 1868.6270000000004, 524.905, 528.6110000000001, 2478.391, 760.2529999999999, 585.407, 544.648, 1059.551, 2115.797, 1788.1989999999998, 1216.233, 2286.3109999999997, 2985.070000000001, 3022.548, 2725.3619999999996], 22, 20157.596999999994, 0, 0], ['shop', 0.6, [35.0, 56.0, 59.0, 56.0, 66.0, 44.0, 72.0, 85.0, 88.0, 21.0, 86.0, 93.0, 110.0, 110.0, 64.0, 63.0, 44.0, 64.0, 125.0, 149.0, 32.0, 127.0, 55.0, 22.0, 45.0, 76.0, 148.0, 39.0, 11.0, 89.0, 164.0, 79.0, 210.0, 125.0, 172.0, 167.0, 38.0, 150.0, 65.0, 200.0, 78.0, 92.0, 2.0, 54.0, 179.0, 170.0, 88.0, 40.0, 188.0, 87.0, 72.0, 167.0, 89.0, 160.0, 237.0, 75.0, 24.0, 62.0, 175.0, 80.0, 63.0, 153.0, 79.0, 32.0, 155.0, 135.0, 57.0, 67.0, 46.0, 122.0, 170.0, 29.0, 46.0, 65.0, 78.0, 62.0, 117.0, 167.0, 172.0, 49.0, 84.0, 84.0, 67.0, 117.0, 147.0, 54.0, 182.0, 42.0, 58.0, 54.0, 222.0, 49.0, 88.0, 86.0, 160.0, 207.0, 145.0, 104.0, 199.0, 227.0], [8.0, 8.0, 40.0, 96.0, 56.0, 55.0, 18.0, 55.0, 100.0, 80.0, 102.0, 54.0, 111.0, 93.0, 129.0, 90.0, 117.0, 68.0, 1.0, 58.0, 4.0, 128.0, 138.0, 63.0, 144.0, 178.0, 92.0, 110.0, 12.0, 138.0, 66.0, 169.0, 134.0, 15.0, 99.0, 159.0, 152.0, 154.0, 150.0, 123.0, 32.0], [356.26099999999997, 648.886, 690.396, 593.4300000000001, 656.511, 427.994, 829.4929999999999, 1012.0239999999999, 1141.868, 199.123, 1012.1599999999999, 1135.89, 1319.9, 1353.445, 813.376, 774.937, 292.653, 731.878, 1550.0180000000003, 1765.9249999999997, 324.893, 1504.5520000000004, 600.6800000000001, 146.485, 450.289, 970.161, 1963.4820000000004, 427.68, 125.503, 1068.6480000000001, 1969.8249999999998, 900.101, 2576.4450000000006, 1633.337, 2017.5950000000003, 2032.679, 401.03600000000006, 1795.3260000000002, 738.467, 2584.9719999999998, 921.9010000000001, 1237.72, 13.387, 603.876, 2290.292, 2054.44, 1035.6090000000002, 421.796, 2345.3840000000005, 1046.745, 657.624, 2085.2340000000004, 1068.769, 2023.491, 3074.3180000000007, 881.0650000000002, 210.236, 725.3469999999998, 2208.3889999999997, 941.981, 733.687, 1828.52, 955.047, 314.78700000000003, 1928.528, 1833.7179999999998, 628.22, 772.267, 420.202, 1527.203, 2119.9559999999997, 356.93499999999995, 502.896, 693.994, 909.4590000000001, 753.9730000000001, 1409.3480000000002, 1969.4860000000003, 2258.3489999999993, 502.585, 875.7960000000002, 982.757, 733.7939999999999, 1473.7189999999998, 1868.6270000000004, 524.905, 2177.6279999999997, 528.6110000000001, 760.2529999999999, 585.407, 2889.8420000000015, 544.648, 1059.551, 976.359, 1919.8760000000002, 2671.548, 1894.01, 1216.233, 2498.9059999999995, 2725.3619999999996], 34, 18778.696999999996, 0, 0], ['shop', 0.4, [35.0, 56.0, 59.0, 56.0, 66.0, 44.0, 72.0, 85.0, 88.0, 21.0, 86.0, 93.0, 110.0, 119.0, 64.0, 63.0, 95.0, 93.0, 44.0, 113.0, 135.0, 64.0, 149.0, 32.0, 175.0, 55.0, 22.0, 45.0, 76.0, 39.0, 11.0, 89.0, 122.0, 157.0, 79.0, 121.0, 38.0, 150.0, 196.0, 65.0, 146.0, 78.0, 189.0, 92.0, 2.0, 115.0, 54.0, 88.0, 40.0, 119.0, 189.0, 188.0, 72.0, 107.0, 89.0, 95.0, 111.0, 128.0, 75.0, 125.0, 24.0, 62.0, 175.0, 63.0, 79.0, 83.0, 32.0, 57.0, 67.0, 46.0, 122.0, 135.0, 143.0, 29.0, 46.0, 65.0, 90.0, 78.0, 75.0, 62.0, 167.0, 49.0, 84.0, 84.0, 67.0, 147.0, 54.0, 182.0, 42.0, 152.0, 121.0, 58.0, 54.0, 49.0, 88.0, 96.0, 74.0, 145.0, 182.0, 175.0], [8.0, 61.0, 47.0, 18.0, 32.0, 60.0, 102.0, 19.0, 153.0, 111.0, 129.0, 60.0, 58.0, 4.0, 165.0, 77.0, 56.0, 144.0, 126.0, 92.0, 110.0, 37.0, 138.0, 129.0, 134.0, 15.0, 100.0, 154.0, 28.0, 145.0], [356.26099999999997, 648.886, 690.396, 593.4300000000001, 656.511, 427.994, 829.4929999999999, 1012.0239999999999, 1141.868, 199.123, 1012.1599999999999, 1135.89, 1353.445, 1424.8780000000002, 813.376, 774.937, 1151.248, 1125.566, 292.653, 1380.7009999999998, 1739.721, 731.878, 1765.9249999999997, 324.893, 2074.0800000000004, 600.6800000000001, 146.485, 450.289, 970.161, 427.68, 125.503, 1068.6480000000001, 1591.848, 1873.437, 900.101, 1530.9729999999997, 401.03600000000006, 1795.3260000000002, 2578.906, 738.467, 1887.3829999999998, 921.9010000000001, 2335.396, 1237.72, 13.387, 1388.6729999999998, 603.876, 1035.6090000000002, 421.796, 1513.8909999999996, 2536.7170000000006, 2345.3840000000005, 657.624, 1295.412, 1068.769, 1214.8939999999998, 1361.732, 1560.9310000000003, 881.0650000000002, 1612.2969999999998, 210.236, 725.3469999999998, 2208.3889999999997, 733.687, 955.047, 987.435, 314.78700000000003, 628.22, 772.267, 420.202, 1527.203, 1794.0149999999996, 1817.835, 356.93499999999995, 502.896, 693.994, 1094.565, 909.4590000000001, 887.7429999999999, 753.9730000000001, 1969.4860000000003, 502.585, 875.7960000000002, 982.757, 733.7939999999999, 1868.6270000000004, 524.905, 2177.6279999999997, 528.6110000000001, 1938.819, 1424.9470000000001, 760.2529999999999, 585.407, 544.648, 1059.551, 1132.9180000000001, 884.529, 1894.01, 2245.2159999999994, 2185.1020000000003], 45, 17337.59599999999, 0, 0], ['shop', 0.2, [35.0, 56.0, 59.0, 56.0, 66.0, 44.0, 72.0, 74.0, 85.0, 21.0, 86.0, 93.0, 110.0, 119.0, 64.0, 63.0, 95.0, 113.0, 93.0, 140.0, 129.0, 44.0, 113.0, 64.0, 32.0, 122.0, 55.0, 22.0, 45.0, 76.0, 39.0, 159.0, 120.0, 11.0, 120.0, 89.0, 151.0, 79.0, 121.0, 128.0, 38.0, 65.0, 151.0, 78.0, 92.0, 2.0, 115.0, 54.0, 159.0, 88.0, 40.0, 119.0, 87.0, 72.0, 89.0, 116.0, 95.0, 123.0, 75.0, 125.0, 24.0, 62.0, 175.0, 63.0, 79.0, 83.0, 32.0, 108.0, 57.0, 67.0, 46.0, 122.0, 143.0, 29.0, 46.0, 145.0, 65.0, 90.0, 78.0, 75.0, 62.0, 116.0, 152.0, 49.0, 84.0, 84.0, 108.0, 67.0, 54.0, 42.0, 154.0, 58.0, 54.0, 49.0, 88.0, 96.0, 74.0, 147.0, 145.0, 151.0], [100.0, 12.0, 87.0, 99.0, 64.0, 118.0, 60.0, 58.0, 4.0, 151.0, 51.0, 144.0, 92.0, 37.0, 91.0, 138.0, 15.0, 154.0], [356.26099999999997, 648.886, 690.396, 593.4300000000001, 656.511, 427.994, 829.4929999999999, 962.025, 1012.0239999999999, 199.123, 1012.1599999999999, 1135.89, 1353.445, 1424.8780000000002, 813.376, 774.937, 1151.248, 1463.397, 1125.566, 1759.2729999999997, 1555.556, 292.653, 1380.7009999999998, 731.878, 324.893, 1466.391, 600.6800000000001, 146.485, 450.289, 970.161, 427.68, 1928.4070000000002, 1528.5249999999999, 125.503, 1561.6389999999997, 1068.6480000000001, 1750.1960000000001, 900.101, 1530.9729999999997, 1583.0049999999999, 401.03600000000006, 738.467, 1939.6710000000003, 921.9010000000001, 1237.72, 13.387, 1388.6729999999998, 603.876, 2096.614, 1035.6090000000002, 421.796, 1513.8909999999996, 1046.745, 657.624, 1068.769, 1512.0419999999997, 1214.8939999999998, 1455.969, 881.0650000000002, 1612.2969999999998, 210.236, 725.3469999999998, 2208.3889999999997, 733.687, 955.047, 987.435, 314.78700000000003, 1469.2929999999997, 628.22, 772.267, 420.202, 1527.203, 1817.835, 356.93499999999995, 502.896, 1676.6660000000002, 693.994, 1094.565, 909.4590000000001, 887.7429999999999, 753.9730000000001, 1506.9539999999997, 1791.6050000000002, 502.585, 875.7960000000002, 982.757, 1319.9070000000002, 733.7939999999999, 524.905, 528.6110000000001, 1957.614, 760.2529999999999, 585.407, 544.648, 1059.551, 1132.9180000000001, 884.529, 1824.9149999999995, 1894.01, 1886.2039999999997], 57, 14341.014, 0, 0]]\n",
      "elapsed time: 7041.691995152001\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from timeit import default_timer as timer\n",
    "from multiprocessing import Pool, cpu_count\n",
    "\n",
    "def power(hop, det_d):\n",
    "    print(hop,det_d,\"begins\")\n",
    "    TIME_LIMIT = 650 #secondes\n",
    "\n",
    "    NB_RIDERS = 75\n",
    "    WT_R = 3\n",
    "    RIDER_FREQUENCY = NB_RIDERS/(TIME_LIMIT-(WT_R*60)) #nombre de passagers par secondes\n",
    "    #print(\"Frequence d'apparition passager:\",RIDER_FREQUENCY,\"par secondes.\")\n",
    "    DET_FACTOR_R = 0.5\n",
    "\n",
    "\n",
    "    NB_DRIVERS = 100\n",
    "    DRIVER_FREQUENCY = NB_DRIVERS/(TIME_LIMIT-(WT_R*60)) #nombre de conducteurs par secondes\n",
    "    #print(\"Frequence d'apparition conducteurs:\",DRIVER_FREQUENCY,\"par secondes.\")\n",
    "    \n",
    "    \n",
    "    seed = 1\n",
    "\n",
    "    local_mean_nb_unmatched = []\n",
    "    local_mean_waiting_time = []\n",
    "    local_mean_trip_length = []\n",
    "    local_mean_trip_time = []\n",
    "    local_mean_nb_shop = []\n",
    "    local_mean_nb_mhop = []\n",
    "    local_mean_saved_distance = []\n",
    "        \n",
    "    \n",
    "    random.seed(seed)\n",
    "    count_id = 0\n",
    "    global sma\n",
    "    sma = SMA(place='grid', show_graph=False, verbose=False, hop=hop)\n",
    "\n",
    "    riders_nodes = []\n",
    "    for _ in range(NB_RIDERS):\n",
    "        v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "        while not nx.has_path(sma.G, v1, v2):\n",
    "            v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "        riders_nodes.append((v1, v2))\n",
    "\n",
    "\n",
    "    drivers_nodes = []\n",
    "    for _ in range(NB_DRIVERS):\n",
    "        v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "        while not nx.has_path(sma.G, v1, v2):\n",
    "            v1, v2 = random.sample(list(sma.G.nodes),2)\n",
    "        drivers_nodes.append((v1,v2))\n",
    "               \n",
    "        \n",
    "        #on ajoute 10% des utilisateurs au départ\n",
    "    for _ in range(int(NB_DRIVERS/10)):\n",
    "        v1, v2 = drivers_nodes.pop()\n",
    "        d = ContinuousDriverAgent(count_id, v1, v2, detour_factor=det_d, pref_weight='travel_time',test=False)\n",
    "        sma.addAgent(d)\n",
    "        count_id+=1\n",
    "                \n",
    "    for _ in range(int(NB_RIDERS/10)):\n",
    "        v1, v2 = riders_nodes.pop()\n",
    "        r = RiderAgent(count_id, v1, v2, detour_factor=DET_FACTOR_R, waiting_time=WT_R, pref_weight='travel_time')\n",
    "        sma.addAgent(r)\n",
    "        count_id+=1  \n",
    "                \n",
    "                \n",
    "                \n",
    "    drivers_frequency = 0\n",
    "    riders_frequency = 0\n",
    "\n",
    "    for _ in range(TIME_LIMIT):\n",
    "        if sma.tick%int(TIME_LIMIT/4)==0:\n",
    "            print(hop,det_d,\"tick:\",sma.tick)\n",
    "\n",
    "        drivers_frequency+=DRIVER_FREQUENCY\n",
    "        while drivers_frequency>=1 and len(drivers_nodes)>0:\n",
    "            v1, v2 = drivers_nodes.pop()\n",
    "            d = ContinuousDriverAgent(count_id, v1, v2, detour_factor=det_d, pref_weight='travel_time',test=False)\n",
    "            sma.addAgent(d)\n",
    "                    #print(\"new_d\")\n",
    "            count_id+=1\n",
    "            drivers_frequency-=1\n",
    "\n",
    "        riders_frequency+=RIDER_FREQUENCY\n",
    "        while riders_frequency>=1 and len(riders_nodes)>0:\n",
    "            v1, v2 = riders_nodes.pop()\n",
    "            r = RiderAgent(count_id, v1, v2, detour_factor=DET_FACTOR_R, waiting_time=WT_R, pref_weight='travel_time')\n",
    "            sma.addAgent(r)\n",
    "            #print(\"new_r\")\n",
    "            count_id+=1  \n",
    "            riders_frequency-=1\n",
    "                \n",
    "        sma.runOnce()\n",
    "            \n",
    "        #on récupère les données\n",
    "    trip_time=sma.data['d_trip_time']\n",
    "    waiting_time=sma.data['r_waiting_time']\n",
    "    trip_length=sma.data['d_trip_length']\n",
    "    nb_unmatched=sma.data['r_nb_unmatched']\n",
    "    nb_shop=sma.data['shop_count']\n",
    "    nb_mhop=sma.data['mhop_count']\n",
    "    saved_distance=sma.data['saved_distance']\n",
    "        \n",
    "\n",
    "        \n",
    "    print(hop,det_d,\"finished\")        \n",
    "    \n",
    "    return [hop, det_d, trip_time, waiting_time, trip_length, nb_unmatched, saved_distance, nb_shop, nb_mhop]\n",
    "\n",
    "\n",
    "def main():\n",
    "    DET_FACTOR_D = [1,0.8,0.6,0.4,0.2]\n",
    "    HOP = ['mhop','shop']\n",
    "    values = []\n",
    "    res = None\n",
    "    #DET_FACTOR_D = [0.1,0.2]\n",
    "    for hop in HOP:\n",
    "        for det_d in DET_FACTOR_D:\n",
    "            values.append((hop,det_d))\n",
    "   \n",
    "    start = timer()\n",
    "\n",
    "    print(f'starting computations on {cpu_count()} cores')\n",
    "\n",
    "    with Pool() as pool:\n",
    "        res = pool.starmap(power, values)\n",
    "        print(res)\n",
    "\n",
    "    end = timer()\n",
    "    print(f'elapsed time: {end - start}')\n",
    "    return res3\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    res3 = main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 89, 58, 69]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,2,3,4,5,6]\n",
    "b = [89,58,69]\n",
    "a+=b\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "res\n",
    "res2=res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import csv\n",
    "# with open('results_big_xp_1seed.csv', 'w', newline='') as file:\n",
    "#     mywriter = csv.writer(file, delimiter=',')\n",
    "#     mywriter.writerows(res2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[[(1.4236666666666666, 0.6591668984407515),\n",
       "   (1.588, 0.8431754792976898),\n",
       "   (1.7133333333333334, 0.9799574820708634),\n",
       "   (1.943, 1.1423250656251729),\n",
       "   (2.163299663299663, 1.2659110359067156)],\n",
       "  [(1.5371212121212123, 0.8550788819743654),\n",
       "   (1.775, 1.0582520903700057),\n",
       "   (1.4453900709219858, 0.7916131159765147),\n",
       "   (1.5920765027322403, 0.7678928573787296),\n",
       "   (1.3715686274509804, 0.6555012228313615)],\n",
       "  [(1.0242251499999997, 0.5280332050527764),\n",
       "   (1.1497170199999998, 0.6741921188256947),\n",
       "   (1.2435438099999998, 0.7775000056646134),\n",
       "   (1.4203971999999996, 0.9062258064965265),\n",
       "   (1.5947941414141418, 1.0128146512005767)],\n",
       "  [(53.0, 0.0), (33.0, 0.0), (28.0, 0.0), (14.0, 0.0), (7.0, 0.0)],\n",
       "  [(17.541626000000008, 0.0),\n",
       "   (22.557441000000008, 0.0),\n",
       "   (18.253521000000006, 0.0),\n",
       "   (17.286314000000004, 0.0),\n",
       "   (7.38731799999999, 0.0)]],\n",
       " [[(1.4115, 0.6426451197978554),\n",
       "   (1.4978333333333333, 0.7677262786233704),\n",
       "   (1.6438333333333333, 0.9333471873971777),\n",
       "   (1.7778333333333334, 1.0770150494151263),\n",
       "   (1.9346666666666665, 1.235162337508718)],\n",
       "  [(1.3657407407407407, 0.7746259994071177),\n",
       "   (1.3955555555555557, 0.8330325383060035),\n",
       "   (1.463008130081301, 0.8429486911247096),\n",
       "   (1.2062893081761006, 0.7823808367688508),\n",
       "   (1.4073446327683614, 0.8079365686306711)],\n",
       "  [(1.0141986499999998, 0.5136009226480687),\n",
       "   (1.07865158, 0.608663348490858),\n",
       "   (1.1871292, 0.7337287111561466),\n",
       "   (1.2943790300000002, 0.8520372986664312),\n",
       "   (1.41104945, 0.9661381662550588)],\n",
       "  [(57.0, 0.0), (45.0, 0.0), (34.0, 0.0), (22.0, 0.0), (16.0, 0.0)],\n",
       "  [(14.341014, 0.0),\n",
       "   (17.33759599999999, 0.0),\n",
       "   (18.778696999999998, 0.0),\n",
       "   (20.157596999999996, 0.0),\n",
       "   (15.00901099999999, 0.0)]]]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_res = []\n",
    "mean_trip_time = []\n",
    "mean_waiting_time = []\n",
    "mean_trip_length = []\n",
    "mean_nb_unmatched = []\n",
    "mean_saved_distance = [] \n",
    "\n",
    "for i in range(len(res2)):\n",
    "    mean_trip_time.insert(0,(np.mean(res2[i][2])/60,np.std(res2[i][2])/60))\n",
    "    mean_waiting_time.insert(0,(np.mean(res2[i][3])/60,np.std(res2[i][3])/60))\n",
    "    mean_trip_length.insert(0,(np.mean(res2[i][4])/1000,np.std(res2[i][4])/1000))\n",
    "    mean_nb_unmatched.insert(0,(np.mean(res2[i][5]),np.std(res2[i][5]))) #meme si une seule valeur\n",
    "    mean_saved_distance.insert(0,(np.mean(res2[i][6])/1000,np.std(res2[i][6])/1000))\n",
    "    if i == 4 or i == 9:\n",
    "        show_res.append([mean_trip_time, mean_waiting_time, mean_trip_length, mean_nb_unmatched, mean_saved_distance])\n",
    "        mean_trip_time = []\n",
    "        mean_waiting_time = []\n",
    "        mean_trip_length = []\n",
    "        mean_nb_unmatched = []\n",
    "        mean_saved_distance = [] \n",
    "        \n",
    "show_res\n",
    "        \n",
    "        \n",
    "    \n",
    "    \n",
    "# mean_trip_time=((np.mean(local_mean_trip_time),np.std(local_mean_trip_time)))\n",
    "# mean_waiting_time=((np.mean(local_mean_waiting_time),np.std(local_mean_waiting_time)))\n",
    "# mean_trip_length=((np.mean(local_mean_trip_length),np.std(local_mean_trip_length)))\n",
    "# mean_nb_unmatched=((np.mean(local_mean_nb_unmatched),np.std(local_mean_nb_unmatched)))\n",
    "# mean_nb_shop=((np.mean(local_mean_nb_shop),np.std(local_mean_nb_shop)))\n",
    "# mean_nb_mhop=((np.mean(local_mean_nb_mhop),np.std(local_mean_nb_mhop)))\n",
    "# mean_saved_distance=((np.mean(local_mean_saved_distance),np.std(local_mean_saved_distance)))    \n",
    "#[mean_trip_time, mean_waiting_time, mean_trip_length, mean_nb_unmatched, mean_saved_distance, mean_nb_shop, mean_nb_mhop])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "entries = [\"Average trip time of drivers (min)\", \"Average waiting time of riders (min)\", \n",
    "           \"Average trip length of drivers (km)\", \"Number unmatched riders\", \"Saved distance (km)\"]\n",
    "DET_FACTOR_D = [0.2,0.4,0.6,0.8,1]\n",
    "HOP = ['mhop','shop']\n",
    "for i in range(len(entries)) :\n",
    "    f = plt.figure(figsize=(7, 5))\n",
    "    for j in range(len(HOP)):\n",
    "        avg = [x for x,_ in show_res[j][i]]\n",
    "        poly_avg = np.polyfit(DET_FACTOR_D,avg,3) \n",
    "        poly_y_avg = np.poly1d(poly_avg)(DET_FACTOR_D)\n",
    "        \n",
    "        \n",
    "        #std = [x for _,x in show_res[j][i]]\n",
    "#         poly_std = np.polyfit(MAX_NB_DRIVERS,std,5) \n",
    "#         poly_y_std = np.poly1d(poly_std)(MAX_NB_DRIVERS)\n",
    "        #plt.plot(DET_FACTOR_D, avg, label = HOP[j])\n",
    "        plt.plot(DET_FACTOR_D, poly_y_avg, label = HOP[j])\n",
    "        #plt.fill_between(DET_FACTOR_D, np.add(avg,std), np.subtract(avg,std), alpha=0.2)\n",
    "\n",
    "    plt.xlabel('Drivers detour')\n",
    "    plt.ylabel(entries[i])\n",
    "    plt.legend()\n",
    "    \n",
    "    #entry = entries[i].replace(' ','_').split(\"(\")[0]\n",
    "    #path = '/home/fevrec/Documents/These/these/smac_agents/mas_basics/xp1/'+entry+'.png'\n",
    "    #plt.savefig(path,format='png')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_id = 49\n",
    "print(\"arr\",sma.getAgentFromId(d_id).arr)\n",
    "print(\"ddl\",sma.getAgentFromId(d_id).ddl)\n",
    "print(\"slk\",sma.getAgentFromId(d_id).slk)\n",
    "print(\"cap\",sma.getAgentFromId(d_id).capacities)\n",
    "print(\"perc\",sma.getAgentFromId(d_id).perceptions)\n",
    "print(\"stops\",sma.getAgentFromId(d_id).stops)\n",
    "print(\"trip\",sma.getAgentFromId(d_id).trip)\n",
    "print(\"v_r\",sma.getAgentFromId(d_id).current_pos)\n",
    "print(\"v_arr\",sma.getAgentFromId(d_id).v_arr)\n",
    "sma.getAgentFromId(d_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sma.getAgentFromId(d_id).decide()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_id = 20\n",
    "print(\"arr\",sma.getAgentFromId(d_id).arr)\n",
    "print(\"ddl\",sma.getAgentFromId(d_id).ddl)\n",
    "print(\"slk\",sma.getAgentFromId(d_id).slk)\n",
    "print(\"cap\",sma.getAgentFromId(d_id).capacities)\n",
    "print(\"perc\",sma.getAgentFromId(d_id).perceptions)\n",
    "print(\"stops\",sma.getAgentFromId(d_id).stops)\n",
    "print(\"trip\",sma.getAgentFromId(d_id).trip)\n",
    "print(\"v_r\",sma.getAgentFromId(d_id).current_pos)\n",
    "print(\"v_arr\",sma.getAgentFromId(d_id).v_arr)\n",
    "sma.getAgentFromId(d_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.has_path(G,53090940,53027459)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SMA:\n",
    "    def __init__(self, verbose=False, place='Piedmont, California, USA', speed=50, show_graph=False, hop='mhop'):\n",
    "        self.tick=0 #1 tick = 1 seconde\n",
    "        self.resetTicks()\n",
    "        \n",
    "        if hop in ['mhop','shop','nohop']:\n",
    "            self.hop = hop\n",
    "        else :\n",
    "            raise Exception(\"hop parameters is either : mhop, shop or nohop\")\n",
    "            \n",
    "        \n",
    "        if place=='grid':\n",
    "            north, south, east, west = 37.79, 37.78, -122.41, -122.43\n",
    "            self.min_lat, self.min_lon, self.max_lat, self.max_lon = south, west, north ,east \n",
    "            \n",
    "            \n",
    "        else:\n",
    "            gdf = ox.geocode_to_gdf(place) \n",
    "            # get the street network within this bounding box\n",
    "            west, south, east, north = list(gdf.bounds.iloc[0])\n",
    "            self.min_lat, self.min_lon, self.max_lat, self.max_lon = south, west, north ,east \n",
    "            #self.bbox = (self.min_lon, self.min_lat, self.max_lon, self.max_lat)\n",
    "            \n",
    "        self.G = ox.graph_from_bbox(north, south, east, west, network_type='drive')\n",
    "        \n",
    "#         #filter deadends\n",
    "#         deadends = []\n",
    "#         for node in list(self.G.nodes):\n",
    "#             if self.G.nodes[node]['street_count']==1:\n",
    "#                 deadends.append(node)\n",
    "#         print(deadends)\n",
    "#         self.G.remove_nodes_from(deadends)\n",
    "        \n",
    "        if show_graph:\n",
    "            fig, ax = ox.plot_graph(self.G, figsize=(20, 20),  node_size=20)\n",
    "        self.speed = speed\n",
    "        # hwy_speeds = {'residential': 30,\n",
    "        #               'secondary': 50,\n",
    "        #               'tertiary': 70}\n",
    "\n",
    "        hwy_speeds = {'residential': self.speed,\n",
    "                      'primary':self.speed,\n",
    "                      'secondary': self.speed,\n",
    "                      'tertiary': self.speed,\n",
    "                      'motorway': self.speed,\n",
    "                      'trunk': self.speed}\n",
    "\n",
    "        self.G = ox.add_edge_speeds(self.G, hwy_speeds, precision=0)\n",
    "        #temps arrondis\n",
    "        self.G = ox.add_edge_travel_times(self.G, precision=0)\n",
    "        \n",
    "        #dictionnaire des agents par type\n",
    "        self.agentTypeIdDict = {}\n",
    "        self.agentTypeIdDict[\"drivers\"] = []\n",
    "        self.agentTypeIdDict[\"riders\"] = []\n",
    "        self.agentTypeIdDict[\"tsas\"] = []\n",
    "        self.agentTypeIdDict[\"tgas\"] = []\n",
    "        \n",
    "        #dictionnaire des agents par id\n",
    "        self.agentDict = {}\n",
    "        \n",
    "        #arbre d'indexation spatiale R-TREE\n",
    "        self.rtree = rtree.index.Index()\n",
    "        \n",
    "        #self.G = None\n",
    "        self.verbose = verbose\n",
    "        \n",
    "        \n",
    "        ####DATA####\n",
    "        self.data = dict()\n",
    "        self.data['d_trip_time'] = []\n",
    "        self.data['d_trip_length'] = []\n",
    "        self.data['r_waiting_time'] = []\n",
    "        self.data['r_nb_unmatched'] = 0\n",
    "    \n",
    "    def resetTicks(self):\n",
    "        self.tick=0\n",
    "          \n",
    "    def setRoadGraph(self,graph):\n",
    "        self.G = graph\n",
    "        \n",
    "    def addAgent(self,ag):\n",
    "        self.agentDict[ag.unique_id] = ag\n",
    "        if \"RiderAgent\" in ag.__class__.__name__:\n",
    "            self.agentTypeIdDict[\"riders\"].append(ag.unique_id)\n",
    "        elif \"DriverAgent\" in ag.__class__.__name__:\n",
    "            self.agentTypeIdDict[\"drivers\"].append(ag.unique_id)\n",
    "        elif \"TransportServiceAgent\" in ag.__class__.__name__:\n",
    "            self.agentTypeIdDict[\"tsas\"].append(ag.unique_id)\n",
    "        elif \"TransportGeneratorAgent\" in ag.__class__.__name__:\n",
    "            self.agentTypeIdDict[\"tgas\"].append(ag.unique_id)\n",
    "        else: raise Exception(ag.__class__.__name__,\"is a wrong type of agent.\")\n",
    "            \n",
    "            \n",
    "    def getAgentFromId(self, unique_id):\n",
    "        return self.agentDict[unique_id]\n",
    "    \n",
    "    def getRiders(self):\n",
    "        R = []\n",
    "        for r in self.agentTypeIdDict['riders']:\n",
    "            R.append(self.agentDict[r])\n",
    "        return R\n",
    "        \n",
    "    def getDrivers(self):\n",
    "        D = []\n",
    "        for d in self.agentTypeIdDict['drivers']:\n",
    "            D.append(self.agentDict[d])\n",
    "        return D\n",
    "        \n",
    "    def getTSAs(self):\n",
    "        TSA = []\n",
    "        for tsa in self.agentTypeIdDict['tsas']:\n",
    "            TSA.append(self.agentDict[tsa])\n",
    "        return TSA\n",
    "    \n",
    "    def getTGAs(self):\n",
    "        TGA = []\n",
    "        for tga in self.agentTypeIdDict['tgas']:\n",
    "            TGA.append(self.agentDict[tga])\n",
    "        return TGA\n",
    "\n",
    "    def run(self,rounds=None):\n",
    "        if rounds==None:\n",
    "            #on s'arrete si tout les passagers ou tout les conducteurs sont arrivés\n",
    "            self.runOnce()\n",
    "            while len([agent for agent in sma.agentDict.values() if (\"RiderAgent\" in agent.__class__.__name__)]) > 0 and len([agent for agent in sma.agentDict.values() if (\"DriverAgent\" in agent.__class__.__name__)]) > 0:\n",
    "                self.runOnce()\n",
    "            #print(\"Finished in\",self.tick,\"ticks\")\n",
    "        \n",
    "        else :\n",
    "            #génération classique\n",
    "            for i in range(0,rounds):\n",
    "                self.runOnce()\n",
    "\n",
    "    def runOnce(self):\n",
    "        self.tick+=1\n",
    "        #random.shuffle(self.agentList)\n",
    "        for ag in self.agentDict.values() :\n",
    "            #print(ag.unique_id)\n",
    "            ag.update()\n",
    "            ag.decide()\n",
    "        \n",
    "        #phase de nettoyage des agents morts\n",
    "        for ag in self.agentDict.copy().values():\n",
    "            if ag.is_alive == False:\n",
    "                if \"RiderAgent\" in ag.__class__.__name__:\n",
    "                    self.agentTypeIdDict[\"riders\"].remove(ag.unique_id)\n",
    "                elif \"DriverAgent\" in ag.__class__.__name__:\n",
    "                    self.agentTypeIdDict[\"drivers\"].remove(ag.unique_id)\n",
    "                elif \"TransportServiceAgent\" in ag.__class__.__name__:\n",
    "                    self.agentTypeIdDict[\"tsas\"].remove(ag.unique_id)\n",
    "                elif \"TransportGeneratorAgent\" in ag.__class__.__name__:\n",
    "                    self.agentTypeIdDict[\"tgas\"].remove(ag.unique_id)\n",
    "                else: raise Exception(ag.__class__.__name__,\"is a wrong type of agent, even if diying.\")\n",
    "                \n",
    "                self.agentDict.pop(ag.unique_id)\n",
    "                \n",
    "                \n",
    "        if self.verbose == True:      \n",
    "            print(\"tick\",str(self.tick),\"ended\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['mhop','shop','nohop']\n",
    "'mhop' in a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#remplacé par r-tree\n",
    "class TransportServiceAgent(Agent):\n",
    "    #tsa : agent blackboard\n",
    "    def __init__(self, unique_id):\n",
    "        super().__init__(unique_id)\n",
    "        self.nodes_to_drivers = dict()\n",
    "        for node in list(sma.G.nodes):\n",
    "            self.nodes_to_drivers[node] = set()\n",
    "        self.drivers_to_nodes = dict()\n",
    "        \n",
    "    \n",
    "     \n",
    "    def update_driver_data(self, d):\n",
    "        if d.is_alive == False:\n",
    "            for node in self.drivers_to_nodes[d]:\n",
    "                self.nodes_to_drivers[node].remove(d)\n",
    "            del self.drivers_to_nodes[d]\n",
    "            \n",
    "        else :\n",
    "            node_set = set([item for sublist in d.perceptions for item in sublist])\n",
    "            #print(\"node set\",node_set)\n",
    "            #print(\"d nodes ranges\",d.perceptions)\n",
    "            if d in self.drivers_to_nodes.keys() :\n",
    "                #noeuds à retirer\n",
    "                old_nodes = self.drivers_to_nodes[d] - node_set\n",
    "                #noeuds à ajouter\n",
    "                new_nodes = node_set - self.drivers_to_nodes[d]\n",
    "\n",
    "                for old_node in old_nodes:\n",
    "                    self.nodes_to_drivers[old_node].remove(d)\n",
    "\n",
    "                for new_node in new_nodes:\n",
    "                    self.nodes_to_drivers[new_node].add(d)\n",
    "            else :\n",
    "                for node in node_set:\n",
    "                    self.nodes_to_drivers[node].add(d)\n",
    "\n",
    "\n",
    "            self.drivers_to_nodes[d] = node_set\n",
    "            \n",
    "    def get_drivers_from_node(self, node):\n",
    "        \n",
    "        return self.nodes_to_drivers[node]\n",
    "    \n",
    "    def get_nodes_from_driver(self,driver):\n",
    "        \n",
    "        return self.drivers_to_nodes[driver]\n",
    "    \n",
    "    def update(self):\n",
    "        #print(\"nodes to drivers\",self.nodes_to_drivers)\n",
    "        #print(\"drivers to nodes\",self.drivers_to_nodes)\n",
    "        pass\n",
    "    \n",
    "    def decide(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# download/model a street network for some city then visualize it\n",
    "G = ox.graph_from_place('Piedmont, California, USA', network_type='drive') \n",
    "fig, ax = ox.plot_graph(G,  figsize=(20, 20),  node_size=70)\n",
    "hwy_speeds = {'residential': 30,\n",
    "              'secondary': 50,\n",
    "              'tertiary': 70}\n",
    "G = ox.add_edge_speeds(G, hwy_speeds)\n",
    "\n",
    "#temps arrondis\n",
    "G = ox.add_edge_travel_times(G, precision=0)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounds = 10000\n",
    "sma = SMA()\n",
    "G = sma.G\n",
    "sma.tick = 0\n",
    "orig = list(G)[1]\n",
    "dest = list(G)[120]\n",
    "#d1 = ContinuousDriverAgent(1, orig, dest, detour=0.5, pref_weight='length',test=True)\n",
    "d1 = ContinuousDriverAgent(2, orig, dest, detour_factor=0.5, pref_weight='travel_time',test=False)\n",
    "sma.addAgent(d1)\n",
    "for _ in range(rounds):\n",
    "    sma.runOnce()\n",
    "    #print(sma.rtree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounds = 50\n",
    "sma = SMA()\n",
    "sma.setRoadGraph(G)\n",
    "sma.tick = 0\n",
    "orig = list(G)[1]\n",
    "dest = list(G)[120]\n",
    "#d1 = ContinuousDriverAgent(1, orig, dest, detour=0.5, pref_weight='length',test=True)\n",
    "tsa1 = TransportServiceAgent(1)\n",
    "d1 = ContinuousDriverAgent(2, orig, dest, detour_factor=0.1, pref_weight='travel_time',test=True)\n",
    "\n",
    "sma.addAgent(tsa1)\n",
    "sma.addAgent(d1)\n",
    "\n",
    "sma.runOnce()\n",
    "nc = ['b' if (v in d1.get_perception_set_node()) else 'w' for v in sma.G.nodes()]\n",
    "\n",
    "fig, ax = ox.plot_graph(sma.G, figsize=(20, 20), node_color=nc, node_edgecolor='k', node_size=70, \n",
    "                           node_zorder=3, edge_color='w', edge_linewidth=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounds = 50\n",
    "sma = SMA()\n",
    "sma.setRoadGraph(G)\n",
    "sma.tick = 0\n",
    "orig = list(G)[1]\n",
    "dest = list(G)[120]\n",
    "#d1 = ContinuousDriverAgent(1, orig, dest, detour=0.5, pref_weight='length',test=True)\n",
    "tsa1 = TransportServiceAgent(1)\n",
    "d1 = ContinuousDriverAgent(2, orig, dest, detour_factor=0.8, pref_weight='travel_time',test=True)\n",
    "\n",
    "sma.addAgent(tsa1)\n",
    "sma.addAgent(d1)\n",
    "\n",
    "nc = ['b' if (v in d1.get_perception_set_node()) else 'w' for v in sma.G.nodes()]\n",
    "\n",
    "fig, ax = ox.plot_graph(sma.G, figsize=(20, 20), node_color=nc, node_edgecolor='k', node_size=30, \n",
    "                           node_zorder=3, edge_color='w', edge_linewidth=3)\n",
    "\n",
    "for _ in range(rounds):\n",
    "    sma.runOnce()\n",
    "print(d1.get_perception_set_node())\n",
    "r1, r2 = random.sample(d1.get_perception_set_node(),2)\n",
    "\n",
    "d1.add_rider_to_scheduler(None,  r1, r2, 60, 100)\n",
    "\n",
    "for _ in range(10000):\n",
    "    sma.runOnce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SPL = nx.shortest_path_length(sma.G, orig, dest, weight='length')\n",
    "# sub_g_orig = ox.truncate.truncate_graph_dist(sma.G, orig, max_dist=SPL/4, weight='length', retain_all=True)\n",
    "# #fig, ax = ox.plot_graph(sub_g)\n",
    "\n",
    "# sub_g_dest = ox.truncate.truncate_graph_dist(sma.G, dest, max_dist=SPL/4, weight='length', retain_all=True)\n",
    "# #fig, ax = ox.plot_graph(sub_g)\n",
    "\n",
    "# ec = ['b' if ((u,v) in sub_g_orig.edges() or (u,v) in sub_g_dest.edges()) else 'r' for u, v, k in sma.G.edges(keys=True)]\n",
    "\n",
    "# fig, ax = ox.plot_graph(sma.G, node_color='w', node_edgecolor='k', node_size=30, \n",
    "#                            node_zorder=3, edge_color=ec, edge_linewidth=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "orig = list(G)[1]\n",
    "dest = list(G)[120]\n",
    "weight='travel_time'\n",
    "SPL = nx.shortest_path_length(sma.G, orig, dest, weight=weight)\n",
    "coef_det = 0.2\n",
    "det = SPL + (SPL*coef_det)\n",
    "\n",
    "\n",
    "def get_perception(self, orig, dest, max_weight):\n",
    "    visited = []\n",
    "    perception = []\n",
    "    current_node = orig\n",
    "    self.algo_recu(current_node)\n",
    "    return perception\n",
    "\n",
    "def algo_recu(self, current_node):\n",
    "    for succ in G.neighbors(current_node):\n",
    "        if succ not in visited :\n",
    "            visited.append(succ)\n",
    "            try: \n",
    "                if nx.shortest_path_length(sma.G, orig, succ, weight=self.pref_weight) + nx.shortest_path_length(sma.G, succ, dest, weight=pref_weight) <= max_weight:\n",
    "                    perception.append(succ)\n",
    "                    self.algo_recu(succ)\n",
    "            except (KeyError, nx.NetworkXNoPath):\n",
    "                pass\n",
    "            \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nc = ['b' if (v in perception) else 'w' for v in sma.G.nodes()]\n",
    "\n",
    "fig, ax = ox.plot_graph(sma.G, node_color=nc, node_edgecolor='k', node_size=30, \n",
    "                           node_zorder=3, edge_color='w', edge_linewidth=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "routes = ox.k_shortest_paths(G, orig, dest, k=2, weight='length')\n",
    "fig, ax = ox.plot_graph_routes(G, list(routes), route_colors='y', route_linewidth=4, node_size=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Faire ce quil y a au dessus mais pour chaque noeuds composant le shortest trip ? AVEC SLK''' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_all_paths(G, source, target, weight_name, w):\n",
    "    cutoff = len(G)-1\n",
    "    visited = [source]\n",
    "    stack = [iter(G[source])]\n",
    "    weight = 0\n",
    "    while stack:\n",
    "        children = stack[-1]\n",
    "        child = next(children, None)\n",
    "        if child is None:\n",
    "            stack.pop()\n",
    "            visited.pop()\n",
    "        elif len(visited) < cutoff:\n",
    "            if child == target:\n",
    "                if (visited[-1],child) in G.edges():\n",
    "                    temp = G[visited[-1]][child][0][weight_name]\n",
    "                else:\n",
    "                    temp = G[child][visited[-1]][0][weight_name]\n",
    "                if weight+temp <= w:\n",
    "                    yield visited + [target]\n",
    "            elif child not in visited:\n",
    "                if (visited[-1],child) in G.edges():\n",
    "                    weight += G[visited[-1]][child][0][weight_name]\n",
    "                else:\n",
    "                    weight += G[child][visited[-1]][0][weight_name]\n",
    "                visited.append(child)\n",
    "                stack.append(iter(G[child]))\n",
    "        else: \n",
    "            if child == target or target in children:\n",
    "                if (visited[-1],child) in G.edges():\n",
    "                    temp = G[visited[-1]][child][0][weight_name]\n",
    "                else:\n",
    "                    temp = G[child][visited[-1]][0][weight_name]\n",
    "                if weight+temp <= w:\n",
    "                    yield visited + [target]\n",
    "            stack.pop()\n",
    "            visited.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_perception(G, source, target, weight_name, w):\n",
    "    SPL = nx.shortest_path_length(G, source, target,  weight='length'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SP =  nx.shortest_path_length(sma.G, orig, dest, weight='length')\n",
    "paths = list(nx.all_simple_paths(sma.G, orig, dest, cutoff=10))\n",
    "#paths = list(my_all_paths(sma.G, source=orig, target=dest, weight_name='length', w=10))\n",
    "        #return set([item for sublist in paths for item in sublist])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = nx.johnson(sma.G, weight='length')\n",
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(G.nodes())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sma.addAgent(d1)\n",
    "for _ in range(rounds):\n",
    "    sma.runOnce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}