A Agent Based VIS Framework - CiteSeerX

SCS Transactions on Simulation, 15(4) :139-152, December 1998.

An Agent Based Framework for Visual-Interactive Ecosystem Simulations André M.C. Campos, David R.C. Hill Blaise Pascal University ISIMA (Computer Science & Modeling Institute) Campus des Cézeaux BP 125 AUBIERE Cedex FRANCE Tel : (33) 4 73 40 50 00 - Fax : (33) 4 73 40 50 01 e-mail : [email protected], [email protected] URL http://www.isima.fr/ecosim/ Abstract : Customizing ecosystem simulation applications is a complex operation and the design of multi-agent systems remains expensive and error-prone. Object-Oriented frameworks are a promising technology for the reuse of proven designs and implementation (i.e. software components and design patterns). This paper focuses on the design of agentoriented, visual-interactive ecosystem simulations. We propose a customizable application framework, the novel aspects being the use of new advanced software engineering techniques for the reuse of simulation models. The proposed framework is presented with the Unified Modeling Language applied to complex ecosystems with behavioral models encapsulated into active autonomous objects with social interactions (i.e. agents). The framework is also designed to support 2D or 3D visual-interactive feedback to end-users at run-time in addition to its ability to interface with Geographical Information Systems and the Web. Keywords : Visual Interactive Simulation, Object-Oriented Design, Multi-Agent Systems, Ecological Modeling, Object-oriented application framework reusability.

1. Introduction Software development technology is still growing and the introduction of design patterns shows the real key to software reuse: reusable design. Since 1995, with the important contribution of Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides [1], the object-oriented software field has been renewed. Most of these techniques can be applied to simulation software, which are first of all computer programs. The lack of use of these techniques can be explained by the terminology gap separating the language of software engineering specialists from the language of simulation specialists. For instance, the term “framework” that will be used in this paper refers to the object-oriented software engineering definition, which is different from what is used in the whole computer science community, including the computer simulation community. In this paper we consider a framework as a set of cooperating classes and patterns of a reusable design for a specific class of software [2], [3], [4]. As Fishwick states in [5] : “Many of the examples given in recent O-O (Object-Oriented) based software engineering texts appear to be simulations. Therefore, there is an intensive cross-fertilization occurring in this extension area”. Our focus is on objectoriented patterns and our intention is to show that one can present generic elements of software architecture as a solution to problems of visual-interactive simulation of multi-agent systems. In this context, a pattern is a design tool that allows people to present the essence of a

1


generic solution to a recurring problem. This is a software metaphor of what Christopher Alexander, a true architect, and his colleagues already named “a pattern” in 1977 [6]. Software architecture is so essential for simulationists that it imposed, through Simula, the object-oriented programming technique to the rest of the computer science community. The novel aspect of this contribution is the presentation of a set of components and design patterns, grouped in a software framework [4], that enables engineers to use and reuse the design experiences of people who have already encountered and solved identical problems in visual ecosystem simulations. The main benefit of this work is to facilitate in the objectoriented design of simulation software which is at the frontier of many research domains. The proposed framework will provide a software architecture mould that will promote the design and implementation of visual ecosystem simulations involving agents. First, a small section presents an overview and references to visual-interactive simulation and agent-based simulation. How previous simulation techniques can work together will help in understanding how a design framework can be viewed as a useful link. Then, the main section will describe the design of the proposed framework, Multi-Agent Visual Interactive Simulation (MAVIS), which provides visual-interactive features for entity-based simulations in ecosystem studies. The last part of this article presents some implementation issues and three application examples.

2. Background 2.1. Visual Interactive Simulation and Multi-Agent Systems Though the main focus is on advanced software engineering for modeling and simulation, peripheral subjects such as Visual-Interactive Simulation (VIS) and Multi-Agent Simulation (MAS) will also be addressed. These areas of knowledge are not disjointed, and this background section will provide an overview and references. The rest of the article will focus on how a design framework can be used as an interface to link these “different” research domains. The Visual Interactive Simulation (VIS) concept, first introduced by Hurrion [7], was used in many simulation domains [8]. In the 1990’s, the study and exploration of complex dynamic ecosystems has also been intensively developed in interactive simulation environments. A VIS System provides a natural way for a domain expert to interpret the influence of simulation input parameters on results by their visual representation. When the model behavior is not consistent, the expert can try to change it. In fact, when the situation under study is complex, it is important to be able to create an artificial environment where experiments can be conducted and where all or most of the parameters can be added or suppressed, and their values controlled precisely. In this way, the domain expert performs an active task in the simulation flow [10]. The purpose is then to use the system like a little laboratory, moving the entities, changing their behaviors and modifying the environment states, in order to study different situations and prototype a model. The need for visual and interactive aspects in ecological simulation becomes obvious if we consider that part of the simulation validation is an iterative and interactive process where domain experts (as end-users) update a knowledge model (set of ecological information and rules). The known risk in stochastic simulations (whether visual or not) is to draw conclusions from a small number of samples .This is why this paper does not emphasize VIS as a tool for the production of statistical results, but presents it more as an exploration tool, 2


since the complexity of ecological modeling is great. However, when individual-based models were introduced they helped in structural validation, i.e. the structure of the model tries to reflect the structure of reality [9]. This was easier to achieve if all rules are in separate entities, rather than synthesized in aggregated variables [11]. With individual-based models, changes can be applied locally thereby facilitating the simulation validation. This lead to the idea of an agent, where it is possible to represent an environmental phenomena as the consequence of the interactions of parallel agent sets, where each agent has its own operational autonomy. This idea came from the field of Distributed Artificial Intelligence (DAI) and has been recently surveyed in a textbook [12]. Wooldridge and Jennings [13] have also proposed an interesting survey of agent definitions. Among the various definitions presented in the previous references, there is a wide spectrum of concepts ranging from formal specification of intelligent agents using DEVS [15], to the recently described polymorphic agents possessing reactive and cognitive behavior [15]. We want to point out that this paper does not deal with software agents introduced to solve networking problems developing new application software [16], [17]. Agent-oriented programming techniques can be found in [18], [19], and an interesting paper exploring the relationships between object and agent programming is provided by Uhrmacher [20]. Most of this paper concerns the issue of model design. Many agent papers focus on the design of agent architecture and agent design strategies, whereas the novel aspect of this paper is that we focus on the design of the underlying simulation software architecture. In the Multi-Agent System (MAS) paradigm, agents encapsulate and perform their individual tasks locally, but they influence the global behavior of the system. The use of agent technology in computer simulation promotes the inclusion of social-oriented cognition in individual-based simulations, emphasizing the emergence of macro-phenomena from micro-level specifications [21]. This approach is well suited to the study of ecosystems with biological entities like animals or insects [22], [23] (as well as artificial biological entities [24]), because they are separate individual organisms that perform tasks in parallel and which have individual actions that influence global behaviors. Readers interested in a taxonomy of agents: deliberative, cognitive, reactive, etc. or any combination thereof, can consult [25]. Our belief is that the MAS paradigm is best used to simulate animal interactions and/or complex social behaviors [26]; in this case a combination of both reactive and cognitive capabilities is often found useful.

