3  Zahlen in Reih und Glied

Die Achillessehne zieht schräg nach hinten-oben an deinem Fersenbein — das hast du in Kapitel 2 am eigenen Fuß getastet. Jetzt eine Frage, die der Pfeil allein nicht beantwortet: Wie viel von diesem Zug wirkt nach hinten, und wie viel nach oben? Dieses Kapitel gibt die zwei Zahlen, mit denen das ausgerechnet wird.

Der Trick ist ein Blickwechsel. Ein Kraftpfeil ist zweierlei zugleich: ein Pfeil mit Richtung und Länge und eine Liste aus zwei Zahlen \((x, y)\). Wer zwischen beiden Sichten wechseln kann, addiert, verdoppelt und zerlegt Kräfte, ohne zu zeichnen — und genau das ist die Grundoperation, aus der später jede Rechnung dieses Buches besteht. Im Studium heißt der Kraftpfeil dann Vektor; ab hier nennen wir ihn so.

Lernziele

Nach diesem Kapitel kannst du

  1. einen Vektor als Kraftpfeil und als Zahlenliste \((x, y)\) lesen und zwischen beiden Darstellungen wechseln,
  2. zwei Vektoren addieren (grafisch als Aneinanderhängen, rechnerisch komponentenweise) und das Ergebnis mit dem Kräfteparallelogramm aus Kapitel 2 vergleichen,
  3. einen Vektor mit einer Zahl skalieren und seinen Betrag über den Satz des Pythagoras berechnen,
  4. eine Kraft in ihre waagerechte und senkrechte Komponente zerlegen — genau das, was das Modell mit dem Achillessehnenzug tut.

3.1 Der Pfeil als zwei Zahlen

Um aus einem Pfeil Zahlen zu machen, brauchen wir einen Bezugsrahmen: ein Koordinatensystem. Seine beiden Richtungen stehen seit Kapitel 1 fest und gelten im ganzen Buch: Die x-Achse zeigt nach vorn (zu den Zehen), die y-Achse nach oben. Ein Schritt nach hinten ist dann ein negatives \(x\), ein Schritt nach unten ein negatives \(y\).

Bleibt der Nullpunkt. Für eine Kraft ist er gleichgültig, und zwar nicht nur für ihre Richtung: Auch ihre beiden Zahlen ändern sich nicht, wenn der Pfeil woanders ansetzt. Darin unterscheidet sich eine Kraft von einem Ort. Ein Ort wird vom Nullpunkt aus gezählt — verschiebt man den Nullpunkt, bekommt derselbe Punkt andere Zahlen. In die Zahlen einer Kraft gehen dagegen nur ihr Betrag und ihre Richtung ein; wo sie angreift, kommt darin nicht vor. Derselbe Zug hat deshalb überall dieselben zwei Zahlen, und wir legen den Nullpunkt in diesem Kapitel bequem in den Angriffspunkt der jeweiligen Kraft. Sobald das Buch dagegen Orte im Knochen benennt, braucht es einen festen Nullpunkt, und der liegt — wie in Kapitel 1 vereinbart — hinten unten am Fersenbein; von dort misst die erste Koordinate nach vorn, die zweite nach oben. „24 Millimeter vorn, 3 Millimeter oben“ ist in dieser Zählung die Stelle an der Unterseite, an der später der Sporn auftaucht. Ab Kapitel 10, wenn aus dem Knochen ein Netz wird, rechnet das Buch mit solchen Ortszahlen.

Damit bekommt jeder Pfeil seine zwei Zahlen: \(x\) ist, wie weit er nach vorn reicht, \(y\), wie weit nach oben. Für den Achillessehnenzug (Betrag 3,5 · Körpergewicht, Zugrichtung 118° gegen die Vorn-Richtung, dieselbe Richtung wie in Kapitel 2) sind das die beiden Zahlen in Abbildung 3.1. Es sind dieselben zwei Zahlen, mit denen das Modell später rechnet.

Bevor das erste Bild entsteht, richten wir das Rechenwerk ein: das Koordinatensystem, die drei Kräfte aus Kapitel 2 mit ihren Angriffspunkten, die Umrechnung in Komponenten und die Zeichenwerkzeuge, die alle Bilder dieses Kapitels benutzen. Die Zelle ist eingeklappt — wer wissen will, woher ein Name kommt, klappt sie auf. Ihre Zahlen holt sie aus dem Zahlenanhang (Anhang A), sie erfindet keine.

Das Rechenwerk dieses Kapitels — zum Nachlesen aufklappen
# --- Gemeinsame Bausteine aller Vektor-Grafiken dieses Kapitels ----------
# Zahlen ausschließlich aus dem Zahlenkanon (wie Kapitel 2): KG = 736 N;
# Achillessehne 3,5 · KG unter 118°, Bodenreaktion 2,5 · KG (90°), Plantarfaszie
# 2,0 · KG (−10°, Kanonrichtung RICHTUNG_FASZIE 0,985/−0,174).
# Koordinatensystem: x nach vorn (+), y nach oben (+); der Winkel φ wird von
# der +x-Achse gegen den Uhrzeigersinn gemessen. Komponenten
# x = Betrag·cos φ, y = Betrag·sin φ — dieselbe Formel wie hinter den Reglern;
# bei jedem Bau des Buches werden beide gegeneinander gehalten.
import json
import pathlib
import sys

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrow

# Zeichenmechanik der Skalierungs-Gerade (Muster 3): der Lehrgedanke bleibt in
# der sichtbaren Zelle, das Matplotlib-Beiwerk liegt in programme/kap03.
sys.path.insert(0, str(pathlib.Path("programme/kap03").resolve()))
from skalierung import zeichne_betrag_ueber_faktor
from addition import zeichne_addition

sys.path.insert(0, "programme/gemeinsam")
import kanon

KG_N = kanon.wert_von("KOERPERGEWICHT")   # Körpergewicht in Newton (Kanon)
MM_PRO_KG = 6.0                  # Pfeillänge: mm je · KG (wie kap02)

FARBE = {"vektor": "#d62728", "x": "#1f77b4", "y": "#2ca02c",
         "betrag": "#7a2b8a", "boden": "#1f77b4", "faszie": "#2ca02c",
         "res": "#7a2b8a", "achse": "#888"}

# Angriffspunkte (mm): auf die echte Kontur projizierte Punkte, AUF der Kontur
# liegend (Konvention Felddarstellungen; wie kap02).
ANS = {"boden": (8.594, 2.237), "achilles": (1.343, 23.278),
       "faszie": (24.065, 3.353)}
RICHT = {"boden": 90.0, "achilles": 118.0, "faszie": -10.0}
BETRAG = {"boden": 2.5, "achilles": 3.5, "faszie": 2.0}

_kontur = json.loads(
    pathlib.Path("../geometrie/kalkaneus_kontur.json").read_text())
KONTUR = np.array(_kontur["punkte"]) * 1000.0     # m -> mm

def kg(x):
    """Betrag in deutscher Kommadarstellung ohne Vorzeichen, z. B. 3,50."""
    return f"{x:.2f}".replace(".", ",")

def sgn(x):
    """Signierte Kommadarstellung, z. B. +3,09 oder −1,64 (−0,00 wird +0,00)."""
    if abs(x) < 5e-3:
        x = 0.0
    return ("+" if x >= 0 else "−") + f"{abs(x):.2f}".replace(".", ",")

def zerlege(betrag, grad):
    """x-/y-Komponente eines Vektors (dieselbe Formel wie hinter den Reglern)."""
    r = np.deg2rad(grad)
    return betrag * np.cos(r), betrag * np.sin(r)

def kontur_und_orientierung(ax):
    """Fersenschnitt füllen und mit Orientierung (hinten/vorn/oben) versehen."""
    ax.fill(KONTUR[:, 0], KONTUR[:, 1], color="#f0e2d0", ec="#a9825f",
            lw=1.6, zorder=1)
    ax.text(46, 9, "Fersenbein", fontsize=8, color="#8a6a4a", ha="center",
            zorder=2)
    ax.text(-13, 47, "hinten (Ferse)", fontsize=9, color="#666")
    ax.text(48, 47, "vorn (Zehen)", fontsize=9, color="#666")

def koordkreuz(ax, o, laenge=13.0):
    """Kleines Koordinatenkreuz am Ursprung o: x nach vorn, y nach oben."""
    ax.add_patch(FancyArrow(o[0], o[1], laenge, 0, width=0.12, head_width=2.2,
                            length_includes_head=True, color=FARBE["achse"],
                            zorder=4))
    ax.add_patch(FancyArrow(o[0], o[1], 0, laenge, width=0.12, head_width=2.2,
                            length_includes_head=True, color=FARBE["achse"],
                            zorder=4))
    ax.text(o[0] + laenge + 1, o[1] - 1, "x (vorn)", fontsize=8,
            color=FARBE["achse"])
    ax.text(o[0] + 1, o[1] + laenge + 1, "y (oben)", fontsize=8,
            color=FARBE["achse"])

# Achillessehnen-Komponenten einmal berechnen (Kanonzahlen, für den Fließtext).
ACH_X, ACH_Y = zerlege(BETRAG["achilles"], RICHT["achilles"])
Code
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrow

fig, ax = plt.subplots(figsize=(7.2, 4.6))
kontur_und_orientierung(ax)

o = np.array(ANS["achilles"])
dx, dy = ACH_X * MM_PRO_KG, ACH_Y * MM_PRO_KG
spitze = o + np.array([dx, dy])

koordkreuz(ax, o, laenge=12.0)
# Der Vektor selbst.
ax.add_patch(FancyArrow(o[0], o[1], dx, dy, width=0.5, head_width=3.2,
                        length_includes_head=True, color=FARBE["vektor"],
                        zorder=5))
# Projektionen (gestrichelt) = die zwei Zahlen.
ax.plot([o[0], spitze[0]], [o[1], o[1]], "--", color=FARBE["x"], lw=1.6)
ax.plot([spitze[0], spitze[0]], [o[1], spitze[1]], "--", color=FARBE["y"], lw=1.6)
ax.plot(o[0], o[1], "o", color="#333", ms=6, zorder=6)

ax.text((o[0] + spitze[0]) / 2, o[1] - 3.4,
        f"x = {sgn(ACH_X)} · KG", color=FARBE["x"], fontsize=10, ha="center",
        fontweight="bold")
ax.text(spitze[0] - 1.2, (o[1] + spitze[1]) / 2,
        f"y = {sgn(ACH_Y)} · KG", color=FARBE["y"], fontsize=10, va="center",
        ha="right", fontweight="bold")

# Die Zahlenliste als Kasten daneben.
ax.text(40, 30,
        "Achillessehne\n"
        f"Pfeil:  3,5 · KG unter 118°\n"
        f"Liste:  ({sgn(ACH_X)};  {sgn(ACH_Y)}) · KG",
        fontsize=10, family="monospace",
        bbox=dict(boxstyle="round", fc="#fbf3e8", ec="#a9825f"))

