SimuleerEenEpidemie.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simuleer een epidemie\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-box alert-success\">\n",
    "In dit project zullen we bestuderen hoe ziektes zich kunnen verspreiden doorheen een (sociaal) netwerk. We zullen onderzoeken hoe de structuur van een netwerk een invloed kan hebben op hoe snel een ziekte doorgegeven wordt. Finaal zullen we ook verschillende strategieën bekijken om de verspreiding van een ziekte tegen te gaan.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.integrate import solve_ivp\n",
    "from scipy.spatial import distance_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Het SIR-model\n",
    "\n",
    "Een van de eenvoudigste manieren om ziekteverspreiding in een gemeenschap te modelleren, is aan de hand van het SIR-model. **SIR staat voor *Susceptible* (vatbaar), *Infected* (geïnfecteerd) en *Resistant* (resistent of hersteld), de drie types individuen die in een gemeenschap voorkomen.** <br>\n",
    "Het SIR-model bestaat uit drie vergelijkingen die de veranderingen van het aantal individuen in een bepaalde groep beschrijven. De variabelen die de toestand beschrijven zijn:\n",
    "\n",
    "-  $S(t)$: het aantal vatbare individuen op tijdstip $t$;\n",
    "-  $I(t)$: het aantal geïnfecteerde individuen op tijdstip $t$;\n",
    "-  $R(t)$: het aantal resistente individuen op tijdstip $t$.\n",
    "\n",
    "Hierbij is t de tijd in een bepaalde tijdseenheid (de tijdseenheid wordt gekozen afhankelijk van het probleem).\n",
    "\n",
    "In deze beschrijving maken we een eerste grote vereenvoudiging van de werkelijkheid. We nemen aan dat elk van deze variabelen reële getallen zijn, en dat het aantal individuen in elke groep continu kan variëren. In werkelijkheid zijn het discrete waarden: het aantal geïnfecteerden en vatbare individuen is een natuurlijk getal, je bent immers besmet of je bent het niet. Modelleerders werken echter graag met continue variabelen omdat ze dan de technieken van de wiskundige analyse kunnen gebruiken."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 1**: Onder welke omstandigheden gaat deze continue benadering ongeveer op? Denk je dat je dit model kan gebruiken om een gezin van vier personen te beschrijven?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deze drie variabelen worden aan elkaar gelinkt aan de hand van drie differentiaalvergelijkingen (die elk een verandering in de tijd beschrijven). Hierbij nemen we aan dat de grootte van de populatie ongewijzigd blijft: we nemen dus aan dat, gedurende de tijdspanne die het model beschrijft, er niemand geboren wordt en ook niemand sterft. Eigenlijk beperken we ons hier tot de verspreiding van een relatief onschuldige ziekte zoals een verkoudheid. We kunnen de situatie dus voorstellen met het volgende stelsel differentiaalvergelijkingen: \n",
    " \n",
    "$$\n",
    "\\frac{\\text{d}S(t)}{\\text{d}t} = -\\beta \\, S(t) \\, I(t)\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\frac{\\text{d}I(t)}{\\text{d}t} = \\beta \\, S(t) \\,I(t) - \\gamma \\, I(t)\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\frac{\\text{d}R(t)}{\\text{d}t} = \\gamma \\, I(t)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-box alert-info\">\n",
    "Elke vergelijking vertelt ons hoe het aantal mensen in elke groep wijzigt doorheen de tijd. Daaruit kunnen we ook berekenen hoeveel mensen zich op een bepaald moment bevinden in elke groep. De parameters $\\beta$ en $\\gamma$ spelen daarbij een fundamentele rol.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De vergelijkingen zijn gekoppeld via de *overgangspercentages*. Elk overgangspercentage vertelt ons hoe van de ene naar de andere groep wordt overgegaan. <br>\n",
    "Het overgangspercentage van vatbaar (S) naar geïnfecteerd (I) hangt af van het contact tussen een vatbare persoon en een geïnfecteerde persoon. We noemen dit *infectiepercentage* $\\beta$. Dit betekent dat één geïnfecteerde persoon $\\beta S$ personen zal besmetten. Het aantal vatbare personen vermindert dus met $\\beta S I$ per tijdseenheid. <br>\n",
    "Het overgangspercentage van geïnfecteerd (I) naar resistent (R) hangt alleen af van het *herstelpercentage*, dat we $\\gamma$ noemen. Het aantal geïnfecteerde personen vermindert dus met  $\\gamma I$ per tijdseenheid."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 2**: Toon aan met een berekening dat het totaal aantal individuen in de populatie $(S(t)+I(t)+R(t))$ constant zal blijven."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-box alert-info\">\n",
    "Het SIR-model is moeilijk om exact te worden opgelost. Dit is het geval bij veel differentiaalvergelijkingen die optreden in de biologische wetenschappen. We moeten dus een <em>numerieke benadering</em> van de oplossing vinden. Dit betekent dat we een algoritme zullen gebruiken om een geschatte maar nauwkeurige oplossing te vinden. Vanuit deze oplossing kunnen we leren hoe de verschillende variabelen in de loop van de tijd veranderen.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Er zijn verschillende mogelijkheden om dit te doen: \n",
    "\n",
    "-  We zouden ons continue probleem kunnen vervangen door een **discrete** tegenhanger. <br>\n",
    "Dit zou ons toelaten bepaalde numerieke methoden te gebruiken om een benaderende oplossing te krijgen. \n",
    "\n",
    "-  Anderzijds kunnen we een **iteratieve** methode gebruiken. <br>Uitgaande van een initiële schatting, maken iteratieve methoden opeenvolgende benaderingen die stapsgewijs convergeren naar de exacte oplossing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteratieve manier\n",
    "\n",
    "Met behulp van computers is het gemakkelijk om iteratief een numerieke oplossing voor het SIR-model te vinden. <br>\n",
    "Om dit te doen, vertrekken we van een beginvoorwaarde: het is logisch om te beginnen met een populatie met nul resistente personen, een paar geïnfecteerde personen en de rest vatbaar. Vervolgens kunnen we onze numerieke oplossing gebruiken om het aantal mensen in elke groep op bepaalde tijdstippen te berekenen.\n",
    "\n",
    "Via de Python-module SciPy kunnen we eenvoudig dergelijke differentiaalvergelijkingen simuleren. Eerst moeten we de differentiaalvergelijkingen *implementeren*: we stoppen daartoe de drie vergelijkingen hierboven gegeven in een rijmatrix.\n",
    "\n",
    "Met behulp van de Python-module NumPy kan een matrix voorgesteld worden met een *Numpy array*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SIR(t, y, beta, gamma):\n",
    "    \"\"\"Differentiaalvergelijkingen die S, I en R in functie van de tijd t bepalen.\"\"\"\n",
    "    S, I, R = y\n",
    "    return np.array([-beta * S * I,\n",
    "                    beta * S * I - gamma * I,\n",
    "                    gamma * I])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nu kunnen we het stelsel differentiaalvergelijkingen *numeriek oplossen* met de [solve_ivp](https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.solve_ivp.html)-functie voor een bepaalde *beginsituatie*. <br>We beschouwen een populatie met 1000 mensen, waarvan initieel één persoon geïnfecteerd is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# voorbeeld 1 \n",
    "# beginsituatie\n",
    "S0 = 999\n",
    "I0 = 1\n",
    "R0 = 0\n",
    "\n",
    "beta = 0.001\n",
    "gamma = 0.1\n",
    "\n",
    "\n",
    "oplossing = solve_ivp(SIR,                     # functie met parameters\n",
    "                      [0, 100],                # tijdsinterval waarin we simuleren\n",
    "                      np.array([S0, I0, R0]),  # initiële omstandigheden\n",
    "                      args=(beta, gamma))    # parameters van stelsel differentiaalvergelijkingen "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deze oplossing kunnen we dan grafisch weergeven:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# voorbeeld 1 grafiek oplossing S, I, R \n",
    "plt.figure()\n",
    "\n",
    "plt.plot(oplossing.t, oplossing.y[1], color=\"purple\")  # I \n",
    "plt.plot(oplossing.t, oplossing.y[2], color=\"green\")   # R\n",
    "plt.plot(oplossing.t, oplossing.y[0], color=\"orange\")  # S\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# voorbeeld 1 grafiek verdeling populatie over S, I, R in functie van de tijd\n",
    "plt.figure()\n",
    "\n",
    "plt.stackplot(oplossing.t, oplossing.y[[1,0,2],:],\n",
    "              labels=[\"I\", \"S\", \"R\"],\n",
    "              colors=[\"red\", \"yellow\", \"lightgreen\"])\n",
    "plt.xlabel(\"Tijd\")\n",
    "plt.ylabel(\"Aantal personen\")\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# grafiek voorbeeld 1 combinatie verdeling populatie en S, I, R\n",
    "plt.figure()\n",
    "\n",
    "plt.stackplot(oplossing.t, oplossing.y[[1,0,2],:],\n",
    "              labels=[\"I\", \"S\", \"R\"],\n",
    "              colors=[\"red\", \"yellow\", \"lightgreen\"])\n",
    "plt.xlabel(\"Tijd\")\n",
    "plt.ylabel(\"Aantal personen\")\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.plot(oplossing.t, oplossing.y[1], color=\"purple\")  # I \n",
    "plt.plot(oplossing.t, oplossing.y[2], color=\"green\")   # R\n",
    "plt.plot(oplossing.t, oplossing.y[0], color=\"orange\")  # S\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 3**: Simuleer een aantal situaties door de parameters aan te passen: \n",
    "-  Wat als initieel de helft van de populatie resistent was? \n",
    "-  Wat als initieel 80 % van de populatie resistent was?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# voorbeeld 2 \n",
    "# beginsituatie\n",
    "S0 = 1099\n",
    "I0 = 1\n",
    "R0 = 0\n",
    "\n",
    "beta = 0.0001\n",
    "gamma = 0.048\n",
    "\n",
    "\n",
    "oplossing = solve_ivp(SIR,                     # functie met parameters\n",
    "                      [0, 365],                # tijdsinterval waarin we simuleren\n",
    "                      np.array([S0, I0, R0]),  # initiële omstandigheden\n",
    "                      t_eval=np.linspace(0,365,36),   # aantal punten van oplossing\n",
    "                      args=(beta, gamma))    # parameters van stelsel differentiaalvergelijkingen "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# voorbeeld 2 grafiek oplossing S, I, R \n",
    "plt.figure()\n",
    "\n",
    "plt.plot(oplossing.t, oplossing.y[1], color=\"purple\")  # I \n",
    "plt.plot(oplossing.t, oplossing.y[2], color=\"green\")   # R\n",
    "plt.plot(oplossing.t, oplossing.y[0], color=\"orange\")  # S\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# grafiek voorbeeld 2 grafiek verdeling populatie over S, I, R in functie van de tijd\n",
    "plt.figure()\n",
    "\n",
    "plt.stackplot(oplossing.t, oplossing.y[[1,0,2],:],\n",
    "              labels=[\"I\", \"S\", \"R\"],\n",
    "              colors=[\"red\", \"yellow\", \"green\"])\n",
    "plt.xlabel(\"Tijd\")\n",
    "plt.ylabel(\"Aantal personen\")\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# grafiek voorbeeld 2 combinatie verdeling populatie en S, I, R\n",
    "plt.figure()\n",
    "\n",
    "plt.stackplot(oplossing.t, oplossing.y[[1,0,2],:],\n",
    "              labels=[\"I\", \"S\", \"R\"],\n",
    "              colors=[\"red\", \"yellow\", \"lightgreen\"])\n",
    "plt.xlabel(\"Tijd\")\n",
    "plt.ylabel(\"Aantal personen\")\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.plot(oplossing.t, oplossing.y[1], color=\"purple\")  # I \n",
    "plt.plot(oplossing.t, oplossing.y[2], color=\"green\")   # R\n",
    "plt.plot(oplossing.t, oplossing.y[0], color=\"orange\")  # S\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 4**: Bereken de waarde van $S$ voor het tijdstip waarop $I$ maximaal is. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 5**: Hoe verandert de grafiek als beta met een kwart verminderd wordt? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sociale netwerken\n",
    "\n",
    "Het standaard SIR-model maakt de onrealistische veronderstelling dat twee willekeurige individuen telkens dezelfde kans hebben om met elkaar in contact te komen en zo mogelijks een ziekte door te geven. In werkelijkheid gaat natuurlijk niet iedereen met dezelfde mensen om. We hebben allemaal mensen waar we meer mee omgaan (meer in contact mee komen) dan met anderen. **Het geheel van wie met wie in contact staat, wordt een *sociaal netwerk* genoemd (denk aan Facebook).** De structuur van zo'n netwerk zal een sterke invloed hebben op de dynamiek van de ziekteverspreiding. \n",
    "\n",
    "In deze sectie zullen we bekijken hoe we een netwerk wiskundig kunnen beschrijven.\n",
    "\n",
    "\n",
    "### Een voorbeeld: netwerken en grafen\n",
    "\n",
    "In Figuur 1 zie je een voorbeeld van enkele netwerken. Elk netwerk is voorgesteld door een *graaf*. De punten vertegenwoordigen de leerlingen en worden *knopen* genoemd. De contacten tussen leerlingen worden weergegeven door lijnsegmenten tussen knopen, en worden *bogen* genoemd. **We zeggen dat twee knopen met elkaar *verbonden* zijn als ze met een boog geconnecteerd worden.** Hier gaan we ervan uit dat een knoop niet verbonden kan zijn met zichzelf. We gaan er dus van uit dat je niet met jezelf 'bevriend' kan zijn. Verder is er maar maximaal één boog mogelijk tussen twee knopen.\n",
    "\n",
    "![Voorbeelden van gekleurde grafen die netwerken tussen kinderen van verschillende leeftijden voorstellen. De vierkantjes stellen jongens voor, de cirkels meisjes.](.image/netwerkkinderen.png)\n",
    "\n",
    "<center>Figuur 1. Sample networks of self-reported social contacts within a classroom (Conlan et al, 2011).</center>\n",
    "\n",
    "<center> Zoals gebruikelijk is in een genogram, een grafische voorstelling om relaties tussen mensen voor te stellen, stellen de cirkels hier meisjes voor en de vierkanten jongens. Zo zie je voor het netwerk voor kinderen tussen 4 en 5 jaar een kliekje van jongens, die bevriend zijn met een vriendengroepje van meisjes en ook nog met een ander meisje. Dat meisje is bevriend met nog een andere jongen. Er zijn ook twee meisjes die enkel met elkaar bevriend zijn en zes kinderen zonder vrienden.</center>\n",
    "\n",
    "De figuren die men gebruikt om een netwerk of een graaf voor te stellen, zijn niet uniek. Eenzelfde netwerk kan vaak op verschillende manieren voorgesteld worden. Zoals je ziet worden de knopen voorgesteld door cirkels, vierkanten of andere vormen, die geconnecteerd zijn door lijnen, de bogen. In het vorige voorbeeld duidt de vorm van de knopen ook een geslacht in een sociaal netwerk aan; men kan dat ook doen door kleuren te gebruiken. In dat geval spreekt men van een *gekleurde graaf*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 6**: Beschrijf het verschil tussen de sociale netwerken van de verschillende leeftijdsgroepen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-box alert-info\">\n",
    "    Een netwerk kan voorgesteld worden door een <em>graaf</em>. De punten worden <em>knopen</em> genoemd. Knopen kunnen al dan niet met elkaar verbonden zijn. De lijnen tussen knopen worden <em>bogen</em> genoemd. We zeggen dat twee knopen met elkaar <em>verbonden</em> zijn als ze met een boog geconnecteerd worden.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Een figuur is nuttig om te bekijken hoe het netwerk eruitziet. Om er berekeningen mee te doen zijn er echter andere voorstellingen nodig. Een graaf kan wiskundig voorgesteld worden door een *verbindingsmatrix* (Engels: adjacency matrix). <br>\n",
    "Als het aantal knopen in de graaf $n$ is, dan is de verbindingsmatrix een vierkante matrix V met dimensie $n \\times n$. Het element $v_{ij} = 1$ als de knopen $i$ en $j$ verbonden zijn, en $v_{ij} = 0$ als ze niet verbonden zijn. <br>De verbindingsmatrix linkt grafentheorie met matrixtheorie!\n",
    "\n",
    "Neem het onderstaande klein graafje als voorbeeld.\n",
    "\n",
    "![Graaf met vijf knopen.](.image/graph.png)\n",
    "<center> Figuur 2.</center>\n",
    "Dit heeft als verbindingsmatrix\n",
    "\n",
    "$$\n",
    "V = \\begin{bmatrix}\n",
    "       0 & 1 & 0 & 1 & 0 \\\\\n",
    "       1 & 0 & 1 & 0 & 1 \\\\\n",
    "       0 & 1 & 0 & 1 & 1 \\\\\n",
    "       1 & 0 & 1 & 0 & 1 \\\\\n",
    "       0 & 1 & 1 & 1 & 0\n",
    "     \\end{bmatrix}.\n",
    "$$\n",
    "\n",
    "(A: 0, B: 1, C: 2, D: 3, E: 4. Knoop 0 (A) is niet verbonden met knoop 2 (C). Dus $v_{02} = 0$. Knoop 1 (B) is wel verbonden met knoop 2 (C). Dus $v_{12} = 1$.)<br>\n",
    "Merk op dat een verbindingsmatrix altijd vierkant en altijd symmetrisch is.\n",
    "\n",
    "In Python stellen we de matrix voor met een *NumPy array*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V = np.array([[0, 1, 0, 1, 0],  # A: eerste rij en eerste kolom\n",
    "              [1, 0, 1, 0, 1],  # B: tweede rij en tweede kolom\n",
    "              [0, 1, 0, 1, 1],  # C\n",
    "              [1, 0, 1, 0, 1],  # D\n",
    "              [0, 1, 1, 1, 0]]) # E"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Een ziekte-uitbraak in een sociaal netwerk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Het sociaal netwerk dat we beschouwen, wordt weergegeven in onderstaande figuur. De knopen, hier personen, zijn genummerd om ze makkelijk te kunnen identificeren. We houden geen rekening met geslacht of andere attributen. We zullen in dit sociaal netwerk een ziekte-uitbraak simuleren!\n",
    "\n",
    "![Een sociaal netwerk tussen vijftien personen.](.image/socialnetwerk.png)\n",
    "<center> Figuur 3.</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 7**: Voltooi de verbindingsmatrix voor het sociale netwerk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V = np.array([[0, 0, 1, ...],\n",
    "              [0, 0, 1, ...],\n",
    "              ...])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Laat ons nu kijken hoe we het SIR-ziekteverspreidingsmodel kunnen vertalen naar de taal van netwerken. <br> \n",
    "Aan de hand van een algemeen netwerk zullen we een veel realistischer model opstellen. Geen continue benadering meer! Dit model sluit verrasssend beter aan bij de werkelijkheid, en bovendien is het ook veel eenvoudiger om te bevatten en te simuleren. We kunnen een exacte oplossing bekomen zonder dat we afgeleiden of andere geavanceerde wiskundige technieken nodig hebben!\n",
    "\n",
    "### Ziektedynamiek op een netwerk\n",
    "\n",
    "In plaats van het aantal $S$-, $I$- en $R$-individuen doorheen de tijd bij te houden zoals bij het standaard SIR-model, zullen we voor elke knoop in het netwerk zijn of haar toestand bijhouden. De tijd zal niet continu variëren maar zal nu in discrete stappen voorbij gaan: $t = 0, 1, 2, 3, \\ldots$. De toestand van knoop nummer $i$ op tijdstip $t$ wordt beschreven door $N_i^t\\in \\{S, I, R\\}$. Dit wil zeggen dat knoop $i$ op tijdstip $t$ de toestand $S$ (vatbaar), $I$ (geïnfecteerd) of $R$ (resistent) kan hebben. De verandering in toestand van de knopen beschrijven we aan de hand van enkele eenvoudige regels. Analoog aan het oorspronkelijke SIR-model dat twee parameters heeft, beta (het infectiepercentage) en gamma (het herstelpercentage), heeft ook het netwerk SIR-model twee parameters.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vatbare en geïnfecteerde mensen\n",
    "\n",
    "Laten we ons eerst beperken tot vatbare en geïnfecteerde individuen. We gaan ervan uit dat vatbare individuen geïnfecteerd kunnen worden, en geïnfecteerde individuen kunnen resistent worden. Er is dus geen mogelijke overgang van geïnfecteerd naar vatbaar en ook niet van vatbaar naar resistent. Beschouw volgende regels:\n",
    "\n",
    "1. Indien een knoop op tijdstip $t$ in toestand $S$ zit, dan heeft elke **geïnfecteerde** buur een kans $p_\\text{inf}$ om de ziekte door te geven. De knoop gaat naar toestand $I$ indien minstens één buur de ziekte doorgeeft.\n",
    "2. Indien een knoop op tijdstip $t$ in toestand $I$ zit, dan gaat deze naar de toestand $R$ met een kans $p_\\text{res}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dus, stel dat een knoop in toestand $S$ zit, en ze heeft $k$ buren die in toestand $I$ zitten. De kans dat geen enkele buur de ziekte doorgeeft, is dan:\n",
    "\n",
    "$$\n",
    "(1-p_\\text{inf})^k,\n",
    "$$\n",
    "\n",
    "dus de kans dat de ziekte wel doorgegeven wordt, en er dus een transitie van toestand $S$ naar $I$ plaatsvindt, is:\n",
    "\n",
    "$$\n",
    "1 - (1-p_\\text{inf})^k\\,.\n",
    "$$\n",
    "\n",
    "We maakten hier gebruik van de productregel en de complementregel uit de kansrekening. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Voorbeeld\n",
    "Beschouw de knoop in het blauw omlijnd in het onderstaand voorbeeld. Stel dat $p_\\text{inf}=0.2$, wat is dan de kans dat één van de drie zieke buren de ziekte doorgeeft?\n",
    "\n",
    "![](.image/ziekteverspr.png)\n",
    "<center> Figuur 4.</center>\n",
    "\n",
    "Dit berekenen we met de volgende code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_inf = 0.2\n",
    "k = 3\n",
    "\n",
    "p_ziekte_doorgegeven = 1 - (1 - p_inf)**k\n",
    "\n",
    "print(\"kans om de ziekte te krijgen is\", p_ziekte_doorgegeven)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Het effectief doorgeven van de ziekte kunnen we simuleren met NumPy, waar `np.random.rand()` een willekeurig getal, uniform verdeeld tussen 0 en 1, genereert. <br>We doen dat met de code in de volgende code-cel. Voer voor de simulatie die cel enkele keren uit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "p_ziekte_doorgegeven > np.random.rand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bij `True` wordt de ziekte effectief doorgegeven, bij `False` niet. Merk op dat er een toevalsfactor in de simulatie is ingebouwd. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 8**: Stel dat $p_\\text{inf}=1$ (iedereen die ziek is, geeft direct de ziekte door aan al zijn of haar buren in het netwerk). Initieel zijn enkel knopen 1 en 11 geïnfecteerd in het voorbeeldnetwerk uit Figuur 3.<br> \n",
    "-  Wie is allemaal geïnfecteerd in de volgende stap? \n",
    "-  En in de stap daarna?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementatie\n",
    "We kunnen het model eenvoudig implementeren in Python m.b.v. SciPy. <br>Eerst zullen we een simpel sociaal netwerk genereren om dit model te illustreren:\n",
    "-  We genereren daarvoor een populatie van `n` personen. Om het visueel te houden worden deze voorgesteld als punten in het $x,y$-vlak.\n",
    "- Nadien genereren we een verbindingsmatrix die weergeeft of er een verbinding is tussen de knopen. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Eerst zullen we de knopen van het netwerk genereren. We genereren terzelfdertijd de afstand tussen de knopen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def genereer_populatie(n):\n",
    "    \"\"\"Genereren van punten en bepalen van hun onderlinge afstand.\"\"\"\n",
    "    # n punten genereren, uniform in het xy-vlak\n",
    "    X = np.random.rand(n, 2)\n",
    "    # alle paarsgewijze afstanden tussen n punten\n",
    "    D = distance_matrix(X, X)\n",
    "    return X, D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# populatie van netwerk van 200 punten genereren\n",
    "n = 200\n",
    "X, D = genereer_populatie(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(X,D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De afstanden tussen twee personen vormen samen de afstandsmatrix $D$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# X bestaat uit 200 koppels en D is 200x200-matrix\n",
    "print(X.shape, D.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nu zullen we de verbindingsmatrix V genereren."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om een simpel model voor de verbindingsmatrix V te bekomen, laat ons zeggen dat de kans dat $v_{ij}=1$, dus dat knopen $i$ en $j$ verbonden zijn, gegeven wordt door:\n",
    "\n",
    "$$\n",
    "p_{ij} = \\exp(-\\alpha \\, d_{ij})\\,.\n",
    "$$\n",
    "\n",
    "**Hier geldt dat de kans op een verbinding tussen knopen $i$ en $j$ afneemt naarmate de afstand tussen de twee knopen toeneemt.** <br>\n",
    "$\\alpha$ is een parameter ($\\alpha \\geq 0$) die dit verband regelt. Een grote waarde van $\\alpha$ zorgt ervoor dat twee ver uiteen gelegen knopen een heel kleine kans hebben om in verbinding te staan. Voor een kleine waarde van $\\alpha$ is dit wel nog mogelijk. Bovendien geldt dat hoe groter de afstand is tussen twee knopen, hoe kleiner de kans op een verbinding. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# illustratie van effect van waarde van alpha\n",
    "plt.figure() \n",
    "\n",
    "xwaarden = np.linspace(0, 10, 100)\n",
    "plt.plot(xwaarden, np.exp(-0.1 * xwaarden), label=r\"$\\alpha=0.1$\")       # r in omschrijving label omwille van LaTeX-code\n",
    "plt.plot(xwaarden, np.exp(-0.5 * xwaarden), label=r\"$\\alpha=0.5$\")\n",
    "plt.plot(xwaarden, np.exp(-1 * xwaarden), label=r\"$\\alpha=1$\")\n",
    "plt.plot(xwaarden, np.exp(-5 * xwaarden), label=r\"$\\alpha=5$\")\n",
    "plt.plot(xwaarden, np.exp(-10 * xwaarden), label=r\"$\\alpha=10$\")\n",
    "plt.xlabel(r\"Afstand $d_{ij}$\")                 \n",
    "plt.ylabel(r\"Kans op verbinding $v_{ij}$\")\n",
    "plt.legend(loc=0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 9**: Denk goed na over de betekenis van $\\alpha$. Wat als $\\alpha=0$? Wat als $\\alpha$ heel groot is?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_verbindingsmatrix(D, alpha=1.0):\n",
    "    \"\"\"Genereren van verbindingsmatrix afhankelijk van de afstandsmatrix en alpha.\"\"\"\n",
    "   \n",
    "    # verbindingsmatrix heeft dezelfde dimensie als de afstandsmatrix, beide zijn vierkant\n",
    "    n = D.shape[1]             # aantal kolommen in D is gelijk aan de populatiegrootte\n",
    "    \n",
    "    # matrix aanmaken met 0 en 1 om verbindingen voor te stellen\n",
    "    # alle elementen op de diagonaal zijn nul, matrix is symmetrisch\n",
    "    A = np.zeros((n, n))\n",
    "    \n",
    "    for i in range(n):\n",
    "        for j in range(i+1, n):\n",
    "                 # kans op een verbinding\n",
    "                 p = np.exp(- alpha * D[i,j])\n",
    "                 # met een kans van p, maak een verbinding tussen i en j\n",
    "                 if p > np.random.rand():\n",
    "                        A[i,j] = 1\n",
    "                        A[j,i] = 1      # symmetrische matrix\n",
    "    return A\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# verbindingsmatrix van netwerk genereren voor alpha = 10\n",
    "V = sample_verbindingsmatrix(D, alpha=10)\n",
    "print(V)        # elke matrix kan gebruikt worden als representatie van een figuur  \n",
    "print(V.min(), V.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# visualiseren dat V uit nullen en enen bestaat\n",
    "plt.imshow(V, cmap=\"gray\")   # elke matrix kan gebruikt worden als representatie voor afbeelding, 0 zwart, 1 wit "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Het netwerk voorstellen met een graaf. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hiervoor schrijven we een nieuwe functie in Python.<br> Geïnfecteerde personen zullen weergegeven worden in het rood, resistente in het groen en vatbare in het geel. We zullen dus een gekleurde graaf gebruiken. <br>\n",
    "Als de toestand van de knopen nog niet is meegegeven, kleuren we ze blauw.\n",
    "\n",
    "Bij de lijst punten (knopen) van het netwerk, hoort dus ook een lijst van toestanden, waarbij de eerste toestand overeenkomt met de eerste knoop, de tweede toestand met de tweede knoop, enz. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " def plot_netwerk(X, V, toestanden=None):\n",
    "    \"\"\"Graaf van het netwerk.\"\"\" \n",
    "    n = V.shape[1]          # populatiegrootte is gelijk aan aantal kolommen van V\n",
    "    \n",
    "    # van elke knoop kleur nagaan en lijst van maken\n",
    "    if toestanden is None:\n",
    "        # geen toestanden gegeven, alle noden zijn blauw\n",
    "        knoop_kleuren = \"blue\"\n",
    "    else:\n",
    "        kleur_map = {\"S\" : \"yellow\", \"I\" : \"red\", \"R\" : \"green\"}    # dictionary\n",
    "        knoop_kleuren = [kleur_map[toestand] for toestand in toestanden]\n",
    "    \n",
    "    \n",
    "    plt.figure()\n",
    "    \n",
    "    plt.axis(\"off\")  # bij graaf geen assen  \n",
    "    \n",
    "    # plot n knopen, eerste kolom van X bevat x-coördinaat, tweede kolom y-coördinaat in juiste kleur\n",
    "    plt.scatter(X[:,0], X[:,1], color=knoop_kleuren, zorder=1)    # zorder=1: punten op bovenste layer van graaf\n",
    "    \n",
    "    # teken de verbindingen in het grijs\n",
    "    # n is de populatiegrootte en V[i,j] is de waarde van de verbinding (0 of 1)\n",
    "    # als V[i,j] = 1, dan lijnstuk tussen i-de en j-de knoop\n",
    "    # dus van X i-de en j-de rij nodig, dus X[i,j] nodig met x'n in eerste kolom daarvan en y's in tweede\n",
    "    for i in range(n):\n",
    "        for j in range(i+1, n):\n",
    "            if V[i,j] == 1:\n",
    "                plt.plot(X[[i,j],0], X[[i,j],1], alpha=0.8, color=\"grey\", zorder=0)    # zorder=0: lijnen onderste layer van graaf\n",
    "    plt.scatter([], [], color=\"yellow\", label=\"S\")       # lege punten om labels al te kunnen tonen\n",
    "    plt.scatter([], [], color=\"red\", label=\"I\")\n",
    "    plt.scatter([], [], color=\"green\", label=\"R\")\n",
    "    plt.legend(loc=0)\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_netwerk(X, V)       # knopen en verbindingen van ons netwerk plotten, nog zonder toestanden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Laat ons nu aan elk van de knopen een initiële toestand toekennen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initieel is iedereen in toestand $S$, behalve vijf willekeurige personen die geïnfecteerd zijn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_inf = 5  # initieel aantal geïnfecteerden\n",
    "\n",
    "#lijst maken van initiële toestanden \n",
    "initiele_toestanden = [\"S\"] * n         # lijst maken van 200 S'n\n",
    "initiele_toestanden[0:n_inf] = [\"I\"] * n_inf  # 5 S'n vervangen dootr I, maakt niet uit welke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(initiele_toestanden)\n",
    "print(len(initiele_toestanden))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_netwerk(X, V, initiele_toestanden)     # knopen en verbindingen van ons netwerk plotten, nu met initiële toestanden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Overgang van ene toestand naar andere"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We hebben dus een functie nodig die telkens de toestand op tijdstip $t$ omzet naar de toestand op tijdstip $t+1$. Dit is een vrij ingewikkelde functie! De overgang tussen tijdstippen noemen we een *tijdstap*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_toestand(toestanden, V, p_inf=1, p_res=0):\n",
    "    \"Functie die toestand aanpast naar nieuwe toestand per tijdstap.\"\n",
    "    n = len(toestanden)        # aantal toestanden is populatiegrootte\n",
    "    nieuwe_toestanden = []     # maak lijst om de nieuwe toestanden in op te slaan\n",
    "    \n",
    "    for i, toestand in enumerate(toestanden):         # ga lijst toestanden af en houd overeenkomstige index bij\n",
    "        if toestand == \"S\":                           # persoon i is vatbaar\n",
    "            # tel aantal geïnfecteerden die persoon i kent\n",
    "            n_inf_kennissen = 0\n",
    "            for j in range(n):\n",
    "                if V[i,j] == 1 and toestanden[j] == \"I\":     # als persoon i in contact met geïnfecteerde persoon\n",
    "                    n_inf_kennissen += 1\n",
    "            # kans dat persoon i ziek wordt door een zieke kennis\n",
    "            p_ziekte = 1 - (1 - p_inf)**n_inf_kennissen\n",
    "            # effectief besmet of niet\n",
    "            if (p_ziekte > np.random.rand()):\n",
    "                toestand = \"I\" \n",
    "            else:\n",
    "                toestand = \"S\"\n",
    "            nieuwe_toestanden.append(toestand)\n",
    "        elif toestand == \"I\":                          # persoon i is vatbaar\n",
    "            # persoon die geïnfecteerd is, kan resistent worden\n",
    "            # effectief besmet of niet\n",
    "            if (p_res > np.random.rand()):\n",
    "                toestand = \"R\"  \n",
    "            else:\n",
    "                toestand = \"I\"\n",
    "            nieuwe_toestanden.append(toestand)\n",
    "        elif toestand == \"R\":                          # persoon i is resistent\n",
    "            # resistente personen blijven resistent\n",
    "            nieuwe_toestanden.append(\"R\")\n",
    "    \n",
    "    return nieuwe_toestanden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initiële toestanden updaten voor bepaalde p_inf en p_res voor één tijdstap\n",
    "p_inf = 0.1\n",
    "p_res = 0.01\n",
    "\n",
    "nieuwe_toestanden = update_toestand(initiele_toestanden, V, p_inf, p_res)\n",
    "\n",
    "print(\"aantal infecties op t=0:\", 5)\n",
    "print(\"aantal infecties op t=1:\", nieuwe_toestanden.count(\"I\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_netwerk(X, V, nieuwe_toestanden)         # knopen en verbindingen van ons netwerk plotten, nu met toestanden op t=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simulatie evolutie toestanden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We kunnen dit herhalen voor een hele reeks tijdstappen aan de hand van een for-lus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simuleer_epidemie(init_toestanden, V, tijdstappen, p_inf=1, p_res=0):\n",
    "    \"\"\"Simulatie van evolutie toestanden.\"\"\"\n",
    "    # sla de toestanden op in een lijst van lijsten\n",
    "    toestanden_lijst = [init_toestanden]     # lijst huidige toestanden wordt als eerste element in toestanden_lijst gestopt\n",
    "    toestanden = init_toestanden\n",
    "    for t in range(tijdstappen):\n",
    "        toestanden = update_toestand(toestanden, V, p_inf, p_res)\n",
    "        toestanden_lijst.append(toestanden)\n",
    "    return toestanden_lijst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Laat ons dit eens doen voor 100 tijdstappen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simulatie van evolutie toestanden van initiële toestand over 100 tijdstappen\n",
    "simulatie = simuleer_epidemie(initiele_toestanden, V, 100, p_inf, p_res)   # nog steeds p_inf = 0.1 en p_res = 0.01"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Laat ons nu eens naar enkele snapshots doorheen de tijd kijken."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# verloop na 0, 10, 20, 50, 70 en 100 tijdstappen\n",
    "for t in [0, 10, 20, 50, 70, 100]:\n",
    "    toestanden = simulatie[t]             # simulatie is lijst van toestanden van toestanden\n",
    "    print(\"tijdstip {}: {} geïnfecteerd, {} resistent\".format(t, toestanden.count(\"I\"), toestanden.count(\"R\")))\n",
    "    plot_netwerk(X, V, toestanden)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We kunnen de voortgang makkelijker opvolgen aan de hand van een grafiek. Laat ons eens kijken hoe de verhoudingen tussen vatbaren, geïnfecteerden en resistenten wijzigen doorheen de tijd:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_progressiekrommen(toestanden_lijst):\n",
    "    \"\"\"Evolutie cijfers.\"\"\"\n",
    "    tijdstappen = len(toestanden_lijst)     # aantal elementen in toestanden_lijst is gelijk aan aantal tijdstappen\n",
    "    # tel het aantal personen voor elke toestand per tijdstap\n",
    "    S = [toestanden.count(\"S\") for toestanden in toestanden_lijst]\n",
    "    I = [toestanden.count(\"I\") for toestanden in toestanden_lijst]\n",
    "    R = [toestanden.count(\"R\") for toestanden in toestanden_lijst]\n",
    "    \n",
    "    plt.figure()\n",
    "    \n",
    "    plt.plot(range(tijdstappen), I, color=\"purple\", label=\"I\")\n",
    "    plt.plot(range(tijdstappen), S, color=\"orange\", label=\"S\")\n",
    "    plt.plot(range(tijdstappen), R, color=\"green\", label=\"R\")\n",
    "    plt.legend(loc=0)\n",
    "    plt.xlabel(\"Tijd\")\n",
    "    plt.ylabel(\"Aantal personen\")\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_progressievlakken(toestanden_lijst):\n",
    "    \"\"\"Evolutie cijfers.\"\"\"\n",
    "    tijdstappen = len(toestanden_lijst)     # aantal elementen in toestanden_lijst is gelijk aan aantal tijdstappen\n",
    "    # tel het aantal personen voor elke toestand per tijdstap\n",
    "    S = [toestanden.count(\"S\") for toestanden in toestanden_lijst]\n",
    "    I = [toestanden.count(\"I\") for toestanden in toestanden_lijst]\n",
    "    R = [toestanden.count(\"R\") for toestanden in toestanden_lijst]\n",
    "    \n",
    "    plt.figure()\n",
    "    \n",
    "    plt.stackplot(range(tijdstappen), I, S, R,\n",
    "                    labels=[\"I\", \"S\", \"R\"], colors=[\"red\", \"yellow\", \"lightgreen\"])\n",
    "    plt.legend(loc=0)\n",
    "    plt.xlabel(\"Tijd\")\n",
    "    plt.ylabel(\"Aantal personen\")\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_progressiekrommen(simulatie)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_progressievlakken(simulatie)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Oefening 10**: Indien er te snel te veel mensen ziek worden, kan het gezondheidsapparaat overrompeld worden, met catastrofale gevolgen! Om dit te vermijden wordt het principe van *social distancing* toegepast: mensen moeten sociaal contact zo veel mogelijk vermijden. Dit zorgt ervoor dat de ziekte trager wordt doorgegeven. \n",
    "- Je kan social distancing simuleren door $\\alpha$ hoger te zetten, bv. op 25. Doe dit. Zie je waarom het resultaat *flatten-the-curve*-effect noemt?\n",
    "- Had je dit ook al opgemerkt bij oefening 5?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-box alert-info\">\n",
    "    Wil je deze notebook downloaden, maar is het bestand te groot geworden door de grafieken?<br>\n",
    "    Verwijder dan eerst de output van de cellen door in het menu <b>Cell > All output > Clear</b> te kiezen.\n",
    "    Je kan de notebook ook opslaan als pdf of uitprinten, net zoals je met een webpagina zou doen.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Referenties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conlan, A. J. K., Eames, K. T. D., Gage, J. A., von Kirchbach, J. C., Ross,J. V., Saenz, R. A.,& Gog J. R. 2011. <br> &nbsp; &nbsp; &nbsp; &nbsp; Measuring social networks in British primary schools through scientific engagement. *Proceedings of the Royal Society B, 278*(1711), 1467–1475.<br> &nbsp; &nbsp; &nbsp; &nbsp;  https://doi.org/10.1098/rspb.2010.1807"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".image/cclic.png\" alt=\"Banner\" align=\"left\" style=\"width:100px;\"/><br><br>\n",
    "Deze notebook van M. Stock voor Dwengo vzw is in licentie gegeven volgens een <a href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\">Creative Commons Naamsvermelding-NietCommercieel-GelijkDelen 4.0 Internationaal-licentie</a>. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Dwengo vzw](.image/logodwengo.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}