Skip to content

GamaArchitecture

Jump to bottom
Julien Mazars edited this page Jan 17, 2016 · 8 revisions

Architecture of GAMA

GAMA is made of a number of Eclipse Java projects, some representing the core projects without which the platform cannot be run, others additional plugins adding functionalities or concepts to the platform.

Vocabulary: Each project is either designed as a plugin (containing an xml file "plugin.xml") or as a feature (containing an xml file "feature.xml").

  • A plugin can be seen as a module (or bundle in the OSGI architecture), which can be necessary (the GAMA platform can't run without it) or optional (providing new functionalities to the platform). This decomposition between several plugins ensure the cohesion between functional blocks, each plugin has to be as independent as he can.
  • A feature is a group of one or several modules (or plugin), which can be loaded. NB : Unlike a plugin, a feature does not include source code, but only two files : a build.properties and a feature.xml.

To see how to create a plugin and a feature, please read this page.

Table of contents

The minimal configuration

Here is the list of projects which have to be imported in order to run the GAMA platform, and to execute a simple model in gaml language:

  • msi.gama.core : Encapsulates the core of the modeling and simulation facilities offered by the platform : runtime, simulation, meta-model, data structures, simulation kernel, scheduling, etc. It contains 2 main packages :
    • msi.gama
    • msi.gaml, wich defines the GAML modeling language: keywords, operators, statements, species, skills�
  • msi.gama.application : Describes the graphical user interface (msi.gama.gui package). This project also contains the file gama1.7.Eclipse3_8_2.product, when you can configure the application (and also launch the application). It contains the following sub-packages :
    • msi.gama.gui.displays
    • msi.gama.gui.navigator
    • msi.gama.gui.parameters
    • msi.gama.gui.swt
    • msi.gama.gui.views
    • msi.gama.gui.wizards
    • msi.gama.gui.viewers
  • msi.gama.ext : Gathers all the external libraries upon which GAMA relies upon
    • msi.gama.lang.gaml : Contains the gaml.xtext file which defines the GAML grammar
    • msi.gama.lang.gaml.ui : Contains the GAML Editor (syntax highlighting, code completion�)
  • msi.gama.processor : Is responsible for processing the annotations made in the Java source code and producing additions to GAML (Java, properties and documentation files), which are added into a source package called "gaml.additions" (containing two main generated files: GamlAdditions.java and GamlDocumentation.java). These additions are loaded automatically when GAMA launches, allowing extensions made by developers in other plugins to be recognized when their plugin is added to the platform.
  • ummisco.gaml.editbox : Project used to define the edit boxes in the gaml ui.

Minimal configuration projects dependencies:

Minimal configuration projects dependencies

Optional Plugins

Plugins present in the release version

From this minimal configuration, it is possible to add some features. Here is the list of the features installed by default in the release version:

  • idees.gama.mapcomparison : Contains some useful tools to do map comparaison
  • msi.gaml.extensions.fipa : Provides some operators for communication between agents, using the FIPA standards
  • msi.gama.headless : Enables to run simulations in console mode
  • simtools.gaml.extensions.traffic : Provides operators and skills for traffic simulation
  • simtools.gaml.extensions.physics : Physics engine, collision modelling, using the library JBullet
  • ummisco.gaml.extensions.maths : Solving differential equation, using Euler methods and Runge Kutta.
  • irit.gaml.extensions.database : Provides database manipulation tools, using SQL requests
  • irit.gaml.extensions.test : Add unitary test statements
  • ummisco.gama.opengl : Provide a 3D visualization using OpenGL.
  • simtools.gamanalyzer.fr : Adding tools for the analysis of several execution result of a simulation (in order to find some correlations).
  • dream.gama.opengis : Used to load some geographic information datas from online GIS server.
  • simtools.graphanalysis.fr : Advanced graph operators

Plugins not present by default in the release version

Some other plugins are not present by default in the release version (because their use is very specific), but it's possible to install them through features. Here is the list of those plugins:

  • idees.gama.weka : Data-mining operators, using the library Weka.
  • msi.gaml.architecture.simplebdi : Architecture for using the Belief-Desire-Intention software model.
  • ummisco.gaml.extensions.sound : Use of sound in simulations
  • ummisco.gaml.extensions.stats : Advanced statistics operators
  • ummisco.gama.communicator : Communication between several instances of GAMA
  • ummisco.gaml.extensions.rjava : Adding the R language into GAMA for data mining

Plugins not designated to be in the release version

Other plugins will never be on the released version, and will never be loaded during the gama execution. They are just used in the "developer" version:

  • msi.gama.documentation : Generate automatically the documentation in the wiki form (and also a pdf file)

Unmaintained projects

Some other projects are still in the git repository in case we need to work on it one day, but they are either unfinished, obsolete, or used in very rare situations (They are not delivered in release versions, of course). Here is the list :

  • cenres.gaml.extensions.hydro : Provide some tools in order to create hydrology models
  • msi.gaml.extensions.traffic2d : Provide some tools for traffic in 2 dimensions (depreciated, now replace by msi.gaml.extensions.traffic)
  • msi.gaml.extensions.humainmoving : Provide a skill to represent human movement
  • ummisco.gama.gpu : Computation directly on the GPU for more efficiency. Results or not concluant, slower than using CPU.
  • msi.gama.hpc : "High Power Computing" to execute gama simulation in several computer.
  • msi.gaml.extensions.cplex : Originaly designed to be able to run CPLEX function in GAMA. The CPLEX is a proprietary library, we can't deliver it in the project. Instead, we use a stub, "cplex.jar", that you can replace by the real cplex.jar file.
  • irit.maelia.gaml.additions : Used for the project "Maelia". Provide the possibility to represent the computing time in a simulation.
  • msi.gama.display.web : Originaly designed to run some GAMA simulation in a browser, inside gama application, using WebGL. Does not work for the moment
  • ummisco.miro.extension : Once used for the "miro" project, no longer used.
  • ummisco.miro.extension.traffic : Once used for the "miro" project, no longer used.

Features

  • ummisco.gama.feature.audio : sound plugin
  • ummisco.feature.stats : stats plugin
  • ummisco.gama.feature.opengl.jogl2 : gathers physics and opengl plugins
  • simtools.graphlayout.feature : gathers core, ext, processor and graphanalysis plugins
  • ummisco.gama.feature.core : gathers mapcomparison, database, test, application, core, ext, headless, gaml, gaml.ui, processor, fipa, traffic and maths plugins
  • ummisco.gama.feature.dependencies : a bunch of libraries and plugins
  • other.gama.feature.plugins gathers hydro, opengis, addition, web, hpc, cplex, traffic2d, communicator, gpu, stats, extensions and traffic plugins
  • ummisco.gama.feature.models : model plugin
  • idees.gama.features.weka : weka plugin
  • ummisco.gama.feature.jogl2.product : gathering of the following features : core, dependencies, models, jogl2
  • ummisco.gama.feature.product : gathering of the following features : core, dependencies, models, jogl1

Models

Beside those plugins and features, a project dedicated to gather a bunch of examples is also in the git repository. It contains gaml code:

  • msi.gama.models

Plugins overview

Global architecture of GAMA (nb : the features graphlayout, core, dependencies, plugins, jogl2.product and product are not represented here)

Global architecture of GAMA

Home

  1. What's new (Changelog)

Platform

  1. Installation and Launching
    1. Installation
    2. Launching GAMA
    3. Updating GAMA
    4. Installing Plugins
  2. Workspace, Projects and Models
    1. Navigating in the Workspace
    2. Changing Workspace
    3. Importing Models
  3. Editing Models
    1. GAML Editor (Generalities)
    2. GAML Editor Tools
    3. Validation of Models
  4. Running Experiments
    1. Launching Experiments
    2. Experiments User interface
    3. Controls of experiments
    4. Parameters view
    5. Inspectors and monitors
    6. Displays
    7. Batch Specific UI
    8. Errors View
  5. Running Headless
    1. Headless Batch
    2. Headless Server
    3. Headless Legacy
  6. Preferences
  7. Troubleshooting

Learn GAML step by step

  1. Introduction
    1. Start with GAML
    2. Organization of a Model
    3. Basic programming concepts in GAML
  2. Manipulate basic Species
  3. Global Species
    1. Regular Species
    2. Defining Actions and Behaviors
    3. Interaction between Agents
    4. Attaching Skills
    5. Inheritance
  4. Defining Advanced Species
    1. Grid Species
    2. Graph Species
    3. Mirror Species
    4. Multi-Level Architecture
  5. Defining GUI Experiment
    1. Defining Parameters
    2. Defining Displays Generalities
    3. Defining 3D Displays
    4. Defining Charts
    5. Defining Monitors and Inspectors
    6. Defining Export files
    7. Defining User Interaction
  6. Exploring Models
    1. Run Several Simulations
    2. Batch Experiments
    3. Exploration Methods
  7. Optimizing Model Section
    1. Runtime Concepts
    2. Optimizing Models
  8. Multi-Paradigm Modeling
    1. Control Architecture
    2. Defining Differential Equations

Recipes

  1. Manipulate OSM Data
  2. Diffusion
  3. Using Database
  4. Using FIPA ACL
  5. Using BDI with BEN
  6. Using Driving Skill
  7. Manipulate dates
  8. Manipulate lights
  9. Using comodel
  10. Save and restore Simulations
  11. Using network
  12. Headless mode
  13. Using Headless
  14. Writing Unit Tests
  15. Ensure model's reproducibility
  16. Going further with extensions
    1. Calling R
    2. Using Graphical Editor
    3. Using Git from GAMA

GAML References

  1. Built-in Species
  2. Built-in Skills
  3. Built-in Architecture
  4. Statements
  5. Data Type
  6. File Type
  7. Expressions
    1. Literals
    2. Units and Constants
    3. Pseudo Variables
    4. Variables And Attributes
    5. Operators [A-A]
    6. Operators [B-C]
    7. Operators [D-H]
    8. Operators [I-M]
    9. Operators [N-R]
    10. Operators [S-Z]
  8. Exhaustive list of GAMA Keywords

Developing GAMA

  1. Installing the GIT version
  2. Developing Extensions
    1. Developing Plugins
    2. Developing Skills
    3. Developing Statements
    4. Developing Operators
    5. Developing Types
    6. Developing Species
    7. Developing Control Architectures
    8. Index of annotations
  3. Introduction to GAMA Java API
    1. Architecture of GAMA
    2. IScope
  4. Using GAMA flags
  5. Creating a release of GAMA
  6. Documentation generation

Tutorials

  1. Predator Prey
  2. Road Traffic
  3. 3D Tutorial
  4. Incremental Model
  5. Luneray's flu
  6. BDI Agents

Community

  1. Team
  2. Projects using GAMA
  3. Scientific References
  4. Training Sessions

Versions of GAMA

Resources

  1. Videos
  2. Conferences
  3. Code Examples
  4. Pedagogical materials
Clone this wiki locally