Pas de temps adaptatif pour les solveurs PDE

Reading Time: 13 minutes

Le pas de temps adaptatif modifie la taille du pas de temps au cours d’une simulation. Le solveur fait des étapes plus petites lorsque la solution change rapidement et des étapes plus grandes lorsque l’évolution se lisse.

Un calcul à pas fixe doit utiliser une valeur de Δt tout au long de la simulation. Cette valeur est souvent sélectionnée en fonction de l’événement, de la transitoire ou de la restriction de stabilité les plus exigeants. La même petite étape est ensuite utilisée pendant de longs intervalles où cela n’est pas nécessaire.

Une méthode adaptative estime l’erreur de chaque étape proposée. Il accepte l’étape lorsque l’erreur normalisée est inférieure à la tolérance demandée et la rejette lorsque l’erreur est trop importante. Un contrôleur sélectionne ensuite une nouvelle taille de pas.

Le contrôle des erreurs n’est qu’une partie du processus. Les méthodes explicites doivent toujours respecter les limites de LFC et de diffusion. Les méthodes implicites peuvent nécessiter des restrictions pour la précision, la convergence non linéaire, la résolution des ondes, les événements ou les contraintes physiques. Un solveur fiable combine ces exigences plutôt que de permettre à une estimation d’erreur de tout contrôler.

Qu’est-ce que le pas de temps adaptatif ?

Après discrétisation spatiale, une PDE dépendante du temps devient généralement un système d’équations différentielles ordinaires :

du/dt = F(t, u)

Une méthode numérique fait passer la solution de tⁿ à :

tⁿ⁺¹ = tⁿ + Δt

Un solveur adaptatif suit un cycle d’acceptation ou de rejet :

Proposez un pas de temps.
Calculer une solution d’essai.
Estimez l’erreur temporelle locale.
Normaliser l’erreur en utilisant les tolérances absolues et relatives.
Accepter ou rejeter l’étape de procès.
Sélectionnez la taille de l’étape suivante.

Les étapes rejetées n’avancent pas le temps de simulation. Le solveur restaure l’état accepté précédent et répète le calcul avec une valeur plus petite de Δt.

Erreur locale et erreur globale

L’erreur de troncature locale est l’erreur introduite par un pas de temps lorsque l’étape commence à partir de la solution exacte.

L’erreur globale est la différence accumulée entre les solutions numériques et exactes après de nombreuses étapes.

Pour une méthode de commande p :

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

Global error = O(Δt^p)

Les méthodes adaptatives estiment normalement l’erreur locale. Garder chaque estimation locale en dessous d’une tolérance ne fournit pas une limite universelle rigoureuse sur l’erreur globale, mais elle offre un mécanisme de contrôle pratique efficace.

Tolérances absolues et relatives

Une valeur d’erreur brute a peu de sens sans l’échelle de chaque composant de solution. Les solveurs adaptatifs calculent donc une erreur normalisée.

Une échelle de composantes communes est :

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

L’erreur quadratique moyenne pondérée normalisée est :

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

L’étape est normalement acceptée lorsque :

E ≤ 1

La tolérance absolue contrôle les composants proches de zéro. La tolérance relative contrôle les composantes dont la magnitude est grande par rapport à atol.

Différents champs peuvent nécessiter des tolérances absolues différentes. Une température mesurée dans des centaines de Kelvin ne doit pas nécessairement utiliser la même tolérance absolue qu’une concentration proche de 10⁻⁹.

Comment la prochaine étape est sélectionnée

Si l’erreur locale estimée se comporte comme :

error ∝ Δt^(p+1)

Un contrôleur de base peut utiliser :

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

Le facteur de sécurité est inférieur à un. Cela réduit le risque que la prochaine étape se situe directement sur la limite de rejet.

Les implémentations de production limitent également les changements de taille des étapes :

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

L’exposant correct dépend de l’ordre représenté par l’estimateur d’erreur et la convention de contrôleur. Il ne doit pas être copié aveuglément entre les méthodes non liées.

Contrôleurs I, PI et PID

Un contrôleur intégré simple utilise uniquement l’erreur normalisée actuelle. Cela peut entraîner une alternance de l’historique des pas de temps entre les augmentations et les rejets agressifs.

Les contrôleurs PI et PID utilisent également les erreurs des étapes précédentes acceptées. Cela produit des changements de taille de pas plus fluides et peut réduire les taux de rejet.

Un contrôleur PI simplifié a la forme :

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

Les coefficients dépendent de l’ordre de méthode et de la conception du contrôleur. Un contrôle sophistiqué est utile, mais il ne peut pas réparer un estimateur d’erreurs inexact ou un intégrateur de temps inadapté.

