adevs
Classes | Public Member Functions | List of all members
adevs::Simulator< X, T > Class Template Reference

#include <adevs_simulator.h>

Inheritance diagram for adevs::Simulator< X, T >:
adevs::AbstractSimulator< X, T >

Public Member Functions

 Simulator (Devs< X, T > *model)
 
nextEventTime ()
 
void execNextEvent ()
 Execute the simulation cycle at time nextEventTime()
 
void execUntil (T tend)
 Execute until nextEventTime() > tend.
 
void computeNextOutput ()
 
void computeNextState (Bag< Event< X, T > > &input, T t)
 
 ~Simulator ()
 
void addModel (Atomic< X, T > *model)
 
 Simulator (LogicalProcess< X, T > *lp)
 
void beginLookahead ()
 
void endLookahead ()
 
void lookNextEvent ()
 
- Public Member Functions inherited from adevs::AbstractSimulator< X, T >
void addEventListener (EventListener< X, T > *l)
 
void removeEventListener (EventListener< X, T > *l)
 Remove an event listener.
 
virtual ~AbstractSimulator ()
 Destructor leaves the model intact.
 
void notify_output_listeners (Devs< X, T > *model, const X &value, T t)
 Notify listeners of an output event.
 
void notify_state_listeners (Atomic< X, T > *model, T t)
 Notify listeners of a state change.
 

Detailed Description

template<class X, class T>
class adevs::Simulator< X, T >

This Simulator class implements the DEVS simulation algorithm. Its methods throw adevs::exception objects if any of the DEVS model constraints are violated (i.e., a negative time advance or a model attempting to send an input directly to itself).

Constructor & Destructor Documentation

template<class X, class T>
adevs::Simulator< X, T >::Simulator ( Devs< X, T > *  model)
inline

Create a simulator for a model. The simulator constructor will fail and throw an adevs::exception if the time advance of any component atomic model is less than zero.

Parameters
modelThe model to simulate
template<class X , class T >
adevs::Simulator< X, T >::~Simulator ( )

Deletes the simulator, but leaves the model intact. The model must exist when the simulator is deleted. Delete the model only after the Simulator is deleted.

References adevs::Bag< T >::begin(), and adevs::Bag< T >::end().

template<class X, class T>
adevs::Simulator< X, T >::Simulator ( LogicalProcess< X, T > *  lp)

Create a simulator that will be used by an LP as part of a parallel simulation. This method is used by the parallel simulator.

Member Function Documentation

template<class X, class T>
void adevs::Simulator< X, T >::addModel ( Atomic< X, T > *  model)
inline

Assign a model to the simulator. This has the same effect as passing the model to the constructor.

template<class X , class T >
void adevs::Simulator< X, T >::beginLookahead ( )

Call this method to indicate that all subsequent calls are part of a lookahead calculation. Lookahead calculations will cause the atomic models involved to save their states at the point that the lookahead calculation was begun. These states are restored when the lookahead calculation ends.

Lookahead calculations are done with the lookNextEvent method, which may throw a lookahead_impossible_exception. This occurs when the simulator calculate a new state for an atomic model whose beginLookahead method is unsupported.

template<class X , class T >
void adevs::Simulator< X, T >::computeNextOutput ( )

Compute the output values of the imminent component models if these values have not already been computed. This will notify registered EventListeners as the outputs are produced.

Referenced by adevs::Simulator< InternalType, T >::execNextEvent().

template<class X, class T>
void adevs::Simulator< X, T >::computeNextState ( Bag< Event< X, T > > &  input,
t 
)

Apply the bag of inputs at time t and then compute the next model states. Requires that lastEventTime() <= t <= nextEventTime(). This, in effect, implements the state transition function of the resultant model.

Parameters
inputA bag of (input target,value) pairs
tThe time at which the input takes effect

Compute model transitions and build up the prev (pre-transition) and next (post-transition) component sets. These sets are built up from only the models that have the model_transition function evaluated.

The model adds are processed first. This is done so that, if any of the added models are components something that was removed at a higher level, then the models will not have been deleted when trying to schedule them.

If this model has children, then remove them from the deletion set. This will avoid double delete problems.

References adevs::Bag< T >::begin(), adevs::Bag< T >::end(), adevs::Devs< X, T >::getParent(), adevs::Devs< X, T >::model_transition(), adevs::set_assign_diff(), adevs::Atomic< X, T >::typeIsAtomic(), and adevs::Devs< X, T >::typeIsNetwork().

Referenced by adevs::Simulator< InternalType, T >::execNextEvent().

template<class X , class T >
void adevs::Simulator< X, T >::endLookahead ( )

This call terminates a lookahead calculation and restores the models to their states when beginLookahead was called.

References adevs::Bag< T >::begin(), and adevs::Bag< T >::end().

template<class X , class T >
void adevs::Simulator< X, T >::lookNextEvent ( )

Look at future events assuming a input trajector with only non-events. This has the same effect as calling execNextEvent but the simulator can be restored to its prior state by calling endLookahead.

template<class X, class T>
T adevs::Simulator< X, T >::nextEventTime ( )
inlinevirtual

Get the model's next event time

Returns
The absolute time of the next event

Implements adevs::AbstractSimulator< X, T >.

Referenced by adevs::Simulator< InternalType, T >::execUntil().


The documentation for this class was generated from the following files: