colab_lab_4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMC7udjSKzxu4Hqbt1lECQd",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nrflynn2/swe-molecular-sciences/blob/main/colab_lab_4.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Lab 4: Cellular Automata\n",
        "\n",
        "Review the lab material and go through the entire notebook. The lab contains 5 exercises for you to solve. The entire lab is worth 2.5% of your final grade and each exercise is worth 0.4% of your final grade. Going through the full notebook is worth 0.5% of your final grade. Any extra credit or bonus exercises are worth an additional 0.4%.\n",
        "\n",
        "Labs are due by Friday at 11:59 PM PST and can be submitted on BCourses assignment page for the corresponding lab.\n",
        "\n",
        "*Part of this lab was inspired by https://towardsdatascience.com/simulating-covid-19-with-cellular-automata-aeb820910a9*"
      ],
      "metadata": {
        "id": "N7fwM8cYF9Jv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Cellular Automata\n",
        "\n",
        "\n",
        "## Introduction\n",
        "\n",
        "From simple rules to complex systems, cellular automata (CA) represent a fascinating intersection of mathematics, computer science, and natural systems modeling. These deceptively simple systems demonstrate how complex behaviors can emerge from basic rules, making them powerful tools for understanding everything from biological growth to urban development.\n",
        "\n",
        "The concept of cellular automata emerged in the 1940s when John von Neumann, aiming to create self-replicating machines, developed the first mathematical model of a cellular automaton. However, it was John Conway's \"Game of Life,\" introduced in 1970, that truly popularized cellular automata. This simple two-dimensional system, with just two states (alive or dead) and a few basic rules, demonstrated how complex patterns and behaviors could emerge from simple rules.\n",
        "\n",
        "At their most basic level, cellular automata are mathematical models consisting of:\n",
        "1. A grid of cells (in one, two, or more dimensions)\n",
        "2. A finite set of possible states for each cell\n",
        "3. A set of rules governing how cells change states\n",
        "4. A neighborhood definition determining which cells influence each other\n",
        "\n",
        "Each cell in the grid updates its state based on its current state and the states of its neighboring cells, following predetermined rules. This process occurs in discrete time steps, creating a dynamic system that can exhibit remarkably complex behavior.\n",
        "\n",
        "Essential functionality for programmatic implementations include:\n",
        "1. An initialization or setup step\n",
        "2. A compute step\n",
        "3. An output and visualization step\n",
        "\n",
        "We'll see a few CA programs later on in this lab.\n",
        "\n",
        "## Fundamental Types and Examples\n",
        "\n",
        "### One-Dimensional Cellular Automata\n",
        "The simplest form of cellular automata exists in one dimension, often visualized as a line of cells that evolves over time. Stephen Wolfram's extensive study of these systems led to his classification of cellular automata into four classes:\n",
        "- Class 1: Evolution leads to a stable, uniform state\n",
        "- Class 2: Evolution leads to simple periodic patterns\n",
        "- Class 3: Evolution produces chaotic, random-looking patterns\n",
        "- Class 4: Evolution creates complex patterns with stable and moving structures\n",
        "\n",
        "### Two-Dimensional Cellular Automata\n",
        "Two-dimensional cellular automata, like Conway's Game of Life, operate on a grid where each cell interacts with its neighbors. Common neighborhood definitions include:\n",
        "- Von Neumann neighborhood: Four adjacent cells (north, south, east, west)\n",
        "- Moore neighborhood: Eight surrounding cells (including diagonals)\n",
        "- Extended neighborhoods: Larger patterns of influence\n",
        "\n",
        "![UN01](https://github.com/nrflynn2/swe-molecular-sciences/blob/main/figures/L04_UN01_Flynn.png?raw=1)\n",
        "\n",
        "## Mathematical Framework\n",
        "\n",
        "A cellular automaton produces a sequences of transformation states for all its cells based on a function that relates every cell’s current\n",
        "state, its neighborhood, and the time step.\n",
        "\n",
        "The mathematical description of cellular automata involves:\n",
        "\n",
        "1. **State Space**: The set of all possible states a cell can occupy\n",
        "   $S = {s₁, s₂, ..., sₖ}$\n",
        "\n",
        "2. **Transition Function**: A rule that determines the next state of a cell\n",
        "   $f: Sⁿ → S$\n",
        "   where n is the number of cells in the neighborhood. Cellular automata changes its states based on inputs and its previous states.\n",
        "\n",
        "3. **Global Configuration**: The state of all cells at a given time\n",
        "   $C(t): Z^d → S$\n",
        "   where d is the dimension of the automaton\n",
        "\n",
        "## Practical Implementation\n",
        "\n",
        "When implementing cellular automata, several considerations are important:\n",
        "\n",
        "1. **Boundary Conditions**\n",
        "   - No boundaries (infinite space)\n",
        "   - Periodic (1D ring or 2D torus)\n",
        "   - Fixed boundaries (walled)\n",
        "   - Cut-off boundaries (no neighbors at the ends)\n",
        "\n",
        "2. **Performance Optimization**\n",
        "   - Parallel processing\n",
        "   - Efficient data structures\n",
        "   - GPU acceleration\n",
        "\n",
        "3. **Visualization Techniques**\n",
        "   - Real-time rendering\n",
        "   - State color mapping\n",
        "   - Pattern detection\n",
        "\n",
        "In addition, we have to consider variations in the input or setup steps:\n",
        "   - Setup a $n \\times m$ grid, where $1 \\leq n, m \\leq MAXSIZE$\n",
        "   - Cellular automaton can be sequential or parallel distributed\n",
        "   - User needs to specify boundary conditions\n",
        "   - User needs to specify states for the variables\n",
        "   - User needs to specify initial configuration for the cellular automaton\n",
        "   - User needs to specify rules\n",
        "     - Rules are expressed through state transition functions\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "ax9UNHtfIx5G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "For example, consider the evolution of the 1-dimensional cellular automaton shown below\n",
        "   - Majority rule (a cell is influenced by the state of its neighboring cells)\n",
        "\n",
        "![UN01](https://github.com/nrflynn2/swe-molecular-sciences/blob/main/figures/L04_UN02_Flynn.png?raw=1)\n",
        "\n",
        "![UN01](https://github.com/nrflynn2/swe-molecular-sciences/blob/main/figures/L04_UN03_Flynn.png?raw=1)\n",
        "\n",
        "## Exercise 1: What happens at t = 2?\n",
        "\n",
        "Each verical line marks the boundary of the cells from the above figure. Show what the state of each cell for t = 2 would be by marking grey cells with an x (similar to as shown in t = 0 and t = 1).\n",
        "\n",
        "t = 0: |x| |x|x| | |x| |x|x| | |x| |x| |\n",
        "\n",
        "t = 1: | |x|x|x| | | |x|x|x| | | |x| | |\n",
        "\n",
        "t = 2: |?|?|?|?|?|?|?|?|?|?|?|?|?|?|?|?|\n"
      ],
      "metadata": {
        "id": "Zm5ycPQWQtjk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Forest Fires, Conway's Game of Life, & Applications to Molecular Sciences\n",
        "\n",
        "## Only You Can Prevent Forest Fires\n",
        "\n",
        "Cellular automata represent a fundamental bridge between simple rules and complex behavior. Their study continues to provide insights into natural processes, computation, and the nature of complexity itself. As we face increasingly complex challenges in science and society, the principles revealed by cellular automata become ever more relevant to our understanding of the world and our ability to model and predict complex systems.\n",
        "\n",
        "Understanding cellular automata opens doors to appreciating how simple rules can generate complex behaviors, a principle that appears repeatedly across disciplines. Whether studying natural systems, designing algorithms, or exploring artificial life, the insights gained from cellular automata provide valuable perspectives on the nature of computation and complexity.\n",
        "\n",
        "Let's look deeper into some applications, starting with a simulation for forest fires. The following Forest Fire Simulation code implements a cellular automaton model commonly known as the \"Forest Fire Model,\" which simulates the dynamic behavior of forest fires in a simplified ecosystem.\n",
        "\n",
        "At its core, the simulation runs on a 2D grid where each cell represents one of three states: empty ground (0), a living tree (1), or a burning tree (2). The grid is implemented using a NumPy array, and the simulation follows a set of probabilistic rules that govern the transition between states, creating a complex system from simple rules:\n",
        "   - Empty cells can spontaneously grow new trees with a small probability (p_growth)\n",
        "   - Trees can catch fire either from adjacent burning trees or through random lightning strikes (p_lightning)\n",
        "   - Burning trees burn out completely in one time step, becoming empty cells\n",
        "\n",
        "The implementation uses a class-based structure (ForestFireSimulation) that encapsulates all the necessary methods and state. The core update logic iterates through each cell in the grid and applies the rules based on the current state and neighborhood conditions. The simulation uses a Moore neighborhood (all 8 surrounding cells) to determine fire spread.\n",
        "\n",
        "The color mapping in the visualization is:\n",
        "   - Gray for empty\n",
        "   - Green for trees\n",
        "   - Red for fire\n",
        "\n",
        "The cellular automaton transition behavior along with animations make it easy to observe the dynamics of fire spread and forest regeneration. We could further customize the following parameters to see how it affects the forest fire dynamics:\n",
        "   - Grid dimensions\n",
        "   - Growth probability\n",
        "   - Lightning strike probability\n",
        "   - Initial forest density"
      ],
      "metadata": {
        "id": "r9uBueyWIx8A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib import colors\n",
        "import matplotlib.animation as animation\n",
        "from IPython.display import HTML\n",
        "\n",
        "class ForestFireSimulation:\n",
        "    def __init__(self, width=50, height=50, p_growth=0.01, p_lightning=0.001):\n",
        "        \"\"\"\n",
        "        Initialize the forest fire simulation.\n",
        "\n",
        "        Parameters:\n",
        "        width, height: Dimensions of the grid\n",
        "        p_growth: Probability of a new tree growing\n",
        "        p_lightning: Probability of lightning striking a tree\n",
        "        \"\"\"\n",
        "        self.width = width\n",
        "        self.height = height\n",
        "        self.p_growth = p_growth\n",
        "        self.p_lightning = p_lightning\n",
        "\n",
        "        # States: 0 = empty, 1 = tree, 2 = burning\n",
        "        self.grid = np.random.choice([0, 1], size=(height, width), p=[0.4, 0.6])\n",
        "\n",
        "        # Color map for visualization\n",
        "        self.colors = colors.ListedColormap(['lightgray', 'darkgreen', 'red'])\n",
        "        self.bounds = [0, 0.5, 1.5, 2.5]\n",
        "        self.norm = colors.BoundaryNorm(self.bounds, self.colors.N)\n",
        "\n",
        "    def update(self):\n",
        "        \"\"\"Update the forest state according to the rules.\"\"\"\n",
        "        new_grid = self.grid.copy()\n",
        "\n",
        "        for i in range(self.height):\n",
        "            for j in range(self.width):\n",
        "                if self.grid[i, j] == 0:  # Empty\n",
        "                    # Tree can grow in empty cell\n",
        "                    if np.random.random() < self.p_growth:\n",
        "                        new_grid[i, j] = 1\n",
        "\n",
        "                elif self.grid[i, j] == 1:  # Tree\n",
        "                    # Check if any neighbors are burning\n",
        "                    for di in [-1, 0, 1]:\n",
        "                        for dj in [-1, 0, 1]:\n",
        "                            if (0 <= i + di < self.height and\n",
        "                                0 <= j + dj < self.width and\n",
        "                                self.grid[i + di, j + dj] == 2):\n",
        "                                new_grid[i, j] = 2\n",
        "                                break\n",
        "\n",
        "                    # Lightning strike can start new fire\n",
        "                    if new_grid[i, j] != 2 and np.random.random() < self.p_lightning:\n",
        "                        new_grid[i, j] = 2\n",
        "\n",
        "                elif self.grid[i, j] == 2:  # Burning\n",
        "                    # Burning trees become empty\n",
        "                    new_grid[i, j] = 0\n",
        "\n",
        "        self.grid = new_grid\n",
        "        return self.grid\n",
        "\n",
        "    def animate(self, num_frames=200):\n",
        "        \"\"\"Create an animation of the forest fire simulation.\"\"\"\n",
        "        fig = plt.figure(figsize=(10, 10))\n",
        "\n",
        "        def update(frame):\n",
        "            plt.clf()\n",
        "            self.update()\n",
        "            plt.imshow(self.grid, cmap=self.colors, norm=self.norm)\n",
        "            plt.title(f'Forest Fire Simulation - Frame {frame}')\n",
        "            plt.axis('off')\n",
        "\n",
        "        anim = animation.FuncAnimation(fig, update, frames=num_frames,\n",
        "                                     interval=100, repeat=False)\n",
        "        plt.close()\n",
        "        return anim\n",
        "\n",
        "    def run_single_step(self):\n",
        "        \"\"\"Run a single step of the simulation and display the current state.\"\"\"\n",
        "        self.update()\n",
        "        plt.figure(figsize=(10, 10))\n",
        "        plt.imshow(self.grid, cmap=self.colors, norm=self.norm)\n",
        "        plt.title('Forest Fire Simulation')\n",
        "        plt.axis('off')\n",
        "        plt.show()\n",
        "\n",
        "    def run_multi_step(self, steps):\n",
        "        for _ in range(steps):\n",
        "          self.update()\n",
        "        plt.figure(figsize=(10, 10))\n",
        "        plt.imshow(self.grid, cmap=self.colors, norm=self.norm)\n",
        "        plt.title('Forest Fire Simulation')\n",
        "        plt.axis('off')\n",
        "        plt.show()"
      ],
      "metadata": {
        "id": "H6FR8yUMT80T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the following cell, we create a simulation object with an initial configuation and we walk through one step of the simulation."
      ],
      "metadata": {
        "id": "OGoroyfAaYP0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the simulation object\n",
        "sim = ForestFireSimulation(\n",
        "    width=50,\n",
        "    height=50,\n",
        "    p_growth=0.01,\n",
        "    p_lightning=0.001\n",
        ")\n",
        "\n",
        "sim.run_single_step()"
      ],
      "metadata": {
        "id": "hcXV-Mf6Uh3P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's now fast-forward 100 steps into the simulation to see how the forest has changed.\n",
        "\n",
        "Ouch! The amount of active fires is not that high but we can see that, over time, a lot of damage has been caused to the forest's ecosystem :("
      ],
      "metadata": {
        "id": "U1M0yB2cahDr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sim.run_multi_step(100)"
      ],
      "metadata": {
        "id": "ylS2nnA7VBQ2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Exercise 2\n",
        "\n",
        "Consider two additional scenarios, rapid_spread and slow_growth. Show the state of each scenario when running the multi step function for 100 steps. In maximum 4 sentences, explain:\n",
        "  - What do the states at t = 100 for both rapid_spread and slow_growth look like\n",
        "  - Compare and contrast the forest fire dynamics that both scenarios are modeling\n",
        "  - What was the joint role played by both p_growth and p_lightning for each scenario?\n",
        "  - Did either of the simulations result in elimination of any active fires? If so, how?\n",
        "  - Did either of the simulations result in close to half the board containing active fires? If so, how?"
      ],
      "metadata": {
        "id": "EBtKr9Hpax2U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Different simulation scenarios:\n",
        "\n",
        "# Rapid spread scenario\n",
        "rapid_spread = ForestFireSimulation(\n",
        "    width=50,\n",
        "    height=50,\n",
        "    p_growth=0.5,\n",
        "    p_lightning=0.1\n",
        ")\n",
        "\n",
        "# Slow growth scenario\n",
        "slow_growth = ForestFireSimulation(\n",
        "    width=50,\n",
        "    height=50,\n",
        "    p_growth=0.005,\n",
        "    p_lightning=0.00001\n",
        ")"
      ],
      "metadata": {
        "id": "a06OwsTsUH5f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rapid_spread.run_multi_step(100)"
      ],
      "metadata": {
        "id": "uYjo4BtTVh_U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "slow_growth.run_multi_step(100)"
      ],
      "metadata": {
        "id": "450GTzKzVmZN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To model additional behaviors of interest, we could also extend the simulation, e.g.,:\n",
        "  - Adding wind direction and strength to affect fire spread probability\n",
        "  - Implementing terrain elevation that influences fire behavior\n",
        "  - Adding seasonal variations in growth and fire probability\n",
        "  - Including fire resistance variations among different tree types\n",
        "  - Implementing fire-fighting interventions\n",
        "  - Adding moisture levels that affect both growth and fire spread\n",
        "  - Collecting and analyzing statistics about fire size and frequency\n",
        "  - Implementing more sophisticated growth patterns based on tree density\n",
        "  - Adding varying degrees of fire damage instead of complete destruction\n",
        "\n",
        "As we just saw, simulations such as the forest fire program can be useful tools, with practical applications in:\n",
        "  - Understanding concepts in complex systems and emergence\n",
        "  - Demonstrating basic principles of wildfire behavior\n",
        "  - Exploring how different parameters affect system dynamics\n",
        "  - Studying the role of randomness in natural systems\n",
        "\n",
        "Let's reflect more on emergent behavior through John Conway's Game of Life."
      ],
      "metadata": {
        "id": "RrS0lDjTWcxT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conway's Game of Life\n",
        "\n",
        "Conway's Game of Life is deceptively simple. Given an infinite two-dimensional grid of cells, each of which can either be [dead/empty/unpopulated] or [alive/full/populated], the game obeys the following four rules (neighbor means any of the eight surrounding cells):\n",
        "\n",
        "  - Any live cell with fewer than two live neighbors dies, as if by underpopulation.\n",
        "  - Any live cell with two or three live neighbors lives on to the next generation.\n",
        "  - Any live cell with more than three live neighbors dies, as if by overpopulation.\n",
        "  - Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.\n",
        "\n",
        "These rules are applied to every cell on the board at once; each iteration is one time step. Watch the following video for a few demosntrative examples:https://www.youtube.com/watch?v=ouipbDkwHWA\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "4JF_mbuycNcU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The primary significance of the \"game\" is that very simple rules can create systems of breathtaking complexity. The game only has four basic rules, and yet you can create oscillators, glider guns (the first pattern that provably could grow forever), and even ultimately a general purpose computer. Below are a few links that demonstrate these complex behaviors (you should at least go through the first one):\n",
        "  - Glider gun (hit \"Start\" to initiate simulation): https://playgameoflife.com/lexicon/Gosper_glider_gun\n",
        "    - You can explore additional configurations and their behavior through the \"Lexicon\"\n",
        "  - Conway's Game of Life simulation that reproduces itself (i.e., simulation within a simulation): https://www.youtube.com/watch?v=xP5-iIeKXE8\n",
        "  - Building a computer in Conway's Game of Life: https://www.youtube.com/watch?v=Kk2MH9O4pXY\n",
        "  - Showcase of other dynamics these simple rules can model (ignore the dramatic music...): https://www.youtube.com/watch?v=C2vgICfQawE\n",
        "  - Origin of the Game of Life as described by John Conway: https://www.youtube.com/watch?v=R9Plq-D1gEk\n",
        "\n",
        "\"Emergence\" is the concept that a complex system can arise from small simple interactions. In other words, a bunch of little simple things that interact with each other can result in an enormously complex thing. The collection of things can have properties not present in any of the individual things. The implications are vast.\n",
        "  - Individual ants behave under simple rules. However, a colony of ants is collectively intelligent and able to solve complex problems.\n",
        "  - Water molecules are individually quite simple. Who would look at a water molecule and predict that freezing a bunch of them would produce intricate snowflakes?\n",
        "  - Several types of models, such as LLMs, are the result of many many simple matrix multiplications that collectively find, store, and reproduce complex patterns, which has been offered as an analogy to human conscience resulting from electrical impulses.\n",
        "\n",
        "Conway's Game of Life is the most obvious illustration of this concept. It's Turing complete and, with just 4 simple rules, provides a model of computation that can compute anything a Turin machine can, meaning it can simulate a computer. There also exist other cellular automata that are computationally universal, meaning they can simulate any computer program."
      ],
      "metadata": {
        "id": "rt9GDxw8csAc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Example Applications in Molecular Sciences\n",
        "\n",
        "Recent research has shown that cellular automata principles can be implemented using DNA molecules, such as DNA Tile Assembly:\n",
        "- Implementation of binary cellular automata using DNA tiles\n",
        "- Self-assembling DNA structures that compute logical operations\n",
        "- Error correction in molecular computing systems\n",
        "\n",
        "Current research applies cellular automata to understand molecular self-organization, such as protein Folding Dynamics:\n",
        "- Lattice models of protein folding\n",
        "- Energy landscape exploration\n",
        "- Prediction of secondary structures\n",
        "\n",
        "and membrane Organization:\n",
        "- Lipid raft formation\n",
        "- Protein clustering\n",
        "- Signal transduction pathways\n",
        "\n",
        "There are also applications related to drug-target interaction prediction:\n",
        "- Cellular automata models of molecular docking\n",
        "- Drug resistance evolution\n",
        "- Hybrid CA-MD models"
      ],
      "metadata": {
        "id": "PDcNy4m5gJCQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Exercise 3\n",
        "\n",
        "True or False. John Conway's Game of Life Cellular Automaton is capable of simulating any computer program, including a computer itself.\n",
        "\n",
        "Answer:"
      ],
      "metadata": {
        "id": "kztqvqK5haVe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Simulating COVID-19 with Cellular Automata\n",
        "\n",
        "Modeling the spread of a novel virus and its resulting disease is an important step in learning proper preventive measures. An example of such a simulation for COVID-19 is demonstrated in the following article published in the Washington Post advocating the importance of social distancing: https://www.washingtonpost.com/graphics/2020/world/corona-simulator/\n",
        "\n",
        "The following simulation studies the effect of different safety policies under epidemiological conditions, such as influence of social distancing and wearing a mask. You should read the implementation details of the simulation described in detail at https://www.washingtonpost.com/graphics/2020/world/corona-simulator/, specifically:\n",
        "- The Environment\n",
        "- Movement and Social Distancing\n",
        "- The Timeline of Infection\n",
        "- Infection Model and Wearing a Mask\n",
        "- Safety Policies\n",
        "- Statistics and Probabilities\n",
        "\n",
        "Visually, the simulation uses the following representation of cells:\n",
        "- Color\n",
        "  - Green is an individual susceptible to infection\n",
        "  - Red is an individual who is infected\n",
        "  - Blue is an individual that has recovered\n",
        "- Shape\n",
        "  - Squares are non-social distancing individuals\n",
        "  - Circles are social distancing individuals"
      ],
      "metadata": {
        "id": "mb-qQq7_Ix_M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You are not expected to understand the implementation details of the following classes to complete the lab exercises. To aid optional understanding  of the implementations, we'll review some details.\n",
        "\n",
        "The Person class simulates an individual in our epidemic/disease transmission model. The Person class models a person with various characteristics and behaviors related to disease transmission, progression, and social behaviors.\n",
        "\n",
        "**Basic attributes of the Person:**\n",
        "\n",
        "- Position in some space\n",
        "- Age\n",
        "- Social distancing status (before and during symptoms)\n",
        "- Mask wearing status (before and during symptoms)\n",
        "- Movement probability (how likely they are to move around)\n",
        "- Altruistic behavior (whether they'll take precautions when sick)\n",
        "\n",
        "**Disease status:**\n",
        "\n",
        "- Can be susceptible, infected, or recovered\n",
        "- Tracks how many other people they've infected\n",
        "- Records information about their behavior during infectious periods (whether they social distanced or wore masks)\n",
        "\n",
        "**Disease progress:**\n",
        "\n",
        "The disease progression model has several phases:\n",
        "- Infection Stages:\n",
        "  - Latent (infected but not infectious)\n",
        "  - Infectious (can spread to others)\n",
        "  - Removal (no longer infectious)\n",
        "  - Recovery\n",
        "- Symptom Stages:\n",
        "  - Incubation (no symptoms yet)\n",
        "  - Can follow one of four paths:\n",
        "    * Asymptomatic then recovery\n",
        "    * Mild symptoms then recovery\n",
        "    * Mild symptoms, then severe symptoms, then death\n",
        "    * Mild symptoms, then severe symptoms, then recovery\n",
        "\n",
        "**Behavior changes:**\n",
        "\n",
        "- If the person is \"altruistic\" and develops mild symptoms, they:\n",
        "  * Reduce their movement\n",
        "  * Start wearing a mask\n",
        "  * Begin social distancing\n",
        "- If they develop severe symptoms:\n",
        "  * Stop moving around\n",
        "  * Wear a mask\n",
        "  * Practice social distancing\n",
        "\n",
        "**Infection Mechanics:**\n",
        "\n",
        "- Has a method to determine if a person becomes infected based on:\n",
        "  * Number of infectious neighbors\n",
        "  * Base infection probability\n",
        "  * Whether infected neighbors are wearing masks\n",
        "  * Uses a Kermack-McKendrick model for calculating infection probability"
      ],
      "metadata": {
        "id": "lrL_GIzFoWGq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Notes:\n",
        "- There are separate probabilities for wearing a mask and social distancing, meaning some people will do both, one or the other\n",
        "  or neither\n",
        "- There is an altruistic prob, where people who get mild symptoms have a chance of wearing a mask and social\n",
        "  distancing (for as long as their symptoms last) if they weren't before.\n",
        "    - It also says whether someone will intentionally move at a low rate\n",
        "- People who experience severe symptoms will automatically wear masks and social distance and no longer intentionally move\n",
        "  but just move defensively\n",
        "'''\n",
        "class Person:\n",
        "    def __init__(self, position, age, social_distance, wear_mask, movement_prob, low_movement_prob, altruistic_prob, infected,\n",
        "                 total_length_infection, incubation_period_duration_range, infectious_start_before_symptoms_range,\n",
        "                 infectious_period_duration_range, severe_symptoms_start_range, fatality_occur_range,\n",
        "                 asymptomatic_prob, severe_prob, fatality_prob):\n",
        "        self.set_position(position)\n",
        "        self.age = age\n",
        "        self.social_distance = social_distance\n",
        "        self.social_distance_before_symptoms = social_distance\n",
        "        self.wear_mask = wear_mask\n",
        "        self.wear_mask_before_symptoms = wear_mask\n",
        "        self.movement_prob = movement_prob\n",
        "        self.low_movement_prob = low_movement_prob\n",
        "        self.movement_prob_before_symptoms = movement_prob\n",
        "        self.altruistic = np.random.random() < altruistic_prob\n",
        "\n",
        "        self.susceptible = not infected\n",
        "        self.infected = infected\n",
        "        # Most literature says that prob. of reinfection is very low of nonexistent at least in a short period of time\n",
        "        # But scientists are still not sure\n",
        "        self.recovered = False\n",
        "        self.infection_step = -1\n",
        "        # Keeps track of num of people that this person has infected (or contributed to the infection of)\n",
        "        self.num_people_infected = 0\n",
        "        # Also for R0 keep track of number of days during infectious phase they were SD and WM\n",
        "        self.infectious_days_info = {'SD': 0, 'not SD': 0, 'WM': 0, 'not WM': 0}\n",
        "\n",
        "        # CREATE INFECTION PERIODS -----\n",
        "        incubation_period_duration = np.random.randint(incubation_period_duration_range[0],\n",
        "                                                       incubation_period_duration_range[1] + 1)\n",
        "        infectious_start_before_symptoms = np.random.randint(infectious_start_before_symptoms_range[0],\n",
        "                                                             infectious_start_before_symptoms_range[1] + 1)\n",
        "        infectious_period_duration = np.random.randint(infectious_period_duration_range[0],\n",
        "                                                       infectious_period_duration_range[1] + 1)\n",
        "        severe_symptoms_start = np.random.randint(severe_symptoms_start_range[0], severe_symptoms_start_range[1] + 1)\n",
        "        fatality_occur = np.random.randint(fatality_occur_range[0], fatality_occur_range[1] + 1)\n",
        "\n",
        "        # Create Infection periods\n",
        "        infectious_period_start = incubation_period_duration - infectious_start_before_symptoms\n",
        "        assert infectious_period_start >= 1, \\\n",
        "            '{} is wrong: infectious period start should be greater than 0 because latent period is at least one day'.format(\n",
        "                infectious_period_start)\n",
        "        removed_period_start = infectious_period_duration + infectious_period_start\n",
        "        assert removed_period_start < total_length_infection, \\\n",
        "            '{} is wrong: removal should be less than the total length of infection'.format(removed_period_start)\n",
        "        # total_length = total_length_infection if removed_period_start < total_length_infection else removed_period_start + 1\n",
        "        total_length = total_length_infection\n",
        "        self.infectious_periods = [('latent', 0),\n",
        "                                   ('infectious', infectious_period_start),\n",
        "                                   ('remove', removed_period_start),\n",
        "                                   ('recover', total_length)]\n",
        "\n",
        "        # Symptoms is more complicated\n",
        "        self.symptoms_periods = [('incubation', 0)]\n",
        "        symptoms_start = incubation_period_duration\n",
        "        assert symptoms_start > infectious_period_start, \\\n",
        "            'Symptoms ({}) start during infectious stage (starts {})'.format(symptoms_start, infectious_period_start)\n",
        "        assert symptoms_start < removed_period_start, \\\n",
        "            'Symptoms ({}) start during infectious stage (starts {})'.format(symptoms_start, infectious_period_start)\n",
        "        # 1) Some people are asymptomatic (and have no mild or severe symptoms, and also cant die)\n",
        "        if np.random.random() < asymptomatic_prob:\n",
        "            self.symptoms_periods.append(('asymptomatic', symptoms_start))\n",
        "        # 2) If they arent asymptomatic they start with mild\n",
        "        else:\n",
        "            self.symptoms_periods.append(('mild', symptoms_start))\n",
        "            # 3) Can have severe (or not)\n",
        "            if np.random.random() < severe_prob:\n",
        "                severe_start_abs = severe_symptoms_start + symptoms_start\n",
        "                assert severe_start_abs <= total_length, \\\n",
        "                    'severe symptoms should start ({}) before end of infection'.format(severe_start_abs)\n",
        "                self.symptoms_periods.append(('severe', severe_start_abs))\n",
        "                # 4) Can die (or not)\n",
        "                if np.random.random() < fatality_prob:\n",
        "                    fatality_start_abs = fatality_occur + severe_symptoms_start + symptoms_start\n",
        "                    assert fatality_start_abs <= total_length, \\\n",
        "                        'fatality should occur ({}) before end of infection'.format(fatality_start_abs)\n",
        "                    self.symptoms_periods.append(('death', fatality_start_abs))\n",
        "        # 5) If didnt die then recover\n",
        "        if self.symptoms_periods[-1][0] != 'death':\n",
        "            self.symptoms_periods.append(('recover', total_length))\n",
        "        # Make sure the symptoms periods is one of 4 diff combinations\n",
        "        possible_permutations = [['incubation', 'asymptomatic', 'recover'],\n",
        "                                 ['incubation', 'mild', 'recover'],\n",
        "                                 ['incubation', 'mild', 'severe', 'death'],\n",
        "                                 ['incubation', 'mild', 'severe', 'recover']]\n",
        "        assert [item[0] for item in self.symptoms_periods] in possible_permutations, \\\n",
        "            '{} not a possible symptoms stages permutation'.format(possible_permutations)\n",
        "\n",
        "        self.current_symptom_stage = None\n",
        "        self.current_infection_stage = None\n",
        "\n",
        "    def set_position(self, position):\n",
        "        self.position = position\n",
        "\n",
        "    # Not just infected but infectious\n",
        "    def is_infectious(self):\n",
        "        return self.current_infection_stage == 'infectious'\n",
        "\n",
        "    # Progress the infection of an infected person in both infectiousness and symptoms\n",
        "    def progress_infection(self, data_collector):\n",
        "        if not self.infected:\n",
        "            return False, None\n",
        "        if self.is_infectious():\n",
        "            if self.social_distance: self.infectious_days_info['SD'] += 1\n",
        "            else: self.infectious_days_info['not SD'] += 1\n",
        "            if self.wear_mask: self.infectious_days_info['WM'] += 1\n",
        "            else: self.infectious_days_info['not WM'] += 1\n",
        "        self.infection_step += 1\n",
        "        new_infection_stage = False\n",
        "        new_symptoms_stage = False\n",
        "        # If gets to new stage then pop off first\n",
        "        if self.infection_step == self.infectious_periods[0][1]:\n",
        "            self.current_infection_stage = self.infectious_periods[0][0]\n",
        "            self.infectious_periods.pop(0)\n",
        "            new_infection_stage = True\n",
        "\n",
        "        if self.infection_step == self.symptoms_periods[0][1]:\n",
        "            self.current_symptom_stage = self.symptoms_periods[0][0]\n",
        "            self.symptoms_periods.pop(0)\n",
        "            new_symptoms_stage = True\n",
        "\n",
        "        # If dead then return true\n",
        "        if self.current_symptom_stage == 'death':\n",
        "            return True, None\n",
        "\n",
        "        new_SD = None\n",
        "        # If mild symptoms check altruistic prob to see what happens\n",
        "        if self.current_symptom_stage == 'mild' and self.altruistic and new_symptoms_stage:\n",
        "            self.movement_prob = self.low_movement_prob\n",
        "            self.wear_mask = True\n",
        "            new_SD = True if not self.social_distance else None\n",
        "            self.social_distance = True\n",
        "        elif self.current_symptom_stage == 'severe' and new_symptoms_stage:\n",
        "            # Severe means SD and WM and NO non-defensive movement\n",
        "            # todo: Might turn off ALL movement at this stage\n",
        "            self.movement_prob = 0.\n",
        "            self.wear_mask = True\n",
        "            new_SD = True if not self.social_distance else None\n",
        "            self.social_distance = True\n",
        "\n",
        "        # If not dead and end of infection then recovered\n",
        "        if self.current_infection_stage == 'recover' and new_infection_stage:\n",
        "            self.recovered = True\n",
        "            self.infected = False\n",
        "            self.susceptible = False\n",
        "            self.wear_mask = self.wear_mask_before_symptoms\n",
        "            new_SD = self.social_distance_before_symptoms if self.social_distance != self.social_distance_before_symptoms else None\n",
        "            self.social_distance = self.social_distance_before_symptoms\n",
        "            self.movement_prob = self.movement_prob_before_symptoms\n",
        "            self.current_symptom_stage = None\n",
        "            data_collector.add_lifetime_infected(self.num_people_infected, self.infectious_days_info)\n",
        "\n",
        "        return False, new_SD\n",
        "\n",
        "    # Check if person is infected given the number of infected (and in infectious phase) people\n",
        "    # in its immediate neighborhood\n",
        "    def gets_infected(self, infectious_neighbors, base_infection_prob, mask_infection_prob_decrease, data_collector):\n",
        "        # Skip if already infected or recovered\n",
        "        if self.infected or self.recovered or len(infectious_neighbors) == 0:\n",
        "            return False\n",
        "        # Use Kermack-McKendrick Model of infection probability\n",
        "        # 1 - (1 - p) ^ r; p -> infection prob of one person; r -> number of infectious people\n",
        "        # If an infectious person is wearing a mask then the probability of infecting this susceptible person goes down\n",
        "        p = [base_infection_prob + (-1. * (neighbor.wear_mask * mask_infection_prob_decrease)) for neighbor in infectious_neighbors]\n",
        "        p = sum(p) / len(p)\n",
        "        r = len(infectious_neighbors)\n",
        "        I_prob = 1 - (1 - p) ** r\n",
        "\n",
        "        if np.random.random() < I_prob:\n",
        "            self.infected = True\n",
        "            self.susceptible = False\n",
        "            self.current_symptom_stage = self.symptoms_periods[0][0]\n",
        "            self.current_infection_stage = self.infectious_periods[0][0]\n",
        "            self.infectious_periods.pop(0)\n",
        "            self.symptoms_periods.pop(0)\n",
        "            self.infection_step = 0\n",
        "            data_collector.increment_total_infected()\n",
        "            return True\n",
        "        return False"
      ],
      "metadata": {
        "id": "aVReRJf08tKu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The DataCollector class is a comprehensive data tracking and visualization system for the epidemic simulation, including:\n",
        "\n",
        "**Basic data tracking:**\n",
        "- Tracks key epidemic metrics:\n",
        "  * Number of Susceptible (S), Infected (I), and Recovered (R) people\n",
        "  * Number of people Wearing Masks (WM) and Social Distancing (SD)\n",
        "  * Count of deaths and different symptom severities (mild, severe, asymptomatic)\n",
        "- Maintains both current values and historical records of these metrics\n",
        "\n",
        "**Advanced metrics collection:**\n",
        "- Secondary Attack Rate (SAR): Measures how many susceptible people eventually get infected\n",
        "- Basic Reproduction Number (R0): Tracks how many people each infected person infects\n",
        "- R0S: Calculates R0 multiplied by number of susceptible people (important for epidemic dynamics)\n",
        "- Tracks detailed infection data based on behaviors:\n",
        "  * People who social distance vs those who don't\n",
        "  * People who wear masks vs those who don't\n",
        "  * People who do both or neither\n",
        "\n",
        "**Data analysis features:**\n",
        "- Groups infection data into time bins (default 5 time steps)\n",
        "- Calculates averages for different behavioral groups\n",
        "- Tracks how different preventive measures (masks, social distancing) affect transmission\n",
        "\n",
        "**Visualizations:**\n",
        "- Creates four different plots showing:\n",
        "  * Infection patterns based on social distancing\n",
        "  * R0 values for different behavioral groups\n",
        "  * R0S values for different behavioral groups\n",
        "- Can print regular updates during simulation\n",
        "- Allows customization of which metrics to display and how often\n",
        "\n",
        "**Data storage:**\n",
        "- Can save all experimental data including:\n",
        "  * Simulation constants and parameters\n",
        "  * Visualization plots\n",
        "  * Detailed CSV files with all metrics\n",
        "  * Basic and advanced infection data\n",
        "  * R0 and R0S histories\n",
        "  * Secondary Attack Rate results"
      ],
      "metadata": {
        "id": "2Egq7ZqhsVgV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import OrderedDict\n",
        "import os\n",
        "from datetime import datetime\n",
        "import json\n",
        "import pandas as pd\n",
        "\n",
        "\n",
        "data_options = ['S', 'I', 'R', 'WM', 'SD', 'death', 'mild', 'severe', 'asymptomatic']\n",
        "\n",
        "# SAR -> Secondary Attack Rate = total # infected people / total # susceptible (overall metric, ie calculated at end)\n",
        "# R0 -> Basic Reproductive Number = The number of people an infected person directly infects\n",
        "# R0S -> R0 x S -> If > 1 then can multiply, = 1 then can become endemic (persistent but tame), < 1 then can die off\n",
        "advanced_equations = ['SAR', 'R0', 'R0S']\n",
        "\n",
        "\n",
        "class DataCollector:\n",
        "    def __init__(self, constants, save_experiment, print_visualizations):\n",
        "        self.constants = constants\n",
        "        self.save_experiment = save_experiment\n",
        "        self.print_visualizations = print_visualizations\n",
        "        self.basic_to_print = None\n",
        "        self.adv_to_print = None\n",
        "        self.frequency_print = 1\n",
        "        self._reset_data_options(hist=True)\n",
        "        # Advanced Infection data collection\n",
        "        # WM, SD, both, neither, total\n",
        "        self.adv_infection_data = {'total': 0, 'SD': 0, 'not SD': 0}\n",
        "        self.adv_infection_data_history = OrderedDict({'total': [], 'SD': [], 'not SD': []})\n",
        "        # For adv equations\n",
        "        # For SAR (Secondary Attack Rate) need total number of infected overtime\n",
        "        self.total_infected = 0\n",
        "        # And need number of S not including initial infected\n",
        "        self.initial_S = 0\n",
        "        # For R0 need the current number of each infection lifetime for the current bin\n",
        "        self.lifetime_infected_bin_size = 5\n",
        "        self.current_bin_lifetime_infected = []\n",
        "        # Saves all the bin averages\n",
        "        self.lifetime_infected_bin_avgs = OrderedDict()\n",
        "        self.last_bin_avgs = {'total': None, 'SD': None, 'not SD': None, 'WM': None, 'not WM': None, 'both': None, 'neither': None}\n",
        "\n",
        "    def _reset_data_options(self, hist=False):\n",
        "        self.current_data = {}\n",
        "        if hist: self.data_history = OrderedDict()\n",
        "        for k in data_options:\n",
        "            self.current_data[k] = 0\n",
        "            if hist: self.data_history[k] = []\n",
        "\n",
        "    def set_print_options(self, basic_to_print='all', adv_to_print='all', frequency=1):\n",
        "        self.basic_to_print = data_options if basic_to_print == 'all' else basic_to_print\n",
        "        self.adv_to_print = advanced_equations if adv_to_print == 'all' else adv_to_print\n",
        "        self.frequency_print = frequency\n",
        "\n",
        "    def increment_total_infected(self):\n",
        "        self.total_infected += 1\n",
        "\n",
        "    def increment_initial_S(self):\n",
        "        self.initial_S += 1\n",
        "\n",
        "    def _update_adv_infection_data(self, person):\n",
        "        SD = person.social_distance\n",
        "        not_SD = not SD\n",
        "        self.adv_infection_data['total'] += 1\n",
        "        if SD: self.adv_infection_data['SD'] += 1\n",
        "        if not_SD: self.adv_infection_data['not SD'] += 1\n",
        "\n",
        "    def update_data(self, person):\n",
        "        self.current_data['S'] += person.susceptible\n",
        "        self.current_data['I'] += person.infected\n",
        "        if person.infected:\n",
        "            self._update_adv_infection_data(person)\n",
        "        self.current_data['R'] += person.recovered\n",
        "        self.current_data['WM'] += person.wear_mask\n",
        "        self.current_data['SD'] += person.social_distance\n",
        "        if person.current_symptom_stage == 'mild':\n",
        "            self.current_data['mild'] += 1\n",
        "        elif person.current_symptom_stage == 'severe':\n",
        "            self.current_data['severe'] += 1\n",
        "        elif person.current_symptom_stage == 'asymptomatic':\n",
        "            self.current_data['asymptomatic'] += 1\n",
        "\n",
        "    def increment_death_data(self, person):\n",
        "        self.current_data['death'] += 1\n",
        "\n",
        "    def add_lifetime_infected(self, num_infected, infectious_days_info):\n",
        "        # Bin infectious_days_info into majority SD, minority SD, majority WM, minority WM (ie did they SD more often then not)\n",
        "        SD = infectious_days_info['SD'] > infectious_days_info['not SD']\n",
        "        WM = infectious_days_info['WM'] > infectious_days_info['not WM']\n",
        "        both = SD and WM\n",
        "        neither = not SD and not WM\n",
        "        self.current_bin_lifetime_infected.append({'total': num_infected, 'SD': SD, 'not SD': not SD, 'WM': WM,\n",
        "                                                   'not WM': not WM, 'both': both, 'neither': neither})\n",
        "\n",
        "    def reset(self, timestep, last=False):\n",
        "        # Aggregate history data\n",
        "        for key, value in list(self.current_data.items()):\n",
        "            self.data_history[key].append(value)\n",
        "        for key, value in list(self.adv_infection_data.items()):\n",
        "            self.adv_infection_data_history[key].append(value)\n",
        "            self.adv_infection_data[key] = 0\n",
        "        # If bin is done in lifetime infected get avg and empty bin\n",
        "        if timestep % self.lifetime_infected_bin_size == 0 and timestep != 0:\n",
        "            self.lifetime_infected_bin_avgs[timestep] = {}\n",
        "            # If no one infected recovered/died them move on\n",
        "            if len(self.current_bin_lifetime_infected) == 0:\n",
        "                # Set to the last avgs initially and if new ones then set them\n",
        "                for k, last_avg in list(self.last_bin_avgs.items()):\n",
        "                    self.lifetime_infected_bin_avgs[timestep][k] = last_avg\n",
        "            else:\n",
        "                for k in list(self.last_bin_avgs.keys()):\n",
        "                    bin_arr = [dic['total'] for dic in self.current_bin_lifetime_infected if dic[k]]\n",
        "                    if len(bin_arr) == 0:  # No people with that bin type\n",
        "                        self.lifetime_infected_bin_avgs[timestep][k] = self.last_bin_avgs[k]\n",
        "                        continue\n",
        "                    bin_avg = sum(bin_arr) / len(bin_arr)\n",
        "                    self.lifetime_infected_bin_avgs[timestep][k] = bin_avg\n",
        "                    self.last_bin_avgs[k] = bin_avg\n",
        "            self.current_bin_lifetime_infected = []\n",
        "        # Print\n",
        "        if timestep % self.frequency_print == 0 and (self.basic_to_print or self.adv_to_print):\n",
        "            st = 'At timestep: {} --- '.format(timestep)\n",
        "            if self.basic_to_print:\n",
        "                for i, val in enumerate(self.basic_to_print):\n",
        "                    st += '{}: {}'.format(val, self.current_data[val])\n",
        "                    if i != len(self.basic_to_print)-1:\n",
        "                        st += ' --- '\n",
        "            if self.adv_to_print:\n",
        "                if timestep in self.lifetime_infected_bin_avgs:\n",
        "                    total_bin_avg = self.lifetime_infected_bin_avgs[timestep]['total']\n",
        "                    if 'R0' in self.adv_to_print and total_bin_avg != None:\n",
        "                        st += '\\nBasic Reproduction Number (R0): {:.02f}'.format(total_bin_avg)\n",
        "                    if 'R0S' in self.adv_to_print and total_bin_avg != None:\n",
        "                        st += '\\nR0S: {:.02f} x {} = {:.02f}'.format(total_bin_avg, self.current_data['S'], total_bin_avg * self.current_data['S'])\n",
        "            print(st)\n",
        "        # Reset data\n",
        "        self._reset_data_options()\n",
        "        # If last print advanced equations\n",
        "        if last:\n",
        "            SAR = self.total_infected / self.initial_S\n",
        "            if 'SAR' in self.adv_to_print:\n",
        "                print('Secondary Attack Rate (SAR): {} / {} = {:.02f}'.format(self.total_infected, self.initial_S, SAR))\n",
        "            # Convert the lifetime infected bin avgs to a a dict of lists and a list for the x-vals\n",
        "            self.R0_hist = {'total': [], 'SD': [], 'WM': [], 'not SD': [], 'not WM': [], 'both': [], 'neither': []}\n",
        "            self.R0S_hist = {'total': [], 'SD': [], 'WM': [], 'not SD': [], 'not WM': [], 'both': [], 'neither': []}\n",
        "            self.R0_xvals = []\n",
        "            for x_val, info in list(self.lifetime_infected_bin_avgs.items()):\n",
        "                self.R0_xvals.append(x_val)\n",
        "                S = self.data_history['S'][x_val]\n",
        "                for k, y_val in list(info.items()):\n",
        "                    if not y_val: y_val = np.nan\n",
        "                    R0 = y_val\n",
        "                    R0S = S * y_val\n",
        "                    self.R0_hist[k].append(R0)\n",
        "                    self.R0S_hist[k].append(R0S)\n",
        "            # Visualizations\n",
        "            fig, axs = plt.subplots(2, 2, figsize=(15, 10))\n",
        "            # Infections\n",
        "            I_xvals = list(range(len(self.adv_infection_data_history['total'])))\n",
        "            axs[0, 0].plot(I_xvals, self.adv_infection_data_history['total'], 'C0', label='total')\n",
        "            axs[0, 0].plot(I_xvals, self.adv_infection_data_history['SD'], 'C2', label='SD')\n",
        "            axs[0, 0].plot(I_xvals, self.adv_infection_data_history['not SD'], 'C3', label='not SD')\n",
        "            axs[0, 0].set_title('Infections based on SD')\n",
        "            axs[0, 0].legend(loc=\"upper left\")\n",
        "\n",
        "            # R0\n",
        "            R0_xvals = self.R0_xvals\n",
        "            axs[1, 0].plot(R0_xvals, self.R0_hist['total'], 'C0', label='total')\n",
        "            axs[1, 0].plot(R0_xvals, self.R0_hist['SD'], 'C2', label='SD')\n",
        "            axs[1, 0].plot(R0_xvals, self.R0_hist['not SD'], 'C3', label='not SD')\n",
        "            axs[1, 0].plot(R0_xvals, self.R0_hist['WM'], 'C4', label='WM')\n",
        "            axs[1, 0].plot(R0_xvals, self.R0_hist['not WM'], 'C1', label='not WM')\n",
        "            axs[1, 0].plot(R0_xvals, self.R0_hist['both'], 'C5', label='both')\n",
        "            axs[1, 0].plot(R0_xvals, self.R0_hist['neither'], 'C6', label='neither')\n",
        "            axs[1, 0].set_title('R0 based on SD and WM')\n",
        "            axs[1, 0].legend(loc=\"upper left\")\n",
        "\n",
        "            # Save\n",
        "            if self.save_experiment:\n",
        "                # Create new directory (name of current date and time)\n",
        "                now = datetime.now()\n",
        "                dt_string = now.strftime(\"%d-%m-%Y_%H-%M-%S\")\n",
        "                sub_dir = os.path.join('experiments', dt_string)\n",
        "                new_dir = os.path.join(os.getcwd(), sub_dir)\n",
        "                os.mkdir(new_dir)\n",
        "                # Save constants\n",
        "                constants_file = os.path.join(sub_dir, 'constants.json')\n",
        "                json.dump(self.constants, open(constants_file, 'w'), indent=4)\n",
        "                # Save visualizations\n",
        "                figure_file = os.path.join(sub_dir, 'plots.png')\n",
        "                plt.savefig(figure_file)\n",
        "                # Save data as .csv and txt\n",
        "                # Basic\n",
        "                basic_data_file = os.path.join(sub_dir, 'basic_data.csv')\n",
        "                self.data_history['timestep'] = I_xvals\n",
        "                basic_data_df = pd.DataFrame(data=self.data_history)\n",
        "                basic_data_df.to_csv(basic_data_file, index=False)\n",
        "                # Advanced infection\n",
        "                adv_I_file = os.path.join(sub_dir, 'infection_data.csv')\n",
        "                self.adv_infection_data_history['timestep'] = I_xvals\n",
        "                adv_I_df = pd.DataFrame(data=self.adv_infection_data_history)\n",
        "                adv_I_df.to_csv(adv_I_file, index=False)\n",
        "                # R0\n",
        "                R0_file = os.path.join(sub_dir, 'R0_data.csv')\n",
        "                self.R0_hist['timestep'] = self.R0_xvals\n",
        "                R0_df = pd.DataFrame(data=self.R0_hist)\n",
        "                R0_df.to_csv(R0_file, index=False)\n",
        "                # R0S\n",
        "                R0S_file = os.path.join(sub_dir, 'R0S_data.csv')\n",
        "                self.R0S_hist['timestep'] = self.R0_xvals\n",
        "                R0S_df = pd.DataFrame(data=self.R0S_hist)\n",
        "                R0S_df.to_csv(R0S_file, index=False)\n",
        "                # Save SAR to txt file\n",
        "                SAR_file = os.path.join(sub_dir, 'SAR.txt')\n",
        "                with open(SAR_file, 'w') as f:\n",
        "                    f.write(str(SAR))\n",
        "\n",
        "            if self.print_visualizations:\n",
        "                plt.show()"
      ],
      "metadata": {
        "id": "Sna5So258vTr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The configuration states, rules, and experiments on different configurations are described in the linked article referenced earlier. To set up for our first simulation, do the following:\n",
        "- Upload the constants.json file from the lab assignments page. Do not place it within a folder. This file is necessary to define the simulation input configuration.\n",
        "- Create an empty `experiments` folder where results of the simulation will be stored.\n",
        "\n",
        "Then run the simulation cells, review the results, and complete exercises 4 and 5. Note that the simulation code has been modified to only show two of the subplots."
      ],
      "metadata": {
        "id": "dh8h58vMuOs4"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "N_swLiS98S-X"
      },
      "outputs": [],
      "source": [
        "import random\n",
        "import pygame\n",
        "\n",
        "\n",
        "# Different color models (only one right now)\n",
        "color_models = {'SIR': {'susceptible': (204, 255, 204), 'infected': (255, 204, 204), 'recovered': (204, 204, 255)}}\n",
        "# Different shape models (if you care about SD or WM more)\n",
        "shape_models = {'SD': {True: 'circle', False: 'rect'},\n",
        "                'WM': {True: 'circle', False: 'rect'}}\n",
        "# Policies that define overall safety level of the population\n",
        "policies_safety = {\n",
        "    'very high': {'social_distance_prob': 0.75, 'wear_mask_prob': 0.75},\n",
        "    'high': {'social_distance_prob': 0.5, 'wear_mask_prob': 0.5},\n",
        "    'medium': {'social_distance_prob': 0.25, 'wear_mask_prob': 0.25},\n",
        "    'low': {'social_distance_prob': 0.10, 'wear_mask_prob': 0.10},\n",
        "    'mixed': {'social_distance_prob': 0.10, 'wear_mask_prob': 0.75},\n",
        "}\n",
        "\n",
        "\n",
        "class CellularAutomation:\n",
        "    def __init__(self, constants, data_collect):\n",
        "        self.grid_C = constants['grid']\n",
        "        self.render_C = constants['render']\n",
        "        self.person_C = constants['person']\n",
        "        self.disease_C = constants['disease']\n",
        "        self.data_collect = data_collect\n",
        "        # Need two sets of ids (correspond uniquely to a person)\n",
        "        # 1) Those who practice social distancing\n",
        "        # 2) Those who do not practice social distancing\n",
        "        self.ids_social_distance = set()\n",
        "        self.ids_not_social_distance = set()\n",
        "        # The person objects\n",
        "        # id (int): person (object)\n",
        "        self.id_person = {}\n",
        "        # Grid stores the person IDs in a 2D structure\n",
        "        self.grid = np.empty(shape=(self.grid_C['height'], self.grid_C['width']), dtype=object)\n",
        "        self.next_id = 0\n",
        "        # The currently open positions (no person on it)\n",
        "        self.open_positions = []\n",
        "        for y in range(self.grid_C['height']):\n",
        "            for x in range(self.grid_C['width']):\n",
        "                self.open_positions.append((x, y))\n",
        "        # Initialize the grid\n",
        "        self._initialize_grid()\n",
        "\n",
        "    # Out of bounds\n",
        "    def _oob(self, x, y):\n",
        "        return x < 0 or y < 0 or x >= self.grid_C['width'] or y >= self.grid_C['height']\n",
        "\n",
        "    # Env wraps - so get correct pos\n",
        "    def _get_cell_pos(self, x, y):\n",
        "        def corrected(val, max_val):\n",
        "            if val < 0:\n",
        "                 return max_val + val\n",
        "            elif val >= max_val:\n",
        "                return max_val - val\n",
        "            else:\n",
        "                return val\n",
        "        corrected_x = corrected(x, self.grid_C['width'])\n",
        "        corrected_y = corrected(y, self.grid_C['height'])\n",
        "        return corrected_x, corrected_y\n",
        "\n",
        "    # Is the cell empty\n",
        "    def _is_empty(self, x=None, y=None, position=None):\n",
        "        if x and y:\n",
        "            return self.grid[y, x] is None\n",
        "        return self.grid[position[1], position[0]] is None\n",
        "\n",
        "    # A person can die from the disease\n",
        "    def _kill_person(self, id, social_distance):\n",
        "        person = self.id_person[id]\n",
        "        if social_distance: self.ids_social_distance.remove(id)\n",
        "        else: self.ids_not_social_distance.remove(id)\n",
        "        position = person.position\n",
        "        self._clear_cell(position)\n",
        "        assert person.infected\n",
        "        self.data_collect.increment_death_data(person)\n",
        "        # todo: Not sure if I should keep this because if someone dies early then they dont really get a full infectious lifetime\n",
        "        # self.data_collect.add_lifetime_infected(person.num_people_infected, person.infectious_days_info)\n",
        "        del self.id_person[id]\n",
        "\n",
        "    def _clear_cell(self, position):\n",
        "        self.grid[position[1], position[0]] = None\n",
        "        self.open_positions.append(position)\n",
        "\n",
        "    def _add_to_cell(self, id, position):\n",
        "        assert self._is_empty(position=position)\n",
        "        self.id_person[id].position = position\n",
        "        self.grid[position[1], position[0]] = id\n",
        "        self.open_positions.remove(position)\n",
        "\n",
        "    def _move_person(self, id, person, new_position):\n",
        "        current_position = person.position\n",
        "        # Clear current position\n",
        "        self._clear_cell(current_position)\n",
        "        # Place person in new cell\n",
        "        self._add_to_cell(id, new_position)\n",
        "        person.set_position(new_position)\n",
        "\n",
        "    # Grid initialization ------\n",
        "    def _create_person(self, position):\n",
        "        assert self._is_empty(position=position)\n",
        "        age = np.random.randint(self.person_C['age_range'][0], self.person_C['age_range'][1]+1)\n",
        "        policy = policies_safety[self.person_C['policy_type']]\n",
        "        SD_prob = policy['social_distance_prob']\n",
        "        SD = True if np.random.random() < SD_prob else False\n",
        "        WM_prob = policy['wear_mask_prob']\n",
        "        WM = True if np.random.random() < WM_prob else False\n",
        "        infected = np.random.random() < self.person_C['initial_infection_prob']\n",
        "\n",
        "        if not infected: self.data_collect.increment_initial_S()\n",
        "\n",
        "        person = Person(position, age, SD, WM, self.person_C['movement_prob'], self.person_C['altruistic_movement_prob'],\n",
        "                        self.person_C['altruistic_prob'], infected,\n",
        "                        self.disease_C['total_length_infection'], self.disease_C['incubation_period_duration_range'],\n",
        "                        self.disease_C['infectious_start_before_symptoms_range'],\n",
        "                        self.disease_C['infectious_period_duration_range'],\n",
        "                        self.disease_C['severe_symptoms_start_range'],\n",
        "                        self.disease_C['death_occurrence_range'], self.disease_C['asymptomatic_prob'],\n",
        "                        self.disease_C['severity_prob'], self.disease_C['death_prob'])\n",
        "\n",
        "        self.id_person[self.next_id] = person\n",
        "        data_collect.update_data(person)\n",
        "        if SD: self.ids_social_distance.add(self.next_id)\n",
        "        else: self.ids_not_social_distance.add(self.next_id)\n",
        "        self._add_to_cell(self.next_id, position)\n",
        "        self.next_id += 1\n",
        "\n",
        "    # Create all the people\n",
        "    def _initialize_grid(self):\n",
        "        for p in range(self.grid_C['initial_pop_size']):\n",
        "            # Select random position\n",
        "            position = random.choice(self.open_positions)\n",
        "            # Create person\n",
        "            self._create_person(position)\n",
        "\n",
        "    # Yield neighbors\n",
        "    # Return Neighbor (or None), neighbor_position absolute and relative\n",
        "    def _yield_neighbors(self, position, side_length):\n",
        "        x, y = position[0], position[1]\n",
        "        for i in range(side_length ** 2):\n",
        "            cluster_mid = side_length // 2\n",
        "            rel_x = (i % side_length) - cluster_mid\n",
        "            rel_y = (i // side_length) - cluster_mid\n",
        "            abs_x = x + rel_x\n",
        "            abs_y = y + rel_y\n",
        "            correct_x, correct_y = self._get_cell_pos(abs_x, abs_y)\n",
        "            located_id = self.grid[correct_y, correct_x]  # Might be None if no person there\n",
        "            if located_id == None:\n",
        "                yield None, (correct_x, correct_y), (rel_x, rel_y)\n",
        "            else:\n",
        "                yield self.id_person[located_id], (correct_x, correct_y), (rel_x, rel_y)\n",
        "\n",
        "    # This decides movement and num of infected neighbors FOR SD people\n",
        "    def _check_neighbors_SD(self, id, person):\n",
        "        def check_neighbors(last_position=None):\n",
        "            safe_cells = {(-1, -1): None, (0, -1): None, (1, -1): None, (-1, 0): None, (1, 0): None, (-1, 1): None, (0, 1): None, (1, 1): None}\n",
        "            infected_neighbors = []\n",
        "            for neighbor, neighbor_pos, neighbor_pos_rel in self._yield_neighbors(person.position, 3):\n",
        "                if neighbor_pos == person.position:\n",
        "                    continue\n",
        "                # Get abs pos\n",
        "                safe_cells[neighbor_pos_rel] = neighbor_pos\n",
        "                # Add to infected if infectious neighbor\n",
        "                if neighbor and neighbor.is_infectious():\n",
        "                    infected_neighbors.append(neighbor)\n",
        "                # Remove from safe cell if cell contains a person or it was the last pos\n",
        "                if neighbor or last_position == neighbor_pos:\n",
        "                    del safe_cells[neighbor_pos_rel]\n",
        "            return infected_neighbors, safe_cells\n",
        "        # First get number of infected around this and check if it gets infected\n",
        "        infected_neighbors, safe_cells = check_neighbors()\n",
        "        # Check if infected\n",
        "        self._check_infection(person, infected_neighbors)\n",
        "        # Then Moving\n",
        "        # Move it if its own cell is not safe OR its moving intenionally\n",
        "        move_length_SD = 1 if len(safe_cells) < 8 else self.person_C['move_length']  # Move only one time if just moving cuz its unsafe\n",
        "        if len(safe_cells) < 8 or np.random.random() < person.movement_prob:\n",
        "            for m in range(move_length_SD):\n",
        "                last_position = person.position\n",
        "                did_move = False\n",
        "                # Shuffle the safe positions and choose the first actually safe one by checking a 3x3 around it (not including the person.position)\n",
        "                for safe_cell_rel_pos in random.sample(list(safe_cells.keys()), len(list(safe_cells.keys()))):\n",
        "                    safe_cell_abs_pos = safe_cells[safe_cell_rel_pos]\n",
        "                    # Check if its safe (dont check the person.position)\n",
        "                    safe = True\n",
        "                    for neighbor, neighbor_pos, _ in self._yield_neighbors(safe_cell_abs_pos, 3):\n",
        "                        if neighbor_pos == person.position:\n",
        "                            continue\n",
        "                        if neighbor:\n",
        "                            safe = False\n",
        "                            break\n",
        "                    # First one that is safe: move there\n",
        "                    if safe:\n",
        "                        self._move_person(id, person, safe_cell_abs_pos)\n",
        "                        infected_neighbors, safe_cells = check_neighbors(last_position)\n",
        "                        self._check_infection(person, infected_neighbors)\n",
        "                        did_move = True\n",
        "                        break\n",
        "                # End if it did not move\n",
        "                if not did_move:\n",
        "                    break\n",
        "\n",
        "    # If not SD then move if moving intentionally\n",
        "    def _check_neighbors_not_SD(self, id, person):\n",
        "        def check_neighbors(last_position=None):\n",
        "            empty_spots = []\n",
        "            infected_neighbors = []\n",
        "            for neighbor, neighbor_pos, _ in self._yield_neighbors(person.position, 3):\n",
        "                if neighbor_pos == person.position:\n",
        "                    continue\n",
        "                # Add to infected if infectious neighbor\n",
        "                if neighbor and neighbor.is_infectious():\n",
        "                    infected_neighbors.append(neighbor)\n",
        "                # Add empty spot (also if not the last position the person was at if moving more than once)\n",
        "                if not neighbor and neighbor_pos != last_position:\n",
        "                    empty_spots.append(neighbor_pos)\n",
        "            return infected_neighbors, empty_spots\n",
        "        # First get number of infected around this and check if it gets infected\n",
        "        infected_neighbors, empty_spots = check_neighbors()\n",
        "        # Check if infected\n",
        "        self._check_infection(person, infected_neighbors)\n",
        "        # Then Moving\n",
        "        if np.random.random() < person.movement_prob:\n",
        "            for m in range(self.person_C['move_length']):\n",
        "                # if somewhere to move\n",
        "                if len(empty_spots) > 0:\n",
        "                    new_spot = random.choice(empty_spots)\n",
        "                    last_position = person.position\n",
        "                    self._move_person(id, person, new_spot)\n",
        "                    infected_neighbors, empty_spots = check_neighbors(last_position)\n",
        "                    self._check_infection(person, infected_neighbors)\n",
        "                else:\n",
        "                    break\n",
        "\n",
        "    def _check_infection(self, person, infected_neighbors):\n",
        "        newly_infected = person.gets_infected(infected_neighbors, self.disease_C['base_infection_prob'],\n",
        "                                              self.disease_C['mask_infection_prob_decrease'],\n",
        "                                              self.data_collect)\n",
        "        # If this person was just infected then add to the num of people infected to each neighbor for calc. Ro\n",
        "        if newly_infected:\n",
        "            for person in infected_neighbors:\n",
        "                person.num_people_infected += 1\n",
        "\n",
        "    def _update_person(self, id):\n",
        "        person = self.id_person[id]\n",
        "        # Progress Infection (if infected)\n",
        "        dead, new_SD = person.progress_infection(self.data_collect)\n",
        "        if dead:\n",
        "            self._kill_person(id, person.social_distance)\n",
        "            return None # Continue to next person\n",
        "        # At the start figure out where the person is going to move AND the number of infected persons around them\n",
        "        self._check_neighbors_SD(id, person) if person.social_distance else self._check_neighbors_not_SD(id, person)\n",
        "        return new_SD\n",
        "\n",
        "    # For rendering\n",
        "    def _get_person_color(self, person):\n",
        "        if self.render_C['color_model'] == 'SIR':\n",
        "            colors = color_models['SIR']\n",
        "            if person.susceptible: return colors['susceptible']\n",
        "            if person.infected: return colors['infected']\n",
        "            return colors['recovered']\n",
        "\n",
        "    def _render(self, id, screen):\n",
        "        person = self.id_person[id]\n",
        "        shape_model = self.render_C['shape_model']\n",
        "        if shape_model == 'SD':\n",
        "            shape = shape_models[shape_model][person.social_distance]\n",
        "        else:\n",
        "            shape = shape_models[shape_model][person.wear_mask]\n",
        "        color = self._get_person_color(person)\n",
        "        cell_size = self.render_C['cell_size']\n",
        "        if shape == 'rect':\n",
        "            pygame.draw.rect(screen, color,\n",
        "                             [person.position[0] * cell_size, person.position[1] * cell_size, cell_size, cell_size])\n",
        "        else:\n",
        "            radius = cell_size // 2\n",
        "            center_x = (person.position[0] * cell_size) + radius\n",
        "            center_y = (person.position[1] * cell_size) + radius\n",
        "            pygame.draw.circle(screen, color, (center_x, center_y), radius)\n",
        "\n",
        "    def run(self, render=False):\n",
        "        if render:\n",
        "            # Initialize the game engine\n",
        "            pygame.init()\n",
        "            # Set the height and width and title of the screen\n",
        "            screen_width = self.render_C['cell_size'] * self.grid_C['width']\n",
        "            screen_height = self.render_C['cell_size'] * self.grid_C['height']\n",
        "            screen = pygame.display.set_mode((screen_width, screen_height))\n",
        "            pygame.display.set_caption(\"Population Dynamics\")\n",
        "            clock = pygame.time.Clock()\n",
        "            # Initially set the screen to all black\n",
        "            screen.fill((0, 0, 0))\n",
        "        for t in range(self.grid_C['number_iterations']):\n",
        "            self.data_collect.reset(t)\n",
        "            def loop_through_ids(ids):\n",
        "                # Keep track of any switches between SD lists\n",
        "                new_SD_list = []\n",
        "                new_not_SD_list = []\n",
        "                # Shuffle - Random order\n",
        "                lis = list(ids)\n",
        "                random.shuffle(lis)\n",
        "                for id in lis:\n",
        "                    new_SD = self._update_person(id)\n",
        "                    # If dead then continue\n",
        "                    if id not in self.id_person: continue\n",
        "                    if new_SD is True: new_SD_list.append(id)\n",
        "                    elif new_SD is False: new_not_SD_list.append(id)\n",
        "                    # Update data collection\n",
        "                    self.data_collect.update_data(self.id_person[id])\n",
        "                    # Render\n",
        "                    if render: self._render(id, screen)\n",
        "                return new_SD_list, new_not_SD_list\n",
        "            # Update (in random order) those who do NOT practice social distancing\n",
        "            new_SD, new_not_SD_list = loop_through_ids(self.ids_not_social_distance)\n",
        "            assert len(new_not_SD_list) == 0\n",
        "            # Next update (in random order) those who DO practice social distancing, so they get to be at a safe dist.\n",
        "            # from others at the end of the iteration\n",
        "            new_SD_list, new_not_SD = loop_through_ids(self.ids_social_distance)\n",
        "            assert len(new_SD_list) == 0\n",
        "            # Switch people\n",
        "            for id in new_SD:\n",
        "                self.ids_not_social_distance.remove(id)\n",
        "                self.ids_social_distance.add(id)\n",
        "            for id in new_not_SD:\n",
        "                self.ids_social_distance.remove(id)\n",
        "                self.ids_not_social_distance.add(id)\n",
        "            if render:\n",
        "                pygame.display.flip()\n",
        "                screen.fill((0, 0, 0))\n",
        "                # Frames per second\n",
        "                if self.render_C['fps']: clock.tick(self.render_C['fps'])\n",
        "        self.data_collect.reset(t+1, last=True)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "constants = json.load(open('constants.json'))"
      ],
      "metadata": {
        "id": "hmqEK_WN9Rzo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Can save a run as an experiment which saves the data, visualizations and constants in a experiments directory\n",
        "data_collect = DataCollector(constants, save_experiment=True, print_visualizations=True)\n"
      ],
      "metadata": {
        "id": "2yQGtV119W92"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Can print data (look at `data_options` at top of `data_collector.py` for options) and how often to print\n",
        "data_collect.set_print_options(basic_to_print=['S', 'I', 'R', 'death'], frequency=1)\n",
        "CA = CellularAutomation(constants, data_collect)\n"
      ],
      "metadata": {
        "id": "L3Lz0r5H9Yru"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Can render each timestep with pygame\n",
        "CA.run(render=True)"
      ],
      "metadata": {
        "id": "znU7Bs7u9bOO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Exercise 4\n",
        "\n",
        "Describe the results of the simulation run, which uses policy type medium safety as discussed in the referenced Medium article. You should write at least one paragraph."
      ],
      "metadata": {
        "id": "bejnmPrOlXMy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Exercise 5\n",
        "\n",
        "To the earlier CellularAutomation class implementation, we added a definition for a Mixed Safety Policy where:\n",
        "- Each person initially has a 5% chance of social distancing\n",
        "- Each person initially has a 80% chance of wearing a mask\n",
        "\n",
        "Modify constants.json to use the mixed safety policy. A description of each entry in constants.json is below, and you will only need to modify one line in the constants.json file that you uploaded earlier.\n",
        "\n",
        "Reference:\n",
        "```\n",
        "{\n",
        "  \"grid\": {\n",
        "    \"width\": \"Width in cells of grid\",\n",
        "    \"height\": \"Height in cells of grid\",\n",
        "    \"initial_pop_size\": \"Number of people initially spawned in grid\",\n",
        "    \"number_iterations\": \"Number of total iterations of simulation\"\n",
        "  },\n",
        "  \"render\": {\n",
        "    \"cell_size\": \"Cell width/height in pixels\",\n",
        "    \"color_model\": \"How to color people\",\n",
        "    \"shape_model\": \"How to shape people\",\n",
        "    \"fps\": \"How fast in frames-per-second to run the simulation ('None' for as-fast-as-possible)\"\n",
        "  },\n",
        "  \"person\": {\n",
        "    \"age_range\": \"The range for selecting someone's age\",\n",
        "    \"movement_prob\": \"Defines the probability of a person moving each iteration\",\n",
        "    \"altruistic_movement_prob\": \"The movement probability of someone who is altruistic (defined below)\",\n",
        "    \"move_length\": \"Number of steps a person can take if they decide to move\",\n",
        "    \"initial_infection_prob\": \"The probability of infection when initially spawning people\",\n",
        "    \"altruistic_prob\": \"Probability of being altruistic and therefore social distancing and wearing a mask when symptoms arise\",\n",
        "    \"policy_type\": \"Picks one of the predefined policies in 'main.py' which defines initial spawn probabilities for social distancing, wearing a mask and not moving around too much\"\n",
        "  },\n",
        "  \"disease\": {\n",
        "    \"base_infection_prob\": \"The base infection probability of one infectious person\",\n",
        "    \"mask_infection_prob_decrease\": \"The decrease in 'base_infection_prob' if the infectious person is wearing a mask\",\n",
        "    \"total_length_infection\": \"Total length in days (usually) of the infection in a person (REF 3)\",\n",
        "    \"incubation_period_duration_range\": \"Range of possible number of incubation days (REF 3)\",\n",
        "    \"infectious_period_duration_range\": \"Range of possible number of infectious days (REF 3)\",\n",
        "    \"infectious_start_before_symptoms_range\": \"Range of possible number of days the infectious stage starts before symptoms start (REF 3)\",\n",
        "    \"severity_prob\": \"The probability of severe symptoms (given not asymptomatic) (REF 8)\",\n",
        "    \"severe_symptoms_start_range\": \"The range of possible number of days that severe symptoms begin after mild symptoms starting\",\n",
        "    \"death_prob\": \"The probability of death occurring (given severe symptoms, hence why its high-ish) (REF 8)\",\n",
        "    \"death_occurrence_range\": \"The range of possible number of days that death occurs after severe symptoms begin\",\n",
        "    \"asymptomatic_prob\": \"The probability of being asymptomatic (no symptoms but still infectious) (REF 1)\"\n",
        "  }\n",
        "}\n",
        "```\n",
        "\n",
        "Run the simulation with the Mixed Safety Policy configured and show the plots. Describe and justify what you believe are the important findings (at least two) from this simulation, along with at least one result that you expected and at least one result that surprised you. Also provide the updated line in constants.json where you made the change to the file."
      ],
      "metadata": {
        "id": "cuArz2CCxsnr"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "q0fvbLj7yerq"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}