Un Primer Paso A La Simulacion Con

Un primer paso a la simulación con

Isaías Simón Marmolejo

Un primer paso a la simulación con FlexSim

Un primer paso a la simulación con FlexSim ISAÍAS SIMÓN MARMOLEJO Escuela Superios de Ciudad Sahagún Universidad Autónoma del Estado de Hidalgo

Título

Autor Isaías Simón Marmolejo, es maestro en ciencias en ingeniería industrial por la Universidad Autónoma del Estado de Hidalgo (2009) y a la fecha estudia un doctorado en manufactura avanzada en el Centro de Tecnología Avanzada CIATEQ. Actualmente es profesor investigador en la Escuela Superior de Cd. Sahagún de la Universidad Autónoma del Estado de Hidalgo, y es profesor por asignaturas en el Instituto Tecnológico Nacional de México Campus Pachuca con docencia en las asignaturas de: investigación de operaciones, simulación de eventos discretos, planeación y organización de la Producción y cadena de suministros.

Editores

En memoria de mis abuelitas Sofía Mendoza y Esperanza Mota quienes me enseñaron el valor de la vida

Gracias Dios

Índice de contenido PRÓLOGO .............................................................................................................. III ORGANIZACIÓN DEL LIBRO.................................................................................... IV USO DEL SOFTWARE............................................................................................... V USO DE LA WEB ..................................................................................................... VI AGRADECIMIENTOS ............................................................................................. VII

CAPÍTULO 1. 1.1. 1.2. 1.3.

REVISIÓN DE LA LITERATURA .................................................... 1

DEFINICIÓN DE SIMULACIÓN ..................................................................... 2 LA SIMULACIÓN A TRAVÉS DEL TIEMPO ..................................................... 3 LA NUEVA GENERACIÓN DE SIMULADORES ............................................... 5

CAPÍTULO 2.

APRENDIZAJE Y APLICACIONES DEL SOFTWARE FLEXSIM .......... 7

2.1. DESCRIPCIÓN DEL SOFTWARE .................................................................... 8 2.2. APLICACIONES DEL SOFTWARE .................................................................. 9 2.3. DEL SOFTWARE FLEXSIM ............................................................................ 9 2.3.1. Características y Terminología de FlexSim........................................................ 9 2.3.2. Conceptos Adicionales ................................................................................ 29

CAPÍTULO 3.

CONSTRUCCIÓN DE UN MODELO BÁSICO ............................... 39

3.1. 3.2.

INTRODUCIR LOS OBJETOS DE FLEXSIM ................................................... 40 CONEXIÓN DE PUERTOS PARA DEFINIR EL FLUJO DE LOS FLOWITEMS 41 3.3. EDITAR LAS PROPIEDADES DE LOS OBJETOS ............................................ 43 3.3.1. Configuración Deseada ............................................................................... 43 3.3.2. Edición de los Objetos del Modelo ................................................................. 46 3.4. CORRER EL MODELO ................................................................................ 49 3.5. NAVEGACIÓN Y VISTAS ANIMADAS.......................................................... 49 3.6. REPORTE Y ESTADÍSTICAS DE LOS OBJETOS ............................................. 50 3.7. PROBLEMAS COMPLEMENTARIOS ........................................................... 55

CAPÍTULO 4.

CONSTRUCCIÓN DE UN MODELO PASO A PASO .................... 61

4.1. DESCRIPCIÓN DEL CASO DE ESTUDIO ....................................................... 62 4.2. PASO 1. DISEÑO Y CONEXIÓN DEL MODELO PRELIMINAR ....................... 64 4.3. PASO 2. ITEMTYPE Y ESTRATEGIAS DE RUTEO (SEND TO PORT), DESDE EL SOURCE HASTA EL SINK ......................................................................................... 67 4.4. PASO 3. EDICIÓN Y COMPORTAMIENTO DE OBJETOS (INTERARRIVALTIME, DEMPIRICAL, TRIGGERS, LABELS, FLOWITEM BIN Y PROCESS TIME) 72 4.4.1. Iniciemos con la programación del Source:....................................................... 72 4.5. PASO 4. AÑADIENDO TASK EJECUTERS (OPERATOR Y DISPATCHER) AL MODELO ............................................................................................................... 87

4.6. PASO 5. INFORMACIÓN ESTADÍSTICA DE LOS OBJETOS Y TEXTOS VISUALES ............................................................................................................... 89

CAPÍTULO 5.

APLICACIONES Y USOS VARIADOS .......................................... 93

5.1. INTRODUCCIÓN ....................................................................................... 94 5.2. EJEMPLO: SISTEMAS PULLED O PUSHED Y EL USO DE LA DISTRIBUCIÓN BERNOULLI ............................................................................................................ 94 5.2.1. Conceptos ................................................................................................. 95 5.2.2. Creación del modelo .................................................................................... 97 5.3. EJEMPLO: SISTEMA DE ENRUTAMIENTOS COMPLEJOS............................ 99 5.3.1. Conceptos ............................................................................................... 100 5.3.2. Creación del modelo ................................................................................. 101 5.4. EJEMPLO: LÓGICA FLEXSCRIPT Y PRIORIDAD DE USO ............................. 107 5.4.1. Conceptos ............................................................................................... 108 5.4.2. Creación del modelo ................................................................................. 113 5.5. EJEMPLO: LOS OBJETOS TASK EXECUTERS Y LA INTERRUPCIÓN DE TAREAS 117 5.5.1. Conceptos ............................................................................................... 119 5.5.2. Creación del modelo .................................................................................. 120 5.6. EJEMPLO: RECURSOS MÓVILES Y RUTAS DE VIAJE ................................. 126 5.6.1. Conceptos ............................................................................................... 128 5.6.2. Creación del modelo .................................................................................. 130 5.7. EJEMPLO: USO DEL RECURSO COMBINER E IMPORTACIÓN DE DATOS DE EXCEL 131 5.7.1. Conceptos ............................................................................................... 132 5.7.2. Creación del modelo .................................................................................. 133 5.8. EJEMPLO: PROGRAMACIÓN DE AVERÍAS Y MANTENIMIENTO EN LOS EQUIPOS CON LA HERRAMIENTA MTBF/MTTR ................................................... 140 5.8.1. Conceptos ............................................................................................... 141 5.8.2. Creación del modelo ................................................................................. 143

CAPÍTULO 6.

UN MODELO DE FLUIDOS ...................................................... 145

6.1. SIMULACIÓN DE FLUIDOS ...................................................................... 146 6.1.1. Descripción del caso de estudio .................................................................... 146 6.1.2. Descripción de los objetos del modelo ........................................................... 147 6.1.3. Descripción de términos para el modelado de fluidos ........................................ 148 6.2. CONSTRUCCIÓN DEL MODELO ............................................................... 150 6.2.1. Conexión de objetos .................................................................................. 151 6.2.2. Configuración de los Objetos....................................................................... 152 6.3. EJECUCIÓN DEL MODELO ....................................................................... 161 COMPENDIO DE PROBLEMAS ............................................................................. 163 REFERENCIAS BIBLIOGRÁFICAS .......................................................................... 171

ii

Prólogo Para poder comprender la realidad y complejidad que un sistema puede conllevar, ha sido necesario construir artificialmente objetos y experimentar con ellos dinámicamente antes de interactuar con el sistema real. Las operaciones, procesos o servicios de varias clases que existen en el mundo real (o de forma hipotética) son usualmente llamados sistemas y para estudiarlos de forma científica frecuentemente se hace un conjunto de suposiciones acerca de cómo estos trabajan. Estas suposiciones, que generalmente toman la forma de relaciones matemáticas o lógicas constituyen un modelo que es usado para intentar ganar un entendimiento de cómo se comporta el sistema correspondiente. Si las relaciones que componen el modelo son bastante simples, puede ser posible usar métodos matemáticos (tales como, cálculo o teoría de probabilidad) para obtener información exacta en cuestiones de interés, a esto se le llama solución analítica. Sin embargo, la mayoría de sistemas del mundo real son complejos, por lo que deben ser estudiados por medio de simulación para permitir que los modelos sean realistas y puedan ser evaluados de forma analítica (la simulación por computadora puede verse como el equivalente computarizado a ese tipo de experimentación). Las áreas de aplicación de la simulación son numerosas y diversas; es usual encontrar aplicaciones en ingeniería, economía, medicina, biología, ecología o ciencias sociales. No obstante, el mostrar un panorama concreto de simulación desde una perspectiva aleatoria en modelos prácticos utilizando el software FlexSim, requiere del entendimiento de los conceptos elementales que componen esta analogía. En este contexto, es necesario tener una buena comprensión teórica de los conceptos de modelado y simulación. Además de contar con conocimientos en el desarrollo experimental. Por tanto en este documento se describen los conceptos principales del tema en estudio. El objetivo de este libro es exhortar el uso de la simulación en la evaluación de un sistema productivo en un ambiente virtual, con la intención de lograr la máxima eficiencia, minimizar costos, mejorar la calidad, reducir el lapso de tiempo entre la fabricación y la entrega de los productos al cliente, proyectar escenarios catastróficos y extremos. Así como la aplicación de alternativas educativas para la formación de personal en diferentes áreas de una organización, estudiantes, catedráticos e investigadores.

iii

Organización del libro Es nuestra intención brindar las bases para describir, representar y analizar la operación de un sistema real y así vislumbrar la proyección del ingenio hacia la propuesta de alternativas y escenarios que logren dar solución a distintas situaciones planteadas. Lo que usted aprenderá es: En el 1er. Capítulo titulado “Revisión de la Literatura”, se abordarán conceptos puntuales de simulación, su evolución a través del tiempo y la nueva generación de los simuladores, con el objeto de introducir al lector en los temas venideros. El 2do. Capítulo “Aprendizaje y Aplicaciones del Software FlexSim”, se hace una remembranza del software, se puntualiza en algunas aplicaciones comunes y se refieren las características y terminologías del mismo. El 3er. Capítulo “Construcción de un Modelo Básico”, contiene las instrucciones básicas y las recomendaciones necesarias para construir un modelo simple de simulación de eventos discretos. En general, se establecen y especifican los medios para añadir lógica a un modelo el cual representará el comportamiento de un sistema real. En el 4to. Capítulo “Construcción de un Modelo Paso a Paso”, se describe un caso de estudio en el cual se abordan diferentes estrategias de ruteo, se hace uso de variables, distribuciones de probabilidad e identificadores como Labels e ItemTypes. Además, se añaden recursos móviles al modelo como apoyo en el transporte, describiéndose los pasos para hacer uso adecuado de la información estadística de los objetos mediante el empleo de la herramienta Dashboard (tablas dinámicas y gráficas). En el 5to. Capítulo, “Aplicaciones y Usos Variados”, se describen siete ejemplos con los cuales el lector aprenderá a describir, representar y analizar una gran variedad de variables y alternativas de rutina en el diseño de un modelo dentro de FlexSim, a través del uso del menú herramientas y de los recursos prediseñados en la biblioteca de objetos. Así mismo se describe con más detalle el control y la manipulación de recursos móviles como apoyo en las tareas de transporte, preparación de equipos, asistencia en mantenimiento, etc. Hay contenidos dedicados a la importación de datos (con hojas de cálculo de Excel), programación de rutinas, uso de distribuciones de probabilidad y análisis estadísticos, entre otras estrategias.

iv

En los modelos venideros se ilustra la manera de manipular material que se encuentra en cantidades discretas (cajas, esferas, piezas, etc.), no obstante dentro de muchos sistemas reales los materiales no necesariamente son piezas discretas sino fluidos. Un fluido o líquido puede ser casi cualquier cosa que se mida por peso o volumen (leche, agua, arroz, azúcar, etc.) e incluso muchos sistemas reales tienen líneas de producción híbridas, donde en algún momento se une material fluido con objetos discretos (envasado de postres, bebidas, etc.). Por tanto, el 6to. Capítulo “Un Modelo de Fluidos”, presenta los conceptos fundamentales para construir un modelo híbrido (material discreto y fluidos) en FlexSim. Aquí, el usuario desarrollará la simulación de un sistema donde se tenga que hacer empaques, uniones y lotes de objetos discretos, mezclas para dosificar productos y conversiones de objetos sólidos a material fluido y viceversa. Al finalizar la revisión del presente trabajo, será evidente para el lector que como resultado de este enfoque único, las aplicaciones de simulación con FlexSim son extremadamente flexibles y contienen un entorno fácil de usar en el desarrollo, modelación, simulación, visualización y control de las actividades y sistemas de proceso de eventos discretos y flujos dinámicos.

Uso del software Para descargar el software con la versión más reciente (Versión 7.7.0, construido el 23-11-2015), visite la página http://www.flexsim.com/es/ y de clic en “DESCARGA PRUEBA GRATUITA”. Si aún no está registrado, cree una cuenta en FlexSim utilizando su correo electrónico, el proceso es sencillo. En este mismo orden de ideas, es prudente mencionar que el software está diseñado para operar en cualquier sistema moderno de Windows, por lo que no tendrán problemas para ejecutarlo en su computadora de escritorio o laptop. Sin embargo, para mejorar la experiencia del usuario y para poder modelar situaciones únicas y de mayor complejidad se recomiendan requerimientos de Hardware adicionales:   

Windows XP, Vista, 7, 8 o bien 8.1 (en cualquier versión tanto con 32-bit o 64-bit). Procesador Intel con por lo menos 4 GB de RAM. Tarjeta de video NVIDIA GeForce para mostrar con mayor calidad los gráficos en tres dimensiones.

v

Uso de la web El documento contiene las características más sobresalientes del libro de texto Applied Simulation Modeling and Analysis Using FlexSim y del tutorial Welcome to the FlexSim User Manual el cual se incluye como ayuda en el software de FlexSim. Sin embargo, si desea conocer más sobre las bondades, acontecimientos recientes, tutoriales, ejemplos, cursos de entrenamiento, proyectos de consultoría, soporte técnico o cualquier otro aspecto de FlexSim, consulte la página http://www.flexsim.com/ o bien http://www.flexsim.com.mx/, y si lo require póngase en contacto con los responsables del sistema.

Enero 2016 Isaías Simón Marmolejo

vi

Agradecimientos Ningún libro es el resultado exclusivo del trabajo de su autor y este no es la excepción. En primer lugar quiero agradecer a la empresa FlexSim Software Products, Inc., a William Nordgren Presidente y CEO de FlexSim, al Vicepresidente, Director de operaciones y Cofundador de FlexSim Roger Hullinger, a Cliff King Vicepresidente de servicios al cliente, al Ing. Ben Wilson que forma parte de FlexSim y quien tuvo mucha paciencia al explicarme algunos modelos descritos en este documento y al Director de FlexSim México Ing. Jorge Toucet Torné por las facilidades brindadas para la realización de este manual. De igual forma quiero expresar mi gratitud a los alumnos del Instituto Nacional de México Campus Pachuca: Omar Vigueras, Dayan Jiménez, Silvia Vargas e Irait Ortiz, quienes ayudaron en la comprobación de problemas y revisión del contenido para esta edición. A mi hijo Yohan I. Simón que atraviesa sus tremendos tres años y que con su energía contagia de alegría cada día de mi vida. Con cariño y amor para mi linda esposa Leticia Flores a quien le robé mucho tiempo durante el proyecto y que ha sido parte fundamental de mi vida. A mis padres Cristina Marmolejo y Mario Simón con quienes tengo una deuda de enorme gratitud por creer en mí y apoyarme en todas mis decisiones. Y por supuesto a mis colegas y amigos de la Escuala Superiro de Cd. Sahagún en especial al Ing. Martín Ortiz Granillo, que en todo momento han compartido alegrías y tristezas, y que de una manera u otra me ofrecieron su apoyo para concluir esta obra.

Isaías Simón Marmolejo

vii

viii

1

CAPÍTULO 1.

Revisión de la Literatura

ESQUEMA DEL CAPÍTULO 1.1. DEFINICIÓN DE SIMULACIÓN 1.2. LA SIMULACIÓN A TRAVÉS DEL TIEMPO 1.3. LA NUEVA GENERACIÓN DE SIMULADORES OBJETIVOS DE APRENDIZAJE Después de un cuidadoso estudio de este capítulo, usted debe ser capaz de hacer lo siguiente: 1. Tendrá una idea general del concepto de simulación, modelo, sistema, eventos, instante del tiempo y de cambios continuos o discretos. 2. Podrá asimilar con claridad cómo ha sido la evolución de la técnica de simulación en los últimos años. 3. Sabrá cómo fue el nacimiento del primer software de simulación orientado a objetos en 3D con realidad virtual. NOTA: La fuente del total de las figuras ilustrativas aquí mostradas fueron tomadas del software FlexSim versión 7.7.0, propiedad de la empresa FlexSim Software Products, Inc.

2

SIMULACIÓN CON FLEXSIM

1.1. DEFINICIÓN DE SIMULACIÓN Para el desarrollo del presente trabajo resulta conveniente iniciar definiendo el término simulación. La simulación es la representación de algún proceso o sistema real a través del tiempo, ya sea hecha manualmente o en una computadora, ésta misma técnica involucra la generación de un historial artificial de un sistema y su observación para obtener inferencias relacionadas con las características operativas del sistema real (Banks et. al., 2001). Asimismo, de acuerdo a Kelton et. al., 2008, la simulación por computadora se refiere a los métodos para estudiar una gran variedad de modelos de sistemas del mundo real mediante la evolución numérica, usando un software diseñado para imitar las operaciones o características del sistema, a menudo en el transcurso del tiempo. La simulación inicia con un modelo. Un modelo es una descripción física o matemática de un sistema, objeto o evento y usualmente representa un punto particular de acción en el tiempo (Beaverstock et. al., 2012). De igual manera, los modelos son empleados para estudiar y determinar la representación de un sistema real de manera abstracta, con la intención de predecir el comportamiento del mismo. Sin embargo, dado que un sistema es un conjunto complejo, integrado de elementos interconectados el cual forma parte de otro sistema superior y se compone de sistemas de orden inferior (Acosta 2007), se dificulta el nivel de abstracción, pues la mayoría de los sistemas reales son muy complejos para permitir evaluaciones analíticas, por lo que los sistemas deben ser estudiados mediante la simulación (Law et. al. 2007). Un modelo de simulación representa la operación de algún proceso o sistema del mundo real, a través del tiempo, ya sea realizada manualmente o por medio de una computadora. La simulación involucra la generación de una historia artificial de un sistema y su observación para obtener inferencias relacionadas con las características operativas del sistema real (Banks et. al., 2005). Este modelo, comúnmente toma la forma de un conjunto de supuestos respecto a la operación del sistema, estos supuestos son expresados en forma de relaciones matemáticas y lógicas entre los objetos de interés del sistema. Entonces el sistema es modelado identificando las características de sus eventos y describiendo un juego de rutinas que dan una descripción detallada del sistema en estudio. Es así como los eventos de la simulación evolucionan en el tiempo (reloj de simulación) ejecutando los eventos en orden creciente del tiempo de ocurrencia: un evento es algo que sucede en un instante de tiempo (simulado) que puede cambiar atributos, variables o acumuladores estadísticos. Asimismo, un evento discreto es un momento especifico del tiempo (Winston, 2005). De esta forma, el estado de los elementos de un sistema cambia continuamente o solo en determinados estados del tiempo. El flujo del agua que entra y sale en una planta tratadora de aguas residuales y la entrada o salida de clientes que pagan la despensa en un cajero de

Capítulo 1. Revisión de la Literatura.

algún supermercado son ejemplos de cambios continuos y discretos, respectivamente. Esto es, en el primer ejemplo el agua no muestra un espacio de tiempo entre litro y litro, por otro lado, la llegada de las personas al cajero de un supermercado muestran tiempos variados entre una y otra. Posteriormente, una vez desarrollado, validado y verificado el modelo de simulación, este puede ser utilizado para investigar una amplia variedad de preguntas del tipo ¿Qué pasa si...?, acerca del mundo real (Kelton et. al., 2008). Realizado lo anterior, se procede con la planeación de los experimentos que se harán mediante el modelo de simulación establecido. Después de haber concluido el modelo de simulación, los clientes o dueños del sistema real tendrán una herramienta que les permitirá proyectar distintos escenarios de simulación en diferentes periodos de tiempo. No obstante, la simulación también puede ser utilizada para estudiar sistemas en su etapa de diseño (antes de que dichos sistemas sean construidos). De esta manera, los modelos de simulación pueden ser utilizados tanto como un instrumento de análisis para intuir los efectos de cambios en sistemas existentes en lapsos de tiempo distintos, o bien como un instrumento de diseño que pueda predecir el comportamiento de sistemas nuevos en proyecciones futuras. Como opinión particular, se considera que un sistema es modelado y simulado con la finalidad de identificar sus componentes, su estructura y observar su conducta (interacción y efecto de sus elementos) en términos de sinergia, con el propósito de crear, planificar, controlar y pronosticar el comportamiento de distintos escenarios que contribuyan a soluciones alternativas en efectos presentes para un futuro sustentable.

1.2. LA SIMULACIÓN A TRAVÉS DEL TIEMPO La palabra simulación, en su concepto actual, se remonta a finales de 1940 cuando Von Neumann y Ulam definieron el término «análisis de Monte Carlo» para aplicarlo a una técnica matemática que usaban al resolver ciertos problemas de protección nuclear que eran demasiado costosos o complicados para resolverse de forma experimental o analíticamente (Neumann, 1992). Sin embargo, la simulación analógica fue muy evidente durante los años 50, misma que se definía como Simulation Programming Languages (SPLs) o bien, Simulación por Ordenador (Nance, 1993). La necesidad de resultados cada vez más precisos y rápidos estimuló el desarrollo de cientos de nuevas técnicas de simulación en los últimos 60 años. Además, con el desarrollo de la computadora de gran velocidad, a principios de 1950 la simulación tomó otro significado, ya que surgió la posibilidad de

3

4

SIMULACIÓN CON FLEXSIM

experimentar con modelos matemáticos (que describen sistemas de interés) en una computadora. Su sorprendente evolución brindó la herramienta necesaria que permite la implementación de los métodos de simulación más complejos de una manera simple y eficiente (Beaverstock et. al., 2012). El primer simulador fue GSP (General Simulation Program) acreditado por K.D. Tocher en conjunto con D.G. Owen en 1960 (Tocher et. al., 1960). Mientras que en el periodo de 1961 a 1965 surgieron nuevos simuladores los cuales incluían, declaraciones del principal lenguaje de programación llamado FORTRAN (FORmula TRANslator System; es un lenguaje de programación adaptado especialmente al cálculo numérico y a la computación científica, desarrollado por John Backus e IBM en 1957), el cual se tenía como idioma hasta entonces (Barceló, 2008): GPSS (General Purpose System Simulator) y SIMULA descritos por Wexelblatt (1981), SIMSCRIPT enunciado por Marcowitz et. al., (1963), CSL (Control and Simulation Language) el cual contribuía con la solución de problemas complejos dentro de las empresas industriales y comerciales (Esso, 1963) y algunos más enunciados en la publicación de Nance (1993). En esa época el diseñador del software utilizaba instrucciones de lenguaje y macros para especificar al sistema su lógica de operación. Por lo cual, el modelador tenía inicialmente que entender todo el conjunto de argumentos antes de poder hacer un seguimiento de las variables de estado del sistema. Esto implicaba la construcción de macros complicados, se requería de mucho tiempo y los costos eran excesivos. Además, los modelos que empleaban estos lenguajes de simulación no contaban con animación (Bernard et. al., 2000). Posteriormente, la aparición de un nuevo lenguaje popular y de uso general llamado PASCAL desarrollado por Niklaus Wirth entre los años 1968 1969, estimuló el diseño posterior de paquetes de simulación basados en este lenguaje (Nance 1993): Bryant (1980; 1981) desarrolló el lenguaje de programación SIMPAS como un lenguaje de simulación de redes, el cual fue diseñado para ser altamente portátil y orientado a eventos. Otro programa sobresaliente fue el lenguaje de simulación de redes llamado INTERACTIVE, que permitía la utilización de símbolos gráficos, además de que la construcción y la ejecución eran interactivos (Lakshmanan, 1983). Por otro lado, un primer lenguaje que facilito añadir animación fue SIMAN, creado por C. Dennis Pegden en 1982. Sin embargo, para crear animación SIMAN utilizaba un segundo lenguaje independiente llamado CINEMA (Nance 1993). SIMAN y CINEMA más tarde (en el año 2000) se combinaron para crear al software Arena. En 1986, WITNESS lanzó el primer producto con nivel de construcciones prefabricadas junto con una mejor representación visual. Este nuevo software redujo aún más la necesidad de una programación directa en el lenguaje de simulación. La nueva generación de simuladores hasta entonces era más fácil de usar, pero aún carecían de flexibilidad y la programación de código

Capítulo 1. Revisión de la Literatura.

5

en el ordenador no estaba disponible para el usuario. A finales de los años 80, existían en el mercado diferentes simuladores para computadora basados en Disk Operating System (DOS) los cuales fueron creados principalmente para usos comerciales, incluyendo WITNESS, ProModel, SLAM y SIMFACTORY. En esa misma época, existieron en el mercado una amplia variedad de software de simulación; no obstante, muchos de ellos eran difíciles de usar, debido a su limitada capacidad gráfica, lo que ocasionaba el uso máximo de la capacidad de la computadora al momento de ejecutar los modelos de simulación (Beaverstock et. al., 2012).

1.3. LA NUEVA GENERACIÓN DE SIMULADORES En la década de los 90s, empezaron a surgir diferentes simuladores. En Europa surgió el SIMPLE++, SIMUL8 y Taylor II (el primer simulador 3D para ejecutarse en una PC). En Estados Unidos, se creó una gran variedad de software de simulación de los cuales los más notables son: Extend y Simcad. En 1998 Taylor ED fue puesto en el mercado. Esta última aplicación se destacó por ser el primer software de simulación orientado a objetos en 3D con realidad virtual, el cual también operaba con la plataforma de Microsoft Windows. Posteriormente, en el año 2003 fue lanzado FlexSim, el cual resultó ser sustancialmente diferente respecto a los simuladores anteriores tanto en su lenguaje de simulación como en su arquitectura (Beaverstock et. al., 2012), ver figura 1.1.

Figura 1.1. Ejemplo de la simulación orientada a objetos en 3D con el software FlexSim

6

SIMULACIÓN CON FLEXSIM

2

CAPÍTULO 2.

Aprendizaje y Aplicaciones del Software FlexSim

ESQUEMA DEL CAPÍTULO 2.1 2.2 2.3

DESCRIPCIÓN DEL SOFTWARE APLICACIONES DEL SOFTWARE DEL SOFTWARE FLEXSIM 2.3.1 Características y Terminología de FlexSim 2.3.2 Conceptos Adicionales

OBJETIVOS DE APRENDIZAJE Después de un cuidadoso estudio de este capítulo usted debe ser capaz de hacer lo siguiente: 1. Conocerá las bondades de FlexSim. 2. Descubrirá los usos y la variedad de aplicaciones de FlexSim. 3. Comprenderá los contenidos del menú principal, la barra de herramientas, el panel de ejecución de la simulación y la biblioteca de objetos. 4. Manipulará correctamente el mouse y teclado con las distintas vistas de los objetos, el Layout, las conexiones de puertos, entre otros usos. NOTAS: Es necesario que a partir de ahora ya se tenga instalado el software en algún equipo de cómputo, así el lector podrá interactuar con el software mientras lee el contenido de éste capítulo. Para descargar el software con la versión más reciente, visite la página http://www.flexsim.com/es/ y dé clic en “DESCARGA PRUEBA GRATUITA”.

8

SIMULACIÓN CON FLEXSIM

2.1. DESCRIPCIÓN DEL SOFTWARE Como se ha mencionado con anterioridad, FlexSim Software Products, Inc. inicia sus actividades desde el año de 1993. Bill Nordgren, presidente de FlexSim, es un pionero de la simulación cofundador y promotor de ProModel, llegando a ser líder mundial en el campo de la simulación en 1988. Junto con Cliff King y Roger Hullinger, Bill también introdujo Taylor II y Taylor ED en el mercado de simulación de América del Norte. Ellos entendieron que los cambios en la tecnología de simulación, el usuario base y las necesidades de los clientes se dirigían hacia el mercado de la facilidad y uso correcto de la herramienta de simulación. Con el tiempo, el trío, agregó al Ph.D. Eamonn Lavery y Anthony Johnson a su equipo de desarrollo. Gracias a estos descubrimientos el motor y la arquitectura del software colocan a FlexSim como el primero en su tipo y líder actual en funcionalidad y visualización 3D. Los siguientes puntos enlistan algunas razones por las cuales FlexSim es una buena alternativa como herramienta en simulación:   



  

Su extensa sección de pre-construidos permiten abordar situaciones mucho más complejas sin tener que escribir código de software. El software se orienta a objetos, lo que admite una mayor visualización del flujo de producción. Todo el proyecto se desarrolla en un ambiente tridimensional (3D), además permite importar infinidad de objetos de distintos paquetes de diseño, incluyendo AutoCAD, ProE, Solid Works, Catia, 3D Studio, AC3D, Rivit, Google Sketch-Up, etc. Otra razón importante es que no sólo se pueden simular sistemas discretos, sino que también se admite la simulación de fluidos o modelos combinados continuo- discreto. La generación de distintos escenarios y condiciones variadas son fáciles de programar. Las distribuciones de probabilidad se pueden representar con gran precisión en lugar de valores promedio para mostrar fielmente la realidad. Las gráficas, los reportes y todo lo que se refiere a los estadísticos se puede revisar a detalle.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

2.2. APLICACIONES DEL SOFTWARE FlexSim ha contribuido con aplicaciones de clase mundial en temas de salud y sistemas de logística tales como: operaciones de contenedores en puertos, simulaciones distribuidas en varios equipos dentro de una empresa manufacturera, en la minería, en centros aeroespaciales e incluso se ha adaptado a la industria del servicio (hoteles, hospitales, supermercados, o muchas otras industrias) para simular la administración y operación de los recursos humanos. Asimismo se ha demostrado en diferentes casos de diversos corporativos alrededor del mundo (Volkswagen, USAA, EATON, Coca-Cola, DAIMLER, Foth, DHL, Disney, MICHELIN, MATTEL, QUALCOMM, VALE, CATERPILLAR, DISCOVER, Pfizer, U.S. ARMY, U.S. AIR FORCE, DU PONT, Gillette, ABB, FREIGHTLINER, CARRIER, ORACLE, Tetra Pak, IBM, NASA, FedEx, AVON, Whirlpool, ALCAN, Remington, etc.) que FlexSim es una herramienta clave para mejorar los resultados al dar respuestas acertadas a los problemas planteados (FlexSim Software Products, Inc., 2013).

2.3. DEL SOFTWARE FLEXSIM 2.3.1. Características y Terminología de FlexSim El software descrito en este libro contiene la versión libre 7.7.0 actualizada el 23 de noviembre de 2015, el cual es completamente funcional para modelar tanto sistemas discretos como de flujos (continuo-discreto), se tiene acceso a casi todos los módulos del menú principal, se pueden exportar e importar imágenes de distintos paquetes como los antes descritos, se permite la accesibilidad a bases de datos como ODBC (Oracle o Access), estructura de datos (Texto, Archivos en Word y hojas de cálculo como Excel), y prácticamente cualquier dispositivo de hardware que se puede conectar a un ordenador. Es posible modificar objetos a través de códigos personales, y es fácil el acceso e interpretación de los estadísticos. También es importante mencionar que en esta versión estudiantil los modelos están limitados a 31 objetos, ya que el software trabaja bajo un compilador de Microsoft llamado Visual C++. NET y Flex-Script restringido, sin embargo este límite puede expandirse mediante una solicitud de la versión profesional a FlexSim Software Products, Inc., en la cual las aplicaciones de terceros, tales como ExpertFit y OptQuest pueden ser compilados para agregar flexibilidad y facilidad de uso en los modelos de simulación.

9

10

SIMULACIÓN CON FLEXSIM

Es evidente entonces que, como resultado de este enfoque único, las aplicaciones de simulación con FlexSim son extremadamente flexibles y contienen un entorno fácil de usar en el desarrollo, modelación, simulación, visualización y control de las actividades y sistemas de proceso de flujo dinámicos.

Asistente de arranque y unidades de medida Al dar inicio en FlexSim, la primer ventana de diálogo que se observa es el asistente de arranque (Start Page), esta ventana permite visualizar la opción para crear un modelo nuevo, abrir uno guardado con anterioridad, o bien podrá elegir una introducción del software si lo prefiere, e incluso será posible activar su licencia completa, entre otras cosas (véase figura 2.1).

Figura 2.1. Asistente de arranque (Start Page).

Si es seleccionada la opción New Model se desplegará la figura 2.2, en la cual se definen las unidades de medida bajo las cuales se quiere operar al modelo, las unidades de medida que elija se mantendrán durante la construcción del modelo y por tanto todos los datos que sean incluidos en el modelo serán considerados de acuerdo a estas unidades a menos que sean cambiadas manualmente dentro del mismo, e incluso los reportes estadísticos obtenidos conservarán estas unidades de medida.

Figura 2.2. Ventana de diálogo para asignar las unidades de medida necesarias.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

11

Ventana principal de FlexSim En la figura 2.3, se muestra la pantalla principal de FlexSim. Aquí, se observan claramente cinco áreas las cuales son necesarias para construir un modelo de simulación exitoso: menú principal, barra de herramientas, panel de ejecución de la simulación, biblioteca de objetos y model view window o área de trabajo donde se podrá modelar, además de una ventana que describe las propiedades tanto del área de trabajo como de cualquier objeto incluido y seleccionado en su modelo (Quick Properties). Posteriormente, el lector verá la descripción general de cada uno de estos contenidos.

Figura 2.3. Ventana principal de FlexSim.

a) Menú principal File. Con el menú mostrado en la figura 2.4 el programador podrá hacer uso de: – – – – – –

New Model: Crea nuevas hojas de trabajo. Open Model: Abre archivos de modelos creados en FlexSim con extensiones .FSM. Recent Models: Recupera modelos trabajados. Save: Guarda cambios en archivos de modelos con extensiones .FSM. Save Model As: Guarda archivos con distintos nombres en carpetas diferentes. New User Library y Open User Libraries…: Permiten crear nuevas librerias de objetos y abrir las antes diseñadas con extensiones .FSL, .FSX respectivamente.

12

SIMULACIÓN CON FLEXSIM

Figura 2.4. Ventana del menú File.

–

–

– – –

State Files: Guarda un modelo en ejecución actual para crear un archivo en cualquier momento de la simulación con todas las características del estado actual de operación, para luego cargar el estado del modelo y ser capaz de ejecutarlo desde ese punto. Global Preferences: Admite mediante una ventana dinámica configurar distintas particularidades en FlexSim, esto permite manipular el formato, los colores, el ambiente, el uso de librerias, personalizar la barra de herramientas, manipular los gráficos, etc. Model Settings: El comando visualiza las unidades de medida con las que opera el modelo. System: Es empleado para actualizar manualmente conexiones realizadas con algún software externo a FlexSim. Exit: Cierra el programa.

Edit. En la figura 2.5 se ilustran los submenús siguientes: – – –

– –

Undo y Redo: Permiten deshacer y rehacer operaciones con los comandos Ctrl+Z y Ctrl+Y respectivamente. Resize and Rotate Objects: Admiten cambios de tamaño y rotación en los objetos siempre que éste se encuentre activado. Set Spline Tension: Ajusta la tensión de los segmentos de la red, dicho ajuste deberá estar entre 0 y 1, el valor 0 hará que todos los segmentos de la red sean totalmente rectos y el 1 maximiza la curvatura de cada segmento. Set Number Precision: Precisa el número de decimales empleados en el reloj de la simulación. Set Conveyor Angle: Ajusta el ángulo del transporte.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

13

Figura 2.5. Ventana del menú Edit.

View. Dentro de los comandos más comunes para alterar la vista de un modelo se destaca los mostrados en la figura 2.6: – – – – – – –

–

Model View (3D): Permite ver al modelo en tres dimensiones; al dar clic sobre el comando se abrirá una nueva área de trabajo al origen del Layout. Model Tree: Muestra todas las carpetas y los objetos que están contenidos en el modelo. Model Control GUI: Brinda la apertura de una interfaz de usuario gráfica (Graphical User Interface “GUI”) diseñada por el modelador, la cual permite hacer cambios en los parámetros del modelo. Start Page: Muestra el asistente de arranque inicial descrito con anterioridad. Drag-Drop Library: El comando hace visible la biblioteca de objetos en caso de haberla cerrado previamente. Toolbox: Despliega una ventana, que administra las herramientas de los modelos, tal como Global Tables, Time Tables, Dashboards, etc. View Settings: Despliega una ventana de diálogo misma que puede ser operada para configurar diferentes vistas en el modelo, estas configuraciones únicamente aplican en la ventana activa al momento y se desactiva al cerrarla, desde aquí es posible definir el color de fondo del Layout (Background Color), especificar las conexiones (Connections), configurar la cuadrícula del área de trabajo (Grid), establecer si los nombres (Names) de los objetos serán visibles o no y algunos ajustes más. Quick Properties: Abre una ventana de propiedades rápida que contextualiza el panel de propiedades de una hoja de trabajo activa o de un objeto seleccionado en el momento.

14

SIMULACIÓN CON FLEXSIM

Figura 2.6. Ventana del menú View.

–

– – –

– –

–