2.2. Frameworks versus patterns Before presenting the design of our application framework, we must specify the differences between patterns and frameworks. As stated previously, an object-oriented application framework is an abstract idea of an application structure, i.e. a reusable design for solutions to problems in some particular domain [3], that can be a system (e.g. [27]), or a part of a system (e.g. [28]). In contrast with traditional approaches of software reuse, which are built on the paradigm of libraries containing a large number of small building-blocks, frameworks allow a higher common abstraction level among a number of similar products or applications to be captured in terms of general concepts and structures, and are similar to abstract classes in the object-oriented paradigm [29]. Both object-oriented design patterns and frameworks are largely used to increase software productivity by software reuse. Recent work from Ralph Johnson showed that the object-oriented reuse technique named “framework” is not well understood outside the object-oriented community. Though it can be viewed as a consistent set of software components + patterns [4], many scientist still think of a framework as a large scale pattern. 3


Indeed, differences between patterns and frameworks are often misleading because they have many similarities. Therefore, we want to quote the differences in three significant ways [1] : • “Design Patterns are more abstract than frameworks ; • Design Patterns are smaller architectural elements than frameworks ; • Design Patterns are less specialized than frameworks.” The role of design patterns1 is to provide structures of software design that can be copied or adapted for a new system. Therefore, they describe how to accomplish certain tasks in the realm of software development. According to Pree [30], the design pattern concept can be viewed as an abstraction of the imitation activity of novice programmers that create parts of a program, though not directly, by copying parts of programs written by other more advanced programmers. In general, this imitation paradigm helps us to reduce the complexity, in many real-life situations as well as in software development. In order to document frameworks, Ralph Johnson has observed that their structures are often composed of a set of patterns interacting together, thus he proposed the use of patterns to describe framework purposes and design choices [3]. In fact, patterns try to describe software design micro-architecture at a high abstraction level [31]. In this paper we do not attempt to cover all phases of the framework documentation proposed by Johnson since our focus addresses only simulations practitioners. To facilitate and shorten our description, we make use of the pattern design catalog by Gamma et al. [1]. This catalog provides detailed specifications when a well known problem is faced. We also retained the current version of the Unified Modeling Language (UML) to present our class diagrams. This new emerging Object Management Group (OMG) standard for O-O notation [32] [33] [34], gives a graphical notation to represent static and dynamic object relationships in many computer science domains.

3. Design of the framework 3.1. Relationships between the packages composing the framework Among many approaches to ecological modeling, we focus our attention on individual-based models and we split our framework into three UML packages2 : the simulator, user-interface and world package. The first package concerns the simulator; it controls and schedules parallel events in a discrete event simulation approach. The second one, the user-interface package, provides the handling of user input and visual outputs. The last one, the world package, tries to model the environment to simulate, i.e. the system structure which possess all the entities and their respective spatial localization.

1 2

The terminology object-oriented design pattern, design pattern and pattern will be used synonymously. UML package : group of strongly connected classes. 4


Agent-based Simulation Model configuration

Visual-Interactive Model settings

User input/output

Simulator simulation events

User Interface environment and entity data

World

Figure 1- Abstract interactive ecosystem simulation. The UML packages for the simulator and world compose together a set of classes and objects, with their respective relationships, that we call the Agent-based Simulation Model. A second model, the Visual-Interactive Model, is incorporated in the framework by the user-interface package to give visual-interactive features to the simulation model. These models, in particular their packages (figure 1), are composed of abstract classes which must be subclassed in order to create new specific simulation domains. The Simulation Model can work independently from the Visual-Interactive Model, therefore no input or output is provided. This model works like a supervisor; getting the current simulation state to give outputs to the user and changing the current simulation state by user inputs. The user interface components interact with the world components to change environment attributes, as entity positions or states. The next two subsections present both models with more details.

3.2. Agent-Based Simulation Model The UML class diagram in Figure 2 shows the object relationships between the World package and the Simulator package. The former defines simulation controllers, and the latter represents the environment being simulated. The Simulator class is composed of other object classes such as the synchronization kernel (Synchro. Kernel) that uses the time (Time) to sort and schedule environmental events (Events) that are heaped in an event list (Event List). The World class is coupled with a GIS (Geographical Information System) and includes individual entities (Entity) which could be just objects in the world (Passive Entity), entities that perform actions (Active Entity) by their behavioral rules (Rule) and entities (Agent) that have a memory (Memory) and can interact socially with their group (Group). The World object comprises all the entities of the simulation domain, and is classified into three categories: the passives entities, the active entities and the agents.

5


Time

uses

Synchro. Kernel

sort

0..

Simulator Package

Simulator

World Package

World

1..

Event List

*

Geographical Information

0..

*

Rule

1..

*

1..

Entity

Active Entity

*

Memory

Agent

Event 0..

*

create event 1..

*

*

0..

modify

*

Passive Entity

1..

*

Group

Figure 2 - Proposition of a UML class diagram for agent-based simulation. The passives entities have the sense of passive resources which do not evolve during a simulation run and which do not have any autonomy. When implementing such entities, no simulation control flow will be given to them by the simulator synchronization kernel. True passive entities would be, for instance, stones, bowls, etc., but any resource that does not receive a simulation control flow is said to be passive in our classification. They are consumed by active entities or agents, but the simulation objectives do not take into account their evolution. For instance, in a concrete context of mixed-grazing simulation that will be presented in the last section, trees are passive entities, since the simulation goal is to study the behavior of horse and cattle herds at summer time. Trees are sometimes eaten by “starving” cows and horses, and though they grow in reality, they will not change their state in the simulation. In many cases the simulation goals help in determining passive entities and in reducing the model detail level. Passive entities indeed just exist to model entities that are modified by others, and they can represent stimulus or constraints for active entities. Active entities, in contrast with the passive one, create the simulation dynamics by performing tasks and generating events in the environment. An active resource growing during the simulation time, will be considered as an active entity from the simulation point of view, and it will receive the simulation control flow to evolve during the simulation time. Agents are an entity type that differ from active entities by their capacity to save situations in their memory and by their ability to implement social interactions emerging from complex individual behaviors. To classify our agents among existing ones, we consider agents that are reactive and cognitive. They are not deliberative agents which can create plans and predict the future state of the “world” [35]. Though our agents have an internal representation of the world, how they react depends on their current state and on what they perceive from

