1.5 Programmering og modellering

Da datamaskinen ble naturviterens beste venn

I 2020, da covid-19-pandemien rammet verden, sto politikere overfor umulige valg. Skulle de stenge ned samfunnet for å bremse smitten, eller holde alt åpent og håpe på det beste? Svaret kom i stor grad fra programmering. Forskere over hele verden bygget datamodeller som simulerte hvordan viruset ville spre seg under ulike scenarier. Modellene var ikke perfekte -- ingen modell er det -- men de ga verdifull innsikt som hjalp med å redde liv.

Dette er bare ett eksempel på hvordan programmering har blitt uunnværlig i naturvitenskapen. Meteorologer bruker programmer til å forutsi været. Biologer analyserer DNA-sekvenser med kode. Fysikere simulerer kollisjoner mellom partikler. Klimaforskere kjører modeller som viser hvordan temperaturen vil endre seg de neste hundre årene. I alle disse tilfellene gjør datamaskinen noe den er suveren til: den utfører millioner av beregninger raskere enn noe menneske kunne klart.

Men programmering handler ikke bare om hastighet. Det handler også om å visualisere data -- å gjøre tall om til grafer og diagrammer som hjelper oss å se mønstre vi ellers ville oversett. Det handler om å simulere scenarier vi ikke kan teste i virkeligheten -- du kan ikke sende en rakett til Mars for å teste hver eneste baneberegning, men du kan simulere den på en datamaskin tusenvis av ganger. Og det handler om å bygge modeller -- forenklede versjoner av virkeligheten som hjelper oss å forstå komplekse fenomener.

I dette kapittelet skal du lære grunnleggende programmering i Python og bruke det til å modellere naturfaglige fenomener. Du trenger ingen forkunnskaper -- vi starter fra begynnelsen.

Variabler og beregninger -- byggesteinene i all programmering

Tenk deg at du har en kalkulator der du kan gi navn til tallene dine. I stedet for å huske at «5.0» er massen og «10» er tiden, kan du skrive masse = 5.0 og tid = 10. Det er akkurat dette en variabel er: en navngitt boks som lagrer en verdi.

I Python, som er programmeringsspråket vi bruker i naturfag, finnes det ulike typer verdier. Desimaltall (kalt float) ser ut som masse = 5.0. Heltall (kalt int) ser ut som antall = 10. Tekst (kalt string) skrives med anførselstegn, som navn = "Natrium". Og sann/usann (kalt boolean) skrives som er_metall = True eller er_metall = False.

Når du har lagret verdier i variabler, kan du gjøre beregninger med dem akkurat som på en kalkulator. Skriv avstand = 100 og tid = 10, og så kan du beregne fart med fart = avstand / tid. Python støtter alle de vanlige matematiske operatorene: pluss (+), minus (-), gange (*), dele (/), og potens (**). Vil du beregne 5 opphøyd i andre, skriver du 5 ** 2, som gir 25.

For å vise resultatet bruker du print-funksjonen. Skriver du print(f"Farten er {fart} m/s"), vil programmet vise «Farten er 10.0 m/s» på skjermen. Bokstaven f foran anførselstegnet betyr at du kan sette inn variabler direkte i teksten med krøllparenteser.

Python har også innebygde matematiske funksjoner. Ved å skrive import math får du tilgang til blant annet math.sqrt(16) for kvadratrot (gir 4.0), math.pi for pi (3.14159...), abs(-5) for absoluttverdi (gir 5), og round(3.7) for avrunding (gir 4).

La oss se på et konkret naturfaglig eksempel. Energien til en foton beregnes med formelen E = h · c / lambda, der h er Plancks konstant (6.626 x 10^-34 J·s), c er lyshastigheten (3 x 10^8 m/s), og lambda er bølgelengden. I Python skriver du dette som h = 6.626e-34, c = 3e8, bolgelengde = 550e-9 (for grønt lys med bølgelengde 550 nanometer), og energi = h * c / bolgelengde. Resultatet er ca. 3.614 x 10^-19 Joule, eller omtrent 2.26 elektronvolt.