Edit Selected Objects: Ofrece alternativas de configuración conjunta aplicables a un grupo de objetos seleccionados tal como: editar (Edit), copiar información del objeto seleccionado a otro conjunto de objetos (Copy from Highlighted), activar o desactivar ajustes en los objetos elegidos (Switches) y permite hacer conexiones de arrastre entre un objeto destacado y el conjunto de objetos seleccionados (Connections). Find Objects: Asiste al ejecutante para encontrar rápidamente objetos definidos en su modelo, ya sea por nombre o por categoría de objeto. Groups. Es un comando que permite crear y editar diversos grupos de objetos en el modelo, los cuales puede formar parte de uno o varios conjuntos. Model Layouts: Es una herramienta útil para crear diferentes diseños en distintos escenarios, de tal modo que sea posible observar vistas semejantes del modelo simplemente con elegir un número de Layout distinto. Measure/Convert: Asiste al modelador, para tomar lectura de la distancia existente entre un punto y otro, en la conversión de unidades de medida o tiempo según fueron establecidas en Model Settings. Animations and Components: Es empleado para lograr que el modelo luzca más realista al crear animación en diferentes puntos del mismo, tal como en la maniobra de un montacargas al realizar una tarea definida, donde sus distintos componentes pueden ser manipulados utilizando fotogramas clave para cambiar su posición, tamaño, rotación, etc., mientras se ejecuta el modelo. Media Files: Importa automáticamente formas 3D e imágenes precargadas al modelo, las cuales se admiten a través de la ventana de

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

–

15

propiedades de un objeto o mediante la opción Quick Properties. Current Database Table: Muestra la tabla de base de datos actualmente activa que se abrió o consultó con los comandos: dbopen (), dbchangetable () o dbsqlquery ().

Consulte en la ayuda de FlexSim el “Resumen de los comandos” para obtener más información sobre los mismos.

Build. La figura 2.7 enlista a los submenús: – – – – –

Build FlexScript: Se constituye por todos los códigos de FlexScript, mismos que son empleados para crear el modelo de simulación en lugar de hacer la programación en C++. Compile Model: Al elegir la opción, se compila todo el código C ++ del modelo. Compile Entire Session: Ejecuta todo el código C ++ definido únicamente en el árbol principal. Open Visual Studio…: Abre Microsoft Visual Studio. Make All Code C++/FlexScript: Son dos alternativas para crear códigos con C++ o FlexScript, mismos que se relacionan con la ejecución y programación del proyecto de simulación en diseño.

Figura 2.7. Ventana del menú Build.

Execute. Los botones resaltados en la figura 2.8, son empleados para la ejecución del modelo: – – – – –

Reset (Ctrl+Left): Restablece el archivo del modelo actual y se prepara para una nueva ejecución. Run (Ctrl+Space): Ejecuta el archivo del modelo. Stop (Ctrl+Space): Detiene el modelo en ejecución. Step (Ctrl+Right): Impulsa al modelo con intención de pasar al próximo evento en la lista de eventos. Increase Run Speed (Ctrl+Up) y Decrease Run Speed (Ctrl+Down): Son comandos empleados para aumentar y disminuir la velocidad del modelo en ejecución.

16

SIMULACIÓN CON FLEXSIM

Figura 2.8. Ventana del menú Execute.

Statistics. La ventana del menú mostrada en la figura 2.9, despliega una lista de alternativas las cuales operan estadísticas del modelo: –

–

–

–

Figura 2.9. Ventana del menú Statistics.

Reports and Statistics: Abre un cuadro de diálogo que contiene información sobre el flujo de las entidades, el estado del tiempo y toda la información necesaria para crear distintos informes sobre la base de las estadísticas colectadas durante el tiempo de simulación. Experimenter…: Se utiliza para proyectar distintos escenarios y con ello diferentes análisis del modelo original, dentro de esta misma opción es posible hacer uso del comando OptQuest, el cual es usado para encontrar los valores óptimos de un conjunto de variables definidas por el usuario a fin de minimizar o maximizar según sean los objetivos, esta aplicación fue desarrollada por OptTek Systems, Inc., y aunque se encuentra plenamente integrada en FlexSim, requiere de una licencia especial misma que se vende como un complemento a la licencia del software FlexSim básico (póngase en contacto con Flexsim Software Products, Inc. para obtener una licencia completa). Repeat Random Streams: Si es seleccionado este campo, será posible hacer que el modelo se ejecute con la misma semilla (streams) todo el tiempo y así los resultados serán iguales cada que corramos el modelo con los comandos Reset y Run. ExpertFit: El botón abre unas de las aplicaciones más importantes de FlexSim usada para determinar la mejor distribución de probabilidad estadística asociada con los datos de entrada, la herramienta fue desarrollado por Averill Law & Associates.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

17

Debug. El menú se basa en herramientas que apoyan la programación en FlexSim, mismas que se ilustran en la figura 2.10. –

– – – – – – –

Output Console, System Console y Compiler Console: Son comandos empleados para; abrir ventanas donde se muestre la información de salida, imprimir información sobre el estado del motor del programa e imprimir la información mientras que el modelo se compila, respectivamente. Script Console: Se abrirá la consola de Scripting la cual opera como una ventana interactiva para ejecutar los comandos de FlexScript manualmente. Breakpoints: Es empleado para determinar puntos de interrupción. FlexScript Code Profile: Muestra la ejecución de los códigos de simulación a fin de lograr una depuración del modelo. Event List: Despliega una lista de los eventos pendientes del modelo y es útil para visualizar información acerca de un evento hasta rastrear la fuente del problema existente. Event Log: Se utiliza para ver el orden en que cierto evento se llevó a cabo en el modelo, además permite explicar lo que sucedió en un evento determinado. Local Variables y Watch Variables: Son paneles empleados para mostrar y/o especificar el uso de variables del modelo respectivamente. Call Stack: Enlista una pila de llamadas actuales, creando un historial de llamadas a distintas funciones en orden descendente.

Figura 2.10. Ventana del menú Debug.

18

SIMULACIÓN CON FLEXSIM

Help. Por último, la figura 2.11 muestra, entre otras cosas, las principales bondades de FlexSim y contribuye con el usuario al desplegar distintos materiales de apoyo. – – – – – – – –

User Manual: Abre el manual de usuario FlexSim administrado por tres pestañas; una lista de contenido (Contents), un índice (Index) y una opción de búsqueda (Search). Commands: Despliega una lista de comandos la cual resume los parámetros y el uso de cada uno de los mismos disponibles en la programación FlexSim. Command Helper: Crea una ventana de ayuda que permite hacer referencia a cualquier comando FlexSim, al teclear el comando buscado se proporcionan detalles como: parámetros, descripción y ejemplos. Attribute Hints: Desprende una ventana de atributos sugeridos en FlexSim y su significado. Online Content: Abre un navegador interno para ver y descargar contenidos en línea a través de FlexSim incluyendo: módulos, formas en 3D, imágenes y modelos como ejemplos. Support Request: Abre una página de soporte para solicitar apoyo técnico a FlexSim mediante un navegador web. License Activation: Desde esta ventana es posible configurar las diferentes licencias que ofrece FlexSim. About FlexSim...: Abre una pantalla de bienvenida que brinda información acerca de FlexSim tal como: el estado de la licencia, información de la tarjeta de gráficos, la versión de FlexSim en ejecución actual e información de contacto.

Figura 2.11. Ventana del menú Help.

Las palabras y expresiones que se han descrito hasta ahora quizá no le resulten del todo familiares, pero recuerde que son importantes para entender con mayor claridad el software. Siguiendo con este orden de ideas, el apartado subsecuente describe la barra de herramientas de la ventana principal de FlexSim.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

b) Barra de Herramientas Dentro de lo más importante de la barra de herramientas se destacan los usos de los principales íconos, mismos que permiten una mayor flexibilidad a la hora de construir y programar un modelo. Entre otras cosas, aquí comprenderá cómo se pueden conectar, seleccionar y crear objetos (véase figura 2.12).

Figura 2.12. Ventana del menú Barra de Herramienta.

Puntero del mouse Modo Estándar – Es empleado para mover objetos de un lugar a otro, cambiarlos de eje posicional o bien, puede emplearse para ajustar sus dimensiones en los 3 ejes (X, Y, Z).

Comandos conectores de objetos Conector de Objetos – Este ícono se emplea para conectar un objeto con otro o bien un grupo de objetos a la vez si así lo prefiere. La intención es conectar los objetos de acuerdo al flujo del proceso y puede ser tan simple como dar clic con el botón izquierdo del mouse en el ícono y después dar nuevamente un clic con el mismo botón del mouse, al objeto de inicio y uno más al objeto final, con el cual se conectará. Esta función se puede realizar de igual forma, manteniendo presionada la letra “A” del teclado. Conector de Puertos Centrales – La función de este conector es similar a la anterior, la diferencia es que el ícono se emplea para conectar puertos centrales de elementos como recursos (operarios, montacargas, grúas, etc.), los cuales mueven FlowItems (cajas, piezas, etc.) de un lugar a otro. Esta función se puede realizar de igual forma, manteniendo presionada la letra “S” del teclado. Conexión Extendida – El ícono funciona de la misma manera que el conector de objetos, este es empleado para hacer una conexión extendida de distintos objetos según las necesidades del modelo. Estas conexiones también pueden ser llamadas conexiones virtuales, un ejemplo de esto; implicaría conectar un objeto Processor, un Dispatcher y a un grupo de Operadores dentro de una red de nodos (Networknode), también puede utilizarse al hacer uso de un TrafficControl. Esta función se puede realizar de igual forma, manteniendo presionada la letra “D” del teclado.

19

20

SIMULACIÓN CON FLEXSIM

Desconectar Objetos, Desconectar Puertos Centrales y Desconectar Conexiones Extendidas: Funcionan de la misma manera que el Conector de Objetos, Conector de Puertos Centrales y Conexión Extendidas respectivamente, pero en lugar de emplearse para conectar, se utilizan para desconectar, cada una de estas operaciones se puede también realizar manteniendo presionada la letra Q, W y E del teclado según el tipo de desconexión requerida Operaciones conjuntas Nueva Selección – Este ícono permite aplicar la misma operación a un conjunto de objetos, para hacer esto sólo presione el ícono y marque un cuadro con el mouse alrededor de todos los objetos donde se quiera aplicar un cambio similar. Esta acción puede realizarse también si se mantiene pulsada la tecla Shift. Cambiar la Selección – Si lo que deseas es deseleccionar un grupo de objetos, lo puedes hacer presionando este ícono, o bien manteniendo pulsada la tecla Ctrl. Creación de objetos Crear Objetos – Al activar este ícono, usted podrá crear múltiples objetos de la biblioteca (Library) simplemente con dar clic con el botón izquierdo del mouse en las distintas posiciones del plano, las veces que sean necesarias, esta acción se puede realizar también pulsando la tecla F. Crear y Conectar Objetos – Funciona de forma similar a Crear Objetos, pero la diferencia es que este ícono conecta a los objetos mientras estos son creados, esta también se puede ejecutar manteniendo presionada la tecla R.

Caja de herramientas (Toolbox) Al pulsar Tools, se despliega una ventana la cual administra distintas herramientas del modelo, tal como Global Table, Time Table, MTBF MTTR, FlowItem, Dashboards, etc. Dicha caja de herramientas también se puede activar desde el menú View>Toolbox, tal como se explicó con anterioridad (véase figura 2.13).

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

21

Toolbox. Como se observa en la figura 2.13, la gama de comandos es amplia y variada, sin embargo, aquí sólo se describen algunos usos: -

-

-

-

-

-

-

Global Table y Time Table, son submenús los cuales proporcionan y permiten agregar, borrar y editar tablas globales y tablas de horario en el modelo, respectivamente. El submenú MTBF MTTR, proporciona la funcionalidad de agregar, borrar y editar tiempos medios entre fallas (MTBF) y tiempos medios de reparación (MTTR) de acuerdo con los objetos del modelo. Dashboard, permite agregar variables gráficas para analizar estadísticas mientras el modelo es ejecutado. La herramienta Process Flow es útil para ver visualmente la lógica del flujo de proceso de un modelo de simulación. Una de las principales ventajas de utilizar el módulo process flow es que es mucho más fácil depurar y solucionar problemas de código. FlowItem, abre la papelera de edición FlowItem Bin, donde es posible definir la clase de FlowItem que se empleará en el modelo (Box, Cylinder, Sphere, Plane, etc.) y establecer conjuntamente características que la definirán en la ejecución (por ejemplo; ItemType, Labels, Location, Size, Rotation, Color, 3D Shape, Animations, etc.). Task Sequences List, es una de las diversas herramientas del comando Global List, la cual permite al usuario agregar, borrar y editar secuencias de tareas en el modelo. Al desplegar la opción Statistics podrá elegir entre otras la opción Dashboard, esta herramienta es una de las más útiles para observar gráficos y estadísticas mientras el modelo se ejecuta, la alternativa es especialmente usada para comparar distintos estados entre objetos. Para concluir la descripción general de Toolbox, la interface de Excel contenida en el botón Import, crea una interfaz con Microsoft Excel para definir la importación y exportación de diferentes parámetros archivados con la extensión .xls o bien .xlsx.

Figura 2.13. Ventana Toolbox.

22

SIMULACIÓN CON FLEXSIM

c) Panel de Ejecución de la Simulación La mayoría de estos íconos ya fueron explicados en el menú principal Execute, sin embargo es importante mencionar que este panel es usado para controlar la ejecución del modelo de una manera ágil (ver la figura 2.14).

Figura 2.14. Barra del panel de ejecución de la Simulación.

Run Time/Stop Time Run Time. Este módulo muestra el tiempo transcurrido de la simulación, el lector no debe olvidar que las unidades de tiempo corresponden a las seleccionadas en un inicio (segundos, minutos, horas, etc.). Stop Time. Muestra el tiempo en que el modelo se detendrá. Dentro de estas últimas alternativas, si usted elige la leyenda No Stop Time se indica que el modelo se extenderá indefinidamente. Al dar clic en Specify Stop Time se permitirá establecer el tiempo de paro requerido. Asimismo, la alternativa By Date and Time podría ser utilizado para definir la hora, el día, el mes y el año en que se requiere detener la ejecución del modelo. De igual forma, en cualquier objeto diseñado en FlexSim se puede definir el tiempo de paro empleando los comandos OnEntry u OnExit definidos en cualquier “Trigger” (o disparador). Run Speed Run Speed. Es un regulador de velocidad, que define el número de unidades de tiempo del modelo que FlexSim intentará calcular por segundo de tiempo real. El resultado real puede caer por debajo de este valor si el modelo requiere demasiado procesamiento en cada evento.

d) Biblioteca de Objetos de FlexSim Los objetos (Objects) en FlexSim son los distintos tipos de recursos utilizados en la simulación, éstos se emplean para ayudar a describir en un modelo virtual el comportamiento del sistema real y pueden brindar animación en tercera dimensión, la cual facilite su entendimiento. Los objetos representan: cajeros en un banco (Processor), máquinas cortadoras de una fábrica (Separator), bandas transportadoras en una línea de producción (Conveyor), líneas de espera en un supermercado (Queue), montacargas (Transporter) que trasportan cajas de un punto a otro, o almacenes (Rack) en un centro de distribución, etc., también

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

23

pueden ayudarnos a determinar el tiempo ocioso de un servidor durante un día de trabajo, el tiempo de operación de un equipo en un año de producción, cuellos de botella en una banda trasportadora, el tiempo que un cliente espera antes de ser atendido, el número de clientes promedio en una línea de espera durante un turno de trabajo, la tasa de producción de un montacargas, el nivel de inventarios en un Centro de Distribución (CEDIS) y muchas otras variables que al final formaran parte de los estadísticos que nos permitirán tomar decisiones sobre el sistema real. Dentro de la ventana de diálogo Library de FlexSim, se pueden encontrar tanto objetos necesarios para simulación con cambios discretos como continuos, y se clasifican en seis categorías distintas: Fixed Resources (Recursos Fijos), Task Executers (Recursos Móviles o Ejecutores de Tareas), Travel Networks (Redes de Viaje), Conveyors (transportadores), Visual (Visuales) y Fluids (Fluidos), véase la figura 2.15. Además, como ya se mencionó dentro de menú Barra de Herramientas en el comando FlowItem Bin, también existen los objetos definidos como FlowItems.

FlowItem

Figura 2.15. Biblioteca de objetos.

Hechas las consideraciones anteriores, cada uno de estos objetos se describirá mientras se avanza en el libro, a continuación se puntualizan algunos ejemplos:

24

SIMULACIÓN CON FLEXSIM

Fixed Resources Un Fixed Resource o Recurso Fijo es el lugar estático donde los FlowItems nacen y mueren (como en un Source o Sink), son procesados o bien retenidos por un tiempo determinado, aquí es donde la entidad puede sufrir cambios o alteraciones para ser transformada, aquí también se pueden unir, agrupar, separar o cortar, etc. El lugar donde se entregan los boletos para ingresar al cine y la sala donde se proyecta la película podría ser representada por objetos fijos y en el caso de un CEDIS de productos perecederos, las fosas de carga y descarga junto con los racks donde se almacenan estos productos, igualmente pueden ser objetos fijos, algunos ejemplos son:

-

Source y Sink Los objetos Source y Sink, son utilizados para iniciar y dar por terminado el flujo de los FlowItems dentro de un modelo de simulación. Mientras que el Source define la creación, la frecuencia de llegadas o el tiempo interarribo y asigna propiedades tales como color, número de ItemTypes a los FlowItems, el Sink recibe y destruye los FlowItems que finalizaron el recorrido del modelo.

-

Queue Vs Conveyor Tanto un Queue como un Conveyor podrían representar colas o líneas de espera, la diferencia es que uno mantiene a los FlowItems fijos y el otro los transporta de un objeto a otro en forma recta o curva. Las líneas de espera se forman cuando las FlowItems no pueden seguir avanzado, esto debido a distintas razones como por ejemplo, la falta de un servidor disponible que atienda a los FlowItems (clientes en la taquilla del cine), bloqueos de FlowItems por distintas capacidades de los objetos o por un mal balanceo de línea, en una planta productora de lácteos, y en un CEDIS de productos alimenticios quizá los FlowItems (cajas de botanas) esperan a un recurso móvil (montacargas) para que las traslade de las fosas de descarga a los racks ubicados en el interior del almacén. En FlexSim podríamos usar objetos como Queue y Conveyor para representar estas situaciones. En el apartado de Conveyor se explican propiedades adicionales de las bandas transportadoras.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

-

Processor, MultiProcessor, Combiner y Separator El Processor es un lugar de operación donde se obliga a los FlowItems a permanecer un tiempo de espera determinado. Este mismo puede procesar más de un FlowItem a la vez. En ellos se puede definir el flujo de los FlowItem, los Setups (tiempos de preparación), el Process Time (tiempos de operación), los Breakdowns (paros o mantenimientos) y es posible llamar desde aquí a uno o varios operadores para hacer estas funciones. Un MultiProcessor permite definir en un mismo lugar una variedad de operaciones subsecuentes a la vez. Internamente, a cada proceso u operación se le puede definir su nombre, duración y si es necesario hasta la cantidad de Operators (operadores) requeridos para desempeñar estas tareas. El Combiner puede tanto unir (Join) los FlowItems definitivamente como empacarlos (Pack) dentro de algún contenedor o bien, es posible agruparlos en lotes (Batch) con la posibilidad de volverlos a separar en operaciones subsecuentes. De igual manera, el Combiner puede llamar a ciertos operadores durante los tiempos de preparación, proceso o reparación. El Separator es usado para separar o cortar un FlowItem en múltiples partes. Esto puede ser realizado al desempacar (Unpack) un FlowItem anteriormente empacado por un Combiner, o bien al dividir (Split) y crear múltiples copias del FlowItem original. Tanto el proceso de desempaque como el de corte serán efectuados hasta que el tiempo definido del proceso haya sido completado. Este Separator también puede llamar a operadores para realizar una preparación, un proceso o una reparación.

-

Rack En relación con el almacenamiento, un Rack es empleado para almacenar FlowItems. En un Rack se pueden definir tanto el número de bahías y niveles como la longitud, anchura y profundidad de estos mismos, de igual forma se puede establecer el contenido máximo de FlowItem, el tiempo mínimo de permanencia, entre otras aplicaciones.

Task Executers Los Task Executers son dispositivos en los cuales se apoyan los FlowItems, frecuentemente son empleados para trasladar FlowItems de un recurso fijo a otro a través de una red de rutas (NetworkNode) o como apoyo durante un tiempo determinado para dar algún servicio de mantenimiento. En este libro para referirnos a los objetos: Dispatcher, TaskExecuter, Operator, Transporter,

25

26

SIMULACIÓN CON FLEXSIM

Elevator, Robot, Crane, ASRSvehicle y BasicTE, usaremos los términos Task Executers, Ejecutores de Tareas o Recursos Móviles. Los recursos móviles reciben instrucciones o realizan secuencias de tareas asignadas por los objetos fijos. Por ejemplo, si la tarea es mover un FlowItem de algún Processor a un Conveyor, un recurso móvil puede ejecutar la tarea. En un cine, los objetos móviles podrían ser las personas que despachan los boletos o las palomitas de maíz, o el empleado que guía a los clientes hacia la sala donde será proyectada la película. La planta productora de lácteos puede mantener algún recurso ocupado mientras se da mantenimiento a un equipo dosificador de yogurt, las pipas tanque son recursos que transportan leche de las granjas a los silos en una planta, igualmente en un CEDIS los montacargas y las personas que cargan y descargan los productos de algún tráiler o estiban las cajas en los racks son recursos móviles. A continuación se describen algunos ejemplos de objetos móviles. -

Operator, Transporter y Robot Un Operator puede ser llamado para ser utilizado durante la preparación de un recurso fijo, el procesamiento o el tiempo de reparación. Los operadores permanecerán con el objeto que los llamo hasta que sean liberados, una vez liberados, pueden ir a trabajar con un objeto diferente si es necesario. Tanto un Operator como un Transporter pueden trasladar FlowItems entre objetos fijos y pueden ser colocados en una red si requiere seguir una ruta a medida que viajan. El Robot es un transporte especial que levanta FlowItems de un punto de partida y los coloca en una ubicación final. Por lo general, la base del Robot no se mueve, pero tiene 6 articulaciones, las cuales giran para mover los FlowItems de un punto a otro.

Travel Networks y Visual Existen también recursos especiales diseñados para tareas específicas que contribuyen de igual forma al mejor desempeño del modelo. -

NetworkNodes Los NetworkNodes se utilizan para definir una red de caminos que los transportistas y operadores siguen. Las rutas se pueden modificar mediante puntos de Spline (ranura) para añadir curvatura a la trayectoria. De forma predeterminada, los recursos móviles que viajan en una red seguirán el camino más corto entre su origen y destino.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

-

Visual El recurso Text, permite diseñar e ilustrar muros, columnas, planos, etc., como parte del escenario dentro del área de trabajo, además pueden usarse para agregar gráficas dinámicas, mismas que se animan mientras el modelo se está simulando y tienen una gran variedad de usos adicionales como colocación de texto, hora, estadísticas, etc.

Conveyors Tal como se mencionó con antelación, FlexSim también posee un conjunto de objetos para la simulación de sistemas con bandas transportadoras, las cuales por sus características visuales y facilidad de uso son muy útiles dentro de un modelo. Las bandas transportadoras, se pueden crear fácilmente co mo un único objeto o en múltiples partes, su uso principal es la transferencia de artículos entre distintos objetos y los mismos transportadores, aquí se puede establecer la velocidad de avance, el tiempo de demora y las distancias necesarias. También es posible ajustar un ángulo de inclinación en un transportador, de modo que los artículos se acumulen en un lado de la banda transportadora, si es necesario. Así mismo se permite la inclinación, inversión y rotación de los elementos mientras se mueven a lo largo de la banda transportadora. Adicionalmente a los operadores se les permite tomar o dejar FlowItems en distintos puntos de esta, donde al mismo tiempo cuando es retirada una pieza de la banda transportadora, los colectores pueden predecir automáticamente un adecuado punto de colecta basados en la velocidad del artículo, la velocidad del operario y la distancia recorrida. Se permite además, programar el comando “Photo Eyes” para desencadenar ciertos eventos o comportamientos como bloqueos por un tiempo específico. De igual forma, es posible colocar objetos “Decision Points” sobre un transportador para actuar como un sensor en la lógica de control, o un punto de comunicación para otros objetos, como el controlador de mezcla.

Fluid Objects En otro orden de ideas pero de forma semejante, para analizar las operaciones de un sistema híbrido (entidades discretas y material fluido), FlexSim pone a disposición del modelador Fluid Objects con los cuales no solo se podrá conducir material fluido por una línea de producción, sino que incluso será posible mezclar materiales continuos (fluidos) con discretos.

27

28

SIMULACIÓN CON FLEXSIM

Dentro de la biblioteca de objetos de fluidos, hay once objetos que están diseñados para manejar material fluido; el material no necesariamente tiene que ser líquido, puede ser casi cualquier cosa que se mide por peso o volumen (leche, arroz, azúcar, etc.). En contraste, la biblioteca estándar de FlexSim está diseñada para mover el material que se encuentra en cantidades discretas (cajas, piezas, etc.), aquí hay nueve objetos de fluidos que no pueden interactuar con los objetos discretos de FlexSim, pero dos de ellos (ItemToFluid y FluidToItem) están diseñados para funcionar como interfaz entre los objetos de fluidos y los objetos discretos, esto permite al modelador convertir FlowItems en líquido y viceversa. Adicionalmente a estos once objetos está el llamado FluidTicker, responsable de romper el tiempo en pequeñas unidades, estas unidades espaciadas de manera uniforme son denominados "ticks" y el modelador puede definir la longitud de un tick. El FluidTicker es el objeto que controla a todos los objetos de fluidos en un modelo. Por esta razón, en cualquier modelo que utiliza objetos de fluidos, debe existir un FluidTicker.

FlowItem Es el término empleado para referirnos a las entidades o transacciones (como son llamadas en cualquier otro software de simulación). Son objetos o elementos dinámicos que entran, se mantienen o abandonan el sistema, fluyen por el sistema, se mueven alrededor, alteran o son alteradas, cambian de estatus o se transforman, son los responsables de que el estado del sistema cambie y afecte el desempeño del mismo. Por lo general los FlowItems son creados, cada una de sus acciones incurre en un tiempo determinado y dentro de ellas se almacena la información necesaria para que los objetos fijos determinen, por ejemplo, su flujo dentro del sistema y su tiempo de operación correspondiente, además reúnen información estadística conforme se avanza en el tiempo, la cual servirá como apoyo en el análisis de los resultados, estas características se definen como ItemType y Labels en FlexSim. Algunos ejemplos de FlowItems podrían ser: los clientes que entran a un cine donde permanecen viendo alguna película y abandonan el sistema cuando esta termina, los cartones de leche, botes de yogurt, barras de quesos o mantequillas que fluyen por una planta productora de lácteos, y las bolsas de frituras enviadas de las fabricas a un CEDIS que entran, permanecen por un tiempo determinado y salen para su venta a los centros comerciales, entre otros.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

e) Model View Window Este espacio se refiere al Layout o Área de Trabajo, donde se diseña el modelo de simulación. La unidad de espacio predeterminada en la pantalla de diseño de una unidad de la red (grid) es de tamaño 1x1x1, es decir si en un inicio el diseñador seleccionó en la ventana de diálogo Model Units la unidad de medida Meters, entonces cada unidad de la red medirá 1x1x1 metros. Sobre la base de las consideraciones anteriores, el usuario tendrá que decidir la unidad real necesaria que desea representar en su cuadricula. De esta forma los recursos fijos o equipos podrán ser escalados apropiadamente y a los recursos ejecutores de tareas tales como operadores o montacargas se les asignara un valor de velocidad respecto al número de unidades de la red avanzadas por unidades de tiempo. Por tanto, ser coherente con los valores asignados es fundamental para una simulación exitosa.

2.3.2. Conceptos Adicionales ItemType/Labels Un ItemType o identificador numérico es una etiqueta especial que se coloca en el FlowItem y puede representar un número de código de barras, un tipo de producto o número de referencia. FlexSim está configurado para utilizar el ItemType como referencia en el enrutamiento de FlowItems, por lo tanto sólo es asignado una vez. Las Labels o etiquetas son variables personalizadas que se pueden especificar en el objeto. Por ejemplo, si desea realizar un seguimiento del número de FlowItems de ItemType 3 que han entrado en un objeto, se puede utilizar una etiqueta que lleve un registro de este valor, de hecho estas etiquetas son las características que distinguen a un grupo de FlowItems de otros. Al igual que un ItemType, una Label puede ser colocada en un FlowItem al inicio, durante o al final del proceso mediante la utilización de algunos comandos como los contenidos en un Trigger. Una misma Label puede tener diferentes valores para distintos FlowItems (entre estos pueden ser: números, texto o bien tablas con información), esto permite hacer diferencias al manipular la operación de los FlowItems en los objetos y es de suma importancia para indicar la ruta, flujo o destino que tomará la entidad en la lógica de un sistema. En el cine, una Label quizá sea el nombre de la película que les interesa ver a los clientes, el sabor y la presentación de un frasco de yogurt son dos atributos que permiten distinguir al producto a la hora de enviarlos por distintas líneas de acondicionado (empaque, lotificado y almacenado), y en un CEDIS las frituras de papas quizá contengan atributos que caractericen su sabor

29

30

Nota: Un FlowItem puede tener tanto una Label como un ItemType, mientras que a los objetos Fixed Resources y Task Executers sólo se les puede asignar Labels.

SIMULACIÓN CON FLEXSIM

(con chile, con queso o las papas tradicionales únicamente acompañadas con sal) y su cantidad (25, 50, ó 100 gramos). En FlexSim usted puede utilizar los comandos setlabelnum(), getlabelnum(), y label() para interactuar con las etiquetas que se hayan creado.

Port Connections Como ya se mencionó, en un modelo de simulación los FlowItems son operados por recursos fijos y frecuentemente son apoyados por recursos móviles para ser transportados de un lugar a otro, pero ¿cuál es el mecanismo utilizado para lograrlo? Cada objeto en FlexSim tiene un número ilimitado de conexiones a través del cual se comunica con otros objetos, estas son llamadas Port Connections (conexiones de puertos) las cuales pueden establecer las condiciones necesarias entre los objetos para definir un flujo. Hay tres tipos de puertos: Output Port (puerto de salida), Input Port (puerto de entrada) y Center Port Connection (conexiones de puerto central). Para establecer una relación entre un Output Port y un Input Port es necesario conectar el Output Port de un objeto inicial, al Input Port del objeto siguiente según corresponda al flujo que deben seguir las FlowItems en el modelo. Así, cada relación de salida-entrada definirá una trayectoria posible de los FlowItems entre los recursos fijos, dicha trayectoria deberá corresponder al diagrama de flujo del sistema real. Los puertos de entrada y salida se utilizan para establecer la ruta de los FlowItems por los recursos fijos y pueden emplearse también para crear redes de nodos o tránsito (NetworkNodes) necesarias para que los recursos móviles transporten los FlowItems de un recurso fijo a otro. Las Center Port Connection se originan en el centro de los objetos, estas relaciones son empleadas para que un objeto sea capaz de hacer referencia a otro, en FlexSim es común que un Fixed Resources haga uso de un Task Executers mediante una conexión de puerto central, tal como la conexión entre un Processor, Queue o Conveyor con un recurso móvil como: Operator, Transporter o Elevator. Independientemente de la conexión de puerto empleada, ya sea de entrada/salida o centro, siempre se hace referencia a un número con el fin de ser utilizado más adelante. Si se observa la figura 2.16, se puede ver que el objeto Queue tiene tres puertos de salida, representados por los triángulos verdes en el lado derecho del objeto. El puerto de salida número 1, es el de la parte superior y el resto de los puertos están numerados desde este punto. Internamente en todos los objetos existe un campo editable llamado Send To Port (enviar a puerto), el cual controla el flujo de los FlowItem para ese objeto a través de esta numeración interna. Los detalles sobre el tema, se abordaran en los ejemplos ilustrativos descritos en los siguientes capítulos.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

31

También es importante recordar que para cualquier esquema de enrutamiento posible en su modelo, debe tener una relación de entrada y salida entre los objetos involucrados, pues sin esta conexión no será posible vincular y animar al objeto con el resto de los recursos involucrados en el modelo.

Figura 2.16. Imagen ilustrativa de Port Connections.

Los puertos pueden ser creados y conectados de dos formas: La primera de estas es mediante el uso de los comandos descritos anteriormente en la barra de herramientas, y la segunda forma de hacer conexión es manteniendo presionada la letra del teclado “A, S o D” (Conector de Objetos, Conector de Puertos Centrales o Conexión Extendida respectivamente, esta última no se describe en su totalidad en este documento) según sea el caso y haciendo clic con el botón izquierdo del mouse sobre el primer objeto que se desea conectar, sin dejar de presionar la letra del teclado seleccionada, se arrastra el mouse y se da un clic sobre el segundo objeto determinado. Al hacer esto, se crea automáticamente un puerto de salida y uno de entrada, un puerto central en ambos objetos o una conexión extendida según corresponda a la letra presionada. Para desconectar un par de objetos dependerá de cómo fueron conectados: si se conectó con la letra “A” desconectamos con la “Q”, la conexión de la letra “S” se rompe con la letra “W” y la conexión “D” con la “E”, la desconexión de objetos obedece al patrón anterior por lo que esta acción deberá ser en el mismo orden con el que fueron conectados, ver figura 2.17.

32

SIMULACIÓN CON FLEXSIM

Figura 2.17. Imagen ilustrativa de conexiones con el uso del teclado.

Interacción del teclado Resulta oportuno decir que estas no son las únicas teclas habilitadas en el teclado como apoyo en la construcción de un modelo de simulación en FlexSim. Existen algunas más y estos son sus usos (figura 2.18):

Figura 2.18. Imagen ilustrativa de la Interacción del teclado.

Descripción de teclas 

Si usted es zurdo, puede utilizar las letras J, K, U e I en sustitución de las letras A, S, Q, W respectivamente, pues al emplearlas se obtienen los mismos resultados.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.













X: Borra la visualización de conexiones, nodos y flechas de una red. Esta es empleada básicamente para ocultar en forma sucesiva las conexiones, nodos y las flechas construidas con NetworkNode. También crea nuevos puntos de Spline en una red de rutas. Para ver su funcionalidad, mantenga presionada la letra X del teclado y haga clic sobre uno de los nodos de la red con el botón izquierdo del mouse. B: Visualización de conexiones, nodos y flechas de una red. Su funcionalidad es totalmente opuesta a la X. Así pues, las conexiones, nodos y flechas diseñadas por NetworkNode y ocultadas por la activación de la letra X pueden ser vistas nuevamente al mantener presionada la letra B y dando clic con el botón izquierdo del mouse sobre el nodo que no fue oculto. En el objeto TrafficControl también puede ser utilizada esta tecla. V: Visualización de Output Port /Input Port, se utiliza para ver los nombres de los puertos de entrada y salida de un objeto. Para observar su funcionamiento, mantenga presionada la tecla V y haga clic en un objeto con el botón izquierdo del mouse. C: Visualización de las conexiones de Puerto Central, se emplea para ver las conexiones de Puerto Central de un objeto. Presiónela y haga clic en un objeto con este tipo de conexión y podrá notar los resultados. F y R: Estas dos letras se usan para crear objetos y conectarlos a la vez, dichas funciones fueron explicadas anteriormente en la barra de herramientas. G: Propiedades de conmutación rápida, su activación permite cambiar el enfoque de la ventana de propiedades de un objeto dentro del modelo. La vista ortográfica recuerda la última ventana de propiedades que se abrió. Después de activar la vista ortográfica, mantenga presionada la tecla G y haga clic en un objeto, la última ventana de propiedades abierta actualizará su enfoque para el nuevo objeto.

33

Nota: para trabajar correctamente con el uso de las teclas, usted deberá permanecer en la vista ortográfica, de lo contrario, las pulsaciones de tecla no funcionarán hasta la segunda vez que se pongan a prueba. Esta acción se puede hacer si se pulsa el botón derecho del mouse sobre el área de trabajo y se desmarca la casilla Perspective Projection contenida en la ventana derecha de nombre Quick

Properties. Si después de esta acción desea regresar a la vista en perspectiva, es necesario activar nuevamente el comando Perspective Projection. Para más detalles, revise el siguiente apartado.

34

SIMULACIÓN CON FLEXSIM

Fundamentos de la Navegación en FlexSim Vistas del modelo FlexSim utiliza un entorno de modelado tridimensional y por defecto la vista más usada para la construcción de un modelo es la Orthographic View (vista ortográfica), está a pesar de ser en 3D se ve un tanto plana. En contraste, la Perspective View (vista en perspectiva) es totalmente en 3D y da una sensación más real pues a partir de un punto de fuga muestra el horizonte a lo lejos, esta vista esta predefinida al momento de iniciar la construcción de un nuevo modelo de simulación. En general, es más fácil diseñar modelos desde una vista ortográfica, sin embargo la vista en perspectiva es empleada con mayor frecuencia para fines de presentación. No obstante, se puede utilizar cualquiera de las dos opciones para crear o ejecutar un modelo (véase figura 2.19).

Figura 2.19. Imagen ilustrativa de las distintas vistas en FlexSim.

Adicional a estas vistas existe una más: la vista Data Tree View (visualización de estructura de datos), la cual permite navegar a través de una estructura de árbol FlexSim para ver o configurar los atributos de los objetos, escribir códigos y hacer muchas otras operaciones.

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

