pathGeneratorGMAPS.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import json\n",
    "import subprocess\n",
    "import shutil\n",
    "import random\n",
    "\n",
    "if 'SUMO_HOME' in os.environ:\n",
    "    sys.path.append(os.path.join(os.environ['SUMO_HOME'], 'tools'))\n",
    "import sumolib\n",
    "import importlib\n",
    "from pprint import pprint\n",
    "import xml.etree.ElementTree as ET\n",
    "from xml.dom import minidom\n",
    "\n",
    "# Add the \"scripts\" directory to sys.path\n",
    "current_dir = os.path.dirname(os.path.abspath(\"__file__\"))\n",
    "scripts_dir = os.path.abspath(os.path.join(current_dir, 'scripts'))\n",
    "sys.path.append(scripts_dir)\n",
    "import vehParameters\n",
    "import GoogleMapsGeocoding as gmaps\n",
    "import LLAMAconnect\n",
    "\n",
    "FOLDER_NAME = \"unicamp\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_xml_parameter(file_path, parameter, new_value, operation=\"modify\"):\n",
    "    \"\"\"\n",
    "    Updates or appends the value of a specified parameter in the given XML configuration file.\n",
    "\n",
    "    Args:\n",
    "        file_path (str): Path to the XML configuration file.\n",
    "        parameter (str): The parameter to be updated (e.g., 'route-files').\n",
    "        new_value (str): The new value to set or append to the parameter.\n",
    "        operation (str): The operation to perform ('modify' or 'append'). Default is 'modify'.\n",
    "\n",
    "    Returns:\n",
    "        bool: True if the update was successful, False otherwise.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        # Parse the XML file\n",
    "        tree = ET.parse(file_path)\n",
    "        root = tree.getroot()\n",
    "\n",
    "        # Search for the parameter within the XML\n",
    "        for elem in root.iter():\n",
    "            if elem.tag == parameter:\n",
    "                current_value = elem.get('value', '')\n",
    "\n",
    "                if operation == \"modify\":\n",
    "                    # Set the new value, replacing the old one\n",
    "                    elem.set('value', new_value)\n",
    "                    print(f\"Modified {parameter} to {new_value}\")\n",
    "                elif operation == \"append\":\n",
    "                    # Append the new value if it already exists\n",
    "                    if current_value:\n",
    "                        new_value = f\"{current_value}, {new_value}\"\n",
    "                    else:\n",
    "                        new_value = f\"{new_value}\"\n",
    "                    elem.set('value', new_value)\n",
    "                    print(f\"Appended new value: {new_value}\")\n",
    "                else:\n",
    "                    print(f\"Invalid operation: {operation}\")\n",
    "                    return False\n",
    "\n",
    "                # Write the updated XML to the file\n",
    "                tree.write(file_path, encoding=\"UTF-8\", xml_declaration=True)\n",
    "                return True\n",
    "\n",
    "        print(f\"Parameter {parameter} not found in the XML.\")\n",
    "        return False\n",
    "\n",
    "    except Exception as e:\n",
    "        print(f\"An error occurred: {e}\")\n",
    "        return False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_xml_child(file_path, parent_tag, child_tag, child_value):\n",
    "    \"\"\"\n",
    "    Adds a new child parameter inside a specified parent tag in the XML configuration file.\n",
    "    If the parent tag does not exist, it creates a new parent tag (<parameter>) with the child.\n",
    "    It also checks if the child element already exists to prevent duplicates.\n",
    "\n",
    "    Args:\n",
    "        file_path (str): Path to the XML configuration file.\n",
    "        parent_tag (str): The parent tag under which to add the child (e.g., 'input').\n",
    "        child_tag (str): The child tag to add (e.g., 'additional-files').\n",
    "        child_value (str): The value to set for the new child tag.\n",
    "\n",
    "    Returns:\n",
    "        bool: True if the addition was successful, False otherwise.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        # Parse the XML file\n",
    "        tree = ET.parse(file_path)\n",
    "        root = tree.getroot()\n",
    "\n",
    "        # Find the parent element by tag\n",
    "        parent_elem = root.find(parent_tag)\n",
    "        if parent_elem is None:\n",
    "            print(f\"Parent tag '{parent_tag}' not found. Creating new parent tag.\")\n",
    "            parent_elem = ET.Element(parent_tag)\n",
    "            root.append(parent_elem)\n",
    "            print(f\"Created new parent tag <{parent_tag}>.\")\n",
    "\n",
    "        # Check if the child element already exists inside the parent element\n",
    "        existing_child = parent_elem.find(child_tag)\n",
    "        if existing_child is not None: \n",
    "            \n",
    "            if existing_child.get('value') == child_value:\n",
    "                print(f\"Child <{child_tag}> with value '{child_value}' already exists. Skipping addition.\")\n",
    "                return False\n",
    "            else:\n",
    "                print(f\"Child <{child_tag}> already exists. Updating value to '{child_value}'.\")\n",
    "                existing_child.set('value', child_value)\n",
    "                tree.write(file_path, encoding=\"UTF-8\", xml_declaration=True, method=\"xml\")\n",
    "                print(\"XML file updated successfully.\")\n",
    "                return True\n",
    "\n",
    "        # Create the new child element and set its value\n",
    "        new_child = ET.Element(child_tag)\n",
    "        new_child.set('value', child_value)\n",
    "        print(f\"Created <{child_tag}> with value '{child_value}'.\")\n",
    "\n",
    "        # Add the new child to the parent element\n",
    "        parent_elem.append(new_child)\n",
    "        print(f\"Added <{child_tag}> to <{parent_tag}>.\")\n",
    "\n",
    "        # Write the updated XML to the file\n",
    "        tree.write(file_path, encoding=\"UTF-8\", xml_declaration=True, method=\"xml\")\n",
    "        print(\"XML file updated successfully.\")\n",
    "        return True\n",
    "\n",
    "    except ET.ParseError as e:\n",
    "        print(f\"XML Parsing error: {e}\")\n",
    "        return False\n",
    "    except Exception as e:\n",
    "        print(f\"An error occurred: {e}\")\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Child <additional-files> with value 'park.add.xml, pa_rerouter.xml' already exists. Skipping addition.\n",
      "Child <time-to-teleport> with value '-1' already exists. Skipping addition.\n",
      "Child <lateral-resolution> with value '0.8' already exists. Skipping addition.\n"
     ]
    }
   ],
   "source": [
    "NET_PATH = f'{FOLDER_NAME}/osm.net.xml'\n",
    "ADDITONALS_PATH = f'{FOLDER_NAME}/park.add.xml'\n",
    "SUMOCFG_PATH = f'{FOLDER_NAME}/osm.sumocfg'\n",
    "PA_REROUTER_PATH = f'{FOLDER_NAME}/pa_rerouter.xml'\n",
    "\n",
    "# Setting up additional files\n",
    "add_xml_child(SUMOCFG_PATH, 'input', 'additional-files', 'park.add.xml, pa_rerouter.xml')\n",
    "\n",
    "# Setting up time to teleport as -1 (never teleport)\n",
    "add_xml_child(SUMOCFG_PATH, 'processing', 'time-to-teleport', '-1')\n",
    "\n",
    "# Adding lateral resolution to use SubLane model\n",
    "add_xml_child(SUMOCFG_PATH, 'parameters', 'lateral-resolution', '0.8')\n",
    "\n",
    "net = sumolib.net.readNet(NET_PATH)\n",
    "parkingAreas = list(sumolib.output.parse(ADDITONALS_PATH, \"parkingArea\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flush_print():\n",
    "    sys.stdout.write(\"\\r\")  # Move the cursor to the beginning of the line\n",
    "    sys.stdout.write(\" \" * 50)  # Overwrite with spaces to clear the line\n",
    "    sys.stdout.write(\"\\r\")  # Move back to the beginning again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def has_parking_spot(lanes, parkingAreas):\n",
    "    # Example of parkingArea:\n",
    "    # <parkingArea id=\"pa-1046248579#0\" lane=\"-1046248579#0_0\" roadsideCapacity=\"94\" length=\"5.00\"/>\n",
    "    # Returns parkingArea id if there is a parking spot in the lane\n",
    "    lane_ids = [lane.getID() for lane in lanes]\n",
    "    for park in parkingAreas:\n",
    "        if park.lane in lane_ids:\n",
    "            return park.id\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getClosestEdges(lat, lon, radius, maxEdges=10):\n",
    "    # Gets the 10 closest edges to the given lat, lon\n",
    "    x, y = net.convertLonLat2XY(lon, lat)\n",
    "    edges = net.getNeighboringEdges(x, y, radius)\n",
    "    closestEdges = []\n",
    "    if (len(edges) > 0):\n",
    "        distanceAndEdges = sorted([(dist, edge) for edge, dist in edges], key=lambda x:x[0])\n",
    "\n",
    "        ## Checking if the edge found can be used by passenger car\n",
    "        for dist, edge in distanceAndEdges:\n",
    "            if edge.allows('passenger'):\n",
    "                closestEdges.append(edge)\n",
    "\n",
    "    if len(edges) == 0:\n",
    "        print(f'No edges found for {lat}, {lon}. Perhaps location is not inside the network or there are no viable roads inside the radius.')\n",
    "        return None\n",
    "    \n",
    "    return closestEdges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getParkingSpot(lat, lon, radius, parkingAreas):\n",
    "    # Get the parking spot closest to the given lat, lon\n",
    "    # Used to set stops for the vehicles\n",
    "\n",
    "    edges = getClosestEdges(lat, lon, radius)\n",
    "    # Look for parking spots\n",
    "    for i in range(len(edges)):\n",
    "        parking_spot = has_parking_spot(edges[i].getLanes(), parkingAreas)\n",
    "        if parking_spot:\n",
    "            return parking_spot\n",
    "    print(f\"No parking spot found close to {lat}, {lon}. Perhaps decrease the radius?\")\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getPath(location_time_list, parkingAreas, steps_per_stop = 10):\n",
    "    # All that is needed to create the trip are the stops (parking areas) and the start and end edges.\n",
    "    # The duarouter is responsible for finding the path between the edges going through the stops.\n",
    "    # Here, we get the edges and stops that are going to be sent to LLAMA to create the trip.\n",
    "\n",
    "    # 'coordinates' is a list of tuples with the latitude and longitude of the points of interest, for example IC, FEEC, IC means that\n",
    "    # the vehicle will start from IC, stop at a parking lot close to FEEC, and then back to IC.\n",
    "    # The first and last coordinates should be edges and the others should be parking spots.\n",
    "    # `steps_per_stop` is the number of simulation steps that the vehicle will stay at each stop.\n",
    "\n",
    "    # Departure for 7 is 0, 8 is 100, 9 is 200 and so on\n",
    "    stop_durations = []\n",
    "    departures = list(location_time_list.keys())\n",
    "    stop_durations.append(-1) # Indicates this is an edge and not a parking spot\n",
    "\n",
    "    path = []\n",
    "    locations = list(location_time_list.values())\n",
    "    home = getClosestEdges(*locations[0], radius)[0].getID()\n",
    "    path.append(home)\n",
    "    \n",
    "    for i in range(1, len(locations)-1):\n",
    "        stop_durations.append(steps_per_stop * (departures[i] - departures[i - 1]))\n",
    "        ps = getParkingSpot(*locations[i], radius, parkingAreas)\n",
    "        if ps is not None:\n",
    "            path.append(ps)\n",
    "        else:\n",
    "            print(f\"Could not find parking spot for {locations[i]}\")\n",
    "            raise Exception(f\"Could not find parking spot for {locations[i]}\")\n",
    "\n",
    "    path.append(home)\n",
    "    stop_durations.append(-1)\n",
    "    \n",
    "    return path, stop_durations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pathToXML(path, vehicleID, veh_type, departure_time, stop_durations):\n",
    "    # Converts the path to the XML format that LLAMA understands\n",
    "    xml = f'<trip id=\"{vehicleID}\" type=\"{veh_type}\" depart=\"{departure_time}\" from=\"{path[0]}\" to=\"{path[-1]}\">\\n'\n",
    "    for i in range(1, len(path)-1):\n",
    "        xml += f'\\t<stop parkingArea=\"{path[i]}\" duration=\"{stop_durations[i]}\"/>\\n'\n",
    "    xml += '</trip>'\n",
    "    return xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting the routine for the students described"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:01<00:00,  1.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'10': {'activity': 'study', 'location': 'Institute of Computing'},\n",
      " '11': {'activity': 'study', 'location': 'Institute of Computing'},\n",
      " '12': {'activity': 'lunch', 'location': 'restaurant'},\n",
      " '13': {'activity': 'study', 'location': 'Institute of Computing'},\n",
      " '14': {'activity': 'study', 'location': 'Institute of Computing'},\n",
      " '15': {'activity': 'study', 'location': 'Institute of Computing'},\n",
      " '16': {'activity': 'study', 'location': 'Institute of Computing'},\n",
      " '17': {'activity': 'study', 'location': 'Institute of Computing'},\n",
      " '18': {'activity': 'dinner', 'location': 'restaurant'},\n",
      " '19': {'activity': 'shopping', 'location': 'store'},\n",
      " '20': {'activity': 'study', 'location': 'home'},\n",
      " '21': {'activity': 'sports', 'location': 'gym'},\n",
      " '22': {'activity': 'leisure', 'location': 'home'},\n",
      " '23': {'activity': 'sleep', 'location': 'home'},\n",
      " '7': {'activity': 'wake up', 'location': 'home'},\n",
      " '8': {'activity': 'study', 'location': 'Institute of Computing'},\n",
      " '9': {'activity': 'study', 'location': 'Institute of Computing'}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# It is important not to use short names of institutes, like IB for institute of biology, because the LLM will not be able to assign the students to the correct institute.\n",
    "places ={\n",
    "    'leisure': [\"bar\", \"movie_theater\", \"shopping_mall\"],\n",
    "    'eating': [\"restaurant\", \"bakery\", \"cafe\"],\n",
    "    'shopping': [\"store\", \"drugstore\", \"supermarket\"],\n",
    "    'sports': [\"gym\"],\n",
    "    'institute': [\"Institute of Computing\", \"Faculty of Electrical and Computer Engineering\", \"Institute of Biology\"],\n",
    "    'university': [\"University of Campinas\"],\n",
    "}\n",
    "\n",
    "student_info = \"The student is a computing student. Today, the student is going to have lunch at a restaurant and the student is going to the supermarket.\"\n",
    "importlib.reload(LLAMAconnect)\n",
    "responses = LLAMAconnect.generate_response_trips(student_info, places, number_of_trips=2) # number of trips defaults to 5\n",
    "pprint(json.loads(responses[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating different houses for students based on a random number generator in the where students might live"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getHome():\n",
    "    # Should be a random value considering where students live\n",
    "    return (-22.820634394979397, -47.07409276270959)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getCoords(trip, sulfixo, institutes, start_radius, step_radius, limit_radius, n_options = 3):\n",
    "    # Returns a dictionary with the latitude and longitude of the locations of interest\n",
    "    # The suffix is the name of the state, city and neighborhood that will be added to the end of each location to improve the search\n",
    "    # 'start_radius' is the initial radius of the search, 'step_radius' is the amount that will be added to the radius if the location is not found and 'limit_radius' is the maximum radius that will be used. After that, the student will choose not to leave the place he is at.\n",
    "    # 'n_options' is the number of options of places we ideally want to find to choose from. This only applies while the limit_radius is not exceeded\n",
    "    coords = {}\n",
    "    place = {}\n",
    "    importlib.reload(gmaps)\n",
    "    for i in range(len(trip)):\n",
    "        local = trip[f'{i + 7}']['location']\n",
    "        local_comp = local + \", \" + sulfixo\n",
    "\n",
    "        if local in coords.keys():\n",
    "            continue\n",
    "        \n",
    "        if local == 'home':\n",
    "            coords['home'] = getHome()\n",
    "            continue\n",
    "        elif local in institutes:\n",
    "                result = gmaps.geocode_address(local_comp)\n",
    "                lat, lon = result[0]['latitude'], result[0]['longitude']\n",
    "                print(f\"\\033[1mFound {local} at {lat}, {lon}.\\033[0m\")\n",
    "        else:\n",
    "            found = True\n",
    "            print(f\"Looking for {local}...\", end='', flush=True)\n",
    "\n",
    "            # Stoting the previous location to use as a reference for the next search\n",
    "            previous = coords[trip[f'{i + 6}']['location']]\n",
    "            result = gmaps.find_nearby_building(previous[0], previous[1], local, radius=start_radius)\n",
    "            expanded = radius\n",
    "\n",
    "            # If the location is not found or there are less optios than expected, expand the search radius\n",
    "            while result is False or len(result) < n_options:\n",
    "                expanded += step_radius\n",
    "                if expanded > limit_radius:\n",
    "                    found = False\n",
    "                    break\n",
    "                \n",
    "                result = gmaps.find_nearby_building(previous[0], previous[1], local, radius=expanded)\n",
    "\n",
    "            if found == False:\n",
    "                result = [{'latitude': previous[0], 'longitude': previous[1]}]\n",
    "                place[f'{local}'] = trip[f'{i + 6}']['location']\n",
    "                flush_print()\n",
    "                print(f\"Could not find {local} in a radius of {limit_radius} meters. The student will not leave the place he is currently at.\")\n",
    "            else:\n",
    "                place[f'{local}'] = result[0]['name']\n",
    "                random.shuffle(result) # Randomize the results to avoid always getting the absolute closest building\n",
    "                lat, lon = result[0]['latitude'], result[0]['longitude']\n",
    "                flush_print()\n",
    "                print(f\"Found {len(result)} options for {local}: {[x['name'] for x in result]}\")\n",
    "                print(f\"\\033[1m{local} picked: {result[0]['name']} at {lat}, {lon}.\\033[0m\")\n",
    "\n",
    "        \n",
    "        coords[f'{local}'] = (lat, lon)\n",
    "        \n",
    "    return coords, place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def coordsToTrip(trip, coords):\n",
    "    location_time = {}\n",
    "    home = coords['home'] # Gets a random home location for each student\n",
    "    last = home\n",
    "    location_time[7] = last\n",
    "    \n",
    "    for j in range(1, len(trip)):\n",
    "        local_coords = coords[trip[f'{j + 7}']['location']]\n",
    "        if local_coords != last:\n",
    "            location_time[j + 7] = local_coords\n",
    "            last = local_coords\n",
    "\n",
    "    return location_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting the latitude and longitude for each of the locations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting coords for trip 1:\n",
      "\u001b[1mFound Institute of Computing at -22.8135274, -47.0638544.\u001b[0m\n",
      "Found 3 options for restaurant: ['Feirinha da Unicamp', 'Restaurante da Saturnino', 'Restaurante da Casa do Professor Visitante']\n",
      "\u001b[1mrestaurant picked: Feirinha da Unicamp at -22.8172479, -47.06998939999999.\u001b[0m\n",
      "Found 5 options for store: ['Vegano dos Pedais Bike Shop e Oficina', 'Editora da Unicamp - Livraria BC', 'OXXO', 'Connect Print', 'Banca de Frutas do Lauro']\n",
      "\u001b[1mstore picked: Vegano dos Pedais Bike Shop e Oficina at -22.81977179999999, -47.0737757.\u001b[0m\n",
      "Found 8 options for gym: ['[FT30 Online] | Método de Treinamento Funcional', 'Ateliê Soma - Pilates & Fisioterapia Integrativa', 'Jardim Aéreo', 'Work Wellness - Physical Functional Training Space', 'Golden Fitness Academy', 'RODA OM - CAMINHOS HOLÍSTICOS E MULTIDIMENSIONAIS', 'KUMARA yoga e terapia', 'Academia Cinética Fitness']\n",
      "\u001b[1mgym picked: [FT30 Online] | Método de Treinamento Funcional at -22.8242997, -47.07093260000001.\u001b[0m\n",
      "\n",
      "Getting coords for trip 2:\n",
      "\u001b[1mFound Institute of Computing at -22.8135274, -47.0638544.\u001b[0m\n",
      "Could not find cafe in a radius of 1000 meters. The student will not leave the place he is currently at.\n",
      "Found 3 options for restaurant: ['Restaurante da Casa do Professor Visitante', 'Feirinha da Unicamp', 'Restaurante da Saturnino']\n",
      "\u001b[1mrestaurant picked: Restaurante da Casa do Professor Visitante at -22.8122661, -47.0663524.\u001b[0m\n",
      "Could not find supermarket in a radius of 1000 meters. The student will not leave the place he is currently at.\n",
      "Found 4 options for gym: ['Academia Sérgio Cavalcante', 'Estúdio do Corpo', 'Studio Pilates Geovana Fantinato', 'VreckFix']\n",
      "\u001b[1mgym picked: Academia Sérgio Cavalcante at -22.8090377, -47.0687294.\u001b[0m\n",
      "\n",
      "All trips have been successfully generated.\n"
     ]
    }
   ],
   "source": [
    "sufixo = \"Barão Geraldo, Campinas, SP, Brazil\"\n",
    "trips = {}\n",
    "location_time_list = []\n",
    "radius = 200\n",
    "for i in range(len(responses)):\n",
    "    json_response = json.loads(responses[i])\n",
    "    trips[i] = json_response\n",
    "    print(f\"Getting coords for trip {i + 1}:\")\n",
    "    coords, names = getCoords(trips[i], sufixo, places['institute'], start_radius=500, step_radius=200, limit_radius=1000)\n",
    "    location_time_list.append(coordsToTrip(trips[i], coords))\n",
    "    print(\"\")\n",
    "print(\"All trips have been successfully generated.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taking the locations and turning them into a XML trips, which are written to PATHGEN.trips.xml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "randomtrips_path = \"/usr/share/sumo/tools/randomTrips.py\"\n",
    "def randomtrips_getArgs(net_path, additional_path, v_class, n_trips):\n",
    "    args = [\n",
    "        \"-n\", net_path,\n",
    "        \"-o\", f\"{FOLDER_NAME}/randtrips.trips.xml\",\n",
    "        \"-r\", f\"{FOLDER_NAME}/randtrips.rou.xml\",\n",
    "        \"--additional\", additional_path,\n",
    "        \"--vclass\", v_class,\n",
    "        \"--vehicle-class\", v_class,\n",
    "        \"-e\", str(n_trips),\n",
    "        \"--validate\"\n",
    "    ]\n",
    "    return args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getRandomTrips(net_path, add_path, vclass, n_trips):\n",
    "    # Run the randomTrips.py to create the trips\n",
    "    subprocess.run(['python3', randomtrips_path] + randomtrips_getArgs(net_path, add_path, vclass, n_trips), check=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parseTripXML(location_time_list, parkingAreas, departure_times, styles, veh_types_per_student, n_vtypes, steps_per_stop = 10, rand_trips=None, out_file_name='finaltrips.rou.xml'):\n",
    "    # Creates the XML for the trips\n",
    "    # 'departure_times' is a list with the departure times for each trip\n",
    "    # 'styles' is a list with the styles of the vehicles. The current supported styles are \"agg\" for aggressive and \"norm\" for normal\n",
    "    # 'veh_types_per_student' is a list with the vehicle types for each student\n",
    "    # 'n_vtypes' is the number of vTypes created for each style\n",
    "    # 'rand_trips' is a file containing the random trips\n",
    "    \n",
    "    importlib.reload(vehParameters)\n",
    "\n",
    "    xml = '<routes xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo.dlr.de/xsd/routes_file.xsd\">\\n'\n",
    "\n",
    "    xml += '\\n<!-- BEGIN - LLM Generated trips -->\\n'\n",
    "\n",
    "    xml += '\\n<!-- Vehicles -->\\n'\n",
    "    vehdists = vehParameters.generateVehicleTypes(styles, n_vtypes)\n",
    "    xml += vehParameters.parseVehiclesXML(vehdists, styles, FOLDER_NAME)\n",
    "\n",
    "    xml += '\\n'\n",
    "    xml += '<!-- Trips -->\\n'\n",
    "    for i in range(len(location_time_list)):\n",
    "        path, stop_durations = getPath(location_time_list[i], parkingAreas, steps_per_stop=steps_per_stop)\n",
    "        xml += pathToXML(path, f'veh{i + 1}', veh_types_per_student[i], departure_times[i], stop_durations) + '\\n'\n",
    "\n",
    "    xml += '\\n\\n <!-- END - LLM Generated trips -->\\n\\n'\n",
    "\n",
    "    xml += '<!-- BEGIN - Random Trips -->\\n\\n'\n",
    "\n",
    "    if rand_trips:\n",
    "        start_read = False\n",
    "        with open(rand_trips, 'r') as f:\n",
    "            for line in f:\n",
    "                test = line.strip()\n",
    "                if test.startswith('<vType'):\n",
    "                    start_read = True\n",
    "                if start_read:\n",
    "                    if line.startswith('</routes>'):\n",
    "                        break\n",
    "                    xml += line\n",
    "\n",
    "    xml += '\\n</routes>'\n",
    "    \n",
    "    with open(f'{FOLDER_NAME}/{out_file_name}', 'w') as f:\n",
    "        f.write(xml)\n",
    "    \n",
    "    return xml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success.\n",
      "Success.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'<routes xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo.dlr.de/xsd/routes_file.xsd\">\\n\\n<!-- BEGIN - LLM Generated trips -->\\n\\n<!-- Vehicles -->\\n<vTypeDistribution id=\"agg\">\\n\\t<vType id=\"v_agg0\" minGap=\"0.29\" accel=\"2.17\" decel=\"5.1\" startupDelay=\"0.37\" sigma=\"0.59\" tau=\"1.3\" maxSpeed=\"114.46\" speedFactor=\"1.71\" lcStrategic=\"6.07\" lcCooperative=\"0.11\" lcSpeedGain=\"8.23\" lcKeepRight=\"4.3\" lcOvertakeRight=\"0.89\" lcSpeedGainLookahead=\"2.33\" lcOvertakeDeltaSpeedFactor=\"0.9\" lcPushy=\"0.89\" lcAssertive=\"3.64\" lcImpatience=\"0.81\" lcTimeToImpatience=\"7.24\" lcLaneDiscipline=\"2.6\" lcSigma=\"0.73\" lcAccelLat=\"1.43\" probability=\"0.386985992962971\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n\\t<vType id=\"v_agg1\" minGap=\"0.53\" accel=\"4.16\" decel=\"3.54\" startupDelay=\"0.26\" sigma=\"0.8\" tau=\"1.2\" maxSpeed=\"122.96\" speedFactor=\"1.51\" lcStrategic=\"4.33\" lcCooperative=\"0.21\" lcSpeedGain=\"8.62\" lcKeepRight=\"1.86\" lcOvertakeRight=\"1.0\" lcSpeedGainLookahead=\"3.93\" lcOvertakeDeltaSpeedFactor=\"0.82\" lcPushy=\"0.64\" lcAssertive=\"4.54\" lcImpatience=\"0.74\" lcTimeToImpatience=\"5.92\" lcLaneDiscipline=\"2.22\" lcSigma=\"0.55\" lcAccelLat=\"1.73\" probability=\"0.2504612567083154\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n\\t<vType id=\"v_agg2\" minGap=\"0.39\" accel=\"2.69\" decel=\"4.16\" startupDelay=\"0.25\" sigma=\"0.68\" tau=\"1.17\" maxSpeed=\"111.79\" speedFactor=\"1.96\" lcStrategic=\"7.97\" lcCooperative=\"0.08\" lcSpeedGain=\"5.89\" lcKeepRight=\"2.09\" lcOvertakeRight=\"0.52\" lcSpeedGainLookahead=\"3.6\" lcOvertakeDeltaSpeedFactor=\"0.63\" lcPushy=\"0.67\" lcAssertive=\"3.14\" lcImpatience=\"0.69\" lcTimeToImpatience=\"6.48\" lcLaneDiscipline=\"1.71\" lcSigma=\"0.93\" lcAccelLat=\"2.04\" probability=\"0.016702323570495458\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n\\t<vType id=\"v_agg3\" minGap=\"0.16\" accel=\"2.95\" decel=\"2.26\" startupDelay=\"0.31\" sigma=\"0.66\" tau=\"1.41\" maxSpeed=\"101.43\" speedFactor=\"1.73\" lcStrategic=\"5.06\" lcCooperative=\"0.09\" lcSpeedGain=\"8.85\" lcKeepRight=\"1.45\" lcOvertakeRight=\"0.87\" lcSpeedGainLookahead=\"2.88\" lcOvertakeDeltaSpeedFactor=\"1.0\" lcPushy=\"0.72\" lcAssertive=\"2.34\" lcImpatience=\"0.58\" lcTimeToImpatience=\"6.31\" lcLaneDiscipline=\"0.93\" lcSigma=\"0.86\" lcAccelLat=\"1.87\" probability=\"0.0068569528367817415\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n\\t<vType id=\"v_agg4\" minGap=\"0.33\" accel=\"1.96\" decel=\"2.44\" startupDelay=\"0.39\" sigma=\"0.69\" tau=\"1.19\" maxSpeed=\"132.78\" speedFactor=\"1.83\" lcStrategic=\"8.41\" lcCooperative=\"0.11\" lcSpeedGain=\"7.74\" lcKeepRight=\"0.89\" lcOvertakeRight=\"0.79\" lcSpeedGainLookahead=\"3.39\" lcOvertakeDeltaSpeedFactor=\"0.87\" lcPushy=\"0.73\" lcAssertive=\"3.16\" lcImpatience=\"0.89\" lcTimeToImpatience=\"7.94\" lcLaneDiscipline=\"2.2\" lcSigma=\"0.75\" lcAccelLat=\"2.35\" probability=\"0.33899347392143636\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n</vTypeDistribution>\\n<vTypeDistribution id=\"norm\">\\n\\t<vType id=\"v_norm0\" minGap=\"1.35\" accel=\"1.25\" decel=\"1.23\" startupDelay=\"0.62\" sigma=\"0.15\" tau=\"1.66\" maxSpeed=\"97.13\" speedFactor=\"1.17\" lcStrategic=\"2.1\" lcCooperative=\"0.57\" lcSpeedGain=\"1.59\" lcKeepRight=\"0.82\" lcOvertakeRight=\"0.03\" lcSpeedGainLookahead=\"1.58\" lcOvertakeDeltaSpeedFactor=\"-0.13\" lcPushy=\"0.11\" lcAssertive=\"1.36\" lcImpatience=\"0.0\" lcTimeToImpatience=\"15.38\" lcLaneDiscipline=\"0.59\" lcSigma=\"0.04\" lcAccelLat=\"0.94\" probability=\"0.013397109643282515\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n\\t<vType id=\"v_norm1\" minGap=\"1.35\" accel=\"1.96\" decel=\"1.84\" startupDelay=\"0.84\" sigma=\"0.07\" tau=\"1.86\" maxSpeed=\"89.21\" speedFactor=\"1.09\" lcStrategic=\"1.64\" lcCooperative=\"0.53\" lcSpeedGain=\"2.3\" lcKeepRight=\"0.85\" lcOvertakeRight=\"0.12\" lcSpeedGainLookahead=\"0.76\" lcOvertakeDeltaSpeedFactor=\"0.28\" lcPushy=\"0.11\" lcAssertive=\"1.26\" lcImpatience=\"0.13\" lcTimeToImpatience=\"12.28\" lcLaneDiscipline=\"0.78\" lcSigma=\"0.03\" lcAccelLat=\"0.66\" probability=\"0.08640100963082312\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n\\t<vType id=\"v_norm2\" minGap=\"1.51\" accel=\"1.27\" decel=\"1.34\" startupDelay=\"0.61\" sigma=\"0.15\" tau=\"1.86\" maxSpeed=\"94.57\" speedFactor=\"1.27\" lcStrategic=\"2.32\" lcCooperative=\"0.68\" lcSpeedGain=\"1.17\" lcKeepRight=\"0.85\" lcOvertakeRight=\"0.17\" lcSpeedGainLookahead=\"1.58\" lcOvertakeDeltaSpeedFactor=\"0.13\" lcPushy=\"0.13\" lcAssertive=\"1.0\" lcImpatience=\"0.06\" lcTimeToImpatience=\"18.26\" lcLaneDiscipline=\"0.79\" lcSigma=\"0.12\" lcAccelLat=\"0.8\" probability=\"0.32631648693333143\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n\\t<vType id=\"v_norm3\" minGap=\"2.04\" accel=\"0.97\" decel=\"1.69\" startupDelay=\"0.78\" sigma=\"0.13\" tau=\"1.78\" maxSpeed=\"92.72\" speedFactor=\"1.28\" lcStrategic=\"2.23\" lcCooperative=\"0.74\" lcSpeedGain=\"3.01\" lcKeepRight=\"0.75\" lcOvertakeRight=\"0.13\" lcSpeedGainLookahead=\"1.64\" lcOvertakeDeltaSpeedFactor=\"-0.21\" lcPushy=\"0.07\" lcAssertive=\"1.16\" lcImpatience=\"0.13\" lcTimeToImpatience=\"12.94\" lcLaneDiscipline=\"0.58\" lcSigma=\"0.14\" lcAccelLat=\"0.83\" probability=\"0.5567171299166331\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n\\t<vType id=\"v_norm4\" minGap=\"1.08\" accel=\"1.77\" decel=\"1.79\" startupDelay=\"0.46\" sigma=\"0.21\" tau=\"1.67\" maxSpeed=\"93.86\" speedFactor=\"1.29\" lcStrategic=\"1.78\" lcCooperative=\"0.52\" lcSpeedGain=\"1.47\" lcKeepRight=\"0.66\" lcOvertakeRight=\"0.04\" lcSpeedGainLookahead=\"1.46\" lcOvertakeDeltaSpeedFactor=\"0.02\" lcPushy=\"0.1\" lcAssertive=\"1.33\" lcImpatience=\"0.06\" lcTimeToImpatience=\"12.39\" lcLaneDiscipline=\"0.5\" lcSigma=\"0.16\" lcAccelLat=\"0.65\" probability=\"0.01716826387592987\">\\n\\t\\t<param key=\"device.rerouting.probability\" value=\"1.0\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-steps\" value=\"18\"/>\\n\\t\\t<param key=\"device.rerouting.adaptation-interval\" value=\"10\"/>\\n\\t</vType>\\n</vTypeDistribution>\\n\\n<!-- Trips -->\\n<trip id=\"veh1\" type=\"agg\" depart=\"0\" from=\"-75259406#0\" to=\"-75259406#0\">\\n\\t<stop parkingArea=\"paIC\" duration=\"10\"/>\\n\\t<stop parkingArea=\"pa72508815#16\" duration=\"40\"/>\\n\\t<stop parkingArea=\"paIC\" duration=\"10\"/>\\n\\t<stop parkingArea=\"pa72508815#16\" duration=\"50\"/>\\n\\t<stop parkingArea=\"pa-72644726#0\" duration=\"10\"/>\\n\\t<stop parkingArea=\"pa-75259406#0\" duration=\"10\"/>\\n\\t<stop parkingArea=\"pa90743683#0\" duration=\"10\"/>\\n</trip>\\n<trip id=\"veh2\" type=\"norm\" depart=\"0\" from=\"-75259406#0\" to=\"-75259406#0\">\\n\\t<stop parkingArea=\"paIC\" duration=\"10\"/>\\n\\t<stop parkingArea=\"pa72508818\" duration=\"40\"/>\\n\\t<stop parkingArea=\"paIC\" duration=\"20\"/>\\n\\t<stop parkingArea=\"pa72508818\" duration=\"40\"/>\\n\\t<stop parkingArea=\"pa-147412866#1\" duration=\"10\"/>\\n</trip>\\n\\n\\n <!-- END - LLM Generated trips -->\\n\\n<!-- BEGIN - Random Trips -->\\n\\n\\n</routes>'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "departure_times = []\n",
    "for i in range(len(location_time_list)):\n",
    "    departure_times.append((list(location_time_list[i].keys())[0] - 7) * 10)\n",
    "\n",
    "styles = [\"agg\", \"norm\"] # Currently only two styles, but can be expanded\n",
    "n_vtypes = 5 \n",
    "veh_style_per_student = []\n",
    "for i in range(len(location_time_list)):\n",
    "    if i < len(location_time_list) / 2:\n",
    "        veh_style_per_student.append('agg')\n",
    "    else: \n",
    "        veh_style_per_student.append('norm')   \n",
    "\n",
    "# IMPORTANT: If the desire is to generate alternative routes for the random trips, rand_trips must be set to randtrips.trips.xml, otherwise, the random_trips will be merged with the alternative routes for the LLM generated trips.\n",
    "# If rand_trips is set to None, the PATHGEN.rou.alt.xml file should be used in osm.sumocfg. Otherwise, the merged.rou.alt.xml file should be used.\n",
    "rand_trips = None\n",
    "final_trips_file_name = \"finaltrips.rou.xml\"\n",
    "\n",
    "getRandomTrips(NET_PATH, ADDITONALS_PATH, \"passenger\", 10) # Generating random trips to randomtrips.rou.xml\n",
    "parseTripXML(location_time_list, parkingAreas, departure_times, styles, veh_style_per_student, n_vtypes, steps_per_stop=10, rand_trips=rand_trips, out_file_name=final_trips_file_name) # Parsing to PATHGEN.trips.xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting alternative routes for every route found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Arguments to get alternative routes\n",
    "duaiterate_path = \"/usr/share/sumo/tools/assign/duaIterate.py\"\n",
    "def duaiterate_getArgs(net_path, trips_path, additional_path, iterations):\n",
    "    args = [\n",
    "        \"-n\", net_path,\n",
    "        \"-t\", trips_path,\n",
    "        \"--additional\", additional_path,\n",
    "        \"duarouter--additional-files\", additional_path,\n",
    "        \"-l\", str(iterations),\n",
    "    ]\n",
    "    return args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getAltRoutes(net_path, trips_path, additional_path, iterations):\n",
    "    # Run the duarouter to find alternative routes\n",
    "    # Currently this only works for less than 10 iterations because of file naming\n",
    "    try:\n",
    "        subprocess.run(['python3', duaiterate_path] + duaiterate_getArgs(net_path, f'{FOLDER_NAME}/{trips_path}', additional_path, iterations), check=True)\n",
    "        file_name = trips_path.split('.')[0]\n",
    "\n",
    "        shutil.move(f'00{iterations-1}/{file_name}_00{iterations-1}.rou.alt.xml', f'{FOLDER_NAME}/{file_name}.rou.alt.xml')\n",
    "        for i in range(iterations):\n",
    "            if os.path.exists(f'00{i}'):\n",
    "                shutil.rmtree(f'00{i}')\n",
    "\n",
    "        shutil.move('dua.log', f'{FOLDER_NAME}/dua.log')\n",
    "        shutil.move('stdout.log', f'{FOLDER_NAME}/stdout.log')\n",
    "        os.remove('edgedata.add.xml')\n",
    "                \n",
    "    except subprocess.CalledProcessError as e:\n",
    "        print(f\"{e}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Executing step 0\n",
      ">> Running router on unicamp/finaltrips.rou.xml\n",
      ">>> Begin time: 2024-12-09 16:30:05.392255\n",
      ">>> End time: 2024-12-09 16:30:05.902250\n",
      ">>> Duration: 0:00:00.509995\n",
      "<<\n",
      ">> Running simulation\n",
      ">>> Begin time: 2024-12-09 16:30:05.902302\n",
      ">>> End time: 2024-12-09 16:30:06.974468\n",
      ">>> Duration: 0:00:01.072166\n",
      "<<\n",
      "< Step 0 ended (duration: 0:00:01.582323)\n",
      "------------------\n",
      "\n",
      "dua-iterate ended (duration: 0:00:01.620371)\n"
     ]
    }
   ],
   "source": [
    "# This creates the {final_trips_file_name}.rou.alt.xml file\n",
    "getAltRoutes(NET_PATH, final_trips_file_name, ADDITONALS_PATH, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If there is no need to generate alternative router for the random trips, the following XML parser must be used to add them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_routes(alternative_routes, random_routes, output_file_name = 'merged.rou.alt.xml'):\n",
    "    # Merges two route files into one\n",
    "    \n",
    "    xml = '<routes xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo.dlr.de/xsd/routes_file.xsd\">\\n'\n",
    "    xml += '\\n<!-- BEGIN - LLM Generated trips -->\\n'\n",
    "\n",
    "    with open(alternative_routes, 'r') as f:\n",
    "        start_read = False\n",
    "        for line in f:\n",
    "            test = line.strip()\n",
    "            if test.startswith('<vType'):\n",
    "                start_read = True\n",
    "            if start_read:\n",
    "                if line.startswith('</routes>'):\n",
    "                    break\n",
    "                xml += line\n",
    "\n",
    "    xml += '\\n\\n <!-- END - LLM Generated trips -->\\n\\n'\n",
    "    xml += '<!-- BEGIN - Random Trips -->\\n\\n'\n",
    "\n",
    "    with open(random_routes, 'r') as f:\n",
    "        start_read = False\n",
    "        for line in f:\n",
    "            test = line.strip()\n",
    "            if test.startswith('<vType'):\n",
    "                start_read = True\n",
    "            if start_read:\n",
    "                xml += line\n",
    "\n",
    "    with open(f'{FOLDER_NAME}/{output_file_name}', 'w') as f:\n",
    "        f.write(xml)\n",
    "    \n",
    "    return xml    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modified route-files to merged.rou.alt.xml\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If alternative routes for random trips were ignored, the 'merged.rou.alt.xml' file will be created and should be used in osm.sumocfg\n",
    "output_file_name = 'merged.rou.alt.xml'\n",
    "if rand_trips == None:\n",
    "    if os.path.exists(f'{FOLDER_NAME}/{output_file_name}'):\n",
    "        os.remove(f'{FOLDER_NAME}/{output_file_name}')\n",
    "    \n",
    "    # If there are alternative routes, merge them\n",
    "    if os.path.exists(f'{FOLDER_NAME}/finaltrips.rou.alt.xml'):\n",
    "        merge_routes(f'{FOLDER_NAME}/finaltrips.rou.alt.xml', f'{FOLDER_NAME}/randtrips.rou.xml', output_file_name)\n",
    "\n",
    "    # If alternative routes were found not generated, we are going to use the original ones\n",
    "    else:\n",
    "        merge_routes(f'{FOLDER_NAME}/finaltrips.rou.xml', f'{FOLDER_NAME}/randtrips.rou.xml', output_file_name)\n",
    "\n",
    "# Changing sumocfg to use the new route file\n",
    "update_xml_parameter(SUMOCFG_PATH, 'route-files', output_file_name, operation=\"modify\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}