7  Steigung und Fläche

In Kapitel 6 war der E-Modul die Steigung der Spannungs-Dehnungs-Geraden — ein erster Blick auf eine Idee, die dieses Kapitel ausbaut. Eine Kraft, die sich über einen Schritt ändert, wirft nämlich zwei ganz verschiedene Fragen auf: Wie schnell ändert sie sich (die Steigung), und wie viel kommt insgesamt zusammen (die Fläche unter der Kurve). Die erste Frage beantwortet die Ableitung, die zweite das Integral. Beide entstehen hier ohne Grenzwertdefinition, ohne ε und δ — nur als Steigung und Fläche einer Belastungskurve, die man ablesen und nachrechnen kann.

Lernziele

Nach diesem Kapitel kannst du

  1. die Ableitung als Steigung einer Kurve deuten und näherungsweise aus zwei benachbarten Punkten bestimmen (Differenzenquotient),
  2. das Integral als Fläche unter einer Kurve deuten und über schmale Streifen annähern (Summe von Rechtecken),
  3. an einer Belastungskurve die Stelle der größten Steigung und die Fläche unter der Kurve bestimmen und die beiden Fragen auseinanderhalten,
  4. begründen, warum eine einzelne Spitze den Schritt nicht beschreibt.

7.1 Der Aufhänger: derselbe Schritt, zwei Fragen

Über die Standphase eines Schrittes — vom Fersenauftritt bis zum Abstoß — ändert sich die Bodenreaktionskraft: Sie beginnt bei null, wenn die Ferse den Boden berührt, wächst über den Bodenkontakt zu einem Höchstwert und geht zum Abheben wieder auf null zurück. Zwei Fragen liegen in dieser Kurve: Wo ändert sich die Kraft am schnellsten? Das ist die Frage nach der größten Steigung. Und: Wie viel Last kam über den ganzen Schritt zusammen? Das ist die Frage nach der Fläche unter der Kurve. Beide haben verschiedene Antworten, und beide braucht das Buch später — die Steigung als Werkzeug für räumliche Änderungen (Kapitel 8), die Fläche für die über den Schritt gemittelte Last (Teil V).

HinweisWoher diese Kurve kommt

Dieses Kapitel rechnet nicht auf einem Messschrieb, sondern auf den fünf Stützwerten des Kräftefahrplans aus Kapitel 2 (Tabelle 2.2), zwischen denen es glatt und ohne Überschwingen interpoliert. Der erste dieser Stützwerte, 1,45 · KG beim Fersenauftritt, ist der Wert einer geglätteten Kurve; die kurze, harte Spitze des Aufpralls ist darin nicht aufgelöst. Weil keine Schrittdauer vorliegt, trägt die waagerechte Achse den Anteil der Standphase und keine Sekunden.

Alle Zahlen und Bilder dieses Kapitels ziehen ihre Werte aus einer Stelle: den fünf Stützwerten des Kräftefahrplans und wenigen Rechenschritten, die daraus die Kurve, ihre Steigung und ihre Fläche machen. Zwei eingeklappte Kästen halten das fest. Der erste ist die Anzeige- und Zeichenwerkstatt: deutsche Kommas, das Achsenformat und die Zeichenmechanik zweier Bilder, die in programme/kap07 liegt. Fachinhalt steht darin keiner — den trägt der Fließtext.

Das Rechenwerk dieses Kapitels: Anzeige und Zeichenmechanik — zum Nachlesen aufklappen 
# --- Anzeigehilfen und Zeichenmechanik (keine Zahlen) --------------------
import pathlib
import sys

from matplotlib.ticker import FuncFormatter

# Zeichenmechanik der Werkbank-Bilder (Muster 3): der Lehrgedanke bleibt in den
# sichtbaren Zellen, das Matplotlib-Beiwerk liegt in programme/kap07.
sys.path.insert(0, str(pathlib.Path("programme/kap07").resolve()))
from zeichnungen import (zeichne_sekanten_in_tangente,
                         zeichne_konvergenz_loglog)

def komma(x, stellen=2):
    """Deutsche Kommadarstellung mit Endnullen-Trimmung; Minuszeichen −.

    Endnullen werden nur bei vorhandenem Dezimalpunkt entfernt — sonst
    verstümmelte stellen=0 die Ganzzahlen (50 → „5").
    """
    s = f"{x:.{stellen}f}"
    if "." in s:
        s = s.rstrip("0").rstrip(".")
    return s.replace("-", "−").replace(".", ",")

def komma_sig(x, n=3):
    """Deutsche Darstellung mit n signifikanten Stellen (ohne e-Notation)."""
    if x == 0:
        return "0"
    s = f"{x:.{n}g}"
    if "e" in s or "E" in s:
        s = f"{x:.10f}".rstrip("0").rstrip(".")
    return s.replace("-", "−").replace(".", ",")

def de_achse(ax):
    """Achsen-Tickbeschriftung linearer Achsen auf deutsche Kommas umstellen."""
    def deutsch(wert, _stelle):
        return komma_sig(wert, 3)
    f = FuncFormatter(deutsch)
    ax.xaxis.set_major_formatter(f)
    ax.yaxis.set_major_formatter(f)

Der zweite Kasten ist die eigentliche Quelle des Kapitels: das Körpergewicht aus dem Zahlenanhang (Anhang A), die fünf Stützwerte des Kräftefahrplans und die Vorschrift, die daraus eine glatte Kurve, ihre momentane Steigung und ihre exakte Fläche macht. Wer wissen will, woher ein Wert im Kapitel stammt, klappt ihn auf; wer den Text liest, verpasst nichts.

Das Rechenwerk der Bodenkurve — zum Nachlesen aufklappen 
# --- Körpergewicht aus dem Kanon und die fünf Momente des Fahrplans ---
import sys

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

KG = kanon.wert_von("KOERPERGEWICHT")   # 736 N, Körpergewicht der Läuferin
# Anteil der Standphase s ∈ [0,1] (gewählte, gleichabständige Auftragung der
# fünf Phasen) und Bodenkraft in Vielfachen von KG. Quelle: die Bodenspalte des
# Kräftefahrplans aus Kapitel 2 (Höchstwerte 1,45 und 2,5 · KG aus dem Kanon,
# Zwischenwerte 2,0 / 1,2 / 0,3 · KG Modellannahme):
XS = [0.0, 0.25, 0.5, 0.75, 1.0]
YS = [kanon.wert_von("F_AUFPRALL"),        # 1,45 · KG — aus dem Kanon
      2.0,                                 # Modellannahme
      kanon.wert_von("F_BODEN") / KG,      # 2,50 · KG — aus dem Kanon
      1.2,                                 # Modellannahme
      0.3]                                 # Modellannahme
