Skip to content

RegularSpecies

Julien Mazars edited this page Feb 17, 2016 · 18 revisions

Regular species

Regular species are composed of attributes, actions, reflex, aspect etc... They describes the behaviour of our agents. You can instantiate as much as you want agents from a regular species, and you can define as much as you want different regular species. You can see a species as a "class" in OOP.

Index

Declaration

The regular species declaration starts with the keyword species followed by the name (or followed by the facet name:) :

species my_specie {
}

or:

species name:my_specie {
}

Directly in the "species" scope, you have to declare all your attributes (or "member" in OOP). You declare them exactly the way you declare basic variables. Those attributes are accessible wherever you want inside the species scope.

species my_specie {
	int variableA;
}

Built-in attributes

As for the global species, some attributes exist already by default in a regular species. Here is the list of built-in attributes:

  • name (type: string) is used to name your agent. By default, the name is equal to the name of your species + an incremental number. This name is the one visible on the species inspector.
  • location (type: point) is used to control the position of your agent. It refers to the center of the envelop of the shape associated to the agent.
  • shape (type: geometry) is used to describe the geometry of your agent. If you want to use some intersection operator between agents for instance, it is this geometry that is computed (nb : it can be totally different from the aspect you want to display for your agent !). By default, the shape is a point.
  • host (type: agent) is used when your agent is part of another agent. We will see this concept a bit further, in the topic multi-level architecture.

All those 4 built-in attributes can be accessed in both reading and writing very easily:

species my_species {
	init {
		name <- "custom_name";
		location <- {0,1};
		shape <- rectangle(5,1);
	}
}

All those built-in attributes are attributes of an agent (an instantiation of a species). Species has also their own attributes, which can be accessed with the following syntax (read only) :

name_of_your_species.attribute_you_want

Notice that the world agent is also an agent ! It has all the built-in attributes declared above. The world agent is defined inside the global scope. From the global scope then, you can for example access to the center of the envelop of the world shape :

global
{
    init {
    	write location; // writes {50.0,50.0,0.0}
    }
}

Here is the list of those attributes:

  • name (type: string) returns the name of your species
  • attributes (type: list of string) returns the list of the names of the attributes of your species
  • population (type: list) returns the list of agent that belong to it
  • subspecies (type: list of string) returns the list of species that inherit directly from this species (we will talk about the concept of inheritance later)
  • parent (type: species) returns its parent species if it belongs to the model, or nil otherwise (we will talk about the concept of inheritance later)

Built-in action

Some actions are define by default for a minimal agent. We already saw quickly the action write, used to display a message in the console. Another very useful built-in action is the action die, used to destroy an agent.

species my_species{
    reflex being_killed {
        do die;
    }
}

Here is the list of the other built-in actions which you can find in the documentation: debug, message, tell.

The init statement

After declaring all the attributes of your species, you can define an initial state (before launching the simulation). It can be seen as the "constructor of the class" in OOP.

species my_species {
	int variableA;
	init {
		variableA <- 5;
	}
}

The aspect statement

Inside each species, you can define one or several aspects. This scope allows you to define how you want your species to be represented in the simulation. Each aspect has a special name (so that they can be called from the experiment). Once again, you can name your aspect by using the facet name:, or simply by naming it just after the aspect keyword.

species my_species {
	aspect standard_aspect { // or "aspect name:standard_aspect"
	}
}

You can then define your aspect by using the statement draw. You can then choose a geometry for your aspect (facet geometry), a color (facet color), an image (facet image), a text (facet text)... We invite you to read the documentation about the draw statement to know more about.

species name:my_species {
	aspect name:standard_aspect {
		draw geometry:circle(1) color:#blue;
	}
}

In the experiment scope, you have to tell the program to display a particular species with a particular aspect (nb : you can also choose to display your species with several aspect in the same display).

experiment my_experiment type:gui
{
	output{
		display my_display {
			species my_species aspect:standard_aspect;
		}
	}
}

Now there is only one thing missing to display our agent: we have to instantiate them.

Instantiate an agent

As already said quickly in the last session, the instantiation of the agents is most often in the init scope of the global species (this is not mandatory of course. You can instantiate your agents from an action / behavior of any specie). Use the statement create to instantiate an agent. The facet species is used to specify which species you want to instantiate. The facet number is used to tell how many instantiation you want. The facet with is used to specify some default values for some attributes of your instance. For example, you can specify the location.

global{
	init{
		create species:my_species number:1 with:(location:{0,0},vA:8);
	}
}


species name:my_specie {
	int vA;
}

Here is an example of model that display an agent with a circle aspect in the center of the environment:

model display_one_agent

global{
	float worldDimension <- 50#m;
	geometry shape <- square(worldDimension);
	init{
		point center <- {(worldDimension/2),(worldDimension/2)};
		create species:my_species number:1 with:(location:center);
	}
}

species name:my_species {
	aspect name:standard_aspect {
		draw geometry:circle(1#m);
	}
}

experiment my_experiment type:gui
{
	output{
		display myDisplay {
			species my_species aspect:standard_aspect;
		}
	}
}
  1. What's new (Changelog)
  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
  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
  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
  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
  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

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

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

Resources

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