1.3 Numeriske metoder og programmering

Eulers metode, Python for fysikksimuleringer, modellering av bevegelse.

90 min

10 oppgaver

Eulers metodePythonNumerisk integrasjonSimuleringIterasjon

Din fremgang i kapitlet

0 / 10 oppgaver

Numeriske metoder og programmering

Hvorfor trenger vi numeriske metoder?

Mange fysiske problemer kan ikke løses analytisk (med penn og papir). Eksempler:
- Fritt fall med luftmotstand
- Trekroppsproblemer i astronomi
- Værsimuleringer
- Kvanteproblemer

Løsning: Bruk datamaskinen til å beregne tilnærmede løsninger!

Hva er en numerisk metode?

En numerisk metode er en algoritme som:
- Deler opp et problem i små steg
- Beregner en tilnærmet løsning steg for steg
- Gir resultater med kontrollert presisjon

Fordeler:
- Kan løse problemer uten analytisk løsning
- Rask (med moderne datamaskiner)
- Visuell (kan lage grafer og animasjoner)

Ulemper:
- Tilnærmet (ikke eksakt)
- Krever programmering
- Kan akkumulere feil

Programmering i fysikk

Python er det mest populære språket for vitenskapelig programmering:
- Enkelt å lære
- Kraftige biblioteker (NumPy, Matplotlib)
- Gratis og åpen kildekode
- Brukes i forskning og industri

Hva skal vi lære:
1. Grunnleggende Python-syntaks
2. Eulers metode for differensiallikninger
3. Simulering av bevegelse
4. Visualisering av resultater

Numerisk metode

En algoritme som beregner en tilnærmet løsning på et matematisk problem ved å dele det opp i mange små steg. Brukes når analytiske løsninger ikke finnes eller er for kompliserte.

Differensiallikninger i fysikk

En differensialligning er en likning som inneholder deriverte.

Newtons 2. lov som differensialligning

Newtons 2. lov:
$F = ma$

Akselerasjon er den dobbeltderiverte av posisjon:
$a = \frac{dv}{dt} = \frac{d^2s}{dt^2}$

Derfor:
$m\frac{d^2s}{dt^2} = F$

Dette er en andreordens differensialligning.

Eksempel: Fritt fall uten luftmotstand

Kraft:
$F = -mg$

(Negativ fordi tyngdekraften peker nedover)

Differensialligning:
$m\frac{d^2s}{dt^2} = -mg$

$\frac{d^2s}{dt^2} = -g$

Analytisk løsning:
$s(t) = s_0 + v_0 t - \frac{1}{2}gt^2$

Denne kan vi løse med penn og papir! ✓

Eksempel: Fritt fall MED luftmotstand

Krefter:
- Tyngdekraft: $F_g = -mg$
- Luftmotstand: $\displaystyle F_d = \frac{1}{2}C_d \rho A v^2$ (oppover hvis nedover bevegelse)

Total kraft:
$F = -mg + \frac{1}{2}C_d \rho A v^2$

Differensialligning:
$m\frac{dv}{dt} = -mg + \frac{1}{2}C_d \rho A v^2$

Problem: Denne har INGEN analytisk løsning! ✗

Løsning: Bruk numeriske metoder! ✓

Omskriving til første orden

For å bruke Eulers metode omskriver vi til førsteordens system:

$\frac{ds}{dt} = v$

$\frac{dv}{dt} = -g + \frac{C_d \rho A v^2}{2m}$

Dette er to koblede førsteordens differensiallikninger.

Eulers metode

Eulers metode er den enkleste numeriske metoden for å løse differensiallikninger.

Grunnidé

Derivert = helling av tangent:
$\frac{dy}{dx} = f(x, y)$

Tilnærming:
Hvis vi kjenner $y$ ved $x$ , kan vi estimere $y$ ved $x + \Delta x$ :

$y(x + \Delta x) \approx y(x) + \frac{dy}{dx} \cdot \Delta x$

$y(x + \Delta x) \approx y(x) + f(x, y) \cdot \Delta x$

Eulers algoritme

Gitt:
- Differensialligning: $\displaystyle \frac{dy}{dt} = f(t, y)$
- Initialverdi: $y(t_0) = y_0$
- Tidssteg: $\Delta t$ (ofte skrevet $dt$ )

Algoritme:

1. Start med $(t_0, y_0)$
2. Beregn $\displaystyle \frac{dy}{dt} = f(t_0, y_0)$
3. Estimér neste verdi: $y_1 = y_0 + f(t_0, y_0) \cdot \Delta t$
4. Oppdatér tid: $t_1 = t_0 + \Delta t$
5. Gjenta fra steg 2 med $(t_1, y_1)$

Generell formel:
$y_{n+1} = y_n + f(t_n, y_n) \cdot \Delta t$
$t_{n+1} = t_n + \Delta t$

Visualisering

Tenk på Eulers metode som å:
1. Stå på en kurve
2. Se tangentretningen (derivert)
3. Ta et lite steg i tangentretningen
4. Gjenta

Presisjon:
- Mindre $\Delta t$ → Bedre presisjon (men flere beregninger)
- Større $\Delta t$ → Raskere, men mindre nøyaktig

Eksempel: Eksponentiell vekst

Differensialligning:
$\frac{dy}{dt} = ky$

