Modellierung der Außenballistik: Analytik und Python

Analytische und numerische Modellierung der Außenballistik: Drei zentrale Fälle

Das Problem der Außenballistik beschreibt die ebene Bewegung eines Körpers unter Einfluss der Schwerkraft, der mit einer Anfangsgeschwindigkeit in einem Winkel zur Horizontalen abgeschossen wird. Drei Fälle werden betrachtet: keine Luftwiderstandskraft, linearer Widerstand nach dem Gesetz von Stokes und quadratischer Widerstand gemäß Newtons Gesetz. Analytische Lösungen werden durch numerische Methoden ergänzt, um realistische Simulationen zu ermöglichen.

Im ersten Fall – ohne Widerstand – ist die Bahn eine Parabel. Für v₀ = 20 m/s und α = 30° ergeben sich Reichweite und maximale Höhe aus einfachen Formeln:

x(t) = v₀ cos(α) t

y(t) = v₀ sin(α) t - (g t²)/2

Linearer Widerstand: Gesetz von Stokes

Bei linearem Widerstand ist die Kraft proportional der Geschwindigkeit: F = -k v. Die Differentialgleichungen lauten:

m dv_x/dt = -k v_x

m dv_y/dt = -m g - k v_y

Die Lösung liefert exponentielle Abhängigkeiten der Geschwindigkeit:

v_x(t) = v₀ cos(α) e^(-kt/m)

v_y(t) = (v₀ sin(α) + (m g)/k) e^(-kt/m) - (m g)/k

Durch Integration dieser Gleichungen erhält man y(x). Für v₀ = 70 m/s, α = 55°, k = 0.04 kg/s und m = 0.5 kg wird die Bahn asymmetrisch und die Reichweite sinkt im Vergleich zum idealen Fall deutlich.

Quadratischer Widerstand: Newtonsches Gesetz

Bei hohen Geschwindigkeiten dominiert der quadratische Widerstand: F = -k v². Das System von gewöhnlichen Differentialgleichungen lautet:

dv_x/dt = -k v v_x

dv_y/dt = -g - k v v_y

wobei v = √(v_x² + v_y²). Leonhard Euler löste dieses System bereits im 18. Jahrhundert analytisch. Heute verwendet man numerische Integration mittels Runge-Kutta-Verfahren 4–5.

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp

class BallisticsSimulator:
    def __init__(self):
        self.g = 9.81
        self.rho = 1.225

    def calculate_k(self, diameter, mass, Cd=0.3):
        A = np.pi * (diameter / 2) ** 2
        k = (Cd * self.rho * A) / (2 * mass)
        return k

    def equations_of_motion(self, t, state, k):
        x, vx, y, vy = state
        v = np.sqrt(vx**2 + vy**2)
        ax = -k * v * vx
        ay = -self.g - k * v * vy
        return [vx, ax, vy, ay]

    def simulate(self, v0, angle_deg, x0=0, y0=0,
              diameter=0.1, mass=10, Cd=0.3,
              t_max=100, dt=0.01):
        k = self.calculate_k(diameter, mass, Cd)
        angle_rad = np.radians(angle_deg)
        vx0 = v0 * np.cos(angle_rad)
        vy0 = v0 * np.sin(angle_rad)
        initial_state = [x0, vx0, y0, vy0]
        t_span = (0, t_max)
        t_eval = np.arange(0, t_max, dt)
        solution = solve_ivp(
            self.equations_of_motion,
            t_span,
            initial_state,
            args=(k,),
            t_eval=t_eval,
            method='RK45'
        )
        t = solution.t
        x = solution.y[0]
        y = solution.y[2]
        fall_index = np.where(y < 0)[0]
        if len(fall_index) > 0:
            fall_index = fall_index[0]
            t = t[:fall_index + 1]
            x = x[:fall_index + 1]
            y = y[:fall_index + 1]
        return t, x, y, k

    def plot_trajectory(self, t, x, y, k, v0, angle):
        plt.figure(figsize=(12, 8))
        plt.plot(x, y, 'b-', linewidth=2, label='Bahnkurve')
        plt.scatter(x[0], y[0], color='red', s=100, zorder=5, label='Start')
        plt.scatter(x[-1], y[-1], color='green', s=100, zorder=5, label='Aufprall')
        plt.xlabel('Entfernung, m', fontsize=12)
        plt.ylabel('Höhe, m', fontsize=12)
        plt.title(f'Schussbahn\nV₀ = {v0} m/s, Winkel = {angle}°, k = {k:.6f}',
                  fontsize=14)
        plt.grid(True, alpha=0.3)
        plt.legend()
        plt.axis('equal')
        plt.show()

    def print_results(self, t, x, y):
        print("=== SIMULATIONSERGEBNISSE ===")
        print(f"Reichweite: {x[-1]:.2f} m")
        print(f"Maximale Höhe: {max(y):.2f} m")
        print(f"Flugzeit: {t[-1]:.2f} s")

# Beispiel: v0=250 m/s, Winkel=60°, d=0.2 m, m=20 kg

Für v₀ = 250 m/s, α = 60°, Durchmesser 20 cm, Masse 20 kg und Cd = 0.3 wird der Koeffizient k nach k = (Cd ρ A)/(2m) berechnet, wobei A die Querschnittsfläche ist. Die Funktion solve_ivp mit dem RK45-Verfahren gewährleistet eine hohe Genauigkeit bis zum Aufprall (y = 0).

Simulationsparameter und Ergebnisse

Wichtige Eingabeparameter:

• Anfangsgeschwindigkeit v₀: 20–250 m/s
• Abschusswinkel α: 30–60°
• Masse m: 0.5–20 kg
• Durchmesser: 10–20 cm
• Cd: 0.3 (typischer Wert)
• k: automatisch berechnet

Ergebnisse für den quadratischen Fall:

• Flugreichweite: ~10–20 km (abhängig von Parametern)
• Maximalhöhe: 5–15 km
• Flugdauer: 50–100 Sekunden
• Endgeschwindigkeit: nahe der Grenzgeschwindigkeit

Der Vergleich der Fälle zeigt eine Reduktion der Reichweite um 30–50 %, wenn Luftwiderstand berücksichtigt wird.

Schlüsselerkenntnisse

• Kein Widerstand → parabolische Bahn; maximale Reichweite bei α = 45°.
• Gesetz von Stokes gilt für niedrige Geschwindigkeiten (<30 m/s), führt zu exponentiellem Verlauf.
• Newtonsches Gesetz ist Standard für Artillerie und erfordert numerische Lösung von ODEs.
• Python-Code mit scipy.integrate ist vielseitig und leicht an reale Cd- und ρ-Werte anzupassen.

— Editorial Team