SkapLab – Programmering i naturfag

🤔 Hvorfor programmering i naturfag?

Programmering lar oss utforske naturfaglige systemer som er for komplekse, farlige eller tidkrevende å eksperimentere med direkte. En simulator er en matematisk modell – akkurat som en atommodell eller en næringsnett-illustrasjon, men interaktiv.

LK20 KM7 sier eksplisitt: «bruke programmering til å utforske naturfaglige fenomener». Det betyr ikke at du skal bli programmerer – men at du skal forstå hva kode gjør og kunne justere enkle simuleringer.

🧩 Grunnbegreper du trenger

Variabel: Lagrer en verdi (som en boks med innhold). temperatur = 25

Løkke (loop): Gjentar kode mange ganger. for tid in range(100):

if-setning: Tar beslutninger. if atom.henfall():

Funksjon: Gjenbrukbar kodeblokk. def beregn_kraft(m, a):

I naturfag bruker vi disse til å simulere tid, sannsynlighet, krefter og vekst.

🔗 Ressurser for å lære Python til naturfag

🐍 Python.orgOffisiell Python-dokumentasjon. Gratis. Start med «Getting Started».

📓 Jupyter NotebooksInteraktive kodebok der kode og forklaring blandes. Brukes i forskning. Prøv på jupyter.org/try

🎮 Scratch – MITVisuell programmering. Bra for å forstå løkker og logikk. Scratch.mit.edu

📊 PhET SimulationsInteraktive naturfagssimulatorer fra U Colorado. phet.colorado.edu

🔢 NumPy + MatplotlibPython-biblioteker for vitenskapelig beregning og grafer. Standard i forskning.

🌐 code.orgInteraktive kurs for nybegynnere. Norsk grensesnitt tilgjengelig.

Radioaktivt henfall er et stokastisk (tilfeldig) fenomen – hvert atom har en fast sannsynlighet for å henfalle per tidsenhet. Kode lar oss simulere dette med tusenvis av atomer.

☢️ radioaktivt_henfall.js – simuler N atomer over T sekunder

Klikk «Kjør simulering» for å se resultatet

🔑 Hva koden gjør: Linje 8: Beregner sannsynligheten for at ett atom henfaller per sekund fra halvveringstiden. Linje 13–17: For hvert tidssteg, gå gjennom alle N atomer og la et tilfeldig tall avgjøre om det henfaller (stokastikk). Resultatet er eksponentiell henfallskurve med naturlig statistisk støy. 🧪 Prøv selv: Endre halvveringstid til 10 eller 50 og kjør på nytt. Endre N_start til 100 – legg merke til mer statistisk støy!

Newtons bevegelseslover kan simuleres numerisk: beregn akselerasjon fra krefter, oppdater hastighet, oppdater posisjon. Denne metoden (Euler-integrasjon) brukes i videospill og romsonder.

🍎 newton_fall.js – fritt fall med og uten luftmotstand

// Fritt fall – Newtons 2. lov: F = ma → a = F/m
// Sammenligner fall med og uten luftmotstand

const g = 9.81;          // Tyngdeakselerasjon (m/s²)
const masse = 1.0;        // Kg
const k_luft = 0.5;       // Luftmotstandskoeffisient (kg/s)
const dt = 0.1;           // Tidssteg (sekunder)
const T_maks = 10;        // Simuleringstid (sekunder)

// === UTEN LUFTMOTSTAND ===
let v1 = 0, y1 = 0;
const t_data = [0], y_data_uten = [0], y_data_med = [0];

// === MED LUFTMOTSTAND ===
let v2 = 0, y2 = 0;

for (let t = dt; t <= T_maks; t += dt) {
  // Uten luftmotstand: kun tyngdekraft
  const a1 = g;
  v1 += a1 * dt;
  y1 += v1 * dt;
  
  // Med luftmotstand: F_netto = mg - k*v
  const F_netto = masse * g - k_luft * v2;
  const a2 = F_netto / masse;
  v2 += a2 * dt;
  y2 += v2 * dt;
  
  t_data.push(parseFloat(t.toFixed(1)));
  y_data_uten.push(parseFloat(y1.toFixed(2)));
  y_data_med.push(parseFloat(y2.toFixed(2)));
}

const terminalv = (masse * g / k_luft).toFixed(1);
output("Terminalhastig het (teoretisk): " + terminalv + " m/s");
output("Etter " + T_maks + " s uten luft: " + y1.toFixed(1) + " m, v=" + v1.toFixed(1) + " m/s");
output("Etter " + T_maks + " s med luft: " + y2.toFixed(1) + " m, v=" + v2.toFixed(1) + " m/s");
tegnNewton(t_data, y_data_uten, y_data_med);

Klikk «Kjør simulering»

🔑 Hva koden gjør: Euler-integrasjon: beregner akselerasjon fra kreftene (linje 23, 28), legger akselerasjon til hastighet (×dt), legger hastighet til posisjon (×dt). Dette er akkurat det GPS-satellitter og romplaner bruker. Liten dt = mer nøyaktig simulering. 🧪 Prøv selv: Endre k_luft til 0 for å fjerne luftmotstand. Endre masse – se at terminalhastig het endrer seg men fallkurven er den samme uten luftmotstand (Galileo!).

Lotka-Volterra-ligningene beskriver rovdyr–byttedyr-dynamikk. To differensialligninger simulerer samspillet mellom for eksempel ulv og elg – og gir de karakteristiske svingningene.