PHASEN = ["Fersenauftritt", "Belastungsaufbau", "mittlere Standphase",
          "Fersenablösung", "Abstoß"]

def pchip_steigungen(xs, ys):
    """Knotensteigungen des monotonen kubischen Hermite-Splines (Fritsch-
    Carlson): glatt und ohne Überschwingen über die Stützpunkte."""
    n = len(xs)
    h = [xs[i + 1] - xs[i] for i in range(n - 1)]
    d = [(ys[i + 1] - ys[i]) / h[i] for i in range(n - 1)]   # Sekantensteigungen
    m = [0.0] * n
    for i in range(1, n - 1):
        if d[i - 1] == 0 or d[i] == 0 or (d[i - 1] > 0) != (d[i] > 0):
            m[i] = 0.0                # Vorzeichenwechsel/Extremum: flach
        else:
            w1 = 2 * h[i] + h[i - 1]
            w2 = h[i] + 2 * h[i - 1]
            m[i] = (w1 + w2) / (w1 / d[i - 1] + w2 / d[i])

    def rand(dk, dk1, hk, hk1):
        mm = ((2 * hk + hk1) * dk - hk * dk1) / (hk + hk1)
        if (mm > 0) != (dk > 0):
            mm = 0.0
        elif (dk > 0) != (dk1 > 0) and abs(mm) > 3 * abs(dk):
            mm = 3 * dk
        return mm

    m[0] = rand(d[0], d[1], h[0], h[1])
    m[n - 1] = rand(d[n - 2], d[n - 3], h[n - 2], h[n - 3])
    return m

STEIG = pchip_steigungen(XS, YS)    # einmal berechnet

def _segment(x):
    if x <= XS[0]:
        return 0
    if x >= XS[-1]:
        return len(XS) - 2
    for i in range(len(XS) - 1):
        if x <= XS[i + 1]:
            return i
    return len(XS) - 2

def kurve_wert(x):
    """Bodenreaktionskraft an der Stelle x (Anteil 0–1), in Vielfachen von KG."""
    i = _segment(x)
    h = XS[i + 1] - XS[i]
    t = (x - XS[i]) / h
    h00 = 2 * t ** 3 - 3 * t ** 2 + 1
    h10 = t ** 3 - 2 * t ** 2 + t
    h01 = -2 * t ** 3 + 3 * t ** 2
    h11 = t ** 3 - t ** 2
    return h00 * YS[i] + h10 * h * STEIG[i] + h01 * YS[i + 1] + h11 * h * STEIG[i + 1]

def kurve_steigung(x):
    """Momentane Steigung dF/ds (KG je Anteil der Standphase) an der Stelle x."""
    i = _segment(x)
    h = XS[i + 1] - XS[i]
    t = (x - XS[i]) / h
    d00 = 6 * t ** 2 - 6 * t
    d10 = 3 * t ** 2 - 4 * t + 1
    d01 = -6 * t ** 2 + 6 * t
    d11 = 3 * t ** 2 - 2 * t
    return (d00 * YS[i] + d10 * h * STEIG[i] + d01 * YS[i + 1]
            + d11 * h * STEIG[i + 1]) / h

def flaeche_exakt():
    """Exakte Fläche unter der Kurve über [0,1] (KG). Geschlossene Formel je
    Abschnitt: ∫ Hermite = h·(y_i+y_{i+1})/2 + h²·(m_i − m_{i+1})/12."""
    s = 0.0
    for i in range(len(XS) - 1):
        h = XS[i + 1] - XS[i]
        s += h * (YS[i] + YS[i + 1]) / 2 + h * h * (STEIG[i] - STEIG[i + 1]) / 12
    return s

def stuetzpunkte():
    """Die fünf Momente des Kräftefahrplans als Liste (Anteil, KG, N, Phase)."""
    return [{"s": XS[i], "kraft_kg": YS[i], "kraft_n": YS[i] * KG,
             "phase": PHASEN[i]} for i in range(len(XS))]

Zur Kontrolle schreibt Tabelle 7.1 die fünf Stützwerte aus, wie das Rechenwerk sie aus dem Kräftefahrplan übernimmt: je Phase den Anteil der Standphase und die Bodenkraft in Vielfachen des Körpergewichts und in Newton.

Tabelle 7.1: Die Bodenspalte des Kräftefahrplans — die einzigen Eingabezahlen dieses Kapitels. Die Höchstwerte 1,45 und 2,50 · KG stammen aus dem Zahlenanhang, die drei Zwischenwerte sind Modellannahme.
Anteil der Standphase Phase Bodenkraft Bodenkraft
0 % Fersenauftritt 1,45 · KG 1067 N
25 % Belastungsaufbau 2 · KG 1472 N
50 % mittlere Standphase 2,5 · KG 1840 N
75 % Fersenablösung 1,2 · KG 883,2 N
100 % Abstoß 0,3 · KG 220,8 N

Deutung unter der Tabelle. Diese fünf Stützwerte sind die einzigen Eingabezahlen des Kapitels; Kurve, Steigung und Fläche folgen allein aus ihnen. Die drei elementaren Rechenschritte, um die es geht — eine Steigung aus zwei Punkten und zwei Arten, eine Fläche aus Rechtecken zu summieren —, stehen weiter unten, jeder dort, wo sein Begriff eingeführt wird. Abbildung 7.1 stellt zunächst zwei Bilder untereinander: oben die Form, die eine Kraftmessplatte beim Fersenlauf aufzeichnet, unten den Verlauf, mit dem dieses Kapitel rechnet.

Code 
import numpy as np
import matplotlib.pyplot as plt

# Skizze der Messform: null an den Enden, zwei Gipfel auf den Kanonhöhen.
SX = [0.0, 0.12, 0.22, 0.45, 0.66, 0.85, 1.0]
SY = [0.0, 1.45, 1.30, 2.50, 1.90, 0.60, 0.0]
SM = pchip_steigungen(SX, SY)

def skizze(x):
    """Derselbe monotone Spline, angewandt auf die Stützpunkte der Skizze."""
    i = len(SX) - 2
    for k in range(len(SX) - 1):
        if x <= SX[k + 1]:
            i = k
            break
    h = SX[i + 1] - SX[i]
    t = (x - SX[i]) / h
    return ((2 * t ** 3 - 3 * t ** 2 + 1) * SY[i]
            + (t ** 3 - 2 * t ** 2 + t) * h * SM[i]
            + (-2 * t ** 3 + 3 * t ** 2) * SY[i + 1]
            + (t ** 3 - t ** 2) * h * SM[i + 1])

s = np.linspace(0, 1, 400)
fig, achsen = plt.subplots(2, 1, figsize=(7.0, 6.0))

