PyClaw: Accessible, Extensible, Scalable Tools for Wave Propagation Problems

Development of scientific software involves tradeoffs between ease of use, generality, and performance. We describe the design of a general hyperbolic PDE solver that can be operated with the convenience of MATLAB yet achieves efficiency near that of hand-coded Fortran and scales to the largest supercomputers. This is achieved by using Python for most of the code while employing automatically-wrapped Fortran kernels for computationally intensive routines, and using Python bindings to interface with a parallel computing library and other numerical packages. The software described here is PyClaw, a Python-based structured grid solver for general systems of hyperbolic PDEs \cite{pyclaw}. PyClaw provides a powerful and intuitive interface to the algorithms of the existing Fortran codes Clawpack and SharpClaw, simplifying code development and use while providing massive parallelism and scalable solvers via the PETSc library. The package is further augmented by use of PyWENO for generation of efficient high-order weighted essentially non-oscillatory reconstruction code. The simplicity, capability, and performance of this approach are demonstrated through application to example problems in shallow water flow, compressible flow and elasticity.

💡 Research Summary

The paper presents PyClaw, a Python‑based framework that brings together the ease‑of‑use of high‑level languages, the performance of legacy Fortran solvers, and the scalability of modern parallel libraries to solve hyper‑bolic wave‑propagation problems. Starting from the well‑established Clawpack and its high‑order extension SharpClaw, the authors wrap the core Fortran routines with automatically generated Python bindings (using tools such as f2py) and expose them through a clean, object‑oriented API built on NumPy arrays. This design lets scientists write short, MATLAB‑like scripts to define domains, initial and boundary conditions, select Riemann solvers, and drive time integration, while the heavy numerical work is still performed by highly optimized compiled code.

Scalability is achieved by interfacing PyClaw with PETSc via the petsc4py bindings. Each process owns a PETSc DMDA (distributed array) that stores the local portion of the solution grid; PETSc handles halo exchanges, load balancing, and I/O. Because the underlying Fortran kernels remain unchanged, the parallel implementation inherits the near‑optimal per‑core performance of the original codes while scaling to thousands of MPI ranks on modern supercomputers. The authors demonstrate near‑linear speed‑up on large 3‑D elasticity and compressible‑flow benchmarks, confirming that the overhead of the Python layer is negligible compared with the computational cost of the Riemann solves and flux evaluations.

To raise the order of accuracy, PyClaw integrates PyWENO, a symbolic code generator that produces high‑performance C/Fortran routines for weighted essentially non‑oscillatory (WENO) reconstruction. Users can specify reconstruction stencils in Python, and PyWENO automatically generates and compiles the corresponding kernels, enabling SharpClaw’s fifth‑order spatial discretization together with a fourth‑order SSP‑Runge‑Kutta time integrator. The resulting schemes retain the non‑oscillatory properties of classic shock‑capturing methods while delivering substantially reduced numerical diffusion.

The paper also discusses software‑engineering practices that make PyClaw a sustainable scientific code base. Continuous integration tests run across Linux, macOS, and Windows; Docker images and conda packages provide reproducible environments; documentation is generated with Sphinx and hosted on ReadTheDocs. These practices ensure that both novice users (who can run example scripts interactively) and advanced developers (who may write custom Fortran Riemann solvers or extend the parallel infrastructure) can work efficiently.

Three application examples illustrate the framework’s versatility: (1) shallow‑water equations on a mapped grid with wet‑dry handling, (2) a 3‑D nozzle flow problem solved on several thousand cores with terabyte‑scale output, and (3) seismic wave propagation in a heterogeneous elastic medium using high‑order WENO reconstruction. In each case, PyClaw reproduces the results of the original Fortran codes, but with dramatically reduced development time and the ability to run on large parallel machines without code modification.

In summary, PyClaw demonstrates that a carefully layered architecture—Python front‑end, Fortran kernels, PETSc parallel back‑end, and optional high‑order WENO generation—can deliver both the productivity required for rapid scientific exploration and the performance needed for production‑scale simulations. The work sets a template for future scientific software that seeks to combine high‑level usability with exascale readiness.