# Newton-Maßstab.
ax.plot([-19, -19 + MM_PRO_KG], [4, 4], color="#333", lw=2)
ax.text(-19, 6.4, f"1 · KG ≈ {KG_N:.0f} N", fontsize=8, color="#333")

ax.set_xlim(-22, 70)
ax.set_ylim(0, 52)
ax.set_aspect("equal")
ax.axis("off")
plt.tight_layout()
plt.show()
Abbildung 3.1: Derselbe Kraftpfeil, zweimal gelesen: als Pfeil der Achillessehne (3,5 · KG, Richtung 118°) über dem Fersenschnitt und als Zahlenliste (x, y). Das Koordinatensystem sitzt im Angriffspunkt, x zeigt nach vorn, y nach oben. Die gestrichelten Linien sind die beiden Zahlen des Vektors: x ≈ −1,64 · KG (nach hinten), y ≈ +3,09 · KG (nach oben).

Deutung. Ein negatives \(x\) heißt „nach hinten”, ein positives \(y\) „nach oben”. Die Achillessehne zieht also mit 1,64 · KG nach hinten und gleichzeitig mit 3,09 · KG nach oben — beides steckt in dem einen schrägen Pfeil. Der Pfeil zeigt es dem Auge; die Liste \((-1{,}64;\ +3{,}09)\) macht es rechenbar. Ab jetzt ist ein Vektor für uns beides.

Eine Verabredung noch: Ein Vektor bringt seine Einheit mit. Hier zählen die zwei Zahlen Vielfache des Körpergewichts, die Bilder messen in Millimetern, später kommen Kilopascal dazu. Den vier Rechenregeln dieses Kapitels ist das gleichgültig — sie gelten für Zahlenpaare, ganz gleich, was die Paare messen.

Diesen Blickwechsel schreibt man auch als reines Python auf — eine Zahlenliste ist im Rechner ein Paar, ein Vektor ist zwei Zahlen mit Namen:

Vom Pfeil zur Zahlenliste (x, y)
def vektor_aus_pfeil(betrag, richtung_grad):
    """Aus Pfeil (Betrag, Richtung) die Zahlenliste (x, y) machen.

    betrag:        Laenge des Pfeils, in Vielfachen des Koerpergewichts (KG).
    richtung_grad: Winkel gegen die Vorn-Richtung, in Grad.
    Rueckgabe:     das Zahlenpaar (x, y) des Vektors.

    Dies ist die einzige Umrechnung Betrag+Richtung -> Komponenten im
    sichtbaren Rechenwerk; die Zerlegung weiter unten ruft sie wieder auf.
    """
    import math
    winkel_bogen = richtung_grad * math.pi / 180.0
    x = betrag * math.cos(winkel_bogen)
    y = betrag * math.sin(winkel_bogen)
    return (x, y)

Auf den Achillessehnenzug angewandt, liefert sie die beiden Zahlen, die im Bild an den gestrichelten Linien standen:

Tabelle 3.1: Der Achillessehnenzug (3,5 · KG unter 118°) als Zahlenliste \((x, y)\), gerechnet mit vektor_aus_pfeil.
Anteil Richtung Wert (· KG)
waagerecht \(x\) nach hinten −1,64
senkrecht \(y\) nach oben +3,09

Deutung unter der Tabelle. Dieselben zwei Zahlen wie im Bild. Der Rechner kennt den Pfeil nicht — er kennt nur die Liste. Alles Weitere in diesem Kapitel sind Rechnungen mit solchen Listen.

3.2 Zwei Vektoren addieren

In Kapitel 2 haben wir zwei Kräfte mit dem Kräfteparallelogramm zusammengesetzt — als Bild, mit Zirkel und Lineal (Abbildung 2.4). Mit Zahlenlisten geht dasselbe ohne Zeichnen: Man addiert die Vektoren komponentenweise, \(x\) zu \(x\) und \(y\) zu \(y\). Grafisch heißt das, den zweiten Pfeil an die Spitze des ersten zu hängen; der Weg vom Start zur letzten Spitze ist die Summe.

Nehmen wir die Bodenreaktionskraft (2,5 · KG, gerade nach oben) und den Zug der Plantarfaszie (2,0 · KG, nach vorn-unten — 10° unter der +x-Achse, daher das kleine negative \(y\)). Das Addieren selbst ist eine einzige Zeile — dieselbe Rechnung, die ein Computer für Tausende Kräfte gleichzeitig macht. Wir hängen beide Pfeile Spitze an Fuß aneinander; die Zeichnung übernimmt eine Hilfsfunktion des Kapitels, sichtbar bleibt die Addition. Zu sehen ist der violette Summenpfeil vom Start zur letzten Spitze (Abbildung 3.2):

Zwei Vektoren komponentenweise addieren — und die Summe zeichnen
def vektor_addieren(a, b):
    """Zwei Vektoren komponentenweise addieren: x zu x, y zu y.

    a, b:      je ein Zahlenpaar (x, y).
    Rueckgabe: das Summenpaar (x1 + x2, y1 + y2).
    """
    x = a[0] + b[0]
    y = a[1] + b[1]
    return (x, y)

boden = vektor_aus_pfeil(2.5, 90.0)      # Bodenreaktion: (0,00; 2,50) · KG
faszie = vektor_aus_pfeil(2.0, -10.0)    # Plantarfaszie: (1,97; −0,35) · KG
summe = vektor_addieren(boden, faszie)
print(f"Boden + Faszie = {summe[0]:+.2f}, {summe[1]:+.2f}  (in · KG)")