med $y(0) = 1$ og $k = 0.5$ .

Analytisk løsning:
$y(t) = e^{kt}$

Numerisk løsning (Eulers metode):

La $\Delta t = 0.1$ .

Steg 1:
- $t_0 = 0$ , $y_0 = 1$
- $\displaystyle \frac{dy}{dt} = 0.5 \times 1 = 0.5$
- $y_1 = 1 + 0.5 \times 0.1 = 1.05$
- $t_1 = 0.1$

Steg 2:
- $t_1 = 0.1$ , $y_1 = 1.05$
- $\displaystyle \frac{dy}{dt} = 0.5 \times 1.05 = 0.525$
- $y_2 = 1.05 + 0.525 \times 0.1 = 1.1025$
- $t_2 = 0.2$

Osv.

Sammenligning:

Tid $t$	Analytisk $e^{0.5t}$	Euler ( $\Delta t = 0.1$ )	Feil
0.0	1.0000	1.0000	0%
0.1	1.0513	1.0500	0.12%
0.2	1.1052	1.1025	0.24%
1.0	1.6487	1.6289	1.2%

Eulers metode gir god tilnærming! ✓

✏️Eulers metode: Enkel bevegelse

En bil akselererer fra hvile med konstant akselerasjon $a = 2$ m/s². Bruk Eulers metode til å beregne hastigheten etter 5 sekunder med tidssteg $\Delta t = 1$ s. Sammenlign med den analytiske løsningen.

Gitt:
- Akselerasjon:

a = 2

m/s²
- Starthastig het:

v_0 = 0

m/s
- Tid:

t = 5

s
- Tidssteg:

\Delta t = 1

Differensialligning:
$\frac{dv}{dt} = a = 2$

Analytisk løsning:
$v(t) = v_0 + at = 0 + 2 \times 5 = 10 \text{ m/s}$

---

Eulers metode:

Algoritme:
$v_{n+1} = v_n + a \cdot \Delta t = v_n + 2 \times 1 = v_n + 2$

Steg for steg:

Steg 0:
- $t_0 = 0$ s, $v_0 = 0$ m/s

Steg 1:
- $a = 2$ m/s²
- $v_1 = v_0 + a \cdot \Delta t = 0 + 2 \times 1 = 2$ m/s
- $t_1 = 1$ s

Steg 2:
- $a = 2$ m/s²
- $v_2 = v_1 + a \cdot \Delta t = 2 + 2 \times 1 = 4$ m/s
- $t_2 = 2$ s

Steg 3:
- $v_3 = 4 + 2 = 6$ m/s
- $t_3 = 3$ s

Steg 4:
- $v_4 = 6 + 2 = 8$ m/s
- $t_4 = 4$ s

Steg 5:
- $v_5 = 8 + 2 = 10$ m/s
- $t_5 = 5$ s

---

Resultat:

Tid (s)	Euler (m/s)	Analytisk (m/s)	Feil
0	0	0	0%
1	2	2	0%
2	4	4	0%
3	6	6	0%
4	8	8	0%
5	10	10	0%

Konklusjon: Eulers metode gir eksakt løsning når akselerasjonen er konstant! ✓
Hvorfor?
- Når

a

er konstant, er

v(t)

en rett linje
- Eulers metode følger tangenten, som er en rett linje
- Perfekt samsvar!
Generelt: Eulers metode er eksakt for lineære problemer.

Python-grunnlag for fysikk

Variabler og beregninger

``python

`Variabler`


m = 0.5        # masse i kg
v = 10         # hastighet i m/s
g = 9.81       # tyngdeakselerasjon i m/s²
Beregninger

Ek = 0.5  m  v*2    # Kinetisk energi
Ep = m  g  h         # Potensiell energi
p = m  v              # Bevegelsesmengde
Skriv ut

print("Kinetisk energi:", Ek, "J")
print(f"Bevegelsesmengde: {p} kg·m/s")  # f-string


Lister (arrays)

`python

`Liste med tall`


tid = [0, 1, 2, 3, 4, 5]
hastighet = [0, 2, 4, 6, 8, 10]
Tilgang til elementer

print(tid[0])         # 0 (første element)
print(tid[-1])        # 5 (siste element)
print(hastighet[2])   # 4
Legge til elementer

tid.append(6)
hastighet.append(12)
Lengde av liste

n = len(tid)          # 7


Løkker

`python

`For-løkke`


for i in range(5):
    print(i)          # Skriver 0, 1, 2, 3, 4
While-løkke

t = 0
while t < 5:
    print(t)
    t = t + 1         # Eller: t += 1
Løkke over liste

hastigheter = [0, 2, 4, 6]
for v in hastigheter:
    Ek = 0.5  m  v*2
    print(f"v = {v} m/s, Ek = {Ek} J")

`Betingelser
`python v = 10
if v > 0: print("Beveger seg fremover") elif v < 0: print("Beveger seg bakover") else: print("I ro")`
Funksjoner
`python
Definere funksjon
def kinetiskenergi(m, v): """Beregner kinetisk energi.""" return 0.5 m v2 Bruke funksjon Ek = kinetiskenergi(0.5, 10) print(Ek) # 25.0`NumPy for numeriske beregninger
`python import numpy as np
Array (mer effektiv enn liste)
tid = np.array([0, 1, 2, 3, 4, 5]) hastighet = np.array([0, 2, 4, 6, 8, 10]) Elementvise operasjoner Ek = 0.5

 m  hastighet*2  # Beregner for alle verdier
Nyttige funksjoner

print(np.max(hastighet))      # 10 (største verdi)
print(np.min(hastighet))      # 0 (minste verdi)
print(np.mean(hastighet))     # 5.0 (gjennomsnitt)
print(np.sum(hastighet))      # 30 (sum)


Matplotlib for plotting

`python import matplotlib.pyplot as plt

