Reading Time: 11 minutes

Das adaptive Zeitschritt ändert die Zeitschrittgröße während einer Simulation. Der Solver macht kleinere Schritte, wenn sich die Lösung schnell ändert, und größere Schritte, wenn die Evolution glatt wird.

Bei einer Festschrittberechnung muss während der gesamten Simulation ein Wert von Δt verwendet werden. Dieser Wert wird oft nach dem anspruchsvollsten Ereignis, der vorübergehenden oder der Stabilitätsbeschränkung ausgewählt. Der gleiche kleine Schritt wird dann in langen Intervallen verwendet, wo es unnötig ist.

Eine adaptive Methode schätzt den Fehler jedes vorgeschlagenen Schritts. Es akzeptiert den Schritt, wenn der normalisierte Fehler unter der angeforderten Toleranz liegt, und lehnt ihn ab, wenn der Fehler zu groß ist. Ein Controller wählt dann eine neue Schrittgröße aus.

Die Fehlerkontrolle ist nur ein Teil des Prozesses. Explizite Methoden müssen weiterhin die CFL- und Diffusionsgrenzen einhalten. Implizite Methoden erfordern möglicherweise Einschränkungen für Genauigkeit, nichtlineare Konvergenz, Wellenauflösung, Ereignisse oder physikalische Einschränkungen. Ein zuverlässiger Solver kombiniert diese Anforderungen, anstatt eine Fehlerschätzung zu ermöglichen, alles zu steuern.

Was ist eine adaptive Zeitschritt?

Nach der räumlichen Diskretisierung wird eine zeitabhängige PDE üblicherweise zu einem System gewöhnlicher Differentialgleichungen:

du/dt = F(t, u)

Eine numerische Methode führt die Lösung von tⁿ zu:

tⁿ⁺¹ = tⁿ + Δt

Ein adaptiver Solver folgt einem Akzept- oder Ablehnungszyklus:

  1. Schlagen Sie einen Zeitschritt vor.
  2. Berechnen Sie eine Testlösung.
  3. Schätzen Sie den lokalen zeitlichen Fehler.
  4. Normalisieren Sie den Fehler mit absoluten und relativen Toleranzen.
  5. Akzeptieren oder lehnen Sie den Testschritt ab.
  6. Wählen Sie die nächste Schrittgröße aus.

Abgelehnte Schritte verschieben die Simulationszeit nicht. Der Solver stellt den zuvor akzeptierten Zustand wieder her und wiederholt die Berechnung mit einem kleineren Wert von Δt.

Lokaler Fehler und globaler Fehler

Lokaler Fehler ist der Fehler, der durch einen Zeitschritt verursacht wird, wenn der Schritt von der genauen Lösung aus beginnt.

Globaler Fehler ist der akkumulierte Unterschied zwischen den numerischen und exakten Lösungen nach vielen Schritten.

Für eine Bestellmethode p:

Local truncation error = O(Δt^(p+1))

Global error = O(Δt^p)

Adaptive Methoden schätzen normalerweise den lokalen Fehler. Das Einhalten jeder lokalen Schätzung unterhalb einer Toleranz bietet keine strenge universelle Grenze für globale Fehler, bietet jedoch einen effektiven praktischen Kontrollmechanismus.

Absolute und relative Toleranzen

Ein Rohfehlerwert hat ohne die Skala jeder Lösungskomponente wenig Bedeutung. Adaptive Löser berechnen daher einen normalisierten Fehler.

Eine gemeinsame Komponentenskala ist:

scaleᵢ =
atolᵢ
+
rtol × max(
    |uᵢⁿ|,
    |uᵢ(trial)|
)

Der normalisierte gewichtete quadratische mittlere quadratische Fehler ist:

E =
sqrt(
    1 / m
    × Σ [
        errorᵢ / scaleᵢ
      ]²
)

Der Schritt wird normalerweise akzeptiert, wenn:

E ≤ 1

