Reading Time: 10 minutes

Schlüssel zum Mitnehmen

  • Die kuratierten Projektideen decken Anfänger, Mittelstufe und Fortgeschrittene mit Schwerpunkt Simulation und Computerwissenschaften ab.
  • Schwierigkeitsgrade spiegeln die Voraussetzungen, die mathematische Komplexität und die erwartete Zeitinvestition wider.
  • Codevorlagen sind für jedes Projekt enthalten, damit die Schüler schnell mit dem Bauen beginnen können.
  • Lernergebnisse zeigen, was jedes Projekt lehrt.
  • Eine Roadmap für Skills-to-Projects hilft den Schülern, ein Projekt basierend auf ihrem aktuellen Wissen auszuwählen.

Studentenprojekte in Computational Science und Simulation sind dort, wo die Theorie endlich auf Code trifft. Sie können in Vorlesungen endliche Volumenmethoden, partielle Differentialgleichungen und Erhaltungsgesetze lernen, aber Gleichungen auf einem Whiteboard lehren nicht, wie sich das Schreiben eines Solver von Grund auf anfühlt.

Wenn Sie verstehen möchten, wie numerische Methoden in Arbeitssimulationen übersetzen, wählen Sie ein Projekt aus und beginnen Sie mit dem Bau.

Dieser Leitfaden kuratiert praktische Projektideen, die von Universitäts-Computer-Kursen, wissenschaftlichen Open-Source-Projekten und Peer-Repositories inspiriert sind. Jedes Projekt verwendet Python und baut auf etwas aus, das Schüler in ein Portfolio aufnehmen können.

Projektschwierigkeiten erklärt

Vor der Auswahl eines Projekts hilft es zu verstehen, was jede Ebene in Bezug auf Aufwand bedeutet.

Ebene Voraussetzungen Erwartete Zeit Was du tun wirst
Anfänger Python-Grundlagen, numpy, matplotlib 2–4 Wochen Lösen Sie einfache ODEs oder PDEs mit expliziten Methoden und visualisieren Sie die Ergebnisse
Zwischen- Numerische Analyse, lineare Algebra, ODE/PDE-Hintergrund 4–8 Wochen Solver implementieren, Randbedingungen handhaben und Genauigkeit vergleichen
Fortgeschritten Fortgeschrittene numerische Methoden, Parallel-Computing oder spezialisierter Physikhintergrund 8–16 Wochen Erstellen Sie Multi-Physik-Simulationen, optimieren Sie die Leistung oder vergleichen Sie mit Literaturergebnissen

Die Tabelle ist kein Ranking. Es ist ein passendes Werkzeug. Wählen Sie ein Level, das Ihrer aktuellen Vorbereitung entspricht, und bewegen Sie sich dann nach oben, sobald Sie sich wohl fühlen.

Skill-to-Projects-Roadmap

Die unten stehende Roadmap zeigt, welche mathematischen und Programmierkonzepte welche Projekte abbilden.

┌─────────────────┬─────────────────────────────────────────────────────────┐
│ Skill / Concept │ Projects That Use It                                    │
├─────────────────┼─────────────────────────────────────────────────────────┤
│ Python basics   │ Heat equation solver, SIR epidemic model, Lennard-Jones │
│ NumPy arrays    │ Wave propagation, diffusion on grid                     │
│ ODE solvers     │ SIR model, projectile with drag, Lotka-Volterra         │
│ PDE basics      │ Heat equation, wave equation, diffusion                 │
│ Linear algebra  │ Jacobi iteration, eigenvalue problems, Krylov methods   │
│ Monte Carlo     │ Ising model, radioactive decay, option pricing          │
│ FFT / spectral  │ Wave propagation, turbulence, spectral methods          │
│ Parallelism     │ MPI diffusion solver, GPU molecular dynamics            │
│ Phase-field     │ Solidification, fracture mechanics, grain boundary      │
└─────────────────┴─────────────────────────────────────────────────────────┘

Anfängerprojekte

