Evacu8

Inspiration

The LA wildfires last year affected many of us at Cal Poly. One thing that kept coming up was how messy evacuations got, not because there weren't plans, but because conditions changed faster than the plans could keep up with. Our team members know people who suffered in these wildfires. Roads got cut off, fire jumped in unexpected directions, and people had to make calls on the fly with bad information.

That got us thinking: what if you could simulate an evacuation plan across a range of scenarios before anyone actually has to use it?

What it does

evacu8 is a simulation tool aimed at first responders and planners. You give it an ignition point and some environmental conditions, and it:

Simulates wildfire spread across a grid using a probabilistic model that accounts for wind
Runs Monte Carlo simulations to capture how much fire behavior can vary
Evaluates evacuation routes over a real road network

Instead of giving you one "best route," it gives you:

Route viability scores — e.g. "this route works in 82% of simulated scenarios"
Zone cutoff times — when specific areas become too dangerous

The core idea is moving away from a single, deterministic plan toward one that accounts for uncertainty.

How we built it

The system is mostly backend computation with a lightweight frontend on top.

Simulation engine

We built a grid-based wildfire model in NumPy. Each cell tracks fuel load, burn state, and when it ignited. Spread probability depends on wind speed/direction, fuel, and some randomness per timestep. It's a simplified version of real fire spread dynamics — not physically precise, but fast enough to run interactively and still behaves reasonably under different conditions.

Monte Carlo pipeline

We run simulations per scenario using SciPy for sampling. Wind speed, direction, and spread variability are randomized around realistic values. From those runs, we get burn probability maps, arrival time distributions, and uncertainty bounds on how the fire progresses.

Evacuation modeling

The road network comes from OpenStreetMap data. Each road segment has travel time, a congestion estimate, fire exposure risk, and closure probability. We compare a baseline shortest-path route with an optimized route that minimizes a combined cost across all those factors.

Interface

There's a thin frontend for picking ignition points, tweaking parameters, and viewing the results. The backend is exposed as an API, so the two pieces stay cleanly separated.

Challenges

Realism vs. speed. A proper physics-based fire model is way too slow for interactive use. We had to cut many corners while keeping the behavior plausible enough to be useful.

Making uncertainty useful. 500 simulation runs produce a lot of data. Most of it is noise if you don't summarize it well. Route success percentages and zone cutoff times turned out to be the most practical outputs.

Coupling two hard problems. Fire simulation and route optimization are each tricky on their own. Combining them means dealing with roads that fail partway through a simulation and incomplete information about what's burning where.

Demo stability. We kept external dependencies minimal (just wind data) so the system runs reliably during a live demo.

What we're proud of

It actually runs: this is a working simulation and optimization engine, not just a mockup
Stochastic fire spread is integrated with graph-based evacuation routing
The outputs are practical (route success rates, cutoff times), not just pretty maps
You can re-run it with different assumptions and compare results
It collects a lot of information from different APIs

What we learned

Deterministic plans fall apart fast when conditions are uncertain
Monte Carlo is only helpful if you can turn the output into something a person can act on
Clean abstractions made it possible to split work across the team
The hard part isn't running simulations — it's presenting results in a way that helps someone make a decision