Paso de tiempo adaptativo para solucionadores PDE: estimación de errores y CFL

Paso de tiempo adaptativo Cambia el tamaño del paso de tiempo durante una simulación. El solucionador toma pasos más pequeños cuando la solución cambia rápidamente y pasos más grandes cuando la evolución se vuelve suave.

Un cálculo de paso fijo debe usar un valor de Δt a lo largo de toda la simulación. Ese valor a menudo se selecciona de acuerdo con el evento más exigente, transitorio o restricción de estabilidad. Luego se usa el mismo pequeño paso durante largos intervalos donde es innecesario.

Un método adaptativo estima el error de cada paso propuesto. Acepta el paso cuando el error normalizado está por debajo de la tolerancia solicitada y lo rechaza cuando el error es demasiado grande. Luego, un controlador selecciona un nuevo tamaño de paso.

El control de errores es solo una parte del proceso. Los métodos explícitos aún deben respetar los límites de CFL y de difusión. Los métodos implícitos pueden necesitar restricciones de precisión, convergencia no lineal, resolución de onda, eventos o restricciones físicas. Un solucionador confiable combina estos requisitos en lugar de permitir que una estimación de error controle todo.

¿Qué es el paso de tiempo adaptativo?

Después de la discretización espacial, una PDE dependiente del tiempo se convierte comúnmente en un sistema de ecuaciones diferenciales ordinarias:

du/dt = F(t, u)

Un método numérico avanza la solución de tⁿ a:

tⁿ⁺¹ = tⁿ + Δt

Un solucionador adaptativo sigue un ciclo de aceptación o rechazo:

1. Proponer un paso de tiempo.
2. Calcular una solución de prueba.
3. Estimar el error temporal local.
4. Normalice el error utilizando tolerancias absolutas y relativas.
5. aceptar o rechazar el paso de prueba.
6. Seleccione el siguiente tamaño de paso.

Los pasos rechazados no adelantan el tiempo de simulación. El solucionador restaura el estado aceptado anterior y repite el cálculo con un valor menor de Δt.

Error local y error global

El error de truncamiento local es el error introducido en un paso de tiempo cuando el paso comienza desde la solución exacta.

El error global es la diferencia acumulada entre las soluciones numéricas y exactas después de muchos pasos.

Para un método de orden p:

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

Global error = O(Δt^p)

Los métodos adaptativos normalmente estiman el error local. Mantener cada estimación local por debajo de una tolerancia no proporciona un límite riguroso universal sobre el error global, pero ofrece un efectivo mecanismo de control práctico.

Tolerancias absolutas y relativas

Un valor de error bruto tiene poco significado sin la escala de cada componente de la solución. Por lo tanto, los solucionadores adaptativos calculan un error normalizado.

Una escala de componentes comunes es:

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

El error cuadrado medio ponderado normalizado es:

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

El paso se acepta normalmente cuando:

E ≤ 1

La tolerancia absoluta controla los componentes cerca de cero. La tolerancia relativa controla componentes cuyas magnitudes son grandes en comparación con atol.

Diferentes campos pueden requerir diferentes tolerancias absolutas. Una temperatura medida en cientos de Kelvin no debería usar necesariamente la misma tolerancia absoluta que una concentración cercana a 10⁻⁹.

Cómo se selecciona el siguiente paso

Si el error local estimado se comporta como:

error ∝ Δt^(p+1)

Un controlador básico puede usar:

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

El factor de seguridad es menor que uno. Reduce la posibilidad de que el siguiente paso se sitúe directamente en el límite de rechazo.

Las implementaciones de producción también limitan los cambios de tamaño de paso:

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

El exponente correcto depende del orden representado por el estimador de error y la convención del controlador. No debe copiarse a ciegas entre métodos no relacionados.

Controladores I, PI y PID

Un controlador integral simple utiliza solo el error normalizado actual. Esto puede hacer que el historial de pasos de tiempo alterna entre aumentos agresivos y rechazos.

Los controladores PI y PID también usan errores de pasos anteriores aceptados. Esto produce cambios de tamaño de paso más suaves y puede reducir las tasas de rechazo.

Un controlador de PI simplificado tiene el formulario:

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

Los coeficientes dependen del orden del método y el diseño del controlador. El control sofisticado es útil, pero no puede reparar un estimador de error inexacto o un integrador de tiempo inadecuado.

Pares de Runge-Kutta integrados

Un par incrustado de Runge-Kutta calcula dos aproximaciones a partir del mismo conjunto de etapas intermedias.

