Figure 1: A simple heat flow problem with six components and three distinct physical processes of heat flow.
MPSEs are designed to solve problems with complex mathematical models that can be broken down into simple submodels with mathematically modeled interactions between them. Multiple-domain models with the following properties fall into this category: (a) physical phenomenon consisting of a collection of simple, connected, and possibly heterogeneous parts; (b) each part obeys a single physical law that can be modeled by a simple mathematical model in a simple subdomain; and (c) the interactions between the different parts are mediated by adjusting interface conditions along the subdomain boundaries with neighbors. These properties are common in models of physical phenomena. An example is given in Figure 1. It models the temperature distribution in a small system of 6 substances (with different laws for temperature distribution), a heater, and a sink.
Figure 1: A simple heat flow problem with six components and three
distinct physical processes of heat flow.
MPSEs contain two major types of computing agents - solvers and mediators. Each solver agent computes the local solution of a subproblem of the global problem. The ``core'' of the solver is actually a PSE designed for solving ``simple'' problems in an individual subdomain. The solver is considered a ``black box'' by the other agents and it interacts with them only using a defined interagent language. This feature allows all computational decisions for solving the individual subproblem to be taken independently from the decisions in any other subproblem - a major difference from the traditional approaches to multidisciplinary simulations. Each mediator agent is responsible for adjusting an interface between two neighboring subdomains. Thus the mediators control the data exchange between the solvers working on neighboring subproblems by applying mediating formulas and algorithms to the data coming from and going to the solvers. Different mediators may apply different mediating algorithms depending on the physical nature of their interfaces. The mediators are also responsible for enforcing global solution strategies and for recognizing (locally) that some goal (like ``end of computations'') has been achieved. A network that solves the problem on Figure 1 is shown on Figure 2.
Figure 2: The user constructs a network of cooperating computing agents:
solvers and mediators. The network for the problem of Figure 1
is shown with
six solvers, 
, and eight mediators, 
.
The agent framework provides a natural abstraction to the user in the problem domain and hides the details of the actual algorithms and software involved in the problem solving. For the problem in Figure 1 the user first breaks down the geometry of the composite domain into simple subdomains to define the subproblems for each subdomain. Then the physical conditions along the interfaces between the subdomains are given. All this is done in the user's terms. Then the user constructs the proper network of computing agents by simply instantiating various agents. The user is provided with an MPSE constructor (agent instantiator) -- a process which creates active agents of both kinds. The user selects solvers for his subproblems and mediators for the physical conditions along the specific interfaces.
Once an agent is instantiated, it takes over the communication with the user and with its environment (the other agents) and acquires all necessary information for its task. Each PSE (agent) retains its own interface and can interact with the user. The user defines each subproblem independently, interacting with the solver agent through its user interface and similarly interacting with the mediators to specify the physical conditions holding along the various interfaces.
The agents actively exchange partial solutions and data with other agents without outside control and management. After each mediator agent has the connectivity and mediating data from the user, it contacts the corresponding solver agents and requests the information it needs. This information includes the geometry of the interface, the functional capabilities of the solvers with respect to providing the necessary data for adjusting the interface, visualization capabilities, etc. All this is done without user involvement. By instantiating the individual agents (concentrating on the individual subdomains and interfaces) the user builds the highly interconnected and interoperable network that will solve the problem, by cooperation between individual agents.
Figure 3: Software architecture of an MPSE: the user's abstraction. The user
initially interacts with the User Interface Builder to define the
global composite problem. Later the interaction is with the Global Execution
Interface to monitor and control the solution of the problem. Direct
interaction with individual solvers and mediators is also possible. The agents
communicate with each other using the software bus.
The user's high-level view of the MPSE architecture is shown in Figure 3. The MPSE constructor communicates with the user through the user interface builder and uses the software bus [6] to instantiate various agents. Agents communicate with each other through the software bus and have their own local user interfaces to interact with the user. The order of instantiating the agents is not important. If a solver agent does not have all data it needs to compute a local solution (i.e., a mediator agent is missing), then it suspends the computations and waits for some mediator agent to contact it and to provide the missing values. Similarly, mediator agents suspend their computations until the appropriate solver agents appear. This built in synchronization is an important advantage of our architecture.
Since agent instantiation happens one agent at a time, the data which the user has to provide (domain, interface, problem definition, etc.) is strictly local. The user actually does not even need to know the global model. If the global problem is very large then different specialists may only model parts of it.