zeichne_addition(boden, faszie, summe)   # Pfeile aneinanderhängen, Summe violett
Boden + Faszie = +1.97, +2.15  (in · KG)
Abbildung 3.2: Zwei Kräfte addieren, ohne zu zeichnen: Bodenreaktion (2,5 · KG nach oben) und Plantarfaszie (2,0 · KG nach vorn-unten, 10° unter der +x-Achse) werden Spitze an Fuß aneinandergehängt (blau, dann grün). Der violette Pfeil vom Start zur letzten Spitze ist die Summe — dieselbe Resultierende wie im Kräfteparallelogramm aus Kapitel 2. Rechts die komponentenweise Rechnung: x zu x, y zu y.

Deutung. Die Summe zeigt nach vorn oben und hat den Betrag 2,92 · KG — genau die Resultierende, die das Parallelogramm in Kapitel 2 als Diagonale lieferte (dort auf ≈ 2,9 · KG gerundet). Beachte: \(2{,}92\) ist nicht \(2{,}5 + 2{,}0 = 4{,}5\). Weil die beiden Kräfte in verschiedene Richtungen zeigen, addieren sich ihre Beträge nicht — wohl aber ihre Komponenten, jede für sich. Das ist der ganze Gewinn der Zahlenliste.

Ein Vorbehalt wie schon in Kapitel 2: Diese Summe ist die Nettokraft, die Gesamtbilanz der beiden Kräfte. Boden und Faszie greifen aber an verschiedenen Punkten des Fersenbeins an — für die Wirkung im Knochen bleibt dieser Unterschied wichtig, den ein einziger Summenpfeil nicht sieht. Wir addieren hier die Vektoren, nicht die Angriffspunkte.

Zum Selberändern — dieselbe Addition im Browser, und sie antwortet mit einem Bild: Der blaue Bodenpfeil startet im Ursprung, der grüne Faszienpfeil hängt an seiner Spitze, der violette gestrichelte Pfeil ist die Summe vom Start zur letzten Spitze. Ändere die beiden Zahlenpaare — verdopple etwa die Faszie, indem du ihre zwei Zahlen jeweils mal zwei nimmst — und führe die Zelle aus: Der Summenpfeil legt sich sichtbar flacher, weil sein waagerechter Anteil wächst.

3.3 Der Betrag: die Länge aus x und y

Bisher kannten wir den Betrag als das, was wir vorgeben. Aus einer Zahlenliste lässt er sich aber auch zurückrechnen — er ist die Länge des Pfeils, und die liefert der Satz des Pythagoras. \(x\) und \(y\) sind die beiden Katheten eines rechtwinkligen Dreiecks, der Betrag ist die Hypotenuse:

\[ \lvert \vec v \rvert \;=\; \sqrt{x^2 + y^2}. \]

Für die Achillessehne, deren Liste wir oben abgelesen haben, ist das die Probe aufs Exempel — die Zahlen müssen den Betrag 3,5 · KG zurückgeben:

\[ \sqrt{(-1{,}64)^2 + (+3{,}09)^2} \;=\; \sqrt{2{,}69 + 9{,}55} \;=\; \sqrt{12{,}24} \;\approx\; 3{,}50 \ \text{· KG}. \]

Im mitlesbaren Code ist das eine einzige Zeile Rechnung: beide Zahlen quadrieren, addieren, die Wurzel ziehen.

Der Betrag aus den zwei Zahlen (Satz des Pythagoras)
def betrag_pythagoras(v):
    """Die Laenge eines Vektors aus seinen zwei Zahlen (Satz des Pythagoras).

    v:         das Zahlenpaar (x, y).
    Rueckgabe: der Betrag |v| = Wurzel aus (x*x + y*y).
    """
    x = v[0]
    y = v[1]
    return (x * x + y * y) ** 0.5

Setzt man die abgelesene Liste ein, muss der vorgegebene Betrag zurückkommen:

Tabelle 3.2: Die Probe aufs Exempel: aus der Zahlenliste des Achillessehnenzugs wird über den Satz des Pythagoras wieder ihr Betrag.
Größe Wert (· KG)
\(x\) (nach hinten) −1,64
\(y\) (nach oben) +3,09
Betrag aus \(x\) und \(y\) 3,50
Vorgabe aus dem Zahlenanhang 3,50

Deutung unter der Tabelle. Der Weg über die Komponenten und zurück zum Betrag schließt sich: Aus 3,5 · KG unter 118° wurde die Liste \((-1{,}64;\ +3{,}09)\), und aus der Liste wird wieder 3,5 · KG. Pfeil und Zahlen sind wirklich dasselbe, nur zweimal aufgeschrieben.

3.4 Einen Vektor skalieren

Eine Kraft verdoppeln heißt: den Pfeil doppelt so lang machen, die Richtung behalten. In Zahlen ist das eine Skalierung — man multipliziert jede Komponente mit derselben Zahl, dem Skalar. Aus \((x, y)\) wird \((k\cdot x,\ k\cdot y)\). Die Richtung bleibt, die Länge ändert sich — aber in welchem Takt?

WichtigVorhersage-Punkt

Bevor du schiebst: Der Regler streckt einen Grundpfeil (1 · KG) um einen Faktor von 0 bis 3. Beide Zahlen wachsen mit dem Faktor, der Betrag aber steht unter einer Wurzel. Wächst er trotzdem im Gleichschritt mit dem Faktor, oder krümmt die Wurzel die Kurve? Lege dich fest.