Paires Runge-Kutta intégrées

Une paire Runge-Kutta intégrée calcule deux approximations à partir du même ensemble d’étapes intermédiaires.

Les deux formules ont des ordres différents :

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

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

La différence fournit une estimation d’erreur :

e =
u(high)
-
u(low)

Étant donné que les deux formules partagent leurs évaluations sur scène, l’estimateur est beaucoup moins cher que de réaliser deux intégrations indépendantes.

Les méthodes Runge-Kutta explicites intégrées sont les mieux adaptées aux systèmes non raides. Si la rigidité contrôle la taille du pas, augmentant ou décroissant Δt

Dormand-Prince 5(4)

Dormand-Prince 5(4) est une paire intégrée en sept étapes. Il produit une solution de cinquième ordre et une estimation d’erreur du quatrième ordre.

La paire utilise une extrapolation locale : l’approximation du cinquième ordre devient la solution acceptée, tandis que la formule d’ordre inférieur contrôle l’étape.

Il a également une propriété FSAL en usage ordinaire. La dernière évaluation dérivée d’une étape acceptée peut devenir la première évaluation de la prochaine étape, réduisant le nombre de nouvelles évaluations de fonctions après le démarrage.

Dormand-Prince est utilisé par Scipy RK45 et MATLAB ode45. Il s’agit d’un choix général solide pour les problèmes de valeur initiale non rigides et fluides.

tsit5

tsit5 est la méthode runge-kutta intégrée de tsitouras 5(4) . Il est largement utilisé dans l’écosystème SCIML comme méthode par défaut pour les problèmes non raides aux tolérances ordinaires.

La méthode est conçue pour fournir un équilibre favorable entre la qualité d’estimation des erreurs, le coût de la scène et l’efficacité pratique.

Cela reste une méthode explicite. Si une PDE semi-discrète est rigide en raison de la diffusion, des réactions ou des échelles de temps fortement séparées, une méthode implicite, Rosenbrock, BDF ou IMEX peut être plus efficace.

Bogacki–Shampe 3(2)

Bogacki–Shamine 3(2) est une paire intégrée en quatre étapes. Il fournit une solution acceptée au troisième ordre avec un estimateur d’erreurs de deuxième ordre.

Il est implémenté comme RK23 dans Scipy et sous-tend le ode23 de Matlab.

La paire peut être utile lorsque la précision modérée est suffisante ou lorsque les évaluations des fonctions sont peu coûteuses. Son ordre inférieur peut nécessiter plus d’étapes acceptées qu’une méthode de cinquième ordre lorsque des tolérances strictes sont demandées.

doublonnage

Le doublement par étapes estime l’erreur temporelle en comparant la même méthode numérique à deux résolutions.

La procédure calcule :

Un pas de longueur complet Δt.
Deux demi-pas de longueur Δt/2.
La différence entre les deux résultats.

Pour une méthode de commande p, une estimation de l’erreur dans le résultat raffiné en deux demi-étapes est :

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

La solution acceptée devrait normalement être le résultat des deux demi-étapes car elle est plus précise.

Le doublement par étapes nécessite trois applications de la méthode sous-jacente : une étape complète et deux demi-étapes. Une implémentation implicite peut donc nécessiter trois résolutions non linéaires ou linéaires à moins que certains travaux de configuration ne puissent être réutilisés.

Estimation résiduelle et défectueuse

Les méthodes basées sur les résidus évaluent la précision avec laquelle une trajectoire numérique reconstruite satisfait l’équation différentielle entre les points acceptés.

Une reconstruction continue ũ(t) présente un défaut :

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

Le défaut peut prendre en charge une estimation d’erreur lorsqu’il est combiné avec des informations de stabilité ou une norme appropriée.

Le résidu algébrique d’une solution implicite n’est pas automatiquement une estimation d’erreur temporelle. La méthode de Newton peut réduire l’équation discrète résiduelle presque à zéro, même lorsque le pas de temps est trop important pour représenter la solution physique avec précision.

La convergence algébrique et l’erreur de troncature temporelle nécessitent donc des contrôles distincts.

Méthodes adaptatives BDF

Les formules de différenciation vers l’arrière sont des méthodes implicites en plusieurs étapes utilisées pour les systèmes rigides. Les implémentations d’ordre variable basculent généralement entre les commandes un à cinq.

Un solveur BDF stocke les informations des états acceptés précédents. Il construit un prédicteur pour le nouvel état, résout l’équation implicite et estime l’erreur de troncature locale à l’aide de différences divisées ou d’une représentation historique de type Nordsieck.