Diese Projekte führen Kernsimulationskonzepte ohne überwältigende Mathematik oder komplexen Setup ein. Sie sind so konzipiert, dass sie auf einem Laptop ohne spezielle Hardware ausgeführt werden.

1. Wärmegleichungslöser auf einem Gitter

Schwierigkeitsgrad: Anfänger
Zeit: 2–3 Wochen

Was Sie simulieren werden: Wärmeverteilung durch eine Metallplatte, einen Stab oder einen Raum. Die 1D- oder 2D-Wärmegleichung ist ein klassisches erstes Projekt in numerischen PDEs, da sie konzeptionell einfach ist und wichtige Konzepte lehrt, die später verwendet werden.

Mathe-Modell:

∂T/∂t = α ∇²T

Hier ist α thermische Diffusivität, T Temperatur und ∇² der räumliche Laplacian.

Python-Stapel: NumPy, Matplotlib

Code-Vorlage:

import numpy as np
import matplotlib.pyplot as plt

def heat_solver(alpha, L, dt, steps):
    """Solve the 1D heat equation with explicit finite differences."""
    dx = L / 50
    x = np.linspace(0, L, 51)
    T = np.zeros_like(x)
    T[20:31] = 1.0  # initial hot strip
    
    history = [T.copy()]
    
    for step in range(steps):
        T_new = T.copy()
        for i in range(1, len(T) - 1):
            T_new[i] = T[i] + dt * alpha / dx**2 * (
                T[i + 1] - 2 * T[i] + T[i - 1]
            )
        T = T_new
        history.append(T.copy())
    
    return x, np.array(history)

x, history = heat_solver(alpha=1.0, L=1.0, dt=0.0001, steps=1000)

plt.imshow(history, aspect="auto", extent=[0, 1, 1000, 0])
plt.xlabel("Position")
plt.ylabel("Time step")
plt.colorbar(label="Temperature")
plt.show()

Lernergebnisse:

  • explizite und implizite Stabilität verstehen.
  • Implementierung der Randbedingung.
  • Visualisierung diffusiver Felder.
  • Grundlegende Stabilität im CFL-Stil.

Warum dieses Projekt: Die Wärmegleichung ist die „Hallo Welt“ der Simulation. Jedes spätere Projekt mit Diffusion, Wellen oder Phasenfeldmodellierung baut auf ähnlichen numerischen Mustern auf.

Empfohlene Erweiterungen:

  • Wechseln Sie zu einem vollständig impliziten Schema oder Crank-Nicon-Niconson und vergleichen Sie die Stabilität.
  • Fügen Sie einen Quellbegriff wie ein Heizelement hinzu.
  • Exportieren Sie die Ergebnisse zur Analyse in CSV.

2. Modell der SIR-Epidemie

Schwierigkeitsgrad: Anfänger
Zeit: 2–3 Wochen

Was Sie simulieren werden: Das klassische Kompartimentmodell der Verbreitung von Krankheiten: anfällig, infektiös und erholt. Dieses Modell erfasst epidemische Kurven, Herdenimmunität und die Grundreproduktionszahl ohne räumliches Gitter.

Mathe-Modell:

dS/dt = -βSI/N
dI/dt = βSI/N - γI
dR/dt = γI

Hier ist β die Übertragungsrate, γ die Wiederfindungsrate und N = S + I + R die Population.

Python-Stapel: NumPy, SciPy, Matplotlib

Code-Vorlage:

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

def sir_model(y, t, beta, gamma):
    S, I, R = y
    N = S + I + R
    dS = -beta * S * I / N
    dI = beta * S * I / N - gamma * I
    dR = gamma * I
    return [dS, dI, dR]

beta, gamma = 0.5, 0.1
y0 = [990, 10, 0]
t = np.linspace(0, 100, 100)

solution = odeint(sir_model, y0, t, args=(beta, gamma))

plt.plot(t, solution)
plt.legend(["Susceptible", "Infectious", "Recovered"])
plt.xlabel("Time")
plt.ylabel("Population")
plt.show()

