Internal transition function (δint), called when the model should be activated, e.g when #elapsed reaches #time_advance

Override this method to implement the appropriate behavior of your model.

Example:

def internal_transition
  self.phase = :steady
end

The output function (λ)

Override this method to implement the appropriate behavior of your model. See #post to send values to output ports.

Example:

def output
  post(42, :output)
end

Time advance function (ta), called after each transition to give a chance to self to be active.

Override this method to implement the appropriate behavior of your model.

Example:

def time_advance
  Quartz.infinity
end

The state_initialize macro defines an initialization block that is automatically included in all constructor defined in the included type and its subclasses.

It can be used to initialize state variables declared using the state_var macro.

Example :

class MyModel < AtomicModel
  state_var x : Int32
  state_var y : Int32

  state_initialize do
    @x = 0
    @y = 0
  end

The state_var macro defines a state variable of a model. Its primary usage is to identify which instance variables are part of the state of the model.

This allows to automatically define state retrieval methods, state serialization/deserialization methods and state initialization methods which will be used for simulation distribution purposes, for constructing model hierarchies from a file, or to allow changing initial state for model parameter exploration.

Usage

state_var must receive a type declaration which will be used to declare instance variables :

class MyModel < AtomicModel
  state_var x : Int32
  state_var y : Int32
end

Default values can be passed using the type declaration notation or through a block :

class MyModel < AtomicModel
  state_var x : Int32 = 0
  state_var y : Int32 = 0
  state_var z : Int32 { (rand * 100 + 1).to_i32 }
  state_var ß : Int32 { x * 42 }
end

Note from previous example that the initialization block of ß is allowed to reference the value of another state variable.

If default values are omitted, a chance is given to initialize those state variables through the state_initialize macro :

class MyModel < AtomicModel
  state_var x : Int32
  state_var y : Int32

  state_initialize do
    @x = 0
    @y = 0
  end
end

Multiple calls to state_var for the same variable is allowed. Previous properties are inherited and overlapping propertings are overwritten. The following example :

class MyModel < AtomicModel
  state_var sigma : Duration = Duration::INFINITY
  state_var sigma { Duration.infinity(self.class.precision) }
end

Defines the sigma state variable as a Duration type with a default value determined by the initialization block.

This is particularly useful in case a model inherits another model :

class BaseModel < AtomicModel
  state_var sigma : Duration = Duration::INFINITY
end

class MyModel < BaseModel
  state_var sigma = Quartz.duration(85, milli)
end

All initialize methods defined in the included type and its subclasses will be redefined to include the body of the given block. Note that the block content is always included at the top of the method definition. Thus, if you define :

class MyModel < AtomicModel
  state_var x : Int32
  state_var y : Int32

  state_initialize do
    @x = 0
    @y = 0
  end

  def initialize(name)
    super(name)
    add_input_port("in")
  end
end

The constructor will be automatically redefined to :

  def initialize(name)
    @x = 0
    @y = 0
    super(name)
    add_input_port("in")
  end
end

Options

Along with the type declaration, state_var also accept a hash or named tuple literal whose keys corresponds to the following options :

• visibility: used to restrict the visibility of the getter that is defined for this state variable (:private or :protected). No restriction is applied by default (public) :

state_var hidden : Bool = true, visibility: :private

• converter: specify an alternate type for parsing and generation. Examples of converters are Time::Format and Time::EpochConverter for Time.

state_var timestamp : Time, converter: Time::EpochConverter

Code generation

A getter is generated for each declared state variable, whose visibility can be restricted through the visibility option.

When the type definition is complete, a struct wrapping all state variables is defined for convenience.