---

Bewegungsgleichungen des Schiefen Wurfs

Wir leiten jetzt die Bewegungsgleichungen des schiefen Wurfs (Projektile mit Abwurfwinkel) her und bauen anschließend ein Python-Programm, das Weg-, Geschwindigkeits- und Beschleunigungs-Zeit-Funktionen plottet.

1. Physikalisches Modell des schiefen Wurfs

Annahmen:

• Bewegung in zwei Dimensionen: horizontal $x$, vertikal $y$
• $x$-Achse waagerecht, $y$-Achse nach oben positiv
• Homogenes Gravitationsfeld, konstante Erdbeschleunigung $g$
• Kein Luftwiderstand

Ein Körper wird zum Zeitpunkt $t = 0$ mit Anfangsgeschwindigkeit $v_0$ unter dem Winkel $\alpha$ über der Horizontalen von der Position $(x_0, y_0)$ aus geworfen.

Zerlegung der Anfangsgeschwindigkeit:

$$v_{0x} = v_0 \cos\alpha, \qquad v_{0y} = v_0 \sin\alpha$$

Kräfte (nur Gewichtskraft $m \vec g$):

$$a_x(t) = 0, \qquad a_y(t) = -g$$

Skizzen zum schiefen Wurf (externe Links)

• Parabolische Flugbahn mit eingetragenen Geschwindigkeitskomponenten:
  Skizze: Projectile Motion mit Komponenten

• Projektile mit Abwurfwinkel, inkl. Formeln für Reichweite und Höhe:
  Skizze: Projectile Motion – Definition & Formeln

• Graphen für Position, Geschwindigkeit und Beschleunigung bei obliquem Wurf:
  Skizze: Projectile Motion – Oblique

• Zusammenstellung von $x(t)$-, $y(t)$- und $y(x)$-Graphen:
  Skizze: Projectile Motion – y(x), y(t), x(t)

2. Vektorielle Formulierung und Komponenten

Vektorielle Bewegungsgleichung:

$$m \vec a = \vec F = m \vec g$$

Mit $$\vec r(t) = \begin{pmatrix} x(t) \ y(t) \end{pmatrix}, \quad \vec v(t) = \frac{\mathrm d \vec r}{\mathrm d t}, \quad \vec a(t) = \frac{\mathrm d \vec v}{\mathrm d t}$$

und $$\vec g = \begin{pmatrix} 0 \ -g \end{pmatrix}$$

erhalten wir komponentenweise:

• Horizontal: $$a_x(t) = 0$$
• Vertikal: $$a_y(t) = -g$$

Diese beiden Richtungen sind entkoppelt und werden getrennt behandelt.

3. Horizontalbewegung: $x(t)$, $v_x(t)$, $a_x(t)$

3.1 Beschleunigung und Geschwindigkeit

Aus $$a_x(t) = \frac{\mathrm d v_x(t)}{\mathrm d t} = 0$$

integrieren wir von $0$ bis $t$:

$$\int_{v_x(0)}^{v_x(t)} \mathrm d v_x = \int_0^t 0 ,\mathrm d t$$

Linke Seite: $$v_x(t) - v_x(0) = 0$$

Mit dem Anfangswert $$v_x(0) = v_{0x} = v_0 \cos\alpha$$

erhalten wir

$$v_x(t) = v_0 \cos\alpha$$

Die horizontale Geschwindigkeit ist also zeitlich konstant.

3.2 Weg-Zeit-Funktion in $x$-Richtung

Definiere $$\frac{\mathrm d x(t)}{\mathrm d t} = v_x(t) = v_0 \cos\alpha$$

Integration von $0$ bis $t$:

$$\int_{x(0)}^{x(t)} \mathrm d x = \int_0^t v_0 \cos\alpha ,\mathrm d t$$

Linke Seite: $$x(t) - x_0$$

Rechte Seite: $$v_0 \cos\alpha \cdot t$$

Damit

$$x(t) = x_0 + v_0 \cos\alpha , t$$

und zusammen mit $v_x(t)$ und $a_x(t)$:

$$x(t) = x_0 + v_0 \cos\alpha , t, \quad v_x(t) = v_0 \cos\alpha, \quad a_x(t) = 0$$

4. Vertikalbewegung: $y(t)$, $v_y(t)$, $a_y(t)$

4.1 Beschleunigung, Geschwindigkeit

Wir haben

$$a_y(t) = \frac{\mathrm d v_y(t)}{\mathrm d t} = -g$$

Integration von $0$ bis $t$:

$$\int_{v_y(0)}^{v_y(t)} \mathrm d v_y = \int_0^t -g ,\mathrm d t$$

Linke Seite: $$v_y(t) - v_y(0)$$

Beim schiefen Wurf:

$$v_y(0) = v_{0y} = v_0 \sin\alpha$$