ax = achsen[0]
ax.plot(s * 100, [skizze(x) for x in s], color="#4c72b0", lw=2.6)
for ort, hoehe, txt, (dx, dy) in [
        (0.12, 1.45, "passiver Gipfel\n1,45 · KG", (-4, 34)),
        (0.45, 2.50, "aktiver Gipfel\n2,5 · KG", (58, -6))]:
    ax.annotate(txt, xy=(ort * 100, hoehe), xytext=(dx, dy),
                textcoords="offset points", fontsize=8.5, color="#33517d",
                ha="center", arrowprops=dict(arrowstyle="->", color="#33517d"))
ax.set_title("So sieht eine Messung aus (Skizze, waagerecht nicht maßstäblich)",
             fontsize=10)
ax.set_ylabel("Bodenreaktionskraft (· KG)")
ax.set_xlim(0, 100)
ax.set_ylim(0, 2.9)
ax.set_xticks([0, 100])
ax.set_xticklabels(["Aufsetzen", "Abheben"])
ax.grid(True, axis="y", ls=":", lw=0.5, alpha=0.6)
de_achse(ax)
ax.set_xticks([0, 100])
ax.set_xticklabels(["Aufsetzen", "Abheben"])

ax = achsen[1]
f = np.array([kurve_wert(x) for x in s])
ax.plot(s * 100, f, color="#b3541e", lw=2.6)
for p in stuetzpunkte():
    ax.plot(p["s"] * 100, p["kraft_kg"], "o", color="#5b6b7a", ms=8, zorder=5)
    ax.annotate(p["phase"], xy=(p["s"] * 100, p["kraft_kg"]),
                xytext=(0, 10), textcoords="offset points", ha="center",
                fontsize=8, color="#444")
ax.set_title("Damit rechnet dieses Kapitel: fünf Stützwerte, glatt verbunden",
             fontsize=10)
ax.set_xlabel("Anteil der Standphase (%)")
ax.set_ylabel("Bodenreaktionskraft (· KG)")
ax.set_xlim(0, 100)
ax.set_ylim(0, 2.9)
ax.grid(True, ls=":", lw=0.5, alpha=0.6)
de_achse(ax)
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda v, _p: komma_sig(v, 3)))
plt.tight_layout()
plt.show()
Abbildung 7.1: Oben die typische Form der senkrechten Bodenreaktionskraft beim Fersenlauf: null beim Aufsetzen, ein schmaler passiver Gipfel (≈ 1,45 · KG), ein Einschnitt, der breite aktive Gipfel (2,5 · KG), null beim Abheben. Belegt sind an dieser Skizze nur die zwei Gipfelhöhen aus dem Zahlenanhang und die Nullwerte an den Enden; der Verlauf dazwischen und die waagerechte Lage der Gipfel sind gezeichnet und nicht maßstäblich, deshalb trägt die waagerechte Achse keine Zahlen. Unten der Verlauf, mit dem dieses Kapitel rechnet: die fünf Stützwerte des Kräftefahrplans (Punkte), glatt und überschwingungsfrei verbunden, über dem Anteil der Standphase. Beide y-Achsen zählen in Vielfachen des Körpergewichts KG = 736 N.

Deutung. Die gemessene Kurve hat zwei Gipfel. Der erste ist der Aufprall: Die Ferse trifft auf, die Kraft schnellt in einem kurzen Zacken hoch und fällt wieder ab. Der zweite ist die eigentliche Arbeit: Der Körper rollt über den Fuß, und die Kraft steigt breit auf ihren Höchstwert, bevor sie zum Abheben auf null zurückgeht. Der Verlauf des Kapitels darunter behält von dieser Form die Höchstwerte und die Reihenfolge der Momente; er verliert den schmalen Zacken (fünf Stützwerte lösen ihn nicht auf), und er beginnt und endet nicht bei null, weil der Kräftefahrplan Standbilder festhält und keine Ränder. Für Steigung und Fläche ist das ohne Belang: Beide Fragen — wo ist die Kurve am steilsten, wie groß ist die Fläche darunter — stellen sich an jeder Kurve gleich, und genau sie trennt dieses Kapitel.

7.2 Steigung: wie schnell sich die Kraft ändert

Die Steigung zwischen zwei Punkten ist der Höhenunterschied geteilt durch den waagerechten Abstand — bei einer Belastungskurve also die Kraftänderung je Stück Standphase. Nimmt man zwei Punkte im Abstand \(h\) um eine Stelle \(s_0\), ist die abgelesene Steigung der Differenzenquotient

\[ \frac{\Delta F}{\Delta s} \;=\; \frac{F\!\left(s_0 + \tfrac{h}{2}\right) - F\!\left(s_0 - \tfrac{h}{2}\right)}{h}. \]

Das ist die Steigung im Kleinen: die mittlere Änderungsrate über das kurze Stück \(h\). Weil die waagerechte Achse ein Anteil ist, hat die Steigung die Einheit Kraft je Anteil; eine Rate in Newton je Sekunde wäre es erst mit einer Schrittdauer.

Für die Steigung im Kleinen steht oben \(\Delta F/\Delta s\) — der Unterschied zweier Werte geteilt durch den Unterschied zweier Stellen. Rückt \(h\) gegen null, schreibt man dafür \(\mathrm{d}F/\mathrm{d}s\): dasselbe Verhältnis, nur mit einem \(\mathrm{d}\), das an ein beliebig klein gewordenes \(\Delta\) erinnert. Kapitel 8 und 9 benutzen diese Schreibweise durchgehend, dort mit dem Ort als Achse.

Die erste der drei Lehrfunktionen des Kapitels gießt genau diese Formel in wenige Zeilen: Sie nimmt eine beliebige Funktion f und liest ihre Steigung bei x0 aus zwei Punkten im Abstand h ab. Nichts weiter als der Bruch von oben — Höhenunterschied geteilt durch Abstand. Die zweite Zeile darunter setzt sie einmal fest auf die Bodenkurve an, damit die Bilder des Kapitels nur noch eine Stelle und einen Abstand zu nennen brauchen:

Der zentrale Differenzenquotient, mit Prüfung des Abstands h 
def zentraler_differenzenquotient(f, x0, h):
    """Steigung aus zwei Punkten im Abstand h um x0 (x0−h/2 und x0+h/2).
    Fehlerordnung h²; für eine Gerade exakt. h ≤ 0 ist unzulässig."""
    if not h > 0:
        raise ValueError(f"Abstand h muss positiv sein: {h}")
    return (f(x0 + h / 2) - f(x0 - h / 2)) / h

def boden_steigung(x0, h):
    """Differenzenquotient der Bodenreaktionskurve an x0 mit Abstand h."""
    return zentraler_differenzenquotient(kurve_wert, x0, h)