6


their local environment. Their actions are classically dependent on their current state and perception of the world ( f(state, perception) Þ action). In our application framework, simulation entities corresponding to the real world application are defined as classes derived from Active Entity, Passive Entity or Agent according to their role and to the simulation goals. Obviously, the biological classification of those three categories can be organized according to a hierarchical structure of the simulation domain as in [36] and [37]. Each class represents a particular species of entity (with its own features), and each instance is an individual of this species. So it is possible to: • Define new species of entities by creating new classes; • Define sub-species by inheritance and modification of the default behavior of their individuals. • Define an individual differentiation among the entities by allowing a specific instantiation. The classification example in Figure 3 is an excerpt of the types of entities that can be selected for the sheep grazing simulation domain. An agent in the system will be an instance of a class defined by the simulation application, like the classes Sheep and Flock of Sheep in Figure 3, which both derive from the agent class of our application framework. The behavior model must also be designed and instantiated for the target application, which can also develop its own behavior implementation approach. In figure 3, the Dog entity is created here just to show the differences between agents and actives entities. We consider that the Dog’s sole objective is to keep the sheep in a specific region. So, it is not necessary to model its memory3 or its group (we consider only one Dog in the simulation). In contrast, sheep have to remember the food localization and they have a social group behavior. Passive Entity

Active Entity

Agent

Group

Sheep Food

Dog

Sheep

Flock of Sheep

Figure 3 - Classification example in a simple ecological simulation domain.

3.3. Social interactions. Social interactions are managed by the Group object which assigns specific responsibilities to agents. This means that when an agent takes part in a group, it receives specific behavioral rules according to the group interests, which can differ from the individual ones. An interesting system behavior can result from the interaction of very simple reactive agents (Ecoresolution [25]), and the fact that it might result from cognitive agents is well established. A good illustrative example is the different rules assigned for each bee living in a beehive (the way by which the rules are assigned dynamically is presented later when we will detail the active entities). The relationships between agents and their groups is the kernel of the social organization in an ecological simulation, and it is a basic concept of Multi-Agent Systems. The corresponding aggregation relationship in the framework is represented by a 3

Active entities which have no memory are also known as tropic agents, described in Ferber’s textbook which will be available in English [25]. Their actions only depend on the environment and localization state at a fixed time. 7


Composite pattern (see Figure 4a) which has a run-time check to impose social constraints for the addition of new objects into the group set. These constraints depend on the natural organization of social entities encompassed by the simulation. So, to add a new entity in a group, the procedure must verify if the entity and the group have a convergent activity and form a structural unit [25]. For example, when modeling animal behavior, the agents of the same animal species will have convergent activities, and their herd is also considered as a structural unit (and as an agent). A concrete application that we have studied and that will be presented in the last section, concerns mixed grazing of horses and cattle in the French massif central. Though horses and cattle are both grazing, the dynamic addition of a new agent, whether in the real system or in the simulation model, will generate a group update depending on the agent natural behavior. All cows have convergent activities and behavior and when a cow agent joins the cattle herd, even if it is not a dominant cow, the herd behavior can slightly change (as in the real situation). To continue the discussion at a more abstract level, we note that the Composite pattern is recursive, i.e. groups can be nested. This approach provides a flexible design, which may present multiple levels of hierarchy depending on the run-time check procedure implemented in the Group subclass in the application instance. a

CLASS DIAGRAM Agent

b

OBJECT DIAGRAM

* Sheep A: Flock of Sheeps

Group

Sheep

messages

Flock of Sheep

Sheep A1:

Sheep A2:

Sheep A3:

Sheep

Sheep

Sheep

Figure 4 - The Composite (a) and its tree structure (b) formed by an example of the Group-Agent relationship. The message interdependencies is modeled by a whole-part chain of messages. That is, when an agent wants to send a message to its brothers (in the composite tree structure, see Figure 4b), he passes it to its group instance. To pass this message, each agent shares a common interface attribute to access its group. After the message is processed by the group, a state variable will represent the message context that will be consulted by the agent brothers in their next active time. For instance, we suppose the sheep A1 in Figure 4b wants to tell his brothers (A2 and A3) that it found food in the north-east direction. This message will be sent to the group object (Sheep A) which will save it like an internal state and make it available for its agents to consult. When another sheep is activated in the simulation (A2 or A3), it asks the internal state variables of its group for the food direction. The group state is modified only by the agents composing it. The agent memory is a concept hard to model in a framework, since there are no generic rules or paradigms for this kind of abstraction. In our approach, we consider that the memory object is an abstract data structure, which can be as simple as a tree, a list, an array, or as complex and advanced as an information network, like the LTM (Large Term Memory) described in [38]. However, it must have three main characteristics: it has a predefined maximum size, it has an indexed search method, and it is able to save, get and forget information. The forget procedure is used to make dynamic use of the memory leaving out old

8


data for new information, (i.e. if information is not consulted for some time, the forget procedure is called for it. ). The Active Entity class, as well as its subclasses Agent and Group, have a “run” method which is called when an instance of itself is activated in the simulation. This method encapsulates the call of a behavioral rule using the Strategy pattern [1]. In this way, active entities in the framework can dynamically change their rules in the simulation by a relationship with rule objects, instead of multiple conditions in an internal or external state attribute. Figure 5 shows a typical example of interchangeable rules for an active entity. The Rule subclasses overload the “execute” method implementing their own algorithms. This approach is particularly valid for agents which have specific rules in their groups and could have dynamic roles (i.e., their behavior could be changed at runtime). rule

Rule abstract execute();

Bee run();

rule.execute(); Rule of Guard Bee

Rule of Worker Bee

Rule of Regular Bee

execute();

execute();

execute();

Figure 5 - Strategy Pattern in the rule/active entity relationship. The “run” method is also responsible for the creation of environmental events like move, turn, look at, eat, create, die, be born, take or push. Obviously these events are not restricted only to the modification of the entity itself, but can change or activate other entities in the simulation, like an ant transporting its resources or a predator killing a prey. Consequently, the latter entities, if they are also active, can reply to other events and so on, creating thereby a domino effect. The recursive drawback must be controlled by the Event List object.

