Chapter 5 Coastal Engineering: Wave Runup Estimation

Chapter 5 Coastal Engineering: Wave Runup Estimation#

  1. Introduction: Wave Runup

  2. Simulation: Multimodel Wave Runup

  3. Self-Assessment

1. Introduction#

🌊 Wave Runup Estimation Tool#

Wave runup is the uprush of water from wave action on a beach or coastal structure. Accurately predicting runup is crucial for:

  • 🌊 Coastal flood risk assessment

  • 🏖️ Beach erosion modeling

  • 🏗️ Design of coastal infrastructure

Several emprical models (derived from experimental studies and field observation) are used for estimating wave runup. These models estimates the vertical extent of runup (R) based on:

  • Deep-water wave height \(( H \)) (m)

  • Deep-water wavelength \(( L \)) (m)

  • Beach slope \(( \beta \)) (dimensionless)

📐 General Empirical Runup Formula#

\[ R = C \times \left[ a \times \beta \times \sqrt{H \times L} + \sqrt{ \frac{(H \times L) \times (b \times \beta^2 + c)}{2} } \right] \]

Where:

  • \(( H \times L \)): Incident wave energy at the shoreline

  • \(( a, b, c, C \)): Empirically derived coefficients

  • \(( R \)): Estimated 2% exceedance runup height

References#

[Federal Emergency Management Agency, 2021] recommends empirical and numerical models based on site geometry, wave conditions, and erosion profiles. Adjustments for slope, roughness, and storm effects refine runup estimates for hazard zone delineation.[U.S. Army Coastal Engineering Research Center, 1984] also provides empirical formulas based on wave height, period, slope, and surface roughness. Runup estimates guide design elevations, overtopping limits, and coastal flood protection.

2. Simulation#

🌊 Multi-Model Wave Runup Simulator — Beach Slope Sensitivity Analysis#

This Jupyter-based tool compares wave runup estimates from 9 published models based on input wave height, wavelength, and beach slope. It enables interactive exploration of how runup magnitude varies with coastal conditions.

🧠 What It Does#

  • Implements models from Stockdon, Power, Holman, Nielsen, Ruggiero, Vousdoukas, Senechal, Beuzen, and Passarella

  • Calculates runup using empirical formulas involving √(H×L) and slope (β)

  • Provides side-by-side output for model comparison

  • Includes interactive sliders to explore wave height, wavelength, and slope sensitivity

  • Prompts users to reflect on how increasing β affects runup

🎛️ User Inputs#

Parameter

Description

Wave Height (H)

Height of incoming waves (m)

Wavelength (L)

Distance between wave crests (m)

Beach Slope (β)

Shoreline slope (unitless)

📊 Outputs#

  • Runup estimates (in meters) from each model

  • Bar chart showing model-to-model variation

  • Reflective prompt to help users understand physical influence of beach slope

🧭 How to Interpret#

  • All models predict increased runup with steeper beach slopes and higher wave energy

  • Differences between models reflect varying datasets, calibration regions, and empirical assumptions

  • Use this tool for:

    • Design benchmarking

    • Field study sensitivity tests

    • Teaching coastal processes and model uncertainty

A steep β amplifies wave runup—highlighting its importance in flooding, erosion, and coastal resilience assessments.

#pip install jupyterquiz
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import interact, FloatSlider
#pip install jupyterlab-mathjax3

# Display theoretical overview in output


# Define the wave parameters
H = 2.0# Wave height in meters
L = 100.0# Wavelength in meters
T = 10.0# Wave period in seconds
beta = 0.1# Beach slope

# Stockdon2006 model
def stockdon2006(H, L, beta):
    R = 1.1 * (0.35 * beta * np.sqrt(H * L) + np.sqrt((H * L * (0.563 * beta**2 + 0.004)) / 2))
    return R

# Power2018 model
def power2018(H, L, beta):
    R = 0.83 * (0.27 * beta * np.sqrt(H * L) + np.sqrt((H * L * (0.52 * beta**2 + 0.005)) / 2))
    return R

# Holman1986 model
def holman1986(H, L, beta):
    R = 0.75 * (0.5 * beta * np.sqrt(H * L) + np.sqrt((H * L * (0.65 * beta**2 + 0.003)) / 2))
    return R

# Nielsen2009 model
def nielsen2009(H, L, beta):
    R = 1.2 * (0.3 * beta * np.sqrt(H * L) + np.sqrt((H * L * (0.55 * beta**2 + 0.006)) / 2))
    return R

# Ruggiero2001 model
def ruggiero2001(H, L, beta):
    R = 1.05 * (0.25 * beta * np.sqrt(H * L) + np.sqrt((H * L * (0.57 * beta**2 + 0.005)) / 2))
    return R

# Vousdoukas2012 model
def vousdoukas2012(H, L, beta):
    R = 1.15 * (0.32 * beta * np.sqrt(H * L) + np.sqrt((H * L * (0.53 * beta**2 + 0.004)) / 2))
    return R

# Senechal2011 model
def senechal2011(H, L, beta):
    R = 1.08 * (0.28 * beta * np.sqrt(H * L) + np.sqrt((H * L * (0.56 * beta**2 + 0.005)) / 2))
    return R

# Beuzen2019 model
def beuzen2019(H, L, beta):
    R = 1.25 * (0.33 * beta * np.sqrt(H * L) + np.sqrt((H * L * (0.54 * beta**2 + 0.004)) / 2))
    return R

# Passarella2018 model
def passarella2018(H, L, beta):
    R = 1.05 * (0.29 * beta * np.sqrt(H * L) + np.sqrt((H * L * (0.55 * beta**2 + 0.005)) / 2))
    return R