Lernergebnisse:

  • Lösungssysteme von Oden.
  • Verständnis R₀ = β/γ .
  • Interpretation von Epidemie-Spitzen und endgültigem Größenverhalten.
  • Aufzeichnen von Phasenebenenverhalten wie infektiöse versus anfällige Population.

Warum dieses Projekt: Es hat reale Relevanz bei minimaler Komplexität. Das Modell ist einfach genug zu verstehen, aber reich genug, um sinnvolle Experimente zu unterstützen.

Empfohlene Erweiterungen:

  • Fügen Sie Altersstruktur mit mehreren Fächern hinzu.
  • Impfung als zeitabhängigen Parameter einschließen.
  • Vergleichen Sie Euler-, RK4- und Scipy-Ode-Solver.

3. Wellengleichung auf einer Zeichenfolge

Schwierigkeitsgrad: Anfänger
Zeit: 3–4 Wochen

Was Sie simulieren: eine vibrierende Saite, eine Drummembran oder eine Schallwelle. Die Wellengleichung führt Ausbreitung, Reflexion und stehende Wellen ein.

Mathe-Modell:

∂²u/∂t² = c² ∇²u

Randbedingungen können fest, frei oder gemischt sein.

Python-Stapel: NumPy, Matplotlib

Code-Vorlage:

import numpy as np
import matplotlib.pyplot as plt

c, L = 1.0, 1.0
dx = L / 100
x = np.linspace(0, L, 101)
dt = 0.001
steps = 5000

u = np.zeros((101, steps))
u[:, 0] = np.sin(np.pi * x / L)

# First step approximation
u[:, 1] = u[:, 0]

for n in range(1, steps - 1):
    for i in range(1, 100):
        u[i, n + 1] = (
            2 * u[i, n]
            - u[i, n - 1]
            + (c * dt / dx)**2 * (u[i + 1, n] - 2 * u[i, n] + u[i - 1, n])
        )

plt.plot(x, u[:, 1000])
plt.xlabel("Position")
plt.ylabel("Displacement")
plt.show()

Lernergebnisse:

  • Finite Differenz-Zeitschritt für PDEs zweiter Ordnung.
  • CFL-Zustands- und Stabilitätsanalyse.
  • Wellenreflexion und stehende Wellen.
  • Visualisierung mit Animation oder Zeitschnappschüssen.

Empfohlene Erweiterungen:

  • Probieren Sie verschiedene Anfangsbedingungen wie ein Gaußsches Wellenpaket aus.
  • Fügen Sie reflektierende oder absorbierende Grenzen hinzu.
  • Vergleichen Sie die numerische Lösung mit einer analytischen Lösung.

Zwischenprojekte

Diese Projekte erfordern einen stärkeren Hintergrund in der numerischen Analyse, der linearen Algebra oder der Physik. Der Code umfasst iterative Solver, adaptive Methoden oder komplexere Modelle.

4. Jacobi- und Krylov-Iteration für lineare Systeme

Schwierigkeitsgrad: Mittelstufe
Zeit: 4–6 Wochen

Was Sie simulieren werden: Iterative Lösungen für Ax = b mit Jacobi, Gauss-Seidel und konjugiertem Gradienten. Dies ist das Rückgrat vieler PDE-Solver.

Mathe-Modell:

Ax = b

Hier ist A normalerweise spärlich, und für viele Probleme im Diffusionsstil ist es symmetrisch positiv-definit.

Python-Stapel: NumPy, SciPy, Matplotlib

Code-Vorlage:

import numpy as np
import scipy.sparse as sp
import scipy.sparse.linalg as spla

def create_1d_laplacian_matrix(n, dx):
    """Create a 1D Laplacian matrix."""
    main = 2.0 * np.ones(n)
    off = -1.0 * np.ones(n - 1)
    return sp.diags([off, main, off], [-1, 0, 1], format="csr") / dx**2

n = 100
dx = 0.01
A = create_1d_laplacian_matrix(n, dx)
b = np.ones(n)

# Jacobi iteration
x_jac = np.zeros(n)
D = A.diagonal()

for iteration in range(100):
    r = b - A @ x_jac
    x_jac = x_jac + r / D