3.4. World model and GIS coupling Lets now focus on the World Model. There are several relevant issues to take into account when we define the World object. We consider it to be the object container possessing all entities in the simulation, and probably coupled with a Geographical Information System. The relevant issues we retain are : the number of active and passive entities, the spatial environment dimension and its scale of representation, the velocity performance and the memory capacity required. Spatial-oriented structure A E B D C

Entity-oriented structure

Spatial-index to entity structure

A

Position (2,4)

A

B

Position (4,7)

B

C

C

Position (6,6)

D

E

D

Position (5,3)

...

E

Position (3,1)

Figure 6 - Choices of World data structure to interfaces with GIS.

9

F


In accordance with these issues, we retain three simple approaches to encapsulate the world data structure, and to manipulate GIS data (Figure 6). The first approach is spatial oriented, the second is entity-oriented and the last is a combination of the two previous approaches. In a spatial-oriented approach we can see the world as a grid providing a matrix of positions, where a position can be assigned to an entity (in general, this is an extension of the cellular automata approach). This approach is suitable for simulations with a large number of entities, and where the computer-time performance is more important than memory constraints. With this kind of structure we can instantaneously know essential spatial information, for example, the entity that is at a predefined position or how many agents or resources are in a predefined area. The second approach is for simulations with few simulation entities, and when we do not want to use the large memory space required by a spatial-localization table (matrix of positions). Thus, localization information is saved inside the entity, instead of having a matrix of position where a position points to the entity. As a consequence, little space memory will be lost in the simulation implementation. However, the computer-time performance will decrease, since to get information about an environmental position we may have to consult all entities in the worst case. For instance, we cannot know the entity which is at coordinate (3,1) if we do not consult all entities. The last approach uses a low resolution grid as a spatial index to entities. Each grid position represents a rectangular area where a set of entities may be inside. So a grid points to a list of entities, each one having its exact position in the grid area. This approach keeps the presented features of the two other approaches while making a compromise in terms of time and space performances. Both the World, Simulator and Event List are classes which must ensure that they have only one instance of themselves, and that every object in the framework could easily access them. A solution is to use the Singleton pattern [1] which makes the class responsible for keeping track of its sole instance and intercept requests to create new objects.

3.5.Visual-Interactive Model A visual feedback in simulation systems can contribute to many parts of a modeling life cycle : the software development and verification, the validation of the model, the analysis and design of experiments and the presentation of results [39]. In fact, this approach uses the capacities of the human mind to visually recognize forms of behavior and complex spatial relationships [40]. This makes it possible to detect some deviations compared with the expected operation of the model. The visual-interactive approach is recognized as more powerful than the visual-only approach, since it provides tools for domain expert end-users to modify the model dynamically. They can work as if they had virtual laboratories immediately answering their inputs by changing the model state. However, the visual-interactive technique is criticized because disorganized use of interactions with models can seriously invalidate simulation results. Interacting with a model during its execution may completely falsify the computation of statistics, which may be based on samples which are far too small. With the possibility of direct interaction during execution, modifications of the model by a user who has not been warned, may lead to abnormal situations which can never be found in real systems. Despite these drawbacks, it should be pointed out that the involvement of users who are experts in the system modeled is far greater, if they can use ‘commands’ of the model themselves. This approach is far more preferable to that which excludes the expert from the project analysis phase. When it comes to the analysis and experimentation of new strategies,

10


the experts themselves can make proposals directly and so take over the new modified model, which in a way becomes their model. Thus, in our framework we propose the use of the visual-interactive features over the simulation model. In this way, after the modeling of the simulation model itself, we have to specify the entity visual presentations, i.e. how they will be viewed (or recognized) in the user interface. This kind of separation between data and data view is suitable for visual-interactive systems because it increases flexibility and reuse and allows the simulation model independence from : • Input/output platform : which means that there are no restrictions within the simulation model about graphical libraries and windowing environments ; • Visualization and interaction techniques : which means that the simulation model will not change even if we use animated icons, 3D views, direct-manipulation or other similar techniques. Therefore, maintaining consistency between what the user interface displays and the data itself can become a problem in complex dynamic systems. For example, the managing of the ratio between the virtual time of the simulation and the virtual time of the animation is not easy, since the events in the simulation are arranged in a time schedule, whereas the animation must give the illusion of a continuous process. Another example is the user interaction with the model by direct-manipulation. This technique allows the user to modify an object by mouse operations over the screen presentation of the object, which means that this visual representation must ensure the correctness of every attribute of the object at all times, since user events are asynchronous. In order to facilitate the user interface development, methodological approaches are usually used; the following models provide examples: MVC (Model-View-Controller) [28], [41], ALV (Abstraction-Link-View) [42], Client-Server [43] and ADV (Abstract Data View) [44] (a comparative survey is presented in [45]). There are no big differences between these approaches, since they all share the same idea of observable objects and their observer objects. For the framework presented, we chose to use the MVC pattern for pragmatic reasons: it provides a robust way for maintaining consistency, it is easy to implement, and it is increasingly popular in the user-interface community. MVC is composed of three kinds of objects: the Model is the application object, the View is its screen presentation and the Controller defines the user interaction. The View object ensures that its appearance reflects the state of the Model object (as well as its possible state in an intermediary image frame, which gives the illusion of a continuous process in a animated simulation). The MVC approach also allows the attachment of multiple views to provide different presentations for a Model object, which in our case is an instance of the Entity class. Another feature of MVC is that views can be nested, which is perhaps suitable for a reactive agent approach (where intelligent agents can be composed of other reduced agents). The patterns used to structure the MVC and how it is constructed is described in detail in [1]. Figure 7 shows the proposed visual-interactive model. The classes Simulator and Entity are the same as the ones found in the Agent-based Simulation Model (explained in the previous section), and the coupling between both models is done via these classes. The user-interface (User Interface) in this model encapsulates the Simulator object, leaving user communications to its input/output components (I/O Elements), among which one or more of them can be a drawable area (Canvas). These drawable areas possess a buffer memory (Buffer) to quickly accomplish its work, and are one-to-one related with viewer objects 11


(Viewer). The aim of the latter is to manage how the visual data is drawn into the Canvas object, being in this way a rendering engine and how user events are forwarded to the visual data, i.e. the MVC component (Entity - View - Controller). We added a fourth class (Visual Model) to the MVC component to provide a concrete way for the View object to present the Entity object by the appropriate viewer. Examples of Viewer and Visual Model subclasses are also given in Figure 7. User Interface

Simulator

1..

*

Examples:

I/O Elements

Viewer

1..

*

draw

Viewer

Primitive Viewer

Canvas

Bitmap Viewer

3D model Viewer

interact

0..

*

MVC component 0..

Visual Model

Camera

*

Controller

Lights

Buffer Visual Model

View

Entity