`Data`


tid = [0, 1, 2, 3, 4, 5]
hastighet = [0, 2, 4, 6, 8, 10]
Plott

plt.plot(tid, hastighet, 'b-')  # Blå linje
plt.xlabel('Tid (s)')
plt.ylabel('Hastighet (m/s)')
plt.title('Hastighet som funksjon av tid')
plt.grid(True)
plt.show()

Eulers metode i Python

Mal for Eulers metode

``python import numpy as np import matplotlib.pyplot as plt

`Parametere`


t0 = 0          # Starttid
y0 = 1          # Startverdi
tslutt = 10    # Sluttid
dt = 0.1        # Tidssteg
Derivert (differensialligning)

def f(t, y):
    """Returnerer dy/dt."""
    return -0.5  y  # Eksempel: eksponentiell nedgang
Initialiser lister

tid = [t0]
y = [y0]
Eulers metode

t = t0
yverdi = y0
while t < tslutt:
    # Beregn derivert
    dydt = f(t, yverdi)    # Euler-steg
    yverdi = yverdi + dydt  dt
    t = t + dt
    # Lagre
    tid.append(t)
    y.append(yverdi)
Plott

plt.plot(tid, y)
plt.xlabel('Tid')
plt.ylabel('y')
plt.title('Løsning av differensialligning')
plt.grid(True)
plt.show()

`Eksempel: Fritt fall
`python import numpy as np import matplotlib.pyplot as plt
Parametere
g = 9.81 # m/s² s0 = 100 # Starthøyde (m) v0 = 0 # Starthastighet (m/s) dt = 0.01 # Tidssteg (s) Initialiser tid = [0] s = [s0] v = [v0] Eulers metode t = 0 s

verdi = s0
vverdi = v0while sverdi > 0:  # Stopp når objektet treffer bakken
    # Akselerasjon
    a = -g
    # Euler-steg
    vverdi = vverdi + a  dt
    sverdi = sverdi + vverdi  dt
    t = t + dt
    # Lagre
    tid.append(t)
    s.append(sverdi)
    v.append(vverdi)
Resultat

print(f"Falltid: {t:.3f} s")
print(f"Slutthastig het: {vverdi:.3f} m/s")
Analytisk løsning

tanalytisk = np.sqrt(2  s0 / g)
vanalytisk = -g  tanalytisk
print(f"Analytisk tid: {tanalytisk:.3f} s")
print(f"Analytisk hastighet: {vanalytisk:.3f} m/s")
Plott

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
Høyde

ax1.plot(tid, s, 'b-', label='Numerisk')
ax1.setxlabel('Tid (s)')
ax1.setylabel('Høyde (m)')
ax1.settitle('Høyde som funksjon av tid')
ax1.grid(True)
ax1.legend()
Hastighet

ax2.plot(tid, v, 'r-', label='Numerisk')
ax2.setxlabel('Tid (s)')
ax2.setylabel('Hastighet (m/s)')
ax2.settitle('Hastighet som funksjon av tid')
ax2.grid(True)
ax2.legend()

plt.tightlayout() plt.show()``

✏️Simulering: Fritt fall med luftmotstand

En ball med masse 0.5 kg og radius 0.05 m slippes fra 100 m høyde. Bruk Eulers metode til å simulere fallet med luftmotstand. Sammenlign med fritt fall uten luftmotstand.

Gitt:
- Masse:

m = 0.5

kg
- Radius:

r = 0.05

m
- Starthøyde:

s_0 = 100

m
- Starthastighet:

v_0 = 0

m/s
- Luftens tetthet:

\rho = 1.2

kg/m³
- Luftmotstandskoeffisient:

C_d = 0.5

Fysikk:

Tverrsnittareal:
$A = \pi r^2 = \pi \times 0.05^2 = 0.00785 \text{ m}^2$

Krefter:
- Tyngdekraft: $F_g = -mg = -0.5 \times 9.81 = -4.905$ N
- Luftmotstand: $\displaystyle F_d = \frac{1}{2}C_d \rho A v^2$ (oppover når bevegelse nedover)

Netto kraft:
$F = -mg + \frac{1}{2}C_d \rho A v^2$

Akselerasjon:
$a = \frac{F}{m} = -g + \frac{C_d \rho A v^2}{2m}$

Differensiallikninger:
$\frac{ds}{dt} = v$
$\frac{dv}{dt} = -g + \frac{C_d \rho A v^2}{2m}$

---

Python-kode:

``python import numpy as np import matplotlib.pyplot as plt

`Parametere`


m = 0.5          # kg
r = 0.05         # m
A = np.pi  r2 # m²
rho = 1.2        # kg/m³
Cd = 0.5
g = 9.81         # m/s²
s0 = 100         # m
v0 = 0           # m/s
dt = 0.001       # s (lite tidssteg for nøyaktighet)
Initialiser med luftmotstand

