Numerical Methods for a 2D "Bad" Boussinesq Equation: RK4, Strang Splitting, and High-frequency Fourier Modes

This paper presents stable and accurate numerical methods for the 2D "bad" Boussinesq equation using pseudo-spectral Fourier techniques with high-frequency mode filtering, demonstrating that excluding modes violating a specific stability condition prevents solution blow-up while comparing the performance of RK4 and Strang splitting schemes.

The Gist

Imagine you are trying to predict how a giant, invisible wave moves across a vast, flat ocean. This isn't just any wave; it's a tricky one described by a famous math equation called the "Bad" Boussinesq equation. It's called "bad" not because it's evil, but because it's mathematically unstable. If you try to calculate it using standard methods, the numbers can go haywire, growing infinitely large in a split second—like a snowball rolling down a hill that suddenly turns into an avalanche.

This paper is about building a special, sturdy boat to navigate these treacherous mathematical waters without capsizing.

The Problem: The "Bad" Equation

Think of the equation as a recipe for wave movement. The "Bad" version has a specific ingredient (a term involving the fourth derivative of the wave) that acts like a wild, unpredictable engine. In the real world, this models certain types of water waves. But in a computer simulation, if you let this engine run free, it causes the solution to "blow up"—the numbers explode, and the simulation crashes.

The author, Arief Anbiya, wanted to see if we could simulate this in two dimensions (like a real ocean surface, not just a line) without the computer crashing.

The Solution: The "Pruning" Trick

To solve this, the author used a clever technique called pseudo-spectral Fourier methods. Imagine the wave is a complex song made up of many different musical notes (frequencies).

• Low notes are the deep, smooth parts of the wave.
• High notes are the tiny, jagged ripples.

The author discovered that the "Bad" equation gets unstable specifically because of the highest, sharpest notes. If you include them, the song turns into noise and the simulation explodes.

So, the solution was to act like a strict music editor. Before the computer starts playing the song, the author created a rule (a "trimming condition") to cut out any notes that were too high-pitched and dangerous.

• The Rule: Only keep the notes that satisfy a specific mathematical safety check.
• The Result: By removing these "bad" high-frequency notes, the simulation stays stable. It's like removing the rotten apples from a basket so the whole basket doesn't spoil.

The paper shows that if you even accidentally leave in just a tiny bit of these dangerous high notes, the simulation crashes quickly (around time $t=23.5$). But if you strictly follow the pruning rule, the simulation runs smoothly for a long time (up to $t=100$).

Two Ways to Drive the Boat

Once the dangerous notes were cut out, the author tested two different ways to drive the simulation forward in time:

1. RK4 (Runge-Kutta 4th Order): Think of this as a very careful, step-by-step driver who checks the road constantly. It's a classic, reliable method for solving math problems.
2. Strang Splitting: Imagine this as a driver who takes a shortcut. They separate the "easy" part of the wave (the linear part) from the "hard" part (the non-linear part), solve them separately, and then stitch them back together.

The Comparison:

• When the time steps were small (taking tiny, careful steps), both drivers performed almost identically well.
• However, as the time steps got bigger (taking larger, riskier jumps), the "shortcut" driver (Strang Splitting) started to lose accuracy more noticeably than the careful driver (RK4).

What They Found

• Stability is Key: The most important discovery is that the "Bad" equation is so sensitive that you must follow the linear safety rule (cutting the high notes) even when solving the full, complex non-linear problem. It turns out the linear part of the equation is the main culprit for the explosions, not the non-linear part.
• Accuracy: The simulations were tested against a known "perfect" wave (a soliton). The computer's version of the wave stayed very close to the perfect one, with errors less than 3% over a long period.
• Reflections: The author also showed how to make the wave bounce off walls (using Dirichlet boundary conditions), simulating a wave hitting a sea wall and reflecting back.

The Bottom Line

This paper doesn't claim to fix the ocean or predict tsunamis for real-world use. Instead, it's a technical guide on how to build a stable computer model for a notoriously difficult math equation. The main takeaway is: If you want to simulate this "Bad" wave, you have to be a ruthless editor and cut out the high-frequency noise, or the whole thing will blow up. By doing so, you can get accurate, stable results using standard numerical tools.

Technical Summary

Technical Summary: Numerical Methods for a 2D "Bad" Boussinesq Equation

