# SimUnit¶

The `SimUnit`

type stores most of the things needed to run a simulation. This includes the filter, policy, cost model, and termination condition. The cost model and termination condition are discussed in more detail later on this page.

A `SimUnit`

has the following fields:

```
type SimUnit
x::Vehicle
f::AbstractFilter
p::Policy
cm::CostModel
tc::TerminationCondition
end
```

Below are the constructors for the `SimUnit`

type. At a minimum, it needs a vehicle, filter, and policy. If no cost model is provided, it defaults to `ConstantCost(1.0)`

. If no termination condition is provided, it defaults to `StepThreshold(10)`

.

```
SimUnit(x, f, p) # default termination and cost
SimUnit(x, f, p, tc) # default cost
SimUnit(x, f, p, tc, cm) # fully defined
```

## Cost Model¶

The abstract `CostModel`

type handles how costs are applied throughout the simulations.
Two cost models are provided:

To define your own cost model, you must extend the abstract `CostModel`

type and implement the `get_action_cost`

function.

```
type CustomCost <: CostModel
# whatever fields you need for get_action_cost
end
function get_action_cost(a::Action, cm::CostModel)
# return a Float64 describing cost
end
```

For an example, let’s examine the `ConstantCost`

model, which applies the same cost at each step.
This cost might represent the time each step takes.
Therefore, a simulated trajectory’s cost would simulate how much time it took.
The `ConstantCost`

model is defined as follows,

```
type ConstantCost <: CostModel
value::Float64
end
function get_action_cost(a::Action, cc::ConstantCost)
return cc.value
end
```

The `MoveAndRotateCost`

is a more complex example.

```
type MoveAndRotateCost <: CostModel
speed::Float64
time_per_rotation::Float64
end
function get_action_cost(a::Action, marc::MoveAndRotateCost)
dx = a[1]
dy = a[2]
dist = sqrt(dx*dx + dy*dy)
return (dist / marc.speed) + marc.time_per_rotation
end
```

## Termination Condition¶

The abstract `TerminationCondition`

type determines when an individual simulation should be terminated.

To define your own termination condition, you must extend the abstract `TerminationCondition`

type and implement the `is_complete`

function.

```
type CustomTC <: TerminationCondition
# whatever fields you need
end
function is_complete(f::AbstractFilter, ctc::CustomTC, step_count::Int)
# return true if termination condition reached, false if not
end
```

The `step_count`

argument is passed in by the thing.
(Clarify if it starts at one or zero.)
You can define the `is_complete`

function for a specific kind of filter if you only plan on using one filter.

The `StepThreshold`

is provided.
It terminates after a specified number of steps has been simulated.

```
type StepThreshold <: TerminationCondition
value::Int
end
function is_complete(f::DF, st::StepThreshold, step_count::Int)
ret_val = false
if step_count >= st.value
ret_val = true
end
return ret_val
end
```

The `MaxNormThreshold`

termination condition is also provided.
The implementation is below

```
type MaxNormThreshold <: TerminationCondition
value::Float64
end
function is_complete(f::DF, mnt::MaxNormThreshold, ::Int)
ret_val = false
if maximum(f.b) > mnt.value
ret_val = true
end
return ret_val
end
```