Die absolute Toleranz steuert Komponenten nahe Null. Die relative Toleranz steuert Komponenten, deren Größen im Vergleich zu atol groß sind.

Unterschiedliche Felder können unterschiedliche absolute Toleranzen erfordern. Eine in Hunderten von Kelvin gemessene Temperatur sollte nicht unbedingt die gleiche absolute Toleranz wie eine Konzentration in der Nähe von 10⁻⁹ verwenden.

Wie der nächste Schritt ausgewählt wird

Wenn sich der geschätzte lokale Fehler wie folgt verhält:

error ∝ Δt^(p+1)

Ein Basisregler kann verwenden:

Δt(new) =
safety
× Δt(old)
× E^(-1/(p+1))

Der Sicherheitsfaktor ist kleiner als eins. Es verringert die Wahrscheinlichkeit, dass der nächste Schritt direkt an der Ablehnungsgrenze sitzt.

Produktionsimplementierungen begrenzen auch Schrittgrößenänderungen:

growth_min
≤
Δt(new) / Δt(old)
≤
growth_max

Der richtige Exponent hängt von der Reihenfolge des Fehlerschätzers und der Controller-Konvention ab. Es sollte nicht blind zwischen nicht verwandten Methoden kopiert werden.

I, PI und PID-Regler

Ein einfacher integrierter Controller verwendet nur den aktuellen normalisierten Fehler. Dies kann dazu führen, dass sich die Zeitschritt-Historie zwischen aggressiven Erhöhungen und Ablehnungen abwechselt.

PI- und PID-Regler verwenden auch Fehler aus früheren akzeptierten Schritten. Dies führt zu glatteren Schrittgrößenänderungen und kann die Ablehnungsraten verringern.

Ein vereinfachter PI-Regler hat die Form:

Δt(n+1) =
safety
× Δt(n)
× E(n)^(-k₁)
× E(n-1)^(k₂)

Die Koeffizienten hängen von der Methodenreihenfolge und dem Controller-Design ab. Eine ausgefeilte Steuerung ist nützlich, kann jedoch nicht einen ungenauen Fehlerschätzer oder einen ungeeigneten Zeitintegrator reparieren.

Eingebettete Runge-Kutta-Paare

Ein eingebettetes Runge-Kutta-Paar berechnet zwei Näherungen aus demselben Satz von Zwischenstufen.

Die beiden Formeln haben unterschiedliche Reihenfolgen:

u(high) =
uⁿ
+
Δt Σ bᵢ kᵢ

u(low) =
uⁿ
+
Δt Σ b̂ᵢ kᵢ

Der Unterschied liefert eine Fehlerschätzung:

e =
u(high)
-
u(low)

Da beide Formeln ihre Stufenbewertungen teilen, ist der Schätzer viel billiger als das Abschließen von zwei unabhängigen Integrationen.

Eingebettete explizite Runge-Kutta-Methoden eignen sich am besten für nicht steife Systeme. Wenn die Steifigkeit die Schrittweite steuert, erhöht oder verringert sich Δt

Dormand–Prinz 5(4)

Dormand-Prince 5 (4) ist ein siebenstufiges eingebettetes Paar. Es produziert eine Lösung fünfter Ordnung und eine Fehlerschätzung vierter Ordnung.

Das Paar verwendet die lokale Extrapolation: Die Approximation fünfter Ordnung wird zur akzeptierten Lösung, während die Formel niedrigerer Ordnung den Schritt steuert.

Es hat auch eine Fsal-Eigenschaft im normalen Gebrauch. Die letzte abgeleitete Auswertung eines akzeptierten Schritts kann zur ersten Auswertung des nächsten Schritts werden, wodurch die Anzahl neuer Funktionsauswertungen nach dem Start reduziert wird.

Dormand-Prince wird von Scipys RK45 und Matlabs ode45 verwendet. Es ist eine starke Allzweckentscheidung für reibungslose, nicht steife Anfangswertprobleme.

tsit5

