Vaccineren of niet? een project over het observeren van kudde-immuniteit door middel van ziektesimulatie: 15 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Projectoverzicht:

Ons project onderzoekt groepsimmuniteit en hoopt mensen aan te moedigen zich te laten vaccineren om het infectiepercentage in onze gemeenschappen te verlagen. Ons programma simuleert hoe een ziekte een populatie infecteert met verschillende percentages gevaccineerde en niet-gevaccineerde percentages. Het toont groepsimmuniteit door te laten zien hoe een groter aantal gevaccineerde populaties het aantal getroffen mensen kan verminderen.

We modelleren dit in Matlab met behulp van grafentheorieconcepten. Grafentheorie is een wiskundige manier om de relaties tussen objecten weer te geven. In de grafentheorie hebben grafieken hoekpunten (of knooppunten) verbonden door randen (of lijnen). Voor ons project zijn de knooppunten de betrokken individuen en de randen hun verbindingen. Als twee knooppunten bijvoorbeeld zijn verbonden met een rand, betekent dit dat ze "vrienden" zijn of een vorm van contact met elkaar hebben. Dit contact is een manier om de ziekte te verspreiden. Daarom hebben we grafentheorie gebruikt om ons concept te modelleren, omdat we wilden zien hoe ziekte zich verspreidt onder individuen die verbonden zijn in een populatie.

Ons project omvat ook de Monte Carlo-methode. De Monte Carlo-methode zijn algoritmen die herhaalde willekeurige steekproeven creëren om numerieke resultaten te ontvangen. In ons project gebruiken we deze methode om onze simulatie meerdere keren uit te voeren, waarbij we het percentage aanvankelijk niet-gevaccineerden veranderen om de snelheid te zien waarmee mensen besmet raken.

Alle projectcode is onderaan gelinkt!

PC-tegoed:

Matlab-link naar Grafiektheorie:

Stap 1: Maak een nabijheidsmatrix

Maak een nieuw schrift. We gaan de onze 'infectionSim.m' noemen.

We gaan een variabele 'NUMOFPEOPLE' maken. U kunt het toewijzen aan een willekeurig geheel getal. Dit geeft het aantal mensen in uw populatie weer.

Vanaf nu gaan we ervan uit dat:

NUMOFPEOPLE = 20;

Begin eerst met het gebruik van Matlab's grafentheoriefuncties voor een ongerichte graaf.

Als u meer wilt weten, vindt u hier een link om er meer over te lezen.

www.mathworks.com/help/matlab/math/directed-and-undirected-graphs.html

Een aangrenzende matrix gemaakt.

adjMatrix = nullen (NUMOFPEOPLE);

Dit zal een vierkante matrix van nullen creëren. Elke rij in de matrix is een persoon. Elke kolom in de matrix is een persoon of vriend die de persoon gedurende de dag ontmoet.

Zie afbeelding 100 (hierboven) om te visualiseren hoe adjMatrix eruitziet voor 20 personen.

**Vanaf dit punt gaan we ervan uit dat NUMOFPEOPLE gelijk is aan 20.**

U kunt proberen deze aangrenzende matrix te plotten. Hier is wat meer informatie over het plotten van dit soort matrices.

Opmerking: hoe de aangrenzende matrix werkt.

Ex:

%de aangrenzende matrix maken

een = [0, 1, 0, 0, 0; 1, 0, 1, 1, 1; 0, 1, 0, 0, 0; 0, 1, 0, 0, 0; 0, 1, 0, 0, 0] %plotten g = grafiek(a); %gebruikmakend van de grafiekfunctie (grafiekentheorie) figure(1); h = perceel(g);

Zie figuur 1 (hierboven) om te zien hoe u randen in de aangrenzende matrix kunt toevoegen met behulp van de code in "Opmerking".

Stap 2: Creëer relaties

Nu de mensen (hoekpunten of knooppunten) zijn gemaakt, moeten we een netwerk van relaties (lijnen of randen van de grafiek) maken. Hiermee wordt gesimuleerd hoe mensen gedurende een dag met elkaar omgaan en andere mensen ontmoeten.