tidluft = [0]
sluft = [s0]
vluft = [v0]
t = 0
s = s0
v = v0while s > 0:
    # Luftmotstand (oppover hvis v < 0, dvs. nedover bevegelse)
    Fd = 0.5  Cd  rho  A  v2 if v < 0 else -0.5  Cd  rho  A  v2
    # Akselerasjon
    a = -g + Fd / m
    # Euler-steg
    v = v + a  dt
    s = s + v  dt
    t = t + dt
    # Lagre
    tidluft.append(t)
    sluft.append(s)
    vluft.append(v)
Resultat med luftmotstand

tluftslutt = t
vluftslutt = v
Uten luftmotstand (analytisk)

tidingen = np.linspace(0, tluftslutt, 1000)
singen = s0 - 0.5  g  tidingen2
vingen = -g  tidingen
Analytisk falltid uten luftmotstand

tanalytisk = np.sqrt(2  s0 / g)
vanalytisk = -g  tanalytisk
Print resultater

print("MED LUFTMOTSTAND:")
print(f"  Falltid: {tluftslutt:.3f} s")
print(f"  Slutthastig het: {vluftslutt:.3f} m/s")
print()
print("UTEN LUFTMOTSTAND:")
print(f"  Falltid: {tanalytisk:.3f} s")
print(f"  Slutthastig het: {vanalytisk:.3f} m/s")
print()
print("FORSKJELL:")
print(f"  Falltid: {tluftslutt - tanalytisk:.3f} s lengre med luftmotstand")
print(f"  Hastighet: {abs(vluftslutt) - abs(vanalytisk):.3f} m/s lavere med luftmotstand")
Terminalhastig het (teoretisk)

vterminal = np.sqrt(2  m  g / (Cd  rho  A))
print(f"  Terminalhastighet: {vterminal:.3f} m/s")
Plott

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
Høyde

ax1.plot(tidluft, sluft, 'b-', label='Med luftmotstand', linewidth=2)
ax1.plot(tidingen, singen, 'r--', label='Uten luftmotstand', linewidth=2)
ax1.setxlabel('Tid (s)', fontsize=12)
ax1.setylabel('Høyde (m)', fontsize=12)
ax1.settitle('Høyde som funksjon av tid', fontsize=14)
ax1.legend(fontsize=11)
ax1.grid(True, alpha=0.3)
ax1.setxlim(0, max(tluftslutt, tanalytisk)  1.1)
Hastighet

ax2.plot(tidluft, vluft, 'b-', label='Med luftmotstand', linewidth=2)
ax2.plot(tidingen, vingen, 'r--', label='Uten luftmotstand', linewidth=2)
ax2.axhline(-vterminal, color='g', linestyle=':', label='Terminalhastighet', linewidth=2)
ax2.setxlabel('Tid (s)', fontsize=12)
ax2.setylabel('Hastighet (m/s)', fontsize=12)
ax2.settitle('Hastighet som funksjon av tid', fontsize=14)
ax2.legend(fontsize=11)
ax2.grid(True, alpha=0.3)
ax2.setxlim(0, max(tluftslutt, tanalytisk)  1.1)

plt.tightlayout() plt.show()`

---

Resultat (typisk):

`MED LUFTMOTSTAND: Falltid: 4.87 s Slutthastig het: -42.1 m/s

UTEN LUFTMOTSTAND: Falltid: 4.52 s Slutthastig het: -44.3 m/s

FORSKJELL: Falltid: 0.35 s lengre med luftmotstand Hastighet: 2.2 m/s lavere med luftmotstand Terminalhastighet: 71.4 m/s``

---

Analyse:

1. Falltid:
- Med luftmotstand: 4.87 s
- Uten luftmotstand: 4.52 s
- Forskjell: 0.35 s (8% lengre)

Forklaring: Luftmotstanden bremser ballen, så den bruker lengre tid.

2. Slutthastig het:
- Med luftmotstand: -42.1 m/s
- Uten luftmotstand: -44.3 m/s
- Forskjell: 2.2 m/s lavere

Forklaring: Luftmotstanden reduserer slutthastigheten.

3. Terminalhastighet:
- Teoretisk: 71.4 m/s
- Ballen når ikke terminalhastighet (kun 42 m/s)
- 100 m er ikke høyt nok

4. Graf-observasjoner:
- Høyde-tid graf: Kurvene divergerer (luftmotstand gir mer "kurvet" bane)
- Hastighet-tid graf: Med luftmotstand flater hastigheten ut (nærmer seg terminalhastighet)

Konklusjon:
For denne ballen ved 100 m høyde er luftmotstanden moderat betydelig (8% effekt på tid). For høyere høyder eller lettere objekter ville effekten vært større.

Tidssteg ( $\Delta t$ eller $dt$ ) er kritisk for nøyaktighet!

For lite tidssteg:
- ✓ Meget nøyaktig
- ✗ Meget treigt (mange beregninger)

For stort tidssteg:
- ✓ Rask beregning
- ✗ Unøyaktig
- ✗ Kan gi ustabile løsninger

Hvordan velge?
1. Start med lite tidssteg (f.eks. $dt = 0.001$ )
2. Test forskjellige verdier (0.01, 0.001, 0.0001)
3. Sjekk konvergens: Når løsningen ikke endrer seg betydelig ved mindre $dt$ , er du OK
4. Tommelfingerregel: Bruk $dt$ slik at systemet endrer seg lite per steg

