Libro PrimerFlexSim

Un primer paso a la
simulación con
 Isaías Simón Marmolejo
FlexSim expreso.
Un primer paso a la
simulación con FlexSim
Un primer paso a la
simulación con
FlexSim
Primera edición
ISAÍAS SIMÓN MARMOLEJO

Escuela Superior de Ciudad Sahagún
Universidad Autónoma del Estado de Hidalgo, México
Un primer paso a la simulación con
FlexSim
© ISAÍAS SIMÓN MARMOLEJO
Autor
Isaías Simón Marmolejo de nacionalidad mexicana, es maestro en ciencias en ingeniería
industrial por parte de la Universidad Autónoma del Estado de Hidalgo (UAEH) y a la
fecha estudia un doctorado en manufactura avanzada en el Centro de Tecnología
Avanzada, CIATEQ A.C. Tiene 5 años de experiencia como profesor investigador en la
Escuela Superior de Ciudad Sahagún de la UAEH, y desde el 2008 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.
Correo electrónico del autor: isaiasm@uaeh.edu.mx
FlexSim Iberia
Director del proyecto editorial: COPYRIGHT © 2016
Marcello Rosadini FlexSim Iberia
Todos los derechos reservados.
MITICO STUDIO S.L. (FlexSim Iberia)
N.I.F: B65987257 Impreso en España
CL Cartagena, 243 3-1 08025, Barcelona, Printed in Spain
ESPAÑA.
T. +34 932 20 20 45 ISBN: 978-84-617-5095-5
M. +34 607 01 40 22
m.rosadini@flexsim.com.es
http://iberia.flexsim.com.es/
Authorized by:
Bibliografía: Simón-Marmolejo, I. FlexSim Software Products, Inc.
(2016). Un primer paso a la simulación con
https://www.flexsim.com/
FlexSim (p. 189). España: FlexSim Iberia.
AVISO
Ninguna parte de esta publicación puede ser reproducida, almacenada en un sistema
de recuperación, o transmitida de ninguna forma, ni por ningún medio, sea éste
electrónico, mecánico, químico, electro-óptico, fotocopia, grabado o cualquier otro,
sin la previa autorización por escrito del Editor.
Los problemas legales aplicables a lo antes descrito, serán competentes a los
JUZGADOS y los TRIBUNALES de Barcelona (España). De conformidad con lo
dispuesto en el artículo 270 del Código Penal vigente, podrán ser castigados con penas
de multa y privación de la libertad.
En memoria de mis abuelitas Sofía Mendoza Ruíz y Esperanza Mota Porras
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. REVISIÓN DE LA LITERATURA .................................................... 1
1.1. DEFINICIÓN DE SIMULACIÓN ..................................................................... 2

1.2. LA SIMULACIÓN A TRAVÉS DEL TIEMPO ..................................................... 3
1.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. INTRODUCIR LOS OBJETOS DE FLEXSIM ................................................... 40

