Chapter 5 Coastal Engineering: Stability of Beach Profile

Chapter 5 Coastal Engineering: Stability of Beach Profile#

Introduction: Wave Kinematics
Simulation: AiryWave
Self-Assessment

1. Introduction#

Fig. 30 **Figure 5.9 **: Breach Profile and Stability.#

🏖️ Beach Profile Overview#

A beach profile is a cross-sectional representation of the beach from the backshore (dune or cliff) to the offshore zone. It includes features like:

Berm: Flat area formed by wave deposition
Foreshore: Slope between high and low tide marks
Inshore/Offshore bars: Submerged ridges formed by wave action
Dune or cliff: Landward boundary

Beach profiles are dynamic and respond to wave energy, sediment supply, tides, and seasonal changes.

⚠️ Why Beach Profiles Can Be Unstable#

Beach profiles are inherently unstable due to:

Storm events: High-energy waves erode berms and dunes, pushing sand offshore into bars
Seasonal variation: Winter profiles are flatter and eroded; summer profiles are steeper and accreted
Sediment imbalance: Reduced sediment supply from rivers or human activity (e.g., dams, jetties) leads to erosion
Sea-level rise: Increases overwash and landward migration of beaches
Human interference: Seawalls, groynes, and development disrupt natural sediment transport

🛠️ How to Improve and Check Beach Profile Stability#

🔧 Improvement Strategies#

Beach nourishment: Adding compatible sand to restore eroded profiles
Living shorelines: Use vegetation and natural materials to stabilize dunes and berms
Sediment management: Maintain sediment supply from rivers and dredging
Profile equilibration: Design nourishment projects to allow natural reshaping by waves

📐 Stability Assessment Methods#

Beach profiling: Measure elevation changes along transects using Emery method or GPS
Slope analysis: Calculate beach angle and cross-sectional area
Sediment sampling: Analyze grain size and sorting to predict mobility
Monitoring seasonal changes: Compare summer vs. winter profiles over time
Modeling equilibrium profiles: Use Dean’s equation ( h = A y^{2/3} ) to predict stable shapes

🌍 U.S. Coastal Stability Overview#

🚨 Most Unstable Coastal Zones#

Region	Causes of Instability
Louisiana Gulf Coast	Rapid land loss (football field every 100 minutes), subsidence, sea-level rise
Florida Gulf Coast	Low dunes, high erosion rates, frequent hurricanes
Outer Banks, NC	Barrier islands eroding up to 15 ft/year, storm surge vulnerability
Texas Gulf Coast	High erosion, urbanization, sediment loss

✅ Most Stable Coastal Zones#

Region	Stability Factors
Pacific Northwest (e.g., Oregon)	Rocky coastlines, higher dunes, lower erosion rates
New England (e.g., Cape Cod)	Active restoration, dune management, and sediment control
California Channel Islands	Protected marine zones, limited development

References#

Beach profiles are dynamic systems shaped by natural forces and human interventions. Their stability is crucial for coastal resilience, habitat preservation, and infrastructure protection. By applying equilibrium theory, sediment management, and adaptive design, engineers and planners can mitigate erosion and enhance long-term stability. In the U.S., the Gulf Coast faces the greatest instability, while parts of the Pacific Northwest and New England remain relatively stable due to geology and proactive management. In [] introduces the equilibrium beach profile as a concave-upward shape governed by wave energy dissipation and sediment characteristics. Dean emphasizes that beach profiles naturally adjust to maintain equilibrium under varying wave conditions, and that slope stability is a function of sediment transport balance rather than geotechnical failure. [U.S. Army Corps of Engineers, 1984] builds on this by describing beach profiles in terms of morphological zones—berm, foreshore, and nearshore bars—each shaped by local wave climate and sediment supply. It focuses on empirical methods to assess profile changes due to storms, wave runup, and sediment transport. Slope stability in this context is interpreted as the beach’s ability to resist erosion and maintain form under dynamic forcing, rather than structural failure. The manual includes design guidance such as the Bruun Rule for shoreline retreat and empirical relationships between beach slope and sediment grain size. In [U.S. Army Corps of Engineers, 2002], the Coastal Engineering Manual integrates Dean’s equilibrium theory with broader design and analysis frameworks. It uses beach profiles not only for morphological understanding but also for predicting wave transformation, runup, and erosion potential.