Deutung. Dreifache Kraft, dreifacher Betrag, und keine Krümmung. Der Grund steht in der Betragsformel: Multipliziert man beide Zahlen mit demselben Faktor \(k\), so steht unter der Wurzel \(k^2 \cdot (x^2 + y^2)\), und \(k\) zieht sich als Ganzes heraus:

\[ \sqrt{(k x)^2 + (k y)^2} \;=\; k\,\sqrt{x^2 + y^2} \;=\; k\,\lvert \vec v\rvert \qquad (k \ge 0,\ \text{der Regler reicht von } 0 \text{ bis } 3). \]

Der Betrag wächst also genau wie der Faktor — nur beim Skalieren, denn nur dort werden beide Zahlen mit derselben Zahl vervielfacht. Skalieren streckt oder staucht den Pfeil, ohne seine Richtung zu ändern.

Im mitlesbaren Code ist das Skalieren eine Multiplikation je Komponente. Der Grundpfeil kommt ungerundet aus vektor_aus_pfeil, damit die Zahlen exakt bleiben. Statt die Zahlenliste nur abzudrucken, messen wir für viele Faktoren zwischen 0 und 3 die Länge des gestreckten Pfeils — dieselbe Länge, die eben an den Reglerpfeilen stand — und tragen sie über dem Faktor auf. Die Zeichnung selbst übernimmt eine Hilfsfunktion des Kapitels; sichtbar bleibt die Rechnung. Zu sehen ist danach kein Pfeilbild mehr, sondern eine einzige Linie:

Einen Vektor strecken und den Betrag über dem Faktor auftragen
def vektor_skalieren(v, faktor):
    """Vektor strecken: jede Komponente mal faktor -> (faktor*x, faktor*y)."""
    x = faktor * v[0]
    y = faktor * v[1]
    return (x, y)

grund = vektor_aus_pfeil(1.0, 118.0)          # Grundpfeil 1 · KG bei 118°

faktoren = []
betraege = []
for schritt in range(0, 61):                  # 0,00 bis 3,00 in feinen Stufen
    k = schritt / 20
    x, y = vektor_skalieren(grund, k)
    faktoren.append(k)
    betraege.append((x * x + y * y) ** 0.5)   # Länge des Pfeils (Pythagoras)

marken = [0.5, 1.0, 2.0, 3.0]                 # vier Faktoren zum Markieren
marken_betraege = []
for k in marken:
    x, y = vektor_skalieren(grund, k)
    marken_betraege.append((x * x + y * y) ** 0.5)

zeichne_betrag_ueber_faktor(faktoren, betraege, marken, marken_betraege)
Abbildung 3.3: Der Betrag des Grundpfeils (1 · KG bei 118°) über dem Skalierungsfaktor. Die Punkte markieren vier Faktoren (0,5× · 1× · 2× · 3×); sie liegen alle auf einer Geraden durch den Ursprung. Die Wurzel in der Betragsformel krümmt hier nichts: Doppelter Faktor heißt exakt doppelter Betrag.

Deutung. Die Punkte fallen auf eine Gerade, die durch den Ursprung läuft: Bei Faktor null ist der Betrag null, bei Faktor eins 1 · KG, bei Faktor zwei genau 2 · KG. Verdoppelt man den Faktor, verdoppelt sich der Betrag — kein Knick, keine Krümmung, die der Satz des Pythagoras hineintragen würde. Diese strenge Proportionalität ist die Linearität, an der Kapitel 13 und 14 später das ganze Modell festmachen: doppelte Last, doppelte Antwort.

3.5 Eine Kraft zerlegen

Damit sind wir bei der Kernoperation, um die es dem Modell geht: der Zerlegung — der Umrechnung von Betrag und Richtung in die zwei Komponenten. Das ist genau das, was vektor_aus_pfeil ganz am Anfang schon getan hat; hier bekommt der Vorgang seinen anschaulichen Namen und seine Frage zurück: Wie viel vom Achillessehnenzug wirkt nach hinten, wie viel nach oben?

WichtigVorhersage-Punkt

Bevor du schiebst: Der Regler dreht den Kraftpfeil (feste Länge 3,5 · KG) von 0° bis 360°. Bei welchem Winkel ist die senkrechte Komponente am größten — und ist die waagerechte dann null? Lege dich fest.

Deutung. Am größten wird die senkrechte Komponente bei 90°: Dann zeigt der Pfeil gerade nach oben, \(y = +3{,}5\) · KG, und die waagerechte Zahl ist null. Bei 270° zeigt er gerade nach unten — \(y = -3{,}5\) · KG, das Minimum (die stärkste Wirkung nach unten), die waagerechte wieder null. Dem Betrag nach ist die senkrechte Komponente also bei 90° und 270° am größten, dem Vorzeichen nach einmal nach oben, einmal nach unten. Je schräger der Pfeil, desto mehr teilt sich seine Kraft auf beide Zahlen auf; kein Winkel legt in beide Richtungen zugleich das Maximum.

Abbildung 3.4 hält den Achillessehnenzug als rechtwinkliges Dreieck fest:

Code
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrow

fig, ax = plt.subplots(figsize=(7.2, 4.8))
kontur_und_orientierung(ax)

o = np.array(ANS["achilles"])
dx, dy = ACH_X * MM_PRO_KG, ACH_Y * MM_PRO_KG
spitze = o + np.array([dx, dy])
ecke = o + np.array([dx, 0.0])          # Fußpunkt des senkrechten Anteils