Primitive Set

Bitmap

3D Model

Figure 7 - UML Class diagram of the Visual-Interactive model and examples of Viewer and Visual Model subclasses. As the user interface could have various Canvases, each one associated with a different Viewer, more than one view of a same entity can be shown at the same time. Figure 8 illustrates this feature where two views of the same entity are presented. Bitmaped Sheep Control:

3D modelled Sheep Control:

Controller

Controller

Bitmap of a Sheep:

Bitmaped Sheep:

Visual Model

View

Sheep: Entity

3D modelled Sheep:

3D model of a Sheep:

View

Visual Model

Figure 8 - UML Object diagram showing different views (bitmap and 3D model) of the same sheep entity. The sheep bitmap and 3D model are Visual Model objects which will be used to give to the Sheep Entity different appearances in different views. We want to highlight that Visual Model objects are independent from the Entity instance which uses them. As a consequence, visual models, like the sheep bitmap or the sheep 3D model, can be shared by other sheep instances to give them the same visual appearance. Entities which must be visually differentiated use different Visual Model objects. In order to give the illusion of a visual continuous process in a discrete event simulation, we need a clock-based time flow mechanism. This approach avoids visual problems found when the animation uses an event-based time flow (in this case, the risk of

12


drawing conclusions when the animation does not reflect the continuous process of the simulation is not negligible). In addition, it is also appropriate to emulate the animation flow by means of a clock which will synchronize the display at a frequency acceptable to the human eye (about 15 frames per second [46]; films typically use 24 frames/second). However, in simulation applications with this frame rate (sometimes considered as “virtual reality” because of “real-time” user input/output), systems impose time restrictions on each system component [47]. Figure 9 shows a timing diagram illustrating typical real-time performance requirements over the input, output and simulation itself. These requirements are not so easily met by common hardware platforms, an advanced graphics card is mandatory. Input device Output rendering Simulation events

15 Hz 20 Hz 40 Hz

time (s)

Figure 9 - An example of timing rate for input, output and simulation in a clock-based discrete event simulation.

4. Dealing with spatial resource competition : Implementation Issues The framework presented, and its embedded design patterns, are independent from the programming language, but as for other distributed system, a Multi-Agent System is difficult to implement if programming and run-time facilities are not provided [48]. Languages for agent-based applications are still prototypes and they cannot be viewed as production tools. For instance, each language analyzed in [13] was designed either to illustrate or examine some set of agent principles. However, in many object-oriented programming language, objects have no thread of control assigned to them, all objects share the same thread, and operations over different objects are performed serially. When the number of active objects is small it is interesting to use Simula co-routines, Smalltalk processes, Ada, C++ tasks or Java threads; operations will still be performed serially but the illusion of parallelism is given by pseudo or quasi-parallelism. Unfortunately, there are at least two reasons that prevent the use of a system or language thread scheduler for MAS with spatial resource competition. First, the number of threads to handle can be too large: the simulation of a real large scale ecosystem is a particular case of MAS where the number of agents can overload the thread scheduler. Second, ecosystem models do sometimes have simultaneous processes competing for space, which implies careful attention to the underlying implementations of both the simulator kernel and the retained language/system couple, particularly on mono-processors platforms [49]. Concurrent activities are serialized by the system scheduler and the simulator scheduler. The main problem is that scheduling algorithms, and their internal data structure management techniques, can make hidden and unwanted priorities between simultaneous agents competing for spatial resources. Indeed, if we use the underlying operating system implementation of threads, simultaneous threads implementing ecological processes competing for space will be handled by the Operating System thread scheduler. Two implementation cases can now be encountered depending on your Operating system. Lets study the first case, where atomic code portions of concurrent processes are linked and executed sequentially without any stochastic choices.

13


Since the simulation time is the same (simultaneous atomic agent actions are considered), everything is “supposed to be ok”, and this is true for many simulation applications (particularly for queuing systems). However, when 2 or more agents are competing for space or for a specific resource that they could access at the same simulation time, the simulation is maliciously biased if the agent selection depends on the scheduler implementation choices. This case exhibits a deterministic behavior, but there is a second case where the implementation of the operating system scheduler tries to reflect parallelism (i.e. Unix-like Operating Systems). Then the selection between simultaneous atomic actions is frequently made by an internal “quick and dirty” random generator. This is also mainly the case of most Ada and OCCAM implementations. This case is said to be worse, since it generates an even more malicious behavior of the simulation model. Indeed, it can add an unwanted stochastic behavior to a deterministic application [50], or even worse, it could add an un-wanted autocorrelation between the simulator pseudo-random number generator and the underlying quick and dirty generator imposed by the system scheduler. In this second case, there is no hope to satisfy the Central Limit theorem to compute confidence intervals for the stochastic simulation application. Auto-correlation problems for stochastic simulations are widely discussed in [51], and an interesting overview of statistical tools and techniques for simulation practitioners can be found in the following textbooks [52], [53]. Few agent testbeds deal with stochastic validation techniques. Our approach does not claim to be “the solution” to the problem of implementing realistic concurrent agents competing for space, or for a spatial resource, but it does take into account the implementation problems previously exposed. Our solution imposes the use of a specific simulation kernel to simulate the assignment of thread of control. Though our choices could be viewed as specific to ecological modeling or military modeling, we can classify our implementation techniques among existing ones. Balci, in an interesting technical report [54], detailed the four main conceptual frameworks for simulation modeling: event scheduling, activity scanning, three-phase approach and process interaction. Each conceptual framework comes with a time flow mechanism, either a fixed-time increment for clock-based simulations, or a variable-time increment for an event-based simulation. Terminology confusion sometimes occurs, even among specialists, since an event based time management does not imply an event scheduling! Though the process approach introduced by Simula facilitates the design and implementation of Multi-Agent Systems, we retained the three-phase approach initially proposed in [55]. In a three-phase approach, a classification of activities is done to separate unconditional activities from those which are conditional upon the co-operation of different agents. This is in fact an optimization of the Activity Approach first introduced in the Control and Simulation Language by Buxton and Laski [56], and more recently presented and used by [57] [58] and [59]. In the latter, Mike Pidd explained how a three-phase approach is just as convenient as a process based approach for an object-oriented simulation application. Classically, the first phase deals with time management, the second phases executes unconditional activities, and the last phase focuses on conditional activities. In our case in Figure 10, the third phase implements the random choice between simultaneous agents in competition for spatial resources, thus the equivalent of a “thread of control” is given sequentially but in a random order to each simultaneous agent. The main point is that this random selection uses the same random number generator as the rest of the simulation code, since this selection process is part of the modeling of concurrent activities. This choice definitively avoids auto-correlation between different pseudo-random number generators.

