1. Approach and Techniques for Building Component-based Simulation Models
Bernard P. Zeigler, Ph.D.
Hessam S. Sarjoughian, Ph.D.
Arizona Center for Integrative Modeling and Simulation
(ACIMS)
Arizona State University
University of Arizona
Google: ACIMS
and
Joint Interoperability Test Command (JITC)
Fort Huachuca, AZ

2. Outline Basic principles of M&S from a system-theoretic worldview
Component-based characterization of dynamic systems
Unified framework for discrete and continuous models
Discrete event system specification (DEVS) formalism
Modular, hierarchical model composition
Systems theory support of model reusability and composability
Experimental Frame and model validation
Simulation verification using the concept of abstract simulators
DEVSJAVA, a modular, hierarchical simulation environment
DEVS component-based M&S over network centric middleware

3. M&S Entities and Relations
Device for
executing model
Real World
Simulator
Data: Input/output
relation pairs
modeling
relation
simulation
relation
Each entity is represented
as a dynamic system
Each relation is represented
by a homomorphism or other
equivalence
Model
structure for generating behavior
claimed to represent real world

4. M&S Entities and Relation(cont’d)
Experimental Frame
Real World
Simulator
modeling
relation
simulation
relation
Experimental frame specifies
conditions under which the system
is experimented with and observed
captures modeling objectives
needed for validity, simplification
justifications
Model

5. Dynamic Systems Framework for Continuous and Discrete Models
Simulator:
Numerical
Integrator
DESS model:
dq/dt = a*q +bx
System Specification:
DESS: differential equation
DTSS: discrete time
DEVS: discrete event
Simulator:
Recursive
Algorithm
System
DTSS model:
q(t+1) = a*q(t)+ b*x(t)
System
Simulator:
Event
Processor
DEVS model
time to next event,
state at next event ...

6. Dynamic Systems Framework
for Continuous and Discrete Models (cont’d)

7. Discrete Event Time Segmentsx x 1 X t0 t1 t2 S e y0 Y

8. DEVS Background DEVS = Discrete Event System Specification
Provides formal M&S framework: specification,simulation
Derived from Mathematical dynamical system theory
Supports hierarchical, modular composition
Object oriented implementation
Supports discrete and continuous paradigms
Exploits efficient parallel and distributed simulation techniques
Theory of Modeling and Simulation, 2nd Edition, Academic Press, 2000, Bernard P. Zeigler, Herbert Praehofer, Tag Gon Kim

9. DEVS Hierarchical Modular Composition
Atomic: lowest level model, contains structural dynamics -- model level modularity
Coupled: composed of one or more atomic and/or coupled models
Hierarchical construction
+ coupling

10. DEVS Component-Based Expressability
Coupled Models
Atomic Models
can be
components
in a coupled
model
Partial
Differential
Equations
Ordinary
Differential
Equation
Models
Processing/
Queuing/
Coordinating
Networks,
Collaborations
Physical
Space
Spiking
Neuron
Networks
Spiking Neuron
Models
Processing
Networks
Petri Net
Models
n-Dim
Cell Space
Discrete Time/
StateChart
Models
Stochastic
Models
Cellular
Automata
Quantized
Integrator
Models
Fuzzy Logic
Models
Self Organized
Criticality
Models
Reactive
Agent
Models
Multi
Agent
Systems

11. DEVS Theoretical Properties
Closure Under Coupling
Universality for Discrete Event Systems
Representation of Continuous Systems
quantization integrator approximation
pulse representation of wave equations
Simulator Correctness, Efficiency

12. DEVS Atomic Model
Ports are represented explicitly – there can be any number of input and output ports on which values can be received and sent
The time advance function determines the maximum lifetime in a state
A bag can contain many elements with possibly multiple occurrences of its elements.
Atomic DEVS models can handle bags of inputs and outputs.
The external transition function handles inputs of bags by causing an immediate state change, which also may modify the time advance.
The output function can generate a bag of outputs when the time advance has expired.
The internal transition function is activated immediately after the output function causing an immediate state change, which also may modify the time advance.
The confluent transition function decides the next state in cases of collision between external and internal events.

13. Atomic Model Examples Pulse out start Generator Pulse Generator
time
Pulse Generator
Output
interPulseTime >0
start
passive
active
ta = ∞
Fire-once Neuron
Output
Input
receptive
fire
refract
Firing delay >0
ta = ∞
ta = ∞
external event
Internal event
output event

14. Internal Transition /Output Generation
Generate output
using the
output
function
Time advance
using the
internal
transition
function s
Make a transition s’