# Calculate runup using different models
runup_stockdon2006 = stockdon2006(H, L, beta)
runup_power2018 = power2018(H, L, beta)
runup_holman1986 = holman1986(H, L, beta)
runup_nielsen2009 = nielsen2009(H, L, beta)
runup_ruggiero2001 = ruggiero2001(H, L, beta)
runup_vousdoukas2012 = vousdoukas2012(H, L, beta)
runup_senechal2011 = senechal2011(H, L, beta)
runup_beuzen2019 = beuzen2019(H, L, beta)
runup_passarella2018 = passarella2018(H, L, beta)

# Print the results
print(f"Stockdon2006 Runup=   {runup_stockdon2006:.2f} meters")
print(f"Power2018 Runup   =   {runup_power2018:.2f} meters")
print(f"Holman1986 Runup  =   {runup_holman1986:.2f} meters")
print(f"Nielsen2009 Runup =   {runup_nielsen2009:.2f} meters")
print(f"Ruggiero2001 Runup=   {runup_ruggiero2001:.2f} meters")
print(f"Vousdoukas2012 Runup= {runup_vousdoukas2012:.2f} meters")
print(f"Senechal2011 Runup  = {runup_senechal2011:.2f} meters")
print(f"Beuzen2019 Runup    = {runup_beuzen2019:.2f} meters")
print(f"Passarella2018 Runup= {runup_passarella2018:.2f} meters")

# Plot the results
#models = ['Stockdon2006', 'Power2018', 'Holman1986', 'Nielsen2009', 'Ruggiero2001', 'Vousdoukas2012', 'Senechal2011', 'Beuzen2019', 'Passarella2018']
#runups = [runup_stockdon2006, runup_power2018, runup_holman1986, runup_nielsen2009, runup_ruggiero2001, runup_vousdoukas2012,runup_senechal2011, runup_beuzen2019, runup_passarella2018]


# Interactive plotting function
def plot_runup(H, L, beta):
    models = {
        'Stockdon2006': stockdon2006,'Power2018': power2018,'Holman1986': holman1986,
        'Nielsen2009': nielsen2009,'Ruggiero2001': ruggiero2001,'Vousdoukas2012': vousdoukas2012,
        'Senechal2011': senechal2011,'Beuzen2019': beuzen2019,'Passarella2018': passarella2018}
    runups = [model(H, L, beta) for model in models.values()]
    plt.figure(figsize=(10, 5))
    plt.bar(models.keys(), runups)
    plt.xlabel('Models')
    plt.ylabel('Runup (meters)')
    plt.title('Wave Runup Calculations Using Different Models')
    plt.xticks(rotation=45)
    plt.ylim(0, max(runups) * 1.2)
    plt.grid(axis='y')
    plt.show()
# Create sliders and interactive widget
interact(plot_runup,
         H=FloatSlider(value=2.0, min=0.1, max=10.0, step=0.1, description='Wave Height (H)'),
         L=FloatSlider(value=100.0, min=10.0, max=500.0, step=10.0, description='Wavelength (L)'),
         beta=FloatSlider(value=0.1, min=0.01, max=0.5, step=0.01, description='Beach Slope (β)'))

from ipywidgets import interact, FloatSlider

def explore_runup(H, L, beta):
    R = 1.1 * (0.35 * beta * (H * L)**0.5 + ((H * L * (0.563 * beta**2 + 0.004)) / 2)**0.5)
    print(f"Estimated runup: {R:.2f} m")
    print("🧠 What happens when you increase β? Why?")

interact(explore_runup,
         H=FloatSlider(min=0.5, max=5.0, step=0.1, value=2.0, description="Wave Height (H)"),
         L=FloatSlider(min=50, max=300, step=10, value=100, description="Wavelength (L)"),
         beta=FloatSlider(min=0.01, max=0.5, step=0.01, value=0.1, description="Beach Slope (β)"))

Stockdon2006 Runup=   1.62 meters
Power2018 Runup   =   1.16 meters
Holman1986 Runup  =   1.26 meters
Nielsen2009 Runup =   1.80 meters
Ruggiero2001 Runup=   1.46 meters
Vousdoukas2012 Runup= 1.63 meters
Senechal2011 Runup  = 1.54 meters
Beuzen2019 Runup    = 1.80 meters
Passarella2018 Runup= 1.51 meters

<function __main__.explore_runup(H, L, beta)>

3. Self-Assessment#

Conceptual Understanding Wave Runup Estimation#

  1. Define wave runup.
    Why is predicting runup height important in coastal engineering?

  2. Key Parameters
    What are the three main parameters used in most empirical runup models?

  3. Formula Interpretation
    In the general empirical formula
    [ R = C \left( a \beta \sqrt{HL} + \sqrt{ \frac{HL (b \beta^2 + c)}{2} } \right) ] what do the two terms inside the brackets represent physically?

  4. Energy Representation
    Why is the product ( H \times L ) used in estimating runup energy?

  5. Coefficient Meaning
    What does the coefficient ( C ) generally reflect in each model?

  6. Model-Specific Reasoning Which model has the highest scaling factor for wave runup prediction in the code provided, and what might that imply?

  7. Model-Specific Reasoning Why might two models return different runup predictions for the same wave and beach conditions?

  8. Model-Specific Reasoning How does beach slope influence the runup height in most models

Model-Specific Reasoning

  • Which model has the highest scaling factor for wave runup prediction in the code provided, and what might that imply?

  • Why might two models return different runup predictions for the same wave and beach conditions?

  • How does beach slope influence the runup height in most models

Contents