Diseases models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Going from Simple to Complex\n",
    "I have made this notebook such that the complexity of models grows as we go ahead. I will try to capture every important step.\n",
    "As our firts step towards mesa modelling, lets import all the important libraries and base classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mesa import Agent, Model #These are the base classes in our mesa model. \n",
    "from mesa.time import RandomActivation # schedule you use for activation of agents each period\n",
    "from mesa.space import MultiGrid # grid can have multiple agents in single cell\n",
    "from mesa.datacollection import DataCollector # Data collection class.\n",
    "import matplotlib.pyplot as plt # For plotting results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Suceptible-Infected  model\n",
    "In this model I am gonna assume that the agents simply are either infected or suceptible. An infected agent will infect the Suceptible agents regardless of time. Also, the probability of transmission is hard-coded t0 0.4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(Agent):\n",
    "    \"\"\"An agent of the Disease model\"\"\"\n",
    "    def _init_(self, unique_id, model, state=False):\n",
    "        super().__init__(unique_id, model)\n",
    "        self.state = state # State is True if the agent is infected\n",
    "\n",
    "    def move(self):\n",
    "        \"\"\"The function to move agents in the grid\"\"\"\n",
    "        possible = self.model.grid.get_neighborhood(\n",
    "            self.pos,\n",
    "            moore=True,\n",
    "            include_center = False)\n",
    "        new_position = self.random.choice(possible)\n",
    "        self.model.grid.move_agent(self,new_position)\n",
    "\n",
    "    def interact(self):\n",
    "        \"\"\"How agents interact when they bump in each other\"\"\"\n",
    "        if self.state == True : # Only a infected agent can infect others\n",
    "            \n",
    "            for other in self.model.grid.get_cell_list_contents(self.pos):\n",
    "                s= self.random.random() \n",
    "                if s < 0.4 :#probability of transmission\n",
    "                    if other.state ==False:\n",
    "                        other.state = True\n",
    "                        self.model.infected += 1 \n",
    "    def step(self): # this is the most important function as mesa requires that each agent have a step() \n",
    "        self.move()\n",
    "        self.interact()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleDisease(Model):\n",
    "    \"\"\"Simple disease model\"\"\"\n",
    "    def __init__(self,N=300,width=20,height=20):\n",
    "        self.N = N\n",
    "        #self.width = width\n",
    "        #self.height = height\n",
    "\n",
    "        self.grid = MultiGrid(width,height,False)\n",
    "        self.schedule = RandomActivation(self)\n",
    "        self.infected = 0\n",
    "        self.total = 0\n",
    "\n",
    "        # create agents and add to schedule\n",
    "        for i in range(self.N):\n",
    "            agent = Person(i,self)\n",
    "            self.schedule.add(agent)\n",
    "            x= self.random.randrange(self.grid.width)\n",
    "            y= self.random.randrange(self.grid.height)\n",
    "            self.grid.place_agent(agent,(x,y))\n",
    "            if self.random.random() < 0.1:\n",
    "                agent.state =True\n",
    "                self.infected +=1 \n",
    "            else:\n",
    "                agent.state=False\n",
    "\n",
    "        self.datacollector = DataCollector(\n",
    "            model_reporters={\"Infected\":\"infected\", \"Total Infections\": \"total\"},\n",
    "            agent_reporters={\"x\":lambda z:z.pos[0], \"y\": lambda z:z.pos[1], \"status\": lambda z: z.state},\n",
    "        )\n",
    "\n",
    "    def step(self):\n",
    "        #self.infected = 0\n",
    "        self.total += self.infected\n",
    "        self.datacollector.collect(self)\n",
    "        self.infected = 0\n",
    "        self.schedule.step()\n",
    "        #self.total += self.infected when this line is here, it causes calculation mistaKES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now simply checking the result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SimpleDisease(500,20,20)\n",
    "for i in range(40):\n",
    "    model.step()\n",
    "infected = model.datacollector.get_model_vars_dataframe()\n",
    "infected.plot()\n",
    "#print(infected)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A simple Suceptible-Infected-Recovered Model\n",
    "Now I'll be using the recovery period to create Recovered population. For keeping track of recovery from disease, we need a way to keep track of time iin the model. So, we will import accordingly.\n",
    "Also as agent status can no more be a binary, we need a new system. So, each agent.status can now be \"Suceptible\", \"Infected\", or \"Recovered\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleDisease_2(Model):\n",
    "    \"\"\"Simple disease model\"\"\"\n",
    "    def __init__(self,N=300,width=20,height=20, recover_day = 7):\n",
    "        self.N = N\n",
    "        self.grid = MultiGrid(width,height,False)\n",
    "        self.schedule = RandomActivation(self)\n",
    "        self.infected = 0\n",
    "        self.total = 0\n",
    "        self.recover_days = recover_day # this is the new line here\n",
    "        self.recovered = 0\n",
    "        \n",
    "        # create agents and add to schedule\n",
    "        for i in range(self.N):\n",
    "            agent = Person(i,self)\n",
    "            self.schedule.add(agent)\n",
    "            x= self.random.randrange(self.grid.width)\n",
    "            y= self.random.randrange(self.grid.height)\n",
    "            self.grid.place_agent(agent,(x,y))\n",
    "            if self.random.random() < 0.1:\n",
    "                agent.state = \"Sick\"\n",
    "                agent.infected_time = self.schedule.time\n",
    "                self.infected +=1\n",
    "            else:\n",
    "                agent.state= \"Suceptible\"\n",
    "                agent.infected_time = 1000\n",
    "\n",
    "        self.datacollector = DataCollector(\n",
    "            model_reporters={\"Infected\":\"infected\", \"Total Infections\": \"total\",\"Recovered\":\"recovered\"},\n",
    "            agent_reporters={\"x\":lambda z:z.pos[0], \"y\": lambda z:z.pos[1], \"status\": lambda z: z.state},\n",
    "        )\n",
    "\n",
    "    def step(self):\n",
    "        self.total += self.infected\n",
    "        self.datacollector.collect(self)\n",
    "        self.infected = 0 # so that we get new data every period\n",
    "        self.schedule.step()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(Agent):\n",
    "    \"\"\"An agent of the Disease model\"\"\"\n",
    "    def _init_(self, unique_id, model, state= \"Suceptible\"):\n",
    "        super().__init__(unique_id, model)\n",
    "        self.state = state\n",
    "        #self.infected_time = 0\n",
    "\n",
    "    def move(self):\n",
    "        \"\"\"The function to move agents\"\"\"\n",
    "        possible = self.model.grid.get_neighborhood(\n",
    "            self.pos,\n",
    "            moore=True,\n",
    "            include_center = False)\n",
    "        new_position = self.random.choice(possible)\n",
    "        self.model.grid.move_agent(self,new_position)\n",
    "\n",
    "    def interact(self):\n",
    "        \"\"\"How agents interact when they bump in each other\"\"\"\n",
    "        if self.state == \"Sick\" :\n",
    "            for other in self.model.grid.get_cell_list_contents(self.pos):\n",
    "                s= self.random.random() \n",
    "                if s < 0.4 :#probability of transmission \n",
    "                    if other.state == \"Suceptible\":\n",
    "                        other.state = \"Sick\"\n",
    "                        self.model.infected += 1\n",
    "                        other.infected_time = self.model.schedule.time\n",
    "    def step(self):\n",
    "        self.move()\n",
    "        self.interact()\n",
    "        if self.state == \"Sick\":\n",
    "            if (self.model.schedule.time - self.infected_time)==self.model.recover_days:\n",
    "                self.state=\"Recovered\"\n",
    "                self.model.recovered +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SimpleDisease_2(300,20,20,5)\n",
    "for i in range(50):\n",
    "    model.step()\n",
    "    #print(model.schedule.time)\n",
    "infected = model.datacollector.get_model_vars_dataframe()\n",
    "infected.plot()\n",
    "#print(infected)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mistakes made in the above models\n",
    "I made the mistake of not counting the index infections in infected. Thus while recovered kept an accountof that,they were larger than total infections I counted.\n",
    "Corrected it with simple changes in agent initialization step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Suceptible-Infected-Removed with deaths\n",
    "Now I'll try to introduce a simple death simulation in the previous model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleDisease_3(Model):\n",
    "    \"\"\"Simple disease model\"\"\"\n",
    "    def __init__(self,N=300,width=20,height=20, recover_day = 7,death_rate=0.1):\n",
    "        self.N = N\n",
    "        self.grid = MultiGrid(width,height,False)\n",
    "        self.schedule = RandomActivation(self)\n",
    "        self.infected = 0\n",
    "        self.total = 0\n",
    "        self.recover_days = recover_day # this is the new line here\n",
    "        self.recovered = 0\n",
    "        self.death_total = 0\n",
    "        self.death_daily = 0\n",
    "        self.death_rate = death_rate\n",
    "        \n",
    "        # create agents and add to schedule\n",
    "        for i in range(self.N):\n",
    "            agent = Person(i,self)\n",
    "            self.schedule.add(agent)\n",
    "            x= self.random.randrange(self.grid.width)\n",
    "            y= self.random.randrange(self.grid.height)\n",
    "            self.grid.place_agent(agent,(x,y))\n",
    "            if self.random.random() < 0.1:\n",
    "                agent.state = \"Sick\"\n",
    "                agent.infected_time = self.schedule.time\n",
    "                self.infected +=1\n",
    "            else:\n",
    "                agent.state= \"Suceptible\"\n",
    "                agent.infected_time = 1000\n",
    "\n",
    "        self.datacollector = DataCollector(\n",
    "            model_reporters={\"Infected\":\"infected\", \"Total Infections\": \"total\",\"Recovered\":\"recovered\",\n",
    "                            \"Total Deaths\":\"death_total\",\"Daily Deaths\":\"death_daily\"},\n",
    "            agent_reporters={\"x\":lambda z:z.pos[0], \"y\": lambda z:z.pos[1], \"status\": lambda z: z.state},\n",
    "        )\n",
    "\n",
    "    def step(self):\n",
    "        #self.infected = 0\n",
    "        self.total += self.infected\n",
    "        self.death_total += self.death_daily \n",
    "        self.datacollector.collect(self)\n",
    "        self.infected = 0\n",
    "        self.death_daily = 0\n",
    "        self.schedule.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(Agent):\n",
    "    \"\"\"An agent of the Disease model\"\"\"\n",
    "    def _init_(self, unique_id, model, state= \"Suceptible\"):\n",
    "        super().__init__(unique_id, model)\n",
    "        self.state = state\n",
    "        #self.infected_time = 0\n",
    "\n",
    "    def move(self):\n",
    "        \"\"\"The function to step check our fuckbois\"\"\"\n",
    "        possible = self.model.grid.get_neighborhood(\n",
    "            self.pos,\n",
    "            moore=True,\n",
    "            include_center = False)\n",
    "        new_position = self.random.choice(possible)\n",
    "        self.model.grid.move_agent(self,new_position)\n",
    "\n",
    "    def interact(self):\n",
    "        \"\"\"How agents interact when they bump in each other\"\"\"\n",
    "        if self.state == \"Sick\" :\n",
    "            for other in self.model.grid.get_cell_list_contents(self.pos):\n",
    "                s= self.random.random() \n",
    "                if s < 0.4 :#probability of transmission \n",
    "                    if other.state == \"Suceptible\":\n",
    "                        other.state = \"Sick\"\n",
    "                        self.model.infected += 1\n",
    "                        other.infected_time = self.model.schedule.time\n",
    "    def step(self):\n",
    "        self.move()\n",
    "        self.interact()\n",
    "        if self.state == \"Sick\":\n",
    "            if self.random.random() < self.model.death_rate:\n",
    "                self.state = \"Dead\"\n",
    "                self.model.death_daily +=1 \n",
    "            else:\n",
    "                if (self.model.schedule.time - self.infected_time)==self.model.recover_days:\n",
    "                    self.state=\"Recovered\"\n",
    "                    self.model.recovered +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SimpleDisease_3(300, 20, 20, 7, 0.02)\n",
    "for i in range(50):\n",
    "    model.step()\n",
    "    #print(model.schedule.time)\n",
    "infected = model.datacollector.get_model_vars_dataframe()\n",
    "infected.plot()\n",
    "#print(infected)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Suceptible-Infected-Removed with deaths and Infection times\n",
    "In this model I'll try to add germination period(or whatever is the exact technical term for time it takes for the agent to take disease effect). Also, to keep it relevant, from now, those who are infected and show symptoms will stay home."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleDisease_4(Model):\n",
    "    \"\"\"Simple disease model\"\"\"\n",
    "    def __init__(self,N=300,width=20,height=20, recover_day = 7,death_rate=0.1, asymptom_days=3):\n",
    "        self.N = N\n",
    "        self.grid = MultiGrid(width,height,False)\n",
    "        self.schedule = RandomActivation(self)\n",
    "        self.infected = 0\n",
    "        self.total = 0\n",
    "        self.recover_days = recover_day \n",
    "        self.recovered = 0\n",
    "        self.death_total = 0\n",
    "        self.death_daily = 0\n",
    "        self.death_rate = death_rate\n",
    "        self.asymptom = asymptom_days\n",
    "        self.asymptomatic = 0\n",
    "        \n",
    "        # create agents and add to schedule\n",
    "        for i in range(self.N):\n",
    "            agent = Person(i,self)\n",
    "            self.schedule.add(agent)\n",
    "            x= self.random.randrange(self.grid.width)\n",
    "            y= self.random.randrange(self.grid.height)\n",
    "            self.grid.place_agent(agent,(x,y))\n",
    "            if self.random.random() < 0.1:\n",
    "                agent.state = \"Sick\"\n",
    "                agent.infected_time = self.schedule.time\n",
    "                self.infected +=1\n",
    "            else:\n",
    "                agent.state= \"Suceptible\"\n",
    "                agent.infected_time = 1000\n",
    "\n",
    "        self.datacollector = DataCollector(\n",
    "            model_reporters={\"Infected\":\"infected\", \"Total Infections\": \"total\",\"Recovered\":\"recovered\",\n",
    "                            \"Total Deaths\":\"death_total\",\"Daily Deaths\":\"death_daily\",\n",
    "                            \"Asymptomatic:\":\"asymptomatic\"},\n",
    "            agent_reporters={\"x\":lambda z:z.pos[0], \"y\": lambda z:z.pos[1], \"status\": lambda z: z.state},\n",
    "        )\n",
    "\n",
    "    def step(self):\n",
    "        #self.infected = 0\n",
    "        self.total += self.infected\n",
    "        self.death_total += self.death_daily \n",
    "        self.datacollector.collect(self)\n",
    "        self.infected = 0\n",
    "        self.death_daily = 0\n",
    "        #asymptomatic = 0\n",
    "        self.schedule.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(Agent):\n",
    "    \"\"\"An agent of the Disease model\"\"\"\n",
    "    def _init_(self, unique_id, model, state= \"Suceptible\"):\n",
    "        super().__init__(unique_id, model)\n",
    "        self.state = state\n",
    "        #self.infected_time = 0\n",
    "\n",
    "    def move(self):\n",
    "        \"\"\"The function to step check our fuckbois\"\"\"\n",
    "        possible = self.model.grid.get_neighborhood(\n",
    "            self.pos,\n",
    "            moore=True,\n",
    "            include_center = False)\n",
    "        new_position = self.random.choice(possible)\n",
    "        self.model.grid.move_agent(self,new_position)\n",
    "\n",
    "    def interact(self):\n",
    "        \"\"\"How agents interact when they bump in each other\"\"\"\n",
    "        if self.state == \"Sick\" :\n",
    "            for other in self.model.grid.get_cell_list_contents(self.pos):\n",
    "                s= self.random.random() \n",
    "                if s < 0.4 :#probability of transmission self.model.tprob\n",
    "                    if other.state == \"Suceptible\":\n",
    "                        other.state = \"Asymptomatic\" # here I add asymptomates \n",
    "                        self.model.infected += 1\n",
    "                        self.model.asymptomatic +=1\n",
    "                        other.infected_time = self.model.schedule.time\n",
    "    def step(self):\n",
    "        if self.state != \"Sick\" and self.state!=\"Dead\" :\n",
    "            self.move()\n",
    "        self.interact()\n",
    "        if self.state == \"Sick\":\n",
    "            if self.random.random() < self.model.death_rate:\n",
    "                self.state = \"Dead\"\n",
    "                self.model.death_daily +=1 \n",
    "                self.model.schedule.remove(self)\n",
    "            else:\n",
    "                if (self.model.schedule.time - self.infected_time)==self.model.recover_days:\n",
    "                    self.state=\"Recovered\"\n",
    "                    self.model.recovered +=1\n",
    "        elif self.state == \"Asymptomatic\":\n",
    "            if (self.model.schedule.time - self.infected_time) == self.model.asymptom:\n",
    "                self.state = \"Sick\"\n",
    "                self.model.asymptomatic -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SimpleDisease_4(500, 20, 20, 7, 0.02,3)\n",
    "for i in range(50):\n",
    "    model.step()\n",
    "    #print(model.schedule.time)\n",
    "infected = model.datacollector.get_model_vars_dataframe()\n",
    "infected.plot()\n",
    "#print(infected)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introducing Economic Effects\n",
    "Now that we have a robust disease outcome framework, we can include a very basic economic perspective to this model. In the model that follows, every agent earns \\$50 as he moves. Since they have no other expenditure, they add this to their savings (initially \\$1000). When they become sick and are in \"therapy\", they need to spend $200 each day till recovery.\n",
    "We use the sum of all incomes approach of measuring national income and assesing the impacts of disease on Economy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleDisease_5(Model):\n",
    "    \"\"\"Simple disease model\"\"\"\n",
    "    def __init__(self,N=300,width=20,height=20, recover_day = 7,death_rate=0.1, asymptom_days=3):\n",
    "        self.N = N\n",
    "        self.grid = MultiGrid(width,height,False)\n",
    "        self.schedule = RandomActivation(self)\n",
    "        self.infected = 0\n",
    "        self.total = 0\n",
    "        self.recover_days = recover_day \n",
    "        self.recovered = 0\n",
    "        self.death_total = 0\n",
    "        self.death_daily = 0\n",
    "        self.death_rate = death_rate\n",
    "        self.asymptom = asymptom_days\n",
    "        self.asymptomatic = 0\n",
    "        self.Y = (self.N * 50)\n",
    "        self.suceptible = 0\n",
    "        \n",
    "        # create agents and add to schedule\n",
    "        for i in range(self.N):\n",
    "            agent = Person(i,self)\n",
    "            self.schedule.add(agent)\n",
    "            x= self.random.randrange(self.grid.width)\n",
    "            y= self.random.randrange(self.grid.height)\n",
    "            self.grid.place_agent(agent,(x,y))\n",
    "            if self.random.random() < 0.01:\n",
    "                agent.state = \"Sick\"\n",
    "                agent.infected_time = self.schedule.time\n",
    "                self.infected +=1\n",
    "            else:\n",
    "                agent.state= \"Suceptible\"\n",
    "                agent.infected_time = 1000\n",
    "                self.suceptible += 1\n",
    "            agent.saving = 1000\n",
    "\n",
    "        self.datacollector = DataCollector(\n",
    "            model_reporters={\"Infected\":\"infected\", \"Total Infections\": \"total\",\"Recovered\":\"recovered\",\n",
    "                            \"Total Deaths\":\"death_total\",\"Daily Deaths\":\"death_daily\",\n",
    "                            \"Asymptomatic:\":\"asymptomatic\",\"Suceptible\":\"suceptible\"},\n",
    "            #agent_reporters={\"x\":lambda z:z.pos[0], \"y\": lambda z:z.pos[1], \"status\": lambda z: z.state},\n",
    "        )\n",
    "        self.income = DataCollector(model_reporters={\"Income\":\"Y\"})\n",
    "        # A separate datacolletor for economic outcomes\n",
    "    def step(self):\n",
    "        #self.infected = 0\n",
    "        self.total += self.infected\n",
    "        self.death_total += self.death_daily \n",
    "        self.datacollector.collect(self)\n",
    "        self.income.collect(self)\n",
    "        self.infected = 0\n",
    "        self.Y =0\n",
    "        self.suceptible = 0\n",
    "        self.death_daily = 0\n",
    "        #asymptomatic = 0\n",
    "        self.schedule.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(Agent):\n",
    "    \"\"\"An agent of the Disease model\"\"\"\n",
    "    def __init__(self, unique_id, model, state= \"Suceptible\"):\n",
    "        super().__init__(unique_id, model)\n",
    "        self.state = state\n",
    "        self.saving =1000\n",
    "        #self.infected_time = 0\n",
    "\n",
    "    def move(self):\n",
    "        \"\"\"The function to step check our fuckbois\"\"\"\n",
    "        possible = self.model.grid.get_neighborhood(\n",
    "            self.pos,\n",
    "            moore=True,\n",
    "            include_center = False)\n",
    "        new_position = self.random.choice(possible)\n",
    "        self.model.grid.move_agent(self,new_position)\n",
    "\n",
    "    def interact(self):\n",
    "        \"\"\"How agents interact when they bump in each other\"\"\"\n",
    "        if self.state == \"Sick\" :\n",
    "            for other in self.model.grid.get_cell_list_contents(self.pos):\n",
    "                s= self.random.random() \n",
    "                if s < 0.4 :#probability of transmission self.model.tprob\n",
    "                    if other.state == \"Suceptible\":\n",
    "                        other.state = \"Asymptomatic\" # here I add asymptomates \n",
    "                        self.model.infected += 1\n",
    "                        self.model.asymptomatic +=1\n",
    "                        other.infected_time = self.model.schedule.time\n",
    "    def step(self):\n",
    "        if self.state != \"Sick\" and self.state!=\"Dead\" :\n",
    "            self.move()\n",
    "            self.saving += 50\n",
    "            self.model.Y += 50\n",
    "        self.interact()\n",
    "        if self.state == \"Sick\":\n",
    "            self.saving += (-200)\n",
    "            if self.random.random() < self.model.death_rate:\n",
    "                self.state = \"Dead\"\n",
    "                self.model.death_daily +=1 \n",
    "                self.model.schedule.remove(self)\n",
    "            else:\n",
    "                if (self.model.schedule.time - self.infected_time)==self.model.recover_days:\n",
    "                    self.state=\"Recovered\"\n",
    "                    self.model.recovered +=1\n",
    "        elif self.state == \"Asymptomatic\":\n",
    "            if (self.model.schedule.time - self.infected_time) == self.model.asymptom:\n",
    "                self.state = \"Sick\"\n",
    "                self.model.asymptomatic -= 1\n",
    "        elif self.state ==\"Suceptible\":\n",
    "            self.model.suceptible += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SimpleDisease_5(50000, 150, 150, 7, 0.02,3)\n",
    "for i in range(50):\n",
    "    model.step()\n",
    "    #print(model.schedule.time)\n",
    "infected = model.datacollector.get_model_vars_dataframe()\n",
    "economy = model.income.get_model_vars_dataframe()\n",
    "infected.plot()\n",
    "economy.plot()\n",
    "#print(infected)\n",
    "plt.show()"
   ]
  }
 ],
 "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}