• Has the previously mentioned transition system.
• Updated the UML documents with the latest class structure.
• Added animation controls to play the visualization at a variable speed and easily fast forward to the point in the visualization you want to view.

What am I working on?

• Event animation system. Animations that fire on a DEVS event meeting some required constraints/
• .ma file importing. ATLAS file importing.
• Model movement, and position editing facilities. Typing in the coordinates is difficult. Cell model alignment ( useful for making roads, pipes, rooms, etc, out of cell spaces )
• Maya model importing. I realize now this is almost a fourth year project alone... hopefully I can find some code to use instead of redoing it.
• More flexible log file importing

Posted new Demo with enhanced functionality.

The demo is still rather limited, because the event transition system is not functional. However, it is very close to being completed.

The transition system is composed of:

• Visual state transition rule system
  • Each DEVS model has a set of visual states. { red cube, blue cube, etc }
  • Each DEVS model has a set of transition rules { (in red cube, 1.0 received on port "in", go to blue cube ), etc }
• Sorted by time event list

As the time is incremented, the events will be sent to the DEVS model states to be processed. Any transition rules invoked by the event will cause the DEVS model's to change visual state.

As the time is decremented, the visualization will be reset and rerun to the point specified. Optimizations could include:

• Storing the DEVS model's visual state progression as the visualization time is increased, so time can be reversed easily. This could be optimized further by storing the model's visual state progression only if when a transition rule is reversed there are multiple valid previous states.

Cell DEVS model's have one transition rule set and one visual state set for all cells, however the cell's have their own unique visual representation with its own specific active state and location.

• Finished log file parser
• Finished windowing toolkit development. Implemented windowing system on top of GLUT
• Added Octary Partition Tree to organize visual information for efficient rendering and object selection
• Posted Demo for a simple preview

I've decided to go with GLUT since it was simple to start building something immediately. I've created a simple windowing system to use for implementing a GUI to visualize the simulations.

I created a log file parser that creates a list of events loaded from a log file. The DEVS models listed in the log file are created, and added to the visualization as well. The parser still needs to be extended to handle Cell-DEVS models as a special case of DEVS models.

The next step is to load data from .ma files to get the complete list of DEVS models, and the starting state for the models.

After that the goal will be to associated a visual representation with the state of a DEVS model, and allow the user to specify how the events associated with that DEVS model will affect its visual representation. For example, a Cell-DEVS model may have transparent boxes associated with its cells, that change colour depending on their state.

Once simple examples of box and spheres are rendered correctly in the visualization, and a method of manipulating visualizations with a GUI are completed, a Maya model file loader will be created to allow assigning more complicated visual representations to DEVS models.

Anticipated concerns:

• The simulation link will require a separate thread for interactive simulations. The consumer/producer solution will likely be necessary. This will require a cross-platform thread library.

• Finished a simple UML design of the simulation viewer.
• Setup CD++ simulation environment on my workstations at home
• Successfully built/ran Life and ATM simulations
• Researched possible OpenGL cross platform windowing toolkits
• Started building parser for Simulation Log files.

UML Design Documents

The UML design documents will be updated as the project progresses. They can be found here: UML Documents

Simulation Log Parser

The simulation log files appear to be in a standard format. If there is any documentation describing this format it would be very useful to create the parser. I will investigate further.

OpenGL Toolkit

Finding a suitable OpenGL cross platform toolkit is proving very difficult. There is no exemplary solution to this problem that is open sourced and free. I have narrowed it down to several choices which I think are all valuable in some way:

GLUT:

The GLUT toolkit provides very basic windowing services to implement a simulation viewer.

Pros:

• Widely implemented
• Simple to use

Cons:

• Only basic windowing functionality is provided
• Several inherit design limitations make building complex applications difficult

NGL/NUI:

The NGL and NUI libraries provide extensive support for windowing, widgets, mixed with OpenGL rendering. The library provides mechanism for a variety of common tasks in 3D application programming. For example it provides mechanisms to load 3D Studio Max model files.

Pros:

• Packed with functionality for quick application development

Cons:

• Currently has low performance when rendering windows
• Not as widely implemented as GLUT and therefore not as well tested

JOGL:

The JOGL library is an extension to Java that lets you use OpenGL hardware accelerated rendering from a java program.

Pros:

• Allows mixing OpenGL rendering with the robust Java API

Cons:

• Relatively new API. Only support for hardware accelerated AWT Panels.