{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# FARSITE Single-Step Demo\n", "\n", "Fully self-contained single FARSITE simulation step.\n", "No outputs from other notebooks are required.\n", "\n", "**Steps:**\n", "1. Define fire parameters\n", "2. Fetch perimeters from WIFIRE\n", "3. Download LANDFIRE + generate `landscape.lcp` (skipped if already exists)\n", "4. Fetch weather from WIFIRE\n", "5. Run FARSITE (t=0 → t=1)\n", "6. Compare prediction vs observed\n", "\n", "**Prerequisites:** `TestFARSITE`, `lcpmake`, and `install_packages.sh` must be executable:\n", "```bash\n", "chmod +x TestFARSITE lcpmake install_packages.sh\n", "```" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "!./install_packages.sh" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Setup" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Imports OK\n", "Working directory: /home/jovyan/work/FARSITE_demo\n" ] } ], "source": [ "import os\n", "import sys\n", "import json\n", "import time\n", "import zipfile\n", "import io\n", "import subprocess\n", "import warnings\n", "import numpy as np\n", "import pandas as pd\n", "import geopandas as gpd\n", "import requests\n", "import matplotlib.pyplot as plt\n", "from matplotlib.patches import Patch\n", "from pathlib import Path\n", "from shapely.geometry import Point, Polygon, MultiPolygon\n", "from shapely.validation import make_valid\n", "from osgeo import gdal, osr\n", "\n", "gdal.UseExceptions()\n", "osr.UseExceptions()\n", "\n", "# Ensure working directory is the notebook directory\n", "os.chdir(Path(os.path.abspath('')))\n", "\n", "from farsite import forward_pass_farsite, DEFAULT_DIST_RES, DEFAULT_PERIM_RES\n", "\n", "print('Imports OK')\n", "print(f'Working directory: {Path.cwd()}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Define Fire Parameters" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fire: Border 2 Synthetic\n", "LCP: landscape.lcp\n", "Dist/Perim res: 150/150 m\n" ] } ], "source": [ "FIRE_NAME = 'Border 2 Synthetic'\n", "GEOSERVER_LAYER = 'WIFIRE:synthetic_fire_perimeters'\n", "IGNITION_LAT = 32.61 # WGS84 — used for LANDFIRE download area\n", "IGNITION_LON = -116.88\n", "RADIUS_KM = 10 # LANDFIRE download radius (km)\n", "LANDFIRE_EMAIL = 'h7ahmed@ucsd.edu' # ← change this\n", "LCP_PATH = Path('landscape.lcp')\n", "DIST_RES = DEFAULT_DIST_RES # meters\n", "PERIM_RES = DEFAULT_PERIM_RES # meters\n", "\n", "print(f'Fire: {FIRE_NAME}')\n", "print(f'LCP: {LCP_PATH}')\n", "print(f'Dist/Perim res: {DIST_RES}/{PERIM_RES} m')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Fetch Fire Perimeters" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def fetch_fire_perimeters(fire_name, geoserver_layer, verbose=True):\n", " \"\"\"Fetch fire perimeters ingested into WIFIRE Firemap WFS from FIRIS, sorted oldest to newest.\"\"\"\n", " params = {\n", " 'SERVICE': 'WFS',\n", " 'VERSION': '2.0.0',\n", " 'REQUEST': 'GetFeature',\n", " 'TYPENAMES': geoserver_layer,\n", " 'CQL_FILTER': f\"fire_name = '{fire_name}'\",\n", " 'OUTPUTFORMAT': 'application/json',\n", " 'SRSNAME': 'EPSG:4326',\n", " }\n", " if verbose:\n", " print(f\"Fetching perimeters for '{fire_name}'...\")\n", " resp = requests.get('https://firemap.sdsc.edu/geoserver/wfs', params=params, timeout=30)\n", " resp.raise_for_status()\n", " features = resp.json().get('features', [])\n", " if not features:\n", " raise ValueError(f\"No perimeters found for '{fire_name}'\")\n", "\n", " gdf = gpd.GeoDataFrame.from_features(features, crs='EPSG:4326')\n", " gdf['datetime'] = pd.to_datetime(gdf['perimeter_timestamp'].str.rstrip('Z'))\n", "\n", " # MultiPolygon -> largest polygon\n", " def largest_poly(geom):\n", " if isinstance(geom, MultiPolygon):\n", " return max(geom.geoms, key=lambda g: g.area)\n", " return geom\n", " gdf['geometry'] = gdf['geometry'].apply(largest_poly)\n", " gdf = gdf.sort_values('datetime').reset_index(drop=True)\n", " gdf = gdf.to_crs('EPSG:5070')\n", "\n", " if verbose:\n", " print(f' Retrieved {len(gdf)} perimeters:')\n", " for i, row in gdf.iterrows():\n", " print(f' [{i}] {row[\"datetime\"]} — {row.geometry.area / 1e6:.2f} km²')\n", " return gdf" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fetching perimeters for 'Border 2 Synthetic'...\n", " Retrieved 13 perimeters:\n", " [0] 2025-01-24 13:00:00 — 0.04 km²\n", " [1] 2025-01-24 14:00:00 — 0.38 km²\n", " [2] 2025-01-24 15:00:00 — 0.94 km²\n", " [3] 2025-01-24 16:00:00 — 2.03 km²\n", " [4] 2025-01-24 17:00:00 — 3.49 km²\n", " [5] 2025-01-24 18:00:00 — 5.74 km²\n", " [6] 2025-01-24 19:00:00 — 9.00 km²\n", " [7] 2025-01-24 20:00:00 — 13.72 km²\n", " [8] 2025-01-24 21:00:00 — 21.99 km²\n", " [9] 2025-01-24 22:00:00 — 31.39 km²\n", " [10] 2025-01-24 23:00:00 — 39.84 km²\n", " [11] 2025-01-25 00:00:00 — 49.62 km²\n", " [12] 2025-01-25 01:00:00 — 55.94 km²\n", "\n", "Ignition (t=0): 2025-01-24 13:00:00 — 0.040 km²\n", "Observed (t=1): 2025-01-24 14:00:00 — 0.376 km²\n", "Interval: 0 days 01:00:00\n", "Weather loc: (32.5959, -116.8571)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_385/1093134951.py:18: UserWarning: Geometry is in a geographic CRS. Results from 'centroid' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", "\n", " centroid_wgs84 = gpd.GeoSeries([initial_poly], crs='EPSG:5070').to_crs('EPSG:4326').centroid.iloc[0]\n" ] } ], "source": [ "perimeters_gdf = fetch_fire_perimeters(FIRE_NAME, GEOSERVER_LAYER)\n", "\n", "if len(perimeters_gdf) < 2:\n", " raise ValueError('Need at least 2 perimeters')\n", "\n", "# t=0: used as FARSITE ignition input\n", "# t=1: used as ground truth for comparison\n", "t0_row = perimeters_gdf.iloc[0]\n", "t1_row = perimeters_gdf.iloc[1]\n", "\n", "initial_poly = t0_row.geometry\n", "observed_poly = t1_row.geometry\n", "T0 = pd.Timestamp(t0_row['datetime'])\n", "T1 = pd.Timestamp(t1_row['datetime'])\n", "DT = T1 - T0\n", "\n", "# Weather query location = centroid of first perimeter in WGS84\n", "centroid_wgs84 = gpd.GeoSeries([initial_poly], crs='EPSG:5070').to_crs('EPSG:4326').centroid.iloc[0]\n", "WX_LAT = centroid_wgs84.y\n", "WX_LON = centroid_wgs84.x\n", "\n", "print(f'\\nIgnition (t=0): {T0} — {initial_poly.area / 1e6:.3f} km²')\n", "print(f'Observed (t=1): {T1} — {observed_poly.area / 1e6:.3f} km²')\n", "print(f'Interval: {DT}')\n", "print(f'Weather loc: ({WX_LAT:.4f}, {WX_LON:.4f})')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Download LANDFIRE + Generate Landscape File\n", "Skipped automatically if `landscape.lcp` already exists." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def download_landfire_data(poly, output_dir, email, verbose=True):\n", " \"\"\"\n", " Download LANDFIRE raster data for the bounding box of a polygon.\n", " poly should be in EPSG:4326.\n", " Returns dict of paths to per-layer ASCII rasters.\n", " \"\"\"\n", " output_dir = Path(output_dir)\n", " output_dir.mkdir(exist_ok=True, parents=True)\n", "\n", " # Buffer slightly so the domain is larger than the ignition point\n", " buffered = poly.buffer(0.5, cap_style='flat', join_style='bevel')\n", " minx, miny, maxx, maxy = buffered.bounds\n", "\n", " if verbose:\n", " print(f'Submitting LANDFIRE request...')\n", " print(f' Bounding box: [{minx:.4f}, {miny:.4f}, {maxx:.4f}, {maxy:.4f}]')\n", "\n", " params = {\n", " 'Email': email,\n", " 'Layer_List': '250CBD;250CBH;250CC;250CH;250FBFM40;ASP2020;ELEV2020;SLPP2020',\n", " 'Area_of_Interest': f'{minx} {miny} {maxx} {maxy}',\n", " 'Output_Projection': '5070',\n", " 'Resample_Resolution': '90',\n", " 'Priority_Code': 'K3LS9F',\n", " }\n", " resp = requests.get('https://lfps.usgs.gov/api/job/submit', params=params, timeout=30)\n", " resp.raise_for_status()\n", " job_id = resp.json()['jobId']\n", " if verbose:\n", " print(f' Job ID: {job_id}')\n", "\n", " t_start = time.time()\n", " while True:\n", " s = requests.get(f'https://lfps.usgs.gov/api/job/status?JobId={job_id}', timeout=30).json()\n", " status = s.get('status', '').lower()\n", " if verbose:\n", " print(f' [{int(time.time()-t_start)}s] {status}')\n", " if status == 'succeeded':\n", " download_url = s['outputFile']\n", " break\n", " elif status in ('failed', 'canceled'):\n", " raise RuntimeError(f'LANDFIRE job {status}')\n", " time.sleep(10)\n", "\n", " zip_resp = requests.get(download_url, stream=True, timeout=60)\n", " zip_resp.raise_for_status()\n", " with zipfile.ZipFile(io.BytesIO(zip_resp.content)) as zf:\n", " zf.extractall(output_dir)\n", "\n", " multi_tif = next(output_dir.glob('*.tif'))\n", " layer_names = ['250CBD','250CBH','250CC','250CH','250FBFM40','ASP2020','ELEV2020','SLPP2020']\n", " with warnings.catch_warnings():\n", " warnings.simplefilter('ignore')\n", " for band_idx, name in enumerate(layer_names, start=1):\n", " gdal.Translate(str(output_dir / f'{name}.asc'), str(multi_tif),\n", " format='AAIGrid', bandList=[band_idx])\n", " if verbose:\n", " print(f' ✓ {name}.asc')\n", "\n", " return {\n", " 'elevation': output_dir / 'ELEV2020.asc',\n", " 'slope': output_dir / 'SLPP2020.asc',\n", " 'aspect': output_dir / 'ASP2020.asc',\n", " 'fuel': output_dir / '250FBFM40.asc',\n", " 'canopy_cover': output_dir / '250CC.asc',\n", " 'canopy_height': output_dir / '250CH.asc',\n", " 'canopy_base': output_dir / '250CBH.asc',\n", " 'canopy_density': output_dir / '250CBD.asc',\n", " }\n", "\n", "\n", "def generate_lcp_from_rasters(output_path, rasters, latitude, verbose=True):\n", " \"\"\"Run lcpmake to build a FARSITE landscape (.lcp) file from ASCII rasters.\"\"\"\n", " lcpmake = Path(os.path.abspath('lcpmake'))\n", " if not lcpmake.exists():\n", " raise FileNotFoundError(f'lcpmake not found at {lcpmake}')\n", "\n", " output_path = Path(output_path)\n", " cmd = [\n", " str(lcpmake),\n", " '-latitude', str(latitude),\n", " '-landscape', str(output_path.with_suffix('')),\n", " '-elevation', str(rasters['elevation']),\n", " '-slope', str(rasters['slope']),\n", " '-aspect', str(rasters['aspect']),\n", " '-fuel', str(rasters['fuel']),\n", " '-cover', str(rasters['canopy_cover']),\n", " '-height', str(rasters['canopy_height']),\n", " '-base', str(rasters['canopy_base']),\n", " '-density', str(rasters['canopy_density']),\n", " '-fb40',\n", " ]\n", " if verbose:\n", " print('Running lcpmake...')\n", " result = subprocess.run(cmd, capture_output=True, text=True)\n", " if result.returncode != 0:\n", " raise RuntimeError(f'lcpmake failed:\\n{result.stderr}')\n", " lcp = output_path.with_suffix('.lcp')\n", " if not lcp.exists():\n", " raise RuntimeError('lcpmake ran but .lcp was not created')\n", " if verbose:\n", " print(f' ✓ {lcp} ({lcp.stat().st_size / 1024:.1f} KB)')\n", " return lcp" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✓ Using existing landscape file: landscape.lcp (2896.1 KB)\n", "LCP ready: landscape.lcp\n" ] } ], "source": [ "if LCP_PATH.exists():\n", " print(f'✓ Using existing landscape file: {LCP_PATH} ({LCP_PATH.stat().st_size / 1024:.1f} KB)')\n", "else:\n", " print('Landscape file not found — downloading LANDFIRE data...')\n", "\n", " # Build a bounding polygon in WGS84 around the ignition point\n", " ignition_pt = Point(IGNITION_LON, IGNITION_LAT)\n", " pt_gdf = gpd.GeoSeries([ignition_pt], crs='EPSG:4326')\n", " ignition_poly_wgs84 = pt_gdf.to_crs(pt_gdf.estimate_utm_crs()) \\\n", " .buffer(RADIUS_KM * 1000) \\\n", " .to_crs('EPSG:4326').iloc[0]\n", "\n", " rasters = download_landfire_data(\n", " poly=ignition_poly_wgs84,\n", " output_dir=Path('data') / 'landfire',\n", " email=LANDFIRE_EMAIL,\n", " )\n", " LCP_PATH = generate_lcp_from_rasters(\n", " output_path=LCP_PATH,\n", " rasters=rasters,\n", " latitude=IGNITION_LAT,\n", " )\n", "\n", "print(f'LCP ready: {LCP_PATH}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Fetch Weather" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def fetch_weather(lat, lon, start_dt, end_dt, verbose=True):\n", " \"\"\"\n", " Fetch mean wind speed and direction from WIFIRE Firemap pylaski API.\n", " Returns dict with 'windspeed' and 'winddirection'.\n", " \"\"\"\n", " start_str = pd.Timestamp(start_dt).strftime('%Y-%m-%dT%H:%M:%S')\n", " end_str = pd.Timestamp(end_dt).strftime('%Y-%m-%dT%H:%M:%S')\n", "\n", " timestamp = int(time.time() * 1000)\n", " params = {\n", " 'selection': 'closestTo',\n", " 'lat': str(lat),\n", " 'lon': str(lon),\n", " 'observable': ['wind_speed', 'wind_direction'],\n", " 'from': start_str,\n", " 'to': end_str,\n", " 'callback': 'wxData',\n", " '_': str(timestamp),\n", " }\n", " if verbose:\n", " print(f' Querying weather: {start_str} to {end_str}')\n", " try:\n", " resp = requests.get('https://firemap.sdsc.edu/pylaski/stations/data',\n", " params=params, timeout=15)\n", " resp.raise_for_status()\n", " text = resp.text.strip()\n", " if text.startswith('wxData(') and text.endswith(')'):\n", " text = text[len('wxData('):-1]\n", " data = json.loads(text)\n", " station = data['features'][0]['properties']\n", " ws_list = station.get('wind_speed', [])\n", " wd_list = station.get('wind_direction', [])\n", " ws = float(np.mean(ws_list)) if ws_list else 5.0\n", " wd = float(np.mean(wd_list)) if wd_list else 270.0\n", " if verbose:\n", " print(f' Wind: {ws:.1f} mph @ {wd:.0f}°')\n", " return {'windspeed': ws, 'winddirection': wd}\n", " except Exception as e:\n", " if verbose:\n", " print(f' ⚠ Weather fetch failed ({e}), using defaults: 5 mph @ 270°')\n", " return {'windspeed': 5.0, 'winddirection': 270.0}" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Querying weather: 2025-01-24T13:00:00 to 2025-01-24T14:00:00\n", " Wind: 8.8 mph @ 87°\n", "Wind speed: 8.8 mph\n", "Wind direction: 87°\n" ] } ], "source": [ "weather = fetch_weather(WX_LAT, WX_LON, T0, T1)\n", "print(f'Wind speed: {weather[\"windspeed\"]:.1f} mph')\n", "print(f'Wind direction: {weather[\"winddirection\"]:.0f}°')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 6. Run FARSITE" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running FARSITE...\n", " Period: 2025-01-24 13:00:00 → 2025-01-24 14:00:00 (0 days 01:00:00)\n", " Wind: 8 mph @ 87°\n", " Input: 0.040 km²\n", "\n", "✓ FARSITE succeeded\n", " Predicted area: 0.300 km²\n", " Observed area: 0.376 km²\n" ] } ], "source": [ "farsite_params = {\n", " 'windspeed': int(weather['windspeed']),\n", " 'winddirection': int(weather['winddirection']),\n", " 'dt': DT.to_pytimedelta(),\n", "}\n", "\n", "print('Running FARSITE...')\n", "print(f' Period: {T0} → {T1} ({DT})')\n", "print(f' Wind: {farsite_params[\"windspeed\"]} mph @ {farsite_params[\"winddirection\"]}°')\n", "print(f' Input: {initial_poly.area / 1e6:.3f} km²')\n", "\n", "predicted_poly = forward_pass_farsite(\n", " poly=initial_poly,\n", " params=farsite_params,\n", " start_time=T0.strftime('%Y-%m-%d %H:%M:%S'),\n", " lcppath=str(LCP_PATH),\n", " dist_res=DIST_RES,\n", " perim_res=PERIM_RES,\n", ")\n", "\n", "if predicted_poly is not None:\n", " print(f'\\n✓ FARSITE succeeded')\n", " print(f' Predicted area: {predicted_poly.area / 1e6:.3f} km²')\n", " print(f' Observed area: {observed_poly.area / 1e6:.3f} km²')\n", "else:\n", " print('\\n✗ FARSITE failed — check tmp/logs/')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 7. Compare Prediction vs Observed" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Observed area: 0.376 km²\n", "Predicted area: 0.300 km²\n", "Area error: 20.0%\n", "IoU: 0.457\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Figure saved → farsite_demo_result.png\n" ] } ], "source": [ "if predicted_poly is None:\n", " print('No output to visualize.')\n", "else:\n", " obs = make_valid(observed_poly)\n", " pred = make_valid(predicted_poly)\n", " try:\n", " intersection = obs.intersection(pred).area\n", " union = obs.union(pred).area\n", " except Exception:\n", " obs = obs.buffer(0)\n", " pred = pred.buffer(0)\n", " intersection = obs.intersection(pred).area\n", " union = obs.union(pred).area\n", "\n", " iou = intersection / union if union > 0 else 0.0\n", " area_err_pct = abs(pred.area - obs.area) / obs.area * 100\n", "\n", " print(f'Observed area: {obs.area / 1e6:.3f} km²')\n", " print(f'Predicted area: {pred.area / 1e6:.3f} km²')\n", " print(f'Area error: {area_err_pct:.1f}%')\n", " print(f'IoU: {iou:.3f}')\n", "\n", " try:\n", " import contextily as ctx\n", " use_basemap = True\n", " except ImportError:\n", " use_basemap = False\n", "\n", " fig, ax = plt.subplots(figsize=(10, 10))\n", "\n", " gpd.GeoSeries([pred], crs='EPSG:5070').to_crs('EPSG:3857').boundary.plot(\n", " ax=ax, color='#e74c3c', linewidth=2.5)\n", " gpd.GeoSeries([obs], crs='EPSG:5070').to_crs('EPSG:3857').boundary.plot(\n", " ax=ax, color='#3498db', linewidth=2.5)\n", "\n", " if use_basemap:\n", " try:\n", " ctx.add_basemap(ax, source=ctx.providers.OpenStreetMap.Mapnik, crs='EPSG:3857')\n", " except Exception as e:\n", " print(f'Basemap skipped: {e}')\n", "\n", " ax.legend(handles=[\n", " Patch(facecolor='none', edgecolor='#e74c3c',\n", " label=f'FARSITE prediction {pred.area/1e6:.3f} km²'),\n", " Patch(facecolor='none', edgecolor='#3498db',\n", " label=f'Observed {obs.area/1e6:.3f} km²'),\n", " ], loc='upper left', fontsize=10)\n", "\n", " ax.set_title(\n", " f'{FIRE_NAME}\\n'\n", " f'{T0.strftime(\"%Y-%m-%d %H:%M\")} → {T1.strftime(\"%H:%M\")} | '\n", " f'Wind: {farsite_params[\"windspeed\"]} mph @ {farsite_params[\"winddirection\"]}° | '\n", " f'IoU: {iou:.3f} | Area error: {area_err_pct:.1f}%',\n", " fontsize=11\n", " )\n", " ax.set_axis_off()\n", " plt.tight_layout()\n", " plt.savefig('farsite_demo_result.png', dpi=150, bbox_inches='tight')\n", " plt.show()\n", " print('Figure saved → farsite_demo_result.png')" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.10" } }, "nbformat": 4, "nbformat_minor": 4 }