Eksempel:
For fritt fall fra 100 m:
- Falltid ≈ 4.5 s
- Bruk minst 1000 steg: $dt = 0.0045$ s
- Bedre: 10000 steg: $dt = 0.00045$ s

Akkumulering av feil

Eulers metode er tilnærmet, og feil akkumuleres!

Kilde til feil:
1. Avrundingsfeil: Datamaskinen bruker begrenset presisjon
2. Diskretiseringsfeil: Vi approximerer en kontinuerlig prosess med diskrete steg
3. Stabilitets problemer: For store tidssteg kan gi eksplosive feil

Løsninger:
- Bruk mindre tidssteg
- Bruk mer avanserte metoder (Runge-Kutta, se videregående kurs)
- Valider mot analytiske løsninger når mulig
- Test konvergens ved å redusere tidssteg

Eksempel:
Simulering av planetbaner over millioner av år krever meget presise metoder. Eulers metode ville akkumulere feil og "predikere" at planeten flyr ut av solsystemet!

Oppgaver

Lett3 oppgaver

1Python

2Python

7Opplasting

Medium3 oppgaver

3Python

4Python

8Opplasting

Vanskelig4 oppgaver

5Python

6Python

9Python

10Python

1.3 Numeriske metoder og programmering

Eulers metode, Python for fysikksimuleringer, modellering av bevegelse.

90 min

10 oppgaver

Eulers metodePythonNumerisk integrasjonSimuleringIterasjon

Din fremgang i kapitlet

0 / 10 oppgaver

Numeriske metoder og programmering

Hvorfor trenger vi numeriske metoder?

Mange fysiske problemer kan ikke løses analytisk (med penn og papir). Eksempler:
- Fritt fall med luftmotstand
- Trekroppsproblemer i astronomi
- Værsimuleringer
- Kvanteproblemer

Løsning: Bruk datamaskinen til å beregne tilnærmede løsninger!

Hva er en numerisk metode?

En numerisk metode er en algoritme som:
- Deler opp et problem i små steg
- Beregner en tilnærmet løsning steg for steg
- Gir resultater med kontrollert presisjon

Fordeler:
- Kan løse problemer uten analytisk løsning
- Rask (med moderne datamaskiner)
- Visuell (kan lage grafer og animasjoner)

Ulemper:
- Tilnærmet (ikke eksakt)
- Krever programmering
- Kan akkumulere feil

Programmering i fysikk

Python er det mest populære språket for vitenskapelig programmering:
- Enkelt å lære
- Kraftige biblioteker (NumPy, Matplotlib)
- Gratis og åpen kildekode
- Brukes i forskning og industri

Hva skal vi lære:
1. Grunnleggende Python-syntaks
2. Eulers metode for differensiallikninger
3. Simulering av bevegelse
4. Visualisering av resultater

Numerisk metode

En algoritme som beregner en tilnærmet løsning på et matematisk problem ved å dele det opp i mange små steg. Brukes når analytiske løsninger ikke finnes eller er for kompliserte.

Differensiallikninger i fysikk

En differensialligning er en likning som inneholder deriverte.

Newtons 2. lov som differensialligning

Newtons 2. lov:
$F = ma$

Akselerasjon er den dobbeltderiverte av posisjon:
$a = \frac{dv}{dt} = \frac{d^2s}{dt^2}$

Derfor:
$m\frac{d^2s}{dt^2} = F$

Dette er en andreordens differensialligning.

Eksempel: Fritt fall uten luftmotstand

Kraft:
$F = -mg$

(Negativ fordi tyngdekraften peker nedover)

Differensialligning:
$m\frac{d^2s}{dt^2} = -mg$

$\frac{d^2s}{dt^2} = -g$

Analytisk løsning:
$s(t) = s_0 + v_0 t - \frac{1}{2}gt^2$

Denne kan vi løse med penn og papir! ✓

Eksempel: Fritt fall MED luftmotstand

Krefter:
- Tyngdekraft: $F_g = -mg$
- Luftmotstand: $\displaystyle F_d = \frac{1}{2}C_d \rho A v^2$ (oppover hvis nedover bevegelse)

Total kraft:
$F = -mg + \frac{1}{2}C_d \rho A v^2$

Differensialligning:
$m\frac{dv}{dt} = -mg + \frac{1}{2}C_d \rho A v^2$

Problem: Denne har INGEN analytisk løsning! ✗

Løsning: Bruk numeriske metoder! ✓

Omskriving til første orden

For å bruke Eulers metode omskriver vi til førsteordens system:

$\frac{ds}{dt} = v$

$\frac{dv}{dt} = -g + \frac{C_d \rho A v^2}{2m}$

Dette er to koblede førsteordens differensiallikninger.

Eulers metode

Eulers metode er den enkleste numeriske metoden for å løse differensiallikninger.

Grunnidé

Derivert = helling av tangent:
$\frac{dy}{dx} = f(x, y)$

Tilnærming:
Hvis vi kjenner $y$ ved $x$ , kan vi estimere $y$ ved $x + \Delta x$ :

$y(x + \Delta x) \approx y(x) + \frac{dy}{dx} \cdot \Delta x$

