1. Introduction
Urban pluvial flooding occurs when short-duration, high-intensity rainfall generates runoff that cannot be conveyed rapidly enough through drainage networks, or infiltrate into the soil. These events are typically flash floods, owing to their rapid onset and strong spatial localization, especially within densely built environments. Their small temporal and spatial scales make pluvial floods significantly harder to forecast and map than riverine or coastal flooding, as highlighted by the UK Environment Agency [
1]. Although pluvial flooding may also affect rural areas, it is predominantly an urban phenomenon, where surface sealing, limited infiltration, and the concentration of exposed assets amplify its impacts.
Recent assessments indicate that nearly two million residents in urban areas of the United Kingdom face an annual 0.5% probability of experiencing pluvial flooding, equivalent to a 1-in-200-year event. This accounts for about 5% of the total urban population and represents nearly one-third of the flood risk from all sources. The projections for 2050 suggest that the number of people exposed could rise to 3.2 million, due to the combined effects of climate change (approximately +300,000 people) and population growth (+900,000). Because pluvial floods often occur with minimal warning in locations not traditionally considered flood-prone, they are sometimes referred to as an “invisible hazard” [
2].
In urban environments, pluvial flooding takes place when intense rainfall overwhelms the capacity of the sewer network, minor urban watercourses, or surface drainage features, causing water to pond on streets and potentially enter buildings [
3]. This definition encompasses three interconnected processes:
These mechanisms are intrinsically linked and must be analyzed together for reliable flood modeling and risk assessment.
During heavy rainfall, a thin layer of runoff develops before the surface flow becomes fully established. The initial water film is extremely shallow, fractions of a millimeter on impervious surfaces and a few millimeters on vegetated areas [
4]. The runoff then follows topographic pathways such as streets, alleys, and open channels, eventually reaching either an urban watercourse or a drainage inlet (e.g., gullies or manholes) that provides access to the piped network.
Urban pluvial flooding is therefore a complex, dynamic process governed by rainfall intensity, surface characteristics, and the hydraulic performance of urban drainage systems. Its growing relevance underscores the need for improved modeling approaches and integrated urban water management strategies capable of addressing the increasing pressures posed by climate change and urban expansion.
In the present study, a two-dimensional hydraulic model based on the Saint-Venant equations (shallow-water equations), solved through a first-order explicit finite-volume scheme, is proposed. The numerical method employs a Rusanov-type flux, ensuring numerical stability, mass conservation, and the robust handling of wetting and drying conditions. Dissipative effects are accounted for through a semi-implicit formulation of Manning friction. An application to a real-world urban flooding event yields maximum inundation depth maps and arrival times consistent with the flow patterns reported in the literature. The results confirm the model’s reliability for urban hydraulic hazard assessments.
2. Model Description
The simulation model solves the shallow-water equations (Saint-Venant equations) in two horizontal dimensions, 2D_SWE. These are a set of hyperbolic conservation laws representing the conservation of mass (continuity) and momentum in the x and y directions. In the conservative form, the state vector U = [h; hu; hv] comprises the water depth h and the two components of momentum hu and hv (with u and v being the depth-averaged velocities).
Its objective is to update, in a conservative and stable manner, water depth , and depth-integrated momenta and , while accounting for bed topography, rainfall and point inflows, wetting and drying, bottom friction, and open boundary conditions.
The implementation follows a finite-volume, Godunov-type approach, designed for robustness on complex topography and partially dry domains (
Figure 1). The governing equations can be written as follows:
where:
- -
is the bed elevation;
- -
is the source term represented by rainfall (mm/h), and point-source inflows;
- -
are friction terms;
- -
is the gravitational acceleration.
Figure 1.
Flowchart of the entire tool.
Figure 1.
Flowchart of the entire tool.
The computational domain is discretized into rectangular cells. Each cell stores cell-averaged values of , , and .
The update over a time step Δ
t follows the standard finite-volume form:
where:
and are numerical fluxes;
collects the source terms (rainfall, inflows, and friction).
Topography introduces source terms that can destroy the equilibrium if not handled carefully. To preserve the lake-at-rest condition (zero velocity, and constant free surface), the solver applies hydrostatic reconstruction at every cell interface.
At an interface, the following are carried out:
- -
The maximum bed elevation is identified:
- -
The reconstructed water depths are computed:
This ensures the exact balance between the pressure and bed slope, the non-negative reconstructed depths, and, finally, the correct treatment of partially dry interfaces. This approach follows the well-balanced strategy introduced by Audusse et al. [
5].
At each interface, fluxes are computed using a Rusanov (local Lax–Friedrichs) solver. For each interface, the following are carried out:
- -
Physical fluxes are computed from left and right reconstructed states;
- -
The maximum wave speed is estimated:
- -
The numerical flux is defined as follows:
This choice guarantees stability, handles shocks and hydraulic jumps robustly, and is particularly reliable in wet–dry transitions. Even if this approach is more diffusive than Roe solvers, Rusanov fluxes are widely used in flood modeling for their robustness; thus, this is an upwind scheme that has the lowest explicit level of upwinding [
6].
Accurately simulating wetting and drying processes—i.e., the movement of shorelines or boundaries between inundated and non-inundated areas—remains one of the most delicate aspects of solving the shallow-water equations. The model incorporates several numerical strategies to ensure a stable and physically consistent handling of wet/dry interfaces.
The first key component is the hydrostatic reconstruction, previously discussed, which guarantees that the reconstructed water depths remain non-negative. By enforcing this constraint, cells containing no water contribute zero flux, preventing non-physical exchanges between wet and dry regions.
In addition, the model introduces a small threshold depth, (typically ), to distinguish wet cells from dry ones. This threshold is used strictly for stability purposes. Cells with are treated as dry: their momentum components are explicitly set to zero, and they do not exchange fluxes with neighboring cells, except possibly as passive receivers of inflow.
This treatment is applied at two critical stages of the computation:
- 1.
Before flux evaluation, after the addition of rainfall or external sources. The algorithm loops through all cells and sets the following:
This prevents the development of spurious velocities that would otherwise arise from dividing by extremely small water depths.
- 2.
After the flux update, once the new water depth has been computed. If , the updated momentum values are again set to zero.
This ensures that a cell that becomes dry during the time step does not retain residual momentum that could produce non-physical “ghost” flows.
Such momentum clamping in nearly dry cells is widely adopted in shallow-water solvers to preserve numerical stability and physical realism in wetting–drying scenarios, and it is consistent with the approaches documented in the literature [
7].
The model also enforces a positivity constraint on water depth: any small negative value that may arise from the numerical round-off or truncation errors is reset to zero. This correction is essential when using explicit schemes, as finite-precision arithmetic can occasionally produce slightly negative depths even when fluxes are physically conservative.
Together, the hydrostatic reconstruction, the positivity preservation, and the momentum resetting mechanism form a robust and reliable drying algorithm. As water recedes and the depth approaches the threshold , the model naturally transitions the cell into a dry state, halting all outgoing fluxes. The cell remains dry until it is reactivated by precipitation or by incoming flux from neighboring wet cells. This yields a stable and physically coherent representation of wetting and drying dynamics on complex, evolving free-surface domains.
Physically, hmin is a tolerance (on the order of millimeters) below which water is not tracked—any such tiny depth is considered zero to avoid instability. The value is chosen small enough to not affect mass conservation significantly, but large enough to avoid division by extremely small depths (herein, 10−4 m is used by default). This threshold, along with the well-balanced flux, prevents the common issue of “ringing” or oscillations at the shoreline.
Rainfall is treated as a source term in the continuity equation:
This is applied uniformly over all cells, and no momentum is added (the rainfall is assumed to be vertically incident). Point inflows (e.g., sewer surcharges, and inflow hydrographs) are injected as volume:
Optionally, the inflow can be distributed over a 3 × 3 stencil to avoid local instabilities.
The time step Δ
t is computed dynamically using a CFL criterion:
This guarantees that no information propagates more than one cell per time step, maintaining the stability of the explicit scheme. All domain boundaries are treated as open (Neumann) boundaries with zero normal gradient and implemented by copying interior cell values to boundary cells. This allows waves and floodwater to exit the domain without artificial reflection.
Bottom friction is applied as a source term on momentum using Manning’s law:
The update is performed semi-implicitly:
This approach is stable even for shallow depths, and avoids severe time step reductions, while correctly damping velocities over rough terrain.
The entire code is then parallelized using Numba (
Figure 1), which allows Python code to approach the speed of low-level languages for array-heavy computations. The @njit (parallel = True) operator on the Python (2025) code hints that Numba can auto-parallelize the outer loops. Indeed, the code uses prange (parallel range) for loops over the grid, enabling the multi-core execution of those loops. For example, the loop over all cells for the rainfall addition is parallelized, as are the loops for flux calculations in x and y, and the update loops over cells. This means each iteration (each row’s computation, for instance) can run concurrently on separate CPU threads. In practice, the code sets the number of threads (in this case, 16) and then compiles the step function at runtime on the first call. Once compiled, each step is executed in parallel, making it feasible to simulate large grids (millions of cells) with a reasonable speed. The parallelization strategy is highly beneficial for simulating 2D floods, as the computation of fluxes and updates is by far the most expensive part of the model. By leveraging multiple cores, the model achieves a near-linear speedup with the number of threads (until memory bandwidth becomes the bottleneck). In summary, the use of Numba allows the Python implementation to run at speeds comparable to compiled code, enabling fine-resolution and large-domain shallow-water simulations without sacrificing the convenience of Python for setup and I/O. The numerical scheme itself (finite-volume Godunov with Rusanov flux) is inherently local and loops over cells, which makes it highly parallelizable—each cell’s update only depends on its neighbors’ values from the previous step. This locality fits perfectly with Numba’s parallel loop model. The result is a robust, explicit shallow-water solver that is both accurate in capturing the essential physics (as a result of the well-balanced and stable numerical method) and computationally efficient (as a result of the parallel JIT execution).