5 Steigung und Fläche

Bis hierher war der Träger eine Kette: Knoten, die an ihren Nachbarn ziehen, Federn, die sich addieren, ein Gleichungssystem, das wir lösen. Kein einziges Mal mussten wir dabei etwas ableiten oder integrieren — reine Schulalgebra, wie versprochen. Jetzt, zu Beginn des dritten Teils, kommt zum ersten Mal die Physik der Wärme ins Spiel, und mit ihr zwei Fragen, die uns von nun an bei jedem Temperaturprofil begegnen werden.

Schau dir die Momentaufnahme unseres Trägers an: dieselbe Szene wie in Kapitel 1, der Brandherd rechts unten, die Wärme unterwegs nach links dem kühlen Auflager entgegen — eingefroren eine halbe Stunde nach dem Ausbruch des Feuers. Und das Erste, was auffällt: Nach dreißig Minuten liegt die linke Hälfte des Trägers noch fast so kalt da wie zu Beginn. Die Hitze ist erst gut eine Handbreit weit ins Metall gekrochen; die Mitte weiß noch nichts vom Feuer.

Code

import numpy as np
import matplotlib.pyplot as plt

def temperatur(ort):
    leit = 50.0 / (7850.0 * 460.0)
    zeit = 1800.0
    wert = 20.0 + 480.0 * ort
    for n in range(1, 6):
        b = 960.0 * ((-1.0) ** n) / (n * np.pi)
        wert = wert + b * np.sin(n * np.pi * ort) * np.exp(-leit * (n * np.pi) ** 2 * zeit)
    return wert

x = np.linspace(0.0, 1.0, 400)
T = temperatur(x)

fig, ax = plt.subplots(figsize=(8.5, 4.2))
ax.fill_between(x, 0, T, color="tab:blue", alpha=0.12)
ax.plot(x, T, color="tab:orange", lw=2.2)

# Steigungs-Pfeil (Tangente) nahe am Brandherd
x0 = 0.8
m = 1148.56
ax.plot([x0 - 0.07, x0 + 0.07], [temperatur(x0) - m * 0.07,
        temperatur(x0) + m * 0.07], color="tab:green", lw=2.4)
ax.annotate("wie steil?", xy=(x0 - 0.05, temperatur(x0) - m * 0.05),
            xytext=(0.50, 300), color="tab:green", fontsize=11,
            arrowprops=dict(arrowstyle="->", color="tab:green"))
ax.text(0.45, 45, "wie viel Fläche?", color="tab:blue", fontsize=11)

ax.add_patch(plt.Rectangle((-0.03, -8), 0.03, 40, hatch="///",
                           facecolor="lightsteelblue", edgecolor="black",
                           clip_on=False))
ax.text(-0.02, 40, "20 °C", ha="center", va="bottom", fontsize=9)
for mitte in (1.0, 1.05):
    ax.fill([mitte - 0.03, mitte, mitte + 0.03], [470, 500, 470],
            color="orangered", clip_on=False)
ax.text(1.06, 500, "Brandherd", va="center", color="orangered", fontsize=10)

ax.set_xlim(-0.05, 1.18)
ax.set_ylim(0, 540)
ax.set_xlabel("Ort entlang des Trägers (m)")
ax.set_ylabel("Temperatur (°C)")
ax.set_title("Zwei Fragen an ein Temperaturprofil")
plt.tight_layout()
plt.show()

Abbildung 5.1: Das Temperaturprofil des Trägers nach 30 Minuten (die Momentaufnahme aus Kapitel 1, hier als glatte Kurve). Links hält das kühle Auflager 20 °C, rechts sitzt der Brandherd (500 °C); dazwischen liegt der Träger über die linke Hälfte noch fast kalt und steigt erst nahe dem Feuer steil an. Zwei Fragen stellt uns dieser Verlauf ab jetzt immer wieder: Wie steil ist er nahe am Brandherd (grüner Pfeil)? Und wie viel Fläche liegt unter ihm (blau)?

Was man hier sieht: kein gleichmäßiges Gefälle, sondern eine Kurve, die über die linke Hälfte fast flach bei 20 °C liegt und erst zum Brandherd hin steil emporschießt. Das ist der Fingerabdruck von Stahl: Die Wärme braucht Zeit, um vorzudringen — nach einer halben Stunde reicht ihr spürbarer Einfluss nur etwa eine Handbreit weit ins Metall. Zwei Fragen drängen sich auf. Die erste: Wie steil steigt die Temperatur zum Brandherd hin? Denn ein steiles Gefälle treibt viel Wärme — das ist der Motor des Wärmestroms, den Kapitel 6 aufbaut. Die zweite: Wie viel Fläche liegt unter der Kurve? Denn diese Fläche ist ein Maß für die Wärme, die insgesamt im Träger steckt — und genau solche Flächen wird Kapitel 7 für jedes Element ausrechnen.

Steigung und Fläche: mehr Analysis braucht dieses Buch nicht. Und das Beste kommt gleich zu Beginn — beide lassen sich für Geraden mit reiner Schulgeometrie exakt bestimmen, mit dem Dreieck und dem Trapez. Weil unsere FEM fast nur mit Geraden rechnet, ist das keine Nebensache, sondern der ganze Trick.

Die kalte Mitte — warum Feuerwiderstand in Minuten zählt

Nach dreißig Minuten steht die Mitte des Trägers bei \(x = 0{,}5\ \mathrm{m}\) gerade einmal bei rund 32 °C — kaum mehr als handwarm, obwohl am rechten Ende 500 °C herrschen. Das ist kein Rechenfehler, sondern die Trägheit des Stahls: In der Zeit \(t\) wandert der spürbare Wärmeeinfluss nur etwa \(\sqrt{a\cdot t}\) weit ins Metall, mit der Temperaturleitfähigkeit \(a = 1{,}385\cdot 10^{-5}\ \mathrm{m^2/s}\) des Stahls. Nach einer halben Stunde sind das \(\sqrt{1{,}385\cdot 10^{-5} \cdot 1800}\approx 0{,}16\ \mathrm{m}\) — rund 16 Zentimeter. Genau deshalb misst man Feuerwiderstand in Minuten — R30, R60, R90 —: Es ist eine Frage der Zeit, wie weit die Hitze bis zum tragenden Kern und bis zum Auflager vordringt. Für dieses Kapitel heißt das: In der Mitte ist noch fast nichts los. Wollen wir sehen, wie steil die Temperatur ansteigt, müssen wir dorthin schauen, wo etwas geschieht — nahe an den Brandherd, zu \(x = 0{,}8\ \mathrm{m}\).

Lernziele

Nach diesem Kapitel kannst du …

… die Steigung eines Temperaturprofils an einer Stelle aus zwei nahen Punkten berechnen (den Differenzenquotienten \(\Delta T / \Delta x\)) und in °C/m angeben,
… erklären, was beim Schrumpfen des Abstands \(h\) passiert und was die „Ableitung” \(\mathrm{d}T/\mathrm{d}x\) dann bedeutet,
… eine Fläche unter einer Kurve mit Rechteckstreifen annähern und die Näherung durch mehr Streifen verbessern,
… für Geraden und Stücke aus Geraden Steigung und Fläche exakt angeben — mehr braucht die FEM dieses Buches nicht,
… das Symbol \(\int\) lesen als „Summe aus unendlich schmalen Streifen”.

Naheliegende Vermutung

Vermutung: „Für die Finite-Elemente-Methode braucht man das ganze Analysis-Studium: Ableitungsregeln, Integraltabellen, Grenzwerte. Ohne das kommt man an eine Wärmerechnung gar nicht heran.”

Warum sie naheliegt: Ableiten und Integrieren gelten als der schwere Stoff der Oberstufe und der ersten Semester. Und die FEM rechnet doch Wärmeleitung aus — die steht in den Lehrbüchern voller Integrale.