3.2. 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. EJECUTAR 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 (INTER-
ARRIVALTIME, 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.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.7. EJEMPLO: USO DEL RECURSO COMBINER E IMPORTACIÓN DE DATOS DE
EXCEL 131
5.7.1. Conceptos ............................................................................................... 132
5.8. EJEMPLO: PROGRAMACIÓN DE AVERÍAS Y MANTENIMIENTO EN LOS
EQUIPOS CON LA HERRAMIENTA MTBF/MTTR ................................................... 140
5.8.1. Conceptos ............................................................................................... 141
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, visite la página

http://www.flexsim.com/es/ y de clic en “DESCARGAR 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.
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 al Dr. Joselito Medina Marín

del Instituto de Ciencias Básicas e Ingeniería de la Universidad Autónoma del
Estado de Hidalgo, y a los alumnos del Instituto Nacional de México Campus
Pachuca: Omar Vigueras, Dayan Jiménez, Silvia Vargas, Giselle Islas 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 cuatro 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 Escuela Superior 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.
vii
viii
1 CAPÍTULO 1.
ESQUEMA DEL CAPÍTULO

Revisión de la
Literatura
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 16.1.2, 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. 3
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
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 eﬁciente (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.
2
CAPÍTULO 2. Aprendizaje y
Aplicaciones del
Software FlexSim
2.1 DESCRIPCIÓN DEL SOFTWARE

2.2 APLICACIONES DEL SOFTWARE
2.3 DEL SOFTWARE FLEXSIM
2.3.1 Características y Terminología de FlexSim
2.3.2 Conceptos Adicionales
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”.
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. 9
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,
Fort, 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 16.1.2 actualizada el 05

de agosto de 2016, 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.
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
Figura 2.1. Asistente activar su licencia completa, entre
de arranque (Start otras cosas (véase figura 2.1).
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.
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.
– Auto Increment Save: Cada que se usa esta opción, se guarda el archivo
del modelo actual (.FSM) de manera única agregando un número
ascendente al archivo.
– 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.
Figura 2.4. Ventana

del menú File.
– Open User Libraries: Esta opción carga una o más bibliotecas guardadas,
añadiéndolas al panel de la biblioteca. Si la biblioteca contiene
componentes para la instalación automática, aparecerá un mensaje que
le pregunta si desea instalar estos componentes. Pulse OK para instalar
estos componentes.
– 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.
– 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.
– Model Settings: El comando visualiza las unidades de medida con las que
opera el modelo.
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.
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
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.
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:
– 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.
Figura 2.9. Ventana

del menú Statistics.
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.
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.
– Copyright Information… Se listan una serie de condiciones para la
redistribución del código fuente y del formato binario del software.
– 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.

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.
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.
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).
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 Figura 2.13. Ventana
Toolbox.
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.
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
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:
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.
- 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,
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.
- 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 como 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.
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.
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
Nota: Un FlowItem (con chile, con queso o las papas tradicionales únicamente acompañadas con sal)
puede tener tanto una y su cantidad (25, 50, ó 100 gramos).
Label como un
ItemType, mientras En FlexSim usted puede utilizar los comandos setlabelnum(),
que a los objetos getlabelnum(), y label() para interactuar con las etiquetas que se hayan
Fixed Resources y creado.
Task Executers sólo
se les puede asignar
Labels.
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.
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.
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.
 X: Borra la visualización de conexiones, nodos y flechas de una red. Esta Nota: para trabajar
es empleada básicamente para ocultar en forma sucesiva las conexiones, correctamente con el
nodos y las flechas construidas con NetworkNode. También crea nuevos uso de las teclas,
puntos de Spline en una red de rutas. Para ver su funcionalidad, mantenga usted deberá
presionada la letra X del teclado y haga clic sobre uno de los nodos de la permanecer en la
vista ortográfica, de
red con el botón izquierdo del mouse.
lo contrario, las
 B: Visualización de conexiones, nodos y flechas de una red. Su pulsaciones de tecla
funcionalidad es totalmente opuesta a la X. Así pues, las conexiones, no funcionarán hasta
nodos y flechas diseñadas por NetworkNode y ocultadas por la activación la segunda vez que se
de la letra X pueden ser vistas nuevamente al mantener presionada la letra pongan a prueba.
B y dando clic con el botón izquierdo del mouse sobre el nodo que no Esta acción se puede
fue oculto. En el objeto TrafficControl también puede ser utilizada esta hacer si se pulsa el
tecla. botón derecho del
mouse sobre el área
 V: Visualización de Output Port /Input Port, se utiliza para ver los
de trabajo y se
nombres de los puertos de entrada y salida de un objeto. Para observar desmarca la casilla
su funcionamiento, mantenga presionada la tecla V y haga clic en un Perspective Projection
objeto con el botón izquierdo del mouse. contenida en la
 C: Visualización de las conexiones de Puerto Central, se emplea para ventana derecha de
ver las conexiones de Puerto Central de un objeto. Presiónela y haga clic nombre Quick
en un objeto con este tipo de conexión y podrá notar los resultados. Properties. Si
 F y R: Estas dos letras se usan para crear objetos y conectarlos a la vez, después de esta
dichas funciones fueron explicadas anteriormente en la barra de acción desea
herramientas. regresar a la vista en
 G: Propiedades de conmutación rápida, su activación permite cambiar el perspectiva, es
enfoque de la ventana de propiedades de un objeto dentro del modelo. necesario activar
La vista ortográfica recuerda la última ventana de propiedades que se nuevamente el
abrió. Después de activar la vista ortográfica, mantenga presionada la comando Perspective
tecla G y haga clic en un objeto, la última ventana de propiedades abierta Projection. Para más
actualizará su enfoque para el nuevo objeto. detalles, revise el
siguiente apartado.
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.
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 podría 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.
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
direcció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
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.
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 respuesta 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
3.1 INTRODUCIR LOS OBJETOS DE FLEXSIM

3.2 CONEXIÓN DE PUERTOS PARA DEFINIR EL
FLUJO DE LOS FLOWITEMS
3.3 EDITAR LAS PROPIEDADES DE LOS OBJETOS
3.4 EJECUTAR EL MODELO
3.5 NAVEGACIÓN Y VISTAS ANIMADAS
3.6 REPORTE Y ESTADÍSTICAS DE LOS OBJETOS
3.7 PROBLEMAS COMPLEMENTARIOS
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. Cómo construir un modelo sencillo.

2. Cómo conectar los puertos para que fluyan los FlowItems por los objetos.
3. Cómo agregar e introducir datos a los objetos.
4. Cómo navegar en las distintas vistas de animación.
5. 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!
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
Model View (3D)
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
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 derecha de la figura 3.2.
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 Figura 3.3. Vista
de configuraciones.
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 qué operaciones hace el
objeto, cómo 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.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: >, <, *, -, ( ), etc., para que FlexSim funcione correctamente.
Espacios y guiones si están permitidos pero ningún nombre deberá iniciar con un
número. Si en la edición de objetos subsecuentes se utiliza este mismo nombre para
otro objeto se producirá un error, pues no puede utilizar el mismo nombre para dos
objetos distintos.
Descripción de objeto. Este botón abre un cuadro de edición donde se puede

realizar una descripción o notas sobre el objeto. Esta se guarda con el objeto, para su
posterior visualización.
Propiedades de la página. Aquí se muestra una ventana compuesta por un

conjunto de fichas con la información más relevante del objeto, la cual contiene
características variadas en función del objeto seleccionado. Todos los objetos tienen
las pestañas del objeto que se está tratando (en este caso Processor), Labels y General,
y la mayoría de los objetos restantes tienen las pestañas: Breakdowns (averías), Flow
(flujo) y Triggers (disparadores o ejecutores), observese su decripción:
 Processor - Es una pestaña de datos o atributos relacionadas con el objeto y

definidos por el usuario.
 Labels - Como se dijo en el capítulo anterior, estas son variables
personalizadas que se pueden especificar en el objeto. Por ejemplo, si
usted desea realizar un seguimiento del número de FlowItems de ItemType
3 que han entrado en un Fixed Resources, puede utilizar una etiqueta para
mantener un registro de este valor. Utilice los comandos setlabelnum(),
getlabelnum() y label() para interactuar con las etiquetas que se han

creado.
 General - En esta pestaña se podrán modificar los atributos que afectan el
aspecto visual del objeto: diseño, color, dimensiones, posición y rotación.
Además se pueden observar los Port Connections de los objetos.
 Breakdowns - Muestra la información sobre la confiabilidad del objeto; se
utiliza para establecer tablas con tiempos entre fallas y reparación.
 Flow - Pestaña para establecer la lógica del flujo de entrada y salida de los
FlowItems en el objeto.
 Triggers - Es una función opcional, permite mejorar el comportamiento del
objeto; a través de un desencadenamiento de eventos, crea y responde a
eventos que implican a un objeto.
Botones del panel. Son tres y se describen a continuación:
 Apply (Aplicar) - Aplica al objeto los cambios realizados en la ventana.

 OK - Aplica al objeto los cambios realizados en la ventana y cierra la ventana.
 Cancel (Cancelar) - Cierra la ventana sin aplicar los cambios realizados.
Botones previo/siguiente. Son útiles para hacer rápidas modificaciones a las

propiedades de varios objetos de la misma clase. En estos botones se aplicarán los
cambios realizados en la ventana del objeto y se podrá cambiar el enfoque de la
ventana del objeto anterior a la siguiente o viceversa.
Botón vista de árbol. Este botón abre una ventana que muestra sólo el árbol de Nota: Algunas
edición del objeto. propiedades del
objeto se actualizan
Ayuda. Al pulsar este botón se abrirá el manual de usuario en la página que describe de manera inmediata
la ficha que se encuentre seleccionada. al cambiarlas en la
ventana. Estos
Más detalles sobre la edición de objetos se revisarán en los ejemplos cambios
complementarios. permanecerán y no se
moverán aunque sean
cancelados. Por
ejemplo, al colocar
Breakdowns, Labels,
al modificar la
apariencia, posición,
rotación, tamaño y
puertos.
3.3.2. Edición de los Objetos del Modelo
Source
Después de lo antes expuesto. Abra la ventana de propiedades del objeto Source con
doble clic y dentro de la pestaña Source para este caso, localice la lista de selección
de opciones Inter-Arrivaltime. Al desplegar esta lista usted podrá notar que hay una
opción llamada Statistical Distribution, si hace clic se mostrará una variedad de
distribuciones estadísticas como opciones disponibles para editar este atributo. Al
abrir la ventana seguramente notó que la distribución exponencial es la opción por
default con un valor de ubicación de “0” y un valor de escala de “10”.
Para este modelo,

seleccione una
distribución uniforme y
coloque un 2 como valor
mínimo y un 3 como valor
máximo para simular la
velocidad en segundos a la
que la máquina
dosificadora envía frascos
de yogurt al sistema, véase
Figura 3.5. figura 3.5.
Configuración del
tiempo de llegada de
los frascos de yogurt al
sistema.
A la derecha de la lista de elección de opciones desplegable (Inter-

Arrivaltime), hay tres botones, cada uno actúa de manera diferente para editar la lista
de selección de opciones:
- El primer botón es parecido a una página de texto, se denomina Code Template

(código de la plantilla ), a menudo es referido como la opción de edición
fácil. Esta opción abrirá una ventana debajo de la lista de selección de
opciones con los atributos editables.
- El segundo botón Code Edit (edición de código ) es semejante a un
pergamino, brinda opciones de configuración avanzadas pues permite al
usuario manipular directamente el lenguaje del modelado asociado a ese
atributo. Sin embargo para usar esta opción se requiere de algunos
conocimientos de lenguaje, ya sea FlexScript o C++.
- Por último, el tercer ícono con forma de gotero llamado Sampler
(muestreador ), activa una ventana emergente con expresiones sugeridas,
refieren variables, etiquetas u otras propiedades de un objeto, la herramienta

elimina la necesidad de escribir código y hace que la construcción del modelo
sea más rápido y fácil. El Sampler es sensible al contexto, por lo que sólo le
permitirá probar expresiones en FlexSim válidas. Por ejemplo, si usted está
tratando de especificar el tiempo de operación de un Processor, el
muestreador sólo le dará opciones que devuelven valores numéricos, como
los comandos: gettablenum(), gettablenum() o getvarnum(). Ahora bien,
si usted intenta hacer referencia a un objeto móvil como alternativa en el
transporte, el muestreador sólo hará referencia a ese objeto y devolverá
valores como: centerobject (current, 1) o node("/Operator1", model())
según sea el caso.
La mayoría de los modelos a diseñar en este documento se pueden hacer

sólo mediante el uso de la lista de selección de opciones y con la edición más sencilla
disponible en el botón Code Template.
Queue
Dado que en el Queue se puede tener cualquier cantidad de frascos esperando a ser
procesados, se dejará este objeto bajo las condiciones predeterminadas.
Conveyor
Obsérvese la figura 3.6, para

ajustar la velocidad a la que viajan
las cajas dentro del objeto
Conveyor, dé doble clic sobre el
objeto y en la lista de selección de
opciones de nombre Conveyor
Type, elija ConveyorType1 y a
continuación haga clic en el
botón edición de propiedades … .
Al ejecutar estas últimas

acciones, se activará una nueva Figura 3.6.
ventana emergente para editar las Configuración de
propiedades del ConveyorType1, la velocidad de
localice el campo de texto avance y la
denominado Speed. capacidad del
Conveyor.
Como puede ver, el valor predefinido es de 1.00 y significa que los

FlowItems viajarán a una velocidad de un metro por segundo. Modifique ese valor
y coloque el de 0.2 m/s. Además, active la casilla Slug Builder para tener acceso a
los distintos criterios como el porcentaje de llenado, el número de elementos y el
tiempo transcurrido. Cambie el Fill Percent al 100% y el valor de 10 definido en Item
Count sustitúyalo por 5 para representar salidas agrupadas de 5 frascos a la vez.
Processor
Antes de editar el atributo Process Time (tiempo de proceso) en el Processor de su

modelo, es necesario mencionar que: es un elemento que integra a una sucesión de
eventos interrelacionados separados por un intervalo de tiempo en un proceso. El
tiempo de proceso es frecuentemente programado dentro de un objeto y
corresponde a una rutina de tiempo, descrita por una distribución de probabilidad y
en ocasiones por tiempos constantes. Algunos ejemplos podrían ser: el tiempo de
proceso en que un servidor atiende a un cliente que compra un pase para entrar al
cine, o la velocidad a la que dosifica una máquina los cartones de leche en
presentación de un litro y quizá también, el tiempo que invierte un inspector de
control de calidad al momento de dictaminar si una pieza está defectuosa o no.
En este propósito, abra la ventana de propiedades del Processor (figura 3.7)

y programe el tiempo que la máquina etiquetadora invierte en pegar la etiqueta al
frasco, correspondiente a una distribución lognormal2 (4, 0.3, 0.1, 0) segundos.
Figura 3.7.
Configuración tiempo
del proceso de la
máquina etiquetadora.
3.4. EJECUTAR EL MODELO
La ejecución de la simulación es muy sencilla en comparación con los pasos

anteriores. Si no recuerda este tema, revise nuevamente el apartado 2.3.1
Características y Terminología de FlexSim, donde se habló sobre el tema Panel de
Ejecución de la Simulación. En primer lugar, para definir el tiempo en que el modelo
se detendrá (30 días de 8 horas cada uno ó 864,000 segundos), dé clic en la opción
Stop Time ubicado en el Panel de Ejecución de la Simulación y establezca el tiempo
de paro requerido. A continuación haga clic en el botón Reset y después en el botón
Run. Esto activa la ejecución de eventos del modelo y con ello se da inicio a la
simulación de eventos discretos. Guarde su modelo con el nombre de Ejemplo 1.
3.5. NAVEGACIÓN Y VISTAS ANIMADAS
Para que pueda navegar correctamente sobre el área de trabajo revise nuevamente el
tema Fundamentos de la Navegación en FlexSim del apartado 2.3.2. Conceptos
Adicionales. Ahí encontrará como manipular las dimensiones y ubicación de los
objetos, además podrá explorar las distintas vistas del modelo que usted acaba de
diseñar.
Una vez puesto en ejecución el modelo de simulación, observe que los FlowItems se
pasan de un objeto a otro en un tiempo cero independientemente del lugar donde
estos se ubiquen en el área de trabajo. Por ejemplo, el tiempo que le tomará a un
FlowItem viajar del Queue al Conveyor será instantáneo, no importa cuán cerca o
lejos estén uno del otro. En este sentido, los tiempos de viaje entre los objetos serán
considerados como insignificantes en el funcionamiento del modelo y por lo tanto
será ignorado.
Es importante que no se confunda el tiempo de viaje de un objeto a otro,

con el tiempo de traslado que invierte un Conveyor o un recurso móvil al mover un
FlowItem de un recurso a otro.
En muchos modelos el tiempo de traslado puede ser crucial y tendría que

tenerse en cuenta al utilizar objetos como los recursos móviles. Un recurso móvil
podría ser utilizado para enviar un FlowItem de un objeto a otro. El tiempo de
traslado de un recurso móvil está en función de sus dimensiones, su velocidad de
avance y de su aceleración o desaceleración según corresponda. Sin embargo, en
temas subsecuentes usted observará que la velocidad (tiempo de viaje) a la que los
recursos móviles toman o liberan los objetos sigue siendo instantánea o de tiempo
“0” como se ha indicado anteriormente. Así mismo, para obtener resultados exactos
los recursos móviles deberán ser de tamaño apropiado pues así cubrirán las unidades
de espacio predeterminadas en la red de la pantalla de diseño misma que ahora es de

tamaño 1x1x1 metros. Para este primer modelo, hemos decidido que las dimensiones
a escala no sean importantes, pero lo revisaremos en modelos subsiguientes.
3.6. REPORTE Y ESTADÍSTICAS DE LOS OBJETOS
El desempeño del sistema se describe con estadísticas. Las estadísticas son la

acumulación de valores en una variable por un tiempo determinado, inician en “0”
cada que se restaura (Reset) el modelo y se acumulan valores hasta el momento en
que se detiene la simulación, además estos resultados son vistos como números,
porcentajes o gráficos y pueden programarse variables de interés para el usuario o
simplemente consultarse las ya definidas. Los ejemplos son: el número de clientes
que entran a la sala del cine en un momento dado, el número de clientes máximos en
la fila de espera de un banco, el tiempo que se mantuvo en proceso un equipo, el
porcentaje de piezas defectuosas, el tiempo máximo en que se surte un pedido en un
almacén, el nivel mínimo de un inventario, entre otros.
Una vez que ha ejecutado el modelo durante un período de tiempo

predeterminado, usted puede analizar los resultados de la ejecución en distintas
formas:
1. Algunas estadísticas rápidas para los usuarios están disponibles en los

objetos que se encuentran en el área de trabajo, si da clic en un objeto
cualquiera podrá ver debajo de este mismo un texto en color gris con las
estadísticas colectadas durante la simulación a excepción de los Conveyors,
y al mismo tiempo es posible observar las estadísticas del objeto en la
ventana Quick Properties mientras el modelo se ejecuta. Para que FlexSim
muestre las estadísticas de todos los objetos en el área de trabajo a la vez, es
necesario dar clic derecho sobre el Layout y nuevamente dentro de la
ventana Quick Properties busque la opción Show Name para remplazarla
y activar el comando Show Name and Stats.
2. En el menú Statistics>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 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.
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 instrumentos
(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
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 se guarda con el 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”.
 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 no se describen en este
libro pero pueden ser definidas dentro del menú
Statistics>Experimenter…>Experiment Run.
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 y 2 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 sólo
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
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
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.
Nota: usted
necesitará tres
líneas como estas
para representar su
modelo.
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.).
Resultados esperados:
1. Construye el escenario del modelo lo mejor posible.

2. Ejecuta 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:

de flujo del problema
del problema 2.
Tabla 2. Tabla de información que deberá observar después de ejecutar su modelo.
Con tarjeta Tickets de Compra de Total o

Resultados esperados
electrónica prepago boleto promedio
Promedio del número de personas formadas

0.46 2.83 1.45 1.58
en la línea de espera
Número máximo de personas formadas en la

8 16 12 12
línea de espera
Tiempo que espera un alumno antes de ser

2.29 27.39 22.24 17.30
atendido
Nota: recuerde que

sus datos pueden Número total de clientes atendidos 2,144 1,115 704 3,963
variar un poco
Número de clientes atendidos por hora 11.91 6.16 3.9 21.97
debido a la
aleatoriedad de las % de utilización del servidor 59.5 83 78 73.50
distribuciones de
probabilidad. Horas trabajadas por cada servidor 107.1 149.4 140.4 132.30
4 CAPÍTULO 4.

Construcción de un
Modelo Paso a Paso
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
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.
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. 63
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
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
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 y 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
á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.
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:
 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 de este ejemplo 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.
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.
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.
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 gettablenum. 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:
getlabel(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 setlabel, 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:
setlabel(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.
Una vez creados y conectados los objetos, y después de haber entendido los
conceptos necesarios, iniciaremos con la programación.
4.4. PASO 3. EDICIÓN Y COMPORTAMIENTO DE OBJETOS (INTER-

ARRIVALTIME, 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
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 ( ), 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 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 triggers (factores desencadenantes), son puntos de acción que se

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.
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.
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
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.
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):
 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
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 = param(1);
treenode item = parnode(2); treenode
conveyor = param(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 = param(1);
treenode item = param(2); treenode
conveyor = param(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 *******\\
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
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.
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
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
Figura 4.13. Processor4 procese
Programación del flujo únicamente las piezas con
de los FlowItems el ItemType 1, el
mediante la Processor5 manipulará a las
clasificación Values By piezas con el ItemType 2 y
Case. 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 getlabel(item, "labelname"). Dentro de la expresión sustituya el
nombre de la etiqueta “labelname” por el de “Pieza Defectuosa”. La instrucción
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 getlabel(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 uniforme
(130, 150, 0). Lo anterior hará
que cada que entre un FlowItem
Figura 4.15. Tiempos
a un equipo, este será valorado
de proceso variados.
por sus etiquetas y como aquí se
indicó que si la pieza contiene la
etiqueta “Pieza Defectuosa” con 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).
Nota: observe 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 (Port 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 convenientes que permitan cumplir con las necesidades
del modelo.
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 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
móviles de acuerdo a como
de un Dispatcher.
estas vayan apareciendo,
pero los modeladores
pueden especificar sus
Nota: conecte del propias estrategias en el Dispatcher si así lo desean. Para configurar un equipo de
Dispatcher a los recursos móviles como se muestra en la figura 4.17, arrastre un Dispatcher y dos o
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.
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. Figura 4.18.
Finalmente analice la Utilización del gráfico
tendencia de los puntos Time in System dentro
rojos y trate de pensar en del modelo de
una solución a este simulación.
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.
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 un
momento especifico de la simulación.
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.
Figura 4.20: Imagen

ilustrativa del modelo
final.
5 CAPÍTULO 5.

Aplicaciones y Usos
Variados
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
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.
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 diferentes 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 PUSHED Y EL USO DE LA

DISTRIBUCIÓN BERNOULLI
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. 95
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,
é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])

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 80%
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.
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 Item Type, 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 5.2.
donde podrá identificar los Programación del
colores para los dos distintos Source.
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 cualquier 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.
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.
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.
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
En el Ejemplo 2, se dio una pequeña introducción al uso de las tablas globales para
Nota: es preferible la utilización de un conjunto de datos derivados empíricamente como una
utilizar números distribución estadística. Ahora haremos uso de estas en un conjunto de datos de una
tanto en Labels forma más natural como los podríamos ver en Excel. Al igual que las Labels, las
como en Tablas Tablas pueden contener información como texto y datos numéricos. Los comandos
siempre que sea que se utilizan para manipular los datos de una celda, siguen un patrón similar a los
posible, ya que este comandos empleados para hacer referencia a una Label.
tipo de datos son
más fáciles y rápidos Es posible utilizar gettablenum para consultar datos de una celda. Para usar este
de manipular. comando debe escribir:
gettablenum("tablename", rownum, colnum)
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(“tablename”, rownum, colnum, value)
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 cuales devuelve o insertan un valor de tipo string

segun la fila o columna especificada en una tabla, tal como se muestra
respectivamente:
gettablestr( “tablename”, rownum, colnum )
settablestr( “tablename”, rownum, colnum, “value”)
pero no son tratados en este ejemplo.
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 Nota: tanto los
figura anterior. El primer procesador debe estar conectado en el puerto de salida uno puertos de entrada
del Queue, el segundo procesador en el segundo puerto de salida, y así sucesivamente como los de salida
hasta que el Sink se encuentre en el sexto puerto de salida. de las diferentes
estaciones deberán
estar conectados al
Queue.
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 Item Type. 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 Set 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.
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
agregará 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.
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.
La segunda
instrucción importante
Figura 5.7. Comando dentro del Queue debe
que incrementa una programarse en la pestaña
unidad en la Label Flow. Aquí es donde se
“Etapa” cada vez que indicará la salida de los
un FlowItem entre al distintos productos a las
Queue. 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, 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 getlabel(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 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
Nombre de la Tabla Global.
trabajo mediante la
Comando necesario para instrucción Send To
referenciar la posición de la fila
dentro de la Tabla Global. Port.
Comando necesario para

referenciar la posición de la
columna dentro de la Tabla
Global.
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ó.
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 el
botón cada
que lo desea, y así
garantizar el flujo
adecuado.
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.
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.
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.
– 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);
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:
 current: cualquier recurso que posea ese código hará referencia al objeto
presente.
 item: da referencia del FlowItem actual, al objeto que solicitó un
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:
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:
content(object): 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.
Otros comandos como get y set, establecen datos en labels y tablas, estos tienen el
formato siguiente:
getlabel(object, “labelname”): Obtiene el valor numérico de la etiqueta

especificada en el objeto seleccionado.
gettablenum(“tablename”, rownum, colnum): Obtiene el valor numérico contenido
en la celda de una Tabla, especificado por una rownum (fila) o colnum (columna).
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.
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.
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. Ilustración

del modelo concluido.
Programación
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
Figura 5.12. botón Refresh Arrivals se
Programación del postraran los cambios.
Source.
Queues
ALMACEN_1
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
Figura 5.13. OPERADOR_1. Véase la
Referenciando a figura 5.13.
recurso móvil
OPERADOR_1.
Nota: indique al
operador
transportar tres
piezas a la vez.
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 == 1)
{
openoutput(Almacen);
closeoutput(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

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.
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
Figura 5.14. móvil mediante una
Programación del conexión de puerto
tiempo de preparación, central y a través de la
tiempo de proceso, opción Direct
asignación de operario
Reference, pero ahora se
y prioridad de las tareas
mostrará una tercera
para la MAQUINA_1.
alternativa.
Primero, en esta
misma tabla de propiedades de la 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 en 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.
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.
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.
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.
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
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 Montacargas 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
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
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.
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 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 5.17.
Ventana de
propiedades del
Rack_1.
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
grupo de NetworkNodes conectados constituyen una red.
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.
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.

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.
Figura 5.19. Curva y

sus puntos de control
Spline.
Una vez configurada y definida la trayectoria, los recursos móviles podrán Nota: al dar clic
utilizar la ruta trazada. Si desea que esta no sea visible mientras el modelo es ejecutado, presionando la tecla
presione la tecla “X” y dé múltiples clics sobre algún NetworkNode. “X” pero sobre los
puntos Spline el
resultado será un
incremento de
Concepto 3: Tiempo de viaje puntos Spline sobre
la curva.
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
del NN3 al NN2, pero si es unidireccional, sólo deberá especificarse dentro del nodo
que permite el acceso al recurso móvil.

de propiedades del
NN1. Para tener acceso
a esta ventana dé doble
clic sobre algún nodo
de la red.
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
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.
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
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.
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.
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.
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
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 Excel
importado
Nombre de la hoja
de Excel
Tabla destino para
importación de
datos
Coordenadas de
posición inicial, y
Figura 5.24. Ventana total de filas y
MTEI “Importación columnas
Múltiple de Tablas de
Excel”.
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
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
Figura 5.25.
correctamente dentro de la
Programación del
Tabla Global. En este ejercicio Source_Pallet a partir
el nombre de la tabla es “Tabla de la configuración del
Global_1”, misma que fue importador de datos
creada anteriormente. MTEI a través de la
ImportLine1.
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
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.
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
Nota: los cambios los datos de las órdenes definidas en Excel agregadas a través de la configuración del
en la tabla de importador MTEI. Esto se puede hacer dentro de la pestaña Triggers del Combiner,
nombre al elegir de la lista de selección de opciones OnEntry el comando Update Combiner
Components List, Component List. Aquí dentro sólo es necesario hacer uso de la tabla "GlobalTable1"
se actualizan y posteriormente dar clic en Apply y Ok.
conforme a la tabla
GlobaTable1 al dar
Reset y ejecutar el
modelo.
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 “0”. Dentro de cada uno de estos Sources
deberá indicarse un color diferente para que cada uno muestre un producto 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, y elija Display Label Value. Posteriormente, sustituya el comando
(getlabel(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.
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.
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 es 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
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 Up Time para la frecuencia de falla exponential(0, minutes(15), 1)
o Down Time para la reparación uniform(minutes(1), minutes(2), 1)
5.8.1. 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.
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.
- Up Time: Esta lista de selección devuelve el Mean Time Between Failure, MTBF
(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.
- Down Time: Esta lista de selección devuelve el Mean Time To Repair, MTTR
(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.
- 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.
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):

de la herramienta
MTBF/MTTR.
Figura 5.29.
Presentación del
modelo final.
6 CAPÍTULO 6. Un Modelo de
Fluidos
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
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. Modelar fácilmente Materiales Fluidos.

2. Convertir FlowItems en Material Fluido y Material Fluido en FlowItems.
3. Transferir y almacenar Material Fluido.
4. Utilizar marcas de nivel para mantener el control de volumen en los
tanques contenedores.
5. Podrá mezclar tanto Materiales Fluidos como Discretos.
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). Ejemplos de 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).

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
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
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
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).
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 16.1.2 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, o bien atener las observaciones de la segunda nota en la pagína
160.
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
– 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
El Almacen1 y el Almacen2 llaman a un operador distinto para transportar los
preocupe ahora por
FlowItems hasta el ItemToFluid, por lo que los Operators deberán tener una
la estética de su
conexión de puerto central tanto del Almacen1 como del Almacen2, respectivamente
modelo, ya que
(véase la figura 6.2).
cada objeto tomará
forma mientras se
avanza en la
programación del
mismo.
6.2.2. 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
Nota: si desea los FlowItems creados hasta los dos objetos ItemToFluids (Use Transport de la pestaña
cambiar el color de Flow). Respecto al Almacen3 sólo es necesario escoger de la lista de selección de
los FlowItems opciones FlowItem Class la alternativa Cylinder para representar a los frascos.
puede usar el Finalmente en este mismo Source se debe configurar el campo Inter-Arrivaltime a
comando Set Object 1.5 segundos.
Color de la opción
OnExit de la
pestaña Triggers.
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 Figura 6.4. Ventana
tabla de colores de propiedades del
aparecerá. Seleccionar el ItemToFluids1.
color blanco con un clic.
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).
Repetir estos pasos para

el ItemToFluid2, no olvide
cambiar su capacidad
máxima a 20 litros e indicar la
Figura 6.5. necesidad de crear 5 litros de
Configuración de fruta por cada FlowItem
proporciones, (cubetas de preparado de
velocidad y capacidad fruta) que entre al
del objeto ItemToFluid2.
ItemToFluid1.
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):
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 del
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.
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
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. Modificar 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
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.
 Dentro de
LechePasteurizada, ajuste
el Port a 1, Amount a 10,
y Step a 1.
Figura 6.8.  Dentro de
Configuración de la PreparadoDeFruta, ajuste
entrada y mezcla de
ingredientes dentro del el Port a 2, Amount a 3, y
FluidMixer. 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.
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 Figura 6.9.
Mixer. De la misma forma Configuración del
indicador de nivel del
puede manipular el resto de
FluidMixer.
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
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”.
2. En esta misma pestaña cambie el Contenido Máximo a 0.5. Esto le dice al

Nota: dentro de objeto que en todo momento sólo puede recoger material fluido suficiente
este objeto puede para 1 FlowItem. Si este valor es mayor, el FluidToItem formará una línea
cambiar el aspecto de espera y con ello se creará demasiado espacio de almacenamiento en el
del FlowItem de modelo.
salida tal como su 3. Dentro del campo Flowitem Name, escriba “Postre”. Así, todos los nuevos
forma, tamaño,
FlowItems serán llamados Postre.
color, etc.
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:
Nota: observe que
el Conveyor usado  Para este modelo, los Conveyors se mantienen con sus propiedades de inicio
es diferente al pero deberán ser indicadas sus dimensiones y dirección hasta lograr el diseño
mostrado en el deseado.
Ejemplo 2 del  Al Combiner llegan tanto FlowItems (frascos) como FlowItems (Postres).
Capítulo 4, para Para que la velocidad de envase sea de 3,600 frascos por hora, en el campo
activar este nuevo Process Time de la ventana de propiedades del Combiner, coloque el valor de
Conveyor diríjase al
1 para indicar que sea envasado un frasco por segundo. En la pestaña
menú File>Global
Combiner elegir el modo de combinar Join para visualizar en la salida sólo un
Preferences>Environme
producto. Para concluir la programación de este objeto, en la pestaña Triggers,
nt y active la casilla
“Display Legacy
Conveyours in the
Library”. El nuevo
objeto se mostrará
en la ventana
Library para su uso.
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 disccreto y fluido.
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
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.

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

“Línea de producción
automatica”.
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.
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 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.
o 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.
o 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.
o 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
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.

“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.
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
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
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 o de cambio continuo-discreto 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 simulación y el uso del software FlexSim.
Director del proyecto editorial: ISBN: 978-84-617-5095-5

Marcello Rosadini
MITICO STUDIO S.L. (FlexSim Iberia)

Barcelona, ESPAÑA.
T. +34 932 20 20 45
M. +34 607 01 40 22
m.rosadini@flexsim.com.es Authorized by: FlexSim Software Products, Inc.
http://iberia.flexsim.com.es/ https://www.flexsim.com/

Libro PrimerFlexSim

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Libro PrimerFlexSim

Загружено:

Авторское право:

Доступные форматы

Un primer paso a la

ISAÍAS SIMÓN MARMOLEJO

Correo electrónico del autor: isaiasm@uaeh.edu.mx

ORGANIZACIÓN DEL LIBRO.................................................................................... IV

USO DEL SOFTWARE............................................................................................... V

USO DE LA WEB ..................................................................................................... VI

AGRADECIMIENTOS ............................................................................................. VII

CAPÍTULO 1. REVISIÓN DE LA LITERATURA .................................................... 1

1.1. DEFINICIÓN DE SIMULACIÓN ..................................................................... 2

CAPÍTULO 2. APRENDIZAJE Y APLICACIONES DEL SOFTWARE FLEXSIM.......... 7

2.1. DESCRIPCIÓN DEL SOFTWARE .................................................................... 8

CAPÍTULO 3. CONSTRUCCIÓN DE UN MODELO BÁSICO ............................... 39

3.1. INTRODUCIR LOS OBJETOS DE FLEXSIM ................................................... 40

CAPÍTULO 4. CONSTRUCCIÓN DE UN MODELO PASO A PASO .................... 61

4.1. DESCRIPCIÓN DEL CASO DE ESTUDIO ....................................................... 62

CAPÍTULO 5. APLICACIONES Y USOS VARIADOS .......................................... 93

5.1. INTRODUCCIÓN ....................................................................................... 94

CAPÍTULO 6. UN MODELO DE FLUIDOS ..................................................... 145

6.1. SIMULACIÓN DE FLUIDOS ...................................................................... 146

REFERENCIAS BIBLIOGRÁFICAS .......................................................................... 171

Las operaciones, procesos o servicios de varias clases que existen en el

No obstante, el mostrar un panorama concreto de simulación desde una

El objetivo de este libro es exhortar el uso de la simulación en la evaluación

Es nuestra intención brindar las bases para describir, representar y analizar la

En el 1er. Capítulo titulado “Revisión de la Literatura”, se abordarán

El 2do. Capítulo “Aprendizaje y Aplicaciones del Software FlexSim”, se

El 3er. Capítulo “Construcción de un Modelo Básico”, contiene las

En el 4to. Capítulo “Construcción de un Modelo Paso a Paso”, se describe

En el 5to. Capítulo, “Aplicaciones y Usos Variados”, se describen siete

Uso del software

Para descargar el software con la versión más reciente, visite la página

En este mismo orden de ideas, es prudente mencionar que el software está

De igual forma quiero expresar mi gratitud al Dr. Joselito Medina Marín

Y por supuesto a mis colegas y amigos de la Escuela Superior de Cd.

Isaías Simón Marmolejo

ESQUEMA DEL CAPÍTULO

1.1. DEFINICIÓN DE SIMULACIÓN

Después de un cuidadoso estudio de este capítulo, usted debe ser capaz de

1. Tendrá una idea general del concepto de simulación, modelo, sistema,

1.1. DEFINICIÓN DE SIMULACIÓN

Para el desarrollo del presente trabajo resulta conveniente iniciar definiendo el

La simulación inicia con un modelo. Un modelo es una descripción física

Un modelo de simulación representa la operación de algún proceso o

algún supermercado son ejemplos de cambios continuos y discretos,

Posteriormente, una vez desarrollado, validado y verificado el modelo

Como opinión particular, se considera que un sistema es modelado y

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

La necesidad de resultados cada vez más precisos y rápidos estimuló el

experimentar con modelos matemáticos (que describen sistemas de interés) en

El primer simulador fue GSP (General Simulation Program) acreditado

Posteriormente, la aparición de un nuevo lenguaje popular y de uso

En 1986, WITNESS lanzó el primer producto con nivel de

en el ordenador no estaba disponible para el usuario. A finales de los años 80,

1.3. LA NUEVA GENERACIÓN DE SIMULADORES

En la década de los 90s, empezaron a surgir diferentes simuladores. En Europa

Figura 1.1. Ejemplo de

2.1 DESCRIPCIÓN DEL SOFTWARE

1. Conocerá las bondades de FlexSim.

Es necesario que a partir de ahora ya se tenga instalado el software en algún equipo de

2.1. DESCRIPCIÓN DEL SOFTWARE

Como se ha mencionado con anterioridad, FlexSim Software Products, Inc. inicia

 Su extensa sección de pre-construidos permiten abordar situaciones

2.2. APLICACIONES DEL SOFTWARE