Las dos fórmulas tienen diferentes órdenes:

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

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

La diferencia proporciona una estimación de error:

e =
u(high)
-
u(low)

Debido a que ambas fórmulas comparten sus evaluaciones de etapa, el estimador es mucho más barato que completar dos integraciones independientes.

Los métodos incrustados explícitos de Runge-Kutta son los más adecuados para los sistemas no rígidos. Si la rigidez controla el tamaño del paso, aumentando o disminuyendo Δt

Príncipe 5(4)

Dormand-Prince 5(4) es un par incrustado de siete etapas. Produce una solución de quinto orden y una estimación de error de cuarto orden.

El par utiliza extrapolación local: la aproximación de quinto orden se convierte en la solución aceptada, mientras que la fórmula de orden inferior controla el paso.

También tiene una propiedad FSAL en uso ordinario. La última evaluación derivada de un paso aceptado puede convertirse en la primera evaluación del siguiente paso, reduciendo el número de nuevas evaluaciones de funciones después del inicio.

Dormand-Príncipe es utilizado por RK45 de Scipy y ode45 de Matlab. Es una fuerte elección de propósito general para problemas de valor inicial no rígidos y suaves.

tsit5

TSIT5 es el método de Runge-Kutta integrado Tsitouras 5(4). Es ampliamente utilizado en el ecosistema SCIML como método predeterminado para problemas no rígidos en tolerancias ordinarias.

El método está diseñado para proporcionar un equilibrio favorable entre la calidad de la estimación de errores, el costo de la etapa y la eficiencia práctica.

sigue siendo un método explícito. Si una PDE semidiscreta es rígida debido a la difusión, las reacciones o las escalas de tiempo fuertemente separadas, un método implícito, Rosenbrock, BDF o IMEX pueden ser más eficientes.

Bogacki-Shammine 3(2)

Bogacki-Shampin 3(2) es un par incrustado de cuatro etapas. Proporciona una solución aceptada de tercer orden con un estimador de error de segundo orden.

Se implementa como RK23 en scipy y subyace al ode23 de Matlab.

El par puede ser útil cuando la precisión moderada es suficiente o cuando las evaluaciones de funciones son económicas. Su orden inferior puede requerir pasos más aceptados que un método de quinto orden cuando se solicitan tolerancias estrictas.

paso a paso

La duplicación de pasos estima el error temporal al comparar el mismo método numérico en dos resoluciones.

El procedimiento calcula:

1. Un paso completo de longitud Δt.
2. Dos semi-seguros de longitud Δt/2.
3. La diferencia entre los dos resultados.

Para un método de orden p, una estimación del error en el resultado de dos pasos refinado es:

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

La solución aceptada normalmente debería ser el resultado de los dos semi-pasos porque es más precisa.

La duplicación de pasos requiere tres aplicaciones del método subyacente: un paso completo y dos medios pasos. Por lo tanto, una implementación implícita puede requerir tres soluciones no lineales o lineales a menos que se pueda reutilizar algún trabajo de configuración.

Estimación de residuos y defectos

Los métodos basados en residuos evalúan qué tan de cerca una trayectoria numérica reconstruida satisface la ecuación diferencial entre puntos aceptados.

Una reconstrucción continua ũ(t) tiene un defecto:

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

El defecto puede soportar una estimación de error cuando se combina con información de estabilidad o una norma apropiada.

El residuo algebraico de una solución implícita no es automáticamente una estimación de error temporal. El método de Newton puede reducir la ecuación discreta residual casi a cero incluso cuando el paso de tiempo es demasiado grande para representar la solución física con precisión.

Por lo tanto, la convergencia algebraica y el error de truncamiento temporal requieren controles separados.

Métodos BDF adaptativos

Las fórmulas de diferenciación hacia atrás son métodos implícitos de varios pasos que se utilizan para sistemas rígidos. Las implementaciones de orden variable comúnmente cambian entre los pedidos del uno al cinco.

Un solucionador de BDF almacena información de estados anteriores aceptados. Construye un predictor para el nuevo estado, resuelve la ecuación implícita y estima el error de truncamiento local usando diferencias divididas o una representación de historia similar a Nordsieck.

El solucionador puede cambiar:

• El tamaño de paso de tiempo
• El orden BDF
• La frecuencia de las actualizaciones jacobianas
• El solucionador lineal o la configuración del preacondicionador