2. Simulation#

Interactive Beach Profile Evaluation Based on SPM Principles#

This Jupyter Notebook tool provides an interactive evaluation of coastal beach profiles using key parameters inspired by the Shore Protection Manual (SPM). It assesses whether a beach is reflective, dissipative, or intermediate, and estimates stability based on sediment mobility.

User Inputs#

You can modify the following parameters using sliders:

Wave Height (Hb): Represents significant wave height in meters.
Wave Period (T): Time interval between wave crests in seconds.
Beach Slope (tan β): Indicates the steepness of the beach profile.
Sediment Size (D50): Median grain size of beach sediment in meters.

Coastal Metrics Computed#

Wave Steepness ( S = \frac{H_b}{L_0} ): Measures relative wave height to wavelength.
Iribarren Number ( Ir = \frac{\tan \beta}{\sqrt{H_b / L_0}} ): Surf similarity parameter.
Mobility Ratio ( M = \frac{H_b}{w_f} ): Compares wave energy to sediment settling ability.

Classification Logic#

Based on the inputs, the profile is classified as:

Iribarren Number	Beach Type
Ir > 3.3	Reflective Profile
Ir < 0.3	Dissipative Profile
0.3 ≤ Ir ≤ 3.3	Intermediate Profile

Additionally, sediment mobility determines:

Mobility Ratio	Stability Status
< 100	Likely Stable
> 300	Likely Unstable
100–300	Possibly Transitional

How It Works#

When you adjust the sliders, the tool recalculates the following:

Deep-water wavelength ( L_0 )
Wave steepness
Iribarren number
Sediment fall velocity (approximate)
Mobility ratio
Profile classification and stability result

🏖️ SPM-Based Beach Profile Classification (Interactive Python Tool)#

This Jupyter Notebook tool evaluates beach morphodynamics using principles from the Shore Protection Manual (SPM). It calculates wave steepness, Iribarren number, and sediment mobility to classify coastal profiles and estimate their stability.

🧠 What the Tool Does#

Accepts inputs: wave height, wave period, beach slope, and sediment grain size (D50)
Computes:
- Wave steepness: steepness of wave form
- Iribarren number (Ir): classifies beach response to wave forcing
- Mobility ratio: estimates sediment movement tendency
Outputs:
- Profile type: Reflective, Intermediate, or Dissipative
- Stability status: Likely Stable, Possibly Transitional, Likely Unstable
Enables interactive exploration via sliders

🎛️ User Inputs (via Sliders)#

Variable	Description	Typical Range
`Hb`	Wave Height (m)	0.5 – 5.0 m
`T`	Wave Period (s)	4.0 – 12.0 s
`slope`	Beach Slope	0.005 – 0.05
`D50`	Mean sediment diameter (m)	0.00005 – 0.001 m

📊 Output Metrics & Interpretation#

Output Metric	Meaning & Guidance
Wave Steepness	Higher = sharper waves, more erosive potential
Iribarren Number	Low (<0.3) = flat/dissipative; High (>3.3) = steep/reflective
Mobility Ratio	High >300 = active sediment motion; Low <100 = sediment stability
Profile Type	Helps predict hydrodynamic energy and sediment distribution
Stability Status	Indicates likelihood of profile erosion or accretion

📋 Example Summary Displayed#

📋 Beach Profile Evaluation Based on SPM:
  • Wave Height: 1.50 m
  • Wave Period: 8.00 s
  • Beach Slope: 0.020
  • Sediment Size (D50): 0.00020 m

🔎 Wave Steepness: 0.0157
🔎 Iribarren Number: 1.95
🔎 Mobility Ratio: 335.4

🏖️ Profile Type: Intermediate Profile — transitional behavior
🔒 Stability Status: Likely Unstable

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

# 🌐 Constants
g = 9.81  # gravity (m/s²)
rho = 1025  # seawater density (kg/m³)

