exmaple_sim_shortest_queue.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Queueing system with control"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decide stations can branch clients by using lambda functions. In the following model the clients are sent to one of two process stations depending on the queue lengths at the corresponding stations."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating integer pseudo random numbers\n",
    "from random import randint\n",
    "\n",
    "# Collecting results\n",
    "import pandas as pd\n",
    "\n",
    "# Simulation\n",
    "from queuesim.stations import Source, Decide, DecideCondition, Process, Dispose\n",
    "from queuesim import Simulator\n",
    "from queuesim.random_dist import exp as exp_dist"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## General model parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arrivals to be simulated\n",
    "count = 100_000\n",
    "\n",
    "# Inter-arrival times distribution\n",
    "inter_arrival_time = exp_dist(50)\n",
    "\n",
    "# Service times distribution\n",
    "process_time = exp_dist(80)\n",
    "\n",
    "# Fast service times distribution\n",
    "process_time_fast = exp_dist(40)\n",
    "\n",
    "# Number of operators per service station (by using two stations)\n",
    "c = 1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare data collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "enq_dict = {}\n",
    "en_dict = {}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two stations with individual queues, new clients choosing the queue by change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E[NQ]=6.54\n",
      "E[N]=8.14\n"
     ]
    }
   ],
   "source": [
    "# Simulator\n",
    "simulator = Simulator()\n",
    "\n",
    "# Stations\n",
    "source = Source(simulator, count, inter_arrival_time)\n",
    "decide = Decide(simulator)\n",
    "process1 = Process(simulator, process_time, c)\n",
    "process2 = Process(simulator, process_time, c)\n",
    "dispose = Dispose(simulator)\n",
    "\n",
    "# Link stations\n",
    "source.set_next(decide)\n",
    "decide.add_next(process1, 1)\n",
    "decide.add_next(process2, 1)\n",
    "process1.set_next(dispose)\n",
    "process2.set_next(dispose)\n",
    "\n",
    "# Run simulation\n",
    "simulator.run()\n",
    "\n",
    "# Results\n",
    "name = \"2 queues, random\"\n",
    "enq = process1.statistic_queue_length.mean + process2.statistic_queue_length.mean\n",
    "en = process1.statistic_wip.mean + process2.statistic_wip.mean\n",
    "enq_dict[name] = enq\n",
    "en_dict[name] = en\n",
    "print(\"E[NQ]=\", round(enq, 2), sep=\"\")\n",
    "print(\"E[N]=\", round(en, 2), sep=\"\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two stations with individual queues, new clients will enter the shortest queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E[NQ]=3.25\n",
      "E[N]=4.84\n"
     ]
    }
   ],
   "source": [
    "# Simulator\n",
    "simulator = Simulator()\n",
    "\n",
    "# Stations\n",
    "source = Source(simulator, count, inter_arrival_time)\n",
    "decide = DecideCondition(simulator)\n",
    "process1 = Process(simulator, process_time, c)\n",
    "process2 = Process(simulator, process_time, c)\n",
    "dispose = Dispose(simulator)\n",
    "\n",
    "\n",
    "def shortest_queue(client) -> int:\n",
    "    nq1 = process1.nq\n",
    "    nq2 = process2.nq\n",
    "    if nq1 < nq2: return 0\n",
    "    if nq1 > nq2: return 1\n",
    "    return randint(0, 1)\n",
    "\n",
    "\n",
    "# Link stations\n",
    "source.set_next(decide)\n",
    "decide.set_condition(shortest_queue)\n",
    "decide.add_next(process1)\n",
    "decide.add_next(process2)\n",
    "process1.set_next(dispose)\n",
    "process2.set_next(dispose)\n",
    "\n",
    "# Run simulation\n",
    "simulator.run()\n",
    "\n",
    "# Results\n",
    "name = \"2 queues, shortest\"\n",
    "enq = process1.statistic_queue_length.mean + process2.statistic_queue_length.mean\n",
    "en = process1.statistic_wip.mean + process2.statistic_wip.mean\n",
    "enq_dict[name] = enq\n",
    "en_dict[name] = en\n",
    "print(\"E[NQ]=\", round(enq, 2), sep=\"\")\n",
    "print(\"E[N]=\", round(en, 2), sep=\"\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One service station (with a single queue) with two parallel operators at the station"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E[NQ]=2.87\n",
      "E[N]=4.47\n"
     ]
    }
   ],
   "source": [
    "# Simulator\n",
    "simulator = Simulator()\n",
    "\n",
    "# Stations\n",
    "source = Source(simulator, count, inter_arrival_time)\n",
    "process = Process(simulator, process_time, 2 * c)\n",
    "dispose = Dispose(simulator)\n",
    "\n",
    "# Link stations\n",
    "source.set_next(process)\n",
    "process.set_next(dispose)\n",
    "\n",
    "# Run simulation\n",
    "simulator.run()\n",
    "\n",
    "# Results\n",
    "name = \"1 queue, 2 parallel operators\"\n",
    "enq = process.statistic_queue_length.mean\n",
    "en = process.statistic_wip.mean\n",
    "enq_dict[name] = enq\n",
    "en_dict[name] = en\n",
    "print(\"E[NQ]=\", round(enq, 2), sep=\"\")\n",
    "print(\"E[N]=\", round(en, 2), sep=\"\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One service station (with a single queue) with batch processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E[NQ]=4.99\n",
      "E[N]=6.58\n"
     ]
    }
   ],
   "source": [
    "# Simulator\n",
    "simulator = Simulator()\n",
    "\n",
    "# Stations\n",
    "source = Source(simulator, count, inter_arrival_time)\n",
    "process = Process(simulator, process_time, c, b=2)\n",
    "dispose = Dispose(simulator)\n",
    "\n",
    "# Link stations\n",
    "source.set_next(process)\n",
    "process.set_next(dispose)\n",
    "\n",
    "# Run simulation\n",
    "simulator.run()\n",
    "\n",
    "# Results\n",
    "name = \"1 queue, batch processing\"\n",
    "enq = process.statistic_queue_length.mean\n",
    "en = process.statistic_wip.mean\n",
    "enq_dict[name] = enq\n",
    "en_dict[name] = en\n",
    "print(\"E[NQ]=\", round(enq, 2), sep=\"\")\n",
    "print(\"E[N]=\", round(en, 2), sep=\"\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One service station (with a single queue) with a twice as fast operator as on the other models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E[NQ]=3.27\n",
      "E[N]=4.07\n"
     ]
    }
   ],
   "source": [
    "# Simulator\n",
    "simulator = Simulator()\n",
    "\n",
    "# Stations\n",
    "source = Source(simulator, count, inter_arrival_time)\n",
    "process = Process(simulator, process_time_fast, c)\n",
    "dispose = Dispose(simulator)\n",
    "\n",
    "# Link stations\n",
    "source.set_next(process)\n",
    "process.set_next(dispose)\n",
    "\n",
    "# Run simulation\n",
    "simulator.run()\n",
    "\n",
    "# Results\n",
    "name = \"1 queue, fast operator\"\n",
    "enq = process.statistic_queue_length.mean\n",
    "en = process.statistic_wip.mean\n",
    "enq_dict[name] = enq\n",
    "en_dict[name] = en\n",
    "print(\"E[NQ]=\", round(enq, 2), sep=\"\")\n",
    "print(\"E[N]=\", round(en, 2), sep=\"\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>E[NQ]</th>\n",
       "      <th>E[N]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2 queues, random</th>\n",
       "      <td>6.539298</td>\n",
       "      <td>8.142318</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2 queues, shortest</th>\n",
       "      <td>3.249753</td>\n",
       "      <td>4.843885</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1 queue, 2 parallel operators</th>\n",
       "      <td>2.868173</td>\n",
       "      <td>4.469316</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1 queue, batch processing</th>\n",
       "      <td>4.988186</td>\n",
       "      <td>6.580458</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1 queue, fast operator</th>\n",
       "      <td>3.273463</td>\n",
       "      <td>4.074482</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  E[NQ]      E[N]\n",
       "2 queues, random               6.539298  8.142318\n",
       "2 queues, shortest             3.249753  4.843885\n",
       "1 queue, 2 parallel operators  2.868173  4.469316\n",
       "1 queue, batch processing      4.988186  6.580458\n",
       "1 queue, fast operator         3.273463  4.074482"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = pd.DataFrame({'E[NQ]': enq_dict, 'E[N]': en_dict})\n",
    "\n",
    "results"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All 5 models have the same arrival rate and the same operating capacity.\n",
    "\n",
    "In terms of queue lengths (or waiting time) the two queues with random selection is worst. Batch processing at a single station is a bit better, selecting the shortest of two queues is even more better. A single process station with a single fast operator is quite good. But a single process station with two operators is even better (in terms of queue length). Because in this case, if a client is already in process, if a second client arrives, this can be served immediately, too. In the case of the single, fast operator this second client would have to wait a short time.\n",
    "\n",
    "When considering the average number of clients in the system, the model with the fast operator is the best. In this model, the average waiting times are a bit longer than in the model with the two parallel operators at a single station. But because the processing times are significantly shorter, the average number of clients (waiting and in process) in the system is lower."
   ]
  }
 ],
 "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.11.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}