# Compare with direct sparse solve
x_direct = spla.spsolve(A, b)
error = np.linalg.norm(x_direct - x_jac)

print(f"Jacobi error after 100 iterations: {error:.3e}")

Lernergebnisse:

  • Spärliche Matrixdarstellung und -operationen.
  • Iterative Solver-Konvergenzanalyse.
  • Vergleich von Jacobi, Gauss-Seidel und konjugiertem Gradienten.
  • Grundlegende Vorkonditionierungskonzepte.

Warum dieses Projekt: Jeder PDE-Solver verwendet spärliche lineare Systeme intern. Das Verständnis iterativer Methoden auf Code-Ebene hilft bei der Entmystifizierung von Tools wie FIPY, Fenics und OpenFoam.

Empfohlene Erweiterungen:

  • Fügen Sie einen diagonalen Vorkonditionierer hinzu.
  • Vergleichen Sie die Konvergenzraten in 2D- und 3D-Gittern.
  • Implementieren Sie einen einfachen Multigrid-Zyklus.

5. Molekulare Dynamik mit Potential von Lennard-Jones

Schwierigkeitsgrad: Mittelstufe
Zeit: 4–8 Wochen

Was Sie simulieren werden: ein Gas oder eine Flüssigkeit von Partikeln, die durch das Lennard-Jones-Potenzial interagieren. Dieses Projekt demonstriert den vollständigen Zyklus vom Physikmodell bis zur numerischen Integration, Datenanalyse und Visualisierung.

Mathe-Modell:

V(r) = 4ε[(σ/r)¹² - (σ/r)⁶]
F = -∇V(r)

Typische Integrationsverfahren umfassen Geschwindigkeitsverlet- oder Leapfrog-Schemata.

Python-Stapel: NumPy, Matplotlib, h5py

Code-Vorlage:

import numpy as np

def lj_force(pos_i, pos_j, sigma=1.0, epsilon=1.0):
    """Compute Lennard-Jones force between two particles."""
    r_vec = pos_j - pos_i
    r = np.linalg.norm(r_vec)
    
    if r == 0:
        return np.zeros_like(r_vec)
    
    inv_r = sigma / r
    force_mag = 24 * epsilon * (2 * inv_r**12 - inv_r**6) / r
    return force_mag * (r_vec / r)

def compute_forces(positions):
    n = len(positions)
    forces = np.zeros_like(positions)
    
    for i in range(n):
        for j in range(i + 1, n):
            f = lj_force(positions[i], positions[j])
            forces[i] += f
            forces[j] -= f
    
    return forces

Lernergebnisse:

  • numerische Integration auf Partikelbasis.
  • periodische Randbedingungen.
  • Überwachung der Energieeinsparung.
  • radiale Verteilungsfunktionen.

Warum dieses Projekt: Molecular Dynamics ist ein Tor zu leistungsfähigem wissenschaftlichem Rechnen. Sobald Sie Lennard-Jones-Partikel verstanden haben, können Sie sich zu komplexen Potentialen, grobkörniger oder GPU-beschleunigter MD bewegen.

Empfohlene Erweiterungen:

  • Mit cupy oder numba auf GPU-Beschleunigung umschalten.
  • Studienphasenübergänge durch Temperaturschwankung.
  • Berechnen Sie die Wärmeleitfähigkeit mit den Green-Kubo-Beziehungen.

6. Modell für 2D-Magnetismus

Schwierigkeitsgrad: Mittelstufe
Zeit: 4–6 Wochen

Was Sie simulieren werden: Das Ising-Modell ist eines der einfachsten Modelle des Magnetismus und eines der am besten untersuchten Probleme in der statistischen Physik. Es zeigt, wie lokale Regeln makroskopische Phasenübergänge erzeugen können.

Mathe-Modell:

H = -J Σᵢⱼ sᵢsⱼ - h Σᵢ sᵢ
P(ΔE) = exp(-ΔE/kT)

Python-Stapel: NumPy, Matplotlib, SciPy

Code-Vorlage:

import numpy as np