Una solución suave puede justificar el aumento del orden. Un evento, fase de inicio, discontinuidad o prueba de error fallida puede obligar al solucionador a reducir su orden y tamaño de paso.

BDF2 es una fórmula de diferenciación hacia atrás. No es Crank-Nicolson, aunque ambos métodos son de segundo orden.

Control de errores en Comsol BDF

El controlador BDF de COMSOL evalúa una estimación de error local cuadrado medio ponderado de la raíz. Un paso pasa cuando el error normalizado está por debajo de uno.

El solucionador puede usar órdenes BDF de uno a cinco. Examina la suavidad de la solución, selecciona un orden, intenta un paso y repite el paso con un tamaño más pequeño cuando falla la prueba de error local.

Su registro de solucionador incluye:

• Order para el orden BDF actual
• Tfail para pruebas de error de paso de tiempo fallidas
• NLfail Para fallos de solucionador no lineal

Un recuento alto de Tfail sugiere que el controlador frecuentemente proponía pasos que eran demasiado grandes para la precisión solicitada. Un recuento alto de NLfail indica que la solución algebraica no lineal luchó.

Estas dos fallas no deben interpretarse como el mismo problema.

El mecanismo detallado se describe en Paso de tiempo automático y selección de pedidos en problemas dependientes del tiempo.

Error algebraico y error temporal

Un método implícito resuelve un sistema no lineal en cada paso de tiempo. Si Newton o el solucionador lineal termina demasiado pronto, el error algebraico puede volverse comparable al error temporal.

El controlador de paso de tiempo puede entonces reaccionar a un error que proviene de una convergencia algebraica incompleta en lugar de la discretización del tiempo.

Una configuración de solucionador creíble debería hacer que la tolerancia algebraica sea lo suficientemente estrecha que el objetivo temporal. Hacer que sea innecesariamente estricto también desperdicia el trabajo.

Algunos solucionadores coordinan la convergencia no lineal y la selección de pasos de tiempo. Un controlador no lineal puede reducir el paso cuando la estabilidad de Newton requiere un valor menor que el que propone el estimador de precisión BDF.

Límites CFL y pasos adaptativos

El control de error explícito no puede anular una restricción de estabilidad explícita.

Para la advección, un límite CFL típico es:

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

Para la difusión explícitamente integrada:

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

Las constantes dependen de la discretización espacial, la dimensión, la geometría de la malla y el integrador de tiempo.

El paso utilizable puede ser:

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

Un método adaptativo Runge-Kutta puede informar un error muy pequeño y aún así volverse inestable si se viola el límite de CFL.

¿Los métodos implícitos necesitan un límite CFL?

Una discretización implícita estable de un modelo lineal puede no tener el mismo límite de estabilidad de CFL explícito. Eso no significa que el paso de tiempo pueda ser arbitrariamente grande.

Grandes pasos implícitos pueden:

• Miss olas y transitorios rápidos
• introducir una amortiguación numérica excesiva
• perder la monotonicidad
• dificultar las iteraciones de Newton
• cruzar un evento sin resolverlo
• Reducir la precisión de los procesos no lineales acoplados

Estas restricciones deben denominarse exactitud, convergencia no lineal o límites de resolución física en lugar de una condición CFL universal.

Restricciones de paso de tiempo múltiples

Los códigos de simulación grandes a menudo calculan varios tamaños de paso candidatos. PISM, por ejemplo, considera las restricciones específicas del modelo relacionadas con la advección, la difusión, los intervalos de información y otros procesos físicos.

Es útil registrar la razón por la que limita cada paso aceptado. Un cálculo dominado por un controlador de error requiere una optimización diferente de una limitada por la velocidad más rápida o la celda de malla más fina.

El pism documento de paso de tiempo proporciona una práctica Ejemplo de control de múltiples restricciones.

Tiempos de salida y pasos internos

Los tiempos de salida solicitados no siempre necesitan convertirse en pasos de integración. Muchos solucionadores utilizan una salida densa o una interpolación para calcular los resultados almacenados entre los niveles de tiempo internos aceptados.

Forzar cada tiempo de salida para que se convierta en un paso de solucionador exacto puede reducir la eficiencia cuando se solicita una salida frecuente.

La alineación de pasos exacta puede seguir siendo apropiada cuando:

• una carga discontinua cambia en un momento conocido.
• una condición de contorno cambia abruptamente.
• Un evento cambia las ecuaciones gobernantes.
• Una acción de control debe ocurrir en un instante preciso.
• El método carece de una salida densa suficientemente precisa.

