---

Bewegungsgleichungen des Waagerechten Wurfs

Wir betrachten jetzt den waagerechten Wurf (horizontaler Wurf): Ein Körper verlässt in einer gewissen Höhe den Startpunkt mit reiner Horizontalgeschwindigkeit; die Schwerkraft wirkt nur nach unten. Danach kommt ein Python-Programm mit Plots.

1. Physikalisches Modell des waagerechten 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

Initialbedingungen beim Startzeitpunkt $t = 0$:

• Startpunkt $x(0) = x_0$, $y(0) = y_0$
• Anfangsgeschwindigkeit nur horizontal $$v_x(0) = v_{0}, \quad v_y(0) = 0$$

Kräfte:

• Nur Gewichtskraft $m \vec g$ nach unten, also $$a_x(t) = 0, \quad a_y(t) = -g$$

Skizzen zum waagerechten Wurf (externe Links)

• Typischer waagerechter Wurf vom Tisch, mit Zerlegung der Geschwindigkeit in $v_x$ und $v_y$: Skizze: Horizontal Projectile Motion

• Schema eines horizontal gestarteten Projektils mit parabolischer Bahn: Skizze: Horizontal Projectiles

• Waagerechter Wurf aus der Praxis (Ball rollt vom Tisch): Skizze: Projectile from elevated position

2. Aufspaltung in $x$- und $y$-Richtung

Die Bewegungsgleichung in Vektorform lautet $$m \vec a = \vec F = m \vec g$$

Mit $$\vec r(t) = \begin{pmatrix} x(t) [4pt] 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 [4pt] -g \end{pmatrix}$$

ergeben sich Komponenten:

• Horizontal: $$a_x(t) = 0$$

• Vertikal: $$a_y(t) = -g$$

Diese beiden Komponenten sind unabhängig und können separat behandelt werden.

3. Horizontaler Teil: $x(t)$ und $v_x(t)$

3.1 Beschleunigung und Geschwindigkeit

Aus $$a_x(t) = \frac{\mathrm d v_x(t)}{\mathrm d t} = 0$$ folgt durch Integration von $0$ bis $t$: $$\int_{v_x(0)}^{v_x(t)} \mathrm d v_x = \int_0^t 0 ,\mathrm d t$$ $$v_x(t) - v_x(0) = 0$$

Damit $$v_x(t) = v_x(0) = v_{0}$$

Die horizontale Geschwindigkeit ist also konstant.

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

Definiere $$v_x(t) = \frac{\mathrm d x(t)}{\mathrm d t} = v_{0}$$

Integriere von $0$ bis $t$: $$\int_{x(0)}^{x(t)} \mathrm d x = \int_0^t v_{0} ,\mathrm d t$$ $$x(t) - x_0 = v_{0} t$$

Damit $$x(t) = x_0 + v_{0} t$$

Das ist die Weg-Zeit-Funktion in horizontaler Richtung.

4. Vertikaler Teil: $y(t)$, $v_y(t)$

4.1 Beschleunigung neben Geschwindigkeit

Start mit $$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$$ $$v_y(t) - v_y(0) = -g t$$

Beim waagerechten Wurf: $$v_y(0) = 0$$

Also $$v_y(t) = -g t$$

Die vertikale Geschwindigkeit nimmt (nach unten, also negativ) linear mit der Zeit zu.

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

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

Integration von $0$ bis $t$: $$\int_{y(0)}^{y(t)} \mathrm d y = \int_0^t -g t' ,\mathrm d t'$$ $$y(t) - y_0 = -g \int_0^t t' ,\mathrm d t' = -g \frac{t^2}{2}$$

Damit $$y(t) = y_0 - \frac{1}{2} g t^2$$

Das ist die Weg-Zeit-Funktion in vertikaler Richtung; sie entspricht genau dem freien Fall aus der Ruhe, nur dass gleichzeitig eine horizontale Bewegung stattfindet.

5. Beschleunigung-Zeit-Funktionen

Aus der Definition des Modells:

• Horizontal: $$a_x(t) = 0$$

• Vertikal: $$a_y(t) = -g$$

Die Beschleunigung ist also konstant nach unten gerichtet; horizontal gibt es keine.

6. Parametrische Bahnkurve

Die Bewegungsgleichungen lauten zusammengefasst:

• Horizontal: $$x(t) = x_0 + v_{0} t, \quad v_x(t) = v_{0}, \quad a_x(t) = 0$$

• Vertikal: $$y(t) = y_0 - \frac{1}{2} g t^2, \quad v_y(t) = -g t, \quad a_y(t) = -g$$

Eliminiert man $t$ zwischen $x(t)$ und $y(t)$, ergibt sich die Bahnkurve: $$t = \frac{x - x_0}{v_{0}}$$ und damit $$y(x) = y_0 - \frac{1}{2} g \left(\frac{x - x_0}{v_{0}}\right)^2$$

Das ist eine Parabel in der $x$-$y$-Ebene.

7. Python-Programm zum waagerechten Wurf

Das folgende Python-Programm “2512022304_WaagerechterWurf.py” :

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

• wählt Startwerte $x_0$, $y_0$, $v_{0}$ (nur horizontal),

• bestimmt die Flugzeit bis zum Aufprall ($y(t) = 0$),

• erzeugt einen Zeitvektor $t$,

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

• zeichnet:

  • Plot von $x(t)$ und $y(t)$ (Weg-Komponenten),
  • Plot von $v_x(t)$ und $v_y(t)$,
  • Plot von $a_x(t)$ und $a_y(t)$,
  • zusätzlich die Bahnkurve $y(x)$.

Download “2512022304_WaagerechterWurf.py”

import numpy as np
import matplotlib.pyplot as plt

# Konstante Erdbeschleunigung
g = 9.81  # m/s^2

# Anfangswerte für den waagerechten Wurf
x0 = 0.0     # Startposition x in m
y0 = 20.0    # Starthöhe in m
v0 = 10.0    # Anfangsgeschwindigkeit in m/s (rein horizontal)

# Optional: Benutzereingabe
# x0 = float(input("Startposition x0 in m: "))
# y0 = float(input("Starthöhe y0 in m: "))
# v0 = float(input("Horizontale Startgeschwindigkeit v0 in m/s: "))

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

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

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

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

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

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

# Flugzeit bis zum Boden: y(t_f) = 0
# y0 - 0.5 * g * t_f^2 = 0  ->  t_f = sqrt(2*y0/g)
if y0 <= 0:
    raise ValueError("y0 muss > 0 sein, damit der waagerechte Wurf Sinn ergibt.")

t_flight = np.sqrt(2 * y0 / g)

# Zeitvektor
t = np.linspace(0, t_flight, 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 (x(t) und y(t))
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("Waagerechter Wurf: Weg-Zeit-Funktionen")
plt.legend()
plt.grid(True)

# Plot 2: Geschwindigkeit-Zeit-Funktionen (vx(t) und vy(t))
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("Waagerechter Wurf: Geschwindigkeit-Zeit-Funktionen")
plt.legend()
plt.grid(True)

# Plot 3: Beschleunigung-Zeit-Funktionen (ax(t) und ay(t))
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("Waagerechter 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("Waagerechter Wurf: Bahnkurve y(x)")
plt.grid(True)

plt.show()

Mit diesem Code kannst du sehr gut sehen:

• $x(t)$ wächst linear,
• $y(t)$ fällt parabolisch,
• $v_x(t)$ bleibt konstant,
• $v_y(t)$ wird (negativ) immer größer im Betrag,
• $a_x(t) = 0$, $a_y(t) = -g$ konstant.

---