Toda la información del modelo está contenida dentro del árbol FlexSim jerarquizada en nodos individuales, incluyendo los objetos de la biblioteca, comandos, etc. En FlexSim se pueden abrir tantas ventanas de vista como se desee, pero se debe recordar que a medida que se abren más ventanas, la demanda de recursos informáticos aumenta y entonces todo dependerá de la capacidad del hardware que tenga su equipo.

Navegación y manipulación de objetos La navegación dentro del área de trabajo o Layout, se puede hacer a través del mouse. Si se desea un desplazamiento horizontal basta con hacer clic y mantener el botón izquierdo del mouse presionado mientras se arrastra por el área de trabajo. Para girar la vista del área de trabajo se deberá hacer clic izquierdo, y mantener presionado el botón derecho del mouse sobre el área, arrastre el mouse en distintas direcciones. Para poder hacer un enfoque (zoom), es necesario mantener pulsados ambos botones del mouse y mover el mouse hacia arriba y hacia abajo, el mismo resultado se obtiene al mover el scroll del mouse hacia arriba o hacia abajo. Ahora bien, si se encuentra trabajando dentro de la vista en perspectiva, la tecla F8 podría darle una navegación guiada. Pero antes de presionar esta tecla es necesario cerciorarse que el puntero del mouse este en el centro del modelo, de lo contrario usted corre el riesgo de perder momentáneamente su diseño dentro del área de trabajo. A continuación usted puede pulsar la tecla F8, mueva el mouse en todas direcciones para explorar su uso, si desea dar por terminada la navegación guiada presione nuevamente F8. Si por alguna razón perdió su modelo dentro del área de trabajo y por más que busca no lo encuentra, olvide esa pantalla y diríjase a la barra de herramientas, ahí encontrará el ícono (3D Model View), presiónelo y se abrirá una nueva ventana al punto de origen donde podrá ver nuevamente su modelo. En la ventana de diálogo localizada dentro de menú View>View Settings, puede alterar el diseño y los colores del área de trabajo en infinidad de formas. Hechas las observaciones anteriores, podemos describir ahora como cambiar la posición de los objetos dentro del área de trabajo. Para mover un objeto en el plano X / Y, es necesario presionar y mantener presionado sobre el objeto el botón izquierdo del mouse mientras este mismo se arrastra hasta la ubicación deseada. Para mover el objeto en el eje Z, haga clic en él y desplace el scroll del mouse hacia arriba o hacia abajo. También puede mantener pulsados ambos botones del mouse sobre el objeto y arrastrarlo hacia arriba y hacia abajo.

35

36

SIMULACIÓN CON FLEXSIM

Tamaño y rotación. Para poder modificar el tamaño y la rotación de los objetos, es necesario hacer clic sobre este mismo con el botón izquierdo del mouse, de inmediato usted observará tres flechas de color a lo largo de cada eje del objeto. Si lo que desea es cambiar el tamaño del objeto, haga clic izquierdo sobre el eje que desea cambiar y arrastre el mouse. Para editar la rotación del objeto, dé clic derecho sobre el eje que necesite rotar y mueva el mouse en la di rección buscada (la figura 2.20 ilustra tales acciones.). Si los tres ejes de colores no se muestran, vaya al menú Edit > Resize and Rotate Objects.

Figura 2.20. Imagen ilustrativa de la navegación de objetos dentro de FlexSim.

Selección de objetos múltiples Cuando damos clic izquierdo en un objeto podemos observar un cuadro amarillo alrededor de este mismo, esto indica que el objeto está resaltado, sólo se puede resaltar un objeto a la vez. Un objeto seleccionado se enmarca con un cuadro rojo, para seleccionar un objeto es necesario hacer uso de Shift+Clic sobre este mismo, o bien Ctrl+Clic para hacer una selección de objetos múltiple. Esta última acción permite al diseñador hacer modificaciones grupales en los objetos seleccionados, por ejemplo, copiar los atributos del objeto resaltado con el cuadro amarillo a los objetos seleccionados con el cuadro rojo, esta edición grupal la puede hacer a través de la ventana Edit Selected Objects la cual se puede abrir desde el menú principal View>Edit Selected Objects. Para concluir y quitar la

Capítulo 2. Aprendizaje y Aplicaciones del Software FlexSim.

37

selección de los objetos, hay que dar Shift+Clic sobre el área de trabajo (véase la figura 2.21).

Figura 2.21. Imagen ilustrativa de resaltado y selección de objetos múltiples en FlexSim.

Modelos Antes de concluir este apartado, resulta oportuno describir de manera general cómo se visualiza un modelo en el ambiente FlexSim. Como se describió en el capítulo 1 de este libro, un modelo en FlexSim es sólo un conjunt o de aproximaciones y suposiciones estructurales y cuantitativas, acerca de la forma en que funciona o funcionaría un sistema real en intención de responder preguntas para dar respuesta a situaciones planteadas. Por ejemplo, un modelo: puede ser un sistema de colas, procesos y transporte; como es sabido, las colas se desarrollan naturalmente en un modelo en que la velocidad de llegada es superior a la velocidad de atención, el procesamiento es simplemente un retraso de tiempo forzado sobre el objeto que se está procesando y el transporte es el traslado físico de una entidad realizado por un recurso móvil. En el modelo de la figura 2.22, se presenta una línea de producción donde a partir del Source (fuente) fluyen FlowItems (cajas) los cuales se mueven por un Conveyor (banda transportadora) hasta pasar por un Processor y salir con el apoyo de recursos móviles del sistema.

38

SIMULACIÓN CON FLEXSIM

Figura 2.22. Modelado de una célula de manufactura.

Dado que el flujo de las cajas es mayor a la velocidad con la que el Processor opera, se crea una cola de espera, la cual aumenta conforme se avanza en el tiempo y es entonces donde nace la incertidumbre a preguntas como: ¿Cuánto tiempo esperan las cajas en el Conveyor antes de que entren al Processor?, ¿Cuál es el tamaño máximo de la cola?, ¿Será necesario otro Processor para satisfacer la velocidad a la que llegan las cajas?, ¿Cuál es el tiempo de operación del Processor? Como puede notar, la res puesta a estas preguntas contribuye en el mejor desempeño del sistema real, por lo que, en los ejemplos modelados y descritos en los siguientes capítulos, usted tendrá la oportunidad de reafirmar este conocimiento y comprobar la funcionalidad de cada uno de estos elementos.

Recomendaciones Antes de iniciar con el modelado en FlexSim, se sugiere al lector comprender cada tema en su totalidad, ya que todo es consecutivo, es decir lo que se aprenda en un apartado será la base para el siguiente. Al mismo tiempo, recuerde que para poder construir un modelo exitoso, no solo es necesario comprender completamente el sistema real de estudio, sus supuestos y su operatividad, sino que también es indispensable una buena dosis de creatividad y del conocimiento vasto del software utilizado.

3

CAPÍTULO 3.

Construcción de un Modelo Básico

ESQUEMA DEL CAPÍTULO 3.1 3.2

INTRODUCIR LOS OBJETOS DE FLEXSIM CONEXIÓN DE PUERTOS PARA DEFINIR EL FLUJO DE LOS FLOWITEMS 3.3 EDITAR LAS PROPIEDADES DE LOS OBJETOS 3.4 CORRER EL MODELO 3.5 NAVEGACIÓN Y VISTAS ANIMADAS 3.6 REPORTE Y ESTADÍSTICAS DE LOS OBJETOS 3.7 PROBLEMAS COMPLEMENTARIOS OBJETIVOS DE APRENDIZAJE Establecidas las condiciones anteriores, es momento de dar inicio con el uso de FlexSim. Esté apartado contiene las instrucciones básicas y las recomendaciones necesarias para construir un modelo simple de simulación de eventos discretos. En general, se establecen y especifican los medios para añadir lógica a un modelo, el cual representará el comportamiento de un sistema real, lo que usted aprenderá es: 1. 2. 3. 4. 5.

Cómo construir un modelo sencillo. Cómo conectar los puertos para que fluyan los FlowItems por los objetos. Cómo agregar e introducir datos a los objetos. Cómo navegar en las distintas vistas de animación. Cómo ver las estadísticas simples en cada objeto en FlexSim.

NOTAS: Para terminar y entender con claridad la construcción de cada modelo, el diseñador deberá disponer de por lo menos 60 minutos. ¡Mucho éxito!

40

SIMULACIÓN CON FLEXSIM

3.1. INTRODUCIR LOS OBJETOS DE FLEXSIM En este primer modelo se trabajará con los objetos: Source, Queue, Processor, Conveyor y Sink. Ejemplo 1. Una planta productora de lácteos elabora en una de sus líneas de producción yogurt para beber. Al final de la línea el producto es envasado en frascos de 250 ml., mediante una banda trasportadora el producto es movido hasta una máquina etiquetadora para colocarle al frasco la descripción del producto contenido; finalmente se da por entendido que los frascos abandonan al sistema con destino hacia algún almacén. Descripción: 

   

La línea de producción cuenta con una máquina dosificadora la cual funciona en automático, en esta máquina los frascos de yogurt son envasados en presentaciones de 250 ml. a una velocidad distribuida uniformemente entre un valor mínimo de 2 y un máximo de 3 fcos/s. Se asume que dentro del Queue o almacén de producto en proceso, se puede tener cualquier cantidad de frascos esperando a ser procesados. La velocidad del Conveyor ubicado en el sistema, es de 0.2 m/s. y su contenido máximo es de 5 fcos. por serie. El tiempo que la máquina etiquetadora invierte en pegar la etiqueta al frasco, corresponde a una distribución lognormal2 (4, 0.3, 0.1, 0) segundos. La empresa labora sólo un turno de 8 horas diarias, simule el proceso por 30 días.

FlexSim permite la personalización de cada uno de los objetos que integran un modelo de simulación, por el momento se considera un nivel de detalle innecesario. Este primer modelo se construye de manera abstracta por lo que utilizaremos los objetos ya predefinidos dentro de la biblioteca de objetos de FlexSim. La máquina dosificadora es simbolizada por un Source, los frascos serán representados por FlowItems los cuales tienen forma de cajas, el almacén de producto en proceso es representado por un Queue, la banda trasportadora por un Conveyor, la máquina etiquetadora por un Processor y la salida del sistema por un Sink. Hecha la observación anterior, se inicia la construcción del modelo de simulación en FlexSim, bajo el supuesto de que las unidades de medida seleccionadas son segundos y metros.

Capítulo 3. Construcción de un Modelo Básico.

41

Creación del modelo Dentro de FlexSim, ubique la biblioteca de objetos, haga clic sobre cada uno de ellos y arrástrelos uno a uno hacia la ventana de visualización 3D o área de trabajo. Una vez que tenga todos los objetos dentro del área de trabajo, ordénelos de acuerdo al flujo antes descrito, recuerde que el flujo será de izquierda a derecha o bien del puerto de salida al puerto de entrada como se mencionó anteriormente, ver figura 3.1.

Figura 3.1. Colocación de Fixed Resources dentro de 3D View - Model tomados de la biblioteca para construir nuestro primer modelo.

3.2. CONEXIÓN DE PUERTOS PARA DEFINIR EL FLUJO DE LOS FLOWITEMS Una vez terminado el diseño, es necesario hacer la conexión de los objetos de acuerdo con sus respectivos puertos. En la barra de herramientas, hay un botón que permite seleccionar el tipo de conexión de puerto necesario, observe la figura 3.2. La letra en el menú desplegable muestra los distintos modos para hacer conexiones. Seleccione la letra “A” definida como Connect Objects (A) desde este menú y haga clic izquierdo en el objeto donde se quiere iniciar la conexión de puertos. Después de haber realizado lo anterior, usted notará una línea de color amarillo dibujada desde el objeto seleccionado hasta el puntero del mouse. Con esta línea amarilla en el puntero del mouse, aproxímese lo más que pueda al objeto que desea conectar, al hacer esto se puede observar que esté es resaltado con un cuadro amarillo. En este momento pulse nuevamente el botón izquierdo del mouse sobre cualquier parte del objeto y se conseguirá una conexión. Si la conexión de los puertos Output Port e Input Port se estableció correctamente debería verse ahora una línea de color negro con extremos en forma de triángulo de color rojo, los cuales conectan a los dos objetos seleccionados. Dependiendo de la configuración, el triángulo rojo puede ser ocultado, pero ahora se muestra de forma predeterminada, de manera sucesiva

42

SIMULACIÓN CON FLEXSIM

conecte al resto de los objetos que se encuentran dentro del área de trabajo. Recuerde que la conexión es de izquierda a derecha y aunque no siempre es necesario, para este modelo deberá iniciar la conexión de acuerdo con la dirección del flujo. Iniciemos con el objeto Source y conectemos sucesivamente hasta llegar al Sink. Una vez que las conexiones están hechas, pulse la tecla Esc para volver a la funcionalidad estándar del mouse o presione el botón Standard Mode (Esc) ubicado a la izquierda de Connect Objects.

Figura 3.2. Conexión y visualización de los distintos puertos conectores.

Si por alguna razón se equivocó e hizo la conexión de dos objetos que no tienen ninguna relación entre sí, existe una manea de romper la conexión; busque en la barra de herramientas el botón denominado Disconnect Objects y seleccione la letra “Q”. Con la misma acción y siguiendo la dirección con la que se conectó, puede desconectar. La dirección de arrastre del mouse al momento de conectar es muy importante. El punto donde se inicia la conexión se establece como el objeto emisor y el punto final que fue hasta donde se arrastró el mouse para alcanzar y conectar con otro recurso, se establece como el objeto receptor dentro de la relación de conexión de puertos. Como ya se ha mencionado en el tema Port Connections, existen algunas otras alternativas para hacer diferentes conexiones y con distintos comandos, véase la parte inferior de la figura 3.2.

Capítulo 3. Construcción de un Modelo Básico.

43

Aspecto y visualización de las conexiones El aspecto de las conexiones de los puertos puede cambiarse desde la ventana denominada View Settings. A esta configuración, se puede acceder haciendo clic izquierdo en el menú View>View Settings o bien puede elegir More View Settings… de la parte inferior correspondiente a la ventana Quick Properties. Desde aquí se puede cambiar la visualización de los puertos de conexión y desconexión, cambiar el tamaño del conector y se pueden encontrar muchas otras opciones avanzadas para la vista del modelo actual. La imagen a la derecha (figura 3.3) muestra las configuraciones disponibles.

3.3. EDITAR LAS PROPIEDADES DE LOS OBJETOS 3.3.1. Configuración Deseada Con los objetos en su lugar y sus puertos conectados, es necesario editar los mismos para obtener la configuración deseada. El concepto Properties (propiedades), se refiere a un conjunto de atributos editables. Las propiedades de un objeto corresponden con su función y el comportamiento del mismo: cuánto tiempo los FlowItems permanecerán dentro del objeto y a dónde irán cuando sean liberados, así como la manera en que lucen (forma, dimensiones, color, etc.). Todos los objetos en FlexSim tienen atributos y parámetros, estos varían dependiendo del tipo de objeto, pueden ser editados y modificados. Al dar doble clic con el botón izquierdo del mouse sobre el objeto de interés o al hacer clic derecho al objeto y seleccionar la opción "Properties" del menú emergente, se despliega una ventana de propiedades misma que a pesar de ser diferente para cada objeto, tiene muchas similitudes con las ventanas de propiedades de otros objetos (las propiedades también se visualizan dentro del panel Quick Properties al dar un simple clic en el objeto). Esta ventana, define entre muchas otras cosas que operaciones hace el objeto, como es su comportamiento, cuáles son sus dimensiones e incluso es posible animar su operación. En la ventana el usuario también podrá hacer uso de controles como casillas de selección variada y edición de atributos constituidos por campos de texto sencillos de modificar. Algunos atributos son representados por una lista desplegable a la que FlexSim se refiere como Pick List Options (lista de elección de opciones), es una lista desplegable de alternativas comunes asociadas con este parámetro. La figura 3.4, ilustra la ventana de propiedades de un Processor.

Figura 3.3. Vista de configuraciones.

44

SIMULACIÓN CON FLEXSIM

Figura 3.4. Imagen ilustrativa de la ventana de propiedades de un objeto en FlexSim.

Imagen del objeto. Esta corresponde al tipo de objeto que se está editando. Nombre del objeto. Este espacio está dedicado para que el modelador coloque el nombre que desee asignarle a su objeto y así lo pueda reconocer en diferentes operaciones del modelo. Es importante mencionar, que no deberán usarse los caracteres como: >, Reports and Statistics se puede tener acceso a una tabla de informe resumido, a una tabla de informe del estado en el que se encuentra su modelo, a una tabla de documentación del modelo, o bien a una tabla de opciones. Por ejemplo, la pestaña de Summary Report (informe resumido) muestra un informe tabular, ya sea para todos los objetos de un modelo o un conjunto de objetos seleccionados. Los atributos definidos dentro de un objeto pueden ser: contenido máximo y mínimo, número de entradas y salidas, tiempo de ocio y tiempo de proceso, tiempo que el equipo estuvo en espera de FlowItem o de algún operario, tiempos de preparación y muchos otros atributos. Usted puede seleccionar de la lista las variables, aquellas que

Capítulo 3. Construcción de un Modelo Básico.

51

desee incluir en el informe. Tanto el Summary Report como el State Report se exporta a un archivo de texto con extensión CSV (Comma Separated Values). Y después de elegir con un clic la opción Generate Report (Generar Reporte), es posible leer los datos mediante Microsoft Excel. Vea la figura 3.8.

Figura 3.8. Ventana de Informe y Estadísticos.

3. Por su parte, un Dashboard (tablero de instrumentos) expresa la manera más poderosa para recopilar estadísticas en FlexSim. Este tablero de instrumentos le permite generar una base de datos del historial informativo de cada objeto y FlowItem a través de la creación de gráficas dinámicas y variables que se animan mientras el modelo se está ejecutando, la alternativa es especialmente usada para comparar distintos estados entre objetos tal como: contenidos, tiempos, rendimiento, análisis de finanzas, etc. Así pues, para que usted pueda manipular y analizar el historial completo de los datos colectados durante toda la ejecución del modelo, deberá utilizar un Dashboard. El tablero es activado, dando clic sobre el ícono Dashboards de la Barra de Herramientas y presionando el botón Add a Dashboard o bien desde Toolbox (Menú View>Toolbox>Add>Statistics>Dashboard). Después de realizar lo anterior, se creará un tablero a la derecha del Layout con el mismo nombre y a la izquierda podrá observarse que la Library Icons cambia para mostrar una lista de todos los Widgets (reproductores) que se pueden agregar al tablero de instrumentos. Cuando se crea un tablero de instrumentos, es importante personalizarlo para diferenciarlo de algún otro, en la casilla Dashboard Name puede hacerlo. En este mismo instante, el usuario podrá observar que se encuentra activa la casilla Edit Mode, la cual permite mover y redimensionar los Widgets contenidos dentro del Dashboard. Si se desactiva el modo de edición se bloquearán todos los Widgets.

52

SIMULACIÓN CON FLEXSIM

Crear y editar Widgets en el modelo Para agregar un nuevo Widget de la biblioteca al tablero de instrumentos de nuestro modelo, arrastre el Widget de nombre “Average Content” a la ventana del tablero o haga un clic izquierdo en el Widget que desee incluir y posteriormente dé clic izquierdo otra vez en el tablero de instrumentos. Al concluir podrá salir del modo de creación, haga clic o presione la tecla Esc. El nuevo Widget incluído se puede personalizar al seleccionarlo, cambiando sus magnitudes y su ubicación o bien en la ventana emergente Stat Chart Properties será posible editar sus propiedades, además podría copiarlo al pulsar CTRL + C y presionando CTRL + V para pegarlos en el mismo tablero de instrumentos, en otro cuadro de instrumentos del mismo modelo, o en otras instancias de FlexSim. Posteriormente, vaya a la ventana emergente Stat Chart Properties y elija la opción para agregar objetos de la lista (símbolo “+” de color verde), marque Select Objects y seleccione a los objetos Conveyor y Queue, finalmente dé Apply>OK. Al instante, si su modelo se está ejecutando será posible observar el contenido promedio de los dos objetos introducidos dentro del Widget de nombre “Average Content”. Así de simple opera el tablero de instr umentos (véase la figura 3.9).

Figura 3.9. Creación y edición de Widgets dentro de un tablero de instrumentos “Dashboard”.

Es posible agregar tantos Widgets como lo desee, y cada gráfico o tabla de datos pueden ser personalizados para mostrar información adicional mediante la ventana Stat Chart Properties (pestañas; Statistics, Utilization Analysis, Item Trace, Colors y General, según corresponda con el tipo de Widget), tenga presente que no todas las estadísticas tienen sentido para todos los objetos. Si un objeto seleccionado no tiene la estadística especificada, el gráfico no mostrará los datos de ese objeto. Se

Capítulo 3. Construcción de un Modelo Básico.

sugiere al lector revise y explore cada pestaña a detalle.

Finalmente es importante comentar que los Widgets contenidos dentro de un Dashboard se pueden exportar en los formatos: CSV, HTML o PNG:  



Los archivos guardados con la extensión CSV sólo registran los datos del tablero de instrumentos. Cuando guarda con formato HTML, se permite al usuario cambiar el tamaño y la organización de todos los Widgets contenidos en el tablero, estos archivos son completamente independientes y se pueden abrir en cualquier computadora con un navegador web (aunque algunos navegadores web pueden no ser compatibles), después de cambiar el tamaño y la organización de los Widgets en la vista HTML, el archivo puede ser salvado de nuevo para conservar el diseño. Para almacenar imágenes con mayor resolución, el formato PNG da una profundidad de contraste gráfica basada en un algoritmo de comprensión sin pérdida de bitmaps.

De manera individual cada Widget puede ser exportado a estos formatos, si hace clic derecho en el Widget que desea guardar. En relación con este último, los Widgets pueden expresarse de muchas formas, aquí se mencionan algunos ejemplos: 



 

Un Text Panel. Es una tabla de datos textuales, este panel puede ser usado para mostrar el estado de las variables, las estadísticas y los datos actuales de uno o varios objetos. Bar Chart Vs Pie Chart. Una gráfica de barras permite emplearse para ilustrar contenidos promedio, estado de los objetos, entradas y salidas de FlowItems por unidad de tiempo y muchos otros temas adicionales, mientras que una gráfica de pastel muestra únicamente el estado del objeto durante su ejecución. Linear Graph. La ficha correspondiente a la gráfica lineal, busca ilustrar las variables de interés del usuario a través de gráficas de tiempo. Gantt Chart. Hay dos tipos de gráficas de Gantt: La State Gantt Chartes, usual para crear gráficas de Gantt de la información específica de los objetos en función del tiempo, mientras que la ficha Item Trace Gantt Chart, ayuda al modelador a construir gráficas de Gantt con información correspondiente a los cambios que sufrieron los FlowItem a través del tiempo. Por ejemplo, es posible observar; el tiempo en que un Item es creado, a través de qué objetos el Item viajó y en qué momento. La herramienta hace un registro del seguimiento de los Items aun cuando el Item está en un objeto durante un tiempo 0.

53

54

SIMULACIÓN CON FLEXSIM





Custom Chart. El gráfico personalizado le permite representar gráficamente cualquier tipo de datos numéricos, ya sea en una tabla de valores, gráfico de barras o gráfico de líneas. Aquí es posible agregar además de objetos, nodos, variables globales, etc. Financial Analysis. Esta ficha es una de las más importantes, debido a que transforma la información numérica de los objetos en información monetaria.

Después de que usted ha revisado, interactuado y graficado la información estadística, con las tres herramientas antes descritas (Estadísticas Rápidas, Reports and Statistics y Dashboard), seguramente encontró aspectos de mucho interés. Si lo desea, compare los resultados con un modelo teórico (modelo matemático) y podrá darse cuenta que los valores son muy similares. Recuerde que este modelo depende de números aleatorios, los cuales fueron empleados por FlexSim durante la ejecución, por lo que los resultados podrían varían un poco. Más información, está disponible en el menú Help>Users Manual>Contents>Charting and Reporting.

Con el fin de dar por concluído el primer ejemplo, recuerde que para hacer inferencias validas, los modelos de simulación se estabilizan al hacer ejecuciones con periodos de tiempo largos. De igual forma, tenga presente la importancia de ejecutar el número necesario de réplicas, pues las ejecuciones múltiples contribuyen también a mejorar la validez de la inferencia. Así, un mayor número de réplicas implica un número más elevado de muestras aleatorias independientes con distribuciones estadísticas diversas. Estas configuraciones pueden ser definidas dentro del menú Statistics>Experimenter…>Experiment Run.

Capítulo 3. Construcción de un Modelo Básico.

3.7. PROBLEMAS COMPLEMENTARIOS La aplicación de la simulación no tiene mucho sentido cuando se crean simplemente modelos sin un objetivo en mente. La creencia de que si usted construye un modelo de simulación y algo bueno va a suceder no siempre se cumple en la práctica. Así que es recomendable que revise nuevamente el capítulo 1 de este libro, pues ahí se establecen los pasos a seguir y el nivel de detalle necesario para diseñar un modelo de simulación. Recuerde que las lecciones aprendidas al resolver problemas reales mediante la simulación son más propensas a ser recordadas. Los ejercicios en este capítulo solo proporcionan ideas de posibles situaciones a las cuales se enfrentará al modelar un sistema real, así que trate de resolverlo y analizarlo de la mejor manera posible.

Problema 1. La empresa productora de lácteos del modelo anterior, desea disminuir el nivel de inventarios del almacén de producto en proceso. Propósito: 1. Aprender cómo duplicar objetos. 2. Analizar los efectos de añadir una segunda línea de etiquetado. Descripción:  

Crear una segunda línea de etiquetado (una banda trasportadora y un procesador adicional). Balancear la carga de trabajo para ambas líneas de etiquetado, ¿cómo cree usted que se verá afectado el tiempo de espera de los frascos de yogurt?

Ahora que ha construido con éxito su primer modelo en FlexSim, puede resolver este ejercicio sin problema. Si tiene abierto el modelo del Ejemplo 1, sólo vuelva a guardar este modelo pero con el nombre de Problema 1. Paso 1. Para agregar el segundo Conveyor y la segunda máquina etiquetadora (Processor2) al nuevo modelo, en lugar de arrastrar los objetos al área de trabajo, se puede hacer una copia de los ya existentes simplemente haciendo copiar/pegar en el objeto. Por ejemplo, haga clic izquierdo en el Processor ya existente y ejecute la combinación de teclas CTRL + C para copiar, y CTRL + V para pegar el duplicado. Cuando los objetos son duplicados de esta manera, se hace una copia perfecta del Processor con todos sus atributos intactos. Esto puede ahorrarle mucho tiempo en la construcción de los modelos al crear objetos con los mismos comportamientos o

55

56

SIMULACIÓN CON FLEXSIM

similitudes. Tenga en cuenta que al duplicar un objeto existente, se crea una instancia nueva del objeto, por lo que los cambios realizados en la copia o el original son completamente independientes. Paso 2. A partir del Queue ya existente, proceda a conectar el nuevo Conveyor y sucesivamente líguelo a la nueva máquina etiquetadora. Posteriormente enlace al nuevo Processor2 con el mismo Sink, con esto podrá observar el flujo de los frascos de yogurt por las dos líneas de etiquetado. No olvide que FlexSim reconocerá los cambios que usted ha hecho en el modelo, hasta que presione Reset y después Run. Bien, espero haya tenido éxito porque aún debe responder las siguientes preguntas: 1. ¿Cuál es el número máximo y el promedio de frascos de yogurt que esperan en el Queue? 2. ¿Cuánto tiempo en promedio espero un frasco en el Queue antes de entrar a la banda transportadora? 3. ¿Cuál es el porcentaje de utilización de las máquinas etiquetadoras? 4. ¿Cuántos frascos en total fueron etiquetados? 5. Compare la producción de frascos del Ejemplo 1 con el Problema 1 y explique ¿Por qué si se agregó una máquina etiquetadora más al modelo, la producción de frascos etiquetados no incremento al doble? 6. Por último, en un modelo nuevo proponga un mejor escenario que mejore la producción de frascos de yogurt. Problema 2. Crazybus Pachuca Antecedentes Crazybus Pachuca, es una nueva línea de metrobus que desea instalarse en la ciudad de Pachuca, Hidalgo. Esta nueva línea pretende proporcionar un servicio de transporte del Tecnológico a la Central de Autobuses, con su flota de metrobuses regionales. La empresa considera que este es el medio adecuado para que los alumnos del Tecnológico viajen rápidamente a la Central de Autobuses. Su compromiso es hacer tantos viajes como sean necesarios, siempre y cuando existan alumnos que deseen viajar. Ellos esperan que el número de alumnos que viajarán aumente, pues los autobuses que actualmente usan los futuros ingenieros serán dados de baja el siguiente año. El propietario desea que las operaciones en la venta de boletos sea lo más rápido posible en horas pico, por lo que decide colocar un mostrador con tres agentes de venta: uno para pasajeros con tarjeta de pago electrónica, otro para los que poseen tickets de prepago mensual y el tercero para las personas que compran un boleto en ese momento. Usted como el único ingeniero en la nueva línea de metrobuses, considera que el nivel de servicio será inadecuado y que los agentes estarán de ociosos

57

Capítulo 3. Construcción de un Modelo Básico.

mucho tiempo. Pero, como no desea explicarle esto al propietario de la firma sin ningún sustento, a través de un modelo de simulación decide crear un escenario de lo que podría ocurrir. Planteamiento del problema Usted cree que las operaciones en las ventas serán ineficientes y decide usar la simulación como herramienta para ilustrar el comportamiento del sistema al dueño de la firma. Información referente La estimación de la frecuencia con la que llegan los alumnos al mostrador donde se autoriza la entrada a la estación del metrobus, sigue una distribución exponencial, mientras que el tiempo en que cada uno de los agentes atiende a un pasajero se distribuye normalmente. Para mayor información revise los pasos siguientes, el diagrama de flujo y las tablas que a continuación se presentan: Paso 1. Las unidades de medida que deberá emplear son:  

Una unidad de la red deberá ser igual a 1 pie. Una unidad de tiempo será igual a 1 minuto.

Paso 2. Utilice el diagrama de la figura 3.10 como referencia para crear el modelo, recuerde que será necesaria una línea como esta para cada tipo de cliente.

Figura 3.10. Diagrama de flujo del problema.

usted necesitará tres líneas como estas para representar su modelo. Nota:

58

SIMULACIÓN CON FLEXSIM

Paso 3. Para programar los atributos de cada uno de los objetos utilice la siguiente información: –

Tablas de Distribuciones

Tabla 1. Distribuciones del ejercicio. Tipo de cliente

Tiempo entre llegadas

Tiempo de servicio

Tarjeta electrónica

Media: 5 min. Clave: exponential(0, 5, 0)

Media: 3 min, Desv: 1 min Clave: normal(3, 1, 0)

Tickets de prepago

Media: 10 min. Clave: exponential(0, 10, 0)

Media: 8 min, Desv: 3 min Clave: normal(8, 3, 0)

Compra de boleto

Media: 15 min. Clave: exponential(0, 15, 0)

Media: 12 min, Desv: 3 min Clave: normal(12, 3, 0)

– –

Los agentes de venta realizan transacciones de un cliente a la vez. Cada línea de espera mide 30 pies. La longitud de un Conveyor la puede alterar al dar clic en el objeto y en la ventana de propiedades derecha llamada Quick Properties, busque la opción de nombre Straight Conveyor y en el eje “X” calcule la diferencia de 30 unidades entre los puntos Start y End. Respecto a la velocidad a la que avanzan los clientes en las líneas de espera, deberá programarse un ritmo de 250 pies por minuto (recuerde que la velocidad estándar a la que camina una persona es de 3 millas por hora o bien aproximadamente a 4.83 kilómetros por hora). El ajuste de la velocidad lo puede asignar al dar doble clic sobre cada Conveyor, y eligiendo Custom (personalizar) de la lista de selección de opciones de nombre Conveyor Type. Ahí dentro puede definir en Speed los ft/min necesarios.

Paso 4. FlowItems. Al crear su modelo usted tendrá como salida cajas de los tres Sources, estas cajas pueden ser remplazadas por objetos en forma de personas. Dé doble clic sobre el Source que desee editar y en la primera pestaña “source”, ubique la lista de selección de opciones llamada FlowItem Class y seleccione Person, después dé clic en Apply y Ok. Ejecute su modelo para ver los cambios. Si puede, asigne un color de camiseta a los clientes de cada Source (Source1 = rojo, Source2 = azul y Source3 = verde). Un tip para hacerlo es abriendo la ventana de propiedades del Source y dentro de la pestaña Triggers, ubique la lista de selección OnExit. Aquí hay un comando llamado Set Object Color que puede editar (el tema se ampliará en ejemplos subsiguientes.).

Capítulo 3. Construcción de un Modelo Básico.

59

Resultados esperados: 1. Construye el escenario del modelo lo mejor posible. 2. Corre el modelo por 180 horas y responde a las siguientes cuestiones.  ¿Cuál es el promedio y el número máximo de personas formadas en las filas de cada servidor?  ¿Cuál es el tiempo de espera por cada tipo de alumnos?  En promedio, ¿Cuántos clientes por hora atendió cada servidor?  Durante todo el tiempo de simulación, ¿Cuántas horas estuvieron en operación cada uno de los servidores? 3. Prepara y entrega un resumen ejecutivo basado en tus observaciones, donde expliques si es o no factible la contratación de tres servidores para esta operación. Solución del problema 2. El modelo luce como se muestra en la figura 3.11:

Figura 3.11. Diagrama de flujo del problema del problema 2.

60

SIMULACIÓN CON FLEXSIM

Tabla 2. Tabla de información que deberá observar después de ejecutar su modelo. Resultados esperados

Con tarjeta electrónica

Tickets de prepago

Compra de boleto

Total o promedio

Promedio del número de personas formadas en la línea de espera

0.46

2.83

1.45

1.58

Número máximo de personas formadas en la línea de espera

8

16

12

12

Tiempo que espera un alumno antes de ser atendido

2.29

27.39

22.24

17.30

Número total de clientes atendidos

2,144

1,115

704

3,963

Número de clientes atendidos por hora

11.91

6.16

3.9

21.97

% de utilización del servidor

59.5

83

78

73.50

Horas trabajadas por cada servidor

107.1

149.4

140.4

132.30

Nota: recuerde que

sus datos pueden variar un poco debido a la aleatoriedad de las distribuciones de probabilidad.

4

CAPÍTULO 4.

Construcción de un Modelo Paso a Paso

ESQUEMA DEL CAPÍTULO 4.1 DESCRIPCIÓN DEL CASO DE ESTUDIO 4.2 PASO 1. DISEÑO Y CONEXIÓN DEL MODELO PRELIMINAR 4.3 PASO 2. ITEMTYPE Y ESTRATEGIAS DE RUTEO (SEND TO PORT), DESDE EL SOURCE HASTA EL SINK 4.4 PASO 3. EDICIÓN Y COMPORTAMIENTO DE OBJETOS (INTER- ARRIVALTIME, DEMPIRICAL, TRIGGERS, LABELS, FLOWITEM BIN Y PROCESS TIME) 4.5 PASO 4. AÑADIENDO TASK EJECUTERS (OPERATOR Y DISPATCHER) AL MODELO 4.6 PASO 5. INFORMACIÓN ESTADÍSTICA DE LOS OBJETOS Y TEXTOS VISUALES OBJETIVOS DE APRENDIZAJE Introducir al lector en los siguientes puntos: 1. Uso de los comandos setitemtype y getitemtype para contribuir en la lógica del enrutamiento (Send to Port). 2. Aplicar distribuciones estadísticas para la creación de distintos FlowItems. 3. Diferenciación entre piezas nuevas y defectuosas mediante las Labels. 4. Se hace uso de los Triggers en la lógica de eventos particulares. 5. Se puntualiza la importancia de las imágenes 3D. 6. Son descritas las Pick Lists para elegir entre múltiples opciones un código de comando específico. 7. Se añaden Task Ejecuters al modelo. 8. Visualizar informes de estadísticos rápidos sobre la puesta en marcha del modelo.

62

SIMULACIÓN CON FLEXSIM

4.1. DESCRIPCIÓN DEL CASO DE ESTUDIO El siguiente modelo es un tanto más complejo, antes de iniciar con la descripción, vamos a cubrir algunas estrategias necesarias para poder abordar este ejemplo. En primer lugar, tenga en cuenta los pasos básicos que hemos tratado en el ejemplo anterior pues serán necesarios. Y en segundo lugar, considere que existen otros métodos útiles para la construcción de un modelo de simulación: por ejemplo, en el primer capítulo se observó que un sistema es un complejo integrado de elementos interconectados que forma parte de otro sistema superior y se compone de sistemas de orden inferior, se puede decir entonces que, los elementos que componen al sistema bajo estudio, pueden ser solamente un subconjunto de otro sistema mayor. En este sentido, FlexSim está diseñado para permitir añadir niveles de complejidad variada en diferentes partes del área de trabajo, y así, en lugar de tratar de construir el modelo como un sólo sistema, puede fragmentarlo en partes más pequeñas, esto permitirá verificar y validar cada subsistema por separado antes de conectarlos como un todo integrado. Después de las consideraciones anteriores, se presentarán los conceptos claves necesarios para el siguiente ejercicio, tenga en cuenta que durante la construcción del modelo se estará haciendo uso de una variedad amplia de listas de selección de opciones. Ejemplo 2. El propósito de este ejemplo es aprender como asignar y utilizar ItemTypes y Labels en un FlowItems para propósitos de identificación, enrutamiento y proceso. Además, aprenderá a utilizar una distribución empírica para asignar ItemTypes y podrá hacer análisis estadísticos en los objetos mientras estos son ejecutados. Descripción: 