TSIT5 ist die Tsitouras 5 (4) eingebettete Runge-Kutta-Methode. Es wird im SCIML-Ökosystem häufig als Standardmethode für nicht steife Probleme bei normalen Toleranzen verwendet.

Das Verfahren soll ein günstiges Gleichgewicht zwischen Fehlerschätzungsqualität, Stufenkosten und praktischer Effizienz schaffen.

Es bleibt eine explizite Methode. Wenn eine halbdiskrete PDE aufgrund von Diffusionen, Reaktionen oder stark getrennten Zeitskalen steif ist, kann eine implizite, Rosenbrock-, BDF- oder IMEX-Methode effizienter sein.

Bogacki – Shampin 3(2)

Bogacki-Shampin 3 (2) ist ein vierstufiges eingebettetes Paar. Es bietet eine akzeptierte Lösung dritter Ordnung mit einem Fehlerschätzer zweiter Ordnung.

Es ist als RK23 in Scipy implementiert und liegt unter ode23 von MATLAB.

Das Paar kann nützlich sein, wenn eine mäßige Genauigkeit ausreicht oder wenn Funktionsbewertungen kostengünstig sind. Die niedrigere Ordnung erfordert möglicherweise mehr akzeptierte Schritte als eine Methode fünfter Ordnung, wenn strenge Toleranzen angefordert werden.

Schritt-Doppel

Step-Double-Schätze zeitlichen Fehler durch Vergleichen derselben numerischen Methode mit zwei Auflösungen.

Das Verfahren berechnet:

  1. Ein voller Längenschritt Δt.
  2. Zwei Halbschritte Δt/2.
  3. Der Unterschied zwischen den beiden Ergebnissen.

Für ein Verfahren der Ordnung p ist eine Schätzung des Fehlers im verfeinerten zwei-Halb-Schritt-Ergebnis:

e(refined) ≈
[
    u(half)
    -
    u(full)
]
/
(
    2^p - 1
)

Die akzeptierte Lösung sollte normalerweise das Ergebnis der beiden Halbschritte sein, da sie genauer ist.

Das Step-Doubling erfordert drei Anwendungen der zugrunde liegenden Methode: einen vollen Schritt und zwei Halbschritte. Eine implizite Implementierung erfordert daher möglicherweise drei nichtlineare oder lineare Lösungsvorgänge, es sei denn, einige Einrichtungsarbeiten können wiederverwendet werden.

Rest- und Defektschätzung

Restbasierte Methoden bewerten, wie genau eine rekonstruierte numerische Trajektorie die Differentialgleichung zwischen akzeptierten Punkten erfüllt.

Eine kontinuierliche Rekonstruktion ũ(t) hat einen Defekt:

d(t) =
dũ/dt
-
F(t, ũ)

Der Defekt kann eine Fehlerschätzung unterstützen, wenn er mit Stabilitätsinformationen oder einer geeigneten Norm kombiniert wird.

Der algebraische Rest einer impliziten Lösung ist nicht automatisch eine zeitliche Fehlerschätzung. Die Newton-Methode kann die diskrete Gleichung fast auf Null reduzieren, selbst wenn der Zeitschritt zu groß ist, um die physikalische Lösung genau darzustellen.

Algebraische Konvergenz und zeitliche Verkürzungsfehler erfordern daher separate Kontrollen.

Adaptive BDF-Methoden

Rückwärtsdifferenzierungsformeln sind implizite mehrstufige Methoden, die für steife Systeme verwendet werden. Implementierungen mit variabler Ordnung wechseln normalerweise zwischen den Bestellungen eins bis fünf.

Ein BDF-Solver speichert Informationen aus früheren akzeptierten Zuständen. Es konstruiert einen Prädiktor für den neuen Zustand, löst die implizite Gleichung und schätzt den lokalen Kürzungsfehler unter Verwendung geteilter Unterschiede oder einer nordsieck-ähnlichen Historiendarstellung.