# 📐 Classification logic based on SPM principles
def classify_spm_profile(Hb, T, slope, D50):
    D50=D50/1000
    L0 = (g * T**2) / (2 * np.pi)          # deep water wavelength
    steepness = Hb / L0                    # wave steepness
    Ir = slope / np.sqrt(Hb / L0)          # Iribarren number
    fall_velocity = 0.01 * D50**0.5        # empirical fall velocity (approximation)
    mobility_ratio = Hb / fall_velocity    # sediment mobility index

    # SPM-style profile categorization
    if Ir > 3.3:
        profile = "Reflective Profile — steep, stable beach"
    elif Ir < 0.3:
        profile = "Dissipative Profile — flat, prone to erosion"
    else:
        profile = "Intermediate Profile — transitional behavior"

    # Stability estimate (simplified)
    if mobility_ratio < 100:
        stability = "Likely Stable"
    elif mobility_ratio > 300:
        stability = "Likely Unstable"
    else:
        stability = "Possibly Transitional"

    return steepness, Ir, mobility_ratio, profile, stability

# 🎛️ Sliders
Hb_slider = widgets.FloatSlider(value=1.5, min=0.5, max=5.0, step=0.1, description='Wave Height (m)')
T_slider = widgets.FloatSlider(value=8.0, min=4.0, max=12.0, step=0.5, description='Wave Period (s)')
slope_slider = widgets.FloatSlider(value=0.02, min=0.005, max=0.05, step=0.005, description='Beach Slope')
D50_slider = widgets.FloatSlider(value=0., min=0.005, max=10., step=0.05, description='D50 (mm)')

# 📦 Output container
output = widgets.Output()

# 🔄 Update function
def update(Hb, T, slope, D50):
    with output:
        clear_output(wait=True)
        steepness, Ir, mobility, profile, stability = classify_spm_profile(Hb, T, slope, D50)

        print("📋 Beach Profile Evaluation Based on SPM:")
        print(f"  • Wave Height: {Hb:.2f} m")
        print(f"  • Wave Period: {T:.2f} s")
        print(f"  • Beach Slope: {slope:.3f}")
        print(f"  • Sediment Size (D50): {D50:.5f} m")
        print(f"\n🔎 Wave Steepness: {steepness:.4f}")
        print(f"🔎 Iribarren Number: {Ir:.2f}")
        print(f"🔎 Mobility Ratio: {mobility:.1f}")
        print(f"\n🏖️ Profile Type: {profile}")
        print(f"🔒 Stability Status: {stability}")

# 🔗 Link sliders to function
ui = widgets.VBox([Hb_slider, T_slider, slope_slider, D50_slider])
interactive_plot = widgets.interactive_output(update, {
    'Hb': Hb_slider,
    'T': T_slider,
    'slope': slope_slider,
    'D50': D50_slider
})

# 🚀 Display
display(ui, output)

## 3. Simulation

🧪 Sediment Fall Velocity Estimation Tool#

This interactive Python tool estimates the fall velocity of quartz sediment grains in water using multiple empirical models. It helps students explore how grain size and water temperature affect settling speed, and compare different theoretical approaches.

🎯 Purpose#

To calculate and compare sediment fall velocities using:

Stokes Law (laminar flow, small grains)
Newton’s Law (turbulent flow, large grains)
Dietrich (1982) empirical model (transitional regime)
Soulsby (1997) empirical model (coastal engineering)

📥 User Inputs#

Grain Size (mm): Diameter of quartz sediment particles
Water Temperature (°C): Affects kinematic viscosity of water

📐 Key Calculations#

Kinematic Viscosity: Interpolated from temperature using a lookup table
Density Ratio: $( s = \rho_s / \rho_w $), where:
- $( \rho_s $) = sediment density (2650 kg/m³)
- $( \rho_w $) = water density (1000 kg/m³)
Fall Velocity Models:
- Stokes: $( w_s = \frac{(s - 1) g d^2}{18 \nu} $)
- Newton: $( w_s = 1.6 \sqrt{(s - 1) g d} $)
- Dietrich (1982): Empirical fit using dimensionless particle size $( D_* $)
- Soulsby (1997): $( w_s = \frac{10 \nu}{d} \left( \sqrt{1 + 0.01 D_*^3} - 1 \right) $)
Reynolds Number: Used to classify flow regime:
- Stokes Regime: $( Re < 1 $)
- Newton Regime: $( Re > 500 $)
- Transitional Regime: Intermediate values