14


Start after initializations

Time scan and management (PHASE I)

Execute agent unconditional activities due now (PHASE II)

Scan simultaneous agent activities competing for space or resources (PHASE III) with RANDOM SELECTION

Condition 1

Condition i

Condition n

Agent activity 1

Agent activity i

Agent activity n

Statistical data collection No

End of simulation ?

END

Figure 10 – Three phase approach retained four our agent modeling The schema in Figure 10, allows a true parallel competition for spatial resources, this is particularly important when dealing with agents able to move to the same position, or when we simulate colonization processes, grazing processes, or choices between foraging and other social or spatial behavior, etc. Concerning statistical validation techniques, our approach will simulate parallelism with a true stochastic choice, using the pseudo-random number generator retained for the model to avoid auto-correlation. Thus, agents activated at the same time can really be considered as running “in parallel”, even if only one thread is running for the operating system. This would not have been the case if we had used a classical operating system and language thread scheduler with a process approach to implement the simulation synchronization kernel.

5. Application Examples Three application examples have been developed in order to test the MAVIS framework. The first one is a abstract predator-prey simulation [60], the two other simulations are linked to specific multi-disciplinary studies concerning the simulation of the memory of grazing sheep [61], and the modeling of mixed grazing by cattle and horses in the French Massif Central [62].

15


The first application concerning a predator-prey simulation has two visual versions, one giving 3D visual feedback (figure 11), and the other giving a more classical 2D visual feedback (Figure 12). This was done in order to demonstrate the flexibility and independence of the Visual-Interactive Model. Both visual versions are implemented in Web-based languages (Java and VRML), in order to be incorporated into Web pages and run remotely. The main goal of the latter is to study web-based exploration environments, allowing on-line changes to the behavior model of a multi-agent simulation. This technique is particularly interesting when domain expert end-users are not local. In this application, users can change interactively and dynamically the behavior of predator and prey which is based on the pursuit uncertainty, the latter being modeled with fuzzy sets. In this application prey and predators are created as agent entities in the same limited world (Figure 13). The simulation goals consist of verifying and analyzing situations where a predator believes that it can catch a prey (involving an attack), and also situations where a prey believes that it can be caught (involving an escape attempt). Each prey has its own behavior, but also learns about the predators with the capture of other prey. The World data structure chosen is entity-oriented, due to the small number of entities in the simulation. The main subclasses of the framework in the predator-prey application were the simulated entities – Shark, representing the predator, Fish representing the prey, School of fishes and Fish’s Food (see Figure 13) and their respective visual representations (which are defined classes linking for Figure 11 - Screendump of the predator-prey simulation VRML files in the 3D example using Java. with VRML support. version and for bitmap image files in the 2D version). Both shark and fish are Agent subclasses and the fish’s food is a Passive Entity subclass. The event types which the active entities can produce for the Event List object are : move, turn and eat. We emphasize that this simulation does not address the predator and prey population growth, so we do not model events like birth or death (for this

16


application the “equilibrium” is maintained in this way : a prey eaten results in a new born prey).

Figure 12 - Screendump of the predator-prey simulation example using the Java AWT library. Agent

Shark

1..

*

Fish

Group

Passive Entity

School of fishes

Fish’s food

messages

Figure 13 - Application subclasses in the prey-predator simulation. The second application is a multi-disciplinary project developed by INRA (French National Institute for Agnonomic Research) and ISIMA/LIMOS (Computer Science and Modeling Institute of Blaise Pascal University). This project uses a Multi-Agent approach to simulate the behavior of groups of sheep searching for a preferred food at pasture. Biological data was collected in an experiment conducted during the summer of 1996. The current model outputs are now being fit with real curves. It was initially implemented as a stand-alone application in the C++ language under Unix OS and using the XWindow environment. Later, it was modified to use a GCI web-based interface. As in the predator-prey application, the grazing-sheep application defines its sheep as an Agent subclass and the Sheep’s Food as a Passive subclass. Though the number of simulated entities is small, the World data structure selected was spatial-oriented in order to optimize the simulation speed. Visual representations were done by a set of simple drawing primitives of the XWindows library [61]. The third application using MAVIS focuses on a large environmental project dealing with the evolution of grazing systems in the French Massif Central [62]. The current trend is towards a reduction of the stocking rate on upland pastures, which may induce a reduction of the grazing value and increase the risk of shrub invasion. This specific application concerns a mixed grazing system where horses eat what the cattle will leave to reduce invasion by shrubs. In this context, a simulation model was built with the following objectives :

17


• •

to help assess the interest of mixed grazing by cattle and horses to limit the risks previously stated to follow landscape evolutions and vegetation changes with a geographical information system coupled with simulation software.

Figure 15 : Multi-agent simulation with agent traces Since 1995, an upland permanent pasture (1000 m. a.s.l) with highly heterogeneous vegetation has been divided into two 20.5 ha (approx. 50 acres) paddocks which were grazed and studied from May to October. The first paddock is kept as a control and is only grazed by cattle, whereas the second is grazed by cattle and horses. In order to facilitate the actual development of a multi-agent simulation for this ecosystem, we applied the Mavis framework. The corresponding model is input with biological data collected over three years to provide the following information : • • •

Animal behavior and paths (tracked with GPS satellites : using differential civil GPS) Animal eating activity (with ETHOSYS sensors) Vegetation changes (manual sampling and updating a temporal Geographical Information System database)

Meteorological data were also stored in addition to topographical maps and vegetation maps. The total amount of data can exceed 500 megabytes each year. This huge data set gives very interesting information for the specification of agents in charge of simulating horses and cattle behavior. Figure 15 shows the resulting simulation environment which was implemented in Java. In addition to a 2D multi-agent simulation, the collected data can be replayed by the simulation package to follow a specific day of the period under study. 3D visual representations of the landscape are also available, though it involves more intensive computation to obtain high resolution results, such as those presented in Figure 16. Such renderings are known to be useful to discuss with decision makers, who are not scientists, but who “can assess” your scientific input depending on your result “quality”.

18


Figure 16 : Cows horses and field 3D visualization

