Reading Time: 6 minutes

Die Diffusion ist eine der intuitivsten partiellen Differentialgleichungen (PDES), die Sie simulieren können: Ein scharfer Peak breitet sich aus, ein steiler Schritt glättet sich in einen sanften Übergang und Gradienten verschwinden allmählich. Wenn Sie FIPY lernen, ist die Diffusion auch einer der besten Ausgangspunkte, da sie den FIPY-Kernworkflow sauber abbildet: Mesh → Variable → Gleichung → Zeitschleife → Visualisierung .

In diesem Handbuch lösen Sie die Diffusionsgleichung in FIPY von Grund auf, führen eine vollständige 1D-Simulation durch, die Sie sicher optimieren können, lernen, wie Sie die Ausgabe interpretieren, und dann sehen Sie, wie sich das gleiche Setup auf 2D erstreckt. Das Ziel ist praktisches Vertrauen: Sie sollten in der Lage sein, Auflösung, Zeitschritt, Diffusionsgeschwindigkeit und Randbedingungen zu ändern, ohne das Modell zu brechen.

Was Diffusion bedeutet (ohne die schwere Mathematik)

Die Diffusion beschreibt, wie sich etwas aufgrund von Konzentrations- (oder Temperatur-) Unterschieden ausbreitet. Die Wärme breitet sich durch eine Stange aus. Ein Tropfen Farbstoff breitet sich in Wasser aus. Mathematisch schreiben wir oft Diffusion in dieser Form:

∂φ/∂t = ∇·(D ∇φ)

Hier ist φ das Feld, das Ihnen wichtig ist (Temperatur, Konzentration usw.). Der Koeffizient D steuert, wie schnell die Diffusion erfolgt. Größer D bedeutet, dass das Profil schneller glättet.

Randbedingungen sind wichtig, da PDEs Regeln an den Rändern der Domäne benötigen. Bei einem ersten Diffusionslauf sind „No-Flux“ -Grenzen üblich: Nichts fließt aus der Domäne. Das macht die Evolution leicht zu interpretieren, da das System nicht durch die Grenzen gezwungen wird.

Wie FIPY Diffusion darstellt

FIPY löst PDEs mit der Finite Volume-Methode (FVM). Sie können sich Ihre Domain als in kleine Zellen aufgeteilt vorstellen. Das unbekannte Feld lebt auf diesen Zellen (typischerweise in den Zellzentren). Die Diffusion wird als Fluss zwischen benachbarten Zellen implementiert: Hohe Werte schieben den Fluss in Richtung niedrige Werte, bis das Profil glatter wird.

Die praktischen FIPY-Bausteine sind:

  • Mesh — Geometrie und Auflösung (1D- oder 2D-Raster)
  • CellVariable — das Feld φ, das Sie lösen
  • TransientTerm() — die Zeitableitung ∂φ/∂t
  • DiffusionTerm(coeff=D) — Der Diffusionsoperator
  • Eine Zeitschleife – wiederholt mit dt lösen und Schnappschüsse visualisieren

Bevor Sie beginnen: Minimale Umgebungs-Checkliste

Sie benötigen Python plus FIPY und eine Plotbibliothek. Wenn Sie Notebooks verwenden, funktioniert der gleiche Code. Führen Sie einfach die Zellen in der richtigen Reihenfolge aus.

  • Python installiert (eine moderne Version wird empfohlen)
  • eine virtuelle Umgebung (empfohlen)
  • FIPY installiert (und seine numerischen Abhängigkeiten)
  • Matplotlib zum Plotten installiert

Erstes Arbeitsbeispiel: 1D-Diffusion

Wir modellieren die Diffusion auf einer 1D-Domäne von 0 nach 1 unter Verwendung eines einheitlichen Gitters. Die Anfangsbedingung ist ein Schritt:
φ = 1 in der linken Hälfte und φ = 0 in der rechten Hälfte. Die Diffusion wird diese Diskontinuität im Laufe der Zeit glätten.

Der folgende Code ist ein vollständiges Skript, das Sie so ausführen können, wie es ist.

# Solving Diffusion Equations with FiPy: 1D Example
# Save as: diffusion_1d_fipy.py

from fipy import Grid1D, CellVariable, TransientTerm, DiffusionTerm
import matplotlib.pyplot as plt

# --- 1) Mesh setup ---
nx = 200
dx = 1.0 / nx
mesh = Grid1D(nx=nx, dx=dx)

# --- 2) Variable (field) ---
phi = CellVariable(name="phi", mesh=mesh, value=0.0)

# Initial condition: step (left half = 1, right half = 0)
x = mesh.cellCenters[0]
phi.setValue(1.0, where=(x < 0.5))

