Reading Time: 5 minutes

Key Takeaways

  • Explicit methods calculate the next state directly from the current state. They are cheap per step but require small time steps for stability.
  • Implicit methods solve a coupled system that includes both current and future states. They are more expensive per step but can be stable for much larger time steps.
  • Stiff equations contain processes with widely different time scales. They often make explicit methods impractical.
  • The CFL condition sets the maximum stable time step for many explicit schemes. Violating it can cause numerical divergence.
  • Hybrid approaches such as operator splitting, IMEX methods, and Strang splitting combine explicit treatment for non-stiff terms with implicit treatment for stiff terms.

The Fundamental Difference

When you solve a time-dependent partial differential equation numerically, you replace the continuous time derivative with a discrete difference. The way you approximate that derivative leads to two major families of methods: explicit and implicit schemes.

Explicit methods compute the state at time tₙ₊₁ entirely from known values at tₙ or earlier time steps. The formula has the form:

uⁿ⁺¹ = F(uⁿ)

Every term on the right-hand side is already known. The new state is found through direct algebra.

Implicit methods evaluate part or all of the equation at the unknown future state tₙ₊₁. The formula has the form:

G(uⁿ, uⁿ⁺¹) = 0

Because the solution depends on itself, you must solve a coupled system of equations at every time step. This usually requires matrix assembly and linear or nonlinear solvers, such as Newton-Raphson methods or Krylov methods.

Explicit methods are like stepping forward based only on the current position. Implicit methods are like solving for the current and next position together because the future state influences the equation.

Explicit Methods: Forward Euler and Beyond

The simplest explicit method is Forward Euler:

uⁿ⁺¹ = uⁿ + Δt · f(uⁿ)

You evaluate the right-hand side at the current state, multiply by the time step, and add the result to the current state. The cost per step is low because each update is direct.

Other explicit methods include:

  • Explicit Runge-Kutta methods, including RK4.
  • Adams-Bashforth multistep methods.
  • Forward Time Central Space schemes for diffusion equations.

Explicit methods are useful for:

  • Hyperbolic PDEs such as wave propagation and some fluid dynamics problems.
  • Problems where the physical time step is already small.
  • Highly parallelizable workflows where each update is cheap.

The main limitation is stability. Explicit methods are conditionally stable, which means there is a strict upper bound on the time step. If you exceed that bound, the simulation can diverge.

Implicit Methods: Backward Euler and Crank-Nicolson

The simplest implicit method is Backward Euler, also called Implicit Euler:

uⁿ⁺¹ = uⁿ + Δt · f(uⁿ⁺¹)

The future state uⁿ⁺¹ appears on both sides of the equation. To compute it, you solve an algebraic equation or a system of equations after spatial discretization.

This requires more work per time step than an explicit method. The solver may need matrix assembly, linear solver calls, and convergence checks.

The Crank-Nicolson method is a second-order implicit scheme that averages the explicit and implicit evaluations:

uⁿ⁺¹ = uⁿ + (Δt / 2) · [f(uⁿ) + f(uⁿ⁺¹)]

Crank-Nicolson is popular because it is second-order accurate in time and stable for many linear problems. It is a compromise between the low cost of explicit schemes and the stability of implicit schemes.

Backward Differentiation Formulas are another important family of implicit multistep methods. BDF1 is equivalent to Backward Euler. BDF2 is second-order and is widely used for stiff systems in production solvers.

Implicit methods are useful for:

  • Parabolic PDEs such as diffusion and heat transfer.
  • Stiff systems with widely separated time scales.
  • Problems where larger time steps are needed for practical runtime.

The Stability Question: CFL Condition and Beyond

Stability is one of the most important concepts in time integration. It determines whether numerical errors grow or decay as the simulation advances.

The CFL Condition

The Courant-Friedrichs-Lewy condition is a necessary stability condition for many numerical schemes, especially for hyperbolic PDEs. It states that the numerical domain of dependence must contain the true physical domain of dependence.

In practical terms, the time step must be small enough that information does not move farther than the scheme can represent during one step.

For a simple advection equation with velocity v and spatial grid spacing Δx, the Courant number is:

Courant number = v · Δt / Δx

A typical stability requirement is:

v · Δt / Δx ≤ C_critical

Typical stability limits include:

  • Advection: C ≤ 1, with linear scaling in Δx.
  • Diffusion: Δt ≤ Δx² / (2α), with quadratic scaling in Δx.

For explicit diffusion with the Forward Time Central Space scheme, the Fourier number is:

F = α · Δt / Δx² ≤ 0.5

If you refine the spatial grid by a factor of 2, the maximum explicit time step must usually be divided by 4. This quadratic restriction makes explicit methods expensive for fine meshes in diffusion-dominated problems.