6. Conclusion We have presented the main elements of a reusable object-oriented application framework in order to facilitate the development of individual-based ecosystem simulations implemented with agents. We reviewed some software architecture definitions concerning design patterns and frameworks, that are found useful for many simulationists who are not always familiar with the software engineering terminology. Various environmental phenomena can be modeled as a consequence of social interactions of agents. The agent technology is known to be appropriate to model group behaviors, and in our case, each agent can be cognitive and reactive, have its own operational autonomy, can perform tasks in parallel and may possess a social behavior. This kind of modeling is consistent with the following main biological principle: each individual is different in behavior and physiology. The design framework proposed presents a reusable software architecture solution for visual-interactive features enabling domain expert end-users to change simulation parameters dynamically. This approach contributes to the reusability of the development, verification and validation of knowledge models, as well as the reusability of analysis and design of experiments. This is mainly due to the interaction between the user and the simulation model itself, which leads the simulation to work like a virtual laboratory immediately answering user inputs by changing its model state. In addition, the implementation of the proposed simulation kernel, based on the three phase approach, avoids statistical problems encountered when simulating concurrent agents competing for spatial resources with a process approach. In order to be able to use statistical validation methods on stochastic models, our approach simulates parallelism with a true stochastic choice, using the pseudo-random number generator of the model to avoid auto-correlation with the pseudo-random number generator of the underlying operating system thread scheduler. This solution was essential in the validation of the last two applications we presented concerning sheep grazing and mixed grazing (horses and cattle) [61], [62]. We demonstrated the flexibility and independence of the Visual-Interactive Model by implementing different visual outputs of the same model, either 2D or 3D, including Webbased interfaces with Java and VRML. Whatever the quality and flexibility of the software interface, it is almost mandatory that domain expert users be intrinsically involved with the model development and simulation execution, since disorganized use of interactions with the models seriously weakens the validity of simulation results. Ecological modeling studies are, most of the time, inter-disciplinary since they involve communication between simulationists and domain experts. For each study, interactions between the two is fundamental. Indeed, a continuous and mutual sharing of ideas, information and findings is necessary to ensure the success of such simulation projects. We noticed that the choice of the Web, as a backbone for 19


simulation and visualization of preliminary results, helps to generate sufficient fruitful dialogues between scientists separated by long distances [63]. In order to test the framework, we developed three different applications, each one in a different biological domain. Each application has real-time visual input/output and two of those applications were developed in close collaboration with ethologists and sociologists in the concerned biological domains. However, the main benefit of the framework presented will remain linked to software design reusability for various ecological simulation problems.

7. Acknowledgements We would like to thank M. Costa (PUC-Rio) for her discussion about the agent framework, B. Dumont (INRA) for his data validation over the sheep grazing application, C. Roux for his help in the sheep grazing implementation, Y. Wanwanscappel and A. Momboise for their help in the prey-predator VRML implementation and S. Mechoud for the mixed horse and cattle grazing implementation. The first author also would like to thank the CAPES (Brazilian Research Council) for his doctoral fellowship.

References [1] Gamma E., Helm R., Johnson R., Vlissides J., Design Pattern - Elements of Reusable Object-Oriented Software, Addison-Wesley, 1995. [2] Deutsch L.P., Design reuse and frameworks in the Smalltalk 80 System, In Ted J. Biggerstaff and Alan J. Perlis, ed. Software Reusability Vol II : Applications and Experience, pp. 57-71, Addison-Wesley readings, MA, 1989. [3] Johnson R.E., Documenting Frameworks using Patterns, proceedings of Object-Oriented Programming Systems, Languages and Applications OOPSLA’92, ACM Press, pp. 6376, Vancouver Canada, 1992. [4] Johnson, Ralph E. "Frameworks = (Components + Patterns)" Communications of ACM, vol. 40, n° 10, pp. 39-42, October 1997. [5] Fishwick P.A., Computer Simulation : Growth Through Extension, SCS Transactions, vol. 14, n° 1, pp. 13-23, 1997. [6] Alexander, C., Ishikawa, S., Silverstein, M., Jacobson M., Fiksdahl-King I., Angel, S., A Pattern Language, Oxford University Press, New York, 1977. [7] Hurrion R.D., The Design, Use and Required Facilities of an Interactive Visual Computer Simulation Language to Explore Production Planning Problem, London, Univ. of London, 1976. PhD Thesis. [8] Bell P.C., O’Keefe R.M., Visual Interactive Simulation : History, recent developments and major issues, in Simulation, vol. 49, n° 3, pp.109-116, 1987. [9] De Angelis, D., and Gross, L. J., (Eds.), Individual-based models and approches in ecology : populations, communities, and ecosystems, Chapman and Hall, New York. 1992 [10] Green M., Sun H., Interactive Animation, IEEE Computer Graphics and Applications, vol. 8, n° 6, pp. 52-65, 1988.

20


[11] Huston M., De Angelis D., and Post W., New Computer Models Unify Ecological Theory. Computer Simulation shows that many ecological patterns can be explained by interactions among individual organisms, BioScience vol. 38, n° 10, pp. 682-691, 1988. [12] O’Hare, G.M.P., Jennings, N.R., eds., Foundations of Distributed Artificial Intelligence, New-York : Wiley & sons, 1996. [13] Wooldridge M., Jennings N.R., Intelligent Agents : Theory and Practice, The Knowledge Engineering Review, vol. 10, n° 2, pp. 115-152, 1995. [14] Guessoum Z., A Hybrid Agent Model : Reactive and Cognitive behavior, IEEE, ISADS’97, Berlin April 9-11, 1997. [15] Zeigler, B.P., Object-Oriented Simulation with Hierarchical, Modular Models – Intelligent Agents and Endomorphic Systems, San Diego, CA, Academic Press, 1990. [16] Etzioni O., Weld D., A Softbot-based interface to the Internet. Communication of the ACM, vol. 37, n° 7, pp. 72-76, 1994. [17] Genesereth M.R., Ketchpel S.P., Software Agents, Communications of the ACM, vol. 37, n° 8, pp. 76-82, Aug 1994. [18] Gasser L., Briot J.P., Object-Based Concurrent Programming and DAI, in Avouris N.M., Gasser L. (Eds.) Distributed Artificial Intelligence: Theory and Praxis. Kluwer Academic Press, Dordrecht, pp.81-108, 1992. [19] Shoham Y., Agent-Oriented Programming, in Artificial Intelligence, vol. 60, n° 1, pp. 5192, 1993. [20] Uhrmacher A.M., Concepts of Object- and Agent-Oriented Simulation, SCS Transactions, vol. 14, n° 2, pp. 59-67, June 1997. [21] Doram J., From Computer Simulation to Artificial Societies, SCS Transactions, vol. 14, n° 2, pp. 69-77, June 1997. [22] Tu X., Terzopoulos D., Artificial Fishes: Physics, Locomotion, Perception and Behavior, proc. of SIGGRAPH’94, ACM Press, pp. 43-50, Orlando Florida, July 1994. [23] Drogoul A., Corbara B., Lalande S., MANTA: New Experimental Results on the Emergence of (Artificial) Ant Societies, in Artificial Societies: the computer simulation of social life, Nigel Gilbert & R. Conte (Eds), UCL Press, pp. 190-211, London, 1995. [24] Grand S., Cliff D., Malhotra A., Creatures: Artificial Life Autonomous Software Agents for Home Entertainment, in Autonomous Agents’97, Marina del Rey CA, February 1997. [25] Ferber J., Les Systèmes Multi-Agents - vers une intelligence collective, InterEditions, Paris 1995. To be translated by Addison Wesley. [26] Drogoul A., De la Simulation Multi-Agent à la Résolution Collective de Problèmes, PhD. Thesis, University of Paris VI, 1993. [27] Weinand A., Gamma E., Marty R., ET++ - An object-oriented application framework in C++, a Seamless Object-Oriented Application Framework, proc. of Object-Oriented Programming Systems, Languages and Applications, ACM Press, pp. 46-57, San Diego CA, 1988. [28] Krasner G.E., Pope S.T., A cookbook for using the Model-View-Controller user interface paradigm in Smalltalk-80, Journal of Object-Oriented Programming, vol. 1, n° 3, pp. 2649, 1988. 21


