You are on page 1of 39

1.

Plataforma GAMA

En

este

captulo

nos

introducimos

en

la

plataforma

GAMA.

Aprenderemos a instalar la plataforma, crear modelos, definir variables, crear


experimentos,

visualizar

el

comportamiento

de

las

variables,

crear

animaciones, etc, a la vez vamos a ir creando el cdigo que utilizaremos para


nuestro proyecto propsito de este trabajo.
4.1 Introduccin
GAMA, es una plataforma de simulacin de cdigo abierto, cuyo objetivo
principal es brindar un entorno de modelado y simulacin para sistemas
multiagentes espacialmente referenciados.
GAML es el lenguaje utilizado por GAMA para la programacin de los
agentes y para su entorno, cuenta con libreras que permiten generar
movimientos, comunicacin, funciones matemticas, grficas, etc.
El framework de GAMA es proporcionado por Eclipse, basado en la
arquitectura de RCP (Rich Client Platform), que ofrece una sola aplicacin en
donde se pueden realizar las tareas de edicin de los modelos y la simulacin,
visualizacin y exploracin, utilizando las herramientas adecuadas dentro de la
misma aplicacin, permitiendo adaptarse fcilmente a las necesidades de los
modeladores.
Instalacin y puesta en marcha
El

instalador

se

puede

bajar

de

la

direccin:

https://code.google.com/p/gama-platform, (requiere registrar la informacin


personal), disponible en formato .rar. Debemos seleccionar la versin y el
sistema operativo en el que vayamos a trabajar, Windows, Mac, o Linux, y si
queremos el software en 32 bits o 64 bits.

El fichero que hemos descargado se descomprime en cualquier


directorio dentro del equipo, creando una carpeta de nombre GAMA, podemos
utilizar dentro de ella una sub carpeta o crear en el disco duro una carpeta
distinta donde se generar un espacio de trabajo donde al correr la aplicacin
la plataforma GAMA almacenar por defecto todos los proyectos que vayamos
generando, y donde el sistema buscar por defecto los ficheros shape,
imgenes o meta-datos que se requieran en nuestros proyectos.
4.2 Espacio de Trabajo
Todos los modelos que se ejecutan y editan en GAMA los podemos
visualizar en la parte izquierda de la ventana principal (Gama Projects),
ordenados por categoras:
2. Models Library
3. Shared models
4. User models

Figura 1 Gama Projects

Models Library: contiene las libreras y proyectos que vienen por defecto al
instalar GAMA, los modelos que estn aqu ocupan como espacio de trabajo
directamente

la

carpeta

GAMA,

se

encuentran

ubicados

dentro

de

/plugin(msi.gama.models), que a su vez tiene cuatro carpetas principales:


Feactures, Syntax, Toy Models y Tutorials.

Shared models: Todos los proyectos que se encuentran en el repositorio SVN


del sitio gama-models.googlecode.com, cuyo objetivo principal es proporcionar
un lugar para compartir fcilmente modelos con los usuarios de GAMA.
Inicialmente, la carpeta se encuentra vaca, pero basta con dar click derecho
sobre la carpeta y presionar la opcin Update Shared Models para tener
acceso de lectura a los proyectos que se encuentran en el repositorio de la
web. De esta forma podemos visualizar el cdigo escrito por otros usuarios y
compartir nuestros proyectos al resto de miembros de la comunidad GAMA,
para aprender nuevos mtodos de resolucin de problemas.
User models: aqu se encuentran agrupados los proyectos creados por el
usuario, por cada proyecto creado se crea tambin una carpeta dentro de la
carpeta de trabajo que se haba creado al inicializar la plataforma GAMA.
Podemos cambiar la carpeta de trabajo que habamos seleccionado
inicialmente: en el men FILE, en la opcin Switch Workspace, podemos
escoger una nueva carpeta de trabajo, clonarla o renombrarla, dependiendo de
la necesidad.
Importacin de modelos
Tenemos varias opciones (General, Install, SVN y Team) para importar
modelos existentes en la carpeta de trabajo, archivos del sistema, preferencias,
SVN, zip, etc. Una vez escogida la opcin para importar, escogemos la
ubicacin donde sern instalados.
Compartir Proyectos
En GAMA, gracias a la integracin nativa del sistema de control de
versiones SVN, se puede compartir los proyectos creados sin la necesidad de
instalar plugins adicionales, basta con tener acceso al repositorio SVN,
mediante internet.
Una vez compartidos nuestros proyectos podemos gestionarlos sin
ningn problema, pero debemos tener en cuenta que los proyectos importados
de un repositorio se consideran automticamente como shared, compartidos,
entre el espacio de trabajo utilizado por GAMA y el repositorio.

Edicin de modelos
Editar modelos en GAMA es muy sencillo debido a que utiliza el
framework de eclipse.
Se organizan en proyectos, que contienen modelos y estos a su vez
datos

asociados,

ubicados

en

las

diferentes

categoras

indicadas

anteriormente. Teniendo clara la organizacin en nuestros proyectos, podemos


fcilmente realizar las modificaciones o ediciones que sean necesarias
posteriormente.

4.3 GAML Editor


