{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "*This notebook contains material from [CBE40455-2020](https://jckantor.github.io/CBE40455-2020);\n", "content is available [on Github](https://github.com/jckantor/CBE40455-2020.git).*\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "< [3.3 Agent Based Models](https://jckantor.github.io/CBE40455-2020/03.03-Agent-Based-Models.html) | [Contents](toc.html) | [3.5 Assignment](https://jckantor.github.io/CBE40455-2020/03.05-Assignment.html) >

\"Open

\"Download\"" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 1, "link": "[3.4 Modeling Events](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4-Modeling-Events)", "section": "3.4 Modeling Events" } }, "source": [ "# 3.4 Modeling Events" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.4.1 Learning Objectives](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.1-Learning-Objectives)", "section": "3.4.1 Learning Objectives" } }, "source": [ "## 3.4.1 Learning Objectives\n", "\n", "* Key performance indicators\n", "* Visualization with Gannt charts\n", "* Adding 'state' to models\n", "* Combining events with `AnyOf` and `AllOf`\n", "* Deterministic versus stochastic models" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.4.2 Example: A room full of Roombas](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.2-Example:-A-room-full-of-Roombas)", "section": "3.4.2 Example: A room full of Roombas" } }, "source": [ "## 3.4.2 Example: A room full of Roombas\n", "\n", "Let's imagine a large facility that is being cleaned by a collection of Roomba-type robotic cleaning units. Each unit is characterized by time required to charge, and an amount of time it can clean before needing to be recharged. The facility must be cleaned during a 16 hour overnight shift. On average, 3 units must be operating continuously to meet the cleaning requirements, i.e., 3 x 16 = 48 hours machine cleaning each night. We would like to determine how many charging stations will be required.\n", "\n", "| Unit | Charge Time (hrs) | Clean Time (hrs) |\n", "| :--: | :--: | :--: |\n", "| A | 1.0 | 2.5 |\n", "| B | 0.5 | 1.5 |\n", "| C | 0.8 | 2.0 |\n", "| D | 1.4 | 3.5 |\n", "| E | 0.5 | 1.2 |" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.4.3 Shared resource](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3-Shared-resource)", "section": "3.4.3 Shared resource" } }, "source": [ "## 3.4.3 Shared resource" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.1 Installation, Import, and Setup section](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.1-Installation,-Import,-and-Setup-section)", "section": "3.4.3.1 Installation, Import, and Setup section" } }, "source": [ "### 3.4.3.1 Installation, Import, and Setup section" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.1 Installation, Import, and Setup section](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.1-Installation,-Import,-and-Setup-section)", "section": "3.4.3.1 Installation, Import, and Setup section" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: simpy in /Users/jeff/opt/anaconda3/lib/python3.7/site-packages (4.0.1)\n" ] } ], "source": [ "# necessary installations\n", "!pip install simpy\n", "\n", "# import section\n", "import simpy \n", "import pandas as pd\n", "import numpy as np" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.2 Data section](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.2-Data-section)", "section": "3.4.3.2 Data section" } }, "source": [ "### 3.4.3.2 Data section" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.2 Data section](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.2-Data-section)", "section": "3.4.3.2 Data section" } }, "outputs": [ { "data": { "text/html": [ "