Was stattdessen stimmt: Die schweren Werkzeuge stecken in der Methode, nicht im Anwender. Unsere Ansatzfunktionen sind Geraden (Kapitel 7). Die Steigung einer Geraden ist ein Dreieck (Höhe durch Breite), die Fläche unter einer Geraden ist ein Trapez — beides Schulgeometrie, beides exakt, ganz ohne Grenzwert. Der ganze „unendlich klein”-Apparat wird genau einmal gebraucht, um zu begründen, warum die Geradenrechnung erlaubt ist; danach rechnest du nur noch mit Dreiecken und Trapezen. Dieses Kapitel zeigt beide Seiten: erst, was „unendlich klein” anschaulich heißt, dann, wie wenig davon beim Rechnen übrig bleibt.

Erste Frage: Wie steil?

5.1 Die Steigung zwischen zwei Punkten

Fangen wir handfest an. „Wie steil steigt die Temperatur?” heißt: Um wie viel Grad ändert sie sich, wenn ich ein Stück am Träger weitergehe? Das ist genau die Frage nach einer Steigung — dieselbe, die du von einer Straße kennst: „zehn Prozent Steigung” heißt zehn Meter Höhe auf hundert Meter Weg, also Höhenunterschied geteilt durch zurückgelegte Strecke.

Beim Träger ist die „Höhe” die Temperatur und der „Weg” der Ort. Weil in der Mitte noch fast nichts passiert, gehen wir nahe an den Brandherd. Nimm die Stelle \(x = 0{,}8\ \mathrm{m}\) und den Punkt ganz rechts am Brandherd bei \(x = 1{,}0\ \mathrm{m}\). Der Fühler zeigt dort

\[ T(0{,}8) = 197{,}77\ °\mathrm{C}, \qquad T(1{,}0) = 500{,}00\ °\mathrm{C}. \]

Die Verbindungslinie dieser beiden Punkte nennt man eine Sekante (von lateinisch secare, schneiden — sie schneidet die Kurve in zwei Punkten). Ihre Steigung ist der Temperaturunterschied geteilt durch den Ortsunterschied:

\[ \text{Steigung} \;=\; \frac{\Delta T}{\Delta x} \;=\; \frac{T(1{,}0) - T(0{,}8)}{1{,}0 - 0{,}8} \;=\; \frac{500{,}00 - 197{,}77}{0{,}2} \;=\; \frac{302{,}23}{0{,}2} \;=\; 1511{,}2\ \frac{°\mathrm{C}}{\mathrm{m}}. \]

Das Zeichen \(\Delta\) (großes griechisches Delta) heißt schlicht „Unterschied”: \(\Delta T\) ist der Temperaturunterschied, \(\Delta x\) der Ortsunterschied. Und die Einheit verrät sofort, was die Zahl bedeutet: °C pro Meter. Über diese zwanzig Zentimeter steigt die Temperatur im Schnitt um rund 1500 Grad je Meter — das ganze Gefälle drängt sich in den schmalen Streifen nahe dem Brandherd. Abbildung 5.2 zeichnet die Sekante ein.

Code

import numpy as np
import matplotlib.pyplot as plt

def temperatur(ort):
    leit = 50.0 / (7850.0 * 460.0)
    zeit = 1800.0
    wert = 20.0 + 480.0 * ort
    for n in range(1, 6):
        b = 960.0 * ((-1.0) ** n) / (n * np.pi)
        wert = wert + b * np.sin(n * np.pi * ort) * np.exp(-leit * (n * np.pi) ** 2 * zeit)
    return wert

x = np.linspace(0.62, 1.0, 200)
fig, ax = plt.subplots(figsize=(7.5, 4.6))
ax.plot(x, temperatur(x), color="tab:orange", lw=2.2, label="Temperaturprofil")

xa, xb = 0.8, 1.0
Ta, Tb = temperatur(xa), temperatur(xb)
ax.plot([xa, xb], [Ta, Tb], color="tab:green", lw=2.0, label="Sekante")
ax.plot([xa, xb], [Ta, Ta], color="0.4", lw=1.2, ls="--")
ax.plot([xb, xb], [Ta, Tb], color="0.4", lw=1.2, ls="--")
ax.plot([xa, xb], [Ta, Tb], "o", color="tab:green", ms=9,
        markeredgecolor="black", zorder=5)
ax.text((xa + xb) / 2, Ta - 34, "Δx = 0,2 m", ha="center", fontsize=10,
        color="0.3")
ax.text(xb + 0.005, (Ta + Tb) / 2, "ΔT = 302,2 °C", va="center", fontsize=10,
        color="0.3")
ax.annotate("Steigung = ΔT / Δx = 1511,2 °C/m", xy=(0.9, (Ta + Tb) / 2),
            xytext=(0.63, 430), fontsize=10, color="tab:green",
            arrowprops=dict(arrowstyle="->", color="tab:green"))
ax.text(xa, Ta + 12, "197,8 °C", ha="right", fontsize=9)
ax.text(xb, Tb - 6, "500,0 °C", ha="right", va="top", fontsize=9)
ax.set_xlabel("Ort x (m)")
ax.set_ylabel("Temperatur (°C)")
ax.set_title("Steigung als Steigungsdreieck")
ax.legend(loc="upper left")
plt.tight_layout()
plt.show()

Abbildung 5.2: Die Sekante durch die Punkte bei x = 0,8 m (197,8 °C) und x = 1,0 m am Brandherd (500 °C). Das Steigungsdreieck darunter zeigt Δx = 0,2 m (waagerecht) und ΔT = 302,2 °C (senkrecht); die Steigung ist ihr Verhältnis, 1511,2 °C/m. Die Sekante ist flacher als die Kurve dicht am Brandherd und steiler als links davon — sie mittelt über das Stück.

Was man hier sieht: ein rechtwinkliges Steigungsdreieck. Die waagerechte Kathete ist \(\Delta x = 0{,}2\ \mathrm{m}\), die senkrechte \(\Delta T = 302{,}2\ °\mathrm{C}\), und die Steigung der Sekante ist ihr Verhältnis. Das ist reine Schulgeometrie — kein Grenzwert, keine Ableitungsregel. Genau dieses Dreieck werden wir gleich immer kleiner machen.

Bevor wir das tun, gießen wir die Rechnung in eine kleine Funktion. Erst brauchen wir aber das Profil selbst als etwas, das wir befragen können — eine Funktion, die zu jedem Ort die Temperatur zurückgibt. Wir haben die 30-Minuten-Momentaufnahme aus Kapitel 1 dafür in die Funktion temperatur gegossen. Wie sie im Inneren rechnet, ist hier Nebensache — die Formel dahinter begründen Kapitel 6 und Kapitel 12; für uns ist sie einfach ein Fühler, den wir an jede Stelle des Trägers halten können.

Code

import math


def temperatur(ort):
    """Temperatur des Trägers am gegebenen Ort, 30 Minuten nach dem Ausbruch.

    ort: Stelle auf dem Träger, 0 (kühles Auflager) bis 1 (Brandherd), in Metern.
    Rueckgabe: Temperatur an dieser Stelle in Grad Celsius.

    Das ist die Momentaufnahme aus Kapitel 1 als glatte Kurve. Woher die
    Formel kommt, entwickeln die Kapitel 6 und 12; hier ist sie nur unser
    Messobjekt.
    """
    leitfaehigkeit = 50.0 / (7850.0 * 460.0)
    zeit = 30.0 * 60.0
    wert = 20.0 + 480.0 * ort
    for n in range(1, 6):
        vorzeichen = (-1.0) ** n
        beitrag = 960.0 * vorzeichen / (n * math.pi)
        abklingen = math.exp(-leitfaehigkeit * (n * math.pi) ** 2 * zeit)
        wert = wert + beitrag * math.sin(n * math.pi * ort) * abklingen
    return wert


def steigung_zwischen(ort_links, ort_rechts):
    """Steigung der Sekante durch zwei Punkte des Profils (in Grad C pro Meter).

    ort_links, ort_rechts: die beiden Orte in Metern.
    Rueckgabe: Temperaturunterschied geteilt durch Ortsunterschied.
    """
    delta_temperatur = temperatur(ort_rechts) - temperatur(ort_links)
    delta_ort = ort_rechts - ort_links
    return delta_temperatur / delta_ort


