**FIRE SPREAD MODEL**

**Introduction**

This model was developed with a simulation engine for fire spread model.
This simulator can be used to simulate any two dimensional cell space
models.

To begin you have to understand the how this simulation works, you first
have to consider an *n*-by-*n* matrix, or a two dimensional square of
numbers. Each cell in the matrix represents a specific location for the
fire to spread. To further illustrate the content of each cell space in
the matrix you have to consider these **phase**s, and **fuel** which is
will also help determine what happen to the cell.

.

**[PHASES]{.underline}**

**0 -- means the cell is unburning**

**1 -- means the cell is currently burning**

**2 -- means the cell is all burnt out**

[*n*-by-*n* matrix]{.underline}

  -------------- -------------- -------------- -------------- --------------
                                                              

                                                              

                                                              

                                                              

                                                              
  -------------- -------------- -------------- -------------- --------------

**The Simulator Algorithm**

if phase is equal to burning and fuel is greater than 1

then fuel is assigned fuel minus one.

else if phase is equal to burning and fuel is equal to one

then phase is assigned burnt and fuel is assigned 0

else if phase is equal to burnt, do nothing

else if phase is equal to unburning and at-least 2 inputs are burning
and fuel is greater than equal to one, then phase is assigned burning.

if (phase = burning && fuel \> 1)

then fuel = fuel -1

else if (phase = burning && fuel = 1)

then phase = burnt and fuel = 0

else if (phase = burnt)

{

do nothing

}

else if (phase = unburning && atleast 2 inputs are burning && fuel \>=
1)

{

phase = burning

}

else, do nothing

The phases and the fuel levels will be loaded in the initial state from
an input file.

This model needs four inputs for the four neighbors (north, south, east
and west), set of state (which include the three phases and the fuel
level), and output function, a state transition function (where the
simulator algorithm will be placed), run function (which will go through
each cell) and a garbage collector that will clean up the buffer.

Now that the basics are established lets now move on to more details.
After you've drawn out your design you then have to think about a few
things. Lets look at some of the code.

**/\***

**Prevent this header from being included twice in the same file.**

**\*/**

**#ifndef \_\_sim_package_h\_**

**#define \_\_sim_package_h\_**

**/\***

**This is the header file and simulator implementation for a cell
space**

**modeling and simulation package.\*/**

**/\***

**This is an Abstract model class. All cell models should be derived
from this model and implement its pure virtual functions.**

**\*/**

**class model**

**{**

**public:**

**/\***

**Constructor.**

**\*/**

**model()**

**{**

**}**

**/\***

**Virtual destructor.**

**\*/**

**virtual \~model()**

**{**

**}**

**/\***

**Pure virtual state transition function.**

**\*/**

**virtual void state_transition_func(const void\* x) = 0;**

**/\***

**Pure virtual output function.**

**\*/**

**virtual void\* output_func() const = 0;**

**/\***

**Pure virtual garbage collection function. Will be called**

**at the very end of every simulation cycle.**

**\*/**

**virtual void gc_output(void\* garbage) = 0;**

**};**

This simulator class is specialized with a template argument that tells
it what kind of model to simulator.

template \<class mclass\> class simulator

{

public:

/\*

Construct an array of row by col cells. Each cell

has an instance of the template model.

\*/

simulator(int rows, int cols)

{

this-\>rows = rows;

this-\>cols = cols;

/\*

Create a rows x cols array of mclass objects.

\*/

bush = new mclass\*\[rows\];

output_values = new int\*\[rows\];

for (int i = 0; i \< rows; i++)

{

/\*for every row create a column \*/

output_values\[i\] = new int\[cols\];

bush\[i\] = new mclass\[cols\];

}

}

/\*

Destroys the cellspace and all of the models in it.

\*/

simulator::\~simulator()

{

for (int i = 0; i \< rows; i++)

{

delete \[\] bush\[i\];

}

delete \[\] bush;

}

To run the simulation we define a function call *run,* that will run for
each time step.

**[Algorithm of *run* function]{.underline}**

for each time step

compute and print output at each cell

you then have to store the output of each cell in a temp array for it to
be used compute the next state at each cell

for each outputted cell assign the values to input from temp array

end time step

This figure indicates the matrix and its four input neighbors

+---------------------+-------------------------+---------------------+
|                     | N                       |                     |
|                     |                         |                     |
|                     | (x-1,y)                 |                     |
+---------------------+-------------------------+---------------------+
| W                   |                         | E                   |
|                     |                         |                     |
| (x-1,y)             |                         | (x,y+1)             |
+---------------------+-------------------------+---------------------+
|                     | S                       |                     |
|                     |                         |                     |
|                     | (x+1,y)                 |                     |
+---------------------+-------------------------+---------------------+

/\*

Simulate the model for tend time steps.

\*/

void run(int tend)

{

// for each time step

for (int i = 0; i \< tend; i++)

{

// compute and print output at each cell

for (int y = 0; y \< cols; y++)

{

for ( int x = 0; x \< rows; x++)

{

> output_values\[x\]\[y\] = \*((int\*)(bush\[x\]\[y\].output_func()));

cout \<\< output_values\[x\]\[y\];

}

cout \<\< endl;

}

cout \<\< endl;

// compute next state at each cell

for (int x = 1; x \< rows-1; x++)

{

for (int y =1; y \< cols-1; y++)

{

// Assign values to input from output array

input\[0\] = output_values\[x+1\]\[y\];

input\[1\] = output_values\[x-1\]\[y\];

input\[2\] = output_values\[x\]\[y+1\];

input\[3\] = output_values\[x\]\[y-1\];

// compute next states using input
bush\[x\]\[y\].state_transition_func(input);

}

}

// end of timestep

}

}

In the main you have to create a class that will take as argument the
abstract model class and include such functions state transition
function, the output function, and the garbage collection output
function. In the main you would want to create an instance of the
simulator class, and with the instantiated object you have to call the
function run.

Consider my code for my state transition function. It will take in the
four neighboring inputs from the simulator class. Also to check the
condition for at-least two burning inputs you have to create a counter
that will count the amount of inputs that are burning.

void state_transition_func(const void\* x)

{

const int \*burning_input = (const int\*)x;

int burning_counter = 0;

for( int counter = 0; counter \< 4; counter++)

{

if (burning_input\[counter\] == 1)

{

burning_counter++;

}

}

// count number of values in burning_input that are burning

if ((phase == 1) && (fuel \> 1))

{

fuel -= 1;

}

else if ((phase == 1) &&(fuel == 1))

{

phase = 2;

fuel = 0;

}

else if (phase == 2)

{

//do nothing

}

> else if(((phase == 0) && ((burning_counter \> 1 )) && (fuel \>=1)))

{

phase = 1;

}

}