Complex micro-electric machine systems require extensive computations to simulate. These computations, if performed on the same computer used for visualization, can disrupt the frame rate of the imagery. In a teleimmersive environment, this delay can be significant enough to disrupt the sense of presence within the environment.
We are demonstrating the use of CAVERNsoft (University of Illinois at Chicago, EVL) in conjunction with some code for performing multi-body analyses of MEMS devices (micro-electro mechanical systems). The key idea is to share a real-time dynamic analysis between multiple clients. The multi-body dynamics code--Sandia's own C/C++ code which utilizes SD/FAST libraries created by Symbolic Dynamics Inc.--acts as a server and updates the state of the system based on multi-body physics. The use of CAVERNsoft classes allows the dynamics server to stream the state of the system to a number of clients over a network (LAN or WAN). The clients employ a CAVELib-based front-end and utilize CAVERNsoft classes to both, (1) access the system state output by the dynamics server, and (2) to allow user input to the simulation process.
This image depicts a mirror system moved by a small rotating gear. The gear is moved by the pistons to its right. This microscopic system is simulated for this project.
The simulation process can be computationally expensive, and it is best to have it run separately. Visualization of the output can be equally taxing due to the polygon complexity which could arise in the models. Running in a multi-piped environment such as a CAVE increases the visualization requirements as well. The system has been broken into three separate components, namely a central server, a simulation client, and a visualization client.
One problem often faced in shared environments is that of getting the current information about the environment shipped to users who join later than others. These late joiners must be able to enter the world and receive all appropriate updates of the scene.
The information about the components of the MEMS components could vary from execution to execution. Late joiners need to know which information must be retrieved from the database. A master location is created in the datase where all clients can retrieve the appropriate elements from the network database. Connecting clients are programmed to look to these database keys for information about other path and key names in the database.
| Path | Key | Sample Data |
|---|---|---|
| SDF_APP | MASTER_KEY | RACK_POSITION RACK_FORCE RACK_VELOCITY SPRING_CONST DAMPING_CONST CONSTRAINT_TOL INTEGRATION_TOL STEP_SIZE NUM_STEPS |
| SDF_APP | PARTS_KEY | 0 1 2 3 4 5 6 7 |
| SDF_APP | RACK_POSITION | 0.00 |
| SDF_APP | RACK_FORCE | 100.00 |
| SDF_APP | RACK_VELOCITY | 0.00 |
| SDF_APP | SPRING_CONST | 1000.00 |
| SDF_APP | DAMPING_CONST | 20.00 |
| SDF_APP | CONSTRAINT_TOL | 0.00001 |
| SDF_APP | INTEGRATION_TOL | 0.000001 |
| SDF_APP | STEP_SIZE | 0.01 |
| SDF_APP | NUM_STEPS | 800 |
| Part Path | Part Key | Sample Data |
| 0 | PART_POSITION | 0.0 0.0 0.0 |
| PART_ORIENTATION | 0.0 0.0 0.0 | |
| PART_VRML | mirror2.iv | |
| 1 | PART_POSITION | 0.0 1.3 2.1 |
| PART_ORIENTATION | 10.0 10.0 30.5 | |
| PART_VRML | substrate.iv |
The central database server is a combination of several key classes from CAVERNsoft. It incorporates a database server along with TCP and UDP reflectors. The functionality and behavior of these classes are sufficient as implemented within CAVERNSoft, so the server only brings them together into a single application. Each of the three components listens to a particular network socket and directs commands from connected client processes.
SDFPartManagerThe central class to the entire project is the SDFPartManager. This class is aware of the network protocols required to transmit information. It manages all values for the simulation internally, continuously updating them as needed when new network packets are received with updated information. The data contained within the SDFPartManager is considered internal, and components of the architecture which require the values of the data must explicitly request it.
The database used by the manager also contains specific information for the simulation constants. These initializing constants are used by the simulation component during startup. A single entry in the database is used as a record of all the parts which comrpise the simulation. This entry contains a list of all the part names.
The manager uses a hashing dictionary to associate integer identifying values with data for parts of the simulation. Each part is given a name equal to this integer value. Additionally, each has the following: position vector, an orientation value, and the name of a VRML model used to visually represent the part. Methods for modifying these values are provided by the manager class.
In summary, the SDFPartManager contains constants for the visualization, namely rack position, force, and velocity; spring and damping constants; constraint and integration tolerances; calculation step sizes and the number of steps for the simulation calcuations. These values are each given their own key in the CAVERN database used by the manager. Additionally, one key is used to list all the part names in the simulation. Each part then has its own entry in the database with part ID, position, orientation, and VRML file. The manager also has a command database key used for sending command states to the simulation process.
SDFPartManagerGUIAlthough the SDFPartManager class provides methods for accessing and setting values, these are only algorithmic implementations. Setting numeric values from within an immersive environment can be a complicated task. To address the problem, the a subclass implementation provides a 2D windowed interface for setting initializer values.
The Fast Light Tool Kit (FLTK) is available for UNIX and Windows environments. It provides a simple 2D interface for entering values from a keyboard into the system. Tied directly into a SDFPartManager, the interface will automatically update whenever new values are received.
Simulation Component
Calculations are handled by the simulation component. This code is based around original output from the SD/FAST library. After SD/FAST has generated source code for initializing and incrementing a simulation, that code is incorporated with the SDFPartManager to easily read and store values with other parts of the system.
GUI Control ComponentThe graphical user interface component runs as a separate process. Implementing a single instance of the SDFPartManagerGUI class, it is networked to the central database. Thus at a higher level of abstraction, the GUI can itself be considered an independent client. It receives all values from the rest of the cohesive system, but it only respects to events containing updated values for the initializer constants. The controls in the GUI are capable of sending the commands needed by the simulation to start and stop the simulation.
Because the GUI runs as a separate process, it does not need to run on the same system as the client. The GUI Control uses only CAVERNsoft and FLTK. Any platform for which those will compile can support the GUI.
sdfLimboBased upon the CAVERNsoft G2 Limbo module, the sdfLimbo class allows for teleimmersive interaction with the simulation. Users are represented by puppet avatars in a shared virtual space. The module observers the SDFPartManager in order to receive notification any time new information about part models, positions, or orientations are received. The manager notified the Limbo module when this has occurred, and the visualization is updated accordingly.
A collaborative sessions of the MEMS application was demonstrated at the Accelerated Strategic Initiative booth at Supercomputing 2000 in Dallas, Texas.
Intended as a proof of concept, the demonstration run at Supercomputing 2000 in Dallas, Texas allowed multiple users to connect to a single server and interact with each other within the environment. The simulation was run on a single server, and the results were broadcast concurrently to all connected users. The users were thus viewing the same frames of animation at the same time.
Currently the piecez within the system must operate at a whole. One improvement would be to allow users to move and manipulate the individual pieces to more closely examine them. The calculations currently do not take into account the exact geometry of the models. In effect, the visualization is a representation of the simulation rather than an integral part of the simulation itself. The simulation must be more closely tied to the model geometry.
The inclusion of haptic interaction could enhance the user's ability to examine the models. Because the parts of the simulation are closely connected, a haptic method of feedback could provide more information about the proximity of the pieces. Additionally, such feedback could be extended to allow for the user manually assembling the parts of the simulation. The user could assemble the various gears and pieces into place before starting the simulation and then examine the effectiveness of the design.