Dit kan op vele manieren. Een manier om deze taak te voltooien, is door eerst een willekeurig nummer aan elke persoon toe te wijzen om te bepalen met hoeveel mensen elke persoon op een dag zal communiceren.

numOfFriendsMatrix = randi([leastFriendsPersonCanHave, mostFriendsPersonCanHave], 1, NUMOFPEOPLE);

Dit maakt een matrix van 1 bij 20 van willekeurige gehele getallen die het aantal interacties vertegenwoordigen dat elke persoon een dag heeft. De kolommen van deze matrix zouden het nummer zijn dat overeenkomt met elke persoon. Als we bijvoorbeeld de leastFriendsPersonCanHave = 2 en mostFriendsPersonCanHave = 5 toewijzen, krijgen we willekeurige waarden tussen 2 en 5.

Heeft u problemen met randi()? Typ in terminal

help randi

Vervolgens maken we een gerandomiseerde matrix (genaamd "allFriendsmatrix") van hoe elke persoon in de populatie is verbonden/interactie binnen de populatie.

tempMatrix = ;

aantal = 0; allFriendsMatrix = ; voor k = 1:NUMOFPEOPLE while length(tempMatrix) ~= numOfFriendsMatrix(k) count = count +1; temp = randi([1, NUMOFPEOPLE]); tempMatrix(aantal) = temp; end clear each while length(tempMatrix) ~= 9 tempMatrix = [tempMatrix, NaN]; einde allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; aantal = 0; einde

Uitgebreide uitleg van code:

Eerst maken we een lege tijdelijke matrix om de vrienden-/interactielijst van elke persoon te bewaren. We initialiseren ook de telling, die alleen bijhoudt waar de nieuwe willekeurige verbinding in de tempMatrix moet worden geplakt. De for-lussen lopen 20 keer zodat dit voor elke individuele persoon in de populatie gebeurt. De eerste while-lus loopt totdat de tempMatrix van elke persoon even lang is als het willekeurig toegewezen aantal interacties. In deze lus wordt een willekeurig getal dat overeenkomt met de persoon in de populatie gegenereerd en in de tempMatrix geplaatst. Omdat de lengtes van elk van de tempMatrixes verschillend zijn, moesten we enkele NaN-waarden maken zodat we al deze tempMaticies allemaal in één matrix kunnen samenvoegen ('allFriendsMatrix'). De tweede while-lus lost dit probleem op door NaN's toe te voegen aan elke tempMatrix. De while-lus is ingesteld om 9 keer te worden uitgevoerd omdat het een getal groter dan 5 is, wat de bovengrens was van vrienden die een persoon kan worden toegewezen. De waarde '9' is variabel en kan/moet worden gewijzigd wanneer 'mostFriendsPersonCanHave' groter is dan 9. De laatste drie regels code (exclusief het einde) voegen de tempMatrix toe aan de volgende rij van de 'allFriendsMatrix'. Dan ruimt het tempMatrix op en telt voor de volgende persoon.

Uitgang:

Dit is hoe de uitvoer eruit zou moeten zien voor de eerste run door de for-lus (vóór de laatste drie regels).

tempMatrix = 16 8 17 16 13 NaN NaN NaN NaN

allFriendsMatrix =

16 8 17 16 13 NaN NaN NaN NaN 8 8 2 7 11 NaN NaN NaN NaN 10 13 NaN NaN NaN NaN NaN NaN NaN 11 17 2 NaN NaN NaN NaN NaN NaN 10 12 NaN NaN NaN NaN NaN NaN NaN 4 13 2 12 NaN NaN NaN NaN NaN 17 10 9 3 1 NaN NaN NaN NaN 16 16 6 NaN NaN NaN NaN NaN NaN 3 8 17 17 14 NaN NaN NaN NaN 20 19 3 NaN NaN NaN NaN NaN NaN 13 10 NaN NaN NaN NaN NaN NaN NaN 2 18 10 16 NaN NaN NaN NaN NaN 2 6 14 3 13 NaN NaN NaN NaN 8 16 14 8 NaN NaN NaN NaN NaN 7 7 NaN NaN NaN NaN NaN NaN NaN 19 10 9 NaN NaN NaN NaN NaN NaN 10 19 NaN NaN NaN NaN NaN NaN NaN 5 18 NaN NaN NaN NaN NaN NaN NaN 1 7 NaN NaN NaN NaN NaN NaN NaN 16 7 13 10 1 NaN NaN NaN NaN