print("T(0,8 m) = %.2f °C" % temperatur(0.8))
print("T(1,0 m) = %.2f °C" % temperatur(1.0))
print("Sekantensteigung 0,8 → 1,0 m: %.1f °C/m" % steigung_zwischen(0.8, 1.0))

T(0,8 m) = 197.77 °C
T(1,0 m) = 500.00 °C
Sekantensteigung 0,8 → 1,0 m: 1511.2 °C/m

Interpretation der Ausgabe: dieselben Zahlen wie in der Handrechnung — 197,77 °C, 500,00 °C und daraus die Steigung 1511,2 °C/m. Die Funktion steigung_zwischen tut nichts anderes als das Steigungsdreieck: oben der Unterschied, unten der Abstand, dann teilen. Sie ist unser Werkzeug für das nächste Experiment.

5.2 Das Steigungsdreieck schrumpfen lassen

Die Sekante über zwanzig Zentimeter hat einen Schönheitsfehler: Sie mittelt über ein ganzes Stück Kurve. Links von \(1{,}0\ \mathrm{m}\) ist die Kurve flacher, ganz rechts am Brandherd steiler; die Sekante mischt beides. Wir wollten aber wissen, wie steil es genau an der Stelle \(0{,}8\ \mathrm{m}\) ist — nicht im Mittel über zwanzig Zentimeter.

Der Ausweg ist so naheliegend wie folgenreich: Wir lassen den rechten Punkt näher heranrücken. Statt bis \(1{,}0\) gehen wir nur bis \(0{,}9\), dann bis \(0{,}81\), dann bis \(0{,}801\). Der Abstand — wir nennen ihn ab jetzt \(h\) — wird immer kleiner, und die Sekante schmiegt sich immer enger an die Kurve bei \(0{,}8\ \mathrm{m}\) an.

Vorhersage-Punkt

Bevor du die Tabelle liest: Gleich rechnet das Programm die Sekantensteigung bei \(x = 0{,}8\ \mathrm{m}\) für immer kleinere Abstände \(h = 0{,}2 / 0{,}1 / 0{,}01 / 0{,}001\ \mathrm{m}\) aus. Was glaubst du: Werden die vier Zahlen wild durcheinanderspringen, oder laufen sie auf einen festen Wert zu? Und wenn sie zulaufen — von oben (immer kleiner werdend) oder von unten? Leg dich fest.

Code

def steigungstabelle(ort, abstaende):
    """Druckt die Sekantensteigung an einem Ort fuer mehrere Abstaende h.

    ort: die feste Stelle, an der wir die Steigung wissen wollen (in Metern).
    abstaende: Liste der Abstaende h zum rechten Nachbarpunkt.
    Rueckgabe: nichts; die Funktion druckt eine Tabelle.
    """
    print("   h (m)  | T(x)      | T(x+h)    | Steigung (°C/m)")
    print("  --------+-----------+-----------+----------------")
    for h in abstaende:
        steigung = steigung_zwischen(ort, ort + h)
        print("  %6.3f  | %8.3f  | %8.3f  | %13.4f"
              % (h, temperatur(ort), temperatur(ort + h), steigung))


steigungstabelle(0.8, [0.2, 0.1, 0.01, 0.001])

   h (m)  | T(x)      | T(x+h)    | Steigung (°C/m)
  --------+-----------+-----------+----------------
   0.200  |  197.770  |  500.000  |     1511.1501
   0.100  |  197.770  |  334.037  |     1362.6659
   0.010  |  197.770  |  209.485  |     1171.5196
   0.001  |  197.770  |  198.921  |     1150.8614

Interpretation der Ausgabe: Die vier Steigungen springen nicht, sie laufen zu — von oben: \(1511{,}2 \to 1362{,}7 \to 1171{,}5 \to 1150{,}9\ °\mathrm{C/m}\). Je kleiner \(h\), desto weniger ändert sich die Zahl noch. Sie nähert sich einem Grenzwert von rund \(1149\ °\mathrm{C/m}\). Sie kommen von oben, weil die Kurve nach rechts zum Brandherd hin steiler wird: Ein weiter entfernter rechter Punkt liegt schon im steileren Teil und zieht die Sekante nach oben. Rückt er heran, verschwindet dieser Effekt.

Diesen Zielwert, dem die Sekantensteigungen zulaufen, nennt man die Ableitung des Profils an der Stelle \(0{,}8\ \mathrm{m}\). Er ist die Steigung der Kurve genau dort — die Steilheit an einem einzigen Punkt. Weil er aus dem Differenzenquotienten \(\Delta T / \Delta x\) entsteht, wenn man \(\Delta x\) „zu Ende schrumpfen” lässt, schreibt man ihn mit einem kleinen \(\mathrm{d}\) statt des großen \(\Delta\):

\[ \frac{\mathrm{d}T}{\mathrm{d}x}\bigg|_{x=0{,}8\,\mathrm{m}} \;\approx\; 1149\ \frac{°\mathrm{C}}{\mathrm{m}}. \]

Lies \(\mathrm{d}T/\mathrm{d}x\) als „\(\Delta T / \Delta x\), zu Ende gedacht”: dasselbe Steigungsdreieck, nur so klein geschrumpft, dass es die Kurve genau an einer Stelle berührt. Das kleine \(\mathrm{d}\) ist ein \(\Delta\), das man unendlich klein gemacht hat. Mehr steckt hinter dem berühmten Symbol nicht — kein Zauber, nur ein zu Ende gedachtes Dreieck. Die Einheit bleibt dieselbe wie bei der Sekante: °C pro Meter. Das ist wichtig, denn diese Steilheit ist es, die den Wärmestrom antreibt (Kapitel 6): Wo \(\mathrm{d}T/\mathrm{d}x\) groß ist, fließt viel Wärme.

Die Sekante, die sich beim Schrumpfen an die Kurve anschmiegt, hat einen eigenen Namen: Im Grenzfall berührt sie die Kurve nur noch in dem einen Punkt, statt sie zu schneiden — dann heißt sie Tangente (von lateinisch tangere, berühren). Die Ableitung ist die Steigung dieser Tangente. Abbildung 5.3 zeigt die Verwandlung in drei Bildern.

Code

import numpy as np
import matplotlib.pyplot as plt

def temperatur(ort):
    leit = 50.0 / (7850.0 * 460.0)
    zeit = 1800.0
    wert = 20.0 + 480.0 * ort
    for n in range(1, 6):
        b = 960.0 * ((-1.0) ** n) / (n * np.pi)
        wert = wert + b * np.sin(n * np.pi * ort) * np.exp(-leit * (n * np.pi) ** 2 * zeit)
    return wert

x0 = 0.8
T0 = float(temperatur(x0))
m_tangente = 1148.56
x = np.linspace(0.6, 1.0, 200)

fig, achsen = plt.subplots(1, 3, figsize=(10.5, 3.8), sharey=True)
faelle = [(0.2, "h = 0,2 m", 1511.2, achsen[0]),
          (0.05, "h = 0,05 m", 1260.8, achsen[1])]
for h, name, steig, ax in faelle:
    ax.plot(x, temperatur(x), color="tab:orange", lw=2.0)
    xb = x0 + h
    ax.plot([x0, xb], [T0, temperatur(xb)], color="tab:green", lw=2.0)
    ax.plot([x0, xb], [T0, temperatur(xb)], "o", color="tab:green", ms=8,
            markeredgecolor="black", zorder=5)
    ax.set_title("%s\nSteigung %.1f °C/m" % (name, steig), fontsize=10)
    ax.set_xlabel("Ort x (m)")

ax = achsen[2]
ax.plot(x, temperatur(x), color="tab:orange", lw=2.0)
xt = np.array([0.68, 0.92])
ax.plot(xt, T0 + m_tangente * (xt - x0), color="tab:red", lw=2.0)
ax.plot(x0, T0, "o", color="tab:red", ms=9, markeredgecolor="black", zorder=5)
ax.set_title("Tangente (h → 0)\nSteigung 1148,6 °C/m", fontsize=10)
ax.set_xlabel("Ort x (m)")
achsen[0].set_ylabel("Temperatur (°C)")
plt.tight_layout()
plt.show()