Las piezas llegan al sistema exponencialmente cada 30 segundos. Hay cuatro tipos de piezas (1, 2, 3, 4) distribuidas en 20%, 30%, 40% y 10%, respectivamente (aquí es necesario utilizar una distribución empírica “dempirical”). Las piezas se procesan en una de las cuatro máquinas. Cada máquina procesa sólo un tipo de pieza. Los tiempos de procesamiento en cada máquina son uniformes (100, 120) segundos, pero si la pieza es reprocesada tardara una distribución uniforme (130, 150) segundos. Después de que las piezas son procesadas, se colocan en un almacén de

Capítulo 4. Construcción de un Modelo Paso a Paso.

 



producto en proceso esperando a ser inspeccionadas. El tiempo de inspección corresponde a una constante de 15 segundos. Las piezas que pasan la prueba, salen a un siguiente almacén de producto en proceso, pero las piezas defectuosas se dirigen nuevamente al primer almacén de producto en proceso para ser procesadas nuevamente. El 20% de las piezas no pasan la prueba de inspección. Las piezas que entrarán a reproceso tiene prioridad en la fila de espera. Añadir un ejecutor de tareas o un recurso móvil para llevar las piezas del primer Queue a las máquinas procesadoras y del centro de inspección hacia el Conveyor y Sink. Hacer un análisis estadístico en los objetos mientras el modelo es ejecutado.

Hecha la observación anterior, la construcción del modelo atenderá a los siguientes pasos: Paso 1. Diseño y conexión del modelo preliminar Paso 2. ItemType y estrategias de ruteo (Send to Port) desde el Source hasta el Sink a) Concepto 1: El atributo ItemType dentro del FlowItem b) Concepto 2: El uso de distribuciones estadísticas en los FlowItmes c) Concepto 3: Envió de los FlowItems a los Puertos d) Concepto 4: Colocación de Labels para definir el comportamiento de los objetos. Paso 3. Edición y comportamiento de los objetos a) Programación del Source b) Programación de Labels en la ventana FlowItem Bin c) Programación del Conveyor d) Programación del primer Queue e) Programación de los Processors (máquinas procesadoras) f) Programación del Processor (centro de inspección) Paso 4. Añadiendo un ejecutor de tareas Paso 5. Información estadística de los objetos

63

64

SIMULACIÓN CON FLEXSIM

4.2. PASO 1. DISEÑO Y CONEXIÓN DEL MODELO PRELIMINAR Diseño Después de tener lista su nueva ventana de trabajo, arrastre de la biblioteca objetos los recursos fijos necesarios. Para que usted tenga una idea clara de hacia dónde nos dirigimos, observe la figura 4.1, e intente colocar los recursos tal como se observa. Antes de continuar, guarde este modelo con el nombre de Ejemplo 2.

Figura 4.1. Vista preliminar del modelo a construir.

Conveyor El nuevo Conveyor lanzado en esta versión de FlexSim, es uno de los objetos más avanzados, rico en funciones y fácil de usar. Algunos de sus beneficios incluyen:   

Desarrollo y actualización continua, con especial consideración en las necesidades del cliente. Se basa en un motor de simulación preciso y moderno que aprovecha la potencia y la velocidad de los equipos informáticos modernos. Permite una mayor facilidad de uso y tiene la capacidad de modelar sistemas

Capítulo 4. Construcción de un Modelo Paso a Paso.



de bandas transportadoras simples y complejos. Admite opciones integradas para modelar una amplia variedad de escenarios tales como: construcción de Slug (disparos), Release (liberaciones), Picking Operations (procedimientos de recolección), Systems Power and Free (sistemas de poder y liberación), etc.

Los siguientes capítulos del libro explicarán poco a poco y a detalle cómo incorporar estas nuevas funciones avanzadas del Conveyor en sus modelos de simulación. Continuando con la construcción del modelo, observe que el recurso Conveyor no tiene una estructura similar al de la figura 4.1. Para poder modificar la estructura de un Conveyor existen muchas alternativas, sin embargo, el lector debe tener en cuenta que un Straight Conveyor o una banda transportadora en línea recta puede tener tres objetos integrados los cuales son: Transfers, Entry Transfers, Exit Transfers. Estos objetos no están disponibles en la biblioteca de objetos FlexSim, pero se crean automáticamente siempre que se conecte un transportador a otros objetos:  



Transfers: Implican la conexión desde un trasportador a otro y pueden afectar la trasferencia de un Item entre estos mismos. Entry Transfer: Es creada al conectar un puerto de salida de un objeto fijo con un puerto de entrada de un transportador (como un Source, un Queue o algún otro objeto fijo a un transportador). La alternativa permite afectar cómo un Item se introduce a un transportador. Exit Transfers: Son las conexiones desde un transportador a un objeto fijo (como cuando se conecta un Conveyor con un Processor). Además las transferencias de salida, tienen la capacidad de hacer uso de recursos móviles para recoger artículos y entregarlos a otro objeto. Los recursos móviles pueden tomar artículos en la salida de la banda transportadora o en un rango de posibles puntos a lo largo de la misma.

De manera semejante los controles de edición de un Conveyor también se ven y funcionan de manera diferente, cada uno tiene integrados tres símbolos (dos similares ubicados en los extremos de la banda en forma de cruz de color rojo y uno al centro en forma de flecha), los cuales se muestran al dar clic sobre este mismo. Estos comandos en forma de cruz permiten entre otras cosas alterar la longitud (eje X), la profundidad (eje Y) y la altura (eje Z) de la banda transportadora de manera individual, por lo que cada extremo puede manipularse por separado (un Curved Conveyor tiene además controles de color verde que le permiten editar el radio, el

65

66

SIMULACIÓN CON FLEXSIM

ángulo inicial y el ángulo de apertura) y la flecha central de la banda indica la dirección del flujo de los FlowItems. Así mismo, puede mover o cambiar el tamaño de un transportador al mantener presionado el botón izquierdo del mouse en algún extremo de la banda mientras mueve este mismo en los ejes X y Y o bien si desea modificar la altura simplemente haga girar el scroll del mouse. Si desea cambiar el flujo de los FlowItems, ubique dentro de la ventana Quick Properties la opción Reverse Direction y dé clic sobre este botón, de inmediato usted notará que la dirección de la flecha central del Conveyor cambio a un sentido opuesto. Dadas las consideraciones anteriores, agregue al modelo tres Straight Conveyor y dos Curved Conveyor, y trate de unirlos de forma que se muestren como usted lo requiere (ver figura 4.2). Obsérvese que con el simple hecho de aproximar los extremos de las bandas se crea una conexión de tipo Transfers, la cual las une formando un solo sistema de Conveyors. Sin embargo, esta alternativa para integrar curvas a lo largo de un sistema de Conveyors no es la única opción, el objeto Join Conveyors puede hacer lo anterior de forma más simple y rápida. Para probar como funciona, simplemente coloque dos Conveyors de manera perpendicular uno al extremo del otro y únalos usando un objeto Join Conveyors (dé clic sobre el extremo del primer conveyor y posteriormente clic sobre el extremo del segundo conveyor), de inmediato se creará un Conveyor en forma de curva el cual une a estos dos extremos. Para liberar el puntero del mouse del objeto Join Conveyors, precione la tecla ESC.

Figura 4.2. Estructura y conexión del Conveyor.

Capítulo 4. Construcción de un Modelo Paso a Paso.

Conexión Conecte cada uno de los objetos conforme al flujo de los FlowItems. Cuando conecte el primer Queue con los cuatro Processors, recuerde que dependiendo del orden en que usted conecte los objetos, se irán creando puertos numerados a partir de la primera conexión, esta numeración es importante, pues será empleada para definir la ruta de los FlowItems. Para nuestro ejemplo conecte de arriba hacia abajo. Antes de iniciar con la programación se explicarán algunos conceptos fundamentales.

4.3. PASO 2. ITEMTYPE Y ESTRATEGIAS DE RUTEO (SEND TO PORT), DESDE EL SOURCE HASTA EL SINK Concepto 1: El atributo ItemType dentro del FlowItem Como ya se mencionó en el segundo capítulo, un concepto fundamental es el ItemType, este es un identificador numérico que se almacena en cada FlowItem y viajan juntos a través de todo el modelo en FlexSim. Los usos comunes de un atributo ItemType permiten a los recursos fijos tomar decisiones de enrutamiento ya que una vez definidos dentro de un FlowItem, estos pueden ser usados para diferenciar si un producto es pequeño, mediano o grande. Cada FlowItem tiene sólo un ItemType y su valor es único, lo que significa que si durante el proceso cambia el ItemType de un FlowItem, sólo cambiará el valor para ese FlowItem específico, y el ItemType del resto de los FlowItems no será cambiado. El significado del valor de un ItemType es totalmente a su consideración, aunque por lo general se entiende como un valor que describe un tipo de producto o categoría. Sin embargo, un ItemType puede ser usado para establecer cualquier otro atributo como color, tamaño o grado de rotación, que permita afectar la lógica y comportamiento del modelo. Frecuentemente, un ItemType es establecido en todos los FlowItems mediante un Trigger, el cual desencadena una serie de eventos a través de una lista de selección de opciones llamada OnExit. Generalmente esta tarea se realiza dentro de la ventana de propiedades de un Source, sin embargo, un atributo ItemType se puede establecer o consultar en cualquier otro punto dentro del modelo si usamos dos comandos especiales:

67

68

SIMULACIÓN CON FLEXSIM



El comando setitemtype permite al usuario establecer el atributo ItemType en un FlowItem con un valor específico. Para poder utilizar un comando, setitemtype necesita saber en qué FlowItem desea establecer el ItemType, así como el valor que este tomara. Para referenciar a un ItemType dentro de un FlowItem, es necesario emplear la palabra clave de FlexSim llamada item. El valor asignado al ItemType puede ser un valor estático, o puede ser generado de forma aleatoria a través del uso de una distribución estadística, como por ejemplo duniform(1, 4). En este caso, el ItemType tomará el valor de un número discreto, distribuido uniformemente entre 1 y 4, excluyendo los valores fraccionarios como 1.1, o 2.6. Esta acción aunque es muy sencilla, es suficiente para establecer un ItemType en la mayoría de las lista de selección de opciones incluidas en un objeto.



Para poder utilizar el ItemType de un FlowItem, es necesario usar el comando getitemtype. Si deseamos consultar un ItemType dentro de un lista de selección de objetos establecida en una pestaña Flow o Trigger es necesario emplear la instrucción getitemtype(item). Nótese el uso de la palabra item entre paréntesis. La palabra clave item en este contexto se utiliza para hacer referencia a cualquier Item que es causante de que una opción sea tomada. El resultado de la consulta es un número que define el tipo de FlowItem y este valor puede ser utilizado para hacer referencia a un número de puerto. Si no recuerda lo que se dijo antes acerca de cómo trabajan los puertos, en el Concepto 3 se mencionará nuevamente el tema.

En este segundo modelo, usaremos el comando setitemtype para crear cuatro ItemTypes distintos, los cuales identifiquen a las cuatro diferentes piezas (FlowItem), y el comando getitemtype más adelante contribuirá en la lógica del enrutamiento de las piezas por los distintos procesos del sistema. Concepto 2: Uso de distribuciones estadísticas en los FlowItems En el capítulo 5 del libro “Discrete-Event System Simulation” (Banks et. al., 2009), se discute la importancia del empleo de distribuciones estadísticas como apoyo para representar un sistema real. En términos más simples, una variable con un comportamiento caracterizado por una distribución de probabilidad permite que el modelador tenga acceso a distintos tipos de “números aleatorios". En FlexSim para utilizar una distribución adecuada, usted necesita saber tres cosas: el nombre de la distribución, los parámetros (o argumentos) necesarios y el lugar donde será usada.

Capítulo 4. Construcción de un Modelo Paso a Paso.

El nombre de una distribución, indica el tipo de cálculo que se va a hacer. Recuerde que además de la existencia de las distribuciones ya definidas como las continuas (exponencial, normal, etc.) y discretas (bernoulli, poisson, etc), se pueden crear nuevas, como la distribución empírica (dempirical). No olvide que el uso adecuado de una distribución de probabilidad determinará gran parte de la calidad de su modelo, por lo que si desea más información al respecto, se sugiere entrar al manual de ayuda de FlexSim. En el menú principal, pude hacer clic en Help>User Manual y dentro del manual en la primer pestaña llamada Contents despliegue la biblioteca Command Reference, seleccione la categoría Category Reference y busque el apartado Statistics. Aquí encontrara los comandos para crear, manipular y acceder a los datos estadísticos e incluso a las distribuciones de probabilidad. Distribución empírica discreta Dentro de FlexSim, existen tres distribuciones empíricas y con frecuencia una distribución dempirical toma dos parámetros: el nombre de una Global Table (tabla global) y el valor de una stream (semilla). Como usted sabe la semilla sólo es un valor inicial para que el software genere números aleatorios, por lo que este parámetro es en gran medida opcional y puede dejarse en blanco si así se desea. Por lo tanto, nos centraremos en el primer parámetro Global Table. Para poder utilizar este parámetro en una dempirical es necesario crear una tabla global, la cual deberá tener un formato específico. La tabla puede tener tantas filas como sean necesarias para definir tantos valores como se desee, pero sólo se admiten dos columnas. El porcentaje de probabilidad se debe colocar en la columna 1 a partir de la fila 1 de la tabla, y sus valores asociados se ponen en la columna 2 (estos valores son ItemTypes y serán asignados a los FlowItems). Los porcentajes se introducen como números entre 0 y 100, y deben sumar un total de 100 por ciento, por tanto todos los valores fuera de este rango nunca serán mostrados. Por ejemplo, la instrucción: Item Type: dempirical ("ProductoTipo", 5); Asigna un valor a la variable Type usando una distribución empírica discreta definida en la tabla global llamada “ProductoTipo”, a través de la generación de números aleatorias iniciados por una semilla de valor 5. En nuestro modelo, para programar la frecuencia de llegada de los FlowItems y los tiempos de operación de cada equipo, utilizaremos distribuciones de probabilidad definidas. Mientras que para asignar la probabilidad que le corresponde a cada una de las cuatro piezas (20%, 30%, 40% y 10%, respectivamente), programaremos una distribución empírica utilizando una tabla global.

69

70

SIMULACIÓN CON FLEXSIM

Concepto 3: Envío de los FlowItems a los Puertos Ya hemos hablado del campo Send To Port, pero ahora vamos a echar un vistazo más de cerca, la lista de selección Send To Port se encuentra dentro de la ventana de propiedades de todos los recursos fijos en la pestaña llamada Flow o flujo (para el caso de los Conveyors, es necesario agregar un objeto Decision Points como complemento de este mismo). En este sentido, cuando el FlowItem está listo para ser enviado al siguiente objeto se hace una evaluación de la dirección que tomará. Por ejemplo, en un Processor el FlowItem está listo para ser enviado cuando este terminó su tiempo de operación. La expresión Send to Port devuelve un número de salida que corresponda a un puerto válido, y así, es posible referenciar los FlowItems a un número de puerto. Usted puede utilizar una distribución estadística para obtener números aleatorios del puerto, o la información consultada de un FlowItem correspondiente a un número de puerto (por ejemplo, un ItemType). Un número de puerto valido se considera cuando existe un puerto con ese número. Es decir, si usted quiere enviar un FlowItem a través del puerto 50, el modelo debería tener un puerto número 50, de lo contrario los FlowItems enviados a este puerto no serán capaces de salir del objeto que los contiene. Una vez que el campo Send To Port es evaluado, el puerto de salida se abrirá y el FlowItem es empujado al siguiente objeto, siempre que la conexión de puertos esté lista (una conexión está lista cuando el puerto de salida y el puerto de entrada están abiertos). En caso de que la expresión Send To Port devuelva un 0, todos los puertos de salida se abrirán y el FlowItem podrá salir por el primer puerto disponible. Si la función devuelve un -1 entonces el FlowItem no se mostrará, esta información de comandos especiales la puede consultar en el manual de ayuda del software.

El modelo que diseñaremos requiere dos enrutamientos distintos: 1. Como cada máquina procesa sólo un tipo de pieza, es necesario entonces identificar en el primer Queue el tipo de ItemType que contiene un FlowItem y así podremos asignarle la operación que le corresponde. 2. Sabiendo que se producen piezas defectuosas, es necesario indicar en el área de inspección (Processor9) que el 20% de las piezas resultarán defectuosas y deberán ser devueltas al primer Queue para su reproceso por medio de la banda transportadora.

Capítulo 4. Construcción de un Modelo Paso a Paso.

Concepto 4: Colocación de Labels para definir el comportamiento de los objetos Para añadir los detalles que definirán el comportamiento de los objetos tales como el tiempo de proceso necesario para las piezas nuevas o piezas reprocesadas, es necesario agregar una bandera a los FlowItems que indique a los objetos su diferencia, además de hacer uso eficaz de los triggers. Como ya mencionamos, un atributo ItemType logrará una distinción de piezas variadas, pero ahora necesitamos que esas piezas tengan una etiqueta que las distinga aún más para poder asignar la primera regla de ruteo. Así que, eso significa que necesitamos algún otro mecanismo que les indique a los objetos en el modelo si los FlowItems serán piezas nuevas o reprocesadas, ese mecanismo se denomina Label. Una Label es sólo una manera de almacenar información en un FlowItem de FlexSim. Los recursos fijos y los recursos móviles, pueden hacer uso también de las Labels y no hay límite en cuanto al número de Labels que puede tener un objeto. Una Label debe tener un nombre y un tipo de datos asociado con ella, el tipo de datos más común para una Label es un número, pero las etiquetas también pueden contener cadenas de texto, listas o tablas. Hay algunos comandos especiales que usted necesita conocer para trabajar con Labels. Pues, la creación de un lugar para almacenar información no es muy útil sin una manera de establecer o consultar los datos. Al igual que en las distribuciones de las que hablamos anteriormente, estos comandos tienen parámetros asociados a los mismos, los cuales son requeridos para su buen funcionamiento. En el caso de las Labels, estos parámetros funcionan como un tipo de dirección, ellos nos permiten identificar dónde existe una etiqueta: 

En primer lugar hablemos del comando getlabelnum. El comando getlabelnum, es utilizado para hacer consultas pues permite obtener los datos numéricos almacenados en una Label, en este caso la etiqueta fue designada para almacenar un número dentro de un FlowItem. Los dos parámetros necesarios son: un item que contiene la etiqueta a consultar y un nombre de la etiqueta escrita entre comillas. Por esta razón, cada Label necesita un nombre y un valor numérico, para poder referenciarlo más tarde usando este comando. Si queremos consultar los datos almacenados en una Label denominada "prueba" que pertenece a un FlowItem, podemos escribir lo siguiente:

71

72

SIMULACIÓN CON FLEXSIM

getlabelnum(item,"prueba")

Nuevamente tenga en cuenta que el nombre de la etiqueta tiene que estar entre comillas. El resultado de este comando será cualquier número almacenado dentro la etiqueta "prueba" la cual pertenece al FlowItem referenciado por el termino item. Si hay un comando get también hay comando complementario set. 

El comando setlabelnum, permite al usuario establecer un valor numérico en una Label mientras el modelo es ejecutado. Los parámetros necesarios son los mismos que getlabelnum. Así que, si queremos establecer el valor de 1 a una etiqueta denominada "prueba" de un FlowItem, se tendría que escribir lo siguiente: setlabelnum(item, "prueba", 1)

En este ejemplo muy sencillo, hemos elegido utilizar un número estático (1) como el valor que se asigna a la Label. Muchas veces esto es suficiente pero dependerá mucho de los objetivos que se busquen en el modelo. Sin embargo, es importante tener en cuenta que el valor asignado puede ser también una distribución de probabilidad. Existen comandos distintos que tienen que ver con la obtención y el establecimiento de valores no numéricos en una Label. La ayuda de FlexSim describe a detalle estos usos. Después de haber creado, conectado y entendido los conceptos necesarios, iniciaremos con la programación.

4.4. PASO 3. EDICIÓN Y COMPORTAMIENTO DE OBJETOS (INTERARRIVALTIME, DEMPIRICAL, TRIGGERS, LABELS, FLOWITEM BIN Y PROCESS TIME) 4.4.1. Iniciemos con la programación del Source: 1. Para que las piezas lleguen al sistema exponencialmente cada 30 segundos (figura 4.2.1), es necesario entrar a la ventana de propiedades del Source. En la primer pestaña, ubique la lista de selección de opciones Inter-Arrivaltime, seleccione Statistical Distribution>exponential y

Capítulo 4. Construcción de un Modelo Paso a Paso.

73

coloque los valores (0, 30, 0). Figura 4.2.1 Distribución para frecuencia de llegadas.

2. Para indicar al Source la necesidad de generar aleatoriamente un ItemType en cada uno de los FlowItem (pieza 1, 2, 3 y 4) que emergerán al modelo bajo una distribución de 20%, 30%, 40% y 10% respectivamente, es necesario utilizar una distribución empírica “dempirical”. Así que, iniciemos con la construcción de una tabla global. Vaya al menú Barra de Herramientas y localice la opción Tools, y haciendo uso de la lista de selección de opciones desplegable en forma de cruz y de color verde, elija Global Table con un clic. Dentro de la ventana emergente, diseñe la tabla según corresponda a sus necesidades. Para este caso, 4 filas y 2 columnas son suficientes, ver figura 4.3.

Figura 4.3. Tabla global necesaria para representar la asignación de ItemTypes respecto a la probabilidad de ocurrencia.

Ya que la tabla fue creada, es posible asignar un nombre a una distribución dempirical quien correctamente realizará los cálculos de tal manera que el ItemType número 1 sea asignado al 20% de todos los FlowItems generados durante todo el tiempo simulado, el valor 2 será generado 30% de las veces, el valor 3 el 40% del tiempo y el valor 4 será generado el 10% del tiempo. Ahora, para utilizar estos datos se deberá introducir la expresión dempirical ("GlobalTable1") en la lista de selección de opciones llamada OnCreation (localizada en la pestaña Triggers de la ventana de propiedades del Source), la opción permite crear nuevos FlowItems. No importa que nombre usted asigne a la tabla, pero tenga en cuenta que al colocar el nombre de la tabla global dentro del comando de la función dempirical, este se escribe entre comillas. Además, es necesario escribir el nombre tal y como fue definido en un

74

SIMULACIÓN CON FLEXSIM

inicio pues el comando distingue entre letras mayúsculas y minúsculas. Al ejecutar el comando, se crea una cadena de búsqueda para encontrar una tabla con ese nombre, por lo que sí está mal escrito o no hay comillas alrededor del nombre, el comando dempirical no sabrá que se indicó la búsqueda de esa tabla. Este concepto puede parecer confuso ahora, pero tendrá más sentido si observamos la figura 4.4, donde quedo asignado el comando.

Figura 4.4. Para asignar una dempirical, dentro de una la lista de selección de objetos dé clic en la cruz verde y seleccione Set Item Type and Color. Con esto crearemos ItemTypes y le daremos un color distinto a nuestras piezas.

Ahora que se encuentra dentro de esta pestaña llamada Triggers, se comentará más al respecto. Los factores desencadenantes (triggers), son puntos de acción que ejecutan con una lógica conjunta cuando ocurre un evento particular, tal como cuando un FlowItem llega o sale de un objeto. La mayor parte de los triggers asociados a un objeto están contenidos en una pestaña llamada Triggers de su ventana de propiedades. Todos los objetos tienen triggers, pero dependiendo de la funcionalidad de cada objeto podría variar su cantidad. Para ilustrar lo anterior la figura 4.5, muestra el ejemplo de otra pestaña Triggers pero esta vez de un Processor.

Figura 4.5. Pestaña Triggers de un Processor.

Capítulo 4. Construcción de un Modelo Paso a Paso.

Los triggers comunes que están disponibles en la mayoría de los objetos incluyen: 



OnReset: Se produce siempre que el modelo de simulación se restablece, este es un buen lugar para establecer codificaciones iniciales de variables y etiquetas. OnMessage: Se produce siempre que un mensaje es enviado a un objeto, los mensajes pueden proceder de otro objeto para coordinar su lógica o desde el mismo objeto para crear un tiempo de retraso o iniciar la lógica de algún evento futuro. Las instrucciones más empleadas son: sendmessage() y senddelayedmessage().





  

OnEntry: Se produce siempre que un FlowItem entra en un objeto, a menudo se utiliza para cambiar el valor de la etiqueta de un FlowItem, su color o su ItemType. OnExit: Se produce cuando un FlowItem abandona o sale de un objeto, este comando a menudo se utiliza para actualizar los datos o para tomar acciones antes de que el FlowItem entre al próximo objeto. OnSetupFinish: Esta función, llama a un objeto cuando su tiempo de preparación ha expirado. OnProcessFinish: La función, llama a un objeto cuando su tiempo de proceso ha expirado. Custom Draw: Se produce cada ciclo de tiempo simulado y permite añadir diferentes diseños en 3D (por ejemplo, el cambio de apariencia de un objeto en función de su estado actual).

Y cada uno de estos factores desencadenantes puede ser manipulado por un menú de opciones múltiples, el cual varía dependiendo del tipo de trigger empleado, tal como se muestra en la figura 4.6: 

 

El ícono abre una lista de selección de opciones posibles. Al dar clic sobre él, se abre una ventana de diálogo donde se puede manipular la lógica de cada trigger como se muestra en la figura 4.7. Mientras que el ícono permite eliminar alguna selección realizada. Y como ya se ha explicado, el ícono abre una ventana que permite configurar códigos en FlexScript, este módulo admite la creación de códigos personalizados. El tema se amplía en apartados siguientes, sin embargo no se discute en su totalidad el concepto en este libro.

75

76

SIMULACIÓN CON FLEXSIM

Figura 4.6. Lista típica de selección de opciones de un OnEntry.

Figura 4.7. Ventana de diálogo para asignar ItemType y un color.

Aclarados algunos detalles podemos continuar con la programación del modelo.

Programación de Labels en la ventana FlowItem Bin Trabajemos ahora con las Labels. En este modelo, las Labels serán empleadas para diferenciar una pieza nueva de una defectuosa y servirán como una bandera tanto para que el primer Queue configure la prioridad de entrada de los FlowItems en los procesadores, como para programar los tiempos de operación mismos que dependen del tipo de FlowItem que será manipulando. Ahora que sabemos que existen muchas maneras de crear y manipular el uso de las Labels, en este modelo vamos a crear dos Labels. Para empezar es necesario definir la primer Label en cada FlowItem antes de que estos sean creados por el Source. Los objetos Sources no crean FlowItems por sí mismos, sino que crean copias

Capítulo 4. Construcción de un Modelo Paso a Paso.

77

de FlowItems de un FlowItem maestro que existe en un lugar llamado FlowItem Bin. Por lo tanto, cualquier cambio realizado en este FlowItem maestro afectará a todas las copias posteriores al Source. Las Labels son un ejemplo de cambio que se pueden realizar en un FlowItem maestro, además de los atributos de tamaño, forma y color. Usted puede acceder a FlowItem Bin ( ) desde la Barra de Herramientas ubicada en la parte superior del Layout de FlexSim, o bien haciendo clic en Tools>FlowItem Bin. Esto nos llevará a la ventana de FlowItem Bin que permite seleccionar un tipo FlowItem en la parte izquierda y ver en la parte derecha una vista ortográfica en 3D del FlowItem seleccionado. La clase de FlowItem que vamos a utilizar en nuestro modelo es una Sphere (esfera), selecciónela de la lista y pulse el botón de Properties (propiedades). Lo anterior mostrará una ventana de propiedades, correspondiente a ese FlowItem. Como usted puede ver en la pestaña Labels, este objeto no tiene etiquetas definidas por defecto. En la parte inferior de esta pestaña hay un botón en forma de cruz verde con el cual puede elegir entre Add Number Label (añadir etiqueta numérica) o bien Add String Label (añadir etiqueta de cadena), dé clic y cree una nueva etiqueta que pueda contener datos numéricos. Tenga en cuenta que las etiquetas numéricas no pueden mantener información de texto y viceversa. Si es establecido un valor numérico en una etiqueta de cadena, este será tratado como texto (por ejemplo Pieza 22) y no como un valor numérico como posiblemente usted quisiera. Una vez que haya hecho clic en el botón Add Number Label, la nueva etiqueta tendrá el nombre de newnumberlabel. Usted puede cambiar el nombre haciendo clic en este mismo. Para nuestro modelo, escriba el nombre de la etiqueta Pieza Nueva, y coloque el valor de 1 en la casilla de al lado. El uno, es entonces el valor predeterminado de la Label y se puede utilizar para indicar un FlowItem nuevo que aún no ha sido inspeccionado. Vea la figura 4.8. La segunda Label (Pieza Defectuosa) será definida dentro de la ventana de propiedades de la banda transportadora.

Figura 4.8. Para aplicar los cambios de Apply>Ok y cierre la ventana FlowItem.

78

SIMULACIÓN CON FLEXSIM

Importación de imágenes Si usted entra por curiosidad a la pestaña General de esta última ventana perteneciente a la Sphere (figura 4.8), podrá ver que dentro de esta misma se pueden modificar las características de este FlowItem. 3D Shape, define la ruta de ubicación donde la imagen de la Sphere se encuentra ubicada (sólo se admiten figuras con extensión *.wrl; *.3ds; *.dxf; *.stl; *.skp), este es el lugar adecuado para que usted sustituya la figura de la esfera por alguna otra si así lo desea. Por ejemplo, podría importarse la imagen de un frasco, un pastel, un automóvil, un avión, una persona, o de cualquier otro objeto diseñado previamente en AutoCAD, ProE, Solid Works, Catia, 3D Studio, AC3D, Rivit o Google Sketch-Up. Además, edita el color, la posición, la rotación y las dimisiones de la esfera. Para terminar vaya nuevamente al Source, abra su ventana de propiedades y en la primer pestaña busque la lista se selección de opciones llamada FlowItem Class y seleccione Sphere. Al ejecutar el modelo, esta acción le permitirá ver que fluyen esferas del Source en lugar de cajas. Programación del Conveyor Para introducir con éxito una segunda Label dentro de cada FlowItem y dado que por el momento el Conveyor en esta nueva versión de FlexSim no posee una forma rápida de agregar estas etiquetas, se decodificará una lista de selección de opciones del objeto Decision Point perteneciente a la primer sección del Conveyor. En este entendido, será necesario detallar el uso de las Pick Lists. Pick Lists En párrafos anteriores, se ha mencionado que las Pick Lists (listas de selección) definidas dentro de la ventana de propiedades correspondientes a cada objeto en FlexSim, permiten elegir entre múltiples opciones un código de comando específico de manera fácil, el cual implementa funcionalidades de interfaz. Aquí, cada una de estas listas de selección hace referencia a una sección de códigos. La ventaja de estas listas de selección de interfaz es que permite al modelador conducirse sin escribir configuraciones de códigos complicadas, simplemente eligiendo una opción. Sin embargo, también es posible seleccionar comandos e introducir expresiones manualmente (véase la figura 4.9):

Capítulo 4. Construcción de un Modelo Paso a Paso.





79

En este propósito, cada lista de selección de opciones está asociada con un Popup. Los Popups permiten editar fácilmente distintos parámetros de la alternativa elegida. Por lo que si se desea, es posible hacer uso del editor en forma inmediata simplemente presionando el botón edición de parámetros ( ). Una vez dentro de la aplicación, se permite introducir valores o expresiones deseadas en cada Popup. En este sentido pero en otro orden de ideas, si se tiene la habilidad de escribir códigos explícitos, también se admiten configuraciones mediante el botón edición de código ( ). Al elegir esta última opción, una ventana emergente muestra todos los códigos preestablecidos como plantilla correspondiente con la codificación de cada elección tomada. Sin embargo, aquí se permite decodificar la plantilla para redefinir la instrucción que se requiere ejecutar.

En el ejemplo que a continuación se describe, se ilustra sólo un caso específico de estudio. Pese a esto, el lector puede obtener mayor información respecto a la redacción de códigos en FlexSim revisando los temas; Template Code, Code Editor y Writing in FlexSim del manual de ayuda FlexSim.

Figura 4.9. Ejemplo de los distintos usos de una Pick List.

Asignación de Labels Después de las consideraciones anteriores, ubique la primera sección de la banda trasportadora (StraightConveyor) y agregue de la biblioteca de objetos un Decision Point al inicio y sobre esta sección del Conveyor. Posteriormente dé doble clic sobre el objeto Decision Point y dentro de la venta de propiedades emergente busque la

80

SIMULACIÓN CON FLEXSIM

pestaña de Decision Point Type. Aquí, elija el botón ( ) perteneciente a la lista de selección de opciones de nombre On Arrival. Al instante se desplegará una nueva ventana con el nombre DP1- On Arrival en la cual se observa la siguiente instrucción: Treenode current = parnode(1); treenode item = parnode(2); treenode conveyor = parnode(3);

Lo que aquí se muestra, es sólo un ejemplo de declaraciones de cabecera necesaria para iniciar el reconocimiento de alguna rutina específica. En esta misma ventana pero en la parte inferior izquierda, es posible indicar si se desea interpretar la codificación como FlexScript o como compilador C ++. La revisión de la sintaxis FlexScript se hace pulsando el botón .