15. Response to External Input
Make a transition
using the
external
transition
function
elapsed
time
Time advance

16. Response to Simultaneous External Input and Internal Event
output
input
Generate output
Make a transition
elapsed
time
using the
confluent
transition
function
Time advance

17. DEVS Coupled Model Elements of coupled model: Components
Interconnections
Internal Couplings
External Input Couplings
External Output Couplings

18. Coupling in Action output output internal external time advanceAB B A
Output
port
Input
port
external
State
internal
time advance
output
internal
external
State
time advance
output

19. Coupled Model Example – Neuron net
FireOnce
Neuron 1
Neuron 3
Neuron 2
pulseIn
pulseOut
Neuron 4
Pulse
Generator
FireOnce Neuron Network can compute the shortest path
in a directed graph by mapping distances of edges to equivalent time values.

20. We separated models and simulators – now we bring them together
DEVS
Simulation
Protocol
Single
processor
C++
Java
Distributed
Simulator
DEVS
Simulator
Other
Representation
Real-Time
Simulator
Non
DEVS
The DEVS simulation protocol is the agreement between the DEVS modeler and the implemented simulator

21. DEVS Simulation Protocol Classes
Stand alone atomic models are assigned to
AtomicSimulators
Atomic models as components within coupled models are assigned to
coupledSimulators
Atomic
Simulator
coupledSimulator
coordinator
1:n
Coupled models are assigned to
coordinators
1:n
coupledCoordinator
Coupled models as components within coupled models are assigned to
coupledCoordinators
genDevs.
simulation.
coupledSimulator
genDevs.
simulation.
coordinator

22. Atomic Model Simulator
Every atomic model has a simulator assigned to it which keeps track of the time of the last event, tL and the time of the next event, tN.
Initially, the state of the model is initialized as specified by the modeler to a desired initial state, sinit. The event times, tL and tN are set to 0 and ta(sinit), respectively.
If there are no external events, the clock time, t is advanced to tN, the output is generated and the internal transition function of the model is executed. The simulator then updates the event times as shown, and processing continues to the next cycle.
If an external event is injected to the model at some time, text (no earlier than the current clock and no later than tN), the clock is advanced to text.
If text == tN the output is generated.
Then the input is processed by the confluent or external event transition function, depending on whether text coincides with tN or not. m
timeline
(abstract or logica) tL tN
inject at time t
s =: s init
tL =: 0
tN =: ta(sinit)
If t == tN
generate output  (s)
When receive m
if m!= null and t < tN,
s := ext (s,t-tN,m)
if m!= null and t == tN,
s := con (s,t-tN,m)
if m= null and t == tN,
s =: int (s)
Legend:
m = message
s = state
t = clock time
tL = time of last event
tN = time of next event
tL =: t
tN =: t + ta(s)

23. Basic DEVS Simulation Protocol
For a coupled model with atomic model components, a coordinator is assigned to it and coupledSimulators are assigned to its components. In the basic DEVS Simulation Protocol, the coordinator is responsible for stepping simulators through the cycle of activities shown.
Coupled Model Coordinator:
Coordinator sends nextTN to request tN from each of the simulators.
All the simulators reply with their tNs in the outTN message to the coordinator
Coordinator sends to each simulator a getOut message containing the global tN (the minimum of the tNs)
Each simulator checks if it is imminent (its tN = global tN) and if so, returns the output of its model in a message to the coordinator in a sendOut message.
Coordinator uses the coupling specification to distribute the outputs as accumulated messages back to the simulators in an applyDelt message to the simulators – for those simulators not receiving any input, the messages sent are empty.
1 nextTN
Coupled
Model
3 getOut
coordinator
5 applyDelt
4 sendOut
2. outTN
simulator
Component tN
tN. tL
simulator
Component tN
tN. tL
simulator
Component tN
tN. tL
After each transition
tN = t + ta(), tL = t
Each simulator reacts to the incoming message as follows:
If it is imminent and its input message is empty, then it invokes its model’s internal transition function
If it is imminent and its input message is not empty, it invokes its model’s confluence transition function
If is not imminent and its input message is not empty, it invokes its model’s external transition function
If is not imminent and its input message is empty then nothing happens.

24. DEVS as the basis for Network Centric M&S
Discrete
Event
Formalisms
Discrete Time
Systems
Diff Eqn.
Systems
DEVS Model
DEVS Model
DEVS Model
Simulator
Simulator
Simulator
message
message
message
Translator
Translator
Translator
Network Centric Middleware – NCES