\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idcharge_timeclean_time
0A1.02.5
1B0.51.5
2C0.82.0
3D1.43.5
4E0.51.2
\n", "
" ], "text/plain": [ " id charge_time clean_time\n", "0 A 1.0 2.5\n", "1 B 0.5 1.5\n", "2 C 0.8 2.0\n", "3 D 1.4 3.5\n", "4 E 0.5 1.2" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# data section\n", "\n", "roomba_data = [\n", " [\"A\", 1.0, 2.5],\n", " [\"B\", 0.5, 1.5],\n", " [\"C\", 0.8, 2.0],\n", " [\"D\", 1.4, 3.5],\n", " [\"E\", 0.5, 1.2],\n", "]\n", "\n", "roomba_df = pd.DataFrame(roomba_data, columns=[\"id\", \"charge_time\", \"clean_time\"])\n", "display(roomba_df)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.3 Modeling and simulation section](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.3-Modeling-and-simulation-section)", "section": "3.4.3.3 Modeling and simulation section" } }, "source": [ "### 3.4.3.3 Modeling and simulation section\n", "\n", "The output of the modeling and simulation is a Pandas DataFrame giving a complete history of the events occuring during a simulation." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.3 Modeling and simulation section](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.3-Modeling-and-simulation-section)", "section": "3.4.3.3 Modeling and simulation section" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
ideventbeginend
0Acharging0.01.0
1Bcharging1.01.5
2Ccharging1.52.3
3Bcleaning1.53.0
4Acleaning1.03.5
\n", "
" ], "text/plain": [ " id event begin end\n", "0 A charging 0.0 1.0\n", "1 B charging 1.0 1.5\n", "2 C charging 1.5 2.3\n", "3 B cleaning 1.5 3.0\n", "4 A cleaning 1.0 3.5" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def roomba_model(id, charge_time, clean_time):\n", " while True:\n", " with chargers.request() as request:\n", " yield request\n", " tic = env.now\n", " yield env.timeout(charge_time)\n", " toc = env.now\n", " data_log.append([id, \"charging\", tic, toc])\n", " \n", " tic = env.now\n", " yield env.timeout(clean_time)\n", " toc = env.now\n", " data_log.append([id, \"cleaning\", tic, toc])\n", "\n", "data_log = []\n", "\n", "env = simpy.Environment()\n", "chargers = simpy.Resource(env, capacity=1)\n", "for r in roomba_df.index:\n", " env.process(roomba_model(roomba_df[\"id\"][r], roomba_df[\"charge_time\"][r], roomba_df[\"clean_time\"][r]))\n", "env.run(until=16)\n", "\n", "df = pd.DataFrame(data_log, columns=[\"id\", \"event\", \"begin\", \"end\"])\n", "df.head()" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.4 Key performance indictors](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.4-Key-performance-indictors)", "section": "3.4.3.4 Key performance indictors" } }, "source": [ "### 3.4.3.4 Key performance indictors\n", "\n", "Key Performance Indicators (KPI) is a commonly used termed to denote quantitative measures important to the performance of an organization, unit, or system." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.4 Key performance indictors](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.4-Key-performance-indictors)", "section": "3.4.3.4 Key performance indictors" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
time
event
charging15.4
cleaning31.3
\n", "
" ], "text/plain": [ " time\n", "event \n", "charging 15.4\n", "cleaning 31.3" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def kpi(df):\n", " df[\"time\"] = df[\"end\"] - df[\"begin\"]\n", " return pd.pivot_table(df, index=[\"event\"], values=\"time\", aggfunc={\"time\":np.sum} )\n", " \n", "kpi(df)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.5 Visualization with Gantt charts](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.5-Visualization-with-Gantt-charts)", "section": "3.4.3.5 Visualization with Gantt charts" } }, "source": [ "### 3.4.3.5 Visualization with Gantt charts\n", "\n", "Designed circa 1910-1915 by Henry Gantt, an American mechanical engineer who worked with Frederick W. Taylor, one of the first management consultants and a leader in the Efficiency Movement of the late 19th century.\n", "\n", "Gantt charts provide a convenient method to display complex schedules and the time-dependent allocation of resources." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "nbpages": { "level": 3, "link": "[3.4.3.5 Visualization with Gantt charts](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.3.5-Visualization-with-Gantt-charts)", "section": "3.4.3.5 Visualization with Gantt charts" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAroAAAEGCAYAAACKHTaKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAdmklEQVR4nO3dfZRU9Z3n8c+3u3mUJ3kQedJGhQaaBx0MMxAJbYyRHgbEDRrUJHoyHs7qMquRlWV0jzJOsmEjxzGzxBWOoyYa0ZxoVDTCSCbNzOxojAYRmwfFSIBAA6I2tCDQ9Hf/qOrZHuyHqupbdat+9X6d04fqqtv3fvt7f1X14fav7jV3FwAAABCakrgLAAAAALKBoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJDKcrmxN99886yysrKHJY0XITsdTZLeaWxsvGny5MkH4i4GAACgEOQ06JaVlT189tlnjx00aNDHJSUlnNcsRU1NTXbw4MFxdXV1D0uaE3c9AAAAhSDXR1XHDxo06DAhNz0lJSU+aNCgeiWOhAMAACAFuQ66JYTczCT7xnQPAACAFOVs6kL5kpcSAXf1nnNztU1J2rls1pu53B4AAADyQ9EfIfza175W/uijj56ZjXXfdtttQ5977rne2Vg3AAAA2pfTD6OFpqmpSe6u0tLSVh9/4IEH9ua4JAAAACQV3RHdFStWDBg9evS4ioqKcXPnzh0pSRs2bOh10UUXjRk+fPiE5qO79fX1JVOnTh09bty4saNHjx73xBNP9JOk7du3dy0vLx9/1VVXlY8ePbry/fff73rHHXcMKS8vHz958uSK2bNnj7z77rsHS//xaPGwYcMmfOc73xnavL6NGzd2l6S9e/eWTZs2bdQFF1xQ+fWvf/3coUOHTti3bx//AQEAAOikogq6b7zxRvfly5cP2bBhw7vbt2/fsnLlyl2StH///i5vvPHGtueff/69e+65Z5gk9ezZs+mll17asWXLlq0bNmx498477xze1NQkSdq1a1e3hQsXHtyxY0ftvn37ytasWXPmli1batevX//e22+/fUZb2x84cGDjli1btn77298+uGzZssGStGTJkqEzZsw4smPHjtqrr77643379nXNQSsAAACCV1RHDtetW9dn9uzZHw8ZMqRRkgYPHnxKkubMmfNJaWmpJk+e/NmhQ4e6SIlz1952223DX3vttV4lJSU6cOBA1z179pRJ0pAhQ05cdtlln0qJo8HV1dWf9OzZ03v27OmXX375J21t/7rrrvtYkqZMmXL0hRdeOFOSXn/99V7PPffcDkmaN2/e4T59+pzKZg8AAACKRVEF3bZ0797930955p64uXLlyv6HDh0q27x589Zu3br5sGHDJhw7dqxEShzt7cx2ysrKvLGx0SIoHQAAAG0oqqkLV1xxxeE1a9acWVdXVypJ+/fvb/1TZJLq6+tLBw4ceLJbt26+Zs2a3nv37m11SsGMGTMa1q1b1/fo0aNWX19fsn79+n7p1PSFL3yh4fHHH+8vSc8++2yfw4cPt1kTAAAAUldUR3QvvvjizxYtWrRv+vTpY0pKSnz8+PFH21r2pptu+qi6uvqC0aNHj5s4ceLRkSNHftbacjNmzDg6c+bM+nHjxlUOGDDgZEVFxbG+ffumPP1g2bJle+fNm3feqFGjBkyePLlh4MCBJ/v168f0BQAAgE6y5j/VZ9u/XzAix3JxwYj6+vqSvn37Nh05cqRk6tSpFQ899NAfLrnkkjZDdEvHjh2zsrIy79Kli9avX3/GwoULz922bduW1pbdtGnTwEmTJpVHWjwAAECgcnZEd+eyWbZp06adkyZN+jBX28yVb3zjG+e+9957PY4fP27z588/lGrIlaQdO3Z0veaaa85vampSly5dfOXKlTuzWCoAAEDRKKqpC9myZs2aDzL92QkTJhzfunVrq0dwAQAAkLmi+jAaAAAAigdBFwAAAEEi6AIAACBIuZuju7SvT5KkX+jcnG1TkpbWZ/2sCwAAAMg/RX9E9/bbbx969913D456vRdddNGYqNcJAACA1BV90M2WjRs3bou7BgAAgGJWdEF3xYoVA0aPHj2uoqJi3Ny5c0e2fKy2trbb9OnTR1VWVo6dPHlyxcaNG7tL0pNPPtl34sSJY8aOHTtu2rRpo3fv3l0mJY4GX3311eVTpkypGD58+ITvfve7ZzWvq2fPnhdJ0osvvth7ypQpFTNnzjxv5MiRlXPmzBnZ1NQkSXr66af7jhw5srKysnLsjTfeOOLSSy+9IGeNAAAACFxRBd033nij+/Lly4ds2LDh3e3bt29ZuXLlrpaP33TTTec++OCDu2pra7fed999e26++eZzJOnyyy9veOutt7Zt3bp1y7x58z669957z27+mR07dnTfsGHDu7/97W+3Ll++fOjx48ft9O1u3bq1x49+9KPdO3bsqN21a1e3V155pdfRo0ft1ltvPffll19+r7a2duuhQ4c4pzEAAECEiipcrVu3rs/s2bM/HjJkSKMkDR48+FTzY/X19SUbN27sdfXVV5/ffN+JEydMkj744IOuc+fOHX7w4MEuJ06cKBkxYsTx5mW++tWvftKjRw/v0aNHY//+/U/u2bOn7Pzzzz/ZcrsTJkz4tPm+ysrKo++//37X3r17nxoxYsTxMWPGnJCk+fPnf/Twww8Pym4HAAAAikdRBd32nDp1Sr17927ctm3b565StnDhwnNuvfXWuuuvv77+xRdf7H3vvfcObX6sW7du3ny7tLRUjY2Nnzuim8oyAAAAiFZRTV244oorDq9Zs+bMurq6Uknav39/afNj/fv3bxo+fPiJRx555ExJampq0quvvtpDko4cOVJ6zjnnnJSkxx57bEAUtUycOPGz3bt3d9u+fXtXSXr66af7R7FeAAAAJBRV0L344os/W7Ro0b7p06ePqaioGHfLLbeMaPn46tWrf//oo48OrKioGDdq1KjKZ555pp8k3XXXXXuvvfba8ysrK8cOGDCgMYpaevXq5ffff/8fZs6cOaqysnJsr169TvXu3ftUxz8JAACAVJi7d7xUFJb2zdGGTt9u/l4wor6+vqRv375NTU1N+ta3vnXOqFGjPrvnnnsOtLX8pk2bBk6aNKk8hyUCAAAUrBxeGa3eNm3atHPSpEkf5mybee6BBx4YuHr16oEnT560ysrKo7fffju9AQAAiEjujuhKIuh2Dkd0AQAAUpfrObpNTU1NnHEgA8m+NcVdBwAAQKHIddB95+DBg30Ju+lpamqygwcP9pX0Tty1AAAAFIqcnke3sbHxprq6uofr6urGq8jO+NBJTZLeaWxsvCnuQgAAAApFTufoAgAAALnCUVUAAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAUODMbKeZfSXuOgAg3xB0ARQ9M5tvZr8xs0/N7EDy9i1mlvWL26QSUs2sj5k9YGa7zKzBzN5Pfj8wSzXVmBnn7QZQ8Ai6AIqamS2S9ENJ90k6W9JgSf9Z0hcldY2xNEmSmXWV9CtJlZJmSuojaaqkQ5KmRLwtMzPeFwAEgxc0AEXLzPpKulfSLe7+c3c/4gkb3f16dz+eXG6WmW00s8NmttvMlrZYR7mZuZndkDzi+qGZ3dXi8aVm9jMz+4mZHTGzWjO7OPnY45LOkbQmeaR2cStlfiu5zFXuvsXdm9z9gLv/rbv/ssVyF5rZ22ZWb2ZPm1n35DbONLMXzeygmX2cvD28RX01ZvY9M/u/ko5KelzSdEkrkjWtiKTZABADgi6AYjZVUjdJz3ew3KdKBM5+kmZJutnM5p62zCWSKiRdJuluMxvb4rE5kp5K/vwLklZIkrt/U9IuSbPdvZe7/6CVbX9F0lp3b+igxmuUOOI7UtJESTcm7y+R9Kikc5UIzMeat9/CNyUtkNQ7+XP/ImlhsqaFHWwXAPIWQRdAMRso6UN3b2y+w8z+zcw+MbNjZvYlSXL3GnffnDya+rak1ZJmnLauv3H3Y+6+SdImSZNaPPav7v5Ldz+lxBHTSUrdAEn7Ulju7919r7t/JGmNpAuTtR9y92fc/ai7H5H0vVZqf8zda9290d1PplEbAOQ1gi6AYnZI0kAzK2u+w92nuXu/5GMlkmRmf2pmv07++b9eiTm8p38QrK7F7aOSerXzWPeW20yhxiEpLNfq9s2sp5mtNLM/mNlhSf8sqZ+ZlbZYfneKtQBAQSHoAihmr0o6LunKDpZ7UokpByPcva+khyRFdUYG7+Dx9ZKuMLMzMlz/IiWmVPypu/eR9KXk/S3rP72GjmoCgIJA0AVQtNz9E0l/I+lBM5tnZr3NrMTMLpTUMlj2lvSRu39mZlMkXRdhGfslndfO448rccT1GTMbk6xvgJndaWZ/nsL6eysxL/cTM+sv6Z4IagKAgkDQBVDUkh8Au13SYiUC3n5JKyX9d0n/llzsFkn3mtkRSXdL+lmEJXxf0v9Izgv+b63Ud1yJD6Rtk/SKpMOSXldi6sRvUlj/A5J6SPpQ0muS1qbwMz+UNC95loa/T+m3AIA8ZO78hQoAAADh4YguAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBymbQ9Ti+Xn311Vi2W+hf9I2+0bvC+KJv9I2+5f8XfYulb60K7oju8ePH4y6hING3zNC3zNG7zNC3zNC3zNC3zNC3zGSjb6leghIoGuVLXkrvB9a2vfzO7lFeVyDHltbHXUHK0t5nHcjn/VYlSTVtPFhA+yzbWh0T7TxX25PP46FDp42JjJ4rbfQtpL4gXMEd0QUAAACkNI7omtkpSZtb3PWUuy+LviQAAACg89KZunDM3S/MWiUAAABAhJi6AAAAgCClc0S3h5m91eL777v70y0XMLMFkhZI0uLFi1VdXR1BielpaGhQTU1Nzrdb6OgbTpft8cCYix79xOkYE63j9S0/daZvVVVVrd4f6dQFd18laVXzt2msOzI1NTVt/rJoG31rIcNPZocm2+Mh0jHHPpOU/X1WUBgTkloZE/RFUoG9vhWRbPSNqQsAAAAIEkEXAAAAQerMHN217r4k6oIAAACAKKQcdN29NJuFAPli57JZKS/b8Xwirr6TC+nss9Tk735j7l9qTh8Tnetb/o6HdKX7XGm/b+H0BeFi6gIAAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkMriLgCFqXzJS3GXkDU7u1+X8rJVklSTpUICVyUVZu+W1qe1eFaeK2vz4/mXznMlblVSYY63mFVJGfet/LMnoyskz+xcNivuEpAijugCAAAgSB0e0TWzU5I2S+oiqVHSTyT9nbs3Zbk2AAAAIGOpTF045u4XSpKZnSXpSUl9JN2TzcIAAACAzkhr6oK7H5C0QNJCM7PslAQAAAB0XtofRnP335tZqaSzJO1v+ZiZLVAiCGvx4sWqrq6OpMh0NDQ0qKamJufbLXT0DUgNzxMAHb0O8J6amc70raqqqtX7Iz3rgruvkrSq+dso152qmpqaNn9ZtC3tvuXJp76BXEv79YXnChCcjl4HyCKZyUbf0j7rgpmdJ+mUpAORVgIAAABEKK2ga2aDJD0kaYW7x3LEFgAAAEhFKlMXepjZW/r/pxd7XNL9Wa0KAAAA6KQOg667l+aiEBSWsK8Kk/qVr5iHlbli6V3Uz5X86lt6V4mLU371rXB0pm87I60EyAxXRgMAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIUlncBSBz5UteinaFa1Nf387u10W77QJVJUk1afzA0vqs1JEPMhqPaYy59hTTeKyS0htz7Ql4PEYp8tfaNMQ9tquk6MZbLhXx2I51vC6bFdu228IRXQAAAAQp5aBrZmeb2VNm9r6ZvWlmvzSz0dksDgAAAMhUSlMXzMwk/ULSj919fvK+SZIGS3o3e+UBAAAAmUl1ju6lkk66+0PNd7j7puyUBAAAAHReqkF3vKQ3O1rIzBZIWiBJixcvVnV1dSdKy0xDQ4Nqampyvl0gFYxN5JNiGo+8NxSXuPd1sY63zv7OnelbVVVVq/dHetYFd18laVXzt1GuO1U1NTVt/rLBiegT68idoMcm47HgBD0eT9Op9wbGdsGJe2zHmkViHK+d/Z2z0bdUP4xWK2lypFsGAAAAsijVoPtPkrolpyZIksxsoplNz05ZAAAAQOekFHTd3SVdJekrydOL1Ur6vqS6bBYHAAAAZCrlObruvlfSNVmsBWmK8gok6c+LKd6rzrRUVHPCO5DueIy2d8UzHhlzuRfv1Z7iHduMt8KTj1cnixNXRgMAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIUlncBRST8iUvRbq+nd2vi2xdVZJUE9nqorW0Pu4KMpbP+zxuVVLbYy7mfR7lfot6n1VJPFeLSNyvIVVS/o639jAWkcQRXQAAAAQppaBrZqfM7C0z22RmvzOzadkuDAAAAOiMVKcuHHP3CyXJzK6Q9H1JM7JWFQAAANBJmUxd6CPp46gLAQAAAKKU6hHdHmb2lqTukoZI+nJrC5nZAkkLJGnx4sWqrq6OpMh0NDQ0qKamJufbRfbk8/5kvGUHPS1M+bzfeK4Wl7j3NeMtM53pW1VVVav3ZzJ1Yaqkn5jZeHf3lgu5+ypJq5q/zajSTqqpqWnzl43d2mg/PVss8nZ/KoXxxj7PSOz7nP2Wkdj3Wzvy+r2hPYzFjMS9rwt2vMUsG31Le+qCu78qaaCkQZFWAgAAAEQo7aBrZmMklUo6FH05AAAAQDTSnaMrSSbpBnc/laWaAAAAgE5LKei6e2m2CykGO5fNiniN0V35hflE2ZHP+zxu+Tzmot1v0e6zfO4bohf3awjjDYWOK6MBAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABMncPVvrztqK21O+5KU4NpuSnd2vi7sESNLS+shWVVNTo6qqqsjW1xHGN9oV4dhOBeMR7crxeMylvB77y2bFXULGOvmeaq3dyRFdAAAABCnloGtmc83MzWxMNgsCAAAAopDOEd1rJf1r8l8AAAAgr6UUdM2sl6RLJP2lpPlZrQgAAACIQFmKy10paa27v2tmh8xssru/efpCZrZA0gJJWrx4saqrqyMsFYhGTU1NZOtqaGiIdH1AZzAWkU8Yj/Eo5L535j21rQ+xpRp0r5X0w+Ttp5Lffy7ouvsqSauav02rwqiszd9PQiI/RHmWhFyfdYHxjfbkdCxKjEe0K+fjMZfyeOwXct+z8Z7aYdA1s/6Svixpgpm5pFJJbmZ3eBbPTQYAAAB0RipzdOdJetzdz3X3cncfIekDSdOzWxoAAACQuVSC7rWSfnHafc+Isy8AAAAgjwV3ZbScz5kMBH3LDH3LHL3LDH3LDH3LDH3LDH3LDFdGAwAAAFJE0AUAAECQsjl1IRZmtiB5mjOkgb5lhr5ljt5lhr5lhr5lhr5lhr5lJht9C/GI7oK4CyhQ9C0z9C1z9C4z9C0z9C0z9C0z9C0zkfctxKALAAAAEHQBAAAQphCDLnNiMkPfMkPfMkfvMkPfMkPfMkPfMkPfMhN534L7MBoAAAAghXlEFwAAACDoAgAAIExBBV0zm2lm281sh5ktibueQmBmI8zs12a2xcxqzezWuGsqJGZWamYbzezFuGspFGbWz8x+bmbbzGyrmU2Nu6ZCYGbfST5H3zGz1WbWPe6a8pGZPWJmB8zsnRb39TezV8zsveS/Z8ZZYz5qo2/3JZ+nb5vZL8ysX5w15qPW+tbisUVm5mY2MI7a8llbfTOzv0qOuVoz+0EU2wom6JpZqaQfSaqWNE7StWY2Lt6qCkKjpEXuPk7Sn0n6L/QtLbdK2hp3EQXmh5LWuvsYSZNE/zpkZsMk/VdJF7v7eEmlkubHW1XeekzSzNPuWyLpV+4+StKvkt/jP3pMn+/bK5LGu/tESe9K+utcF1UAHtPn+yYzGyHpq5J25bqgAvGYTuubmV0q6UpJk9y9UtLyKDYUTNCVNEXSDnf/vbufkPSUEg1DO9x9n7v/Lnn7iBKhY1i8VRUGMxsuaZakh+OupVCYWV9JX5L0D5Lk7ifc/ZN4qyoYZZJ6mFmZpJ6S9sZcT15y93+W9NFpd18p6cfJ2z+WNDenRRWA1vrm7v/o7o3Jb1+TNDznheW5NsabJP2dpMWS+MR/K9ro282Slrn78eQyB6LYVkhBd5ik3S2+3yMCW1rMrFzSRZJ+E28lBeMBJV7ImuIupICMlHRQ0qPJKR8Pm9kZcReV79z9j0oc3dglaZ+kenf/x3irKiiD3X1f8nadpMFxFlOgvi3p5biLKARmdqWkP7r7prhrKTCjJU03s9+Y2QYz+0IUKw0p6KITzKyXpGck3ebuh+OuJ9+Z2V9IOuDub8ZdS4Epk/Qnkv6Pu18k6VPxZ+QOJeeUXqnEfxSGSjrDzL4Rb1WFyRPn1OQoWxrM7C4lprn9NO5a8p2Z9ZR0p6S7466lAJVJ6q/ENMo7JP3MzKyzKw0p6P5R0ogW3w9P3ocOmFkXJULuT9392bjrKRBflDTHzHYqMU3my2b2RLwlFYQ9kva4e/NfDX6uRPBF+74i6QN3P+juJyU9K2lazDUVkv1mNkSSkv9G8ifRYmBmN0r6C0nXOyfeT8X5SvyHdFPy/WG4pN+Z2dmxVlUY9kh61hNeV+KvpZ3+IF9IQfe3kkaZ2Ugz66rEBzVeiLmmvJf839I/SNrq7vfHXU+hcPe/dvfh7l6uxFj7J3fnCFsH3L1O0m4zq0jedZmkLTGWVCh2SfozM+uZfM5eJj7El44XJN2QvH2DpOdjrKVgmNlMJaZnzXH3o3HXUwjcfbO7n+Xu5cn3hz2S/iT52of2PSfpUkkys9GSukr6sLMrDSboJifML5S0Tok3gJ+5e228VRWEL0r6phJHJN9Kfv153EUhaH8l6adm9rakCyX9z5jryXvJI+A/l/Q7SZuVeO3mEqOtMLPVkl6VVGFme8zsLyUtk3S5mb2nxNHxZXHWmI/a6NsKSb0lvZJ8b3go1iLzUBt9Qwfa6Nsjks5LnnLsKUk3RPFXBC4BDAAAgCAFc0QXAAAAaImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AJAlZjagxWn76szsj8nbDWb2YNz1AUDoOL0YAOSAmS2V1ODuy+OuBQCKBUd0ASDHzKzKzF5M3l5qZj82s38xsz+Y2X8ysx+Y2WYzW5u8RLfMbLKZbTCzN81sXfMlbQEAbSPoAkD8zpf0ZUlzJD0h6dfuPkHSMUmzkmH3f0ua5+6TlbiC0PfiKhYACkVZ3AUAAPSyu580s82SSiWtTd6/WVK5pApJ45W4FKuSy+yLoU4AKCgEXQCI33FJcvcmMzvZ4vruTUq8TpukWnefGleBAFCImLoAAPlvu6RBZjZVksysi5lVxlwTAOQ9gi4A5Dl3PyFpnqT/ZWabJL0laVq8VQFA/uP0YgAAAAgSR3QBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABOn/AYkrXJHm8JmbAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "from matplotlib.lines import Line2D\n", "\n", "def gantt(df, lw=10):\n", " \n", " # create sorted lists of the unique ids and events appearing in the data log\n", " ids = sorted(list(set(df[\"id\"])))\n", " events = sorted(list(set(df[\"event\"])))\n", " \n", " # create list of unique colors for each event\n", " colors = [f\"C{i}\" for i in range(len(events))]\n", " \n", " # create plot window\n", " fig, ax = plt.subplots(1, 1, figsize=(12, 3))\n", " \n", " # for each event and id, find entries in the data log and plot the begin and end points\n", " for i, event in enumerate(events):\n", " for j, id in enumerate(ids): \n", " for k in df[(df[\"id\"]==id) & (df[\"event\"]==event)].index:\n", " ax.plot([df[\"begin\"][k], df[\"end\"][k]], [j,j], \n", " colors[i], solid_capstyle=\"butt\", lw=lw)\n", " \n", " # create legend\n", " lines = [Line2D([0], [0], lw=lw, color=colors[i]) for i in range(len(events))]\n", " ax.legend(lines, events, bbox_to_anchor=(0.0, 1.1), loc=\"lower left\")\n", " \n", " # annotate the axes\n", " ax.set_yticks(range(len(ids)))\n", " ax.set_yticklabels(ids)\n", " ax.grid(True)\n", " ax.set_xlabel(\"Time\")\n", " ax.set_title(\"Gannt Chart\")\n", " for sp in ['top', 'bottom', 'right', 'left']:\n", " ax.spines[sp].set_visible(False)\n", " \n", "gantt(df)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.4.4 Assignment Review](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.4-Assignment-Review)", "section": "3.4.4 Assignment Review" } }, "source": [ "## 3.4.4 Assignment Review" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.4.4.1 Exercise 1. ](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.4.1-Exercise-1.)", "section": "3.4.4.1 Exercise 1. " } }, "source": [ "### 3.4.4.1 Exercise 1. \n", "\n", "Answer the question posed above: How many charging stations are needed to provide 48 hours cleaning services in the overnight shift?" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 4, "link": "[3.4.4.1.1 Solution](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.4.1.1-Solution)", "section": "3.4.4.1.1 Solution" } }, "source": [ "#### 3.4.4.1.1 Solution" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "nbpages": { "level": 4, "link": "[3.4.4.1.1 Solution](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.4.1.1-Solution)", "section": "3.4.4.1.1 Solution" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
time
event
charging20.2
cleaning49.4
\n", "
" ], "text/plain": [ " time\n", "event \n", "charging 20.2\n", "cleaning 49.4" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAroAAAEGCAYAAACKHTaKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAdgElEQVR4nO3de5RU5Znv8d/T3VzlJheRmzYqNNBcdDDMYEJoY4z0MCCeoEFNoivjYo0e5mjkyGH0LGU8yQknshwzh3iE5aiJBjQrGhWNMJJJMzeN0SBic1GMHSDQgKgNLdemn/NHVSdt291UdVfV3vXW97MWi6pdu/d+eGpX1Y+339rb3F0AAABAaIqiLgAAAADIBoIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBKsnlzt54442zSkpKHpY0XoTsdDRKeruhoeGmyZMn74+6GAAAgHyQ06BbUlLy8Nlnnz120KBBHxUVFXFesxQ1NjbagQMHxtXW1j4saXbU9QAAAOSDXI+qjh80aNAhQm56ioqKfNCgQXVKjIQDAAAgBbkOukWE3I5J9o3pHgAAACnK2dSF0sUvJgLu6t3n5mqfklSzdOYbudwfAAAA4qHgRwi/+tWvlj766KNnZmPbt91229Bnn322dza2DQAAgPbl9MtooWlsbJS7q7i4uNXHH3jggT05LgkAAABJBTeiu3z58gGjR48eV1ZWNm7OnDkjJWnDhg29LrroojHDhw+f0DS6W1dXVzR16tTR48aNGzt69OhxTzzxRD9J2r59e9fS0tLxV111Veno0aPL33vvva533HHHkNLS0vGTJ08umzVr1si77757sPTp0eJhw4ZN+Pa3vz20aXsbN27sLkl79uwpueSSS0ZdcMEF5V/72tfOHTp06IS9e/fyHxAAAIBOKqig+/rrr3dftmzZkA0bNryzffv2LStWrNgpSfv27evy+uuvb3vuuefeveeee4ZJUs+ePRtffPHFHVu2bNm6YcOGd+68887hjY2NkqSdO3d2W7BgwYEdO3ZU7927t2TNmjVnbtmypXr9+vXvvvXWW2e0tf+BAwc2bNmyZeu3vvWtA0uXLh0sSYsXLx46ffr0wzt27Ki++uqrP9q7d2/XHLQCAAAgeAU1crhu3bo+s2bN+mjIkCENkjR48OBTkjR79uyPi4uLNXny5GMHDx7sIiXOXXvbbbcNf/XVV3sVFRVp//79XXfv3l0iSUOGDDlx2WWXfSIlRoMrKys/7tmzp/fs2dMvv/zyj9va/3XXXfeRJE2ZMuXI888/f6Ykvfbaa72effbZHZI0d+7cQ3369DmVzR4AAAAUioIKum3p3r37H0955p64uWLFiv4HDx4s2bx589Zu3br5sGHDJhw9erRISoz2dmY/JSUl3tDQYBkoHQAAAG0oqKkLV1xxxaE1a9acWVtbWyxJ+/bta/1bZJLq6uqKBw4ceLJbt26+Zs2a3nv27Gl1SsH06dPr161b1/fIkSNWV1dXtH79+n7p1PS5z32u/vHHH+8vSc8880yfQ4cOtVkTAAAAUldQI7oXX3zxsYULF+6dNm3amKKiIh8/fvyRtta96aabPqysrLxg9OjR4yZOnHhk5MiRx1pbb/r06UdmzJhRN27cuPIBAwacLCsrO9q3b9+Upx8sXbp0z9y5c88bNWrUgMmTJ9cPHDjwZL9+/Zi+AAAA0EnW9Kv6bPvjBSNyLBcXjKirqyvq27dv4+HDh4umTp1a9tBDD/3+C1/4QpshurmjR49aSUmJd+nSRevXrz9jwYIF527btm1La+tu2rRp4KRJk0ozWjwAAECgcjaiW7N0pm3atKlm0qRJH+Rqn7ny9a9//dx33323x/Hjx23evHkHUw25krRjx46u11xzzfmNjY3q0qWLr1ixoiaLpQIAABSMgpq6kC1r1qx5v6M/O2HChONbt25tdQQXAAAAHVdQX0YDAABA4SDoAgAAIEgEXQAAAAQpd3N0l/T1SZL0c52bs31K0pK6rJ91AQAAAPFT8CO6t99++9C77757cKa3e9FFF43J9DYBAACQuoIPutmycePGbVHXAAAAUMgKLuguX758wOjRo8eVlZWNmzNnzsjmj1VXV3ebNm3aqPLy8rGTJ08u27hxY3dJWrVqVd+JEyeOGTt27LhLLrlk9K5du0qkxGjw1VdfXTplypSy4cOHT/jOd75zVtO2evbseZEkvfDCC72nTJlSNmPGjPNGjhxZPnv27JGNjY2SpKeeeqrvyJEjy8vLy8feeOONIy699NILctYIAACAwBVU0H399de7L1u2bMiGDRve2b59+5YVK1bsbP74TTfddO6DDz64s7q6eut99923++abbz5Hki6//PL6N998c9vWrVu3zJ0798N777337Kaf2bFjR/cNGza885vf/GbrsmXLhh4/ftxa7nfr1q09fvjDH+7asWNH9c6dO7u9/PLLvY4cOWK33nrruS+99NK71dXVWw8ePMg5jQEAADKooMLVunXr+syaNeujIUOGNEjS4MGDTzU9VldXV7Rx48ZeV1999flNy06cOGGS9P7773edM2fO8AMHDnQ5ceJE0YgRI443rfOVr3zl4x49eniPHj0a+vfvf3L37t0l559//snm+50wYcInTcvKy8uPvPfee1179+59asSIEcfHjBlzQpLmzZv34cMPPzwoux0AAAAoHAUVdNtz6tQp9e7du2Hbtm2fuUrZggULzrn11ltrr7/++roXXnih97333ju06bFu3bp50+3i4mI1NDR8ZkQ3lXUAAACQWQU1deGKK644tGbNmjNra2uLJWnfvn3FTY/179+/cfjw4SceeeSRMyWpsbFRr7zySg9JOnz4cPE555xzUpIee+yxAZmoZeLEicd27drVbfv27V0l6amnnuqfie0CAAAgoaCC7sUXX3xs4cKFe6dNmzamrKxs3C233DKi+eOrV6/+3aOPPjqwrKxs3KhRo8qffvrpfpJ011137bn22mvPLy8vHztgwICGTNTSq1cvv//++38/Y8aMUeXl5WN79ep1qnfv3qdO/5MAAABIhbn76dfKhCV9c7SjlvuN7wUj6urqivr27dvY2Niob37zm+eMGjXq2D333LO/rfU3bdo0cNKkSaU5LBEAACBv5fDKaHW2adOmmkmTJn2Qs33G3AMPPDBw9erVA0+ePGnl5eVHbr/9dnoDAACQIbkb0ZVE0O0cRnQBAABSl+s5uo2NjY2ccaADkn1rjLoOAACAfJHroPv2gQMH+hJ209PY2GgHDhzoK+ntqGsBAADIFzk9j25DQ8NNtbW1D9fW1o5XgZ3xoZMaJb3d0NBwU9SFAAAA5IucztEFAAAAcoVRVQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugCQ58ysxsy+HHUdABA3BF0ABc/M5pnZr83sEzPbn7x9i5ll/eI2qYRUM+tjZg+Y2U4zqzez95L3B2appioz47zdAPIeQRdAQTOzhZJ+IOk+SWdLGizpbyR9XlLXCEuTJJlZV0m/lFQuaYakPpKmSjooaUqG92VmxucCgGDwhgagYJlZX0n3SrrF3X/m7oc9YaO7X+/ux5PrzTSzjWZ2yMx2mdmSZtsoNTM3sxuSI64fmNldzR5fYmY/NbMfm9lhM6s2s4uTjz0u6RxJa5IjtYtaKfObyXWucvct7t7o7vvd/X+5+y+arXehmb1lZnVm9pSZdU/u40wze8HMDpjZR8nbw5vVV2Vm3zWz/5B0RNLjkqZJWp6saXlGmg0AESDoAihkUyV1k/Tcadb7RInA2U/STEk3m9mcFut8QVKZpMsk3W1mY5s9NlvSk8mff17Sckly929I2ilplrv3cvfvt7LvL0ta6+71p6nxGiVGfEdKmijpxuTyIkmPSjpXicB8tGn/zXxD0nxJvZM/92+SFiRrWnCa/QJAbBF0ARSygZI+cPeGpgVm9p9m9rGZHTWzL0qSu1e5++bkaOpbklZLmt5iW3/v7kfdfZOkTZImNXvs3939F+5+SokR00lK3QBJe1NY7x/dfY+7fyhpjaQLk7UfdPen3f2Iux+W9N1Wan/M3avdvcHdT6ZRGwDEGkEXQCE7KGmgmZU0LXD3S9y9X/KxIkkysz83s18lf/1fp8Qc3pZfBKttdvuIpF7tPNa9+T5TqHFICuu1un8z62lmK8zs92Z2SNK/SupnZsXN1t+VYi0AkFcIugAK2SuSjku68jTrrVJiysEId+8r6SFJmTojg5/m8fWSrjCzMzq4/YVKTKn4c3fvI+mLyeXN629Zw+lqAoC8QNAFULDc/WNJfy/pQTOba2a9zazIzC6U1DxY9pb0obsfM7Mpkq7LYBn7JJ3XzuOPKzHi+rSZjUnWN8DM7jSzv0xh+72VmJf7sZn1l3RPBmoCgLxA0AVQ0JJfALtd0iIlAt4+SSsk/Q9J/5lc7RZJ95rZYUl3S/ppBkv4nqT/mZwX/N9bqe+4El9I2ybpZUmHJL2mxNSJX6ew/Qck9ZD0gaRXJa1N4Wd+IGlu8iwN/5jSvwIAYsjc+Q0VAAAAwsOILgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQcpm0PUo/rzyyiuR7Def/9Azeka/4veHntEvehavP/Qr9j1rVXAjusePH4+6hLxDz9JHz9JDv9JHz9JDv9JHz9JDv9IXh56leglK5Fjp4hcztq2a7u2f275CkqoytruMKT22KmPbOl0P0lUh5aRnce5BOiqkjvdrSV3G6ugsXpfq1PORzf5VSPHsV0sxOp7bk8nnSor2/aczPvMevLbjfcnXHuTLMduW4EZ0AQAAACmNEV0zOyVpc7NFT7r70syXBAAAAHReOlMXjrr7hVmrBAAAAMggpi4AAAAgSOmM6PYwszeb3f+euz/VfAUzmy9pviQtWrRIlZWVGSgxPfX19aqqqsr5fgFkB6/neOH56Jw49Y/PS6SiM8dILo+xioqKVpdndOqCu6+UtLLpbhrbzpiqqqo2/7F5pRPf7ARCEqvXM6/Lzj0f9C9Wx3O7n5c8V0jqzDEbh0zG1AUAAAAEiaALAACAIHVmju5ad1+c6YIAAACATEg56Lp7cTYLwafVLJ2Zwa21f1WTOMyhaU1NRreW2Su75KpnNRndWnRXt4nrMZYuXpedk83+hdivKGX2uZKifP/pjJpmtzt/jOVnD/IdUxcAAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgmTunq1tZ23D7amqqlJFRUUUuz6t0sUvRl1CxtV0vy7qEhBDpcdWRV1CVnC8ozUhHu8c62jVkrq0Vs9xJrPWFjKiCwAAgCCVnG4FMzslabOkLpIaJP1Y0j+4e2OWawMAAAA67LRBV9JRd79QkszsLEmrJPWRdE82CwMAAAA6I62pC+6+X9J8SQvMrNW5EAAAAEAcpDKi+ynu/jszK5Z0lqR9zR8zs/lKBGEtWrRIlZWVGSkyHfX19aqqqsr5fgEAAEKWbr7KZSZr60tvaQfd9rj7Skkrm+5mctupivNZF7Q2vLMuAACAwpBuvopDJkv7rAtmdp6kU5L2Z74cAAAAIDPSCrpmNkjSQ5KWexZPwAsAAAB0VipTF3qY2Zv60+nFHpd0f1arAgAAADrptEHX3YtzUUghqFk6M+oSWtW5OTTpXSUlFHGYdxRnNS3uh9Ov3B3v4fQsN6LsV00ke+289ntWmO/t7eE1mZ+4MhoAAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkEqiLiDuShe/GMl+a7pfl7N9VUhSVc52lzWlx1bldodrE8dGLp+rfFUhfeoYy/lz1Uy+PF8VUixel/nyXFVIsehXpJbU5WxXUX02StG9hiuk/DzGcnhcxBEjugAAAAhSykHXzM42syfN7D0ze8PMfmFmo7NZHAAAANBRKU1dMDOT9HNJP3L3ecllkyQNlvRO9soDAAAAOibVObqXSjrp7g81LXD3TdkpCQAAAOi8VIPueElvnG4lM5svab4kLVq0SJWVlZ0orWPq6+tVVVWV8/0CABCldD/7+LwsDFE+x7k8xioqKlpdntGzLrj7Skkrm+5mctupqqqqavMf2yFro/tmKQAAqUr3s69Tn5d8NuaNjGaiNGU8k3VAql9Gq5Y0OZuFAAAAAJmUatD9F0ndklMTJElmNtHMpmWnLAAAAKBzUgq67u6SrpL05eTpxaolfU9SbTaLAwAAADoq5Tm67r5H0jVZrCWWapbOjGjPubuSSRzm0GRCTQ739emeFfZVZ1LR8hiriawSKV+er7i8Lmsi3Xvqz1Vc+lUoovtslKJ6DXOM5SeujAYAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJHP3bG07axtuT+niFzO6vZru12V0e3FUemxVxrZVCP2SpKqK51RRUSEps8dcofRPS+oi2zXPV3p4f+iACI/v9nDsp4/jP00tjv2qqqo/flbmgLW2kBFdAAAABCmloGtmp8zsTTPbZGa/NbNLsl0YAAAA0BklKa531N0vlCQzu0LS9yRNz1pVAAAAQCd1ZOpCH0kfZboQAAAAIJNSHdHtYWZvSuouaYikL7W2kpnNlzRfkhYtWqTKysqMFAnETX19vaqqqqIuI2/RO4SM4xuFquWxn8vPyra+9NaRqQtTJf3YzMZ7i1M2uPtKSSub7nas1E5am9mzLgCt6dWr159eVBxzacvht3A/i+cLWRbp8d0ejn1kWctjP8dnXWhV2lMX3P0VSQMlDcp8OQAAAEBmpB10zWyMpGJJBzNfDgAAAJAZ6c7RlRIn5L3B3U9lqSYAAACg04K7Mloc5oPkG3qWPnqWHvqVPnqWHvqVPnqWHvqVPq6MBgAAAGQJQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBMnfP1raztuH2lC5+MYrdpqSm+3VRl1CwSo+tirqENnFcRGhJXad+PK7vNxxT0Yrr+w3HRbRie1wsnZm1bVdVVamioiJr22/BWlvIiC4AAACClHLQNbM5ZuZmNiabBQEAAACZkM6I7rWS/j35NwAAABBrKQVdM+sl6QuS/lrSvKxWBAAAAGRASYrrXSlprbu/Y2YHzWyyu7/RciUzmy9pviQtWrRIlZWVGSwVADKrqqoq6hIAIFLZfB+sr6/P2ftsW196SzXoXivpB8nbTybvfybouvtKSSub7qZVYaasjee3oAHET6e/Dcz7DYA8l82zIuT4rAutOm3QNbP+kr4kaYKZuaRiSW5md3gWz00GAAAAdEYqc3TnSnrc3c9191J3HyHpfUnTslsaAAAA0HGpBN1rJf28xbKnxdkXAAAAEGPBXRktDvNB8g09Sx89Sw/9Sh89Sw/9Sh89Sw/9Sh9XRgMAAACyhKALAACAIGVz6kIkzGx+8jRnSBE9Sx89Sw/9Sh89Sw/9Sh89Sw/9Sl8cehbiiO78qAvIQ/QsffQsPfQrffQsPfQrffQsPfQrfZH3LMSgCwAAABB0AQAAEKYQgy7zZ9JHz9JHz9JDv9JHz9JDv9JHz9JDv9IXec+C+zIaAAAAIIU5ogsAAAAQdAEAABCmoIKumc0ws+1mtsPMFkddT9yZ2Qgz+5WZbTGzajO7Neqa8oGZFZvZRjN7Iepa8oGZ9TOzn5nZNjPbamZTo64pzszs28nX49tmttrMukddU9yY2SNmtt/M3m62rL+ZvWxm7yb/PjPKGuOmjZ7dl3xdvmVmPzezflHWGCet9avZYwvNzM1sYBS1xVVbPTOzv00eZ9Vm9v1c1xVM0DWzYkk/lFQpaZyka81sXLRVxV6DpIXuPk7SX0j6r/QsJbdK2hp1EXnkB5LWuvsYSZNE79pkZsMk/TdJF7v7eEnFkuZFW1UsPSZpRotliyX90t1HSfpl8j7+5DF9tmcvSxrv7hMlvSPp73JdVIw9ps/2S2Y2QtJXJO3MdUF54DG16JmZXSrpSkmT3L1c0rJcFxVM0JU0RdIOd/+du5+Q9KQSzUUb3H2vu/82efuwEgFkWLRVxZuZDZc0U9LDUdeSD8ysr6QvSvonSXL3E+7+cbRVxV6JpB5mViKpp6Q9EdcTO+7+r5I+bLH4Skk/St7+kaQ5OS0q5lrrmbv/s7s3JO++Kml4zguLqTaOMUn6B0mLJPFN/hba6NnNkpa6+/HkOvtzXVdIQXeYpF3N7u8WoS1lZlYq6SJJv462kth7QIk3ucaoC8kTIyUdkPRocrrHw2Z2RtRFxZW7/0GJEY+dkvZKqnP3f462qrwx2N33Jm/XShocZTF56FuSXoq6iDgzsysl/cHdN0VdSx4ZLWmamf3azDaY2edyXUBIQRcdZGa9JD0t6TZ3PxR1PXFlZn8lab+7vxF1LXmkRNKfSfp/7n6RpE/Er5TblJxXeqUS/0EYKukMM/t6tFXlH0+cN5MRtxSZ2V1KTGX7SdS1xJWZ9ZR0p6S7o64lz5RI6q/E9Mg7JP3UzCyXBYQUdP8gaUSz+8OTy9AOM+uiRMj9ibs/E3U9Mfd5SbPNrEaJqTFfMrMnoi0p9nZL2u3uTb8p+JkSwRet+7Kk9939gLuflPSMpEsirilf7DOzIZKU/DvnvyLNR2Z2o6S/knS9c2L99pyvxH9ANyU/A4ZL+q2ZnR1pVfG3W9IznvCaEr8NzemX+EIKur+RNMrMRppZVyW+wPF8xDXFWvJ/Vf8kaau73x91PXHn7n/n7sPdvVSJ4+tf3J3Rtna4e62kXWZWllx0maQtEZYUdzsl/YWZ9Uy+Pi8TX95L1fOSbkjevkHScxHWkhfMbIYSU7Fmu/uRqOuJM3ff7O5nuXtp8jNgt6Q/S77HoW3PSrpUksxstKSukj7IZQHBBN3khPoFktYp8cHwU3evjraq2Pu8pG8oMTL5ZvLPX0ZdFILzt5J+YmZvSbpQ0v+OuJ7YSo58/0zSbyVtVuI9OvJLaMaNma2W9IqkMjPbbWZ/LWmppMvN7F0lRsaXRllj3LTRs+WSekt6Ofn+/1CkRcZIG/1CO9ro2SOSzkuecuxJSTfk+jcHXAIYAAAAQQpmRBcAAABojqALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAkCVmNqDZqftqzewPydv1ZvZg1PUBQOg4vRgA5ICZLZFU7+7Loq4FAAoFI7oAkGNmVmFmLyRvLzGzH5nZv5nZ783sv5jZ981ss5mtTV6mW2Y22cw2mNkbZrau6XK3AIC2EXQBIHrnS/qSpNmSnpD0K3efIOmopJnJsPt/Jc1198lKXG3ou1EVCwD5oiTqAgAAesndT5rZZknFktYml2+WVCqpTNJ4JS7VquQ6eyOoEwDyCkEXAKJ3XJLcvdHMTja7FnyjEu/TJqna3adGVSAA5COmLgBA/G2XNMjMpkqSmXUxs/KIawKA2CPoAkDMufsJSXMl/R8z2yTpTUmXRFsVAMQfpxcDAABAkBjRBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABCk/w/QDS+vfSDUNwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "data_log = []\n", "\n", "env = simpy.Environment()\n", "chargers = simpy.Resource(env, capacity=2)\n", "for r in roomba_df.index:\n", " env.process(roomba_model(roomba_df[\"id\"][r], roomba_df[\"charge_time\"][r], roomba_df[\"clean_time\"][r]))\n", "env.run(until=16)\n", "\n", "df = pd.DataFrame(data_log, columns=[\"id\", \"event\", \"begin\", \"end\"])\n", "display(kpi(df))\n", "gantt(df)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 4, "link": "[3.4.4.1.1 Solution](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.4.1.1-Solution)", "section": "3.4.4.1.1 Solution" } }, "source": [ "We see that two chargers are sufficient to meet the performance requirement. But keep in mind there has been no deliberate strategy for allocating the chargers. The Roombas simply wait in line when they need access. There may be better ways to allocate a scare resource than first-come, first-serve." ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.4.4.2 Exercise 2.](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.4.2-Exercise-2.)", "section": "3.4.4.2 Exercise 2." } }, "source": [ "### 3.4.4.2 Exercise 2.\n", "\n", "Modify the model to assume the changers are fully charged at the start of the cleaning shift. Does that reduce the number of chargers required?" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 4, "link": "[3.4.4.2.1 Solution](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.4.2.1-Solution)", "section": "3.4.4.2.1 Solution" } }, "source": [ "#### 3.4.4.2.1 Solution" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "nbpages": { "level": 4, "link": "[3.4.4.2.1 Solution](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.4.2.1-Solution)", "section": "3.4.4.2.1 Solution" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
time
event
charging19.7
cleaning51.8
\n", "
" ], "text/plain": [ " time\n", "event \n", "charging 19.7\n", "cleaning 51.8" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def roomba_model(id, charge_time, clean_time):\n", " while True:\n", " tic = env.now\n", " yield env.timeout(clean_time)\n", " toc = env.now\n", " data_log.append([id, \"cleaning\", tic, toc])\n", " with chargers.request() as request:\n", " yield request\n", " tic = env.now\n", " yield env.timeout(charge_time)\n", " toc = env.now\n", " data_log.append([id, \"charging\", tic, toc])\n", " \n", "data_log = []\n", "\n", "env = simpy.Environment()\n", "chargers = simpy.Resource(env, capacity=2)\n", "for r in roomba_df.index:\n", " env.process(roomba_model(roomba_df[\"id\"][r], roomba_df[\"charge_time\"][r], roomba_df[\"clean_time\"][r]))\n", "env.run(until=16)\n", "\n", "df = pd.DataFrame(data_log, columns=[\"id\", \"event\", \"begin\", \"end\"])\n", "display(kpi(df))\n", "gantt(df)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.4.5 Introducing State Variables](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.5-Introducing-State-Variables)", "section": "3.4.5 Introducing State Variables" } }, "source": [ "## 3.4.5 Introducing State Variables\n", "\n", "The solution to this exercise can be generalized by introducing a state variable `soc` denoting the 'state of charge'. The state of charge is the fraction of charge remaining in the device battery. The state of charge is reduced during cleaning operations, and restored during charging operation, in proportion to the time spent cleaning and charging, respectively.\n", "\n", "Given an initial full charge, let parameter $\\tau_{clean}$ denote the maximum time the device can clean before completely exhausting the battery. Let $\\text{SOC}_{k}$ be the state of charge after the $k_{th}$ cleaning cycle. Then\n", "\n", "$$\\text{SOC}_{k+1} = \\max(0, \\text{SOC}_k - \\frac{t_{k, clean}}{\\tau_{clean}})$$\n", "\n", "where $t_{k,clean}$ is the period of the $k_{th}$ cleaning cycle.\n", "\n", "An additional parameter is introduced to represent the minimum battery reserve that would be allowed for normal operations.\n", "\n", "Similarly, the state of charge following a charging cycle is given by\n", "\n", "$$\\text{SOC}_{k+1} = \\min(1, \\text{SOC}_k + \\frac{t_{k, charge}}{\\tau_{charge}})$$\n", "\n", "It is interesting to explore the behavior of this system as a function of the initial state of charge and reserve requirements. Take time to explore the role of these two parameters. See if you find any surprising behaviors." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "nbpages": { "level": 2, "link": "[3.4.5 Introducing State Variables](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.5-Introducing-State-Variables)", "section": "3.4.5 Introducing State Variables" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
time
event
charging20.25
cleaning53.10
\n", "
" ], "text/plain": [ " time\n", "event \n", "charging 20.25\n", "cleaning 53.10" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAroAAAEGCAYAAACKHTaKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAdDElEQVR4nO3dfXRV9Z3v8c83CY8CQQgiTxpUEiA86GCZgZYSa61kGBBvsUVtq6vjYl29zNXKlcvoXcp421tuZTl2LvUKy1FbLWhXtSpaYaTTMDN3tFaLiOFBsVKgEEDUQOQxnO/945x0IiZwzsk5Z5/zO+/XWizOw87+fflmJ/nwy2/vbe4uAAAAIDQlURcAAAAAZANBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIJXlcrA33njjnLKysocljREhOxUxSW+3tLTcNGHChH1RFwMAAFAIchp0y8rKHj733HNHDRgw4KOSkhKua5akWCxm+/fvH93Y2PiwpJlR1wMAAFAIcj2rOmbAgAEHCbmpKSkp8QEDBjQpPhMOAACAJOQ66JYQctOT6BvLPQAAAJKUs6ULlQtfjAfclbvOz9WYkrR98fQ3cjkeAAAA8kPRzxB+9atfrXz00UfPzsa+b7vttsHPPvts72zsGwAAAKeX05PRQhOLxeTuKi0tbff9Bx54YHeOSwIAAEBC0c3oLl26tH9VVdXo6urq0bNmzRouSevWret1ySWXjBw6dOjY1tndpqamkkmTJlWNHj16VFVV1egnnniiryRt3bq1a2Vl5Zirr766sqqqqua9997rescddwyqrKwcM2HChOoZM2YMv/vuuwdKn54tHjJkyNjvfOc7g1v3t379+u6StHv37rLJkyePuOiii2q+/vWvnz948OCxe/bs4T8gAAAAnVRUQff111/vvmTJkkHr1q17Z+vWrZuWLVu2Q5L27t3b5fXXX9/y3HPPvXvPPfcMkaSePXvGXnzxxW2bNm3avG7dunfuvPPOobFYTJK0Y8eObvPmzdu/bdu2hj179pStWrXq7E2bNjWsXbv23bfeeuusjsavqKho2bRp0+Zvf/vb+xcvXjxQkhYuXDh46tSph7Zt29ZwzTXXfLRnz56uOWgFAABA8Ipq5nDNmjV9ZsyY8dGgQYNaJGngwIEnJWnmzJkfl5aWasKECUcPHDjQRYpfu/a2224b+uqrr/YqKSnRvn37uu7atatMkgYNGnT88ssv/0SKzwbX1dV93LNnT+/Zs6dfccUVH3c0/nXXXfeRJE2cOPHw888/f7Ykvfbaa72effbZbZI0e/bsg3369DmZzR4AAAAUi6IKuh3p3r37ny555h5/uGzZsn4HDhwo27hx4+Zu3br5kCFDxh45cqREis/2dmacsrIyb2lpsQyUDgAAgA4U1dKFK6+88uCqVavObmxsLJWkvXv3tn8WmaSmpqbSioqKE926dfNVq1b13r17d7tLCqZOndq8Zs2a8sOHD1tTU1PJ2rVr+6ZS0+c+97nmxx9/vJ8kPfPMM30OHjzYYU0AAABIXlHN6F566aVH58+fv2fKlCkjS0pKfMyYMYc72vamm276sK6u7qKqqqrR48aNOzx8+PCj7W03derUw9OmTWsaPXp0Tf/+/U9UV1cfKS8vT3r5weLFi3fPnj37ghEjRvSfMGFCc0VFxYm+ffuyfAEAAKCTrPVX9dn2pxtG5FgubhjR1NRUUl5eHjt06FDJpEmTqh966KE/fOELX+gwRLd15MgRKysr8y5dumjt2rVnzZs37/wtW7Zsam/bDRs2VIwfP74yo8UDAAAEKmczutsXT7cNGzZsHz9+/Ae5GjNXvvGNb5z/7rvv9jh27JjNmTPnQLIhV5K2bdvW9Wtf+9qFsVhMXbp08WXLlm3PYqkAAABFo6iWLmTLqlWr3k/3Y8eOHXts8+bN7c7gAgAAIH1FdTIaAAAAigdBFwAAAEEi6AIAACBIuVuju6jcx0vSL3R+zsaUpEVNWb/qAgAAAPJP0c/o3n777YPvvvvugZne7yWXXDIy0/sEAABA8oo+6GbL+vXrt0RdAwAAQDEruqC7dOnS/lVVVaOrq6tHz5o1a3jb9xoaGrpNmTJlRE1NzagJEyZUr1+/vrskrVixonzcuHEjR40aNXry5MlVO3fuLJPis8HXXHNN5cSJE6uHDh069rvf/e45rfvq2bPnJZL0wgsv9J44cWL1tGnTLhg+fHjNzJkzh8diMUnSU089VT58+PCampqaUTfeeOOwyy677KKcNQIAACBwRRV0X3/99e5LliwZtG7dune2bt26admyZTvavn/TTTed/+CDD+5oaGjYfN999+26+eabz5OkK664ovnNN9/csnnz5k2zZ8/+8N577z239WO2bdvWfd26de/89re/3bxkyZLBx44ds1PH3bx5c48f/ehHO7dt29awY8eObi+//HKvw4cP26233nr+Sy+99G5DQ8PmAwcOcE1jAACADCqqcLVmzZo+M2bM+GjQoEEtkjRw4MCTre81NTWVrF+/vtc111xzYetrx48fN0l6//33u86aNWvo/v37uxw/frxk2LBhx1q3+cpXvvJxjx49vEePHi39+vU7sWvXrrILL7zwRNtxx44d+0nrazU1NYffe++9rr179z45bNiwYyNHjjwuSXPmzPnw4YcfHpDdDgAAABSPogq6p3Py5En17t27ZcuWLZ+5S9m8efPOu/XWWxuvv/76phdeeKH3vffeO7j1vW7dunnr49LSUrW0tHxmRjeZbQAAAJBZRbV04corrzy4atWqsxsbG0slae/evaWt7/Xr1y82dOjQ44888sjZkhSLxfTKK6/0kKRDhw6VnnfeeSck6bHHHuufiVrGjRt3dOfOnd22bt3aVZKeeuqpfpnYLwAAAOKKKuheeumlR+fPn79nypQpI6urq0ffcsstw9q+v3Llyt8/+uijFdXV1aNHjBhR8/TTT/eVpLvuumv3tddee2FNTc2o/v37t2Sill69evn999//h2nTpo2oqakZ1atXr5O9e/c+eeaPBAAAQDLM3c+8VSYsKs/RQKeOm783jGhqaiopLy+PxWIxfetb3zpvxIgRR++55559HW2/YcOGivHjx1fmsEQAAICClcM7ozXZhg0bto8fP/6DnI2Z5x544IGKlStXVpw4ccJqamoO33777fQGAAAgQ3I3oyuJoNs5zOgCAAAkL9drdGOxWIwrDqQh0bdY1HUAAAAUilwH3bf3799fTthNTSwWs/3795dLejvqWgAAAApFTq+j29LSclNjY+PDjY2NY1RkV3zopJikt1taWm6KuhAAAIBCkdM1ugAAAECuMKsKAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAqcmW03sy9HXQcA5BuCLoCiZ2ZzzOw3ZvaJme1LPL7FzLJ+c5tkQqqZ9TGzB8xsh5k1m9l7iecVWaqp3sy4bjeAgkfQBVDUzGy+pB9Kuk/SuZIGSvrPkj4vqWuEpUmSzKyrpF9JqpE0TVIfSZMkHZA0McNjmZnxcwFAMPiGBqBomVm5pHsl3eLuP3f3Qx633t2vd/djie2mm9l6MztoZjvNbFGbfVSamZvZDYkZ1w/M7K427y8ys5+Z2U/M7JCZNZjZpYn3Hpd0nqRViZnaBe2U+a3ENle7+yZ3j7n7Pnf/n+7+yzbbXWxmb5lZk5k9ZWbdE2OcbWYvmNl+M/so8Xhom/rqzex7Zvb/JB2W9LikKZKWJmpampFmA0AECLoAitkkSd0kPXeG7T5RPHD2lTRd0s1mNuuUbb4gqVrS5ZLuNrNRbd6bKenJxMc/L2mpJLn7NyXtkDTD3Xu5+w/aGfvLkla7e/MZavya4jO+wyWNk3Rj4vUSSY9KOl/xwHykdfw2vilprqTeiY/7V0nzEjXNO8O4AJC3CLoAilmFpA/cvaX1BTP7dzP72MyOmNkXJcnd6919Y2I29S1JKyVNPWVff+fuR9x9g6QNksa3ee/f3P2X7n5S8RnT8Upef0l7ktjuH9x9t7t/KGmVpIsTtR9w96fd/bC7H5L0vXZqf8zdG9y9xd1PpFAbAOQ1gi6AYnZAUoWZlbW+4O6T3b1v4r0SSTKzPzezXyd+/d+k+BreU08Ea2zz+LCkXqd5r3vbMZOocVAS27U7vpn1NLNlZvYHMzso6V8k9TWz0jbb70yyFgAoKARdAMXsFUnHJF11hu1WKL7kYJi7l0t6SFKmrsjgZ3h/raQrzeysNPc/X/ElFX/u7n0kfTHxetv6T63hTDUBQEEg6AIoWu7+saS/k/Sgmc02s95mVmJmF0tqGyx7S/rQ3Y+a2URJ12WwjL2SLjjN+48rPuP6tJmNTNTX38zuNLO/TGL/vRVfl/uxmfWTdE8GagKAgkDQBVDUEieA3S5pgeIBb6+kZZL+u6R/T2x2i6R7zeyQpLsl/SyDJXxf0v9IrAv+b+3Ud0zxE9K2SHpZ0kFJrym+dOI3Sez/AUk9JH0g6VVJq5P4mB9Kmp24SsM/JPWvAIA8ZO78hgoAAADhYUYXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgZTPoehR/XnnllUjGLfQ/9I2e0bP8/UPf6Bk9y88/9Cyv+tau4GZ0jx07FnUJBYm+pY6epY6epYe+pY6epY6epY6epSeXfcvm5cWytuPTWlQeybCpqjy6IiP72d49k9etzw7+rakrhH+rlJl/L//WPLSoKau7r1z4Ykb2Uwj9LKrvCSkcN5k4BgqiJ+J7R3vq6+tVW1ub6dHbvVtlcDO6AAAAgCSVJbuhmZ2UtLHNS0+6++LMlwQAAAB0XtJBV9IRd784a5UAAAAAGcTSBQAAAAQplRndHmb2Zpvn33f3p9puYGZzJc2VpAULFqiuri4DJaamNucjAkBY6uvroy4BBYjjBskeA83NzRk/Xjo6uS2jSxfcfbmk5a1PU9h35tRHMioABCMLZ0N/2urMXHUB+SWl44ZjIEjJHgNZuupCu1i6AAAAgCARdAEAABCkzqzRXe3uCzNdEAAAAJAJwd0ZLZfrPkJC31JHz1JHz9JD31JHz1JHz1JHz9LDndEAAACATiLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEjm7tnad9Z2fFqLyiMZFrlVeXRF1CV02vbu10VdAnJhUdOfHlYufDHCQjKD47YItDlmMyWIY3/x9M+8Vl9fr9ra2twXU+Cy1Ddr70VmdAEAABCksjNtYGYnJW2U1EVSi6SfSPp7d49luTYAAAAgbWcMupKOuPvFkmRm50haIamPpHuyWRgAAADQGSktXXD3fZLmSppnZu2uhQAAAADyQTIzup/i7r83s1JJ50ja2/Y9M5ureBDWggULVFdXl5EiU1Gb8xEBoGP19fVRlwCkhGO2fe31pbm5mX6lIRt96+jktpSD7um4+3JJy1ufZnLfSauPZFQAaNenvvmuLvwzzxG+rFxFIIBjv72+cNWF9OSybylfdcHMLpB0UtK+zJcDAAAAZEZKQdfMBkh6SNJSz+IFeAEAAIDOSmbpQg8ze1P/cXmxxyXdn9WqAAAAgE46Y9B199JcFJIp9bXPsV4mDYW2zmh71AUoEz3L/N2H8l2hHWeZ1t6dlZKRX30rjOM2v3pWGLLZs3SPfaCzuDMaAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJDM3bO176zt+LQWlUcybL6rPLoip+Nt735dTscrCIuaPvW0cuGLOR2ez8ln8XWRH3L5eeBz0D6+FqKX88/B4uk5Ha+t+vp61dbWZnq31t6LzOgCAAAgSEkHXTM718yeNLP3zOwNM/ulmVVlszgAAAAgXWXJbGRmJukXkn7s7nMSr42XNFDSO9krDwAAAEhPUkFX0mWSTrj7Q60vuPuG7JQEAAAAdF6yQXeMpDfOtJGZzZU0V5IWLFigurq6TpSWntqcjwgkp76+PuoSAACQFO3PpObm5oyP39HJbckG3aS4+3JJy1ufZnLfSauPZFTgjD7zRbg6t1ddAACgVRauepC0LF11oV3JnozWIGlCNgsBAAAAMinZoPvPkrolliZIksxsnJlNyU5ZAAAAQOckFXQ9fleJqyV9OXF5sQZJ35fUmM3iAAAAgHQFd2e0XK77CAl9Sx09Sx09Sw99Sx09Sx09Sx09Sw93RgMAAAA6iaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIJm7Z2vfWdvxaS0qj2TYbKo8uqLT+9je/boMVJI/MtETib60h560L7S+aFFTWh9WufDFTg8dWi85xjqQ5jGWrEwci1Lx9j1j/Vs8PeWPqa+vV21tbUbGb8Pae5EZXQAAAAQpqaBrZifN7E0z22BmvzOzydkuDAAAAOiMsiS3O+LuF0uSmV0p6fuSpmatKgAAAKCT0lm60EfSR5kuBAAAAMikZGd0e5jZm5K6Sxok6UvtbWRmcyXNlaQFCxaorq4uI0WmojbnIwJA4amvr4+6BASOYywaue57OuM1NzdnvM6OTm5LZ+nCJEk/MbMxfsolG9x9uaTlrU/TK7WT6iMZFQAKStpnPK/OzJnaCF8Wzqr/NI7FdiXd9wz1L53Pc5auutCulJcuuPsrkiokDch8OQAAAEBmpBx0zWykpFJJBzJfDgAAAJAZqa7RleIX5L3B3U9mqSYAAACg04K7M1ou132EhL6ljp6ljp6lh76ljp6ljp6ljp6lhzujAQAAAJ1E0AUAAECQCLoAAAAIEkEXAAAAQSLoAgAAIEgEXQAAAASJoAsAAIAgEXQBAAAQJIIuAAAAgkTQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkAi6AAAACBJBFwAAAEEi6AIAACBIBF0AAAAEiaALAACAIBF0AQAAECSCLgAAAIJE0AUAAECQzN2zte+s7fi0FpVHMmwxqDy6IuoS/mR79+uiLiFYfJ6LA5/n4pAvn2c+x9mTL59jSdq+eHpS29XX16u2tjbTw1t7LzKjCwAAgCAlHXTNbJaZuZmNzGZBAAAAQCakMqN7raR/S/wNAAAA5LWkgq6Z9ZL0BUl/LWlOVisCAAAAMqAsye2ukrTa3d8xswNmNsHd3zh1IzObK2muJC1YsEB1dXUZLDU5tTkfEQAAAPX19Ult19zcnPS2yero5LZkg+61kn6YePxk4vlngq67L5e0vPVpShVmSn0kowIAABS1ZK+kkKWrLrTrjEHXzPpJ+pKksWbmkkoluZnd4Vm8NhkAAADQGcms0Z0t6XF3P9/dK919mKT3JU3JbmkAAABA+pIJutdK+sUprz0trr4AAACAPBbcndFyue4jJPQtdfQsdfQsPfQtdfQsdfQsdfQsPdwZDQAAAOgkgi4AAACClM2lC5Ews7mJy5whBfQtdfQsdfQsPfQtdfQsdfQsdfQsPbnsW4gzunOjLqBA0bfU0bPU0bP00LfU0bPU0bPU0bP05KxvIQZdAAAAgKALAACAMIUYdFkrkx76ljp6ljp6lh76ljp6ljp6ljp6lp6c9S24k9EAAAAAKcwZXQAAAICgCwAAgDAFFXTNbJqZbTWzbWa2MOp68p2ZDTOzX5vZJjNrMLNbo66pUJhZqZmtN7MXoq6lUJhZXzP7uZltMbPNZjYp6prynZl9J/G1+baZrTSz7lHXlI/M7BEz22dmb7d5rZ+ZvWxm7yb+PjvKGvNNBz27L/H1+ZaZ/cLM+kZZY75pr2dt3ptvZm5mFVHUls866puZ/U3ieGswsx9ka/xggq6ZlUr6kaQ6SaMlXWtmo6OtKu+1SJrv7qMl/YWk/0LPknarpM1RF1FgfihptbuPlDRe9O+0zGyIpP8q6VJ3HyOpVNKcaKvKW49JmnbKawsl/crdR0j6VeI5/sNj+mzPXpY0xt3HSXpH0t/muqg895g+2zOZ2TBJX5G0I9cFFYjHdErfzOwySVdJGu/uNZKWZGvwYIKupImStrn77939uKQnFW8iOuDue9z9d4nHhxQPHkOirSr/mdlQSdMlPRx1LYXCzMolfVHSP0qSux9394+jraoglEnqYWZlknpK2h1xPXnJ3f9F0oenvHyVpB8nHv9Y0qycFpXn2uuZu/+Tu7cknr4qaWjOC8tjHRxnkvT3khZI4uz+dnTQt5slLXb3Y4lt9mVr/JCC7hBJO9s83yVCW9LMrFLSJZJ+E20lBeEBxb+pxaIupIAMl7Rf0qOJJR8Pm9lZUReVz9z9j4rPcuyQtEdSk7v/U7RVFZSB7r4n8bhR0sAoiylA35b0UtRF5Dszu0rSH919Q9S1FJgqSVPM7Ddmts7MPpetgUIKukiTmfWS9LSk29z9YNT15DMz+ytJ+9z9jahrKTBlkv5M0v9190skfSJ+lXxaiTWlVyn+n4TBks4ys29EW1Vh8vh1NJltS5KZ3aX40rafRl1LPjOznpLulHR31LUUoDJJ/RRfNnmHpJ+ZmWVjoJCC7h8lDWvzfGjiNZyGmXVRPOT+1N2fibqeAvB5STPNbLviy2O+ZGZPRFtSQdglaZe7t/7G4OeKB1907MuS3nf3/e5+QtIzkiZHXFMh2WtmgyQp8XfWfjUaEjO7UdJfSbreudD+mVyo+H9ENyR+JgyV9DszOzfSqgrDLknPeNxriv+GNCsn8oUUdH8raYSZDTezroqftPF8xDXltcT/nv5R0mZ3vz/qegqBu/+tuw9190rFj7F/dndm2c7A3Rsl7TSz6sRLl0vaFGFJhWCHpL8ws56Jr9XLxQl8qXhe0g2JxzdIei7CWgqCmU1TfFnWTHc/HHU9+c7dN7r7Oe5emfiZsEvSnyW+3+H0npV0mSSZWZWkrpI+yMZAwQTdxAL6eZLWKP7D4Gfu3hBtVXnv85K+qfis5JuJP38ZdVEI1t9I+qmZvSXpYkn/K+J68lpi9vvnkn4naaPi36+53Wg7zGylpFckVZvZLjP7a0mLJV1hZu8qPju+OMoa800HPVsqqbeklxM/Dx6KtMg800HPcAYd9O0RSRckLjn2pKQbsvUbBG4BDAAAgCAFM6MLAAAAtEXQBQAAQJAIugAAAAgSQRcAAABBIugCAAAgSARdAMgSM+vf5tJ9jWb2x8TjZjN7MOr6ACB0XF4MAHLAzBZJanb3JVHXAgDFghldAMgxM6s1sxcSjxeZ2Y/N7F/N7A9m9p/M7AdmttHMVidu0y0zm2Bm68zsDTNb03p7WwBAxwi6ABC9CyV9SdJMSU9I+rW7j5V0RNL0RNj9P5Jmu/sExe8q9L2oigWAQlEWdQEAAL3k7ifMbKOkUkmrE69vlFQpqVrSGMVvzarENnsiqBMACgpBFwCid0yS3D1mZifa3PM9pvj3aZPU4O6ToioQAAoRSxcAIP9tlTTAzCZJkpl1MbOaiGsCgLxH0AWAPOfuxyXNlvS/zWyDpDclTY62KgDIf1xeDAAAAEFiRhcAAABBIugCAAAgSARdAAAABImgCwAAgCARdAEAABAkgi4AAACCRNAFAABAkP4/YXsPiLiaXXMAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def roomba_model(id, charge_time, clean_time, reserve=0.1):\n", " soc = 1.0 # state of charge\n", " while True:\n", " if soc > reserve:\n", " tic = env.now\n", " yield env.timeout((soc - reserve) * clean_time)\n", " toc = env.now\n", " soc = max(0.0, soc - (toc - tic)/clean_time)\n", " data_log.append([id, \"cleaning\", tic, toc])\n", " \n", " with chargers.request() as request:\n", " yield request\n", " tic = env.now\n", " yield env.timeout((1 - soc)*charge_time)\n", " toc = env.now\n", " soc = min(1.0, soc + (toc - tic)/charge_time)\n", " data_log.append([id, \"charging\", tic, toc])\n", " \n", "data_log = []\n", "\n", "env = simpy.Environment()\n", "chargers = simpy.Resource(env, capacity=2)\n", "for r in roomba_df.index:\n", " env.process(roomba_model(roomba_df[\"id\"][r], roomba_df[\"charge_time\"][r], roomba_df[\"clean_time\"][r]))\n", "env.run(until=16)\n", "\n", "df = pd.DataFrame(data_log, columns=[\"id\", \"event\", \"begin\", \"end\"])\n", "display(kpi(df))\n", "gantt(df)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.4.5.1 Exercise 3.](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.5.1-Exercise-3.)", "section": "3.4.5.1 Exercise 3." } }, "source": [ "### 3.4.5.1 Exercise 3.\n", "\n", "Assume each Roomba needs to dispose of waste after 20 minutes of cleaning, that it takes 5 minutes to dispose of the waste, and requires access to a waste disposal station. \n", "\n", "Hints:\n", "* You will need to create a log a new event called 'waste disposal'. \n", "* Model the waste disposal station as a shared resource.\n", "* You may need to make some decisions on how to handle the waste at the end of a cleaning cycle. Don't get too bogged down, just make some reasonable assumptions. We'll address this issue in the next class. " ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "nbpages": { "level": 3, "link": "[3.4.5.1 Exercise 3.](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.5.1-Exercise-3.)", "section": "3.4.5.1 Exercise 3." } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
time
event
charging17.730000
cleaning48.720000
waste disposal12.083333
\n", "
" ], "text/plain": [ " time\n", "event \n", "charging 17.730000\n", "cleaning 48.720000\n", "waste disposal 12.083333" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "five_min = 1.0/12.0\n", "twenty_min = 1.0/3.0\n", "\n", "def roomba_model(id, charge_time, clean_time, reserve=0.1):\n", " soc = 1.0 # state of charge\n", " sow = 0.0 # state of waste\n", " while True:\n", " if soc > reserve and sow < 1.0:\n", " tic = env.now\n", " events = [env.timeout((soc - reserve) * clean_time), \n", " env.timeout((1.0 - sow)*twenty_min)]\n", " yield simpy.AnyOf(env, events)\n", " toc = env.now\n", " soc = max(0.0, soc - (toc - tic)/clean_time)\n", " sow = min(1.0, sow + (toc - tic)/twenty_min)\n", " data_log.append([id, \"cleaning\", tic, toc])\n", " if sow >= 1.0 - 0.001:\n", " with waste_stations.request() as request:\n", " yield request\n", " tic = env.now\n", " yield env.timeout(five_min)\n", " toc = env.now\n", " sow = 0.0\n", " data_log.append([id, \"waste disposal\", tic, toc])\n", " if soc <= reserve + 0.001:\n", " with chargers.request() as request:\n", " yield request\n", " tic = env.now\n", " yield env.timeout((1 - soc)*charge_time)\n", " toc = env.now\n", " soc = min(1.0, soc + (toc - tic)/charge_time)\n", " data_log.append([id, \"charging\", tic, toc])\n", " \n", "data_log = []\n", "\n", "env = simpy.Environment()\n", "chargers = simpy.Resource(env, capacity=3)\n", "waste_stations = simpy.Resource(env, capacity=5)\n", "for r in roomba_df.index:\n", " env.process(roomba_model(roomba_df[\"id\"][r], roomba_df[\"charge_time\"][r], roomba_df[\"clean_time\"][r]))\n", "env.run(until=16)\n", "\n", "df = pd.DataFrame(data_log, columns=[\"id\", \"event\", \"begin\", \"end\"])\n", "display(kpi(df))\n", "gantt(df)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.4.6 Stochastic Model](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.6-Stochastic-Model)", "section": "3.4.6 Stochastic Model" } }, "source": [ "## 3.4.6 Stochastic Model" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "nbpages": { "level": 2, "link": "[3.4.6 Stochastic Model](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.6-Stochastic-Model)", "section": "3.4.6 Stochastic Model" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
time
event
charging18.180000
cleaning49.390134
waste disposal10.833333
\n", "
" ], "text/plain": [ " time\n", "event \n", "charging 18.180000\n", "cleaning 49.390134\n", "waste disposal 10.833333" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import random\n", "\n", "five_min = 5.0/60.0\n", "ten_min = 10.0/60.0\n", "twenty_min = 20.0/60.0\n", "thirty_min = 30.0/60.0\n", "\n", "def roomba_model(id, charge_time, clean_time, reserve=0.1):\n", " soc = 1.0 # state of charge\n", " sow = 0.0 # state of waste\n", " while True:\n", " if soc > reserve and sow < 1.0:\n", " tic = env.now\n", " yield simpy.AnyOf(env, [env.timeout((soc - reserve) * clean_time), \n", " env.timeout((1.0 - sow)*random.uniform(ten_min, thirty_min))])\n", " toc = env.now\n", " soc = max(0.0, soc - (toc - tic)/clean_time)\n", " sow = min(1.0, sow + (toc - tic)/twenty_min)\n", " data_log.append([id, \"cleaning\", tic, toc])\n", " if sow >= 1.0 - 0.001:\n", " with waste_stations.request() as request:\n", " yield request\n", " tic = env.now\n", " yield env.timeout(five_min)\n", " toc = env.now\n", " sow = 0.0\n", " data_log.append([id, \"waste disposal\", tic, toc])\n", " if soc <= reserve+ 0.001:\n", " with chargers.request() as request:\n", " yield request\n", " tic = env.now\n", " yield env.timeout((1 - soc)*charge_time)\n", " toc = env.now\n", " soc = min(1.0, soc + (toc - tic)/charge_time)\n", " data_log.append([id, \"charging\", tic, toc])\n", " \n", "data_log = []\n", "\n", "env = simpy.Environment()\n", "chargers = simpy.Resource(env, capacity=3)\n", "waste_stations = simpy.Resource(env, capacity=2)\n", "for r in roomba_df.index:\n", " env.process(roomba_model(roomba_df[\"id\"][r], roomba_df[\"charge_time\"][r], roomba_df[\"clean_time\"][r]))\n", "env.run(until=16)\n", "\n", "df = pd.DataFrame(data_log, columns=[\"id\", \"event\", \"begin\", \"end\"])\n", "display(kpi(df))\n", "gantt(df)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.4.7 Monte Carlo Simulation](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.7-Monte-Carlo-Simulation)", "section": "3.4.7 Monte Carlo Simulation" } }, "source": [ "## 3.4.7 Monte Carlo Simulation" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "nbpages": { "level": 2, "link": "[3.4.7 Monte Carlo Simulation](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.7-Monte-Carlo-Simulation)", "section": "3.4.7 Monte Carlo Simulation" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mean = 47.91\n", "std = 0.34\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import random\n", "\n", "five_min = 5.0/60.0\n", "ten_min = 10.0/60.0\n", "twenty_min = 20.0/60.0\n", "thirty_min = 30.0/60.0\n", "\n", "def roomba_model(id, charge_time, clean_time, reserve=0.1):\n", " soc = 1.0 # state of charge\n", " sow = 0.0 # state of waste\n", " while True:\n", " if soc > reserve and sow < 1.0:\n", " tic = env.now\n", " yield simpy.AnyOf(env, [env.timeout((soc - reserve) * clean_time), \n", " env.timeout((1.0 - sow)*random.triangular(ten_min, thirty_min))])\n", " toc = env.now\n", " soc = max(0.0, soc - (toc - tic)/clean_time)\n", " sow = min(1.0, sow + (toc - tic)/twenty_min)\n", " data_log.append([id, \"cleaning\", tic, toc])\n", " if sow >= 1.0 - 0.001:\n", " with waste_stations.request() as request:\n", " yield request\n", " tic = env.now\n", " yield env.timeout(five_min)\n", " toc = env.now\n", " sow = 0.0\n", " data_log.append([id, \"waste disposal\", tic, toc])\n", " if soc <= reserve+ 0.001:\n", " with chargers.request() as request:\n", " yield request\n", " tic = env.now\n", " yield env.timeout((1 - soc)*charge_time)\n", " toc = env.now\n", " soc = min(1.0, soc + (toc - tic)/charge_time)\n", " data_log.append([id, \"charging\", tic, toc])\n", " \n", "y = []\n", "for k in range(1000):\n", " data_log = []\n", "\n", " env = simpy.Environment()\n", " chargers = simpy.Resource(env, capacity=2)\n", " waste_stations = simpy.Resource(env, capacity=2)\n", " for r in roomba_df.index:\n", " env.process(roomba_model(roomba_df[\"id\"][r], roomba_df[\"charge_time\"][r], roomba_df[\"clean_time\"][r]))\n", " env.run(until=16)\n", "\n", " df = pd.DataFrame(data_log, columns=[\"id\", \"event\", \"begin\", \"end\"])\n", " y.append(kpi(df)[\"time\"][\"cleaning\"])\n", "\n", "y = np.array(y)\n", "plt.hist(y, bins=20)\n", "plt.xlim(45.0, 52.0)\n", "plt.plot([48,48], plt.ylim(), lw=3)\n", "print(\"mean =\", round(y.mean(), 2))\n", "print(\"std =\", round(y.std(), 2))" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.4.8 Assignment (to be submitted Thursday, Sept. 3rd).](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.8-Assignment-(to-be-submitted-Thursday,-Sept.-3rd).)", "section": "3.4.8 Assignment (to be submitted Thursday, Sept. 3rd)." } }, "source": [ "## 3.4.8 Assignment (to be submitted Thursday, Sept. 3rd).\n", "\n", "The facility has expanded to an average of 100 hours of machine cleaning time are required during the 16 hour overnight shift. The company would like to settle on a single cleaning model rather than servicing five different models. \n", "\n", "a. Modify the above model to determine the the model (A, B, C, D, or E) and number of devices required to meet the service requirement.\n", "\n", "b. Modify the above model to include a second process that writes the number of charging stations in use at every minute to a second data log. Prepare a plot and histogram of charging station usage." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "nbpages": { "level": 2, "link": "[3.4.8 Assignment (to be submitted Thursday, Sept. 3rd).](https://jckantor.github.io/CBE40455-2020/03.04-Modeling-Events.html#3.4.8-Assignment-(to-be-submitted-Thursday,-Sept.-3rd).)", "section": "3.4.8 Assignment (to be submitted Thursday, Sept. 3rd)." } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "< [3.3 Agent Based Models](https://jckantor.github.io/CBE40455-2020/03.03-Agent-Based-Models.html) | [Contents](toc.html) | [3.5 Assignment](https://jckantor.github.io/CBE40455-2020/03.05-Assignment.html) >

\"Open

\"Download\"" ] } ], "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.7.4" } }, "nbformat": 4, "nbformat_minor": 4 }