Continuando con la programación, dentro de esta última ventana se tendrá que definir la segunda Label, para permitirle colocar una segunda bandera a cada FlowItem que entre al Conveyor, escriba la siguiente instrucción: treenode current = parnode(1); treenode item = parnode(2); treenode conveyor = parnode(3); { //************* PickOption Start *************\\ /***popup:CreateInitializeLabel*/ /**Create and Initialize Label*/ treenode involved = /** \nObject: *//***tag:involved*//**/item/**/; string labelname = /** \nLabel: *//***tag:labelname*//**/"Pieza Defectuosa"/**/; double newvalue = /** \nValue: *//***tag:newvalue*//**/2/**/; setnodenum(assertlabel(involved,labelname,DATATYPE_NUMBER),newvalue); } //******* PickOption End *******\\

Capítulo 4. Construcción de un Modelo Paso a Paso.

81

Involved: permite definir el Item que desea manipular, como aquí no tenemos preferencia para ningún FlowItem entonces esta instrucción se generaliza para todos los FlowItem que pasen por aquí, la instrucción Labelname describe el nombre de nuestra segunda etiqueta el cual es “Pieza Defectuosa” y finalmente con New Value se establece el número 2. El dos, es entonces el valor predeterminado de la segunda Label y se puede utilizar para indicar que un FlowItem el cual ya fue inspeccionado no paso la prueba y requiere reproceso. Para aplicar los cambios de Apply>Ok a las dos últimas ventanas emergentes. Ver figura 4.10.

Figura 4.10. Imagen ilustrativa para la creación de la segunda Label en el objeto Decision Point de un Conveyor.

Más información respecto al lenguaje de programación FlexScript la podrá consultar en el apartado 5.4. del siguiente capítulo. Los próximos pasos a seguir para la construcción de este modelo son: definir como emplear Send To Port para indicar el flujo que seguirá cada una de las cuatro piezas en los diferentes procesadores y seleccionar el trigger adecuado que permita ordenar la entrada de las piezas nuevas y las que entraran a reproceso.

Programación del primer Queue Las piezas se procesan en una de las cuatro máquinas, pero como cada máquina procesa sólo un tipo de pieza es necesario entonces identificar en el primer Queue el tipo de ItemType que contiene un FlowItem y así podremos asignarle la operación que le corresponde. Pero antes de iniciar con la programación del Queue, se

82

SIMULACIÓN CON FLEXSIM

explicarán las bondades de la pestaña Flow, dé doble clic sobre el primer Queue y seleccione la pestaña Flow. Algunos otros triggers se encuentran en la pestaña Flow de los recursos u objetos fijos. Como su nombre lo indica, la pestaña Flow se centra en el movimiento de los FlowItem del objeto actual al siguiente objeto, por tanto, esta pestaña permite establecer la lógica del flujo de entrada y salida de los FlowItems en los objetos. Como usted puede ver en la figura 4.11, hay dos secciones en la pestaña Flow: El Output (salida), siempre está activo y el Input (entrada) se activa cuando es marcada la opción Pull (jalar).

Figura 4.11. La imagen muestra la pestaña Flow del objeto Queue



Output: - Send To Port: Específica la lógica que determina a través de que puerto el FlowItem puede viajar después de dejar el objeto que lo contiene. - Use Transport: Cuando esta opción es seleccionada, es llamado un recurso móvil para transportar los FlowItem de este a otro objeto, y el menú desplegable es usado para especificar que recurso móvil debería ser usado.



Input: La opción Pull es usada cuando los FlowItems deberían ser jalados al objeto actual en lugar de que sean empujados desde el objeto anterior. - Pull Strategy: Específica la estrategia de la lógica empleada para definir cuál puerto o puertos deberían ser usados. - Pull Requirement: Refiere la lógica para jalar a los FlowItems de acuerdo con algún criterio, tal como, un ItemType o un valor de etiqueta.

Capítulo 4. Construcción de un Modelo Paso a Paso.

83

En la figura anterior al seleccionar First Available de la lista de selección de opciones Send To Port, se desencadenará una acción lógica la cual indica que los FlowItems deberán salir por el Puerto 1, pero si el Puerto 1 no está disponible, los FlowItems deberán salir por algún otro puerto que esté conectado; sin embargo, la evaluación de los puertos es hecha en secuencia (del puerto 1 al puerto n). Existen muchas formas de indicar el flujo de los FlowItems de un objeto a otro. La figura 4.12, muestra una lista de las diferentes opciones que se pueden emplear para indicar instrucciones lógicas tanto en Send to Port como en los comandos Pull.

Figura 4.12. La imagen muestra las distintas categorías elegibles en Send To Port.

Del mismo modo si emplea alguna opción Pull, los FlowItems pueden ser jalados de objetos antecesores basándose en: By Expression (por ejemplo: getitemtype(item)), Longest Queue (la fila de entrada más larga), en forma Round Robin (asignación a todos los recursos con la misma constancia de oportunidades), Conditional Port (de acuerdo a una condición específica como una distribución de probabilidad), etc. O bien, puede hacer configuraciones lógicas utilizando el ícono de códigos en forma de pergamino, localizado a la derecha de esta lista de selección. En relación con esto último, programe al Queue. Dentro de la ventana de propiedades del Queue, seleccione la pestaña Flow y dé clic con el puntero de mouse

84

Figura 4.13. Programación del flujo de los FlowItems mediante la clasificación Values By Case.

SIMULACIÓN CON FLEXSIM

sobre la lista de selección de opciones del trigger Send To Port, ahí dentro elija la categoría Port By Case (o Values By Case). Como usted puede observar, el comando getitemtype(item) está asignado por defecto así que dejemos este espacio tal y como esta. Posteriormente dé clic en el ícono y agregue tantos casos como sean necesario (para nuestro modelo sólo son necesarios 4 casos distintos). En la columna izquierda numere del caso 2 al caso 4, estos valores permitirán identificar qué tipo de ItemType (o número de pieza) tiene como atributo cada FlowItem, como puede ver no es necesario numerar el caso 1 pues este es definido de manera predeterminada. En la columna de la derecha coloque el número de puerto por el que deberá salir cada FlowItem según corresponda. Esto obliga al Queue a liberar a la pieza 1 por el puerto 1, a la pieza 2 por el puerto 2 y así sucesivamente. Entonces lograremos que el Processor4 procese únicamente las piezas con el ItemType 1, el Processor5 manipulará a las piezas con el ItemType 2 y así consecutivamente. Véase figura 4.13. Después de haber realizado lo anterior, de clic en Apply y pase a la pestaña Triggers de este mismo objeto. Recordemos que en la descripción del problema fue solicitada una instrucción para dar prioridad de entrada a las piezas que serán reprocesadas. Es decir, si dentro de la línea de espera hay formadas seis piezas del tipo 1 con la etiqueta “Pieza Nueva” esperando a ser procesadas y llega una séptima pieza del mismo tipo pero con la etiqueta “Pieza Defectuosa”, esta última deberá formarse al inicio de la línea de espera para que inmediatamente después de que el procesador esté disponible la atienda y no tenga que seguir formada. En este propósito, diríjase a la pestaña Triggers>OnEntry y seleccione la opción Sort by Expression. Ahí dentro seleccione orden descendente y elija la expresión getlabelnum(item, "labelname"). Dentro de la expresión sustituya el nombre de la etiqueta “labelname” por el de “Pieza Defectuosa”. La instrucción

Capítulo 4. Construcción de un Modelo Paso a Paso.

85

anterior ordenará al Queue dar prioridad de entrada a las piezas que tengan la etiqueta “Pieza Defectuosa”. Finalmente de clic en Apply y Ok. Véase figura 4.14.

Figura 4.14. Programación de prioridades de en una línea de espera.

Programación de los Processors (máquinas procesadoras) Existen cuatro máquinas procesadoras en las cuales debemos programar tiempos de proceso distintos. En cada máquina se programará un tiempo de proceso con una distribución uniforme entre 100 y 120 segundos si la pieza es nueva, pero si la pieza es reprocesada por estar defectuosa tardará una distribución uniforme de entre 130 y 150 segundos. Para hacer lo anterior, dé doble clic en uno de los Processors y dentro de la primera pestaña busque la lista de selección de opciones Process Time. Ahí, seleccione la categoría Values By Case y edite la función getlabelnum(item, "Pieza Defectuosa"). Note que la etiqueta “Pieza Defectuosa” fue definida manualmente (véase figura 4.15). Después, programe dos casos; en el primero indique la distribución uniforme (100, 120, 0) y en el segundo uniform(130, 150, 0). Lo anterior hará que cada que entre un FlowItem a un equipo, este será valorado por sus etiquetas y como aquí se indicó que si la pieza contiene la etiqueta “Pieza Defectuosa” con

Figura 4.15. Tiempos de proceso variados.

86

SIMULACIÓN CON FLEXSIM

valor de 2, entonces siempre que esta llegue a la máquina le aplicará un reproceso con un tiempo de proceso de uniform(130, 150, 0). Note que existe un cero al final de la instrucción anterior, este “0” hace referencia a la Stream, aplique estos cambios a cada una de las cuatro máquinas. Programación del Processor (centro de inspección) Con todo lo que se ha revisado hasta ahora, usted es capaz de identificar las listas de selección de opciones para hacer que el tiempo de inspección corresponda a una constante de 15 segundos. No olvide que las piezas que pasan la prueba, salen del sistema a través de un Sink (Post 2), pero las piezas defectuosas se dirigen nuevamente mediante el Port 1 de la banda transportadora al primer Queue para ser procesadas nuevamente (el 20% de las piezas no pasan la prueba de inspección). Ver figura 4.16.

Figura 4.16. Tiempo de proceso y asignación de FlowItem por probabilidad dentro del centro de inspección.

. Hay una última cosa que hace falta para cumplir con los requisitos de este segundo modelo básico, usar un transporte para mover los FlowItems de un objeto a otro. Para satisfacer este requisito, se definen nuevos conceptos que requieren de su atención. Sin embargo, las instrucciones son tan simples como determinar el(los) objeto(s) adecuado(s), elegir las listas de selección de opciones correctas, y después distinguir y editar las alternativas adecuadas que permitan cumplir con las necesidades del modelo.

Capítulo 4. Construcción de un Modelo Paso a Paso.

4.5. PASO 4. AÑADIENDO TASK EJECUTERS (OPERATOR Y DISPATCHER) AL MODELO Para poder desarrollar este punto, el modelo ya debería estar funcionando correctamente. Ahora vamos a añadir otro nivel de complejidad al sistema agregando ejecutores de tarea o recursos móviles para transportar los FlowItems del Processor (Inspector) al Sink donde salen las piezas del sistema y hacia el primer segmento del Conveyor quien conduce las piezas a reproceso. El objetivo de este apartado es en primer lugar que usted logre un mayor entendimiento de cómo es que los recursos ejecutores de tareas son empleados para el transporte de FlowItems, y el segundo punto a tratar será demostrar un principio de modelado que muestra lo fácil que es añadir nuevas funcionalidades a su modelo sin tener que cambiar ninguna funcionalidad anterior. En el segundo capítulo, se describió lo que es un ejecutor de tareas o recurso móvil y se mencionaron en términos generales algunas de sus funciones, pero aquí vamos a describir cómo podemos hacer uso de este recurso. Primero, arrastrar un objeto Operator hacia el área de trabajo. De todos los recursos móviles disponibles (Crane, Transporter, Robot, etc.) el Operator es uno de los más utilizados en los modelos comunes, usualmente se utiliza para modelar un recurso humano de algún tipo. Este es el objeto que habitualmente se emplea para simular un empleado que debe participar en la elaboración o fabricación de un FlowItem y también puede ser utilizado para transportar FlowItems de un recurso fijo a otro, que es para lo que se usará en este modelo. Ahora que tiene a un Operator en el modelo es el momento de asignarle un recurso fijo el cual le indicara su tarea. Haga una conexión de puerto central (recuerde que una opción para activar esta función es manteniendo presionada la letra “S” del teclado mientras se da clic en ambos objetos) entre el Processor que funciona como inspector y el Operator. Después de haber realizado lo anterior usted puede ir a la pestaña Flow de la ventana de propiedades del Processor (inspector) y habilitar la opción Use Transport. Esto activará una nueva lista de selección denominada Request Transport From, esta le indica al Processor a que recurso móvil se asignará la tarea de transportar. Al hacer clic en el botón de edición de parámetros ( ) se dará cuenta que la opción por defecto llama al Port Number 1 como un objeto conectado al puerto central número 1. Si fuese necesario, aquí se permite especificar exactamente qué puerto central buscará el comando para determinar el uso de un ejecutor de tareas alterno. Dado que en este Processor tenemos hecha una

87

88

SIMULACIÓN CON FLEXSIM

sola conexión central, podemos dejar el valor de 1 mismo que aparece como predeterminado. Ahora bien, cuando se ejecuta el modelo nuevamente en lugar de ver que los FlowItems se pasan de un objeto a otro de manera automática, verá que el operador recoge y entrega los FlowItems correctamente en su destino. Usted puede obtener algunas variaciones interesantes en el comportamiento del recurso móvil si mueve los objetos fijos a diferentes puntos del área de trabajo. Cuando se utiliza un recurso móvil para el transporte, las distancias a recorrer pueden ser de mucho interés en el análisis del modelo. Lo anterior funciona muy bien en situaciones en las que se sabe que sólo es necesario un recurso móvil para ejecutar una tarea, pero ¿qué pasa si usted tiene un equipo de operadores que desea utilizar? o ¿cuándo se necesita agregar o quitar rápidamente miembros de ese equipo? esto se puede lograr fácilmente con el uso del objeto Dispatcher. El objeto Dispatcher interactúa con los recursos móviles de un modo especial, pues permite que las tareas que están siendo generadas por un recurso fijo se deleguen a un grupo de recursos móviles, poniéndolos a disposición de un recurso fijo siempre que estos estén disponibles. Por defecto, las tareas son asignadas a los recursos Figura 4.17. Conexión móviles de acuerdo a como de un Dispatcher. estas vayan apareciendo, pero los modeladores pueden especificar sus propias estrategias en el Dispatcher si así lo desean. Para configurar un equipo de Nota: conecte del recursos móviles como se muestra en la figura 4.17, arrastre un Dispatcher y dos o Dispatcher a los Operadores no al más Operators al área de trabajo. Conecte con la tecla “A” presionada, al Dispatcher revés, de lo con los Operators. A continuación, conecte con la tecla “S” presionada, al Dispatcher contrario los con el primer Queue. Para terminar, entre a la ventana de propiedades del Queue y Operators no se en la pestaña Flow active Use Transport. Ahora que hemos terminado, el equipo de moverán.

Capítulo 4. Construcción de un Modelo Paso a Paso.

89

recursos móviles funcionará adecuadamente. Si desea intentar diferentes configuraciones, puede agregar o quitar recursos móviles en su modelo en cualquier momento y ver cuáles son los resultados. Con la misma facilidad con la que conecto Operators puede conectar cualquier otro recurso móvil.

4.6. PASO 5. INFORMACIÓN ESTADÍSTICA DE LOS OBJETOS Y TEXTOS VISUALES Como se ha comentado con antelación, a través del uso de una gráfica lineal incluida dentro de una ventana Dashboard, es posible visualizar informes estadísticos rápidos sobre la puesta en marcha del modelo. El objeto que aquí se observa es una gráfica lineal de nombre Time in System. Este tipo de grafico es un recurso especial de FlexSim, se utiliza para registrar y visualizar la información estadística de los FlowItems mientras el modelo se ejecuta. La gráfica Time in System registra el tiempo en el que un FlowItem deja el modelo y el tiempo total que permaneció en el modelo y con ellos se crean series de puntos gráficos. En su modelo, cree una ventana Dashboard y arrastre de la biblioteca de gráficos una de tipo Time in System vs Time a la ventana emergente, después ejecute el modelo nuevamente y observe como cada FlowItem es graficado con un punto rojo. Note que conforme se avanza en el tiempo, cuatro series de puntos siguen una tendencia exponencial, que representa los tiempos de salida y permanencia de los cuatro FlowItem diferenciados en el sistema con los ItemTypes (1, 2, 3 y 4). Véase la Figura 4.18. Finalmente analice la tendencia de los puntos rojos y trate de pensar en una solución a este problema. Así como agregó una gráfica para representar el tiempo de permanencia de los FlowItems, es posible agregar diferentes variables para cada objeto del modelo, pruebe con otros objetos y analice los resultados.

Figura 4.18. Utilización del gráfico Time in System dentro del modelo de simulación.

90

SIMULACIÓN CON FLEXSIM

Por otro lado, el Text (herramienta visual) es otro recurso especial, que se puede utilizar para mostrar información de un objeto mientras se ejecuta el modelo. En la actualidad, las herramientas visuales pueden ser el recurso más versátil de la biblioteca de objetos. Se puede utilizar como apoyo visual para crear elementos en 3D como: muros, contenedores de objetos, pantallas de texto e incluso estos recursos son el medio por el cual podemos insertar el diseño de un plano completo creado en AutoCAD. Si utilizamos alguna herramienta visual como pantalla de texto podrá ver información sobre los objetos o bien podrá realizar un seguimiento de datos personalizado. Para hacer un ejercicio rápido, sólo tiene que arrastrar un objeto de nombre Text dentro del modelo, como puede apreciarse al colocarlo en el Layout se muestra el texto “Hello”, dé doble clic en el para tener acceso a la ventana de propiedades y en la opción edición de parámetros modifique el nombre si lo desea. También es posible vincular a un Text con otros recursos a través de los puertos de conexión central. Esto permite que una herramienta visual haga referencia a otros recursos y muestre sus estadísticas, intente probar con esta alternativa. Para concluir es prudente mencionar que de todos los objetos en FlexSim se pueden obtener estadísticos y gráficos de las variables que los definen. Al dar clic izquierdo en cualquier objeto, la ventana Quick Properties muestra información acerca del Throughput (rendimiento), Content (contenido) y Staytime (tiempo de permanencia) en que se encuentran los recursos mientras el modelo se compila. Todas las operaciones de un recurso están en un estado y punto particular del tiempo, el estado dependerá del tipo de recurso tal como se muestran en las imágenes de la figura 4.19. Además, se puede almacenar la información histórica de los eventos ocurridos en un recurso respecto a un intervalo de tiempo dado, o bien si lo desea, puede programar el registrador de datos para que éste sea actualizado en tiempo real mientras se ejecuta su modelo, esto es muy útil para ver lo que está sucediendo en el momento.

Figura 4.19: Estadísticos de algunos recursos y gráfica de pastel que muestra sólo 21 estados de los 50 disponibles en un objeto.

Capítulo 4. Construcción de un Modelo Paso a Paso.

91

Figura 4.20: Imagen ilustrativa del modelo final.

5

CAPÍTULO 5.

Aplicaciones y Usos Variados

ESQUEMA DEL CAPÍTULO 5.1 INTRODUCCIÓN 5.2 EJEMPLO: 1.1. SISTEMAS PULLED O PUSHED Y EL USO DE LA DISTRIBUCIÓN BERNOULLI 5.3 EJEMPLO: SISTEMA DE ENRUTAMIENTOS COMPLEJOS 5.4 EJEMPLO: LÓGICA FLEXSCRIPT Y PRIORIDAD DE USO 5.5 EJEMPLO: LOS OBJETOS TASK EXECUTERS Y LA INTERRUPCIÓN DE TAREAS 5.6 EJEMPLO: RECURSOS MÓVILES Y RUTAS DE VIAJE 5.7 EJEMPLO: USO DEL RECURSO COMBINER E IMPORTACIÓN DE DATOS DE EXCEL 5.8 EJEMPLO: PROGRAMACIÓN DE AVERÍAS Y MANTENIMIENTO EN LOS EQUIPOS CON LA HERRAMIENTA MTBF/MTTR OBJETIVOS DE APRENDIZAJE Al finalizar el capítulo, el lector tendrá las siguientes habilidades: 1. Establecerá estrategias de enrutamiento a través del sistema Pull. 2. Podrá ejemplificar la utilización de una Tabla Global. 3. Se introducirá al lector en el lenguaje de programación FlexScript para crear lógica personalizada en un modelo de simulación. 4. Conseguirá conectar diferentes recursos móviles mediante el uso de la opción Direct Reference, sin necesidad de hacer conexiones centrales. 5. Tendrá un panorama más amplio sobre el uso de los recursos móviles y las bondades de los Racks. 6. Será capaz de configurar una Red de Nodos para indicar la ruta de viaje de un recurso móvil. 7. Logrará manipular bases de datos de Excel a través de un objeto Combiner para hacer empaques personalizados sobre la marcha. 8. Establecerá un programa de averías y mantenimiento. 9. Aprenderá como dividir y desempaquetar FlowItems.

94

SIMULACIÓN CON FLEXSIM

5.1. INTRODUCCIÓN En esta sección se configura un sistema Pull, se hace uso de la aplicación Global Table para definir enrutamientos, y se programan Task Sequences. Además, usted tendrá la oportunidad de trabajar con Network Nodes, manipular puntos de inflexión y Break Task para tener mayor control sobre las tareas de un recurso móvil. Adicionalemnte, aprenderá a utilizar la función Multiple Table Excel Import para importar bases de datos desde un archivo con extensión .xls o bien .xlsx. Así mismo, logrará contener, unir, o agrupar FlowItems, o bien desempaquetar y/o cortar los mismos. Finalmente, se plantea la programación de averías y mantenimiento mediante la manipulación de los parámetros MTBF y MTTR en los objetos. Al finalizar esta sección, podrá realizar múltiples ejecuciones y análisis de distinto escenarios con la utilización de distintos objetos hasta ahora nuevos para usted. En este orden de ideas, se presentarán los conceptos claves necesarios para los siete ejercicios aquí citados, se describe el problema a resolver y se guía al usuario en la construcción de cada modelo, tenga en cuenta que durante este proceso se estará haciendo uso de una variedad amplia de Pick Lists.

5.2. EJEMPLO: SISTEMAS PULLED O DISTRIBUCIÓN BERNOULLI

PUSHED

Y

EL

USO

DE

LA

Hasta este momento sólo hemos tratado con escenarios Push, donde los recursos intermedios en operación deciden la forma en que deben enviarse FlowItems al siguiente recurso después de ser liberados o empujados a través de su puerto de salida. En la mayoría de los modelos, este es exactamente el comportamiento que usted necesitará, por tanto, es este el modo predefinido en el comportamiento de los recursos fijos. Sin embargo, es posible encontrarse con escenarios difíciles de modelar que pueden ser simplificados mediante el uso de un sistema Pull en lugar de un Push. El modelo del Ejemplo 3 será construido bajo criterios distintos a los conceptos establecidos en el ejercicio anterior (Ejemplo 2). Lo que usted aprenderá es: 1. Cómo usar la distribución Bernoulli para asignar atributos. 2. Cómo establecer estrategias de enrutamiento a través del sistema Pull, basada

Capítulo 5. Aplicaciones y Usos Variados.

en el ItemType de un FlowItem. Ejemplo 3. La empresa Electronic S.A. de C.V., elabora en una de sus líneas de producción dos componentes electrónicos distintos, mismos que necesitan ser revisados por cinco centros de inspección antes de enviarlos al almacén de producto terminado. Descripción:    

 

Los componentes electrónicos son creados en un Source con un tiempo entre llegadas exponencial (0, 30, 1). Los componentes tipo 1 son creados el 80% del tiempo y los del tipo 2 el 20%. Antes de entrar a los centros de inspección, todos los componentes son almacenados en un Queue. Existen dos centros de inspección para los componentes del tipo 1 y tres para los componentes del tipo 2. Después de la restricción anterior, los componentes entrarán al primer centro de inspección disponible. El tiempo necesario en un centro de inspección es de 120 a 150 segundos uniformemente distribuidos. El producto terminado será almacenado en un Sink.

5.2.1. Conceptos Concepto 1: Distribución de Bernoulli. La distribución de Bernoulli es única ya que no se traduce en números que caen a lo largo de una curva, sino que da lugar a uno de dos números con probabilidades asignadas a ellos. En este entendido, esta es utilizada para modelar una ocurrencia aleatoria que tiene dos posibles resultados como una prueba de pasa/no pasa, éxito/fracaso, 1/2, verdadero/falso, etc. Para tener una mejor idea, estudiaremos los parámetros de Bernoulli necesarios para su funcionamiento: bernoulli(num prob, num succeed-value, num fail-value, [num stream])

95

96

SIMULACIÓN CON FLEXSIM

La probabilidad de ocurrencia debe ser establecida como un parámetro con un valor porcentual entre 0 y 100. Si es establecido el valor de 80, este indicará el porcentaje del tiempo en que deberán aparecer números con succeed-value (valor de éxito). Y los números con fail-value (valor de fracaso) quedarán establecidos como el resultado de la diferencia entre 100 y 80. Por ejemplo, si hubiésemos tecleado la instrucción bernoulli(80, 1, 2, 1), obtendriamos como resultado un valor de 1 el 20% del tiempo, y un valor de 2 el resto del tiempo (20%), mientras que el último 1 indicará el valor de la semilla. Tenga en cuenta que en este ejemplo, la distribución Bernoulli únicamente puede devolver uno de esos dos números, ya sea el 1 o el 2. Los valores de éxito y fracaso pueden ser asignados a cualquier otro tema, pues no se limitan sólo al ejemplo anterior.

Concepto 2: Sistemas Pulled o Pushed. Un sistema Pull es definido cuando los recursos fijos intermedios de una cadena de objetos evalua los FlowItem disponibles antes de jalarlos través de los Input Ports. Un ejemplo claro sería imaginar que un Processor arrebata FlowItems de un Queue que lo antecede, siempre y cuando los FlowItems cumplan con ciertos requisitos establecidos por el Processor. La forma en que trabajan los sistemas Pull y Push es similar, pero existen algunas diferencias significativas. En el sistema Push, el primer evento que ocurre es OnEntry (una entrada) causada por un FlowItem que entra a un recurso, sin embargo en el sistema Pull lo primero que debe ocurrir es que se tenga disponible un FlowItem. Posteriormente, una serie Pull Requirement es evaluada; estos requisitos establecen reglas específicas definidas por el usuario, las cuales indican las características que un FlowItem debe poseer antes de ser jalado hacia un recurso. Si los FlowItems cumplen con los requisitos establecidos, estos son jalados hacia el recurso. El tiempo de retardo está asociado con cualquier retardo de viaje que puede ser aplicable a la situación, así que por ahora no se preocupe. Después de lo anterior, la ejecución de la simulación sigue siendo Push hasta después del evento OnExit (salida). Cuando los FlowItems son empujados, OnExit es el último evento que ocurrirá en el recurso fijo, por tanto, la evaluación del campo Pull Requirement sucede justo después de OnExit. La lista de selección de opciones Pull Requirement se encuentra contenida en la pestaña Flow de todos los recursos fijos y se utiliza entonces para indicar al objeto por cuál de sus puertos de entrada puede pasar un FlowItem disponible.

97

Capítulo 5. Aplicaciones y Usos Variados.

5.2.2.

Creación del modelo Dentro del área de trabajo de FlexSim, arrastre de la biblioteca de objetos los recursos necesarios. Ordénelos y conéctelos tal como se muestra en la figura 5.1, guarde el modelo con el nombre de Ejemplo 3. Figura 5.1. Modelo terminado del ejemplo 3.

Programación Abra la ventana del Source y programe la frecuencia de llegadas de manera exponencial con los parámetros de localización (0), escala (30) y semilla (1). Después diríjase a la pestaña Triggers de este mismo objeto y, dentro de la lista de selección de opciones OnCreation, seleccione Set Type, Name, or Label, y en el campo de texto Type escriba la instrucción bernoulli(80, 1, 2, 1) para indicar la creación de dos ItemType distintos que identificaran a los dos componentes electrónicos en diferentes proporciones. Debajo de esta última instrucción, dé clic en el ícono agregar ( ) para darle un color diferente a cada tipo de componente electrónico. Al hacer clic en el ícono verde, seleccione Set Color By Case, esto desplegará una ventana

Figura Programación Source.

5.2. del

98

SIMULACIÓN CON FLEXSIM

donde podrá identificar los colores para los dos distintos ItemTypes creados con la distribución Bernoulli. Asigne un color para cada ItemType y dé clic en Apply y Ok. Véase la figura 5.2.

Otra programación importante debe hacerse dentro de cada uno de los cinco Processors. Primero programe el tiempo de proceso en una distribución uniforme con parámetros (120, 150, 0), después pase a la pestaña Flow y active la casilla Pull Strategy. Para la primera lista de selección de opciones aquí mostrada, deje el nombre por defecto Any Port para que cuanquier puerto de entrada este disponible. Dentro de la segunda lista de selección llamada Pull Requirement, elija la opción Specific ItemType y defina el número de ItemType que será recibido en la máquina para ser procesado (ver figura 5.3). Para los dos primeros equipos especifique 1 y en los siguientes tres equipos indique el número 2, esto permitirá la entrada unicamente de los FlowItems que contengan el número específico de ItemType que usted determinó. Con esos pequeños cambios usted logrará modelar su pequeño sistema bajo las condiciones establecidas en un inicio.

Figura 5.3. Programación del tiempo de proceso y estrategia Pull.

Capítulo 5. Aplicaciones y Usos Variados.

5.3. EJEMPLO: SISTEMA DE ENRUTAMIENTOS COMPLEJOS Ahora que hemos aprendido más sobre ItemTypes, Labels y enrutamientos, sigamos con la explicación de Global Table para definir flujos de FlowItems en distintas direcciones; estos son muy comunes en diversos modelos.

Lo que usted aprenderá es: 1. Cómo ejemplificar la utilización de una Global Table o tabla global en el enrutamiento de productos. 2. Cómo hacer uso de un ItemType y una Label para darle seguimiento a un FlowItem que entrará a una estación de trabajo.

Ejemplo 4. En una célula de manufactura existen tres productos diferentes y necesitan ser procesados en distintas estaciones de trabajo antes de abandonar el sistema. Cada producto tiene su propia ruta de operaciones.

Descripción:  

 

Tres productos diferentes (distribuidos uniformemente) entran en una célula de manufactura compuesta por 5 estaciones de trabajo. Dentro de la célula de trabajo, los productos son procesados en un orden específico: o El producto 1 necesita ser procesado en las estaciones 1, 3 y 2. o El producto 2 necesita ser procesado en las estaciones 1, 2 y 4. o El producto 3 necesita ser procesado en las estaciones 2, 4, 3 y 5. Use una Global Table para asegurar que los productos sean enviados a las estaciones de trabajo en el orden apropiado. Utilice un Queue como almacén de producto en proceso.

99

100

SIMULACIÓN CON FLEXSIM

Actividades extras: 1. Compruebe si es posible cambiar todos los FlowItems dentro del modelo a un color común en función de su etapa de operación. 2. Utilice una agenda de llegadas para poner a prueba las rutas de cada tipo de producto por separado. 5.3.1. Conceptos Concepto 1: Global Table Nota: es preferible utilizar números tanto en Labels como en Tablas siempre que sea posible, ya que este tipo de datos son más fáciles y rápidos de manipular.

En el Ejemplo 2, se dio una pequeña introducción al uso de las tablas globales para la utilización de un conjunto de datos derivados empíricamente como una distribución estadística. Ahora haremos uso de estas en un conjunto de datos de una forma más natural como los podríamos ver en Excel. Al igual que las Labels, las Tablas pueden contener información como texto y datos numéricos. Los comandos que se utilizan para manipular los datos de una celda, siguen un patrón similar a los comandos empleados para hacer referencia a una Label. Es posible utilizar gettablenum para consultar datos de una celda. Para usar este comando debe escribir: gettablenum("table name", row_number, column_number)

Tenga en cuenta que, al igual que el comando Label, el primer parámetro determina donde está la Global Table, así que escriba correctamente el nombre porque la tabla está referenciada por este mismo y no como un objeto. Las comillas en el nombre de la tabla son obligatorias. Los siguientes dos parámetros definen las coordenadas de la celda donde se desean consultar los datos: el primero establece el número de fila y el segundo el número de la columna.

El comando que establece el valor de una celda es muy similar al comando gettablenum. Usted debería escribir: settablenum(“table name”, row_number, column_number, desired_value)

Capítulo 5. Aplicaciones y Usos Variados.

101

Tal como sucedió en los comandos setLabel, el parámetro ubicado al final de la instrucción desired_value (valor deseado) especifica el valor que tomará la celda.

Existen comandos los caules devuelve o insertan un valor de tipo string segun la fila o columna especificada en una tabla, tal como se muestra respectivamente: gettablestr( “table name”, row_num, column _num ) settablestr( “table name”, row_num, column_num, string )

pero no son tratados en este ejemplo.

5.3.2. Creación del modelo Después de las consideraciones anteriores, iniciemos con la creación del ejemplo 4. Observe la figura 5.4, introduzca los recursos necesarios y conéctelos en el orden correcto. Note que el Queue está conectado con el Source, con cada una de las 5 estaciones de trabajo y con el Sink.

Figura 5.4. Distribución y conexiones de los puertos del modelo.

Asegúrese de que su diseño luzca exactamente como el que se muestra en la figura anterior. El primer procesador debe estar conectado en el puerto de salida uno del Queue, el segundo procesador en el segundo puerto de salida, y así sucesivamente hasta que el Sink se encuentre en el sexto puerto de salida.

Nota: tanto los puertos de entrada como los de salida de las diferentes estaciones deberán estar conectados al Queue.

102

SIMULACIÓN CON FLEXSIM

Si usted edita los nombres de los recursos puede colocar cualquier otra descripción, pero recuerde que no se pueden asignar dos nombres iguales y tampoco se admite el uso de caracteres reservados como acentos y algunos otros.

Programación Antes de construir el modelo de este ejemplo, considere los siguientes consejos puesto que pueden no ser evidentes en la descripción: Usted deberá utilizar una Global Table para indicar las decisiones de enrutamiento que cada ItemType tendrá en sus distintas etapas de su proceso. Los datos en las celdas de la Tabla deberán representar los números de cada puerto. También es necesaria una etiqueta en los FlowItems, cuyo valor será incrementado justo después de que una etapa del proceso se ha completado. Para poder leer el contenido correcto de la Tabla existen muchas alternativas, el ejemplo aquí descrito muestra una alternativa eficiente.

Source Dado que las frecuencias de llegada (Inter-Arrivaltime) ahora no son de nuestro interés dejemos ese campo como está y pasemos a la pestaña Triggers. Dentro de esta pestaña primero vamos a crear los tres productos diferentes (distribuidos uniformemente) quienes entrarán a la célula de manufactura. Abra la lista de selección de opciones OnCreation y seleccione Set Type, Name or Label. Al momento usted verá una nueva ventana que ya tiene definida la instrucción Set ItemType con una distribución uniforme (1, 3), así que no es necesario hacer ningún cambio, dado que el comando ya especifica la asignación de tres ItemTypes distribuidos uniformemente. Después de haber creado tres productos diferentes, vamos a asignarles a cada uno de estos una Label que iniciará con “0”, y que se autoincrementara conforme avancen los productos en cada etapa del proceso. En esta misma pestaña busque la lista de selección de opciones OnExit justo encima de la lista anterior y seleccione la alternativa Create and Initialize Label. Dentro de la nueva ventana emergente asigne el nombre “Etapa” a su nueva Label y defina el valor inicial de “0”. Para no pasar por alto ningún detalle, observe la figura 5.5.

Capítulo 5. Aplicaciones y Usos Variados.

103

Figura 5.5. Creación de tres productos y una etiqueta inicial.

Antes de continuar con la programación del Queue, se deberá crear una Global Table, le servirá como guía para que los productos sean enviados a las distintas estaciones de trabajo en el orden correcto.

Global Table Diríjase a la Barra de Herramientas y dé clic en Tools. Ubique el signo + de color verde y seleccione Global Table. Al momento será abierta una nueva tabla, en la que agreguará tres filas y cinco columnas. Llene las celdas con los datos que corresponden al flujo de los productos por los distintos centros de operaciones (ver figura 5.6). Recuerde que los datos insertados en las celdas de esta tabla representan los números de cada puerto. Por ejemplo, si el valor es 1 se indica que el producto deberá salir por el puerto uno con dirección a la “Estacion_1”, si es 3 el producto saldrá por el puerto tres y llegará a la “Estacion_3” y así en suceción hasta que el producto salga del sistema por el puerto 6 con dirección al Sink.

Figura 5.6. Creación de una Global Table.

104

SIMULACIÓN CON FLEXSIM

El nombre asignado a la tabla global es “TablaDeAsignacion”. Usted puede usar cualquier otro nombre pero recuerde que es recomendable utilizar un nombre corto y bastante claro pues será empleado como referencia en algunos comandos posteriores. Queue El almacén de producto en proceso será el responsable de incrementar los valores de las Labels para indicar la etapa a la que se dirige cada producto. Así pues, cuando un FlowItem entra al Queue por primera vez, el valor de la Label de 0 pasará a 1 y si regresa por segunda vez al Queue después de alguna estación de trabajo, este valor será incrementado nuevamente una unidad más, y así tendremos la referencia de la etapa a la que se dirige nuestro producto. Para programar estos incrementos, abra la ventana de propiedades de este recurso y dirijase a la pestaña Triggers, en la lista de selección OnEntry elija Increment Value, y en la opción Increment opte por el comando label(item, "labelname"); dentro de este comando sustituya el nombre “labelname” por el de “Etapa” para hacer referencia a la Label que ya hemos definido con anterioridad. Finalmente dentro de la celda de texto editable (by) escriba el valor de 1. Ver figura 5.7.

Figura 5.7. Comando que incrementa una unidad en la Label “Etapa” cada vez que un FlowItem entre al Queue.

La segunda instrucción importante dentro del Queue debe programarse en la pestaña Flow. Aquí es donde se indicará la salida de los distintos productos a las diferentes estaciones de trabajo según corresponda a su etapa de operaciones. De la lista de selección de opciones Send To Port elija By Global Table Lookup. Dentro de la nueva ventana emergente verá tres listas de selección diferentes, en la primera llamada Table Name, escoja el nombre de la tabla que usted ya ha diseñado con anterioridad “TablaDeAsignacion”. En la lista Row elija el comando getitemtype(item) y en la última lista Column seleccione getlabelnum(item, “label”), en este último comando sustituya el nombre de “label” por el de “Etapa” (ver figura 5.8). Con la instrucción anterior, logrará que el Queue busque una Tabla Global de nombre “TablaDeAsignacion” que servirá como referencia para asignar la dirección

Capítulo 5. Aplicaciones y Usos Variados.

105

de los distintos productos, el comando establecido en Row indica la posición de la fila en la tabla global y el comando definido en Column refiere la posición de la columna. Así pues, si dentro del Queue existe un FlowItem con un ItemType de valor 1 y con una Label también de valor 1, el Queue sabe que se trata del Producto número 1 y que está por entrar a la etapa 1, así que libera inmediatamente a ese producto por el puerto de salida 1 con dirección hacia la Estacion_1, de esta manera el Queue no tendrá ningún problema al intentar enviar los productos hacia las diferentes estaciones de trabajo o hacia la salida, independientemente del tipo de producto y etapa a la que se dirijan. Dado que no es solicitada la programación de los tiempos de operación ni alguna otra tarea dentro de las estaciones de trabajo, todos lo Processors se mantienen sin editar. Con esto, el modelo deberá estar funcionando adecuadamente. Sin embargo hay dos actividades más que debemos resolver.

Figura 5.8. Asignación de productos a las distintas estaciones de trabajo mediante la instrucción Send To Port.

1. ¿Es posible cambiar todos los FlowItems dentro del modelo a un color común en función de su etapa de operación? La respuesta a esta pregunta es “Sí”. Para hacerlo regrese nuevamente al Queue, busque la pestaña Triggers, y dentro de la lista OnExit seleccione Set Color By Case. Agregue los comandos necesarios como se muestra en la figura 5.9. Así, si la etapa de cualquiera de los tres productos es 0, el color será café y conforme el producto avanza en sus distintas etapas del proceso los productos toman diferentes colores en el siguiente orden; rojo, verde, azul y amarillo. El número de colores distintos que toma cada producto depende del número de etapas que este mismo recorrió.

106

SIMULACIÓN CON FLEXSIM

Figura 5.9. Edición de colores

2. Utilice una agenda de llegadas para poner a prueba las rutas de cada tipo de producto por separado.

Para revisar el flujo de cada producto por separado (véase figura 5.10.), abra la ventana de propiedades del Source y en la primer pestaña busque la lista de nombre Arrival Style y dentro elija la opción Arrival Sequence. Si así lo desea, personalice el nombre de los FlowItem con el texto “Producto”. Con esto, cada que ejecute su modelo verá sólo el flujo de un FlowItem de nombre “Producto” por los diferentes recursos del sistema. Figura 5.10. Programación del Estilo de Arribos. La opción es útil para observar el recorrido completo de cada producto por separado haciendo clic en cada que lo desea y así garantizar el flujo adecuado.

Capítulo 5. Aplicaciones y Usos Variados.

5.4. EJEMPLO: LÓGICA FLEXSCRIPT Y PRIORIDAD DE USO El siguiente modelo (Ejemplo 5) se enfoca en el uso eficiente de los Task Executers (Ejecutores de Tareas) mediante el empleo de valores de prioridad en la secuencia de tareas. Además, se abordará de manera puntual el lenguaje de programación FlexScript.

Lo que usted aprenderá es: 1. Cómo conectar diferentes recursos móviles mediante el uso de Direct Reference, sin necesidad de hacer conexiones directas. 2. Cómo referenciar a objetos a través del uso de los nodos del árbol FlexSim. 3. Cómo indicar la prioridad que tienen las diferentes tareas asignadas a un operario. Ejemplo 5. A un primer almacén llegan piezas que deberán ser enviadas mediante un operador hasta el segundo almacén donde, de manera automática, pasan a las diferentes máquinas disponibles. Para que las máquinas funcionen es necesario que un operador más las opere. Descripción:   

 



Dentro del Source se tiene programado un total de 20 lotes con 5 piezas para su disposición (Arrival Sequence). Las piezas llegan a un primer Queue con capacidad de 5 unidades y necesitan ser transportadas por un operador al segundo Queue disponible. Al segundo Queue se le asignará una instrucción para establecer un punto de reorden. Así, el primer operario podrá reabastecer piezas siempre que la cantidad contenida en este almacén caiga a uno. La asignación de las piezas a las diferentes máquinas se hará considerando la primera máquina disponible. Las máquinas tienen un tiempo de preparación de 2 segundos y las piezas deberán ser procesadas cada 20 segundos. Un operador distinto al anterior deberá estar presente durante el tiempo de preparación de cada máquina. Después de que una pieza fue procesada, esta saldrá del sistema.

107

108

SIMULACIÓN CON FLEXSIM

5.4.1.

Conceptos Concepto 1: Generalidades de FlexScript Como se ha mencionado en los capítulos 3 y 4 de este libro, y tal como lo describe Beaverstock et. al., 2012, capítulo 12 Customizing Model Logic., FlexSim utiliza un lenguaje de programación llamado FlexScript para crear lógica personalizada en un modelo de simulación. La sintaxis de esta es semejante al lenguaje de programación C / C ++, por tanto, cualquiera que esté familiarizado con C/C ++ podrá comenzar rápidamente con la escritura de códigos en este ambiente. Para tener acceso a esta ventana de trabajo, haga clic en el botón edición de código ( ) de alguna lista de selección de opciones. Así mismo, en el apartado 3.3.2, se hace referencia al ícono Sampler ( ), el cual activa una ventana emergente con expresiones sugeridas; refiere variables, etiquetas u otras propiedades de un objeto. Algunas consideraciones para usar FlexScript son: – – –

El lenguaje es sensible a mayúsculas: “A” no es igual a "a", y Source1 no es lo mismo que source1. No se requiere un formato específico: Para obtener un código más "legible" es precindible el uso de espacios, tabulaciones y retornos de línea. Las cadenas de texto se introducen entre comillas con el fin de poner un indicador de texto específico. Por ejemplo, “Pieza Defectuosa” será tratada como una cadena. Nota: es importante tener en cuenta que el corrector de errores de código no revisa la sintaxis de los campos de texto.

– – –

–

Los paréntesis hacen una llamada a la función, y las comas separan los argumentos de la función. Por ejemplo, moveobject(object1, object2);. Un enunciado completo (función o comando) siempre debe terminar con un punto y coma (;). Los paréntesis también se pueden utilizar libremente para hacer explicaciones asociadas a matemática y lógica: Por ejemplo, ((7*x)+1). La cantidad de paréntesis abiertos y cerrados siempre será la misma. Si usted pone su cursor junto a un paréntesis abierto, FlexSim lo destacará, mientras que al colocar el cursor al lado de un paréntesis de cierre se destacará el de apertura. Las llaves {} se utilizan para definir un bloque de instrucciones: Los bloques de instrucciones también definen un ámbito de aplicación y se usan con instrucciones if, for, y switch.

Capítulo 5. Aplicaciones y Usos Variados.

–

– – – –

Para comentar una línea se emplean // seguidas de un comentario: Los comentarios se muestran en texto verde y son ignorados por FlexSim. El área de comentarios termina con \\. Los comentarios multi-línea comienzan con /* y terminan con */. Es mejor no utilizar espacios o caracteres especiales en definiciones de nombres: El carácter de subrayado ( _ ) es el único carácter especial "seguro". Los nombres pueden incluir números pero no pueden comenzar con un número. Por ejemplo, Almacen_34 es aceptable pero 34Almacen no lo es. Evite acentuar nombres de variables declaradas: El acento impide declarar adecuadamente una nueva variable en FlexScript.

Variables FlexScript Hay diferentes tipos de variables; cada una determina qué tipo de datos puede almacenarse, como se lista a continuación:    

Integer: Declarada como int, sólo contener valores enteros (números naturales, sus negativos y cero). Double: Declarada como double, sólo contener el conjunto de los números reales, tal como 6.34, -3.56, etc. String: Declarada como string, es un cadena de texto definida entre comillas, por ejemplo, “mi primer modelo”. Treenode: Declarada como treenode, contiene referencias para los nodos del árbol FlexSim ( ).

Antes de que una variable sea utilizada esta debe ser creada o declarada. Una declaración debe contener tipo y nombre de la variable. Por ejemplo, para declarar una variable tipo double de nombre “resultado” que contenga el resultado de una muestra correspondiente a una distribución exponencial, se enuncia en la siguiente forma: double resultado; resultado = exponential(0.0, 15.0, 0);

o bien esta misma instrucción podría declararse en una sola línea: double resultado = exponential(0.0, 15.0, 0);

109

110

SIMULACIÓN CON FLEXSIM

Otros ejemplos son: int almacen = 50; double altura = 1.75; string lugar = "centro de distribución"; treenode ProductoEnProceso = node("/Queue8", model());

Operadores del lenguaje de programación FlexScript Los operadores en Flexsim siguen reglas de programación C++. Los mecanismos de operación son utilizados para manipular valores y variables. Algunos de los comandos le resultaran familiares, tales como los símbolos matemáticos, +, -, /, y *. Al dar clic en edición de código ( ) de cualquier objeto, usted podrá ver una ventana emergente con listas de comandos matemáticos más avanzados a la izquierda de la pantalla principal de FlexSim. Para más información véase Help>User Manual>Contents>FlexSim Coding> Writing Logic in FlexSim.

Comandos FlexScript FlexScript contiene una amplia variedad de comandos de fácil acceso para referenciar u obtener información de nodos particulares en la estructura de árbol. Estos son usados para ejecutar otras funciones, por ejemplo, interactuar con Excel. Algunos ejemplos son: =, +=, -=, *=, etc.

Referencia a los objetos La estructura de árbol de FlexSim da a los objetos relaciones jerárquicas entre sí. Estas relaciones permiten hacer referencia a objetos de forma rápida y sencilla utilizando los comandos y palabras clave. Hay dos terminos importantes al hacer referencia a un sólo objeto:  

cualquier recurso que posea ese código hará referencia al objeto presente. item: da referencia del FlowItem actual, al objeto que solicitó un current:

Capítulo 5. Aplicaciones y Usos Variados.

comportamiento personalizado durante la ejecución. Así mismo, un nodo de objeto puede hacer referencia a través de una ruta de acceso y mediante su conexión a otros objetos. Un nodo en cualquier parte del modelo también puede ser referenciado por su rango dentro del árbol a través de la función Rank(), que toma el nodo contenedor como primer argumento, y el número de rango como el segundo. Por ejemplo, para hacer referencia al tercer FlowItems dentro de un Queue y usarlos en una variable usted deberá expresarse como sigue: treenode third = rank(current, 3);

Un nodo de objeto también puede ser referenciado por su primera posición o la última en un árbol. Para obtener una referencia del primer subnodo de un árbol se puede utilizar la función first(), que toma al nodo contenido como el único argumento. La función last() trabaja de la misma manera, pero devuelve una referencia al último nodo. La instrucción first(current) en un Queue con lógica de operación Primeras en Entrar Primeras en Salir (FIFO, por sus siglas en inglés) por defecto se referirá al FlowItem listo para salir. Las referencias adicionales para los objetos se hacen especificándolas a través de conexiones de puerto, estas son: inobject(object, port); outobject(object, port); centerobject(object, port);

Un comando final usado para hacer referencia a un nodo es node(), que define la ruta de acceso al nodo y toma una cadena de texto como su primer parámetro, y por segundo, el nodo a partir del cual comienza la búsqueda. Este comando realiza una búsqueda para el nodo especificado en la ruta de la cadena. Por ejemplo: Considere una simple simulación donde un Queue esta conectado en serie con un Processor. Si la lógica de simulación necesita referenciar al Queue1 desde el trigger correspondiente al Processor3, existen dos maneras para lograrlo:

111

112

SIMULACIÓN CON FLEXSIM

outobject(current, 1);

o bien

node(“/Queue1”, model ());

Aquí, el Queue1 es referenciado desde el Processor3. En el caso del comando outobject(), el Processor3 está describiendo que el objeto se mantiene conectado al puerto de salida 1 del Queue1. Este comando es simple, pero sólo es válido cuando se crea y utiliza dentro del Processor3.

Otras funciones útiles de FlexScript Los comandos FlexScript proveen rutas directas para obtener información estadística acerca del modelo, por ejemplo: Devuelve el número de items que se encuentran contenidos en el nodo del objeto referenciado. getinput (object): Devuelve el número de items recibidos por el objeto. getoutput (object): Devuelve el número de elementos liberados por el objeto. content (object):

Otros comandos como get y set, establecen datos en labels y tablas, estos tienen el formato siguiente: getlabelnum (object, “labelname”):

especificada en el objeto seleccionado.

Obtiene el valor numérico de la etiqueta

“tablename”, row, column): Obtiene el valor numérico contenido en la celda de una Tabla, especificado por una row (fila) o column (columna). Gettablenum (object,

Para los datos incluidos como nodos en las variables node de un objeto pueden utilizarse comandos como: Getvarnum (object, “maxcontent”),

que obtiene el valor numérico de la variable especificada en un objeto determinado.

Capítulo 5. Aplicaciones y Usos Variados.

113

Concepto 2: Prioridad Anteriormente se hizo mención del concepto Task Sequence Priority (Prioridad en la Secuencia de Tareas), diciéndose que que los Task Executers funcionan mediante el concepto “el primero que llega es el primero en salir”. Este comportamiento es eficiente y está definido por defecto, pero en ocasiones queremos que ciertas tareas tengan prioridad sobre las demás. Con este fin, cada secuencia de tareas tiene un valor de prioridad que permite a los Ejecutores de Tareas ordenar la secuencia en la que deben atender una tarea. Las prioridades son ordenadas de mayor a menor, por lo que un valor de prioridad 3 es de mayor importancia que una prioridad 0. La secuencia de tareas seguirá el principios FIFO, pero ahora con respecto a la prioridad asignada en la tarea. Por ejemplo, si una secuencia de tareas de prioridad 3 llega a un recurso móvil después de una secuencia de tareas con prioridad 1, ésta se ejecuta primero, pero si una secuencia con prioridad 3 llega después de una prioridad superior a este valor, entonces la prioridad 3 deberá esperar su turno de ejecución.

5.4.2. Creación del modelo Dentro de FlexSim, trate de construir el modelo tal como se muestra en la figura 5.11. Observe que los Task Executers no tienen conexiones de puerto central, así que no los conecte aún, sólo conecte a los Recursos Fijos. No olvide asignarles un nombre a sus ejecutores y recursos, ya que estos serán usados como referencia en la construcción del modelo.

Figura 5.11. Ilistración del modelo concluido.

114

SIMULACIÓN CON FLEXSIM

Programación

Figura Programación Source.

En la ventana de propiedades del Source (figura 5.12), deberá programar 20 lotes con 5 piezas cada uno, esta acción la puede encontrar en el menú Arrival Style>Arrival Sequence y al pulsando el botón Refresh Arrivals se postraran los cambios.

5.12. del

Queues ALMACEN_1

Figura 5.13. Referenciando a recurso móvil OPERADOR_1.

Nota: indique al operador transportar tres piezas a la vez.

Una vez especificada el contenido máximo de 5 unidades para el Queue, se deberá indicar el uso de un Ejecutor de Tareas con el comando Direct Reference. Este comando está disponible en cualquier lista de selección de opciones que solicite el uso de un operador. Abra la ventana de propiedades de Queue y busque la pestaña Flow, active el botón User Transport y, dentro de la lista de selección de opciones, elija Direct Reference, ahí mismo habilite la herramienta Sampler, y finalmente de clic secundario sobre el OPERADOR_1. Véase la figura 5.13.

Capítulo 5. Aplicaciones y Usos Variados.

La instrucción anterior llamará automáticamente al OPERADOR_1 cada que una pieza dentro de ALMACEN_1 solicite ser transportada, sin la necesidad de hacer una conexión de puerto central. Además, es necesario mantener cerrado el puerto de salida de este almacén para indicar la liberación de piezas cada que el ALMACEN_2 lo requiera (según corresponda con el punto de reorden planteado). Esto lo puede hacer en la pestaña Triggers>OnExit> Close and Open Ports, indicando en Action closeoutput, Object current y Condition true.

ALMACEN_2 Nótese que la lista de selección Send To Port ya está configurada por defecto para asignar las piezas a las diferentes máquinas considerando First available (la primer máquina disponible), así que no hay necesidad de programar esta instrucción dentro del recurso. Sin embargo, es aquí donde se solicitará un punto de reabastecimiento a una pieza; la idea es que siempre que el inventario de este almacén descienda a una unidad contenida se indique desde aquí al ALMACEN_1 la liberación de piezas que serán transportadas por el OPERATOR_1. Para que esto sea posible, diríjase a la pestaña Triggers>OnExit y seleccione la opción edición de códigos, escribiendo a partir de la línea 6 lo siguiente: int contenido = content(current); treenode Almacen = node("/ALMACEN_1",model()); if (contenido==2) { openoutput(Almacen); }

Como puede observarse, la programación en FlexScript inicia con la declaración de la variable contenido tipo Integer, seguida por la variable Almacen tipo Treenode, misma que accede a la estructura de árbol de FlexSim y que da una relación jerárquica a los objetos entre sí. Estas relaciones permiten hacer referencia desde el ALMACEN_2 hasta el ALMACEN_1 de forma rápida y sencilla utilizando los comandos y palabras clave. La instrucción if hacen un llamado a la variable contenido, y si se cumple la relación lógica definida por el operador ( ==) se ejecuta la instrucción del bloque establecido entre en conjunto de {}, dando instrucción a la variable Almacen para

115

116

SIMULACIÓN CON FLEXSIM

abrir el puerto de salida del Almacen_1 y liberar nuevamente piezas al operador que las transporta. Hecho lo anterior, continuemos con la programación de los Processors:

Para que operen correctamente las tres máquinas procesadoras del modelo, dentro de cada una de estas deberá programarse lo siguiente (mientras revisa cada punto listado abajo, obsérvese la figura 5.14.): 1. Dé doble clic sobre la MAQUINA_1 y en la lista de selección Setup Time escriba el valor de 2, esto establecerá un tiempo de preparación de 2 segundos antes de que cualquier pieza pueda entrar para ser procesada. Al final de la programación cuando sea ejecutado el modelo la máquina, será rodeada con un cuadro amarillo el cual indica que el equipo está siendo preparado para recibir una pieza. Debajo de la anterior lista de selección se encuentra la lista Process Time, ahí dentro programe una constante de operación igual a 20 segundos.

Figura 5.14. Programación del tiempo de preparación, tiempo de proceso, asignación de operario y prioridad de las tareas para la MAQUINA_1.

2. Ahora que se han establecido los tiempos de operación, prográmese el uso de otro recurso móvil para ejecutar la tarea de preparación. Se ha revisado con anterioridad como referenciar a un recurso móvil mediante una conexión de puerto central y a través de la opción Direct Reference, pero ahora se mostrará una tercera alternativa. Primero, en esta misma tabla de propiedades de la

Capítulo 5. Aplicaciones y Usos Variados.

MAQUINA_1 (pestaña Processor), active las casillas Use Operator(s) for Setup, esto indicará el uso de un operador durante la preparación del equipo. Posteriormente, dentro de la lista de selección de opciones Pick Operator, seleccione la alternativa By Name y elija al OPERADOR_2. Como consecuencia de esto, usted podrá ver como el OPERADOR_2 es llamado por la MAQUINA_1 cada que esta requiera ejecutar las tareas de preparación, sin la necesidad de hacer alguna conexión de otro tipo. 3. Si se quiere que ciertas tareas tengan prioridad sobre las demás, recuerde que cada secuencia de tareas tiene un valor de prioridad el cual permite a los recursos móviles o ejecutores de tareas ordenar la secuencia en la que debe atenderse una tarea. Así que, para dar por terminada la programación de la MAQUINA_1, deberá asignarle una prioridad, en este caso coloque el valor de 1 en la casilla de texto Priority. Con ello, la programación de la MAQUINA_1 habra concluido. Dé clic Apply, Ok. 4. Programe de la misma manera el resto de las máquinas, pero no olvide asignar una prioridad distinta a cada máquina. De preferencia a la MAQUINA_2 asigne un valor de prioridad 2 y a la MAQUINA_3 un valor de prioridad 3. 5. Recuerde que las prioridades son ordenadas de mayor a menor, así que una vez que su modelo sea ejecutado verifique que realmente el OPERADOR_2, le esté dando prioridad a las tareas de la MAQUINA_3. Para ilustrar esto, observe nuevamente la figura 5.14.

5.5. EJEMPLO: LOS OBJETOS TASK EXECUTERS Y LA INTERRUPCIÓN DE TAREAS El siguiente modelo Ejemplo 6 se basa en los conceptos presentados de los modelos anteriores, y añade una manera distinta para obtener un mayor control sobre el comportamiento predeterminado en la secuencia de tareas a través de una tarea especial llamada Break Task (interrupción de tareas). En la lista de selección de opciones Break To ubicada en la ventana de propiedades de cualquier recurso móvil se pueden configurar distintas interrupciones de tareas.

117

118

SIMULACIÓN CON FLEXSIM

Lo que usted aprenderá es: 1. Cómo hacer uso adecuado de la instrucción "Break To" en un recurso móvil. 2. Cómo aprovechar a los recursos móviles y las bondades de los racks.

Ejemplo 6. Un centro de distribución de una empresa mexicana de alimentos, maneja tres productos distintos: papas, galletas y cacahuates enchilados. Estos llegan a la planta a través de camiones contenedores. Los productos son almacenados y retenidos en tres fosas hasta que un montacargas llega por ellos para trasladarlos al almacén correspondiente. El problema consiste en hacer una adecuada práctica picking (proceso de desempacar o preparar un pedido de uno o más productos de un contenedor o envase para satisfacer una demanda, haciendo mezclas de ellos de acuerdo a las especificaciones o condiciones del pedido) para distribuir cada uno de los tres productos en los distintos racks. Descripción:       

Un camión contenedor representado por un Source descarga continuamente un FlowItem cada 2 segundos y los distribuye al azar en tres fosas de descarga. A los FlowItems se les asigna un ItemType uniformemente distribuido entre 1, 2 y 3, para representar a los tres productos distintos. Las tres fosas de descarga pueden contener a los tres distintos ItemTypes pero tienen sólo capacidad para retener 10 elementos a la vez. Un montacargas transporta los FlowItems de las fosas a tres racks. Cada rack tiene capacidad para 12 productos y está destinado para un ItemType distinto. Después de que los FlowItem han permanecido 5 minutos dentro de los racks, estos son enviados fuera del sistema a través de un Sink. El montacargas puede transportar hasta 3 artículos a la vez. En cada viaje el montacargas sólo debe transportar elementos que tienen el mismo ItemType.

El ejemplo es muy práctico, ya que puede contribuir con el mejor desempeño de toda la cadena logística de un centro de distribución.

Capítulo 5. Aplicaciones y Usos Variados.

5.5.1.

Conceptos Concepto 1: Requisitos de la instrucción Break Task La instrucción Break Task le dice al recurso móvil que compruebe si hay alguna secuencia de tareas que deba ser interrumpida. Por ejemplo, si dos elementos están esperando para ser transportados de un punto a otro por un montacargas que tiene la capacidad de cargar dos o más elementos desde una misma ubicación, entonces el montacargas tendrá dos tareas secuenciadas por realizar. La primera tarea secuenciada que esta activada, indica la recolección y entrega del primer elemento, y la segunda tarea (recolección y entrega del segundo elemento) es colocada en una cola de secuencias misma que se ejecutará hasta que la tarea activa es concluida. Entonces la instrucción Break Task, permite al montacargas detener la secuencia de la primera tarea después de que se haya cargado el primer elemento, y antes de que este elemento sea transportado de un punto a otro comenzará la secuencia de la segunda tarea, la cual le indica al montacargas viajar hasta la ubicación del segundo objeto para tomarlo. Una secuencia de tareas estándar de un recurso móvil está formada por cinco diferentes elementos: Desplazamiento – Carga - Interrupción - Desplazamiento - Descargar

El campo Break To localizado en la ventana de propiedades de cualquier recurso móvil, sólo se evalúa cuando este se encuentra con una interrupción. Entonces, cuando es programada una Break Task dentro de un recurso móvil, la instrucción envía una notificación para interrumpir la secuencia de la primera tarea y se ordena al recurso móvil realizar otra secuencia de tarea antes de que finalice la actual o antes de desplazarse y dejar la primera carga. Si no está programada ninguna interrupción de tarea dentro de una secuencia de tareas el requisito Break To nunca será evaluado. Así podrá cargar dos o más objetos a la vez, pero bajo los criterios que usted defina antes de que estos sean transportados a su destino final. En caso de que lo anterior llegue a ocurrir, el recurso móvil primero comprobará que realmente es capaz de cargar múltiples FlowItems a la vez. Si la verificación indica que es posible, entonces se evaluará la necesidad Break To para ejecutar una secuencia de tarea interrumpida, de lo contrario la interrupción programada devolverá un valor nulo y no será ejecutada la interrupción a pesar de que esta haya sido definida.

119

120

SIMULACIÓN CON FLEXSIM

El tema aquí mostrado es de suma importancia, pues la administración de inventarios puede ser una tarea desalentadora en una empresa con miles de productos que son tomados y distribuidos a cientos de localizaciones.

5.5.2.

Creación del modelo Observe la figura 5.15 y trate de construir en una nueva hoja de FlexSim un modelo muy parecido. Cuando usted arrastre un Rack dentro del área de trabajo, notará que no tiene el mismo diseño que los mostrados en este modelo, no se preocupe ahora por ese detalle, pues en la programación del Rack se ajustan sus dimensiones y su color. Una vez que tenga todos sus recursos, nómbrelos y conéctelos. Observe nuevamente que el montacargas no está conectado aún, esto lo haremos más tarde.

Figura 5.15. Diseño final del ejemplo 6.

Programación Source Para simular un suministro constante de elementos que fluyen hacia el primer conjunto de fosas, utilice un tiempo de llegadas constante escribiendo un 2 directamente en el campo de Inter-Arrivaltime. Esto asumirá un suministro infinito

Capítulo 5. Aplicaciones y Usos Variados.

de artículos cada dos segundos. Posteriormente, acceda a la pestaña Triggers y dentro de la lista de selección OnCreation seleccione Set Itemtype and Color. La instrucción anterior ordenará la colocación de ItemTypes uniformemente distribuidos entre 1, 2 y 3, para representar a los tres productos distintos y además, les agregará un color diferente.

Queue Localice en la primera pestaña de la ventana de propiedades del Queue el campo de texto llamado Maximum Content; dentro de este escriba un valor de 10 para indicar su capacidad máxima. Ahora programará el uso del montacargas para mover las piezas de las fosas a los racks, y lo puede hacer en la pestaña Flow. Seleccione la pestaña Use Transport y habilite la opción correcta para llamar al montacargas.

Transporter Como se mencionó anteriormente, el Transporter o Transportador es una sub-clase de Task Executers y es utilizado principalmente para transportar FlowItems de un objeto a otro. En un rack puede tomar o dejar FlowItems en diferentes posiciones, ya que cuenta con un par de horquillas, estas son guiadas a través de una torre de elevación para ubicar una posición deseada en las coordenadas x, y, z. Además del Transporter, los recursos móviles en general pueden realizar varias funciones:      

Moverse físicamente mientras el modelo es ejecutado. Transportar FlowItems de un recurso a otro. Ejecutar una serie de tareas. Asistir a un recurso fijo en operaciones particulares (por ejemplo, en el tiempo de preparación, tiempo de proceso, mantenimiento, etc.). Distribuir tareas a otros recursos móviles. Seguir un camino creado con Network Nodes.

Y tal como su nombre lo indica, la función principal de un ejecutor de tareas o recurso móvil, es ejecutar una serie de tareas. Una secuencia de tareas contiene una serie de especificaciones que son ejecutadas en orden, y que tienen un valor de prioridad respecto a la importancia de otras. Pueden ser adelantadas o detenidas

121

122

SIMULACIÓN CON FLEXSIM

mientras están siendo ejecutadas y ser creadas automáticamente. Por ejemplo, cuando en un recurso fijo se activa la instrucción “Use Transport”, las siguientes tareas son ejecutadas: 1. Viajar hasta el objeto contenedor de FlowItems quienes necesitan ser transportados. 2. Cargar los FlowItems. 3. Break (interrupción), esto permite comprobar si hay alguna otra tarea en espera (por ejemplo, cargar otro elemento que esté disponible siempre que el recurso móvil tenga capacidad). 4. Viajar hasta el destino de los FlowItems. 5. Descargar los FlowItems en el recurso fijo destino. Otra secuencia de tareas generada automáticamente ocurre cuando es necesario asistir en la operación de un proceso. En este caso el recurso móvil: 1. Viaja hasta el objeto que necesita asistencia en la operación del proceso, y 2. Espera a ser utilizado durante el proceso. Una característica de gran importancia dentro de FlexSim, es que usted puede definir sus propias secuencias de tareas según sea lo más conveniente.

Parametros importantes de la ventana de propiedades del Transporter (figura 5.16):   





Lift Speed: Indica la velocidad en unidades de rejilla por unidades de tiempo. Capacity: Indica el número máximo de FlowItems que un recurso móvil puede transportar a la vez. Speed (Max Speed, Acceleration y Deceleration): Indican la velocidad máxima a la que el recurso móvil puede viajar, la rapidez con la que un recurso móvil alcanza su velocidad máxima y la rapidez con que el mismo pierde velocidad a medida que se acerca a su destino. Flip Threshold: Este valor indica el ángulo imaginario que el recurso móvil dibujará después de que toma un FlowItem de un recurso y gira para avanzar en la dirección correcta. Si la opción es activada o desactivada no se afectan las estadísticas del modelo, pues es sólo un apoyo visual. Rotate while travelling: Si esta casilla es marcada, el recurso móvil girará para orientarse y caminar o moverse en el sentido de la marcha. Si la opción es activada o desactivada no se afectan las estadísticas del modelo, pues tambien

Capítulo 5. Aplicaciones y Usos Variados.



 

123

es un apoyo visual. Travel offsets for load/unload tasks: Esta lista de selección ofrece 3 opciones: 1. Si es elegida la opción "Travel offsets for load/unload tasks", el recurso móvil se desplazara hasta el punto exacto donde serán recogidos o entregados los FlowItems. 2. La opción "Do not travel offsets for load/unload tasks", permite viajar hasta el origen del objeto destino y recoger o dejar allí a los FlowItems. En caso de que el recurso móvil este usando NetworkNodes para viajar a su destino, este se detendrá en los nodos de la red y desde ahí tomará los FlowItems sin llegar necesariamente hasta los recursos fijos. 3. La alternativa "Do not travel offsets and block space on network" es aplicable sólo cuando el recurso móvil está conectado a una red de caminos NonPassing (red bloqueada). Si es elegida esta última opción, el objeto llegará al nodo bloqueado, terminará su recorrido y mientras se esté haciendo la carga/descarga, el espacio en la red seguirá ocupado y se bloqueará la admisión de otros objetos que viajan por el mismo camino. Load time/Unload time: Este atributo permite definir el tiempo de carga y descarga necesario. Break To: Lógica que describe la interrupción de una secuencia de tareas actual,

Figura 5.16. La ventana de propiedades del Transporter es parecida a la que muestran todos los recursos móviles. La pestaña inicial se clasifica en dos secciones, la primera permite manipular las propiedades y operación del recurso móvil, y la segunda aborda su comportamiento respecto a la ejecución de tareas.

124

SIMULACIÓN CON FLEXSIM





para introducir una secuencia de tareas antes de que la primera termine. Dispatcher Pass To: Permite crear estrategias para compartir tareas a otros recursos móviles. Si hay más tareas que números de recursos móviles, las tareas son colocadas en una línea de espera y serán asignadas hasta que un recurso móvil esté disponible. Dispatcher Queue Strategy: Aquí se puede establecer una lógica que dé prioridad a ciertas tareas ordenándolas en una fila de actividades secuenciadas.

Hechas las observaciones anteriores pasemos a la programación del montacargas. En la capacidad del montacargas asignaremos un valor de 3 para mover tres productos a la vez; en la lista de selección Break To seleccione Same Items of Same or Closest Station. Esta última instrucción le permitirá al montacargas tomar todos los FlowItems disponibles en una fosa, si la misma no contiene por lo menos tres productos del mismo tipo, el montacargas buscará la fosa más cercana y tomará todos los productos necesarios hasta completar la carga.

Rack Ya hemos comentado que un Rack es empleado para almacenar FlowItems, pero ahora observaremos más de cerca las características que lo definen (ver figura 5.17):  

 

 

Floor Storage: Al ser activada esta casilla el Rack tomará una posición horizontal y bajará al nivel del suelo. Mark Shelves that have called a transporter: Cuando esta opción está marcada podrá ver un cuadro de color rojo debajo de todos los FlowItems que ya hayan cumplido con su tiempo de permanencia. La opción se ve sólo cuando algún recurso móvil traslada FlowItems del Rack hacia otro objeto. Shelf tilt amount: Esta opción permite darle un grado de inclinación a las rejillas del Rack. Picking/Placing Y Offset: Esta alternativa es empleada para ubicar la posición del recurso móvil al llegar al Rack. Entre más grande sea el valor mayor será la distancia a la que se tomarán o dejarán los FlowItems. Maximum Content: Muestra el contenido máximo del Rack. Opacity: Permite ver diferentes transparencias del Rack. Un valor de 0 significa

125

Capítulo 5. Aplicaciones y Usos Variados.





totalmente transparente y un valor de 1 significa totalmente opaco. Place in Bay/Level: Estas listas de opciones son ejecutadas en el preciso momento en que un FlowItem entra al Rack. Devuelven una posición de bahía o nivel para encontrar o almacenar un FlowItem. Minimum Dwell Time: Define el tiempo mínimo de permanencia de un FlowItem en el Rack; aquí también se pueden plantear estrategias de liberación.

En lo referente a la programación necesaria en esta pestaña, indique un contenido máximo de 12 para permitir la entrada de FlowItems hasta alcanzar el valor del contenido máximo. Dentro de las listas de selección Place in Bay y Place in Level elija Random Bay if Available y Random Level if Available respectivamente, observe que el valor de 1 preestablecido en cada una de estas últimas opciones logra ubicar sólo una pieza por celda. Una vez que un FlowItem está dentro del Rack es necesario indicarle cual deberá ser su tiempo mínimo de permanencia, así que dentro de la función Minimum Dwell Time coloque el valor de 300 para indicar 5 min, de esta manera después de que el tiempo asignado se agoté, el Rack libera al FlowItem.

Figura Ventana propiedades Rack_1.

5.17. de del

126

SIMULACIÓN CON FLEXSIM

Para definir la apariencia del Rack, dé clic en la pestaña Size Table y busque la manera de indicar sólo 3 bahías y 4 niveles (al finalizar de Aplly Basic Settings), además especifique 2 metros de ancho por 1 de alto en cada celda. Si desea cambiar el color del Rack, pase a la pestaña General y dentro de la lista de selección Color elija el color que más le agrade. Para concluir, es necesario indicar también a cada uno de los Racks que sólo pueden almacenar una clase ItemType. Es decir, al Rack_1 le asignaremos los FlowItems con ItemType 1, en el Rack_2 se almacenarán ItemTypes 2 y al Rack_3 los ItemTypes 3. La instrucción anterior puede programarse dentro de la pestaña Flow activando el sistema Pull. En la lista de selección Pull Strategy elija By Expression y tome la opción getitemtype(item), esto indicará la entrada sólo a un ItemType específico. En la lista siguiente llamada Pull Requirement seleccione Specific Itemtype y en Type asigne el valor de 1 si se trata del Rack_1, 2 en el Rack_2 y así sucesivamente.

Ahora abrá concluido el modelo, si lo ejecuta deberá funcionar correctamente.

Actividades extra: 1. Observe al montacargas y explique su comportamiento pasados los primeros 250 segundos. 2. Experimente probando alternativas distintas dentro de la lista de selección “Break To” y describa cuáles fueron los comportamientos del montacargas.

5.6. EJEMPLO: RECURSOS MÓVILES Y RUTAS DE VIAJE Como usted ya se habrá dado cuenta, los recursos móviles viajan en línea recta entre su origen y su destino para acortar la distancia, pero si lo desea, es posible indicar por donde puede o no viajar un recurso móvil. El medio para lograr este fin es a través del uso de un recurso especial conocido como NetworkNode, que permite crear caminos o rutas en una red. Un NetworkNode es sólo un nodo en el modelo y un

Capítulo 5. Aplicaciones y Usos Variados.

grupo de NetworkNodes conectados constituyen una red. Lo que usted aprenderá es: 1. Cómo confifurar una red de nodos para indicar la ruta de viaje de un recurso móvil. 2. Cómo crear trayectorias con curva a través de puntos de control Spline. 3. Cómo identificar la distancia que hay entre un nodo y otro, y sabiendo la velocidad a la que viaja un recurso móvil podrá definir el tiempo necesario para recorrer un camino específico, y 4. Sabrá cómo hacer bloqueos de accesos por rutas determinadas para que el recurso móvil tome rutas alternas. Ejemplo 7. Imagine que una persona o almacenista desea transportar cajas de un almacén a otro pero al salir del primer almacén, es necesario tomar el camino curveado y el regreso lo deberá hacer por la trayectoria recta. Descripción:  









Se emplearán un Source, un Queue y un Sink, para representar la fuente, el almacén 1 y el almacén 2 respectivamente. El almacenista deberá representarse por un Operator quien se moverá a una velocidad de 2 metros por segundo. El nodo “home” del Operator deberá ser el NN1. Deberán ser introducidos tres nodos al área de trabajo con la intención de crear una red. Los tres nodos serán conectados entre sí, pero además, el nodo número 1 (NN1) se conectará al Queue y al Operator, y el NN2 se conecta al Sink. La ruta formada por el NN1 y el NN2 tendrá una forma curveada y estará ligeramente despegada del suelo formando un montículo. La ruta creada por los nodos NN2, NN3 y NN1 será en línea recta. Las piezas tomadas de Queue serán transportadas por la ruta NN1 – NN2 hasta llegar al Sink. Cuando el almacenista regrese del Sink al Queue por otra pieza deberá hacerlo por la ruta NN2 – NN3 – NN1. Para esto será necesario bloquear algunos sentidos de ambas rutas. Haciendo uso de una distancia virtual, programe la ruta NN2 – NN3 – NN1 de tal forma que el almacenista tarde 2 minutos en regresar del Sink al Queue.

127

128

SIMULACIÓN CON FLEXSIM

5.6.1.

Conceptos Concepto 1: Conexión de NetworkNodes Para conectar dos NetworkNode entre sí, mientras presiona la tecla “A” haga clic en el primer nodo (NN1), después arrastre el mouse hasta el segundo nodo (NN2), y sin dejar de presionar la tecla “A” dé clic en este ultimo (ver figura 5.18). Lo anterior creará una conexión con una línea negra, observe que a 1/3 y 2/3 de distancia están dos flechas encontradas. Las flechas verdes indican que un recurso móvil puede avanzar en ambas direcciones (Passing), el color amarillo señala un camino sin paso (Non-passing) y el rojo significa que no existe una conexión (No Connection). Entonces, si las dos flechas son de color verde la conexión se considera como bilateral y si alguna de las flechas es roja se bloquerá el acceso en algún sentido, por lo que la conexión será unilateral. Para cambiar estos colores, puede hacer clic derecho sobre el punto verde y en la ventana emergente seleccione otra opción.

Figura 5.18. Conexión de dos NetworkNode.

Concepto 2: Puntos de control Spline La línea negra que describe la trayectoria por donde se desplazará el recurso móvil puede ser tanto una recta como una curva. Si es seleccionada la opción “Curved” del menú desplegable (dando clic secundario sobre la flecha verde), se crearán dos nuevos puntos de control pertenecientes a un Spline (curva diferenciable definida en porciones). Al mover estos dos puntos de posición utilizando el mouse, la trayectoria de la curva será modificada tanto en el eje X como en el Y. Para cambiar la trayectoria en el eje Z, haga clic en cualquier punto de control Spline y gire el scroll del mouse hacia arriba y hacia abajo. Véase figura 5.19.

Capítulo 5. Aplicaciones y Usos Variados.

129

Figura 5.19. Curva y sus puntos de control Spline.

Una vez configurada y definida la trayectoria, los recursos móviles podrán utilizar la ruta trazada. Si desea que esta no sea visible mientras el modelo es ejecutado, presione la tecla “X” y dé múltiples clics sobre algún NetworkNode.

Concepto 3: Tiempo de viaje El tiempo requerido para que un recurso móvil viaje entre dos nodos de la red es igual a la distancia existente entre los nodos dividida entre la velocidad a la que viaja el recurso móvil (suponiendo que no hay aceleración o desaceleración). La Current Distance está dada en términos de unidades de la red y marca la distancia entre dos nodos elegidos. La figura 5.20 indica que la distancia entre los nodos (NN1 y NN2) es de 12.03 unidades de la red. Ahora bien, si el recurso móvil se desplaza a una velocidad de 2 unidades de la red por segundo, entonces el mismo tardará aproximadamente 6.02 segundos en viajar del nodo número 1 (NN1) al numero (NN2). Para ajustar las distancias aproxime los nodos tanto como sea necesario.

Una característica especial de los nodos de una red en FlexSim es que puede ser especificada una Virtual Distance (distancia virtual) entre los nodos de una red. Por ejemplo, si la distancia virtual desde el NN2 hasta el NN3 es ajustada a 240 (unidades de la red). Entonces el recurso móvil se tomará 120 segundos (2 minutos) para recorrer la ruta marcada entre estos dos nodos (240 unidades de la red entre 2 unidades de la red por segundo). Si los nodos o la ruta de la red son bidireccionales, la distancia virtual necesita ser especificada en ambas direcciones, de NN2 al NN3 y

Nota: al dar clic presionando la tecla “X” pero sobre los puntos Spline el resultado será un incremento de puntos Spline sobre la curva.

130

SIMULACIÓN CON FLEXSIM

del NN3 al NN2, pero si es unidireccional, sólo deberá especificarse dentro del nodo que permite el acceso al recurso móvil.

Figura 5.20. Ventana de propiedades del NN1. Para tener acceso a esta ventana dé doble clic sobre algún nodo de la red.

5.6.2.

Creación del modelo Con toda la información proporcionada hasta el momento, seguramente usted no tendrá problemas para diseñar y programar este modelo. Revise detalladamente la figura 5.21, y desarrolle el modelo de tal forma que se vea y funcione de acuerdo con la descripción anterior. Recuerde que para crear y establecer una red dentro de su modelo es necesario seguir tres simples pasos: 1. Cree tantos NetworkNodes como sean necesarios y conecte cada uno de los nodos de la red entre sí para crear las rutas necesarias. Recuerde, la conexión entre nodos se hace presionando la tecla “A” y dando clic en los nodos que desea conectar. 2. Conecte un NetworkNodes por cada recurso fijo que requiera el servicio de un recurso móvil. Se puede conectar un recurso fijo a un nodo de la ruta utilizando la misma combinación: presionado la tecla “A” y dando clic en un nodo, posteriormente se arrastra el mouse y haga clic sobre el recurso fijo

Capítulo 5. Aplicaciones y Usos Variados.

131

que desea conectar. El resultado de esta conexión es una línea azul, la cual indica que la conexión fue completada. Es importante señalar que este tipo de conexión no ocupa ningún puerto en el objeto. 3. Asigne un recuso móvil únicamente a un nodo de la red. La conexión se hace también pulsando la tecla “A”. Ese nodo se convierte en la ubicación "home" del recurso móvil. El resultado de esta conexión es una línea roja que tampoco ocupa algún puerto. Si el recurso fijo no está conectado con algún nodo de la red de rutas, el objeto será visto como inalcanzable por el recurso móvil y FlexSim mostrará un error, ya que una vez que un recurso móvil está conectado a una red de rutas, no podrá viajar fuera de ella, porque todos sus posibles movimientos son ahora definidos por la red.

Figura 5.21. Diseño final del modelo 7.

5.7. EJEMPLO: USO DEL RECURSO COMBINER E IMPORTACIÓN DE DATOS DE EXCEL En este modelo, vamos a utilizar un Combiner por primera vez de una forma avanzada. El Combiner, es un tipo de procesador especializado, cuyos parámetros son muy parecidos a los de un Processor, de igual manera, el objeto puede llamar a ciertos operadores durante los tiempos de preparación, proceso o reparación.

132

SIMULACIÓN CON FLEXSIM

Lo que usted aprenderá es: 1. Cómo manipular la tabla Components List con datos filtrados desde Excel a través de un Combiner para hacer empaques personalizados sobre la marcha. 2. Cómo importar y utilizar un horario de llegadas dentro del recurso Source. Ejemplo 8. Un pequeño distribuidor dispone de 10 tipos de productos los cuales son empaquetados y enviados a 5 diferentes clientes. El problema es que cada cliente tiene órdenes de compra diferentes y estas órdenes son solicitadas a diferentes tiempos. Descripción: 

  

El distribuidor tiene almacenado en 10 Queues suficientes productos para atender todas las ordenes solicitadas, lo único que necesita es esperar a que la orden llegue al sistema a través del Source de Pallets. Para armar los paquetes de productos y programar la llegada de las órdenes al sistema, utilice dos tablas diseñadas en Excel. Un Combiner armará los paquetes según corresponda a la orden solicitada por cada uno de los 5 clientes en un tiempo de 3 minutos. Los productos de un paquete correspondiente a una orden, son colocados sobre un pallet y enviados por una banda transportadora hacia el Sink que los sacará del sistema.

Actividades extras: 1. Programe otros usos para el Combiner y observe los resultados.

5.7.1.

Conceptos Concepto 1: Recurso Combiner El Combiner puede tanto unir (join) los FlowItems definitivamente como empacarlos (pack) dentro de algún contenedor o agruparlos en lotes (batch) con la posibilidad de volverlos a separar en operaciones subsecuentes. Los Combinadores toman a los FlowItems que llegan a través del puerto de entrada 1 (Input Port 1) y los utilizan como base para contener, unir o agrupar a los FlowItem que entran por

Capítulo 5. Aplicaciones y Usos Variados.

el resto de los puertos de entrada según sea especificado. Cuando se empaca con la instrucción pack es común usar como base un tipo especial de FlowItems llamado container flowitem (algunos ejemplos de estos FlowItems especiales son un Pallet o un Tote). Los FlowItems que son unidos con la instrucción join lo hacen de tal forma que pierden su individualidad. En caso de activar esta instrucción, los FlowItems que entran por el puerto de entrada 1 se unirán definitivamente a los FlowItems que entran por el puerto 2 y cualquier otro puerto superior. Como resultado de la operación join, los FlowItems que entran por el puerto 2 y superior son destruidos y sólo podrá ver como salida del Combiner al FlowItem que llegó por el puerto 1, esto se considera entonces un FlowItem “joined” o unido. Concepto 2: Importar desde Excel La información de una institución con frecuencia es almacenada en bases de datos, pues estas permiten una mayor organización, por lo tanto en la mayoría de los modelos diseñados por el usuario será necesario importar datos desde algún origen externo al software FlexSim como por ejemplo de Excel. La herramienta que se revisará aquí es conveniente para filtrar o importar datos a FlexSim en lugar de crear Tablas Globales complejas. Para los usuarios avanzados que desean hacer importaciones personalizadas, FlexSim proporciona comandos integrales en el lenguaje del modelado. También es posible hacer una interfaz gráfica agradable que configure tanto la importación de una sola hoja como de varias hojas a la vez. En este modelo se ilustrará la utilización de la herramienta Excel Import/Export Interface.

5.7.2.

Creación del modelo

Para empezar, es necesario que tome y coloque los recursos fijos que formarán parte del modelo tal como se muestra en la figura 5.27. Conecte cada Source con su respectivo Queue y cada Queue con el recurso Combiner, pero no olvide lo que se comentó en un inicio respecto a la prioridad para la conexión del Queue que enviará pallets (FlowItems especiales) y no pase por alto el orden de las conexiones. Hecho lo anterior, conecte al Conveyor y finalmente al Sink.

133

134

SIMULACIÓN CON FLEXSIM

Bases de datos en Excel y configuración de un importador de datos MTEI

Figura 5.22. Tabla de órdenes de productos solicitadas por cada uno de los distintos clientes.

Figura 5.23. Frecuencia de llegadas, nombre ItemType y cantidad de órdenes solicitadas.

Debido a la descripción del modelo son necesarias dos tablas, cada tabla deberá diseñarse en una hoja diferente pero dentro de un mismo archivo o libro de Excel. Las figuras 5.22 y 5.23, muestran el formato que deberán tener las hojas en Excel, es necesario que ambas tablas contengan toda la información mostrada, además, evite dejar filas vacías entre el encabezado de cada columna y los datos. Nombre a la hoja que contiene las órdenes de los clientes como Órdenes y a la hoja que contiene la agenda de la frecuencia de llegadas, el nombre de la orden, el número de ItemType y la cantidad de órdenes solicitadas, llámela Programación de llegadas. Guarde el archivo de Excel con el nombre de “Base de datos_Ejemplo 8” en algún lugar donde se pueda encontrar fácilmente. Recuerde, no haga dos archivos de un libro, use dos hojas (dos pestañas en la parte inferior de Excel) en un libro.

Capítulo 5. Aplicaciones y Usos Variados.

Para configurar un importador de datos a través del comando de Importación Múltiple de Tablas de Excel (MTEI, por sus siglas en inglés), lo primero que debe hacer es agregar “tablas destino” a la interfaz MTEI, así FlexSim sabrá donde deberán ser colocados los datos de Excel. La primer “tabla destino” deberá programarse dentro del Source llamado “Source_Pallet”, lo que permitirá configurar posteriormente los Inter-Arrivals. Vaya a la ventana de propiedades de este Source y seleccione el comando Arrival Schedule de la lista de selección Arrival Style. Después, pulse el botón Add Table to MTEI y haga clic en Aceptar (al finalizar, de Aceptar a la nota emergente). No hay una retroalimentación visual para añadir una tabla a la interfaz MTEI, por lo tanto asegúrese de pulsar el botón Add Table to MTEI sólo una vez (posteriormente dé clic en Apply y Ok). La segunda tabla destino será definida dentro de una Global Table, esta acción posteriormente permitirá programar correctamente los distintos productos que contendrá cada orden solicitada por los clientes. Diríjase a la caja de herramientas de nombre Toolbox y agregue entonces una Global Table, asígnele un nombre (Tabla Global_1) y haga clic en el botón Add Table to MTEI mismo que se encuentra en la esquina inferior izquierda de la tabla. Una vez más, haga clic en ese botón (sólo una vez) y de Aceptar. Ahora que ambas tablas se han añadido a la interfaz MTEI, se puede configurar la importación. Hecho lo anterior, seleccione de la barra de herramientas Interfaz de Datos con Excel ( ) o diríjase nuevamente a la Toolbox, en la opción Import, elija Excel Import/Export. Cualquiera de las dos alternativas anteriores abre la interfaz de importación/exportación de Excel. Después dé clic en el botón que está en la pestaña de nombre “Import”. Esto abrirá la ventana MTEI que se muestra en la figura 5.24. Una vez abierta la ventana podrá ver una línea de importación en la columna de la izquierda (ImportLine1). Aquí es posible observar el total de líneas de importación que el usuario desee usar. Por el momento, mantenga destacada la ImportLine1 para que se sigan mostrando los parámetros de configuración. Usted puede asignar un nombre a las líneas de importación para personalizarlas si así lo cree conveniente. Aquí se puede establecer el libro de Excel que se desea importar, haciendo clic en el botón Examinar ( … ) ubicado al lado derecho de la lista Excel Workbook. En esta última lista, también notará dos opciones desplegables. "NEW" abrirá un explorador de archivos mientras la importación comienza permitiendo al usuario elegir desde qué archivo desea importar y "BLANK" significa que la línea de importación seleccionada actualmente utiliza el mismo archivo que la línea de

135

136

SIMULACIÓN CON FLEXSIM

importación directamente sobre esta lista. Por otro lado, en la celda de texto editable llamada Excel Sheet Name puede especificarse el nombre de la hoja del libro de trabajo donde los datos residen (para el ejercicio se elige primero la hoja de Excel de nombre “Programación de llegadas”).

Libro de importado

Excel

Nombre de la hoja de Excel Tabla destino para importación de datos

Figura 5.24. Ventana MTEI “Importación Múltiple de Tablas de Excel”.

Coordenadas de posición inicial, y total de filas y columnas

La siguiente lista desplegable Table Type, le permite elegir qué tipo de tabla usar como destino para los datos importados. Usted puede elegir entre una Global Table, una tabla que reside dentro de un objeto de origen, o bien puede buscar otra tabla a través de esta misma la lista de opciones. Para actualizar la información correspondiente al Source_Pallet, dentro de la opción Source Table elija al Source_Pallet y prográmela como Arrival Schedule. Finalmente, indique el uso de encabezado de filas y columnas, y en las celdas Starting Row y Total Rows asígneles un valor de 5. El primer valor indicará que la fila número 5 contiene los datos iniciales y el siguiente 5 refiere al total de filas que contienen información válida. En cuanto a los valores necesarios para las columnas serán 3 y 4 para indicar el inicio de la lectura de datos en la columna 3 y hasta un total de 4 columnas. Una vez que tenga la interfaz MTEI configurada, haga clic en Apply y Ok. Ahora, acceda nuevamente la Interfaz de Excel, dé clic en el botón Import Tables (ubicado en la parte inferior izquierda de la ventana de Importación de Datos de Excel), y espere a que las barras de progreso lleguen hasta el final. Con ello, la importación de datos quedará concluida. Para asegurarse que la primera tabla se haya importado correctamente con los datos introducidos en Excel, abra la ventana de

Capítulo 5. Aplicaciones y Usos Variados.

137

propiedades del Source_Pallet y observe que automáticamente la tabla de Excel se ha filtrado al recurso Source. La siguiente figura 5.25 muestra los resultados de la primera configuración empleando el importador de datos MTEI. Nota: aprovechando que está dentro del objeto Source_Pallet, indique el uso de Pallets en lugar de Boxes dentro de la lista de selección “FlowItem Class”.

Para concluir con la configuración del importador de datos MTEI, es necesario que repita el procedimiento anterior pero en una línea de importación distinta (ImportLine2), que debe vincular a la hoja de Excel llamada Órdenes con el tipo de tabla “Global Table”. Una vez terminada la configuración, no olvide verificar que los datos de Excel se hayan filtrado correctamente dentro de la Tabla Global. En este ejercicio el nombre de la tabla es “Tabla Global_1”, misma que fue creada anteriormente.

Combiner Dentro de la ventana de propiedades del Combiner en la pestaña Combiner se encuentran las opciones principales que describen el comportamiento de este objeto: Pack, Join y Batch. La tabla Components List es muy interesante ya que se actualiza automáticamente cada vez que es conectado un nuevo puerto de entrada al Combiner (Véase la figura 5.26). Tenga en cuenta que la primera columna enlista los puertos de entrada comenzando con el puerto 2, esto indica al Combiner suministrar FlowItems de todos los puertos a partir del 2. Como puede ver, el puerto 1 no se enlista, debido a que el puerto 1 suministra los FlowItems especiales que serán usados como contenedor o base. Así que no olvide entonces que la primera conexión que deberá hacer al Combiner es la conexión del recurso fijo que pueda proporcionar FlowItems especiales (Queue_Pallet). La segunda columna indica el número de elementos que el Combiner acepta de cada puerto como parte de la combinación deseada. Tal como se observa, esta

Figura 5.25. Programación del Source_Pallet a partir de la configuración del importador de datos MTEI a través de la ImportLine1.

138

SIMULACIÓN CON FLEXSIM

tabla nos permite hacer cosas bastante creativas con el Combiner, como hacer combinaciones dinámicas en la tabla con la intención de empacar una mezcla de productos diferentes definida por condiciones de alguna orden solicitada.

Nota: los cambios en la tabla de nombre Components List, se actualizan conforme a la tabla GlobaTable1 al dar Reset y ejecutar el modelo.

Para que usted pueda apreciar la imagen que se muestra en la figura 5.26, es necesario entonces que vincule al Combiner con la Tabla Global que ahora contiene los datos de las órdenes definidas en Excel agregadas a través de la configuración del importador MTEI. Esto se puede hacer dentro de la pestaña Triggers del Combiner, al elegir de la lista de selección de opciones OnEntry el comando Update Combiner Component List. Aquí dentro sólo es necesario hacer uso de la tabla "GlobalTable1" y posteriormente dar clic en Apply y Ok.

Figura 5.26. Programación del Combiner a partir de la GlobalTable1, configurada a través de la ImportLine2 del importador de datos MTEI.

Recuerde que el tiempo de operación del Combiner es una constante de 180 segundos. Productos Dado que los 10 Queues requieren suficientes productos para atender todas las órdenes solicitadas por los clientes, es necesario que desde el Source1 hasta el Source10 se tengan un Inter-Arrivaltime de cero. Dentro de cada uno de estos Sources deberá indicarse un color diferente para que cada uno muestre un producto

Capítulo 5. Aplicaciones y Usos Variados.

139

de color diferente. Usted puede hacer esto dentro de la pestaña Triggers de cada Source. No olvide agregar los textos con la ayuda de los recursos visuales de nombre “Text y Bilboard”. El resto de los recursos no requieren modificaciones, así que con esto hemos terminado la programación del modelo.

Figura 5.27. Presentación del modelo final.

Para saber a qué cliente corresponde la orden que prepara el Combiner mientras opera, usted puede cambiar la lógica de la programación y editar los códigos de una instrucción, busque dentro del apoyo visual “Text” la lista de selección Text Display, elija Display Label Value. Posteriormente, sustituya el comando (getlabelnum(involved,labelname),0,1) por getitemtype(first(involved)),0,1) contenido dentro del botón de edición de código de esta misma lista. Con ello podrá visualizar el ItemType de la orden que se prepara dentro del Combiner mientras el modelo es ejecutado.

