Å bli vaksinert eller ikke? et prosjekt om å observere flokkimmunitet gjennom sykdomssimulering: 15 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

Oversikt over prosjektet:

Vårt prosjekt utforsker flokkimmunitet og håper å oppmuntre folk til å få vaksinasjoner for å redusere smittefrekvensen i lokalsamfunnene våre. Programmet vårt simulerer hvordan en sykdom infiserer en befolkning med forskjellige prosentandeler av vaksinerte og uvaksinerte priser. Det viser flokkimmunitet ved å vise hvordan et økt antall av den vaksinerte befolkningen kan redusere antallet berørte mennesker.

Vi modellerer dette i Matlab ved hjelp av grafteorikonsepter. Grafteori er en matematisk måte å representere forholdet mellom objekter. I grafteori har grafer hjørner (eller noder) forbundet med kanter (eller linjer). For prosjektet vårt er nodene individene det gjelder og kantene er deres forbindelser. For eksempel, hvis to noder er koblet til en kant, betyr det at de er "venner" eller har en eller annen form for kontakt med hverandre. Denne kontakten er en måte for sykdommen å spre seg på. Dette er grunnen til at vi brukte grafteori til å modellere konseptet vårt fordi vi ønsket å se hvordan sykdom sprer seg blant individer som er koblet i en befolkning.

Prosjektet vårt involverer også Monte Carlo -metoden. Monte Carlo -metoden er algoritmer som lager gjentatte stikkprøver for å motta numeriske resultater. I vårt prosjekt bruker vi denne metoden til å kjøre simuleringen vår flere ganger og endre andelen opprinnelige uvaksinerte for å se hvor raskt folk blir smittet.

All prosjektkode er koblet nederst!

PC-kreditt:

Matlab-lenke til grafteori:

Trinn 1: Lag Adjacency Matrix

Lag et nytt skript. Vi kommer til å kalle vår 'infeksjonSim.m'.

Vi skal lage en variabel 'NUMOFPEOPLE'. Du kan tilordne den til en hvilken som helst heltallsverdi. Dette vil representere antall mennesker i befolkningen din.

Fra nå av vil vi anta det

NUMOFPEOPLE = 20;

Start først med å bruke Matlabs grafteorifunksjoner for en ikke -styrt graf.

Hvis du er interessert i å lære mer, her er en lenke for deg å lese mer grundig om det.

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

Lagde en tilknytningsmatrise.

adjMatrix = nuller (NUMOFPEOPLE);

Dette vil opprette en firkantmatrise på 0s. Hver rad i matrisen er en person. Hver kolonne i matrisen er en person eller venn som personen møter gjennom dagen.

Se figur 100 (ovenfor) for å visualisere hvordan adjMatrix ser ut for 20 personer.

** Fra dette tidspunktet antar vi at NUMOFPEOPLE er lik 20. **

Du kan prøve å plotte denne tilknytningsmatrisen. Her er litt mer informasjon om å plotte denne typen matriser.

Merk: Hvordan adjasensmatrisen fungerer.

Eks:

%lage den tilstøtende matrisen

a = [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] %plotting g = graf (a); %ved hjelp av graffunksjonen (grafteori) figur (1); h = tomt (g);

Se figur 1 (ovenfor) for å se hvordan du legger til kanter i tilstøtningsmatrisen, ved hjelp av koden i "Merk".

Trinn 2: Lag relasjoner

Nå som personene (hjørner eller noder) er opprettet, må vi lage et nettverk av relasjoner (linjer eller kanter på grafen). Dette vil simulere hvordan mennesker samhandler og møter andre mennesker gjennom en dag.

Dette kan gjøres på mange måter. En måte å fullføre denne oppgaven på er å først tildele et tilfeldig tall til hver person for å bestemme hvor mange mennesker hver person vil samhandle med på en dag.

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

Dette gir en 1 til 20 matrise av tilfeldige heltall som representerer antall interaksjoner hver person har om dagen. Kolonnene i denne matrisen vil være tallet som tilsvarer hver person. For eksempel hvis vi tildeler minstFriendsPersonCanHave = 2 og mostFriendsPersonCanHave = 5, ville vi få tilfeldige verdier mellom 2 og 5.