Voeg vervolgens deze relaties toe aan de adjMatrix.

voor elke rij = 1:NUMOFPEOPLE

voor elkeKol = 1:9 if isnan(alleVriendenMatrix(elkeRij,ElkeKol)) == 0 adjMatrix(ElkeRij, alleVriendenMatrix(ElkeRij,ElkeKol)) = 1; adjMatrix(alleVriendenMatrix(elkeRij,ElkeKol),ElkeRij) = 1; einde einde einde

Code Uitleg

Deze dubbele for-lus gaat door elke rij en kolom van de 'allFriendsMatrix'. Het if-statement wordt uitgevoerd voor alle waarden die niet 'NaN' zijn. In principe zal het de randen of lijnen van de grafiek creëren. Dus de eerste regel die dit maakt is persoon 1 naar persoon 16 en persoon 16 naar persoon 1. Omdat het ongericht is, moet 1 voor beide worden gewijzigd! We kunnen niet zomaar de rand 1 tot 16 hebben en niet 16 tot 1. Ze moeten symmetrisch zijn om het goed te laten werken in Matlab.

In onze simulatie hebben we vastgesteld dat mensen niet met zichzelf kunnen communiceren. Wanneer we de waarden willekeurig hebben verdeeld, bestaat de kans dat onze aangrenzende matrix deze fouten heeft.

Laten we dit oplossen met de volgende code:

voor elk = 1:NUMOFPEOPLE

adjMatrix(elk, elk) = 0; einde

Code Uitleg

Deze for-lus zorgt ervoor dat persoon 1 niet verbonden is met persoon 1, persoon 2 is niet verbonden met persoon 2, enz. door ze allemaal 0 te maken. Zoals je hieronder in het uitvoergedeelte kunt zien, hebben we de diagonaal van het vierkant matrix van linksboven naar rechtsonder zijn allemaal nullen.

Uitgang:

Dit is de laatste adjMatrix voor deze huidige simulatie. Dit geldt voor alle lijnen in de grafiek (Figuur 2).

adjMatrix =

0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 1 1 0 1 1 0 0 0 1 0 1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 1 0 1 0 1 1 1 1 0 0 0 1 0 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 1 0 1 1 0 0 0 0 0 1 0 1 0 1 0 0 0 1 1 0 0 0 1 1 0 1 1 0 1 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 1 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 1 1 0 0 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 1 0 0 0 0

Zie figuur 2 om de grafiek van 'adjMatrix' te zien.

Stap 3: Voeg ziektestatistieken toe

Nu uw programma een grafiek kan maken met een reeks willekeurige mensen en willekeurige relaties kan creëren, moeten we de informatie of statistieken van de ziekte invoeren om te zien hoe deze interacties binnen een populatie de infectie kunnen verhogen of verlagen.

Maak deze variabelen:

unvacc %type: dubbel; procent kans dat niet-gevaccineerde mensen de ziekte niet krijgen

vacc %type: dubbel; procent kans dat gevaccineerde mensen de ziekte niet krijgen unvacc_perc %type: double; procent bevolking niet-gevaccineerd init_infect %type: int; procent gevaccineerde bevolking

Vervolgens moeten we wat berekeningen maken.

We gaan een 'infectieMat' maken die een 3*NUMOFPEOPLE-matrix is.

vacc_perc = 1-unvacc_perc;

infectieMat = nan(3, NUMOFPEOPLE); getal = rond (vacc_perc * NUMOFPEOPLE); infectieMat(1, 1:getal) = vacc; infectieMat(1, nummer+1:end) = unvacc; infectieMat(2, 1:end) = 0; infectieMat(2, 1:init_infect) = 1;

Code Uitleg

regel 1: Percentage niet-gevaccineerde bevolking berekend

regel 2: maak een matrix van 3*N aantal personen

regel 3: zoek het aantal gevaccineerde mensen uit het gevaccineerde percentage