Der Löser kann sich ändern:

  • Die Zeitschrittgröße
  • Die BDF-Bestellung
  • Die Häufigkeit von Jacobi-Updates
  • Der lineare Solver oder Vorkonditionierer-Setup

Eine reibungslose Lösung kann die Erhöhung der Reihenfolge rechtfertigen. Ein Ereignis, eine Startphase, eine Unterbrechung oder ein Fehlertest kann den Solver dazu zwingen, seine Reihenfolge und Schrittgröße zu reduzieren.

BDF2 ist eine Rückwärtsdifferenzierungsformel. Es ist nicht Crank-Niconson, obwohl beide Methoden zweiter Ordnung sind.

Fehlerkontrolle in COMSOL BDF

Der BDF-Controller von Comsol wertet eine gewichtete quadratische quadratische Fehlerschätzung aus. Ein Schritt geht weiter, wenn der normalisierte Fehler unter eins liegt.

Der Solver kann BDF-Bestellungen von eins bis fünf verwenden. Es untersucht die Glätte der Lösung, wählt eine Reihenfolge aus, versucht einen Schritt und wiederholt den Schritt mit einer kleineren Größe, wenn der lokale Fehlertest fehlschlägt.

Sein Solver-Protokoll enthält:

  • Order für die aktuelle BDF-Bestellung
  • Tfail für fehlgeschlagene Zeitschrittfehlertests
  • NLfail für nichtlineare Solver-Fehler

Eine hohe Zählung Tfail deutet darauf hin, dass der Controller häufig Schritte vorgeschlagen hat, die für die angeforderte Genauigkeit zu groß waren. Eine hohe Anzahl NLfail zeigt an, dass die algebraische nichtlineare Lösung gekämpft hat.

Diese beiden Fehler sollten nicht als dasselbe Problem interpretiert werden.

Der detaillierte Mechanismus wird in COMSOLs automatischer Zeitschritt und Reihenfolgeauswahl bei zeitabhängigen Problemen beschrieben.

Algebraischer Fehler und zeitlicher Fehler

Eine implizite Methode löst ein nichtlineares System bei jedem Zeitschritt. Wenn Newton oder der lineare Solver zu früh abbricht, kann ein algebraischer Fehler mit dem zeitlichen Fehler vergleichbar werden.

Der Zeitschrittregler kann dann auf einen Fehler reagieren, der eher aus der unvollständigen algebraischen Konvergenz als aus der Zeitdiskretisierung stammt.

Eine glaubwürdige Löserkonfiguration sollte die algebraische Toleranz ausreichend enger als das zeitliche Ziel machen. Es unnötig streng zu machen, auch Arbeit zu verschwenden.

Einige Löser koordinieren nichtlineare Konvergenz und Zeitschrittauswahl. Eine nichtlineare Steuerung kann den Schritt reduzieren, wenn die Newton-Stabilität einen kleineren Wert erfordert, als der BDF-Genauigkeitsschätzer vorschlägt.

CFL-Grenzen und adaptives Tritt

Explizite Fehlerkontrolle kann eine explizite Stabilitätsbeschränkung nicht überschreiben.

Für die Advektion ist eine typische CFL-Grenze:

Δt(CFL) =
C
× h
/
|v|max

Für explizit integrierte Diffusion:

Δt(diffusion) =
C
× h²
/
α

Die Konstanten hängen von der räumlichen Diskretisierung, der Dimension, der Netzgeometrie und dem Zeitintegrator ab.

Der nutzbare Schritt kann sein:

Δt =
min(
    Δt(error),
    Δt(CFL),
    Δt(diffusion),
    Δt(event),
    Δt(maximum)
)

Eine adaptive Runge-Kutta-Methode kann einen sehr kleinen Fehler melden und dennoch instabil werden, wenn die CFL-Spannung verletzt wird.

Benötigen implizite Methoden ein CFL-Limit?

Eine a-stabile implizite Diskretisierung eines linearen Modells hat möglicherweise nicht die gleiche explizite CFL-Stabilitätsgrenze. Das bedeutet nicht, dass der Zeitschritt beliebig groß sein kann.