Unconditional Stability

Implicit methods can provide unconditional stability for many classes of problems. With Backward Euler, a large time step may not cause numerical divergence, although accuracy can still suffer.

This is why implicit methods are common for stiff diffusion problems. The question changes from “how large can the time step be before the solution diverges?” to “how large can the time step be while preserving the accuracy I need?”

Unconditional stability is not the same as unlimited accuracy. Truncation error still grows with Δt. You still need to choose the time step based on the physical time scale you want to resolve.

Stiff Equations and Why They Break Explicit Methods

A system is stiff when it contains processes that operate on very different time scales. For example, a chemical reaction may complete in milliseconds while diffusion evolves over minutes.

An explicit method must use time steps small enough to resolve the fastest process, even when you only care about the slow behavior. This can require millions of tiny steps for a problem where the relevant dynamics are much slower.

Stiffness often appears as numerical instability in explicit methods. Small numerical errors can grow quickly, even when the true physical solution is stable.

Implicit methods avoid this problem because their stability regions can absorb fast modes without resolving every fast transient. This is why Backward Euler, BDF, and Crank-Nicolson are common choices for stiff ODEs and PDEs.

Hybrid Approaches: Operator Splitting and IMEX

Real PDEs often contain both stiff and non-stiff terms. Consider a convection-diffusion-reaction equation:

∂u/∂t = −∇·(vu) + α∇²u + R(u)

Each term has a different numerical character:

  • The advection term is wave-like and often treated explicitly.
  • The diffusion term is stiff and often treated implicitly.
  • The reaction term may be stiff if it represents fast chemistry or rapid source behavior.

Using one method for every term can be wasteful. Fully explicit schemes may need tiny time steps. Fully implicit schemes may be unnecessarily expensive for non-stiff terms.

Operator Splitting

Operator splitting, also called fractional stepping, decomposes the PDE into sequential sub-steps:

Step 1: Solve ∂u/∂t = −∇·(vu)     explicitly
Step 2: Solve ∂u/∂t = α∇²u        implicitly
Step 3: Solve ∂u/∂t = R(u)        explicitly or implicitly

The full time step is built by chaining these smaller solves.

Strang splitting improves accuracy by using a symmetric sequence:

Step 1: Half step with advection, Δt / 2
Step 2: Full step with diffusion, Δt
Step 3: Half step with advection, Δt / 2

Ordinary splitting is usually first-order accurate in time. Strang splitting is second-order for suitable problems.

IMEX Methods

IMEX methods combine implicit and explicit treatment inside one integration scheme. Non-stiff terms are evaluated explicitly, while stiff terms are evaluated implicitly:

uⁿ⁺¹ = uⁿ + Δt · [L_explicit(uⁿ) + L_implicit(uⁿ⁺¹)]

IMEX Runge-Kutta and IMEX multistep methods are widely used for PDE systems with mixed stiffness.

IMEX methods are useful for convection-diffusion equations, Navier-Stokes formulations, and reaction-diffusion systems where different terms require different stability treatment.

Python Examples: Putting Theory Into Practice

The examples below show the practical difference between explicit and implicit time stepping for diffusion.

Explicit Time Stepping with NumPy

A true explicit Forward Euler update can be written directly with NumPy. This version must respect the diffusion CFL condition.

import numpy as np
import matplotlib.pyplot as plt

# Mesh
nx = 100
L = 1.0
dx = L / nx
x = np.linspace(0, L, nx + 1)

# Initial condition
phi = np.zeros(nx + 1)
phi[x < 0.5] = 1.0

# Diffusion coefficient
D = 1.0

# Explicit stability limit:
# dt <= dx**2 / (2 * D)
dt = 0.4 * dx**2 / D
steps = 500

for step in range(steps):
    phi_new = phi.copy()
    phi_new[1:-1] = (
        phi[1:-1]
        + D * dt / dx**2 * (phi[2:] - 2 * phi[1:-1] + phi[:-2])
    )
    
    # Fixed boundary values
    phi_new[0] = 0.0
    phi_new[-1] = 0.0
    
    phi = phi_new

plt.plot(x, phi)
plt.xlabel("x")
plt.ylabel("phi")
plt.show()

This scheme is simple and cheap per step. But the time step must be very small. If the mesh is refined, the time step must shrink quadratically.

Implicit Time Stepping with FiPy

FiPy’s TransientTerm() == DiffusionTerm() formulation is implicit by default. It assembles and solves a matrix system at each step, which allows larger stable time steps for diffusion problems.

from fipy import Grid1D, CellVariable, TransientTerm, DiffusionTerm