regel 4: voor de gevaccineerde mensen, geef ze een immuniteit die verband houdt met het hebben van het vaccin. Deze waarde wordt toegekend op basis van onderzoek over de ziekte.

regel 5: voor de rest van de bevolking (niet-gevaccineerde personen), geef ze het percentage immuniteit. Deze waarde wordt toegekend op basis van onderzoek over de ziekte.

regel 6: stel in eerste instantie alle mensen in op niet geïnfecteerd.

regel 7: vul voor het aantal aanvankelijk geïnfecteerde mensen de eerste paar kolommen dienovereenkomstig in.

Nu we alle parameters voor de ziektesimulatie hebben ingesteld, gaan we de kans randomiseren of de persoon (zowel gevaccineerd als niet-gevaccineerd) besmet raakt. Dit gebeurt in de volgende stap door willekeurige waarden tussen 0 en 1 toe te kennen aan elke persoon in de derde rij van deze 'infectieMat'.

Stap 4: Randomiseer de kans dat een gevaccineerde en niet-gevaccineerde persoon besmet kan raken

Wijs vervolgens elke persoon een willekeurig nummer toe, dit zal later worden gebruikt om te bepalen of de persoon besmet raakt of niet.

voor w = 1: lengte (infectieMat)

infectieMat(3, w) = rand; einde

Code uitleg

Deze for-lus behandelt de derde rij van de 'infectionMat' die in de laatste stap is gemaakt. 'rand' kent een waarde tussen 0 en 1 toe aan elke index van rij 3.

Uitgang:

infectieMat is nu voltooid! Dit was met een populatie met 100% vaccinatie en 1 persoon die aanvankelijk besmet was.

infectieMat =

Kolommen 1 t/m 12 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 1.0000 0 0 0 0 0 0 0 0 0 0 0 0.0869 0.5489 0.3177 0.9927 0.7236 0.5721 0.7172 0.9766 0.4270 0.9130 0.8973 13 0.8500 0.7500 Kolommen 0,7500 0,7500 0 0 0 0 0 0 0 0 0,0480 0,3593 0,2958 0,6291 0,1362 0,3740 0,8648 0,2503

rij 1: Percentage kans om de ziekte NIET te krijgen

rij 2: Geïnfecteerd of niet geïnfecteerd (booleaanse waarde)

rij 3: Nummer dat wordt gebruikt om te controleren of een niet-geïnfecteerde persoon besmet raakt als hij een besmette persoon ontmoet. Als een niet-geïnfecteerde persoon een geïnfecteerde persoon ontmoet, is dit aantal groter dan het getal in rij 1 (voor dezelfde kolom), dan zijn ze geïnfecteerd. We zullen deze functionaliteit coderen in stap 7.

Stap 5: Maak matrices van niet-gevaccineerde en geïnfecteerde mensen op basis van initiële informatie

Maak 2 matrices genaamd "matrixUnvacc" en "matrixInfected" die alle geïnfecteerde mensen van infectieMat opslaat. Dit zal worden gebruikt, zodat we de grafiek van degenen die geïnfecteerd, niet-gevaccineerd of gevaccineerd zijn, een kleurcode kunnen geven, zodat we de impact van niet-gevaccineerde versus gevaccineerde personen kunnen visualiseren.

elk wissen

matrixGeïnfecteerd = ; matrixUnvacc = ; voor h= 1:lengte(infectieMat) if infectieMat(1, h) == unvacc matrixUnvacc = [matrixUnvacc, h]; end end for person = 1:NUMOFPEOPLE if infectieMat(2, person) == 1 matrixInfected = [matrixInfected, person]; einde einde

Code Uitleg

Maak twee lege matrices om de nummers op te slaan van de mensen die respectievelijk niet-gevaccineerd en geïnfecteerd zijn. Beide for-lussen lopen 20 keer en als aan het if-statement wordt voldaan, wordt het nummer toegevoegd aan de juiste matrix.

Uitgang:

matrixUnvacc =

matrixInfected =

[1]

Stap 6: Plot de eerste grafiek

Vervolgens gaan we de aangrenzende matrix plotten.

g = grafiek (adjMatrix);

