Build a landslide nowcasting using rainfall thresholds and susceptibility.
- User
Build a landslide nowcasting using rainfall thresholds and susceptibility.
Assistant
1. Deconstruct the User's Request:
- Goal: Build a landslide nowcasting system.
- Methodology: Using two specific components:
- Rainfall Thresholds.
- Susceptibility Maps (or models).
- Implied Output: A guide, conceptual framework, or potentially Python code (since "build" usually implies code in an AI context). Given the complexity of real-world data, I should provide a conceptual framework with illustrative code rather than a deployable production system (which requires specific GIS data and real-time API hooks).
2. Define "Landslide Nowcasting":
- Nowcasting implies assessing the current risk right now or in the immediate future (0-6 hours), usually based on real-time observations (rainfall) rather than long-term forecasts.
- It's different from Forecasting (prediction days ahead) and Warning (issuing an alert).
3. Key Components:
- Component A: Susceptibility (Static).
- This is the "where."
- Factors: Slope, Soil type, Land cover, Geology, Historical landslides.
- Output: A map where every pixel has a probability (0 to 1) or class (Low, Mod, High) of sliding.
- Component B: Rainfall Thresholds (Dynamic).
- This is the "when" or "trigger."
- Common models: ID curves (Intensity-Duration), Antecedent Rainfall (soil saturation).
- Output: A binary (Trigger/No Trigger) or probability value based on recent rain.
4. The "Build" Process (Workflow Design):
- Step 1: Data Acquisition. (DEM for slope, Rainfall data).
- Step 2: Susceptibility Modeling. (Calculate slope, weight factors).
- Step 3: Rainfall Analysis. (Accumulate rain, compare to threshold).
- Step 4: Integration (The Nowcasting). (Combine Static Susceptibility Dynamic Trigger = Hazard).
- Step 5: Visualization/Alerting.
5. Drafting the Solution (Python-centric approach):
-
Assumptions: I need to create dummy data because I don't have the user's shapefiles or NetCDFs.
-
Libraries:
numpy,pandas(for data),matplotlib(for plots),rasterio/gdal(if going full GIS, but maybe stick tonumpyarrays for simplicity to keep it runnable),scikit-learn(optional, for susceptibility, but weighted overlay is easier to explain conceptually). Let's stick tonumpyfor the grid logic. -
Part 1: Susceptibility Model.
- Formula:
- For the code example, I'll generate a synthetic terrain (random noise + gradient) to simulate a slope.
-
Part 2: Rainfall Thresholds.
- Classic ID Threshold: .
- Let's implement a function that checks if current rainfall exceeds this curve.
- Alternatively, a simpler binary grid: "Is it raining hard here?"
-
Part 3: The Nowcasting Logic.
- Hazard = Susceptibility Rainfall_Factor.
- If Susceptibility is 0 (Flat), Hazard is 0 even with rain.
- If Rainfall is 0 (Dry), Hazard is 0 even on a cliff.
- If Susceptibility is High AND Rain is High -> Hazard is Very High.
6. Refining the Content:
- Theory Check: Is multiplying them correct? Often yes, or an overlay matrix (Low/High, Low/High).
- Threshold specifics: Mention Caine (1980) or local specific curves.
- Antecedent Rainfall: This is crucial. It's not just current rain; it's the rain from the last 3 days. I should mention the concept of API (Antecedent Precipitation Index).
7. Structuring the Response:
- Introduction: Define the approach.
- Step 1: Susceptibility (The Static Layer). Explain factors (Slope, Geology). Show code to generate a synthetic susceptibility map.
- Step 2: Rainfall Thresholds (The Dynamic Trigger). Explain ID curves. Show code to define a threshold function.
- Step 3: The Nowcasting Engine. Explain the combination logic (Matrix or Multiplication). Show code to combine Step 1 and Step 2.
- Step 4: Visualization. Plot the result.
- Conclusion/Improvements: Mention real-time data sources (IMERG, GPM), ML methods (Random Forest), and delivery systems.
8. Self-Correction/Review during drafting:
- Initial thought: Use
rasterio. - Correction: That requires external files. Better to use
numpyto generate a synthetic topography so the user can copy-paste and run the code immediately to see it work. - Threshold detail: Don't just make it binary. Make the threshold return a "probability of exceedance" or a normalized intensity (0-1) relative to the threshold. This makes the final map smoother. Let's define
Rainfall_Severity= (Actual Rain / Threshold Rain).
9. Final Code Structure:
- Import libs.
- Generate Terrain (Slope).
- Define Threshold (Intensity-Duration).
- Generate Synthetic Rainfall Event.
- Calculate Hazard.
- Plot.
10. Writing the explanation: Keep it professional, structured, and scientific. Use LaTeX for formulas where appropriate.
(Self-Correction on "Nowcasting" vs "Early Warning"): Ensure I emphasize that this script simulates a snapshot in time. Nowcasting requires a loop over time, but for a code example, a snapshot is sufficient.
11. Final Polish: Add comments in the code explaining why we are doing specific math operations (e.g., normalizing slope to 0-1).
(Drafting the response - mental simulation of the Python code):
# Slope map slope = np.random... # Susceptibility (0-1) sus = (slope * 0.6 + soil * 0.4) # Rain intensity intensity = ... # Threshold function threshold = 5 * duration**-0.5 # Trigger level trigger = intensity / threshold # Hazard hazard = sus * triggerThis looks solid. I will present this framework. To build a landslide nowcasting system, you need to combine a static component (the land's inherent ability to fail, i.e., Susceptibility) with a dynamic component (the trigger, i.e., Rainfall Thresholds).
Here is a comprehensive guide and a Python framework to build this system.
The Conceptual Framework
1. Susceptibility (The "Where") This is a static map identifying areas prone to landslides based on terrain and soil.
- Key Factors: Slope angle (most critical), Aspect, Elevation, Soil Type, Land Cover, Distance to Faults, Distance to Drainage.
- Output: A normalized probability score (0.0 to 1.0).
2. Rainfall Thresholds (The "When") This defines the meteorological trigger. The most common global standard is the Intensity-Duration (ID) curve.
- Formula:
- : Rainfall Intensity (mm/h)
- : Duration (hours)
- : Empirical constants derived from historical landslide events.
- Concept: If the current rainfall intensity exceeds the threshold for a specific duration, the trigger is active.
3. Nowcasting (The Integration) The Nowcast is the intersection of these two.
Python Implementation
Below is a complete, runnable Python script. It generates synthetic elevation data (to create a susceptibility map) and synthetic rainfall data (to simulate a storm event) to produce a real-time hazard nowcast.
Prerequisites:
numpy,matplotlib,scipy(for terrain simulation).import numpy as np import matplotlib.pyplot as plt from scipy.ndimage import gaussian_filter # ========================================== # 1. CONFIGURATION & SYNTHETIC DATA GENERATION # ========================================== # Grid dimensions (e.g., 10km x 10km area, 100m resolution) ROWS, COLS = 100, 100 RESOLUTION = 100 # meters # A. Generate Synthetic Terrain (Simulating a mountainous region) # We use a random grid smoothed to look like hills np.random.seed(42) random_terrain = np.random.rand(ROWS, COLS) smooth_terrain = gaussian_filter(random_terrain, sigma=10) # Add a ridge x_grid, y_grid = np.meshgrid(np.arange(COLS), np.arange(ROWS)) ridge = np.exp(-((x_grid - 50)**2) / (2 * 10**2)) elevation = (smooth_terrain * 500 + ridge * 800 + 100) # B. Define Rainfall Threshold Parameters (Caine, 1980 typical values) # I = alpha * D^beta ALPHA = 14.82 BETA = -0.39 # ========================================== # 2. SUSCEPTIBILITY MODEL (The Static Layer) # ========================================== def calculate_slope(dem, cell_size): """ Calculates slope in degrees from a Digital Elevation Model (DEM). """ # Compute gradient dy, dx = np.gradient(dem, cell_size) slope_rad = np.arctan(np.sqrt(dx**2 + dy**2)) slope_deg = np.degrees(slope_rad) return slope_deg def build_susceptibility_map(elevation): """ In a real scenario, you would use Weight of Evidence or Logistic Regression. For this build, we use a simplified heuristic: Hazard ~ Slope + Soil Moisture Proxy(Curvature). """ # 1. Calculate Slope slope = calculate_slope(elevation, RESOLUTION) # 2. Calculate Curvature (proxy for water accumulation) # Concave areas (negative curvature) collect water dz_dx, dz_dy = np.gradient(elevation, RESOLUTION) dxx = np.gradient(dz_dx, RESOLUTION)[0] dyy = np.gradient(dz_dy, RESOLUTION)[1] curvature = dxx + dyy # 3. Normalize features (0 to 1) norm_slope = (slope - np.min(slope)) / (np.max(slope) - np.min(slope)) norm_curv = (curvature - np.min(curvature)) / (np.max(curvature) - np.min(curvature)) # 4. Weighted Sum (Slope is 80% important, Curvature 20%) susceptibility = (0.8 * norm_slope) + (0.2 * (1 - norm_curv)) # 1-curv because concave is safer for stability usually, but accumulates water. # Let's stick to Slope as primary driver for this simple example. susceptibility = 0.9 * norm_slope + 0.1 * np.random.rand(ROWS, COLS) # Adding slight noise return susceptibility, slope # ========================================== # 3. RAINFALL NOWCASTING (The Dynamic Layer) # ========================================== def get_rainfall_threshold(duration_hours): """ Returns the critical Intensity (mm/hr) for a given duration. I = 14.82 * D^-0.39 """ return ALPHA * (duration_hours ** BETA) def simulate_rainfall_event(timestep): """ Simulates a moving storm cell over the grid. """ # Create a storm center that moves across the map center_x = 30 + timestep * 2 center_y = 50 # Intensity increases over time (storm peak) peak_intensity = 5 + timestep * 1.5 # Gaussian storm blob storm = peak_intensity * np.exp(-((x_grid - center_x)**2 + (y_grid - center_y)**2) / (2 * 20**2)) return storm # ========================================== # 4. MAIN NOWCASTING LOOP # ========================================== # Pre-calculate static susceptibility sus_map, slope_map = build_susceptibility_map(elevation) # Initialize Plot fig, axes = plt.subplots(1, 3, figsize=(18, 6)) plt.suptitle("Landslide Nowcasting System", fontsize=16) # Run for a specific timestep (e.g., hour 15 of a storm) current_time = 15 duration = 3 # Rolling 3-hour rainfall accumulation # 1. Get Current Rainfall current_rainfall = simulate_rainfall_event(current_time) # 2. Determine Threshold Exceedance # Calculate the threshold value for the duration threshold_val = get_rainfall_threshold(duration) # Create a Trigger Map: # 0 if rain < threshold # >1 if rain > threshold (scaled by how much it exceeds) # We look at mean intensity over the duration trigger_map = current_rainfall / threshold_val trigger_map[trigger_map < 1.0] = 0.0 # Below threshold = No Trigger trigger_map[trigger_map >= 1.0] = 1.0 # Triggered (Binary) or keep raw value for severity # 3. Calculate Nowcast (Hazard) # Hazard = Susceptibility * Trigger Status nowcast_map = sus_map * trigger_map # ========================================== # 5. VISUALIZATION # ========================================== # Plot 1: Susceptibility ax1 = axes[0] im1 = ax1.imshow(sus_map, cmap='YlOrRd') ax1.set_title("1. Static Susceptibility\n(Slope + Terrain)") plt.colorbar(im1, ax=ax1, label='Probability (0-1)') # Plot 2: Rainfall Intensity vs Threshold ax2 = axes[1] # Visualizing the rain on a log scale to see the blob clearly im2 = ax2.imshow(current_rainfall, cmap='Blues', vmin=0, vmax=50) # Overlay the threshold contour # (In a real app, this would be a contour line where rain == threshold) ax2.contour(current_rainfall, levels=[threshold_val], colors='black', linewidths=2) ax2.set_title(f"2. Rainfall Intensity\n(Black Line = Threshold: {threshold_val:.1f} mm/hr)") plt.colorbar(im2, ax=ax2, label='Intensity (mm/hr)') # Plot 3: Final Nowcast ax3 = axes[2] # Masking low values for clarity nowcast_vis = np.ma.masked_where(nowcast_map < 0.1, nowcast_map) im3 = ax3.imshow(sus_map, cmap='Greys', alpha=0.3) # Background im3 = ax3.imshow(nowcast_vis, cmap='Reds', vmin=0, vmax=1) ax3.set_title("3. Nowcast (Hazard Level)\n(Triggered Areas Only)") plt.colorbar(im3, ax=ax3, label='Hazard Level') plt.tight_layout() plt.show()How to Interpret the Output
- Left Panel (Susceptibility): This map never changes. It highlights the ridges and steep slopes calculated from the DEM. Note that the valley floor is dark (low susceptibility) because it is flat.
- Middle Panel (Rainfall): This is the moving storm. The black contour line represents the Rainfall Threshold. Any pixel inside this black line is receiving rainfall intensity greater than the critical limit ().
- Right Panel (Nowcast): This is the result. It shows zero hazard in flat areas even if heavy rain is falling (because susceptibility is 0). It shows zero hazard on steep slopes if no rain is falling (because trigger is 0). It only shows Red/Orange where a steep slope intersects with the heavy rainfall cell.
Moving from Prototype to Production
To convert this logic into an operational system, implement the following architecture:
1. Data Ingestion (The "Feed")
You need real-time feeds.
- Rainfall: Use satellite data (e.g., NASA GPM / IMERG) or Radar data.
- Antecedent Soil Moisture: Use NASA SMAP or Sentinel-1. Rainfall thresholds fail if the ground is already saturated. In a production model, the formula becomes:
2. Calibration
The constants
ALPHAandBETAin the code are generic. You must calibrate them for your specific region using historical landslide inventories (checking which rainfall amounts actually caused failures in the past).3. The Threshold Logic (ID Curve)
In the code, I used a simple ID curve. For higher accuracy, use a Cumulative Rainfall Threshold.
- Example: If cumulative rain over 24 hours > 100mm, Trigger = True.
4. Dissemination
Output the final
nowcast_mapas a GeoTIFF and serve it via a WMS (Web Map Service) to a dashboard (GIS/Web).