140

SIMULACIÓN CON FLEXSIM

5.8. EJEMPLO: PROGRAMACIÓN DE AVERÍAS Y MANTENIMIENTO EN LOS EQUIPOS CON LA HERRAMIENTA MTBF/MTTR Un aspecto de cuidado en todas las empresas es sin lugar a duda el mantenimiento de los equipos, la maquinaria y sus instalaciones. Por tanto, este tema no se puede dejar de lado dentro de un modelo de simulación ya que un paro de los equipos, máquinas o personal programado o no, impacta directamente en la operación secuenciada de todo el sistema de producción. El objetivo general de este ejercicio es que el lector tenga claro que la herramienta MTBF/MTTR es de vital importancia en el empleo óptimo de los recursos a la hora de programar patrones de fallo y ejecuciones de mantenimiento, y como resultado de lo anterior será posible plantear diversas estrategias aplicables a cada objeto dentro de FlexSim que respondan lo más cercano posible al desempeño del sistema real. Lo que usted aprenderá es: 1. Cómo dividir y desempaquetar FlowItems de manera experimental. 2. Cómo establecer un programa de averías y mantenimiento. 3. Cómo hacer uso de un recurso móvil para ejecutar los mantenimientos. Ejemplo 9. Dentro de una pequeña empresa existen dos líneas de producción donde los productos son divididos y desempaquetados por dos Separators respectivamente. Además, debido al ritmo de trabajo los Separators fallan constantemente y necesitan ser reparados.