Abbildung 5.3: Von der Sekante zur Tangente. Links ein großes h = 0,2 m: die Sekante (grün) schneidet die Kurve weit auseinander, Steigung 1511,2 °C/m. Mitte ein kleines h = 0,05 m: die Sekante liegt schon enger an, 1260,8 °C/m. Rechts das „zu Ende gedachte“ h: die Tangente berührt die Kurve nur noch im Punkt 0,8 m, Steigung 1148,6 °C/m — die Ableitung.

Was man hier sieht: Wie die grüne Sekante beim Schrumpfen des Abstands \(h\) in die rote Tangente kippt. Von links nach rechts wird die Gerade immer flacher und legt sich immer enger an die Kurve — bis sie sie im letzten Bild nur noch berührt. Der Steigungswert unter jedem Bild wandert dabei von 1511,2 über 1260,8 auf 1148,6 °C/m: genau die Zahlen aus unserer Tabelle.

Diese Drehung von der Sekante in die Tangente ist die eigentliche Bewegung hinter dem Wort „Ableitung”. Die folgende Darstellung (Animation in der HTML-Fassung, Bildreihe im Druck) zeigt sie als durchgehenden Vorgang, mit mitlaufendem Steigungswert.

Code

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from IPython.display import HTML

def temperatur(ort):
    leit = 50.0 / (7850.0 * 460.0)
    zeit = 1800.0
    wert = 20.0 + 480.0 * ort
    for n in range(1, 6):
        b = 960.0 * ((-1.0) ** n) / (n * np.pi)
        wert = wert + b * np.sin(n * np.pi * ort) * np.exp(-leit * (n * np.pi) ** 2 * zeit)
    return wert

x0 = 0.8
T0 = float(temperatur(x0))
x = np.linspace(0.6, 1.0, 200)
schrittweiten = [0.19, 0.15, 0.11, 0.085, 0.06, 0.04, 0.025, 0.012]

fig, ax = plt.subplots(figsize=(8.0, 4.2))

def zeichne(k):
    ax.clear()
    h = schrittweiten[k]
    ax.plot(x, temperatur(x), color="tab:orange", lw=2.2)
    xb = x0 + h
    steig = (temperatur(xb) - T0) / h
    ax.plot([x0 - 0.04, xb + 0.04],
            [T0 - steig * 0.04, temperatur(xb) + steig * 0.04],
            color="tab:green", lw=2.0)
    ax.plot([x0, xb], [T0, temperatur(xb)], "o", color="tab:green", ms=9,
            markeredgecolor="black", zorder=5)
    ax.plot(x0, T0, "o", color="tab:red", ms=9, markeredgecolor="black",
            zorder=6)
    ax.set_title("h = %.3f m     Steigung = %.1f °C/m" % (h, steig),
                 fontsize=12)
    ax.set_xlim(0.6, 1.0)
    ax.set_ylim(20, 540)
    ax.set_xlabel("Ort x (m)")
    ax.set_ylabel("Temperatur (°C)")
    return []

ani = FuncAnimation(fig, zeichne, frames=len(schrittweiten), interval=650,
                    blit=False)
plt.close(fig)
HTML(ani.to_jshtml())

Abbildung 5.4: Die Sekante dreht sich in die Tangente: Der rechte Punkt rückt Schritt für Schritt an die Stelle x = 0,8 m heran (h wird kleiner), und die Sekante kippt aus der Steilheit über das ganze Stück in die Steilheit am Punkt selbst. Oben läuft der Steigungswert mit — er kommt bei rund 1149 °C/m zur Ruhe, der Ableitung.

Was man sieht: ein und dieselbe Bewegung, ob als Film oder als Bildreihe. Der rechte Punkt wandert heran, die Sekante kippt flacher, der Steigungswert sinkt und kommt bei rund 1149 °C/m zur Ruhe. „Ableiten” ist genau diese Bewegung — mehr nicht.

5.3 Der Sonderfall, um den sich alles dreht: die Gerade

Jetzt kommt die frohe Botschaft, die dem ganzen Kapitel den Titel gibt. Bei unserer krummen Kurve mussten wir \(h\) schrumpfen lassen, weil die Steigung von Ort zu Ort anders ist — flach über der kalten Mitte, steil am Brandherd. Aber schau, was bei einer Geraden passiert.

Denk dir das Feuer über viele Stunden ununterbrochen weiterbrennen, bis sich nichts mehr ändert: Dann ist das Profil kein krummer Verlauf mehr, sondern eine perfekte Gerade vom kühlen Auflager (20 °C) zum Brandherd (500 °C). Ihre Steigung ist überall dieselbe. Egal, ob du das Steigungsdreieck über den ganzen Meter legst oder über einen Millimeter — du bekommst immer

\[ \frac{\Delta T}{\Delta x} = \frac{500 - 20}{1{,}0} = 480\ \frac{°\mathrm{C}}{\mathrm{m}}. \]

Bei einer Geraden ist die Sekante über jedes Stück schon die Tangente. Es gibt nichts zu schrumpfen, keinen Grenzwert zu bilden, keine Zahlen, die zulaufen — die Steigung steht mit einem einzigen Dreieck exakt fest. \(\Delta T / \Delta x\) und \(\mathrm{d}T/\mathrm{d}x\) sind hier dasselbe.

Merksatz

Unsere FEM rechnet fast nur mit Geraden. Zwischen zwei Knoten nähern wir jedes Temperaturprofil durch ein gerades Stück an (Kapitel 7). Und für gerade Stücke ist die Steigung Schulgeometrie: Höhe des Dreiecks durch seine Breite, \(\Delta T / \Delta x\), exakt und ohne Grenzwert. Der ganze Schrumpf-Apparat aus diesem Abschnitt wird nur einmal gebraucht — um zu verstehen, was „Steigung an einem Punkt” überhaupt heißt. Beim eigentlichen Rechnen bleibt das Dreieck.

Das ist kein Taschenspielertrick, sondern die tragende Idee der Methode: Statt die krumme Kurve überall exakt abzuleiten, zerlegen wir sie in kurze gerade Stücke und leiten die ab — was für Geraden trivial ist. Je kürzer die Stücke (je feiner das Netz), desto besser trifft die Stückelung die echte Kurve. Genau diesen Handel — Krummes durch viele Gerade ersetzen — hast du in Kapitel 1 schon am Regler „NETZ” gesehen.

Zweite Frage: Wie viel?

5.4 Die Fläche unter der Kurve

Die zweite Frage des Kapitels klingt zunächst ganz anders als die erste, führt aber zu demselben Werkzeugkasten. Sie lautet: Wie viel Wärme steckt insgesamt im Träger?

Warum hat das mit einer Fläche zu tun? Denk an die Liste aus Kapitel 2: An jedem Knoten sitzt eine Temperatur. Die gespeicherte Wärme eines kleinen Trägerstücks ist umso größer, je heißer es ist und je länger das Stück. Heiß mal lang — Höhe mal Breite — ist aber genau eine Fläche unter dem Temperaturprofil. Ein hoher, breiter Abschnitt der Kurve steht für viel Wärme, ein niedriger, schmaler für wenig. Die gesamte Wärme ist die gesamte Fläche unter der Kurve.

Nur: Wie misst man die Fläche unter einer krummen Kurve? Ein Rechteck kann man (Länge mal Breite), ein Dreieck auch — aber diese gebogene Fläche hat keine Schulformel. Der Ausweg ist derselbe Gedanke wie beim Netz: Zerlege das Schwierige in viele einfache Stücke. Wir stellen unter die Kurve lauter schmale Rechteckstreifen, deren Fläche wir einzeln ausrechnen können, und addieren sie.

Vorhersage-Punkt

Bevor du weiterliest: Gleich legen wir 4, dann 8, dann 64 Rechteckstreifen unter die Kurve. Jeder Streifen ist so hoch wie die Kurve an seinem linken Rand. Weil die Kurve ansteigt, ist jeder Streifen ein bisschen zu niedrig — die Streifensumme wird die wahre Fläche also unterschätzen. Was glaubst du: Kommt man mit 64 Streifen schon nah an den wahren Wert (rund 105 °C·m), oder bleibt ein großer Fehler? Leg dich fest.