Løkker -- når du trenger å gjenta noe tusen ganger

Forestill deg at du skal beregne posisjonen til en ball som faller fritt hvert tidsskritt i 100 sekunder. Du kunne skrive 100 separate beregninger -- men det ville vært vanvittig kjedelig og feilformbart. I stedet bruker du en løkke, som ber datamaskinen gjenta en handling så mange ganger du vil.

Den vanligste typen er for-løkken, som du bruker når du vet nøyaktig hvor mange ganger noe skal gjentas. I Python skriver du for i in range(1, 6): etterfulgt av den innrykkede koden du vil gjenta. Denne løkken kjører fem ganger, med i lik 1, 2, 3, 4 og 5 etter tur. Funksjonen range() genererer tallrekker: range(5) gir tallene 0 til 4, range(1, 6) gir 1 til 5, og range(0, 10, 2) gir 0, 2, 4, 6, 8 (altså med steg på 2).

Den andre typen er while-løkken, som fortsetter å kjøre så lenge en betingelse er sann. Tenk deg at du halverer en mengde radioaktivt stoff og vil finne ut hvor mange halveringer som trengs før mengden er under en viss grense. Du skriver while mengde >= 1: og lar løkken halvere mengden og telle antallet halveringer. Du vet ikke på forhånd hvor mange ganger løkken trenger å kjøre -- det avhenger av startmengden.

Løkker blir virkelig kraftige når du kombinerer dem med lister. En liste er en samling av verdier, skrevet med hakeparenteser: temperaturer = [18, 20, 22, 19, 21]. Du kan hente et enkelt element med temperaturer[0] (det første elementet, 18), finne antall elementer med len(temperaturer), og legge til nye elementer med temperaturer.append(23).

For eksempel, hvis du har en liste med temperaturmålinger og vil beregne gjennomsnittet, skriver du en for-løkke som legger sammen alle verdiene, og deler summen på antallet. Eller du kan bruke Pythons innebygde sum()-funksjon: gjennomsnitt = sum(temperaturer) / len(temperaturer). For listen [18.5, 19.2, 20.1, 18.8, 19.5] gir dette 19.22 grader Celsius.

Betingelser -- når programmet ditt må ta valg

I virkeligheten handler mange ting om valg. Hvis temperaturen er over 30 grader, tar du på deg shorts. Hvis det regner, tar du med paraply. Programmering fungerer på samme måte: if-setninger lar programmet ta beslutninger basert på betingelser.

I Python skriver du if temperatur > 30: etterfulgt av hva som skal skje i det tilfellet. Du kan legge til flere alternativer med elif (forkortelse for «else if») og et siste alternativ med else som fanger opp alt annet. For eksempel: Hvis temperaturen er over 30, skriv «Varmt!». Eller hvis den er over 20, skriv «Behagelig». Eller hvis den er over 10, skriv «Kjølig». Ellers skriv «Kaldt!».

For å sammenligne verdier bruker du sammenligningsoperatorer: == (er lik), != (er ikke lik), > (større enn), < (mindre enn), >= (større enn eller lik), og <= (mindre enn eller lik). Merk at er lik skrives med dobbelt likhetstegn (==), ikke enkelt -- fordi enkelt likhetstegn brukes til å tildele verdier til variabler.

Du kan også kombinere flere betingelser med and (begge må være sanne), or (minst én må være sann), og not (snur sann til usann). For eksempel: if alder >= 15 and har_billett: sjekker om personen både er gammel nok og har billett.

Betingelser er spesielt nyttige i naturfaglig modellering. Tenk deg at du simulerer en populasjon: hvis populasjonen faller under en viss grense, er arten truet. Eller du simulerer en kjemisk reaksjon: hvis temperaturen er over et terskelpunkt, starter reaksjonen. Betingelser gjør modellene dine mer realistiske ved å la dem reagere på endringer -- akkurat som naturen gjør.

Visualisering -- når tall blir til bilder

