Network_Simulation_v1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "eadbb6dc-7e5b-4de4-bd5c-da7ea124999a",
   "metadata": {
    "id": "eadbb6dc-7e5b-4de4-bd5c-da7ea124999a"
   },
   "source": [
    "## Overview\n",
    "\n",
    "In this project, you will practice applying your mechanistic simulation skills to create models that generate datasets you can analyze and optimize. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59fec8ab-0734-4b1b-af31-bca0884cd8c2",
   "metadata": {
    "id": "59fec8ab-0734-4b1b-af31-bca0884cd8c2"
   },
   "source": [
    "## Global imports\n",
    "\n",
    "Write your imports here so you don't have to write imports below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a0_e6SDTUIXA",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "a0_e6SDTUIXA",
    "outputId": "594b0ffd-dbae-46e8-9a32-944901a27633"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: simpy in /usr/local/lib/python3.7/dist-packages (4.0.1)\n"
     ]
    }
   ],
   "source": [
    "!pip install simpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8ab98770-ea96-49d8-aa0b-b5331c0f956b",
   "metadata": {
    "id": "8ab98770-ea96-49d8-aa0b-b5331c0f956b"
   },
   "outputs": [],
   "source": [
    "import simpy as sp\n",
    "import numpy as np\n",
    "from typing import List, Tuple\n",
    "import random\n",
    "from typing import Callable\n",
    "import scipy\n",
    "from scipy.optimize import minimize_scalar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27ddd42c-b8bf-48af-8771-882074bd5f1e",
   "metadata": {
    "id": "27ddd42c-b8bf-48af-8771-882074bd5f1e"
   },
   "source": [
    "## Problem 1\n",
    "\n",
    "**Write and discuss the steps to answering the following research question:** We would like to design a [network packet](https://en.wikipedia.org/wiki/Network_packet) routing system. To do so, we will need to define the system and run a simulation so that we can generate data that will be used for optimization of design parameters. Our router will be a bit of a simpler system, so do not worry about any specifics you know about ethernet or telecommunications in general.  The goal of our router is that it will route packets from devices connected to it through to the internet.\n",
    "\n",
    "We'll parameterize our router so that it can accept $\\alpha$ packet routing connections at any time. Assume that packets take $\\beta$ time to be routed through the router. Let's say that each device connected to the router is only willing to wait up to $\\gamma$ time for the packet to be routed to its destination.  Let's also say that our system will allow for prioritization on three levels, so that we can make sure those high-priority packets like those for voice and video calls can route through before lower-priority packets like standard file downloads.  To model our system, let's say that we have $n$ devices on our network connected to the router.  Each device generates $X_v$ videocalling packets, $X_s$ standard priority packets, and $X_l$ low priority packets at an $X_i$ interval.  Higher priority packets will not preempt lower priority packets, but they will be able to jump the queue (`simpy.PriorityResource`).\n",
    "\n",
    "Based on the distributions for the parameters below, what is the average number of packets that make it through the router to the internet, for $n$ = [3, 5, 10, 15]?  All time-related parameters below are in milliseconds. Make sure to set the random seed.\n",
    "- $\\alpha$ = 6\n",
    "- $\\beta$ = exponentially-modified normal continuous random variable at location 1 and scale 1.5\n",
    "- $\\gamma$ = 3\n",
    "- $X_v$ = uniform discrete random variable between [2,10]\n",
    "- $X_s$ = uniform discrete random variable between [2,10]\n",
    "- $X_l$ = uniform discrete random variable between [2,10]\n",
    "- $X_i$ = binomial discrete random variable with n at 10 and p at 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "EF3vkN76TrEy",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EF3vkN76TrEy",
    "outputId": "07d715c7-4386-41d3-80d5-1a0438a16a53"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SIMULATION:  average number of packets that make it through the router to the internet (time units are minutes)\n",
      "Xv at time    0.00, Packets 00 arrived\n",
      "at time    0.00, Packets 00 waited   0.00\n",
      "Xi at time    5.96, Packets 01 arrived\n",
      " at time    6.99, Packets 01 left the line after waiting   1.03 minutes\n",
      "Xi at time    7.55, Packets 02 arrived\n",
      " at time    8.75, Packets 02 left the line after waiting   1.20 minutes\n",
      "Xl at time    8.85, Packets 03 arrived\n",
      "Xv at time    9.20, Packets 04 arrived\n",
      " at time    9.87, Packets 03 left the line after waiting   1.02 minutes\n",
      " at time   10.41, Packets 04 left the line after waiting   1.22 minutes\n",
      "Xv at time   12.20, Packets 05 arrived\n",
      " at time   13.65, Packets 05 left the line after waiting   1.45 minutes\n",
      "at time   15.62, Packets 00 finished their rouing at router device 'ethernet'andom_router\n"
     ]
    }
   ],
   "source": [
    "RANDOM_SEED = 5\n",
    "\n",
    "alpha = 6\n",
    "\n",
    "gamma = 3\n",
    "\n",
    "min_beta = 1\n",
    "\n",
    "max_beta = 1.5\n",
    "\n",
    "def source(env, number, interval, counter, the_rng):\n",
    "    \"\"\"Source generates packets randomly\"\"\"\n",
    "    for i in range(number):\n",
    "        p = packet(env, 'Packets %02d' % i, counter, 12.0, the_rng)\n",
    "        env.process(p)\n",
    "        t = the_rng.exponential(interval)\n",
    "        yield env.timeout(t)\n",
    "\n",
    "\n",
    "def packet(env, name, counter, time_in_bank, the_rng):\n",
    "    \"\"\"Packet arrives, is served and leaves.\"\"\"\n",
    "    packet_list=['Xv','Xs','Xl','Xi']\n",
    "    router_list=['ethernet','telecommunications']\n",
    "    random_router = random.choice(router_list)\n",
    "    random_packet = random.choice(packet_list)\n",
    "    arrive = env.now\n",
    "    print(random_packet+' at time %7.2f, %s arrived' % (arrive, name))\n",
    "    \n",
    "    with counter.request() as req:\n",
    "        router = the_rng.uniform(min_beta, max_beta)\n",
    "        # Wait for the counter or abort at the end of our tether\n",
    "        results = yield req | env.timeout(router)\n",
    "\n",
    "        wait = env.now - arrive\n",
    "\n",
    "        if req in results:\n",
    "            # We got to the counter\n",
    "            print('at time %7.2f, %s waited %6.2f' % (env.now, name, wait))\n",
    "\n",
    "            tib = the_rng.exponential(time_in_bank)\n",
    "            yield env.timeout(tib)\n",
    "            print('at time %7.2f, %s finished their rouing at router device %random_router' % (env.now, name, random_router))\n",
    "\n",
    "        else:\n",
    "            # We reneged\n",
    "            print(' at time %7.2f, %s left the line after waiting %6.2f minutes' % (env.now, name, wait))\n",
    "\n",
    "\n",
    "# Setup and start the simulation\n",
    "print('SIMULATION:  average number of packets that make it through the router to the internet (time units are minutes)')\n",
    "the_rng = np.random.default_rng(RANDOM_SEED)\n",
    "env = sp.Environment()\n",
    "\n",
    "# Start processes and run\n",
    "counter = sp.Resource(env, capacity=1)\n",
    "env.process(source(env, alpha, gamma, counter, the_rng))\n",
    "env.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9952b51f",
   "metadata": {},
   "source": [
    "### Answer:The Solution is divided into two parts first portion is to get the packtes that are going and also get the connection randomly and then get the number of packet and  simulate the average packet that pass through them and the first portion is pass through 2nd function  source to get the source of the pakcet and the time required to get through"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8db30c6-8539-4e8d-a2dc-5c0f7786321a",
   "metadata": {
    "id": "f8db30c6-8539-4e8d-a2dc-5c0f7786321a"
   },
   "source": [
    "## Problem 2\n",
    "\n",
    "**Write and discuss the steps to answering the following research question:** Create a function that will automatically run the simulation above given $n$ and return the number of packets that successfully route through. Make sure that the function sets the same random seed inside the function, so that your simulation parameters are consistent across runs. Using `scipy.optimize.minimize_scalar()` ([see reference](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize_scalar.html#scipy.optimize.minimize_scalar)), what is the value of $n$ (number of devices on the network) that results in the highest number of packets that successfully route through our router design, where $5 \\le n \\le 30$?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "a188aac9-d9d4-499e-b8f6-9163afc05af4",
   "metadata": {
    "id": "a188aac9-d9d4-499e-b8f6-9163afc05af4"
   },
   "outputs": [],
   "source": [
    "def optimzer():\n",
    "  RANDOM_SEED = 5\n",
    "  alpha = 6\n",
    "  gamma = 3\n",
    "  min_beta = 1\n",
    "  max_beta = 1.5\n",
    "  opt_bounds = (5, 30)\n",
    "  #a,b,c,d,e=source(env, 5, gamma, 12.0, the_rng)\n",
    "  for i in range(alpha):\n",
    "    o = scipy.optimize.minimize_scalar(packet, bounds=opt_bounds, args=(env, 'Packets %02d' % i, counter, 12.0, the_rng))\n",
    "    env.process(o)\n",
    "    t = the_rng.exponential(interval)\n",
    "    yield env.timeout(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "VCW-gCp-nmmV",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "VCW-gCp-nmmV",
    "outputId": "eaa2c35b-e67f-4546-85a0-b678e91326af"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Xl at time    0.00, Packets 00 arrived\n",
      "Xs at time    0.00, Packets 01 arrived\n",
      "Xs at time    0.00, Packets 02 arrived\n",
      "Xs at time    0.00, Packets 03 arrived\n",
      "Xl at time    0.00, Packets 04 arrived\n",
      "An exception occurred\n"
     ]
    }
   ],
   "source": [
    "the_rng = np.random.default_rng(RANDOM_SEED)\n",
    "env = sp.Environment()\n",
    "# Start processes and run\n",
    "counter = sp.Resource(env, capacity=1)\n",
    "env.process(optimzer())\n",
    "try:\n",
    "  env.run()\n",
    "except:\n",
    "  print(\"An exception occurred\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99793de7",
   "metadata": {
    "id": "VJUf5N9ruops"
   },
   "source": [
    "### Answer: In this problem we can optimze the simultaion of packets and using the fucntion to get the optimze number  of packet pass through and also define the range between 5 to 30 "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "hw4.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}