Code

import numpy as np
import matplotlib.pyplot as plt

def temperatur(ort):
    leit = 50.0 / (7850.0 * 460.0)
    zeit = 1800.0
    wert = 20.0 + 480.0 * ort
    for n in range(1, 6):
        b = 960.0 * ((-1.0) ** n) / (n * np.pi)
        wert = wert + b * np.sin(n * np.pi * ort) * np.exp(-leit * (n * np.pi) ** 2 * zeit)
    return wert

x = np.linspace(0.0, 1.0, 400)
fig, achsen = plt.subplots(1, 3, figsize=(10.5, 3.7), sharey=True)
for anzahl, ax in zip([4, 8, 64], achsen):
    breite = 1.0 / anzahl
    for i in range(anzahl):
        xl = i * breite
        hoehe = float(temperatur(xl))
        ax.add_patch(plt.Rectangle((xl, 0), breite, hoehe,
                                   facecolor="tab:blue", alpha=0.25,
                                   edgecolor="tab:blue", lw=0.4))
        xs = np.linspace(xl, xl + breite, 12)
        ax.fill_between(xs, hoehe, temperatur(xs), color="tab:red",
                        alpha=0.55, lw=0)
    ax.plot(x, temperatur(x), color="tab:orange", lw=2.0)
    ax.set_title("%d Streifen" % anzahl, fontsize=10)
    ax.set_xlabel("Ort x (m)")
achsen[0].set_ylabel("Temperatur (°C)")
plt.tight_layout()
plt.show()

Abbildung 5.5: Dieselbe Fläche unter dem Profil, mit 4, 8 und 64 Rechteckstreifen angenähert. Jeder Streifen ist so hoch wie die Kurve an seinem linken Rand. Der rot schraffierte Rest ist das, was die Streifen übersehen — die kleinen Dreiecke zwischen Streifenoberkante und Kurve, gebündelt dort, wo die Kurve zum Brandherd hin steil wird. Mit mehr Streifen schrumpft dieser Rest sichtbar zusammen.

Was man hier sieht: Mit 4 Streifen sind die roten Fehlerdreiecke am Brandherd noch dick — die Treppe passt schlecht unter die steile Kurve. Mit 8 Streifen ist der rote Rest schon halbiert, mit 64 Streifen kaum noch zu sehen: Die Treppe schmiegt sich fast an die Kurve. Mehr Streifen heißt weniger übersehene Fläche. Setzen wir Zahlen dahinter.

Code

def flaeche_mit_streifen(anzahl):
    """Naehert die Flaeche unter dem Profil mit Rechteckstreifen an.

    anzahl: wie viele gleich breite Streifen wir von 0 bis 1 Meter legen.
    Rueckgabe: die aufsummierte Streifenflaeche (in Grad C mal Meter).

    Jeder Streifen ist so hoch wie die Kurve an seinem linken Rand; seine
    Flaeche ist Hoehe mal Breite. Wir summieren sie der Reihe nach auf -- die
    laufende Summe aus Kapitel 2.
    """
    breite = 1.0 / anzahl
    summe = 0.0
    for i in range(anzahl):
        ort_links = i * breite
        hoehe = temperatur(ort_links)
        summe = summe + hoehe * breite
    return summe


print(" Streifen | Fläche (°C·m) | Fehler zur wahren Fläche")
print(" ---------+---------------+-------------------------")
for anzahl in [4, 8, 64]:
    flaeche = flaeche_mit_streifen(anzahl)
    print("   %4d   |    %8.2f   |    %7.2f"
          % (anzahl, flaeche, 105.51 - flaeche))

 Streifen | Fläche (°C·m) | Fehler zur wahren Fläche
 ---------+---------------+-------------------------
      4   |       54.65   |      50.86
      8   |       77.75   |      27.76
     64   |      101.79   |       3.72

Interpretation der Ausgabe: Die Streifensummen kriechen von unten an die wahre Fläche heran: \(54{,}6 \to 77{,}8 \to 101{,}8\ °\mathrm{C\cdot m}\). Mit 4 Streifen fehlen noch fast 51 °C·m, mit 8 nur noch gut halb so viel, mit 64 nur noch \(3{,}7\ °\mathrm{C\cdot m}\) — rund dreieinhalb Prozent. Jede Verdopplung der Streifenzahl halbiert grob den Fehler. Genau wie beim Schrumpfen von \(h\) läuft eine Reihe von Näherungen auf einen festen Wert zu; diesmal ist es die Fläche, der wahre Wert liegt bei rund \(105{,}5\ °\mathrm{C\cdot m}\).

Diesen Grenzwert — die Fläche, der die immer feineren Streifensummen zulaufen — nennt man das Integral des Profils. Und wie die Ableitung ein zugeschrumpftes \(\Delta\) bekam, bekommt das Integral ein eigenes Zeichen für die zugeschrumpfte Summe:

\[ \int_0^{1\,\mathrm{m}} T(x)\ \mathrm{d}x \;\approx\; 105{,}5\ °\mathrm{C\cdot m}. \]

Das langgezogene \(\int\) ist nichts als ein in die Länge gezogenes S für „Summe” — die Summe der Streifen, wenn man sie unendlich schmal werden lässt. Das \(\mathrm{d}x\) dahinter ist die Breite eines solchen unendlich schmalen Streifens (dasselbe \(\mathrm{d}x\) wie in der Ableitung, wieder ein zugeschrumpftes \(\Delta x\)). Und \(T(x)\) ist seine Höhe. Zusammengelesen heißt \(\int_0^{1\,\mathrm{m}} T(x)\,\mathrm{d}x\) also wörtlich:

„Summiere über alle Orte von 0 bis 1 Meter die Höhe \(T(x)\) mal die schmale Breite \(\mathrm{d}x\).”

Es ist die for-Schleife aus flaeche_mit_streifen, nur auf Papier geschrieben und mit unendlich vielen, unendlich schmalen Streifen — so wie das Summenzeichen \(\Sigma\) aus Kapitel 2 die Schleife des Aufsummierens war. Auch die Einheit liest man direkt ab: Höhe mal Breite, also °C mal Meter, \(°\mathrm{C\cdot m}\).

Die folgende Darstellung zeigt das Zulaufen als Bewegung (in der HTML-Fassung animiert): Die Streifen werden schmaler, und die rote Restfläche schmilzt weg.

Code

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from IPython.display import HTML

def temperatur(ort):
    leit = 50.0 / (7850.0 * 460.0)
    zeit = 1800.0
    wert = 20.0 + 480.0 * ort
    for n in range(1, 6):
        b = 960.0 * ((-1.0) ** n) / (n * np.pi)
        wert = wert + b * np.sin(n * np.pi * ort) * np.exp(-leit * (n * np.pi) ** 2 * zeit)
    return wert

x = np.linspace(0.0, 1.0, 400)
stufen = [2, 3, 4, 6, 8, 12, 16, 24, 32, 64]

fig, ax = plt.subplots(figsize=(8.0, 4.4))

def zeichne(k):
    ax.clear()
    anzahl = stufen[k]
    breite = 1.0 / anzahl
    summe = 0.0
    for i in range(anzahl):
        xl = i * breite
        hoehe = float(temperatur(xl))
        summe = summe + hoehe * breite
        ax.add_patch(plt.Rectangle((xl, 0), breite, hoehe,
                                   facecolor="tab:blue", alpha=0.25,
                                   edgecolor="tab:blue", lw=0.4))
        xs = np.linspace(xl, xl + breite, 8)
        ax.fill_between(xs, hoehe, temperatur(xs), color="tab:red",
                        alpha=0.55, lw=0)
    ax.plot(x, temperatur(x), color="tab:orange", lw=2.2)
    ax.set_title("%d Streifen     Summe = %.1f °C·m  (wahr: 105,5)"
                 % (anzahl, summe), fontsize=12)
    ax.set_xlim(0.0, 1.0)
    ax.set_ylim(0, 540)
    ax.set_xlabel("Ort x (m)")
    ax.set_ylabel("Temperatur (°C)")
    return []