En tabell med hundre tall er vanskelig å forstå. Men en graf som viser de samme tallene? Den forteller deg umiddelbart om det er en trend, et mønster eller en avvikelse. Visualisering handler om å gjøre data synlig, og i Python bruker vi biblioteket matplotlib til dette.

Å lage en enkel graf er overraskende lett. Du importerer biblioteket med import matplotlib.pyplot as plt, lager to lister med x- og y-verdier, og bruker plt.plot(x, y) for å tegne grafen. Med plt.xlabel(), plt.ylabel() og plt.title() legger du til forklarende tekst, og plt.show() viser resultatet.

Du kan tilpasse utseendet med formatstrenger. For eksempel betyr 'b-' blå linje, 'r--' rød stiplet linje, 'go' grønne sirkler, og 'k^' svarte trekanter. Vil du ha blå linje med sirkler på datapunktene, skriver du 'b-o'. Du kan også lage punktdiagrammer med plt.scatter(), stolpediagrammer med plt.bar(), legge til rutenett med plt.grid(True), og vise en forklaring med plt.legend().

Visualisering er ikke bare pynt -- det er et vitenskapelig verktøy. Når du plotter temperaturdata over et år, kan du umiddelbart se sesongvariasjoner. Når du plotter radioaktiv nedbrytning, ser du den karakteristiske eksponentielle kurven. Og når du sammenligner to datasett i samme graf -- for eksempel rovdyr- og byttedyrpopulasjoner -- kan du se sammenhenger som tallene alene ikke ville avslørt.

Modellering -- forenkle virkeligheten for å forstå den

Nå er vi fremme ved det mest spennende: å bruke alt vi har lært til å modellere naturfaglige fenomener. En modell er en forenklet representasjon av virkeligheten. Den fanger opp de viktigste mekanismene og ignorerer detaljer som ikke er avgjørende. Ingen modell er perfekt, men en god modell gir oss innsikt.

La oss starte med radioaktiv nedbrytning. Når et radioaktivt stoff brytes ned, halveres mengden for hvert tidsintervall som kalles halveringstiden. Formelen er N = N0 · 0.5^(t/halveringstid), der N er mengden som gjenstår, N0 er startmengden og t er tiden. I Python kan du simulere dette med en for-løkke som beregner mengden for hvert tidssteg og lagrer verdiene i en liste. Starter du med 1000 atomer og en halveringstid på 10 år, vil du ha 500 atomer etter 10 år, 250 etter 20 år, 125 etter 30 år, og bare 31.2 etter 50 år -- litt over 3 prosent av det du begynte med. Plotter du resultatene, ser du en jevn, fallende kurve som aldri helt når null.

Vil du finne ut hvor lang tid det tar før bare 1 prosent av stoffet er igjen, kan du bruke en while-løkke som halverer mengden gjentatte ganger og teller tiden. Svaret er ca. 66-67 år, som tilsvarer rundt 6.6 halveringstider. Du kan bekrefte dette matematisk: 0.01 = 0.5^n gir n = log(0.01)/log(0.5) = 6.64 halveringstider, altså 66.4 år.

Et annet klassisk eksempel er eksponentiell befolkningsvekst. Hvis en populasjon vokser med 2 prosent per år, betyr det at neste års populasjon er 1.02 ganger årets. En for-løkke som gjentar dette i 50 år viser at 1000 individer blir til 2692 -- nesten en tredobling. Plotter du dette, ser du en kurve som stiger stadig brattere, som er kjennetegnet på eksponentiell vekst.

For mer avanserte modeller kan du simulere et rovdyr-byttedyr-system (Lotka-Volterra-modellen). Her påvirker to populasjoner hverandre: kaniner reproduserer seg, men blir spist av rever. Rever dør ut uten mat, men formerer seg når det er mange kaniner. Resultatet er fascinerende sykliske svingninger der populasjonene stiger og faller i utakt -- nøyaktig slik vi observerer i naturen.

Kritisk vurdering -- en modell er bare så god som antakelsene

