In Kapitel 3 ist aus dem Kraftpfeil eine Zahlenliste geworden, ein Vektor — und am Ende jenes Kapitels stand die Verschiebung \(\vec u = (u_x, u_y)\) gleichberechtigt daneben: die Kraft gegeben, der Weg gesucht. Jetzt sehen wir uns nicht eine einzelne Kraft an, sondern zwei Punkte, zwischen denen etwas Nachgiebiges sitzt. Stell dir zwei Federn in einer Reihe vor: links an der Wand festgemacht, rechts ziehst du. Dazwischen ein Punkt, der frei hängt. Verschiebst du diesen mittleren Punkt um eine Wegeinheit — welche Kraft brauchst du dafür, und welche Kraft spürt der Endpunkt?
Mit einer einzigen Zahl kommt man nicht aus. Eine Verschiebung an einer Stelle erzeugt Kraft an mehreren Stellen zugleich, weil die Federn die Punkte koppeln. Was diese vielen Zahlen ordnet — welche Verschiebung welche Kraft an welchem Punkt macht — ist eine Tabelle. Im Studium heißt sie Matrix, und die besondere Matrix dieses Kapitels, die Verschiebungen in Kräfte übersetzt, heißt Steifigkeitsmatrix. Sie ist das Herzstück der ganzen Methode: Genau diese Größe stellt das Fersenmodell später für Tausende Knoten auf.
Warum dafür ausgerechnet Federn herhalten müssen, sei gleich gesagt: Jedes Dreieck des Netzes wird sich ab Kapitel 10 genau so verhalten wie eine Feder zwischen seinen drei Ecken — verschiebt man eine Ecke, entsteht an allen Ecken Kraft. Die Federkette ist die eindimensionale Übung dafür, klein genug, dass man jede einzelne Zahl von Hand nachrechnen kann.
Lernziele
Nach diesem Kapitel kannst du
eine Matrix als Tabelle lesen, die einen Verschiebungsvektor in einen Kraftvektor übersetzt (Richtung: Verschiebung → Kraft),
das Produkt „Matrix mal Vektor” von Hand ausrechnen und als Bündel von gewichteten Summen deuten,
die Steifigkeitsmatrix eines Zwei-Feder-Systems selbst aufstellen und ihre Symmetrie erklären,
ablesen, was ein Diagonaleintrag und was ein Nebendiagonaleintrag bedeutet (Eigensteifigkeit gegenüber Kopplung der Knoten).
Bevor die erste Grafik entsteht, richten wir das Rechenwerk ein: das Zwei-Feder-System mit seinen zwei didaktischen Steifigkeiten, die Zeichenwerkzeuge für Matrizen, Federn und Kraftpfeile und die deutsche Zahlendarstellung, die alle Bilder und Tabellen dieses Kapitels benutzen. Die Zelle ist eingeklappt — wer wissen will, woher ein Name kommt, klappt sie auf. Sie führt keine Zahl aus dem Zahlenanhang: Die Steifigkeiten sind frei gewählte Lehreinheiten, damit man jede Zahl von Hand nachrechnen kann.
Das Rechenwerk dieses Kapitels — Federsystem und Zeichenwerkzeuge, zum Nachlesen aufklappen
# --- Gemeinsame Bausteine aller Grafiken dieses Kapitels ------------------# DIDAKTISCHE Lehreinheiten, KEINE Kanonzahlen: die Federsteifigkeiten# sind frei gewählte kleine Werte in „Kraft je Wegeinheit", damit man alles von# Hand nachrechnen kann. Fest: k1 = 2, k2 = 1 (der Regler variiert k2).# Verschiebungen in „Wegeinheiten". Vorzeichenlogik von f = K·u: f ist die# äußere Kraft, die die Verschiebung u hält; Zugkraft einer Feder = Steifigkeit# mal Dehnung. Matrixaufbau und Produkt identisch mit js/kap04_matrix.js und der# Werkbank; beide werden gegeneinander geprüft.import pathlibimport sysimport numpy as npimport matplotlib.pyplot as plt# Zeichenmechanik der Matrix-Landkarte (Muster 3): der Lehrgedanke — welche# Bedeutung jeder Eintrag hat — bleibt in der sichtbaren Zelle, das# Matplotlib-Beiwerk liegt in programme/kap04.sys.path.insert(0, str(pathlib.Path("programme/kap04").resolve()))from landkarte import zeichne_landkarteK1, K2 =2, 1# Lehreinheiten (didaktisch, NICHT aus dem Kanon)FARBE = {"diagonale": "#b3541e", "kopplung": "#1f77b4", "null": "#9aa0a6","aendert": "#fdf0c8", "feder1": "#7a2b8a", "feder2": "#2ca02c","knoten": "#333", "kraft": "#d62728", "wand": "#777", "achse": "#888"}def bau_K(k1, k2):"""Steifigkeitsmatrix des Zwei-Feder-Systems (dieselbe Formel wie Werkbank und JS). Rueckgabe: 3x3-Liste."""return [[k1, -k1, 0], [-k1, k1 + k2, -k2], [0, -k2, k2]]def mat_vek(K, u):"""Matrix-Vektor-Produkt f = K*u (wie Werkbank und JS)."""return [sum(K[i][j] * u[j] for j inrange(3)) for i inrange(3)]def komma(x):"""Deutsche Kommadarstellung, Ganzzahlen ohne Nachkomma; Minuszeichen −.""" r =round(x)ifabs(x - r) <1e-9:returnstr(int(r)).replace("-", "−")returnf"{x:.1f}".replace("-", "−").replace(".", ",")def sgn(x):"""Signierte Kommadarstellung, z. B. +1 oder −2 (−0 wird +0)."""ifabs(x) <5e-3: x =0.0return ("+"if x >=0else"−") + komma(abs(x))def landkarten_farbe(i, j, v):if i == j:return FARBE["diagonale"]ifabs(v) <5e-3:return FARBE["null"]return FARBE["kopplung"]def matrix_grafik(ax, x0, y0, M, zell_farbe=None, aendert=None, leer=None, cw=1.0, ch=1.0, fs=15):"""Eine Matrix mit eckigen Klammern zeichnen; Zeile i wächst nach unten.""" n, m =len(M), len(M[0])for i inrange(n):for j inrange(m): cx, cy = x0 + j * cw, y0 - i * chif aendert and (i, j) in aendert: ax.add_patch(plt.Rectangle((cx - cw /2, cy - ch /2), cw, ch, color=FARBE["aendert"], zorder=0))if leer and leer(i, j): ax.text(cx, cy, "·", ha="center", va="center", color="#bbb", fontsize=fs, zorder=3)else: col = zell_farbe(i, j, M[i][j]) if zell_farbe else"#222" ax.text(cx, cy, komma(M[i][j]), ha="center", va="center", color=col, fontsize=fs, zorder=3, fontfamily="monospace") left, right = x0 - cw /2-0.14, x0 + (m -1) * cw + cw /2+0.14 top, bot = y0 + ch /2+0.06, y0 - (n -1) * ch - ch /2-0.06for bx, d in ((left, 1), (right, -1)): ax.plot([bx, bx +0.14* d], [top, top], color="#333", lw=1.6) ax.plot([bx, bx], [top, bot], color="#333", lw=1.6) ax.plot([bx, bx +0.14* d], [bot, bot], color="#333", lw=1.6)def feder(ax, xa, xb, y, farbe, amp=0.13, windungen=6):"""Eine Feder als Zickzack zwischen xa und xb auf Höhe y.""" start, ende = xa + (xb - xa) *0.14, xb - (xb - xa) *0.14 xs, ys = [xa, start], [y, y]for k inrange(windungen +1): xs.append(start + (ende - start) * k / windungen) ys.append(y + (amp if k %2==0else-amp)) xs += [ende, xb] ys += [y, y] ax.plot(xs, ys, color=farbe, lw=1.8, zorder=3)def pfeil(ax, x, y, laenge, farbe, breite=2.2):"""Waagerechter Kraftpfeil ab (x, y); Vorzeichen = Richtung."""ifabs(laenge) <1e-6:return ax.annotate("", xy=(x + laenge, y), xytext=(x, y), arrowprops=dict(arrowstyle="-|>", color=farbe, lw=breite))def zeichne_system(ax, u, f=None, laenge=2.4, us=0.6, ks=0.28, y=0.0, mit_wand=True, namen=True):"""Das Drei-Knoten-Federsystem: u = Verschiebungen, f = Kräfte je Knoten.""" bx = [0.0, laenge, 2* laenge] px = [bx[i] + u[i] * us for i inrange(3)]if mit_wand: ax.plot([-0.5, -0.5], [y -0.5, y +0.5], color=FARBE["wand"], lw=2)for s in np.linspace(-0.45, 0.45, 7): ax.plot([-0.5, -0.72], [y + s, y + s +0.18], color=FARBE["wand"], lw=1) ax.plot([-0.5, px[0]], [y, y], color=FARBE["wand"], lw=1.4)for i inrange(3): # Ruhelage blass gestrichelt ax.plot([bx[i], bx[i]], [y -0.6, y +0.35], "--", color="#ccc", lw=0.9) feder(ax, px[0], px[1], y, FARBE["feder1"]) feder(ax, px[1], px[2], y, FARBE["feder2"]) ax.text((px[0] + px[1]) /2, y +0.34, "Feder 1", color=FARBE["feder1"], ha="center", fontsize=9) ax.text((px[1] + px[2]) /2, y +0.34, "Feder 2", color=FARBE["feder2"], ha="center", fontsize=9)for i inrange(3): ax.plot(px[i], y, "o", color=FARBE["knoten"], ms=9, zorder=4)if namen: ax.text(px[i], y -0.72, f"Knoten {i +1}", color="#444", ha="center", fontsize=9)if f isnotNone:for i inrange(3):ifabs(f[i]) <5e-3:continue pfeil(ax, px[i], y +0.95, f[i] * ks, FARBE["kraft"]) ax.text(px[i] + f[i] * ks /2, y +1.18, f"f{i +1} = {sgn(f[i])}", color=FARBE["kraft"], ha="center", fontsize=9)return px# Das durchgehende Lehrbeispiel einmal ausrechnen (für den Fließtext).K_BSP = bau_K(K1, K2) # [[2,−2,0],[−2,3,−1],[0,−1,1]]U_HAND = [0, 1, 2]F_HAND = mat_vek(K_BSP, U_HAND) # [−2, 1, 1]SPALTEN = [mat_vek(K_BSP, e) for e in ([1, 0, 0], [0, 1, 0], [0, 0, 1])]
4.1 Eine Feder als eine Zahl
Bevor zwei Federn koppeln, eine allein. Eine Feder tut etwas Einfaches: Je weiter man sie auslenkt, desto stärker zieht sie zurück — und zwar im festen Verhältnis. Der Betrag der Federkraft ist der Federweg mal einer festen Kennzahl, der Federsteifigkeit\(k\):
\[
F = k \cdot s.
\]
Hier ist \(s\) der Federweg (die Längenänderung der Feder gegenüber ihrer Ruhelage), \(F\) der Betrag der Kraft, und \(k\) sagt, wie viel Kraft eine Wegeinheit Federweg kostet — „Kraft je Wegeinheit”. Eine steife Feder hat ein großes \(k\), eine weiche ein kleines. Wie groß \(k\) ausfällt, hängt an beidem: am Material der Feder und an ihrer Gestalt (Länge und Querschnitt) — \(k\) ist also keine reine Materialzahl. Das Vorzeichen (Zug oder Druck, nach vorn oder hinten) kommt erst dazu, wenn wir die Feder ins System einbauen. Diese Regel heißt Hookesches Gesetz; ihren vollen Auftritt hat sie in Kapitel 6, an Sehne, Knochen und Fettpolster, und dort wird \(k\) auch in seine zwei Anteile zerlegt, Material und Gestalt. Hier brauchen wir nur die einfachste Gestalt.
Warum das an die Ferse gehört: Zwischen Boden und Knochen sitzt das Fersenpolster, ein nachgiebiges Kissen; darüber der Knochen, selbst leicht elastisch. Man kann sich diese Kette wie zwei nachgiebige Glieder in Reihe denken — Polster und Knochen (Abbildung 4.1). Das ist ein Denkmodell, keine Messung: Welches Glied wie steif ist, sagt das Bild nicht, und die Zahlen \(k_1, k_2\) dieses Kapitels sind didaktisch gewählt, nicht die echten Gewebesteifigkeiten (der Zahlenanhang führt keine Steifigkeiten, sondern die Materialkennwerte — die E-Moduln —, aus denen sich \(k\) zusammen mit der Geometrie ab Kapitel 6 ergibt).
Code
import jsonimport pathlibimport numpy as npimport matplotlib.pyplot as pltfig, (axo, axu) = plt.subplots(2, 1, figsize=(6.6, 7.0), gridspec_kw={"height_ratios": [2.3, 1]})# Feder als Zickzack zwischen zwei beliebigen Punkten (für die Analogie).def feder_seg(ax, a, b, farbe, amp=2.2, w=6, lw=1.8): a, b = np.asarray(a, float), np.asarray(b, float) d = b - a laenge = np.hypot(*d) r = d / laenge n = np.array([-r[1], r[0]]) # Normale für den Zickzack pts = [a, a + r * laenge *0.12]for k inrange(w +1): t =0.12+ (0.76* k / w) pts.append(a + r * laenge * t + n * (amp if k %2==0else-amp)) pts += [a + r * laenge *0.88, b] pts = np.array(pts) ax.plot(pts[:, 0], pts[:, 1], color=farbe, lw=lw, zorder=4)# --- oben: die echte Modellkontur, Federn und Kräfte direkt eingetragen ---_kontur = json.loads( pathlib.Path("../geometrie/kalkaneus_kontur.json").read_text())kontur_mm = np.array(_kontur["punkte"]) *1000.0# hinten = x kleinaxo.fill(kontur_mm[:, 0], kontur_mm[:, 1], color="#f0e2d0", ec="#a9825f", lw=1.6, zorder=2)axo.text(48, 8, "Fersenbein", fontsize=8, color="#8a6a4a", ha="center")# Boden mit Schraffur (fest), unter dem Tuber.axo.plot([-6, 30], [-9.0, -9.0], color="#8a6a4a", lw=2)for xx in np.linspace(-5, 29, 12): axo.plot([xx, xx -2.2], [-9.0, -12.0], color="#8a6a4a", lw=0.8)# Knoten aus den validierten Randgruppen: Boden/Polster unter dem Tuber# (x < 14 mm), Lasteinleitung an der Talus-Gelenkfläche (oben, ~ (33, 36)).k1 = np.array([8.0, -9.0]) # Knoten 1: Boden, festk2 = np.array([8.594, 2.237]) # Knoten 2: Polster-Knochen-Grenze (Konturpunkt)k3 = np.array([33.0, 36.0]) # Knoten 3: Talus-Gelenkfläche (Last)feder_seg(axo, k1, k2, FARBE["feder1"], amp=2.4) # Polsterfeder_seg(axo, k2, k3, FARBE["feder2"], amp=2.4) # Knochen-Gliedfor p, txt, dx, dy, ha in [(k1, "Knoten 1 (Boden, fest)", -3, -4.5, "left"), (k2, "Knoten 2 (Polster-\nKnochen-Grenze)", -3.5, 3.0, "right"), (k3, "Knoten 3\n(Gelenkfläche)", 4.0, -1.0, "left")]: axo.plot(p[0], p[1], "o", color=FARBE["knoten"], ms=8, zorder=5) axo.text(p[0] + dx, p[1] + dy, txt, fontsize=8, ha=ha, va="center")axo.text(1.0, -4.0, "Polster", color=FARBE["feder1"], fontsize=8, ha="right")axo.text(14.5, 18, "Knochen", color=FARBE["feder2"], fontsize=8, ha="left")# Die Last drückt von oben auf die Gelenkfläche (Gelenkkraft des Sprungbeins).axo.annotate("", xy=(k3[0], k3[1] +1.5), xytext=(k3[0], k3[1] +13), arrowprops=dict(arrowstyle="-|>", color=FARBE["kraft"], lw=2))axo.text(k3[0] -1.5, k3[1] +14, "Last (Gelenkkraft\nvon oben)", color=FARBE["kraft"], fontsize=8.5, ha="right")# Orientierung wie überall im Buch.axo.text(-4, 46, "hinten (Ferse)", fontsize=8, color="#666")axo.text(50, 46, "vorn (Zehen)", fontsize=8, color="#666")axo.set_title("Analogie an der Ferse (Modellkontur)", fontsize=10)axo.set_xlim(-14, 74); axo.set_ylim(-14, 54)axo.set_aspect("equal"); axo.axis("off")# --- darunter: dasselbe abstrakt, waagerecht ---zeichne_system(axu, [0, 0, 0], None, laenge=1.9, us=0)axu.annotate("", xy=(4.4, 0.0), xytext=(3.9, 0.0), arrowprops=dict(arrowstyle="-|>", color=FARBE["kraft"], lw=2))axu.text(4.5, 0.0, "Zug", color=FARBE["kraft"], fontsize=9, va="center")axu.set_title("dasselbe abstrakt: zwei Federn, drei Knoten", fontsize=10)axu.set_xlim(-1.1, 5.2); axu.set_ylim(-1.1, 0.9)axu.set_aspect("equal"); axu.axis("off")plt.tight_layout(h_pad=2.6)plt.show()
Abbildung 4.1: Analogie (keine echten Steifigkeiten), eingetragen in die echte Modellkontur des Fersenbeins (Kanon-Geometrie, 66 mm): Das Fersenpolster ist die Feder zwischen Boden und Knochenunterseite (unter dem Tuber), der Knochen selbst das zweite nachgiebige Glied bis zur Talus-Gelenkfläche, wo die Last von oben drückt. Drei Punkte — Boden (fest), Polster-Knochen-Grenze, Gelenkfläche — sind unsere drei Knoten. Darunter dasselbe abstrakt und waagerecht gezeichnet, wie wir es ab hier verwenden; dort ziehen wir am freien Ende statt zu drücken, weil Zug die Federn sichtbar dehnt — an der Rechnung ändert die Richtung nur das Vorzeichen.
Deutung. Oben das körperliche Bild auf der echten Knochenkontur: Der Boden hält fest, das Polster federt, der Knochen gibt minimal nach, und die Gelenkkraft des Sprungbeins drückt von oben auf die Kette. Darunter dasselbe als Rechenbild: drei Knoten, zwei Federn, Knoten 1 fest. Wir legen die Kette waagerecht, weil sich Verschiebungen dann als Zahlen auf einer einzigen Achse lesen lassen — nach vorn (rechts) ist positiv, wie im Koordinatensystem aus Kapitel 3. Und wir ziehen am freien Ende, statt zu drücken, weil Zug die Federn sichtbar dehnt; an der Rechnung ändert die Richtung nur das Vorzeichen. Kapitel 5 hängt dieser Kette später eine dritte Feder an.
Abbildung 4.2 zeigt das System mit allen Namen: Jeder Knoten hat eine Verschiebung \(u_i\) (wie weit er sich aus der Ruhelage bewegt) und spürt eine Kraft \(f_i\).
Die drei \(u_i\) schreiben wir als Liste \(u = (u_1, u_2, u_3)\), die drei \(f_i\) als Liste \(f = (f_1, f_2, f_3)\). Hier zeigt sich, warum Kapitel 3 auf der Zahlenliste bestanden hat: Drei Verschiebungen dreier verschiedener Knoten lassen sich nicht mehr zu einem Pfeil zusammenfassen — der erste Knoten rückt woandershin als der zweite, und ein Pfeil hat nur einen Fußpunkt. Als Liste aber gehorchen sie denselben Regeln wie jeder Pfeil: Man kann sie addieren und mit einer Zahl vervielfachen, Eintrag für Eintrag. Deshalb heißen auch sie Vektoren. Ab jetzt ist ein Vektor für uns eine Liste von Zahlen, die zusammengehören — mit oder ohne Pfeil dazu.
Wie lang eine solche Liste ausfällt, hängt daran, wie viele Zahlen ein einzelner Knoten braucht. Hier ist es genau eine je Knoten: Die Federkette liegt auf einer Achse, jeder Knoten kann nur vor oder zurück. Eine solche frei wählbare Zahl eines Knotens heißt in der Mechanik Freiheitsgrad — drei Knoten, drei Freiheitsgrade, und die Tabelle dazu wird 3×3. Im ebenen Knochen ab Kapitel 10 trägt jeder Knoten zwei davon, einen waagerechten und einen senkrechten: Bei gleicher Knotenzahl ist die Liste dann doppelt so lang und die Tabelle viermal so groß. Die Leseart ändert sich dadurch nicht — nur zählt man dort Freiheitsgrade statt Knoten.
Abbildung 4.2: Das Zwei-Feder-System, beschriftet: drei Knoten, Feder 1 (k₁) zwischen Knoten 1 und 2, Feder 2 (k₂) zwischen Knoten 2 und 3. Knoten 1 ist an der Wand fest. Jeder Knoten trägt eine Verschiebung uᵢ und eine Kraft fᵢ. Gezeigt ist eine Beispielauslenkung, damit die Federn sichtbar gespannt sind.
Deutung. Die Verschiebungen (unten, grau) sind die Ursache, die Kräfte (oben) die Wirkung. Die Federn übertragen die eine in die andere — und weil Feder 1 die Knoten 1 und 2 verbindet und Feder 2 die Knoten 2 und 3, hängt jede Kraft von mehreren Verschiebungen ab. Das aufzuschreiben ist die Aufgabe der Matrix.
Ein Wort zu diesen Kräften \(f_i\), bevor wir rechnen. Wir gehen im ganzen Kapitel von den Verschiebungen aus und fragen: Welche Kraft muss von außen wirken, damit die Knoten genau so stehenbleiben? \(f_i\) ist also die äußere Halte- oder Lagerkraft an Knoten \(i\) — die Kraft, die man von außen aufbringen (oder die das Lager liefern) muss. Die Feder selbst zieht am Knoten genau entgegengesetzt dazu. In allen Bildern, Reglern und der Animation sind die roten Pfeile diese äußeren Haltekräfte; ein positives \(f_i\) zeigt nach vorn (rechts).
4.2 Von den Federn zur Tabelle
Jeder Knoten spürt eine Kraft, die von mehreren Verschiebungen abhängt — die Federn koppeln die Knoten. Sammelt man diese Abhängigkeiten in ein Rechteck (Zeile für den Knoten, Spalte für die Verschiebung), entsteht die Steifigkeitsmatrix \(K\). Für unser Zwei-Feder-System hat sie diese Gestalt:
Woher jede einzelne Zahl kommt, rechnen wir gleich nach. Zuerst ein Experiment mit dieser Tabelle: Wir machen die zweite Feder steifer und schauen, was sich ändert.
WichtigVorhersage-Punkt
Bevor du schiebst: Der erste Regler zeigt die Matrix und lässt dich die zweite Feder steifer machen (k₂ größer). Welche Einträge der Tabelle ändern sich dabei — und bleibt die Tabelle symmetrisch (also gleich, wenn man sie an der Diagonale spiegelt)? Lege dich fest, bevor du schiebst.
Deutung. Steifer machen (k₂ größer) ändert nur die vier Einträge unten rechts — die beiden Knoten, an denen Feder 2 hängt (Knoten 2 und 3); der Diagonaleintrag \(K_{33} = k_2\) folgt der Steifigkeit direkt und geht bei sehr weicher Feder gegen null. Die obere linke Ecke, die zu Feder 1 gehört, bleibt unberührt. Und die Tabelle bleibt symmetrisch: der Eintrag „Zeile 2, Spalte 3” ist stets gleich dem Eintrag „Zeile 3, Spalte 2”.
Woher die Tabelle kommt. Jetzt rechnen wir die Einträge nach. Feder 1 hat den Federweg \(u_2 - u_1\), Feder 2 den Federweg \(u_3 - u_2\). Nach \(F = k\cdot s\) zieht Feder 1 mit \(k_1(u_2 - u_1)\), Feder 2 mit \(k_2(u_3 - u_2)\). Die äußere Haltekraft an einem Knoten muss dem entgegenwirken, was die Federn dort ziehen; zählt man das je Knoten zusammen, entstehen drei Gleichungen:
Die Symmetrie ist kein Zufall: Der Kopplungseintrag zwischen zwei Knoten kommt von der Feder dazwischen, und die eine Feder zählt für beide Richtungen gleich — was Knoten 2 von einer Bewegung des Knotens 3 spürt, ist genau das, was Knoten 3 von einer Bewegung des Knotens 2 spürt. Deshalb steht in Zeile \(i\), Spalte \(j\) dasselbe wie in Zeile \(j\), Spalte \(i\): \(K = K^{\mathsf T}\).
Aufgeschrieben ist das Aufstellen der Matrix eine kleine Funktion — reines Python, das die drei Vorfaktorzeilen einfach hinschreibt. Sie ist der erste Baustein, den die späteren Kapitel wiederverwenden, deshalb bleibt sie sichtbar:
Die Steifigkeitsmatrix zweier Federn aufstellen
def steifigkeitsmatrix_zwei_federn(k1, k2):"""Die 3x3-Steifigkeitsmatrix zweier Federn in Reihe (Knoten 1-2-3). k1: Steifigkeit der Feder zwischen Knoten 1 und 2 (Kraft je Wegeinheit). k2: Steifigkeit der Feder zwischen Knoten 2 und 3. Rueckgabe: die Matrix als Liste von drei Zeilen. Jede Zeile gehoert zu einem Knoten, jede Spalte zu einer Verschiebung. """return [ [k1, -k1, 0], [-k1, k1 + k2, -k2], [0, -k2, k2], ]
Mit den didaktischen Werten \(k_1 = 2\) und \(k_2 = 1\) aufgerufen, liefert sie die Tabelle, die schon in der Formel oben stand — Tabelle 4.1 zeigt sie Zeile für Zeile, dazu die Probe auf Symmetrie an einem der Kopplungspaare:
Tabelle 4.1: Die Steifigkeitsmatrix des Zwei-Feder-Systems für \(k_1 = 2\) und \(k_2 = 1\) (didaktische Lehreinheiten). Jede Zeile gehört zu einem Knoten, jede Spalte zu einer Verschiebung.
Zeile
Spalte 1 (u₁)
Spalte 2 (u₂)
Spalte 3 (u₃)
Knoten 1
2
−2
0
Knoten 2
−2
3
−1
Knoten 3
0
−1
1
symmetrisch (\(K = K^{\mathsf T}\))
ja
Deutung unter der Tabelle. Dieselbe Tabelle wie im Regler und in der Formel. Die Probe in der letzten Zeile vergleicht \(K_{12}\) mit \(K_{21}\) und \(K_{23}\) mit \(K_{32}\) und bestätigt die Symmetrie — der Rechner findet sie, weil sie in der Bauvorschrift schon steckt.
4.3 Die Matrix mal den Vektor
Die Matrix ist eine Übersetzungsmaschine: Man gibt ihr einen Verschiebungsvektor \(u\) und bekommt den Kraftvektor \(f\). Die Rechenvorschrift dafür heißt Matrix-Vektor-Produkt, geschrieben \(f = K\,u\) (Abbildung 4.3).
Code
import matplotlib.pyplot as pltfig, ax = plt.subplots(figsize=(7.6, 3.0))matrix_grafik(ax, 2.4, 0.0, [[u] for u in U_HAND], cw=0.9, ch=1.0, fs=14, zell_farbe=lambda i, j, v: "#555")ax.text(2.4, 1.7, "u", ha="center", fontsize=13, color="#555")matrix_grafik(ax, 4.4, 0.0, K_BSP, cw=1.0, ch=1.0, fs=14, zell_farbe=landkarten_farbe)ax.text(5.4, 1.7, "K", ha="center", fontsize=13, color="#b3541e")matrix_grafik(ax, 8.0, 0.0, [[v] for v in F_HAND], cw=0.9, ch=1.0, fs=14, zell_farbe=lambda i, j, v: FARBE["kraft"])ax.text(8.0, 1.7, "f", ha="center", fontsize=13, color=FARBE["kraft"])for x0, x1 in [(3.1, 3.6), (7.0, 7.5)]: ax.annotate("", xy=(x1, 0.0), xytext=(x0, 0.0), arrowprops=dict(arrowstyle="-|>", color="#333", lw=2))ax.text(3.35, 0.35, "K·", ha="center", fontsize=11)ax.text(7.25, 0.35, "=", ha="center", fontsize=13)ax.text(1.2, -0.1, "Verschiebung", ha="center", fontsize=9, color="#555")ax.text(9.5, -0.1, "Kraft", ha="center", fontsize=9, color=FARBE["kraft"])ax.set_xlim(0.2, 10.2); ax.set_ylim(-2.1, 2.1)ax.set_aspect("equal"); ax.axis("off")plt.tight_layout()plt.show()
Abbildung 4.3: Die Matrix als Übersetzungsmaschine: links der Verschiebungsvektor u = (0; 1; 2), in der Mitte die Steifigkeitsmatrix K, rechts der Kraftvektor f = (−2; 1; 1). Der Pfeil läuft von der Verschiebung zur Kraft — das ist die Leserichtung des ganzen Kapitels.
Die Vermutung, die man beim ersten Blick hat: „Ich verschiebe nur den Mittelknoten — dann entsteht auch nur an ihm eine Kraft.” Prüfen wir sie.
WichtigVorhersage-Punkt
Bevor du schiebst: Der zweite Regler verschiebt nur den Mittelknoten (u₂), während Knoten 1 und 3 in Ruhe bleiben. An welchen Knoten entsteht Kraft, und in welche Richtung? Nur an Knoten 2 — oder auch an den Nachbarn? Lege dich fest.
Deutung. Verschiebt man nur Knoten 2 (nach vorn), braucht es an allen drei Knoten eine äußere Haltekraft. Feder 1 wird gedehnt und zieht Knoten 1 nach vorn — um ihn festzuhalten, muss man mit \(f_1\) nach hinten dagegenhalten; Feder 2 wird gestaucht und drückt Knoten 3, der ebenso eine Haltekraft nach hinten braucht. Der Mittelknoten selbst braucht die größte, nach vorn. Genau diese drei Haltekräfte stehen in der mittleren Spalte der Matrix: \((-k_1,\ k_1+k_2,\ -k_2) = (-2,\ 3,\ -1)\). Keine Null darunter; jede der drei Zahlen wird zu einer Kraft.
Rechnen wir das Produkt einmal von Hand, mit einer konkreten Verschiebung \(u = (0,\ 1,\ 2)\) — Knoten 1 bleibt fest, Knoten 2 rückt um eine, Knoten 3 um zwei Wegeinheiten vor. Jede Kraft ist eine gewichtete Summe der Verschiebungen: Man nimmt eine Zeile der Matrix, multipliziert sie Eintrag für Eintrag mit dem Verschiebungsvektor und zählt zusammen:
Die Probe mit der Federlogik: Feder 1 ist um \(u_2 - u_1 = 1\) gedehnt, ihre Zugkraft ist \(k_1 \cdot 1 = 2\); Feder 2 ist um \(u_3 - u_2 = 1\) gedehnt, Zugkraft \(k_2 \cdot 1 = 1\). An Knoten 1 zieht nur Feder 1 (mit 2 nach rechts), also muss man ihn mit \(f_1 = -2\) festhalten; an Knoten 3 zieht nur Feder 2 (mit 1), also \(f_3 = +1\); an Knoten 2 ziehen beide gegeneinander, netto bleibt \(f_2 = +1\). Dieselben drei Zahlen — die Matrix hat nichts anderes getan als die Federlogik, nur gebündelt.
Aufgeschrieben ist das Matrix-Vektor-Produkt eine Doppelschleife: für jede Zeile die gewichtete Summe. Auch sie bleibt sichtbar, denn sie ist der zweite Baustein, auf dem die späteren Kapitel aufbauen:
Das Matrix-Vektor-Produkt als Doppelschleife
def matrix_mal_vektor(matrix, vektor):"""Matrix-Vektor-Produkt f = matrix * vektor (gewichtete Summen). matrix: Liste von Zeilen (jede Zeile eine Liste von Zahlen). vektor: Liste von Zahlen, so lang wie eine Zeile. Rueckgabe: der Ergebnisvektor als Liste. """ ergebnis = []for zeile in matrix: summe =0for spalte_index inrange(len(vektor)): summe = summe + zeile[spalte_index] * vektor[spalte_index] ergebnis.append(summe)return ergebnis
Mit derselben Verschiebung \(u = (0,\ 1,\ 2)\) aufgerufen, liefert sie genau die drei Kräfte, die oben von Hand nachgerechnet wurden — Tabelle 4.2 stellt Verschiebung und Kraft knotenweise nebeneinander:
Tabelle 4.2: Das Produkt \(f = K\,u\) für \(u = (0;\ 1;\ 2)\), gerechnet von der sichtbaren Funktion. Die drei Kräfte stimmen mit der Handrechnung und mit der Federlogik überein.
Knoten
Verschiebung \(u\)
Haltekraft \(f\)
1
0
−2
2
1
1
3
2
1
Deutung unter der Tabelle. Knoten 1 steht still und braucht trotzdem die größte Haltekraft (nach hinten), weil die gedehnte Feder 1 an ihm zieht. Genau das ist der Punkt der Matrix: Sie übersetzt alle Verschiebungen in alle Kräfte, nicht jede Stelle für sich.
Editierbare Zelle. Der folgende Block rechnet dasselbe im Browser und zeichnet die drei Haltekräfte als Balken über den Knoten. Verändere die Verschiebung u oder die Steifigkeiten k1, k2 und führe die Zelle aus: Die Balken wandern mit, und man sieht sofort, an welchen Knoten Kraft entsteht.
WarnungEin Knoten zieht nicht nur an sich selbst
Vermutung:„Wenn nur der Mittelknoten verschoben ist (nur \(u_2 \ne 0\)), sind auch nur an ihm Kräfte nötig — die festgehaltenen Nachbarn bleiben ja, wo sie sind.”
Warum sie naheliegt: Bewegt hat sich nur ein Knoten; die anderen stehen still. Wo sich nichts rührt, so scheint es, braucht es auch keine Kraft.
Was stattdessen gilt: Die Nachbarn bleiben nur deshalb stehen, weil man sie festhält — und dazu braucht es Kraft. Die gedehnte Feder 1 zöge Knoten 1 mit, die gestauchte Feder 2 drückte Knoten 3; die äußeren Haltekräfte an diesen festgehaltenen Nachbarn sind genau die Außerdiagonaleinträge der mittleren Spalte, \(-k_1 = -2\) und \(-k_2 = -1\). Weil jeder Knoten so an seinen Nachbarn hängt, lassen sich die Verschiebungen am Ende nicht einzeln bestimmen, sondern nur alle freien Unbekannten gemeinsam (der feste Knoten 1 gehört nicht dazu) — das ist genau die Aufgabe von Kapitel 5.
4.4 Jede Spalte eine Einheitsverschiebung
Woher weiß man, was in einer Spalte steht, ohne alle Gleichungen zu sortieren? Es gibt eine anschauliche Leseart: Die \(j\)-te Spalte der Matrix sind die Haltekräfte, die entstehen, wenn man Knoten \(j\) um genau eine Einheit verschiebt und alle anderen festhält. Setzt man \(u = (1, 0, 0)\) in das Produkt ein, bleibt gerade die erste Spalte übrig; \(u = (0, 1, 0)\) liefert die zweite, \(u = (0, 0, 1)\) die dritte (Abbildung 4.4).
Das ist eine formale Probe der noch unbeschränkten Matrix: Um für die erste Spalte auch Knoten 1 um eine Einheit zu verschieben, denken wir die Einspannung kurz weg (in Bild und Animation ist die Wand deshalb ausgegraut, „Randbedingung noch nicht angewendet”). Sie kommt erst beim Lösen dazu (Kapitel 5).
Ein Blick auf die Zeilen zeigt, warum die Einspannung überhaupt nötig ist: jede Zeile der Matrix summiert sich zu null (etwa \(-2 + 3 - 1 = 0\)). Also ist \(K \cdot (1, 1, 1)^{\mathsf T} = (0, 0, 0)^{\mathsf T}\) — verschiebt man alle Knoten um dasselbe Stück, dehnt sich keine Feder, und keine Haltekraft wird nötig. Das ist eine Starrkörperbewegung: Das ganze System gleitet, ohne sich zu verformen. Solange nichts festgehalten ist, lässt die Matrix diese Bewegung zu; erst die Einspannung von Knoten 1 nimmt sie heraus und macht die Aufgabe lösbar (Kapitel 5).
Abbildung 4.4: Spaltendeutung (formale Probe der noch unbeschränkten Matrix, Einspannung weggedacht): drei Einheitsverschiebungen, untereinander. Die roten Pfeile sind die äußeren Haltekräfte fᵢ. Oben wird nur Knoten 1 um eine Einheit verschoben — die Haltekräfte (2; −2; 0) sind die erste Spalte der Matrix. Mitte: nur Knoten 2 → (−2; 3; −1), die zweite Spalte. Unten: nur Knoten 3 → (0; −1; 1), die dritte Spalte.
Deutung. Jede Spalte ist ein eigenes kleines Experiment: einen Knoten anstoßen, sehen, wo überall Kraft entsteht. Die Animation darunter führt diese drei Experimente nacheinander vor — die Kräfte erscheinen und wandern als Zahlenspalte in die Matrix.
4.5 Die Matrix lesen
Damit lässt sich die ganze Tabelle als Grundriss lesen (Abbildung 4.5). Drei Sorten Einträge, drei Bedeutungen:
Diagonale (\(K_{11}, K_{22}, K_{33}\)): die Diagonale ist die Eigensteifigkeit eines Knotens — die Haltekraft an ihm selbst, wenn nur er sich um eine Einheit bewegt. Sie ist die Summe der am Knoten anliegenden Federsteifigkeiten und damit nichtnegativ: Knoten 2 trägt beide Federn, daher \(K_{22} = k_1 + k_2 = 3\); Knoten 3 trägt nur Feder 2, daher \(K_{33} = k_2\) (und \(K_{33} = 0\), wenn diese Feder ganz weich wird — der k₂-Regler zeigt es).
Außerdiagonaleinträge (die Nebendiagonalen, \(K_{12}, K_{23}, \dots\)): die Kopplung zweier Knoten über die Feder zwischen ihnen. Ist eine Feder vorhanden (\(k > 0\)), ist der Eintrag negativ, weil ein Vorrücken des einen Knotens den anderen mitzieht.
Nullen (\(K_{13} = K_{31} = 0\)): Knoten 1 und 3 sind durch keine Feder direkt verbunden — sie „sehen sich nicht”. Eine Bewegung des einen macht am anderen unmittelbar keine Haltekraft nötig (erst über den Umweg Knoten 2).
Diese drei Bedeutungen lassen sich als eine kurze Zuordnung schreiben: Diagonale, Kopplung oder Null, je nach Ort und Wert des Eintrags. Damit färbt die Hilfsfunktion des Kapitels jeden Eintrag der eben gebauten Matrix \(K\) ein (Abbildung 4.5) — sichtbar bleibt die Zuordnung, das Einfärben und die Legende übernimmt die Hilfsfunktion:
Jeden Matrixeintrag benennen und den Grundriss der Matrix einfärben
def eintrags_art(i, j, wert):"""Sagt, was ein Matrixeintrag bedeutet (Zeile i, Spalte j, Wert)."""if i == j:return"diagonale"# Eigensteifigkeit des Knotensif wert !=0:return"kopplung"# Feder zwischen zwei Knotenreturn"null"# keine direkte Verbindungzeichne_landkarte(K, eintrags_art) # jede Zelle nach ihrer Bedeutung einfärben
Abbildung 4.5: Grundriss der Matrix: die 3×3-Steifigkeitsmatrix eingefärbt. Orange die Diagonale (Eigensteifigkeit = Summe der anliegenden Steifigkeiten), blau die Außerdiagonaleinträge (Kopplung über eine Feder), grau die Nullen (Knoten 1 und 3 sind nicht direkt verbunden). Die Matrix ist symmetrisch zur Diagonale.
Deutung. Der Grundriss macht die Bauart sichtbar: viel auf und neben der Diagonale, Nullen dort, wo keine Feder verbindet. Bei Tausenden Knoten bleibt das so — fast alles ist null, weil jeder Knoten nur mit seinen wenigen Nachbarn gekoppelt ist. Eine Matrix, in der fast alles null ist, heißt dünn besetzte Matrix — und dass die Steifigkeitsmatrix so gebaut ist, macht große FE-Rechnungen überhaupt erst möglich (Kapitel 5 und 10).
Ein Wort zur Einspannung: Wir haben eben eine volle 3×3-Matrix aufgestellt, die alle Knoten beschreibt — auch den festen Knoten 1. Dass Knoten 1 gar nicht frei ist, wird erst beim Lösen eingearbeitet, wenn aus \(K\,u = f\) die unbekannten Verschiebungen bestimmt werden. Das ist die Aufgabe des nächsten Kapitels; hier stellen wir nur die Übersetzungsmaschine bereit.
Übungen
Ü 4.1 (Verstehen). Hier eine Steifigkeitsmatrix eines Zwei-Feder-Systems: \[
K = \begin{bmatrix} 5 & -5 & 0 \\ -5 & 8 & -3 \\ 0 & -3 & 3 \end{bmatrix}.
\] Zeige den Eintrag, der die Kopplung zwischen Knoten 1 und 2 beschreibt, und deute sein Vorzeichen. Wie groß sind \(k_1\) und \(k_2\)?
HinweisMusterlösung zu Ü 4.1
Die Kopplung zwischen Knoten 1 und 2 steht in Zeile 1, Spalte 2 (und, gespiegelt, in Zeile 2, Spalte 1): \(K_{12} = K_{21} = -5\). Das negative Vorzeichen liest man über die Haltekraft: Verschiebt man Knoten 2 um \(+1\) und hält die anderen fest (\(u = (0, 1, 0)\)), so ist die Haltekraft an Knoten 1 gleich \(K_{12} = -5\) — die gedehnte Feder zieht Knoten 1 nach vorn, und man muss ihn mit \(-5\) nach hinten dagegenhalten. Aus \(K_{11} = k_1 = 5\) und \(K_{33} = k_2 = 3\) liest man die Steifigkeiten ab; die Probe \(K_{22} = k_1 + k_2 = 8\) stimmt.
Ü 4.2 (Verändern). Öffne den Steifigkeits-Regler und mache Feder 2 sehr weich (k₂ nahe null). Sage vorher, was mit den Kopplungseinträgen \(K_{23}\) und \(K_{32}\) geschieht und ob Knoten 3 dann noch mit dem Rest gekoppelt ist. Prüfe es am Regler.
HinweisMusterlösung zu Ü 4.2
Bei \(k_2 \to 0\) gehen \(K_{23}, K_{32}\) und \(K_{33}\) gegen null. Knoten 3 ist dann faktisch abgekoppelt — eine unendlich weiche Feder überträgt keine Kraft mehr. Die Matrix zerfällt in ein Ein-Feder-System (Knoten 1–2) plus einen losen Knoten 3. Genau das ist die Kopplung, die im Widerlegungskasten der Punkt war: Sie sitzt in den Außerdiagonaleinträgen und verschwindet mit der Feder.
Ü 4.3 (Übertragen). Skizziere ein Drei-Feder-System (vier Knoten in einer Reihe, drei Federn) und sage die Besetzung seiner 4×4-Steifigkeitsmatrix vorher: Welche Einträge sind null? Genau diese Kette nimmt sich Kapitel 5 vor — die Skizze ist also die Brücke dorthin.
HinweisMusterlösung zu Ü 4.3
Null sind alle Einträge zwischen Knoten, die keine gemeinsame Feder haben: \(K_{13}, K_{14}, K_{24}\) (und ihre gespiegelten \(K_{31}, K_{41}, K_{42}\)). Es bleibt eine Bandstruktur: die Diagonale plus je eine Außerdiagonale darüber und darunter besetzt, der Rest null. Bei einer langen Federkette ist die Matrix fast leer — dieselbe dünne Besetzung wie im echten Netz.
Ein Hinweis für den Übergang: Kapitel 5 zeichnet dieselbe Kette gespiegelt. Dort steht die Wand rechts, Knoten 4 ist der feste, und von links wird gegen sie gedrückt statt am freien Ende gezogen. Für die Matrix ist das gleichgültig — sie hängt nur daran, welche Feder welche zwei Knoten verbindet, nicht daran, auf welcher Seite die Wand steht. Was sich dreht, sind die Vorzeichen der Kräfte und die Frage: Hier ist die Verschiebung gegeben und die Kraft gesucht, dort umgekehrt.
Roter Faden
Wo kam das schon vor, wo kommt es wieder?
Zurück: Die Vektoren aus Kapitel 3 sind hier zu zwei Bündeln geworden — dem Verschiebungsvektor und dem Kraftvektor —, und aus dem Pfeil ist dabei endgültig eine Liste geworden, die keinen Pfeil mehr braucht. Das Addieren und Skalieren aus Kapitel 3 sind die Grundrechenarten, aus denen das Matrix-Vektor-Produkt besteht: jede Kraft eine gewichtete Summe. Die Federkraft \(F = k\cdot s\) hat dem Hookeschen Gesetz aus Kapitel 6 vorgegriffen. Die Studiums-Zeile „Tabelle, die Verschiebungen in Kräfte übersetzt → Matrix” ist damit abgearbeitet; abgehakt wird sie in der Tabelle am Ende von Teil II.
Vor:Kapitel 5 löst das aufgestellte System \(K\,u = f\) nach den unbekannten Verschiebungen — mit einer Einspannung, diesmal am anderen Ende der Kette. Und die Elementsteifigkeitsmatrix in Kapitel 10 ist dieselbe Idee für ein Dreieck statt für eine Feder; dort trägt jeder Knoten zwei Freiheitsgrade statt einem.
Was dieses Kapitel NICHT tut
Es kehrt die Matrix nicht um: Aus gegebenen Kräften die Verschiebungen zu bestimmen (das Gleichungssystem \(K\,u = f\) nach \(u\) auflösen) ist Kapitel 5; Matrixinversion, Determinanten und allgemeine lineare Algebra kommen im Buch gar nicht vor. Es behandelt keine Dreieckselemente (Kapitel 10), sondern nur die Steifigkeitsmatrix eines kleinen Federsystems, von Hand nachvollziehbar. Und die Steifigkeiten \(k_1, k_2\) sind didaktische Lehreinheiten, keine echten Gewebesteifigkeiten — im Zahlenanhang stehen die zugehörigen Materialkennwerte (E-Moduln), aus denen zusammen mit der Geometrie ab Kapitel 6 die Bauteilsteifigkeiten folgen.
