{ "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.9 Refinements of a Grocery Store Checkout Operation](https://jckantor.github.io/CBE40455-2020/03.09-Refinements-to-the-Grocery-Store-Checkout-Operation.html) | [Contents](toc.html) | [3.11 Batch Chemical Process](https://jckantor.github.io/CBE40455-2020/03.11-Project-Batch-Chemical-Process.html) >

\"Open

\"Download\"" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 1, "link": "[3.10 Objected-Oriented Simulation](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10-Objected-Oriented-Simulation)", "section": "3.10 Objected-Oriented Simulation" } }, "source": [ "# 3.10 Objected-Oriented Simulation\n", "\n", "Up to this point we have been using Python generators and shared resources as the building blocks for simulations of complex systems. This can be effective, particularly if the individual agents do not require access to the internal state of other agents. But there are situations where the action of an agent depends on the state or properties of another agent in the simulation. For example, consider this discussion question from the Grocery store checkout example:\n", "\n", ">Suppose we were to change one or more of the lanes to a express lanes which handle only with a small number of items, say five or fewer. How would you expect this to change average waiting time? This is a form of prioritization ... are there other prioritizations that you might consider?\n", "\n", "The customer action depends the item limit parameter associated with a checkout lane. This is a case where the action of one agent depends on a property of another. The shared resources builtin to the SimPy library provide some functionality in this regard, but how do add this to the simulations we write?\n", "\n", "The good news is that Python offers a rich array of object oriented programming features well suited to this purpose. The SymPy documentation provides excellent examples of how to create Python objects for use in SymPy. The bad news is that object oriented programming in Python -- while straightforward compared to many other programming languages -- constitutes a steep learning curve for students unfamiliar with the core concepts.\n", "\n", "Fortunately, since the introduction of Python 3.7 in 2018, the standard libraries for Python have included a simplified method for creating and using Python classes. Using [dataclass](https://realpython.com/python-data-classes/), it easy to create objects for SymPy simulations that retain the benefits of object oriented programming without all of the coding overhead. \n", "\n", "The purpose of this notebook is to introduce the use of `dataclass` in creating SymPy simulations. To the best of the author's knowledge, this is a novel use of `dataclass` and the only example of which the author is aware." ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.10.1 Installations and imports](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.1-Installations-and-imports)", "section": "3.10.1 Installations and imports" } }, "source": [ "## 3.10.1 Installations and imports" ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "nbpages": { "level": 2, "link": "[3.10.1 Installations and imports](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.1-Installations-and-imports)", "section": "3.10.1 Installations and imports" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: sympy in /Users/jeff/opt/anaconda3/lib/python3.7/site-packages (1.5.1)\n", "Requirement already satisfied: mpmath>=0.19 in /Users/jeff/opt/anaconda3/lib/python3.7/site-packages (from sympy) (1.1.0)\n" ] } ], "source": [ "!pip install sympy" ] }, { "cell_type": "code", "execution_count": 92, "metadata": { "nbpages": { "level": 2, "link": "[3.10.1 Installations and imports](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.1-Installations-and-imports)", "section": "3.10.1 Installations and imports" } }, "outputs": [], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import random\n", "import simpy\n", "import pandas as pd\n", "from dataclasses import dataclass" ] }, { "cell_type": "code", "execution_count": 128, "metadata": { "nbpages": { "level": 2, "link": "[3.10.1 Installations and imports](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.1-Installations-and-imports)", "section": "3.10.1 Installations and imports" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.7.4 (default, Aug 13 2019, 15:17:50) \n", "[Clang 4.0.1 (tags/RELEASE_401/final)]\n" ] } ], "source": [ "import sys\n", "print(sys.version)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.10.1 Installations and imports](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.1-Installations-and-imports)", "section": "3.10.1 Installations and imports" } }, "source": [ "Additional imports are from the `dataclasses` library that has been part of the standard Python distribution since version 3.7. Here we import `dataclass` and `field`." ] }, { "cell_type": "code", "execution_count": 93, "metadata": { "nbpages": { "level": 2, "link": "[3.10.1 Installations and imports](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.1-Installations-and-imports)", "section": "3.10.1 Installations and imports" } }, "outputs": [], "source": [ "from dataclasses import dataclass, field" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.10.2 Introduction to `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2-Introduction-to-`dataclass`)", "section": "3.10.2 Introduction to `dataclass`" } }, "source": [ "## 3.10.2 Introduction to `dataclass`\n", "\n", "Tutorials and additional documentation:\n", "\n", "* [The Ultimate Guide to Data Classes in Python 3.7](https://realpython.com/python-data-classes/): Tutorial article from ReaalPython.com\n", "* [dataclasses — Data Classes](https://docs.python.org/3/library/dataclasses.html): Official Python documentation.\n", "* [Data Classes in Python](https://towardsdatascience.com/data-classes-in-python-8d1a09c1294b): Tutorial from TowardsDataScience.com" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.1 Creating a `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.1-Creating-a-`dataclass`)", "section": "3.10.2.1 Creating a `dataclass`" } }, "source": [ "### 3.10.2.1 Creating a `dataclass`\n", "\n", "A `dataclass` defines a new class of Python objects. A `dataclass` object takes care of several routine things that you would otherwise have to code, such as creating instances of an object, testing for equality, and other aspects. \n", "\n", "As an example, the following cell shows how to define a dataclass corresponding to a hypothetical Student object. The Student object maintains data associated with instances of a student. The dataclass also defines a function associated with the object." ] }, { "cell_type": "code", "execution_count": 94, "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.1 Creating a `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.1-Creating-a-`dataclass`)", "section": "3.10.2.1 Creating a `dataclass`" } }, "outputs": [], "source": [ "from dataclasses import dataclass\n", "\n", "@dataclass\n", "class Student():\n", " name: str\n", " graduation_class: int\n", " dorm: str\n", " \n", " def print_name(self):\n", " print(f\"{self.name} (Class of {self.graduation_class})\")" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.1 Creating a `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.1-Creating-a-`dataclass`)", "section": "3.10.2.1 Creating a `dataclass`" } }, "source": [ "Let's create an instance of the Student object." ] }, { "cell_type": "code", "execution_count": 95, "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.1 Creating a `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.1-Creating-a-`dataclass`)", "section": "3.10.2.1 Creating a `dataclass`" } }, "outputs": [], "source": [ "sam = Student(\"Sam Jones\", 2024, \"Alumni\")" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.1 Creating a `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.1-Creating-a-`dataclass`)", "section": "3.10.2.1 Creating a `dataclass`" } }, "source": [ "Let's see how the `print_name()` function works." ] }, { "cell_type": "code", "execution_count": 96, "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.1 Creating a `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.1-Creating-a-`dataclass`)", "section": "3.10.2.1 Creating a `dataclass`" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sam Jones (Class of 2024)\n" ] } ], "source": [ "sam.print_name()" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.1 Creating a `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.1-Creating-a-`dataclass`)", "section": "3.10.2.1 Creating a `dataclass`" } }, "source": [ "The next cell shows how to create a list of students, and how to iterate over a list of students." ] }, { "cell_type": "code", "execution_count": 97, "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.1 Creating a `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.1-Creating-a-`dataclass`)", "section": "3.10.2.1 Creating a `dataclass`" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sam Jones (Class of 2024)\n", "Alumni\n", "Becky Smith (Class of 2023)\n", "Howard\n" ] } ], "source": [ "# create a list of students\n", "students = [\n", " Student(\"Sam Jones\", 2024, \"Alumni\"),\n", " Student(\"Becky Smith\", 2023, \"Howard\"),\n", "]\n", "\n", "# iterate over the list of students to print all of their names\n", "for student in students:\n", " student.print_name()\n", " print(student.dorm)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.1 Creating a `dataclass`](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.1-Creating-a-`dataclass`)", "section": "3.10.2.1 Creating a `dataclass`" } }, "source": [ "Here are a few details you need to use `dataclass` effectively:\n", "\n", "* The `class` statement is standard statement for creating a new class of Python objects. The preceding `@dataclass` is a Python 'decorator'. Decorators are Python functions that modify the behavior of subsequent statements. In this case, the `@dataclass` decorator modifies `class` to provide a streamlined syntax for implementing classes.\n", "* A Python class names begin with a capital letter. In this case `Student` is the class name.\n", "* The lines following the the class statement declare parameters that will be used by the new class. The parameters can be specified when you create an instance of the dataclass. \n", "* Each paraameter is followed by type 'hint'. Commonly used type hints are `int`, `float`, `bool`, and `str`. Use the keyword `any` you don't know or can't specify a particular type. Type hints are actually used by type-checking tools and ignored by the python interpreter.\n", "* Following the parameters, write any functions or generators that you may wish to define for the new class. To access variables unique to an instance of the class, preceed the parameter name with `self`." ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.2.2 Specifying parameter values](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.2-Specifying-parameter-values)", "section": "3.10.2.2 Specifying parameter values" } }, "source": [ "### 3.10.2.2 Specifying parameter values\n", "\n", "There are different ways of specifying the parameter values assigned to an instance of a dataclass. Here are three particular methods:\n", "\n", "* Specify the parameter value when creating a new instance. This is what was done in the Student example above.\n", "* Provide a default values determined when the dataclass is defined.\n", "* Provide a default_factory method to create a parameter value when an instance of the dataclass is created." ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 4, "link": "[3.10.2.2.1 Specifying a parameter value when creating a new instance](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.2.1-Specifying-a-parameter-value-when-creating-a-new-instance)", "section": "3.10.2.2.1 Specifying a parameter value when creating a new instance" } }, "source": [ "#### 3.10.2.2.1 Specifying a parameter value when creating a new instance\n", "\n", "Parameter values can be specified when creating an instance of a dataclass. The parameter values can be specified by position or by name as shown below." ] }, { "cell_type": "code", "execution_count": 115, "metadata": { "nbpages": { "level": 4, "link": "[3.10.2.2.1 Specifying a parameter value when creating a new instance](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.2.1-Specifying-a-parameter-value-when-creating-a-new-instance)", "section": "3.10.2.2.1 Specifying a parameter value when creating a new instance" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sam Jones (Class of 2031)\n", "Gilda Radner (Class of 2030)\n" ] } ], "source": [ "from dataclasses import dataclass\n", "\n", "@dataclass\n", "class Student():\n", " name: str\n", " graduation_year: int\n", " dorm: str\n", " \n", " def print_name(self):\n", " print(f\"{self.name} (Class of {self.graduation_year})\")\n", " \n", "sam = Student(\"Sam Jones\", 2031, \"Alumni\")\n", "sam.print_name()\n", "\n", "gilda = Student(name=\"Gilda Radner\", graduation_year=2030, dorm=\"Howard\")\n", "gilda.print_name()" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 4, "link": "[3.10.2.2.2 Setting default parameter values](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.2.2-Setting-default-parameter-values)", "section": "3.10.2.2.2 Setting default parameter values" } }, "source": [ "#### 3.10.2.2.2 Setting default parameter values\n", "\n", "Setting a default value for a parameter can save extra typing or coding. More importantly, setting default values makes it easier to maintain and adapt code for other applications, and is a convenient way to handle missing data. \n", "\n", "There are two ways to set default parameter values. For str, int, float, bool, tuple (the immutable types in Python), a default value can be set using `=` as shown in the next cell." ] }, { "cell_type": "code", "execution_count": 99, "metadata": { "nbpages": { "level": 4, "link": "[3.10.2.2.2 Setting default parameter values](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.2.2-Setting-default-parameter-values)", "section": "3.10.2.2.2 Setting default parameter values" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "John Doe (Class of None)\n" ] } ], "source": [ "from dataclasses import dataclass\n", "\n", "@dataclass\n", "class Student():\n", " name: str = None\n", " graduation_year: int = None\n", " dorm: str = None\n", " \n", " def print_name(self):\n", " print(f\"{self.name} (Class of {self.graduation_year})\")\n", " \n", "jdoe = Student(name=\"John Doe\", dorm=\"Alumni\")\n", "jdoe.print_name()" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 4, "link": "[3.10.2.2.2 Setting default parameter values](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.2.2-Setting-default-parameter-values)", "section": "3.10.2.2.2 Setting default parameter values" } }, "source": [ "Default parameter values are restricted to 'immutable' types. This technical restriction eliminiates the error-prone practice of use mutable objects, such as lists, as defaults. The difficulty with setting defaults for mutable objects is that all instances of the dataclass share the same value. If one instance of the object changes that value, then all other instances are affected. This leads to unpredictable behavior, and is a particularly nasty bug to uncover and fix.\n", "\n", "There are two ways to provide defaults for mutable parameters such as lists, sets, dictionaries, or arbitrary Python objects. \n", "\n", "The more direct way is to specify a function for constucting the default parameter value using the `field` statement with the `default_factory` option. The default_factory is called when a new instance of the dataclass is created. The function must take no arguments and must return a value that will be assigned to the designated parameter. Here's an example." ] }, { "cell_type": "code", "execution_count": 117, "metadata": { "nbpages": { "level": 4, "link": "[3.10.2.2.2 Setting default parameter values](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.2.2-Setting-default-parameter-values)", "section": "3.10.2.2.2 Setting default parameter values" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "John Doe (Class of None)\n", " 1. Math\n", " 2. Chemical Engineering\n" ] } ], "source": [ "from dataclasses import dataclass\n", "\n", "@dataclass\n", "class Student():\n", " name: str = None\n", " graduation_year: int = None\n", " dorm: str = None\n", " majors: list = field(default_factory=list)\n", " \n", " def print_name(self):\n", " print(f\"{self.name} (Class of {self.graduation_year})\")\n", " \n", " def print_majors(self):\n", " for n, major in enumerate(self.majors):\n", " print(f\" {n+1}. {major}\")\n", " \n", "jdoe = Student(name=\"John Doe\", dorm=\"Alumni\", majors=[\"Math\", \"Chemical Engineering\"])\n", "jdoe.print_name()\n", "jdoe.print_majors()\n", "\n", "Student().print_majors()" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 4, "link": "[3.10.2.2.3 Initializing a dataclass with __post_init__(self)](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.2.2.3-Initializing-a-dataclass-with-__post_init__(self))", "section": "3.10.2.2.3 Initializing a dataclass with __post_init__(self)" } }, "source": [ "#### 3.10.2.2.3 Initializing a dataclass with __post_init__(self)\n", "\n", "Frequently there are additional steps to complete when creating a new instance of a dataclass. For that purpose, a dataclass may contain an\n", "optional function with the special name `__post_init__(self)`. If present, that function is run automatically following the creation of a new instance. This feature will be demonstrated in following reimplementation of the grocery store checkout operation." ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.10.3 Using `dataclass` with Simpy](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3-Using-`dataclass`-with-Simpy)", "section": "3.10.3 Using `dataclass` with Simpy" } }, "source": [ "## 3.10.3 Using `dataclass` with Simpy" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.3.1 Step 0. A simple model](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3.1-Step-0.-A-simple-model)", "section": "3.10.3.1 Step 0. A simple model" } }, "source": [ "### 3.10.3.1 Step 0. A simple model\n", "\n", "To demonstrate the use of classes in SimPy simulations, let's begin with a simple model of a clock using generators." ] }, { "cell_type": "code", "execution_count": 176, "metadata": { "nbpages": { "level": 3, "link": "[3.10.3.1 Step 0. A simple model](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3.1-Step-0.-A-simple-model)", "section": "3.10.3.1 Step 0. A simple model" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A 0\n", "B 0\n", "A 1.0\n", "B 1.5\n", "A 2.0\n", "B 3.0\n", "A 3.0\n", "A 4.0\n", "B 4.5\n" ] } ], "source": [ "import simpy\n", "\n", "def clock(id=\"\", t_step=1.0):\n", " while True:\n", " print(id, env.now)\n", " yield env.timeout(t_step)\n", " \n", "env = simpy.Environment()\n", "env.process(clock(\"A\"))\n", "env.process(clock(\"B\", 1.5))\n", "env.run(until=5.0)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.3.2 Step 1. Embed the generator inside of a class](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3.2-Step-1.-Embed-the-generator-inside-of-a-class)", "section": "3.10.3.2 Step 1. Embed the generator inside of a class" } }, "source": [ "### 3.10.3.2 Step 1. Embed the generator inside of a class" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.3.2 Step 1. Embed the generator inside of a class](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3.2-Step-1.-Embed-the-generator-inside-of-a-class)", "section": "3.10.3.2 Step 1. Embed the generator inside of a class" } }, "source": [ "As a first step, we rewrite the generator as a Python dataclass named `Clock`. The parameters are given default values, and the generator is incorporated within the Clock object. Note the use of `self` to refer to parameters specific to an instance of the class." ] }, { "cell_type": "code", "execution_count": 181, "metadata": { "nbpages": { "level": 3, "link": "[3.10.3.2 Step 1. Embed the generator inside of a class](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3.2-Step-1.-Embed-the-generator-inside-of-a-class)", "section": "3.10.3.2 Step 1. Embed the generator inside of a class" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A 0\n", "B 0\n", "A 1.0\n", "B 1.5\n", "A 2.0\n", "B 3.0\n", "A 3.0\n", "A 4.0\n", "B 4.5\n" ] } ], "source": [ "import simpy\n", "from dataclasses import dataclass\n", "\n", "@dataclass\n", "class Clock():\n", " id: str = \"\"\n", " t_step: float = 1.0\n", " \n", " def process(self):\n", " while True:\n", " print(self.id, env.now)\n", " yield env.timeout(self.t_step)\n", "\n", "env = simpy.Environment()\n", "env.process(Clock(\"A\").process())\n", "env.process(Clock(\"B\", 1.5).process())\n", "env.run(until=5)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.3.3 Step 2. Eliminate (if possible) global variables](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3.3-Step-2.-Eliminate-(if-possible)-global-variables)", "section": "3.10.3.3 Step 2. Eliminate (if possible) global variables" } }, "source": [ "### 3.10.3.3 Step 2. Eliminate (if possible) global variables\n", "\n", "Our definition of clock requires the simulation environment to have a specific name `env`, and assumes env is a global variable. That's generally not a good coding practice because it imposes an assumption on any user of the class, and exposes the internal coding of the class. A much better practice is to use class parameters to pass this data through a well defined interface to the class." ] }, { "cell_type": "code", "execution_count": 186, "metadata": { "nbpages": { "level": 3, "link": "[3.10.3.3 Step 2. Eliminate (if possible) global variables](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3.3-Step-2.-Eliminate-(if-possible)-global-variables)", "section": "3.10.3.3 Step 2. Eliminate (if possible) global variables" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A 0\n", "B 0\n", "A 1.0\n", "B 1.5\n", "A 2.0\n", "B 3.0\n", "A 3.0\n", "A 4.0\n", "B 4.5\n", "A 5.0\n", "B 6.0\n", "A 6.0\n", "A 7.0\n", "B 7.5\n", "A 8.0\n", "B 9.0\n", "A 9.0\n" ] } ], "source": [ "import simpy\n", "from dataclasses import dataclass\n", "\n", "@dataclass\n", "class Clock():\n", " env: simpy.Environment\n", " id: str = \"\"\n", " t_step: float = 1.0\n", " \n", " def process(self):\n", " while True:\n", " print(self.id, self.env.now)\n", " yield self.env.timeout(self.t_step)\n", "\n", "env = simpy.Environment()\n", "env.process(Clock(env, \"A\").process())\n", "env.process(Clock(env, \"B\", 1.5).process())\n", "env.run(until=10)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 3, "link": "[3.10.3.4 Step 3. Encapsulate initializations inside __post_init__](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3.4-Step-3.-Encapsulate-initializations-inside-__post_init__)", "section": "3.10.3.4 Step 3. Encapsulate initializations inside __post_init__" } }, "source": [ "### 3.10.3.4 Step 3. Encapsulate initializations inside __post_init__" ] }, { "cell_type": "code", "execution_count": 185, "metadata": { "nbpages": { "level": 3, "link": "[3.10.3.4 Step 3. Encapsulate initializations inside __post_init__](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.3.4-Step-3.-Encapsulate-initializations-inside-__post_init__)", "section": "3.10.3.4 Step 3. Encapsulate initializations inside __post_init__" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A 0\n", "B 0\n", "A 1.0\n", "B 1.5\n", "A 2.0\n", "B 3.0\n", "A 3.0\n", "A 4.0\n", "B 4.5\n" ] } ], "source": [ "import simpy\n", "from dataclasses import dataclass\n", "\n", "@dataclass\n", "class Clock():\n", " env: simpy.Environment\n", " id: str = \"\"\n", " t_step: float = 1.0\n", " \n", " def __post_init__(self):\n", " self.env.process(self.process())\n", " \n", " def process(self):\n", " while True:\n", " print(self.id, self.env.now)\n", " yield self.env.timeout(self.t_step)\n", "\n", "env = simpy.Environment()\n", "Clock(env, \"A\")\n", "Clock(env, \"B\", 1.5)\n", "env.run(until=5)" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.10.4 Grocery Store Model](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.4-Grocery-Store-Model)", "section": "3.10.4 Grocery Store Model" } }, "source": [ "## 3.10.4 Grocery Store Model\n", "\n", "Let's review our model for the grocery store checkout operations. There are multiple checkout lanes, each with potentially different characteristics. With generators we were able to implement differences in the time required to scan items. But another parameter, a limit on number of items that could be checked out in a lane, required a new global list. The reason was the need to access that parameter, something that a generator doesn't allow. This is where classes become important building blocks in creating more complex simulations.\n", "\n", "Our new strategy will be encapsulate the generator inside of a dataclass object. Here's what we'll ask each class definition to do:\n", "\n", "* Create a parameter corresponding to the simulation environment. This makes our classes reusable in other simulations by eliminating a reference to a globall variable.\n", "* Create parameters with reasonable defaults values.\n", "* Initialize any objects used within the class.\n", "* Register the class generator with the simulation environment.\n" ] }, { "cell_type": "code", "execution_count": 173, "metadata": { "nbpages": { "level": 2, "link": "[3.10.4 Grocery Store Model](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.4-Grocery-Store-Model)", "section": "3.10.4 Grocery Store Model" } }, "outputs": [], "source": [ "from dataclasses import dataclass\n", "\n", "# create simulation models\n", "@dataclass\n", "class Checkout():\n", " env: simpy.Environment\n", " lane: simpy.Store = None\n", " t_item: float = 1/10\n", " item_limit: int = 25\n", " t_payment: float = 2.0\n", " \n", " def __post_init__(self):\n", " self.lane = simpy.Store(self.env)\n", " self.env.process(self.process())\n", " \n", " def process(self):\n", " while True:\n", " customer_id, cart, enter_time = yield self.lane.get()\n", " wait_time = env.now - enter_time\n", " yield env.timeout(self.t_payment + cart*self.t_item)\n", " customer_log.append([customer_id, cart, enter_time, wait_time, env.now]) \n", " \n", "@dataclass\n", "class CustomerGenerator():\n", " env: simpy.Environment\n", " rate: float = 1.0\n", " customer_id: int = 1\n", " \n", " def __post_init__(self):\n", " self.env.process(self.process())\n", " \n", " def process(self):\n", " while True:\n", " yield env.timeout(random.expovariate(self.rate))\n", " cart = random.randint(1, 25)\n", " available_checkouts = [checkout for checkout in checkouts if cart <= checkout.item_limit]\n", " checkout = min(available_checkouts, key=lambda checkout: len(checkout.lane.items))\n", " yield checkout.lane.put([self.customer_id, cart, env.now])\n", " self.customer_id += 1\n", "\n", "def lane_logger(t_sample=0.1):\n", " while True:\n", " lane_log.append([env.now] + [len(checkout.lane.items) for checkout in checkouts])\n", " yield env.timeout(t_sample)\n", " \n", "# create simulation environment\n", "env = simpy.Environment()\n", "\n", "# create simulation objects (agents)\n", "CustomerGenerator(env)\n", "checkouts = [\n", " Checkout(env, t_item=1/5, item_limit=25),\n", " Checkout(env, t_item=1/5, item_limit=25),\n", " Checkout(env, item_limit=5),\n", " Checkout(env),\n", " Checkout(env),\n", "]\n", "env.process(lane_logger())\n", "\n", "# run process\n", "customer_log = []\n", "lane_log = []\n", "env.run(until=600)" ] }, { "cell_type": "code", "execution_count": 174, "metadata": { "nbpages": { "level": 2, "link": "[3.10.4 Grocery Store Model](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.4-Grocery-Store-Model)", "section": "3.10.4 Grocery Store Model" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Average waiting time = 4.18 minutes\n", "\n", "Average lane queue \n", "lane 0 1.406500\n", "lane 1 1.192167\n", "lane 2 0.050667\n", "lane 3 0.840000\n", "lane 4 0.635833\n", "dtype: float64\n", "\n", "Overall aaverage lane queue \n", "0.8250\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "

" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def visualize():\n", "\n", " # extract lane data\n", " lane_df = pd.DataFrame(lane_log, columns = [\"time\"] + [f\"lane {n}\" for n in range(0, len(checkouts))])\n", " lane_df = lane_df.set_index(\"time\")\n", "\n", " customer_df = pd.DataFrame(customer_log, columns = [\"customer id\", \"cart items\", \"enter\", \"wait\", \"leave\"])\n", " customer_df[\"elapsed\"] = customer_df[\"leave\"] - customer_df[\"enter\"]\n", "\n", " # compute kpi's\n", " print(f\"Average waiting time = {customer_df['wait'].mean():5.2f} minutes\")\n", " print(f\"\\nAverage lane queue \\n{lane_df.mean()}\")\n", " print(f\"\\nOverall aaverage lane queue \\n{lane_df.mean().mean():5.4f}\")\n", "\n", " # plot results\n", " fig, ax = plt.subplots(3, 1, figsize=(12, 7))\n", " ax[0].plot(lane_df)\n", " ax[0].set_xlabel(\"time / min\")\n", " ax[0].set_title(\"length of checkout lanes\")\n", " ax[0].legend(lane_df.columns)\n", "\n", " ax[1].bar(customer_df[\"customer id\"], customer_df[\"wait\"])\n", " ax[1].set_xlabel(\"customer id\")\n", " ax[1].set_ylabel(\"minutes\")\n", " ax[1].set_title(\"customer waiting time\")\n", "\n", " ax[2].bar(customer_df[\"customer id\"], customer_df[\"elapsed\"])\n", " ax[2].set_xlabel(\"customer id\")\n", " ax[2].set_ylabel(\"minutes\")\n", " ax[2].set_title(\"total elapsed time\")\n", " plt.tight_layout()\n", " \n", "visualize()" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.10.5 Customers as agents](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.5-Customers-as-agents)", "section": "3.10.5 Customers as agents" } }, "source": [ "## 3.10.5 Customers as agents" ] }, { "cell_type": "code", "execution_count": 163, "metadata": { "nbpages": { "level": 2, "link": "[3.10.5 Customers as agents](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.5-Customers-as-agents)", "section": "3.10.5 Customers as agents" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Average waiting time = 3.26 minutes\n", "\n", "Average lane queue \n", "lane 0 1.080167\n", "lane 1 0.954167\n", "lane 2 0.063167\n", "lane 3 0.590333\n", "lane 4 0.362167\n", "dtype: float64\n", "\n", "Overall aaverage lane queue \n", "0.6100\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from dataclasses import dataclass\n", "\n", "# create simulation models\n", "@dataclass\n", "class Checkout():\n", " env: simpy.Environment\n", " lane: simpy.Store = None\n", " t_item: float = 1/10\n", " item_limit: int = 25\n", " t_payment: float = 2.0\n", " \n", " def __post_init__(self):\n", " self.lane = simpy.Store(self.env)\n", " self.env.process(self.process())\n", " \n", " def process(self):\n", " while True:\n", " customer_id, cart, enter_time = yield self.lane.get()\n", " wait_time = env.now - enter_time\n", " yield env.timeout(self.t_payment + cart*self.t_item)\n", " customer_log.append([customer_id, cart, enter_time, wait_time, env.now]) \n", " \n", "@dataclass\n", "class CustomerGenerator():\n", " env: simpy.Environment\n", " rate: float = 1.0\n", " customer_id: int = 1\n", " \n", " def __post_init__(self):\n", " self.env.process(self.process())\n", " \n", " def process(self):\n", " while True:\n", " yield env.timeout(random.expovariate(self.rate))\n", " Customer(self.env, self.customer_id)\n", " self.customer_id += 1\n", " \n", "@dataclass\n", "class Customer():\n", " env: simpy.Environment\n", " id: int = 0\n", " \n", " def __post_init__(self):\n", " self.cart = random.randint(1, 25)\n", " self.env.process(self.process())\n", " \n", " def process(self):\n", " available_checkouts = [checkout for checkout in checkouts if self.cart <= checkout.item_limit]\n", " checkout = min(available_checkouts, key=lambda checkout: len(checkout.lane.items))\n", " yield checkout.lane.put([self.id, self.cart, env.now])\n", " \n", "\n", "def lane_logger(t_sample=0.1):\n", " while True:\n", " lane_log.append([env.now] + [len(checkout.lane.items) for checkout in checkouts])\n", " yield env.timeout(t_sample)\n", " \n", "# create simulation environment\n", "env = simpy.Environment()\n", "\n", "# create simulation objects (agents)\n", "CustomerGenerator(env)\n", "checkouts = [\n", " Checkout(env, t_item=1/5, item_limit=25),\n", " Checkout(env, t_item=1/5, item_limit=25),\n", " Checkout(env, item_limit=5),\n", " Checkout(env),\n", " Checkout(env),\n", "]\n", "env.process(lane_logger())\n", "\n", "# run process\n", "customer_log = []\n", "lane_log = []\n", "env.run(until=600)\n", "\n", "visualize()" ] }, { "cell_type": "markdown", "metadata": { "nbpages": { "level": 2, "link": "[3.10.6 Creating Smart Objects](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.6-Creating-Smart-Objects)", "section": "3.10.6 Creating Smart Objects" } }, "source": [ "## 3.10.6 Creating Smart Objects" ] }, { "cell_type": "code", "execution_count": 145, "metadata": { "nbpages": { "level": 2, "link": "[3.10.6 Creating Smart Objects](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.6-Creating-Smart-Objects)", "section": "3.10.6 Creating Smart Objects" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Average lane queue \n", "lane 0 1.167000\n", "lane 1 0.937500\n", "lane 2 0.056500\n", "lane 3 0.615833\n", "lane 4 0.317333\n", "dtype: float64\n", "\n", "Overall average lane queue \n", "0.6188\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from dataclasses import dataclass, field\n", "import pandas as pd\n", "\n", "# create simulation models\n", "@dataclass\n", "class Checkout():\n", " lane: simpy.Store\n", " t_item: float = 1/10\n", " item_limit: int = 25\n", " \n", " def process(self):\n", " while True:\n", " customer_id, cart, enter_time = yield self.lane.get()\n", " wait_time = env.now - enter_time\n", " yield env.timeout(t_payment + cart*self.t_item)\n", " customer_log.append([customer_id, cart, enter_time, wait_time, env.now]) \n", " \n", "@dataclass\n", "class CustomerGenerator():\n", " rate: float = 1.0\n", " customer_id: int = 1\n", " \n", " def process(self):\n", " while True:\n", " yield env.timeout(random.expovariate(self.rate))\n", " cart = random.randint(1, 25)\n", " available_checkouts = [checkout for checkout in checkouts if cart <= checkout.item_limit]\n", " checkout = min(available_checkouts, key=lambda checkout: len(checkout.lane.items))\n", " yield checkout.lane.put([self.customer_id, cart, env.now])\n", " self.customer_id += 1\n", "\n", "@dataclass\n", "class LaneLogger():\n", " lane_log: list = field(default_factory=list) # this creates a variable that can be modified\n", " t_sample: float = 0.1\n", " lane_df: pd.DataFrame = field(default_factory=pd.DataFrame)\n", " \n", " def process(self):\n", " while True:\n", " self.lane_log.append([env.now] + [len(checkout.lane.items) for checkout in checkouts])\n", " yield env.timeout(self.t_sample)\n", " \n", " def report(self):\n", " self.lane_df = pd.DataFrame(self.lane_log, columns = [\"time\"] + [f\"lane {n}\" for n in range(0, N)])\n", " self.lane_df = self.lane_df.set_index(\"time\")\n", " print(f\"\\nAverage lane queue \\n{self.lane_df.mean()}\")\n", " print(f\"\\nOverall average lane queue \\n{self.lane_df.mean().mean():5.4f}\")\n", " \n", " def plot(self):\n", " self.lane_df = pd.DataFrame(self.lane_log, columns = [\"time\"] + [f\"lane {n}\" for n in range(0, N)])\n", " self.lane_df = self.lane_df.set_index(\"time\") \n", " fig, ax = plt.subplots(1, 1, figsize=(12, 3))\n", " ax.plot(self.lane_df)\n", " ax.set_xlabel(\"time / min\")\n", " ax.set_title(\"length of checkout lanes\")\n", " ax.legend(self.lane_df.columns) \n", " \n", "# create simulation environment\n", "env = simpy.Environment()\n", "\n", "# create simulation objects (agents)\n", "customer_generator = CustomerGenerator()\n", "checkouts = [\n", " Checkout(simpy.Store(env), t_item=1/5),\n", " Checkout(simpy.Store(env), t_item=1/5),\n", " Checkout(simpy.Store(env), item_limit=5),\n", " Checkout(simpy.Store(env)),\n", " Checkout(simpy.Store(env)),\n", "]\n", "lane_logger = LaneLogger()\n", "\n", "# register agents\n", "env.process(customer_generator.process())\n", "for checkout in checkouts:\n", " env.process(checkout.process()) \n", "env.process(lane_logger.process())\n", "\n", "# run process\n", "env.run(until=600)\n", "\n", "# plot results\n", "lane_logger.report()\n", "lane_logger.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "nbpages": { "level": 2, "link": "[3.10.6 Creating Smart Objects](https://jckantor.github.io/CBE40455-2020/03.10-Creating-Simulation-Classes.html#3.10.6-Creating-Smart-Objects)", "section": "3.10.6 Creating Smart Objects" } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "< [3.9 Refinements of a Grocery Store Checkout Operation](https://jckantor.github.io/CBE40455-2020/03.09-Refinements-to-the-Grocery-Store-Checkout-Operation.html) | [Contents](toc.html) | [3.11 Batch Chemical Process](https://jckantor.github.io/CBE40455-2020/03.11-Project-Batch-Chemical-Process.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 }