“MODELADO Y SIMULACION POR EVENTOS´ DISCRETOS …

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:


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


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-


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.


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.


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


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


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:


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.


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


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.


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-


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


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


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.


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:


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.


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.


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.


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


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


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.


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


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


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


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()


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:


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


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.


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]]


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,


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?.


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.


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.


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.


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-


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)


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


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 “..........”).


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"


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],":"


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"


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])


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


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:




p=procesar_expo1(self.d_pro) # ‘‘Duracion de proceso exponencial’’

activate(p,p.run())


class procesar_expo1(Process): #Proceso de duracion exponencial

global re_sim

def __init__(self,media):


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):


self.interval=interval

def run(self):

start=now()


t_cola=now()

print "inicio de proceso 1 en el tiempo",t_cola

t_esp=t_cola-start



yield hold,self,self.interval

t_salida=now()



t_proc.tally(t_ate)




procesar_const1.ENT_PRO+=1

class lle_const1(Process): #‘‘Intervalo entre llegadas constante’’

def __init__(self,interval,t_pro,d_pro):



self.t_pro=t_pro

self.d_pro=d_pro

def pro_lle(self):

if self.t_pro==1:

while 1:



p=procesar_const1(self.d_pro)

activate(p,p.run())

elif self.t_pro==2:

while 1:



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):


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])


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:



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):


self.interval=d_pro

self.t_pro=t_pro

self.n=n

def run(self):

if self.t_pro==1:

start=now()


t_cola=now()

print "inicio de proceso al tiempo",t_cola

t_esp=t_cola-start




t_salida=now()

print "libero el recurso en el tiempo",t_salida



t_proc.tally(t_ate)


if self.n==1:

proceso_dif1.tipo1+=1

else:


if self.t_pro==2:

start=now()


t_cola=now()


t_esp=t_cola-start



yield hold,self,expovariate(1.0/self.interval)

t_salida=now()




t_proc.tally(t_ate)



if self.n==1:


else:


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):


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


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.


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


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


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


4.1.2. Ejemplo: Manufactura de piezas


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


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)]]



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


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



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


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


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


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.


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.


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]]


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)]


p1= almacen de piezas

t1= Evento 1: inicio del proceso de transporte

p2= pieza en proceso de transporte


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


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


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.


Tiempo total de simulacion: 5 horas= 300 minutos.

Numero de replicas: 2



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


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.



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]]


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)]


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)


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


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


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.



Numero de replicas: 2



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.


4.3.1. Ejemplo: Mantenimiento de equipos


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.


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]]


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)]



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.


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



Numero de equipos: 20

Tiempo duracion de cada proceso: Exponencial con media 15 minutos.


Numero de replicas: 2.



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-


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.


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



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()


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


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()


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"


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":


print "la cola",j+1,"almacena:"

for k in range(len(atributos)):

print atributos[k][0],"s/n"


res=raw_input()


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":


print "la cola almacena:"

for k in range(len(atributos)):

print atributos[k][0],"s/n"

res=raw_input()


en_cola.append([1,atributos[k][0]])

Cp[lugares[i]]=en_cola

if col=="nulo":


if op==3:

print "Ud eligio entidad en proceso"


uso_lugar[lugares[i]]="proceso"

if col!="nulo":


print "Que tipo de entidades se procesan?"

for j in range(len(atributos)):

print atributos[j][0],"s/n"

res=raw_input()


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":


continue

Cp[lugares[i]]=a_procesar

elif col=="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"


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))


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


if dest in transicion:

fun_node[arcos[i]]=[origen,dest]

break

else:

continue

elif dest in transicion:


else:

print "Nombre invalido"

break

elif origen in transicion:

print "Nodo Destino tipo lugar:"


if dest in transicion or dest not in lugares:

while 1:

print "Destino debe ser lugar:",lugares


if dest in lugares:


break

else:

continue

elif dest in lugares:


break

elif origen not in lugares or origen not in transicion:


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


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:



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:


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:



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":


linea_logica.append([sig0,uso_tran[sig0],arcos[k]])

existe.append(sig0)

secuencia=open("secuencia.txt","w")


pickle.dump(linea_logica[i],secuencia)

secuencia.close()

print linea_logica

return linea_logica

def sec_event(linea_logica):

ord_logi=[]


ord_logi.append(linea_logica[i][1])


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":




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)


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":




op=int(raw_input())

if op==1:



lis_t.append(1)

lis_t.append(t_lle)

elif op==2:



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:



lis_t.append(1)

lis_t.append(t_lle)

elif op==2:



lis_t.append(2)

lis_t.append(mu)

return lis_t

def t_simu():


print "Cuanto tiempo desea simular su modelo de RdPC"

ts=float(raw_input())

return ts

ejecutar.py

from __future__ import generators



from parametros import *

class llegadas_expo1(Process):

def __init__(self,media,t_pro,d_pro):


self.mu=media

self.t_pro=t_pro

self.d_pro=d_pro

def pro_lle(self):

if self.t_pro==1:

while 1:



activate(p,p.run())



elif self.t_pro==2:

while 1:




activate(p,p.run())


class procesar_expo1(Process):

global re_sim




self.mu=media

def run(self):

start=now()



t_cola=now()

t_esp=t_cola-start




t_salida=now()



t_proc.tally(t_ate)




class procesar_const1(Process):




def run(self):

start=now()


t_cola=now()


t_esp=t_cola-start




t_salida=now()




t_proc.tally(t_ate)




class lle_const1(Process):

def __init__(self,interval,t_pro,d_pro):



self.t_pro=t_pro

self.d_pro=d_pro

def pro_lle(self):

if self.t_pro==1:

while 1:




activate(p,p.run())

elif self.t_pro==2:

while 1:




activate(p,p.run())

class lle_varias(Process):

def __init__(self,tiempos,t_pro,d_pro):


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()



if x>0.5:



activate(p,p.run())

yield hold,self,t1

lle_varias.tipo1+=1

if x<=0.5:


activate(p,p.run())

yield hold,self,t2

lle_varias.tipo2+=1

class proceso_dif1(Process):

def __init__(self,t_pro,d_pro,n):


self.interval=d_pro

self.t_pro=t_pro

self.n=n

def run(self):

if self.t_pro==1:

start=now()


t_cola=now()


t_esp=t_cola-start




t_salida=now()




t_proc.tally(t_ate)


if self.n==1:


else:


if self.t_pro==2:

start=now()


t_cola=now()



t_esp=t_cola-start



yield hold,self,expovariate(1.0/self.interval)

t_salida=now()



t_proc.tally(t_ate)



if self.n==1:


else:


"""*******************************************Modelo 2***********************************************"""

class ini_alma2(Process):

def __init__(self,num,t_pro,d_pro1,d_pro2):


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):


self.t1=t1

self.t2=t2


def run(self):

start=now()


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_proc.tally(t_ate)

print "libero el primer recurso en el tiempo",tf


start2=now()


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


procesar_2_cons.PROCESADAS+=1

class procesar_2_exp(Process):

def __init__(self,m1,m2):


self.m1=m1

self.m2=m2

def run(self):

start1=now()

print "inicio de proceso 1 al tiempo",start1


time_pro1=expovariate(1.0/self.m1)


t_cola1=now()


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


t_proc.tally(t_ate1)


start2=now()

print "inicio de proceso 2 al tiempo",start2

time_pro2=expovariate(1.0/self.m2)


t_cola2=now()



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




procesar_2_exp.PROCESADAS+=1

class lle_con2(Process):

def __init__(self,interval,t_pro,d_pro1,d_pro2):



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:



p=procesar_2_cons(d_pro1,d_pro2)

activate(p,p.run())


if self.t_pro==2:

while 1:


p=procesar_2_exp(d_pro1,d_pro2)

activate(p,p.run())


class lle_exp2(Process):

def __init__(self,me,t_pro,d_pro1,d_pro2):


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:


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:


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):


self.interval1=interval1


self.op=op

self.t_pro=t_pro


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())


if self.op==2:

if x>0.5:

p=proceso_pa3(self.t_pro,self.d_pro1)

activate(p,p.run())


if x<=0.5:

p=proceso_pa3(self.t_pro,self.d_pro1)

activate(p,p.run())


class proceso_sec3(Process):

def __init__(t_pro,self,interval1,interval2):




self.t_pro=t_pro

def run(self):

if self.t_pro==1:

start=now()


t_cola=now()

t_esp=t_cola-start



tf=now()

t_ate=tf-t_cola

t_proc.tally(t_ate)






start2=now()


t_cola2=now()




tf2=now()

t_ate2=tf2-t_cola2






proceso_sec3.procesadas+=1

if self.t_pro==2:

start=now()


t_cola=now()

t_esp=t_cola-start


yield hold,self,expovariate(1.0/self.interval1)

tf=now()

t_ate=tf-t_cola

t_proc.tally(t_ate)





start2=now()


t_cola2=now()




tf2=now()

t_ate2=tf2-t_cola2







proceso_sec3.procesadas+=1

class proceso_pa3(Process):

def __init__(self,t_pro,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 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()





join =i ; break












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):


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:


x=random()

if x>0.5:


activate(p,p.run())

yield hold,self,0.000000000000001

if x<=0.5:


activate(p,p.run())

yield hold,self,0.000000000000001

if self.op==2:



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:


x=random()

if x>0.5:


activate(p,p.run())

yield hold,self,0.000000000000001

if x<=0.5:


activate(p,p.run())

yield hold,self,0.000000000000001

if self.op==2:


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):


self.media=media

self.t_pro=t_pro

def run(self):

if self.t_pro==1:

arrive=now()





join =i ; break





yield hold,self,self.media







if self.t_pro==2:

arrive=now()





join =i ; break





yield hold,self,expovariate(1.0/self.media)






class procesar_const4(Process):




def run(self):

start=now()


t_cola=now()


t_esp=t_cola-start

t_espera2.tally(t_esp)



t_salida=now()



t_proc2.tally(t_ate)





class procesar_expo4(Process):



self.mu=media

def run(self):

start=now()

print "inicio de proceso 2 al tiempo",start



t_cola=now()

t_esp=t_cola-start

t_espera2.tally(t_esp)



t_salida=now()



t_proc2.tally(t_ate)




def rec_sim(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())


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"


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())


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:


print "La duracion del proceso es constante? s/n"

r=raw_input()


print "Valor de la duracion:"


t_pro=1

else:

print "Duracion de proceso exponencial"

print "Valor de la media:"


t_pro=2

t1=in_lle[1]

t2=in_lle[3]

tiempos=[t1,t2]


initialize()

lle_varias.tipo1=0

lle_varias.tipo2=0

proceso_dif1.tipo1=0

proceso_dif1.tipo2=0


seed=98651462

t_espera=Monitor2()

t_proc=Monitor2()

lle=lle_varias(tiempos,t_pro,d_pro)

activate(lle,lle. pro_lle())


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"


r1=raw_input()

if r1=="s" or r1=="S":


t_pro=1

print "Indique la duracion constante el proceso 1"

d_pro1=float(raw_input())

print "Indique la duracion constante el proceso 2"



t_pro=2

print "Duracion de los dos procesos es exponencial"

print "Introduzca el valor de la media para le proceso 1"





initialize()


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())


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 "**********************************************************"


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"


r1=raw_input()

if r1=="s" or r1=="S":

print "Indique la duracion del proceso 1"


print "Indique la duracion del proceso 2"


t_pro=1


print "Duracion de los dos procesos es exponencial"





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())


if in_lle[0]==1:

lle=lle_con2(in_lle[1],t_pro,d_pro1,d_pro2)



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()


print "Valor de la duracion 1:"



print "Valor de la duracion 2:"


t_pro=1

else:

print "Duracion de los procesos exponencial"

print "Valor de la media 1:"


print "Valor de la media 2:"


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())


initialize()


seed=98651462

proceso_sec3.procesadas=0

proceso_pa3.procesadas=0

t_espera=Monitor2()


t_proc=Monitor2()

t_proc2=Monitor2()

lle=dos_lle3(t1,t2,op,t_pro,d_pro1,d_pro2)



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"]:


if len(recursos)==2:

print "Procesos de duracion constante? s/n"

r=raw_input()


print "valor de la duracion:"


t_pro=1

elif r!="s" and r!="S":

print "Duracion de proceso exponencial"

print "Valor de la media:"


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())


initialize()

re_sim= rec_sim(recursos)

seed=98651462

t_espera=Monitor2()


t_proc=Monitor2()

t_proc2=Monitor2()

procesar_const1.ENT_PRO=0

procesar_const4.ENT_PRO=0



proceso_pa4.procesadas=0

model=model4(num,op,t_pro,d_pro)

activate(model,model.ejecutar(),0.0)


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


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)

“MODELADO Y SIMULACION POR EVENTOS´ DISCRETOS …

Documents

Transcript of “MODELADO Y SIMULACION POR EVENTOS´ DISCRETOS …