Después de una discontinuidad, es posible que el historial de varios pasos o el controlador adaptativo deban reiniciarse.

Paso de tiempo adaptativo en Fipy

Fipy resuelve ecuaciones de volumen finito espacialmente discretizadas pero no gira una llamada como:

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

en un controlador de error temporal incrustado. Las tolerancias del solucionador en Fipy controlan principalmente la solución lineal algebraica.

La documentación actual de Fipy recomienda el paquete externo steppyngstounes para la gestión de pasos adaptativa. Los ejemplos de Fipy utilizan errores de controlador derivados de residuos de ecuación, controles de conservación u otros criterios específicos de la aplicación.

Consulte la Documentación de pasos adaptativos de FIPY.

Un ejemplo de duplicación de pasos ficticios

El siguiente ejemplo educativo envuelve la discretización transitoria implícita de primer orden de Fipy en un controlador de duplicación de pasos.

Realiza un paso completo de Euler hacia atrás y dos medios pasos. El resultado de dos pasos se acepta cuando su error normalizado está por debajo de uno.

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)

Esta implementación es intencionalmente simple. Cada intervalo de intentos requiere tres soluciones implícitas, por lo que puede ser costoso. Un BDF de producción o método integrado normalmente proporciona un estimador más eficiente y un controlador PI o PID más suave.

Agregar una restricción CFL explícita

Para un término de advección explícitamente integrado, el paso seleccionado por error se puede limitar por separado:

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
)

Para mallas no uniformes, utilice la escala de celda local más restrictiva o una estimación basada en rostros apropiada para el método espacial.

Elegir tolerancias

No existe un par universal de tolerancias adecuadas para cada PDE.

Un proceso práctico es:

1. Elija tolerancias absolutas de acuerdo con la escala física de cada campo.
2. Seleccione una tolerancia relativa moderada.
3. Repita la simulación con tolerancias reducidas por un factor de diez.
4. Comparar las cantidades de interés científico.
5. Continúe apretando hasta que el resultado cambie menos que el error temporal aceptado.

Reducir rtol hace que el requisito sea más estricto y normalmente aumenta el costo computacional. El aumento de rtol afloja el requisito y normalmente reduce la precisión.

Una tolerancia absoluta que es demasiado pequeña puede forzar un trabajo excesivo cuando un componente pasa por cero. Uno que es demasiado grande puede ocultar cambios significativos en las pequeñas variables.

Rechazo de pasos

Un paso explícito rechazado desperdicia las evaluaciones de etapa. Un paso implícito rechazado puede desperdiciar iteraciones no lineales, cálculos jacobianos, factorizaciones y configuración de preacondicionador.

Un pequeño número de pasos rechazados es normal. Una alta tasa de rechazo puede indicar:

• un paso inicial que es demasiado grande
• un controlador demasiado agresivo
• una discontinuidad o evento
• Tolerancias mal escaladas
• Un estimador de error poco confiable
• Rigidez en un método explícito
• Convergencia no lineal incompleta
• un modelo incorrecto o mal condicionado

El ajuste del controlador no debe usarse para ocultar las fallas del modelo o del solucionador.

Cuando los pasos adaptativos pueden pasar por alto una dinámica importante

Un estimador de error mide la solución numérica generada por el método elegido. No sabe automáticamente qué características físicas importan.

Un solucionador puede tomar medidas que son demasiado grandes para:

• impulsos externos cortos
• Ondas de alta frecuencia
• Eventos de umbral
• Activación de contacto
• Cambios rápidos de fase
• Términos de origen discontinuos

Utilice restricciones de paso máximo, manejo de eventos o niveles de tiempo forzados cuando se deban resolver dichas funciones.

Cuando los pasos fijos son útiles

El paso de tiempo fijo sigue siendo apropiado cuando:

• Un método de conservación de estructura requiere un paso constante.
• Se necesitan trayectorias discretas idénticas para la depuración.
• La solución tiene una escala de tiempo casi uniforme.
• La simulación se sincroniza con los datos medidos.
• Una GPU o una implementación en paralelo funciona mejor con cargas de trabajo predecibles.
• El estudio de convergencia paso a tiempo requiere un refinamiento controlado.

Los solucionadores adaptativos aún pueden devolver resultados en tiempos de salida comunes a través de la interpolación. Por lo tanto, no se requiere un paso fijo para comparar ejecuciones en marcas de tiempo especificadas.

