Master's Project: Fuel Model for Urban Wildfires

Existing models are built around wildland environments and do not adequately represent the diverse and complex fuels present in cities and the WUI. My goal is to fill this gap by creating a model that better characterizes urban fire behavior.

An urban fuel model could be used to predict standard fire metrics such as rate of spread, fireline intensity, and flame length in a given geographic area. This information could be used to help communities assess their fire risk by informing where to prioritize fire breaks or controlled burns.

Timeline: Project to be completed before 2026.

Project Plan

• Build a custom fuel model lookup system for urban environments, extending the work of Scott & Burgan 2005.
  • Parameters: fuel load by category (live vs. dead fuels), particle size class, surface-area-to-volume (SAV) ratio, heat content, fuel bed depth, and dead fuel moisture of extinction
  • Wildland fuel model examples from Scott & Burgan 2005:
    
    
    
  
  
• Use machine learning and remote sensing techniques to classify urban environments with custom fuel model.
• Input results into wildfire model in order to test effectiveness (Rothermel 1972 and Byram 1959).

---

Other projects:

---

Eaton Fire Structure Analysis

The Eaton Fire occurred in January 2025 near Altadena, California. The fire destroyed over 9,000 structures, while others in close proximity to the flames remained intact. Our goal for this project was to build a model that predicts whether a structure burned in the 2025 Eaton Fire based on proximity to nearby burned structures and proximity to vegetation. This project was inspired by the study of Knapp et al. (2021), which analyzed housing arrangement and structure loss in the 2018 Camp Fire.

Analysis: Python
Visualization: QGIS


Feature Engineering

Proximity to Burned Structures

Ratio of structures in a radius of 20m that burned:




Ratio of structures in a radius of 50m that burned:





Proximity to Vegetation

Step 1:NDVI Derivation

NDVI (Normalized Difference Vegetation Index) highlights how much near-infrared light and red light are reflected, providing an effective way to distinguish vegetation from its background.



Step 2:Calculate the distance between each structure and an NDVI between 0.3 and 0.8.

• An NDVI between 0.3 and 0.8 tends to represent brush and trees.
• The following animation demonstrates the cells captured in the NDVI range of 0.3 to 0.8.
  

E.g. The minimum distance between a structure polygon and a NDVI cell with a value 0.3-0.8:


• We calculated both the minimum distance for each polygon and the average distance for all points on the polygon. We found the average distance to be a more robust predictor.

Distribution of mean distance between structure and an NDVI between 0.3 and 0.8:




Results

Logistic Regression


60.9% accuracy, and 0.721 F1-score.
Strongest predictor: NDVI minimum distance.

XG Boost


86% accuracy, 0.93 AUC, and 0.86 F1-score.
Strongest predictor: NDVI mean distance.

This project provided an initial look at potential housing and vegetation arrangement factors related to the 2025 Eaton Fire. Future work could expand the analysis by trying different models, incorporating additional distance thresholds, or examining building materials and wind patterns. Additionally, perhaps the same process could be run for a different wildfire.

Mappy

Fall 2020-May 2021, I worked at the Formal Analysis of Interactive Media (FAIM) Lab at Pomona College. I assisted in the development of Mappy, a Rust program which interprets pixel data from emulated Nintendo NES games. Mappy's main feature is to produce game maps (linking together different levels and rooms), I specifically worked on Sprite Blobbing and Avatar Detection features, which involve tracking game sprites and grouping/classifying them based on their movement and relation to user input. In fall 2021, we submitted a paper on Mappy to a small conference called AIIDE (AI and Interactive Digital Entertainment). Not only was the paper accepted, but it also received an award for best paper at the conference.

Click here to view the paper!



Triumvirate Arena

Triumvirate Arena is a battle card game featuring three players: Nate, Chloe, and Grace. Each player type has three signature moves which might increase or decrease your health/mana, and/or do damage to the other player. The goal of this two player game is to reduce the opponent to zero health. This project was part of the spring 2022 Game Engine Programming class at Pomona College.

We wrote Triumvirate Arena in Rust, completely from scratch, without a pre-made game engine (using Bitblt and Vulkan shaders). In our team of 3 (myself, Chloe, and Grace), I worked on gameflow mechanics (health/mana interactions, turn taking); player moves; and creating original music, while my partners worked on other mechanics.



Click here for the Triumvirate Arena repository, in order to see the code and more gameplay examples!




Features:

• Two player turn taking
• Choose player
• Choose move
• Animated health bars
• Fonts + text writing
• Bitblt images
• Original music
• Sound effects for selecting moves, players, etc.
• Main/end screen
• Get info screens for players and moves
• Health and mana tracking (generation and subtraction moves)
• Health and mana requirements for moves

JumpyBall

JumpyBall is a 3D parkour game. The player navigates through levels by jumping across platforms, avoiding the ground, and working their way to the end gem.

We used the Frender game engine (created by Professor Joseph Osborn), which assisted with the 3D rendering. We created the physics, collision system and assets from scratch.

In JumpyBall, I primarily worked on asset creation and the collision system. I created all of the 3D models in Blender and wrote a Python script to create a set of bounding boxes for objects on the map (used for collision system). This project was also part of the spring 2022 Game Engine Programming class at Pomona College.



Click here for the JumpyBall repository!




Features:

• Jumping (double jump)
• Rolling
• Mid air rolling
• Roll while jumping
• Collision
• Bounding boxes for every object in scene, created via Blender Python script
• AABB-Sphere collision
• Camera (mouse responsive out of window)
• Level Switching
• Switch between levels (and beat the game) by collecting gems
• Level restart when player falls
• Modeling
• Made-from-scratch 3d models of ball, landing objects, and world
• Textures
• Cosmetic map textures (ex. lava ground, space sphere)
• Ball texture
• Landing object textures (pillars and cubes)
• Music (original JumpyBall music)


eBay Delivery Prediction Project

During fall 2021, I worked in a team of 5 to create a neural network that can accurately predict the delivery time of items sold on eBay (based on features such as declared handling days, item category, weight, etc.).

• Data cleaning
• Implemented Neural Network in PyTorch
• Implemented gradient boosting model (CatBoost)
Standalone website
Repository


---

LiDAR Paper

As a part of my computer science senior seminar in Fall 2022, I wrote a paper on LiDAR and machine learning. See the abstract below.

(click here to download the full paper)






---