# Waagerechter Anteil (nach hinten) und senkrechter Anteil (nach oben).
ax.add_patch(FancyArrow(o[0], o[1], dx, 0, width=0.4, head_width=2.8,
                        length_includes_head=True, color=FARBE["x"], zorder=4))
ax.add_patch(FancyArrow(ecke[0], ecke[1], 0, dy, width=0.4, head_width=2.8,
                        length_includes_head=True, color=FARBE["y"], zorder=4))
# Der schräge Pfeil (Hypotenuse).
ax.add_patch(FancyArrow(o[0], o[1], dx, dy, width=0.5, head_width=3.2,
                        length_includes_head=True, color=FARBE["vektor"], zorder=5))
# Rechter-Winkel-Markierung an der Ecke.
r = 2.0
ax.plot([ecke[0], ecke[0]], [ecke[1], ecke[1] + r], color="#555", lw=1)
ax.plot([ecke[0], ecke[0] + (r if dx > 0 else -r)], [ecke[1] + r, ecke[1] + r],
        color="#555", lw=1)

ax.text(o[0] + dx / 2, o[1] - 3.6, f"waagerecht {sgn(ACH_X)} · KG",
        color=FARBE["x"], fontsize=9.5, ha="center", fontweight="bold")
ax.text(ecke[0] - 1.5, o[1] + dy / 2, f"senkrecht {sgn(ACH_Y)} · KG",
        color=FARBE["y"], fontsize=9.5, ha="right", va="center", fontweight="bold")
ax.text(2.0, 37.0, "3,5 · KG", color=FARBE["vektor"],
        fontsize=10, ha="left", va="center", fontweight="bold")
ax.plot(o[0], o[1], "o", color="#333", ms=6, zorder=6)

ax.set_xlim(-16, 70)
ax.set_ylim(0, 54)
ax.set_aspect("equal")
ax.axis("off")
plt.tight_layout()
plt.show()
Abbildung 3.4: Zerlegung des Achillessehnenzugs (3,5 · KG, 118°) in seine Komponenten: der schräge Pfeil (rot), sein waagerechter Anteil nach hinten (blau, −1,64 · KG) und sein senkrechter Anteil nach oben (grün, +3,09 · KG) bilden ein rechtwinkliges Dreieck. Der schräge Pfeil ist die Hypotenuse — sein Betrag ist die Wurzel aus der Summe der Quadrate der beiden Katheten.

Deutung. Der schräge Zug und seine zwei geraden Anteile sind dieselbe Kraft — der rote Pfeil und das blau-grüne Dreieck beschreiben genau das eine Ziehen der Sehne. Das Modell rechnet nie mit dem schrägen Pfeil, sondern immer mit den zwei Zahlen: eine für vorn/hinten, eine für oben/unten.

Die Zahlen dahinter liefern Kosinus und Sinus. Aus Betrag und Richtung:

\[ x = \lvert \vec v \rvert \cdot \cos\varphi, \qquad y = \lvert \vec v \rvert \cdot \sin\varphi. \]

In dieser Formel steht kein Ort. Rechts vom Gleichheitszeichen kommen nur der Betrag und der Winkel vor; der Angriffspunkt taucht nirgends auf. Sie liefert deshalb dieselben zwei Zahlen, ob die Sehne nun am Fersenbein zieht oder ob man den Pfeil zum Nachrechnen an den Nullpunkt legt. Für die Wirkung im Knochen bleibt der Angriffspunkt entscheidend — für die Zerlegung selbst spielt er keine Rolle.

Für den Achillessehnenzug (3,5 · KG, 118°):

\[ x = 3{,}5 \cdot \cos 118^\circ \approx -1{,}64\ \text{· KG}, \qquad y = 3{,}5 \cdot \sin 118^\circ \approx +3{,}09\ \text{· KG}. \]

Das ist die Antwort auf die Frage vom Anfang: 1,64 · KG nach hinten, 3,09 · KG nach oben. Gerechnet wird sie von derselben vektor_aus_pfeil wie zu Beginn — Zerlegung ist ihr anschaulicher Name, keine zweite Funktion. Tabelle 3.3 stellt Formel, eingesetzte Zahlen und Ergebnis nebeneinander:

Tabelle 3.3: Die Zerlegung des Achillessehnenzugs, Schritt für Schritt: aus Betrag und Richtung werden über Kosinus und Sinus die beiden Komponenten.
Komponente Rechnung Wert (· KG)
waagerecht \(x\) (nach hinten) 3,50 · cos 118° −1,64
senkrecht \(y\) (nach oben) 3,50 · sin 118° +3,09

Zum Selberändern — dieselbe Zerlegung über den ganzen Winkelkreis, als Bild. Die blaue Kurve ist die waagerechte Komponente \(x\), die grüne die senkrechte \(y\); die Punkte markieren die fünf Winkel aus der Liste. Ändere den Betrag oder die markierten Winkel und führe die Zelle aus — dort, wo eine Kurve die Nulllinie schneidet, verschwindet der zugehörige Anteil:

Dass Richtung und Zahlenpaar wirklich zwei Namen für dasselbe sind, zeigt der Pfeil, wenn er langsam wandert:

Deutung. Der Pfeil behält seine Länge, aber seine zwei Zahlen ändern sich ununterbrochen — mal steckt die Kraft mehr im waagerechten, mal mehr im senkrechten Anteil. Im Modell wandert die Last des Schrittes enger: Dort dreht sich keine der drei Kräfte, es ändert sich nur ihre Mischung (Tabelle 2.2) — und mit ihr das Zahlenpaar ihrer Summe.

