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