$y(x + \Delta x) \approx y(x) + f(x, y) \cdot \Delta x$

Eulers algoritme

Gitt:
- Differensialligning: $\displaystyle \frac{dy}{dt} = f(t, y)$
- Initialverdi: $y(t_0) = y_0$
- Tidssteg: $\Delta t$ (ofte skrevet $dt$ )

Algoritme:

Generell formel:
$y_{n+1} = y_n + f(t_n, y_n) \cdot \Delta t$
$t_{n+1} = t_n + \Delta t$

Visualisering

Tenk på Eulers metode som å:
1. Stå på en kurve
2. Se tangentretningen (derivert)
3. Ta et lite steg i tangentretningen
4. Gjenta

Presisjon:
- Mindre $\Delta t$ → Bedre presisjon (men flere beregninger)
- Større $\Delta t$ → Raskere, men mindre nøyaktig

Eksempel: Eksponentiell vekst

Differensialligning:
$\frac{dy}{dt} = ky$

med $y(0) = 1$ og $k = 0.5$ .

Analytisk løsning:
$y(t) = e^{kt}$

Numerisk løsning (Eulers metode):

La $\Delta t = 0.1$ .

Steg 1:
- $t_0 = 0$ , $y_0 = 1$
- $\displaystyle \frac{dy}{dt} = 0.5 \times 1 = 0.5$
- $y_1 = 1 + 0.5 \times 0.1 = 1.05$
- $t_1 = 0.1$

Steg 2:
- $t_1 = 0.1$ , $y_1 = 1.05$
- $\displaystyle \frac{dy}{dt} = 0.5 \times 1.05 = 0.525$
- $y_2 = 1.05 + 0.525 \times 0.1 = 1.1025$
- $t_2 = 0.2$

Osv.

Sammenligning:

Tid $t$	Analytisk $e^{0.5t}$	Euler ( $\Delta t = 0.1$ )	Feil
0.0	1.0000	1.0000	0%
0.1	1.0513	1.0500	0.12%
0.2	1.1052	1.1025	0.24%
1.0	1.6487	1.6289	1.2%

Eulers metode gir god tilnærming! ✓

✏️Eulers metode: Enkel bevegelse

Gitt:
- Akselerasjon:

a = 2

m/s²
- Starthastig het:

v_0 = 0

m/s
- Tid:

t = 5

s
- Tidssteg:

\Delta t = 1

Differensialligning:
$\frac{dv}{dt} = a = 2$

Analytisk løsning:
$v(t) = v_0 + at = 0 + 2 \times 5 = 10 \text{ m/s}$

---

Eulers metode:

Algoritme:
$v_{n+1} = v_n + a \cdot \Delta t = v_n + 2 \times 1 = v_n + 2$

Steg for steg:

Steg 0:
- $t_0 = 0$ s, $v_0 = 0$ m/s

Steg 1:
- $a = 2$ m/s²
- $v_1 = v_0 + a \cdot \Delta t = 0 + 2 \times 1 = 2$ m/s
- $t_1 = 1$ s

Steg 2:
- $a = 2$ m/s²
- $v_2 = v_1 + a \cdot \Delta t = 2 + 2 \times 1 = 4$ m/s
- $t_2 = 2$ s

Steg 3:
- $v_3 = 4 + 2 = 6$ m/s
- $t_3 = 3$ s

Steg 4:
- $v_4 = 6 + 2 = 8$ m/s
- $t_4 = 4$ s

Steg 5:
- $v_5 = 8 + 2 = 10$ m/s
- $t_5 = 5$ s

---

Resultat:

Tid (s)	Euler (m/s)	Analytisk (m/s)	Feil
0	0	0	0%
1	2	2	0%
2	4	4	0%
3	6	6	0%
4	8	8	0%
5	10	10	0%

Konklusjon: Eulers metode gir eksakt løsning når akselerasjonen er konstant! ✓
Hvorfor?
- Når

a

er konstant, er

v(t)

en rett linje
- Eulers metode følger tangenten, som er en rett linje
- Perfekt samsvar!
Generelt: Eulers metode er eksakt for lineære problemer.

Python-grunnlag for fysikk

Variabler og beregninger

``python

`Variabler`


m = 0.5        # masse i kg
v = 10         # hastighet i m/s
g = 9.81       # tyngdeakselerasjon i m/s²
Beregninger

Ek = 0.5  m  v*2    # Kinetisk energi
Ep = m  g  h         # Potensiell energi
p = m  v              # Bevegelsesmengde
Skriv ut

print("Kinetisk energi:", Ek, "J")
print(f"Bevegelsesmengde: {p} kg·m/s")  # f-string


Lister (arrays)

`python

`Liste med tall`


tid = [0, 1, 2, 3, 4, 5]
hastighet = [0, 2, 4, 6, 8, 10]
Tilgang til elementer

print(tid[0])         # 0 (første element)
print(tid[-1])        # 5 (siste element)
print(hastighet[2])   # 4
Legge til elementer

tid.append(6)
hastighet.append(12)
Lengde av liste

n = len(tid)          # 7


Løkker

`python

`For-løkke`


for i in range(5):
    print(i)          # Skriver 0, 1, 2, 3, 4
While-løkke

t = 0
while t < 5:
    print(t)
    t = t + 1         # Eller: t += 1
