Chapter 5 Coastal Engineering: Breakwater Design

Chapter 5 Coastal Engineering: Breakwater Design#

Introduction: Breakwater Design
Simulation: Hudson Method
Simulation: Hudson and Van der Meer
Self-Assessment

1. Introduction#

Descriptive alt text for accessibility — Fig. 33 **Figure 5.14 **: Breakwater Crosssection.#

Breakwater#

-A breakwater is a permanent offshore structure designed to reduce wave energy and protect shorelines from erosion. It can be built using natural rock or concrete armor units. A rubble mound breakwater consists of graded stone layers: smaller stones form the internal core, while larger armor stones create the outer layer that absorbs wave impact. As waves strike the armor layer, much of their energy is dissipated, and the remaining water flows through the voids in the core, further reducing energy and stabilizing the structure.

-The key design components of a breakwater include the crest elevation and crest width, which determine the structure’s height and top surface area. The armor stone size, along with the thickness and placement method of the armor layer, are critical for absorbing wave energy. Beneath this, the filter layer thickness and core components, such as selected sand or gravel and filter fabric, contribute to internal stability and drainage. The overall structure slope and toe treatment influence wave interaction and foundation integrity.

Breakwater Design Methods: Hudson vs. Van der Meer#

There are two widely used methods for designing rubble mound breakwaters: the Hudson Method [Hudson, 1959] and the Van der Meer Method [Van der Meer, 1990]. Each approach is rooted in different philosophies of design — the former favoring simplicity and conservatism, the latter favoring adaptability and performance-based evaluation.

1. Hudson Method#

The Hudson Method is a classic empirical formula developed from laboratory tests and published in the Shore Protection Manual (SPM). It provides a straightforward way to estimate the required weight of armor stones to resist wave forces on a sloped structure.

Design Formula#

\[ W = \frac{\gamma_r H_s^3}{K_D (S_r - 1)^3 \cot \theta} \]

