abstract class Quartz::AtomicModel

Overview

This class represent a PDEVS atomic model.

Included Modules

Direct Known Subclasses

Defined in:

quartz/atomic.cr

Constant Summary

STATE_CHECKS = {state_complete: false}

Constructors

Class Method Summary

Instance Method Summary

Macro Summary

Instance methods inherited from module Quartz::Verifiable

clear_errors clear_errors, errors errors, invalid?(context : Symbol? = nil) : Bool invalid?, valid?(context : Symbol? = nil) : Bool valid?

Instance methods inherited from module Quartz::Observable

add_observer(observer : Observer) add_observer, count_observers count_observers, delete_observer(observer : Observer) : Bool delete_observer, notify_observers(info = nil) notify_observers

Instance methods inherited from module Quartz::Coupleable

add_input_port(name) add_input_port, add_output_port(name) add_output_port, add_port(port : InputPort)
add_port(port : OutputPort)
add_port
, each_input_port(&) each_input_port, each_output_port(&) each_output_port, input_port(name : Name) : InputPort input_port, input_port?(name : Name) : InputPort? input_port?, input_port_list : Array(InputPort) input_port_list, input_port_names input_port_names, output_port(name : Name) : OutputPort output_port, output_port?(name : Name) : OutputPort? output_port?, output_port_list : Array(OutputPort) output_port_list, output_port_names output_port_names, remove_input_port(name) remove_input_port, remove_output_port(name) remove_output_port, remove_port(port : OutputPort)
remove_port(port : InputPort)
remove_port

Instance methods inherited from module Quartz::Stateful

initial_state initial_state, initial_state=(state : Quartz::State) initial_state=, state state, state=(state : Quartz::State) state=

Instance methods inherited from class Quartz::Model

accept(visitor : Visitor) accept, accept_children(visitor) accept_children, after_initialize after_initialize, inspect(io) inspect, name : Name name, name=(name : Name) name=, processor : Processor? processor, processor=(processor : Processor?) processor=, processor? : Processor | Nil? processor?, to_s(io) to_s

Constructor methods inherited from class Quartz::Model

new(name : Name) new

Instance methods inherited from class Reference

==(other : Quartz::Any) ==

Instance methods inherited from class Object

===(other : Quartz::Any) ===

Constructor Detail

def self.new(name, state) #

[View source]
def self.new(name) #

[View source]

Class Method Detail

def self.check(*attributes : Symbol, **kwargs) #

[View source]
def self.check_with(klass : Verifiers::RuntimeValidator.class, **kwargs) #

Passes the model off to the class or classes specified and allows them to add errors based on more complex conditions.

class MyModel
  include Quartz::Verifiable
  check_with MyVerifier
end

class MyVerifier < Quartz::Verifiers::RuntimeChecker
  def validate(model)
    if some_test
      model.errors.add(:phase, "This model state is invalid")
    end
  end

  # ...
end

[View source]
def self.check_with(klass : Verifiers::EachChecker.class, *attributes : Symbol, **kwargs) #

Passes the model off to the class or classes specified and allows them to add errors based on more complex conditions.

class MyModel
  include Quartz::Verifiable
  check_with MyVerifier
end

class MyVerifier < Quartz::Verifiers::EachChecker
  def check_each(model, attribute, value)
    if some_test
      model.errors.add(attribute, "This model attribute is invalid")
    end
  end

  # ...
end

[View source]
def self.clear_verifiers #

[View source]
def self.precision_level : Scale #

The precision associated with the model.


[View source]
def self.precision_level=(precision_level : Scale) #

The precision associated with the model.


[View source]
def self.verifiers #

[View source]

Instance Method Detail

def confluent_transition(messages : Hash(InputPort, Array(Any))) #

This is the default definition of the confluent transition. Here the internal transition is allowed to occur and this is followed by the effect of the external transition on the resulting state.

Override this method to obtain a different behavior. For example, the opposite order of effects (external transition before internal transition). Of course you can override without reference to the other transitions.


[View source]
def elapsed : Duration #

This attribute is updated automatically along simulation and represents the elapsed time since the last transition.


[View source]
def elapsed=(elapsed : Duration) #

This attribute is updated automatically along simulation and represents the elapsed time since the last transition.


[View source]
abstract def external_transition(messages : Hash(InputPort, Array(Any))) #

The external transition function (δext)

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

Example:

def external_transition(messages)
  messages.each { |port, value|
    puts "#{port} => #{value}"
  }
end

[View source]
def inspect(io) #

[View source]
abstract def internal_transition #

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

[View source]
def model_precision : Scale #

Returns the precision associated with the class.


[View source]
abstract def output #

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

[View source]
abstract def time_advance : Duration #

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

[View source]

Macro Detail

macro input(*names) #

Defines default input ports for each of the given arguments. Those default input ports will be available in all instances, including instances of subclasses (meaning that ports are inherited).

Writing:

class MyModel < AtomicModel
  input port_name
end

Is the same as writing:

class MyModel < AtomicModel
  def initialize(name)
    super(name)
    add_input_port :port_name
  end
end

The arguments can be string literals, symbol literals or plain names. However, they will be converted to symbol literals when the model is instantiated.

class MyModel < AtomicModel
  input :in1, "in2", in3
end

[View source]
macro output(*names) #

Defines default output ports for each of the given arguments. Those default output ports will be available in all instances, including instances of subclasses (meaning that ports are inherited).

Writing:

class MyModel < AtomicModel
  output port_name
end

Is the same as writing:

class MyModel < AtomicModel
  def initialize(name)
    super(name)
    add_output_port :port_name
  end
end

The arguments can be string literals, symbol literals or plain names. However, they will be converted to symbols literals when the model is instantiated.

class MyModel < AtomicModel
  output :out1, "out2", out3
end

[View source]