Løkke over liste

hastigheter = [0, 2, 4, 6]
for v in hastigheter:
    Ek = 0.5  m  v*2
    print(f"v = {v} m/s, Ek = {Ek} J")

 m  hastighet*2  # Beregner for alle verdier
Nyttige funksjoner

print(np.max(hastighet))      # 10 (største verdi)
print(np.min(hastighet))      # 0 (minste verdi)
print(np.mean(hastighet))     # 5.0 (gjennomsnitt)
print(np.sum(hastighet))      # 30 (sum)


Matplotlib for plotting

`python import matplotlib.pyplot as plt

`Data`


tid = [0, 1, 2, 3, 4, 5]
hastighet = [0, 2, 4, 6, 8, 10]
Plott

plt.plot(tid, hastighet, 'b-')  # Blå linje
plt.xlabel('Tid (s)')
plt.ylabel('Hastighet (m/s)')
plt.title('Hastighet som funksjon av tid')
plt.grid(True)
plt.show()

Eulers metode i Python

Mal for Eulers metode

``python import numpy as np import matplotlib.pyplot as plt

`Parametere`


t0 = 0          # Starttid
y0 = 1          # Startverdi
tslutt = 10    # Sluttid
dt = 0.1        # Tidssteg
Derivert (differensialligning)

def f(t, y):
    """Returnerer dy/dt."""
    return -0.5  y  # Eksempel: eksponentiell nedgang
Initialiser lister

tid = [t0]
y = [y0]
Eulers metode

t = t0
yverdi = y0
while t < tslutt:
    # Beregn derivert
    dydt = f(t, yverdi)    # Euler-steg
    yverdi = yverdi + dydt  dt
    t = t + dt
    # Lagre
    tid.append(t)
    y.append(yverdi)
Plott

plt.plot(tid, y)
plt.xlabel('Tid')
plt.ylabel('y')
plt.title('Løsning av differensialligning')
plt.grid(True)
plt.show()

verdi = s0
vverdi = v0while sverdi > 0:  # Stopp når objektet treffer bakken
    # Akselerasjon
    a = -g
    # Euler-steg
    vverdi = vverdi + a  dt
    sverdi = sverdi + vverdi  dt
    t = t + dt
    # Lagre
    tid.append(t)
    s.append(sverdi)
    v.append(vverdi)
Resultat

print(f"Falltid: {t:.3f} s")
print(f"Slutthastig het: {vverdi:.3f} m/s")
Analytisk løsning

tanalytisk = np.sqrt(2  s0 / g)
vanalytisk = -g  tanalytisk
print(f"Analytisk tid: {tanalytisk:.3f} s")
print(f"Analytisk hastighet: {vanalytisk:.3f} m/s")
Plott

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
Høyde

ax1.plot(tid, s, 'b-', label='Numerisk')
ax1.setxlabel('Tid (s)')
ax1.setylabel('Høyde (m)')
ax1.settitle('Høyde som funksjon av tid')
ax1.grid(True)
ax1.legend()
Hastighet

ax2.plot(tid, v, 'r-', label='Numerisk')
ax2.setxlabel('Tid (s)')
ax2.setylabel('Hastighet (m/s)')
ax2.settitle('Hastighet som funksjon av tid')
ax2.grid(True)
ax2.legend()

plt.tightlayout() plt.show()``

✏️Simulering: Fritt fall med luftmotstand

En ball med masse 0.5 kg og radius 0.05 m slippes fra 100 m høyde. Bruk Eulers metode til å simulere fallet med luftmotstand. Sammenlign med fritt fall uten luftmotstand.

Gitt:
- Masse:

m = 0.5

kg
- Radius:

r = 0.05

m
- Starthøyde:

s_0 = 100

m
- Starthastighet:

v_0 = 0

m/s
- Luftens tetthet:

\rho = 1.2

kg/m³
- Luftmotstandskoeffisient:

C_d = 0.5

Fysikk:

Tverrsnittareal:
$A = \pi r^2 = \pi \times 0.05^2 = 0.00785 \text{ m}^2$

Krefter:
- Tyngdekraft: $F_g = -mg = -0.5 \times 9.81 = -4.905$ N
- Luftmotstand: $\displaystyle F_d = \frac{1}{2}C_d \rho A v^2$ (oppover når bevegelse nedover)

Netto kraft:
$F = -mg + \frac{1}{2}C_d \rho A v^2$

Akselerasjon:
$a = \frac{F}{m} = -g + \frac{C_d \rho A v^2}{2m}$

Differensiallikninger:
$\frac{ds}{dt} = v$
$\frac{dv}{dt} = -g + \frac{C_d \rho A v^2}{2m}$

---

Python-kode:

``python import numpy as np import matplotlib.pyplot as plt

`Parametere`


m = 0.5          # kg
r = 0.05         # m
A = np.pi  r2 # m²
rho = 1.2        # kg/m³
Cd = 0.5
g = 9.81         # m/s²
s0 = 100         # m
v0 = 0           # m/s
dt = 0.001       # s (lite tidssteg for nøyaktighet)
Initialiser med luftmotstand

tidluft = [0]
sluft = [s0]
vluft = [v0]
t = 0
s = s0
v = v0while s > 0:
    # Luftmotstand (oppover hvis v < 0, dvs. nedover bevegelse)
    Fd = 0.5  Cd  rho  A  v2 if v < 0 else -0.5  Cd  rho  A  v2
    # Akselerasjon
    a = -g + Fd / m
    # Euler-steg
    v = v + a  dt
    s = s + v  dt
    t = t + dt
    # Lagre
    tidluft.append(t)
    sluft.append(s)
    vluft.append(v)
Resultat med luftmotstand

tluftslutt = t
vluftslutt = v
Uten luftmotstand (analytisk)

tidingen = np.linspace(0, tluftslutt, 1000)
singen = s0 - 0.5  g  tidingen2
vingen = -g  tidingen
Analytisk falltid uten luftmotstand

tanalytisk = np.sqrt(2  s0 / g)
vanalytisk = -g  tanalytisk
Print resultater

print("MED LUFTMOTSTAND:")
print(f"  Falltid: {tluftslutt:.3f} s")
print(f"  Slutthastig het: {vluftslutt:.3f} m/s")
print()
print("UTEN LUFTMOTSTAND:")
print(f"  Falltid: {tanalytisk:.3f} s")
print(f"  Slutthastig het: {vanalytisk:.3f} m/s")
print()
print("FORSKJELL:")
print(f"  Falltid: {tluftslutt - tanalytisk:.3f} s lengre med luftmotstand")
print(f"  Hastighet: {abs(vluftslutt) - abs(vanalytisk):.3f} m/s lavere med luftmotstand")
Terminalhastig het (teoretisk)

vterminal = np.sqrt(2  m  g / (Cd  rho  A))
print(f"  Terminalhastighet: {vterminal:.3f} m/s")
Plott

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
Høyde

ax1.plot(tidluft, sluft, 'b-', label='Med luftmotstand', linewidth=2)
ax1.plot(tidingen, singen, 'r--', label='Uten luftmotstand', linewidth=2)
ax1.setxlabel('Tid (s)', fontsize=12)
ax1.setylabel('Høyde (m)', fontsize=12)
ax1.settitle('Høyde som funksjon av tid', fontsize=14)
ax1.legend(fontsize=11)
ax1.grid(True, alpha=0.3)
ax1.setxlim(0, max(tluftslutt, tanalytisk)  1.1)
Hastighet

ax2.plot(tidluft, vluft, 'b-', label='Med luftmotstand', linewidth=2)
ax2.plot(tidingen, vingen, 'r--', label='Uten luftmotstand', linewidth=2)
ax2.axhline(-vterminal, color='g', linestyle=':', label='Terminalhastighet', linewidth=2)
ax2.setxlabel('Tid (s)', fontsize=12)
ax2.setylabel('Hastighet (m/s)', fontsize=12)
ax2.settitle('Hastighet som funksjon av tid', fontsize=14)
ax2.legend(fontsize=11)
ax2.grid(True, alpha=0.3)
ax2.setxlim(0, max(tluftslutt, tanalytisk)  1.1)

plt.tightlayout() plt.show()`