Det er fristende å stole blindt på det datamaskinen forteller oss. Datamaskiner er jo så presise! Men husk: en datamaskin gjør bare det den får beskjed om. Hvis modellen din bygger på feil antakelser, vil resultatene også være feil -- uansett hvor mange desimaler datamaskinen viser.

La oss ta et eksempel. Tenk deg en enkel modell som forutsier karakterer basert på studietimer: karakter = studietimer x 0.5 + 1. For 10 timers studier gir denne modellen karakter 6. Men hva med 20 timers studier? Da får du karakter 11, som er umulig i det norske karaktersystemet! Modellen har ingen øvre grense.

Dessuten antar modellen en lineær sammenheng -- at dobbelt så mye studering gir dobbelt så mye bedre karakter. I virkeligheten er sammenhengen langt mer kompleks. Kvaliteten på studiene er minst like viktig som mengden. Forkunnskaper spiller inn. Vanskelighetsgraden varierer mellom fag. Dagsform på eksamen kan utgjøre hele forskjellen. Og to personer som studerer like mange timer, kan få helt ulike karakterer.

Denne typen kritisk vurdering er essensiell i all naturvitenskapelig modellering. Når du lager eller bruker en modell, bør du alltid spørre: Hvilke antakelser bygger modellen på? Er antakelsene rimelige? Hva ignorerer modellen? I hvilke situasjoner vil modellen gi meningsløse resultater?

Husk at alle modeller er forenklinger. Eksponentiell vekst-modellen vår antar at en populasjon kan vokse uendelig -- i virkeligheten begrenses veksten av tilgjengelig mat, plass og andre faktorer. Radioaktiv nedbrytning-modellen vår er faktisk ganske nøyaktig fordi den bygger på veletablerte fysiske lover. Rovdyr-byttedyr-modellen fanger opp det grunnleggende mønsteret, men ignorerer faktorer som sykdom, sesongvariasjoner og konkurranse fra andre arter. En god naturviter vet at modellen er et verktøy for å forstå, ikke en erstatning for virkeligheten.

Oppsummering

I dette kapittelet har vi sett hvordan programmering har blitt et uunnværlig verktøy i naturvitenskapen -- fra pandemisimuleringer til klimamodeller og DNA-analyser.

Grunnleggende Python bygger på variabler (navngitte bokser som lagrer verdier), matematiske operatorer (+, -, , /, for potens), og print-funksjonen for å vise resultater. Variabler kan inneholde desimaltall (float), heltall (int), tekst (string) og sann/usann-verdier (boolean). Funksjoner fra math-biblioteket gir tilgang til kvadratrot, pi, absoluttverdi og avrunding.

Løkker lar deg gjenta kode: for-løkker brukes når du vet antall repetisjoner, while-løkker brukes når du vil fortsette så lenge en betingelse er sann. Lister samler mange verdier i en variabel, og range()-funksjonen genererer tallrekker.

Betingelser med if/elif/else lar programmet ta valg. Sammenligningsoperatorer (==, !=, >, <, >=, <=) og logiske operatorer (and, or, not) bestemmer hvilken kodeblokk som kjøres.

Visualisering med matplotlib gjør data til grafer og diagrammer som avslører mønstre. Linjediagram med plt.plot(), punktdiagram med plt.scatter(), og tekst med plt.xlabel(), plt.ylabel() og plt.title() er de viktigste verktøyene.

Modellering bruker alt dette sammen til å simulere naturfaglige fenomener. Radioaktiv nedbrytning følger formelen N = N0 · 0.5^(t/halveringstid), eksponentiell vekst følger N = N0 · (1+r)^t, og rovdyr-byttedyr-systemer viser sykliske svingninger.

Kritisk vurdering* er avgjørende: alle modeller er forenklinger. Du bør alltid spørre hvilke antakelser modellen bygger på, hva den ignorerer, og i hvilke situasjoner den gir meningsløse resultater. Programmering automatiserer beregninger, men det er du som naturviter som må vurdere om resultatene gir mening.