Große implizite Schritte können:

  • vermisse Wellen und schnelle Transienten
  • Übermäßige numerische Dämpfung einführen
  • Monotonie verlieren
  • Machen Sie Newton-Iterationen schwierig
  • ein Ereignis überqueren, ohne es zu lösen
  • Reduzieren Sie die Genauigkeit gekoppelter nichtlinearer Prozesse

Diese Einschränkungen sollten eher als Genauigkeit, nichtlineare Konvergenz oder physikalische Auflösungsgrenzen als als universelle CFL-Bedingung bezeichnet werden.

Mehrere Zeitschrittbeschränkungen

Große Simulationscodes berechnen oft mehrere Kandidatenschrittgrößen. PISM berücksichtigt beispielsweise modellspezifische Einschränkungen im Zusammenhang mit Advektion, Diffusion, Berichtsintervallen und anderen physikalischen Prozessen.

Das Aufzeichnen des Grundes, der jeden akzeptierten Schritt begrenzt, ist nützlich. Eine von einem Fehlercontroller dominierte Berechnung erfordert eine andere Optimierung als eine durch die schnellste Geschwindigkeit oder die feinste Maschenzelle begrenzte.

Die PISM zeitschritte Dokumentation bietet ein praktisches Beispiel für die Kontrolle mehrerer Einschränkungen.

Ausgabezeiten und interne Schritte

Angeforderte Ausgabezeiten müssen nicht immer Integrationsschritte werden. Viele Solver verwenden dichte Ausgabe oder Interpolation, um gespeicherte Ergebnisse zwischen akzeptierten internen Zeitniveaus zu berechnen.

Wenn jede Ausgabezeit zu einem exakten Solverschritt wird, kann die Effizienz verringert werden, wenn häufige Ausgaben angefordert werden.

Die genaue Schrittausrichtung kann dennoch angemessen sein, wenn:

  • Eine diskontinuierliche Last ändert sich zu einem bekannten Zeitpunkt.
  • Eine Randbedingung schaltet abrupt.
  • Ein Ereignis ändert die maßgeblichen Gleichungen.
  • Eine Kontrollaktion muss zu einem genauen Zeitpunkt erfolgen.
  • Der Methode fehlt eine ausreichend genaue Dichte.

Nach einer Unterbrechung muss der mehrstufige Verlauf oder die adaptive Steuerung möglicherweise neu gestartet werden.

Adaptives Zeitspringen in FIPY

FIPY löst räumlich diskretisierte Finite-Volumen-Gleichungen, schaltet aber keinen Aufruf wie:

equation.solve(
    var=phi,
    dt=dt,
    rtol=...,
    atol=...
)

in einen eingebetteten temporären Fehlercontroller. Solvertoleranzen in FIPY steuern hauptsächlich die algebraische lineare Lösung.

Die aktuelle FIPY-Dokumentation empfiehlt das externe steppyngstounes-Paket für die adaptive Schrittverwaltung. FIPY-Beispiele verwenden Controller-Fehler, die aus Gleichungsresiden, Erhaltungsprüfungen oder anderen anwendungsspezifischen Kriterien abgeleitet wurden.

Siehe die offizielle Fipy Adaptive Stepping Documentation.

Ein FIPY-Schrittverdopplungsbeispiel

Das folgende Lernbeispiel umfasst die implizite transiente Diskretisierung von FIPY in einem Schritt-Doppel-Controller.

Es führt einen vollen Rückwärts-Euler-Schritt und zwei Halbschritte durch. Das Ergebnis mit zwei Schritten wird akzeptiert, wenn sein normalisierter Fehler unter eins liegt.

import numpy as np

from fipy import (
    Grid1D,
    CellVariable,
    TransientTerm,
    DiffusionTerm
)

# Mesh and physical model
cell_count = 100
domain_length = 1.0
cell_size = domain_length / cell_count
diffusivity = 0.01

