estudio sobre la integraciÓn de la herramienta de
TRANSCRIPT
ESTUDIO SOBRE LA FUNCIONALIDAD DE LA
HERRAMIENTA GRAFICA VISIT COMO AMBIENTE DE
VISUALIZACIÓN EXTERNO PARA SISTEMAS DE
SIMULACIÓN INDEPENDIENTES.
José Ignacio Méndez
Tesis para optar por el título de Ingeniero de Sistemas y Computación
Dirigido por:
José Tiberio Hernández, Ph. D.
Universidad de los Andes
Facultad de Ingeniería
Departamento de Ingeniería de Sistemas y Computación
Santa Fe de Bogotá
2009
2
3
Tabla de Contenido
Introducción ........................................................................................................................................ 5
1. Objetivos ......................................................................................................................................... 6
1.1 Objetivo General ....................................................................................................................... 6
1.2 Objetivos Específicos ................................................................................................................. 6
2. Marco Teórico ................................................................................................................................. 7
2.1 El Modelo .................................................................................................................................. 7
2.2 La Simulación. ............................................................................................................................ 7
2.3 Herramienta de Visualización. .................................................................................................. 7
3. Evaluación de Herramientas. .......................................................................................................... 8
3.1 Criterios de Selección ................................................................................................................ 8
3.2 Proceso de selección. ................................................................................................................ 8
3.3 Descripción de VisIt ................................................................................................................. 11
3.4 Comunicación. ......................................................................................................................... 14
3.5 LibSim ...................................................................................................................................... 14
3.6 Visit Data Interface (VDI) ......................................................................................................... 17
4.1 Características ......................................................................................................................... 19
4.2 Implementación ...................................................................................................................... 19
4.2.1 Edificios y Automóviles ........................................................................................................ 20
4.2.2 Interacción con la Simulación. ............................................................................................. 21
5. Conclusiones.............................................................................................................................. 22
6. Bibliografía ................................................................................................................................ 23
4
Lista de Tablas y Figuras
Tabla 1 Herramientas de Visualización ............................................................................................. 10
Ilustración 1 Interacción Modelo-Visualización .................................................................................. 7
Ilustración 2 Arquitectura de alto nivel de VisIt (Vista Funcional) .................................................... 11
Ilustración 3 Modelo de Plataforma en Ejecución. (Vista de Despliegue) ....................................... 12
Ilustración 4 Modelo de Red. (Vista de Despliegue) ......................................................................... 12
Ilustración 5 Modelo de Dependencias Tecnológicas. (Vista de Despliegue) ................................... 13
Ilustración 6: Diagrama de Compontes de la Simulación Integrada con VisIt .................................. 19
Ilustración 7 Diagrama de Clases Detallado de la Simulación ........................................................... 20
Ilustración 8 Visualización de Edificios .............................................................................................. 20
Ilustración 9 Visualización de Automóviles y Edificios ...................................................................... 21
5
Introducción Actualmente en el campo de la Computación se utiliza la elaboración de simulaciones que permiten entender problemáticas a partir de la formulación de modelos de software. Las simulaciones desarrolladas comprenden modelos que describen relaciones matemáticas o lógicas, necesarias para definir el comportamiento y la estructura de sistemas complejos del mundo real a lo largo de periodos de tiempo definidos [1]. En el área de Computación Gráfica es una tarea imprescindible contar con visualizaciones
adecuadas para diferentes tipos de simulaciones, de la misma forma es relevante contar con una
herramienta de visualización que permita representar gráficamente el objeto de estudio,
buscando de la mano de la presentación y la interacción enriquecer el análisis de la investigación
[2].
En este trabajo se estudia la herramienta de visualización VisIt. Inicialmente se realiza una
descripción de su arquitectura con el fin de exponer la funcionalidad de la aplicación que permite
comunicarse con sistemas externos. Adicionalmente se documenta la implementación y los
resultados de la simulación independiente utilizada en el estudio teniendo como objeto demostrar
la viabilidad de la comunicación entre VisIt y un sistema de simulación independiente.
6
1. Objetivos
1.1 Objetivo General
El propósito de este trabajo consiste en evaluar el software VisIt, y determinar su viabilidad como herramienta de visualización. El trabajo hace énfasis en la conexión entre las aplicaciones (La simulación y la herramienta de visualización), y la especificación de las diferentes formas de interacción entre ambos sistemas.
1.2 Objetivos Específicos
Seleccionar una herramienta de visualización que permita conectarse con diferentes modelos de forma independiente, y que permita visualizar simulaciones.
Desarrollar la visualización de un modelo con elementos estructurales y funcionales, que permita probar las características de la herramienta de visualización.
Identificar los requerimientos necesarios para que la comunicación entre la simulación y la herramienta de visualización se pueda llevar a cabo de forma exitosa.
Especificar y desarrollar la interfaz de comunicación necesaria para que se presente una integración entre la simulación y la herramienta de visualización.
7
2. Marco Teórico Con el fin de encontrar soluciones a problemas complejos se conforman equipos interdisciplinarios
que permiten, a través de diferentes ópticas, analizar la problemática en cuestión. Así mismo,
buscando resolver problemáticas reales se utilizan modelos que permiten observar, y cuantificar
comportamientos relevantes por medio de una simulación [1] [2] [3].
Ilustración 1 Interacción Modelo-Visualización
2.1 El Modelo
En base a un proceso de abstracción que identifica las características esenciales de un problema,
se desarrolla un modelo que permita analizar e identificar comportamientos de un sistema. En
base al modelo se desarrolla el programa de software que permite simular el sistema con el fin de
apoyar el análisis de las circunstancias relacionadas con el sistema en estudio.
2.2 La Simulación.
Consiste en realizar un modelo abstracto de un problema real, con el fin estudiar factores particulares que permitan tomar decisiones sobre el objeto de estudio. Dentro del marco de esta investigación la simulación de prueba está compuesta por el modelaje de un problema sencillo desarrollado bajo tecnología C ++.
2.3 Herramienta de Visualización.
Inicialmente se requiere de una herramienta que permita visualizar la problemática modelada, y la presente de tal forma que soporte el estudio y el análisis del problema. Adicionalmente se requiere que esta herramienta soporte la presentación de diferentes tipos de visualización de un mismo problema, y funcione bajo un ambiente distribuido [1].
8
3. Evaluación de Herramientas.
Dentro del marco de trabajo se requiere identificar una herramienta de visualización que permita
ser extendida dependiendo de los requerimientos particulares de cada modelo, y soporte de
forma robusta los requerimientos de representación grafica de cada simulación. La aplicación se
selecciona en base a las diferentes herramientas disponibles en el área de visualización.
3.1 Criterios de Selección
Criterios básicos de selección:
1. Modelos de datos soportados por la herramienta de visualización.
2. Modelos de visualización soportados por la herramienta de visualización.
Criterios técnicos de selección:
1. Debe soportar diferentes tipos de representaciones graficas, y permitir crear nuevos tipos de representaciones graficas.
2. Debe utilizar la librería VTK. [6] 3. Adicionalmente debe ser extensible y soportar la comunicación con diferentes
simulaciones, y representar gráficamente los datos provistos por la simulación. 4. Debe soportar varios tipos de datos de entrada, y permitir la creación de nuevos tipos
de datos de entrada. 5. Debe proveer procesamiento en paralelo que permita analizar una gran cantidad de
datos. 6. Debe permitir la interacción de usuarios desde diferentes ubicaciones.(Distribuido) 7. Debe ser multiplataforma. 8. Debe ser software libre.
3.2 Proceso de selección.
VisIt VisIt es una herramienta de visualización científica desarrollada por el Advanced Simulation and Computing Initiative (ASCI) del Departamento de Energía de Estados Unidos (Department of Energy. DOE). VisIt fue inicialmente desarrollada como un framework flexible con el fin de generar diferentes tipos de visualización en base al desarrollo de plug-ins incrementales [4].
Criterios: 1. VisIt soporta 21 formas diferentes de graficar datos y 42 operadores que permiten
manipular los datos gráficamente. Adicionalmente cuenta con la flexibilidad necesaria para definir nuevas formas de representación.
2. VisIt define los modelos de datos basado en la librería VTK, y de la misma forma la utiliza para generar algunos algoritmos de visualización.
9
3. VisIt cuenta con interfaces en C++, Phyton y Java. Las interfaces en Java y C++ permiten que programas desarrollados sobre estas tecnologías cuenten con una herramienta de visualización. Por otro lado la interface de Phyton permite crear scripts de extensiones y procesar datos por lotes fácilmente.
4. VisIt soporta más de 50 formatos, y puede ser extendido para utilizar nuevos formatos de entrada por medio de la utilización de plugins.
5. VisIt es una aplicación que permite ser configurada para procesar información en paralelo o en serie.
6. VisIt es una aplicación distribuida que puede ser utilizada desde diferentes ubicaciones físicas.
7. VisIt es multiplataforma, y puede ser ejecutada sobre Unix (Fedora, Ubuntu, Irix, Tru64, AIX, Linux, Solaris), MacOS X (10.3, 10.4), y Windows (XP, Vista).
Paraview
1. Paraview permite representar gráficos de diferentes formas, entre las que se encuentran: grillas, superficies, contornos, etc. Son 25 formas diferentes de representar gráficamente datos, y 94 operadores gráficos.
2. Paraview permite trabajar utilizando la librería VTK, recibir datos y generar algoritmos de visualización.
3. Paraview permite extender su funcionalidad utilizando scripts (Phyton), adicionalmente se pueden agregar módulos en base a formatos XML o desarrollando clases en C++.
4. Paraview soporta alrededor de 40 formatos, y puede ser extendido para utilizar leer información de nuevos tipos de datos.
5. Paraview fue especialmente diseñada para ejecutarse en paralelo y procesar datos a gran escala.
6. Paraview es una aplicación distribuida que funciona bajo una arquitectura cliente servidor.
7. Paraview es multiplataforma, y puede ser ejecutada sobre Windows, Linux, Mac OS X, IBM Blue Gene, Cray XT3 y sistemas Unix.
OpenDX
1. OpenDx maneja datos en forma de grillas, scattered plots y datos sin estructura (Triangular, Quads, tetraedro o cubos). Adicionalmente representa datos escalares, vectores, y matrices de datos.
2. OpendDx no soporta la librería VTK. 3. OpenDx puede ser extendido modificando el código fuente entregado por IBM. 4. OpenDX utiliza un formato propio (.dx), adicionalmente cuenta con varios módulos
que convierten le permiten utilizar diferentes formatos (DEM, DLG, ERDAS/IMG, DXF, entre otros).
5. No permite ejecutarse en paralelo. 6. OpenDx cuenta con una arquitectura cliente servidor. 7. La aplicación se puede ejecutar en sistemas Irix, HP-UX, Linux, Solaris.
10
VisAd 1. VisAd permite visualizar imágenes en 2D y 3D. Adicionalmente permite extender
su funcionalidad con scripts en phyton. 2. No utiliza la librería VTK. 3. VisAd cuenta con una arquitectura extensible, y se puede extender desarrollando
en módulos en JAVA y JAVA 3D, o scripts en Phyton. 4. VisAd soporta alrededor de 23 formatos de entrada, sin embargo al ser una
aplicación Open Source puede extenderse el código fuente para interpretar nuevos formatos.
5. VisAd no puede procesar datos en paralelo. 6. La aplicación está diseñada para trabajar en un ambiente colaborativo distribuido. 7. VisAd puede ejecutarse en sistemas operativos Solaris, Linux y Windows.
Sirius
1. Sirius permite el desarrollo de varios tipos de visualización, 2D, 3D y está enfocado especialmente al desarrollo de graficas para el estudio molecular.
2. No utiliza la librería VTK. 3. Para ser extendido se debe modificar el código fuente, su arquitectura permite
desarrollar extensiones. 4. Soporta formatos PDB, MOL2, SDF entre otros. Sin embargo al ser una aplicación
Open Source puede extenderse el código fuente para soportar nuevos formatos. 5. Sirius no permite procesar datos en paralelo. 6. La aplicación cuenta con una arquitectura que funciona en un ambiente
distribuido. 7. Sirius puede ser ejecutada sobre sistemas operativos MacOs, Linux y Windows.
Tabla 1 Herramientas de Visualización
Criterio 1 2 3 4 5 6 7 8 Total
VisIt 5 5 5 5 5 5 5 5 40
Paraview 5 5 4 3 5 5 5 5 37
OpenDX 4 0 4 3 5 5 5 5 31
VisAd 4 0 3 3 0 5 5 5 25
Sirius 2 0 0 2 0 0 5 5 14
11
3.3 Descripción de VisIt
El software de visualización VisIt es un sistema distribuido, que permite procesamiento en paralelo
con el fin de visualizar datos en graficas 2D y 3D. La arquitectura de la aplicación está compuesta
por 6 componentes principales [5] [10]:
Ilustración 2 Arquitectura de alto nivel de VisIt (Vista Funcional)
GUI
VCL EngineMDServer
CLIViewer
1
Inicialmente cuenta con un GUI que provee al usuario final la interfaz de interacción y
controles del sistema.
El CLI es una interface de consola por medio de la cual es usuario final puede controlar el
sistema.
Un Viewer es el componente encargado de centralizar la información, cuando la
información cambia de estado el Viewer es el encargado de notificar todos los
componentes sobre los cambios. Adicionalmente controla las ventanas de visualización
que permiten representar gráficamente los datos. (la aplicación permite 16 ventanas de
visualización en forma simultánea.)
Un Servidor de Meta Datos encargado de realizar consultas en sistemas de archivos
(remotos o locales).
El componente Visit Component Loader (VCL) es el encargado de cargar los diferentes
componentes y hacer llamados a procesos en equipos remotos.
Y finalmente un Motor de Procesos (Engine) encargado de procesar la información requerida por el componente Viewer. Puede procesar los datos de forma lineal o en paralelo.
1 LLNL VisIt User Manual.
12
Ilustración 3 Modelo de Plataforma en Ejecución. (Vista de Despliegue)
2
Servidor Web y Aplicaciones
Servidor Web y Aplicaciones
Servidor de Aplicaciones
Procesador: x86 32 Bits,
x86 64 Bits.
Memoria: 2 GB Ram
Disco: 20GB – 8GB (Libres)
OS: Multiplataforma
Engine
Servidor de Datos
MDServer
Procesador: x86 32 Bits,
x86 64 Bits.
Memoria: 1 GB Ram
Disco: 40GB – 16GB
(Libres)
OS: Multiplataforma
ClienteProcesador: x86 32 Bits,
x86 64 Bits.
Memoria: 1 GB Ram
Disco: 10GB – 4GB (Libres)
Tarjeta Grafica: 512 Gb
OS: Multiplataforma
Viewer VCL
GUI CLI
La herramienta de visualización VisIt, funciona de forma distribuida. El cliente se encuentra conformado por un cliente pesado con los componentes encargados de representar gráficamente la visualización, y los componentes de control. Este cliente se comunica con el Engine (Paralelizado o en serie) para recibir los datos requeridos al graficar. Por otro lado los componentes se comunican con el MDServer cuando requieren información de datos locales o remotos.
Ilustración 4 Modelo de Red. (Vista de Despliegue)
2 Aunque VisIt puede ser ejecutado desde diferentes Sistemas Operativos, la librería LibSim no es
actualmente soportada por Windows.
13
Los diferentes componentes de la aplicación dependen de tecnologías que soportan procesos relacionados con los requerimientos de VisIt al producir elementos de computación grafica. La librería Visualization Toolkit (VTK), soporta el procesamiento y la representación grafica de datos, adicionalmente OpenGL, Qt y MESA son utilizados para el procesamiento de imágenes. Así mismo VisIt depende de una gran cantidad de formatos de entrada y salida entre estos se encuentran: Silo, HDF5, HDF4, Exodus, NetCDF, etc [5].
Ilustración 5 Modelo de Dependencias Tecnológicas. (Vista de Despliegue)
Servidor Web y Aplicaciones
Servidor Web y Aplicaciones
Servidor de Aplicaciones
Procesador: x86 32 Bits,
x86 64 Bits.
Memoria: 2 GB Ram
Disco: 20GB – 8GB (Libres)
OS: Multiplataforma
Servidor de Datos
MDServer
Procesador: x86 32 Bits,
x86 64 Bits.
Memoria: 1 GB Ram
Disco: 40GB – 16GB
(Libres)
OS: Multiplataforma
ClienteProcesador: x86 32 Bits,
x86 64 Bits.
Memoria: 1 GB Ram
Disco: 10GB – 4GB (Libres)
Tarjeta Grafica: 512 Gb
OS: Multiplataforma
Viewer
VCL
GUI
CLI
VTK
I/O Libs
VTK
I/O Libs
MESA
OPEN
GL
Engine
Qt
Phyton
VTK
OpenGL
14
3.4 Comunicación.
Internamente los componentes se comunican en el nivel más bajo utilizando sockets, sin embargo a nivel de aplicaciones esta comunicación se lleva a cabo de dos formas diferentes. Inicialmente el Viewer se comunica con los componentes de presentación utilizando el patrón Publicador/Suscriptor. El Viewer almacena los estados en un pool definido por la clase AttributeSubject, los componentes interesados en estos estados se subscriben y reciben una actualización cada vez que el Viewer las pública. En adición los componentes se comunican entre sí por intermedio de proxys a los que se les delega la comunicación a través de Remote Procedure Calls (RPC) [6]. Por otro lado la comunicación entre una simulación independiente y la herramienta de visualización se realiza de forma bidireccional. Inicialmente permitiendo que VisIt lea los datos directamente en tiempo de proceso, y en adición permitiendo que la simulación reciba estímulos desde la herramienta de visualización que generen consecuencias dentro del modelo. (Los cambios en el modelo generados por los estímulos de VisIt deben ser procesados y visualizados en tiempo real.) En primer lugar el desarrollo de la simulación integrada a VisIt se basa en la incorporación a la simulación en C++ de la librería LibSim de VisIt, esta librería permite la conexión entre las dos aplicaciones e inicialmente habilitará el canal para que el motor de procesos interprete los datos en tiempo de ejecución importándolos desde la simulación y no desde el servidor de bases de datos. [5]
3.5 LibSim
La librería se integra a la simulación utilizando los includes: VisItControlInterface_V1.h y
VisItDataInterface_V1.h, estos se deben agregar dentro de los encabezados del programa. [7]
Adicionalmente el linker del compilador debe incluir el archivo libsim.a y por ultimo al desarrollar
sobre el ambiente UNIX la simulación, esta debe vincularse a la librería de carga dinámica
(Dynamic Loader Library) debido a que LibSim utiliza la función dlopen al cargar la librería de
procesos dinámicamente.
Con el fin de ilustrar de forma sencilla como se enlaza la librería utilizamos el ejemplo básico en
base a la documentación de LibSim. Iniciando una simulación con el siguiente código en C++:
15
3
Al código anterior se le deben agregar las siguientes librerías que le permitirán comunicarse con el
VisIt Compute Engine Library (VCEL), componente que le permite a VisIt capturar los datos
directamente desde la simulación.
Dentro del orden de prioridades requeridas para que LibSim pueda generar una comunicación con
el motor de procesos, se encuentra en primer lugar la invocación de la función
VisItSetupEnvionment, esta le permite agregar las variables de entorno necesarias al cargar plug-
ins, dependencias, etc. Posteriormente, se debe invocar la función
VisItInitializeSocketAndDumpSimFile que habilita la creación del archivo .sim donde VisIt recibe
las condiciones iníciales de la comunicación con la simulación, [8] como lo son el nombre del
equipo, la ruta de la simulación, la llave de comunicación, entre otras.
Al realizar estas adiciones la simulación cuenta con la inicialización de la librería, una vez
inicializada se debe proceder a modificar el main con el fin de permitir extender la comunicación
con VisIt. El modelo del mundo debe contar con un componente específico que permita identificar
cada paso de la simulación, y por medio de este enviar los datos sucesivamente hacia VisIt a través
de LibSim. Posteriormente al realizar la modificación del componente que identifica cada paso de
la simulación (loop), pueden agregarse las funciones específicas de LibSim que interactúan con
VisIt en tiempo de ejecución.
Las funciones agregadas al loop son las siguientes:
VisItDetectInput: escucha conexiones en el puerto especifico asignado al inicializar LibSim, esta función es la encargada de manejar los pasos de la simulación dependiendo de las respuestas de VisIt al recibir los datos, o de los time outs generados si no se recibe respuesta de la aplicación.
VisItAttemptToCompleteConnection: cuando la función VisItDetectInput retorna 1, se procede a llamar la función VisItAttemptToCompleteConnection. Esta es la encargada de
3 LLN, Getting Data Into Visit Chpt 5 pg 144
16
realizar el llamado al componente VCEL y al Viewer. Cuando esta conexión es exitosa la simulación aparecerá con el nombre identificado en el archivo .sim dentro de la ventana de simulaciones en la interfaz grafica de VisIt.
4
4 LLNL, Getting Data Into Visit Chpt 5 pg 148
17
VisItProcessEngineCommand: si la función VisItDetectInput devuelve el valor 2, la función VisItProcessEngineCommand procesa las órdenes enviadas por el Viewer de VisIt hacia la simulación, y le envía a través del VCEL los siguientes pasos de la simulación.
Una vez se encuentra activa la comunicación se debe proceder a establecer un lenguaje, que
permite desarrollar el proceso de datos por parte del motor y le permite generar las graficas al
Viewer de Visit. Con esta función se define un lenguaje preestablecido en una interfaz de VisIt
denominado Visit Data Interface (VDI) [7]. Este debe especificar cada tipo de grafica desarrollada.
3.6 Visit Data Interface (VDI)
La herramienta de visualización se apoya sobre el VDI, esta interface se encarga de hacer llegar los
datos al VCEL en un formato estructurado que le permite al motor de procesos determinar qué
tipo de grafica debe generar. El archivo de la librería que se debe incluir en la simulación es
VisItDataInterface_V1.h y en este se definen los tipos de estructuras de datos. [8] El acceso de
datos se le permite a VisIt utilizando los objetos de tipo visitCallbacks, que hacen parte de la
librería VDI. Al implementar la simulación se agrega la librería de la interface VDI y se implementa
un objeto de tipo metadata, el cual será el que recibe VisIt con las estructuras de datos.
5
Posteriormente, se define el estado de la simulación dentro del objeto metadata. A continuación,
en este caso particular se pasan datos que representan una representación grafica sencilla. La
representación de la grafica es almacenada en un arreglo dinámico dentro del objeto
VisIt_SimulationMetaData, cada posición del arreglo contiene un objeto de tipo
VisIt_MeshMetaData que define el tipo de objeto a graficar, el nombre, unidades, etc.
Una vez definida la función que permite entregar al VisIt los datos en un formato estructurado, se
debe agregar a la función visitCallBacks un apuntador que retorne la dirección del objeto
metadata. Al definir la función de tipo rectilínea se define el número de dimensiones (2 o 3), el
tamaño de los objetos del arreglo, y el número de objetos en el arreglo. Adicionalmente se define
la variable de tipo baseIndex que determina a qué distancia se desplaza del origen la grafica.
Dependiendo de la grafica se deben definir los valores máximos y mínimos si se quiere acotar la
5 LLNL Documentación VDI, Getting Data Into Visit Pg. 165
18
representación y posteriormente se deben pasar los arreglos de coordenadas, la función
VisIt_CreateDataArrayFromFloat le permite a la librería VDI pasar la referencia de los objetos en la
simulación.
6
Al terminar los procesos anteriores se logra la comunicación permitiendo a VisIt procesar los datos
desde el programa de simulación. Sin embargo, VisIt no interactúa con el problema de la
simulación y no afecta su ejecución. Buscando generar una interacción con la simulación se debe
desarrollar una interface, sobre el cual la VisIt permita generar llamados a métodos dentro de la
simulación. 6 LLNL Documentación VDI, Getting Data Into Visit Pg. 169
19
4. Simulación de Prueba
Con el fin de evaluar la capacidad de la herramienta al visualizar modelos independientes se realiza una simulación con características estructurales y funcionales. [9]
4.1 Características
Se desarrolla una simulación de prueba que permita observar la viabilidad de VisIt al representar gráficamente información de una simulación independiente. Esta simulación cuenta con elementos cuyos estados son estáticos (Edificios), y elementos cuyos estados son dinámicos (Carros). La simulación cuenta con la lógica de negocio necesaria para que los carros avancen a lo largo del espacio definido, y la herramienta de visualización se encarga de representar cada paso utilizando la información generada por el modelo.
4.2 Implementación
El modelo básico cuenta con dos estructuras encargadas de representar los edificios y los
automóviles. Los automóviles cuentan con unas coordenadas que determinan su posición (x,y,z) y
una variable que determina la dirección en la cual se está moviendo. Los edificios por su parte solo
cuentan con la información relacionada con el centro de su posición (x,y,z) y su altura.
Adicionalmente, dentro de la simulación se cuenta con la clase responsable de determinar el
terreno de la ciudad en el espacio.
Dentro de la clase simulación se desarrolla la lógica que permite generar los edificios y
automóviles en el sistema. Adicionalmente la simulación al simular un paso permite a los
automóviles avanzar dentro del espacio.
Ilustración 6: Diagrama de Compontes de la Simulación Integrada con VisIt
Simulacion
InterfaceSimulacion
VCEL
VIEWERGUI
ViewerProxyVCELProxy
20
Ilustración 7 Diagrama de Clases Detallado de la Simulación
Simulacion
Automovil Edificio Terreno
InterfaceSimulacion
VDI
1
*
1
*
1
*
LibSim
4.2.1 Edificios y Automóviles
Inicialmente se definen las estructuras básicas que permiten visualizar cubos que posteriormente representarán edificios y automóviles en el modelo.
Ilustración 8 Visualización de Edificios
Los edificios se invocan desde la interfaz LibSim como un Mesh sin estructura, y se definen en la herramienta de visualización utilizando el método remoto de VisitGetMesh. De la misma forma se definen los cubos que representan los automóviles a partir de una grilla,
21
adicionalmente se desarrolla la lógica de la aplicación para que los automóviles realicen un movimiento positivo a lo largo del eje x.
Ilustración 9 Visualización de Automóviles y Edificios
4.2.2 Interacción con la Simulación.
La simulación puede ser dirigida en tiempo real por la herramienta de visualización utilizando la invocación de métodos remotos a partir de la interface VDI que permite comunicar la interfaz grafica de VisIt con la simulación. En la simulación se definen métodos que permiten modificar la dirección de un automóvil desplazándolo hacia la derecha, izquierda, adelante o atrás. Posteriormente estos métodos se integran a la interface LibSim utilizando el método ControlCommandCallback se recibe la información sobre las órdenes enviadas por VisIt a la simulación.
Implementación de método para hacer llamados a la simulación.
7
7 LLNL Getting Data Into Visit Pg. 177
22
5. Conclusiones
En base al trabajo realizado se puede determinar que VisIt es una herramienta de visualización extensible y con la arquitectura necesaria para soportar la conexión a modelos de simulación externos.
Los componentes principales en el desarrollo de simulaciones que requieran este tipo de comunicación son la interface LibSim, y el componente VisIt Data Interface.
De la misma forma encontramos que al incluir la librería LibSim dentro de la simulación se puede desarrollar la interface que genera los datos en el formato requerido por VisIt, y por medio del cual se desarrolla la Visualización.
Adicionalmente utilizando la librería LibSim de VisIt, se crea una comunicación bidireccional que le permite a la herramienta de Visualización controlar la ejecución de la simulación en tiempo real. Esto permite detener el proceso de simulación, aplicar cambios y posteriormente observar las consecuencias de los cambios en la visualización.
23
6. Bibliografía
1. Robert Spence, Information Visualization Design For Interaction, 2da Ed., Editorial Prentice
Hall: Inglaterra, Imperial College: Inglaterra, 2007.
2. Chaomei Chen, Information Visualization Beyond the Horizon, Editorial Springer-Verlag:
Inglaterra, 2006.
3. Ibarra Juan; Hernández José, Esquema de Representación para Sistemas Complejos: Una
Aplicación a Sistemas Urbanos, Universidad de Los Andes: Bogotá, 2009.
4. U.S. Department of Energy by Lawrence Livermore National Laboratory, Visit History,
(2009, Marzo) [En Línea], https://wci.llnl.gov/codes/visit/about.html.
5. U.S. Department of Energy by Lawrence Livermore National Laboratory, VisIt User’s
Manual, Version 1.5, Octubre 2005. [En Línea],
https://wci.llnl.gov/codes/visit/manuals.html
6. Gamma Erich, et Al, Design Patterns: Elements of Reusable Object-Oriented Software. Editorial Addison-Wesley: Estados Unidos, 1995.
7. Visualization Toolkit, (2009, Marzo), [En Línea], http://www.vtk.org/.
8. U.S. Department of Energy by Lawrence Livermore National Laboratory, Getting Data Into
Visit, Version 1.5.4, Septiembre 2006. [En Línea],
https://wci.llnl.gov/codes/visit/manuals.html
9. Oscar Javier Chavarro et Al, Esquema de Representación Espacial Multinivel para el Modelamiento Geométrico de Sistemas Complejos, Grupo IMAGINE, Universidad de los Andes: Bogota 2008.
10. Rozanski Nick, Software Systems Architecture, 3ra Edición, Editorial Addison-Wesley: Estados Unidos, 2007.