🐺 lotka_volterra.js – rovdyr/byttedyr-dynamikk

// Lotka-Volterra: Rovdyr–byttedyr
// x = byttedyr (elg), y = rovdyr (ulv)
// dx/dt = alpha*x - beta*x*y  (elg vokser, spises av ulv)
// dy/dt = delta*x*y - gamma*y (ulv vokser ved å spise, dør naturlig)

const alpha = 0.8;   // Elgens veksthastighet (uten ulv)
const beta  = 0.05;  // Sannsynlighet for at ulv møter og spiser elg
const delta = 0.025; // Ulvens vekst per elg spist
const gamma = 0.5;   // Ulvens naturlige dødshastighet

let x = 40;   // Start: 40 elg
let y = 9;    // Start: 9 ulv
const dt = 0.05;
const T = 60;

const t_arr = [0], x_arr = [x], y_arr = [y];

for (let t = dt; t <= T; t += dt) {
  const dx = (alpha * x - beta * x * y) * dt;
  const dy = (delta * x * y - gamma * y) * dt;
  x = Math.max(0, x + dx);
  y = Math.max(0, y + dy);
  if (t % 1 < dt) {  // Lagre én gang per år
    t_arr.push(Math.round(t));
    x_arr.push(Math.round(x));
    y_arr.push(Math.round(y));
  }
}

output("Maks elg: " + Math.max(...x_arr) + " | Min elg: " + Math.min(...x_arr));
output("Maks ulv: " + Math.max(...y_arr) + " | Min ulv: " + Math.min(...y_arr));
tegnPop(t_arr, x_arr, y_arr);

Klikk «Kjør simulering»

🔑 Hva koden gjør: dx (endring i elgbestand) = vekst (alpha×x) minus predasjon (beta×x×y). Mange elg + mange ulv = stor predasjon. Dyner av populasjonene gir de karakteristiske svingende kurvene. Ulvens topp kommer etter elgens topp – det tar tid å formere seg. 🧪 Prøv selv: Endre y = 0 (ingen ulv) – hva skjer med elgen? Endre alpha = 1.5 – raskere elgvekst. Hva skjer med svingningene?

Programmering brukes til å analysere måledata fra forsøk: beregne gjennomsnitt, standardavvik, plotte grafer og finne lineære sammenhenger. Skriv inn dine egne tall!

📊 dataanalyse.js – statistikk og regresjon på egne måledata

// Analyser egne måledata – endre tallene nedenfor!
// Eksempel: Temperatur (°C) og løselighet av NaCl (g/100ml)

const x_data = [20, 40, 60, 80, 100];   // Uavhengig variabel (temperatur)
const y_data = [35.7, 36.6, 37.3, 38.4, 39.2];  // Avhengig variabel (løselighet)
const x_enhet = "Temperatur (°C)";
const y_enhet = "Løselighet (g/100ml)";

// === STATISTIKK ===
const n = x_data.length;
const x_snitt = x_data.reduce((a,b) => a+b,0) / n;
const y_snitt = y_data.reduce((a,b) => a+b,0) / n;

const x_std = Math.sqrt(x_data.map(x => (x-x_snitt)**2).reduce((a,b)=>a+b,0) / (n-1));
const y_std = Math.sqrt(y_data.map(y => (y-y_snitt)**2).reduce((a,b)=>a+b,0) / (n-1));

// === LINEÆR REGRESJON ===
const teller = x_data.map((x,i) => (x-x_snitt)*(y_data[i]-y_snitt)).reduce((a,b)=>a+b,0);
const nevner = x_data.map(x => (x-x_snitt)**2).reduce((a,b)=>a+b,0);
const stigning = teller / nevner;
const konstantledd = y_snitt - stigning * x_snitt;

// Korrelasjonskoeffisient (r)
const r = teller / (Math.sqrt(nevner) * Math.sqrt(y_data.map(y=>(y-y_snitt)**2).reduce((a,b)=>a+b,0)));

output("Gjennomsnitt x: " + x_snitt.toFixed(2) + " | Gjennomsnitt y: " + y_snitt.toFixed(2));
output("Standardavvik x: " + x_std.toFixed(2) + " | Standardavvik y: " + y_std.toFixed(2));
output("Regresjonslinje: y = " + stigning.toFixed(4) + "x + " + konstantledd.toFixed(2));
output("Korrelasjonskoeffisient r = " + r.toFixed(4) + " (1.0 = perfekt lineær sammenheng)");
tegnData(x_data, y_data, stigning, konstantledd, x_enhet, y_enhet);

Klikk «Analyser data»

🔑 Hva koden gjør: Beregner gjennomsnitt, standardavvik og lineær regresjon på dine data. Regresjonslinja gir beste rette linje gjennom punktene. r nær ±1 = sterk lineær sammenheng. r nær 0 = svak/ingen lineær sammenheng (men kan ha kurvelineær sammenheng!). 🧪 Prøv selv: Bytt ut tallene i x_data og y_data med data fra ditt eget forsøk. Endre enhetene. Analyser sammenhengen mellom pH og enzymaktivitet, kraft og akselerasjon, eller CO₂-konsentrasjon og temperatur.

Programmeringi naturfag

🤔 Hvorfor programmering i naturfag?

🧩 Grunnbegreper du trenger

Programmering
i naturfag