Die erste Funktion trägt kein Wissen über die Bodenkurve in sich — sie bekommt f übergeben und bildet den Differenzenquotienten; erst boden_steigung verbindet sie mit der Kurve aus den fünf Momenten. Genau das steckt hinter dem Regler unten: Der Schieberegler stellt h, und der Rechner hinter ihm ruft zentraler_differenzenquotient(kurve_wert, 0.30, h).

WichtigVorhersage-Punkt

Bevor du schiebst: Der Regler stellt den Abstand \(h\) der zwei Messpunkte um die Stelle 30 % der Standphase. Rückst du die Punkte näher zusammen — stabilisiert sich die abgelesene Steigung auf einen Wert, oder wird sie wild? Lege dich fest.

Drei Steigungen auf einen Blick: Abbildung 7.2 legt an drei Stellen der Kurve die Tangente an — die momentane Steigung, wenn die zwei Punkte ganz zusammengerückt sind.

Code 
import numpy as np
import matplotlib.pyplot as plt

s = np.linspace(0, 1, 300)
f = np.array([kurve_wert(x) for x in s])
# Extremstellen der Steigung berechnen (nicht raten): dichtes Raster.
raster = [k / 2000 for k in range(2001)]
s_steil = max(raster, key=kurve_steigung)          # größte positive Steigung
s_fall = min(raster, key=kurve_steigung)           # betragsgrößter (fallender) Anstieg
fig, ax = plt.subplots(figsize=(7.2, 4.2))
ax.plot(s * 100, f, color="#b3541e", lw=2.6)
tangenten = [(s_steil, "größte positive Steigung", (-70, 34), "center"),
             (0.50, "waagerecht am Maximum", (2, -34), "left"),
             (s_fall, "steilster Abfall", (44, -18), "left")]
for x0, txt, (dx, dy), ha in tangenten:
    m = kurve_steigung(x0)
    y0 = kurve_wert(x0)
    xg = np.array([x0 - 0.16, x0 + 0.16])
    ax.plot(xg * 100, y0 + m * (xg - x0), color="#d62728", lw=2)
    ax.plot(x0 * 100, y0, "o", color="#5b6b7a", ms=7)
    ax.annotate(txt + ": " + komma(m, 2) + "\nbei " + komma(x0 * 100, 0) + " %",
                xy=(x0 * 100, y0), xytext=(dx, dy), textcoords="offset points",
                ha=ha, fontsize=8.5, color="#d62728",
                arrowprops=dict(arrowstyle="-", color="#d62728", lw=0.6))
ax.set_xlabel("Anteil der Standphase (%)")
ax.set_ylabel("Bodenreaktionskraft (· KG)")
ax.set_title("Drei Tangenten — die Steigung ändert sich Punkt für Punkt")
ax.set_ylim(0, 2.9)
ax.grid(True, ls=":", lw=0.5, alpha=0.6)
de_achse(ax)
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda v, _p: komma_sig(v, 3)))
plt.tight_layout()
plt.show()
Abbildung 7.2: Dieselbe Kurve mit drei Tangenten: an der Stelle der größten positiven Steigung, am Maximum (waagerecht, Steigung null) und an der Stelle des steilsten Abfalls. Die Steigung ist an jeder Stelle eine andere Zahl — das ist die Ableitung als Funktion. Werte je Tangente in · KG je Anteil der Standphase.

Deutung. Die größte positive Steigung liegt nicht an einem der fünf Stützpunkte, sondern zwischen ihnen, im Belastungsaufbau bei rund einem Drittel der Standphase. Am Maximum ist die Kurve für einen Moment waagerecht (Steigung null). Der betragsgrößte Anstieg ist dagegen ein fallender, auf der Abfallflanke — steigende und betragsgrößte Änderung sind zwei verschiedene Stellen. Wo eine Steigung am größten ist, liest man deshalb nicht an den Stützpunkten ab, sondern rechnet es auf einem dichten Raster nach. Und die Ableitung ist selbst wieder eine Kurve: für jede Stelle eine eigene Steigung.

Wie diese zweite Kurve aussieht, zeigt Abbildung 7.3: oben noch einmal die Kraft über der Standphase, unten die zugehörige Steigung, Stelle für Stelle aufgetragen.

Code 
import numpy as np
import matplotlib.pyplot as plt

s = np.linspace(0, 1, 400)
fig, achsen = plt.subplots(2, 1, figsize=(7.0, 6.0), sharex=True)

ax = achsen[0]
ax.plot(s * 100, [kurve_wert(x) for x in s], color="#b3541e", lw=2.6)
ax.set_ylabel("Kraft F (· KG)")
ax.set_title("Die Kurve", fontsize=10)
ax.set_ylim(0, 2.9)
ax.grid(True, ls=":", lw=0.5, alpha=0.6)
de_achse(ax)

ax = achsen[1]
ax.plot(s * 100, [kurve_steigung(x) for x in s], color="#2a5d8a", lw=2.6)
ax.axhline(0, color="#555", lw=1.0)
ax.set_ylabel("Steigung dF/ds (· KG je Anteil)")
ax.set_xlabel("Anteil der Standphase (%)")
ax.set_title("Ihre Ableitung", fontsize=10)
ax.grid(True, ls=":", lw=0.5, alpha=0.6)
de_achse(ax)
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda v, _p: komma_sig(v, 3)))
plt.tight_layout()
plt.show()
Abbildung 7.3: Oben die Bodenkurve F(s), unten ihre Ableitung dF/ds über derselben waagerechten Achse. Wo die obere Kurve am steilsten steigt, hat die untere ihren Höchstwert; wo die obere ihr Maximum hat, kreuzt die untere die Nulllinie; wo die obere fällt, ist die untere negativ. Die untere Kurve zählt in · KG je Anteil der Standphase.

Deutung. Die untere Kurve ist keine zweite Messgröße, sondern eine andere Sicht auf dieselbe obere: Sie sagt an jeder Stelle, wie steil es dort zugeht. Ihr Höchstwert liegt dort, wo die Kraft am schnellsten wächst; ihr Nulldurchgang liegt genau unter dem Maximum der Kraft, denn dort steigt nichts mehr und fällt noch nichts; ihr tiefster Punkt liegt auf der Abfallflanke. Steigt die Kraft, ist die Ableitung positiv, fällt sie, negativ — das Vorzeichen der unteren Kurve liest die Richtung der oberen ab. In Kapitel 8 wird aus dieser zweiten Kurve eine Größe, die selbst an jedem Ort im Knochen einen Wert hat.

Vom Differenzenquotient zur Ableitung. Rückt man im Regler die zwei Punkte zusammen (\(h \to 0\)), nähert sich die abgelesene Steigung einem festen Wert: der momentanen Steigung an dieser Stelle, der Ableitung. Kein Grenzwert-Kalkül ist dafür nötig. Abbildung 7.4 macht das Beruhigen sichtbar: An der Stelle 30 % bekommt das Zeichenwerk die Stelle und eine Reihe schrumpfender Abstände \(h\); er zeichnet zu jedem \(h\) die Sekante durch die zwei Messpunkte und liest ihre Steigung ab. Zum Vergleich zeichnet er die Tangente — den Grenzwert — gestrichelt ein. Darunter steht mit boden_steigung der Kontrollwert der feinsten Sekante:

Fünf schrumpfende Sekanten in die Tangente laufen lassen 
x0 = 0.30
abstaende = [0.40, 0.20, 0.10, 0.05, 0.025]
zeichne_sekanten_in_tangente(kurve_wert, kurve_steigung, x0, abstaende)

h_fein = abstaende[-1]
print(f"feinste Sekante (h = {komma(h_fein, 3)}): "
      f"{komma(boden_steigung(x0, h_fein), 4)} · KG je Anteil "
      f"(Grenzwert {komma(kurve_steigung(x0), 4)})")
Abbildung 7.4: Sekanten an der Bodenreaktionskurve bei 30 % der Standphase für schrumpfende Abstände h = 0,40 / 0,20 / 0,10 / 0,05 / 0,025 (helle zu dunkle Linien) mit ihren zwei Messpunkten. Je kleiner h, desto mehr kippt die Sekante in die gestrichelte Tangente (den Grenzwert 2,59 · KG je Anteil); die abgelesene Steigung je Sekante steht in der Legende. 
feinste Sekante (h = 0,025): 2,5857 · KG je Anteil (Grenzwert 2,5905)

Deutung. Mit jeder Halbierung von \(h\) dreht sich die Sekante ein Stück weiter in die gestrichelte Tangente hinein; ihre Steigung rückt dichter an den Grenzwert 2,59 heran. Bei \(h = 0{,}025\) ist der Unterschied mit bloßem Auge kaum noch zu sehen — die Punkte müssen sich nur nahe genug kommen. Genau dieses Kippen der Sekante in die Tangente ist der Übergang vom Differenzenquotienten zur Ableitung.

7.3 Fläche: wie viel Last insgesamt zusammenkommt

Die zweite Frage ist die nach der Gesamtbelastung. Sie steckt in der Fläche unter der Kurve. Ein einfaches Rezept, sie zu schätzen: die Standphase in \(n\) gleich breite Streifen zerlegen, über jedem Streifen ein Rechteck stellen, dessen Höhe der Funktionswert in der Streifenmitte ist, und die Rechtecke aufsummieren. Das ist die Fläche unter der Kurve als Rechtecksumme:

\[ A \;\approx\; \sum_{i=1}^{n} F\!\left(s_i^{\text{Mitte}}\right)\,\Delta s, \qquad \Delta s = \frac{1}{n}. \]

Weil die Achse von 0 bis 1 läuft, ist diese Fläche zugleich die mittlere Kraft über den Schritt (Fläche geteilt durch die Breite 1). Eine Schrittdauer liegt nicht vor; multiplizierte man die mittlere Kraft mit der Standphasendauer, erhielte man den Impuls in Newtonsekunden — die Dauer fehlt, also bleibt es bei der mittleren Kraft (in Newton).

Die zweite Lehrfunktion setzt dieses Rezept um — sie legt \(n\) gleich breite Streifen an und summiert die Rechteckflächen. Daneben steht gleich eine Variante, die die Rechteckhöhe nicht in der Streifenmitte, sondern am linken Rand nimmt; wie verschieden gut die beiden treffen, misst der übernächste Abschnitt:

Die Mittelpunktsumme: n Rechtecke, Höhe aus der Streifenmitte 
def mittelpunktsumme(f, a, b, n):
    """n gleich breite Rechtecke, Höhe = Funktionswert in der Streifenmitte.
    Fehlerordnung asymptotisch h² (halbe Streifenbreite → Viertelfehler).
    n muss ganzzahlig und ≥ 1 sein."""
    if int(n) != n:
        raise ValueError(f"Streifenzahl n muss ganzzahlig sein: {n}")
    if not n >= 1:
        raise ValueError(f"Streifenzahl n muss ≥ 1 sein: {n}")
    dx = (b - a) / n
    s = 0.0
    for i in range(int(n)):
        s += f(a + (i + 0.5) * dx)
    return s * dx

def linkssumme(f, a, b, n):
    """Höhe = Funktionswert am linken Streifenrand. Fehlerordnung asymptotisch
    h¹ (halbe Streifenbreite → nur halber Fehler). n ganzzahlig und ≥ 1."""
    if int(n) != n:
        raise ValueError(f"Streifenzahl n muss ganzzahlig sein: {n}")
    if not n >= 1:
        raise ValueError(f"Streifenzahl n muss ≥ 1 sein: {n}")
    dx = (b - a) / n
    s = 0.0
    for i in range(int(n)):
        s += f(a + i * dx)
    return s * dx

def boden_flaeche_naeherung(n):
    """Mittelpunktsumme der Bodenreaktionskurve mit n Streifen (KG)."""
    return mittelpunktsumme(kurve_wert, 0.0, 1.0, n)

Die ersten beiden Funktionen sind wieder allgemein — sie summieren die Rechtecke einer beliebigen f; der einzige Unterschied zwischen ihnen ist die Stelle, an der jedes Rechteck seine Höhe abliest: Mitte gegen linken Rand. Die dritte setzt die Mittelpunktsumme wie schon bei der Steigung fest auf die Bodenkurve an.

WichtigVorhersage-Punkt

Bevor du schiebst: Der Regler erhöht die Zahl der Streifen \(n\) (grob → fein). Halbierst du die Streifenbreite — halbiert sich der Fehler der Flächen-Näherung, oder fällt er schneller? Lege dich fest.

Ein paar breite gegen viele schmale Rechtecke zeigt Abbildung 7.5 direkt.

Code 
import numpy as np
import matplotlib.pyplot as plt

s = np.linspace(0, 1, 300)
f = np.array([kurve_wert(x) for x in s])
wahr = flaeche_exakt()
fig, achsen = plt.subplots(2, 1, figsize=(6.8, 6.4))
for ax, n in zip(achsen, [3, 24]):
    dx = 1.0 / n
    for i in range(n):
        mitte = (i + 0.5) * dx
        ax.add_patch(plt.Rectangle((i * dx * 100, 0), dx * 100, kurve_wert(mitte),
                                   facecolor="#2a7d2a", alpha=0.18,
                                   edgecolor="#2a7d2a", lw=0.8))
    ax.plot(s * 100, f, color="#b3541e", lw=2.4)
    summe = boden_flaeche_naeherung(n)
    ax.set_title(str(n) + " Streifen — Summe " + komma_sig(summe * KG, 4)
                 + " N (wahr " + komma_sig(wahr * KG, 4) + " N)", fontsize=10)
    ax.set_ylabel("Kraft (· KG)")
    ax.set_ylim(0, 2.9)
    de_achse(ax)
