Stormwater Management Skill
Integrated stormwater management and green infrastructure design for sustainable urban drainage.
Purpose
This skill provides comprehensive capabilities for stormwater management planning, including hydrologic analysis, green infrastructure design, BMP selection and sizing, SWMM modeling, and MS4 permit compliance analysis.
Capabilities
SWMM Modeling and Simulation
- EPA SWMM model setup and configuration
- Subcatchment delineation and parameterization
- Drainage network modeling
- Long-term continuous simulation
- Design storm analysis
- LID representation and modeling
Hydrologic Analysis
- TR-55 methodology implementation
- Rational method calculations
- SCS Curve Number determination
- Time of concentration estimation
- Unit hydrograph development
- Rainfall-runoff modeling
Green Infrastructure Sizing
- Bioretention facility design
- Permeable pavement sizing
- Rain garden design
- Green roof specifications
- Tree box filters
- Vegetated swales
Detention/Retention Pond Design
- Storage volume calculations
- Stage-storage-discharge relationships
- Outlet structure design
- Emergency spillway sizing
- Sediment forebay design
- Maintenance access planning
Water Quality BMP Selection
- Pollutant removal efficiency analysis
- BMP selection matrix
- Treatment train design
- Sizing for TSS removal
- Nutrient removal considerations
- Cost-effectiveness analysis
Pollutant Load Modeling
- Event Mean Concentration (EMC) analysis
- Annual pollutant load estimation
- Source area contribution analysis
- Loading rate calculations
- Reduction target setting
Low Impact Development Integration
- Site-level LID planning
- Watershed-scale LID analysis
- LID retrofit opportunities
- Performance monitoring design
- Adaptive management frameworks
MS4 Permit Compliance Analysis
- NPDES requirements interpretation
- MCM implementation tracking
- TMDL compliance assessment
- Monitoring program design
- Annual report preparation
Prerequisites
Installation
pip install numpy scipy pandas matplotlibOptional Dependencies
# For SWMM integration
pip install swmm-api pyswmm
# For GIS analysis
pip install geopandas shapely
# For visualization
pip install plotly foliumUsage Patterns
Rational Method Calculations
import numpy as np
from dataclasses import dataclass
from typing import Dict, List, Tuple
@dataclass
class CatchmentData:
"""Catchment characteristics"""
area_acres: float
runoff_coefficient: float
time_of_concentration_min: float
description: str = ""
class RationalMethod:
"""Rational method for peak runoff calculation"""
def __init__(self):
# IDF curve coefficients (example for generic location)
# Q = C * I * A, where I from IDF: I = a / (Tc + b)^c
self.idf_coefficients = {
2: {'a': 100, 'b': 10, 'c': 0.8},
5: {'a': 120, 'b': 10, 'c': 0.8},
10: {'a': 140, 'b': 10, 'c': 0.8},
25: {'a': 160, 'b': 10, 'c': 0.8},
50: {'a': 180, 'b': 10, 'c': 0.8},
100: {'a': 200, 'b': 10, 'c': 0.8}
}
def rainfall_intensity(self, tc_min: float, return_period: int) -> float:
"""Calculate rainfall intensity from IDF curve (in/hr)"""
coef = self.idf_coefficients.get(return_period, self.idf_coefficients[10])
intensity = coef['a'] / (tc_min + coef['b']) ** coef['c']
return intensity
def peak_runoff(self, catchment: CatchmentData, return_period: int) -> float:
"""Calculate peak runoff using Rational Method (cfs)"""
C = catchment.runoff_coefficient
I = self.rainfall_intensity(catchment.time_of_concentration_min, return_period)
A = catchment.area_acres
Q = C * I * A # cfs
return Q
def composite_runoff_coefficient(self, subareas: List[Tuple[float, float]]) -> float:
"""Calculate composite C for mixed land uses
subareas: list of (area, C) tuples
"""
total_area = sum(a for a, c in subareas)
weighted_c = sum(a * c for a, c in subareas) / total_area
return weighted_c
@staticmethod
def time_of_concentration_kirpich(length_ft: float, slope_pct: float) -> float:
"""Kirpich equation for Tc (minutes)"""
tc = 0.0078 * (length_ft ** 0.77) * (slope_pct ** -0.385)
return tc
# Example runoff coefficients
RUNOFF_COEFFICIENTS = {
'commercial': 0.85,
'industrial': 0.75,
'residential_high_density': 0.65,
'residential_medium_density': 0.45,
'residential_low_density': 0.35,
'parks': 0.20,
'forest': 0.15,
'impervious': 0.95,
'lawn_steep': 0.30,
'lawn_flat': 0.20
}
# Example usage
rational = RationalMethod()
# Calculate composite C for mixed use area
subareas = [
(5.0, RUNOFF_COEFFICIENTS['commercial']),
(10.0, RUNOFF_COEFFICIENTS['residential_medium_density']),
(3.0, RUNOFF_COEFFICIENTS['parks'])
]
composite_c = rational.composite_runoff_coefficient(subareas)
catchment = CatchmentData(
area_acres=18.0,
runoff_coefficient=composite_c,
time_of_concentration_min=15.0,
description="Mixed use development"
)
for rp in [2, 10, 25, 100]:
Q = rational.peak_runoff(catchment, rp)
print(f"{rp}-year storm: Q = {Q:.1f} cfs")SCS Curve Number Method
class SCSMethod:
"""SCS Curve Number method for runoff calculation"""
def __init__(self, curve_number: float):
self.cn = curve_number
self.S = (1000 / curve_number) - 10 # Potential retention (inches)
self.Ia = 0.2 * self.S # Initial abstraction
def runoff_depth(self, rainfall_inches: float) -> float:
"""Calculate runoff depth (inches)"""
P = rainfall_inches
if P <= self.Ia:
return 0.0
Q = (P - self.Ia) ** 2 / (P - self.Ia + self.S)
return Q
def runoff_volume(self, rainfall_inches: float, area_acres: float) -> float:
"""Calculate runoff volume (acre-feet)"""
Q_inches = self.runoff_depth(rainfall_inches)
volume_ac_ft = Q_inches / 12 * area_acres
return volume_ac_ft
@staticmethod
def composite_cn(subareas: List[Tuple[float, float]]) -> float:
"""Calculate area-weighted composite CN
subareas: list of (area, CN) tuples
"""
total_area = sum(a for a, cn in subareas)
weighted_cn = sum(a * cn for a, cn in subareas) / total_area
return weighted_cn
@staticmethod
def adjust_cn_for_amc(cn_ii: float, condition: str) -> float:
"""Adjust CN for antecedent moisture condition
condition: 'dry' (AMC-I), 'normal' (AMC-II), or 'wet' (AMC-III)
"""
if condition == 'dry':
cn = cn_ii / (2.281 - 0.01281 * cn_ii)
elif condition == 'wet':
cn = cn_ii / (0.427 + 0.00573 * cn_ii)
else:
cn = cn_ii
return cn
# Standard curve numbers (AMC-II, Hydrologic Soil Group B)
CURVE_NUMBERS = {
'impervious': 98,
'commercial': 92,
'industrial': 88,
'residential_1_8_acre': 85,
'residential_1_4_acre': 80,
'residential_1_2_acre': 75,
'residential_1_acre': 68,
'open_space_good': 61,
'open_space_fair': 69,
'forest_good': 55,
'pasture_good': 61
}
# Example usage
# Pre-development condition
pre_cn = SCSMethod.composite_cn([
(20, CURVE_NUMBERS['forest_good']),
(80, CURVE_NUMBERS['pasture_good'])
])
pre_scs = SCSMethod(pre_cn)
# Post-development condition
post_cn = SCSMethod.composite_cn([
(30, CURVE_NUMBERS['impervious']),
(40, CURVE_NUMBERS['residential_1_4_acre']),
(30, CURVE_NUMBERS['open_space_good'])
])
post_scs = SCSMethod(post_cn)
rainfall = 3.5 # inches (design storm)
pre_runoff = pre_scs.runoff_volume(rainfall, area_acres=100)
post_runoff = post_scs.runoff_volume(rainfall, area_acres=100)
print(f"Pre-development CN: {pre_cn:.0f}")
print(f"Pos