[29] Mattsson M., Object-Oriented Frameworks - A survey of methodological issues, Licentiate Thesis, Department of Computer Science, Lund University, Sweden, 1996. [30] Pree W., Design Patterns for Object-Oriented Software Development, Addison-Wesley, 1996. [31] Coad P., Object-Oriented Patterns, in Communications of ACM, vol. 35, n° 9, pp. 152159, 1992. [32] Booch G., The Unified Modeling Language, Unix Review, pp. 41-48, December 1996. [33] Fowler M., Scott K., UML Distilled, Addison-Wesley, Longman, 1997. [34] Booch G., Rumbaugh J., Jacobson I., Unified Modeling Language User Guide, Addison-Wesley Longman, 1998. [35] Hanks, S., Pollack, M.E., Cohen, P.R., Benchmarks, test beds, controlled experimentation ant the design of agents architectures, AAAI Magazine, Winter, pp.1742, 1993. [36] Breckling B., Müller F., Current trends in ecological modelling and the 8th ISEM conference on the state-of-the-art, Ecological Modelling, vol. 75, pp. 667-675, 1994. [37] Del Furia L., Rizzoli A., An Integrated Modeling Environment for Object-Oriented Simulation of Ecological Models, 26th Annual Simulation Symposium. IEEE/SCS/ACM, pp.227-236, 1993. [38] Costa M., Feijó B., An Architecture for Concurrent Reactive Agents in Real-Time Animation, Proceedings of IX SIBGRAPI, Brazil, pp. 281-288, 1996. [39] Hill D., Object-Oriented Analysis and Simulation, Addison-Wesley, 1996. [40] Weber J., Visualization: Seeing is Believing, Byte, vol.18, n° 4, pp. 121-128, April 1993. [41] Goldberg A., Robson D., Smalltalk-80, Addison-Wesley, 1983. [42] Hill R.D., The Abstraction-Link-View Paradigm : Using Constraints to Connect User Interfaces to Applications, Proceedings of CHI’92, pp. 335-342, May 1992. [43] Sinha A., Client-Server Computing, Communications of the ACM, vol. 35, n° 7, pp. 7798, July 1992. [44] Cowan D.D., Ierusalimschy R., Lucena C.J.P., T.M.Stepien, Abstract Data Views, in Structured Programming, vol.14, n° 1, pp.1-13, January 1993. [45] Carneiro L.M.F., Coffin M.H., Cowan D.D., C.J.P.Lucena, User Interface High-Order Architectural Models, Tech. Report CS-93-14, Department of Computer Science, University of Waterloo, 1993. [46] Bradford A., Real-Time Animation: toolkit in C++, Addison-Wesley, 1995. [47] Watson A., AI Agents in Virtual Reality Worlds, Jonh Wiley & Sons, 1996. [48] Hill D., Vigor E., "Dealing with Distributed Dilemmas", Application Development Advisor, vol. 1, n° 4, pp.60-63, 1998. [49] Coquillard P., Hill D., Modélisation et Simulation d’Ecosystèmes, Masson, Paris, 1997. [50] Laval Ph., 1995. — Hierachical object-oriented design of a concurrent, individual- based, model of a pelagic Tunicate bloom. Ecological Modelling, vol. 82, pp.265-276.

22


[51] Leroudier, J., La Simulation à événement discrets. Ed. Hommes et Techniques, France, 1980. [52] Kleijen P. C. J., Statistical tools for simulation practionners. Marcel Dekker Inc. Pub., New York, 1987. [53] Kleijnen J., Groenendaal W. V., Simulation a Statistical Perspective. Wiley, 1992. [54] Balci O., The implementation of four conceptual frameworks for simulation modeling in high level languages, Technical Report SCR-88-009, Virginia Polytechnic & State University, 17 p., 1988. [55] Tocher K.D., The art of Simulation, English University Press, London, 1963. [56] Buxton J.N., Laski J.G., “Control and Simulation Language”, The Computer Journal, vol. 5, pp. 194-199, 1962. [57] O’Keefe R.M., The three phase approach : A comment on strategy related characteristics of discrete-event languages and models”, Simulation, vol. 45, n° 5, pp. 208-211, 1986. [58] Hill D., Coquillard P., de Vaugelas J., Meinesz A., "An algorithmic Model for Invasive Species ". Ecological Modelling, vol. 109, pp. 251-265, 1998. [59] Pidd M., Object-orientation and three phase simulation, Winter Simulation Conference, pp. 689-693, 1992. [60] Campos A., Hill D., Web-based Simulation of Agent Behaviors, SCS Western MultiConference on Computer Simulation, 1st International Conference on Web-Based Modeling & Simulation, pp. 9-14, San Diego CA, January 1998. [61] Hill D., Dumont B., Roux C., Modeling Spatial Memory of Sheep at Pasture with Multi-Agents, to be published in European Simulation Symposium, Manchester UK, pp.348-352, June 16-19 1998. [62] Mechoud S., Hill D., Campos A., Orth D., Carrere P., Micol D., Poix C., Michelin Y., Coquillard P., Simulation Multi-Agents de l’entretien du paysage par des herbivores en moyenne montagne, SMAGET Conference, pp. 65-78, 5-7 October 1998. [63] Fishwick, P., Hill, D. and Smith, R. (Eds.). Proceedings of the 1st International Conference on Web-Based Modeling & Simulation. San Diego CA, January 11-14 1998.

23