Pasos adaptativos y reproducibilidad

Pequeños cambios en las tolerancias, las versiones del solucionador, la aritmética de hardware o la convergencia no lineal pueden alterar la secuencia de pasos aceptada.

Un informe reproducible debe registrar:

• Integrador de tiempo y versión
• Tolerancias relativas y absolutas
• Pasos iniciales, mínimos y máximos
• Norma de error
• Tipo de controlador
• CFL o restricciones basadas en la física
• Horarios de eventos
• Recuentos de pasos aceptados y rechazados
• Tolerancias del solucionador no lineal y lineal

Errores comunes

• Uso de tolerancia residual algebraica como tolerancia de error temporal
• Asumiendo los cambios finos dt a rtol y atol argumentos
• Aceptar el resultado de paso completo menos preciso en la duplicación de pasos
• Olvidando el factor 2^p - 1 en la estimación de Richardson
• Uso de un exponente de controlador fijo para cada estimador
• Ignorar el límite CFL de un esquema explícito
• Llamar a toda limitación implícita una condición CFL
• Uso de dormand-príncipe para un problema de difusión fuertemente rígido
• Aflojamiento rtol Cuando se requiere mayor precisión
• Permitir que un paso cruzar una carga discontinua sin un evento
• confuso Tfail con falla del solucionador no lineal
• Comparación de solucionadores adaptativos solo por conteo de pasos aceptado

un flujo de trabajo práctico

1. Verifique primero la implementación de paso fijo.
2. Determine si el sistema semidiscreto es rígido.
3. Seleccione un estimador de error adecuado al método.
4. Escale cada componente de la solución con tolerancias justificadas.
5. Agregue las restricciones de paso máximo basadas en CFL y física.
6. manejar discontinuidades y eventos explícitamente.
7. Registre los pasos, rechazos y razones limitantes aceptadas.
8. Repita la simulación con tolerancias más estrictas.
9. Compare las cantidades físicas en lugar de solo los registros del solucionador.
10. Benchmark Total Runtime con el mismo error medido.

Guías relacionadas

• métodos de integración de tiempo para solucionadores de PDE: esquemas explícitos frente a implícitos — Compare las regiones de estabilidad, Amortiguación, rigidez y costo computacional.
• Métodos implícitos versus explícitos: estabilidad, precisión y cuándo usar cada — Separa la estabilidad numérica de la precisión temporal.
• Elegir el solucionador de PDE de Python correcto: Fipy vs PY-PDE frente a Fenics — Compare los marcos de Python y sus flujos de trabajo de integración de tiempo.
• Cómo maneja Fipy las mallas y las estructuras de cuadrícula: comprender cómo el tamaño de celda y la estructura de malla afectan los límites de estabilidad.

Lectura adicional

• COMSOL: Paso de tiempo automático y selección de pedidos en problemas dependientes del tiempo
• Documentación de PISM: Pasos de tiempo
• Söderlind y Wang: pasos de tiempo adaptativos y estabilidad computacional
• Documentación Scipy Solve_IVP
• Documentación SCIML TSIT5
• Documentación Fipy: pasos adaptativos
• SimScale: comprensión de la condición CFL

Conclusión

El paso de tiempo adaptativo mejora la eficiencia al hacer coincidir el esfuerzo computacional con la solución en evolución. Reduce el paso cerca de transitorios rápidos y lo aumenta cuando la solución se vuelve suave.

Error de estimación de pares de Runge-Kutta integrados desde etapas compartidas. La duplicación de pasos compara un paso completo con dos medios pasos. Los métodos BDF de orden variable utilizan el historial de soluciones, la predicción y las diferencias divididas para controlar el tamaño y el orden del paso.

El control de errores no reemplaza el análisis de estabilidad. Los métodos explícitos deben respetar las restricciones de CFL y de difusión. Los métodos implícitos aún necesitan pasos lo suficientemente pequeños como para resolver la física y permitir una convergencia no lineal confiable.

Fipy no proporciona la adaptación temporal automática a través de argumentos ordinarios rtol y atol a solve(). Los flujos de trabajo Fipy adaptativos requieren un controlador de pasos externo o una lógica de error personalizada.

Un cálculo adaptativo creíble documenta sus tolerancias, norma de error, controlador, pasos rechazados, restricciones de estabilidad, manejo de eventos y convergencia en configuraciones más estrictas. El objetivo no es minimizar el número de pasos. Es alcanzar la precisión física requerida con el menor costo computacional fiable.