mesh = Grid1D(
    nx=cell_count,
    dx=cell_size
)

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

x = mesh.cellCenters[0]

phi.setValue(
    1.0,
    where=x < 0.25
)

equation = (
    TransientTerm()
    ==
    DiffusionTerm(
        coeff=diffusivity
    )
)

def advance_from_state(
    state,
    total_step,
    substeps
):
    trial = CellVariable(
        mesh=mesh,
        value=state,
        hasOld=True
    )

    substep_size = (
        total_step / substeps
    )

    for _ in range(substeps):
        trial.updateOld()

        equation.solve(
            var=trial,
            dt=substep_size
        )

    return np.asarray(
        trial.value
    ).copy()


# Controller settings
current_time = 0.0
final_time = 0.5

dt = 1e-3
minimum_dt = 1e-10
maximum_dt = 0.05

relative_tolerance = 1e-4
absolute_tolerance = 1e-8

safety = 0.9
minimum_factor = 0.2
maximum_factor = 3.0

# Backward Euler has order p = 1
method_order = 1

accepted_steps = 0
rejected_steps = 0

while current_time < final_time:
    dt = min(
        dt,
        final_time - current_time,
        maximum_dt
    )

    state = np.asarray(
        phi.value
    ).copy()

    # One full step
    full_step = advance_from_state(
        state=state,
        total_step=dt,
        substeps=1
    )

    # Two half-steps
    half_steps = advance_from_state(
        state=state,
        total_step=dt,
        substeps=2
    )

    # Error estimate for the refined solution
    error_vector = (
        half_steps - full_step
    ) / (
        2 ** method_order - 1
    )

    scale = (
        absolute_tolerance
        + relative_tolerance
        * np.maximum(
            np.abs(state),
            np.abs(half_steps)
        )
    )

    normalized_error = np.sqrt(
        np.mean(
            (error_vector / scale) ** 2
        )
    )

    if normalized_error <= 1.0:
        # Accept the more accurate half-step result
        phi.setValue(half_steps)
        current_time += dt
        accepted_steps += 1

        if normalized_error == 0.0:
            factor = maximum_factor
        else:
            factor = (
                safety
                * normalized_error
                ** (
                    -1.0
                    / (method_order + 1)
                )
            )

        factor = np.clip(
            factor,
            minimum_factor,
            maximum_factor
        )

        dt *= factor

    else:
        # Reject and retry from the saved state
        rejected_steps += 1

        factor = (
            safety
            * normalized_error
            ** (
                -1.0
                / (method_order + 1)
            )
        )

        factor = np.clip(
            factor,
            minimum_factor,
            1.0
        )

        dt *= factor

        if dt < minimum_dt:
            raise RuntimeError(
                "Adaptive step fell below minimum_dt"
            )

print("Accepted steps:", accepted_steps)
print("Rejected steps:", rejected_steps)
print("Final time:", current_time)

Diese Implementierung ist absichtlich einfach. Jedes versuchte Intervall erfordert drei implizite Lösungen, daher kann es teuer sein. Ein Produktions-BDF- oder Embedded-Verfahren liefert normalerweise einen effizienteren Schätzer und einen glatteren PI- oder PID-Regler.

Hinzufügen einer expliziten CFL-Einschränkung

Für einen explizit integrierten Advektionsbegriff kann der fehlerselektierte Schritt separat eingeschränkt werden:

maximum_speed = 2.0
cfl_number = 0.5

dt_cfl = (
    cfl_number
    * cell_size
    / maximum_speed
)

dt = min(
    dt_error,
    dt_cfl,
    maximum_dt,
    final_time - current_time
)

Verwenden Sie für ungleichmäßige Netze die restriktivste lokale Zellskala oder eine flächenbasierte Schätzung, die der räumlichen Methode angemessen ist.

Toleranzen auswählen

Es gibt kein universelles Paar von Toleranzen, die für jede PDE geeignet sind.