WarnungZwei Zahlen verraten die Richtung, nicht den Wirkort

Vermutung: „Ein schräger Zug nach hinten-oben kann unten nichts bewirken — er zieht ja nach oben.”

Warum sie naheliegt: Die Zerlegung scheint es zu bestätigen: Der Achillessehnenzug hat eine senkrechte Komponente nach oben (+3,09 · KG) und eine waagerechte nach hinten (−1,64 · KG) — nach unten zeigt keine der beiden Zahlen.

Was stattdessen gilt: Ob am Knochen irgendwo mehr Druck entsteht, lässt sich aus \(x\) und \(y\) allein gar nicht entscheiden. Die zwei Zahlen sagen, wohin die Kraft zieht — nicht, was sie in einem ausgedehnten Knochen anrichtet. Das hängt zusätzlich vom Angriffspunkt ab, von der Lagerung (worauf der Knochen ruht) und vom Gleichgewicht aller Kräfte zusammen. Genau diese Rechnung macht erst Teil IV, wenn aus dem Knochen ein Netz wird. Zahlen decken die Richtung auf; wo eine Kraft wirkt, ist die nächste — und andere — Frage.

3.6 Auch ein Weg ist ein Vektor

Bisher waren alle Vektoren dieses Kapitels Kräfte. Ein Vektor ist aber nur ein Pfeil mit Richtung und Länge, und Pfeile gibt es für mehr als Kräfte. Drückt der Boden gegen die Ferse, dann rückt jeder Punkt des Knochens ein kleines Stück von seinem alten Platz: nach oben, nach vorn, schräg. Dieses Stück hat eine Richtung und eine Länge — es ist ein Vektor, nur gemessen in Millimetern statt in Vielfachen des Körpergewichts. Wir nennen ihn Verschiebung und schreiben ihn genau wie eine Kraft als Zahlenliste: \(\vec u = (u_x,\ u_y)\), erste Zahl nach vorn, zweite nach oben. Alles, was dieses Kapitel gezeigt hat — addieren, skalieren, den Betrag ziehen, zerlegen —, gilt für sie unverändert.

Ein Unterschied ist trotzdem entscheidend, und er trägt den ganzen Rest des Buches: Die Kraft ist gegeben. Betrag und Richtung stehen im Zahlenanhang, und wir haben sie oben in ihre zwei Zahlen zerlegt. Die Verschiebung ist gesucht. Niemand sagt uns, um welchen Bruchteil eines Millimeters die hintere Tuberwand nachgibt, wenn die Sehne zieht; das muss gerechnet werden. Abbildung 3.5 zeigt, wonach dabei gefragt wird — den Pfeil, dessen zwei Zahlen wir noch nicht kennen.

Code
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrow

fig, ax = plt.subplots(figsize=(7.2, 4.6))
kontur_und_orientierung(ax)

vorher = np.array(ANS["achilles"])
weg = np.array([-9.0, 6.0])                 # schematisch, stark überhöht
nachher = vorher + weg

koordkreuz(ax, (-22.0, 4.0), laenge=8.0)    # die Richtungen zur Erinnerung
# Die zwei Zahlen der Verschiebung, wie beim Kraftpfeil gestrichelt.
ax.plot([vorher[0], nachher[0]], [vorher[1], vorher[1]], "--",
        color=FARBE["x"], lw=1.6, zorder=4)
ax.plot([nachher[0], nachher[0]], [vorher[1], nachher[1]], "--",
        color=FARBE["y"], lw=1.6, zorder=4)
ax.add_patch(FancyArrow(vorher[0], vorher[1], weg[0], weg[1], width=0.5,
                        head_width=3.0, length_includes_head=True,
                        color=FARBE["res"], zorder=7))
ax.plot(vorher[0], vorher[1], "o", mfc="white", mec="#333", ms=9, mew=1.6,
        zorder=8)
ax.plot(nachher[0], nachher[1], "o", color="#333", ms=8, zorder=8)

ax.text((vorher[0] + nachher[0]) / 2, vorher[1] - 1.6, "$u_x$",
        color=FARBE["x"], fontsize=11, ha="center", va="top",
        fontweight="bold")
ax.text(nachher[0] - 1.2, (vorher[1] + nachher[1]) / 2, "$u_y$",
        color=FARBE["y"], fontsize=11, ha="right", va="center",
        fontweight="bold")
ax.text(-23.0, 40.0, "Verschiebung $\\vec u = (u_x,\\, u_y)$, in mm",
        color=FARBE["res"], fontsize=10.5, ha="left", va="center",
        fontweight="bold")
ax.text(nachher[0] - 2.5, nachher[1] + 4.2, "nach der Belastung", fontsize=9,
        color="#555", ha="left", va="center")
ax.text(vorher[0] + 2.2, vorher[1] - 0.4, "vorher", fontsize=9,
        color="#555", ha="left", va="center")

ax.set_xlim(-26, 70)
ax.set_ylim(0, 54)
ax.set_aspect("equal")
ax.axis("off")
plt.tight_layout()
plt.show()
Abbildung 3.5: Auch ein Weg ist ein Vektor: derselbe Knochenpunkt an der hinteren Tuberwand vor der Belastung (heller Kreis) und danach (dunkler Punkt). Der violette Pfeil dazwischen ist die Verschiebung; ihre zwei gestrichelten Zahlen heißen uₓ (nach vorn/hinten) und u_y (nach oben/unten), gemessen in Millimetern. Die Pfeillänge ist schematisch und stark überhöht — wie weit der Punkt wirklich wandert, rechnet erst Teil IV. Rechter Fuß von außen; hinten links, vorn rechts, oben ↑.