ani = FuncAnimation(fig, zeichne, frames=len(stufen), interval=650,
                    blit=False)
plt.close(fig)
HTML(ani.to_jshtml())

Abbildung 5.6: Immer mehr, immer schmalere Streifen: Von 2 auf 64 Streifen füllt die blaue Treppe die Fläche unter der Kurve immer vollständiger aus, und der rote Rest (die übersehene Fläche) schmilzt sichtbar weg. Oben läuft die Streifensumme mit — sie klettert von unten an die wahre Fläche von rund 105 °C·m heran.

Was man sieht: Der rote Rest ist der Fehler, und er schmilzt mit jeder Verfeinerung. Bei 64 Streifen ist er fast weg. Das ist dieselbe Geschichte wie beim Netz aus Kapitel 1: Feiner zerlegen bringt näher an die Wirklichkeit — nur geht es hier nicht um die Form des Trägers, sondern um die Fläche unter seinem Temperaturprofil.

Von der Fläche zur Wärmemenge

Die Fläche \(\int T\,\mathrm{d}x\) hat die krumme Einheit °C·m. Zur echten Wärmemenge in Joule wird sie durch die Materialdaten des Trägers. Man zählt dazu die Fläche über der 20-°C-Linie (die zusätzliche Wärme, die der Brand gebracht hat):

\[ \int_0^{1\,\mathrm{m}} \bigl(T(x) - 20\,°\mathrm{C}\bigr)\,\mathrm{d}x \;\approx\; 85{,}5\ °\mathrm{C\cdot m}. \]

Diese Fläche multipliziert man mit der Dichte \(\rho\), der Wärmekapazität \(c\) und der Querschnittsfläche \(A\) des Trägers. Für Stahl sind das \(\rho = 7850\ \mathrm{kg/m^3}\) und \(c = 460\ \mathrm{J/(kg\,K)}\), zusammen \(\rho c = 3{,}611\ \mathrm{MJ/(m^3\,K)}\); bei einem quadratischen Querschnitt von \(0{,}1\ \mathrm{m} \times 0{,}1\ \mathrm{m}\) ist \(A = 0{,}01\ \mathrm{m}^2\). Verfolge die Einheiten Schritt für Schritt — sie kürzen sich sauber zu Joule:

\[ \underbrace{°\mathrm{C\cdot m}}_{\text{Fläche}} \;\cdot\; \underbrace{\frac{\mathrm{kg}}{\mathrm{m}^3}}_{\rho} \;\cdot\; \underbrace{\frac{\mathrm{J}}{\mathrm{kg}\cdot\mathrm{K}}}_{c} \;\cdot\; \underbrace{\mathrm{m}^2}_{A} \;=\; \mathrm{J} \]

(die Grad-Differenz °C zählt als Kelvin K und kürzt sich weg). Mit Zahlen:

\[ Q \;=\; \rho\,c\,A \int (T-20)\,\mathrm{d}x \;=\; 7850 \cdot 460 \cdot 0{,}01 \cdot 85{,}5 \;\approx\; 3{,}1\ \mathrm{MJ}. \]

Gut drei Millionen Joule zusätzliche Wärme stecken nach einer halben Stunde im Träger — herausgelesen allein aus der Fläche unter der Kurve. Genau solche Flächen wird Kapitel 7 für jedes einzelne Element ausrechnen.

5.5 Wieder die Gerade: das Trapez ist exakt

Auch bei der Fläche kommt die Erleichterung, sobald das Profil ein gerades Stück ist. Unter einer Geraden brauchen wir keine Streifen zu stapeln und keinen Grenzwert zu bilden — die Fläche unter einer Geraden ist ein Trapez, und dessen Fläche kennt die Schulgeometrie exakt:

\[ \text{Trapezfläche} \;=\; \frac{T_{\text{links}} + T_{\text{rechts}}}{2} \;\cdot\; \text{Breite}. \]

In Worten: die mittlere Höhe der beiden Ränder, mal die Breite. Nimm ein gerades Stück Profil, das über eine Breite von \(0{,}25\ \mathrm{m}\) von \(100\ °\mathrm{C}\) auf \(200\ °\mathrm{C}\) steigt. Seine Fläche ist

\[ \frac{100 + 200}{2} \cdot 0{,}25 \;=\; 150 \cdot 0{,}25 \;=\; 37{,}5\ °\mathrm{C\cdot m} \]

— eine einzige Multiplikation, kein Streifenstapel, kein Fehler. Abbildung 5.7 stellt beide Wege nebeneinander.

Code

import numpy as np
import matplotlib.pyplot as plt

def temperatur(ort):
    leit = 50.0 / (7850.0 * 460.0)
    zeit = 1800.0
    wert = 20.0 + 480.0 * ort
    for n in range(1, 6):
        b = 960.0 * ((-1.0) ** n) / (n * np.pi)
        wert = wert + b * np.sin(n * np.pi * ort) * np.exp(-leit * (n * np.pi) ** 2 * zeit)
    return wert

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10.0, 4.0))

# Links: krumme Kurve mit Rechtecken und rotem Rest
x = np.linspace(0.6, 1.0, 200)
ax1.plot(x, temperatur(x), color="tab:orange", lw=2.2)
anzahl = 4
breite = 0.4 / anzahl
for i in range(anzahl):
    xl = 0.6 + i * breite
    hoehe = float(temperatur(xl))
    ax1.add_patch(plt.Rectangle((xl, 0), breite, hoehe, facecolor="tab:blue",
                                alpha=0.25, edgecolor="tab:blue", lw=0.5))
    xs = np.linspace(xl, xl + breite, 10)
    ax1.fill_between(xs, hoehe, temperatur(xs), color="tab:red", alpha=0.55,
                     lw=0)
ax1.set_title("krumm: Rechtecke lassen einen Rest", fontsize=10)
ax1.set_xlabel("Ort x (m)")
ax1.set_ylabel("Temperatur (°C)")
ax1.set_ylim(0, 520)

# Rechts: gerades Stueck als Trapez
xg = [0.0, 0.25]
Tg = [100.0, 200.0]
ax2.fill_between(xg, [0, 0], Tg, color="tab:blue", alpha=0.25)
ax2.plot(xg, Tg, color="tab:orange", lw=2.4)
ax2.plot(xg, Tg, "o", color="tab:orange", ms=8, markeredgecolor="black")
ax2.text(0.0, 108, "100 °C", ha="left", fontsize=9)
ax2.text(0.25, 208, "200 °C", ha="right", fontsize=9)
ax2.text(0.125, 55, "Trapez\n37,5 °C·m", ha="center", fontsize=10,
         color="tab:blue")
ax2.set_title("gerade: ein Trapez trifft exakt", fontsize=10)
ax2.set_xlabel("Ort x (m)")
ax2.set_xlim(-0.03, 0.28)
ax2.set_ylim(0, 360)
plt.tight_layout()
plt.show()

Abbildung 5.7: Rechteckstreifen gegen Trapez. Links unter der krummen Kurve: Rechtecke lassen immer einen roten Rest, den erst unendlich viele Streifen schließen. Rechts unter einem geraden Stück: Ein einziges Trapez (mittlere Höhe mal Breite) trifft die Fläche exakt — kein Rest, kein Grenzwert. Deshalb ist die Gerade für die FEM Gold wert.

Was man hier sieht: links der mühsame Weg (viele Streifen, immer ein roter Rest), rechts der bequeme (ein Trapez, kein Rest). Sobald das Profil gerade ist, verschwindet die ganze Streifen-Schrumpferei — die Fläche steht mit einer Multiplikation fest. Das ist der zweite Grund, warum unsere FEM so gern mit Geraden rechnet: Nicht nur die Steigung, auch die Fläche wird dann Schulgeometrie.

5.6 Alles nur Geraden — der Brückenschlag zu Kapitel 7