achsen[-1].set_xlabel("Anteil der Standphase (%)")
plt.tight_layout()
plt.show()
Abbildung 7.5: Die Fläche unter der Kurve, erst mit wenigen breiten (n = 3, oben), dann mit vielen schmalen Rechtecken (n = 24, unten). Die Rechteckhöhe ist der Funktionswert in der Streifenmitte. Mit mehr Streifen kriecht die grüne Summe an die wahre Fläche (1229 N) heran; die über- und unterschätzten Ecken werden kleiner.

Deutung. Mit drei Streifen ist die Näherung grob — jedes Rechteck ragt an der einen Kante über die Kurve, an der anderen darunter. Mit vierundzwanzig Streifen schmiegt sich die Treppe an die Kurve; die Summe liegt schon nah an der wahren Fläche. Wie schnell dieser Fehler schrumpft, zeigt die Animation.

7.4 Die Streifen werden schmaler — das Integral im Grenzfall

WichtigVorhersage-Punkt

Bevor du abspielst: Die Animation verdoppelt die Streifenzahl Stufe um Stufe. Wie verhält sich der Fehler bei jeder Verdopplung — bleibt er, halbiert er sich, oder fällt er noch schneller? Schätze, bevor die Streifen laufen.

Lässt man die Streifen immer schmaler werden, nähert sich die Rechtecksumme einem festen Wert — der wahren Fläche. Dieser Grenzfall ist das Integral. Man muss ihn nicht ausrechnen, um ihn zu sehen: Die Summe beruhigt sich, so wie sich die abgelesene Steigung beruhigt hat. Wie schnell, hängt vom gewählten Rechteck ab. Statt die Fehler in eine Faktorentabelle zu schreiben, trägt das Kapitel sie doppelt-logarithmisch über der Streifenzahl auf — dort wird die Fehlerordnung zur ablesbaren Steigung einer Geraden. Sie rechnet die Fehler beider Verfahren mit den zwei Lehrfunktionen mittelpunktsumme und linkssumme und übergibt sie dem Plot; Abbildung 7.6 zeigt das Ergebnis:

Die Fehler beider Summen über wachsender Streifenzahl sammeln 
wahr = flaeche_exakt()
ns = [4, 8, 16, 32, 64, 128]
fehler_mitte = []
fehler_links = []
for n in ns:
    fehler_mitte.append(abs(mittelpunktsumme(kurve_wert, 0, 1, n) - wahr) * KG)
    fehler_links.append(abs(linkssumme(kurve_wert, 0, 1, n) - wahr) * KG)
zeichne_konvergenz_loglog(ns, fehler_mitte, fehler_links)

print(f"feinster Fehler bei n = {ns[-1]}: Mittelpunktsumme "
      f"{komma_sig(fehler_mitte[-1], 2)} N, Linkssumme "
      f"{komma_sig(fehler_links[-1], 2)} N")
Abbildung 7.6: Fehler der Flächen-Näherung über der Streifenzahl n, doppelt-logarithmisch (beide Achsen). Die Mittelpunktsumme (grün, Kreise) läuft parallel zur gestrichelten Referenzgeraden der Steigung −2 (Fehlerordnung zwei), die Linkssumme (orange, Quadrate) parallel zur Referenz der Steigung −1. Der Betrag der Steigung IST die Fehlerordnung. Fehler in Newton gegen die exakte Fläche (≈ 1229 N). 
feinster Fehler bei n = 128: Mittelpunktsumme 0,0095 N, Linkssumme 3,3 N

Deutung unter der Ausgabe. Im doppelt-logarithmischen Bild wird jede Fehlerreihe zur Geraden (die Linkssumme erst asymptotisch), und der Betrag ihrer Steigung ist die Fehlerordnung. Die Mittelpunktsumme läuft parallel zur Referenzgeraden der Steigung −2: Verdoppelt man die Streifenzahl, viertelt sich der Fehler — er fällt also schneller als halbiert. Das ist die Antwort auf die Vorhersagefrage, und sie überrascht: Doppelt so fein bringt viermal so genau. Die Linkssumme, die die Höhe am linken Rand statt in der Mitte nimmt, folgt der Referenzgeraden der Steigung −1: Ihr Fehler halbiert sich nur. Die Mitte eines Streifens ist der bessere Vertreter seiner Fläche als sein Rand — mehr steckt nicht dahinter. Beide Steigungen gelten asymptotisch, für hinreichend viele Streifen dieser glatten Kurve; an einem Knick wäre die Aussage vorsichtiger zu fassen.

Dieses Bild kehrt in Kapitel 13 wieder — dann steht auf der waagerechten Achse nicht die Streifenzahl, sondern die Feinheit des Netzes, und die abgelesene Steigung sagt, wie schnell die Rechnung mit feinerem Netz besser wird.

7.5 Warum das Buch beides braucht

Steigung und Fläche geben zwei verschiedene Antworten auf denselben Schritt, und das Buch braucht beide: die Steigung als Werkzeug für die räumliche Änderung der Spannung im Gleichgewicht (Kapitel 8), die Fläche für die über den Schritt gemittelte Last (Teil V).

Für die Steigung wechselt dabei nur die waagerechte Achse. Bisher stand dort der Anteil der Standphase, und die Steigung hieß: wie schnell ändert sich die Kraft im Lauf des Schrittes. In Kapitel 8 steht dort ein Ort im Knochen, und dieselbe Rechnung — Unterschied zweier Werte geteilt durch den Abstand zweier Stellen — heißt dann: wie schnell ändert sich die Spannung von einer Stelle zur nächsten. Abbildung 7.7 stellt beide untereinander.

Code 
import numpy as np
import matplotlib.pyplot as plt

fig, achsen = plt.subplots(2, 1, figsize=(7.0, 6.0))

ax = achsen[0]
s = np.linspace(0, 1, 400)
ax.plot(s * 100, [kurve_wert(x) for x in s], color="#b3541e", lw=2.6)
x0 = 0.33
m0, y0 = kurve_steigung(x0), kurve_wert(x0)
xg = np.array([x0 - 0.14, x0 + 0.14])
ax.plot(xg * 100, y0 + m0 * (xg - x0), color="#d62728", lw=2)
ax.plot(x0 * 100, y0, "o", color="#5b6b7a", ms=7)
ax.annotate("Steigung dF/ds", xy=(x0 * 100, y0), xytext=(8, -26),
            textcoords="offset points", fontsize=9, color="#d62728")
ax.set_title("über der Standphase: Änderung im Lauf des Schrittes", fontsize=10)
ax.set_xlabel("Anteil der Standphase (%)")
ax.set_ylabel("Kraft F (· KG)")
ax.set_ylim(0, 2.9)
ax.grid(True, ls=":", lw=0.5, alpha=0.6)
de_achse(ax)
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda v, _p: komma_sig(v, 3)))