Ein praktischer Prozess ist:

  1. Wählen Sie absolute Toleranzen entsprechend der physikalischen Skala jedes Feldes.
  2. Wählen Sie eine mäßige relative Toleranz aus.
  3. Wiederholen Sie die Simulation mit um den Faktor zehn reduzierten Toleranzen.
  4. Vergleichen Sie die Mengen von wissenschaftlichem Interesse.
  5. Ziehen Sie weiter an, bis sich das Ergebnis weniger als der akzeptierte zeitliche Fehler ändert.

Das Reduzieren von rtol macht die Anforderung strenger und erhöht normalerweise die Rechenkosten. Das Erhöhen von rtol löst die Anforderung und verringert normalerweise die Genauigkeit.

Eine zu kleine Toleranz kann übermäßige Arbeit erzwingen, wenn eine Komponente durch Null geht. Eine zu große kann sinnvolle Änderungen in kleinen Variablen ausblenden.

Schritt Ablehnung

Ein abgelehnter expliziter Schritt verschwendet Evaluierungen. Ein abgelehnter impliziter Schritt kann nichtlineare Iterationen, Jacobian-Berechnungen, Faktorisierungen und Vorkonditionierer verschwenden.

Eine kleine Anzahl abgelehnter Schritte ist normal. Eine hohe Ablehnungsrate kann anzeigen:

  • Ein erster Schritt, der zu groß ist
  • ein übermäßig aggressiver Controller
  • eine Diskontinuität oder ein Ereignis
  • Schlecht skalierte Toleranzen
  • Ein unzuverlässiger Fehlerschätzer
  • Steifheit in einer expliziten Methode
  • Unvollständige nichtlineare Konvergenz
  • ein falsches oder schlecht konditioniertes Modell

Das Controller-Tuning sollte nicht zum Ausblenden von Modell- oder Solverfehlern verwendet werden.

Wenn adaptives Steppen wichtige Dynamiken verpassen kann

Ein Fehlerschätzer misst die numerische Lösung, die durch die gewählte Methode erzeugt wird. Es weiß nicht automatisch, welche physischen Merkmale wichtig sind.

Ein Solver kann Schritte ausführen, die zu groß sind für:

  • Kurze externe Impulse
  • Hochfrequenzwellen
  • Schwellenereignisse
  • Kontaktaktivierung
  • Schnelle Phasenänderungen
  • Diskontinuierliche Quellbegriffe

Verwenden Sie maximale Schrittbeschränkungen, Ereignisbehandlung oder erzwungene Zeitebenen, wenn solche Funktionen aufgelöst werden müssen.

Wenn feste Schritte nützlich sind

Feste Zeitschritte bleiben angemessen, wenn:

  • Ein strukturerhaltendes Verfahren erfordert einen konstanten Schritt.
  • Für das Debuggen sind identische diskrete Trajektorien erforderlich.
  • Die Lösung hat eine nahezu einheitliche Zeitskala.
  • Die Simulation wird mit Messdaten synchronisiert.
  • Eine GPU oder parallele Implementierung schneidet mit vorhersehbaren Workloads besser ab.
  • Die Zeitschritt-Konvergenzstudie erfordert eine kontrollierte Verfeinerung.

Adaptive Solver können durch Interpolation weiterhin Ergebnisse zu üblichen Ausgabezeiten zurückgeben. Ein festes Stepping ist daher nicht nur erforderlich, um Läufe mit bestimmten Zeitstempel zu vergleichen.

Adaptives Tritt und Reproduzierbarkeit

Kleine Änderungen in Toleranzen, Solver-Versionen, Hardware-Arithmetik oder nichtlinearer Konvergenz können die akzeptierte Schrittfolge ändern.

Ein reproduzierbarer Bericht sollte aufzeichnen:

  • Zeitintegrator und Version
  • Relative und absolute Toleranzen
  • Anfangs-, Minimal- und Maximalschritte
  • Fehlernorm
  • Controller-Typ
  • CFL- oder Physik-basierte Einschränkungen
  • Veranstaltungszeiten
  • Akzeptierte und abgelehnte Schrittzählungen
  • Nichtlineare und lineare Solvertoleranzen