Fügen wir beide Erkenntnisse zusammen und werfen einen ersten Blick auf das, was Kapitel 7 im Großen tun wird. Dort wird das Temperaturprofil nicht als eine krumme Kurve behandelt, sondern als Streckenzug aus geraden Stücken zwischen den Knoten — als wäre die Kurve mit dem Lineal von Knoten zu Knoten nachgezogen. Abbildung 5.8 zeigt so ein Profil, hütchenförmig (es steigt und fällt wieder, ein Vorgriff auf die „Hütchenfunktionen” aus Kapitel 7).

Code

import matplotlib.pyplot as plt

knoten_x = [0.0, 0.25, 0.5, 0.75, 1.0]
knoten_T = [20.0, 120.0, 220.0, 120.0, 20.0]

fig, ax = plt.subplots(figsize=(9.0, 4.4))
ax.fill_between(knoten_x, 0, knoten_T, color="tab:blue", alpha=0.15)
ax.plot(knoten_x, knoten_T, color="tab:orange", lw=2.4, zorder=3)
ax.plot(knoten_x, knoten_T, "o", color="tab:orange", ms=10,
        markeredgecolor="black", zorder=4)
for i in range(5):
    ax.text(knoten_x[i], knoten_T[i] + 8, "%.0f °C" % knoten_T[i],
            ha="center", fontsize=9)
for i in range(4):
    xm = (knoten_x[i] + knoten_x[i + 1]) / 2
    breite = knoten_x[i + 1] - knoten_x[i]
    steig = (knoten_T[i + 1] - knoten_T[i]) / breite
    trapez = (knoten_T[i] + knoten_T[i + 1]) / 2 * breite
    ax.text(xm, 165, "Steigung\n%+.0f °C/m" % steig, ha="center",
            fontsize=9, color="tab:green")
    ax.text(xm, 40, "%.1f\n°C·m" % trapez, ha="center", fontsize=9,
            color="tab:blue")
ax.set_xlabel("Ort x (m)")
ax.set_ylabel("Temperatur (°C)")
ax.set_title("Steigung und Fläche eines Profils aus Geraden")
ax.set_ylim(0, 250)
plt.tight_layout()
plt.show()

Abbildung 5.8: Ein Profil aus lauter Geraden (Vorgriff auf Kapitel 7). Fünf Knoten bei 0 / 0,25 / 0,5 / 0,75 / 1 m, dazwischen gerade Stücke. Über jedem Abschnitt steht seine exakte Steigung (grün, ΔT/Δx) und seine exakte Trapezfläche (blau). Beides ist Schulgeometrie — kein Grenzwert nötig, weil jedes Stück eine Gerade ist.

Was man hier sieht: vier gerade Stücke, und für jedes ist beides sofort ablesbar. Die Steigungen sind \(+400, +400, -400, -400\ °\mathrm{C/m}\) — das Hütchen steigt mit 400 °C/m an und fällt mit 400 °C/m wieder ab, jede Steigung ein bloßes \(\Delta T / \Delta x\). Die Trapezflächen sind \(17{,}5\), \(42{,}5\), \(42{,}5\), \(17{,}5\ °\mathrm{C\cdot m}\); zusammen macht das \(120\ °\mathrm{C\cdot m}\) unter dem ganzen Hütchen. Keine Sekante wurde geschrumpft, kein Streifen gestapelt — jede Zahl ist Dreieck oder Trapez. Das ist die ganze Analysis, die die FEM dieses Buches braucht. In Kapitel 7 bekommt jedes dieser Geradenstücke seinen Namen (Element) und seine Steigung ihren Platz im Gleichungssystem.

Steigung und Fläche gehören zusammen

Eine Beobachtung zum Schluss, die uns später noch dient. Steigung und Fläche sind keine zwei fremden Dinge — sie sind Umkehrungen voneinander. Schau auf das Hütchen: Wenn du die Steigung \(+400\ °\mathrm{C/m}\) des ersten Stücks mit seiner Breite \(0{,}25\ \mathrm{m}\) multiplizierst, bekommst du \(+100\ °\mathrm{C}\) — genau den Temperaturanstieg von 20 auf 120 °C über dieses Stück zurück. Die Fläche unter dem Steigungs-Verlauf baut den Temperaturunterschied wieder auf. Ableiten und Integrieren machen einander rückgängig: Das eine misst, wie schnell sich etwas ändert, das andere summiert die Änderungen wieder zusammen. Diese Verwandtschaft trägt einen großen Namen (den „Hauptsatz”), den wir hier nicht brauchen und nicht beweisen — für uns genügt die Beobachtung am Bild.

5.7 Die interaktive Einheit: das Steigungs- und Flächenlabor

Jetzt bist du dran. Das folgende Programm ist das Steigungs- und Flächenlabor: ein festes Profil (unsere 30-Minuten-Kurve), an dem du beide Werkzeuge dieses Kapitels selbst bedienst. Du drehst an zwei Reglern — dem Sekantenabstand H_SEKANTE und der Streifenzahl STREIFENZAHL — und siehst, wie sich Steigung und Fläche verändern. Der Rechenkern ist genau die Tabelle aus den beiden Abschnitten oben, nur automatisch: eine kurze Schleife für die Fläche, eine Zeile für die Steigung.

Vorhersage-Punkt

Bevor du ausführst: Der Regler H_SEKANTE steht auf \(0{,}001\ \mathrm{m}\). Halbiere ihn im Kopf auf \(0{,}0005\ \mathrm{m}\). Ändert sich die angezeigte Steigung dann noch um mehr als ein paar °C/m, oder steht der Vorkommawert praktisch fest? Und andersherum: Wenn du von \(0{,}2\) auf \(0{,}1\ \mathrm{m}\) halbierst — springt die Steigung da nur um ein paar °C/m oder um über hundert? Leg dich für beide fest, dann probiere es.

Abbildung 5.9: Vorgerenderte Fassung des Steigungs- und Flächenlabors (Sekantenabstand 0,001 m, 8 Streifen). Die grüne Sekante misst die Steigung bei 0,8 m, die blaue Treppe nähert die Fläche an. Im Browser ersetzt dein eigenes Ergebnis dieses Bild, sobald du die Zelle darüber ausführst.

Was man sieht: Mit H_SEKANTE = 0,001 zeigt das Labor eine Steigung von \(1150{,}9\ °\mathrm{C/m}\) — schon dicht an der wahren \(1148{,}6\). Halbierst du \(h\) auf \(0{,}0005\), wandert die Anzeige nur noch um gut ein Grad (auf \(1149{,}7\)); der Vorkommawert steht längst fest. Von \(0{,}2\) auf \(0{,}1\) dagegen sprang sie noch um fast 150 °C/m. Das ist das „Zulaufen” aus dem ersten Teil, jetzt zum Selbstdrehen. Bei der Fläche gilt dasselbe: Verdopple STREIFENZAHL, und der blaue Treppenrand schmiegt sich enger an die Kurve, die Zahl kriecht näher an 105,5 °C·m.

5.8 Das Kapitel-Programm

Das vollständige, eigenständig lauffähige Skript zu diesem Kapitel liegt in programme/kap05/kap05_steigung_und_flaeche.py. Es ist das Labor als Kommandozeilen-Werkzeug: Es druckt die volle Schrumpf-Tabelle der Sekantensteigung (von \(h = 0{,}2\) bis \(0{,}0001\ \mathrm{m}\)), die Streifen-Tabelle der Fläche (von 2 bis 512 Streifen) und rechnet die gespeicherte Wärme in Joule aus. Zum Schluss speichert es eine Abbildung des Profils mit eingezeichneter Sekante und Streifen als PNG. Sein Kern sind genau die Funktionen dieses Kapitels — temperatur, steigung_zwischen, flaeche_mit_streifen —, keine Zeile mehr.

Merkkasten