def metropolis_step(grid, T):
    """Single Metropolis sweep on a 2D Ising grid."""
    L = grid.shape[0]
    
    for i in range(L):
        for j in range(L):
            site = grid[i, j]
            neighbors = (
                grid[(i - 1) % L, j]
                + grid[(i + 1) % L, j]
                + grid[i, (j - 1) % L]
                + grid[i, (j + 1) % L]
            )
            dE = 2 * site * neighbors
            
            if dE < 0 or np.random.rand() < np.exp(-dE / T):
                grid[i, j] = -site
    
    return grid

Lernergebnisse:

  • Monte-Carlo-Methoden und der Metropolis-Algorithmus.
  • Phasenübergänge und kritische Phänomene.
  • Heuristiken der Energieminimierung.
  • Visualisierung von aufkommenden Mustern.

Warum dieses Projekt: Das ISING-Modell verbindet statistische Physik, Rechenmethoden und maschinelles Lernen. Es hat auch ein bekanntes Referenzverhalten, das Validierung ermöglicht.

Empfohlene Erweiterungen:

  • Berechnen Sie die Wärmekapazität und Anfälligkeit in der Nähe der kritischen Temperatur.
  • Studieren Sie verschiedene Gittergeometrien.
  • Implementieren Sie den Wolff- oder Swendsen-Wang-Cluster-Algorithmus.

Fortgeschrittene Projekte

Diese Projekte erfordern einen stärkeren Hintergrund der numerischen Methoden, Erfahrung mit paralleler Rechenleistung oder spezielles Physikwissen. Sie eignen sich für Arbeits- oder Schlusssteinprojekte.

7. FIPY-basierter Diffusionslöser

Schwierigkeitsgrad: Advanced
Zeit: 8–12 Wochen

Was Sie simulieren: Ein realistisches Diffusionsproblem mit FIPY. Dies verbindet PDE-Konzepte und endliche Volumendiskretisierung mit produktiver wissenschaftlicher Software.

Mathe-Modell:

∂c/∂t = ∇·(D∇c) + S

Dies ist eine Diffusionsgleichung mit Quellenbegriffen und Randbedingungen wie Dirichlet, Neumann oder Robin.

Python-Stapel: FiPy, NumPy, Matplotlib

Code-Vorlage:

from fipy import Grid2D, CellVariable, DiffusionTerm

mesh = Grid2D(nx=50, ny=50, dx=0.1, dy=0.1)

c = CellVariable(mesh=mesh, name="concentration", value=0.0)
c.constrain(1.0, mesh.facesLeft)

eq = DiffusionTerm(coeff=1.0) == 0

# Solve to steady state
eq.solve(var=c)

Lernergebnisse:

  • Endliche Volumendiskretisierung mit FIPY.
  • Umgang mit den Randbedingungen von Dirichlet, Neumann und Robin.
  • Netzqualität und Konvergenzstudien.
  • Analytische Lösungen mit numerischen Ergebnissen verbinden.

Warum dieses Projekt: Wenn Sie professionell in der Computerwissenschaft arbeiten möchten, ist es wertvoll, einen endlichen Volumencode wie FIPY zu verwenden und zu erweitern. Dieses Projekt kombiniert die Mesh-Einrichtung, die Begriffsformulierung, die Solver-Konfiguration und die Nachbearbeitung.

Empfohlene Erweiterungen:

  • Fügen Sie Reaktionsbegriffe für Reaktionsdiffusionssysteme oder Turingmuster hinzu.
  • Vergleichen Sie FIPY-Ergebnisse mit analytischen Benchmark-Lösungen.
  • Parallelisieren Sie mit der MPI-Unterstützung von FIPY.

8. Monte Carlo für Optionspreise

Schwierigkeitsgrad: Fortgeschritten
Zeit: 6–10 Wochen

Was Sie simulieren werden: Monte-Carlo-Methoden im Finanzbereich, einschließlich der Preisgestaltung europäischer und amerikanischer Optionen unter Verwendung simulierter Aktienkurspfade. Dies verbindet die Computerwissenschaft mit angewandter Mathematik und quantitativer Finanzierung.