📊 Output Display#

Grain diameter and temperature
Kinematic viscosity
Flow regime and Reynolds number
Fall velocity estimates from all four models

Model	Fall Velocity (m/s)
Stokes	`value`
Newton	`value`
Dietrich (1982)	`value`
Soulsby (1997)	`value`

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

# Kinematic viscosity interpolation
def kinematic_viscosity(temp_C):
    viscosity_table = {
        0: 1.79e-6, 5: 1.52e-6, 10: 1.31e-6, 15: 1.15e-6,
        20: 1.00e-6, 25: 0.89e-6, 30: 0.80e-6
    }
    return np.interp(temp_C, list(viscosity_table.keys()), list(viscosity_table.values()))

# Dietrich (1982) empirical model
def ws_dietrich(d, s, g, v):
    D_star = d * ((s - 1) * g / v**2)**(1/3)
    log_Dstar = np.log10(D_star)
    R1 = -3.76715 + 1.92944 * log_Dstar - 0.09815 * log_Dstar**2 \
         - 0.00575 * log_Dstar**3 + 0.00056 * log_Dstar**4
    R2 = 10**R1
    return R2 * v

# Soulsby (1997) empirical model
def ws_soulsby(d, s, g, v):
    D_star = d * ((s - 1) * g / v**2)**(1/3)
    return (10 * v / d) * (np.sqrt(1 + 0.01 * D_star**3) - 1)

# Main function with model comparison
def fall_velocity_models(d_mm, temp_C=20, rho_s=2650, rho_w=1000, g=9.81):
    d = d_mm / 1000  # mm to meters
    v = kinematic_viscosity(temp_C)
    s = rho_s / rho_w

    # Stokes
    ws_stokes = ((s - 1) * g * d**2) / (18 * v)
    Re_stokes = ws_stokes * d / v

    # Newton
    ws_newton = 1.6 * np.sqrt(g * d * (s - 1))
    Re_newton = ws_newton * d / v

    # Dietrich
    ws_diet = ws_dietrich(d, s, g, v)

    # Soulsby
    ws_souls = ws_soulsby(d, s, g, v)

    # Regime classification
    if Re_stokes < 1:
        regime = "Stokes"
        ws = ws_stokes
        Re = Re_stokes
    elif Re_newton > 500:
        regime = "Newton"
        ws = ws_newton
        Re = Re_newton
    else:
        regime = "Transitional"
        ws = ws_diet  # Use Dietrich as transitional default
        Re = ws * d / v

    display(Markdown(f"""
### 🧪 Fall Velocity Estimation
- **Grain Diameter**: `{d_mm:.2f} mm`
- **Water Temperature**: `{temp_C} °C`
- **Kinematic Viscosity**: `{v:.8f} m²/s`
- **Flow Regime**: **{regime}**
- **Reynolds Number**: `{Re:.2f}`

### 📊 Comparison of Models
| Model           | Fall Velocity (m/s) |
|------------------|---------------------|
| Stokes           | `{ws_stokes:.4f}`   |
| Newton           | `{ws_newton:.4f}`   |
| Dietrich (1982)  | `{ws_diet:.4f}`     |
| Soulsby (1997)   | `{ws_souls:.4f}`    |
"""))

# Interactive widgets
d_slider_mm = widgets.FloatSlider(value=0.3, min=0.05, max=5.0, step=0.05, description='Grain Size (mm)')
temp_slider = widgets.IntSlider(value=20, min=0, max=30, step=1, description='Temp (°C)')

ui = widgets.VBox([d_slider_mm, temp_slider])
out = widgets.interactive_output(fall_velocity_models, {'d_mm': d_slider_mm, 'temp_C': temp_slider})

display(ui, out)

## 3. Simulation

🌊 Berm-Bar Formation Predictor: Summary#

This interactive tool estimates coastal profile formation (berm vs. bar) using four sediment transport models. It uses wave height, wave period, grain size, and beach slope to compute key parameters and classify profile types.

📐 Core Equation: Fall Velocity (Stokes’ Law)#

\[ w_f = \frac{(\rho_s - \rho) g D^2}{18 \mu} \]