---

Resultat (typisk):

`MED LUFTMOTSTAND: Falltid: 4.87 s Slutthastig het: -42.1 m/s

UTEN LUFTMOTSTAND: Falltid: 4.52 s Slutthastig het: -44.3 m/s

FORSKJELL: Falltid: 0.35 s lengre med luftmotstand Hastighet: 2.2 m/s lavere med luftmotstand Terminalhastighet: 71.4 m/s``

---

Analyse:

1. Falltid:
- Med luftmotstand: 4.87 s
- Uten luftmotstand: 4.52 s
- Forskjell: 0.35 s (8% lengre)

Forklaring: Luftmotstanden bremser ballen, så den bruker lengre tid.

2. Slutthastig het:
- Med luftmotstand: -42.1 m/s
- Uten luftmotstand: -44.3 m/s
- Forskjell: 2.2 m/s lavere

Forklaring: Luftmotstanden reduserer slutthastigheten.

3. Terminalhastighet:
- Teoretisk: 71.4 m/s
- Ballen når ikke terminalhastighet (kun 42 m/s)
- 100 m er ikke høyt nok

Konklusjon:
For denne ballen ved 100 m høyde er luftmotstanden moderat betydelig (8% effekt på tid). For høyere høyder eller lettere objekter ville effekten vært større.

Tidssteg ( $\Delta t$ eller $dt$ ) er kritisk for nøyaktighet!

For lite tidssteg:
- ✓ Meget nøyaktig
- ✗ Meget treigt (mange beregninger)

For stort tidssteg:
- ✓ Rask beregning
- ✗ Unøyaktig
- ✗ Kan gi ustabile løsninger

Eksempel:
For fritt fall fra 100 m:
- Falltid ≈ 4.5 s
- Bruk minst 1000 steg: $dt = 0.0045$ s
- Bedre: 10000 steg: $dt = 0.00045$ s

Akkumulering av feil

Eulers metode er tilnærmet, og feil akkumuleres!

Eksempel:
Simulering av planetbaner over millioner av år krever meget presise metoder. Eulers metode ville akkumulere feil og "predikere" at planeten flyr ut av solsystemet!

Oppgaver

Lett3 oppgaver

1Python

2Python

7Opplasting

Medium3 oppgaver

3Python

4Python

8Opplasting

Vanskelig4 oppgaver

5Python

6Python

9Python

10Python