Har du problemer med randi ()? I terminalen skriver du

hjelp randi

Deretter lager vi en randomisert matrise (kalt "allFriendsmatrix") av hvordan hver person i befolkningen er koblet/samhandler i befolkningen.

tempMatrix = ;

telle = 0; allFriendsMatrix = ; for k = 1: NUMOFPEOPLE mens lengde (tempMatrix) ~ = numOfFriendsMatrix (k) count = count +1; temp = randi ([1, NUMOFPEOPLE]); tempMatrix (count) = temp; avslutt hver gang lengde (tempMatrix) ~ = 9 tempMatrix = [tempMatrix, NaN]; avslutte allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; telle = 0; slutt

En grundig forklaring av koden:

Først lager vi en tom midlertidig matrise for å holde hver persons venn/interaksjonsliste. Vi initialiserer også tellingen, som bare holder oversikt over hvor den nye tilfeldige tilkoblingen skal festes i tempMatrix. For -løkkene går 20 ganger slik at dette skjer for hver enkelt person i befolkningen. Den første mens loop går til hver persons tempMatrix er like lang som det tilfeldig tildelte antallet interaksjoner. I denne sløyfen genereres et tilfeldig tall som tilsvarer person i befolkningen og plasseres i tempMatrix. Fordi lengden på hver av tempMatrixes er forskjellige, trengte vi å lage noen NaN -verdier slik at vi kan sammenkoble alle disse tempMaticene til en matrise ('allFriendsMatrix'). Den andre mens loop løser dette problemet ved å legge NaN til hver tempMatrix. Mens loop var satt til å kjøre 9 ganger fordi det er et tall større enn 5, som var den øvre grensen for venner en person kan tildeles. Verdien '9' er variabel og kan/må endres når 'mostFriendsPersonCanHave' er større enn 9. De tre siste kodelinjene (unntatt slutten) legger til tempMatrix i neste rad i 'allFriendsMatrix'. Deretter tømmer det ut tempMatrix og teller for neste person.

Produksjon

Slik skal utgangen se ut for den første kjøringen gjennom for -løkken (før de tre siste linjene).

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 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 19 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 NaN 1 7 NaN NaN NaN NaN NaN NaN NaN 16 7 13 10 1 NaN NaN NaN NaN

Deretter legger du disse relasjonene til adjMatrix.

for eachRow = 1: NUMOFPEOPLE

for eachCol = 1: 9 hvis isnan (allFriendsMatrix (eachRow, eachCol)) == 0 adjMatrix (eachRow, allFriendsMatrix (eachRow, eachCol)) = 1; adjMatrix (allFriendsMatrix (eachRow, eachCol), eachRow) = 1; ende ende ende

Kode Forklaring

Denne doble for loop går gjennom hver rad og kolonne i 'allFriendsMatrix'. If -setningen kjøres for alle verdier som ikke er 'NaN'. I utgangspunktet vil det lage kantene eller linjene i grafen. Så den første linjen dette vil gjøre er person 1 til person 16 og person 16 til person 1. Fordi den er ustyrt, må 1 endres for begge! Vi kan ikke bare ha kanten 1 til 16 og ikke 16 til 1. De må være symmetriske for at den skal fungere skikkelig i Matlab.

I vår simulering fant vi ut at mennesker ikke kan samhandle med seg selv. Når vi randomiserte verdiene, er det en sjanse for at tilstøtende matrise har disse feilene.

La oss fikse dette med følgende kode:

for hver = 1: NUMOFPEOPLE

adjMatrix (hver, hver) = 0; slutt

Kode Forklaring

Denne for sløyfe sikrer at person 1 ikke er koblet til person 1, person 2 ikke er koblet til person 2, osv. Ved å gjøre dem alle 0. Som du kan se nedenfor i utdataseksjonen, har vi diagonal på kvadratet matrisen fra øverst til venstre til nederst til høyre er alle 0 -tallet.

Produksjon

