Embed Size (px)
Citation preview
Overview of Presentation Why do we use simulation? Rescue simulation problem. The system overview. Open Projects.
Simulation systems in Action:
Gaining extra information from the system.
Experience upon the simulated system.
Why do we Simulate?
Simulation Systems in Action: Building low level simulated
system. Applying the algorithms based
upon the below level.
Rescue Simulation Devastating earthquake left more
than 6500 citizens dead in the city of Kobe, Japan on 1st of Jan. 1995.
A meeting at the city hall on April 1999 led to the Rescue simulation project, formally proposed as a competition in Robocup.
Rescue simulation design issues We need a general world
model(city simulation issue). We need to model the disaster
(disaster formulation). We need to act upon the situation.
Current system in detail
Main server side
Cooperative server side
Client side
• Humanoid agents1. FireBrigade2. PoliceForce3. AmbulanceTeam
• Stationary agents1. FireStation2. PoliceOffice3. AmbulanceCenter
•Kernel
•GIS
•Viewer
•Collapse simulator•Blockade simulator•Fire simulator•Traffic simulator•Misc simulator
2D Viewer
3D Viewer
General Disaster Formulations
e(t) = ƒ( x(t), u(t), t)
x(t+ t) = g( x(t), e(t))
t is time
t is interval x(t) is status var. u(t) is input vector e(t) describes the state change
g configures state
Detailed Disaster Formulations
e1(t) = ƒ1 ( x(t), u(t), t)
e2(t) = ƒ2 ( x(t), u(t), t)
.
.
.
en(t) = ƒn ( x(t), u(t), t)
x(t+ t) = g( x(t) , e1(t) , e2(t)
,…, en(t))
t is time
t is interval x(t) is status var. u(t) is input vector fi(t) one disaster
simulation
g configures state
Agent behavior formulations
ea(t) = ƒa (xa(t), sa(x(t)), ua(t), t)
x(t+ t) = g( x(t), e1(t) , e2(t)
,…, en(t), ea1 (t) , ea2(t)
,…, eaN(t) )
xa(t+ t) = ga( xa(t), sa(x(t)),e1(t) , e2(t)
,…, en(t), ea1 (t) , ea2(t)
,…, eaN(t) )
t is time
t is interval x(t) is status var. ea(t) is agent work to the
outside world. fa(t) agent state
change sa restriction of info. For
that agent ga configures agent
state
Current rescue simulation system overall The system is a multi-agent system. The system is a core-based system. The system is a distributed simulation
system. The system is a concrete simulation
system. The system runs under Linux OS. The system is written in C++ language.
The System Structure Overview.
kernel
kernelkernel
kernel
Agents
SimulatorsGIS
Viewers
Simulation Progress
Kernel sends sensory information to each agent module.most of this information is visual information. This information is mixed with some errors.
Each agent module decides what actions the individual should take, and send it to the kernel. This message is called command.
The kernel gathers all messages sent from agent modules, and broadcasts them to the component simulators. Commands are sometimes filtered e.g late commands or commands from dead agents are discarded.
The component simulators individually compute how the world will change based upon its internal status and the commands received from the kernel. These results are then sent back to the kernel
The kernel integrates the results received from the component simulators, and broadcasts them to the GIS and the component simulators. The kernel then increase the simulation clock, and notifies the viewers about the update.
Having being requested for information from the viewers, GIS sends the updated information to the viewers. (GIS keeps track of the changes in the simulated world).
Object structure in the system
Properties of entities Building
Floors Style Ignition Fieryness Brokenness Shape Entrances Neighbors
Properties of entities(contd.) Road
Head/Tail Length Kind Width Block Repair Cost Cars Pass to head/tail
Properties of entities(contd.) Humanoid Agents(civilian)
HP Damage Buriedness Position positionExtra
Fire Brigade Water Quantity Stretched Length
Commands of the system Sense
All the agents Say
All the agents Tell
All the agents Hear
All the agents
Move Humanoids
Rest Humanoids
Clear Police force
Extinguish Fire brigade
Commands of the system(Contd.) Stretch (disabled)
Fire brigade Rescue
Ambulance team Load
Ambulance team Unload
Ambulance team
Summary of the Prev. Session(1)
Simulations fall into 2 major groups: Gaining extra info. about the system(@class) Experiencing new algorithms in the system(@Robocup)
Key Concepts in Simulation systems: World Model / Agent Single-Agents / Multi-Agents Sensing / Action / Command
Rescue Simulation Problem. Simulators / Agents
Summary of the Prev. Session(2) Simulators
Collapse Blockade Traffic Fire Misc
Agents Humanoid
Fire Brigade Ambulance team Police Force
Stations Fire Station Ambulance Center Police Office
Let’s
go ,
See them
in A
ctio
n
Our side of the storyOur side of the story
Main issues for programming under rescue simulation Very limited information of the
world model. Uncertainty (sensor noise). Huge amount of data to be
processed. Multi-agent approach of the system. Random behavior of the system.
Why do we use communication? Communication as a solution for
gaining extra information from the world model.
Communication as a solution for noise recovery.
Communication as a way of synchronizing agents’ behaviors.
Overview of Communication in RescueSimulation
FB
FS
AC
AT
PO
PF
Sample agents’ messages FB/AT/PF to AT when buried in a
building AT to AT reporting duties
AT/FB to PF requesting to open the road
Problems with simple CM (Communication Manager) Real-time behavior of the
messaging system. Only 4 messages in each cycle can
be heard or said. Most of the messages to be TXed
are multi-hopped. Once an agent in the link cannot
hand in the message,total message is lost.
Open Projects for RescueSimulation Modifying kernel to add some
functionalities to the system Modifying viewer to add debugging
information. Writing Traffic Simulator under
windows.
Kernel Modification Current kernel:
Sends position information to each agent
Representable information is sent only to the viewers(it’s complete & noiseless).
Id of objects is not unique for different agents.
Kernel Modification New kernel should:
Send path information to each agent & the debugger.
Represent able information is sent to each agent also (convert sensible information to representable information).
Provide the uniqueness of Ids among the different type of agents.
Viewer Modification Debugging info.
Showing the path taken by each agent.(needs kernel support).
A tool for comparing the noiseless information sent to viewers with noisy info sent to the agents(needs the kernel support).
Thank You!You can download this presentation at :
http://ce.sharif.edu/~arian/present.ppt
Ali Nouri : http://ce.sharif.edu/[email protected]
Arian rescue simulation team:http://ce.sharif.edu/[email protected]
