[Paper Review] Analysis of a Time Multigrid Algorithm for DG-Discretizations in Time

Martin J. Gander, Martin Neumüller|arXiv (Cornell University)|Sep 18, 2014

Advanced Numerical Methods in Computational Mathematics21 references7 citations

TL;DR

This paper presents and analyzes a time multigrid algorithm for discontinuous Galerkin (DG) discretizations in time, using a block Jacobi smoother and standard restriction/prolongation in time. It derives asymptotically optimal smoothing parameters and proves a sharp two-grid contraction estimate, enabling efficient parallel-in-time solution of parabolic PDEs with excellent strong and weak scalability on large-scale systems.

ABSTRACT

We present and analyze for a scalar linear evolution model problem a time multigrid algorithm for DG-discretizations in time. We derive asymptotically optimized parameters for the smoother, and also an asymptotically sharp convergence estimate for the two grid cycle. Our results hold for any A-stable time stepping scheme and represent the core component for space-time multigrid methods for parabolic partial differential equations. Our time multigrid method has excellent strong and weak scaling properties for parallelization in time, which we show with numerical experiments.

Motivation & Objective

• To develop and analyze a robust multigrid method for time-discretized evolution problems using DG in time.
• To enable efficient parallelization in time by overcoming limitations of traditional space-only coarsening in multigrid methods.
• To provide a theoretical foundation for space-time multigrid methods by analyzing the time component independently.
• To establish asymptotically optimal smoothing parameters and convergence bounds for the two-grid cycle.
• To demonstrate strong and weak scalability of the method on large-scale supercomputers.

Proposed method

• Uses a discontinuous Galerkin (DG) time discretization of order $ p_t $, based on weak enforcement of continuity at time interfaces.
• Employs a block Jacobi smoother applied to the linear system arising from DG time discretization, with smoothing parameter optimized asymptotically.
• Applies standard restriction and prolongation operators in time, enabling full coarsening in the time dimension.
• Derives a Fourier mode analysis to determine the optimal smoothing parameter and contraction factor for the two-grid method.
• Uses a two-grid convergence analysis to establish an asymptotically sharp contraction estimate independent of time step size.
• Validates scalability via numerical experiments on the Monte Rosa and Vienna Scientific Cluster supercomputers.

Experimental results

Research questions

• RQ1 What is the optimal smoothing parameter for a block Jacobi smoother in a time multigrid method using DG discretization?
• RQ2 Can a time multigrid method achieve mesh-independent convergence for DG time discretizations?
• RQ3 How does the convergence behavior of the two-grid method depend on the time discretization order $ p_t $ and smoothing parameter?
• RQ4 What are the strong and weak scaling properties of the proposed time multigrid algorithm on large-scale parallel architectures?
• RQ5 Can the method be extended to full space-time multigrid for parabolic PDEs with efficient spatial solves?

Key findings

• The asymptotically optimal smoothing parameter for the block Jacobi smoother is derived, ensuring the best possible convergence rate for the two-grid method.
• A sharp two-grid contraction estimate is proven, showing convergence independent of time step size and valid for any A-stable time stepping scheme.
• The method exhibits excellent strong scaling: computation time halves approximately when the number of cores doubles, up to a limit dictated by local problem size.
• Weak scaling is also excellent: total solution time remains nearly constant as problem size and number of cores increase proportionally.
• For a large problem with 131,120,896 degrees of freedom, the method achieves a 1000x speedup over sequential forward substitution when run in parallel on 2048 cores.
• The method maintains robust performance across different polynomial orders $ p_t $, with computation times scaling favorably with increasing $ p_t $.