Le solveur peut changer :

La taille du pas de temps
la commande BDF
La fréquence des mises à jour jacobiennes
La configuration du solveur linéaire ou du préconditionneur

Une solution fluide peut justifier une augmentation de la commande. Un événement, une phase de démarrage, une discontinuité ou un échec du test d’erreur peut forcer le solveur à réduire son ordre et sa taille de pas.

BDF2 est une formule de différenciation en arrière. Ce n’est pas Crank – Nicolson, bien que les deux méthodes soient de second ordre.

Contrôle des erreurs dans COMSOL BDF

Le contrôleur BDF de COMSOL évalue une estimation de l’erreur locale moyenne pondérée. Une étape passe lorsque l’erreur normalisée est inférieure à un.

Le solveur peut utiliser des commandes BDF de un à cinq. Il examine la douceur de la solution, sélectionne une commande, tente une étape et répète l’étape avec une taille plus petite lorsque le test d’erreur local échoue.

Son journal des solveurs comprend :

Order pour la commande BDF actuelle
Tfail pour les tests d’erreur de pas de temps échoués
NLfail pour les défaillances non linéaires du solveur

Un nombre élevé de Tfail suggère que le contrôleur a fréquemment proposé des étapes trop importantes pour la précision demandée. Un nombre élevé de NLfail indique que la résolution non linéaire algébrique a eu des difficultés.

Ces deux échecs ne doivent pas être interprétés comme le même problème.

Le mécanisme détaillé est décrit dans Sélection automatique de pas de temps et d’ordre dans le temps dans les problèmes dépendant du temps.

Erreur algébrique et erreur temporelle

Une méthode implicite résout un système non linéaire à chaque pas de temps. Si Newton ou le solveur linéaire se termine trop tôt, l’erreur algébrique peut devenir comparable à l’erreur temporelle.

Le contrôleur de pas de temps peut alors réagir à une erreur qui provient d’une convergence algébrique incomplète plutôt que de la discrétisation temporelle.

Une configuration de solveur crédible devrait rendre la tolérance algébrique suffisamment serrée que la cible temporelle. Le rendre inutilement strict, c’est aussi du travail.

Certains solveurs coordonnent la convergence non linéaire et la sélection de pas de temps. Un contrôleur non linéaire peut réduire l’étape lorsque la stabilité de Newton nécessite une valeur inférieure à celle proposée par l’estimateur de précision BDF.

Limites de LFC et pas adaptatifs

Le contrôle d’erreur explicite ne peut pas remplacer une restriction de stabilité explicite.

Pour l’advection, une limite CFL typique est :

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

Pour une diffusion explicitement intégrée :

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

Les constantes dépendent de la discrétisation spatiale, de la dimension, de la géométrie du maillage et de l’intégrateur de temps.

L’étape utilisable peut être :

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

Une méthode Runge-Kutta adaptative peut signaler une très petite erreur et devenir toujours instable si la limite CFL est violée.

Les méthodes implicites ont-elles besoin d’une limite CFL ?

Une discrétisation implicite implicite d’un modèle linéaire peut ne pas avoir la même limite de stabilité explicite de la LFC. Cela ne signifie pas que le pas de temps peut être arbitrairement important.

Les grandes étapes implicites peuvent :

Miss Waves et transitoires rapides
Introduire un amortissement numérique excessif
Perdre la monotonie
Rendre les itérations de Newton difficiles
traverser un événement sans le résoudre
Réduire la précision des processus non linéaires couplés

Ces restrictions doivent être appelées précision, convergence non linéaire ou limites de résolution physique plutôt qu’une condition universelle de LFC.

Plusieurs contraintes de pas de temps

Les grands codes de simulation calculent souvent plusieurs tailles de pas candidates. Le PISM, par exemple, prend en compte les restrictions spécifiques au modèle liées à l’advection, à la diffusion, aux intervalles de rapports et à d’autres processus physiques.

Il est utile d’enregistrer la raison pour laquelle chaque étape acceptée limite chaque étape acceptée. Un calcul dominé par un contrôleur d’erreurs nécessite une optimisation différente d’une limite limitée par la vitesse la plus rapide ou la cellule de maillage la plus fine.

Le PISM documentation de pas-temps d’un contrôle multi-contraintes.

Temps de sortie et étapes internes

Les temps de sortie demandés ne doivent pas toujours devenir des étapes d’intégration. De nombreux solveurs utilisent une sortie dense ou une interpolation pour calculer les résultats stockés entre les niveaux de temps internes acceptés.

Forcer chaque temps de sortie à devenir une étape de solveur exacte peut réduire l’efficacité lorsque la sortie fréquente est demandée.

