Auf der vorherigen Seite habt ihr eine grundlegende Formel kennengelernt, mit der wir Luftreibung modellieren können. Doch wie setzten wir das konkret in Programmcode um, mit dem wir die Luftreibung in unsere Simulation einbauen können?
Weil wir im allgemeineren zweidimensionalen Fall einer Bewegung gleich noch einen Zusammenhang berücksichtigen müssen, den wir für ein einfaches Modell gerne weglassen, schauen wir uns zunächst Luftreibung nur in der Fallrichtung an, also der y-Richtung.
Simulation einer Bewegung in nur einer Richtung mit Luftreibung (z.B. fallender Papiertrichter)
Dieses Modell könnt ihr gut nutzten, wenn ihr eine Bewegung untersucht, die im Wesentlichen nur in die Fallrichtung geht – also ein freier Fall in y-Richtung ohne Anfangsgeschwindigkeit in x-Richtung. Wenn ihr z.B. einen Papiertrichter fallen lasst, ist dieses Modell sehr brauchbar für euch!
Wir haben auf der vorherigen Seite diese Formel für Luftreibung kennen gelernt: \( F_{Luft}=\frac{1}{2}\cdot A\cdot c_w\cdot \rho_{Luft}\cdot v^2 = konst_{Luft} \cdot v^2 \)
Um dies in der Simulation einzubauen, müssen wir zunächst die Parameter angeben. Fügt dazu unter der Zelle mit den Anfangswerten solch eine Zelle hinzu:
# Parameter für die Luftreibung NUR in y-Richtung
d_Objekt = 0.12 #m , Durchmesser des runden Objekts
A = np.square(d_Objekt/2.)*3.141 # m^2, Fläche des Objekts
cw = 0.75 # Papiertrichter: 0.75, Kugel: 0.5
rho_Luft = 1.204 # kg/m^3, Dichte der Luft
m = 0.005 # kg, Masse des Objekts
konst_Luft = 0.5*A*cw*rho_LuftDie Werte, die wir hier für die Variablen angegeben haben, kannst du für einen Papiertrichter gleich übernehmen. Dann musst du nur den Durchmesser und die Masse deines Papiertrichters anpassen.
In der Schleife, in der die Simulation durchgeführt wird, können wir nun in jedem Schritt den Wert der Luftreibungskraft aus der Geschwindigkeit in y-Richtung berechnen und daraus – mit dem zweiten Newtonschen Axiom – die wirkende Beschleunigung. Diese addieren wir zur Erdbeschleunigung hinzu:
for r in range(1, N, 1):
a_x_alt, v_x_alt, x_alt, a_y_alt, v_y_alt, y_alt = a_x_array[r-1], v_x_array[r-1], x_array[r-1], a_y_array[r-1], v_y_array[r-1], y_array[r-1]
# Ergänzung für Luftreibung NUR in y-Richtung (für Papiertrichter):
F_Luft_y = konst_Luft * np.square(v_y_alt)
a_Luft_y = F_Luft_y / m
# Der Spielzug, in dem wie Werte der neuen Runde nach den Spielregeln berechnet werden:
a_x_neu = 0.
v_x_neu = v_x_alt
x_neu = x_alt + v_x_alt*dt
a_y_neu = -g + a_Luft_y
v_y_neu = v_y_alt + a_y_alt * dt
y_neu = y_alt + v_y_alt * dtFür die Simulation von Luftreibung bei einer Bewegung in nur eine Richtung (hier: in y-Richtung) war es das schon! Probiert aus, welchen Effekt ihr damit erzielt! Wenn ihr es ausprobiert, setzt ihr am besten in der Zelle mit den Anfangswerten die Variablen „Nr“ auf 2 (später auf 3, 4, …), um eure alten Daten nicht zu überschreiben.
Simulation der Bewegung eines Balls in zwei Dimensionen mit Luftreibung
Wenn sich ein Objekt in zwei Richtungen (x und y) bewegt, müssen wir bei der Luftreibungskraft berücksichtigen, dass Kräfte allgemein Vektoren sind. In der Formel für die Luftreibung \( F_{Luft}= konst_{Luft} \cdot v^2 \) taucht ja das Quadrat der Geschwindigkeit auf, die eigentlich auch ein Vektor ist. Strenggenommen müssten wir also schreiben: \( \overrightarrow{F}_{Luft}= konst_{Luft} \cdot \overrightarrow{v}^2 \)
Für das Betragsquadrat eines Vektors gilt: \( \overrightarrow{v}^2 = v_x^2 + v_y^2 \)
Hier müssen wir also aufpassen: wir können die Richtungen x und y nun nicht mehr trennen wie bisher, sondern müssen beide bei der Berechnung der Luftreibungskraft beide Komponenten berücksichtigen!
Wir haben also: \( F_{Luft}= konst_{Luft} \cdot (v_x^2 + v_y^2 )\)
Um die x- und y-Komponente der Luftreibungskraft aus der Kraft als Vektor zu berechnen, nutzen wir die sin- und cos-Funktion. Für die Berechnung der Beschleunigung der Luftreibung nutzen wir wieder das zweite Newtonsche Axiom. Zusammen ergibt sich:
x-Richtung: \( a_{Luft, x}= F_{Luft} / m \cdot cos(\alpha) \)
y-Richtung: \( a_{Luft, y}= F_{Luft} / m \cdot sin(\alpha) \)
Hierbei ist \( \alpha \) der Winkel der Bewegungsrichtung des Objekts, also \( \alpha = arctan(v_y / v_x) \). Zuletzt müssen wir noch berücksichtigen, dass die Luftreibungskraft immer entgegengesetzt ist zur Bewegungsrichtung.
Wenn wir das alles in Code packen, kann das z.B. für die Simulation eines Volleyballs (Größe 4: m=250g, d=20cm) mit Luftteibung so aussehen:
Nach der Zelle mit den Anfangswerten ergänzen wir wieder eine Zelle mit Parametern für die Luftreibung:
# Parameter für die Luftreibung bei einem Ball:
d_Objekt = 0.2 #m , Durchmesser des Balls
A = np.square(d_Objekt/2.)*3.141 # m^2, Querschnittsfläche des Balls
cw = 0.5 # cq-Wert für Kugel
rho_Luft = 1.204 # kg/m^3, Dichte der Luft
m = 0.25 # kg, Masse des Objekts
konst_Luft = 0.5*A*cw*rho_LuftDie Zelle mit den Spielregeln sieht dann so aus:
for r in range(1, N, 1):
# Einlesen der "alten" Werte (aus der vorherigen Runde) aus der Tabelle:
a_x_alt, v_x_alt, x_alt, a_y_alt, v_y_alt, y_alt = a_x_array[r-1], v_x_array[r-1], x_array[r-1], a_y_array[r-1], v_y_array[r-1], y_array[r-1]
# Ergänung für Luftreibung in x- und y-Richtung bei einem kugelförmigen Objekt (Ball):
F_Luft_Betragsquadrat = konst_LR * v_x_alt*v_x_alt * v_y_alt*v_y_alt
alpha = np.arctan(v_y_alt / v_x_alt)
F_Luft_x = F_Luft_Betragsquadrat * np.cos(alpha)
F_Luft_y = F_Luft_Betragsquadrat * np.sin(alpha)
a_Luft_x = F_Luft_x / m # Newton II: F=ma <=> a = F/m
a_Luft_y = F_Luft_y / m # Newton II: F=ma <=> a = F/m
# Richtung der Luftreibungskraft/beschleunigung: immer entgegen v!
if v_x_alt > 0:
a_Luft_x = - np.abs(a_Luft_x)
else:
a_Luft_x = np.abs(a_Luft_x)
if v_y_alt > 0:
a_Luft_y = - np.abs(a_Luft_y)
else:
a_Luft_y = np.abs(a_Luft_y)
# Der Spielzug, in dem wie Werte der neuen Runde nach den Spielregeln berechnet werden:
a_x_neu = 0 + a_Luft_x
v_x_neu = v_x_alt
x_neu = x_alt + v_x_alt*dt
a_y_neu = -g + a_Luft_y
v_y_neu = v_y_alt + a_y_alt * dt
y_neu = y_alt + v_y_alt * dt
# Und nun schreiben wir die neuen Werte in die Tabelle an der Stelle der Runde "r":
a_x_array[r] = a_x_neu
v_x_array[r] = v_x_neu
x_array[r] = x_neu
a_y_array[r] = a_y_neu
v_y_array[r] = v_y_neu
y_array[r] = y_neu
zeige_und_speichere_simulierte_werte(a_x_array, v_x_array, x_array, a_y_array, v_y_array, y_array, Nr, Gruppenname)Schaut euch diesen Code genau an und vergleicht ihn mit der physikalischen Beschreibung im Text darüber. Versteht ihr alle Zeilen, die sich geändert haben? Falls nicht, sprecht auch mit eurer Physik-Lehrkraft darüber. Vergleicht einmal das Ergebnis der Simulation mit Luftreibung mit dem ohne Luftreibung. Wie groß ist der Effekt? Überrascht euch das?
P.S.: zu der Berechnung der Komponenten der Luftreibung könnt ihr euch auch dieses Video anschauen:
Und noch ein Hinweis zum Schluss: wir haben oben angemerkt, dass die Berechnung zur Luftreibung, die wir hier vorstellen, nur für kugelförmige Bälle funktioniert. Was müsste man ändern, wenn man z.B. den Flug eines Footballs mit Luftreibung simulieren möchte?