ax = achsen[1]
# Schematische Form ohne Zahlenwerte: Spannung fällt vom Lasteintrag nach innen.
xs = np.linspace(0, 1, 400)
sigma = 0.25 + 0.75 * np.exp(-3.2 * xs)
ax.plot(xs, sigma, color="#2a5d8a", lw=2.6)
xs0 = 0.35
ms = -3.2 * 0.75 * np.exp(-3.2 * xs0)
ys0 = 0.25 + 0.75 * np.exp(-3.2 * xs0)
xg = np.array([xs0 - 0.16, xs0 + 0.16])
ax.plot(xg, ys0 + ms * (xg - xs0), color="#d62728", lw=2)
ax.plot(xs0, ys0, "o", color="#5b6b7a", ms=7)
ax.annotate("Steigung dσ/dx", xy=(xs0, ys0), xytext=(10, 14),
            textcoords="offset points", fontsize=9, color="#d62728")
ax.set_title("über dem Ort: Änderung von Stelle zu Stelle (schematisch)",
             fontsize=10)
ax.set_xlabel("Ort x entlang einer Linie durch den Knochen")
ax.set_ylabel("Spannung σ (schematisch)")
ax.set_xlim(0, 1)
ax.set_ylim(0, 1.15)
ax.set_xticks([]); ax.set_yticks([])
plt.tight_layout()
plt.show()
Abbildung 7.7: Dieselbe Steigung, andere Achse. Oben die Bodenkraft über dem Anteil der Standphase; die Tangente beantwortet: wie schnell ändert sich die Kraft im Lauf des Schrittes. Unten, rein schematisch und ohne Zahlenwerte, eine Spannung entlang einer Linie durch den Knochen; dieselbe Tangente beantwortet dort: wie schnell ändert sich die Spannung von Ort zu Ort. Das untere Bild zeigt eine Form, keine gerechneten Werte; Kapitel 8 rechnet sie.

Deutung. Die Rechnung ändert sich nicht, nur ihre Bedeutung. Oben teilt man einen Kraftunterschied durch einen Unterschied im Schrittverlauf, unten einen Spannungsunterschied durch einen Abstand in Millimetern. Beide Male ist die Steigung eine örtliche Aussage über eine Stelle, und beide Male steht dafür das \(\mathrm{d}\): \(\mathrm{d}F/\mathrm{d}s\) hier, \(\mathrm{d}\sigma/\mathrm{d}x\) in Kapitel 8. Wer die eine Steigung ablesen kann, kann auch die andere.

An der Fläche hängt dagegen eine verbreitete Fehlvorstellung.

WarnungDie höchste Spitze ist nicht die ganze Geschichte

Vermutung: „Der Knochen merkt die Spitzenkraft, alles andere ist egal — es zählt der eine höchste Wert.”

Warum sie naheliegt: Das Maximum (2,5 · KG) ist die auffälligste Zahl der Kurve, und ein einzelner Extremwert ist leicht zu benennen.

Was stattdessen gilt: Eine einzelne Spitze genügt nicht, um den Schritt zu beschreiben. Aber auch die Fläche allein genügt nicht: Gleiche Fläche heißt gleiche mittlere Kraft, und der Knochen antwortet nicht auf die Kraft, sondern auf die Energie, die die Kraft in ihm speichert. Die wächst mit dem Quadrat der Last. Ein kurzer harter Moment speichert deshalb mehr als ein langer sanfter von gleicher Fläche. Deshalb wechselt das Buch unterwegs das Maß: Kapitel 14 beschreibt den Schritt zunächst als gewichtetes Mittel der Kräfte — ein Maß, das mit der Last linear wächst; Kapitel 15 und 16 wechseln dann auf die je Masse gespeicherte Formänderungsenergiedichte, die mit dem Quadrat der Last wächst. Beide Mittel brauchen die Fläche als Werkzeug, und keines braucht die Spitze allein.

Dass gleiche Fläche gleiche mittlere Kraft bedeutet — bei ganz verschiedener Form —, zeigt Abbildung 7.8 an zwei symbolischen Verläufen.

Code 
import numpy as np
import matplotlib.pyplot as plt

# Zwei Dreiecke gleicher Fläche ½·b·H: (H, b) und (H/2, 2b). Rein symbolisch,
# ohne KG-Werte an der Achse.
H, b = 1.0, 0.4                          # Platzhalter, nur zum Zeichnen
formen = [(H, b, "schmal und hoch:  Höhe H, Basis b"),
          (H / 2, 2 * b, "breit und niedrig:  Höhe H/2, Basis 2 b")]
fig, achsen = plt.subplots(2, 1, figsize=(6.8, 6.0))
for ax, (hoehe, basis, titel) in zip(achsen, formen):
    xs = np.array([0, basis / 2, basis])
    ys = np.array([0, hoehe, 0])
    ax.fill(np.concatenate([xs, [0]]), np.concatenate([ys, [0]]),
            color="#b3541e", alpha=0.25)
    ax.plot(xs, ys, color="#b3541e", lw=2.4)
    ax.annotate("H" if hoehe == H else "H/2", xy=(basis / 2, hoehe),
                xytext=(6, -4), textcoords="offset points", fontsize=11)
    ax.text(basis, -0.06, "b" if basis == b else "2 b", ha="center", fontsize=11)
    ax.set_title(titel + "   →   Fläche ½ · b · H", fontsize=10)
    ax.set_ylabel("Kraft (schematisch)")
    ax.set_xlim(0, 1.0)
    ax.set_ylim(0, 1.15)
    ax.set_xticks([]); ax.set_yticks([])
achsen[-1].set_xlabel("Anteil der Standphase (schematisch)")
plt.tight_layout()
plt.show()
Abbildung 7.8: Zwei symbolische Verläufe mit identischer Fläche (rein schematisch, ohne Zahlenwerte): oben ein schmaler, hoher Verlauf (Höhe H, Basis b), unten ein breiter, niedriger (Höhe H/2, Basis 2 b). Beide Dreiecke haben die Fläche ½ · b · H — gleiche mittlere Kraft trotz ganz verschiedener Form und verschiedener Spitze. Die Skizze führt keine Kraftwerte ein; H und b sind Platzhalter.

Deutung. Die obere Form ist doppelt so hoch und halb so breit wie die untere, und doch tragen beide dieselbe Fläche ½ · b · H — dieselbe mittlere Kraft. Die Spitzen sind verschieden, der Mittelwert ist gleich. Das ist aber erst die halbe Aussage: Weil die gespeicherte Energie mit dem Quadrat der Last wächst, ist sie bei der schmalen hohen Form größer als bei der breiten niedrigen — gleiche Fläche heißt gleiche mittlere Kraft, nicht gleiche Energie. Genau deshalb greift das Buch weder die Spitze noch die Fläche allein heraus.

