Fig 1: Coarse Grain Structure of Interactive Mesh Portal
The project will produce novel mesh generation systems supporting two distinct 
distributed object paradigms. The coarse grain model will be supported by a commodity 
approach similar to the Gateway System. This will control "whole programs" such as the 
components shown in the figure above. This will be used for initial operational systems 
LegacyMesh built from the composition of existing programs and form the overall 
architecture of the new ComponentMesh system. The ComponentMesh is built in terms 
of 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 essentially as the software to glue meshlets 
together and to specify those parts of the mesh that are best defined by embedded 
software. The latter include 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 your 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. For instance, 
the collaborative white board could immediately display the Java representation if 
projected by a filter into two dimensions. 
	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.
Whereas the current Gateway approach using CORBA is sufficient for high 
performance implementation of the LegacyMesh, a different lighter weight web object 
model is needed. 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 so that we will be read to go when the project is 
funded. In particular, we will set up multiple PC or workstation clusters (at FSU and 
MSU) as the distributed redundant home base infrastructure to support persistent storage. 
The figures shows two key interfaces – middle tier-backend and client-middle tier 
– whose systematic use allows modular design as shown in our Gateway project. It has 
already allowed us to straightforwardly change the original Gateway custom Java Server 
middle tier to the current CORBA based solution with XML specifications being mapped 
dynamically into CORBA IDL. We have defined coarse grain component and event 
models for Gateway which can if appropriate be migrated to either the new CORBA 
proposals in this area or to Enterprise Java bean solutions as offered in commercial 
solutions like i-Planet from Sun. We note two community activities devoted to 
establishing appropriate standards for generic computing portals. The Grid Forum ( 
www.gridforum.org) is setting key resource standards for computing, network and 
software resources. This is complemented by the Computing Portals group 
(www.computingportals.org) whose preliminary abstract task definition has been adopted 
in Gateway. We will continue our active involvement in these projects monitoring of 
commercial products and incorporate their results in this project.
	Our project will contribute understanding both from the new ComponentMesh 
system and from a new model of mesh generation involving geographically distributed 
collaboration between computational scientists, computer scientists and mesh experts. 
This collaboration is an archetype of general research collaboration and a particularly 
good case to study, as it is well known that high quality meshes often require expert user 
intervention. Such mesh expertise is often absent at a given location and our proposed 
distributed solution seems the most practical approach. We will initiate this part of our 
project with the LegacyMesh where we will use existing mesh technology to build a 
prototype interactive mesh portal. This will exchange data streams using XML based data 
structures, which will be a prototype of those to be used in the ComponentMesh. 
We have studied existing collaborative systems and have extensive experience 
with two – Habanero and TangoInteractive – used by the Alliance and DoD PET projects. 
Technology has changed so rapidly that it is not interesting to re-use these systems but 
rather we intend to design a new system whose internal design will be built on the ideas 
of the Collaborative Web Portal (CWP) recently proposed by Fox. Rather than the 
custom servers and protocols of the earlier systems, we will build on the emerging 
distributed software infrastructure discussed above. Again Ninja from UC Berkeley 
seems attractive as the second generation version available in early 2000 has excellent 
support for robust distribution and queuing of events which is needed by the shared event 
models of collaboration. CWP integrates shared event and shared display models by 
supporting “all events” from user actions (mouse motion etc.), programmatic state 
changes and pixel changes in a display. This allows us to immediately share all 
applications with the shared display mode of collaboration and where necessary augment 
with the more powerful shared event model which can require nontrivial changes to the 
application. We will further integrate asynchronous and synchronous collaboration 
models by using the strategy familiar from pagers where either mode is driven from an 
event (message) queue, which also plays the role of session archive. The situation in 
digital audio-video conferencing is changing rapidly and again we will monitor and 
choose from systems such as the Access Grid (from the NCSA Alliance), Buena Vista 
from TangoInteractive as well as commercial approaches such as White Pines 
(CUSeeMe) and Microsoft Netmeeting.

Research Issues
For this project, a key research area will the general issues concerning integration 
of coarse grain and fine grain objects in the ComponentMesh – can one still achieve the 
needed performance, security and robustness goals that we demonstrated in Gateway. 
Note that the mesh generation application has the interesting feature that changes in the 
fine grain structure (adding new Meshlets) is associated with user input and so has 
performance goals that are important but not as severe as those associated with 
processing existing components. This feature will be shared with other applications such 
as general computational steering. The more difficult problem of high performance 
execution of relatively fine grain software components is being tackled by the DoE CCA 
(Common Component Architecture) activity and we will follow this work closely. For 
some portal applications, scaling to many users is important but that will not be a key 
problem for the mesh generation problem. We will research issues concerning scaling of 
client interfaces from those in hand held devices to PC’s to the CAVE (available at 
MSU). In these areas of distributed system research, we will focus on the mesh problem 
but draw conclusions for more general applications. Support of our new concept of 
meshlets, which is applicable to all grid-based applications (generation, execution and 
visualization) will of course be a major focus. Thus we will investigate in this specific 
important case the issues of mobile code and the tradeoffs between XML (data structure) 
and Java (programmatic) specification of information – this is a typical question 
underlying the different approaches to the pragmatic object web. 
Another major research focus will be support of the distributed collaboration 
between computational scientists, computer scientists and mesh experts. Here we will 
again focus on the special features of interactive mesh generation as we have reasonably 
good understanding of general collaboration tools but poor understanding as to which 
shared capabilities are important to support distributed computing. We will first develop 
a collaborative version of the interactive user-driven mesh specification and visualization 
tool. This will use the full shared event capabilities as customization of the shared control 
of this seems certain to be important as it the vehicle for collaboration between the mesh 
expert and users. This part of the project will start with the coarse grain LegacyMesh 
approach and we will initiate use and evaluation of the collaborative environment by 
using the simple shared display version. We will follow this approach with other tools 
(such as specialized visualizers for the different portal engines shown in the figure) with 
quick evaluation using a shared display version being followed if necessary by a 
customized true shared event implementation. This part of the project will teach us which 
tools of what architecture support this mode of collaboration and how the general 
distributed system architecture of CPW performs. For example what is the relative 
performance of the different collaborative models and will the queued event architecture 
lead to serious overheads?