El GAML Editor es un editor de texto que provee varios servicios de
soporte al proceso de modelado: posee un sistema de validacin automtico
integrado, una cabecera que nos permite acceder a los experimentos
realizados, y una pantalla de visualizacin de advertencia y marcador de
errores.
4.3.1 Creacin de modelos
Para crear un modelo debemos hacer clic derecho sobre la categora
User models y escoger la opcin New y luego la opcin Gama Project,
aparecer una ventana para asignar un nombre al proyecto.
A continuacin, sobre el nombre del proyecto hacemos clic derecho y
escogemos la opcin New, y crear un modelo, escogiendo la opcin Model
file.., se despliega una ventana que permite asignar un nombre al modelo, y
damos clic a finalizar, con ello se ha creado el modelo dentro de la carpeta del
proyecto y en el interior los archivos relacionados al modelo.
Una vez creado el modelo, automticamente el editor muestra un nuevo
modelo vaco, listo para poder iniciar con nuestro trabajo. Los archivos GAML
son archivos planos por lo tanto podemos escribir nuestro cdigo directamente
en el editor o en cualquier procesador de texto, pero es recomendable hacerlo
directamente en el editor, ya que permite visualizar de forma directa y en
tiempo real, errores y estado del modelo.

Los estados del modelo se visualizan fcilmente por una franja horizontal
de color ubicada por encima del rea de edicin, los estados dependen de este
color.

Figura 2 Barra de color que indica el estado del programa

Descripcin de los estados:


Funcional: el modelo est correctamente escrito pero no est disponible para
ejecucin solo para compilacin (color naranja).
Experimentable: el modelo no tiene errores y puede ser ejecutado (color
verde).
Con errores: el archivo contiene errores, que pueden ser de tipo sintctico o
semntico (color rojo o amarillo).
Preferencias del Editor
En los editores basados en eclipse se visualizan una serie de opciones y
preferencias que permiten activar/desactivar el nmero de lneas, cambiar las
fuentes utilizadas, colores, etc. Para ello debemos acceder a la opcin
Preference dando clic derecho sobre la ventana de edicin.
4.3.2 Composicin de un modelo.
Un modelo se compone de cabecera (header), declaracin de especies y
declaracin experimentos:

Cabecera (Modelo Header): todo modelo inicia con la declaracin del nombre
del modelo. Se diferencia del resto de declaraciones porque no termina con un
punto y coma (;): model name_of_the_model
Ejemplo: model trafico
Despus de darle el nombre al modelo debemos declarar las variables
globales (global {}), variables que vamos a poder utilizar a lo largo de
nuestro modelo.
Declaracin de especies: tras la declaracin de las variables globales
debemos declarar las diferentes especies de agentes que intervienen en el
modelo, estas especies pueden utilizar las variables globales en su estructura.
Ejemplo: species A {...}
species b {...}

Declaracin de experimentos: Un experiment type GUI permite visualizar el


modelo mediante una interfaz grfica de usuario (GUI), y define parmetros de
entrada y salida utilizando variables globales definidas por el usuario.
De forma general, gui es el conjunto de componentes grficos que
posibilitan la interaccin entre el usuario y la aplicacin (ventanas, botones,
combos, listas, cajas de dialogo, campos de texto, mapas, etc.).
Ejemplo:
experiment exp_name type: gui {
[input]
[output]
}

[input] parmetros de entrada en el modelo, se define como sigue:


parameter title var: global_var category: cat;

con:

tilte (Ttulo): Texto que se visualiza en el control del parmetro.

var: hace referencia a una variable global (que se define en la seccin


global).

category (categora): cadena que se utiliza para agrupar en la interfaz


de usuario parmetros que comparten alguna caracterstica comn.

[output] este bloque define cmo vamos a visualizar la simulacin, pudiendo


ser una o ms formas de visualizacin en ventanas separadas. Por ejemplo,
podemos ver el medio y las especies en una ventana, mientras en otra
podemos ver la evolucin de las variables a lo largo de la simulacin, etc.

Ejemplo:
experiment exp_name type: gui {
[input]
output {
[display statements]
[monitor statements]
[file statements]
}
}

donde:

Display: parte independiente y mvil de la interfaz que muestra las

especies, imgenes, texto o grficos.


Monitor: permite seguir el valor de una expresin arbitraria de GAML, que
aparecer en una ventana anidada y que se recalcula a cada paso de

tiempo durante la simulacin.


File: guarda los datos en un archivo al correr el experimento.

4.3.3 Validacin de Modelos


Durante la edicin de un modelo, GAMA validar de forma continua lo
que se va digitando y podemos visualizar el estado de nuestro modelo a cada

paso, esto nos permite ver si la sintaxis y la semntica son correctas o si


existen errores, de esta manera podemos corregirlos de forma inmediata.
Durante la validacin podemos ver errores sintcticos, semnticos,
advertencias, documentacin y documentacin semntica, cambio de los
indicadores visuales, errores en los archivos importados y modelos de limpieza.
Errores sintcticos.
Se producen cuando la frase escrita no tiene significado dentro de la
gramtica de GAML, puede ser un smbolo inexistente en el lenguaje, signos
incorrectos, o cualquier texto que impide que el compilador produzca un rbol
de sintaxis correcto.
Estos errores se visualizan por medio de varios indicadores como son:
icono de error en la parte superior del modelo, franja horizontal color roja
ubicada en la parte superior del editor, marcadores de error en la o las lneas
donde se encuentra el error.
Ejemplo: global {
Integer variable <- 100;
}
La forma correcta de declarar la variable es int variable <- 100;
Errores semnticos.
Cuando no se tienen o se eliminan los errores sintcticos la validacin
pasa a una fase semntica, en la cual se asegura que lo escrito en el editor
tenga sentido en las reglas del lenguaje.
Ejemplo: species personas parent: personas;
La frase tiene sentido sintctico pero no sentido semntico, pues no hay
reglas en el leguaje que permitan que una especie sea padre de s misma.
Se visualizan de manera similar a los anteriores, solo varan porque se
subraya el lugar donde se produce el error (la palabra).