# --- 3) Diffusion equation ---
D = 1.0
eq = TransientTerm() == DiffusionTerm(coeff=D)

# --- 4) Time stepping ---
dt = 1e-4
steps = 2000

snapshots = []
times = []
capture_at = {0, 50, 200, 800, 2000}

for step in range(steps + 1):
    if step in capture_at:
        snapshots.append(phi.value.copy())
        times.append(step * dt)

    eq.solve(var=phi, dt=dt)

# --- 5) Plot ---
plt.figure()
for y, t in zip(snapshots, times):
    plt.plot(x.value, y, label=f"t = {t:.4f}")

plt.xlabel("x")
plt.ylabel("phi")
plt.title("1D Diffusion in FiPy")
plt.legend()
plt.show()

Was jeder Block tut (damit Sie ihn sicher ändern können)

Mesh: Ihre Domain und Auflösung

Grid1D(nx=nx, dx=dx) Erzeugt eine in nx-Zellen aufgeteilte Linie. Kleinere dx (größer nx) gibt mehr Details, kostet aber mehr Berechnung. Ihre Domain-Länge beträgt ungefähr nx * dx .

CellVariable: Das Feld, nach dem Sie lösen

phi wird in Zellzentren gespeichert. Sie beginnen mit einer Anfangsbedingung mit setValue(). Mit der Diffusion ist diese anfängliche Form das, was Sie im Laufe der Zeit entspannen.

Die Gleichung: Zeitänderung entspricht Diffusion

Diese Zeile definiert die Diffusions-PDE in der Term-Syntax von FIPY:

TransientTerm() == DiffusionTerm(coeff=D)

D Steuert, wie schnell der Schritt glättet. Wenn Sie D erhöhen, sollten Sie die Übergangszone schneller erweitern.

Die Zeitschleife: Vorwärts treten

Jeder Aufruf von eq.solve(var=phi, dt=dt) steuert die Lösung um einen Zeitschritt vor. Wir machen ein paar Schnappschüsse, damit Sie die Entwicklung sehen können, ohne jeden einzelnen Schritt zu zeichnen.

So erkennen Sie, ob Ihre Diffusionslaufzeit richtig aussieht

Bei einer schrittweisen Anfangsbedingung sollte die Diffusion einen glatten Übergangsbereich erzeugen, der sich allmählich erweitert. Der scharfe Sprung sollte erweichen und die Kurve sollte mit der Zeit weniger steil werden.

  • Wenn sich das Profil nicht ändert: Ihre Schleife läuft möglicherweise nicht wie erwartet, oder dt und steps erzeugen zu wenig Gesamtzeit.
  • Wenn das Profil verrauscht oder „aufbricht“: Reduzieren Sie dt, erhöhen Sie die Auflösung oder vereinfachen Sie die Grenzen.
  • Wenn alles verschoben oder abgeschnitten aussieht: Überprüfen Sie Ihren Ausgangszustand und bestätigen Sie, dass die X-Achse Ihrer Domain entspricht.

Auswahl von DT und DX: Praktische Tipps für Stabilität und Genauigkeit

Auch wenn der Code ausgeführt wird, beeinflussen Parameterauswahl die Qualität und die Laufzeit. Drei Anpassungen decken die meisten „Erstmodell“-Probleme ab:

  • Reduzieren dt Wenn die Entwicklung zwischen den Läufen zu sprunghaft, verrauscht oder inkonsistent aussieht. Ein schneller Test besteht darin, dt zu halbieren und steps zu verdoppeln, sodass die gesamte simulierte Zeit ähnlich bleibt.
  • ERHÖHEN nx, wenn die Kurve gezackt aussieht oder die Übergangszone schlecht aufgelöst ist. Mehr Zellen bedeuten normalerweise glattere Profile und bessere Steigungen bei höheren Rechenkosten.
  • Behandeln Sie größere D als „schnelleres System“. Wenn die Diffusion stark ist, benötigen Sie normalerweise kleinere dt (oder zumindest um zu überprüfen, ob sich die Ergebnisse nicht ändern, wenn Sie die Zeit verfeinern).

Eine einfache Gewohnheit, die Verwirrung verhindert: Wenn Sie dt oder nx ändern, führen Sie zwei Läufe erneut aus und vergleichen Sie sie (grob oder verfeinert). Wenn die Kurven im Grunde gleich sind, sind Sie in einem guten Regime zum Lernen und Iteration.