$( w_f $): fall velocity (m/s)
$( D $): grain diameter (m)
$( \rho_s $): sediment density (2650 kg/m³)
$( \rho $): water density (1025 kg/m³)
$( \mu $): dynamic viscosity (0.001 Pa·s)

🧮 Method Summaries#

1. ω* and H/D Ratio#

\[ \omega^* = \frac{H}{w_f T}, \quad \frac{H}{D} \]

Bar formation: $( \omega^* < 1.5 $) and $( H/D > 20 $)
Berm formation: $( \omega^* > 2.5 $) and $( H/D < 10 $)
Transitional: otherwise

2. SPM-Based (Iribarren Number)#

\[ L_0 = \frac{g T^2}{2\pi}, \quad Ir = \frac{\tan\beta}{\sqrt{H/L_0}}, \quad \text{Mobility} = \frac{H}{w_f} \]

Profile Type:
- Reflective: $( Ir > 3.3 $)
- Dissipative: $( Ir < 0.3 $)
- Intermediate: otherwise
Stability:
- Stable: $( H/w_f < 100 $)
- Unstable: $( H/w_f > 300 $)
- Transitional: otherwise

3. Kraus & Larson (1988)#

\[ \text{Steepness} = \frac{H}{L}, \quad L = \frac{g T^2}{2\pi} \]

Thresholds:
- Berm: $( H/L < \frac{1.7\pi w_f}{gT} $)
- Bar: $( H/L > \frac{5.5\pi w_f}{gT} $)
- Transitional: otherwise

4. Dimensional Fall Time (SPM Fig 4-29)#

\[ \text{Fall Time} = \frac{H}{w_f T} \]

Berm: $( < 1 $)
Bar: $( > 2 $)
Transitional: otherwise

🎛️ Interactive Inputs#

Wave Height (H): 0.5–5.0 m
Grain Size (D): 0.1–5.5 mm
Wave Period (T): 4–12 s
Beach Slope (tanβ): 0.005–0.05

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

g = 9.81  # gravity

# Estimate fall velocity using Stokes' Law
def estimate_fall_velocity_stokes(diameter_m, rho_s=2650, rho=1025, mu=0.001):
    return ((rho_s - rho) * g * diameter_m**2) / (18 * mu)

# Method 1: ω* and H/D Ratio
def method_omega_star(wave_height, wave_period, grain_diameter_mm):
    d = grain_diameter_mm
    fall_velocity = estimate_fall_velocity_stokes(d)
#    omega_star = fall_velocity / np.sqrt(g * d)
    omega_star = wave_height/(fall_velocity * wave_period)
    
    H_D_ratio = wave_height / d

    if omega_star < 1.5 and H_D_ratio > 20:
        likelihood = "🌊 High likelihood of bar formation"
    elif omega_star > 2.5 and H_D_ratio < 10:
        likelihood = "🏖️ High likelihood of berm formation"
    else:
        likelihood = "🌤️ Transitional or mixed profile likely"

    return f"""
### Method: ω* and H/D Ratio
- **ω\***: `{omega_star:.3f}`
- **H/D**: `{H_D_ratio:.1f}`
- **Fall Velocity (Stokes)**: `{fall_velocity:.4f} m/s`
- **Formation Likelihood**: **{likelihood}**
"""

# Method 2: SPM-Based
def method_spm(wave_height, wave_period, beach_slope, grain_diameter_m):
    L0 = (g * wave_period**2) / (2 * np.pi)
    Ir = beach_slope / np.sqrt(wave_height / L0)
    fall_velocity = estimate_fall_velocity_stokes(grain_diameter_m)
    mobility_ratio = wave_height / fall_velocity

    if Ir > 3.3:
        profile = "Reflective Profile"
    elif Ir < 0.3:
        profile = "Dissipative Profile"
    else:
        profile = "Intermediate Profile"

    if mobility_ratio < 100:
        stability = "Likely Stable"
    elif mobility_ratio > 300:
        stability = "Likely Unstable"
    else:
        stability = "Possibly Transitional"

    return f"""
### Method: SPM-Based
- **Iribarren Number**: `{Ir:.2f}`
- **Mobility Ratio (H/wf)**: `{mobility_ratio:.1f}`
- **Fall Velocity (Stokes)**: `{fall_velocity:.4f} m/s`
- **Profile Type**: **{profile}**
- **Stability**: **{stability}**
"""