Rechte Seite: $$-g t$$

Also:

$$v_y(t) - v_0 \sin\alpha = -g t$$

Damit die Geschwindigkeits-Zeit-Funktion in $y$-Richtung:

$$v_y(t) = v_0 \sin\alpha - g t$$

4.2 Weg-Zeit-Funktion in $y$-Richtung

Nun verwenden wir

$$\frac{\mathrm d y(t)}{\mathrm d t} = v_y(t) = v_0 \sin\alpha - g t$$

Integration von $0$ bis $t$:

$$\int_{y(0)}^{y(t)} \mathrm d y = \int_0^t \left( v_0 \sin\alpha - g t' \right)\mathrm d t'$$

Linke Seite: $$y(t) - y_0$$

Rechte Seite:

$$\int_0^t v_0 \sin\alpha ,\mathrm d t' * \int_0^t g t' ,\mathrm d t' = v_0 \sin\alpha , t * g \frac{t^2}{2}$$

Somit:

$$y(t) - y_0 = v_0 \sin\alpha , t - \frac{1}{2} g t^2$$

und

$$y(t) = y_0 + v_0 \sin\alpha , t - \frac{1}{2} g t^2$$

Zusammen mit $v_y(t)$ und $a_y(t)$:

$$y(t) = y_0 + v_0 \sin\alpha , t - \frac{1}{2} g t^2, \quad v_y(t) = v_0 \sin\alpha - g t, \quad a_y(t) = -g$$

5. Parametrische Bahnkurve $y(x)$

Die Bewegungsgleichungen sind:

$$x(t) = x_0 + v_0 \cos\alpha , t$$ $$y(t) = y_0 + v_0 \sin\alpha , t - \frac{1}{2} g t^2$$

Eliminieren von $t$:

Aus $x(t)$:

$$t = \frac{x - x_0}{v_0 \cos\alpha}$$

Setze in $y(t)$ ein:

$$y(x) = y_0 * v_0 \sin\alpha \cdot \frac{x - x_0}{v_0 \cos\alpha} - \frac{1}{2} g \left( \frac{x - x_0}{v_0 \cos\alpha} \right)^2$$

Vereinfachung:

$$y(x) = y_0 * (x - x_0)\tan\alpha - \frac{g}{2 v_0^2 \cos^2\alpha}(x - x_0)^2$$

Das ist eine Parabel in der $x$-$y$-Ebene, was die typische Form der Wurfparabel erklärt.

6. Zeit bis zum Aufprall und Reichweite (Spezialfall $y_0 = 0$)

Häufiger Spezialfall: Abwurf vom Boden, also $y_0 = 0$ und Landung wieder bei $y = 0$.

6.1 Flugzeit

Setze $y(t) = 0$:

$$0 = v_0 \sin\alpha , t - \frac{1}{2} g t^2$$

Faktorisieren:

$$t \left( v_0 \sin\alpha - \frac{1}{2} g t \right) = 0$$

Lösungen:

• $t = 0$ (Startzeit),
• $t = \dfrac{2 v_0 \sin\alpha}{g}$ (Landung).

Flugzeit:

$$T = \frac{2 v_0 \sin\alpha}{g}$$

6.2 Horizontale Reichweite

Reichweite $R$ ist der $x$-Abstand, den das Projektil in der Zeit $T$ zurücklegt:

$$R = x(T) - x_0 = v_0 \cos\alpha \cdot T = v_0 \cos\alpha \cdot \frac{2 v_0 \sin\alpha}{g} = \frac{v_0^2}{g} \sin (2\alpha)$$

Auch diese Standardformel findest du in vielen Darstellungen des schiefen Wurfs.

7. Zusammenfassung der Bewegungsgleichungen (allgemeiner Fall)

Allgemein (2D, ohne Luftwiderstand):

• Weg-Zeit-Funktionen: $$x(t) = x_0 + v_0 \cos\alpha , t$$ $$y(t) = y_0 + v_0 \sin\alpha , t - \frac{1}{2} g t^2$$

• Geschwindigkeits-Zeit-Funktionen: $$v_x(t) = v_0 \cos\alpha$$ $$v_y(t) = v_0 \sin\alpha - g t$$

• Beschleunigungs-Zeit-Funktionen: $$a_x(t) = 0, \qquad a_y(t) = -g$$

Diese Gleichungen beschreiben vollständig den schiefen Wurf im idealisierten Fall.

8. Python-Programm für den schiefen Wurf

Das Programm (“2512022306_SchieferWurf.py”) :

• setzt $g = 9.81~\mathrm{m/s^2}$,

• wählt Anfangsbedingungen $(x_0, y_0, v_0, \alpha)$,

• berechnet die Flugzeit $T$ durch Lösen von $y(T) = 0$,

• erzeugt einen Zeitvektor $t$,

• berechnet $x(t)$, $y(t)$, $v_x(t)$, $v_y(t)$, $a_x(t)$, $a_y(t)$,

• plottet

  • Weg-Zeit-Funktionen (getrennt nach $x(t)$ und $y(t)$),
  • Geschwindigkeits-Zeit-Funktionen,
  • Beschleunigungs-Zeit-Funktionen,
  • zusätzlich die Bahnkurve $y(x)$.

Download “2512022306_SchieferWurf.py”

import numpy as np
import matplotlib.pyplot as plt

# Erdbeschleunigung
g = 9.81  # m/s^2

# Anfangswerte für den schiefen Wurf
x0 = 0.0        # Start-x in m
y0 = 0.0        # Start-y in m (z.B. Boden)
v0 = 20.0       # Anfangsgeschwindigkeit in m/s
alpha_deg = 45  # Abwurfwinkel in Grad

# Winkel in Radiant
alpha = np.deg2rad(alpha_deg)

# Anfangskomponenten der Geschwindigkeit
v0x = v0 * np.cos(alpha)
v0y = v0 * np.sin(alpha)

# Bewegungsgleichungen
def x(t):
    """Weg in x-Richtung"""
    return x0 + v0x * t

def y(t):
    """Weg in y-Richtung"""
    return y0 + v0y * t - 0.5 * g * t**2

def vx(t):
    """Geschwindigkeit in x-Richtung (konstant)"""
    return v0x * np.ones_like(t)

def vy(t):
    """Geschwindigkeit in y-Richtung"""
    return v0y - g * t

def ax(t):
    """Beschleunigung in x-Richtung (0)"""
    return np.zeros_like(t)

def ay(t):
    """Beschleunigung in y-Richtung (-g)"""
    return -g * np.ones_like(t)

# Flugzeit bestimmen: y(T) = 0
# y(t) = y0 + v0y * t - 0.5*g*t**2 = 0
# => -0.5*g*t^2 + v0y*t + y0 = 0
A = -0.5 * g
B = v0y
C = y0

D = B**2 - 4 * A * C  # Diskriminante

if D < 0:
    raise ValueError("Keine reale Flugzeit: prüfe y0, v0 und alpha.")

t1 = (-B + np.sqrt(D)) / (2 * A)
t2 = (-B - np.sqrt(D)) / (2 * A)

# Positive Lösung als Flugzeit wählen
t_candidates = [t for t in (t1, t2) if t > 0]
if not t_candidates:
    raise ValueError("Keine positive Flugzeit gefunden.")

T = max(t_candidates)

# Zeitvektor von 0 bis T
t = np.linspace(0, T, 400)

# Werte berechnen
x_t = x(t)
y_t = y(t)
vx_t = vx(t)
vy_t = vy(t)
ax_t = ax(t)
ay_t = ay(t)

# Plot 1: Weg-Zeit-Funktionen
plt.figure()
plt.plot(t, x_t, label="x(t)")
plt.plot(t, y_t, label="y(t)")
plt.xlabel("Zeit t [s]")
plt.ylabel("Weg [m]")
plt.title("Schiefer Wurf: Weg-Zeit-Funktionen")
plt.legend()
plt.grid(True)

# Plot 2: Geschwindigkeit-Zeit-Funktionen
plt.figure()
plt.plot(t, vx_t, label="v_x(t)")
plt.plot(t, vy_t, label="v_y(t)")
plt.xlabel("Zeit t [s]")
plt.ylabel("Geschwindigkeit [m/s]")
plt.title("Schiefer Wurf: Geschwindigkeit-Zeit-Funktionen")
plt.legend()
plt.grid(True)

# Plot 3: Beschleunigung-Zeit-Funktionen
plt.figure()
plt.plot(t, ax_t, label="a_x(t)")
plt.plot(t, ay_t, label="a_y(t)")
plt.xlabel("Zeit t [s]")
plt.ylabel("Beschleunigung [m/s^2]")
plt.title("Schiefer Wurf: Beschleunigung-Zeit-Funktionen")
plt.legend()
plt.grid(True)

# Plot 4: Bahnkurve y(x)
plt.figure()
plt.plot(x_t, y_t)
plt.xlabel("x [m]")
plt.ylabel("y [m]")
plt.title("Schiefer Wurf: Bahnkurve y(x)")
plt.grid(True)

plt.show()

Code-Experimente:

• Ändere $v_0$ und $\alpha$ und beobachte die Änderung von Flugzeit und Reichweite.
• Setze $y_0 \neq 0$, um einen Wurf von einer erhöhten Plattform zu simulieren (dann bleibt die Flugzeitformel nur noch numerisch, aber der Code löst das über die quadratische Gleichung).

---