Editierbare Zelle — rechne die mittlere Kraft selbst und sieh zu, wie sie sich mit der Streifenzahl beruhigt. Die Zelle läuft im Browser und trägt deshalb alles bei sich: oben ein kurzes Gerüst, das dieselbe glatte Kurve aufspannt wie im Kapitel (die fünf Knotensteigungen stehen dort als fertige Zahlen, statt noch einmal hergeleitet zu werden), unten den Lehrgedanken — die Mittelpunktsumme und die Liste der Streifenzahlen, die du ändern darfst. Das Bild trägt jede Näherung als Punkt auf, die gestrichelte Linie ist die wahre Fläche; wo ein Punkt sie erreicht, ist die Näherung ausgereizt.

Deutung. Mit einem einzigen Streifen liegt die Näherung noch weit über der wahren Fläche — das eine Rechteck liest seine Höhe in der Mitte ab, und dort ist die Kurve am höchsten. Mit zweien schießt sie nach unten durch; ab etwa fünf Streifen liegt sie schon dicht an der gestrichelten Linie, und von zwanzig auf hundert Streifen ist der Unterschied im Bild nicht mehr zu sehen. Das ist dieselbe Annäherung wie am Regler und in der Animation — hier zum Selbst-Ausprobieren, ohne dass für das Verständnis eine Zeile Python nötig wäre.

Übungen

Ü 7.1 (Verstehen). Bestimme mit Abbildung 7.2 die Stelle der größten positiven Steigung und beschreibe, wo die größte Fläche liegt. Erkläre, warum das zwei verschiedene Orte sind — und warum die Steigungsstelle zwischen den fünf Stützpunkten liegen kann.

Die größte positive Steigung liegt nicht am Rand, sondern im Belastungsaufbau bei rund einem Drittel der Standphase — und damit zwischen zwei Stützpunkten, denn zwischen ihnen verläuft die Kurve glatt und darf dort steiler sein als an ihnen. Wer sie sucht, rechnet sie auf einem dichten Raster nach, statt sie an einem Stützpunkt abzulesen. Der betragsgrößte Anstieg ist übrigens ein anderer, fallender, auf der Abfallflanke. Die größte Fläche steckt nicht an einer Stelle, sondern im breiten mittleren Bereich um das Maximum, wo die Kurve lange hoch verläuft. Steigung ist eine Eigenschaft eines Punktes (wie schnell ändert sich die Kraft dort), Fläche eine Eigenschaft eines Bereichs (wie viel Last kam dort zusammen) — deshalb fallen sie nicht zusammen.

Ü 7.2 (Verändern). Öffne den Streifen-Regler und protokolliere den Näherungsfehler für \(n = 4, 8, 16, 32\). Sage vorher, ob sich der Fehler bei jeder Verdopplung halbiert. Was beobachtest du?

Der Fehler viertelt sich bei jeder Verdopplung, nicht halbiert (Mittelpunktsumme, Ordnung zwei) — Abbildung 7.6 zeigt das als Gerade der Steigung −2. Von \(n = 4\) (Fehler rund 10 N) zu \(n = 32\) fällt er auf etwa ein Vierundsechzigstel. Doppelt so fein bringt viermal so genau; das ist mehr, als die naheliegende Vorhersage „halbiert” erwartet.

Ü 7.3 (Übertragen). In Kapitel 6 war der E-Modul die Steigung der Spannungs-Dehnungs-Geraden. Wie liest man aus einer gemessenen Spannungs-Dehnungs-Kurve den (Tangenten- bzw. Sekanten-)E-Modul als Steigung ab, und was entspricht dort der „Fläche unter der Kurve”?

Trägt man Spannung über Dehnung auf, ist nicht die Spannung die Steigung (sie ist der senkrechte Wert), sondern die Steigung der Kurve ist der E-Modul: der Differenzenquotient \(\Delta\sigma/\Delta\varepsilon\) aus zwei nahen Messpunkten, im Grenzfall die Ableitung \(\mathrm{d}\sigma/\mathrm{d}\varepsilon\). Bei einer Geraden (Hookescher Bereich) ist diese Steigung überall gleich \(E\); bei einem nichtlinearen Material (Fettpolster) ändert sie sich Punkt für Punkt — dort unterscheidet man den Tangentenmodul (lokale Steigung) vom Sekantenmodul (Steigung vom Ursprung zum Betriebspunkt). Die Fläche unter der Spannungs-Dehnungs-Kurve ist die je Volumen gespeicherte Verformungsenergie, dieselbe Flächenidee mit anderen Größen. Merk dir diese Fläche: In Kapitel 16 wird sie zu dem Signal, auf das der Knochen antwortet.

Roter Faden

Wo kam das schon vor, wo kommt es wieder? Zurück: Die Spannungs-Dehnungs- Gerade aus Kapitel 6 ist eine Ableitung — der E-Modul ist ihre Steigung. In der Studiums-Tabelle im Vorwort stehen dafür die zwei Zeilen „Steigung einer Messkurve → Ableitung” und „Fläche unter der Belastungskurve → Integral”; dieses Kapitel löst beide ein (fortgeschrieben wird die Tabelle am Ende von Teil III, Kapitel 9). Vor: Die Ableitung wird zum Gleichgewicht in jedem Punkt und damit zur partiellen Differentialgleichung (Kapitel 8) — dort über dem Ort statt über der Standphase; das Integral wird zur numerischen Flächenberechnung über die Elemente (Kapitel 10) und zur Mittelung über den Schritt: in Kapitel 14 als Mittel der Kräfte, in Kapitel 16 als Mittel der gespeicherten Energien. Das doppelt-logarithmische Fehlerbild kehrt in Kapitel 13 wieder, dann über der Netzfeinheit.

Was dieses Kapitel NICHT tut

Es gibt keine Grenzwertdefinition mit ε und δ, keine Ableitungsregeln (Produkt- oder Kettenregel), keine analytische Integration von Formeln und keine Differentialgleichung — die kommt in Kapitel 8. Steigung und Fläche bleiben hier anschauliche, numerisch fassbare Größen: die eine als Differenzenquotient zweier naher Punkte, die andere als Summe schmaler Rechtecke. Die Kurve, auf der das geschieht, ist kein Messschrieb, sondern der glatt verbundene Kräftefahrplan aus Kapitel 2; ihre Fläche liefert die mittlere Kraft, nicht den Impuls in Newtonsekunden, weil keine Schrittdauer vorliegt. Wie eine gemessene Kurve gegenüber dieser Vereinfachung aussieht, zeigt das erste Bild des Kapitels — die Messung selbst führt das Buch nicht.