Die Steigung eines Profils an einer Stelle ist \(\Delta T / \Delta x\) — Temperaturunterschied durch Ortsunterschied, in °C/m (das Steigungsdreieck).
Lässt man den Abstand \(h\) auf null schrumpfen, läuft die Sekantensteigung auf einen Wert zu: die Ableitung \(\mathrm{d}T/\mathrm{d}x\) — „\(\Delta\), zu Ende gedacht”. Sie treibt den Wärmestrom (Kapitel 6).
Die Fläche unter dem Profil nähert man mit Rechteckstreifen an; mehr Streifen, kleinerer Fehler. Der Grenzwert ist das Integral \(\int T\,\mathrm{d}x\) — ein langgezogenes S für „Summe unendlich schmaler Streifen”, in °C·m. Sie misst die gespeicherte Wärme (Kapitel 7).
Für Geraden ist beides Schulgeometrie und exakt: Steigung = Dreieck (\(\Delta T/\Delta x\)), Fläche = Trapez (mittlere Höhe mal Breite). Kein Grenzwert nötig.
Unsere FEM rechnet fast nur mit Geraden — darum ist genau das die ganze Analysis, die dieses Buch braucht.

Roter Faden

Zurück: Die Tabellen dieses Kapitels sind for-Schleifen aus Kapitel 2 — die laufende Summe der Streifenflächen ist dasselbe Aufaddieren, das dort den Mittelwert bildete, und das mathematische Summenzeichen \(\Sigma\) und das Integralzeichen \(\int\) sind beide nur diese Schleife auf Papier. Die Idee „Krummes durch viele einfache Stücke ersetzen” kennst du schon vom Netz aus Kapitel 1.

Vor: Die Steigung \(\mathrm{d}T/\mathrm{d}x\) wird in Kapitel 6 zum Motor des Wärmestroms (Fouriers Gesetz: viel Gefälle, viel Fluss). Die Trapez- und Dreiecksflächen unter den Geradenstücken werden in Kapitel 7 zu den Elementintegralen der Hütchenfunktionen — die vier Steigungen des Hütchens aus Abbildung 5.8 landen dort im Gleichungssystem. Und die Streifenidee kehrt in Kapitel 10 wieder, wenn wir Flächenanteile in Dreiecken aufteilen.

Übungen

Ü 5.1 (Verstehen). Ein gerades Stück Temperaturprofil steigt über eine Breite von \(0{,}4\ \mathrm{m}\) von \(60\ °\mathrm{C}\) auf \(260\ °\mathrm{C}\). Rechne ohne Rechner aus: (a) die Steigung dieses Stücks in °C/m, (b) die Fläche unter ihm in °C·m. Kontrolliere danach im Labor, indem du dir ein entsprechend steiles gerades Profil vorstellst.

Musterlösung zu Ü 5.1

Steigung \(= \Delta T / \Delta x = (260 - 60)/0{,}4 = 200/0{,}4 = 500\ °\mathrm{C/m}\). Weil das Stück gerade ist, ist das exakt — kein Schrumpfen nötig.
Trapezfläche \(=\) mittlere Höhe mal Breite \(= \tfrac{60 + 260}{2} \cdot 0{,}4 = 160 \cdot 0{,}4 = 64\ °\mathrm{C\cdot m}\). Auch das ist exakt, weil die Fläche unter einer Geraden ein Trapez ist.

Ü 5.2 (Verändern). Stelle im Labor ein steileres Erlebnis her, indem du im Kopf durchspielst, was passiert, wenn der Brand heißer wäre (das Profil also überall höher liegt und zum Brandherd hin steiler ansteigt). Sage zuerst vorher: Wird sich dann eher die Steigung bei 0,8 m stark ändern oder eher die Fläche — oder beides? Verändere dann STREIFENZAHL von 8 auf 64 und prüfe, ob die Fläche näher an ihren wahren Wert rückt.

Musterlösung zu Ü 5.2

Ein heißerer Brand hebt das Profil überall an und macht es zum Brandherd hin steiler — darum wachsen beide Größen: Die Steigung bei 0,8 m wird größer (die Kurve steigt steiler zum Brandherd hin an), und die Fläche wird größer (mehr Höhe unter der ganzen Kurve, also mehr gespeicherte Wärme). Das Verfeinern von 8 auf 64 Streifen ändert am wahren Wert der Fläche nichts — es bringt die Näherung nur näher an ihn heran: Der Fehler schrumpft von rund 28 auf unter 4 °C·m. Mehr Streifen verbessern die Messung, nicht die Sache.

Ü 5.3 (Übertragen). Das ist die Übung, die Kapitel 7 unmittelbar braucht. Der Träger hat fünf Knoten mit den Temperaturen \([\,20,\ 20,\ 32,\ 146,\ 500\,]\ °\mathrm{C}\) (aus unserer Kurve abgelesen und gerundet) an den Orten \([\,0,\ 0{,}25,\ 0{,}5,\ 0{,}75,\ 1{,}0\,]\ \mathrm{m}\). Schreibe eine Funktion elementsteigungen(temperaturen, abstand), die aus den fünf Knotentemperaturen die vier Elementsteigungen berechnet (je die Steigung des geraden Stücks zwischen zwei Nachbarknoten) und als Liste zurückgibt. Das vollständige Lösungsskript liegt in loesungen/kap05_ue3.py.

Musterlösung zu Ü 5.3

def elementsteigungen(temperaturen, abstand):
    """Die Steigung jedes geraden Stuecks zwischen zwei Nachbarknoten.

    temperaturen: Liste der Knotentemperaturen (Grad C).
    abstand: gleicher Knotenabstand h (Meter).
    Rueckgabe: Liste der Steigungen (Grad C/m), eine pro Element.
    """
    steigungen = []
    for i in range(len(temperaturen) - 1):
        delta_temperatur = temperaturen[i + 1] - temperaturen[i]
        steigungen.append(delta_temperatur / abstand)
    return steigungen


temperaturen = [20.0, 20.0, 32.0, 146.0, 500.0]
for steigung in elementsteigungen(temperaturen, 0.25):
    print("%.0f °C/m" % steigung)

Ausgabe: \(0\), \(48\), \(456\), \(1416\ °\mathrm{C/m}\). Jede Zahl ist ein bloßes \(\Delta T / \Delta x\) — die Steigung eines geraden Stücks, exakt und ohne Grenzwert. Die Steigungen werden nach rechts hin dramatisch größer: Die ersten beiden Stücke über der kalten Mitte sind fast flach — die Mitte weiß noch nichts vom Feuer —, das letzte direkt am Brandherd ist mit über 1400 °C/m extrem steil. Genau diese vier Elementsteigungen füttert Kapitel 7 in das Gleichungssystem des Trägers; hier hast du sie mit reiner Schulgeometrie selbst erzeugt.

Das Kleingedruckte

Dieses Kapitel hat die Analysis bewusst klein gehalten — nur so viel, wie die zwei Fragen des Trägers verlangen. Was du hier absichtlich nicht gesehen hast: keine Ableitungsregeln (Produkt-, Ketten-, Quotientenregel), keine Stammfunktionen und Integraltabellen, keinen förmlichen Grenzwert-Begriff und keinen Beweis des „Hauptsatzes”, der Ableiten und Integrieren verbindet. All das gibt es, all das füllt dicke Bücher — und all das brauchen wir nicht, weil unsere Ansatzfunktionen Geraden sind und für Geraden Dreieck und Trapez genügen.

Zwei ehrliche Feinheiten noch. Erstens: Die glatte Kurve temperatur, an der wir gemessen haben, ist die exakte 30-Minuten-Momentaufnahme des Trägers (dieselbe Physik wie in Kapitel 1, nur nicht grob mit 26 Knoten gerechnet, sondern als geschlossene Formel). Woher diese Formel kommt, ist Stoff von Kapitel 6 und Kapitel 12; hier war sie nur ein Messobjekt, an dem wir Steigung und Fläche üben konnten. Zweitens: Die „wahren” Werte \(1148{,}6\ °\mathrm{C/m}\) und \(105{,}5\ °\mathrm{C\cdot m}\), denen unsere Näherungen zuliefen, haben wir mit sehr feinen Rechnungen bestimmt — im wirklichen Leben kennt man sie oft nicht vorab, und dann ist die Frage „fein genug?” eine Kunst für sich. Ihr ist Kapitel 12 gewidmet („Traue keinem bunten Bild”).