Mathe-Modell:

dS = μS dt + σS dW
V = e^(-rT) E[max(S-K, 0)]

Python-Stapel: NumPy, pandas, Matplotlib, scipy.stats

Code-Vorlage:

import numpy as np

def monte_carlo_option(S0, K, r, sigma, T, num_paths=10000):
    """Price a European call option using Monte Carlo."""
    z = np.random.randn(num_paths)
    S_final = S0 * np.exp(
        (r - 0.5 * sigma**2) * T + sigma * np.sqrt(T) * z
    )
    
    payoffs = np.maximum(S_final - K, 0)
    price = np.exp(-r * T) * np.mean(payoffs)
    stderr = np.exp(-r * T) * np.std(payoffs) / np.sqrt(num_paths)
    
    return price, stderr

Lernergebnisse:

  • Stochastische Simulation und Pfadgenerierung.
  • Konvergenzanalyse mit Stichprobengröße.
  • Varianzreduktionstechniken wie antithetische Varianten und Kontrollvarianten.
  • Amerikanische Optionspreise mit Monte-Carlo-Methoden mit den kleinsten Quadraten.

Warum dieses Projekt: Monte-Carlo-Methoden funktionieren in hochdimensionalen Umgebungen, was sie in den Bereichen Finanzen, Materialwissenschaften, Quantenfeldtheorie und Unsicherheitsquantifizierung nützlich macht.

Empfohlene Erweiterungen:

  • Implementieren Sie den Longstaff-Schwartz-Algorithmus für amerikanische Optionen.
  • Studieren Sie Griechen wie Delta, Gamma und Vega.
  • Vergleichen Sie die Ergebnisse mit der analytischen Lösung von Black-Scholes.

9. Erstarrung und Phasenfeldsimulation

Schwierigkeitsgrad: Fortgeschritten
Zeit: 12–16 Wochen

Was Sie simulieren werden: Die Phasenfeldmethode wird häufig in der computergestützten Materialwissenschaft für die Entwicklung der Mikrostruktur verwendet, einschließlich Kornwachstum, dendritischer Erstarrung und Niederschlagsbildung.

Mathe-Modell:

∂φ/∂t = -Γ [φ(1-φ)² + F'(φ) + λ∇φ·∇φ]

Hier ist φ das Phasenfeld, Γ Mobilität und F(φ) das Doppeltiegelpotential.

Python-Stapel: FiPy, NumPy, Matplotlib

Code-Vorlage:

from fipy import Grid2D, CellVariable, TransientTerm, DiffusionTerm

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

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

# Example starter equation structure:
# TransientTerm == diffusion + source-like phase evolution term
eq = TransientTerm(var=phi) == DiffusionTerm(coeff=1.0, var=phi)

for step in range(100):
    eq.solve(var=phi, dt=0.01)

Lernergebnisse:

  • Phasenfeldformulierung und Doppeltiegelpotentiale.
  • Schnittstellenbreite und Mobilitätsparameter.
  • Kopplung mit Diffusionsgleichungen.
  • Vergleich mit analytischen Erstarrungslösungen oder Literatur-Benchmarks.

Warum dieses Projekt: Phasenfeldsimulation wird weltweit in der materialwissenschaftlichen Forschung eingesetzt. Es verbindet Mikrostruktur, Thermodynamik und numerische Methoden.

Empfohlene Erweiterungen:

  • Koppeln Sie das Phasenfeld mit Diffusion für Modelle mit gelöstem Einfangen.
  • Untersuchen Sie dendritische Wachstumsmuster unter verschiedenen Bedingungen der Unterkühlung.
  • Vergleichen Sie die Ergebnisse mit experimentellen Aufnahmen aus der Literatur.

So wählen Sie Ihr Projekt aus

Nicht jedes Projekt ist für jeden Schüler richtig. Verwenden Sie das folgende Framework, um einen realistischen Ausgangspunkt auszuwählen.

Passen Sie Ihren Hintergrund an

Sie wissen derzeit Empfohlenes Startprojekt
Python-Grundlagen, kein numerischer Hintergrund Wärmegleichung
Python plus einführende numerische Analyse SIR-Modell oder Wellengleichung
ODE/PDE-Kurs und lineare Algebra Jacobi-Iteration oder molekulare Dynamik
Statistische Mechanik oder fortgeschrittene Mathematik Modell ising
Ziele auf Forschungs- oder Abschlussarbeit FIPY-Diffusion oder Phasenfeldsimulation

Das Wichtigste

  1. Mathematische Voraussetzungen. Springen Sie nicht zur Phasenfeldsimulation, wenn Sie eine PDE noch nicht numerisch gelöst haben.
  2. Programmierkomfort. Wenn Sie neu bei Python sind, beginnen Sie mit der Wärmegleichung und bauen Sie von dort aus.
  3. Zeithorizont. Ein Semesterprojekt braucht einen klaren Spielraum. Wählen Sie etwas aus, das in 4 bis 8 Wochen zu einem aussagekräftigen Ergebnis führen kann.
  4. Karriereziele. Die Materialwissenschaft weist auf Phasenfeld- oder Molekulardynamik hin. Finanzpunkte in Richtung Monte Carlo. Forschungssoftware zeigt auf FIPY- oder iterative Solver.

Häufige Fehler, die Schüler machen

  1. Ein Projekt auswählen, das zu ehrgeizig ist. Ein vollständiger 3D-Phasenfeldlöser in vier Wochen ist nicht realistisch. Scope es mit einfachen Parametern auf 2D.
  2. Überspringen von analytischen Lösungsvergleich. Vergleichen Sie numerische Ergebnisse immer mit einer bekannten Lösung, wenn möglich.
  3. Ignorieren der CFL-Bedingung. Viele Anfängersimulationen scheitern, weil der Zeitschritt zu groß ist.
  4. nicht die Versionskontrolle verwenden. Git ist nicht optional für ein ernstes Projekt. Begehen Sie regelmäßig, damit Sie sich von Fehlern erholen können.

Was solltest du überspringen?

Nicht alle Rechenprojekte sind für die Lernsimulation gleichermaßen nützlich. Vermeiden Sie diese, es sei denn, Sie haben einen bestimmten Grund.

  • Generische „Hello World“ -Simulationen. Wenn es sich bei einem Projekt nicht um ein PDE, ein Naturschutzgesetz, einen numerischen Solver oder ein stochastisches Modell handelt, handelt es sich möglicherweise nicht um ein Computer-Science-Projekt.
  • Projekte, die am Anfang spezielle Hardware erfordern. Beginnen Sie nicht mit der GPU-Molekulardynamik, wenn Sie die CPU-Molekulardynamik noch nicht erstellt haben.
  • Übermäßig komplexe Multiphysik-Kopplung. Beginnen Sie mit Einzel-Physik-Solvern. Multiphysische Kopplung ist ein Forschungsthema, kein ideales erstes Studentenprojekt.

Wo finden Sie Referenzcode?

Mehrere Universitätskurse und Open-Source-Projekte bieten nützliche Referenzimplementierungen:

Verwenden Sie diese Ressourcen als Ausgangspunkte und nicht als Endpunkte. Das eigentliche Lernen erfolgt, wenn Sie den Code selbst schreiben und debuggen.

Letzte Gedanken

Der Unterschied zwischen dem Lesen über numerische Methoden und dem Schreiben einer Simulation ist enorm. Sie können viele PDE-Lehrbücher lesen und verstehen immer noch nicht, was passiert, wenn eine Diffusionsgleichung mit einem zu großen Zeitschritt diskretisiert wird.

Wählen Sie ein Projekt aus, beginnen Sie mit der Codierung und iterieren Sie. Ein paar Wochen Debugging können mehr als Monate passive Vorlesungen unterrichten.

Wenn Sie Hilfe bei einem bestimmten Simulationsproblem benötigen, wie z. Gute Unterstützung kann Ihnen helfen, häufige Fallen zu vermeiden, während Sie die Arbeit selbst erledigen.