L’alignement exact des étapes peut toujours être approprié lorsque :

Une charge discontinue change à un moment connu.
Une condition aux limites change brusquement.
Un événement modifie les équations régissant.
Une action de contrôle doit se produire à un instant précis.
La méthode manque de sortie dense suffisamment précise.

Après une discontinuité, l’historique en plusieurs étapes ou le contrôleur adaptatif peut avoir besoin de redémarrer.

Pas de temps adaptatif dans Fipy

FIPY résout des équations de volume fini dans l’espace discrétisé mais ne tourne pas un appel tel que :

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

dans un contrôleur d’erreur temporelle intégré. Les tolérances des solveurs dans FIPY contrôlent principalement la résolution linéaire algébrique.

La documentation FIPY actuelle recommande le package externe steppyngstounes pour la gestion des étapes adaptatives. Les exemples de FIPY utilisent des erreurs de contrôleur dérivées des résidus d’équation, des contrôles de conservation ou d’autres critères spécifiques à l’application.

Consultez la documentation pas à pas adaptative FIPY.

Un exemple de double-doublement de Fipy

L’exemple éducatif suivant enveloppe la discrétisation transitoire implicite du premier ordre de Fipy dans un contrôleur de doublage par étapes.

Il effectue une étape complète d’Euler vers l’arrière et deux demi-pas. Le résultat en deux demi-étapes est accepté lorsque son erreur normalisée est inférieure à un.

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)

Cette mise en œuvre est intentionnellement simple. Chaque intervalle de tentatives nécessite trois résolutions implicites, donc cela peut être coûteux. Un BDF de production ou une méthode embarquée fournit normalement un estimateur plus efficace et un contrôleur PI ou PID plus lisse.

Ajout d’une contrainte de LCF explicite

Pour un terme d’advection explicitement intégré, l’étape sélectionnée par erreur peut être limitée séparément :

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
)

Pour les maillages non uniformes, utilisez l’échelle de cellule locale la plus restrictive ou une estimation basée sur le visage approprié à la méthode spatiale.

Choisir des tolérances

Il n’y a pas de paires universelles de tolérances adaptées à chaque PDE.

Un processus pratique est :

Choisissez des tolérances absolues en fonction de l’échelle physique de chaque champ.
Sélectionnez une tolérance relative modérée.
Répétez la simulation avec des tolérances réduites d’un facteur dix.
Comparez les quantités d’intérêt scientifique.
Continuez à resserrer jusqu’à ce que le résultat change moins que l’erreur temporelle acceptée.

La réduction de rtol rend l’exigence plus stricte et augmente normalement le coût de calcul. L’augmentation de rtol assouplit le besoin et réduit normalement la précision.

Une tolérance absolue trop faible peut forcer un travail excessif lorsqu’un composant passe par zéro. Celui qui est trop grand peut masquer des changements significatifs dans de petites variables.

Rejet d’étape

Une étape explicite rejetée gaspille les évaluations d’étape. Une étape implicite rejetée peut gaspiller des itérations non linéaires, des calculs jacobiens, des factorisations et la configuration du préconditionneur.

Un petit nombre d’étapes rejetées est normal. Un taux de rejet élevé peut indiquer :

Une première étape trop importante
Un contrôleur trop agressif
une discontinuité ou un événement
Tolérances mal évoluées
Un estimateur d’erreurs non fiable
Rigidité dans une méthode explicite
Convergence non linéaire incomplète
Un modèle incorrect ou mal conditionné

Le réglage du contrôleur ne doit pas être utilisé pour masquer les défaillances du modèle ou du solveur.

Lorsque le pas adaptatif peut manquer une dynamique importante

Un estimateur d’erreurs mesure la solution numérique générée par la méthode choisie. Il ne sait pas automatiquement quelles caractéristiques physiques comptent.

Un solveur peut prendre des mesures trop importantes pour :

impulsions externes courtes
Ondes haute fréquence
Événements de seuil
Activation du contact
Changements de phase rapides
Termes de la source discontinue

Utilisez des contraintes d’étape maximales, une gestion des événements ou des niveaux de temps forcés lorsque ces fonctionnalités doivent être résolues.

Lorsque des étapes fixes sont utiles

Le pas de temps fixe reste approprié lorsque :

Une méthode de conservation de la structure nécessite une étape constante.
Des trajectoires discrètes identiques sont nécessaires pour le débogage.
La solution a une échelle de temps presque uniforme.
La simulation est synchronisée avec les données mesurées.
Un GPU ou une implémentation parallèle fonctionne mieux avec des charges de travail prévisibles.
L’étude de convergence de pas de temps nécessite un raffinement contrôlé.