Sechs schnelle Experimente, die Ihnen die Diffusion schnell lehren

  1. Diffusionsgeschwindigkeit ändern: Versuchen Sie D = 0.1 und D = 5.0 und vergleichen Sie, wie schnell sich der Schritt entspannt.
  2. Auflösung erhöhen: Ändern Sie nx von 200 auf 400 und sehen Sie, wie der Übergangsbereich aussieht.
  3. Versuchen Sie eine Beule anstelle eines Schritts: Stellen Sie phi = 1 nur in einem schmalen Bereich ein und beobachten Sie, wie er sich symmetrisch ausbreitet.
  4. Erfassen Sie weitere Schnappschüsse: Fügen Sie capture_at weitere Indizes hinzu, um die Entwicklung detaillierter zu sehen.
  5. länger laufen: Erhöhen Sie steps und bestätigen Sie, dass das Profil mit der Zeit gleichmäßiger wird.
  6. Ausgabe speichern: Fügen Sie plt.savefig("diffusion_1d.png", dpi=200) vor plt.show() hinzu.

Upgrade auf 2D-Diffusion (Minimalwechsel, Big Payoff)

Sobald sich 1D wohl anfühlt, geht es beim Umschalten auf 2D hauptsächlich darum, das Netz und die Visualisierung zu ändern. Die Gleichungsstruktur bleibt gleich. In 2D beginnen Sie normalerweise mit einem „Spot“ (hoher Wert in einer kleinen Region) und beobachten, wie er sich zu einem glatten Fleck ausbreitet.

# 2D Diffusion sketch (core ideas)
from fipy import Grid2D, CellVariable, TransientTerm, DiffusionTerm
import matplotlib.pyplot as plt

nx = ny = 100
dx = dy = 1.0 / nx
mesh = Grid2D(nx=nx, ny=ny, dx=dx, dy=dy)

phi = CellVariable(name="phi", mesh=mesh, value=0.0)

x, y = mesh.cellCenters
phi.setValue(1.0, where=((x - 0.5)**2 + (y - 0.5)**2 < 0.05**2))

D = 1.0
eq = TransientTerm() == DiffusionTerm(coeff=D)

dt = 1e-4
for _ in range(500):
    eq.solve(var=phi, dt=dt)

# Visualize as an image
plt.figure()
plt.imshow(phi.value.reshape((ny, nx)), origin="lower")
plt.colorbar(label="phi")
plt.title("2D Diffusion in FiPy")
plt.show()

Zwei praktische Hinweise für 2D: Erstens kann es deutlich langsamer sein als 1D, da die Anzahl der Zellen als nx * ny wächst. Zweitens hängen Bildplots von der Umformung ab; Halten Sie Ihre (ny, nx) konsistent.

Fehlerbehebung: Häufige Probleme beim ersten Mal

Fehler importieren oder fehlende Pakete

  • Bestätigen Sie, dass FIPY in derselben Umgebung installiert ist, in der Sie das Skript ausführen.
  • Überprüfen Sie in Notebooks den Kernel auf den richtigen Interpreter.
  • Überprüfen Sie, ob Matplotlib sauber importiert.

Die Kurve ändert sich nicht

  • Erhöhen Sie die simulierte Gesamtzeit: Erhöhen Sie steps oder dt leicht (vorsichtig).
  • Stellen Sie sicher, dass Schnappschüsse spätere Schritte enthalten, nicht nur den Anfang.
  • Bestätigen Sie, dass Sie tatsächlich eq.solve() innerhalb der Schleife aufrufen.

Die Lösung sieht instabil oder laut aus

  • Reduzieren Sie dt (z. B. von 1e-4 auf 5e-5).
  • Erhöhen Sie die Auflösung (nx), um Gradienten besser aufzulösen.
  • Testen Sie ein kleineres D, um die Evolutionsgeschwindigkeit beim Lernen zu verringern.

Es ist zu langsam

  • Beginnen Sie mit weniger Zellen und erhöhen Sie dann allmählich, sobald der Arbeitsablauf frei ist.
  • Erfassen Sie weniger Schnappschüsse und zeichnen Sie weniger häufig.
  • Reduzieren Sie in 2D nx und ny beim Experimentieren mit dem Setup.

Fazit: Das Diffusionsmuster, das Sie überall wiederverwenden werden

Das Lösen von Diffusion in FIPY lehrt eine wiederholbare Struktur, die Sie für viele PDE-Modelle verwenden. Wenn Sie sich mit Grid1D/Grid2D, CellVariable, TransientTerm und DiffusionTerm verbinden, können Sie denselben Workflow auf Konvektions-Diffusion, Reaktionsdiffusion, Quellen und Senken, Parameter-Sweeps, und Validierungsprüfungen.

Wenn Sie die schnellste Lernschleife möchten, nehmen Sie jeweils eine Änderung vor – D , nx, dt oder die Anfangsbedingung – erneut ausführen und erklären, was sich geändert hat und warum. Diese Gewohnheit macht die Diffusion von einer Demo in ein Werkzeug, dem Sie vertrauen können.