Descripción:  



Diseñe dos líneas de producción. Dentro de la 1er. línea existe un flujo constante de una caja cada 20 segundos. Las cajas son transportadas por un operador desde el Source hasta el Separator. Cada caja que entra al Separator es dividida en 5 y transportada al Sink de salida a través de una banda transportadora. La 2da. línea de producción inicia con dos Sources los cuales envían pallets y cajas respectivamente hacia un Combiner. El Combiner crea paquetes de una tarima con cuatro cajas a una velocidad de 10 segundos y los envía a un Separator a través de una banda transportadora. El Separator desempaca las

Capítulo 5. Aplicaciones y Usos Variados.



5.8.1.

cajas del pallet que las contiene a una velocidad constante de 15 segundos por paquete. Los dos separadores paran cada 15 minutos exponencialmente distribuidos y un operario tarda entre 1 y 2 minutos uniformemente distribuidos en arreglarlos: o MTBF para la frecuencia de falla exponential(0, minutes(15), 0) o MTTR para la reparación uniform(minutes(1), minutes(2), 0)

Conceptos Concepto 1: Separator El complemento de un Combiner es un Separator (separador) de FlowItems. Este es principalmente utilizado para unpack (desempaquetar) objetos que fueron empacados en un Combiner, o bien puede ser usado para Split (dividir) FlowItems. La ventana de propiedades de un Separator contiene también listas de selección de opciones para especificar tiempos de proceso, tiempos de preparación entre otros. Aquí el tiempo de proceso inicia tan pronto como un FlowItem llega al Separator. Los dos métodos disponibles empleados para separar son: 1. Unpack: Los FlowItems contenidos dentro de un FlowItem especial son separados. El flujo lógico predeterminado envía los “FlowItem contenedor” por el primer puerto de salida conectado y al resto de los FlowItems por los siguientes puertos. 2. Split: El FlowItem que entra al Separator es dividido o copiado sobre la base de las alternativas marcadas en la lista de selección de opciones correspondiente. Usted puede modificar estos parámetros para desempacar o dividir una cantidad fija o un número generado por una distribución específica al hacer combinaciones de las distintas opciones disponibles. Recuerde que el Separator también puede llamar a operadores para realizar una preparación, un proceso o una reparación.

141

142

SIMULACIÓN CON FLEXSIM

Concepto 2: Averías y Mantenimiento La herramienta MTBF/MTTR permite imitar fallas y mantenimientos en los equipos por distintas razones. Se pueden utilizar para establecer ruptura y tiempo de recuperación aleatorios de un grupo de objetos en el modelo. Cada herramienta MTBF/MTTR puede ser conectada en más de un recurso del modelo. Y cada recurso puede ser controlado por más de una herramienta MTBF/MTTR. Dicha herramienta permite especificar también el estado al cual los recursos entrarán en cuanto dejen de estar activos. La ventana MTBF/MTTR se puede activar dentro de la opción Toolsbox de la barra de herramientas y una vez activa se puede ver como esta se divide en tres pestañas (ver figura 5.28): 1. Members: En esta primer ficha usted puede añadir en una lista de miembros todos los recursos a los cuales desea aplicarles la programación de la herramienta MTBF/MTTR. Haga clic en el botón add object(s) para añadir objetos y seleccionar a los miembros del panel derecho. Si desea eliminarlos de la lista, seleccione el objeto y haga clic en el botón remove. 2. Functions: En esta ficha es posible especificar el tiempo en que un recurso suspenderá o reanudara sus operaciones cotidianas, a través de comandos triggers. - First Failure Time: Esta lista de selección devuelve la hora del primer fracaso o falla. - MTBF: Esta lista de selección devuelve el Mean Time Between Failure (Tiempo Medio Entre Fallas) de los objetos. La función determina el tiempo que esos objetos se ejecutarán antes de entrar en un estado descompuesto. - MTTR: Esta lista de selección devuelve el Mean Time To Repair (Tiempo Medio de Reparación) de los objetos controlados por esta herramienta. La función determina cuánto tiempo el recurso permanecerá en un estado descompuesto antes de reanudar sus operaciones normales. - Down Function: Esta lista desplegable se ejecuta cuando los objetos o recursos de la lista de miembros entran en estado de falla o descompostura. Se ejecuta una vez para cada objeto contenido en la lista de miembros. Es en esta función donde se especifica qué hacer para detener el objeto. Por ejemplo, se puede indicar la necesidad de llamar a una persona para que brinde mantenimiento a los equipos a través de una conexión central. - Resume Function: La lista de opciones se ejecuta cuando los objetos de la lista de miembros reanudan su operación. Se ejecuta una vez para cada objeto de la lista de miembros. Aquí es donde se especifica qué hacer para reanudar la operación del objeto.

Capítulo 5. Aplicaciones y Usos Variados.

-

-

143

On Break Down: Esta lista de selección se activa al mismo tiempo que la Down Function, pero sólo es ejecutada una vez, en lugar de una vez para cada objeto de la lista de miembros. On Repair: Esta lista de selección se activa al mismo tiempo que la Resume Function, pero sólo se ejecuta una vez, en lugar de una vez para cada objeto en la lista de miembros.

3. Breakdowns: La ficha de averías permite configurar un mayor grado de detalles al definir la forma en que un recurso se descompone.

5.8.2. Creación del modelo Seguramente usted puede resolver este ejercicio sin problema, para estar más seguros y no cometer errores puede echar un vistazo a las siguientes figuras (5.28 y 5.29):

Figura 5.28. Ventana de la herramienta MTBF/MTTR.

144

Figura Presentación modelo final.

SIMULACIÓN CON FLEXSIM

5.29. del

6

CAPÍTULO 6.

Un Modelo de Fluidos

ESQUEMA DEL CAPÍTULO 6.1 SIMULACIÓN DE FLUIDOS 6.1.1 Descripción del caso de estudio 6.1.2 Descripción de los objetos del modelo 6.1.3 Descripción de términos para el modelado de fluidos 6.2 CONSTRUCCIÓN DEL MODELO 6.2.1 Conexión de objetos 6.2.2 Configuración de los Objetos 6.3 EJECUCIÓN DEL MODELO OBJETIVOS DE APRENDIZAJE Este capítulo se desarrolla partiendo del entendimiento y uso del software, modelación, ejecución y análisis de las operaciones de un sistema híbrido (entidades discretas y material fluido). Una vez terminado este ejemplo, usted deberá tener una idea clara de cómo operan los objetos fluidos y sabrá: 1. 2. 3. 4.

Modelar fácilmente Materiales Fluidos. Convertir FlowItems en Material Fluido y Material Fluido en FlowItems. Transferir y almacenar Material Fluido. Utilizar marcas de nivel para mantener el control de volumen en los tanques contenedores. 5. Podrá mezclar tanto Materiales Fluidos como Discretos.

146

SIMULACIÓN CON FLEXSIM

6.1. SIMULACIÓN DE FLUIDOS Dentro de algunos procesos industriales se emplea material fluido, como en plantas químicas y refinerías de petróleo. Al simular este tipo de sistemas debe tomarse en cuenta que el estado de los elementos del sistema cambia continuamente en el tiempo. No obstante, la mayoría de los trabajos de investigación publicados en áreas de simulación están centrados principalmente en la simulación de eventos discretos (aquellos que cambian en determinados instantes del tiempo). Además, no todos los sistemas simulados son necesariamente continuos o discretos, sino una combinación de ambos, a lo que algunos autores llaman como modelos híbridos o de cambio continuo-discreto (Law et. al., 2007 y Kelton, et. al., 2008). Algunos paquetes de simulación que tienen la capacidad de controlar tanto eventos discretos como continuos en la misma aplicación son; FlexSim, Extend, Arena, y WITNESS (Beaverstock et. al., 2012). En la presente sección se desarrollará un caso de estudio sencillo de un modelo híbrido, para poder describir el uso y manejo del software. Sin embargo, la construcción de un modelo con estas características requiere de mucha atención, pues a pesar de ser relativamente sencillo, existen detalles que no se deben pasar por alto, así que póngase cómodo, disfrute y aprenda como construir un modelo híbrido.

6.1.1.

Descripción del caso de estudio Ejemplo 10. Una planta productora de lácteos elabora un postre llamado DasaFrut en algunas de sus líneas de producción. La preparación del postre requiere de dos ingredientes: por un lado utiliza leche pasteurizada contenida en cubetas de 25 litros cada una y por otro lado, toma el preparado de fruta ya estabilizada en cubetas de 5 litros. La leche pasteurizada es tomada del Almacen1 y enviada hasta el Tanque FluidTank1. Para realizar dicho envío, es necesario que un operario tome las cubetas del Almacen1 y las lleve hasta un ItemToFluid1 para que la leche sea vertida a través de una tubería al Tanque FluidTank1. El preparado de fruta estabilizada es enviado hacia un segundo Tanque FluidTank2, donde otro operario toma las cubetas del Almacen2 y las lleva hasta un segundo ItemToFluid2 para que la fruta sea depositada a través de una tubería al Tanque FluidTank2. Una vez contenidos los ingredientes en ambos tanques respectivamente, la leche y la fruta se conduce hacia el área de mezclado por tuberías en proporciones variadas. Después de que el producto es

Capítulo 6. Un Modelo de Fluidos

147

mezclado pasa a un proceso de fermentación y finalmente se entrega a un FluidToItem para crear porciones de 500 ml. Las porciones salientes de la máquina FluidToItem ahora son llamadas Postre y necesitan de un recurso Combiner para ser envasadas una en cada frasco (ver figuras 6.1 y 6.2).

Figura 6.1. Diagrama de flujo de producción de postres.

6.1.2. 

   





Descripción de los objetos del modelo

Tanto los FlowItems (cubetas de leche pasteurizada) como los FlowItems (cubetas de preparado de fruta) llegan a una tasa exponential(0, 10, 0) segundos. El contenido máximo del ItemToFluid1 y ItemToFluid2 es de 100 y 20 litros, respectivamente. Las unidades de leche pasteurizada por cada unidad discreta son de 25 litros por cada FlowItem (cubetas de leche pasteurizada) que entre al ItemToFluid1. Las unidades de preparado de fruta por cada unidad discreta es de 5 litros por cada FlowItem (cubetas de preparado de fruta) que entre al ItemToFluid2. La tubería FluidPipe1 que conduce al tanque FluidTank1 tiene una capacidad de contenido máximo de 12 litros y la velocidad de transferencia del ItemToFluid1 al FluidTank1 es de 10 litros por segundo. La tubería FluidPipe2 que conduce al tanque FluidTank2 tiene una capacidad máxima de 20 litros y la velocidad de transferencia del ItemToFluid2 al FluidTank2 es de 2 litros por segundo. La capacidad de los tanques FluidTank1 y FluidTank2 es de 100 litros y 20 litros, respectivamente. Para ambos tanques la marca de tanque inferior es de

148

SIMULACIÓN CON FLEXSIM





 





1 litro y la marca de tanque superior es de 85 y 18 litros respectivamente. Las dos tuberías (FluidPipe3 y FluidPipe4) que conducen al FluidMixer tienen una capacidad máxima de 5 litros y la velocidad de transferencia de los tanques FluidTank1 y FluidTank2 al FluidMixer es de 10 y 2 litros por segundo, respectivamente. Descripción para el mezclado: o Mixer Steps: - Paso 1: EntradaLinea1, 5 segundos de retraso. - Paso 2: EntradaLinea2, no hay tiempo de retardo. o Mixer Recipe - Leche pasteurizada: 10 litros, paso 1. - Preparado de fruta: 3 litros, paso 2. El contenido máximo y la velocidad del FluidProcessor no es relevante, manténgase como está definido. El contenido máximo del FluidToItem es de 0.5 litros y las unidades de líquido por unidad discreta entregadas son de 0.5 litros por FlowItem, estos nuevos FlowItems son llamados Postre. Los FlowItems (frascos) llegan al sistema cada 1.5 segundos de un tercer almacén y son enviados mediante una banda transportadora hasta el Combiner. Al Combiner llegan tanto frascos como FlowItems postres y son envasados a la velocidad de 3,600 frascos por hora, es decir 1 frasco por segundo.

6.1.3. Descripción de términos para el modelado de fluidos Para poder iniciar con la construcción del modelo es necesario entender algunos términos interesantes del módulo de fluidos del software FlexSim ya que son necesarios para el desarrollo del modelo: –

Fluid. En FlexSim, un fluido es cualquier material que no es fácil o eficazmente modelado como un FlowItem discreto. Generalmente es un material que se mide por peso o volumen. Además, los materiales fluidos también pueden representar objetos que son muy numerosos y que como FlowItems no son prácticos de manejar, por ejemplo: miles de tomates formados en una línea de lavado pueden ser modelados como material fluido sin la necesidad de utilizar un FlowItem para cada tomate que sobrecargue y

Capítulo 6. Un Modelo de Fluidos

–

–

–

–

–

–

disminuya la velocidad del sistema. Fluid Objects. Existen doce objetos que están diseñados para manejar material fluido. Diez de estos no pueden interactuar con los objetos discretos de FlexSim, pero dos de ellos (ItemToFluid y FluidToItem) están diseñados para funcionar como interfaz entre los objetos de fluidos y los objetos discretos. Esto permite al modelador convertir FlowItems en el líquido y el líquido en FlowItems. Tick. Los Fluid Objects envían y reciben material en intervalos fijos. Estos intervalos se llaman "Ticks". Al final de cada Tick, los Fluid Objects calculan la cantidad de material que enviaron y recibieron durante ese periodo de tiempo. Tick Time. Duración de cada Tick. El modelador puede establecer este valor a un valor que sea apropiado para su modelo. Entre más corto sea el Tick Time, el modelo será más preciso, pero también puede hacer que este sea más lento. Un valor más grande permitirá una mayor rapidez en la ejecución del modelo, pero el costo será una pérdida de precisión. Entonces el equilibrio de precisión y velocidad está sujeto a las necesidades del modelador. Rate. Tasa de velocidad máxima a la que el material entra o sale de un objeto. En general, los objetos fluidos tienen tanto una velocidad de entrada como una velocidad de salida, estás permanecen separada una de otra. En algunos objetos, la velocidad a la que el material entra afectará la velocidad a la que sale. Para estos objetos, al modelador no se le da la oportunidad de editar la velocidad de salida. La velocidad real a la que el material entra o sale se basa en varios factores: la velocidad de salida del objeto con un flujo a contracorriente o corriente arriba, la velocidad de entrada del objeto corriente abajo, la cantidad de material disponible para enviar y la cantidad de espacio disponible en el objeto corriente abajo. Object Rate. Ésta es la tasa o velocidad máxima a la que el material puede entrar o salir de un objeto a través de todos los puertos de entrada o salida juntos. Los objetos tienen típicamente una velocidad diferente para los puertos de entrada y los puertos de salida. Si al final de cualquier Tick el objeto calcula que la cantidad de material enviada o recibida ha alcanzado la velocidad máxima del objeto, el envío y recepción de material será suspendido por el Tick, incluso si hay puertos que aún no envían o reciben material. Port Rate. Ésta es la tasa de velocidad máxima a la que el material puede entrar o salir de cualquier puerto en el objeto. Los objetos normalmente tienen diferentes velocidades en sus puertos de entrada y puertos de salida. Este

149

150

SIMULACIÓN CON FLEXSIM

–

valor únicamente se aplica a todos los puertos de entrada o salida, y el parámetro no puede ser alterado para afectar puertos individuales. Port Scale Factor: Este número es empleado para cambiar la velocidad de un puerto pero de manera individual. El valor de cada puerto es multiplicado por la velocidad máxima del mismo para encontrar la velocidad máxima actual por cada puerto.

Con todo lo que se ha revisado hasta ahora, seguramente no se tendrán dificultades en la creación, manipulación de propiedades y conexión de objetos, así que iniciemos.

6.2. CONSTRUCCIÓN DEL MODELO Para la construcción del modelo se inicia creando una nueva hoja de trabajo (New Model) en FlexSim. Posteriormente, se eligen de las bibliotecas Discrete o Fluid Objects los recursos necesarios y se arrastran al área de trabajo (véase figura 6.2). Los objetos necesarios para este caso de estudio son:             

3 Sources de nombre Almacen1, Almacen2 y Almacen3 (Discrete Objects). 2 Operators de nombre Operator1 y Operator2 (Task Executers). 2 ItemToFluids de nombre ItemToFluid1 y ItemToFluid2 (Fluid Objects). 2 FluidPipes de nombre FluidPipe1 y FluidPipe2 (Fluid Objects). 2 FluidTanks de nombre FluidTank1 y FluidTank2 (Fluid Objects). 2 FluidPipes más de nombre FluidPipe3 y FluidPipe4 (Fluid Objects). 1 FluidMixer de nombre FluidMixer (Fluid Objects). 1 FluidProcessor de nombre FluidProcessor (Fluid Objects). 1 FluidToItem de nombre FluidToItem (Fluid Objects). 3 Conveyors de nombre StraightConveyor1, StraightConveyor2 y StraightConveyor3 (Discrete Objects). 1 Combiner para envasar el postre en los frascos (Discrete Objects). 1 Sink (Discrete Objects). 1 Objeto Visual para colocar un texto que indique el avance del tiempo (Visual Objects).

Capítulo 6. Un Modelo de Fluidos

Observe que cuando arrastra el primer objeto de fluidos al área de trabajo, automáticamente un Ticker es creado en la posición (0, 0) del área de trabajo. Este mismo, puede moverse de un punto a otro dentro del área de trabajo, pero por ningún motivo lo elimine, pues es fundamental para trabajar con objetos de fluidos.

Nota: si usted está trabajando con una versión de prueba previa a la 7.7.0 podrá darse cuenta que no hay ningún problema con la cantidad de objetos y conexiones que se hagan entre estos. Sin embargo, dadas las características del nuevo Conveyor en la versión más reciente, cada segmento de la banda transportadora que alimenta de botellas vacías al sistema se cuenta como un objeto individual por lo que al intentar conectar el total de los objetos se producirá un error el cual indicará que se ha rebasado el límite de objetos permitidos (Model size limit was reached). Para corregir lo anterior y poder concluir con éxito su modelo será recomendable usar sólo un segmento para representar la banda transportadora y quizá eliminar algún otro objeto que no afecte drásticamente la operación de su modelo.

6.2.1. Conexión de objetos Después de arrastrar los objetos al área de trabajo, es necesario conectarlos. La conexión de objetos fluidos se hace de la misma forma con la que conecta objetos discretos: presionando la tecla “A” y dando clic en los objetos a conectar se crea una conexión de entrada/salida y la tecla “S” crea una conexión de puerto central. Recuerde que los objetos deben ser conectados de acuerdo con el diagrama de flujo de producción mostrado en la figura 6.1. Para este caso de estudio, las conexiones son las que se listan a continuación: – – – – – – –

Del Almacen1 al ItemToFluid1 Del ItemToFluid1 al FluidPipe1 Del FluidPipe1 al FluidTank1 Del FluidTank1 al FluidPipe3 Del FluidPipe3 al FluidMixer Del FluidMixer al FluidProcessor Del FluidProcessor al FluidToItem

151

152

SIMULACIÓN CON FLEXSIM

– – – –

Del FluidToItem al Conveyor2 Conectar también del Almacen3 al Conveyor1 y del Conveyor1 al Combiner Del Conveyor2 al Combiner donde se espera la llegada de frascos Del Combiner al Conveyor3 y al Sink