Advertencias semnticas
La fase de validacin semntica no slo informa del error, tambin emite
varios indicadores que ayudan al modelador a verificar la semntica, mostrando
advertencias para que sean consideradas, puede ser que se declare una
variable de un tipo diferente al que la lgica de GAML espera cuando es
asignado dentro de una especie o procedimiento, por ejemplo:
string numero <- 100 ;
create personas number: numero;
Podemos ver en el ejemplo que la declaracin y la asignacin de la
variable numero es correcta, pero cuando la invocamos en el procedimiento
para crear una especie, personas, no tiene consistencia lgica para el lenguaje
GAML, que espera un valor numrico para crear una cantidad especfica de
personas.
Informacin semntica
Otra forma de retroalimentar a los modeladores en la fase de validacin
semntica son los marcadores de informacin, que sirven para dar mayor
informacin til durante el desarrollo del cdigo, por ejemplo cuando hemos
definido ms de una vez una especie, o si alguna operacin ser ejecutada al
correr el programa. Se muestra como un icono (i) en la lnea en cuestin.
Esto nos permite visualizar de forma fcil temas que debemos tener en
cuenta para ir depurando nuestro programa a medida que lo vamos ingresando
y no esperar a ejecutarlo para empezar a validar el cdigo o ver si la operacin
que hemos definido es la correcta.
Documentacin semntica.
Por ltimo, encontramos en la fase de validacin semntica una
documentacin completa de los diversos elementos presentes en el modelado,
basta con poner el mouse sobre la lnea de la cual deseamos informacin para
visualizar en un recuadro datos completos asociados a esta lnea.

Podemos saber si se trata de una palabra reservada, si ha sido invocada


en alguna parte del cdigo, si podemos asignarle algunas caractersticas
especiales (como una localizacin), si hereda caractersticas de otra especie,
etc.
Cada una estas opciones nos permite tener una gua durante el proceso
de modelado, facilitando la generacin de cdigo correcto, y al final obtener
resultados acordes a los objetivos planteados inicialmente. Estos indicadores
visuales que nos reportan errores, advertencias e informacin importante, se
pueden personalizar en Preferences (ver Figura 27).

Figura 3 Personalizar marcadores1

Cleaning models
Cuando vemos que los metadatos en GAMA se han corrompido por la cantidad
de marcadores y errores que se han producido en los diferentes proyectos
emprendidos en la plataforma, o porque hemos cambiado constantemente de
espacio de trabajo, es necesario realizar una limpieza, aunque es
recomendable no esperar que el programa empiece a reportar errores
incorrectos o tenga un comportamiento extrao, sino hacerlo de forma
continua.
Para ello, accedemos a la opcin Project y luego escogemos clean, se
despliega una ventana con todas las carpetas contenedoras de proyectos, y se
escoge una de las dos opciones que aparece: Clean all projects que por

1 Imgen de Manual GAMA

defecto limpiar la carpeta en la que estamos trabajando actualmente; o Lean


projects selected below, que permite escoger la o las carpetas a limpiar.
Este procedimiento permite re-estructurar todos los proyectos asociados
a la carpeta escogida, primero quita todos los metadatos de validacin
asociados a cada proyecto (dependiendo del tamao esto puede tardar varios
segundos).
4.4 Editor Grfico
Al igual que en la mayora de frameworks utilizados para programacin de
proyectos, en GAMA podemos construir diagramas (archivos GADL) basados
en el plugin Graphiti Eclipse, que es un diseo previo que genera cdigo
completamente funcional y libre de errores, lo que permite definir un modelo
GAMA a travs de una interfaz grfica que genera el cdigo del modelo en el
lenguaje GAML al correrlo.
Instalacin del editor grfico
Debemos ingresar a la opcin Help > install new software, escoger Work
with: -- All Avaible Sites --, aparecen las opciones para instalar nuevos plugins,
para este caso seleccionamos la opcin Graphical modeling Tools for GAMA,
pulsamos Next, y aceptamos los trminos de referencia para dar clic en
finalizar, confirmamos que deseamos instalar este plugin y se reinicia el
programa de forma automtica.
Aparecer en el men principal la pestaa Graphical Modeling, con esta
opcin habilitada podemos generar nuestro modelo de forma grfica.
Creacin de un proyecto con Model diagram
Accedemos el men file > new > other, aparecer la ventana New para
seleccionar Model diagram, y al dar clic en next seleccionamos en tipo de
diagrama (Empty, skeleton o example), la opcin que deseamos ejecutar.

Figura 4 Abrir la opcin Model diagram

Ponemos el nombre del archivo, el autor, y una descripcin de nuestro


modelo. Las opciones skeleton y example, nos permiten aadir al diagrama
algunas caractersticas bsicas.
Al modelar con esta opcin, al igual que en el editor GAML, se visualizan
errores, estados del modelo y advertencias, que ayudan durante el proceso de
modelado. Para modo de ejemplo vamos a crear nuestro diagrama con la
opcin skeleton.
En la ventana de definicin del diagrama aparecen las tres partes bsicas,
world, my_GUI y my_display, mientras en el men de la parte derecha
aparecen las opciones que podemos incorporar de acuerdo a nuestra
necesidad agrupadas en: palette, Agents, Agent features y experiments, dentro
de cada una de ellas encontramos herramientas que sern de utilidad durante
la etapa de diseo.

Figura 5 Diagrama generado por la herramienta

Antes de continuar con el ejercicio, vamos a definir rpidamente cada uno


de los elementos presentes en esta opcin, comenzando con los elementos
que se han creado por defecto al escoger la opcin skeleton, para continuar
con las opciones en el men de la derecha.
Para iniciar con el proceso de modelado creamos las especies que vamos a
utilizar durante la simulacin, los agentes o especies son definidos en la tabla
world, damos doble clic para poder editar.
my_GUI_xp: este elemento hace referencia a lo que generamos en la fase
experiment, como habamos anteriormente, como datos de entrada tenemos
los parmetros. Damos doble clic en el elemento para editar, ingresamos el
nombre y aadimos los parmetros.
my_display: genera la opcin de desplegar de forma grfica las especies que
hemos creado.

