JKUAT_Student_Admission_Simulation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kipsangmarion/jkuat-student-admission-simulation/blob/main/JKUAT_Student_Admission_Simulation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **JKUAT STUDENT ADMISSION SIMULATION**"
      ],
      "metadata": {
        "id": "wkia5GUQ4E7c"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## TABLE OF CONTENTS\n",
        ">[1.Problem Formulation](#scrollTo=N7sUVixLoiiP)\n",
        "\n",
        ">[2.Objectives and Overall Project Plan](#scrollTo=0ufezMC2pI01)\n",
        "\n",
        ">>[2.1 Objectives/ Questions to be answered by system](#scrollTo=WCN07Bqdpe2Z)\n",
        "\n",
        ">>[2.2 Project Plan](#scrollTo=4X7rmb5Vp66Y)\n",
        "\n",
        ">>>[2.2.1 Alternative systems and methods of evaluating them](#scrollTo=4X7rmb5Vp66Y)\n",
        "\n",
        ">>>[2.2.2 Project team:](#scrollTo=4X7rmb5Vp66Y)\n",
        "\n",
        ">[3.Model Conceptualization](#scrollTo=xPvbRasXaBLf)\n",
        "\n",
        ">[4.Data Collection](#scrollTo=uK86yewVh73s)\n",
        "\n",
        ">[5.Model Translation](#scrollTo=19UA4UoMjJS6)\n",
        "\n",
        ">>[5.1 Adding dependecies](#scrollTo=dKA2AJ6fjXPk)\n",
        "\n",
        ">>[5.2 Generating student service times](#scrollTo=P8ZzhAC2j41m)\n",
        "\n",
        ">>[5.3 Generating student arrival times](#scrollTo=wY5YrjjGkbA4)\n",
        "\n",
        ">>[5.4 Calculating inter-arrival times](#scrollTo=_g0hZG9kkuZy)\n",
        "\n",
        ">>[5.5 Calculations for the following data:](#scrollTo=QZwW4PEHlApi)\n",
        "\n",
        ">>[5.6 Adding all the data to a dataframe](#scrollTo=SM6pWG-PmSPi)\n",
        "\n",
        ">>[5.7 Calculating the results](#scrollTo=aKyiI6wdmrGp)\n",
        "\n",
        ">[6.Model Verification](#scrollTo=OtE2BkKQm05M)\n",
        "\n",
        ">[7.Model Validation](#scrollTo=IiKzq-_Sm68o)\n",
        "\n",
        ">[8.Experimental design](#scrollTo=NHCkJRPcnCK0)\n",
        "\n",
        ">>[8.1 Setting up parameters for the simulation](#scrollTo=38F6N50atD4j)\n",
        "\n",
        ">>[8.2 Functions to monitor the student and their arrival](#scrollTo=j-h9EzICu0eF)\n",
        "\n",
        "\n",
        "\n",
        ">>[8.3 Defining the optimal conditions that the simulation should determine](#scrollTo=U1BAmdiQxCHK)\n",
        "\n",
        ">>[8.4 Finding Optimal Conditions](#scrollTo=cQcTNgSXyIY0)\n",
        "\n",
        ">>[8.5 The results](#scrollTo=wA8SDo5ayosK)\n",
        "\n",
        ">[9.More runs](#scrollTo=3SYdz765UD8W)\n",
        "\n",
        ">[10.Implementation](#scrollTo=OsuCcYC2zTCz)\n",
        "\n",
        ">[11.References](#scrollTo=iPpIkK0w6SAJ)\n",
        "\n"
      ],
      "metadata": {
        "id": "04cs5fV3IVB0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#1.Problem Formulation"
      ],
      "metadata": {
        "id": "N7sUVixLoiiP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The student admission process in Jomo Kenyatta University of Agriculture and Technology is slow and cumbersome. The students spend a long time in the queue due to slow service. The servers are few in number when compared to the number of students. Our aim for the simulation is to determine an optimum set of conditions that will allow the admission process to run smoothly, efficiently and faster. In this project, we will focus the simulation on a single college, College of Pure and Applied Sciences."
      ],
      "metadata": {
        "id": "gaWd2u3zzz09"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2.Objectives and Overall Project Plan"
      ],
      "metadata": {
        "id": "0ufezMC2pI01"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.1 Objectives/ Questions to be answered by system\n",
        "\n",
        "* What is the average waiting time for students in the queue?\n",
        "* What is the average amount of time the server is idle?\n",
        "* What is the average service time for a student?\n",
        "* What is the average inter-arrival time?\n",
        "* What is the average amount of time a student spends in the system?\n",
        "* How can we optimize the queueing system to attend to students more efficiently?"
      ],
      "metadata": {
        "id": "WCN07Bqdpe2Z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.2 Project Plan\n",
        "\n",
        "### 2.2.1 Alternative systems and methods of evaluating them\n",
        "1. Online addmission which can be evaluated on the basis of the efficiency of network servers and availability of reliable internet connection for students.\n",
        "\n",
        "### 2.2.2 Project team:\n",
        "\n",
        "Shirley Mbeyu Ddaiddo\n",
        "\n",
        "Ashley Mbeke Muoki\n",
        "\n",
        "Ceasar Njuguna Ngunu\n",
        "\n",
        "Marion Cherotich Kipsang\n",
        "\n",
        "Allan Erissat Okedo\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "4X7rmb5Vp66Y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#3.Model Conceptualization"
      ],
      "metadata": {
        "id": "xPvbRasXaBLf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We consider a system for admitting students to Jomo Kenyatta University of agriculture and Technology, College of Pure and Applied Sciences. We then consider a situation with two servers attending to a single queue of students,\n",
        "\n",
        "and the number of students to be served is 1,000 students.\n",
        "\n",
        "We collect data on student arrival times and service times. We the consider a 40 hours (5 8-hour days) period of time. From that data, and for each student, we determine:\n",
        "* the inter-arrival times:\n",
        "    - This is the difference between the arrival times of the current students in the queue and the student who arrived right before them in the queue.\n",
        "    - The inter-arrival time for the first student in the queue is zero.\n",
        "\n",
        "    `inter_arrival_time = arrival_time[current] - arrival_time[previous]`\n",
        "\n",
        "* time service begins:\n",
        "    - Time service begins is dependent on the arrival time of the current student as compared to the time service ends for the previous student.\n",
        "\n",
        "    - If a student arrives before the previous student has been finished being served, their service begins when the previous student finishes being served.\n",
        "\n",
        "    - If a student arrives when the previous student has already been served,their service begins as soon as they arrive.\n",
        "\n",
        "    ```\n",
        "    If arrival_time[current] < service_end_time[previous]:\n",
        "\n",
        "    begin_service_time [current] = service_end_time[previous]\n",
        "\n",
        "    else\n",
        "\n",
        "    begin_service_time [current] = arrival_time[current]\n",
        "\n",
        "    ```\n",
        "* time service ends:\n",
        "    - Time that service ends for a student is equal to the sum of the time service begins and the time taken to serve them.\n",
        "    \n",
        "    `service_end_time[current] = begin_service_time[current] + service_time[current]`\n",
        "\n",
        "\n",
        "* the queue wait times:\n",
        "    - Time that a student spends queueing depends on their arrival time as compared to the time service ends for the previous student.\n",
        "    - If a student arrives before the previous student has been finished being served, their time in the queue is the difference between the time service ends for the previous student and the current students arrival time.\n",
        "    - If a student arrives when the previous student has already been served, they do not spend any time queueing.\n",
        "\n",
        "    ```\n",
        "    If arrival_time[current] < service_end_time[previous]:\n",
        "\n",
        "    queue_wait_time[current] =  service_end_time[previous]- arrival_time[current]\n",
        "\n",
        "    else\n",
        "    queue_wait_time[current] = 0\n",
        "\n",
        "    ```\n",
        "\n",
        "* time in the system:\n",
        "    - The time a student spends in the system is the sum of the time they spent queueing and the time spend being served.\n",
        "\n",
        "    `time_in_system = service_end_time - arrival_time`\n",
        "\n",
        "* server idle times:\n",
        "    - Server idle times depends on the current students arrival time as compared to the time service ends for the previous student\n",
        "    - If a student arrives before another student has been finished being served, the server has no idle time since there is a student in the queue.\n",
        "    - If a student arrives when there is no one being served, the server is idle until the another student arrives.\n",
        "\n",
        "    ```\n",
        "    If arrival_time[current] < service_end_time[previous]:\n",
        "\n",
        "    server_idle_time = 0\n",
        "\n",
        "    else\n",
        "\n",
        "    server_idle_time = arrival_time[current]- end_service_time[previous]\n",
        "\n",
        "    ```\n",
        "\n",
        "From the calculated data, we can determine the averages required, the effectiveness of the system, and how we can optimize the system."
      ],
      "metadata": {
        "id": "h_WTgYDsanYM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 4.Data Collection"
      ],
      "metadata": {
        "id": "uK86yewVh73s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Data for the system is computer generated using pseudo-random numbers.\n",
        "\n",
        "* Arrival Time:\n",
        "\n",
        "Arrival time for students in minutes is generated using a function that generated pseudo-random numbers that increase. The fuction generates 1,000 arrival times that span 40 hours/ 2400 minutes.\n",
        "\n",
        "* Service Time:\n",
        "\n",
        "Service time for students in minutes is generated using a sin function that outputs pseudo-random values that are then multiplied by 10."
      ],
      "metadata": {
        "id": "zoA67ptLiDWJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5.Model Translation"
      ],
      "metadata": {
        "id": "19UA4UoMjJS6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The flowchart below shows the admission process for a student from beginning to end"
      ],
      "metadata": {
        "id": "qD5il8-6vzyc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![flowchart.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "dKO2NvpkBHKM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The above model is translated into python code."
      ],
      "metadata": {
        "id": "vBM0pdOTjRZ5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.1 Adding dependecies\n",
        "The system requires:\n",
        "* simpy for access to an environment that allows us to run simulations\n",
        "* pandas, and numpy to compute calculations on data frames and arrays\n",
        "* random for the generation of pseudo-random numbers\n",
        "* math for access to the sine function"
      ],
      "metadata": {
        "id": "dKA2AJ6fjXPk"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 106,
      "metadata": {
        "id": "2dz5t_h5M2gH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa1139f3-dbc6-462d-a880-9a5e2af0c37c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: simpy in /usr/local/lib/python3.10/dist-packages (4.0.1)\n"
          ]
        }
      ],
      "source": [
        "!pip install simpy\n",
        "import simpy\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import random\n",
        "import math\n",
        "from math import sin"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Initializing the number of servers"
      ],
      "metadata": {
        "id": "IhXTDUs1ovAW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n_servers = 2"
      ],
      "metadata": {
        "id": "WX_FXwj7o3-a"
      },
      "execution_count": 107,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.2 Generating student service times"
      ],
      "metadata": {
        "id": "P8ZzhAC2j41m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "service_times= []\n",
        "\n",
        "for i in range(1000):\n",
        "  num = random.random()\n",
        "  time = round((10*(sin(num)+1)/2), 2)\n",
        "  service_times.append(time)\n",
        "\n",
        "len(service_times)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vdkCc4GaQNan",
        "outputId": "d3745276-162e-4731-b634-52e5a3075e8e"
      },
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1000"
            ]
          },
          "metadata": {},
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.3 Generating student arrival times"
      ],
      "metadata": {
        "id": "wY5YrjjGkbA4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arrival_times = []\n",
        "\n",
        "arrival_time = 10*random.random()\n",
        "arrival_times.append(round(arrival_time, 2))\n",
        "\n",
        "for i in range(999):\n",
        "    arrival_time = 10*random.random() * ((2400-arrival_times[i])/2400) + arrival_times[i]\n",
        "    arrival_times.append(round(arrival_time, 2))\n",
        "\n",
        "for i in range(999):\n",
        "     arrival_times[i]\n",
        "\n",
        "len(arrival_times)"
      ],
      "metadata": {
        "id": "WZjjqKlSiE1X",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2423a57f-fdb3-4460-bba4-37b3d317a3e5"
      },
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1000"
            ]
          },
          "metadata": {},
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.4 Calculating inter-arrival times"
      ],
      "metadata": {
        "id": "_g0hZG9kkuZy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "inter_arrival_times = [0]\n",
        "for i in range(1, 1000):\n",
        "    inter_arrival_time = round(arrival_times[i] - arrival_times[i - 1], 2)\n",
        "    inter_arrival_times.append(inter_arrival_time)\n",
        "\n",
        "len(inter_arrival_times)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a53tV_u7tT6R",
        "outputId": "3a9aaab5-1e92-4e2e-9571-71b079994f5c"
      },
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1000"
            ]
          },
          "metadata": {},
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.5 Calculations for the following data:\n",
        "\n",
        "* When service begins\n",
        "* Time spent queueing\n",
        "* When service ends\n",
        "* Time spent in the system\n",
        "* Server idle time"
      ],
      "metadata": {
        "id": "QZwW4PEHlApi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "service_begin_times = [[arrival_times[0]] for _ in range(n_servers)]\n",
        "queue_wait_times = [[0.00] for _ in range(n_servers)]\n",
        "service_end_times = [[service_begin_times[0][0] + service_times[0]] for _ in range(n_servers)]\n",
        "times_in_system = [[service_times[0]] for _ in range(n_servers)]\n",
        "server_idle_times = [[0] for _ in range(n_servers)]\n",
        "\n",
        "for i in range(1, 1000):\n",
        "    # Find the server that ends service earliest\n",
        "    server_id = np.argmin([service_end_times[j][-1] for j in range(n_servers)])\n",
        "\n",
        "    if arrival_times[i] > service_end_times[server_id][-1]:\n",
        "        service_begin_time = arrival_times[i]\n",
        "        queue_wait_time = 0.00\n",
        "        server_idle_time = arrival_times[i] - service_end_times[server_id][-1]\n",
        "    else:\n",
        "        service_begin_time = service_end_times[server_id][-1]\n",
        "        queue_wait_time = service_end_times[server_id][-1] - arrival_times[i]\n",
        "        server_idle_time = 0.00\n",
        "\n",
        "    service_end_time = round(service_times[i] + service_begin_time, 2)\n",
        "    time_in_system = round(queue_wait_time + service_times[i], 2)\n",
        "\n",
        "    service_begin_times[server_id].append(service_begin_time)\n",
        "    queue_wait_times[server_id].append(queue_wait_time)\n",
        "    service_end_times[server_id].append(service_end_time)\n",
        "    times_in_system[server_id].append(time_in_system)\n",
        "    server_idle_times[server_id].append(server_idle_time)"
      ],
      "metadata": {
        "id": "axSnoWhLwKav"
      },
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.6 Adding all the data to a dataframe"
      ],
      "metadata": {
        "id": "SM6pWG-PmSPi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Creating a separate DataFrame for each server\n",
        "for i in range(n_servers):\n",
        "    ss = pd.DataFrame(\n",
        "        {'service_time': service_times[:len(service_begin_times[i])],\n",
        "         'arrival_time': arrival_times[:len(service_begin_times[i])],\n",
        "         'inter_arrival_time': inter_arrival_times[:len(service_begin_times[i])],\n",
        "         'time_service_begins': service_begin_times[i],\n",
        "         'queue_wait_time': queue_wait_times[i],\n",
        "         'time_service_ends': service_end_times[i],\n",
        "         'time_in_system': times_in_system[i],\n",
        "         'server_idle_time': server_idle_times[i]\n",
        "        })\n",
        "    ss.to_csv(f'admission_data_server_{i}.csv')"
      ],
      "metadata": {
        "id": "6wJDmpiUlP75"
      },
      "execution_count": 112,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.7 Calculating the results"
      ],
      "metadata": {
        "id": "aKyiI6wdmrGp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "average_waiting_time = ss['queue_wait_time'].mean()\n",
        "average_idle_server_time = ss['server_idle_time'].mean()\n",
        "average_service_time = ss['service_time'].mean()\n",
        "average_inter_arrival_time = ss['inter_arrival_time'].mean()\n",
        "average_time_in_system = ss['time_in_system'].mean()\n"
      ],
      "metadata": {
        "id": "b8Si_5CJriOG"
      },
      "execution_count": 113,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"The average waiting time is: {round(average_waiting_time,2)}\")\n",
        "print(f\"The average idle server time is: {average_idle_server_time}\")\n",
        "print(f\"The average service time is: {round(average_service_time, 2)}\")\n",
        "print(f\"The average inter arrival time is:{round(average_inter_arrival_time, 2)}\")\n",
        "\n",
        "print(f\"The average time a student spent in the system: {round(average_time_in_system, 2)}\")"
      ],
      "metadata": {
        "id": "kdCrohkTJuKf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c050e63f-416f-4915-b21c-4a02ed48f0db"
      },
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The average waiting time is: 555.44\n",
            "The average idle server time is: 0.2417599999999998\n",
            "The average service time is: 7.31\n",
            "The average inter arrival time is:3.11\n",
            "The average time a student spent in the system: 562.74\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 6.Model Verification"
      ],
      "metadata": {
        "id": "OtE2BkKQm05M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "These checks will give us some insights into whether the simulation results align with our expectations. If the simulation is correct, the average service time, queue wait time, and time in the system should be reasonably close to the specified values (10 * (sin(num) + 1) / 2) in the code.\n",
        "\n",
        "The `inter_arrival_times` will not have any effect in this verification, as it is calculated from the generated `arrival_times`, and the `server_idle_times` will be zero for both servers as they are initialized to zero and not updated in the provided code."
      ],
      "metadata": {
        "id": "PCNh7UI1ykPb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Read the CSV files for both servers\n",
        "server_0_data = pd.read_csv('admission_data_server_0.csv')\n",
        "server_1_data = pd.read_csv('admission_data_server_1.csv')\n",
        "\n",
        "# Check the number of rows in each DataFrame\n",
        "print(\"Number of rows in Server 0 data:\", len(server_0_data))\n",
        "print(\"Number of rows in Server 1 data:\", len(server_1_data))\n",
        "\n",
        "# Calculate the average service time for both servers\n",
        "avg_service_time_server_0 = server_0_data['service_time'].mean()\n",
        "avg_service_time_server_1 = server_1_data['service_time'].mean()\n",
        "print(\"Average service time for Server 0:\", avg_service_time_server_0)\n",
        "print(\"Average service time for Server 1:\", avg_service_time_server_1)\n",
        "\n",
        "# Calculate the average queue wait time for both servers\n",
        "avg_queue_wait_time_server_0 = server_0_data['queue_wait_time'].mean()\n",
        "avg_queue_wait_time_server_1 = server_1_data['queue_wait_time'].mean()\n",
        "print(\"Average queue wait time for Server 0:\", avg_queue_wait_time_server_0)\n",
        "print(\"Average queue wait time for Server 1:\", avg_queue_wait_time_server_1)\n",
        "\n",
        "# Calculate the average time in the system for both servers\n",
        "avg_time_in_system_server_0 = server_0_data['time_in_system'].mean()\n",
        "avg_time_in_system_server_1 = server_1_data['time_in_system'].mean()\n",
        "print(\"Average time in the system for Server 0:\", avg_time_in_system_server_0)\n",
        "print(\"Average time in the system for Server 1:\", avg_time_in_system_server_1)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X3WOIAJ7wZmS",
        "outputId": "5923a46c-91b1-4d92-e8fa-57e8ca98cb97"
      },
      "execution_count": 115,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of rows in Server 0 data: 501\n",
            "Number of rows in Server 1 data: 500\n",
            "Average service time for Server 0: 7.308802395209581\n",
            "Average service time for Server 1: 7.30606\n",
            "Average queue wait time for Server 0: 547.6223353293414\n",
            "Average queue wait time for Server 1: 555.43932\n",
            "Average time in the system for Server 0: 554.9339720558883\n",
            "Average time in the system for Server 1: 562.74494\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 7.Model Validation"
      ],
      "metadata": {
        "id": "IiKzq-_Sm68o"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this code, we read the data from each server's CSV file into separate DataFrames. Then, we concatenate the data from all servers into a single DataFrame called `simulated_data`.\n",
        "\n",
        "We calculate the average service time, average queue wait time, average time in the system, and average server idle time for the entire simulated system.\n",
        "\n",
        "By comparing these calculated statistics with the expected values (based on the underlying queuing model), we can validate whether the simulation behaves as intended and whether the calculated metrics align with the assumptions and logic of the simulation.\n",
        "\n",
        "In this code, we use the `sem()` function from pandas to calculate the standard error of the mean for each statistic in the simulated_data. Then, we calculate the margin of error for a 95% confidence interval using a z-score of 1.96 (corresponding to a 95% confidence level for a normal distribution).\n",
        "\n",
        "The margin of error gives an estimate of how much the sample mean might differ from the true population mean. A larger margin of error indicates higher uncertainty in the estimate, while a smaller margin of error suggests a more precise estimate.\n",
        "\n",
        "This calculation assumes the underlying distribution is approximately normal, and the sample size is large enough for the Central Limit Theorem to hold."
      ],
      "metadata": {
        "id": "c6LFIUTAz0xo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Number of servers\n",
        "n_servers = 2\n",
        "\n",
        "# Lists to store data for both servers\n",
        "all_data = []\n",
        "\n",
        "# Loop to read data from each server's CSV file\n",
        "for server_id in range(n_servers):\n",
        "    # Read the CSV file for the current server\n",
        "    server_data = pd.read_csv(f'admission_data_server_{server_id}.csv')\n",
        "\n",
        "    # Append the server data to the list\n",
        "    all_data.append(server_data)\n",
        "\n",
        "# Concatenate data from all servers into a single DataFrame\n",
        "simulated_data = pd.concat(all_data)\n",
        "\n",
        "# Calculate overall statistics for the simulation\n",
        "avg_service_time = simulated_data['service_time'].mean()\n",
        "avg_queue_wait_time = simulated_data['queue_wait_time'].mean()\n",
        "avg_time_in_system = simulated_data['time_in_system'].mean()\n",
        "avg_server_idle_time = simulated_data['server_idle_time'].mean()\n",
        "\n",
        "# Calculate the standard errors for each statistic\n",
        "std_error_service_time = simulated_data['service_time'].sem()\n",
        "std_error_queue_wait_time = simulated_data['queue_wait_time'].sem()\n",
        "std_error_time_in_system = simulated_data['time_in_system'].sem()\n",
        "std_error_server_idle_time = simulated_data['server_idle_time'].sem()\n",
        "\n",
        "# Calculate the margin of error for a 95% confidence interval (z-score = 1.96)\n",
        "margin_of_error_service_time = 1.96 * std_error_service_time\n",
        "margin_of_error_queue_wait_time = 1.96 * std_error_queue_wait_time\n",
        "margin_of_error_time_in_system = 1.96 * std_error_time_in_system\n",
        "margin_of_error_server_idle_time = 1.96 * std_error_server_idle_time\n",
        "\n",
        "# Display results\n",
        "print(\"Average service time:\", avg_service_time)\n",
        "print(\"Margin of error for service time:\", margin_of_error_service_time)\n",
        "\n",
        "print(\"Average queue wait time:\", avg_queue_wait_time)\n",
        "print(\"Margin of error for queue wait time:\", margin_of_error_queue_wait_time)\n",
        "\n",
        "print(\"Average time in the system:\", avg_time_in_system)\n",
        "print(\"Margin of error for time in the system:\", margin_of_error_time_in_system)\n",
        "\n",
        "print(\"Average server idle time:\", avg_server_idle_time)\n",
        "print(\"Margin of error for server idle time:\", margin_of_error_server_idle_time)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tFqsCDrlzpRy",
        "outputId": "489bc57b-c3fc-45ec-c625-409af5b15134"
      },
      "execution_count": 116,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average service time: 7.307432567432567\n",
            "Margin of error for service time: 0.07620587891221656\n",
            "Average queue wait time: 551.526923076923\n",
            "Margin of error for queue wait time: 32.57138117091663\n",
            "Average time in the system: 558.8355544455544\n",
            "Margin of error for time in the system: 32.56886062274342\n",
            "Average server idle time: 0.23203796203796193\n",
            "Margin of error for server idle time: 0.06667187513243492\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 8.Experimental design"
      ],
      "metadata": {
        "id": "NHCkJRPcnCK0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The system is not efficient as seen by the average amount of time the student waits in the system. We can run simulations that would help us optimize the process and determine a more efficient manner of handling student admission."
      ],
      "metadata": {
        "id": "GdVsLw3yr4De"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 8.1 Setting up parameters for the simulation"
      ],
      "metadata": {
        "id": "38F6N50atD4j"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The parameter values average inter-arrival time, average service time, and number of students are obtained from the results of our model above.\n",
        "\n",
        "The arrival rate is one student per average inter-arrival time and the service rate is one student per average service time.\n",
        "\n",
        "We assume that the duration of service is eight hours per day."
      ],
      "metadata": {
        "id": "ntjN-RdXtZsL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "avg_interarrival_time = average_inter_arrival_time   # minutes\n",
        "arrival_rate = 1.0 / avg_interarrival_time\n",
        "avg_service_time = average_service_time  # minutes\n",
        "service_rate = 1.0 / avg_service_time\n",
        "num_students = 1000\n",
        "service_duration = 8 * 60  # 8 hours"
      ],
      "metadata": {
        "id": "itNWGBKosFDd"
      },
      "execution_count": 117,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 8.2 Functions to monitor the student and their arrival\n",
        "\n",
        "* student_arrivals:\n",
        "\n",
        "This function represents the arrival process of students. It loops 40,000 times, where 40,000 is the total number of students to simulate.\n",
        "\n",
        "It checks if there is available capacity in the servers (both busy servers and waiting queue) up to the specified\n",
        "\n",
        "queue_capacity.\n",
        "\n",
        "If there is available capacity, a service time is generated from an exponential distribution using `random.expovariate(service_rate)`.\n",
        "\n",
        "Then, it initiates the student process using `env.process(student(env, servers, service_time))`.\n",
        "\n",
        "After that, it waits for a random inter-arrival time using `env.timeout(random.expovariate(arrival_rate))`, where arrival_rate is the average arrival rate of students.\n",
        "\n",
        "* student:\n",
        "\n",
        "This function represents the process of each student. When a student arrives, it records the arrival time `arrival_time` using `env.now`.\n",
        "\n",
        "Then, the student requests a server from the servers using `servers.request()`.\n",
        "\n",
        "The simulation will pause until the student can get a server from the available pool.\n",
        "\n",
        "Once the student acquires a server, it waits for the service time defined by `service_time` using `env.timeout(service_time)`.\n",
        "\n",
        "After the service is complete, the student's waiting time is calculated as the difference between the current simulation time and the arrival time, and it is appended to the `waiting_times` list."
      ],
      "metadata": {
        "id": "j-h9EzICu0eF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def student_arrivals(env, servers, queue_capacity):\n",
        "    for i in range(num_students):\n",
        "        if servers.count + len(servers.queue) < queue_capacity:\n",
        "            service_time = random.expovariate(service_rate)\n",
        "            yield env.process(student(env, servers, service_time))\n",
        "        yield env.timeout(random.expovariate(arrival_rate))\n",
        "\n",
        "def student(env, servers, service_time):\n",
        "    arrival_time = env.now\n",
        "    with servers.request() as req:\n",
        "        yield req\n",
        "        yield env.timeout(service_time)\n",
        "        waiting_times.append(env.now - arrival_time)\n"
      ],
      "metadata": {
        "id": "_hvzD9emuymx"
      },
      "execution_count": 118,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 8.3 Defining the optimal conditions that the simulation should determine"
      ],
      "metadata": {
        "id": "U1BAmdiQxCHK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "optimal_conditions = {\n",
        "    'num_servers': None,\n",
        "    'queue_capacity': None,\n",
        "    'avg_waiting_time': float('inf'),\n",
        "    'num_days': float('inf')\n",
        "}"
      ],
      "metadata": {
        "id": "WjkBRS47xA-H"
      },
      "execution_count": 119,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 8.4 Finding Optimal Conditions\n",
        "\n",
        "The code uses nested loops to explore different combinations of `num_servers` and `queue_capacity`.\n",
        "\n",
        "For each combination, it sets up the simulation environment, runs the simulation with `env.run(until=num_students / arrival_rate)`, and calculates the average waiting time for all students.\n",
        "\n",
        "It also determines the number of days (`num_days`) needed to serve all students based on the `service_duration`."
      ],
      "metadata": {
        "id": "cQcTNgSXyIY0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for num_servers in range(2, 7):\n",
        "    for queue_capacity in range(60, 105):\n",
        "        waiting_times = []\n",
        "        env = simpy.Environment()\n",
        "        servers = simpy.Resource(env, num_servers)\n",
        "        env.process(student_arrivals(env, servers, queue_capacity))\n",
        "        env.run(until=num_students / arrival_rate)\n",
        "        avg_waiting_time = sum(waiting_times) / len(waiting_times)\n",
        "        num_days = int(env.now // service_duration) + 1\n",
        "        if avg_waiting_time < optimal_conditions['avg_waiting_time']:\n",
        "            optimal_conditions = {\n",
        "                'num_servers': num_servers,\n",
        "                'queue_capacity': queue_capacity,\n",
        "                'avg_waiting_time': avg_waiting_time,\n",
        "                'num_days': num_days\n",
        "            }"
      ],
      "metadata": {
        "id": "JgmWF4GMxvvN"
      },
      "execution_count": 120,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 8.5 The results"
      ],
      "metadata": {
        "id": "wA8SDo5ayosK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def results():\n",
        "  print('Optimal conditions:')\n",
        "  print('Number of servers:', optimal_conditions['num_servers'])\n",
        "  print('Queue capacity:', optimal_conditions['queue_capacity'])\n",
        "  print('Average waiting time:', round(optimal_conditions['avg_waiting_time'], 2), 'minutes')\n",
        "  print('Service days:', optimal_conditions['num_days'])\n",
        "\n",
        "\n",
        "results()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cz_OqEw_yroh",
        "outputId": "3fd47268-2601-444f-8f1e-3b45db1e81a0"
      },
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal conditions:\n",
            "Number of servers: 6\n",
            "Queue capacity: 62\n",
            "Average waiting time: 6.26 minutes\n",
            "Service days: 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 9.More runs"
      ],
      "metadata": {
        "id": "3SYdz765UD8W"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can run multiple simulations to obtains different values for optimal conditions"
      ],
      "metadata": {
        "id": "wyN_WZV6UJCj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(5):\n",
        "  def student_arrivals(env, servers, queue_capacity):\n",
        "    for i in range(num_students):\n",
        "        if servers.count + len(servers.queue) < queue_capacity:\n",
        "            service_time = random.expovariate(service_rate)\n",
        "            yield env.process(student(env, servers, service_time))\n",
        "        yield env.timeout(random.expovariate(arrival_rate))\n",
        "\n",
        "  def student(env, servers, service_time):\n",
        "    arrival_time = env.now\n",
        "    with servers.request() as req:\n",
        "        yield req\n",
        "        yield env.timeout(service_time)\n",
        "        waiting_times.append(env.now - arrival_time)\n",
        "\n",
        "  for num_servers in range(2, 7):\n",
        "    for queue_capacity in range(60, 105):\n",
        "        waiting_times = []\n",
        "        env = simpy.Environment()\n",
        "        servers = simpy.Resource(env, num_servers)\n",
        "        env.process(student_arrivals(env, servers, queue_capacity))\n",
        "        env.run(until=num_students / arrival_rate)\n",
        "        avg_waiting_time = sum(waiting_times) / len(waiting_times)\n",
        "        num_days = int(env.now // service_duration) + 1\n",
        "        if avg_waiting_time < optimal_conditions['avg_waiting_time']:\n",
        "            optimal_conditions = {\n",
        "                'num_servers': num_servers,\n",
        "                'queue_capacity': queue_capacity,\n",
        "                'avg_waiting_time': avg_waiting_time,\n",
        "                'num_days': num_days\n",
        "            }\n",
        "  results()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qlWaeQkUUVvh",
        "outputId": "9c1b9e6c-a19b-4a5a-81df-1bee05491366"
      },
      "execution_count": 122,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal conditions:\n",
            "Number of servers: 6\n",
            "Queue capacity: 62\n",
            "Average waiting time: 6.26 minutes\n",
            "Service days: 7\n",
            "Optimal conditions:\n",
            "Number of servers: 2\n",
            "Queue capacity: 64\n",
            "Average waiting time: 6.23 minutes\n",
            "Service days: 7\n",
            "Optimal conditions:\n",
            "Number of servers: 2\n",
            "Queue capacity: 64\n",
            "Average waiting time: 6.23 minutes\n",
            "Service days: 7\n",
            "Optimal conditions:\n",
            "Number of servers: 5\n",
            "Queue capacity: 82\n",
            "Average waiting time: 6.09 minutes\n",
            "Service days: 7\n",
            "Optimal conditions:\n",
            "Number of servers: 5\n",
            "Queue capacity: 82\n",
            "Average waiting time: 6.09 minutes\n",
            "Service days: 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 10.Implementation"
      ],
      "metadata": {
        "id": "OsuCcYC2zTCz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The system can be implemented based on the optimum conditions provided by the model and adjusted to fit different scenarios."
      ],
      "metadata": {
        "id": "mN_1MVxHzXzK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 11.References"
      ],
      "metadata": {
        "id": "iPpIkK0w6SAJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Kleinrock, L. (1975). Queueing Systems, Volume I - Theory. Wiley-Interscience.\n",
        "\n",
        "Ross, S. M. (2007). Introduction to Probability Models. Academic Press.\n",
        "\n",
        "Lavenberg, S. S. (2005). Queueing Theory and Its Applications: A Personal View. Queueing Systems, 50(1-2), 3-20."
      ],
      "metadata": {
        "id": "kjFtL5AH9gIe"
      }
    }
  ]
}