# Method 3: Kraus & Larson (1988)
def method_kraus_larson(wave_height, wave_period, grain_diameter_mm):

    d = grain_diameter_mm
    fall_velocity = estimate_fall_velocity_stokes(d)    
    wavelength=9.81*wave_period*wave_period/(2*3.14)
    
    steepness = wave_height/wavelength

    dim_up=5.5*3.14*fall_velocity/(9.81*wave_period)
    dim_lw=1.7*3.14*fall_velocity/(9.81*wave_period)
    
    if steepness < dim_lw:
        result = "🏖️ Berm formation likely (low mobility)"
    elif steepness > dim_up:
        result = "🌊 Bar formation likely (high mobility)"
    else:
        result = "🌤️ Transitional profile likely"

    return f"""

### Method: Kraus & Larson (1988)
- **Deep water Wave Steepness (H/L)**: `{steepness:.4f}`
- **Formation Likelihood**: **{result}**
"""



# Method 4: Dimensional Fall Time (SPM Fig 4-29)
def method_fall_time(wave_period, wave_height, grain_diameter_m):
    fall_velocity = estimate_fall_velocity_stokes(grain_diameter_m)
    fall_time = wave_height / (fall_velocity*wave_period)
    if fall_time < 1:
        result = "🏖️ Berm formation likely (short fall time)"
    elif fall_time > 2:
        result = "🌊 Bar formation likely (long fall time)"
    else:
        result = "🌤️ Transitional profile likely"

    return f"""
### Method: Dimensional Fall Time (SPM Fig 4-29)
- **Fall Time (T/wf)**: `{fall_time:.1f}`
- **Fall Velocity (Stokes)**: `{fall_velocity:.4f} m/s`
- **Formation Likelihood**: **{result}**
"""

# Unified interactive function
def berm_bar_predictor(method, wave_height, grain_diameter, wave_period, beach_slope):
    grain_diameter_m = grain_diameter / 1000

    if method == "ω* and H/D Ratio":
        result = method_omega_star(wave_height, wave_period, grain_diameter_m)
    elif method == "SPM-Based":
        result = method_spm(wave_height, wave_period, beach_slope, grain_diameter_m)
    elif method == "Kraus & Larson (1988)":
        result = method_kraus_larson(wave_height, wave_period, grain_diameter_m)
        
    elif method == "Dimensional Fall Time (SPM Fig 4-29)":
        result = method_fall_time(wave_period, wave_height, grain_diameter_m)
    else:
        result = "❌ Unknown method selected."

    clear_output(wait=True)
    display(Markdown(result))

# Widgets
method_selector = widgets.Dropdown(
    options=["ω* and H/D Ratio", "SPM-Based", "Kraus & Larson (1988)", "Dimensional Fall Time (SPM Fig 4-29)"],
    value="ω* and H/D Ratio",
    description="Method:"
)

wave_height_slider = widgets.FloatSlider(value=2.0, min=0.5, max=5.0, step=0.1, description='Wave Height (m)')
grain_size_slider = widgets.FloatSlider(value=0.3, min=0.1, max=5.5, step=0.01, description='Grain Size (mm)')
wave_period_slider = widgets.FloatSlider(value=8.0, min=4.0, max=12.0, step=0.5, description='Wave Period (s)')
beach_slope_slider = widgets.FloatSlider(value=0.02, min=0.005, max=0.05, step=0.005, description='Beach Slope')

ui = widgets.VBox([
    method_selector,
    wave_height_slider,
    grain_size_slider,
    wave_period_slider,
    beach_slope_slider
])

out = widgets.interactive_output(berm_bar_predictor, {
    'method': method_selector,
    'wave_height': wave_height_slider,
    'grain_diameter': grain_size_slider,
    'wave_period': wave_period_slider,
    'beach_slope': beach_slope_slider
})

display(ui, out)

<>:33: SyntaxWarning: invalid escape sequence '\*'
<>:33: SyntaxWarning: invalid escape sequence '\*'
C:\Users\satis\AppData\Local\Temp\ipykernel_20684\1832630208.py:33: SyntaxWarning: invalid escape sequence '\*'
  """