Deutung. Zwei Pfeile, dieselbe Schreibweise, entgegengesetzte Rolle: Der rote Kraftpfeil weiter oben ist die Vorgabe, der violette Wegpfeil hier die Antwort. Ein Punkt des Knochens hat nicht eine Verschiebung, sondern zwei Zahlen — und jeder Punkt seine eigenen. Kapitel 4 stellt deshalb die Frage, die von hier an das ganze Buch antreibt, und es stellt sie andersherum: Wenn ich die Verschiebung kenne, welche Kraft gehört dazu? Was diese Übersetzung leistet, ist eine Tabelle — die Matrix —, und Verschiebungen wie Kräfte gehen als Zahlenlisten in sie hinein und aus ihr heraus.

Übungen

Ü 3.1 (Verstehen). Drei Pfeile sind gegeben: A = 2 · KG nach vorn (0°), B = 2 · KG nach oben (90°), C = 2 · KG nach vorn oben (45°). Schreibe jeden als Zahlenliste \((x, y)\) auf. Vergleiche dann ihre Beträge, ohne zu messen — welcher ist am längsten, welche sind gleich lang?

A \(= (+2{,}00;\ 0{,}00)\), B \(= (0{,}00;\ +2{,}00)\), C \(= (2\cos 45^\circ;\ 2\sin 45^\circ) = (\sqrt 2;\ \sqrt 2) \approx (+1{,}41;\ +1{,}41)\). Alle drei haben denselben Betrag 2,00 · KG — bei A und B sofort ablesbar, bei C exakt über \(\sqrt{(\sqrt 2)^2 + (\sqrt 2)^2} = \sqrt{2 + 2} = 2\). (Rechnet man mit den gerundeten 1,41, kommen 1,99 heraus — ein Rundungsartefakt, kein echter Unterschied.) Gleiche Länge, verschiedene Richtung: genau der Unterschied zwischen einer Kraft und einer bloßen Zahl.

Ü 3.2 (Verändern). Öffne den Kraftwinkel-Regler. Notiere vorher, bei welchem Winkel du die waagerechte und die senkrechte Komponente gleich groß erwartest. Suche den Winkel dann am Regler und lies das Zahlenpaar ab.

Gleich groß und gleichgerichtet (\(x = y\)) sind die Komponenten bei 45° (\(x = y = +2{,}47\) · KG) und bei 225° (\(x = y = -2{,}47\) · KG) — dort gilt \(\cos\varphi = \sin\varphi\). Nur betragsgleich (\(\lvert x\rvert = \lvert y\rvert\), aber mit verschiedenem Vorzeichen) sind sie zusätzlich bei 135° und 315°. Der Zahlenwert ist jeweils \(3{,}5 \cdot \cos 45^\circ \approx 2{,}47\) · KG.

Ü 3.3 (Übertragen). Addiere die Bodenreaktionskraft (2,5 · KG senkrecht nach oben) und den Faszienzug (2,0 · KG nach vorn-unten, Liste \((+1{,}97;\ -0{,}35)\)) und gib die Resultierende als Zahlenliste an. Wie groß ist ihr Betrag, und warum ist er kleiner als \(2{,}5 + 2{,}0\)?

Summe \(= (0{,}00 + 1{,}97;\ 2{,}50 - 0{,}35) = (+1{,}97;\ +2{,}15)\) · KG, Betrag \(\sqrt{1{,}97^2 + 2{,}15^2} \approx 2{,}92\) · KG. Kleiner als 4,5, weil die beiden Kräfte in verschiedene Richtungen zeigen — nur die Komponenten addieren sich, nicht die Beträge.

Roter Faden

Wo kam das schon vor, wo kommt es wieder? Der Kraftpfeil aus Kapitel 2 ist jetzt eine Zahlenliste, und das Kräfteparallelogramm ist eine komponentenweise Addition geworden — die Studiums-Zeile „Kraftpfeil → Vektor” ist damit vorgemerkt für die Tabelle am Ende von Teil II. Dazugekommen ist ein zweiter Vektor, der keine Kraft ist: die Verschiebung, in Millimetern statt in Körpergewichten und, anders als die Kraft, gesucht statt gegeben. Kapitel 4 bündelt viele solche Vektoren zu einer Tabelle, der Matrix, die Verschiebungen in Kräfte übersetzt; das Addieren und Skalieren von hier sind ihre Grundrechenarten. Und die Komponentenzerlegung kehrt bei den Randlasten in Kapitel 12 wieder, wenn Boden, Sehne und Faszie als Zahlenpaare ans Netz gehängt werden.

Was dieses Kapitel NICHT tut

Es führt keine Matrizen ein (das ist Kapitel 4) und behandelt das Skalarprodukt nicht als eigenes Thema. Es bleibt im ebenen Schnitt: zwei Zahlen je Vektor, keine dritte Dimension. Und es behauptet nichts über den Ort, an dem der Knochen wächst — die Zerlegung sagt, wohin eine Kraft zieht, nicht, was sie im ausgedehnten Knochen anrichtet. Ob und wo aus einer Kraft irgendwo Druck entsteht, hängt von Angriffspunkt, Lagerung und Gleichgewicht ab und wird erst in Teil IV mit dem Netz gerechnet.