UNIVERSIDAD DE LOS ANDESFACULTAD DE INGENIERIA
ESCUELA DE SISTEMASDEPARTAMENTO DE INVESTIGACION DE OPERACIONES
“MODELADO Y SIMULACION POR EVENTOSDISCRETOS MEDIANTE REDES DE PETRI USANDO
SIMPY”
P: Mı E P V
P U L A
I S
T:P. Sı M
M 2007
Vive la vida, afrontala!
porque buena o mala...
no tenemos otra
Anonimo
Dedicatoria
Yo, Marıa Eugenia, dedico este nuevo paso de mi vida :
A Dios Todopoderoso y a la Virgen Santısima por acompanarme con su presencia
en cada uno de los momentos buenos y duros que se me presentaron a lo largo de la
elaboracion de este trabajo y de toda la carrera.
A la memoria de mi abuelo Tive, ¡lo logre!, tu nieta es universitaria!.
A los pilares fundamentales de mi vida: Dalia del Rosario y Juan Antonio, mis padres.
Porque uds son ejemplo vivo del sacrificio, de la fuerza de voluntad, del amor, en fin por
existir, ¡Los amo!.
A mi hermana: Daniela Carolina, por el solo hecho de ser y estar, que mi logro sea
ejemplo para tı y dentro de poco tambien nos muestres tus logros, ¡Te quiero mucho!.
A mi abuela y a mi tıa: Eugenia y Ziomara, por ensenarme que el amor de madre es
compartido, por la entrega incondicional, los consejos y las palabras alentadoras en lo
momentos oportunos,¡Las quiero mucho!
A mi familia: por estar pendiente de mi y por brindarme su apoyo.
Dedicatoria
Al hombre que llego a mi vida para llenarla de amor y de sentimientos unicos: Daniel
Jose. Porque has demostrado ser mi mejor amigo, mi companero y apoyo en las buenas y
malas, sin mas... porque !Te amo!.
A mis amigos: Ricci, Marıa Alexandra, Chuy, Gabi, Nanda, Dioren, Iva , Jenny,
por ensenarme que aun existen tesoros como dice la biblia, y por tantas experiencias
compartidas a lo largo de estos anos.
Agradecimientos
A Dios y la Virgen por darme la vida, la salud y la capacidad para llegar a este escalon
en mi vida profesional.
A la Ilustre Universidad de Los Andes especialmente a la Facultad de Ingenierıa por
permitirme formar parte de esta gran familia y darme las herramientas necesarias para
desempenarme como profesional universitario.
A el Prof. Sebastian Medina, por ser mas que el tutor, ser el amigo que supo entregar
su tiempo y sus conocimientos en la elaboracion de este proyecto, con gran calidad
profesional y sentido de responsabilidad.
A todas las personas que de manera directa o indirecta colaboraron conmigo a lo largo
de mi formacion academica, personal y cultural
¡Gracias!
Resumen
En este trabajo se muestra el desarrollo de una metodologıa que permite interpretar la estructura
de modelos sencillos elaborados con el formalismo de modelado Redes de Petri y Redes de Petri
Coloreadas, con el objetivo de analizar su comportamiento dinamico a traves de la aplicacion de la
tecnica de simulacion por eventos discretos utilizando un entorno de simulacion de codigo abierto
llamado SimPy.
Por ser un primer intento en la elaboracion de este enfoque metodologico, las estructuras de los
modelos en Redes de Petri que se seleccionan para desarrollar las pruebas son basicas, y enfocadas
a la representacion de situaciones que se originan en procesos sencillos de logıstica, fabricacion y
servicios que puedan ser simulados bajo el paradigma de orientacion a procesos.
Esta metodologıa se manifiesta mediante la construccion de una sencilla herramienta compu-
tacional programada en codigo Python; funciona en modo texto y para modelos con estructuras
predefinidas. El resultado que se obtiene hasta el momento, es una herramienta que recibe un mode-
lo estatico de Red de Petri, interpreta sus relaciones jerarquicas y causales; y realiza una busqueda
de las funciones existentes en SimPy que aproximen al comportamiento dinamico del sistema mo-
delado, ejecuta la simulacion y genera por pantalla los resultados.
La herramienta puede ser modificada cuantas veces se desee para aumentar su aplicabilidad a
otros tipos de modelos, en provecho de las ventajas que posee Python y SimPy al ser “opensource”.
Palabras Clave:
Simulacion, Modelos, Redes de Petri, SimPy
Indice General
1. Introduccion 1
1.1. Introduccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2. Antecedentes de la investigacion . . . . . . . . . . . . . . . . . . . . . . . 2
1.3. Planteamiento del problema . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4. Justificacion e importancia de la investigacion . . . . . . . . . . . . . . . . 4
1.5. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5.1. Objetivo general . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5.2. Objetivos especificos . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6. Metodos y herramientas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.7. Delimitacion del estudio . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2. Marco Teorico 8
2.1. Redes de Petri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.1. Definiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.2. Propiedades de las Redes de Petri . . . . . . . . . . . . . . . . . . 14
2.1.3. Tipos de Redes de Petri . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2. Redes de Petri Coloreadas . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.1. Definiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.2. Ventajas de los formalismos Redes de Petri y Redes de Petri Colo-
readas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2.3. Analisis de Modelos de Redes de Petri . . . . . . . . . . . . . . . . 20
INDICE GENERAL
2.2.4. Las Redes de Petri y Redes de Petri Coloreadas como herramienta
de modelado para la simulacion por eventos discretos . . . . . . . . 22
2.3. Simulacion de sistemas orientados a eventos discretos . . . . . . . . . . . . 23
2.3.1. Elemenos de un modelo de simulacion . . . . . . . . . . . . . . . . 24
2.3.2. Estrategias de simulacion . . . . . . . . . . . . . . . . . . . . . . . 26
2.4. SimPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.4.1. Clases de SimPy . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.4.2. Programacion de los eventos en SimPy . . . . . . . . . . . . . . . 29
2.4.3. Funciones para la interaccion de procesos . . . . . . . . . . . . . . 30
2.4.4. Control de la simulacion en SimPy . . . . . . . . . . . . . . . . . . 30
3. Diseno e implementacion 32
3.1. Introducion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.2. Analisis de la estructura de la Red de Petri . . . . . . . . . . . . . . . . . . 34
3.3. Analisis del modelo conceptual . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3.1. Ventajas de los modelos conceptuales . . . . . . . . . . . . . . . . 36
3.3.2. Relacion entre los modelos conceptuales y las Redes de Petri . . . . 36
3.4. Restricciones sobre los modelos . . . . . . . . . . . . . . . . . . . . . . . 40
3.5. Tipos de modelos a desarrollar . . . . . . . . . . . . . . . . . . . . . . . . 40
3.6. Implementacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.6.1. Programacion en Python . . . . . . . . . . . . . . . . . . . . . . . 41
3.6.2. Programacion de modelos en SimPy . . . . . . . . . . . . . . . . . 50
3.6.3. Utilizacion de la herramienta . . . . . . . . . . . . . . . . . . . . . 54
4. Ejemplos de Aplicacion 57
4.1. Modelo 1: Llegada-Servicio-Salida . . . . . . . . . . . . . . . . . . . . . . 57
4.1.1. Ejemplo: Cajero Automatico . . . . . . . . . . . . . . . . . . . . . 58
4.1.2. Ejemplo: Manufactura de piezas . . . . . . . . . . . . . . . . . . . 61
4.2. Modelo 2: Dos procesos en secuencia . . . . . . . . . . . . . . . . . . . . 64
INDICE GENERAL
4.2.1. Ejemplo: Subsistema de una linea de produccion . . . . . . . . . . 64
4.2.2. Ejemplo: Servicio de autolavado . . . . . . . . . . . . . . . . . . . 67
4.3. Modelo 3: Dos procesos en paralelo . . . . . . . . . . . . . . . . . . . . . 70
4.3.1. Ejemplo: Mantenimiento de equipos . . . . . . . . . . . . . . . . . 71
5. Conclusiones y Recomendaciones 74
5.1. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.2. Recomendaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Bibliografıa 78
A. Codigo fuente herramienta RdPCSimPy 80
Indice de Tablas
4.1. Resultados de la simulacion: Cajero automatico . . . . . . . . . . . . . . . 60
4.2. Resultados de la simulacion: Manufactura de piezas . . . . . . . . . . . . . 63
4.3. Resultados de la simulacion: Lınea de produccion . . . . . . . . . . . . . . 67
4.4. Resultados de la simulacion: Lınea de produccion . . . . . . . . . . . . . . 70
4.5. Resultados de la simulacion: Mantenimiento de equipos . . . . . . . . . . . 73
Indice de Figuras
2.1. Red de Petri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2. Formas correctas e incorrectas de conexion . . . . . . . . . . . . . . . . . 10
2.3. Resultado de disparar una transicion . . . . . . . . . . . . . . . . . . . . . 11
2.4. Ejecucion secuencial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.5. Concurrencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.6. Decision/Conflicto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.7. Sincronizacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.8. Agrupacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.9. Red de Petri con arco inhibidor . . . . . . . . . . . . . . . . . . . . . . . . 15
2.10. Mecanismo de simulacion de SimPy . . . . . . . . . . . . . . . . . . . . . 28
3.1. Elementos considerados para el desarrollo de la metodologıa . . . . . . . . 33
3.2. Modelo de Red de Petri . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3. Modelo 1: Sistema cliente-servidor . . . . . . . . . . . . . . . . . . . . . . 41
3.4. Modelo 2: Proceso sencuencial (Evento externo) . . . . . . . . . . . . . . . 42
3.5. Modelo 3: Proceso sencuencial (Dependencia entre recursos) . . . . . . . . 42
3.6. Modelo 4: Concurrencia de entidades, dos procesos en un mismo bloque . . 43
3.7. Modelo 5: Dos procesos en paralelo . . . . . . . . . . . . . . . . . . . . . 43
3.8. Paso 0: Crear archivo de Python . . . . . . . . . . . . . . . . . . . . . . . 44
3.9. Estructuracion de la herramienta . . . . . . . . . . . . . . . . . . . . . . . 55
3.10. Ejecutar la herramienta . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
INDICE DE FIGURAS
4.1. RdPC Ejemplo: Cajero Automatico . . . . . . . . . . . . . . . . . . . . . . 60
4.2. RdPC Ejemplo: Manufactura . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.3. RdPC Ejemplo: Lınea de produccion . . . . . . . . . . . . . . . . . . . . . 66
4.4. RdPC Ejemplo: Servicio de autolavado . . . . . . . . . . . . . . . . . . . . 69
4.5. RdPC Ejemplo: Mantenimiento de equipos . . . . . . . . . . . . . . . . . 72
Capıtulo 1
Introduccion
En este capıtulo se desarrollan los fundamentos que sustentan la importancia del pre-
sente proyecto, a saber: antecedentes, planteamiento del problema, justificacion e impor-
tancia, objetivos, metodologıas y herramientas. Con el objeto de enmarcar al lector dentro
del contexto del area de investigacion en el que se desarrolla el mismo.
1.1. Introduccion
A medida que la tecnologıa contribuye a mejorar los sistemas existentes en el mundo
empresarial, industrial, social y academico, estos se han hecho mas complejos a la hora
de representarlos de manera analıtica y estructural. Es por ello que han surgido metodo-
logıas que permiten a los analistas de sistemas supervisar los sistemas y tomar decisiones
oportunas y eficientes.
Una de las tecnicas utilizadas para tales fines, es la simulacion digital que siempre va
acompanada previamente por una metodologıa de modelado que extrae los elementos de
interes para un estudio en particular.
1
CAPITULO 1. INTRODUCCION 2
El presente trabajo de investigacion pretende contribuir con el desarrollo de la simula-
cion y mostrar las potencialides de la metodologıa de modelado Redes de Petri Coloreadas
para el analisis estructural y dinamico de sistemas sencillos mediante el desarrollo de una
herramienta computacional de codigo abierto.
Este informe resume el desarrollo de la investigacion en cinco capıtulos que se descri-
ben a continuacion:
En el Capıtulo 1, se identifica el proyecto, sus objetivos, antecedentes, justificacion e
importancia y los metodos y herramientas utilizados.
En el Capıtulo 2, se desarrollan todos los ascpectos teoricos referentes a las Redes de
Petri, Redes de Petri Coloreadas, simulacion por eventos discretos, Python y SimPy.
En el Capıtulo 3, se detalla como fue programada la herramienta, sus modulos de
programacion y la forma en como funciona.
En el Capıtulo 4, se muestran los prototipos de modelos para los cuales la herramien-
ta funciona, los resultados obtenidos y su comparacion con otros paquetes de simulacion
conocidos.
Finalmente, en el Capıtulo 5, se muestran las conclusiones acerca del trabajo y las
recomendaciones para futuras investigaciones en el area.
1.2. Antecedentes de la investigacion
Desde 1960 hasta 1980, el desarrollo de modelos de simulacion orientados a eventos
discretos se basaba directamente en el uso de los lenguajes de programacion o de lengua-
jes especializados en simulacion asociados a los tres marcos de trabajo mas extendidos:
CAPITULO 1. INTRODUCCION 3
programacion de sucesos, exploracion de actividades, interaccion de procesos.
[Antoni Guasch et al., 2005]. Los primeros entornos de simulacion orientados a eventos
discretos aparecen a principios de los 80, y pueden ser definidos como una “toolbox” con
un numero limitado de herramientas de programacion de alto nivel.
Las herramientas de simulacion orientadas a eventos discretos, actualmente, ofrecen
una plataforma que permite abordar con exito un proceso de mejora continua de siste-
mas complejos en los cuales, las tecnicas analıticas clasicas basadas en el uso de calculo
diferencial, teorıa de probabilidades y metodos algebraicos no pueden ser utilizadas para
formalizar de modo sencillo la complejidad de sus procesos.
La simulacion ofrece a los analıstas de sistemas resultados que contribuyan en la toma
de decisiones, sin embargo, no posee la propiedad de verificar por si sola que el comporta-
miento del sistema sea semejante a la realidad. Esto depende de la construccion previa del
prototipo a escala del sistema en estudio (modelo), que debe formalizar el conocimiento
que tiene del mismo de manera concisa, sin ambiguedades y cuya informacion pueda ser
extraıda y soportada por un computador.
A medida que los sistemas se muestran mas complejos, se ha hecho necesario desarro-
llar metodologıas de modelado que posean mejores niveles de abstraccion, especificamente
en los anos 90 el desarrollo de estos formalismos tuvo un gran crecimiento. Una de esas
metodologıas son las Redes de Petri Coloreadas cuyos fundamentos estan basados en la
metodologıa original de los anos 60: Redes de Petri. La principal diferencia que aportan
las Redes de Petri Coloreadas respecto a las Redes de Petri ordinarias es la capacidad de
manejar estructuras de datos en vez de objetos simples.
En la actualidad existen numerosas herramientas de simulacion para redes de petri y re-
des de petri coloreadas, casi en su totalidad tienen interes estrictamente academico dado
que su potencial practico esta muy alejado del de las herramientas comerciales de simu-
lacion, algunas son: Flor, Herramientas CPN, Artifex, Golpecito, entre otras, coinciden en
CAPITULO 1. INTRODUCCION 4
ser gratuitas, multiplataformas y poseen interfaz grafica para la representacion de la red,
desarrolladas en su mayorıa con C++. La mas usada es CPN-Toll. Estas herramientas to-
man directamente el modelo y lo ejecutan originando resultados de manera inmediata, sin
embargo puede existir la inquietud de emplear una herramienta de simulacion convencional
sacandole provecho a las potencialidades de la Red de Petri Coloreada, en atencion a que
estas herramientas se consideran mucho mas maduras a nivel de aplicaciones empresaria-
les.
1.3. Planteamiento del problema
En base a lo comentado en la seccion anterior, en este trabajo de investigacion se pre-
tende desarrollar una metodologıa que permita capturar un modelo sencillo elaborado en
Red de Petri Coloreada en su forma estatica, para luego ser simulada en un entorno de
simulacion para eventos discretos ya existente, que ademas es programada para hacer uso
de un entorno de simulacion de codigo abierto llamado SimPy y cuyo paradigma es el de
orientacion a procesos.
Se desea que la herramienta se muestre sencilla, y que no sea impresindible que el usuario
conozca el funcionamiento detallado del paquete de simulacion SimPy, es decir, basta con
que el usuario conozca y manipule correctamente la metodologıa de modelado.
1.4. Justificacion e importancia de la investigacion
Las razones por las cuales surge la idea de elaborar este trabajo son en principio las
siguientes: 1) Indagar y aprender acerca del formalismo Redes de Petri, como un novedo-
so formalismo de modelado ideal para la representacion de sistemas orientados a eventos
discretos, y que hasta el momento ha tenido poco desarrollo y, 2) Manejar un paquete de si-
CAPITULO 1. INTRODUCCION 5
mulacion relativamente nuevo, que ha mostrado buenos resultados y que posee las ventajas
de ser “opensource” y multiplataforma. Algunos aspectos que permiten dar justificacion e
importancia a este trabajo de investigacion son:
La metodologıa se desarrolla utilizando un lenguaje de programacion de codigo
abierto y permitira que nuevos usuarios inserten en la herramienta nuevos aspec-
tos para mejorar su rango de aplicacion y ası contribuir con la formacion de entornos
abiertos que permitan que la sociedad en general perciba los beneficios de las mis-
mas.
Brindar soluciones a problemas de modelado y simulacion de manera rapida y con-
fiable
Dar a conocer una metodologıa de modelado y un paquete de simulacion que permita
a los interesados en el area desarrollar nuevas ideas.
1.5. Objetivos
1.5.1. Objetivo general
Desarrollar una metodologıa que permita interpretar la estructura de un modelo senci-
llo en Red de Petri, con el objeto de conocer su comportamiento dinamico a traves de la
simulacion por eventos discretos utilizando el paquete de simulacion SimPy.
CAPITULO 1. INTRODUCCION 6
1.5.2. Objetivos especificos
Utilizar la metodologıa de modelado de las Redes de Petri y Redes de Petri Colorea-
das para la elaboracion de la metodologıa.
Revisar y utilizar los conceptos de simulacion orientada a eventos discretos.
Aprender la estructura y funcionamiento del paquete de simulacion SimPy.
Desarrollar una sencilla herramienta conputacional utilizando el lenguaje de progra-
macion Python y el paquete de simulacion SimPy.
Contribuir con el desarrollo de herramientas de codigo abierto en el area de modelado
y simulacion.
Comparar los resultados obtenidos con herramientas de simulacion comerciales
conocidas.
1.6. Metodos y herramientas
Para la realizacion de este trabajo, se utiliza fundamentalmente el enfoque de simula-
cion por eventos discretos que es considerada por si sola una metodologıa para el estudio y
analisis de sistemas cuyo comportamiento en el tiempo no es continuo ni periodico.
En cuanto a la parte de modelado de sistemas y como base fundamental de este trabajo, la
metodologıa a desarrollar es la de Redes de Petri y Redes de Petri Coloreadas.
La programacion de la herramienta se lleva a cabo utilizando un lenguaje de programacion
de alto nivel llamado Python, que a su vez es el codigo fuente del paquete de simulacion
SimPy, la herrmienta final que permite llevar a cabo las simulaciones de los modelos.
CAPITULO 1. INTRODUCCION 7
1.7. Delimitacion del estudio
En este trabajo se desea mostrar una version inicial de este tipo de metodologıa especi-
ficamente para ser utilizada conjuntamente con el paquete de simulacion SimPy, por tanto,
los modelos en Red de Petri y Red de Petri Coloreadas son basicos, de pocos elementos
y estructuras simples y que ademas puedan ser interpretados bajo el paradigma de simula-
cion de orientacion a procesos para garantizar resultados correctos en respeto al enfoque
que utiliza el paquete de simulacion.
Para el desarrollo de esta metodologıa, se consideraran muchas de las ideas de algunos
autores [Antoni Guasch et al., 2005], que enfocan el uso de las Redes de Petri y Redes de
Petri Coloreadas para la representacion y estudio de situaciones que ocurren frcuentemente
en procesos sencillos de fabricacion, logıstica y servicios. En atencion a lo anterior, los mo-
delos que se utilizan para desarrollar este enfoque metodologico estan sometidos a algunas
restricciones de tipo estructural y de simplicidad, utilizando algunos tipos de estructuras
como prototipos, cuyos colores y funciones ya son conocidas tales como: estados de recur-
sos, clasificacion de entidades y de lıneas de espera, movimiento constante de entidades a
traves de la red (una a una),etc.
Estos aspectos acerca de las restricciones de la herramienta y de los tipos de modelos
seran detallados en los capıtulos 3 y 4 del presente documento.
Capıtulo 2
Marco Teorico
En este capıtulo se detallan y explican todos los aspectos teoricos que se estudian para
llevar a cabo el desarrollo de esta metodologıa, en lo que se refiere al modelado con Redes
de Petri, los conceptos de Simulacion por eventos discretos y el paquete de Simulacion
SimPy.
2.1. Redes de Petri
2.1.1. Definiciones
Las Redes de Petri son una metodologıa de modelado creada en 1962 por Karl Petri y
fueron presentadas en su trabajo doctoral “Kommunikation mit Automaten”. Su principal
caracterısitca es que permiten representar de manera natural situaciones de sincronizacion,
paralelismo y relaciones causa-efecto entre los componentes de un sistema.
Son una alternativa de modelado grafico y matematico de pocas y faciles relaciones sintacti-
cas que permiten analizar la estructura de un sistema, ası como su comportamiento a traves
del tiempo.
8
CAPITULO 2. MARCO TEORICO 9
Garcıa (ver [Garcıa, 2003]), menciona en su tesis que estos modelos pueden ser implemen-
tados de forma automatica utilizando tecnicas hardware o software, y pueden ser utilizados
con fines de monitorizacion de sistemas una vez que se encuentren en funcionamiento. En
otras palabras se pueden usar durante todo el ciclo de vida del sistema.
Desde el punto de vista grafico, las Redes de petri se definen como un grafo bipartito
compuesto basicamente por dos tipos de nodos: transiciones y lugares que se conectan
mediante segmentos orientados llamados arcos. La utilizacion de los nodos transicion por
lo general esta relacionada con la ocurrencia de eventos y su representacion grafica es
rectangular, los nodos lugar, permiten representar las actividades y su forma grafica es
circular.
Existen dos terminos muy importantes que se manejan comunmente en esta metodologıa y
son la habilitacion de una transicion y el disparo de una transicion. La habilitacion permite
modelar si un evento puede o no ocurrir y con el disparo se origina al menos un cambio de
estado en el sistema.
Desde el punto de vista matematico, una Red de Petri puede ser definida como una tupla
de la forma:
RdP = (P,T, A,W, M0)
Donde:
P = [p1, p2, ..., pnp] :Vector de nodos tipo lugar.
T = [t1, t2, ..., tnt] :Vector de nodos tipo transicion.
A = [A1, A2, ..., Ana] :Vector de arcos
W = Ai − − > [1, 2, 3, ...] :Peso asociado a cada arco
M0 = Pi − − > [1, 2, 3, ...] :Numero de marcas iniciales en cada nodo tipo lugar
El estado del sistema queda totalmente determinado por el marcado inicial en los nodos
CAPITULO 2. MARCO TEORICO 10
tipo lugar y puede ser descrito matematicamente por el vector P.
La figura ??, ejemplifica una Red de Petri.
T1 P1 T2 P2
A1 A2 A3
A4
Figura 2.1: Red de PetrilabelRdP1
Modelar mediante la metodologıa de Redes de Petri es sencillo, solo hay que manejar
las siguientes reglas:
1. No pueden conectarse por un mismo arco dos nodos tipo transicion.
2. No pueden conectarse por un mismo arco dos nodos tipo lugar.
Figura 2.2: Formas correctas e incorrectas de conexion
3. El peso asociado a cada arco por defecto es uno (1), si es distinto a este valor debe
representarse de forma explicita al lado del respectivo arco.
4. Es recomendable definir una funcion que permita asociar a cada arco sus nodos ter-
minales, esta funcion servira para el analisis estructural y logico del modelo ası como
CAPITULO 2. MARCO TEORICO 11
2
1
1
1
2
1
1
1
Figura 2.3: Resultado de disparar una transicion
garantizar que el modelo sea correcto en atencion a que para cada arco su nodo origen
y final deben ser de tipos diferentes.
La sola representacion grafica de un sistema mediante una Red de Petri permite conocer
su estructura, sin embargo, la dinamica del mismo esta sujeta a un conjunto de reglas tales
como:
a) Una transicion Ti esta habilitada cuando en cada nodo lugar conectado a su entrada
exite al menos el mismo numero de marcas que el valor del peso W del arco que los
conecta. Esto de forma matematica es:
M(P j) >= W(P j,Ti) = M(P j) >= W(A ji)
b) Una transicion Ti habilitada puede dispararse en cualquier momento.
c) El resultado de disparar la transicion Ti es eliminar de cada uno de los nodos lugar
de entrada, el mismo numero de marcas que indica el peso W de cada arco que los
conecta.
Las Redes de Petri son un formalismo de modelado muy util para representar los me-
canismos propios de procesos orientados a eventos discretos, en atencion a una serie de
aspectos tales como:
CAPITULO 2. MARCO TEORICO 12
T1
T2
T3
P1
P2
Figura 2.4: Ejecucion secuencial
T1
P1
T4T3T2
P2 P3
Figura 2.5: Concurrencia
1. Ejecucion secuencial: dependencia causal entre eventos.
2. Concurrencia: ocurre mas de un cambio en el sistema al mismo instante en que se
activa un evento.
3. Toma de decisiones: ocurre cuando el disparo de una transicion supone la inhabili-
tacion de otras. Estos conflictos pueden ser resueltos de forma determinısta o proba-
bilıstica.
4. Sincronizacion: esta estructura es empleada a menudo cuando se esta espera de un
recurso o de varios tipos de entidades para proseguir con la activacion de un evento.
CAPITULO 2. MARCO TEORICO 13
T1 T2 T3
P1
Figura 2.6: Decision/Conflicto
P3P2P1
T1
P4
Figura 2.7: Sincronizacion
5. Agrupacion: las marcas provienen de diferentes caminos y se agrupan en un mismo
lugar.
T1 T2 T3
T4
P1
Figura 2.8: Agrupacion
CAPITULO 2. MARCO TEORICO 14
2.1.2. Propiedades de las Redes de Petri
Un sistema esta Acotado si el espacio de estados es finito, es decir, si tiene todos los
lugares acotados (numero maximo de marcas).
Un sistema esta Vivo si desde cualquier marcado que se pueda alcanzar existe una
secuencia de disparos que habilita cualquier transicion del sistema.
Que un sistema no tenga bloqueos es una restriccion mas debil que la vivacidad ya
que solo verifica que una transicion se pueda disparar.
Un sistema es Reversible si desde cualquier marcado que se pueda alcanzar se puede
volver al marcado inicial.
Si un sistema tiene bloqueos, no es reversible.
En un sistema existe Exclusion Mutua si, o bien no se pueden disparar simultanea-
mente dos transiciones o bien no se pueden marcar simultaneamente dos lugares.
La exclusion mutua modela el uso de recursos compartidos.
Un sistema es Seguro si para todos los lugares de la Red de Petri el numero de marcas
nunca excede la unidad.
Un sistema es Persistente si para dos transiciones habilitadas, el disparo de una de
ellas no inhabilita la otra.
Esta propiedad es importante en situaciones de paralelismo y sincronizacion.
CAPITULO 2. MARCO TEORICO 15
2.1.3. Tipos de Redes de Petri
El modelado basico de una Red de Petri ha incentivado a una nueva comunidad de in-
vestigadores que se han encargado de modificar el modelo original dando lugar a nuevas
extensiones con el objetivo de ampliar el rango de aplicacion, mejorar el analisis cuanti-
tativo y estructural del modelo, ası como en algunos casos simplificar su uso para casos
especıficos.
Elementos nuevos que se han incluido en la estructura de una Red de Petri son los arcos
inhibidores, representados graficamente por un circulo en un extremo que sustituye a la
punta de la flecha. Es utilizado para inhibir transiciones, es decir, la transicion no se dispara
si para el lugar de entrada, origen del arco inhibidor, existe marca alguna; estos arcos sirven
para aumentar la expresividad del modelo. De forma general, un arco inhibidor modifica la
condicion de disparo de una transicion a:
M(P j) < W(P j,Ti) = M(P j) < W(A ji)
Figura 2.9: Red de Petri con arco inhibidor
Redes de Petri con Prioridad Le es asociado a las transiciones del modelo un numero
entero positivo que indique una prioridad que determina la habilitacion y por tanto el dis-
CAPITULO 2. MARCO TEORICO 16
paro de las mismas. El uso de este enfoque permite solucionar situaciones de conflicto, en
donde sera habilitada, para un instante dado, la transicion con valor de prioridad mas alto.
Redes de Petri con Tiempo Es quizas la extension que mejor ha contribuido a esta me-
todologıa de modelado. Permite describir el comportamiento dinamico de la Red de Petri y
analizar la evolucion en los cambios de estado, ası como determinar las duraciones de cada
accion tomada por el sistema, a saber: cuando se habilita y dispara una transicion y cuan-
to tiempo permanece una marca dentro de un lugar. Existen diversas formas de introducir
el concepto de tiempo, sobresalen dos: el uso de tiempo determinısta y el uso de tiempo
estocastico.
2.2. Redes de Petri Coloreadas
2.2.1. Definiciones
Las Redes de Petri Coloredas fueron introducidas por Kurt Jensen en la decada de los
90, y su aporte a la metodologıa basica de Redes de Petri es la incorporacion de manejo
de datos que permiten elaborar modelos parametricos con el uso de marcas distinguibles,
expresiones de arco condicionales y disparo de transiciones de caracter selectivo.
Con este nuevo tipo de redes, se puede simplificar el tamano de los modelos mediante
la creacion de de estructuras de datos similares a las utilizadas en los lenguajes de progra-
macion, que facilita al modelador crear, codificar y modificar su modelo otorgandole su
propio nivel de abstraccion y su propia especificidad.
Las marcas dentro de los nodos tipo lugar ahora asocian informacion que se denominan
colores (equivalentes al concepto de atributos), el flujo de informacion por los arcos,la
CAPITULO 2. MARCO TEORICO 17
habilitacion y disparo de las transiciones ahora estan condicionados de acuerdo al tipo de
color que se mueve a traves de la red o una seccion de ella.
Kurt Jensen en el ano 1992 (ver [Antoni Guasch et al., 2005]) definio matematicamente
una Red de Petri Coloreada mediante la siguiente tupla:
RdPC = (Cc, P,T, A,N,C, E, I)
Donde:
Cc = [C1,C2, ...,Cc] : Conjuntos finitos y no vacıos de colores. Permite especificar los
atributos deben definirse para cada tipo de entidad que se quiera modelar. Ci son los colores
(atributos) de la entidad de tipo i.
P = [p1, p2, p3, ..., pnp] : Vector de nodos tipo lugar
T = [t1, t2, t3, ..., tnt] : Vector de nodos tipo transicion
A = [A1, A2, ..., Ana] : Vector de arcos
N = N(Ai) : Funcion de nodo. Permite asociar a cada arco sus nodos terminales (origen y
destino).
C = C(Pi) : Conjunto de funciones color. Permiten especificar para cada nodo lugar el tipo
de entidades que se pueden almacenar. Cada nodo lugar solo puede tener objetos con el
mismo tipo de datos
G = G(Ti) : Funcion de guarda. Se utiliza para desinhibir el evento asociado a la transicion
en funcion de los valores de loa atributos de la entidad que se quiera procesar.Admiten solo
expresiones booleanas
E = E(Ai) : Expresion de arco. permite especificar el tipo de dato que debe fluir entre los
nodos origen y terminal del arco Ai.
I = I(Pi) : Funcion de inicializacion. Permite especificar los valores de los colores de las
entidades inicialmente almacenadas en cada nodo tipo lugar.
Graficamente, las expresiones de inicializacion expresan el numero de objetos en un
nodo lugar con un numero en un cırculo al lado del nodo. Los colores de los objetos se
CAPITULO 2. MARCO TEORICO 18
especifican mediante una expresion subrayada junto al nodo lugar con la siguiente infor-
macion:
n′(c1, c2, c3, ..., ck)
Donde:
1. n: numero de objetos con los valores de los colores descritos dentro del parentesis,
2. ci: es el valor del color i.
Cuando en un mismo lugar existen objetos con diferentes valores de color entonces se
utiliza el operador “+” para especificar por separado la cantidad y el tipo de objeto.
La evolucion de las marcas se define a traves de una regla de ocurrencia o disparo
conocida como un juego de marcas. Segun esta regla, el comportamiento del sistema se
rige por las siguientes normas:
1. Una transicion esta habilitada si la guarda G(Ti) se evalua a Cierto y en los lugares
de entrada hay el numero de marcas que indican los arcos de entrada y estas tienen
los atributos (colores) especificados.
2. El disparo o ocurrencia de una transicion habilitada es una operacion instantanea que
por una parte extrae de cada lugar de entrada el atributo o atributos que indican los
arcos de entrada y por otra parte coloca en cada lugar de salida el numero de objetos
que indican los arcos de salida.
CAPITULO 2. MARCO TEORICO 19
2.2.2. Ventajas de los formalismos Redes de Petri y Redes de Petri
Coloreadas
De manera general, las ventajas del formalismo basico se pueden resumir ası:
1. Representan de forma explicita los estados y los eventos del modelo.
2. Los mecanismos de concurrencia, sincronizacion y paralelismo estan representados
de manera natural.
3. El conjunto de recursos compartidos y restringidos se representan explicitamente en
el modelo.
4. Existen muy pocas reglas para la construccion de los modelos.
5. La representacion grafica de los modelos es muy intuitiva lo que permite comprender
el modelo a simple vista.
6. Su semantica es muy precisa y sin ambiguedades.
7. Una vez construido el modelo, su estudio dinamico vıa simulacion es independiente
de la herramienta empleada.
Las Redes de Petri Coloreadas por ser una extension del formalismo basico, tambien po-
seen las ventajas antes mencionadas, sin embargo con el agregado del manejo de colores
aparecen nuevas ventajas tales como:
CAPITULO 2. MARCO TEORICO 20
1. Las expresiones de arco permiten parametrizar las transiciones, facilitando su codi-
ficacion para ser utilizadas para varios tipos de eventos en vez de un unico evento
como ocurrıa en las Redes de petri basicas.
2. Los sistemas con situaciones de paralelismo pueden ser reducidos a estructuras mas
simples gracias a la existencia de atributos.
3. El nivel de detalle de un sistema queda en manos del modelador quien ahora puede
incorporar mediante estructuras de datos (colores) los aspectos que considere rele-
vantes, permitiendo que su modelo sea de uso general o especıfico para cierta aplica-
cion.
2.2.3. Analisis de Modelos de Redes de Petri
Cuando se construye un modelo de algun sistema o subsistema mediante Redes de Petri
en cualquiera de sus extensiones, se desea conocer un conjunto de relaciones jerarquicas
y de causa efecto, ası como de comportamientos dinamicos a traves del tiempo. Para ello,
existen tambien una serie de enfoques que centran su atencion en algunas propiedades del
modelo.
El objeto de realizar un analisis al modelo en Red de Petri es conocer aspectos que deter-
minen si el mismo representa a la realidad de la manera correcta y si es cierto que es util
para un estudio en particular, dicho en otras palabras, si se analiza un modelo se puede
contribuir con el proceso de validacion y verificacion al momento de conocer resultados de
la simulacion.
En el caso de este formalismo de modelado, el analisis se concentra en los siguientes as-
pectos:
Determinacion de bloqueos en el sistema.
CAPITULO 2. MARCO TEORICO 21
Encontrar los posibles caminos para alcanzar un estado final a partir de un estado
inicial
Obtener el conjunto de estados posibles a los que se puede llegar a partir de un estado
inicial
Para llevar a cabo el analisis de un modelo en Red de Petri se utilizan las siguientes tecnicas:
Construccion de un arbol de alcance El problema de alcance consiste en determinar
el conjunto de estados M a los que se puede acceder a partir de un estado inicial M0, una
forma es construir el arbol de alcance mediante las siguientes reglas:
La raız del arbol es un nodo que guarda el estado inicial del sistema M0
Para cada uno de los nodos del arbol se generan tantos nodos hijos como transiciones
hay activadas en el estado de la Red de Petri que representa este nodo. Los arcos que
conectan los nodos padres con los hijos representan la transicion que se ha disparado.
Cuando se genera un nodo hijo que ya existe en algun nivel anterior o igual al actual,
se identifica al mismo como nodo old y no se generan nuevos hijos a partir de el.
Un nodo del arbol que no tiene ninguna transicion habilitada se marca como dead
end.
Un nodo que no esta marcado como old o como dead end es un nodo new
El arbol de alcance permite determinar si una Red de Petri es acotada, tambien determina
si el modelo esta bien dimensionado o es que su comportamiento en verdad es inestable.
CAPITULO 2. MARCO TEORICO 22
Construccion de un arbol de Cobertura Es una variante del arbol de alcance que se
utiliza cuando el modelo en Red de Petri no es acotado.
2.2.4. Las Redes de Petri y Redes de Petri Coloreadas como herra-
mienta de modelado para la simulacion por eventos discretos
En un sistema real se pueden observar subsistemas que van desde lo mas complejo
hasta lo mas insignificante, lo importante es saber identificar en esta gama, cuales de es-
tos subsistemas representan dinamicas interesantes para el analisis del mismo, bajo ciertas
condiciones de un estudio particular. Es por ello que los sistemas se representan mediante
modelos cuyos niveles de detalle los define el analista en atencion a los objetivos propues-
tos y prever con cierta certeza que los resultados de su estudio arrojen conclusiones que se
puedan obtener sobre la observacion directa del sistema.
La simulacion no verifica, es por ello que es importante que el modelo este elaborado
correctamente, por tanto, va acompanada previamente por el modelado. Entre los anos 1960
y 1980, el desarrollo de modelos orientados a eventos discretos se basaba directamente so-
bre lenguajes de programacion o de lenguajes de caracter especıfico en simulacion basados
en tres enfoques: programacion de sucesos, exploracion de actividades e interaccion de
procesos. Esta tendencia comenzo a presentar limitaciones en cuanto la dependencia en-
tre el modelo y la herramienta de programacion lo cual dificultaba el mantenimiento, la
modificacion y la reutilizacion del modelo para nuevos estudios.
A partir de los anos 80, el modelado de sistemas de gran complejidad dio inicio a nuevas
investigaciones en el desarrollo de formalismos y metodologıas de modelado que permitan
especificar modelos conceptuales y con propiedades tales como independencia del entorno
de simulacion, facil identificacion de componentes para descomposicion o simplificacion,
capacidad de modularizacion y facil representacion sintactica y de ser posible, grafica.
CAPITULO 2. MARCO TEORICO 23
Los modelos de eventos discretos, manejan fundamentalmente dos conceptos: evento y
actividad. Las redes de Petri y las redes de Petri coloreadas, son un formalismo de modelado
que representan de manera natural un modelo de eventos discretos.
2.3. Simulacion de sistemas orientados a eventos discretos
Para Guasch (2005), [Antoni Guasch et al., 2005] la simulacion digital es una tecnica
que permite imitar en un computador el comportamiento de un sistema real o hipotetico
segun ciertas condiciones particulares de operacion.
Hoy dıa los campos en los que se aplica la tecnica de la simulacion van desde situa-
ciones cotidianas como por ejemplo un semaforo peatonal, hasta situaciones de altos
niveles cientıficos tales como investigaciones en bio-ingenierıa. En el caso partıcular del
enfoque orientado a eventos discretos, la simulacion se utiliza para representar acciones
instantaneas en tiempos no periodicos, que pueden cambiar el estado actual del sistema en
estudio.
La simulacion se refiere a la realizacion de pruebas experimentales sobre el modelo del
sistema bajo estudio con el objeto de obtener resultados que permitan prever con cierta
exactitud los resultados que se obtendrıan directamente sobre el sistema real.
Existen algunas alternativas para la simulacion de modelos de eventos discretos tales
como:
Simulacion del modelo estatico
Simulacion a mano
Simulacion mediante un lenguaje de proposito general
CAPITULO 2. MARCO TEORICO 24
Experimentacion mediante un entorno de simulacion.
2.3.1. Elemenos de un modelo de simulacion
Segun Guasch (2005), los principales elementos que conforman un modelo de simula-
cion son:
Entidades: representan el conjunto de elementos que conforman el sistema tales
como: personas, piezas, maquinas, transportes, etc.
Pueden ser clasificadas en dos grupos:
• Entidades permanentes: son elementos estaticos del sistema, en cuanto a que
su numero no se modifica a lo largo de la simulacion. Suelen representar los
medios utilizados para ejecutar actividades y las principales propiedades obser-
vadas en ellos son capacidad, estado, velocidades, entre otras.
• Entidades temporales: son elementos que se generan y destruyen a lo largo del
tiempo en que se lleva a cabo la simulacion, su dinamica se resume en llegar,
procesar y salir del sistema.
En el caso del modelado en Redes de Petri se representan por las marcas dentro de
los nodos tipo lugar.
Actividades: son las distintas acciones que tienen lugar en el sistema e involucran a
las entidades tanto temporales como permanentes, por tanto estan condicionados a la
existencia de las mismas. Un aspecto importante en las actividades es su duracion, la
cual puede ser constante o un proceso estocastico y debe ser un parametro conocido
para que el simulador pueda determinar su inicio y finalizacion.
Eventos: puede definirse como una accion instantanea que se origina en el sistema y
CAPITULO 2. MARCO TEORICO 25
que conlleva a un cambio en las variables de estado. Normalmente, las actividades se
inician o finalizan con la aparicion de un evento que ası lo indique.
Existe clasificacion para los eventos como se muestra a continuacion:
• Eventos condicionados: para que se activen es necesario que se cumpla una o
mas condiciones.
• Eventos no condicionados: son los que estan planificados para su ejecucion y
que no dependen de condiciones para su activacion.
• Eventos internos: ocurren por condiciones que impone el mismo sistema.
• Eventos externos: ocurren por condiciones externas al modelo.
En las Redes de Petri, son representados por la habilitacion y disparo de transiciones.
Colas: son estructuras que se originan en los sistemas a partir de una coleccion de
entidades temporales ordenadas de una forma logica. Las entidades en colas sufren
retardos de tiempo de duracion indeterminada.
Atributos: son los elementos que permiten caracterizar a las entidades, por ejemplo:
tamanos, tipos, precios, capacidad, estados, entre otras. En el formalismo de Redes
de Petri Coloreadas corresponden a los colores.
Parametros de entrada: son las medidas de comportamiento que deben ser conocidas
antes de la ejecucion de la simulacion, por ejemplo: tiempos entre llegadas, dura-
ciones de los procesos, numero maximo de entidades, cantidad de recursos, tipos de
colas, etc.
Parametros de salida: son las medidas de comportamiento que se reflejan como re-
sultados de la simulacion, por ejemplo: tiempos promedio en cola y de duracion de
procesos, numero mınimo y maximo de entidades procesadas, etc.
CAPITULO 2. MARCO TEORICO 26
2.3.2. Estrategias de simulacion
Las estrategias de simulacion, son las diferentes formas para seleccionar el siguiente
evento que se va a llevar a cabo en atencion al tiempo que marca el reloj del simulador.
Las mas conocidas son (textos tomados del libro de Antoni Guasch, ver
[Antoni Guasch et al., 2005]):
Programacion de eventos
Exploracion de actividades
Orientacion a procesos
Programacion de eventos. Su principal caracterıstica es que solo se programan las ruti-
nas para manejar los eventos no condicionados. La programacion de esta estrategia se basa
en la creacion de una lista de eventos futuros (LEF), que contiene una entrada para todos
los eventos no condicionados que se deben ejecutar en el futuro. Existe un codigo ejecutivo
que se encarga de explorar en la lista el campo del evento que posea el valor del tiempo de
activacion mas cercano y mueve el reloj de simulacion hasta el mismo. La longitud de la
LEF varıa a medida que transcurre la simulacion.
Interacion de procesos. Esta estrategia se basa en los procesos que sufre la entidad a
medida que se desplaza por el sistema. Considera como elemento fundamental a la entidad
y por tanto, permite diferenciar claramente a las temporales de las permanentes. El codigo
ejecutivo mantiene un registro de cada una de las entidades temporales, indicando en que
estado se encuentra dentro del proceso. Un proceso es una secuencia de eventos, actividades
y retardos. La ventaja que muestra esta estrategia es que permite la construccion de modulos
de alto nivel en los cuales la interaccion de procesos se maneja de forma automatica por
CAPITULO 2. MARCO TEORICO 27
el simulador. Los estados en los cuales se puede encontrar una entidad temporal en algun
instante de tiempo son: activa,demorada,detenida.
Exploracion de actividades. En esta estrategia se emplea un manejo de tiempo mediante
incrementos fijos. Los modelos se desarrollan tomando como punto de vista las actividades
que se deben ejecutar y sus respectivas condiciones. Es importante encontrar una longi-
tud en los incrementos de tiempo adecauda para que no se pasen por alto algunas de las
actividades.
2.4. SimPy
SimPy es un entorno de simulacion creado por Klaus G. Muller, quien lo define (ver
[Muller, 2005a]) como un paquete de simulacion por eventos discretos, orientado a objetos,
basado en procesos, escrito y llamado desde un lenguaje de programacion interpretado
llamado Python y se encuentra dentro de la lınea de desarrollo de software libre.
SimPy hace uso de los generadores de funciones de Python, es por ello que es im-
portante que la persona interesada en manejar este entorno debe previamente, chequear el
funcionamiento de este lenguaje. En este sentido SimPy aprovecha la capacidad de estos
generadores, lo que permite al usuario especificar que una funcion haga enlace con la lis-
ta de eventos, ejecute el evento, actualice el reloj de simulacion y finalmente esta misma
funcion es nuevamente reinsertada en el ultimo punto de salida, esto dicho de otra mane-
ra, permite alternar con la ejecucion de otras funciones que conforman el mismo sistema
modelado. El mecanismo de simulacion de SimPy se resume en la figura 2.10.
SimPy maneja fundamentalmente tres tipos de objetos procesos, recursos y monitores,
mediante la creacion de clases con las cuales representa el flujo de entidades, y registra y
CAPITULO 2. MARCO TEORICO 28
time to zeroSet simulation
(1)Determine next executable model program segment
(2)Update clock
(3)Pass control to selectedsegment
initialize()
simulate(until=endtime)
segmentcode code code
segment segment1 2
.....n
def drive(self)speed=50yield hold,self,25
def drive(self)speed=50yield hold,self,25
Generator atributes in Process instances
StartSimulation
Figura 2.10: Mecanismo de simulacion de SimPy
analiza la historia de variables a medida que lasimulacion avanza.
2.4.1. Clases de SimPy
Clase Process(): permite modelar una entidad ligada a una actividad y que a su vezevoluciona a traves del tiempo, dando lugar a diferentes cambios en el sistema. Paraque un modelo de SimPy pueda ser simulado, se requiere un mınimo de un objetoProcess y este a su vez requiere al menos un metodo de ejecucion que describa laaccion del mismo. Por ejemplo:
class Customer(Process):
# ‘‘objeto de la clase proceso’’
def visit(self,timeInBank):
#‘‘Metodo de ejecucion’’
print "%7.4f %s: Here I am"%(now(),self.name)
yield hold,self,timeInBank
#‘‘uso de geneador de python’’
print "%7.4f %s: I must leave"%(now(),self.name)
Clase Resource(): permite modelar un conjunto de entidades fijas que se utilizan paralos procesos, por ejemplo: cajeros, maquinas, etc. Poseen la capacidad de modelar
CAPITULO 2. MARCO TEORICO 29
colas, e indicar a las entidades si su estado es ocupado o no. Le son modificadosatributos para el manejo de capacidad y la forma de seleccion de las entidades (FIFO,prioridad, etc.). Por ejemplo:
R=Resource(capacity=1,name="xxxx")
Clase Monitor(): permite controlar la historia de las variables de estado y permiterecopilar estadısitcas tales como media, varianza, totales, etc., ademas proporcionaherramientas para costruir histogramas. Ejemplo:
X=Monitor()
X.observe()
X.mean()
X.var()
2.4.2. Programacion de los eventos en SimPy
Como se ha venido diciendo SimPy utiliza las capacidades de los generadores de Pyt-
hon para ejecutar los eventos y actualizar variables de estado y el reloj de simulacion,
especificamente utiliza para ello la palabra reservada yield. A continuacion se muestran
algunas de las formas utilizadas y su descripcion:
yield hold,self,<holdtime>
Esta llamada reactiva el proceso sobre el que actua (self ) despues que se ha consumido un
tiempo igual al indicado en holdtime.
yield passivate,self
Esta llamada identifica al proceso (self ) como pasivo, es decir, lo suspende hasta que se
cumpla cierta condicion y sea reactivado mediante la funcion reactivate()
CAPITULO 2. MARCO TEORICO 30
yield request,self,<resource>
Se utiliza para solicitar un recurso para llevar a cabo el proceso (self ), si el recurso esta ocu-
pado se reserva la entidad en una cola.
yield release,self,<resource>
Se utiliza para liberar un recurso que esta siendo ocupado por una entidad dentro del pro-
ceso (self ).
2.4.3. Funciones para la interaccion de procesos
activate(<instancia de proceso>,<metodo de ejecucion>,<tiempo de activacion>)
Esta funcion identifica a un proceso en estado activo y lo coloca en la lista de eventos.
cancel(<instancia de proceso>)
Esta funcion identifica a un proceso en estado pasivo.
interrupt(<instancia de proceso>)
Se interrumpe el proceso y este es reactivado si existe otro evento programado que lo utilice.
2.4.4. Control de la simulacion en SimPy
Todo modelo programado en SimPy debe invocar las siguientes funciones para poder
llevar a cabo la simulacion del mismo, ellas son:
CAPITULO 2. MARCO TEORICO 31
initialize()
Esta funcion crea la lista de eventos, generando ası un set de simulacion para el tiempo
cero.
simulate(until=<endtime)
Permite la ejecucion de todas las actividades programadas hasta que se llegue al valor de
tiempo endtime.
Las lıneas anteriores explican basicamente el funcionamiento del paquete SimPy, mas
adelante en el siguiente capıtulo se muestra un modelo construido con las principales fun-
ciones de este paquete de simulacion.
Capıtulo 3
Diseno e implementacion
En el presente capıtulo, se explican con detalle las diferentes etapas llevadas a cabo
para desarrollar e implementar esta nueva metodologıa. Se parte desde los aspectos del
modelado en Redes de Petri que sean utiles, y se llega hasta la programacion en Python y
SimPy.
3.1. Introducion
Es importante tener presente cual es el objetivo que persigue el desarrollo de esta meto-
dologıa, el cual es: interpretar un modelo sencillo en Red de Petri o Red de Petri Coloreada
desde el punto de vista de la simulacion por eventos discretos, es decir, saber extraer o cap-
turar desde una representacion estatica de la red aquellos elementos y conceptos que en
conjunto permitan estudiar el sistema representado por la misma a traves del tiempo (com-
portamiento dinamico) mediante la tecnica de la simulacion, en este caso, bajo el enfoque
del flujo de entidades u orientacion a procesos.
Con este objetivo presente, se puede entonces comprender que no se busca realizar
32
CAPITULO 3. DISENO E IMPLEMENTACION 33
una simulacion directa sobre la Red de Petri, es decir no se trata de vigilar disparos de
transiciones, actualizar marcados, etc. sino comprender una estructura mediante la cual
un conjunto de entidades temporales y recursos se combinan para llevar a cabo procesos,
actividades, servicios, entre otros. El formalismo de Redes de Petri posee elementos que de
manera natural permiten representar los eventos, las actividades y los flujos de entidades, a
saber las transiciones, los lugares y los arcos respectivamente; y la simulacion permite dar
vida a estas estructuras manejando los parametros de tiempo y ocurrencia de los eventos.
Se puede decir entonces que el desarrollo de la metodologıa se resume en tres etapas:
analisis de la estructura de la Red de Petri, analisis del modelo conceptual y su implemen-
tacion.
SISTEMA MODELOCONCEPTUAL
MODELO EN RED DE PETRI
ESTRUCTURA DEL MODELO
ELABORACIONDEL
CUESTIONARIO
IMPLEMENTACIONSimPy Python
Figura 3.1: Elementos considerados para el desarrollo de la metodologıa
CAPITULO 3. DISENO E IMPLEMENTACION 34
3.2. Analisis de la estructura de la Red de Petri
El analisis de la estructura permite alcanzar conclusiones rapidas sobre el comporta-
miento del sistema, relacionando propiedades estructurales y de comportamiento. Capturar
los elementos estructurales de la Red de Petri es el primer paso a realizar una vez que el
modelador desea estudiar la dinamica de su modelo. Para llevar a cabo este analisis se con-
sideran los elementos del modelo matematico y de las reglas de construccion del modelo
grafico, de manera tal que el interesado en utilizar esta metodologıa se encuentre familiari-
zado con la informacion que le sea solicitada.
La informacion acerca de la estructura que se requiere es la siguiente:
Numero de nodos tipo lugar: esta solicitud permite almacenar en una estructura vec-
torial el numero de nodos tipo lugar que posee el modelo y se le permite al usuario
darle nombre a cada uno de sus elementos.
Numero de nodos tipo transicion: esta solicitud permite almacenar en una estructura
vectorial el numero de nodos tipo transicion que posee el modelo, tambien se le
permite al usuario darle nombre a cada una de las transiciones.
Numero de arcos: se le pregunta al usuario la cantidad de arcos que posee el modelo,
en este caso se almacenan en una estructura vectorial ası: [A1, A2, A3, ..., An]
Construccion de las funciones de nodo para cada arco (nodos terminales de cada
arco): utilizando la informacion del vector de arcos, los nodos lugar y los nodos
transicion se pregunta al usuario el nodo origen y terminal para cada uno de los arcos.
Esta informacion se almacena siempre y cuando el usuario introduzca correctamente
los nodos en respecto a las reglas para la construccion de Redes de Petri. En este
sentido se verifica que el modelo sea valido desde el punto de vista del formalismo
de modelado.
CAPITULO 3. DISENO E IMPLEMENTACION 35
P1
P4
A1
A2
A3A6
A4 A5
A7
0’(x)
1’(0)
T1
T2
T3
P2 P3
Figura 3.2: Modelo de Red de Petri
Ejemplo:
Para el siguiente modelo (ver figura 3.2), la informacion acerca de la estructura que se
extrae es la siguiente:
Numero de nodos tipo lugar: 4
lugares = [p1, p2, p3, p4]
Numero de nodos tipo transicion: 3
transicion = [t1, t2, t3]
Numero de arcos: 7
arcos = [A1, A2, A3, A4, A5, A6, A7]
Funciones de nodo: 7
f n = [A1 : [t1, p1], A2 : [p1, t2], A3 : [t2, p2], A4 : [p2, t3], A5 : [t3, p3], A6 :
[p3, t1], A7 : [t3, p4]]
CAPITULO 3. DISENO E IMPLEMENTACION 36
3.3. Analisis del modelo conceptual
El objetivo principal de los modelos conceptuales es el de constituir una especificacion
formal del modelo de simulacion.
3.3.1. Ventajas de los modelos conceptuales
A. Guasch [Antoni Guasch et al., 2005] explica que las ventajas de disponer de un mo-
delo conceptual frente a la descripcion textual de un problema de simulacion son:
Los modelos conceptuales recogen de forma detallada y precisa las relaciones
dinamicas entre los diferentes elementos del proceso en estudio por tanto, consti-
tuyen en sı mismos una especificacion del modelo del proceso o sistema que se desea
analizar a traves de la simulacion.
El modelo conceptual facilita el dialogo y la coordinacion entre todas las partes im-
plicadas en el estudio.
El modelo conceptual es una representacion independiente de la herramienta de si-
mulacion escogida.
3.3.2. Relacion entre los modelos conceptuales y las Redes de Petri
Las Redes de Petri a diferencia de los modelos clasicos de redes de colas, permiten for-
malizar de manera explıcita clientes, peticiones, recursos y procesos con el uso de marcas
y colores en el caso de las extensiones coloreadas. Otra propiedad que ofrecen las Redes de
Petri es su grado de libertad en cuanto a la escogencia del nivel de abstraccion ideal para el
sistema en estudio, sin embargo, en opinion de muchos autores [Antoni Guasch et al., 2005,
CAPITULO 3. DISENO E IMPLEMENTACION 37
pp. 57] la caracterıstica que le da potencia a este formalismo de modelado es la descripcion
de las relaciones estado-evento.
En el caso de los sistemas de produccion, la ocurrencia de eventos no depende sola-
mente de la estructura del sistema, sino de la informacion asociada a los elementos que lo
integran o de las entidades temporales o permanentes que fluyen por el mismo. Es en este
sentido que, utilizando ahora la informacion estructural de la Red de Petri, el siguiente paso
para desarrollar la metodologıa es relacionar estos elementos con el modelo conceptual del
sistema en atencion al enfoque de interaccion de procesos para la simulacion por eventos
discretos.
Este analisis se hace otorgandole a los elementos de la red propiedades de uso, basados
en los aspectos mas utilizados en la simulacion por eventos discretos, especificamente para
sistemas productivos sencillos de fabricacion, logıstica y servicios.
Los principales eventos que ocurren en este tipo de sistemas son llegadas, decisiones,
inicio y fin de actividades; y los diferentes cambios de estados del sistema se observan en
las colas, dentro de los procesos, utilizacion de los recursos y puntos de almacenamiento.
Ası, se relacionan los elementos de la estructura con los elementos mencionados ante-
riormente mediante las siguientes interrogantes:
¿Que tipo de evento representa cada nodo tipo transicion?.
¿Que uso le da a cada nodo tipo lugar?.
¿Que nombre reciben las entidades temporales que fluyen a traves de la red?.
¿Cuantos recursos hay en el sistema?.
¿Que atributos poseen las entidades temporales y los recursos?.
CAPITULO 3. DISENO E IMPLEMENTACION 38
Para responder algunas de ellas, se provee al usuario de una serie de alternativas que
previamente fueron seleccionadas mediante el estudio del formalismo de modelado Redes
de Petri aplicado a los tipos de sistemas que se han venido mencionando.
Para ejemplificar lo dicho en el parrafo anterior se muestran los tipos de respuesta para
algunas de las interrogantes, ası:
¿Que uso le da a cada nodo tipo lugar?.
Opciones:
Almacenar entidades.
Representar colas.
Entidad en proceso.
Representar la existencia de un recurso
¿Que tipo de evento representa cada nodo tipo transicion?.
Opciones:
Llegadas.
Inicio de actividad.
Fin de actividad.
Punto de decision.
Una vez que el usuario seleccione su alternativa, se realizaran otra serie de preguntas
referidas a cantidades, tipos, etc.
CAPITULO 3. DISENO E IMPLEMENTACION 39
Otras de las preguntas, se responden de manera directa, por ejemplo:
¿Que nombre reciben las entidades temporales que fluyen a traves de la red?
Respuestas: personas, piezas, vehıculos, etc.
Finalmente, la pregunta acerca de los atributos esta ligada directamente con el formalis-
mo de modelado, especificamente las Redes de Petri Coloreadas. En cuanto a este aspecto,
los atributos (colores) que se le asignaran a los diferentes elementos del sistema estan de
alguna manera predefinidos (para este estudio). Esto se realiza de esta manera porque a
nivel de la implementacion resulta complejo estructurar todos los atributos que el usuario
desee darle a su modelo y que finalmente no constituyen informacion util respecto a la
simulacion del sistema.
Los aspectos del sistema que se consideraron para conformar conjuntos de colores son:
Clasificacion de entidades.
Identificacion de la cola (en caso de que hayan varias).
Estado de un recurso (libre, ocupado).
Forman parte tambien del modelo conceptual los distintos parametros de entrada tales
como: tiempos entre llegadas, duracion de las actividades, tiempo total de simulacion, etc.,
los cuales tambien le son solicitados al usuario una vez que ya el modelo de la red ha sido
extraıdo. Ahora bien, toda esta informacion es organizada en diferentes tipos de estructuras
para luego ser interpretada como un modelo de simulacion por eventos discretos que pueda
ser ejecutado en SimPy.
CAPITULO 3. DISENO E IMPLEMENTACION 40
3.4. Restricciones sobre los modelos
Para el desarrollo de esta metodologıa, se establecieron algunas restricciones acerca de
la estructura de la Red de Petri y algunos parametros para la simulacion.
1. Las expresiones de arco son unitarias, ese decir, el movimiento de entidades a traves
de la red es constante y de una en una.
2. Las expresiones de guarda para las transiciones se asumen booleanas con dos valores
true y false, y su actualizacion no se hace de manera explicita, sino que lo hace el
mismo paquete de simulacion SimPy cuando maneja los eventos.
3. El consumo de tiempo ocurre dentro de un bloque transicion-lugar-transicion, esta
restriccion permite que la dinamica del modelo pueda ser interpretada bajo el para-
digma de interaccion de procesos.
Tambien se impone una restriccion por simplificacion, considerando que el tipo de modelos
estudiados representan dinamicas sencillas.
4. Los recursos solo pueden asumir dos estados posibles: ocupado y desocupado. La
actualizacion de estas variables de estado quedan a cargo del simulador mediante el
manejo una de sus clases: “Resource”.
3.5. Tipos de modelos a desarrollar
Para este desarrollo se consideran solo algunas estructuras de modelos en Red de Pe-
tri que fueron seleccionados por representar dinamicas sencillas y comunes en procesos
productivos.
CAPITULO 3. DISENO E IMPLEMENTACION 41
P1
P4
A1
A2
A3A6
A4 A5
A7
0’(x)
1’(0)
T1
T2
T3
P2 P3
Figura 3.3: Modelo 1: Sistema cliente-servidor
Las figuras 3.3, 3.4 muestran estos tipos de modelos:
3.6. Implementacion
Como ya se ha mencionado dentro de los objetivos especıficos de esta tesis, este enfo-
que metodologico queda expresado mediante la programacion de una sencilla herramienta
en codigo Python y el paquete de simulacion SimPy.
3.6.1. Programacion en Python
Python es un lenguaje de programacion interpretado, de alto nivel y orientado a objetos
que funciona tanto en ambiente windows somo linux.
Python se utiliza para este estudio, como medio para la recepcion de la informacion
acerca del modelo conceptual y los elementos que conforman la estructura de la Red de Pe-
CAPITULO 3. DISENO E IMPLEMENTACION 42
P1
P4
1’(0)
P2 P3
1’(0)
P5
T1
T2
T3
T4
A1
A2
A3
A4 A5
A6
A7
A8 A9
A10
0’(x)
Figura 3.4: Modelo 2: Proceso sencuencial (Evento externo)
P1
P4
P2
A1
A6
A7
A3
A2
10’(x)
T3
T2
T1
P3
1’(0)
A4
A5
1’(0)P5
A9
A8
Figura 3.5: Modelo 3: Proceso sencuencial (Dependencia entre recursos)
CAPITULO 3. DISENO E IMPLEMENTACION 43
P2 P3
P1
T1 T2
T3
T4
2’(0)
0’(x)
A1 A2
A3
A4
A5 A6
A7
Figura 3.6: Modelo 4: Concurrencia de entidades, dos procesos en un mismo bloque
T3
T4
T1 T2
P3
P1
P2
A1
A3
A2
A4A5
A6
A7
A8 A9
A10
T3
P4 P5
20’(x)
1’(0)1’(0)
Figura 3.7: Modelo 5: Dos procesos en paralelo
CAPITULO 3. DISENO E IMPLEMENTACION 44
Figura 3.8: Paso 0: Crear archivo de Python
tri. Se manipulan para ello estructuras de datos tales como listas, diccionarios y funciones,
ademas se aprovecha la capacidad del lenguaje en la creacion y manejo de modulos.
Paso 0:
Ejecutar terminal y crear un archivo extension .py como se muestra en la figura 3.8:
Paso 1:
Construir cada una de las funciones que almacenan la informacion acerca de las res-
puestas que se le realizan al usuario acerca de su modelo en Red de Petri, se muestran
algunas de ellas en su respectivo codigo Python (se omiten algunas lıneas de codigo cuan-
do las funciones son extensas, esta omision se representa mediante “..........”).
CAPITULO 3. DISENO E IMPLEMENTACION 45
Informacion acerca de los lugares:
def lugar():
print ‘‘Cuantos lugares posee su red de petri coloreada?’’
np=int(raw_input())
print ‘‘Con que nombre identificara cada lugar?’’
lugares=[]
for i in range(np):
print ‘‘Nombre P%s’’%(i+1)
nom_p=raw_input()
lugares.append(nom_p)
return lugares
Informacion acerca de las transiciones:
def transiciones():
print ‘‘Cuantas transiciones posee su red de petri coloreada?’’
nt=int(raw_input())
print ‘‘Con que nombre identificara cada transicion?’’
transicion=[]
for i in range(nt):
print ‘‘Nombre T%s’’%(i+1)
nom_t=raw_input()
transicion.append(nom_t)
return transicion
Informacion acerca del numero de arcos:
def arcos():
print ‘‘Cuantos arcos posee su red de petri coloreada?’’
na=int(raw_input())
arcos=[]
for i in range(na):
arcos.append(‘‘A%s’’(i+1))
return arcos
Informacion acerca del uso de lugares y transiciones:
def uso_lugares(lugares,entidad,recursos):
print "Las redes de petri coloreadas modelan situaciones reales"
print "los lugares se utilizan para:"
print "1. almacenar entidades"
print "2. representar colas"
CAPITULO 3. DISENO E IMPLEMENTACION 46
print "3. entidades en proceso"
print "4. almacenar recurso:(libre, ocupado)"
print "en atencion a lo anterior, seleccione con un numero entero,la utilizacion de cada lugar en su RdPC"
global almacen,num_cola,proceso,recurso,uso_lugar,Cp
num_cola=0
uso_lugar={} #‘‘Diccionario’’
a_procesar=[]
aux2=[]
cola=[]
Cp={}
for i in range(len(lugares)):
print "Lugar",lugares[i],":"
print "1. almacenar entidades,2. colas,3.entidades en proceso y 4. recurso"
op=int(raw_input()
if op==1:
.......
uso_lugar[lugares[i]]=‘‘almacen’’
if op==2:
.......
uso_lugar[lugares[i]]=‘‘cola’’
if op==3:
.......
uso_lugar[lugares[i]]=‘‘proceso’’
if op==4:
.......
uso_lugar[lugares[i]]=‘‘recurso’’
return uso_lugar
def uso_transicion(transicion):
print "las transiciones se utilizan fundamentalmente para desencadenar eventos:"
print "1.Llegadas"
print "2.Inicio de proceso (de actividad)"
print "3.Fin de proceso (de actividad)"
print "4. Puntos de decision"
print "en atencion a lo anterior, seleccione con un numero entero,la utilizacion de cada transicion"
global inicio,Fin_pro,llegada,Decision,uso_tran
inicio=0
Fin_pro=0
llegada=0
Decision=0
uso_tran={}
for i in range(len(transicion)):
print "Transicion",transicion[i],":"
CAPITULO 3. DISENO E IMPLEMENTACION 47
print "1. llegadas,2. Inicio de proceso, 3. Fin de Proceso, 4. Punto de decision"
print "cuando en una transicion termina un proceso y comienza otro entonces marque en el menu la opcion 3 (fin de proceso)"
print "El programa determinara la dinamica por el uso del lugar proximo a la transicion"
op_t=int(raw_input())
if op_t==1:
print "Ud eligio transicion de llegadas"
uso_tran[transicion[i]]="llegadas"
if op_t==2:
print "Ud eligio transicion de inicio de proceso"
uso_tran[transicion[i]]="Inicio"
if op_t==3:
print "Ud eligio transicion de fin de proceso"
uso_tran[transicion[i]]="Fin"
if op_t==4:
print "Ud eligio transicion de punto de decision
uso_tran[transicion[i]]="decision"
print uso_tran
return uso_tran
Informacion acerca de entidades y recursos:
def tip_ent():
entidad=[]
print "Nombre de la entidad temporal que fluye por su RdPC"
nom_ent=raw_input()
entidad.append(nom_ent)
return entidad
def inf_rec():
print "Cuantos recursos se representan en su RdPC?"
num_rec=int(raw_input())
recursos=[]
for j in range(num_rec):
print "Nombre del recurso",(j+1)
re=raw_input()
recursos.append(re)
return recursos
Informacion de acerca de los colores:
def colores(entidad,recursos):
global col_ent,list_co,col_re
print "En esta seccion de preguntas, ud dara informacion de las entidades y recursos"
CAPITULO 3. DISENO E IMPLEMENTACION 48
print "Los colores de su RdPC seran predefinidos por este programa"
print "Para la entidad temporal, el conjunto color guarda atributos de CLASIFICACION"
print "Para los recuros, el conjunto color representa el ESTADO del mismo"
print "A saber, que los recursos solo poseen dos estados posibles"
print "OCUPADO y DESOCUPADO"
col_ent={}
list_co={}
col_re={}
li_a=[]
li_at=[]
for j in range(len(entidad)):
...........
for i in range(len(recursos)):
...........
return list_co # ‘‘Esto es una estructura tipo diccionario que almacena’’
# ‘‘el nombre del conjunto color y sus atributos’’
Las funciones mostradas anteriormente se utilizan para manejar la informacion de entrada.
Tambien existen funciones internas para organizar la informacion, de manera que se ob-
tenga una estructura que almacene el funcionamiento dinamico de la red desde el punto de
vista de la simulacion.
A continuacion se muestran fragmentos de codigo de este tipo de funciones:
Obtencion del orden logico a traves de las direcciones de los arcos: en esta funcionse maneja practicamente toda la informacion que se extrae del modelo, su objeti-vo es ordenar esta informacion de manera que se identifique claramente el flujo deentidades temporales a traves del sistema.
def orden_logico(lugares,transicion,arcos,uso_lugar,uso_tran):
fun_node=fun_nodo(lugares,transicion,arcos)
linea_logica=[]
.........
for h in range(len(arcos)):
if fun_node[arcos[k]][1]==fun_node[arcos[h]][0]:
sig0=fun_node[arcos[h]][0]
if sig0 in lugares and sig0 not in existe:
if uso_lugar[sig0]!="estado":
ord_log.append(uso_lugar[sig0])
CAPITULO 3. DISENO E IMPLEMENTACION 49
linea_logica.append([sig0,uso_lugar[sig0],arcos[h]])
existe.append(sig0)
break
elif sig0 in transicion and uso_lugar[fun_node[arcos[k]][0]]!="estado" and sig0 not in existe:
ord_log.append(uso_tran[sig0])
linea_logica.append([sig0,uso_tran[sig0],arcos[h]])
existe.append(sig0)
break
.........
return linea_logica
Eventos y actividades:
def sec_event(linea_logica):
ord_logi=[]
for i in range(len(linea_logica)):
ord_logi.append(linea_logica[i][1])
print ord_logi
return ord_logi
Tambien se construyen funciones para algunos de los parametros de entrada tales como:
Tiempo entre llegadas:
def int_lle(entidad):
............
print "Como se distribuye el tiempo entre llegadas?"
print "1. intervalos constante"
print "2. exponencial"
op=int(raw_input())
if op==1:
.........
if op==2:
.........
Tiempo de simulacion:
def t_simu():
print "Cuanto tiempo desea simular su modelo de RdPC"
ts=float(raw_input())
return ts
CAPITULO 3. DISENO E IMPLEMENTACION 50
Toda la programacion realizada en Python permite almacenar, estucturar y organizar
la informacion del modelo, de forma tal que puedan ahora crearse rutinas utilizando las
capacidades de SimPy para la simulacion de los sistemas bajo estudio.
3.6.2. Programacion de modelos en SimPy
La extraccion de todos los aspectos del modelo inherentes a la simulacion se resumeen una estructura que muestra en orden la secuencia de eventos y estados del sistema, y enun conjunto de variables que almacenan los parametros de entrada. Por ejemplo, para unmodelo de la forma indicada en la figura 3.2, la secuencia que se obtiene es:
modelo=[llegadas,cola,Inicio,proceso,Fin,salida]
Para esta secuencia de eventos se construye un modelo en SimPy que refleje este tipode dinamica de la siguiente forma:
from SimPy.Simulation import *
from random import *
class llegadas_expo1(Process): #‘‘LLegadas de tipo exponencial’’
def __init__(self,media,t_pro,d_pro):
Process.__init__(self)
self.mu=media
self.t_pro=t_pro
self.d_pro=d_pro
def pro_lle(self):
if self.t_pro==1:
while 1:
print "llegada en el tiempo",now()
p=procesar_const1(self.d_pro) #‘‘Duracion de proceso constante’’
activate(p,p.run())
yield hold,self,expovariate(1/self.mu)
llegadas_expo1.LLEGADAS1+=1
elif self.t_pro==2:
while 1:
print "llegada en el tiempo",now()
yield hold,self,expovariate(1/self.mu)
CAPITULO 3. DISENO E IMPLEMENTACION 51
p=procesar_expo1(self.d_pro) # ‘‘Duracion de proceso exponencial’’
activate(p,p.run())
llegadas_expo1.LLEGADAS1+=1
class procesar_expo1(Process): #Proceso de duracion exponencial
global re_sim
def __init__(self,media):
Process.__init__(self)
self.mu=media
def run(self):
start=now()
time_pro=expovariate(1.0/self.mu)
yield request,self,re_sim[0]
t_cola=now()
t_esp=t_cola-start
t_espera.tally(t_esp)
print "espera en cola",t_esp
yield hold,self,time_pro
t_salida=now()
print "libero el recurso 1 en el tiempo",t_salida
t_ate=t_salida-t_cola
t_proc.tally(t_ate)
print "el proceso duro",t_ate
yield release,self,re_sim[0]
procesar_expo1.ENT_PRO+=1
class procesar_const1(Process): #‘‘Proceso de duracion exponencial’’
def __init__(self,interval):
Process.__init__(self)
self.interval=interval
def run(self):
start=now()
yield request,self,re_sim[0]
t_cola=now()
print "inicio de proceso 1 en el tiempo",t_cola
t_esp=t_cola-start
t_espera.tally(t_esp)
print "espera en cola",t_esp
yield hold,self,self.interval
t_salida=now()
print "libero el recurso 1 en el tiempo",t_salida
t_ate=t_salida-t_cola
t_proc.tally(t_ate)
CAPITULO 3. DISENO E IMPLEMENTACION 52
print "el proceso duro",t_ate
yield release,self,re_sim[0]
procesar_const1.ENT_PRO+=1
class lle_const1(Process): #‘‘Intervalo entre llegadas constante’’
def __init__(self,interval,t_pro,d_pro):
Process.__init__(self)
self.interval=interval
self.t_pro=t_pro
self.d_pro=d_pro
def pro_lle(self):
if self.t_pro==1:
while 1:
print "llegada en el tiempo",now()
yield hold,self,self.interval
p=procesar_const1(self.d_pro)
activate(p,p.run())
elif self.t_pro==2:
while 1:
print "llegada en el tiempo",now()
yield hold,self,self.interval
p=procesar_expo1(self.d_pro)
activate(p,p.run())
class lle_varias(Process): # Distintas tasa de llegadas para varios tipos de entidades
def __init__(self,tiempos,t_pro,d_pro):
Process.__init__(self)
self.tiempos=tiempos
self.t_pro=t_pro
self.d_pro=d_pro
def pro_lle(self):
while 1:
if len(self.tiempos)==2:
x=random()
t1=expovariate(1.0/self.tiempos[0])
t2=expovariate(1.0/self.tiempos[1])
if x>0.5:
p=proceso_dif1(self.t_pro,self.d_pro,n=1)
activate(p,p.run())
yield hold,self,t1
lle_varias.tipo1+=1
if x<=0.5:
CAPITULO 3. DISENO E IMPLEMENTACION 53
p=proceso_dif1(self.t_pro,self.d_pro,n=2)
activate(p,p.run())
yield hold,self,t2
lle_varias.tipo2+=1
class proceso_dif1(Process): #‘‘procesar varios tipos de entidades
def __init__(self,t_pro,d_pro,n):
Process.__init__(self)
self.interval=d_pro
self.t_pro=t_pro
self.n=n
def run(self):
if self.t_pro==1:
start=now()
yield request,self,re_sim[0]
t_cola=now()
print "inicio de proceso al tiempo",t_cola
t_esp=t_cola-start
print "espera en cola",t_esp
t_espera.tally(t_esp)
yield hold,self,self.interval
t_salida=now()
print "libero el recurso en el tiempo",t_salida
t_ate=t_salida-t_cola
print "el proceso duro",t_ate
t_proc.tally(t_ate)
yield release,self,re_sim[0]
if self.n==1:
proceso_dif1.tipo1+=1
else:
proceso_dif1.tipo2+=1
if self.t_pro==2:
start=now()
yield request,self,re_sim[0]
t_cola=now()
print "inicio de proceso al tiempo",t_cola
t_esp=t_cola-start
t_espera.tally(t_esp)
print "espera en cola",t_esp
yield hold,self,expovariate(1.0/self.interval)
t_salida=now()
print "libero el recurso en el tiempo",t_salida
t_ate=t_salida-t_cola
CAPITULO 3. DISENO E IMPLEMENTACION 54
t_proc.tally(t_ate)
print "el proceso duro",t_ate
yield release,self,re_sim[0]
if self.n==1:
proceso_dif1.tipo1+=1
else:
proceso_dif1.tipo2+=1
Los modelos presentados en la seccion 3.5 de este capıtulo se implementan de la misma
forma que el mostrado anteriormente.
Para transformar los recursos introducidos por el usuario a objetos de la clase Resourcedel paquete SimPy, se crea una sencilla funcion:
def rec_sim(recursos):
for i in range(len(recursos)):
recursos[i]=Resource(name=recursos[i])
return recursos
Para ejecutar cada modelo, segun sea el caso, se crea una funcion llamada modelo() queinvoca a todos los parametros necesarios para que el paquete SimPy sea ejecutado talescomo:
initialize()
activate()
simulate(until=t)
3.6.3. Utilizacion de la herramienta
La herramienta esta construida en tres scripts: RdPC.py, parametros.py, ejectutar.py y
estan guardados en un mismo directorio al que se denomino RdPCSimPy.
Para utilizarla, el usuario debe acceder al directorio, y una vez allı, llama al interprete de
Python seguidamente del nombre del modulo ejecutar.py, tal como se muestra en la figura
3.10
CAPITULO 3. DISENO E IMPLEMENTACION 55
Figura 3.9: Estructuracion de la herramienta
En el siguiente capıtulo se muestran algunos ejemplos con los respectivos resultados de
la simulacion en SimPy.
CAPITULO 3. DISENO E IMPLEMENTACION 56
Figura 3.10: Ejecutar la herramienta
Capıtulo 4
Ejemplos de Aplicacion
En este capıtulo se muestran algunos de los prototipos de modelos en Red de Petri Colo-
readas cuyo comportamiento dinamico puede ser ejecutado para la simulacion en SimPy
mediante esta metodologıa. Para mejorar la comprension del modelado y de la utiliza-
cion de la herramienta computacional “RdPCSimPy”, se presentan los modelos de manera
ejemplificada, basados en situaciones reales que puedan representar procesos sencillos de
logıstica,servicios y fabricacion.
Los modelos se simulan con la herramienta RdPCSimPy y Arena, con el objetivo de
mostrar la similitud entre los resultados de esta herramienta y un paquete comercial ya
probado.
4.1. Modelo 1: Llegada-Servicio-Salida
Este modelo cuya estructura se muestra en el capıtulo anterior como Modelo 1 permite
representar situaciones donde las entidades temporales (personas, objetos), llegan a hacer
uso de un servicio que es prestado por un unico recurso (personas, maquinas,etc.). Una vez
57
CAPITULO 4. EJEMPLOS DE APLICACION 58
servida, la entidad es almacenada o abandona el sistema.
4.1.1. Ejemplo: Cajero Automatico
Modelo conceptual del sistema
Dadas la quejas presentadas por los clientes del banco XXX, se decide hacer un estudio
del funcionamiento de los cajeros automaticos los dıas lunes entre las 12:00 del mediodia y
1:00 de la tarde, con el objeto de analizar los tiempos de servicio y ası tomar una decision
para minimizar los tiempos de espera en cola. La tasa de llegadas se distribuyen de manera
exponencial con media 5 minutos, y la duracion del proceso se distribuye exponencial con
media 7 minutos.
Modelo matematico en Red de Petri Coloreada:
P = [p1, p2, p3, p4]
T = [t1, t2, t3]
A = [A1, A2, A3, A4, A5, A6, A7]
N(A) = [[t1, p1], [p1, t2], [t2, p2], [p2, t3], [t3, p3], [p3, t1], [t3, p4]]
Cc = [C1 = x,C2 = edo], Donde: x = [1] y edo = [ocupado = 1, libre = 0]
G(T ) = True ∀Ti
E(A) = 1 ∀Ai
CAPITULO 4. EJEMPLOS DE APLICACION 59
C(P) = [C1,C1,C2,C1]
I(P) = [0′(x), 0′(x), 1′(0), 0′(x)]
Modelo conceptual en Red de Petri Coloreada:
t1= Evento 1: llegadas
p1= entidades (personas) en cola
t2= Evento 2: Inicio de proceso
p2= entidad (persona) en proceso
p3= recurso (cajero automatico)
t3= Evento 3: Fin de Proceso
p4= entidades (personas) que salen del proceso
Representacion grafica de la Red de Petri Coloreada:
Parametros de la simulacion:
Tiempo entre llegadas: Exponencial con media 5 minutos.
Duracion del proceso de atencion al cliente: Exponencial con media 7 minutos.
Tiempo total de simulacion: 1 hora=60 minutos.
Numero de Replicas: 4
CAPITULO 4. EJEMPLOS DE APLICACION 60
P1
P4
A1
A2
A3A6
A4 A5
A7
0’(x)
1’(0)
T1
T2
T3
P2 P3
Figura 4.1: RdPC Ejemplo: Cajero Automatico
Resultados de la simulacion:
La tabla 4.1 muestra los resultados de la simulacion en RdPCS imPy y Arena:
Replica Parametro de salida RdPCSimPy Arena1 No llegadas 13 111 No Entidades atendidas 9 81 Tiempo promedio atencion 3.78 4.862 No llegadas 10 102 No Entidades atendidas 5 62 Tiempo promedio atencion 8.15 9.673 No llegadas 10 153 No Entidades atendidas 7 73 Tiempo promedio atencion 5.25 7.724 No llegadas 4 94 No Entidades atendidas 3 5
Tabla 4.1: Resultados de la simulacion: Cajero automatico
CAPITULO 4. EJEMPLOS DE APLICACION 61
4.1.2. Ejemplo: Manufactura de piezas
Modelo conceptual del sistema
Proceso simple de manufacutra de dos tipos de piezas (a y b) que llegan a razon ex-
ponencial con medias 4 y 6 minutos respectivamente, a un mismo proceso de embalaje
ejecutado por una unica maquina, el proceso ocurre durante las 2 ultimas horas del turno
de trabajo, y dura aproximadamente 3 minutos por cada pieza. Una vez que la pieza es
embalda es guardada en el almacen
Modelo matematico en Red de Petri Coloreada:
P = [p1, p2, p3, p4]
T = [t1, t2, t3]
A = [A1, A2, A3, A4, A5, A6, A7]
N(A) = [[t1, p1], [p1, t2], [t2, p2], [p2, t3], [t3, p3], [p3, t1], [t3, p4]]
Cc = [C1 = x,C2 = edo], Donde: x = [a, b] y edo = [ocupado = 1, libre = 0]
G(T ) = True ∀Ti
E(A) = 1 ∀Ai
C(P) = [C1,C1 ∗C2,C2,C1]
I(P) = [[0′(a) + 0′(b)], [0′(a) + 0′(b)], [1′(0)], [0′(a) + 0′(b)]]
CAPITULO 4. EJEMPLOS DE APLICACION 62
Modelo conceptual en Red de Petri Coloreada:
t1= Evento 1: llegada de las piezas a y b
p1= cola de piezas tipo a y tipo b
t2= Evento 2: Inicio del proceso de embalaje
p2= pieza en proceso de embalaje
p3= recurso (maquina)
t3= Evento 3: Fin del proceso de embalaje
p4= piezas en al almacen
Representacion grafica de la Red de Petri Coloreada:
P1
P4
A1
A2
A3A6
A4 A5
A7
1’(0)
T1
T2
T3
P2 P3
0’(a)+0’(b)
Figura 4.2: RdPC Ejemplo: Manufactura
CAPITULO 4. EJEMPLOS DE APLICACION 63
Parametros de la simulacion:
Tiempo entre llegadas piezas tipo a: Exponencial con media 4 minutos.
Tiempo entre llegadas piezas tipo b: Exponencial con media 6 minutos.
Duracion del proceso de atencion al cliente: Exponencial con media 3 minutos.
Tiempo total de simulacion: 2 horas=120 minutos.
Numero de Replicas: 4
Resultados de la simulacion:
La tabla 4.2 muestra los resultados de la simulacion en RdPCSimPy y Arena:
Replica Parametro de salida RdPCSimPy1 No llegadas tipo a 161 No llegadas tipo b 101 No Ent. tipo a atendidas 131 No Ent. tipo b atendidas 71 Tiempo promedio atencion 3.762 No llegadas tipo a 112 No llegadas tipo b 72 No Ent. tipo a atendidas 112 No Ent. tipo b atendidas 72 Tiempo promedio atencion 2.593 No llegadas tipo a 123 No llegadas tipo b 143 No Ent. tipo a atendidas 123 No Ent. tipo b atendidas 123 Tiempo promedio atencion 3.014 No llegadas tipo a 94 No llegadas tipo b 144 No Ent. tipo a atendidas 94 No Ent. tipo b atendidas 134 Tiempo promedio atencion 4.54
Tabla 4.2: Resultados de la simulacion: Manufactura de piezas
CAPITULO 4. EJEMPLOS DE APLICACION 64
4.2. Modelo 2: Dos procesos en secuencia
Esta estructura de modelo se muestra en el capıtulo anterior mediante los tipos Modelo
2 y Modelo 3. Las entidades temporales fluyen a traves de dos procesos o servicios en
lınea, cada proceso es ejecutado por un recurso, las entidades pasan de un proceso a otro.
Una vez que cada entidad pasa por los dos procesos, sale del sistema. Existen dos formas
para utilizar los recursos:
El primer recurso ejecuta el proceso sin importar el estado del segundo, es decir se
puede generar una cola para la obtencion del segundo
El primer recurso ejecuta el proceso si el segundo se encuentra libre, es decir, la
obtencion del segundo es de forma inmediata, no se genera cola. Esta situacion es
frecuente en situaciones de transporte, en lıneas de produccion automatizadas o don-
de el espacio fısico es importante
4.2.1. Ejemplo: Subsistema de una linea de produccion
Modelo conceptual del sistema
Se desea representar y analizar un subsistema de produccion compuesto basicamente
por un almacen, una grua de transporte y una maquina. El funcionamiento es el siguiente:
El robot R realiza el transporte cada pieza desde el almacen y la carga en la maquina
M, esta operacion se realiza en un tiempo exponencial con media 7 minutos aproxi-
madamente.
La maquina M realiza la operacion sobre la pieza durante un tiempo exponencial con
media 5 minutos y esta sale de este subsistema.
CAPITULO 4. EJEMPLOS DE APLICACION 65
La condicion para que el robot R pueda transportar la pieza, es que la maquina M se
encuentre disponible y que existan piezas en el almacen.
Modelo matematico en Red de Petri Coloreada:
P = [p1, p2, p3, p4, p5]
T = [t1, t2, t3]
A = [A1, A2, A3, A4, A5, A6, A7, A8, A9]
N(A) = [[p1, t1], [t1, p2], [p2, t2], [t2, p3], [p3, t1], [t2, p4], [p4, t3], [t3, p5], [p5, t1]]
Cc = [C1 = x,C2 = edo], Donde: x = [1] y edo = [ocupado = 1, libre = 0]
G(T ) = True ∀Ti
E(A) = 1 ∀Ai
C(P) = [C1,C1,C2,C1,C2]
I(P) = [[0′(x), 0′(x), 1′(0), 0′(x), 1′(0)]
Modelo conceptual en Red de Petri Coloreada:
p1= almacen de piezas
t1= Evento 1: inicio del proceso de transporte
p2= pieza en proceso de transporte
CAPITULO 4. EJEMPLOS DE APLICACION 66
p3= recurso (robot R)
t2= Evento 2: descarga del robot e inicio del proceso en la maquina
p4= piezas en proceso con la maquina
p5= recurso (maquina M)
t3= Evento 3: Fin del proceso y salida de piezas del subsistema
Representacion grafica de la Red de Petri Coloreada:
P1
P4
P2
A1
A6
A7
A3
A2
10’(x)
T3
T2
T1
P3
1’(0)
A4
A5
1’(0)P5
A9
A8
Figura 4.3: RdPC Ejemplo: Lınea de produccion
Parametros de la simulacion:
Numero inicial de piezas en el almacen: 50.
Tiempo duracion del proceso de transporte: Exponencial con media 7 minutos.
Tiempo duracion del proceso con la maquina M : Exponencial con media 5 minutos.
CAPITULO 4. EJEMPLOS DE APLICACION 67
Tiempo total de simulacion: 5 horas= 300 minutos.
Numero de replicas: 2
Resultados de la simulacion:
La tabla 4.3 muestra los resultados de la simulacion en RdPCS imPy y Arena:
Replica Parametro de salida RdPCSimPy Arena1 Tiempo promedio proceso trans. 7.14 7.151 Tiempo promedio proceso maquina 7.04 6.401 Entidades procesadas 21 222 Tiempo promedio proceso trans. 6.06 5.462 Tiempo promedio proceso maquina 4.25 6.002 Entidades procesadas 29 26
Tabla 4.3: Resultados de la simulacion: Lınea de produccion
4.2.2. Ejemplo: Servicio de autolavado
Modelo conceptual del sistema
Una empresa presta un servicio de autolavado automatizado de vehıculos, los cuales
llegan a razon de uno cada 30 minutos y son atendidos en orden de llegada. El primer
servicio consiste en lavar el vehıculo y es hecho por una persona, de alli pasa a un servicio
de encerado y pulido llevado a cabo por una persona. Cada servicio tiene una duracion
exponencial con media 20 minutos. El establecimiento trabaja 6 horas consecutivas.
CAPITULO 4. EJEMPLOS DE APLICACION 68
Modelo matematico en Red de Petri Coloreada:
P = [p1, p2, p3, p4, p5]
T = [t1, t2, t3, t4]
A = [A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
N(A) = [[t1, p1], [p1, t2], [t2, p2], [p2, t3], [t3, p3], [p3, t2], [t3, p4], [p4, t4], [t4, p5], [p5, t3]]
Cc = [C1 = x,C2 = edo], Donde: x = [1] y edo = [ocupado = 1, libre = 0]
G(T ) = True ∀Ti
E(A) = 1 ∀Ai
C(P) = [C1,C1,C2,C1,C2]
I(P) = [[0′(x), 0′(x), 1′(0), 0′(x), 1′(0)]
Modelo conceptual en Red de Petri Coloreada:
t1= Evento 1: Llegada de vehıculos
p1= Vehıculos en cola
t2= Evento 2: Inicio del servicio de lavado
p2= Vehıculo en servicio de lavado
p3= Recurso (1 persona)
CAPITULO 4. EJEMPLOS DE APLICACION 69
t3= Evento 3: Fin del lavado e inicio del proceso de encerado
p4= Vehıculo en servicio de encerado
p5= Recurso (1 persona)
t4= Evento 4: Fin del servicio y salida del vehıculo
Representacion grafica de la Red de Petri Coloreada:
P1
P4
1’(0)
P2 P3
1’(0)
P5
T1
T2
T3
T4
A1
A2
A3
A4 A5
A6
A7
A8 A9
A10
0’(x)
Figura 4.4: RdPC Ejemplo: Servicio de autolavado
Parametros de la simulacion:
Intervalo entre llegadas: Exponencial con media 30 minutos
Tiempo duracion del servicio lavado: Exponencial con media 20 minutos.
Tiempo duracion del servicio encerado : Exponencial con media 20 minutos.
Tiempo total de simulacion: 5 horas= 360 minutos.
CAPITULO 4. EJEMPLOS DE APLICACION 70
Numero de replicas: 2
Resultados de la simulacion:
La tabla 4.4 muestra los resultados de la simulacion en RdPCS imPy y Arena:
Replica Parametro de salida RdPCSimPy Arena1 No Llegadas 16 121 Tiempo promedio serv. lavado 13.52 16.071 Tiempo promedio serv encerado 16.57 21.111 Entidades procesadas 12 112 No Llegadas 10 82 Tiempo promedio serv. lavado 24.06 21.502 Tiempo promedio serv encerado 23.70 9.972 Entidades procesadas 9 7
Tabla 4.4: Resultados de la simulacion: Lınea de produccion
4.3. Modelo 3: Dos procesos en paralelo
Existen en el sistema dos recursos que ejecutan un mismo proceso, esta estructura de
red se muestra en el capıtulo anterior como Modelo 5. Las entidades estan almacenadas o
llegan en lote en el tiempo cero (0) y pueden elegir a cual de los dos procesos dirigirse. En
la simulacion existen dos formas de asignar entides a cada proceso: 1) De forma aleatoria
y 2) En funcion del recurso que tenga cola mınima. Ambos procesos poseen la misma
duracion.
CAPITULO 4. EJEMPLOS DE APLICACION 71
4.3.1. Ejemplo: Mantenimiento de equipos
Modelo conceptual del sistema
En una sala de manufactura, se realizan operaciones de mantenimiento utilizando dos
gruas. En la sala existen 20 equipos a los cuales hay que hacerles un cambio de piezas.
Cualquiera de las dos gruas puede hacerlo en atencion a su posicion en la sala. La duracion
del proceso de mantenimiento por cada equipo se distribuye exponencial con media 15
minutos, y el tiempo total asignado para operaciones de mantenimiento es de 4 horas.
Modelo matematico en Red de Petri Coloreada:
P = [p1, p2, p3, p4, p5]
T = [t1, t2, t3, t4]
A = [A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
N(A) = [[p1, t1], [p1, t2], [t1, p2], [p2, t3], [t3, p3], [p3, t1], [t2, p4], [p4, t4], [t4, p5], [p5, t2]]
Cc = [C1 = x,C2 = edo], Donde: x = [1] y edo = [ocupado = 1, libre = 0]
G(T ) = True ∀Ti
E(A) = 1 ∀Ai
C(P) = [C1,C1,C2,C1,C2]
I(P) = [[0′(x), 0′(x), 1′(0), 0′(x), 1′(0)]
CAPITULO 4. EJEMPLOS DE APLICACION 72
Modelo conceptual en Red de Petri Coloreada:
p1= sala de equipos
t1= Evento: Inicio mantenimiento con grua 1.
t2= Evento: Inicio mantenimiento con grua 2.
p2= Equipo en mantenimiento grua 1.
p3= Recurso (grua 1).
p4= Equipo en mantenimiento grua 2.
p5= Recurso (grua 2).
t3= Fin de mantenimiento grua 1.
t4= Fin de mantenimiento grua 2.
Representacion grafica de la Red de Petri Coloreada:
T3
T4
T1 T2
P3
P1
P2
A1
A3
A2
A4A5
A6
A7
A8 A9
A10
T3
P4 P5
20’(x)
1’(0)1’(0)
Figura 4.5: RdPC Ejemplo: Mantenimiento de equipos
CAPITULO 4. EJEMPLOS DE APLICACION 73
Parametros de la simulacion:
Numero de equipos: 20
Tiempo duracion de cada proceso: Exponencial con media 15 minutos.
Tiempo total de simulacion: 4 horas= 240 minutos.
Numero de replicas: 2.
Resultados de la simulacion:
La tabla 4.5 muestra los resultados de la simulacion en RdPCS imPy y Arena:
Replica Parametro de salida RdPCSimPy Arena1 Cant. equipos grua 1 8 91 Cant. equipos grua 2 12 91 Tiempo promedio mant. grua 1 15.37 23.171 Tiempo promedio mant. grua 2 19.01 11.782 Cant. equipos grua 1 7 92 Cant. equipos grua 2 10 112 Tiempo promedio mant. grua 1 20.90 11.832 Tiempo promedio mant. grua 2 14.03 16.92
Tabla 4.5: Resultados de la simulacion: Mantenimiento de equipos
Capıtulo 5
Conclusiones y Recomendaciones
Una vez culminado la presente investigacion se pueden extraer una serie de conclu-
siones y ademas realizar algunas recomendaciones que sirven como referencia a futuras
investigaciones en el area de modelado y simulacion.
5.1. Conclusiones
El desarrollo de este trabajo de investigacion dio lugar a resultados satisfactorios, lo que
se traduce finalmente en el logro de los objetivos que se plantearon al inicio del mismo.
En cuanto al formalismo de modelado se puede decir que es relativamente nuevo, y
aprender a utilizarlo es sencillo, basta con saber que no se pueden conectar nodos de un
mismo tipo y las reglas para disparar las transiciones, lo que se traduce en desencadenar
eventos y originar cambios en el sistema; existen varias extensiones de este tipo de mo-
delado, las mas usadas son las temporales y las coloreadas. Esta metodologıa esta siendo
utilizada en muchas areas del estudio y analisis de sistemas, sin embargo, su utilizacion en
la conceptualizacion de modelos especıficamente para la simulacion por eventos discretos
74
CAPITULO 5. CONCLUSIONES Y RECOMENDACIONES 75
es practicamente inexistente, de allı que este aspecto permita afirmar que el uso que se le da
a este formalismo en el desarrollo de esta metodologıa es un aporte importante en el area
del modelado conjuntamente con la simulacion por eventos discretos. La seleccion de este
tipo de modelado en esta investigacion se basa en las potencialidades de las Redes de Petri
en cuanto al manejo natural de estados y eventos; y el manejo de colores como concepto
que permite parametrizar y simplificar las estructuras de los modelos.
Desde el punto de vista de la simulacion por eventos discretos, esta continua siendo una
de las tecnicas por excelencia utilizada para analizar el comportamiento de sistemas donde
es casi imposible obtener un modelo analıtico. En la actualidad se utilizan para llevar a cabo
simulaciones paquetes o entornos de uso especıfico dejando atras la programacion directa
sobre los lenguajes de proposito general que en algunos casos origina dependencia entre el
modelo y el programa.
Existen en el mercado muchos paquetes de simulacion por eventos discretos como por
ejemplo Arena, sin embargo, su adquisicion requiere del pago de licencias de costo elevado,
por esta razon, el desarrollo de software libre tambien se lleva a cabo en el area de la simu-
lacion, en este caso cabe mencionar a SimPy que es un paquete de simulacion por eventos
discretos totalmente gratuito y que es la herramienta seleccionada para implementar esta
metodologıa.
SimPy utiliza el enfoque de orientacion a procesos y maneja fundamentalmente tres
tipos de objetos: procesos, recursos y monitores, con los cuales permte modelar las enti-
dades dentro de una actividad, el uso de entidades fijas para llevar a cabo los procesos, la
recopilacion de estadısticas y construccion de histogramas. En general se puede decir que
es un paquete que muestra versatilidad para el manejo de diversos tipos de sistemas, desde
los mas simples hasta los mas complejos.
La programacion de modelos en SimPy es sencilla y solo es necesario tener una idea
clara del funcionamiento de Python que es un lenguaje de programacion de alto nivel, total-
CAPITULO 5. CONCLUSIONES Y RECOMENDACIONES 76
mente gratuido y de codigo abierto cuya estructura de programacion es sencilla comparado
con otros lenguajes como C.
El aporte fundamental de este trabajo es ofrecer a la comunidad de investigadores en el
area de Redes de Petri y Redes de Petri Coloreadas una metodologıa que permite capturar
los elementos necesarios desde una representacion estatica de la red y luego relacionarlos
con el modelo conceptual del sistema, con el objeto que llevar a cabo el estudio de la
dinamica del mismo mediante la tecnica de la simulacion por eventos discretos sin que sea
imprescindible que el usuario realice algun tipo de programacion en SimPy. Claro esta, que
el interesado en utilizar la metodologıa y esta herramienta, no debe ser un total ignorante
de los conceptos de simulacion por eventos discretos.
Para llevar a cabo el desarrollo de este trabajo se consideran algunas restricciones desde
el punto de vista de la estructura de los modelos tales como colores predefinidos,arcos uni-
tarios, expresiones de guarda booleanas, consumo de tiempo dentro de bloques especıficos
y otros, ası como tambien restriciones por simplificacion como la seleccion de entidades
en las colas es tipo FIFO, y solo dos posibles estados para los recursos. Sin embargo, estas
restricciones no le restan generalidad a la metodologıa en atencion a que el primer paso
conceptual ya esta dado, es decir, las modificaciones que hay que realizar para ampliar la
aplicabilidad de la misma no son de fondo sino mas bien de forma, entonces, hay realizar
los cambios en la implementacion, que en este caso, es totalmente modificable debido a
que esta elaborada en Python y SimPy cuyos codigos son abiertos y totalmente gratuitos
como se ha mencionado anteriormente.
Finalmente, los resultados que se obtienen con el desarrollo de este trabajo son bue-
nos, los modelos seleccionados, formulados y probados tanto en SimPy y Arena, muestran
resultados aceptables en cuanto a rangos de variabilidad estadıstica, lo que permite afir-
mar que la conceptualizacion, interpretacion, representacion y simulacion de los mismos
se llevo a cabo de forma correcta.
CAPITULO 5. CONCLUSIONES Y RECOMENDACIONES 77
5.2. Recomendaciones
Con el objeto de mejorar y complementar este trabajo para futuras investigaciones, se
sugieren las siguientes recomendaciones:
Profundizar en el estudio de la metodologıa de modelado de Redes de Petri y sus
extensiones de tal manera que se extraigan sus potencialidades para muchas otras
aplicaciones.
Ampliar el rango de aplicacion de la esta metodologıa incorporando nuevos tipos de
estructuras de Redes de Petri mas complejas, ası como ampliar la estructuras para
el manejo de mayor numero de atributos (colores), expresiones de arco y guardas
compuestas.
Permitir la simulacion de interrupciones de procesos, averıas de los recursos y colas
de prioridad mediante modificaciones sencillas de los modelos en SimPy.
Mejorar la interfaz al usuario tratando de combinar entornos graficos compatibles
con Python tales como PyGtk.
Bibliografıa
[Andres marzal e Isabel Garcıa, 2003] Andres marzal e Isabel Garcıa (2003). Introduc-
cion a al programacion con Python [en lınea]. Universitat Jaume I. Disponible en:
http://marmota.act.uji.es/MTP/pdf/python.pdf, Consultado en abril de 2006.
[Antoni Guasch et al., 2005] Antoni Guasch, Miquel Angel Piera, Josep Casanovas,y Jau-
me Figueras (2005). Modelado y Simulacion. Aplicacion a procesos logısticos de fabri-
cacion y servicios. EDICIONS UPC. Alfaomega Grupo Editor, S.A. de C.V., Universitat
Politecnica de Catalunya, Barcelona, Espana.
[de Hamburgo, ] de Hamburgo, U. Interactive tutorials on petri nets, [en lınea]. Disponi-
ble en: http://www.informatik.uni-hamburg.de/TGI/PetriNets/introductions/aalst/, Con-
sultado en junio de 2006.
[Garcıa, 2003] Garcıa, F. J. (2003). Modelado e Implementacion de Sistemas de Tiempo
Real Mediante Redes de Petri con Tiempo. [en lınea]. PhD thesis, Universidad de la Rio-
ja, La Rioja, Espana. Disponible en: www.unirioja.es/servicios/sp/tesis/pdfs/t07ind.pdf,
Consultado en agosto de 2006.
[Jimenez, 2004] Jimenez, E. (2004). Tecnicas de automatizacion avanzadas en procesos
industriales, [en lınea]. PhD thesis, Universidad de la Rioja, La Rioja, Espana. Disponi-
ble en: www.unirioja.es/servicios/sp/tesis/pdfs/tesis27.pdf, Consultado en jnio de 2006.
78
BIBLIOGRAFIA 79
[Martınez, 2003] Martınez, J. R. (Septiembre 2003). Diseno de un gestor de redes de
petri, [en lınea]. Master’s thesis, Universidad de Colima, Manzanillo, Colima, Mexico.
Disponible en: digeset.ucol.mx/tesisposgrado/Pdf/JoseConsultado en junio de 2006.
[Matloff, 2006b] Matloff, N. (February 2006b). Introduction to simpy internals,[en lınea].
Disponible en:http://heather.cs.ucdavis.edu/ matloff/156/PLN/, Consultado en mayo de
2006.
[Matloff, 2006a] Matloff, N. (March 2006a). Introduction to discrete-
event simulation and the simpy language,[en lınea]. Disponible en:
http://heather.cs.ucdavis.edu/ matloff/simpy.html, Consultado en mayo de 2006.
[Muller, 2005a] Muller, K. G. (2005a). Advanced systems simulation capabilities in
simpy, [en lınea]. Disponible en:http://SimPy.SourceForge.Net, Consultado en abril de
2006.
[Muller, 2005b] Muller, K. G. (2005b). Simpy: System simulation in python, [en lınea].
Disponible en: http://simpy.sourceforge.net/simpyoverview.htm, Consultado en junio de
2006.
[T. Guasch et al., ] T. Guasch, V. Puig, J. Figueras, y J.J. Ramos. Simulacion de procesos
logısticos y retos para la optimizacion de flotas en tiempo real, [en lınea]. Disponi-
ble en: www.imac.unavarra.es/SEMAOL/Ponencias/02ToniGuasch.pdf, Consultado en
septiembre de 2006.
[Villapol, 2003] Villapol, M. E. (November 2003). Modelling and analysis of the Resource
Reservation Protocol using Coloured Petri Nets, [en lınea]. PhD thesis, University of
South Australia. Disponible en: http://www.ucv.ve/thesis/biblio/villapdf, Consultado en
septiembre de 2006.
[Webmaster, ] Webmaster, C.-N. Coloured petri nets. Disponible en:
http://www.daimi.au.dk/CPnets/, Consultado en mayo de 2006.
Apendice A
Codigo fuente herramienta RdPCSimPy
Scripts de la herramienta disenada.
RdPC.py
from __future__ import generators
from SimPy.Simulation import *
from random import *
import pickle
"""Elaborado por: Maria E. Perdomo Villarreal y Sebastian E. Medina"""
"""Proyecto de grado: MODELADO Y SIMULACION POR EVENTOS DISCRETOS DE REDES DE PETRI COLOREADAS USANDO SIMPY"""
"""Febrero 2006"""
"""El siguiente programa tiene por objetivo recibir un modelo sencillo de red de petri coloreada mediante un cuestionario referente a los elementos que conforman el modelo asi como de las relaciones jerarquicas que existen en el mismo"""
"""la informacion fluye a traves de funciones que tienen por objeto preparar el modelo para la simulacion por eventos discretos en SimPy"""
"""Esta es la primera version de la herrramienta y esta limitada a problemas sencillos para un solo tipo de entidades y clasificadas a su vez en un maximo de dos"""
"""Pueden existir a lo sumo dos recursos, cuyo color esta predefinido como ESTADO y que comprende dos atributos ocupado y desocupado"""
"""El objetivo de esta herramienta es ayudar al modelador de una RdPC sencilla para que conozca el proceso dinamico de la misma sin necesidad de programar las rutinas de simulacion en SimPy"""
"""Los modelos de referencia estan basados en el libro MODELADO Y SIMULACION. APLICACION A MODELOS LOGISTICOS DE FABRICACION Y SERVICIOS"""
"""Autor: ANTONI GUASH et al"""
#Funcion para solicitar la informacion de las entidades
80
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 81
def tip_ent():
entidad=[]
print "Nombre de la entidad temporal que fluye por su RdPC"
nom_ent=raw_input()
entidad.append(nom_ent)
return entidad
#Funcion para solicitar la informacion de los recursos
def inf_rec():
print "Cuantos recursos se representan en su RdPC?"
num_rec=int(raw_input())
recursos=[]
for j in range(num_rec):
print "Nombre del recurso",(j+1)
re=raw_input()
recursos.append(re)
return recursos
#Funcion para solicitar la informacion de los colores
def colores(entidad,recursos):
global col_ent,list_co,col_re
print "En esta seccion de preguntas, ud dara informacion de las entidades y recursos"
print "Los colores de su RdPC seran predefinidos por este programa"
print "Para la entidad temporal, el conjunto color guarda atributos de CLASIFICACION"
print "Para los recuros, el conjunto color representa el ESTADO del mismo"
print "A saber, que los recursos solo poseen dos estados posibles"
print "OCUPADO y DESOCUPADO"
col_ent={}
list_co={}
col_re={}
li_a=[]
li_at=[]
for j in range(len(entidad)):
print "Existe algun tipo de clasificacion para la entidad",entidad[j],"s/n"
res=raw_input()
if res=="S" or res=="s":
print "Nombre del conjunto color que almacena los atributos de clasificacion"
color=raw_input()
col_ent[entidad[j]]=color
print "Cuantos atributos posee",color
num_a=int(raw_input())
for i in range(num_a):
print "Nombre del atributo %s"%(i+1)
nom_a=raw_input()
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 82
li_a.append([nom_a,i+1])
list_co[color]=li_a
else:
col_ent[entidad[j]]="nulo"
print "No existe conjunto color para la entidad",entidad[j]
for k in range(len(recursos)):
print "Nombre del conjunto color que represente el estado del recurso ",recursos[k],":"
color1=raw_input()
col_re[recursos[k]]=color1
print color1, "posee dos atributos que son ocupado (1) y desocupado (2)"
num_a=2
li_at.append(["ocupado",1])
li_at.append(["libre",2])
list_co[color1]=li_at
return list_co
#Funcion para la informacion de los lugares
def lugar():
print "Cuantos lugares posee su red de petri coloreada?"
np=int(raw_input())
print "Con que nombre identificara a cada lugar?"
lugares=[]
for i in range(0,np):
print "Nombre P%s"%(i+1)
nom_p=raw_input()
lugares.append(nom_p)
return lugares
#Funcion para conceptualizar los lugares
def uso_lugares(lugares,entidad,recursos):
print "Las redes de petri coloreadas modelan situaciones reales"
print "los lugares se utilizan para:"
print "1. almacenar entidades"
print "2. representar colas"
print "3. entidades en proceso"
print "4. almacenar recurso:(libre, ocupado)"
print "en atencion a lo anterior, seleccione con un numero entero,la utilizacion de cada lugar en su RdPC"
global almacen,num_cola,proceso,recurso,uso_lugar,Cp
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 83
num_cola=0
uso_lugar={}
a_procesar=[]
aux2=[]
cola=[]
Cp={}
for i in range(len(lugares)):
print "Lugar",lugares[i],":"
print "1. almacenar entidades,2. colas,3.entidades en proceso y 4. recurso"
op=int(raw_input())
if op==1:
almacenar=[]
print "Ud eligio un almacen"
uso_lugar[lugares[i]]="almacen"
col=col_ent[entidad[0]]
if col!="nulo":
atributos=list_co[col]
print "Que tipo de entidades se almacenan?"
for j in range(len(atributos)):
print atributos[j][0],"s/n"
res=raw_input()
if res=="S" or res=="s":
almacenar.append(atributos[j][0])
Cp[lugares[i]]=almacenar
elif col=="nulo":
Cp[lugares[i]]="nulo"
if op==2:
en_cola=[]
print "Ud eligio almacenar colas"
uso_lugar[lugares[i]]="cola"
col=col_ent[entidad[0]]
print "Cuantas colas?"
num_cola=int(raw_input())
if num_cola>1:
print "Cada cola sera identificada con un numero entero"
print "Esta identificacion se guarda en un conjunto color de forma automatica"
for j in range(num_cola):
cola.append(j+1)
if col !="nulo":
atributos=list_co[col]
print "la cola",j+1,"almacena:"
for k in range(len(atributos)):
print atributos[k][0],"s/n"
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 84
res=raw_input()
if res=="S" or res=="s":
en_cola.append([j+1,atributos[k][0]])
list_co[lugares[i]]=cola
elif num_cola==1:
cola.append(1)
list_co[lugares[i]]=cola
if col!="nulo":
atributos=list_co[col]
print "la cola almacena:"
for k in range(len(atributos)):
print atributos[k][0],"s/n"
res=raw_input()
if res=="S" or res=="s":
en_cola.append([1,atributos[k][0]])
Cp[lugares[i]]=en_cola
if col=="nulo":
Cp[lugares[i]]="nulo"
if op==3:
print "Ud eligio entidad en proceso"
col=col_ent[entidad[0]]
uso_lugar[lugares[i]]="proceso"
if col!="nulo":
atributos=list_co[col]
print "Que tipo de entidades se procesan?"
for j in range(len(atributos)):
print atributos[j][0],"s/n"
res=raw_input()
if res=="S" or res=="s":
for k in range(len(recursos)):
if len(recursos)==1:
a_procesar.append([recursos[0],atributos[j][0]])
else:
print "Se procesa con",recursos[k],"s/n"
r=raw_input()
if r=="s" or r=="S":
a_procesar.append([recursos[k],atributos[j][0]])
break
if r!="s" or r!="S":
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 85
continue
Cp[lugares[i]]=a_procesar
elif col=="nulo":
Cp[lugares[i]]="nulo"
if op==4:
print "Existencia de recurso "
print "Cuantos recursos se almacenan en este lugar"
recurso=int(raw_input())
print "Cuales?"
for h in range(recurso):
re4=raw_input()
if re4 in recursos:
aux2.append(col_re[re4])
Cp[lugares[i]]=aux2
uso_lugar[lugares[i]]="estado"
return uso_lugar
#Funcion para la informacion de las transiciones
def transiciones():
print "Cuantas transiciones tiene su RdPC?"
nt=int(raw_input())
print "Con que nombre identificara a cada transicion?"
transicion=[]
for j in range(0,nt):
print "Nombre T%s"%(j+1)
nom_t=raw_input()
transicion.append(nom_t)
return transicion
#funcion para la conceptualizacion de las transiciones
def uso_transicion(transicion):
print "las transiciones se utilizan fundamentalmente
para desencadenar eventos:"
print "1.Llegadas"
print "2.Inicio de proceso (de actividad)"
print "3.Fin de proceso (de actividad)"
print "4. Puntos de decision"
print "Cuando en una transicion termina un proceso y comienza
otro entonces marque en el menu la opcion 3 (fin de proceso)"
print "El programa determinara la dinamica por el uso del
lugar proximo a la transicion"
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 86
print "en atencion a lo anterior, seleccione con un numero entero,
la utilizacion de cada transicion"
global inicio,Fin_pro,llegada,Decision,uso_tran
inicio=0
Fin_pro=0
llegada=0
Decision=0
uso_tran={}
for i in range(len(transicion)):
print "Transicion",transicion[i],":"
print "1. llegadas,2. Inicio de proceso, 3. Fin de Proceso,
4. Punto de decision"
op_t=int(raw_input())
if op_t==1:
print "Ud eligio transicion de llegadas"
llegada=llegada+1
uso_tran[transicion[i]]="llegadas"
if op_t==2:
print "Ud eligio transicion de inicio de proceso"
inicio=inicio+1
uso_tran[transicion[i]]="Inicio"
if op_t==3:
print "Ud eligio transicion de fin de proceso"
Fin_pro=Fin_pro+1
uso_tran[transicion[i]]="Fin"
if op_t==4:
print "Ud eligio transicion de punto de decision"
Decision=Decision+1
uso_tran[transicion[i]]="decision"
print uso_tran
return uso_tran
#Funcion para la informacion de los arcos
def arcos():
print "Cuantos arcos posee su RdPC?"
num_ar=int(raw_input())
arcos=[]
for j in range(0,num_ar):
arcos.append("A%s"%(j+1))
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 87
return arcos
#Funciones nodo origen y destino de cada arco
def fun_nodo(lugares,transicion,arcos):
print "Las funciones de nodo permiten asociar a cada arco sus nodos terminales(origen y destino). Los nodos deben ser diferentes P->T, T->P"
fun_node={}
for i in range(len(arcos)):
while 1:
print "para el arco",arcos[i],":"
print "Nodo Origen:P o T"
origen=str(raw_input())
if origen in lugares:
print "Nodo Destino tipo transicion:"
dest=str(raw_input())
if dest in lugares or dest not in transicion:
while 1:
print "Destino debe ser transicion:",transicion
dest=str(raw_input())
if dest in transicion:
fun_node[arcos[i]]=[origen,dest]
break
else:
continue
elif dest in transicion:
fun_node[arcos[i]]=[origen,dest]
else:
print "Nombre invalido"
break
elif origen in transicion:
print "Nodo Destino tipo lugar:"
dest=str(raw_input())
if dest in transicion or dest not in lugares:
while 1:
print "Destino debe ser lugar:",lugares
dest=str(raw_input())
if dest in lugares:
fun_node[arcos[i]]=[origen,dest]
break
else:
continue
elif dest in lugares:
fun_node[arcos[i]]=[origen,dest]
break
elif origen not in lugares or origen not in transicion:
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 88
print "Nombre no es valido"
continue
return fun_node
#Funcion que permite organizar la toda la informacion de la
red de manera tal que su dinamica pueda ser extraida para realizar la simulacion
def orden_logico(lugares,transicion,arcos,uso_lugar,uso_tran):
fun_node=fun_nodo(lugares,transicion,arcos)
print "En orden logico, indique en que nodo o nodos (lugar o transicion)
de su RdPC se representa(n) el inicio de la dinamica (recorrido de entidades temporales) del modelo"
global ord_log
ord_log=[]
linea_logica=[]
while 1:
print "si es un lugar, cual de estos:", lugares
print "si es una transicion cual de estas:", transicion
ini_red=raw_input()
for k in range(len(arcos)):
ini=fun_node[arcos[k]][0]
if ini==ini_red:
if ini in lugares:
ini_model=uso_lugar[ini]
ord_log.append(ini_model)
linea_logica.append([ini,ini_model,arcos[k]])
break
if ini in transicion:
ini_model=uso_tran[ini]
ord_log.append(ini_model)
linea_logica.append([ini,ini_model,arcos[k]])
break
print "Algun otro nodo de inicio s/n"
resp=raw_input()
if resp=="s" or resp=="S":
continue
else:
break
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 89
existe=[]
for k in range(len(arcos)):
for h in range(len(arcos)):
if fun_node[arcos[k]][1]==fun_node[arcos[h]][0]:
sig0=fun_node[arcos[h]][0]
if sig0 in lugares and sig0 not in existe:
if uso_lugar[sig0]!="estado":
ord_log.append(uso_lugar[sig0])
linea_logica.append([sig0,uso_lugar[sig0],arcos[h]])
existe.append(sig0)
break
elif sig0 in transicion and uso_lugar[fun_node[arcos[k]][0]]!="estado"
and sig0 not in existe:
ord_log.append(uso_tran[sig0])
linea_logica.append([sig0,uso_tran[sig0],arcos[h]])
existe.append(sig0)
break
elif (h==len(arcos)-1) and (fun_node[arcos[k]][1]!=fun_node[arcos[h]][0]):
sig0=fun_node[arcos[k]][1]
if sig0 in lugares:
if uso_lugar[sig0]!="estado":
ord_log.append(uso_lugar[sig0])
linea_logica.append([sig0,uso_lugar[sig0],arcos[k]])
existe.append(sig0)
elif sig0 in transicion and uso_lugar[fun_node[arcos[k]][0]]!="estado":
ord_log.append(uso_tran[sig0])
linea_logica.append([sig0,uso_tran[sig0],arcos[k]])
existe.append(sig0)
secuencia=open("secuencia.txt","w")
for i in range(len(linea_logica)):
pickle.dump(linea_logica[i],secuencia)
secuencia.close()
print linea_logica
return linea_logica
def sec_event(linea_logica):
ord_logi=[]
for i in range(len(linea_logica)):
ord_logi.append(linea_logica[i][1])
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 90
print ord_logi
return ord_logi
entidad=tip_ent()
recursos=inf_rec()
lista_co=colores(entidad,recursos)
lugares=lugar()
transicion=transiciones()
arcos=arcos()
uso_lugar=uso_lugares(lugares,entidad,recursos)
uso_tran=uso_transicion(transicion)
linea_logica=orden_logico(lugares,transicion,arcos,uso_lugar,uso_tran)
sec_eve=sec_event(linea_logica)
parametros.py
from RdPC import *
def int_lle(entidad):
for i in range(len(entidad)):
color=col_ent[entidad[i]]
lis_t=[]
if color=="nulo":
print "Como se distribuye el tiempo entre llegadas?"
print "1. intervalos constante"
print "2. exponencial"
op=int(raw_input())
if op==1:
print "Valor de la duracion constante:"
t_lle=float(raw_input())
lis_t.append(1)
lis_t.append(t_lle)
elif op==2:
print "Valor de la media"
mu=float(raw_input())
lis_t.append(2)
lis_t.append(mu)
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 91
elif color!="nulo":
atri=list_co[color]
for j in range(len(atri)):
print "El intervalo entre llegadas es el mismo
para los",len(atri),"tipos de entidades s/n"
res=raw_input()
if res=="s" or res=="S":
print "Como se distribuye el tiempo entre llegadas?"
print "1. intervalos constante"
print "2. exponencial"
op=int(raw_input())
if op==1:
print "Valor de la duracion constante:"
t_lle=float(raw_input())
lis_t.append(1)
lis_t.append(t_lle)
elif op==2:
print "Valor de la media"
mu=float(raw_input())
lis_t.append(2)
lis_t.append(mu)
break
elif res!="s" and res!="S":
print "Como se distribuye el tiempo entre llegadas para la entidad",atri[j][0]
print "1. intervalos constante (marque 1)"
print "2. exponencial (marque 2)"
op=int(raw_input())
if op==1:
print "Valor de la duracion constante:"
t_lle=float(raw_input())
lis_t.append(1)
lis_t.append(t_lle)
elif op==2:
print "Valor de la media"
mu=float(raw_input())
lis_t.append(2)
lis_t.append(mu)
return lis_t
def t_simu():
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 92
print "Cuanto tiempo desea simular su modelo de RdPC"
ts=float(raw_input())
return ts
ejecutar.py
from __future__ import generators
from SimPy.Simulation import *
from random import *
from parametros import *
class llegadas_expo1(Process):
def __init__(self,media,t_pro,d_pro):
Process.__init__(self)
self.mu=media
self.t_pro=t_pro
self.d_pro=d_pro
def pro_lle(self):
if self.t_pro==1:
while 1:
print "llegada en el tiempo",now()
p=procesar_const1(self.d_pro)
activate(p,p.run())
yield hold,self,expovariate(1/self.mu)
llegadas_expo1.LLEGADAS1+=1
elif self.t_pro==2:
while 1:
print "llegada en el tiempo",now()
yield hold,self,expovariate(1/self.mu)
p=procesar_expo1(self.d_pro)
activate(p,p.run())
llegadas_expo1.LLEGADAS1+=1
class procesar_expo1(Process):
global re_sim
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 93
def __init__(self,media):
Process.__init__(self)
self.mu=media
def run(self):
start=now()
time_pro=expovariate(1.0/self.mu)
yield request,self,re_sim[0]
t_cola=now()
t_esp=t_cola-start
t_espera.tally(t_esp)
print "espera en cola",t_esp
yield hold,self,time_pro
t_salida=now()
print "libero el recurso 1 en el tiempo",t_salida
t_ate=t_salida-t_cola
t_proc.tally(t_ate)
print "el proceso duro",t_ate
yield release,self,re_sim[0]
procesar_expo1.ENT_PRO+=1
class procesar_const1(Process):
def __init__(self,interval):
Process.__init__(self)
self.interval=interval
def run(self):
start=now()
yield request,self,re_sim[0]
t_cola=now()
print "inicio de proceso 1 en el tiempo",t_cola
t_esp=t_cola-start
t_espera.tally(t_esp)
print "espera en cola",t_esp
yield hold,self,self.interval
t_salida=now()
print "libero el recurso 1 en el tiempo",t_salida
t_ate=t_salida-t_cola
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 94
t_proc.tally(t_ate)
print "el proceso duro",t_ate
yield release,self,re_sim[0]
procesar_const1.ENT_PRO+=1
class lle_const1(Process):
def __init__(self,interval,t_pro,d_pro):
Process.__init__(self)
self.interval=interval
self.t_pro=t_pro
self.d_pro=d_pro
def pro_lle(self):
if self.t_pro==1:
while 1:
print "llegada en el tiempo",now()
yield hold,self,self.interval
p=procesar_const1(self.d_pro)
activate(p,p.run())
elif self.t_pro==2:
while 1:
print "llegada en el tiempo",now()
yield hold,self,self.interval
p=procesar_expo1(self.d_pro)
activate(p,p.run())
class lle_varias(Process):
def __init__(self,tiempos,t_pro,d_pro):
Process.__init__(self)
self.tiempos=tiempos
self.t_pro=t_pro
self.d_pro=d_pro
def pro_lle(self):
while 1:
if len(self.tiempos)==2:
x=random()
t1=expovariate(1.0/self.tiempos[0])
t2=expovariate(1.0/self.tiempos[1])
if x>0.5:
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 95
p=proceso_dif1(self.t_pro,self.d_pro,n=1)
activate(p,p.run())
yield hold,self,t1
lle_varias.tipo1+=1
if x<=0.5:
p=proceso_dif1(self.t_pro,self.d_pro,n=2)
activate(p,p.run())
yield hold,self,t2
lle_varias.tipo2+=1
class proceso_dif1(Process):
def __init__(self,t_pro,d_pro,n):
Process.__init__(self)
self.interval=d_pro
self.t_pro=t_pro
self.n=n
def run(self):
if self.t_pro==1:
start=now()
yield request,self,re_sim[0]
t_cola=now()
print "inicio de proceso al tiempo",t_cola
t_esp=t_cola-start
print "espera en cola",t_esp
t_espera.tally(t_esp)
yield hold,self,self.interval
t_salida=now()
print "libero el recurso en el tiempo",t_salida
t_ate=t_salida-t_cola
print "el proceso duro",t_ate
t_proc.tally(t_ate)
yield release,self,re_sim[0]
if self.n==1:
proceso_dif1.tipo1+=1
else:
proceso_dif1.tipo2+=1
if self.t_pro==2:
start=now()
yield request,self,re_sim[0]
t_cola=now()
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 96
print "inicio de proceso al tiempo",t_cola
t_esp=t_cola-start
t_espera.tally(t_esp)
print "espera en cola",t_esp
yield hold,self,expovariate(1.0/self.interval)
t_salida=now()
print "libero el recurso en el tiempo",t_salida
t_ate=t_salida-t_cola
t_proc.tally(t_ate)
print "el proceso duro",t_ate
yield release,self,re_sim[0]
if self.n==1:
proceso_dif1.tipo1+=1
else:
proceso_dif1.tipo2+=1
"""*******************************************Modelo 2***********************************************"""
class ini_alma2(Process):
def __init__(self,num,t_pro,d_pro1,d_pro2):
Process.__init__(self)
self.num=num
self.t_pro=t_pro
self.d_pro1=d_pro1
self.d_pro2=d_pro2
def ejecutar(self):
global re_sim
if self.t_pro==1:
for i in range(self.num):
p=procesar_2_cons(self.d_pro1,self.d_pro2)
activate(p,p.run())
yield hold,self,0.000000000000001
if self.t_pro==2:
for j in range(self.num):
p=procesar_2_exp(self.d_pro1,self.d_pro2)
activate(p,p.run())
yield hold,self,0.000000000000001
class procesar_2_cons(Process):
def __init__(self,t1,t2):
Process.__init__(self)
self.t1=t1
self.t2=t2
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 97
def run(self):
start=now()
yield request,self,re_sim[0]
t_cola=now()
t_esp=t_cola-start
yield hold,self,self.t1
tf=now()
t_ate=tf-t_cola
print "el proceso 1 duro",t_ate
print "tiempo de espera en cola",t_esp
t_espera.tally(t_esp)
t_proc.tally(t_ate)
print "libero el primer recurso en el tiempo",tf
yield release,self,re_sim[0]
start2=now()
yield request,self,re_sim[1]
t_cola2=now()
t_esp2=t_cola2-start2
yield hold,self,self.t2
tf2=now()
t_ate2=tf2-t_cola2
print "el proceso 2 duro",t_ate2
print "tiempo de espera en cola",t_esp2
t_espera2.tally(t_esp2)
t_proc2.tally(t_ate2)
print "libero el recurso 2 en el tiempo",tf2
yield release,self,re_sim[1]
procesar_2_cons.PROCESADAS+=1
class procesar_2_exp(Process):
def __init__(self,m1,m2):
Process.__init__(self)
self.m1=m1
self.m2=m2
def run(self):
start1=now()
print "inicio de proceso 1 al tiempo",start1
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 98
time_pro1=expovariate(1.0/self.m1)
yield request,self,re_sim[0]
t_cola1=now()
t_esp1=t_cola1-start1
print "espera en cola",t_esp1
t_espera.tally(t_esp1)
yield hold,self,time_pro1
t_salida1=now()
print "libero el recurso 1 en el tiempo",t_salida1
t_ate1=t_salida1-t_cola1
print "el proceso 1 duro",t_ate1
t_proc.tally(t_ate1)
yield release,self,re_sim[0]
start2=now()
print "inicio de proceso 2 al tiempo",start2
time_pro2=expovariate(1.0/self.m2)
yield request,self,re_sim[1]
t_cola2=now()
t_esp2=t_cola2-start2
t_espera2.tally(t_esp2)
print "espero por el sif proceso un tiempo de",t_esp2
yield hold,self,time_pro2
t_salida2=now()
print "libero el recurso 2 en el tiempo",t_salida2
t_ate2=t_salida1-t_cola1
print "el proceso 2 duro",t_ate2
t_proc2.tally(t_ate2)
yield release,self,re_sim[1]
procesar_2_exp.PROCESADAS+=1
class lle_con2(Process):
def __init__(self,interval,t_pro,d_pro1,d_pro2):
Process.__init__(self)
self.interval=interval
self.t_pro=t_pro
self.d_pro1=d_pro1
self.d_pro2=d_pro2
def ejecutar(self):
if self.t_pro==1:
while 1:
print "llegada en el tiempo",now()
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 99
p=procesar_2_cons(d_pro1,d_pro2)
activate(p,p.run())
yield hold,self,self.interval
if self.t_pro==2:
while 1:
print "llegada en el tiempo",now()
p=procesar_2_exp(d_pro1,d_pro2)
activate(p,p.run())
yield hold,self,self.interval
class lle_exp2(Process):
def __init__(self,me,t_pro,d_pro1,d_pro2):
Process.__init__(self)
self.me=me
self.t_pro=t_pro
self.d_pro1=d_pro1
self.d_pro2=d_pro2
def ejecutar(self):
if self.t_pro==1:
while 1:
print "llegada en el tiempo",now()
p=procesar_2_cons(d_pro1,d_pro2)
activate(p,p.run())
yield hold,self,expovariate(1/self.me)
if self.t_pro==2:
while 1:
print "llegada en el tiempo",now()
p=procesar_2_exp(d_pro1,d_pro2)
activate(p,p.run())
yield hold,self,self.expovariate(1/self.me)
class dos_lle3(Process):
def __init__(self,interval1,interval2,op,t_pro,d_pro1,d_pro2):
Process.__init__(self)
self.interval1=interval1
self.interval2=interval2
self.op=op
self.t_pro=t_pro
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 100
self.d_pro1=d_pro1
self.d_pro2=d_pro2
def ejecutar(self):
while 1:
x=random()
if self.op==1:
if x>0.5:
p=proceso_sec3(self.t_pro,self.d_pro1,self.d_pro2)
activate(p,p.run())
yield hold,self,self.interval1
if x<=0.5:
p=proceso_sec3(self.t_pro,self.d_pro1,self.d_pro2)
activate(p,p.run())
yield hold,self,self.interval2
if self.op==2:
if x>0.5:
p=proceso_pa3(self.t_pro,self.d_pro1)
activate(p,p.run())
yield hold,self,self.interval1
if x<=0.5:
p=proceso_pa3(self.t_pro,self.d_pro1)
activate(p,p.run())
yield hold,self,self.interval2
class proceso_sec3(Process):
def __init__(t_pro,self,interval1,interval2):
Process.__init__(self)
self.interval1=interval1
self.interval2=interval2
self.t_pro=t_pro
def run(self):
if self.t_pro==1:
start=now()
yield request,self,re_sim[0]
t_cola=now()
t_esp=t_cola-start
t_espera.tally(t_esp)
yield hold,self,self.interval1
tf=now()
t_ate=tf-t_cola
t_proc.tally(t_ate)
print "el proceso 1 duro",t_ate
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 101
print "tiempo de espera en cola",t_esp
print "libero el primer recurso en el tiempo",tf
yield release,self,re_sim[0]
start2=now()
yield request,self,re_sim[1]
t_cola2=now()
t_esp2=t_cola2-start2
t_espera2.tally(t_esp2)
yield hold,self,self.interval2
tf2=now()
t_ate2=tf2-t_cola2
t_proc2.tally(t_ate2)
print "el proceso 2 duro",t_ate2
print "tiempo de espera en cola",t_esp2
print "libero el recurso 2 en el tiempo",tf2
yield release,self,re_sim[1]
proceso_sec3.procesadas+=1
if self.t_pro==2:
start=now()
yield request,self,re_sim[0]
t_cola=now()
t_esp=t_cola-start
t_espera.tally(t_esp)
yield hold,self,expovariate(1.0/self.interval1)
tf=now()
t_ate=tf-t_cola
t_proc.tally(t_ate)
print "el proceso 1 duro",t_ate
print "tiempo de espera en cola",t_esp
print "libero el primer recurso en el tiempo",tf
yield release,self,re_sim[0]
start2=now()
yield request,self,re_sim[1]
t_cola2=now()
t_esp2=t_cola2-start2
t_espera2.tally(t_esp2)
yield hold,self,expovariate(1.0/self.interval2)
tf2=now()
t_ate2=tf2-t_cola2
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 102
t_proc2.tally(t_ate2)
print "el proceso 2 duro",t_ate2
print "tiempo de espera en cola",t_esp2
print "libero el recurso 2 en el tiempo",tf2
yield release,self,re_sim[1]
proceso_sec3.procesadas+=1
class proceso_pa3(Process):
def __init__(self,t_pro,interval1):
Process.__init__(self)
self.interval1=interval1
self.t_pro=t_pro
def run(self):
if self.t_pro==1:
arrive=now()
Qlength = [NoInSystem(re_sim[i]) for i in range(len(re_sim))]
print "%7.4f %s: llegada %s "%(now(),self.name,Qlength)
for i in range(len(re_sim)):
if Qlength[i] ==0 or Qlength[i]==min(Qlength):
join =i ; break
yield request,self,re_sim[join]
en_cola=now()-arrive
t_espera.tally(en_cola)
print "espero en cola",en_cola
yield hold,self,self.interval1
yield release,self,re_sim[join]
print "Finalizo el proceso ",now()
print "El proceso duro",now()-en_cola
d_proc.tally(now()-en_cola)
proceso_pa3.procesadas+=1
if self.t_pro==2:
arrive=now()
Qlength = [NoInSystem(re_sim[i]) for i in range(len(re_sim))]
print "%7.4f %s: llegada %s "%(now(),self.name,Qlength)
for i in range(len(re_sim)):
if Qlength[i] ==0 or Qlength[i]==min(Qlength):
join =i ; break
yield request,self,re_sim[join]
en_cola=now()-arrive
t_espera.tally(en_cola)
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 103
print "espero en cola",en_cola
yield hold,self,expovariate(1.0/self.interval1)
yield release,self,re_sim[join]
print "Finalizo el proceso ",now()
print "El proceso duro",now()-en_cola
d_proc.tally(now()-en_cola)
proceso_pa3.procesadas+=1
def NoInSystem(R):
""" The number of customers in the resource R
in waitQ and active Q"""
return (len(R.waitQ)+len(R.activeQ))
class Monitor2(Monitor):
def __init__(self):
Monitor.__init__(self)
self.min,self.max=(int(2**(31-1)),0)
def tally(self, x):
self.observe(x)
self.min = min(self.min, x)
self.max = max(self.max, x)
class model4(Process):
def __init__(self,num,op,t_pro,d_pro):
Process.__init__(self)
self.num=num
self.op=op
self.t_pro=t_pro
self.d_pro=d_pro
def ejecutar(self):
if self.t_pro==1:
if self.op==1:
for i in range(self.num):
x=random()
if x>0.5:
p=procesar_const1(self.d_pro)
activate(p,p.run())
yield hold,self,0.000000000000001
if x<=0.5:
p=procesar_const4(self.d_pro)
activate(p,p.run())
yield hold,self,0.000000000000001
if self.op==2:
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 104
for j in range(self.num):
p=proceso_pa4(self.t_pro,self.d_pro)
activate(p,p.run())
yield hold,self,0.000000000000001
elif self.t_pro==2:
if self.op==1:
for i in range(self.num):
x=random()
if x>0.5:
p=procesar_expo1(self.d_pro)
activate(p,p.run())
yield hold,self,0.000000000000001
if x<=0.5:
p=procesar_expo4(self.d_pro)
activate(p,p.run())
yield hold,self,0.000000000000001
if self.op==2:
for j in range(self.num):
p=proceso_pa4(self.t_pro,self.d_pro)
activate(p,p.run())
yield hold,self,0.000000000000001
class proceso_pa4(Process):
def __init__(self,t_pro,media):
Process.__init__(self)
self.media=media
self.t_pro=t_pro
def run(self):
if self.t_pro==1:
arrive=now()
Qlength = [NoInSystem(re_sim[i]) for i in range(len(re_sim))]
print "%7.4f %s: llegada %s "%(now(),self.name,Qlength)
for i in range(len(re_sim)):
if Qlength[i] ==0 or Qlength[i]==min(Qlength):
join =i ; break
yield request,self,re_sim[join]
en_cola=now()-arrive
t_espera.tally(en_cola)
print "espero en cola",en_cola
yield hold,self,self.media
yield release,self,re_sim[join]
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 105
print "Finalizo el proceso ",now()
print "El proceso duro",now()-en_cola
d_proc.tally(now()-en_cola)
proceso_pa4.procesadas+=1
if self.t_pro==2:
arrive=now()
Qlength = [NoInSystem(re_sim[i]) for i in range(len(re_sim))]
print "%7.4f %s: llegada %s "%(now(),self.name,Qlength)
for i in range(len(re_sim)):
if Qlength[i] ==0 or Qlength[i]==min(Qlength):
join =i ; break
yield request,self,re_sim[join]
en_cola=now()-arrive
t_espera.tally(en_cola)
print "espero en cola",en_cola
yield hold,self,expovariate(1.0/self.media)
yield release,self,re_sim[join]
print "Finalizo el proceso ",now()
print "El proceso duro",now()-en_cola
d_proc.tally(now()-en_cola)
proceso_pa4.procesadas+=1
class procesar_const4(Process):
def __init__(self,interval):
Process.__init__(self)
self.interval=interval
def run(self):
start=now()
yield request,self,re_sim[1]
t_cola=now()
print "inicio de proceso 2 en el tiempo",t_cola
t_esp=t_cola-start
t_espera2.tally(t_esp)
print "espera en cola",t_esp
yield hold,self,self.interval
t_salida=now()
print "libero el recurso 2 en el tiempo",t_salida
t_ate=t_salida-t_cola
t_proc2.tally(t_ate)
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 106
print "el proceso duro",t_ate
yield release,self,re_sim[1]
procesar_const4.ENT_PRO+=1
class procesar_expo4(Process):
def __init__(self,media):
Process.__init__(self)
self.mu=media
def run(self):
start=now()
print "inicio de proceso 2 al tiempo",start
time_pro=expovariate(1.0/self.mu)
yield request,self,re_sim[1]
t_cola=now()
t_esp=t_cola-start
t_espera2.tally(t_esp)
print "espera en cola",t_esp
yield hold,self,time_pro
t_salida=now()
print "libero el recurso 2 en el tiempo",t_salida
t_ate=t_salida-t_cola
t_proc2.tally(t_ate)
print "el proceso duro",t_ate
yield release,self,re_sim[1]
procesar_expo4.ENT_PRO+=1
def rec_sim(recursos):
for i in range(len(recursos)):
recursos[i]=Resource(name=recursos[i])
return recursos
def model(sec_eve,linea_logica,recursos,entidad):
global t_espera,t_espera2,t_proc,t_proc2
if "llegadas" in sec_eve and sec_eve.count("llegadas")==1:
in_lle=int_lle(entidad)
t_sim=t_simu()
print "Cuantas replica desea hacer de la simulacion?"
REP=int(raw_input())
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 107
t_ac=0.0
if sec_eve==["llegadas","cola","Inicio","proceso","Fin","almacen"]
and len(in_lle)==2:
print "La duracion del proceso es"
print "Constante s/n"
r1=raw_input()
if r1=="s" or r1=="S":
print "Indique la duracion constante el proceso"
d_pro=float(raw_input())
t_pro=1
elif r1!="s" and r1!="S":
print "Duracion exponencial"
print "Introduzca el valor de la media"
d_pro=float(raw_input())
t_pro=2
for i in range(REP):
initialize()
re_sim=rec_sim(recursos)
seed=98651462
t_espera=Monitor2()
t_proc=Monitor2()
if in_lle[0]==2:
llegadas_expo1.LLEGADAS1=0
procesar_expo1.ENT_PRO=0
lle=llegadas_expo1(in_lle[1],t_pro,d_pro)
activate(lle,lle.pro_lle(),0.0)
simulate(until=t_sim)
print "**************************************************"
print "Ocurrieron",llegadas_expo1.LLEGADAS1,"llegadas"
print "Se procesaron", procesar_expo1.ENT_PRO,"entidades"
elif in_lle[0]==1:
LLEGADAS1=0
ENT_PRO=0
lle=lle_const1(in_lle[1],t_pro,d_pro)
activate(lle,lle.pro_lle())
simulate(until=t_sim)
print "Tiempo promedio de espera en cola:",t_espera.mean()
print "Tiempo promedio de duracion del proceso",t_proc.mean()
print "******************************************************"
elif sec_eve==["llegadas","cola","Inicio","proceso","Fin","almacen"] and len(in_lle)!=2 and len(recursos)==1:
if len(in_lle)==4:
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 108
print "La duracion del proceso es constante? s/n"
r=raw_input()
if r=="s" or r=="S":
print "Valor de la duracion:"
d_pro=float(raw_input())
t_pro=1
else:
print "Duracion de proceso exponencial"
print "Valor de la media:"
d_pro=float(raw_input())
t_pro=2
t1=in_lle[1]
t2=in_lle[3]
tiempos=[t1,t2]
for i in range(REP):
initialize()
lle_varias.tipo1=0
lle_varias.tipo2=0
proceso_dif1.tipo1=0
proceso_dif1.tipo2=0
re_sim=rec_sim(recursos)
seed=98651462
t_espera=Monitor2()
t_proc=Monitor2()
lle=lle_varias(tiempos,t_pro,d_pro)
activate(lle,lle. pro_lle())
simulate(until=t_sim)
print "Tiempo promedio de espera en cola:",t_espera.mean()
print "Tiempo promedio de duracion del proceso:",t_proc.mean()
print "Entidades de tipo 1 procesadas:",proceso_dif1.tipo1
print "Entidades de tipo 2 procesadas:",proceso_dif1.tipo2
elif sec_eve==["almacen","Inicio","proceso","Fin","proceso","Fin"]and len(recursos)==2:
f=open("resultados.txt","w")
f.write("Tiempo de simulacion: %s \n"%t_sim)
f.write("Numero de replicas: %s \n"%REP)
f.write("\n")
print "Cuantas entidades hay en el almacen para ser procesadas?"
num=int(raw_input())
print "La duracion de los 2 procesos es"
print "Constante s/n"
r1=raw_input()
if r1=="s" or r1=="S":
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 109
t_pro=1
print "Indique la duracion constante el proceso 1"
d_pro1=float(raw_input())
print "Indique la duracion constante el proceso 2"
d_pro2=float(raw_input())
elif r1!="s" and r1!="S":
t_pro=2
print "Duracion de los dos procesos es exponencial"
print "Introduzca el valor de la media para le proceso 1"
d_pro1=float(raw_input())
print "Introduzca el valor de la media para le proceso 2"
d_pro2=float(raw_input())
for i in range(REP):
initialize()
re_sim=rec_sim(recursos)
seed=98651462
t_espera=Monitor2()
t_espera2=Monitor2()
t_proc=Monitor2()
t_proc2=Monitor2()
procesar_2_exp.PROCESADAS=0
procesar_2_cons.PROCESADAS=0
rutina=ini_alma2(num,t_pro,d_pro1,d_pro2)
activate(rutina,rutina.ejecutar())
simulate(until=t_sim)
print "************************************************"
f.write("Tiempo promedio de espera en cola proceso 1: %s \n"%t_espera.mean())
f.write("Tiempo promedio de duracion de proceso 1: %s \n"%t_proc.mean())
f.write("Tiempo promedio de espera en cola proceso 2: %s \n"%t_espera2.mean())
f.write("Tiempo promedio de duracion de proceso 2: %s \n"%t_proc2.mean())
print "Tiempo promedio de espera en cola proceso 1:",t_espera.mean()
print "Tiempo promedio de duracion de proceso 1", t_proc.mean()
print "Tiempo promedio de espera en cola proceso 2",t_espera2.mean()
print "Tiempo promedio de duracion de proceso 2", t_proc2.mean()
if procesar_2_exp.PROCESADAS>0:
print "Entidades procesadas",procesar_2_exp.PROCESADAS
f.write("Entidades procesadas: %s \n"%procesar_2_exp.PROCESADAS)
else:
print "Entidades procesadas",procesar_2_cons.PROCESADAS
f.write("Entidades procesadas: %s \n"%procesar_2_cons.PROCESADAS)
print "**********************************************************"
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 110
f.write("\n")
elif sec_eve==["llegadas","cola","Inicio","proceso","Fin","proceso","Fin"] or sec_eve==["llegadas","almacen","Inicio","proceso","Fin","proceso","Fin"]:
print "La duracion de los 2 procesos es"
print "Constante s/n"
r1=raw_input()
if r1=="s" or r1=="S":
print "Indique la duracion del proceso 1"
d_pro1=float(raw_input())
print "Indique la duracion del proceso 2"
d_pro2=float(raw_input())
t_pro=1
elif r1!="s" and r1!="S":
print "Duracion de los dos procesos es exponencial"
print "Introduzca el valor de la media para le proceso 1"
d_pro1=float(raw_input())
print "Introduzca el valor de la media para le proceso 1"
d_pro2=float(raw_input())
t_pro=2
if len(in_lle)==2:
if in_lle[0]==2:
lle=lle_exp2(in_lle[1],t_pro,d_pro1,d_pro2)
activate(lle,lle.ejecutar())
simulate(until=t_sim)
if in_lle[0]==1:
lle=lle_con2(in_lle[1],t_pro,d_pro1,d_pro2)
activate(lle,lle.ejecutar())
simulate(until=t_sim)
elif sec_eve==["llegadas","llegadas","cola","cola","Inicio","proceso","Fin"]
and len(recursos)==2:
print "Indique le valor de la media para el intervalo entre llegadas"
print "Para la primera transicion:"
t1=float(raw_input())
print "Para la segunda transicion:"
t2=float(raw_input())
print "Duracion de los procesos constante? s/n"
r=raw_input()
if r=="s" or r=="S":
print "Valor de la duracion 1:"
d_pro1=float(raw_input())
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 111
print "Valor de la duracion 2:"
d_pro2=float(raw_input())
t_pro=1
else:
print "Duracion de los procesos exponencial"
print "Valor de la media 1:"
d_pro1=float(raw_input())
print "Valor de la media 2:"
d_pro2=float(raw_input())
t_pro=2
print "Selecione mediante el siguiente menu, como es la utilizacion de los recursos, a saber:"
print "Marque uno (1) si el uso es secuencial (La entidad utliza un recurso y luego el otro)"
print "Marque dos (2) si el uso es consecutivo"
print "(Ambos recursos ejecutan un mismo proceso,las entidades pueden utilizar cualquier recurso libre)"
op=int(raw_input())
for i in range(REP):
initialize()
re_sim=rec_sim(recursos)
seed=98651462
proceso_sec3.procesadas=0
proceso_pa3.procesadas=0
t_espera=Monitor2()
t_espera2=Monitor2()
t_proc=Monitor2()
t_proc2=Monitor2()
lle=dos_lle3(t1,t2,op,t_pro,d_pro1,d_pro2)
activate(lle,lle.ejecutar())
simulate(until=t_sim)
print "********************************************************"
if proceso_sec3.procesadas>0:
print "Tiempo promedio de espera en cola proceso 1: ",t_espera.mean()
print "Tiempo promedio de duracion de proceso 1: ", t_proc.mean()
print "Tiempo promedio de espera en cola proceso 2: ",t_espera2.mean()
print "Tiempo promedio de duracion de proceso 2: ", t_proc2.mean()
print "Entidades procesadas:",proceso_sec3.procesadas
else:
print "Tiempo promedio de espera en cola: " ,t_espera.mean()
print "Tiempo promedio de duracion de procesos", t_proc.mean()
print "Entidades procesadas:",proceso_pa3.procesadas
elif sec_eve==["almacen","Inicio","Inicio","proceso","proceso","Fin","Fin"] or sec_eve==["almacen","Inicio","Inicio","proceso","Fin","proceso","Fin"]:
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 112
if len(recursos)==2:
print "Procesos de duracion constante? s/n"
r=raw_input()
if r=="s" or r=="S":
print "valor de la duracion:"
d_pro=float(raw_input())
t_pro=1
elif r!="s" and r!="S":
print "Duracion de proceso exponencial"
print "Valor de la media:"
d_pro=float(raw_input())
t_pro=2
print "Cuantas entidades hay en el almacen para ser procesadas?"
num=int(raw_input())
print "Selecione mediante el siguiente menu, como es el proceso de seleccion de entidades para cada proceso:"
print "Marque uno (1) si la seleccion es aleatoria"
print "Marque dos (2) si la seleccion es atencion al recurso con menor cola"
op=int(raw_input())
for i in range(REP):
initialize()
re_sim= rec_sim(recursos)
seed=98651462
t_espera=Monitor2()
t_espera2=Monitor2()
t_proc=Monitor2()
t_proc2=Monitor2()
procesar_const1.ENT_PRO=0
procesar_const4.ENT_PRO=0
procesar_expo4.ENT_PRO=0
procesar_expo1.ENT_PRO=0
proceso_pa4.procesadas=0
model=model4(num,op,t_pro,d_pro)
activate(model,model.ejecutar(),0.0)
simulate(until=t_sim)
print "********************************************************"
print "Tiempo promedio de espera en cola proceso 1: ",t_espera.mean()
print "Tiempo promedio de duracion de proceso 1: ", t_proc.mean()
print "Tiempo promedio de espera en cola proceso 2: ",t_espera2.mean()
print "Tiempo promedio de duracion de proceso 2: ", t_proc2.mean()
if procesar_const1.ENT_PRO>0:
print "Entidades procesadas",procesar_const1.ENT_PRO+ procesar_const4.ENT_PRO
APENDICE A. CODIGO FUENTE HERRAMIENTA RDPCSIMPY 113
elif procesar_expo1.ENT_PRO>0:
print "Entidades procesadas:",procesar_expo4.ENT_PRO+ procesar_expo1.ENT_PRO
else:
print "Entidades procesadas:",proceso_pa4.procesadas
print "********************************************************"
model(sec_eve,linea_logica,recursos,entidad)