Dette er den siste adjMatrix for denne nåværende simuleringen. Dette utgjør alle linjene i grafen (figur 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

Se figur 2 for å se grafen over 'adjMatrix'.

Trinn 3: Legg til sykdomsstatistikk

Nå som programmet ditt kan lage en graf med et sett med tilfeldige mennesker og skape tilfeldige forhold, må vi legge inn sykdomsinformasjon eller statistikk for å se hvordan disse interaksjonene i en populasjon kan øke eller redusere infeksjonen.

Lag disse variablene:

unvacc %type: double; prosent sjanse for at ikke -vaksinerte mennesker ikke får sykdommen

vaks. %type: dobbelt; prosent sjanse for at vaksinerte ikke får sykdommen unvacc_perc %type: double; prosent befolkning uvaksinert init_infect %type: int; prosent befolkning vaksinert

Deretter må vi gjøre noen beregninger.

Vi skal lage en 'infectMat' som er en 3*NUMOFPEOPLE -matrise.

vacc_perc = 1-unvacc_perc;

infeksjonMat = nan (3, NUMOFPEOPLE); nummer = rund (vacc_perc * NUMOFPEOPLE); infeksjonMat (1, 1: nummer) = vaksine; infeksjonMat (1, tall+1: slutt) = unvacc; infeksjonMat (2, 1: ende) = 0; infeksjonMat (2, 1: init_infect) = 1;

Kode Forklaring

linje 1: Prosent av befolkningen uvaksinert beregnet

linje 2: lag en 3*N antall personer matrise

linje 3: finn ut antall personer som er vaksinert fra vaksinert prosentandel

linje 4: for de vaksinerte, gi dem en immunitet forbundet med å ha vaksinen. Denne verdien tildeles basert på forskning om sykdommen.

linje 5: for resten av befolkningen (uvaksinerte personer), gi dem prosentvis immunitet. Denne verdien tildeles basert på forskning om sykdommen.

linje 6: Sett først alle mennesker til å ikke bli smittet.

linje 7: for antallet personer som først ble smittet, fyll ut de første par kolonnene tilsvarende.

Nå som vi har satt alle parametrene for sykdomsimuleringen, skal vi tilfeldigvis sjanse for at personen (både vaksinert og uvaksinert) blir smittet. Dette gjøres i neste trinn ved å tildele tilfeldige verdier mellom 0 og 1 til hver person i den tredje raden i denne 'infectMat'.

Trinn 4: Tilfeldig sjanse for at en vaksinert og ikke -vaksinert person kan bli smittet

Tildel deretter hver person et tilfeldig tall. Dette vil bli brukt senere for å avgjøre om personen blir smittet eller ikke.

for w = 1: length (infectMat)

infeksjonMat (3, w) = rand; slutt

Kode forklaring

This for loop omhandler den tredje raden av 'infectMat' som ble opprettet i det siste trinnet. 'rand' tilordner en verdi mellom 0 og 1 til hver indeks i rad 3.

Produksjon

infeksjonMat er nå fullført! Dette var med en befolkning med 100% vaksinasjon og 1 person som opprinnelig ble smittet.

infeksjonMat =

Kolonne 1 til 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 0,8352 Kolonne 13 til 0,0075 0,7500 0,7500 0 0 0 0 0 0 0 0 0,0480 0,3593 0,2958 0,6291 0,1336 0,3740 0,8648 0,2503

rad 1: Prosent sjanse for IKKE å få sykdommen

rad 2: Infisert eller ikke infisert (boolsk verdi)

rad 3: Nummer som brukes til å kontrollere om en person som ikke er smittet blir smittet hvis de møter en infisert person. Hvis uinfisert person møter infisert person, er dette tallet større enn tallet i rad 1 (for samme kolonne), så blir de infisert. Vi vil kode denne funksjonaliteten i trinn 7.

Trinn 5: Lag matriser for mennesker som er uvaksinert og infisert fra første informasjon

Lag to matriser kalt "matrixUnvacc" og "matrixInfected" som lagrer alle de smittede fra infeksjonsmat. Dette vil bli brukt slik at vi kan fargekode grafen til de som er smittet, uvaksinert eller vaksinert, og hjelper til med å visualisere virkningen av uvaksinerte versus vaksinerte individer.

klar hver

matrixInfected = ; matrixUnvacc = ; for h = 1: length (infeksjonMat) hvis infeksjonMat (1, h) == unvacc matrixUnvacc = [matrixUnvacc, h]; ende ende for person = 1: NUMOFPEOPLE hvis infeksjonMat (2, person) == 1 matrixInfected = [matrixInfected, person]; ende ende

Kode Forklaring

Lag to tomme matriser for å lagre tallene til de som er henholdsvis uvaksinert og infisert. Både for løkker kjøres 20 ganger, og hvis if -setningen er tilfreds, blir tallet lagt til i riktig matrise.

Produksjon

matrixUnvacc =

matrixInfected =

[1]

Trinn 6: Plott innledende graf

Deretter skal vi plotte adjacensmatrisen.

g = graf (adjMatrix);

figur (1) p = plot (g, 'NodeColor', 'b', 'MarkerSize', 7); highlight (p, matrixUnvacc, 'NodeColor', 'g') highlight (p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc*100; title (['Andel uvaksinerte:', num2str (title_unvacc), '%']); pause (hastighet)

Kode forklaring

Grafteori i Matlab har innebygde funksjoner. Når vi bruker grafen () -funksjonen, er vi i stand til å oversette 'adjMatrix' til en faktisk uorientert graf. Vi må da lage et plott ved hjelp av plott () -funksjonen for å faktisk se hvordan det ser ut. Vi setter dette plottet () til en variabel slik at vi lettere kan manipulere og endre fargene på plottet gjennom simuleringen. Alle mennesker (eller noder) er opprinnelig satt til fargen "blå". Deretter er alle uvaksinerte mennesker satt til fargen 'grønn'. De infiserte menneskene blir deretter satt til fargen "rød". Tittelen er satt i henhold til den bestemte prosentverdien av uvaksinerte mennesker som testes. Pause () -funksjonen stopper MatLab -kjøringen midlertidig. Vi passerer gjennom den variable hastigheten som spres som beregnes i sekunder.

Se bildet (over) for å se en tilfeldig fargekodet graf.

Lær mer om funksjonen høydepunkt () i MatLab.

Trinn 7: Simuler infeksjonens progresjon

Deretter må vi finne ut hvem som blir smittet etter interaksjonene (registrert i adjMatrix) og oppdatere grafen når noen blir infisert.

Bruk adjMatrix for å finne ut hvilke mennesker som er smittet etter samspillet med mennesker på en dag.

for eachRow = 1: length (adjMatrix)

hvis infectMat (2, eachRow) == 1 for eachCol = 1: length (adjMatrix) if adjMatrix (eachRow, eachCol) == 1 % eachRow = personen % eachCol = sin venn % hver persons venn og se om de blir smittet. hvis infeksjonMat (3, hverCol)> infeksjonMat (1, hverCol) infeksjonMat (2, hverKol) = 1; markere (p, eachCol, 'NodeColor', 'r') pause (hastighet) ende ende ende ende ende

For -sløyfen går gjennom hver person. Den sjekker at hvis personen er smittet, vil den sjekke hver av personene/vennen de samhandlet med og sjekke om vennens immunitetsnivå var større enn sykdommens styrke. Det er her 'infectMat' vi opprettet tidligere spiller inn. Den første og tredje raden i hver kolonne av vennen blir sammenlignet, og hvis den tredje raden er større, betyr det at vennen ikke hadde høy nok immunitet til å unnslippe sykdommen og til slutt blir smittet. Vi bytter også til farge ved å bruke høydepunkt () til rødt hvis de blir infisert.

Nå skal koden din for simuleringen fungere! og for enhver befolkningsstørrelse, bare endre NUMOFPEOPLE!

Trinn 8: Bruk Monte Carlo -teorien

For å ta dette et skritt videre og trekke ut data fra simulatoren vår ('infeksjonSim.m'), ønsket vi å beregne og tegne trenden i prosent av uvaksinerte mennesker som ble smittet og prosent av vaksinerte mennesker som ble smittet. Vi antar at andelen vaksinerte som ble smittet bør være mye lavere enn andelen uvaksinerte som ble smittet.

Trinn 9: Lag filen ('infeksjonSim.m') med simuleringen i en funksjon

For å kjøre Monte Carlo, ønsker vi å kjøre simuleringen flere ganger og samle data slik at vi kan bruke det til å tegne prosentandelen av mennesker som ble smittet.

Funksjonen kan settes opp slik:

funksjonsutgang = infeksjonSim (unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect, speed)

Kommenter variablene i simuleringen din siden du nå sender disse inn gjennom hovedfilen (vi begynner å skrive dette i trinn 12):

unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect

Den nye variabelen

hastighet

vil bli tilordnet i hovedfilen (Monte_Carlo.m).

Merk: Ikke glem slutten nederst i funksjonsfilen for å avslutte funksjonen!

Trinn 10: Beregn andelen uvaksinerte og vaksinerte som ble smittet

Dette beregner andelen uvaksinerte som ble smittet. Denne koden går nederst i filen 'infectSim.m'.

number_of_unvacc = 0;

number_of_infec_unvacc = 0; %beregner prosentandelen av uvaksinerte personer som ble smittet for x = 1: length (infectMat) hvis infeksjonMat (1, x) == unvacc number_of_unvacc = number_of_unvacc+1; avslutte hvis infeksjonMat (1, x) == unvacc & infeksjonMat (2, x) == 1 nummer_of_infec_unvacc = nummer_of_infec_unvacc +1; slutten slutten prosent_of_unvacc_and_infec = (number_of_infec_unvacc / number_of_unvacc)*100;

Kode forklaring

I for -løkken vil den gå over NUMOFPEOPLE ganger. Hver gang tallet i infeksjonMat tilsvarer unvacc -tallet (dvs. 0,95 == 0,95), vil antallet uvaksinerte personer økes med 1. Hver gang tallet i infeksjonMat tilsvarer unvacc -nummeret og de er infisert, vil antall infiserte og uvaksinerte øker med 1. Den siste linjen deler antall infiserte, uvaksinerte personer med totalt antall uvaksinerte. Deretter beregnes prosentandelen ut fra dette.

Utfordring:

Prøv å beregne andelen vaksinerte av mennesker som ble smittet! (Tips: den ligner veldig på denne koden ovenfor, men noen av variablene endres og navn justeres.)

Deretter beregnes prosentandelen av infiserte personer basert på den totale befolkningen:

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

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

Kode forklaring

Den kumulative summen beregnes ved hjelp av den andre raden i infectMat, som lagrer 1s og 0s avhengig av om personen er infisert eller ikke. Siden funksjonen cumsum () gir tilbake en matrise, tar vi den siste verdien i matrisen ('pre_per_infect (1, NUMOFPEOPLE)'), som skal være den faktiske summen av alle verdiene fra 'infectMat (2,:)'. Ved å dele summen med NUMOFPEOPLE og multiplisere den med 100 får vi den siste prosentandelen av smittede i den totale befolkningen.

Trinn 11: Lag en utdatavariabel i funksjonen 'infeksjonSim.m'

output = [per_infect, percentage_of_unvacc_and_infec, percentage_of_vacc_and_infec];

Kode forklaring

Lagre denne informasjonen i output, som vil bli sendt tilbake til main (Monte_Carlo.m) når funksjonen kalles og kjøres. Disse dataene brukes til å kartlegge poengene til prosent av de smittede av de som er vaksinert og uvaksinert.

Din 'infeksjonSim.m' -funksjon bør gjøres nå! Det vil imidlertid ikke kjøre fordi vi fortsatt trenger å skrive det viktigste!

Trinn 12: Lag en meny for å få de første betingelsene for simuleringen fra brukeren

Husk hvordan vi sa variabelen

hastighet

ville bli opprettet og passert gjennom hovedfunksjonen? Vi må skaffe verdiene for å overføre til funksjonen. Vær oppmerksom på at rekkefølgen på verdiene når du kaller funksjonen betyr noe!

Start med å be brukeren om å skrive inn noen svar i terminalen.

> Velg en sykdom. Vær oppmerksom på at det er store og små bokstaver >> Pertussis >> Influensa >> Meslinger >> Valgt sykdom: Influensa >> Velg populasjonsstørrelse. >> 20 >> 200 >> Valgt befolkning: 20 >> Velg simuleringshastighet. >> Rask >> Sakte >> Hastighet valgt: Rask

Denne koden nedenfor spør brukeren om hvilken sykdom de vil se på.

disp ('Velg en sykdom. Merk at det er saksfølsomt')

fprintf ('Kikhoste / nFlu / nMeasles / n') sykdom = input ('Sykdom valgt:', 's'); hvis ulik (sykdom, 'kikhoste') vaksine =.85; %15 prosent sjanse for å få sykdom unvacc =.20; %80 prosent sjanse for å få sykdom ellers hvis den er ulik (sykdom, 'influensa') vaksine =.75; %25 prosent sjanse for å få sykdom unvacc =.31; %69 prosent sjanse for å få sykdom ellers hvis den er ulik (sykdom, "Meslinger") vaksine =.97; %3 prosent sjanse for å få sykdom unvacc =.10; %90 prosent sjanse for å få sykdom slutt

Kode forklaring:

Disp () -funksjonen skriver ut setningen til skjermen, og den skriver også ut de forskjellige alternativene. Sykdommen vil bli tildelt deretter. Denne versjonen er for øyeblikket ikke ansvarlig for ugyldig innspill. Ugyldig input vil gi en feil og stoppe programmet helt. Hver sykdom har vaksine og unvacc -verdier knyttet til den. Disse verdiene er IKKE tilfeldige. Vi fikk disse verdiene fra å forske på statistikk om sykdommene.

Deretter må vi spørre brukeren om de vil teste en stor eller liten populasjonsstørrelse for den valgte sykdommen.

disp ('Velg befolkningsstørrelse.')

fprintf ('20 / n200 / n ') speed = input (' Befolkning valgt: ',' s '); hvis isequal (hastighet, '20') populasjonsstørrelse = 20; elseif isequal (hastighet, '200') populasjonsstørrelse = 200; slutt

Kode forklaring

Dette skriver ut en uttalelse til brukeren og ber brukeren angi hvilken størrelse på befolkningen den vil teste. Denne versjonen er for øyeblikket ikke ansvarlig for ugyldig innspill. Ugyldig input vil gi en feil og stoppe programmet helt. 20 ble plukket fordi det er en liten utvalgsstørrelse som fortsatt gir en god ide om hvordan infeksjon sprer seg over en liten populasjon. 200 personer ble valgt som det større alternativet fordi 200 punkter plottet på grafen knapt hadde noen overlapping av poeng, så alt lett kunne sees og skilles fra hverandre.

Deretter må vi finne hastigheten på simuleringen.

disp ('Velg simuleringshastighet.')

fprintf ('Rask / nSlow / n') speed = input ('Hastighet valgt:', 's'); hvis isequal (hastighet, 'Fast') sim_speed = 0; elseif isequal (hastighet, 'Slow') sim_speed = 0,25; slutt

Kode forklaring

Denne prosessen var den samme som å få type sykdom og befolkningsstørrelse. For fort blir det ingen pause. og for sakte vil det være en forsinkelse på 0,25 sekunder i for -løkken når du kjører simuleringen.

Flott! Nå har vi alle inngangene fra brukeren vi trenger! La oss gå videre til å samle inn data for forskjellige prosentandeler av uvaksinerte mennesker.

Trinn 13: Velg en prosentandel av uvaksinerte mennesker og beregne gjennomsnittet av uvaksinerte og infiserte for valgt prosentandel

Denne koden er for 0% av uvaksinerte mennesker.

% ------- % 0 Uvaksinert ------------

per_infect_av_0 = ; percentage_of_unvacc_and_infec_av_0 = ; for i = 1:20 ut = infeksjonSim (unvacc, vacc, populasjonsstørrelse, 0, 1, sim_speed); per_infect_av_0 = [per_infect_av_0, ut (1, 1)]; percentage_of_unvacc_and_infec_av_0 = [percentage_of_unvacc_and_infec_av_0, ut (1, 2)]; slutten gjennomsnittlig_infisert_0 = gjennomsnitt (per_infeksjonsav_0); average_unvacc_and_infected_0 = gjennomsnitt (prosent_ av_unvacc_and_infec_av_0);

Kode forklaring:

For -løkken kjøres 20 ganger. Utgangen fra funksjonen, infeksjonSim (), lagres inn. Hver gang for -løkken kjøres, blir prosentandelen av infiserte i den totale populasjonen lagt til matrisen 'per_infect_av_0'. I tillegg legges også andelen uvaksinerte og infiserte til hver gang i matrisen 'percentage_of_unvacc_and_infec_av_0'. I de to siste linjene blir disse to, ovennevnte matrisene deretter gjennomsnittet og lagret i variabler. For å oppsummere, blir prosentandelene lagret for hver simulering, gjennomsnittlig og grafisk. Monte Carlo brukes til å vise gjennomsnittsverdien av å kjøre en simulering og vise resultatet. For våre eksperimentelle formål velger vi å kjøre simuleringen 20 ganger og gjennomsnittlig disse verdiene.

Utfordring:

Gjenta for alle prosenter du vil teste! Dette kan gjøres ved å endre variabelnavnene i henhold til prosenttallene. Vi testet for 0%, 5%, 10%, 20%, 30%og 50%.

Hint:

Den eneste linjen som må endres i den faktiske koden er

out = infectSim (unvacc, vacc, population_size, 0, 1, sim_speed);

Endre null til prosent i desimalform. For eksempel, for 5% uvaksinert simulering, bør 0 erstattes med 0,5.

Trinn 14: Graf: 'Trenden for infeksjon i uvaksinerte vs. Vaksinert for spesifisert sykdom '

Dette er koden for å lage en graf over infeksjonsutviklingen hos uvaksinerte personer mot uvaksinerte personer.

graph_mat_y = [gjennomsnitt_infisert_0, gjennomsnitt_infisert_5, gjennomsnitt_infisert_10, gjennomsnitt_infisert_20, gjennomsnitt_infisert_30, gjennomsnitt_infisert_50];

graf_mat_x = [0, 5, 10, 20, 30, 50]; skråning = (gjennomsnittlig_infisert_5-gjennomsnittlig_infisert_0)/5; line_y = [gjennomsnitt_infisert_0, (stigning*50)+gjennomsnittlig_infisert_0]; line_x = [0, 50]; figur (2) plott (graf_mat_x, graf_mat_y); line (line_x, line_y, 'Color', 'red', 'LineStyle', '-'); title (['Trend i uvaksinasjon for', sykdom]); xlabel ('Prosentandel av første uvaksinerte'); ylabel ('Prosentandel av siste infiserte')

Kode forklaring

linje 1: tildelte y -verdiene til gjennomsnittet av prosent infiserte

linje 2: tildelte x -verdier til prosentandelen av opprinnelige prosent uvaksinert

linje 3: beregne stigningen på 0% og 5%

linje 4: lagre y -verdiene for linjen. Dette er en fortsettelse av 0% til 5% -delen.

linje 5: lagre y -verdiene for linjen. Denne linjen strekker seg over lengden på grafen.

linje 6: lag figur

linje 7: plott grafen x og y -verdiene til prosentandelen infiserte, som er uvaksinerte.

linje 8: plott linjen. Dette brukes for å vise at det ikke øker lineært, men eksponensielt.

linje 9: Angi tittel for grafen.

linje 10-11: Sett x- og y-etiketter for grafen.

Nå bør du kunne se at jo større prosentandel av befolkningen som er uvaksinert, jo større mengder infeksjon. Du vil også se at de fleste prikkene som blir røde er grønne prikker, som viser at vaksinen til en viss grad hjelper! Håper du likte denne opplæringen. Kommenter hvis du har spørsmål!

Trinn 15: Sluttprodukt: Slik ser simuleringen ut

All koden finner du her