ComponentMesh and Meshlets: A Novel Approach to Grid Generation

Investigator: G. Fox (with J. Thompson at Mississippi State) As a collaboration started as part of the DoD High Performance Modernization program, we are working on new infrastructure for mesh generation for large scale engineering computations. This is designed to operate as a service in a Computational Science portal but here we focus on the key new idea in this project – namely the novel ComponentMesh which exploits Java to build a very dynamic distributed meshing system. This exploits fine grain objects, termed Meshlets, which are built using a JavaBean framework and with compatible XML and Java interfaces.

Meshlets are defined hierarchically and can be as large as an aircraft or as small as a single finite element. Java is used both as the software to glue meshlets together and to specify those parts of the mesh that are best defined by embedded software. The latter includes handlers to define refinement strategies and interpolation schemes. A mesh can in this way be considered as a set of Java objects, which could be registered and used through the Jini mechanism or displayed using Java3D. Alternatively we can map the mesh into a set of XML files that is stored in a dynamic XML database or persistently in a favorite object relational database. This XML can be translated into X3D (VRML standard expressed in XML) or other emerging XML-based graphics standards such as VML. Our use of the twin XML-Java pragmatic object Web standards allows us to take full advantage of the renderers and filters supporting them.

In the ComponentMesh, one can either define a mesh conventionally as a set of nodal points and elements or in terms of the software needed to generate the same or, most interestingly, as a combination thereof. The implicit software-based definition is the most efficient and flexible approach, and one would use this where possible with meshlets representing user-generated points at any level of the mesh hierarchy. The software specification will allow particularly efficient algorithms for associated tools like parallel decomposition and visualization.

Systems like the current Gateway approach using CORBA are sufficient for managing coarse grain objects (complete programs), but a different lighter-weight Web object model is needed to support the ComponentMesh. The situation is rapidly changing, but currently two attractive distributed Java object models are Ninja from an impressive group at UC Berkeley and the very recent E-Speak system from Hewlett-Packard. These provide infrastructure supporting (to differing degrees) necessary services such as security, fault tolerance, and naming (registration and lookup). Ninja has also clearly addressed scaling to a very large number of heterogeneous clients. We plan on evaluating these and other possible base object Web systems during the next few months as we move towards a prototype of these ideas. Clearly the distributed resource in the proposed infrastructure will be very important in testing these new ideas and especially their scaling. Here we will of course use our outside collaborators to see how this dynamic fine grain system performs on a true geographically distributed computational grid.

In a second stage, we will investigate merging this infrastructure with collaborative systems such as the SPW (Shared Portal on the Web) as we envisage that automatic mesh generation can be implemented as a distributed service but with “experts-on-demand” able to help remote users tackle difficult meshing problems. Further we will work with the CSIT visualization group to investigate if one can use similar infrastructure to support the components of a complex scene.