with social score.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook for With Social Score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import json\n",
    "import matplotlib.pyplot as plt\n",
    "import mysql.connector\n",
    "import numpy as np\n",
    "import requests\n",
    "import csv\n",
    "from mysql.connector import errorcode\n",
    "from urllib.request import URLError, Request, urlopen\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uncomment and run this cell just once to update the distance and time obtained from GraphHopper from source to destination into the database \n",
    "\n",
    "### (Only the first time for the respective time) \n",
    "#### command to uncomment the whole cell: (ctrl + /)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #Looping through all the data in CSV and inserting them into the database\n",
    "# dataCount = 0\n",
    "# cnn = mysql.connector.connect(\n",
    "#         user='root',\n",
    "#         password='root',\n",
    "#         host='localhost',\n",
    "#         port=3306,\n",
    "#         database='cs581_rideshare')\n",
    "# cursor = cnn.cursor()\n",
    "\n",
    "# trip_date = datetime.date(2015,5,15)\n",
    "# start_time = datetime.time(8,0,0)\n",
    "# end_time = datetime.time(9,0,0)\n",
    "\n",
    "\n",
    "# sql1 = \"select trip_id, dropoff_latitude, dropoff_longitude from trip_details2 where trip_date = '\" + str(trip_date) + \"'and pickup_time >= '\" + str(start_time) + \"'and pickup_time < '\" + str(end_time) + \"'\"\n",
    "# cursor.execute(sql1)\n",
    "# result = cursor.fetchall()\n",
    "# try:\n",
    "#     for row in result:\n",
    "#         #print(type(data[0]))\n",
    "#         if float(row[1]) != 0 and float(row[2]) != 0:\n",
    "#             result1 = GraphHopperDistance.find_distance(40.796842, -73.949662,row[1], row[2])\n",
    "#             if result1[0] >= 0.0 and result1[1] >= 0.0:\n",
    "#                 sql = \"update trip_details2 set distance = %s, travel_time = %s where trip_id = %s\" % (float(result1[0]), float(result1[1]), row[0])\n",
    "#                 #print sql\n",
    "#                 cursor.execute(sql)\n",
    "#                 cnn.commit()\n",
    "#             else:\n",
    "#                 sql = \"update trip_details2 set distance = %s, travel_time = %s where trip_id = %s\" % (float(200), float(300), row[0])\n",
    "#                 #print sql\n",
    "#                 cursor.execute(sql)\n",
    "#                 cnn.commit()\n",
    "#         #print data\n",
    "#         rowFlag = True\n",
    "#         dataCount += 1\n",
    "# except mysql.connector.Error:\n",
    "#     print(\"error\")\n",
    "# print ('Rows inserted: ',dataCount)\n",
    "# cursor.close()\n",
    "#cnn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Setting the source lat and long position to JFK airport**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# JFK : (40.796842, -73.949662)\n",
    "# Central Park : (40.796842, -73.949662)\n",
    "\n",
    "(SOURCE_LATITUDE, SOURCE_LONGITUDE) = (40.796842, -73.949662)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**This function helps calculate the next pool window given the present start time and POOL WINDOW time in seconds**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def time_plus(time, timedelta):\n",
    "    start = datetime.datetime(\n",
    "        2000, 1, 1,\n",
    "        hour=time.hour, minute=time.minute, second=time.second)\n",
    "    end = start + timedelta\n",
    "    return end.time()\n",
    "\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set the start date, start time, end time and pool window size in seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#SETTING START DATE and START TIME and END TIME for that day\n",
    "start_date = datetime.date(2015,5,15)\n",
    "start_time = datetime.time(8,10,0)\n",
    "until_time = datetime.time(8,11,0)\n",
    "\n",
    "#POOL WINDOW SIZE\n",
    "windowsize = datetime.timedelta(0,60) # Setting the window size\n",
    "end_time = time_plus(start_time, windowsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Classes to represent the Location longitude and latitude and Trip details**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Location:\n",
    "    \"\"\"\n",
    "    Represents the coordinates of a location\n",
    "    \"\"\"\n",
    "    def __init__(self, latitude, longitude):\n",
    "        self.latitude = latitude\n",
    "        self.longitude = longitude\n",
    "        \n",
    "        \n",
    "class Trip:\n",
    "    \"\"\"\n",
    "    Represents the attributes of a trip\n",
    "    \"\"\"\n",
    "    def __init__(self, trip_id, pickup_lat, pickup_long,dropoff_lat, dropoff_long, pickup_time, dropoff_time, passenger_count, distance,graph_distance,graph_time):\n",
    "        self.id = trip_id\n",
    "        self.pickup_lat = pickup_lat\n",
    "        self.pickup_long = pickup_long\n",
    "        self.dropoff_lat = dropoff_lat\n",
    "        self.dropoff_long = dropoff_long\n",
    "        self.pickup_time = pickup_time\n",
    "        self.dropoff_time = dropoff_time\n",
    "        self.passenger_count = passenger_count\n",
    "        self.distance = distance\n",
    "        self.gh_distance = graph_distance\n",
    "        self.gh_time = graph_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Function to get all the trip details from the database for a particular trip window**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data (start_date,start_time,end_time):\n",
    "    cnn = mysql.connector.connect(\n",
    "        user='root',\n",
    "        password='root',\n",
    "        host='localhost',\n",
    "        port=3306,\n",
    "        database='cs581_rideshare')\n",
    "    sql = \"select * from trip_details2 where trip_date = '\" + str(start_date) + \"'and pickup_time >= '\" + str(start_time) + \"'and pickup_time < '\" + str(end_time) + \"'\"\n",
    "    \n",
    "    cursor = cnn.cursor()\n",
    "    cursor.execute(sql)\n",
    "    result = cursor.fetchall()\n",
    "    tripList = []\n",
    "    for row in result:\n",
    "        trip = Trip(int(row[0]), row[6],row[7],row[8],row[9], row[2], row[3], row[4], row[5],row[10],row[11])\n",
    "        tripList.append(trip)\n",
    "    cursor.close()\n",
    "    cnn.close()\n",
    "    return tripList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Class with functions to calculate the distance and time by calling GraphHopper API and converting the distance and time to miles and minutes  respectively**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GraphHopperDistance:\n",
    "    def distance_miles(distance):\n",
    "        miles = distance / 1609.344\n",
    "        return round(miles, 2)\n",
    "\n",
    "    def time_mins(time):\n",
    "        minute, reminder = divmod(time, 60000)\n",
    "        if reminder >= 50:\n",
    "            minute += 1\n",
    "        return minute\n",
    "\n",
    "    def find_distance(pickup_latitude, pickup_longitude, dropoff_latitude, dropoff_longitude):\n",
    "        request_str = 'http://localhost:8989/route?point=' + str(pickup_latitude) + '%2C' + str(pickup_longitude) + '&point=' + str(\n",
    "            dropoff_latitude) + '%2C' + str(dropoff_longitude) + '&vehicle=car'\n",
    "        request = Request(request_str)\n",
    "\n",
    "        try:\n",
    "            response = urlopen(request)\n",
    "            req = requests.get(request_str)\n",
    "            output = json.loads(req.text)\n",
    "            paths = output[\"paths\"]\n",
    "            distance = GraphHopperDistance.distance_miles(paths[0][\"distance\"])\n",
    "            time = GraphHopperDistance.time_mins(paths[0][\"time\"])\n",
    "            result = [distance, time]\n",
    "        except URLError:\n",
    "            result = [-1, -1]\n",
    "\n",
    "        return result\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Function to obatin all the trip details given a trip id**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_trip_details (trip_id):\n",
    "        cnn = mysql.connector.connect(\n",
    "        user='root',\n",
    "        password='root',\n",
    "        host='localhost',\n",
    "        port=3306,\n",
    "        database='cs581_rideshare')\n",
    "        \n",
    "        sql = \"select * from trip_details2 where trip_id = %s\" %trip_id\n",
    "        cursor = cnn.cursor()\n",
    "        cursor.execute(sql)\n",
    "        result = cursor.fetchall()\n",
    "        trip = Trip(int(result[0][0]),result[0][6], result[0][7],result[0][8], result[0][9], result[0][2], result[0][3], result[0][4], result[0][5],result[0][10],result[0][11])\n",
    "        cursor.close()\n",
    "        cnn.close()\n",
    "        return trip\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class with functions to\n",
    "    1. Create trip pairs\n",
    "    2. Adding a trip to another\n",
    "    4. Find the Distace Saving\n",
    "    5. Find Cost Saving\n",
    "    6. Find the count of trips in a merge\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mergedtrips:\n",
    "    def __init__(self, trip1, trip2, ):\n",
    "        self.trip_list1 = []\n",
    "        if(trip1 == trip2):\n",
    "            raise Exception(\"Duplicate Trip\")\n",
    "        self.trip_list1.append(trip1)\n",
    "        self.trip_list1.append(trip2)\n",
    "    \n",
    "    def add(self, trip_id):\n",
    "        if(not(trip_id in self.trip_list1)):\n",
    "            self.trip_list1.append(trip_id)\n",
    "        else:    \n",
    "            raise Exception(\"Duplicate Trip\")\n",
    "        \n",
    "    \n",
    "    def saved_distance(self,distance_matrix,dm_individual):\n",
    "        #try:\n",
    "        dist_matrix= distance_matrix\n",
    "        dm_individual = dm_individual\n",
    "        dist_m = {}\n",
    "        ordered_trip_list1 = []\n",
    "        for id in self.trip_list1:\n",
    "            trip = get_trip_details(id)\n",
    "            distance = dm_individual[trip.id]\n",
    "            if distance > 0:\n",
    "                dist_m[distance] = id\n",
    "        for distance in sorted(list(dist_m)):\n",
    "            ordered_trip_list1.append(dist_m[distance])\n",
    "        trip = get_trip_details(ordered_trip_list1[0])\n",
    "        combined_trip_distance = trip.gh_distance\n",
    "        i=1\n",
    "        source = 0\n",
    "        while(i<len(ordered_trip_list1)):\n",
    "            trip1 = get_trip_details(ordered_trip_list1[source])\n",
    "            trip2 = get_trip_details(ordered_trip_list1[i])\n",
    "            x = trip1.id\n",
    "            y = trip2.id\n",
    "            if x >=y:\n",
    "                difference = dist_matrix[y][x]\n",
    "            else:\n",
    "                difference = dist_matrix[x][y]\n",
    "            if difference > 0:\n",
    "                source = i\n",
    "                combined_trip_distance = float(combined_trip_distance) + float(difference)\n",
    "            else: \n",
    "                print(\"error in distance gain\")\n",
    "            i += 1\n",
    "        normal_trip_distance = sum(list(dist_m))\n",
    "        return (normal_trip_distance, combined_trip_distance)\n",
    "        \n",
    "    def saved_cost(self,dm_individual):\n",
    "        dist_m = {}\n",
    "        dm_individual = dm_individual\n",
    "        combined_cost = 0.0\n",
    "        for id in self.trip_list1:\n",
    "            trip = get_trip_details(id)\n",
    "            distance = dm_individual[trip.id]\n",
    "            dist_m[distance] = id\n",
    "        list_mapping = list(dist_m)\n",
    "        sum_distance = sum(list_mapping)\n",
    "        if len(self.trip_list1) == 4:\n",
    "            combined_cost = sum_distance * 0.6 \n",
    "        elif len(self.trip_list1) == 3:\n",
    "            combined_cost = sum_distance * 0.7\n",
    "        elif len(self.trip_list1) == 2:\n",
    "            combined_cost = sum_distance * 0.8\n",
    "        return(sum_distance, combined_cost)\n",
    "    \n",
    "    def __str__(self):\n",
    "        sorted_trip_list = sorted(self.trip_list1)\n",
    "        hashed_string = \"\"\n",
    "        for trip in sorted_trip_list:\n",
    "            hashed_string += str(trip).zfill(20)\n",
    "        return hashed_string\n",
    "    \n",
    "    def __hash__(self):\n",
    "        return str(self).__hash__()\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return sorted(self.trip_list1) == sorted(other.trip_list1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions to calculate Social Score\n",
    "    Finds the range that the Merged trip belong to and according compares the difference in the Social Preferences to the Threshold value. If satisfied then returns True, else returns False "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getAllowedDifference(sharedDistance,source):\n",
    "    if source==\"JFK\":\n",
    "        if sharedDistance >20.0:\n",
    "            return 0.3\n",
    "        elif sharedDistance > 9.0:\n",
    "            return 0.5\n",
    "        else:\n",
    "            return 0.8\n",
    "    elif source==\"MAN\":\n",
    "        if sharedDistance >20.0:\n",
    "            return 0.8\n",
    "        elif sharedDistance >9.0:\n",
    "            return 0.5\n",
    "        else:\n",
    "            return 0.3\n",
    "    else:\n",
    "        if sharedDistance >40.0:\n",
    "            return 0.3\n",
    "        elif sharedDistance >30.0:\n",
    "            return 0.5\n",
    "        else:\n",
    "            return 0.8\n",
    "    return\n",
    "\n",
    "\n",
    "def areSociallyCompatible(tripId1,tripId2,sharedDistance,source='JFK'):\n",
    "    cnn = mysql.connector.connect(\n",
    "        user='root',\n",
    "        password='root',\n",
    "        host='localhost',\n",
    "        port=3306,\n",
    "        database='cs581_rideshare')\n",
    "    statement = \"select * from user_preferences2 where tripId in(\"+str(tripId1)+\",\"+str(tripId2)+\")\"\n",
    "    cursor = cnn.cursor()\n",
    "    cursor.execute(statement)\n",
    "    passengers = cursor.fetchall()\n",
    "    cursor.close()\n",
    "    cnn.close()\n",
    "    if(len(passengers)<2):\n",
    "        return False\n",
    "    else:\n",
    "        maxRange=getAllowedDifference(sharedDistance,source)\n",
    "        total_preferences=3\n",
    "        prefNum=3\n",
    "        compatiblePreferencesCount=0\n",
    "        totalPreferencesDiff=0;\n",
    "        for i in range(prefNum,prefNum+total_preferences):\n",
    "            totalPreferencesDiff+=abs(passengers[0][i]-passengers[1][i])\n",
    "        if (totalPreferencesDiff/30)<maxRange:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function for suspending unmerged requests to next pool if opted for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nextpoolFunc(trip_id):\n",
    "    cnn = mysql.connector.connect(\n",
    "        user='root',\n",
    "        password='root',\n",
    "        host='localhost',\n",
    "        port=3306,\n",
    "        database='cs581_rideshare')    \n",
    "    sql1 = \"select pools_remaining from cs581_rideshare.user_preferences2 where tripId = %s\" %trip_id\n",
    "    cursor1 = cnn.cursor()\n",
    "    cursor1.execute(sql1)\n",
    "    result = cursor1.fetchall()\n",
    "    cursor1.close()\n",
    "    if result[0][0] > 0:\n",
    "        res=result[0][0]\n",
    "        res-=1\n",
    "        sql = \"update cs581_rideshare.user_preferences2 set pools_remaining=%s where tripId = %s \"%(res,trip_id)\n",
    "        cursor1 = cnn.cursor()\n",
    "        cursor1.execute(sql)\n",
    "        cnn.commit()\n",
    "        cursor1.close()\n",
    "        cnn.close()\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "def nextpool_list(global_nextpool):\n",
    "    trip_list = []\n",
    "    for abc in global_nextpool:\n",
    "        trip = get_trip_details(abc)\n",
    "        trip_list.append(trip)\n",
    "    return trip_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions to find the potential ride shares from all the trips in the pool window\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def get_graph(trips):\n",
    "    graph_for_first_iteration = nx.Graph()\n",
    "    distance_matrix = {}\n",
    "    dm_individual = {}\n",
    "    d2 = {}\n",
    "    #print(distance_matrix)\n",
    "    for i in range(len(trips)):\n",
    "        for j in range(i, len(trips)):\n",
    "            x = trips[i].id\n",
    "            y = trips[j].id\n",
    "            trip_distance_i = float(trips[i].gh_distance)\n",
    "            trip_time_i = float(trips[i].gh_time)\n",
    "            dm_individual[x] = trip_distance_i\n",
    "            trip_distance_j = float(trips[j].gh_distance)\n",
    "            trip_time_j = float(trips[j].gh_time)\n",
    "            dm_individual[y] = trip_distance_j\n",
    "            distance_between_destinations,time_between_destinations = GraphHopperDistance.find_distance(trips[i].dropoff_lat, trips[i].dropoff_long, trips[j].dropoff_lat, trips[j].dropoff_long)\n",
    "            d2[y]=distance_between_destinations\n",
    "            a, b = sorted([trip_distance_i, trip_distance_j])\n",
    "            ab = distance_between_destinations\n",
    "            distance_for_combined_trip = a + ab\n",
    "            #CHECK FOR TIME DELAY CONSTRAINTS\n",
    "            if(trip_distance_i <= trip_distance_j):\n",
    "                shared_distance = trip_distance_i\n",
    "                treshold = 1.2*trip_time_j\n",
    "                time_delay = trip_time_i + time_between_destinations\n",
    "            else:\n",
    "                shared_distance = trip_distance_j\n",
    "                treshold = 1.2*trip_time_i\n",
    "                time_delay = trip_time_j + time_between_destinations\n",
    "            #Calculate Sharing Distance Gain\n",
    "            sharing_gain = abs(distance_for_combined_trip-(a+b))\n",
    "            \n",
    "            #Check if Socially Similar\n",
    "            xyz = areSociallyCompatible(x,y,shared_distance)\n",
    "            \n",
    "            if(time_delay < treshold and xyz):\n",
    "                graph_for_first_iteration.add_nodes_from([trips[i].id, trips[j].id])\n",
    "                graph_for_first_iteration.add_edge(trips[i].id, trips[j].id, weight=sharing_gain, delay=time_delay)\n",
    "        distance_matrix[x]=copy.deepcopy(d2)\n",
    "    return (graph_for_first_iteration,distance_matrix,dm_individual)\n",
    "\n",
    "#This method is to run the maximum matching on the constructed graph and to get the results\n",
    "def get_merged_trips(graph12):\n",
    "    list_of_merged_trips = {}\n",
    "    matched_edges = nx.algorithms.matching.max_weight_matching(graph12)\n",
    "    for i in matched_edges:\n",
    "        trip1 = i\n",
    "        trip2 = matched_edges[i]\n",
    "        list_of_merged_trips[Mergedtrips(trip1, trip2, )] = {\"sharing_gain\": graph12[trip1][trip2][\"weight\"], \"delay\": graph12[trip1][trip2][\"delay\"]}\n",
    "    return list(list_of_merged_trips)\n",
    "\n",
    "#remove edges for the second round\n",
    "def remove_sharedtrip_edge_from_graph(graph, list_of_merged_trips):\n",
    "    graph_copy = copy.deepcopy(graph)\n",
    "    for merged_trip in list_of_merged_trips:\n",
    "        graph_copy.remove_edge(merged_trip.trip_list1[0], merged_trip.trip_list1[1])\n",
    "    return graph_copy\n",
    "\n",
    "#This is to get the Lone trips after the algorithm finishes running\n",
    "def single_trip(list_of_merged_trips):\n",
    "    single_trip_list = []\n",
    "    tripdetails = get_data(start_date,start_time,end_time)\n",
    "    for trip in tripdetails:\n",
    "        merged = False\n",
    "        for merged_trip in list_of_merged_trips:\n",
    "            if(trip.id in merged_trip.trip_list1):\n",
    "                merged = True\n",
    "                break\n",
    "        if (not(merged)):\n",
    "            single_trip_list.append(trip.id)\n",
    "    return single_trip_list\n",
    "\n",
    "#This method is to check of a method is already merged with another node\n",
    "def if_merged(list_of_merged_trips, trip):\n",
    "    for merged_trip in list_of_merged_trips:\n",
    "        if(trip in merged_trip.trip_list1):\n",
    "            return len(merged_trip.trip_list1) < 3\n",
    "    return True\n",
    "\n",
    "\n",
    "#This method is find a trip from a list of merged trips\n",
    "def better_merges(list_of_merged_trips, merged_trip):\n",
    "    try:\n",
    "        def matched_trip(list_of_merged_trips, trip):\n",
    "            for merged_trip in list_of_merged_trips:\n",
    "                if(trip in merged_trip.trip_list1):\n",
    "                    if(len(merged_trip.trip_list1) <= 2):\n",
    "                        return merged_trip\n",
    "        \n",
    "        trip1 = matched_trip(list_of_merged_trips, merged_trip.trip_list1[0])\n",
    "        trip2 = matched_trip(list_of_merged_trips, merged_trip.trip_list1[1])\n",
    "\n",
    "        if trip1 and trip2:\n",
    "            trip1.add(trip2.trip_list1[0])\n",
    "            trip1.add(trip2.trip_list1[1])\n",
    "            list_of_merged_trips.pop(list_of_merged_trips.index(trip2))\n",
    "            return merged_trip\n",
    "\n",
    "        elif trip1:\n",
    "            if if_merged(list_of_merged_trips, merged_trip.trip_list1[1]):\n",
    "                trip1.add(merged_trip.trip_list1[1])\n",
    "            return trip1\n",
    "\n",
    "        elif trip2:\n",
    "            if if_merged(list_of_merged_trips, merged_trip.trip_list1[0]):\n",
    "                trip2.add(merged_trip.trip_list1[0])\n",
    "            return trip2\n",
    "    except Exception as e:\n",
    "        raise e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function to call all the other functions and find the overall merged trips for the given Start and End time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import networkx as nx\n",
    "import copy\n",
    "import datetime\n",
    "\n",
    "\n",
    "\n",
    "#This is the main method for executing the algorithm\n",
    "def algorithm(global_nextpool,start_date,start_time,end_time):\n",
    "    trip_subset = get_data(start_date,start_time,end_time)\n",
    "    print(\"trip_subset len:\",len(trip_subset))\n",
    "    list1 = nextpool_list(global_nextpool)\n",
    "    trip_subset = trip_subset + list1\n",
    "    print(\"new trip_subset len:\",len(trip_subset))\n",
    "    tx = datetime.datetime.now()\n",
    "    graph_for_first_iteration,dist_matrix,dm_individual = get_graph(trip_subset)\n",
    "    ty = datetime.datetime.now()\n",
    "    print(ty - tx)\n",
    "    trips_merged_in_first_round = get_merged_trips(graph_for_first_iteration)\n",
    "    graph_for_second_iteration = remove_sharedtrip_edge_from_graph(graph_for_first_iteration, trips_merged_in_first_round)\n",
    "\n",
    "    merged_trips = get_merged_trips(graph_for_second_iteration)\n",
    "    for merged_trip in merged_trips:\n",
    "        better_merges(trips_merged_in_first_round, merged_trip)\n",
    "\n",
    "    actual_cost = 0.0\n",
    "    saved_cost = 0.0\n",
    "    actual_dist = 0.0\n",
    "    saved_dist = 0.0\n",
    "    cost = 0.0\n",
    "    share_cost = 0.0\n",
    "    dist = 0.0\n",
    "    tripDist = 0.0\n",
    "    four_trips = 0\n",
    "    three_trips = 0\n",
    "    two_trips = 0\n",
    "    pool_detail = {}\n",
    "    next_pool = []\n",
    "    single_trips = single_trip(trips_merged_in_first_round)\n",
    "    print(\"Single trips:\")\n",
    "    for trip in single_trips:\n",
    "        print(trip)\n",
    "        ac = trip\n",
    "        if (nextpoolFunc(ac)):\n",
    "            next_pool.append(trip)\n",
    "    if(len(trip_subset)<2 and len(trip_subset)>0):\n",
    "        tripdet = get_trip_details(trip_subset[0].id)\n",
    "        dist12 = dist12 + float(tripdet.gh_distance)\n",
    "    for i in trips_merged_in_first_round:\n",
    "        if len(i.trip_list1) == 2:\n",
    "            two_trips += 1\n",
    "        elif len(i.trip_list1) == 3:\n",
    "            three_trips += 1\n",
    "        elif len(i.trip_list1) == 4:\n",
    "            four_trips += 1\n",
    "        actual_dist, shared_dist = i.saved_distance(dist_matrix,dm_individual)\n",
    "        actual_cost, shared_cost = i.saved_cost(dm_individual)\n",
    "        cost = cost + actual_cost\n",
    "        share_cost = share_cost + shared_cost\n",
    "        dist = dist + actual_dist\n",
    "        tripDist = tripDist + float(shared_dist)\n",
    "    if(len(trip_subset)<2):\n",
    "        print (\"Actual distance: \",dist12)\n",
    "    else:\n",
    "        print (\"Actual distance: \",dist)\n",
    "    #print (\"Actual distance: \",dist)\n",
    "    print (\"Combined distance:\",tripDist)\n",
    "    print (\"Actual Cost:\",cost)\n",
    "    print (\"Combined Cost:\",share_cost)\n",
    "    print(\"single trips:\", len(single_trips))\n",
    "    print (\"four_trips: \",four_trips)\n",
    "    print (\"two_trips:\",two_trips)\n",
    "    print (\"three_trips:\",three_trips)\n",
    "    pool_detail = {'actual_dist':dist,'combined_dist':tripDist,'actual_cost':cost,'combined_cost':share_cost,'single_trips':len(single_trips),'two_sharing':two_trips,\n",
    "                  'three_sharing':three_trips,'four_sharing':four_trips}\n",
    "    return pool_detail,next_pool\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Method that calls the algorithm function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "pool :  08:10:00 - 08:11:00\n",
      "trip_subset len: 20\n",
      "new trip_subset len: 20\n",
      "0:00:04.172989\n",
      "Single trips:\n",
      "493325\n",
      "493326\n",
      "493330\n",
      "493334\n",
      "Actual distance:  82.65\n",
      "Combined distance: 30.880000000000003\n",
      "Actual Cost: 82.65\n",
      "Combined Cost: 49.589999999999996\n",
      "single trips: 4\n",
      "four_trips:  4\n",
      "two_trips: 0\n",
      "three_trips: 0\n",
      "{'08:10:00': {'combined_dist': 30.880000000000003, 'single_trips': 4, 'combined_cost': 49.589999999999996, 'actual_cost': 82.65, 'four_sharing': 4, 'three_sharing': 0, 'actual_dist': 82.65, 'two_sharing': 0}}\n",
      "0:00:04.671480\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#This is to execute the algorithm when this method is made to run\n",
    "if __name__ == \"__main__\":\n",
    "    tic = datetime.datetime.now()\n",
    "    pool_details = {} \n",
    "    global_nextpool = []\n",
    "    while end_time <= until_time:\n",
    "        print(\"\\npool : \",start_time, \"-\",end_time)\n",
    "        nextpool1 = []\n",
    "        pool_details[str(start_time)],nextpool1 = algorithm(global_nextpool,start_date,start_time,end_time)\n",
    "        global_nextpool = nextpool1\n",
    "        start_time = time_plus(start_time,windowsize)\n",
    "        end_time = time_plus(end_time,windowsize)\n",
    "    print(pool_details)\n",
    "    toc = datetime.datetime.now()\n",
    "    print (toc - tic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Writing the output dictionary to a csv file** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bx = []\n",
    "for key,values in pool_details.items():\n",
    "    ax = []\n",
    "    ax.append(key)\n",
    "    for abc in list(values.values()):\n",
    "        ax.append(abc)\n",
    "    bx.append(ax)\n",
    "print(bx)\n",
    "import csv\n",
    "with open('output.csv', 'w') as csv_file:\n",
    "    csvwriter = csv.writer(csv_file, delimiter=',')\n",
    "    for row in bx:\n",
    "        csvwriter.writerow(row)"
   ]
  }
 ],
 "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.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}