Häufige Fehler

  • Verwenden der algebraischen Resttoleranz als zeitliche Fehlertoleranz
  • Angenommen, FIPY-Änderungen dt bis rtol und atol Argumente
  • Akzeptieren des weniger genauen Full-Step-Ergebnisses bei der Step-Dopplung
  • Vergessen des Faktors 2^p - 1 in der Richardson-Schätzung
  • Verwenden eines festen Controller-Exponenten für jeden Schätzer
  • Ignorieren der CFL-Grenze eines expliziten Schemas
  • Jede implizite Einschränkung aufrufen, eine CFL-Bedingung
  • Verwenden von dormand-Prince für ein stark steifes Diffusionsproblem
  • Lösen von rtol, wenn eine größere Genauigkeit erforderlich ist
  • Ermöglichen, dass ein Schritt eine diskontinuierliche Last ohne Ereignis überschreitet
  • Verwirrung von Tfail mit nichtlinearem Solver-Fehler
  • Vergleichen von adaptiven Lösern nur nach akzeptierter Schrittanzahl

Ein praktischer Arbeitsablauf

  1. Überprüfen Sie zuerst die Implementierung mit festen Schritten.
  2. Bestimmen Sie, ob das halbdiskrete System steif ist.
  3. Wählen Sie einen der Methode angemessenen Fehlerschätzer aus.
  4. Skalieren Sie jede Lösungskomponente mit berechtigten Toleranzen.
  5. Fügen Sie CFL- und Physik-basierte Maximum-Step-Einschränkungen hinzu.
  6. Behandeln Sie Diskontinuitäten und Ereignisse explizit.
  7. Zeichnen Sie akzeptierte Schritte, Ablehnungen und einschränkende Gründe auf.
  8. Wiederholen Sie die Simulation mit engeren Toleranzen.
  9. Vergleichen Sie physikalische Größen und nicht nur Solver-Protokolle.
  10. Benchmark-Gesamtlaufzeit zum gleichen gemessenen Fehler.

Verwandte Anleitungen

weiterlesen

Schlussfolgerung

Das adaptive Zeitschritt verbessert die Effizienz, indem der Rechenaufwand an die sich entwickelnde Lösung angepasst wird. Es reduziert den Schritt in der Nähe von schnellen Transienten und erhöht ihn, wenn die Lösung glatt wird.

Eingebettete Runge-Kutta-Paare schätzen den Fehler aus gemeinsamen Phasen. Step-Doubling vergleicht einen vollen Schritt mit zwei Halbschritten. BDF-Methoden mit variabler Ordnung verwenden den Lösungsverlauf, die Vorhersage und die geteilten Unterschiede, um sowohl die Schrittgröße als auch die Reihenfolge zu steuern.

Die Fehlerkontrolle ersetzt nicht die Stabilitätsanalyse. Explizite Methoden müssen CFL- und Diffusionsbeschränkungen einhalten. Implizite Methoden benötigen immer noch Schritte, die klein genug sind, um die Physik aufzulösen und eine zuverlässige nichtlineare Konvergenz zu ermöglichen.

FIPY bietet keine automatische zeitliche Anpassung durch gewöhnliche rtol– und atol Argumente an solve(). Adaptive FIPY-Workflows erfordern einen externen Schrittcontroller oder eine benutzerdefinierte Fehlerlogik.

Eine glaubwürdige adaptive Berechnung dokumentiert ihre Toleranzen, Fehlernorm, Controller, abgelehnte Schritte, Stabilitätsbeschränkungen, Ereignisbehandlung und Konvergenz unter engeren Einstellungen. Ziel ist es nicht, die Anzahl der Schritte zu minimieren. Es ist die erforderliche physikalische Genauigkeit mit den niedrigsten zuverlässigen Rechenkosten zu erreichen.