Les solveurs adaptatifs peuvent toujours renvoyer des résultats à des temps de sortie communs grâce à l’interpolation. Il n’est donc pas nécessaire d’effectuer une étape fixe pour comparer uniquement les exécutions à des horodatages spécifiés.

Pas adaptatif et reproductibilité

De petits changements dans les tolérances, les versions de solveur, l’arithmétique matérielle ou la convergence non linéaire peuvent modifier la séquence d’étapes acceptée.

Un rapport reproductible doit enregistrer :

Intégrateur de temps et version
Tolérances relatives et absolues
Étapes initiales, minimales et maximales
Norme d’erreur
Type de contrôleur
LFC ou restrictions basées sur la physique
Heures d’événement
Nombre d’étapes acceptés et rejetés
Tolérances non linéaires et linéaires du solveur

erreurs courantes

Utilisation de la tolérance résiduelle algébrique comme tolérance d’erreur temporelle
En supposant que FIPY change dt à rtol et atol les arguments
Accepter le résultat complet moins précis en cas de doublage par étapes
Oublier le facteur 2^p - 1 dans l’estimation de Richardson
Utilisation d’un exposant de contrôleur fixe pour chaque estimateur
Ignorer la limite CFL d’un schéma explicite
Appeler toutes les limitations implicites une condition CFL
Utilisation de Dormand-Prince pour un problème de diffusion fortement raide
Desserrage rtol lorsqu’une plus grande précision est requise
Permettre à une étape de franchir une charge discontinue sans événement
Déroutant Tfail avec une défaillance non linéaire du solveur
Comparaison des solveurs adaptatifs uniquement par le nombre de pas accepté

Un flux de travail pratique

Vérifiez d’abord l’implémentation par étapes fixes.
Déterminez si le système semi-discret est rigide.
Sélectionnez un estimateur d’erreurs approprié à la méthode.
Mettez à l’échelle chaque composant de solution avec des tolérances justifiées.
Ajoutez des LFC et des contraintes de pas maximum basées sur la physique.
Gérez explicitement les discontinuités et les événements.
Enregistrez les étapes, les rejets et les raisons limitatives acceptées.
Répétez la simulation avec des tolérances plus serrées.
Comparez les quantités physiques plutôt que uniquement les journaux de solveurs.
Exécution de référence totale à la même erreur mesurée.

Guides connexes

Méthodes d’intégration temporelle pour les solveurs PDE : schémas explicites ou implicites : comparez les régions de stabilité, l’amortissement, la rigidité et le coût de calcul.
Méthodes implicites vs explicites : stabilité, précision et quand utiliser chacune : séparer la stabilité numérique de la précision temporelle.
Choisir le bon solveur Python PDE : Fipy vs Py-PDE vs Fenics – comparer les frameworks Python et leurs flux de travail d’intégration temporelle.
comment gère les maillages et les structures de grille — Comprendre comment la taille des cellules et la structure du maillage affectent les limites de stabilité.

Lectures complémentaires

Conclusion

Le pas de temps adaptatif améliore l’efficacité en associant l’effort de calcul à la solution évolutive. Il réduit l’étape près des transitoires rapides et l’augmente lorsque la solution devient lisse.

Les paires Runge-Kutta intégrées estiment l’erreur à partir des étapes partagées. Le doublement par étapes compare une étape complète avec deux demi-étapes. Les méthodes BDF d’ordre variable utilisent l’historique des solutions, la prédiction et les différences divisées pour contrôler à la fois la taille et l’ordre des pas.

Le contrôle des erreurs ne remplace pas l’analyse de stabilité. Les méthodes explicites doivent respecter les restrictions de LFC et de diffusion. Les méthodes implicites ont encore besoin d’étapes suffisamment petites pour résoudre la physique et permettre une convergence non linéaire fiable.

FIPY ne fournit pas d’adaptation temporelle automatique grâce aux arguments ordinaires rtol et atol à solve(). Les workflows adaptatifs de Fipy nécessitent un contrôleur d’étape externe ou une logique d’erreur personnalisée.

Un calcul adaptatif crédible documente ses tolérances, sa norme d’erreur, son contrôleur, ses étapes rejetées, ses contraintes de stabilité, sa gestion des événements et sa convergence dans des paramètres plus stricts. L’objectif n’est pas de minimiser le nombre d’étapes. Il s’agit d’atteindre la précision physique requise avec le coût de calcul fiable le plus bas.

Pas de temps adaptatif pour les solveurs PDE : estimation des erreurs et CFL