Lo anterior se repite con una línea de conexiones paralela pero desde el Almacen2 al FluidMixer. Nota: no se preocupe ahora por la estética de su modelo, ya que cada objeto tomará forma mientras se avanza en la programación del mismo.

El Almacen1 y el Almacen2 llaman a un operador distinto para transportar los FlowItems hasta el ItemToFluid, por lo que los Operators deberán tener una conexión de puerto central tanto del Almacen1 como del Almacen2, respectivamente (véase la figura 6.2).

Figura 6.2. Imagen del modelo final en ejecución.

6.2.2.

Nota: si desea cambiar el color de los FlowItems puede usar el comando Set Color de la opción OnExit de la pestaña Triggers.

Configuración de los Objetos Configuración de los Sources (ver figura 6.3). Dado que el valor predeterminado del tiempo de llegada del Almacen1 y del Almacen2 es funcional para este modelo, debe dejarse tal y como está. Únicamente se indica a cada uno de los dos Sources, la instrucción que permite llamar a cada Operator según corresponda para que se lleve los FlowItems creados hasta los dos objetos ItemToFluids (Use Transport de la pestaña Flow). Respecto al Almacen3 sólo es necesario escoger de la lista de selección de opciones FlowItem Class la alternativa Cylinder para representar a los frascos. Finalmente en este mismo Source se debe configurar el campo Inter-Arrivaltime a 1.5 segundos.

Capítulo 6. Un Modelo de Fluidos

153

Figura 6.3. Ventana de propiedades del Almacen1 y Almacen3.

Configuración del color de los objetos. Siempre que un objeto es creado se personaliza con diferentes colores dependiendo de su clase, pero a menudo es útil asignarles un color correspondiente al material que se esté procesando. Dado que en este modelo hay dos líneas de procesamiento compuestas cada una por un ItemToFluid, FluidPipe, FluidTank y otro FluidPipe es necesario identificar a cada línea con un color distinto. Abra la ventana de propiedades de cada uno de los cuatro objetos y cambe el color a un blanco para la línea de leche y a los objetos de la línea de fruta asignarles un verde. Esto hará que los objetos cambien de color cuando estén en funcionamiento, siempre y cuando se tenga producto en ellos. Para ejemplificar lo anterior a continuación se exponen tres pasos y se muestra la figura 6.4 para más detalle: 1. Hacer doble clic en ItemToFluid1 para abrir la ventana de propiedades de ese objeto y dar clic en la pestaña General. 2. Hacer clic en el botón situado a un costado del campo de Color. Una tabla de colores aparecerá. Seleccionar el color blanco con un clic.

Figura 6.4. Ventana de propiedades del ItemToFluids1.

154

SIMULACIÓN CON FLEXSIM

3. Hacer clic en Apply y Ok para aceptar los cambios y cerrar la ventana de propiedades. Repetir estos pasos para el resto de los objetos mencionados anteriormente. Los objetos de una línea de procesamiento deberán ser de color blanco (línea leche) y los de la otra línea de color verde (línea fruta). Configuración de los ItemToFluids. Para crear la proporción correcta de material fluido por cada FlowItem que entre a los objetos ItemToFluids, es necesario dotar a cada uno de estos últimos objetos con ciertas condiciones: 1. Hacer doble clic en el ItemToFluid1 para abrir su ventana de propiedades. En la pestaña ItemToFluid cambiar el valor de la opción Discrete Units per Flowitem por 25. Esto indicará al ItemToFluid1 que deberá crear 25 litros de leche por cada FlowItem (cubetas de leche pasteurizada) que entre. 2. Cambiar el Maximum Object Rate y la Maximum Port Rate por un valor de 2. 3. Dentro de la opción Maximum Content deje el valor de 100 ya preestablecido. 4. Hacer clic en Apply y Ok para aplicar los cambios y cerrar la ventana de propiedades (véase la figura 6.5).

Figura 6.5. Configuración de proporciones, velocidad y capacidad del objeto ItemToFluid1.

Repetir estos pasos para el ItemToFluid2, no olvide cambiar su capacidad máxima a 20 litros e indicar la necesidad de crear 5 litros de fruta por cada FlowItem (cubetas de preparado de fruta) que entre al ItemToFluid2.

Configuración de los FluidPipes. Las tuberías que conducen el material fluido de un objeto a otro son llamadas FluidPipes y necesitan ser configuradas. Una tubería no permite al modelador especificar la tasa o velocidad a la que entra o sale el material fluido. La velocidad de salida se basa en la misma velocidad con la que el material fluido fue recibido, para configurar se deben realizar los siguientes pasos (ver la figura 6.6):

155

Capítulo 6. Un Modelo de Fluidos

1. Hacer doble clic FluidPipe1 para abrir su ventana de propiedades. 2. En la pestaña Pipe, cambiar la Maximum Flow Rate a 10 y establecer un Maximum Content de 12 litros. Esto asegurará que el material fluido (leche) pase a una velocidad de 10 litros por segundo. 3. Posteriormente, para cambiar las dimensiones, añadir secciones y definir la dirección de la tubería, hacer clic en la pestaña Layout. La tubería dentro del modelo deberá iniciar desde ItemToFluid1 y terminar hasta un punto cercano al FluidTank1 (agregar tantas secciones como crea conveniente) y manipule estos parámetros con valores distintos hasta lograr la forma deseada. Cambiar el diseño o estructura no afecta el comportamiento de las tuberías. 4. Hacer clic en el botón Apply y Ok para aplicar los cambios y cerrar la ventana de propiedades.

Figura 6.6. Configuración FluidPipe1.

Especifique esto mismo en la segunda tubería FluidPipe2, pero con un contenido máximo de 20 y una velocidad de flujo de 2 litros por segundo. No olvidar modificar el diseño para representar el envío de material fluido del ItemToFluid2 hasta el FluidTank2.

del

156

SIMULACIÓN CON FLEXSIM

Configuración de los FluidTanks. El FluidPipe1 ahora tiene una tasa de salida máxima de 10 litros por segundo, pero el FluidTank1 tiene una tasa máxima de entrada 1. Si estos valores se dejan como están, la tasa de los FluidTank1 se utilizará durante la ejecución del modelo (ya que se toma el menor de los valores) y el FluidPipe no será capaz de enviar material corriente abajo tan rápido como se ha especificado. Así que la tasa en los FluidTanks necesita ser cambiada. Cualquier FluidTank permite al modelador establecer tres niveles que actúan como disparadores para liberar material cuando el contenido del FluidTank alcanza un nivel deseado. Estos valores se denominan Marks (marcas) y pueden editarse en la pestaña de Marks contenida en la ventana de propiedades del objeto. En este modelo, los tanques deben mantener sus puertos de salida cerrados hasta que hayan recibido una cierta cantidad de material. Al alcanzar la marca especificada, los puertos de salida se abrirán y se quedarán abiertos hasta que el tanque se vacíe o llegue a una marca inferior definida. Los tanques siempre van a mantener sus puertos de entrada abierta. A continuación se mencionan los pasos a seguir para la configuración de los FluidTanks: 1. Hacer doble clic en FluidTank1 y en la pestaña Tank, cambiar el Maximum Object Rate y la Maximum Port Rate por el valor de 10, tanto en la entrada como en la salida (Input Ports, Output Ports). 2. Dentro de la opción Maximum Content deje el valor asignado de 100 tal y como esta. 3. Posteriormente, haga clic en la ficha Marks y cambie el valor de Low Mark (marca inferior) por el de 1, y el de High Mark (marca superior) a 85. La Mid Mark (marca media) deberá permanecer en 0. Si una marca tiene el valor 0, el detonante de esa marca nunca se disparará (véase la figura 6.7). 4. En esta misma pestaña (Marks), ubíquese en la lista de opciones “Passing Low Mark” y dé clic en la cruz verde para agregar la activación de la función, seleccionar aquí dentro la alternativa Open or Close Ports. Dentro de esta opción, configure la instrucción de tal forma que esta sea semejante a lo que se muestra en la misma imagen superior izquierda de la figura 6.7. 5. Además agregue la opción Open or Close Ports para ejecutar una función Passing High Mark semejante a los parámetros mostrados en la imagen inferior izquierda de la misma figura 6.7. 6. Para finalizar dé clic en Apply y Ok para aplicar los cambios y cerrar la ventana de propiedades. Repetir los pasos anteriores para el FluidTank2, indicando una Capacidad Máxima de 20. Además, la Tasa o Velocidad Máxima del Objeto y Puerto deberá ser de 2. Recuerde configurar una Marca Inferior de 1 y una Superior de 18 con sus

Capítulo 6. Un Modelo de Fluidos

157

respectivas instrucciones.

Figura 6.7. Configuración de las operaciones Mark del tanque FluidTank1.

Orientación y tamaño de las tuberías restantes. Para seguir avanzando en el proceso de diseño del modelo, es necesario orientar los siguientes dos tubos (FluidPipe3 y FluidPipe4) hacia el mezclador llamado Mixer. Tenga en mente que el comportamiento de los tubos no se afecta si se cambia su estructura. Utilizar la pestaña de diseño Layout para configurar las tuberías de tal modo que se visualicen como se desea: 1. Hacer doble clic en FluidPipe3 para abrir su ventana de propiedades. En la pestaña Pipe, cambiar el Contenido Máximo a 5 y la Tasa de Velocidad Máxima de Flujo ajustarla a 10. Con esto se asegura que el material saliente de los tanques toma sólo un poco de tiempo para llegar hasta el mezclador. 2. Modi ficar el diseño de la tubería de tal forma que se visualice una conexión entre el FluidTank1 y el FluidMixer. Repetir estos pasos para el FluidPipe4, pero con un Maximum Content de 5 y un Maximum Flow Rate de 2.

Configuración de la entrada y mezcla de material fluido dentro del FluidMixer. Un mezclador de fluidos es capaz de procesar dos o más materiales para combinarlos en uno nuevo. Esto se puede hacer al manipular la tabla contenida en la pestaña Steps ubicada dentro de la ventana de propiedades del FluidMixer. La tabla Mixer Steps, se utiliza para definir una serie de pasos que el mezclador realiza en cada lote que

158

SIMULACIÓN CON FLEXSIM

procesa. En este modelo, es necesario programar dos pasos dentro de la tabla Mixer Steps. El mezclador deberá jalar 10 litros del primer material (leche pasteurizada) por el puerto de entrada 1 durante el Paso 1. Después, se deberán jalar 3 litros del segundo material (preparado de fruta) desde el puerto de entrada 2 durante el paso 2. 1. Haga doble clic en FluidMixer para abrir su ventana de propiedades y dé clic en la pestaña Steps. 2. Dentro del campo Number of Steps se asigna el valor de 2 para agregar dos pasos en la tabla y dé un clic en Update para actualizar la tabla. La descripción de los pasos no es importante, estos pueden ser llamados como se considere conveniente (aquí se nombra como EntradaLinea1 y EntradaLinea2). El tiempo de retardo (delay) de cada paso es ejecutado después de que todo el material de este paso es recibido, y antes de que el mezclador comience a recibir el material del siguiente paso. Ajuste el tiempo de retardo para el paso de 1 a 5 segundos y el tiempo de retardo para el paso de 2 a 0 segundos (observar la figura 6.8). 3. Posteriormente, dentro de la tabla Mixer Recipe, cambie el número de ingredientes a 2 y dé un clic en Update para actualizar la tabla. Esta acción ha creado dos listas de ingredientes. Una vez más la descripción de cada ingrediente puede ser definida como se desee, ya que esto no afecta al modelo. En este caso, los llamaremos LechePasteurizada y PreparadoDeFruta.

Figura 6.8. Configuración de la entrada y mezcla de ingredientes dentro del FluidMixer.

 Dentro de LechePasteurizada, ajuste el Port a 1, Amount a 10, y Step a 1.  Dentro de PreparadoDeFruta, ajuste el Port a 2, Amount a 3, y Step a 2.

Con estos simples cambios, podrá observarse como el objeto mezclador jala primero 10 litros leche pasteurizada por el puerto de entrada 1 durante el Paso 1 y después, toma 3 litros de preparado de fruta desde el puerto de entrada 2 durante el paso 2 para lograr la mezcla deseada.

Capítulo 6. Un Modelo de Fluidos

La pestaña FluidLevelDisplay de este mismo objeto, es una herramienta útil para visualizar un indicador de nivel durante la ejecución del modelo. En dicho indicador será mostrada la cantidad recibida de cada material correspondiente con la tabla Mixer Recipe en cualquier punto del tiempo simulado. Esta herramienta se encuentra visible por defecto, pero se puede ocultar si hace clic y desactiva la pestaña FluidLevelDisplay. Si es asignado el valor de 1 en el campo “Y” de la fila posición, la barra indicadora pasará al frente del Mixer. De la misma forma puede manipular el resto de los campos hasta conseguir un efecto más realista (véase la figura 6.9). Configuración del FluidProcessor. Los valores con los cuales opera el procesador de fluido son adecuados para este modelo, por lo que no es necesario modificarlos. El material fluido es recibido por el puerto de entrada 1, y procesado por una cierta cantidad de tiempo para salir después por el puerto de salida 1 con dirección al objeto siguiente “FluidToItem”. La cantidad de tiempo invertido en el proceso, se basa en el Maximum Content y en la Maximum Output Rate que el modelador define dentro de la ventana de propiedades del FluidProcessor en la pestaña FluidProcessor. Se pueden modificar estos valores si desea ver como la operación del objeto afecta al modelo. Para hacer visible la barra indicadora de nivel de este objeto dentro de la pestaña FluidLevelDisplay repita la acción realizada en el objeto anterior. Configuración del FluidToItem. El objeto que transforma el material fluido en FlowItems se llama FluidToItem. Este objeto multiplica el material fluido por las unidades discretas deseadas para determinar la cantidad de material que deberá constituir una sola pieza o Flowitem. En este modelo, 0.5 litros de material fluido se convertirá en 1 FlowItem y este nuevo FlowItem será llamado Postre (lea los siguientes pasos y obsérvese la figura 6.10). 1. Haga doble clic en el FluidToItem para abrir la ventana propiedades del objeto. En la pestaña FluidToItem, busque el campo llamado Fluid per Discrete

159

Figura 6.9. Configuración del indicador de nivel del FluidMixer.

160

SIMULACIÓN CON FLEXSIM

Unit y asigne un valor de 0.5 para indicar que por cada medio litro de material fluido se deberá crear un FlowItem o porción de Postre.

Figura 6.10. Configuración del objeto FluidToItem para crear el FlowItem “Postre”.

Nota: dentro de este objeto puede cambiar el aspecto del FlowItem de salida tal como su forma, tamaño, color, etc.

2. En esta misma pestaña cambie el Contenido Máximo a 0.5. Esto le dice al objeto que en todo momento sólo puede recoger material fluido suficiente para 1 FlowItem. Si este valor es mayor, el FluidToItem formará una línea de espera y con ello se creará demasiado espacio de almacenamiento en el modelo. 3. Dentro del campo Flowitem Name, escriba “Postre”. Así, todos los nuevos FlowItems serán llamados Postre. 4. Dar clic en Apply y acontinuación en Ok para guardar los cambios.

Configuraciones finales. Una vez terminada la configuración del objeto FluidToItem, se programan los siguientes objetos: 



Para este modelo, los Conveyors se mantienen con sus propiedades de inicio pero deberán ser indicadas sus dimensiones y dirección hasta lograr el diseño deseado. Al Combiner llegan tanto FlowItems (frascos) como FlowItems (Postres). Para que la velocidad de envase sea de 3,600 frascos por hora, en el campo Process Time de la ventana de propiedades del Combiner, coloque el valor de 1 para indicar que sea envasado un frasco por segundo. En la pestaña Combiner elegir el modo de combinar Join para visualizar en la salida sólo un producto. Para concluir la programación de este objeto, en la pestaña

Capítulo 6. Un Modelo de Fluidos



161

Triggers, puede cambiar el color de los frascos de salida a un color azul. Por último, no olvide agregar un Visual Text al modelo, en el cual se indique la hora, el día, el mes y el año en que su modelo es ejecutado.

6.3. EJECUCIÓN DEL MODELO Para ejecutar el modelo, defina el tiempo de simulación (por ejemplo, 576,000 segundos), y después de clic en la opción Reset y Run. Una vez que el modelo esté corriendo, obsérvese como las tuberías parpadean. Si una tubería se muestra de color gris, significa que está vacía. Si se trata de un color opaco, el material fluye a través de la tubería, y si se trata de un color vivo o brillante el material está bloqueado. Además, puede verse cómo la barra indicadora de los objetos baja y sube de nivel conforme entra y sale el material fluido. Finalmente se podrá ver como FlowItems son transformados en líquido y en una etapa posterior el líquido es transformado en FlowItems (véase la Figura 6.11).

Figura 6.11. Presentación del modelo final.

Comentarios finales. Después de haber construido su propio modelo en FlexSim el modelador deberá tener una idea clara de como operan los objetos fluidos en FlexSim. Sin embargo, hay mucho más por aprender. Lea la guía incluida en el software FlexSim y pronto podrá crear opciones y configuraciones diferentes en modelos más grandes, complejos y realistas, basados en el uso de material fluido.

162

SIMULACIÓN CON FLEXSIM

Compendio de problemas 1. Dentro de una empresa farmacéutica es necesario representar la producción de dos diferentes productos, como se muestra en la figura C_1:

Figura C_1. Problema “Empresa farmacéutica”.

Los dos productos, llegan al sistema a través de dos objetos Source. El Producto_A llega a una velocidad exponencialmente distribuida con una media de 2 (todos los tiempos están en minutos). Al llegar, este producto se envía de forma instantánea al área de acondicionado no.1, donde se limpia y etiqueta a razón de una distribución triangular(1, 4, 8, 0). Posteriormente, las partes son enviadas al área de lotificado. El Producto_B, se produce en un departamento diferente y llega al sistema agrupado en paquetes de 3 unidades; estos paquetes de productos arriban al sistema cada 7 minutos exponencialmente. Al llegar el paquete hasta el área de acondicionado número 2, este es separado en tres unidades individuales, aquí, el tiempo de operación observa también una distribución triangular pero con un número mínimo de 2, un número máximo de 8 y una moda de 4. Subsiguientemente cada producto es enviado de manera automática y de forma individual a la misma área de lotificado que emplea el Producto_1. Dentro del área de lotificado, tanto en el Producto_A como en el Producto_B se imprime automáticamente la fecha del producto, el vencimiento y el número de lote. El tiempo invertido en el lotificado de cada producto, depende del tipo de producto: normal(1, 0.2, 0) para el Producto_1 y lognormal2(0, 2.5, 0.5, 0) en caso del Producto_2 (el valor del primer 0 corresponde a la localización, el 2.5 a la escala, el 0.5 a la forma y el último 0 es el valor de la semilla). El 5% de las

164

SIMULACIÓN CON FLEXSIM

piezas no son lotificadas adecuadamente pues presentan defectos de impresión, por lo que de manera inmediata son enviadas al área de reproceso donde son reparadas en un tiempo constante de 5 minutos por producto sin importar de que tipo sea. A la salida del área de reproceso, las piezas son inspeccionadas nuevamente y se tiene evidencia de que sólo el 60% de estas piezas reprocesadas pasan esta última prueba de calidad. Las piezas que no pasan la prueba de calidad son depositadas en un cesto de basura, pero el resto de las piezas buenas obtenidas tanto en el área de lotificado como en el área de reproceso son almacenadas para ser dispuestas a los clientes. Actividades: Ejecute el modelo por un turno de 8 horas o 480 minutos y al final cree un informe completo con la herramienta Reports and Statistics. Observe en las estadísticas colectadas cual fue el desempeño de los recursos, indique donde se crearon cuellos de botella y explique porqué, determine además el tiempo promedio que cada producto permaneció en el sistema y finalmente cuente el número de piezas que fueron enviadas tanto al almacén de clientes como al cesto de basura. 2. La empresa de Luis se compone por un sistema sencillo de dos procesos en serie. Al sistema los artículos llegan con una media de tiempo entre llegada de 3 minutos, siendo la primera llegada en un tiempo 0. Inmediatamente los productos son enviados al centro de maquinado 1 el cual opera a una velocidad media de 2 minutos por pieza. Terminada esta primer operación, los productos son enviados al centro de maquinado 2 (ambos maquinados son independientes, pero operan bajo las mismas condiciones), a través de un operario. Automáticamente, los artículos salen del sistema después de completar el maquinado 2. Actividades: Simule cuatro escenarios diferentes con un tiempo de 2,400 minutos cada uno. Las medidas de desempeño de interés son los diferentes estados (idle, processing, busy, blocked, etc.) de cada centro de maquinado y del operario, la cantidad de artículos procesados y el tiempo total que un artículo pasa en el sistema. -

Escenario 1: El Inter-Arrivaltime del Source y el Process Time de los centros de maquinado son constantes. Escenario 2: El Inter-Arrivaltime del Source es constante y el Process Time de los centros de maquinado es exponencial. Escenario 3: El Inter-Arrivaltime del Source es exponencial y el Process Time de los centros de maquinado es constante. Escenario 4: El Inter-Arrivaltime del Source y el Process Time de los centros de maquinado son exponenciales.

Compendio de Problemas.

165

3. En un negocio familiar, seis tornos trabajan de manera independiente. Cada torno está activo (en operación) entre 7 y 8 horas (distribuidas uniformemente) y después se detienen para entrar en mantenimiento. Existen dos operarios que dan servicio a los tornos, un operario invierte entre 30 y 60 minutos uniformemente distribuidos en el mantenimiento de un torno; únicamente un operario puede asistir en el mantenimiento de un torno a la vez aun si el otro operario está disponible para trabajar. Si la cantidad de tornos descompuestos es superior a dos, se creará una línea de espera virtual de tareas secuenciadas que será atendida hasta que algún operador esté disponible. Cada operador trabajará en el mantenimiento de un torno hasta que esté completamente listo para operar nuevamente, sin importar lo que esté ocurriendo en el sistema. Absolutamente todos los tiempos de operación y de mantenimiento son independientes de cualquier otro. Actividades: Simule esté modelo por un total de 44 horas e identifique y grafique el número de tornos que se encuentran en mantenimiento o en espera de mantenimiento durante el tiempo simulado y defina los diferentes estados (idle, processing, busy, blocked, etc.) de cada operario. 4. Spheres (esferas) llegan cada 5 segundos exponencialmente a un sistema de producción. Inmediatamente después de que llegan las esferas al sistema, estas son almacenadas en un Queue para esperar su turno en el centro de pintura. El proceso de pintado de cada una de las esferas corresponde a una distribución lognormal2(0, 6.2, 0.20, 5) segundos. Al concluir el proceso de pintura, cada esfera sale con un color diferente, mismo que es definido de acuerdo con una distribución duniform(1, 4). Posteriormente, mediante cuatro diferentes bandas transportadoras las esferas son enviadas al área de empaque según corresponda con su color (véase la figura C_2). El empaque se hace a una velocidad constante de 10 segundos y por cada tarima entrante se agrupan cinco esferas del mismo color.

Figura C_2. Problema “Esferas”.

166

SIMULACIÓN CON FLEXSIM

Actividades: Ejecute al modelo por 10,000 segundos y determine la cantidad de tarimas empacadas de cada uno de los diferentes colores de esferas. Nota: para agregar los colores a las esferas, en la pestaña Triggers del área de pintura (Processor) active el comando Set Itemtype and Color contenido en la lista de selección de opciones OnEntry. El flujo correspondiente con el color de la esfera deberá programarse en la lista Send To Port con el comando Port By Case (véase la figura C_2). 5.

Una línea de producción automática contiene seis estaciones de trabajo, estas son antecedidas por un Queue para representar una fila de espera si fuese necesario. Los tiempos de cada estación de trabajo están en segundos y son constantes: 20, 20, 22, 22, 24, 14. Los arribos de las piezas al sistema corresponden a una exponential(0, 18, 0); igualmente en segundos. Se asume que la transferencia de piezas en todas las estaciones de trabajo es despreciable o de tiempo cero con excepción de las piezas movidas por el operario. Después de haber concluido la tarea de la estación 2 la pieza es valorada, si la misma esta defectuosa se almacenará en un contenedor hasta que un operario la tome y la transporte a la primera posición de la fila de espera de la estación 1 para ser atendida inmediatamente. Esta valoración es aplicable para las estaciones 2, 3, 4, 5, 6 y en todos los casos la pieza defectuosa regresará a través de un operario hasta la estación 1. En todos los Queues la atención de una pieza defectuosa es inmediata. La probabilidad será la misma en cada una de las cinco estaciones de trabajo y ésta misma no cambiará a pesar de que la parte sea regresada muchas veces. Actividades: Construya y ejecute tres veces su modelo por un tiempo de 14,000 minutos, pero con probabilidades de defecto entre 5, 10 y 15 por ciento en cada ejecución. Usando los estadísticos, determine la actividad del operario e identifique la cantidad de defectivos durante todo el tiempo simulado de cada una de las tres ejecuciones. Nota: dentro de algunos Triggers, puede crear y utilizar Labels para incrementar y ordenar su valor cuando sea necesario y puede cambiar el color de las piezas para diferenciar las buenas de las defectivas (véase la siguiente figura C_3).

Figura C_3. Problema “Línea de producción automatica”.

Compendio de Problemas.

6. En el mostrador de un restaurante pequeño llamado “D’gordo” los clientes llegan con una distribución exponential(0, 5, 0) en minutos a ordenar una rica hamburguesa; el primer cliente llega en el instante cero. El empleado del mostrador, tarda normalmente un tiempo medio de entre 4 y 6 minutos en recibirlo, atenderlo y cobrarle por su pedido. Después de haber sido completada la orden del cliente, ésta es asignada a uno de los dos cocineros del restaurante disponibles. Los cocineros tienen la misma probabilidad de tomar la orden independientemente de si están ocupados con algún otro pedido. Cada cocinero trabaja de manera individual y les toma una duniform(6, 10, 0) en minutos preparar una hamburguesa. Una vez entregada la hamburguesa, los clientes abandonan el restaurante. Actividades: Simule el modelo por 1,000 minutos, y observe los tiempos mínimos, máximos y promedios de los clientes desde que entran al sistema hasta que lo abandonan, el tiempo promedio de espera en la fila y la cantidad mínima, máxima y promedio de los clientes que esperan a ser atendidos. Diseñe un escenario alterno donde las órdenes de los clientes sean asignadas a los cocineros de acuerdo con el primero que esté disponible, ejecútelo por el mismo tiempo y compare los resultados de ambos modelos.

7. En un almacén llegan productos distribuidos exponencialmente (0, 2, 0) en segundos y mediante una banda transportadora estos son enviados a un centro de empacado compuesto por tres empacadoras que trabajan de manera independiente, además cuentan con suficientes cajas vacías para empacar todo el producto que llegue. En cada caja se empacan cuatro productos y el tiempo necesario para empacar es una lognormal2(0, 20.5, 0.5, 0) segundos. Posteriormente, a las cajas empacadas se les pega una etiqueta que indica si el empaque es para el cliente1 o para el cliente2 (40% cliente1 y 60% cliente2). Las cajas identificadas son transportadas por un montacargas y enviadas hasta el área de embarque clasificado en dos sub_áreas para cajas cliente2 y una para cliente1. Las cajas permanecen en el área de embarque durante un turno de 8 horas y después son entregadas (Nota: para ejecutar ésta acción se sugiere hacer uso de la herramienta MTBF/MTTR en conjunto con los comandos Down Function “Stop Output” y Resume Function “resume output”). El almacén opera tres turnos de 8 horas, los 7 días de la semana. Las máquinas empacadoras y el montacargas descansan 45 minutos cada 8 horas para ser reabastecidas de insumos. Ejecute la simulación por un mes y determine el número promedio y máximo de cajas en cada una de las dos sub_áreas de embarque.

167

168

SIMULACIÓN CON FLEXSIM

8. Una fábrica dedicada a la producción de rompecabezas artesanales tiene la necesidad de simular su sistema de producción para analizar la lógica de sus operaciones y comprobar si la empresa opera de manera eficiente. Se sabe que la fábrica elabora tres productos (rompecabezas) diferentes, quienes necesariamente y en distintas proporciones requieren de: una caja contenedora, cuadros, cilindros y esferas. Éstos mismos, siempre están disponibles en el almacén general. Las operaciones a realizar se indican a continuación, y la figura C_4 muestra lo elegante que luce el modelo terminado: o

o

o

o

Para representar la disposición de los cuatro materiales, se requiere de cuatro Sources. Cada Source enviará al sistema un material distinto, por tanto en cada uno se definirá el nombre del material que le corresponde, un tipo de FlowItem diferente, el número de ItemType (para el material uno será 1, para el siguiente 2, para el tercero se asignará un 3 y un 4 al último, esto colocará un indicador numérico a cada material para su caracterización posterior) y además se definirá un tiempo constante de Inter-Arrivaltime de 10 segundos en todos los Sources. Al frente de cada uno de los Sources se cuenta con un Queue con capacidad de 50 unidades, éstos son utilizados para almacenar los materiales de cada producto según corresponda. Posteriormente, los distintos materiales salen de cada uno de los Queues hacia las tres diferentes máquinas empacadoras. Los tiempos de operación son: normal(25, 5, 1) para la Empacadora_1, normal(20, 2, 1) para la dos y normal(18, 3, 1) para la número 3, todos en segundos. Dado que se requieren tres productos, la Empacadora_1 elabora el primero, la dos el segundo y la tres el producto 3 pero bajo las siguientes condiciones: - Producto1 = una caja contenedora, 2 cuadros, 4 cilindros y 3 esferas. - Producto2 = una caja contenedora, 5 cuadros, 1 cilindros y 2 esferas. - Producto3 = una caja contenedora, 4 cuadros, 2 cilindros y 4 esferas. Después de haber sido empacado cada uno de los tres distintos productos, en esta misma etapa del proceso es necesario identificarlos nuevamente. Así pues, al Producto1 le colocaremos el número de ItemType 5, al dos el 6 y al tres el 7. Posteriormente cada producto abandona las empacadoras y es enviado hasta una sola máquina acondicionadora a través de bandas transportadoras. Máquina Acondicionadora. Este equipo trata a los productos de manera distinta y por tanto sus tiempos de operación cambian dependiendo del producto a procesar: el Producto1 requiere de 30 segundos, el Producto2 (70 segundos) y el

Compendio de Problemas.

169

Producto3 (42 segundos). Para lograr esto, se requiere del diseño de una Tabla Global y del uso de la instrucción By Global Table Lookup, dicha instrucción se puede activar en el módulo Processor contenido en la ventana de propiedades de este objeto. Concluido lo anterior, el producto abandona el sistema. Actividades: Simule el modelo por 800,000 segundos, determine la eficiencia del sistema y proponga una alternativa que contribuya con el mejor desempeño del modelo.

Figura C_4. Problema “Producción de rompecabezas artesanales”.

9. Las piezas arriban a un sistema compuesto por tres equipos a una velocidad media de 10 minutos distribuidos exponencialmente. A su llegada, las piezas se introducen al primer equipo. La operación en este primer equipo corresponde a una distribución triangular(2.5, 4.2, 7, 0) en minutos. Posteriormente, las piezas pasan a un segundo equipo con un tiempo de operación triangular(1, 4, 8, 0) igualmente en minutos. Inmediatamente después, las piezas se dirigen al tercer equipo donde son pintadas de color amarillo a una velocidad triangular(3, 5.5, 2, 0) minutos. Las piezas ya pintadas, regresan nuevamente al primer equipo para ser procesadas por segunda ocasión. Sin embargo, las piezas que entran por segunda ocasión a este primer equipo son distinguidas con un tiempo de operación diferente que corresponde a una triangular (1.5, 5.4, 4.5, 0) minutos. Por lo tanto, el primer equipo está configurado para recibir piezas con probabilidades específicas (el 70% de las entradas son piezas nuevas y el resto piezas procesadas por segunda ocasión). Una vez completadas las operaciones, las piezas abandonan el sistema. Nota: todos los envíos de piezas entre equipos se hacen a través de bandas transportadoras. Actividades: Simule el modelo por un tiempo de 34,000 minutos y observe los tamaños medios y máximos de las filas de espera, así como el tiempo promedio necesario en que una pieza completa las cuatro etapas del sistema.

170

SIMULACIÓN CON FLEXSIM

Referencias bibliográficas Acosta Flores J. (2007). Ingeniería de Sistemas: Un Enfoque Interdisciplinario, (2a ed.), Centro de Investigaciones Interdisciplinarias en Ciencias y humanidades de la UNAM, México: Alfaomega Grupo Editor, S. A. de C. V., pp. 1-26. Banks Jerry, Carson John S., Nelson Barry L. and Nicol David M., (2009). Discrete-Event System Simulation, (5a ed.), U.S.A.: Prentice-Hall. Banks Jerry, Carson John S., Nelson Barry L. and Nicol David M., (2005). Discrete-Event System Simulation, (4a ed.), U.S.A.: Prentice-Hall. Barceló G. Miquel, (2008). Una Historia de la Informática, Rambla del Poblenou, Barcelona, Editorial UOC, pp. 77-80. Beaverstock Malcolm, Greenwood Allen G., Lavery Eamonn y Nordgren William (2012). Applied Simulation Modeling and Analysis using FlexSim, (3a ed.), Published by FlexSim Software Products, Inc. All rights reserved. Printed in Orem, UT 84097 USA. Bernard Zeigler, Tag Gon Kim y Herbert Praehofer, (2000). Theory of Modeling and Simulation, (2a ed.), New York: Academic Press. Bryant R.M., (1980). SIMPAS – a Simulation Language Based on PASCAL, In Proceedings of the 1980 Winter Simulation Conference, T.I. Ören, C.M. Shub, and P.F. Roth, eds., pp. 25-40. Bryant R.M., (1981). A Tutorial on Simulation Programming with SIMPAS, In Proceedings of the 1981 Winter Simulation Conference, T.I. Ören, C.M. Delfosse, and C.M. Shub, eds., pp. 363-377. Coss Bú R. (2003). Simulación: Un enfoque práctico, (20a ed.), Grupo Noriega Editores Balderas 95, Departamento de Ingeniería Industrial, Instituto Tecnológico y de Estudios Superiores de Monterey, México, D.F.: Limusa, S.A. de C.V., pp. 11-18. Esso, (1963). C.S.L.: Reference Manual/Control and Simulation Language, Esso Petroleum Company, Ltd. And IBM United Kingdom, Ltd. FlexSim Software Products, Inc. (Enero, 2013). Improve performance. Save money, Who is using FlexSim?, Consulta del sitio Web http://www.flexsim.com/. Kelton W. David, Sadowski Randall P., Sturrock David T., (2008). Simulación con Software Arena, (4a ed.), México: McRaw-Hill, Inc., pp. 1-25. Lakshmanan Ramon, (1983). Desing and Implementation of a PASCAL Based Interactive Network Simulation Language for Microcomputers, unpublished Ph.D. dissertation, Oakland University, Rochester, Michigan. Law Averill M. & Associates Inc. (2007). Simulation Modeling and Analysis, (4a

172

SIMULACIÓN CON FLEXSIM

ed.), Tucson, Arizona: U.S.A. McRaw-Hill, Inc., pp. 1-273. Marcowitz Harry M., Bernard Hausner and Herbert W. Karr, (1963). SIMSCRIPT: A Simulation Programming Language, The RAND Corporation, Prentice Hall, INC. Nance Richard E., (1993). A History of Discrete Event Simulation Programming Language, Department of Computer Science, Virginia Polytechnic Institute and State University Blacksburg, Virginia, pp. 4-39. Tocher, K.D. and D.G. Owen, (1960). The Automatic Programming of Simulations, Introceedings of the Second International Conference on Operational Research, pp.50-68. Von Neumann (1992). John Von Neumann y los Orígenes de la Computación Moderna, William Aspray - Gedisa Editorial. Wexelblatt Richard L., (1981). History of Programming Languages, Academic Press, ISBN 012745040 8. This is the Proceedings of the ACM SIGPLAN History of Programming Languages Conference, 1-3 June 1978. Winston Wayne L. (2005). Investigación de Operaciones Aplicación y Algoritmos, (4a ed.), México, Thomson Learning, pp. 1-273. 1145-1158.

Un primer paso a la simulación con FlexSim Isaías Simón Marmolejo

La principal aportación de este documento es abordar conceptos claves en relación con el impacto que tiene la simulación dentro de un sistema de producción y el uso del software FlexSim para modelar sistemas virtuales, como una fuente alternativa de efectividad en la toma de decisiones. El libro incluye una revisión de la literatura, conceptos de modelado y simulación, áreas de aplicación y características del uso y manejo del software. El lector notará que en cada problema planteado dentro de los capítulos de este documento se describen características distintas del software, las cuales se analizarán mientras se avanza en los diferentes apartados, al final se detalla un caso complementario de un modelo de fluidos y se agregan ejercicios que no sólo buscan recordar lo aprendido sino que, involucran al diseñador hacia la construcción, análisis e interpretación de resultados para dar respuesta a nuevos problemas. Además, se muestra la sencillez al programar y lo elegante que luce la animación 3D. Al mismo tiempo, el estudiante comprobará que la simulación de eventos discretos desarrollada con FlexSim, permite aportar valor agregado a sistemas industriales y de servicios quienes buscan mejorar su rentabilidad con amplia precisión y capacidad. La guía es una alternativa educativa para la formación de personal en diferentes áreas de una organización, estudiantes, catedráticos e investigadores que deseen saber más sobre el uso del software FlexSim.