nx = 100
dx = 1.0 / nx
mesh = Grid1D(nx=nx, dx=dx)

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

x = mesh.cellCenters[0]
phi.setValue(1.0, where=x < 0.5)

D = 1.0
eq = TransientTerm(var=phi) == DiffusionTerm(coeff=D, var=phi)

# Larger time step than the explicit diffusion limit
dt = 1e-3
steps = 500

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

The implicit version costs more per step, but it can take larger steps without numerical divergence. For diffusion-dominated problems, this often reduces total runtime.

Crank-Nicolson-Style Thinking

Crank-Nicolson averages current and future evaluations. In libraries that support a theta parameter, theta = 0.5 corresponds to Crank-Nicolson behavior.

# Conceptual pattern:
# theta = 0.5 gives Crank-Nicolson in theta-method frameworks.
# theta = 1.0 gives Backward Euler.
# theta = 0.0 gives Forward Euler.

Exact syntax depends on the solver framework. Always check the documentation for how the chosen library implements theta methods or time discretization.

A Practical Runtime Comparison

You can compare explicit and implicit approaches by measuring wall-clock time for the same final physical time.

import time

# Example structure only:
# Run explicit solver with small dt
t_start = time.time()

# explicit_loop(dt_small, many_steps)

print(f"Explicit runtime: {time.time() - t_start:.2f}s")

# Run implicit solver with larger dt
t_start = time.time()

# implicit_loop(dt_large, fewer_steps)

print(f"Implicit runtime: {time.time() - t_start:.2f}s")

The better method depends on the problem. Explicit schemes may win when each step is very cheap and physical time steps are naturally small. Implicit schemes often win for stiff diffusion or reaction-diffusion problems where explicit stability limits are severe.

Decision Guide: When to Use Which Method

Situation Recommended Approach Why
Wave propagation, shock dynamics, high-speed flows Explicit Cheap per step, and physical time steps are already small
Diffusion-dominated problems such as heat transfer or mass transport Implicit Avoids restrictive explicit diffusion CFL limits
Stiff reaction-diffusion coupling IMEX or operator splitting Handles fast reactions implicitly and cheaper terms explicitly
Steady-state or quasi-static problems Implicit Large pseudo-time steps can help approach steady state
High-resolution spatial grid Implicit Explicit diffusion CFL scales with Δx²
Time-accurate transient waves Explicit with CFL control Time accuracy requires resolving physical wave propagation
Chemical kinetics coupled to slow physics Implicit or BDF Stiff ODE behavior can make explicit methods impractical
Multi-scale problems where slow dynamics are the target Implicit or IMEX Fast transients can be stabilized while slow behavior is resolved

There is no universally superior choice. The right method depends on the physics, mesh resolution, stiffness, and what you need to measure.

Common Mistakes

  1. Using explicit methods for stiff diffusion on fine meshes. The CFL condition forces Δt ∝ Δx², so refining the mesh by 4 times can require 16 times more steps.
  2. Taking huge implicit time steps and assuming the result is accurate. Stability does not guarantee accuracy. Choose Δt based on the time scale you need to resolve.
  3. Neglecting CFL checks. Explicit simulations should always verify that the time step satisfies stability limits.
  4. Treating operator splitting as free accuracy. Splitting introduces fractional-step errors. Ordinary splitting is usually first-order, and Strang splitting is usually second-order.
  5. Assuming implicit means better. Implicit solvers cost more per step and can introduce numerical damping, especially with first-order Backward Euler.

Related Guides

Summary

Time integration is where theory meets practice in computational science. The explicit versus implicit choice is one of the most important decisions in a PDE solver.

  • Explicit methods are simple, cheap per step, and ideal for wave-like physics, but they require strict CFL compliance.
  • Implicit methods solve coupled systems at each step, but they can take larger stable steps for stiff diffusion problems.
  • Stiff equations often make explicit methods impractical. Implicit methods such as BDF and Crank-Nicolson handle them more efficiently.
  • Hybrid approaches such as operator splitting and IMEX combine explicit efficiency with implicit stability.

Start by identifying the physics in the equation. If the problem is advection-dominated, explicit methods may fit. If it is diffusion-dominated, implicit methods often fit better. If it combines stiff and non-stiff terms, use IMEX or splitting.

The right time integration choice can make a simulation faster, more stable, and more credible.

Want Help Optimizing Your PDE Solver's Time Integration?

Choosing the right time integration method can make the difference between a simulation that runs quickly and one that takes days. If you are struggling with time-step selection, implicit conversion, IMEX design, or CFL-related instability, our team can help.

We specialize in efficient, stable time-stepping workflows for scientific Python codes. Reach out to discuss your project’s needs.

References