figuur(1) p = plot(g, 'NodeColor', 'b', 'MarkerSize', 7); highlight(p, matrixUnvacc, 'NodeColor', 'g') highlight(p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc*100; title(['Percentage niet-gevaccineerde mensen: ', num2str(title_unvacc), '%']); pauze (snelheid)

Code uitleg

De grafentheorie in Matlab heeft ingebouwde functies. Als we de functie graph() gebruiken, kunnen we de 'adjMatrix' vertalen naar een echte ongerichte grafiek. We moeten dan een plot maken met de functie plot() om te zien hoe het eruit ziet. We stellen deze plot() in op een variabele zodat we de kleuren van de plot gemakkelijker kunnen manipuleren en veranderen tijdens de simulatie. Alle personen (of nodes) zijn in eerste instantie ingesteld op de kleur 'blauw'. Vervolgens worden alle niet-gevaccineerde mensen op de kleur 'groen' gezet. De besmette mensen krijgen dan de kleur 'rood'. De titel wordt bepaald op basis van de bepaalde procentuele waarde van niet-gevaccineerde mensen die worden getest. De functie pause() stopt tijdelijk de uitvoering van MatLab. We passeren de variabele snelheid die wordt gespreid en die in seconden wordt berekend.

Zie afbeelding (hierboven) om een willekeurige kleurgecodeerde grafiek te zien.

Leer meer over de highlight()-functie in MatLab.

Stap 7: Simuleer de progressie van infectie

Vervolgens moeten we uitzoeken wie er geïnfecteerd raakt na de interacties (opgenomen in de adjMatrix) en de grafiek bijwerken wanneer iemand geïnfecteerd raakt.

Gebruik de adjMatrix om te bepalen welke mensen besmet zijn na hun interacties met mensen op een dag.

voor elke rij = 1: lengte (adjMatrix)

if infectieMat(2, eachRow) == 1 voor elkeCol = 1:length(adjMatrix) if adjMatrix(eachRij, EachCol) == 1 % eachRow = de persoon % eachCol = zijn vriend % de vriend van elke persoon en kijk of ze geïnfecteerd raken. if infectieMat(3, EachCol) > infectieMat(1, EachCol) infectieMat(2, EachCol) = 1; highlight(p, eachCol, 'NodeColor', 'r') pause(speed) end end end end end

De for-lus loopt door elke persoon. Het controleert of de persoon geïnfecteerd is, het zal elk van de mensen/vrienden controleren waarmee ze contact hebben gehad en controleren of het immuniteitsniveau van de vriend groter was dan de sterkte van de ziekte. Dit is waar de 'infectionMat' die we eerder hebben gemaakt in het spel komt. De 1e en 3e rij van elke kolom van de vriend wordt vergeleken en als de 3e rij groter is, betekent dit dat de vriend niet voldoende immuniteit had om aan de ziekte te ontsnappen en uiteindelijk geïnfecteerd raakt. We veranderen ook van kleur met highlight() naar rood als ze geïnfecteerd raken.

Nu zou je code voor de simulatie moeten werken! en voor elke populatiegrootte, verander gewoon NUMOFPEOPLE!

Stap 8: Gebruik de Monte Carlo-theorie

Om nog een stap verder te gaan en gegevens uit onze simulator ('infectionSim.m') te halen, wilden we de trend berekenen en in een grafiek uitzetten in het percentage niet-gevaccineerde mensen dat besmet raakte en het percentage gevaccineerde mensen dat besmet raakte. We veronderstellen dat het percentage gevaccineerde mensen dat besmet is geraakt een stuk lager zou moeten zijn dan het percentage niet-gevaccineerde mensen dat besmet is geraakt.

Stap 9: Maak van het bestand ('infectionSim.m') met de simulatie een functie

Om Monte Carlo uit te voeren, zouden we de simulatie meerdere keren willen uitvoeren en gegevens verzamelen zodat we die kunnen gebruiken om de percentages van mensen die geïnfecteerd zijn in een grafiek te zetten.

De functie zou als volgt kunnen worden ingesteld:

functie output = infectieSim(unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect, speed)

Geef commentaar op de variabelen in uw simulatie, aangezien u deze nu doorgeeft via het hoofdbestand (we beginnen dit te schrijven in stap 12):

unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect

De nieuwe variabele

snelheid

wordt toegewezen in het hoofdbestand (Monte_Carlo.m).

Opmerking: vergeet niet het einde onderaan het functiebestand om de functie te beëindigen!

Stap 10: Bereken het percentage niet-gevaccineerde en gevaccineerde mensen die besmet zijn geraakt

Deze berekent het percentage niet-gevaccineerde mensen dat besmet is geraakt. Deze code staat onderaan het bestand 'infectionSim.m'.

number_of_unvacc = 0;

number_of_infec_unvacc = 0; %berekent het percentage niet-gevaccineerde mensen die besmet raakten voor x = 1:lengte(infectieMat) if infectieMat(1, x) == unvacc number_of_unvacc = number_of_unvacc+1; end if infectieMat(1, x) == unvacc & infectieMat(2, x) == 1 number_of_infec_unvacc = number_of_infec_unvacc +1; end end percentage_of_unvacc_and_infec = (number_of_infec_unvacc / number_of_unvacc)*100;

Code uitleg

In de for-lus loopt het over NUMOFPEOPLE keer. Telkens als het nummer in de infectieMat overeenkomt met het unvacc-nummer (dus 0,95 == 0,95), dan wordt het aantal niet-gevaccineerde personen met 1 verhoogd. Telkens als het nummer in de infectieMat overeenkomt met het unvacc-nummer en ze besmet zijn, wordt de aantal geïnfecteerde en niet-gevaccineerde stijgt met 1. De laatste regel deelt het aantal geïnfecteerde, niet-gevaccineerde mensen door het totale aantal niet-gevaccineerde mensen. Hieruit wordt dan het percentage berekend.

Uitdaging:

Probeer het percentage gevaccineerde mensen te berekenen dat besmet is geraakt! (Hint: het lijkt erg op deze bovenstaande code, maar sommige variabelen zijn gewijzigd en namen zijn aangepast.)

Vervolgens wordt het percentage geïnfecteerden berekend op basis van de totale bevolking:

pre_per_infect = cumsum(infectionMat(2,:));

per_infect = (pre_per_infect(1, NUMOFPEOPLE)/NUMOFPEOPLE)*100;

Code uitleg

De cumulatieve som wordt berekend met behulp van de tweede rij van de infectieMat, die 1s en 0s opslaat, afhankelijk van of de persoon besmet is of niet. Aangezien de functie cumsum() een matrix teruggeeft, nemen we de laatste waarde in de matrix ('pre_per_infect(1, NUMOFPEOPLE)'), die de werkelijke som zou moeten zijn van alle waarden van 'infectionMat(2,:)'. Door de som te delen door het NUMOFPEOPLE en te vermenigvuldigen met 100, krijgen we het uiteindelijke percentage geïnfecteerden in de totale populatie.

Stap 11: Maak een uitvoervariabele in uw functie 'infectionSim.m'

output = [per_infect, percentage_van_unvacc_and_infec, percentage_of_vacc_and_infec];

Code uitleg

Sla deze informatie op in output, die teruggestuurd wordt naar main (Monte_Carlo.m) wanneer de functie wordt aangeroepen en klaar is met draaien. Deze gegevens worden gebruikt om de punten van het percentage geïnfecteerden van degenen die zijn gevaccineerd en niet-gevaccineerd in een grafiek te zetten.

Je 'infectionSim.m'-functie zou nu klaar moeten zijn! Het zal echter niet worden uitgevoerd omdat we nog steeds de belangrijkste moeten schrijven!

Stap 12: Maak een menu om de initiële voorwaarden van de simulatie van de gebruiker te krijgen

Onthoud hoe we de variabele zeiden

snelheid

zou worden gemaakt en doorgegeven via de hoofdfunctie? We moeten de waarden verkrijgen om door te geven aan de functie. Let op, de volgorde van de waarden bij het aanroepen van de functie doet er toe!

Begin door de gebruiker te vragen enkele antwoorden in de terminal te typen.

> Kies een ziekte. Let op: het is hoofdlettergevoelig >> Kinkhoest >> Griep >> Mazelen >> Gekozen ziekte: Griep >> Kies de populatiegrootte. >> 20 >> 200 >> Gekozen populatie: 20 >> Kiessnelheid van simulatie. >> Snel >> Langzaam >> Gekozen snelheid: Snel

Deze code hieronder vraagt de gebruiker naar welke ziekte ze willen kijken.

disp('Kies een ziekte. Let op: deze is hoofdlettergevoelig')

fprintf('Kinkhoest\nGriep\nMazelen\n') ziekte = input('Gekozen ziekte: ', 's'); indien gelijk is (ziekte, 'Pertussis') vacc =.85; %15 procent kans op het krijgen van de ziekte unvacc = 0,20; %80 procent kans op ziekte anders indien gelijk (ziekte, 'griep') vacc = 0,75; %25 procent kans op het krijgen van de ziekte unvacc =.31; %69 procent kans op het krijgen van een ziekte anders indien gelijk (ziekte, 'Mazelen') vacc = 0,97; %3 procent kans om de ziekte te krijgen unvacc = 0,10; %90 procent kans op het einde van de ziekte

Code uitleg:

De functie disp() drukt de instructie af op het scherm en drukt ook de verschillende opties af. De ziekte zal dienovereenkomstig worden toegewezen. Deze versie houdt momenteel geen rekening met ongeldige invoer. Ongeldige invoer zal een fout veroorzaken en het programma volledig stoppen. Aan elke ziekte zijn vacc- en unvacc-waarden verbonden. Deze waarden zijn NIET willekeurig. We hebben deze waarden gekregen van onderzoek naar statistieken over de ziekten.

Vervolgens moeten we de gebruiker vragen of ze een grote of kleine populatiegrootte willen testen voor de door hen gekozen ziekte.

disp('Kies de grootte van de populatie.')

fprintf('20\n200\n') speed = input('Gekozen populatie: ', 's'); if isequal(snelheid, '20') populatiegrootte = 20; elseif is gelijk (snelheid, '200') populatiegrootte = 200; einde

Code uitleg

Dit drukt een verklaring af voor de gebruiker en vraagt de gebruiker om in te voeren welke populatiegrootte hij wil testen. Deze versie houdt momenteel geen rekening met ongeldige invoer. Ongeldige invoer zal een fout veroorzaken en het programma volledig stoppen. 20 werd gekozen omdat het een kleine steekproefomvang is die nog steeds een goed idee geeft van hoe de infectie zich over een kleine populatie verspreidt. 200 mensen werd gekozen als de grotere optie omdat 200 punten die in de grafiek waren uitgezet nauwelijks punten overlap hadden, zodat alles gemakkelijk te zien en van elkaar te onderscheiden was.

Vervolgens moeten we de snelheid van de simulatie vinden.

disp('Kiessnelheid van simulatie.')

fprintf('Snel\nLangzaam\n') speed = input('Snelheid gekozen: ', 's'); if isequal (snelheid, 'Snel') sim_speed = 0; elseif is gelijk (snelheid, 'Langzaam') sim_speed = 0.25; einde

Code uitleg

Dit proces was hetzelfde als het verkrijgen van het type ziekte en de omvang van de bevolking. Voor snel is er geen pauze. en voor langzaam is er een vertraging van 0,25 seconde in de for-lus bij het uitvoeren van de simulatie.

Super goed! Nu hebben we alle input van de gebruiker die we nodig hebben! Laten we verder gaan met het verzamelen van gegevens voor verschillende percentages niet-gevaccineerde mensen.

Stap 13: Kies een percentage niet-gevaccineerde mensen en bereken het gemiddelde van niet-gevaccineerde en geïnfecteerde personen voor het gekozen percentage

Deze code is voor 0% van de niet-gevaccineerde mensen.

% ------- %0 Niet gevaccineerd ------------

per_infect_av_0 = ; percentage_of_unvacc_and_infec_av_0 = ; voor i = 1:20 out = infectieSim (unvacc, vacc, populatiegrootte, 0, 1, sim_speed); per_infect_av_0 = [per_infect_av_0, uit(1, 1)]; percentage_of_unvacc_and_infec_av_0 = [percentage_of_unvacc_and_infec_av_0, out(1, 2)]; einde gemiddelde_infected_0 = gemiddelde (per_infect_av_0); gemiddelde_unvacc_and_infected_0 = gemiddelde (percentage_van_unvacc_and_infec_av_0);

Code uitleg:

De for-lus wordt 20 keer uitgevoerd. De uitvoer van de functie, infectieSim(), wordt opgeslagen in out. Elke keer dat de for-lus wordt uitgevoerd, wordt het percentage geïnfecteerden in de totale populatie toegevoegd aan de matrix 'per_infect_av_0'. Bovendien wordt telkens het percentage niet-gevaccineerd en geïnfecteerden toegevoegd aan de matrix 'percentage_of_unvacc_and_infec_av_0'. In de laatste twee regels worden deze twee bovengenoemde matrices vervolgens gemiddeld en opgeslagen in variabelen. Samenvattend worden de percentages voor elke simulatie opgeslagen, gemiddeld en grafisch weergegeven. Monte Carlo wordt gebruikt om de gemiddelde waarde te tonen van het uitvoeren van een simulatie en het tonen van het resultaat. Voor onze experimentele doeleinden kiezen we ervoor om de simulatie 20 keer uit te voeren en die waarden te middelen.

Uitdaging:

Herhaal dit voor alle percentages die u wilt testen! Dit kan worden gedaan door de variabelenamen te wijzigen volgens de percentages. We hebben getest op 0%, 5%, 10%, 20%, 30% en 50%.

Tip:

De enige regel die in de eigenlijke code moet worden gewijzigd, is:

out = infectieSim (unvacc, vacc, populatiegrootte, 0, 1, sim_speed);

Verander de nul in het percentage in decimale vorm. Voor bijvoorbeeld 5% niet-gevaccineerde simulatie moet de 0 worden vervangen door 0,5.

Stap 14: Grafiek: 'De trend van infectie bij niet-gevaccineerde vs. Gevaccineerd tegen bepaalde ziekte'

Dit is de code om een grafiek te maken van de trend van infectie bij niet-gevaccineerde personen versus niet-gevaccineerde personen.

graph_mat_y = [gemiddelde_infected_0, gemiddelde_infected_5, gemiddelde_infected_10, gemiddelde_infected_20, gemiddelde_infected_30, gemiddelde_infected_50];

grafiek_mat_x = [0, 5, 10, 20, 30, 50]; helling = (average_infected_5-average_infected_0)/5; line_y = [gemiddelde_geïnfecteerde_0, (helling*50)+gemiddelde_geïnfecteerde_0]; lijn_x = [0, 50]; figuur (2) plot (graph_mat_x, graph_mat_y); line(line_x, line_y, 'Kleur', 'rood', 'Lijnstijl', '--'); title(['Trend in niet-vaccinatie voor ', ziekte]); xlabel('Percentage van aanvankelijk niet-gevaccineerd'); ylabel('Percentage definitief geïnfecteerd')

Code uitleg

regel 1: y-waarden toegewezen aan de gemiddelden van het percentage geïnfecteerden

regel 2: x-waarden toegewezen aan het percentage aanvankelijk niet-gevaccineerd

regel 3: bereken de helling van 0% en 5%

regel 4: sla y-waarden van regel op. Dit is een voortzetting van de 0% tot 5% sectie.

regel 5: sla y-waarden van regel op. Deze lijn overspant de lengte van de grafiek.

regel 6: figuur maken

regel 7: plot de grafiek x- en y-waarden van het percentage geïnfecteerden, dat niet-gevaccineerd is.

regel 8: teken de lijn. Dit wordt gebruikt om aan te tonen dat het niet lineair, maar exponentieel toeneemt.

regel 9: Stel de titel voor de grafiek in.

regel 10-11: Stel x- en y-labels in voor grafiek.

Nu zou je moeten kunnen zien dat hoe groter het percentage van de bevolking dat niet gevaccineerd is, hoe groter de infectie. Je zult ook zien dat de meeste stippen die rood worden, groene stippen zijn, wat aangeeft dat het vaccin tot op zekere hoogte helpt! Ik hoop dat je deze tutorial leuk vond. Reageer als je vragen hebt!

Stap 15: Eindproduct: hoe de simulatie eruitziet

Alle code vind je hier