Men model diagram

En la parte izquierda se despliega un men con herramientas que sirven


para modelar el proyecto de forma grfica. Podemos crear agentes, darles
efectos, reflejos y aspectos, y crear experimentos, con solo arrastrar la opcin
que deseamos aadir.
Estn organizados por las opciones:

Palette: permite seleccionar o marcar la o las tablas generadas, Agents:


contiene herramientas para crear agentes tipo especies, tipo grid y
especies padres o hijas.

Agent feactures: permite crear action, rflex o aspectos para asignarles


a las especies.

Experiments: opciones para crear display, histogramas, y GUI.


Slo se necesita dar clic a la opcin que deseemos agregar en el modelo

y asignarle dentro de la entidad que corresponda, una vez que terminemos con
el modelado damos clic derecho en la parte de edicin y escogemos la opcin
Generate Gaml model, lo que genera de forma automtica una nueva ventana
con el cdigo correspondiente.

Figura 6. Generacin de cdigo del modelo

El cdigo generado en este ejemplo es:

model example
global {
}
species personas {
}

experiment ejemplo type:gui {


output{
display graficos {
}

4.5 Creacin de sistemas multiagentes en GAMA


En GAMA, al igual que en orientacin a objetos, donde se usan clases para
definir objetos y darle las especificaciones concretas a cada uno de ellos, los
agentes en GAML se especifican por medio de especies, que proporciona un
conjunto de atributos, acciones, comportamientos, propiedades de la poblacin,
como por ejemplo su topologa o en qu orden y cundo deben ejecutarse.
Existen especies que heredan propiedades o cualidades de una especie
padre o genrica, muy similar a lo que ocurre el diseo orientado a objetos.

Figura 7 Relacin entre agentes, modelo y experimento.

De la figura anterior podemos notar que los agentes pueden heredar


caractersticas de otro agente, que en model se declaran todas las variables
globales que pueden ser utilizadas por los agentes de forma directa, y que en
el experiment, se invocan las variables globales y las especies (agent) para
ejecutar la simulacin.

En GAML se definen los agentes como species (especies), mientras que


grid es el medio donde se desenvuelven los agentes.
Una specie, puede representar a una persona, edificio, una capa (shape)
o cualquier elemento que forma parte de la realidad que vamos a modelar. Por
otro lado, un grid representa el medio donde se van a desenvolver los agentes,
con las caractersticas deseadas y que contengan elementos que sirvan para
representar el fenmeno que vamos a simular. Existen varios tipos de especies
que podemos definir en GAML, empezaremos definiendo una especie con las
caractersticas ms bsicas posibles.
Definicin de una especie bsica en GAML.
Como ejemplo vamos a crear un nmero fijo de personas que se distribuyan
de manera aleatoria en el mundo, y que estn representadas por crculos de
color verde con un radio igual a una unidad.
Para cumplir con nuestro objetivo debemos crear un modelo, que
nombraremos persona, e iniciaremos definiendo las variables globales que
vayamos a necesitar, es decir:
Model persona
global {
int personas_numero <- 200 ;
init {
create personas number: personas_numero ;
}
}

Hasta el momento, hemos creado el modelo persona, y declarado la


variable global de tipo entero, persona_numero, e inicializado con el valor de
200, para luego en la funcin init crear especies personas en un nmero de
200.
Luego definiremos la especie llamada personas, con caractersticas
propias, como son un tamao, forma y color:

species personas {
float size <- 1.0 ;

rgb color <- #blue ;


aspect base {
draw circle(size) color:color ;
}
}

donde size es de tipo float a la cual asignamos el valor 1, y color de tipo


rgb con el valor igual a green, para terminar con la declaracin de la especie
debemos definir qu aspecto tendr, para este ejemplo dibujaremos un circulo
de radio igual al valor asignado en la variable size y del color definido en la
variable color. La funcin draw permite dibujar geometras.
Para concluir con nuestro proyecto debemos crear el experiment, donde
invocaremos a la especie personas, para visualizarlas en el momento de
ejecucin.
experiment peatones type: gui {
parameter "Nmero inicial de personas: " var: personas_numero min: 1
max: 1000 category: "Personas" ;
output {
display menu_inicio {
species personas aspect: base ;
}
}

Creamos nuestro experimento, llamado peatones, de tipo gui que


permite la visualizacin de los elementos que generemos dentro de l. En la
estructura del experiment, tenemos, como primera, parte la declaracin de los
parmetros que se visualizarn en la parte derecha en una ventana, asociados
por grupos definidos en category.
Una vez definidos los parmetros, definimos la salida de datos, output, y
el formato, en display definimos el nombre de la ventana visualizar_personas y
qu vamos a desplegar dentro de ella.
En GAML el cdigo completo sera el siguiente:
CREAR PERSONAS (agentes bsicos)
/**
* agentes
* Author: zoila
* Description:

*/
model agentes
/* Insert your model definition here */
global {
int personas_numero <- 200 ;
init {
create personas number: personas_numero ;
}
}
species personas {
float size <- 1.0 ;
rgb color <- #blue ;
aspect base {
draw circle(size) color:color ;
}
}
experiment peatones type: gui {
parameter "Nmero inicial de personas: " var: personas_numero min: 1
max: 1000 category: "Personas" ;
output {
display visualizar_personas {
species personas aspect: base ;
}
}

Al correr el experimento visualizamos la especie personas de la


siguiente manera:

Figura 8 Agentes bsicos.

Definicin del medio


Definidas las especies, ahora vamos a definir el entorno o espacio
topolgico donde se desenvuelven, que permitir mediante variables dinmicas
definir movimientos, acciones o reacciones de las diferentes especies.
Definimos a continuacin una cuadrcula (grid), que son especies
especficas con una topologa particular.
grid grid_name width: nb_cols height: nb_lines neighbors: 4/6/8
{
...
}

Donde:
width (anchura): define el nmero de celdas a lo largo del eje x .
height (altura): nmero de celdas a lo largo del eje y
neighbours (vecinos): Tipo de vecinos (4 - Von Neumann, 6 - hexgono u 8 Moore).
Como ejemplo vamos a definir un rea de accin de los agentes. Para ello,
como primer paso, se define el tamao del rea de 20X20 (va crear un grid
compuesto por 20 celdas horizontales y 20 verticales) y con una vecindad 4Von Neumann:
grid area_personas width: 20 height: 20 neighbours: 4

Se tienen cuatro variables asociadas a las celdas creadas, para nuestro


ejemplo utilizaremos: maxE (mxima energa contenida en la celda), eprod
(energa producida en la celda durante la simulacin), e (cantidad actual de
energa, actualizada a cada paso durante la simulacin) y color (el color que se
pintar la celda de acuerdo a la cantidad de energa contenida en las celdas).
grid area width: 20 height: 20 neighbours: 4 {
float maxE <- 1.0 ;

float Eprod <- (rnd(1000) / 1000) * 0.01 ;


float E <- (rnd(1000) / 1000) max: maxE update: E + Eprod ;
rgb color <- rgb(int(125 * (1 - E)), 125, int(255 * (1 - E))) update:
rgb(int(125 * (1 - E)), 125, int(125 *(1 - E))) ;

El color se define de acuerdo a la cantidad de energa que se tiene en cada


celda.
rgb color <- rgb(int(255 * (1 - E)), int(255 * (1 - E)), 255)

El color se va actualizando de acuerdo a la funcin (update) que permite


visualizar el comportamiento de los agentes, en este caso ser de acuerdo a la
cantidad de energa contenida en la celda a cada instante durante la
simulacin, mediante la siguiente definicin:
update: rgb(int(255 * (1 - E)), int(255 *(1 - E)), 255) ;

Con la finalidad de relacionar nuestros agentes con el medio aadimos una


variable nueva: ubicacionPer de tipo area. Utilizando el nombre de la especie
podemos obtener la lista de todos los agentes, para obtener un elemento al
azar de la lista utilizamos one_of (area).
area ubicacionPer <- one_of (area) ;

Para localizar a nuestros agentes dentro de nuestra area (medio), creamos


la ubicacin del agente (persona) en la seccin init.
species personas {
...
init {
location <- ubicacionPer.location;
}
}

Con lo que solo nos resta crear el experiment y mediante display visualizar
nuestro modelo.
En GAML el cdigo correspondiente es:
/**
* trafinal

* Author: zoila
* Description:
*/
model ejemplo
global {
int personas_numero <- 200;
init {
create personas number: personas_numero ;
}
}
species personas {
float size <- 1.0 ;
rgb color <- #red;
area ubicacionPer <- one_of (area) ;
init {
}

location <- ubicacionPer.location;

aspect base {
draw triangle(size) color: color ;
}

grid area width: 20 height: 20 neighbours: 4 {


float maxE <- 1.0 ;
float EProd <- (rnd(1000) / 1000) * 0.01 ;
float E <- (rnd(1000) / 1000) max: maxE update: E + EProd ;
rgb color <- rgb(int(255 * (1 - E)), int(255 * (1 - E)), 255) update:
rgb(int(255 * (1 - E)), int(255 *(1 - E)), 255) ;
}
experiment persona_predator type: gui {
parameter "Initial number of personas: " var: personas_numero min: 1 max:
1000 category: "Prey" ;
output {
display main_display {
grid area lines: #black ;
species personas aspect: base ;
}
}

Y el modelo se visualiza de la siguiente manera

Figura 9 Agentes y medio.

4.5.3 Dinmica de especies en sistemas multiagente


Una vez creadas y ubicadas en el medio las especies (agentes),
debemos darles dinmicas para representar algn tipo de realidad, por ello
vamos a introducir algunos conceptos y funciones necesarios para realizar
modelos dinmicos.
Iniciamos revisando dos conceptos importantes para la visualizacin y
supervisin de los cambios que se producen en el modelo: inspectores y
monitores.
Inspectores: permiten obtener informacin relacionada con los agentes, se
activan de dos maneras.
El inspector de especies nos da informacin sobre todos los agentes de
una especie y est disponible en el men en la opcin Agentes.

Figura 10 Navegador de Agentes.

Podemos tambin acceder al inspector dando clic derecho sobre nuestro


modelo y activar el inspector, que nos permite visualizar en tiempo real cmo
evolucionan las especies.

Figura 11 Cambios en el nmero de especies durante la simulacin.

Monitores: permiten seguir el valor relacionado a una expresin arbitraria en


GAML, es definido dentro del experiment.
Para visualizar los cambios en los agentes existentes en el modelo
durante toda la simulacin debemos primero definir una variable global que nos
permita almacenar de forma dinmica el valor real de agentes a cada instante
de la simulacin, es decir se actualiza a cada paso.
Int var_cambios -> {length (personas)};

Estamos asignando a la variable var_cambios la longitud de la lista


personas (es decir nos devuelve el nmero de elementos que contiene la lista).

Para visualizar este valor definimos dentro de experiment un monitor:


monitor nombre_monitor value: an_expression refresh_every:
nb_steps;

Donde:
value: aqu vamos a asignar la variable que declaramos como variable global,
este campo es obligatorio.
refresh_every: es un campo opcional que nos permite ingresar el nmero de
pasos de la simulacin necesaria para el clculo de la expresin, en caso de no
ponerla se toma el valor por defecto, que es 1 (en cada paso actualiza la
expresin).

Figura 12 Monitor, visualizacin de la expresin ingresada

Ahora vamos a ver cmo definir funciones que nos permitan darles
movimientos, acciones, reacciones etc.
Para poder da algn tipo de accin o comportamiento a la especie
debemos definir un reflejo, que es un bloque de instrucciones que se ejecutan
internamente durante la simulacin, la forma general de definirla es la
siguiente:
reflex reflex_name when: condition {}

S omitimos la condicin (when {}), se ejecutar a cada paso de la


simulacin, si no, se ejecutar segn sea verdadera la sentencia ah definida, y

adems de acuerdo al orden de definicin de los diferentes reflex definidos en


el modelo.
El ms bsico que podemos definir es para dar movimientos simples a
las especies, es decir, permite a los agentes elegir al azar una nueva ubicacin
en el medio.
species personas {
...
reflex moverse {
ubicacionPer <- one_of (ubicacionPer.neighbours) ;
location <- ubicacionPer.location ;
}
}

En el modelo se pueden definir los reflex que sean necesarios para


simular nuestra realidad, slo se debe tener en cuenta el orden de definicin
para que al ejecutarse represente lo que en realidad deseamos. En cada
bloque podemos definir las variables que vayamos necesitando, que sern
consideradas variables locales.
Estas acciones representan las capacidades que pueden tener los
agentes de cada especie, que sern reutilizadas segn las necesitemos,
pueden aceptar argumentos y pueden o no devolver un resultado.
do action_name arg1: v1 arg2: v2; cuando no devuelven un resultado
var <- self action_name (arg1:v1, arg2:v2); cuando devuelven un
resultado

Definimos el reflejo que permite moverse a la especies de la siguiente manera:


reflex basic_move {
ubicacionPer <- one_of (ubicacionPer.neighbours) ;
location <- ubicacionPer.location ;
}

Este reflejo se ejecuta durante la simulacin.


4.5.4 Definicin de especies a partir de otras especies

En GAML se pueden crear especies a partir de otras, de manera similar


a la herencia en POO, esta creacin de especies sirve para incorporar
propiedades y mtodos de otras especies sin tener que reescribirlo todo, a
estas especies (general) se las conoce como especie padre.
Las especies pueden recibir automticamente todas las variables,
habilidades, acciones y reflejos de las especies padres.

Figura 13 Esquema de especies genricas 2

Definimos una especie genrica que comparta la mayor cantidad de


caractersticas comunes de las especies que vamos a utilizar en nuestro
modelado, como por ejemplo las variables: tamao, color, energa, etc., sus
comportamientos: movimientos, reflejos, forma de morir, etc. y el aspecto: su
forma.
Ejemplo:
species generica {
float size <- 1.2;
rgb color ;
float max_energy;
float max_transfer;
float energy_consum;
area ubicacionPer <- one_of (area) ;

2 Imagen de tutorial de GAMA

float energy <- (rnd(1000) / 1000) * max_energy update: energy energy_consum max: max_energy ;

init {
location <- ubicacionPer.location;
}
reflex basic_move {
ubicacionPer <- one_of (ubicacionPer.neighbours) ;
location <- ubicacionPer.location ;
}
reflex die when: energy <= 0 {
do die ;
}

aspect base {
draw circle(size) color: color ;
}
}

Cuando tenemos definida la especie padre, podemos declarar especies


del tipo genrica (que hereda todas las caractersticas de la especia padre) y
adicionalmente definir las caractersticas especficas de cada una de las
especies hijas.
Como ejemplo, definimos la especie personas cuya especie padre es
genrica y su caracterstica especfica es su color, y con una funcin propia
cobrar.
species personas parent: generica {
rgb color <- #green;
float max_energy <- maxE_personas ;
float max_transfer <- maxT_personas ;
float energy_consum <- enerC_personas ;
reflex cobrar when: ubicacionPer.dinero > 0 {
float energy_transfer <- min([max_transfer, ubicacionPer.dinero]) ;
ubicacionPer.dinero <- ubicacionPer.dinero - energy_transfer ;
energy <- energy + energy_transfer ;

}
}

Para llevar a cabo las simulaciones debemos tener en cuenta las


funciones naturales que existen en nuestra realidad, nacer, crecer, reproducirse
y morir. Hemos visto hasta el momento cmo declarar especies desde el inicio
del modelado, pero debemos tener en cuenta las especies que van
apareciendo durante la simulacin como resultado de alguna accin.
Hemos visto las acciones enfocadas al nivel de energa contenida en
una celda en un instante dado, ahora consideremos el caso que una especie
tenga demasiada energa, en este caso simulamos el nacimiento de especies
hijas, la especie padre que contiene una cantidad grande de energa que cede
a sus cras en partes iguales.

Definimos nuevas variables globales, que permiten simular esta


reproduccin:
global {
...
float personas_proba_reproduce <- 0.01;
int personas_max_descen <- 5;
float personas_energy_reproduce <- 0.5;
float abogados_proba_reproduce <- 0.01;
int abogados _max_descen <- 3;
float abogados_energy_reproduce <- 0.5;
}

Como variables globales, definimos: la probabilidad que tiene una


especie de reproducirse, cuntos hijos pueden tener, la energa que tiene para
reproducirse.
En la especie genrica debemos aumentar tres variables comunes a todas las
especies:
float proba_reproduce
float max_descen
float energy_reproduce

Para poder simular la reproduccin debemos declarar un nuevo reflex,


dentro de la especie genrica, que lo denominaremos reproducir, definiendo
claramente en qu condicin se activa esta funcin.
reflex reproduce when: (energy >= energy_reproduce) and
(flip(proba_reproduce)) {
int num_descen <- 1 + rnd(max_descen -1);
create species(self) number: num_descen {
ubicacionPer <- myself.ubicaionPer ;
location <- UbicacionPer.location ;
energy <- myself.energy / num_descen ;
}
energy <- energy / num_descen;

Las palabras claves que nos permiten hacer referencia a la especie que
est ejecutando las acciones son self y myself, la primera nos hace referencia
al agente que est ejecutando la funcin, y la segunda a la sentencia que est
ejecutando dentro de la funcin.
4.6 Manejo de SIG con GAMA

Una vez definido el manejo de los agentes sobre medios simples, como son
las reas generadas con celdas, ahora debemos ver la posibilidad de tener
como medio una cartografa que nos permita realizar simulaciones ms reales.
Por ello vamos a ver el manejo de mapas dentro de GAMA.
4.6.3 Carga de datos SIG y geometras en GAML
En GAML podemos cargar capas vectoriales, sean estas polilneas,
polgonos o puntos. No slo permite visualizar las capas vectoriales, sino que
tambin permite interactuar con los atributos de cada uno de ellos.
Como vimos en el punto anterior se deben crear especies y asignarlas al
tipo de elemento que va a representar dentro del modelo. Al igual que las
especies creadas para personas, podemos definir una especie del tipo de capa
que vamos a utilizar:
species calles {

rgb color <- #black ;


aspect base {
draw shape color: color ;
}
}

Como podemos ver, la especie es muy similar a las vistas anteriormente,


la nica diferencia es que al dibujarla, su forma est relacionada con un shape.
Debemos previamente declarar las variables globales haciendo referencia a los
archivos SIG.
global {
file shape_file_manzanas <file("../includes/mapas/manzana_mayorista.shp");
file shape_file_mayorista <- file("../includes/mapas/mayorista.shp");
geometry shape <- envelope(shape_file_mayorista);
float step <- 10 #mn;
init {
create manzana from: shape_file_manzanas with: [type::string(read
("TIPO"))] {
if type="TERRENO" {
color <- #red ;
}
}
}
}

Como vemos en la declaracin definimos variables y leemos el archivo tipo


shape, al crearlo interactuamos con sus atributos para fijar diferencias en la
imagen que nos permitan visualizar lo que deseamos, al llamar a esta variable
en el experiment, tenemos el modelo siguiente.

Figura 14 Capas de calles y manzanas, resaltado en rojo los tipos terrenos.

Para las simulaciones en GAMA el paso de tiempo por defecto es 1


segundo, como en el caso de multiagentes tambin se puede definir este valor
de acuerdo a las necesidades en las variables globales.
Una vez cargados los shapes debemos poner agentes dentro de este
medio (cartografas), para poder darles alguna dinmica dentro del mismo, para
ellos vamos a crear especies de tipo persona y ubicarlas dentro de una capa
para poder definir movimientos aleatorios de las personas sobre los shapes.

init {
create manzana from: shape_file_manzanas with: [type::string(read
("TIPO"))] {
if type="TERRENO" {
color <- #red ;
}
}

create calles from: shape_file_calles ;


list<manzana> peatones <- manzana where (each.type="VIVIENDA");
create personas number: personas_num ;
location <- any_location_in (one_of (peatones));
}
}

Hemos definido la capa manzana y creado la capa calles, tambin


seleccionamos las manzanas de tipo VIVIENDA para definir una ubicacin
peatones sobre las reas que cumplan con esta definicin, con ello podemos
localizar a las personas, cuando las creamos, en estos sitios definidos como
peatones.

Figura 15 Especies personas localizadas sobre capas SIG.

4.6.4 Funciones de habilidades de los agentes


Ahora necesitamos darles a las personas la habilidad de moverse por el
medio, la habilidad no es otra cosa que un mdulo integrado que proporciona a
los agentes un conjunto de acciones y variables, que podrn ser utilizadas
durante la simulacin, as como en el caso de agentes padres definamos
parent (padre genrica), ahora definiremos skills (habilidades).

species personas skills: [moving]{


...
}

Dentro de esta funcin debemos definir nuevas variables de acuerdo a las


acciones y elementos que necesitemos durante la simulacin, adems de las
comunes y bsicas que debe tener toda especie (agente), estas variables ser
utilizadas dentro de los reflex, para simular una accin o reaccin. Vamos a
darle en este caso el reflejo de moverse, para ello debemos generar el
siguiente cdigo.
species personas skills: [moving]{
...
reflex movese when: el_objetivo != nil {
do goto objetivo: el_objetivo on: grafico ;
if el_objetivo = ubicacion {
el_objetivo <- nil ;
}
}
}

Como podemos ver en la definicin del mtodo, este permitir a los agentes
moverse. Definimos el destino con la variable el_objetivo, y mediante la accin
goto el agente se mover en direccin al destino, as tambin asignamos un
grfico a la restriccin del movimiento de los agentes, cuando este llegue a su
destino el_objetivo=ubicacin, el agente se detendr y el objetivo se fijar en 0.

Figura 16 Movimiento de especies sobre capas SIG

Estos reflejos y habilidades que se pueden definir en las especies, y la


capacidad de interactuar sobre capas SIG georreferenciadas correctamente,
nos permite realizar simulaciones reales y predecir posibles consecuencias al
alterar algn elemento existente en el medio.

MODELO DE APLICACIN

Una vez revisados los conceptos bsicos de SMA, SIG y urbanismo, vamos
a definir un problema urbano para ser resuelto con la plataforma GAMA,
aplicando los ejercicios realizados en el captulo anterior.

5.1 Definicin del Modelo

El problema de trfico es un tema de actualidad, el aumento de vehculos y


de peatones que se desplazan de su domicilio a su lugar de trabajo ocasiona
dificultades para trasladase en algunos sectores de las ciudades, ocasionando
impactos negativos en la congestin, sean estos a corto o largo plazo. Por ello,
este problema se considera dentro de los estudios urbanos, el control de la
congestin forma parte del desarrollo de una ciudad, pues involucra la
movilidad, crecimiento poblacional, vehicular y vial.
Los esfuerzos de las autoridades urbanas se ven enfocados a formar
grupos multidisciplinarios que realicen estudios de la problemtica y emitan
informes sobre las causas, consecuencias y posibles soluciones.
Para este trabajo se ha realizado un proyecto que nos permita visualizar
cmo se desplazan las personas sobre las vas desde sus hogares hacia sus
lugares de trabajo dependiendo de las horas de entrada y salida. Para cumplir
con este propsito, en captulos anteriores se ha realizado la creacin de
agentes con caractersticas especficas y habilidades de desplazamiento,
tambin se han creado las capas necesarias para simular el desplazamiento,
ahora vamos a integrar estos datos para obtener una simulacin en el sector
del Mercado Mayorista de Quito.

5.2 Ejemplos de aplicaciones


Simulacin de desplazamiento
Tomando las capas SIG que hemos obtenido en el captulo 3 y con el
cdigo generado para crear especies, cargar capas y generar movimiento de

las especies, vamos a modelar cmo las personas se movilizan por las calles
desde su casa hasta los terrenos definidos en la capa manzanas.
El cdigo completo es el siguiente:
/**
* mayorista
* Author: zoila
* Description: trafico en el mayorista
*/
model mayorista
global {
file shape_file_manzanas <file("../includes/mapas/manzana_mayorista.shp");
file shape_file_calles <- file("../includes/mapas/calle_mayorista.shp");
file shape_file_zona <- file("../includes/mapas/mayorista.shp");
geometry shape <- envelope(shape_file_zona);
float step <- 10 #mn;
int personas_numero <- 50;
int hora_actual update: (time / #hour) mod 24;
int min_ini_terr <- 6;
int max_ini_terr <- 8;
int min_sal_terr <- 16;
int max_sal_terr <- 20;
float vel_min <- 1.0 #km / #h;
float vel_max <- 5.0 #km / #h;
graph grafico;
init {

create manzanas from: shape_file_manzanas with:


[type::string(read ("TIPO"))] {
if type="TERRENO" {
color <- #red ;
}
}
create calles from: shape_file_calles ;
grafico <- as_edge_graph(calles);
list<manzanas> manz_viviendas <- manzanas where
(each.type="VIVIENDAS");
list<manzanas> manz_terrenos <- manzanas where
(each.type="TERRENO") ;
create personas number: personas_numero {
speed <- vel_min + rnd (vel_max - vel_min) ;
init_terr <- min_ini_terr + rnd (max_ini_terr min_ini_terr) ;
fin_terr <- min_sal_terr + rnd (max_sal_terr min_sal_terr) ;
lugar_vivienda <- one_of(manz_viviendas) ;
lugar_trabajo <- one_of(manz_terrenos) ;
objetivo_per <- "resting";
location <- any_location_in (lugar_vivienda);
}
}
}

species manzanas {
string type;
rgb color <- #blue ;

aspect base {
draw shape color: color ;
}

species calles {
rgb color <- #black ;
aspect base {
draw shape color: color ;
}
}
species personas skills:[moving] {
rgb color <- #yellow ;
manzanas lugar_vivienda <- nil ;
manzanas lugar_trabajo <- nil ;
int init_terr ;
int fin_terr ;
string objetivo_per ;
point the_target <- nil ;
reflex tiempo_terr when: hora_actual = init_terr and objetivo_per =
"resting"{
objetivo_per <- "working" ;
the_target <- any_location_in (lugar_trabajo);
}
reflex tiempo_casa when: hora_actual = fin_terr and objetivo_per =
"working"{
objetivo_per <- "resting" ;
the_target <- any_location_in (lugar_vivienda);
}
reflex move when: the_target != nil {
do goto target: the_target on: grafico ;
if the_target = location {
the_target <- nil ;
}
}

aspect base {
draw circle(10) color: color;
}

experiment desplazamiento type: gui {


parameter "Capa manzanas:" var: shape_file_manzanas category: "GIS" ;
parameter "Capa de calles:" var: shape_file_calles category: "GIS" ;
parameter "Capa de area del proyecto:" var: shape_file_zona category:
"GIS" ;
parameter "Nmero de perosonas" var: personas_numero category:
"Personas" ;
parameter "Maximo inicio al terreno" var: min_ini_terr category:
"Personas" min: 2 max: 8;

parameter "Maximo inicio al terreno" var: max_ini_terr category:


"Personas" min: 8 max: 12;
parameter "Salida del terreno" var: min_sal_terr category: "Personase"
min: 12 max: 16;
parameter "Maxima salida del terreno" var: max_sal_terr category:
"Personas" min: 16 max: 23;
parameter "minima velocidad" var: vel_min category: "Personas" min: 0.1
#km/#h ;
parameter "maxima velocidad" var: vel_max category: "Personas" max:
10 #km/#h;

output {
display mayorista type:opengl {
species manzanas aspect: base ;
species calles aspect: base ;
species personas aspect: base ;
}
}

Al correr el modelo tenemos el siguiente resultado (estado inicial del modelo):

Figura 17 Ubicacin inicial de las personas

Figura 18 Desplazamiento de las personas hacia los terrenos