$( W $): required stone weight (N or kg)
$( H_s $): significant wave height (m)
$( \gamma_r $): specific weight of armor stone (N/m³)
$( S_r $): specific gravity = $( \rho_r / \rho_w #)
$( K_D $): empirical stability coefficient
$( \theta $): structure slope angle (degrees)

Key Features#

Simplicity: Easy and quick to apply
Conservative: Assumes zero damage or reshaping
Limited Scope: No input for storm duration, wave period, or structure permeability
Common Use: Conceptual or preliminary design, two-layer rock armor

2. 🌊 Van der Meer Method#

Developed in the 1980s from physical model tests, the Van der Meer Method is a more nuanced approach that considers structural permeability, acceptable damage, wave duration, and wave type (plunging or surging). It focuses on determining the nominal stone size ( D_{n50} ), making it well-suited for modern performance-based design.

Plunging Wave Condition#

\[ H_s = c_p \cdot \Delta \cdot D_{n50} \cdot \left( \frac{S}{\sqrt{N}} \cdot \cos \alpha \right)^{0.5} \]

Surging Wave Condition#

\[ H_s = c_s \cdot \Delta \cdot D_{n50} \cdot \left( \frac{S}{\sqrt{N}} \cdot \tan \alpha \cdot \xi_m \right)^{0.6} \]

$( D_{n50} $): nominal stone diameter (m)
$( \Delta $): relative submerged density
$( N $): number of waves during storm
$( S $): allowable damage level (2–8)
$( \alpha $): slope angle (rad)
$( \xi_m $): surf similarity parameter
$( c_p, c_s $): coefficients based on permeability $( P $)

Key Features#

Realistic: Includes permeability, storm duration, and wave breaking
Flexible: Adapts to reshaping and damage-tolerant designs
Accurate: Suited for detailed or final design stages
Breaker Type Awareness: Differentiates plunging and surging conditions

🧾 Summary#

Design Factor	Hudson Method	Van der Meer Method
Primary Output	Stone weight (W)	Stone size (Dn₅₀)
Storm Duration	Not considered	Explicit via number of waves (N)
Damage Modeling	Implicit (zero damage assumed)	User-defined (controlled reshaping allowed)
Wave Period / Type	Not considered	Wave period + breaker type (plunging/surging)
Use Case	Preliminary or conservative	Advanced, performance-based design

Both methods serve different stages of the design process. The Hudson Method is excellent for first approximations or conservative sizing, while the Van der Meer Method is essential for optimizing material usage and anticipating real-world performance.

Hudson vs. Van der Meer: Breakwater Design Methods#

Feature	Hudson Method	Van der Meer Method
Origin	Empirical, early-mid 20th century (SPM)	Empirical-semi-theoretical (1988–1990), based on model tests
Formula Structure	$W = \dfrac{\gamma_r H_s^3}{K_D (S_r - 1)^3 \cot \theta}$	$H_s = c_p \Delta D_{n50} \left( \dfrac{S}{\sqrt{N}} \cos \alpha \right)^{0.5}$ (Plunging)
Key Parameters	Wave height, slope angle, unit density, $K_D$	Wave height and period, storm duration, damage level ($S$), permeability ($P$)
Breaker Type Consideration	No	Yes — distinguishes plunging and surging waves
Damage Level Modeling	Implicit (conservative)	Explicit — quantifies tolerable damage (reshaping vs. failure)
Wave Attack Duration ($N$)	Not included	Explicitly included ($N$ = number of design waves)
Structure Permeability ($P$)	Not included	Included (0–1), affects armor stability
Typical Use Case	Preliminary design, conservative sizing	Advanced, performance-based design and optimization
Output	Armor stone weight ($W$)	Nominal armor diameter ($D_{n50}$)
Simplicity	Straightforward	Requires more input and judgment
Flexibility	Limited (single-layer, uniform assumptions)	Highly adaptable — suited for modern design and probabilistic risk assessments

References#

[] formalized the Hudson formula for preliminary design of rubble mound breakwaters. It provides empirical coefficients, design wave guidance, and structural layout recommendations. It remains a cornerstone in U.S. coastal engineering practice. [Van der Meer and Sigurdarson, 2016] on Van der Meer’s empirical formulae [Van der Meer, 1992] for armor stability under irregular wave conditions, including damage level, permeability, and wave type. It is widely used in Europe, Asia, and advanced coastal projects globally.[]provides detailed derivation and application of both Hudson and Van Der Meer methods.

2. Simulation#

🧱 Hudson-Based Interactive Armor Sizing Tool Summary#

This Python tool estimates the required weight and size of individual armor units for rubble-mound breakwaters using the Hudson method, guided by recommended K_D values from the Shore Protection Manual (SPM, 1984 Table 7-8).

🔧 What the Code Does#

Imports necessary libraries for numerical calculations and interactive widgets.
Stores recommended K_D values for armor units based on:
- Unit type (e.g., Quarry Stone, Tetrapod, Tribar)
- Placement style (Random, Special, Uniform)
- Structure location (Trunk, Head)
- Wave condition (Breaking, Nonbreaking)
- Number of layers (2 or 3)
Uses the Hudson formula to calculate required armor stone weight:

\[ W = \frac{H_s^3 \cdot \gamma_r}{K_D \cdot (S_r - 1)^3 \cdot \cot(\alpha)} \]

$( H_s $): significant wave height
$( \gamma_r $): unit weight of armor material
$( S_r $): relative density
$( \alpha $): slope angle
$( K_D $): damage coefficient from lookup table
Calculates equivalent nominal diameter:

\[ D_{n50} = \left( \frac{6W}{\pi \cdot \gamma_r} \right)^{1/3} \]

📊 Damage Coefficient (K_D) Lookup Table – SPM 1984#

Armor Unit	Placement	Location	Wave Condition	Layers	K_D
Quarry Stone	Random	Trunk	Breaking	2	1.2
Quarry Stone	Random	Trunk	Nonbreaking	2	2.4
Quarry Stone	Random	Head	Breaking	2	1.1
Quarry Stone	Random	Head	Nonbreaking	2	1.9
Smooth Rounded Stone	Random	Trunk	Breaking	2	1.5
Smooth Rounded Stone	Random	Trunk	Nonbreaking	2	2.9
Smooth Rounded Stone	Random	Head	Breaking	2	1.3
Smooth Rounded Stone	Random	Head	Nonbreaking	2	2.3
Rough Angular Stone	Random	Trunk	Breaking	2	2.0
Rough Angular Stone	Random	Trunk	Nonbreaking	2	4.0
Rough Angular Stone	Random	Head	Breaking	2	1.5
Rough Angular Stone	Random	Head	Nonbreaking	2	2.8
Rough Angular Stone	Random	Trunk	Breaking	3	2.2
Rough Angular Stone	Random	Trunk	Nonbreaking	3	4.5
Rough Angular Stone	Random	Head	Breaking	3	1.8
Rough Angular Stone	Random	Head	Nonbreaking	3	3.3
Rough Angular Stone	Special	Trunk	Breaking	3	5.8
Rough Angular Stone	Special	Trunk	Nonbreaking	3	7.0
Rough Angular Stone	Special	Head	Breaking	3	5.0
Rough Angular Stone	Special	Head	Nonbreaking	3	6.0
Tetrapod	Random	Trunk	Breaking	2	7.0
Tetrapod	Random	Trunk	Nonbreaking	2	8.0
Tetrapod	Random	Head	Breaking	2	5.0
Tetrapod	Random	Head	Nonbreaking	2	6.0
Tribar	Uniform	Trunk	Breaking	2	12.0
Tribar	Uniform	Trunk	Nonbreaking	2	15.0
Tribar	Uniform	Head	Breaking	2	7.5
Tribar	Uniform	Head	Nonbreaking	2	9.5
Quarrystone K85	Random	Trunk	Breaking	2	2.2
Quarrystone K85	Random	Trunk	Nonbreaking	2	2.5

Displays interactive UI sliders and dropdowns to select design inputs and see real-time output for:
- Suggested K_D value
- Estimated stone weight (kg)
- Equivalent nominal diameter ( D_{n50} ) in meters

import numpy as np
import ipywidgets as widgets
from IPython.display import display, Markdown, clear_output

# K_D values from SPM 1984 based on Table 7-8
KD_values_spm_1984 = {
    ("Quarry Stone", "Random", "Trunk", "Breaking", 2): 1.2,
    ("Quarry Stone", "Random", "Trunk", "Nonbreaking", 2): 2.4,
    ("Quarry Stone", "Random", "Head", "Breaking", 2): 1.1,
    ("Quarry Stone", "Random", "Head", "Nonbreaking", 2): 1.9,
    ("Smooth Rounded Stone", "Random", "Trunk", "Breaking", 2): 1.5,
    ("Smooth Rounded Stone", "Random", "Trunk", "Nonbreaking", 2): 2.9,
    ("Smooth Rounded Stone", "Random", "Head", "Breaking", 2): 1.3,
    ("Smooth Rounded Stone", "Random", "Head", "Nonbreaking", 2): 2.3,
    ("Rough Angular Stone", "Random", "Trunk", "Breaking", 2): 2.0,
    ("Rough Angular Stone", "Random", "Trunk", "Nonbreaking", 2): 4.0,
    ("Rough Angular Stone", "Random", "Head", "Breaking", 2): 1.5,
    ("Rough Angular Stone", "Random", "Head", "Nonbreaking", 2): 2.8,
    ("Rough Angular Stone", "Random", "Trunk", "Breaking", 3): 2.2,
    ("Rough Angular Stone", "Random", "Trunk", "Nonbreaking", 3): 4.5,
    ("Rough Angular Stone", "Random", "Head", "Breaking", 3): 1.8,
    ("Rough Angular Stone", "Random", "Head", "Nonbreaking", 3): 3.3,
    ("Rough Angular Stone", "Special", "Trunk", "Breaking", 3): 5.8,
    ("Rough Angular Stone", "Special", "Trunk", "Nonbreaking", 3): 7.0,
    ("Rough Angular Stone", "Special", "Head", "Breaking", 3): 5.0,
    ("Rough Angular Stone", "Special", "Head", "Nonbreaking", 3): 6.0,
    ("Tetrapod", "Random", "Trunk", "Breaking", 2): 7.0,
    ("Tetrapod", "Random", "Trunk", "Nonbreaking", 2): 8.0,
    ("Tetrapod", "Random", "Head", "Breaking", 2): 5.0,
    ("Tetrapod", "Random", "Head", "Nonbreaking", 2): 6.0,
    ("Tribar", "Uniform", "Trunk", "Breaking", 2): 12.0,
    ("Tribar", "Uniform", "Trunk", "Nonbreaking", 2): 15.0,
    ("Tribar", "Uniform", "Head", "Breaking", 2): 7.5,
    ("Tribar", "Uniform", "Head", "Nonbreaking", 2): 9.5,
    ("Quarrystone K85", "Random", "Trunk", "Breaking", 2): 2.2,
    ("Quarrystone K85", "Random", "Trunk", "Nonbreaking", 2): 2.5
}

# Hudson formula
def hudson_stone_weight(Hs, gamma_r, Sr, slope_deg, KD):
    slope_rad = np.radians(slope_deg)
    delta = Sr - 1.0
    cot_alpha = 1 / np.tan(slope_rad)
    W = (Hs**3 * gamma_r) / (KD * delta**3 * cot_alpha)
    return W

# Output function
def calculate_weight(Hs, gamma_r, Sr, slope_deg, unit, placement, location, wave_condition, layers):
    KD = KD_values_spm_1984.get((unit, placement, location, wave_condition, layers), None)
    if KD is None:
        clear_output(wait=True)
        display(Markdown("⚠️ This KD combination is not available in the database. Please adjust your selection."))
        return

    W = hudson_stone_weight(Hs, gamma_r, Sr, slope_deg, KD)
    Dn50 = ((W / gamma_r) * 6 / np.pi)**(1/3)

    clear_output(wait=True)
    display(Markdown(f"""
### 🌊 Hudson-Based Armor Sizing
- **Unit Type**: `{unit}`
- **Placement**: `{placement}`
- **Location**: `{location}`
- **Wave Type**: `{wave_condition}`
- **Number of Layers**: `{layers}`
- **Suggested K_D**: `{KD}`
- **Stone Weight**: `{W:.2f} kg`
- **Equivalent Dn₅₀**: `{Dn50:.3f} m`
"""))

# UI elements
unit_selector = widgets.Dropdown(options=sorted(set(k[0] for k in KD_values_spm_1984)), description="Armor Type")
placement_selector = widgets.Dropdown(options=["Random", "Special", "Uniform"], description="Placement")
location_selector = widgets.Dropdown(options=["Trunk", "Head"], description="Location")
wave_type_selector = widgets.Dropdown(options=["Breaking", "Nonbreaking"], description="Wave Condition")
layer_selector = widgets.IntSlider(value=2, min=1, max=3, step=1, description="Layers")

Hs_slider = widgets.FloatSlider(value=2.5, min=0.5, max=6.0, step=0.1, description="Wave Height Hₛ (m)")
gamma_slider = widgets.FloatSlider(value=2600, min=2000, max=2600, step=50, description="Unit Weight γᵣ (N/m³)")
Sr_slider = widgets.FloatSlider(value=2.65, min=2.3, max=3.0, step=0.05, description="Density Ratio Sᵣ")
slope_slider = widgets.FloatSlider(value=30, min=15, max=45, step=1, description="Armor Slope (°)")

ui = widgets.VBox([
    widgets.HTML("<h3>🌊 Hudson Design Parameters</h3>"),
    Hs_slider, gamma_slider, Sr_slider, slope_slider,
    unit_selector, placement_selector, location_selector, wave_type_selector, layer_selector
])

out = widgets.interactive_output(calculate_weight, {
    'Hs': Hs_slider, 'gamma_r': gamma_slider, 'Sr': Sr_slider,
    'slope_deg': slope_slider, 'unit': unit_selector,
    'placement': placement_selector, 'location': location_selector,
    'wave_condition': wave_type_selector, 'layers': layer_selector
})

display(ui, out)

3. Simulation#

🧱 Interactive Breakwater Design Comparison Tool#

This Python-based design studio allows users to compare armor unit sizes using two coastal engineering formulas: Hudson’s method and Van der Meer’s method. It supports real-time simulation, visual output, and adjustable inputs via sliders.

🧠 What the Tool Does#

Calculates required stone weight and diameter for breakwater stability
Compares results from:
- Hudson Method (empirical, conservative)
- Van der Meer Method (wave-type sensitive: plunging or surging)
Adjusts parameters like slope angle, wave height/period, material density, permeability, damage, and duration

🎛️ User Inputs#

Input	Description
`Hs`	Significant wave height (m)
`Tm`	Mean wave period (s)
`γᵣ`	Unit weight of armor material (N/m³)
`Sᵣ`	Relative density of armor material
`Slope (°)`	Armor slope angle in degrees
`Kₙ`	Hudson stability coefficient
`P`	Permeability (Van der Meer only)
`S`	Damage parameter
`N`	Number of waves during storm
`Breaker Type`	Plunging or Surging

📊 Output Metrics#

🔷 Hudson Method#

Stone Weight (kg)
Nominal Diameter (Dn₅₀)

🔷 Van der Meer Method (Plunging/Surging)#

Nominal Diameter (Dn₅₀)
Estimated Weight (kg)

🧭 How to Interpret#

Hudson Method: Uses simplified design logic with fixed stability coefficient; suitable for early estimates
Van der Meer Method: Adapts to breaker type and structural features; more sensitive to wave and permeability variations
Comparing both helps reveal design trade-offs and sensitivity to conditions

Use this tool for preliminary sizing, design education, or scenario-based comparison between armor sizing methods.

# This design studio lets you:
# - Simulate both methods in real-time
# - Visually compare estimated armor unit sizes
# - Explore the influence of wave steepness and slope
# Let me know if you'd like a plot comparing stone weight vs wave height across both methods — or if you want to toggle in predefined armor unit types like Xbloc or Core-loc!



import numpy as np
import ipywidgets as widgets
from IPython.display import display, Markdown, clear_output

# -- Design Functions --

def hudson_stone_weight(Hs, gamma_r, Sr, slope_angle_deg, Kd):
    theta_rad = np.deg2rad(slope_angle_deg)
    cot_theta = 1 / np.tan(theta_rad)
    return (gamma_r * Hs**3) / (Kd * (Sr - 1)**3 * cot_theta)

def van_der_meer_plunging(Hs, Tm, alpha_deg, P, S, N, delta):
    alpha = np.deg2rad(alpha_deg)
    c_p = 5.2 + 0.3 * (P - 0.1) / 0.3
    return Hs / (c_p * delta * ((S / np.sqrt(N)) * np.cos(alpha))**0.5)

def van_der_meer_surging(Hs, Tm, alpha_deg, P, S, N, delta):
    alpha = np.deg2rad(alpha_deg)
    tan_alpha = np.tan(alpha)
    g = 9.81
    xi_m = tan_alpha / np.sqrt(Hs / (g * Tm**2))
    c_s = 6.0 + 0.5 * (P - 0.1) / 0.3
    return Hs / (c_s * delta * ((S / np.sqrt(N)) * tan_alpha * xi_m)**0.6)

# -- Widgets --

Hs_widget = widgets.FloatSlider(value=3.0, min=0.5, max=10.0, step=0.1, description='Hs (m)')
gamma_widget = widgets.FloatSlider(value=2600, min=2000, max=2800, step=50, description='γᵣ (Kg/m³)')
Sr_widget = widgets.FloatSlider(value=2.65, min=2.0, max=3.0, step=0.05, description='Sᵣ')
slope_widget = widgets.FloatSlider(value=30, min=10, max=60, step=1, description='Slope (°)')
Kd_widget = widgets.FloatSlider(value=3.5, min=1.0, max=20.0, step=0.5, description='Kₙ')

Tm_widget = widgets.FloatSlider(value=6.0, min=2.0, max=12.0, step=0.1, description='Tm (s)')
P_widget = widgets.FloatSlider(value=0.4, min=0.0, max=1.0, step=0.05, description='Permeability (P)')
S_widget = widgets.FloatSlider(value=2.0, min=1.0, max=8.0, step=0.5, description='Damage (S)')
N_widget = widgets.IntSlider(value=3000, min=500, max=10000, step=100, description='Waves (N)')
regime_widget = widgets.ToggleButtons(options=['Plunging', 'Surging'], description='Breaker Type:')

output = widgets.Output()

# -- Update and Display --

def update(_=None):
    with output:
        clear_output()
        Hs = Hs_widget.value
        gamma = gamma_widget.value
        Sr = Sr_widget.value
        slope = slope_widget.value
        Kd = Kd_widget.value

        Tm = Tm_widget.value
        P = P_widget.value
        S = S_widget.value
        N = N_widget.value
        delta = Sr - 1.0
        regime = regime_widget.value

        # Hudson
        W_hudson = hudson_stone_weight(Hs, gamma, Sr, slope, Kd)
        Dn_hudson = ((W_hudson / gamma) * 6 / np.pi)**(1/3)

        # Van der Meer
        if regime == 'Plunging':
            Dn_vm = van_der_meer_plunging(Hs, Tm, slope, P, S, N, delta)
        else:
            Dn_vm = van_der_meer_surging(Hs, Tm, slope, P, S, N, delta)

        # Convert weights
        W_tonnes = W_hudson 
        W_vm = gamma * Dn_vm**3 * np.pi / 6
        W_vm_tonnes = W_vm 

        # Display
        display(Markdown(f"""
###  Breakwater Design Comparison

####  Hudson Method
- Estimated Stone Weight: **{W_tonnes:.2f} kg**
- Equivalent Dn₅₀ ≈ **{Dn_hudson:.3f} m**

####  Van der Meer Method ({regime})
- Armor Nominal Diameter (Dn₅₀): **{Dn_vm:.3f} m**
- Equivalent Weight: **{W_vm_tonnes:.2f} kg**

---

🧭 **Interpretation**:
- Hudson is conservative and assumes a fixed Kₙ value
- Van der Meer adjusts design based on breaker type, permeability, damage level, and storm duration
"""))

# Link events
controls = [
    Hs_widget, gamma_widget, Sr_widget, slope_widget, Kd_widget,
    Tm_widget, P_widget, S_widget, N_widget, regime_widget
]
for w in controls:
    w.observe(update, 'value')

# Display Layout
ui = widgets.VBox([
    widgets.HTML("<h3>🌊 Wave & Material Inputs</h3>"),
    widgets.HBox([Hs_widget, Tm_widget, slope_widget]),
    widgets.HBox([gamma_widget, Sr_widget, Kd_widget]),
    widgets.HTML("<h3>🧮 Van der Meer Parameters</h3>"),
    widgets.HBox([P_widget, S_widget, N_widget]),
    regime_widget
])
display(ui)
display(output)
update()

4. Self-Assessment#

Interactive Breakwater Design Studio Module#

This hands-on design module enables exploration and comparison between the Hudson Method and the Van der Meer Method for rubble-mound breakwater armor design.

Learning Objectives#

Understand the conceptual differences between Hudson and Van der Meer approaches
Analyze the influence of slope, permeability, storm duration, and damage tolerance
Compare calculated armor unit sizes (stone weight vs. nominal diameter)
Reflect on the implications of conservative vs. performance-based design

Key Features#

Real-time input adjustment using interactive sliders
Support for both plunging and surging breaker types
Outputs:
- Hudson Method: estimated stone weight and Dₙ₅₀
- Van der Meer Method: Dₙ₅₀ and equivalent weight
Structured display of parameters and interpretation notes

Conceptual Questions#

Why does the Van der Meer method produce different armor sizes for the same wave height compared to the Hudson method?
What are the roles of permeability ( P ) and damage level ( S ) in Van der Meer’s equations?
How does slope angle affect both methods, and why does Van der Meer use trigonometric terms like ( \cos(\alpha) )?
Why does the Hudson Method not account for storm duration or wave period?

Reflective Questions#

Which method gives smaller stone sizes under the same wave conditions, and why?
How does changing the acceptable damage level ( S ) influence the armor size in the Van der Meer method?
Under what circumstances would a designer prefer the Hudson Method despite its limitations?
If two breakwaters were built using Hudson and Van der Meer respectively, how would you expect their performance and economy to differ over a 20-year design life?

Suggested Exercises#

Use the sliders to simulate storm scenarios with increasing wave heights. Note how both methods respond.
Fix ( H_s = 4 ) m and compare stone sizes for permeabilities ( P = 0.1 ) vs ( P = 0.8 ).
Set a constant wave attack ( N = 5000 ) and analyze how increasing the damage tolerance ( S ) changes the design.

Further Exploration#

Try plotting Dn₅₀ vs. Hs for both methods across multiple wave heights.
Integrate economic cost curves to assess which design leads to least-cost, adequate protection.
Compare design outcomes for reshape-tolerant units like Xbloc vs. statistically stable armor like Dolosse.

💬 Tip: Pair this module with field photos or lab videos of plunge vs. surge conditions to reinforce wave interaction behavior.

Chapter 5 Coastal Engineering: Breakwater Design

Contents

Chapter 5 Coastal Engineering: Breakwater Design#

1. Introduction#

Breakwater#

Breakwater Design Methods: Hudson vs. Van der Meer#

1. Hudson Method#

Design Formula#

Key Features#

2. 🌊 Van der Meer Method#

Plunging Wave Condition#

Surging Wave Condition#

Key Features#

🧾 Summary#

Hudson vs. Van der Meer: Breakwater Design Methods#

References#

2. Simulation#

🧱 Hudson-Based Interactive Armor Sizing Tool Summary#

🔧 What the Code Does#

📊 Damage Coefficient (K_D) Lookup Table – SPM 1984#

3. Simulation#

🧱 Interactive Breakwater Design Comparison Tool#

🧠 What the Tool Does#

🎛️ User Inputs#

📊 Output Metrics#

🔷 Hudson Method#

🔷 Van der Meer Method (Plunging/Surging)#

🧭 How to Interpret#

4. Self-Assessment#

Interactive Breakwater Design Studio Module#

Learning Objectives#

Key Features#

Conceptual Questions#

Reflective Questions#

Suggested Exercises#

Further Exploration#