Problem Statement
The paper addresses the numerical simulation of the two-dimensional "bad" Boussinesq equation:
$$u_{tt} = u_{xx} + u_{xxxx} + u_{yy} - 3(u^2)_{xx}$$
This equation models dispersive long water waves but is characterized as "bad" because its linearized version is ill-posed in the Hadamard sense for bounded domains. Specifically, the linearized equation admits high-frequency Fourier modes that grow exponentially in time, leading to potential solution blow-up. While the "good" Boussinesq equation (with a negative $u_{xxxx}$ term) is well-posed, the "bad" version is required for modeling specific physical wave phenomena. The challenge lies in developing a stable numerical scheme that prevents this exponential growth while maintaining accuracy for the nonlinear system.

Methodology
The authors propose a pseudo-spectral Fourier method that incorporates a specific "trimming" condition to exclude unstable high-frequency modes. The methodology proceeds as follows:

1. Linear Stability Analysis: The authors first analyze the linearized equation ($u_{tt} = u_{xx} + u_{xxxx} + u_{yy}$) using Fourier series on a rectangular domain $( -L_x, L_x ) \times ( -L_y, L_y )$. They derive a condition for the Fourier coefficients $(j, k)$ to ensure the eigenvalue $\lambda_{j,k} \leq 0$, thereby preventing exponential growth.

   • For a square domain, the condition is $L^2k^2 + L^2j^2 - \pi^2j^4 \geq 0$.
   • For a rectangular domain, the generalized condition is $L_x^4 k^2 + L_y^2 (L_x^2 j^2 - \pi^2 j^4) \geq 0$.
   • This analysis reveals that while there is no upper bound on the frequency $|k|$ in the $y$-direction, there is a lower bound on $|k|$ that depends on $|j|$, and an upper bound on $|j|$ that depends on $|k|$.

2. Numerical Implementation: The nonlinear equation is rewritten as a first-order system in time. The authors implement two distinct time-stepping schemes paired with the pseudo-spectral method and the derived trimming condition:

   • Scheme 1 (RK4): Uses the fourth-order Runge-Kutta method to solve the resulting system of ordinary differential equations (ODEs) in frequency space.
   • Scheme 2 (Strang Splitting): Separates the linear and nonlinear parts of the equation. The linear part is solved exactly in frequency space using the analytical solution derived from the linearized analysis, while the nonlinear part is handled via Fourier transforms.

3. Boundary Conditions: The primary simulations utilize periodic boundary conditions (inherent to the Fourier method). Additionally, the authors demonstrate a method to implement Dirichlet boundary conditions to simulate wave reflections by applying a masking matrix to the solution in physical space before transforming back to frequency space.

Key Contributions

• Extension to 2D: The paper extends the 1D "trimming" approach (previously established in [11]) to the two-dimensional "bad" Boussinesq equation. The authors derive a new, nuanced trimming condition (Equation 3.2) specific to the 2D rectangular domain, which differs from the 1D case.
• Comparison of Solvers: The work compares the performance of RK4 and Strang splitting for this specific problem. It establishes that the nonlinear equation's stability relies on the linear stability condition derived from the linearized version.
• Stability Verification: The paper demonstrates that strictly adhering to the derived linear trimming condition is critical. Violating the condition, even slightly, leads to numerical blow-up, whereas adherence allows for stable simulations over long time intervals ($t=100$).

Results

• Accuracy: Both methods were tested against an exact soliton solution. For small time steps ($\Delta t = 0.1$), the $L_\infty$ errors for RK4 and Strang splitting were nearly indistinguishable and remained below 3% of the initial peak amplitude up to $t=40$.
• Time Step Sensitivity: As the time step $\Delta t$ increased, the performance of the Strang splitting method degraded more noticeably compared to RK4.
• Stability vs. Blow-up: A critical experiment showed that including even a few Fourier modes that violated the stability condition resulted in a blow-up solution as early as $t=23.5$. Conversely, simulations strictly adhering to the condition remained stable up to $t=100$. This suggests that the linear term $u_{xxxx}$ is the primary driver of the blow-up behavior, rather than the nonlinear term.
• Wave Reflections: The Dirichlet boundary condition implementation successfully simulated wave reflections off domain walls, showing the soliton reflecting off the north and south boundaries.

Significance and Claims
The paper claims that the proposed numerical scheme provides a stable and accurate approximation for the 2D "bad" Boussinesq equation, a problem often considered difficult due to its ill-posed linear nature. The authors emphasize that the "trimming" of high-frequency modes, derived from a linear analysis, is essential for the stability of the nonlinear simulation. They conclude that the linear term contributes more significantly to the blow-up behavior than the nonlinear term, justifying the use of a linear-derived condition to control the nonlinear system. The work serves as a practical extension of 1D spectral methods to 2D, offering a robust framework for simulating dispersive long waves with reflections.