Un Primer Paso A La Simulacion Con Flexsim - I. Simón Marmolejo

Un primer paso a la
simulación con
 I. Simón-Marmolejo
 M. Ortiz-Domínguez
 M. Ortiz-Domínguez
Versión Gratuita
Segunda Edición FlexSim Express
Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

Un primer paso a la
simulación con FlexSim

Un primer paso a la
simulación con
FlexSim
Segunda edición
Compatible con FlexSim 19.2.4
ISAÍAS SIMÓN MARMOLEJO

MARTÍN ORTIZ DOMÍNGUEZ
Escuela Superior de Ciudad Sahagún
Universidad Autónoma del Estado de Hidalgo, México
Estados Unidos México España Argentina Bolivia Chile

Colombia Costa Rica Ecuador Guatemala Panamá Perú

DERECHOS RESERVADOS
© FlexSim Iberia
Director del proyecto editorial: COPYRIGHT © 2019
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/
Bibliografía: Simón-Marmolejo, I.; M. Authorized by:

Ortiz-Domínguez (2019). Un primer paso a FlexSim Software Products, Inc.
la simulación con FlexSim (p. 268). España:
https://www.flexsim.com/
FlexSim Iberia.
Simón-Marmolejo, I.; Ortiz Domínguez, M.

Un primer paso a la simulación con FlexSim
Correo electrónico del autor: isaias.simn@gmail.com
Equipo revisor:
Dr. Joselito Medina Marín
Dra. Francisca Santan Robles
Ing. Daniel Robles Carrasco
1er. edición: Julio 2016

2da. edición: Diciembre 2019
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.

Gracias Dios
En memoria de doña Sofía Mendoza Ruíz y Esperanza Mota Porras quienes me

dierón un gran ejemplo de vida.

Índice de contenido
PRÓLOGO ........................................................................................................... IV
ORGANIZACIÓN DEL LIBRO .......................................................................... V
USO DEL SOFTWARE...................................................................................... VII
USO DE LA WEB ............................................................................................... VII
AGRADECIMIENTOS .....................................................................................VIII
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 ................................................2
1.2.1. La Nueva Generación de Simuladores ......................................................................4
1.3. MODELO DE SIMULACIÓN .............................................................................5
1.4. CLASIFICACIÓN DE LOS MODELOS DE SIMULACIÓN .......................7
1.5. SIMULACIÓN DE EVENTOS DISCRETOS ..................................................9
1.5.1. Mecanismos de Avance del Tiempo en Simulación .................................................. 11
1.6. ETAPAS EN LA ELABORACIÓN DE UN PROYECTO DE
SIMULACIÓN ..................................................................................................................... 14
1.7. VENTAJAS Y DESVENTAJAS DE LA SIMULACIÓN ............................. 20
1.7.1. Ventajas ............................................................................................................... 20
1.7.2. Deventajas ............................................................................................................ 21
1.8. ACTIVIDADES COMPLEMENTARIAS....................................................... 22
CAPÍTULO 2. MUESTREO Y DISTRIBUCIONES DE PROBABILIDAD .... 23
2.1. INTRODUCCIÓN............................................................................................... 24
2.2. TAMAÑO DE LA MUESTRA .......................................................................... 24
2.2.1. Estimación Preliminar de Variables ...................................................................... 26
2.2.2. Cálculo del Número de Observaciones .................................................................... 27
2.2.3. Frecuencia de Visitas al Centro de Trabajo para Realizar Observaciones y Tipo de
Muestreo 35
2.3. DISTRIBUCIÓN DE PROBABILIDAD ........................................................ 36
2.3.1. Experimentos y Epacio Muestral........................................................................... 36
2.3.2. Variables Aleatorias ............................................................................................. 37
2.3.3. Tipos de Distribuciones.......................................................................................... 42
CAPÍTULO 3. IDENTIFICACIÓN DE DISTRIBUCIONES CON
EXPERTFIT ......................................................................................................... 53
3.1. DATOS DE ENTRADA EN UN MODELO DE SIMULACIÓN............. 54
3.2. RECOLECTAR DATOS DEL SISTEMA REAL DE INTERÉS ............... 55
3.3. DISTRIBUCIONES ASOCIADAS A UN CONJUNTO DE DATOS ...... 56
3.4. USO DE EXPERTFIT ........................................................................................ 57
3.4.1. Tipos de Análisis en ExpertFit ............................................................................. 58
3.4.2. Data Analysis ...................................................................................................... 59
3.4.3. Análisis de un Conjunto de Datos Paso a Paso ..................................................... 61
3.5. RESUMEN DEL CAPÍTULO ........................................................................... 77

CAPÍTULO 4. DEL SOFTWARE FLEXSIM ...................................................... 81
4.1. DESCRIPCIÓN DEL SOFTWARE.................................................................. 82
4.2. APLICACIONES DEL SOFTWARE ............................................................... 83
4.3. FLEXSIM ................................................................................................................ 85
4.3.1. Características y Terminología de FlexSim .............................................................. 85
4.3.2. Conceptos Adicionales ...........................................................................................105
CAPÍTULO 5. CONSTRUCCIÓN DE UN MODELO BÁSICO ..................... 115
5.1. INTRODUCIR LOS OBJETOS DE FLEXSIM............................................116
5.2. CONEXIÓN DE PUERTOS PARA DEFINIR EL FLUJO DE LOS
FLOWITEMS......................................................................................................................117
5.3. EDITAR LAS PROPIEDADES DE LOS OBJETOS ..................................119
5.3.1. Configuración Deseada ..........................................................................................119
5.3.2. Edición de los Objetos del Modelo..........................................................................122
5.4. EJECUTAR EL MODELO ...............................................................................125
5.5. NAVEGACIÓN Y VISTAS ANIMADAS .....................................................125
5.6. REPORTE Y ESTADÍSTICAS DE LOS OBJETOS ...................................126
5.7. PROBLEMAS COMPLEMENTARIOS.........................................................131
CAPÍTULO 6. CONSTRUCCIÓN DE UN MODELO PASO A PASO ........... 137
6.1. DESCRIPCIÓN DEL CASO DE ESTUDIO ................................................138
6.2. PASO 1. DISEÑO Y CONEXIÓN DEL MODELO PRELIMINAR ......140
6.3. PASO 2. ITEMTYPE Y ESTRATEGIAS DE RUTEO (SEND TO PORT),
DESDE EL SOURCE HASTA EL SINK ......................................................................143
6.4. PASO 3. EDICIÓN Y COMPORTAMIENTO DE OBJETOS (INTER-
ARRIVALTIME, DEMPIRICAL, TRIGGERS, LABELS, FLOWITEM BIN Y
PROCESS TIME) ...............................................................................................................148
6.4.1. Iniciemos con la Programación del Source: .............................................................148
6.5. PASO 4. AÑADIENDO TASK EJECUTERS (OPERATOR Y
DISPATCHER) AL MODELO .......................................................................................164
6.6. PASO 5. INFORMACIÓN ESTADÍSTICA DE LOS OBJETOS Y
TEXTOS VISUALES ........................................................................................................166
CAPÍTULO 7. APLICACIONES Y USOS VARIADOS..................................... 169
7.1. INTRODUCCIÓN .............................................................................................170
7.2. EJEMPLO: SISTEMAS PULLED O PUSHED Y EL USO DE LA
DISTRIBUCIÓN BERNOULLI .....................................................................................170
7.2.1. Conceptos ..............................................................................................................171
7.2.2. Creación del Modelo ..............................................................................................173
7.3. EJEMPLO: SISTEMA DE ENRUTAMIENTOS COMPLEJOS ..............175
7.3.1. Conceptos ..............................................................................................................176
7.3.2. Creación del Modelo .............................................................................................177
7.4. EJEMPLO: LÓGICA FLEXSCRIPT Y PRIORIDAD DE USO ...............183
7.4.1. Conceptos ..............................................................................................................184
7.4.2. Creación del Modelo .............................................................................................189
7.5. EJEMPLO: LOS OBJETOS TASK EXECUTERS Y LA INTERRUPCIÓN
DE TAREAS .......................................................................................................................193
7.5.1. Conceptos ..............................................................................................................195
5.5.2. Creación del Modelo ..............................................................................................196
7.6. EJEMPLO: RECURSOS MÓVILES Y RUTAS DE VIAJE ........................202
7.6.1. Conceptos ..............................................................................................................204
ii

7.6.2. Creación del Modelo ............................................................................................. 206
7.7. EJEMPLO: USO DEL RECURSO COMBINER E IMPORTACIÓN DE
DATOS DE EXCEL ......................................................................................................... 207
7.7.1. Conceptos ............................................................................................................. 208
7.7.2. Creación del Modelo ............................................................................................. 209
7.8. EJEMPLO: PROGRAMACIÓN DE AVERÍAS Y MANTENIMIENTO
EN LOS EQUIPOS CON LA HERRAMIENTA MTBF/MTTR ............................ 216
7.8.1. Conceptos ............................................................................................................. 217
7.8.2. Creación del Modelo ............................................................................................ 219
CAPÍTULO 8. UN MODELO DE FLUIDOS ...................................................221
8.1. SIMULACIÓN DE FLUIDOS ........................................................................ 222
8.1.1. Descripción del Caso de Estudio ........................................................................... 222
8.1.2. Descripción de los Objetos del Modelo .................................................................. 223
8.1.3. Descripción de Términos para el Modelado de Fluidos ........................................... 224
8.2. CONSTRUCCIÓN DEL MODELO.............................................................. 226
8.2.1. Conexión de Objetos ............................................................................................. 227
8.2.2. Configuración de los Objetos ................................................................................. 228
8.3. EJECUCIÓN DEL MODELO ........................................................................ 237
COMPENDIO DE PROBLEMAS .................................................................... 239
REFERENCIAS BIBLIOGRÁFICAS ............................................................... 247
iii

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. Dichas 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.
iv

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 abordan

conceptos puntuales de simulación, su evolución a través del tiempo, modelos de
simulación y su clasificación, simulación de eventos discretos, así como de las
etapas y ventajas de un modelo de simulación, con el objetivo de introducir al
lector en los temas venideros.
Dentro del 2do. Capítulo de nombre “Muestreo y Distribuciones de

Probabilidad”, se discute lo importante que es la recolección de información del
sistema a modelar, cuántas muestras son necesarias, la frecuencia del muestreo,
entre otros temas, con la finalidad de apreciar lo valiosa que es dicha información
para identificar distribuciones de probabilidad de manera adecuada.
El 3er Capítulo “Identificación de Distribuciones con ExpertFit”, describe

de manera general lo importante que es la recolección de datos del sistema real de
interés y muestra cómo mediante el uso del software ExpertFit es posible
identificar la distribución que mejor se ajuste a un conjunto de datos disponibles.
Entre otras cosas, se discute; cómo determinar los estadísticos de un conjunto de
datos, cómo crear histogramas y gráficos variados para el análisis de los datos, la
forma en que se aplican pruebas de bondad de ajuste y cómo obtener los
parámetros de la mejor distribución asociada con los datos de entrada para su
aplicación en el Software FlexSim.
Respecto al tema “Del Software FlexSim” contenido en el 4to Capítulo, se

hace una remembranza del software, se puntualiza en algunas aplicaciones
comunes y se refieren las características y terminologías del mismo.
Para iniciar con la creación de un modelo, el 5to. Capítulo “Construcción

de un Modelo Básico”, contiene las instrucciones simples y las recomendaciones
necesarias para construir un primer modelo 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.
Con intención de plantear un escenario más completo, el 6to. Capítulo

“Construcción de un Modelo Paso a Paso”, 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 7mo. 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.
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.). A ello, 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 documento, 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 dinámica de fluidos.
vi

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

https://www.flexsim.com/ y de clic en “TRY FLEXSIM FREE”. 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 8 o 10 (con 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.
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 de la guía User
Manual la 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/,
y si lo require póngase en contacto con los responsables del sistema.
2019
Isaías Simón Marmolejo
vii

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 la capacitación brindada a un servidor.
A mis hijos Yohan Simón y Hakim Simón que atraviesan sus tremendos
siete y dos años, respectivamente, 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 que ha sido parte
fundamental de mi pequeña familia.
A mis padres Mario Simón y Cristina Marmolejo con quienes tengo una
deuda de enorme gratitud por siempre creer en mí.
Y por supuesto a mis colegas y amigos de la Escuela Superior de Cd.

Sahagún en especial al Dr. Jorge Zuno Silva y al Ing. Martín Ortiz Granillo, que
de una manera u otra me ofrecieron su apoyo para concluir esta obra.
2019
viii

1
CAPÍTULO 1.
ESQUEMA DEL CAPÍTULO

Revisión de
Literatura
la
1.1. DEFINICIÓN DE SIMULACIÓN

1.2. LA SIMULACIÓN A TRAVÉS DEL TIEMPO
1.3. MODELO DE SIMULACIÓN
1.4. CLASIFICACIÓN DE LOS MODELOS DE SIMULACIÓN
1.5. SIMULACIÓN DE EVENTOS DISCRETOS
SIMULACIÓN
1.7. VENTAJAS Y DESVENTAJAS DE LA SIMULACIÓN
1.8. ACTIVIDADES COMPLEMENTARIAS
OBJETIVOS DE APRENDIZAJE
Después de un cuidadoso estudio de este capítulo, Usted debe ser capaz de

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

entre otros temas.
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.
4. Comprenderá la importancia de los eventos en la simulación de
sistemas de producción o de servicios.
5. Tendrá conocimiento de las etapas necesarias en el desarrollo de un
proyecto de simulación, así como de las ventajas y desventajas del mismo.
NOTA:
La fuente del total de las figuras ilustrativas aquí mostradas fuerón tomadas del
software FlexSim versión 19.2.4, 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 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., 2009).
Por otro lado, Kelton et al., 2008, menciona que 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 evolución y tendencias al tema se dan en
el siguiente apartado.
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., 2018).
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

Capítulo 1. Revisión de la Literatura. 3
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 facilitó 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
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., 2018).

1.2.1. 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, Simcad y Simio. 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., 2018), ver
figura 1.1.
Figura 1.1. Ejemplo de la simulación orientada a objetos en 3D con el software

FlexSim.
Dado que las alternativas para el desarrollo de un proyecto de simulación

pueden ser muchas, no debe olvidarse que un buen software de simulación debe:
1. Permitir un uso simple y entendible. Los manuales, libros o tutoriales del

software deberán ser fáciles de interpretar.
2. Ser capaz de modelar sistemas con una gran cantidad de variables y por
periodos prolongados de tiempo.
3. Debe admitir conjunción de módulos o subsistemas creados por separado,
de tal forma que los subsistemas sean verificados y validados antes de
integrarse como un todo.
4. Deberá tener objetos y rutinas prediseñadas, que permita su fácil
construcción y programación. Con esto, la probabilidad de cometer algún
error disminuye.

5. El software también deberá permitir la programación de rutinas diferentes a

las ya prediseñadas.
6. La detección de errores dentro de la programación deberá ser en lo posible
automática. Así, el reporte de inconsistencias en cuanto códigos y lógica
serán visibles para el usuario.
7. Deberá observarse una buena animación de los objetos mientras el modelo
es ejecutado. Además, los gráficos y objetos deberán ser editables para
ilustrar distintos escenarios.
8. Deberá ser posible importar y exportar información numérica a paquetes
externos como Excel.
9. Se deberá permitir la ejecución de distintas corridas y escenarios.
10. Las estadísticas colectadas al final de la simulación deberán ser claras y
entendibles.
11. Por último, no pase por alto el costo que implica la adquisición,
mantenimiento y operación del software.
1.3. MODELO DE SIMULACIÓN
La simulación inicia con un modelo. Un modelo es una descripción física o

matemática de un objeto, evento o sistema y usualmente representa un punto
particular de acción en el tiempo (Beaverstock et. al., 2018). A ello, 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). Aquí, el término modelo será empleado para estudiar y determinar la
representación de un sistema real de manera abstracta con la intensión de predecir
el comportamiento de éste.
Como se ha expuesto, el sistema es un todo integrado, sin embargo, para

intentar controlar el desarrollo de un sistema hacia su objetividad, es necesario
experimentar con sus elementos, dicha alteración de elementos nos conduce a la
manipulación del sistema. Una alternativa sería manipulando al sistema real y otra
modelarlo, ver figura 1.2.

Fuente: Elaboración propia con base en Law et. al., 2007.
Figura 1.2. Alternativas bajo las cuales se puede experimentar con un sistema.
Después de observar la figura 1.2, muy acertadamente se puede decir que

la mayor certidumbre se puede obtener al experimentar con el sistema real, aunque con
esto se corre el riesgo de contraer problemas graves por malas decisiones:
 El tomar decisiones sobre la alteración de elementos de un sistema existente,

puede ocasionar costos y riesgos no previstos, por lo que sería peligroso
manipular el sistema real con sólo tratar de adivinar posibles efectos.
 No es nada fácil visualizar o proyectar condiciones distintas al estado normal
del sistema en situaciones futuras, pues depende en gran medida de su
ambiente, entonces estaríamos dejando de lado posibles acciones favorables
o menos favorables que podrían ocurrir si las condiciones cambian en
escenarios futuros.
 Muchos sistemas son proyectos de nueva creación y sólo se tienen
idealizados en un documento electrónico o en papel, por lo que no se puede
experimentar físicamente con ellos.
Todo ello si el sistema existe, pero ¿qué pasa cuando el sistema no existe
o resulta complicado e incluso peligroso manipular sus elementos? La
experimentación con un modelo del sistema implica el modelado de una solución
mental, verbal, física o matemática la cual es resultado de la abstracción de las

propiedades de un sistema, mediante intuición, cualidades y ecuaciones que

expresan cualitativa, cuantitativa y lógicamente las relaciones entre sus elementos.
Los modelos mentales son intuitivos y de perfil dificultoso a la hora de

formalizar, su representación en un sistema real se desarrolla a través de la
enseñanza, práctica y experiencia del modelador, los modelos verbales son usados
para relacionar los sistemas frente a un estímulo, estos son elaborados con base
en el conocimiento que existe de ejemplares distintos, mientras que un modelo físico
es una réplica física o un modelo a escala del sistema. Por otro lado, un modelo
matemático utiliza una notación simbólica y ecuaciones matemáticas para
representar a un sistema, las soluciones analíticas mediante herramientas
matemáticas (álgebra, cálculo diferencial e integral, teoría de probabilidades,
modelos de investigación de operaciones, etc.), obtienen soluciones exactas a los
problemas de interés, sin embargo; la mayoría de los sistemas reales son muy
complejos para permitir evaluaciones analíticas, por lo que estos sistemas pueden
ser estudiados mediante la simulación. Law et al. (2007), puntualiza que; este tipo
de modelos es sólo un conjunto de aproximaciones y suposiciones estructurales
y cuantitativas, acerca de la forma en que funciona o funcionaría el sistema.
Es importante notar que, un modelo de simulación 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 y puede clasificarse entre grandes áreas. Véase el
siguiente apartado.
1.4. CLASIFICACIÓN DE LOS MODELOS DE SIMULACIÓN
Aunque muchos autores recientemente han aportado su opinión respecto a la

anterior clasificación (figura 1.2), todos coinciden en que los modelos de
simulación de un sistema en particular se rigen bajo los siguientes criterios:
Estática Vs. Dinámica
No tiene importancia el tiempo o es indispensable; Ejemplos: la simulación de

números aleatorios para algún juego de azar en un casino de las Vegas es una
simulación estática, la simulación de las operaciones de un banco a lo largo de un
día, es un ejemplo de una simulación dinámica. Como se puede observar el tiempo
no desempeña un papel natural en los modelos estáticos, pero sí en los dinámicos.
Determinista Vs. Estocástica
Se está seguro de lo que ocurrirá o hay incertidumbre; Ejemplos: si en la Secretaría

de Relaciones Exteriores todos los ciudadanos llegan a tramitar su pasaporte bajo

una previa cita programada, se presentan tiempos de llegadas determinísticos. Por
el contrario, los modelos de simulación estocásticos tienen una o más variables
de entrada aleatorias y los tiempos son inciertos o nada precisos “tiempo entre
llagada de las personas al cine o los autos a una gasolinera”. Cabe señalar que las
variables de entrada aleatorias producen variables de salida aleatorias. Los
modelos que no tienen entradas aleatorias son deterministas, los modelos
estocásticos, operan con al menos alguna entrada aleatoria.
Cambio continuo Vs. Cambio discreto
El estado de los elementos de un sistema cambia continuamente o solo en

determinados instantes del tiempo. Ejemplos: el flujo de agua que entra y sale en
una planta tratadora de aguas residuales, y la entrada y salida de clientes que pagan
la despensa en un cajero de algún supermercado, son ejemplos de cambios
continuos y discretos respectivamente pues en el primer ejemplo el agua no
muestra un espacio de tiempo entre litro y litro y las llegadas de las personas que
pagan en algún cajero del supermercado si tienen tiempos variados entre una y
otra. Sin embargo, se pueden tener cambios tanto continuos como discretos en el
mismo modelo de un sistema particular, pero la decisión de utilizar un discreto o
continuo depende de los objetivos específicos del proyecto. Por ejemplo, un
modelo del flujo de autos en una caseta de peaje sería discreto si las características
y el tiempo entre llegadas de los automóviles son importantes. Ahora bien, si los
vehículos se analizan "en conjunto" el flujo de tráfico puede ser descrito por las
ecuaciones diferenciales en un modelo continuo, esto último recibe el nombre de
modelo combinado “continuo-discreto” (Law et al., 2007 y Kelton et al., 2008).
Otro caso de un modelo híbrido (continuo-discreto), sería el modelado de una
planta embotelladora de bebidas, donde por una línea de producción fluye el
líquido que será dosificado y por otra línea los envases donde se depositará el
líquido, hasta el punto donde ambos se unen para formar un sólo producto, o
bien para modelar fluidos como: agua, leche o de alta velocidad, tales como
granos, azúcar, etc.
Como una observación adicional se hace notoria la importancia de

acentuar que los modelos operacionales en muchos estudios de simulación son
dinámicos porque cambian continuamente en el tiempo, estocásticos porque son
inciertos, y discretos porque los cambios de estado de sus elementos ocurren sólo
en instantes del tiempo. A estos modelos de simulación se les conoce bien como
“modelos de simulación de eventos discretos”, término que se adopta en el
contenido de este libro.

1.5. SIMULACIÓN DE EVENTOS DISCRETOS
El formalismo Sistemas de Eventos Discretos (SED) fue desarrollado por

Bernard Zeigler a mediados de los setentas (Bernard et al., 2000, 1976). Un
sistema de eventos discretos permite representar todos los sistemas cuyo
comportamiento entrada/salida puede ser descrito por secuencias de eventos
sujetos a un estado con números finitos de cambios en cualquier intervalo finito
de tiempo. Law et al., (2007) menciona que: Simulación de Sistemas de
Eventos Discretos contempla la modelación de sistemas a medida que
evoluciona con el tiempo por una representación en la que la variable de estado
cambia instantáneamente en puntos separados en el tiempo (en términos
matemáticos, podríamos decir que el sistema puede cambiar en sólo un número
contable de puntos en el tiempo). Estos puntos en el tiempo se dan cada que
ocurre un suceso, cuando un evento es definido como una ocurrencia instantánea
que puede cambiar el estado del sistema. Aunque la simulación de sistemas de
eventos discretos conceptualmente podría ser hecha con cálculos manuales, la
cantidad de datos que pueden ser almacenados y manipulados para la mayoría de
los sistemas del mundo real exigen que las simulaciones de eventos discretos se
lleven a cabo en una computadora.
Un 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 lo que pasa en un momento específico del tiempo
(Winston, 2005). De esta forma, el estado de los elementos de un sistema cambia
continuamente o solo en determinados estados del tiempo. Ejemplos de estos
son: un nuevo elemento o entidad que entra en el sistema, una entidad que
termina su operación y continúa su proceso o sale del sistema o bien cuando la
simulación se detiene en un determinado instante del tiempo, esta serie de
actividades son llamadas eventos discretos, porque hay un momento específico
del tiempo en que cada una de estas actividades ocurren.
Acciones como mover un tráiler (recurso móvil) contenedor de leche

de las granjas (punto de partida X), hasta una planta procesadora de productos
lácteos (punto de llegada Y) no se pueden considerar eventos discretos porque
éstas tienen una duración de tiempo; sin embargo, un evento como éste, se podría
describir y modelar como dos acciones o eventos discretos separados: el evento
del tráiler que abandona la granja (punto X) y el evento del tráiler que llega a la
planta procesadora de lácteos (punto Y). Así, es posible integrar valores de
tiempo con cada uno de estos dos distintos eventos discretos, podrían modelarse

las acciones de duración con una diferencia de tiempo entre el evento que marca
el principio del punto X y el evento extremo final del punto Y. Por ejemplo,
observe la figura 1.3:
Figura 1.3. Rutina de eventos discretos.
Puede observarse que la llegada (arribo) al punto 𝑌 ocurre 5 horas y 10

minutos después de dejar el punto 𝑋. Por tanto, en este punto, se puede observar
que si el tráiler deja el punto 𝑋 a las 6:15 am, entonces la leche que trasporta el
tráiler llegará al punto 𝑌 a las 11:25 am. El propósito de la simulación de sistemas
de eventos discretos es trabajar con sistemas amplios y complejos calculando la
cantidad de eventos que ocurren en relación con un sistema real. En el ejemplo
anterior, se supone que cuando llega el tráiler al punto 𝑌, una carga de leche llega
a las válvulas de los silos contenedores (punto 𝑍) de la planta productora de
lácteos donde el proceso de descarga tarda 30 minutos (tiempo de proceso).
Esto es, la entrada de leche a las válvulas de los silos contenedores (recurso fijo)
de la planta se activa por la llegada del tráiler y la descarga de leche ocurre con un
retraso de 30 minutos después de la llegada del tráiler al punto 𝑌, así pues, podría
observarse como la descarga de la leche se concluirá a las 11:55 am. Si se continúa
avanzando con el flujo que sigue la leche por la planta productora de lácteos,
podríamos ver como esto desencadena una serie de eventos que altera el
comportamiento de toda la empresa en distintos lapsos de tiempo. Este pequeño
ejemplo, podría simularse como un sistema de eventos discretos.
Dadas las condiciones anteriores, una manera de llevar a cabo la

simulación es usar el reloj en tiempo real para cronometrar los retrasos, y leer el
valor en el reloj en cada ocurrencia de los eventos, sin embargo, esto tomaría

innecesariamente mucho tiempo. Es decir, sería completamente inútil esperar 5

horas y 10 minutos para determinar el tiempo de la llegada del tráiler a la planta
cuando un simple cálculo es suficiente. El objetivo de la simulación de sistemas
de eventos discretos es calcular, tan rápidamente como sea posible, los tiempos
físicos que ocurren en el sistema real, pero sin esperar realmente los retrasos entre
los eventos que ocurren en el tiempo real. Para lograr esto en un programa
secuencial, se usa una cola de eventos que están listos para ser generados. Esta
trayectoria de eventos se guarda y ordena en tiempo creciente y el programa
procesa los eventos en ese mismo orden. El programa inicia con uno o más
eventos en la cola, pues tiene que construirse el conocimiento sobre cómo otros
eventos pueden ser agregados a la cola de eventos. Los detalles de lo antes
mencionado se describen en el siguiente tema.
1.5.1. Mecanismos de Avance del Tiempo en Simulación
Usualmente los mecanismos de tiempos fijos y tiempos variables están

caracterizados por las secuencias de eventos que ocurren en un determinado
periodo de tiempo, un ejemplo de estos podría ser desde que una pieza entra a un
centro de maquinado hasta que sale como producto terminado, o bien desde que
un cliente entra a un banco a realizar algún servicio hasta que abandona el sistema
y se va. Lo que se describe a continuación se complementa con aportaciones
teóricas de Law et al. (2007), respecto a los mecanismos de avance en el tiempo,
el apartado termina con el ejemplo de un modelado de línea de espera o teoría de
colas el cual ilustra a detalle la importancia de los eventos con respecto al
incremento del tiempo.
Debido a la naturaleza dinámica de los modelos de simulación de eventos

discretos, es necesario no perder de vista el valor actual de la simulación a medida
que esta avanza. Por tanto, es necesario un mecanismo para avanzar en el tiempo
simulado desde un valor a otro. Se le nombra reloj de simulación, a la variable
que en un modelo de simulación muestra el valor actual del tiempo simulado. Los
dos enfoques principales descritos a continuación, han sido sugeridos para
avanzar en el reloj de simulación: avance de tiempo del evento próximo (tiempo variable)
y avance de tiempo con incrementos fijos (tiempo fijo). El primer enfoque es usado por
los principales softwares de simulación y es con este lenguaje de propósito general
con el que la mayoría de los programadores modelan, mientras que el segundo, es
un caso especial del primero.
Con el enfoque del avance de tiempo del evento próximo, el reloj de

simulación es iniciado en cero y el tiempo de ocurrencia de los acontecimientos
futuros es determinado. El reloj de simulación es entonces avanzado al siguiente

tiempo de ocurrencia del primero de los eventos futuros, en el punto en el cual el

estado del sistema es actualizado (cambiado), esto con la finalidad de contabilizar
el hecho de que el evento ha ocurrido y así el conocimiento de los tiempos de
ocurrencia de los eventos futuros también se actualiza. Entonces el reloj de
simulación avanza hasta el tiempo en el que aparece el evento (nuevo) más
cercano, el estado del sistema se actualiza, y los tiempos de eventos futuros se
determinan y así sucesivamente. Este proceso de avance del reloj de simulación
de un evento a otro en el tiempo continúa hasta que, finalmente alguna condición
de detención preestablecida es satisfecha.
Dado que todos los cambios de estado ocurren en eventos de tiempo para
un modelo de simulación de eventos discretos, los períodos de inactividad son
ignorados por saltos en el reloj de un evento de tiempo a otro. Un modelo con
avance de tiempo con incremento fijo no “salta” estos periodos inactivos, los
cuales tienden a la utilización más prolongada del computador. Cabe señalar que
los saltos sucesivos del reloj de simulación son generalmente variables (o
desiguales) de tamaño, de ahí el nombre de mecanismo de tiempo variable.
Ejemplo: En un sistema de teoría de colas o filas con un sólo servidor se

pueden modelar los avances de tiempo de los eventos próximos o tiempos
variables:
Notación:
𝑨𝒊 = 𝑡𝑖 - 𝑡𝑖−1 = periodo de tiempo entre llegadas de un cliente y otro
𝑺𝑡𝑖𝒊 =
= de llegada
tiempo que tarda eldeli-esimo
i-esimocliente
clienteal (𝑡 = 0) por un servidor
ser0 atendido
𝑫𝑖 = tiempo que espera el i-esimo cliente en la cola antes de ser atendido
𝑪𝒊 = 𝑡𝑖 + 𝐷𝑖 + 𝑆𝑖 = tiempo en que el i-esimo cliente completa el
servicio y abandona el sistema
𝒆𝒊 = tiempo de ocurrencia del i-esimo evento (𝑒0 = 0)
En cada una de estas cantidades se define una variable aleatoria. Suponga

que las distribuciones de probabilidad del tiempo entre llegadas de un cliente a
otro 𝐴1 , 𝐴2 , 𝐴3 ... y los tiempos de servicio 𝑆1 , 𝑆2 , 𝑆3 ... se conocen y se tienen
funciones de distribución acumulada denotadas por 𝐹𝐴 y 𝐹𝑆 , respectivamente. En
general, 𝐹𝐴 y 𝐹𝑆 se determinan por la recolección de datos del sistema de interés
y por las distribuciones específicas consistentes con los datos, revisar Capítulo 2
y 3. En el momento 𝑒0 = 0 el estado del servidor es ocioso (inactivo) y el tiempo
𝑡1 de la primer llegada se determina por la generación de 𝐴1 de 𝐹𝐴 y la adición de
0. Entonces el reloj de simulación es avanzado de 𝑒0 al tiempo del próximo

(primer) evento, 𝑒1 = 𝑡1 (ver la figura 1.4, donde las flechas curveadas

representan el avance en el reloj de la simulación). Desde que el cliente llega en el
momento 𝑡1 encuentra al servidor inactivo, por lo que inmediatamente entra en
servicio y su tiempo de espera en la cola (fila) 𝐷1 = 0, esto conlleva a que el
estado del servidor pasa de inactivo a ocupado. El tiempo, 𝑐1 en que el cliente
completa servicio y abandona el sistema se calcula mediante la generación 𝑆1 de
𝐹𝑆 y la adición de 𝑡1 . Finalmente, el tiempo de la segunda llegada, 𝑡2 se calcula
como 𝑡2 = 𝑡1 + 𝐴2 , donde 𝐴2 se genera a partir de 𝐹𝐴 . Sí 𝑡2 < 𝑐1 , como se
muestra en la figura 1.4, el reloj de simulación avanza desde 𝑒1 hasta el momento
del próximo evento, 𝑒2 = 𝑡2 . (Sí 𝑐1 es menor de 𝑡2 , el reloj de la simulación
avanza de 𝑒1 hasta 𝑐1 ).
Fuente: Elaboración propia con base en Law et. al., 2007.
Figura 1.4. Mecanismo de eventos y avance del tiempo (la figura ilustra el enfoque
del tiempo de un sistema de colas con un sólo servidor).
Desde que el cliente llega en el tiempo 𝑡2 encuentra el servidor ya en

estado ocupado, el número de clientes en la cola se incrementa de 0 a 1 y el
momento de la llegada de este cliente se registra; sin embargo, su tiempo de
servicio 𝑆2 no se genera en este momento. De la misma forma, el tiempo de la
llegada del tercer arribo o cliente 𝑡3 se calcula como 𝑡3 = 𝑡2 + 𝐴3 . Sí 𝑐1 < 𝑡3 ,
como se muestra en la figura 1.4, el reloj de simulación avanza de 𝑒2 hasta el
tiempo del próximo evento, 𝑒3 = 𝑐1 , donde el cliente completa el servicio y deja
el sistema, el cliente en la cola (es decir, el que llegó en el tiempo 𝑡2 ) entra en
servicio y su retraso en la cola junto con el tiempo en el que le brindaron el servicio
se calculan como 𝐷2 = 𝑐1 + 𝑡2 y 𝑐2 = 𝑐1 + 𝑆2 (𝑆2 ahora se genera a partir de
𝐹𝑠 ), y el número de clientes en la cola se redujo de 1 a 0. Sí 𝑡3 < 𝑐2 , el reloj de
simulación avanza de 𝑒3 hasta el tiempo del próximo evento,𝑒4 = 𝑡3 , etc. La
simulación podría concluir eventualmente cuando, por ejemplo, el número de
clientes que han observado retrasos (número de clientes en la cola) alcanzan un
valor determinado.

Bajo este esquema, se utilizará la simulación de sistemas de eventos

discretos, dado que es adecuada para representar la ocurrencia de eventos en los
sistemas industriales y de servicios.

SIMULACIÓN
Para describir cómo se modela un sistema, en la literatura se puede encontrar que

los temas relacionados con el diseño, el análisis y la representación de modelos en
el software son esenciales para un estudio de simulación exitoso. Sin embargo,
éstos no son los únicos ingredientes, ya que se observa que ningún estudio de
simulación seguirá una “fórmula” preestablecida, pues hay varios aspectos que
tienden a aparecer con frecuencia en diferentes publicaciones. Lo que se describe
a continuación es una adaptación de los pasos a seguir en un estudio de simulación
con base en Banks et al. (2009), pero retroalimentado con aportaciones de autores
como Kelton et al. (2008), Law et al. (2007), García et al. (2006), Coss (2003) y
con opiniones propias. Con todo esto, en la figura 1.5 se describe una propuesta
de la secuencia de pasos que deben seguirse para la elaboración del modelo de
simulación y para la realización de los experimentos. Debe observarse que cada
uno de los pasos de dicha guía ha sido numerado, con el propósito de tener una
referencia que servirá para los comentarios que se dan a continuación:
1) Formulación del problema
Si lo que se busca es transformar una situación confusa e indeterminada,

reconocida como problemática, es necesario comprender el sistema a modelar.
Esto incluye el estado actual del sistema (lo que está sucediendo y por qué está
sucediendo) y el deseado (cómo puede hacerse mejor). De esta manera, se podrán
plantear los objetivos del proyecto de simulación una vez que se logre definir los
elementos componentes del sistema, las variables, su comunicación e interacción,
así como establecer sus alcances y limitaciones. Una forma eficaz de lograr lo
descrito, es mediante la observación directa, la realización de entrevistas al
personal involucrado en el proyecto y todas las técnicas a nuestro alcance que
sean fuente de información. Así, se obtendrá el conocimiento que describe y
analiza los métodos, se identificarán sus lineamientos y recursos, y se clarificarán
sus supuestos y consecuencias.

Fuente: Elaboración propia con base en Banks et at., 2009.
Figura 1.5. Guía del conjunto de etapas definidas para alcanzar conocimientos
válidos en un proyecto de simulación.

2) Colocación de objetivos y el plan del proyecto global
Los objetivos indicarán las preguntas que deben responderse mediante la

simulación, la clase de información que debe ser colectada y el nivel de detalle
necesario. Aquí se pueden hacer especificaciones acerca de lo que se observa,
manipula, cambia y entrega. Por lo tanto, es necesario establecer lo que se espera
del modelo, como los criterios bajo los cuales se puede medir su comportamiento.
3) Conceptualización del modelo
Para tener una idea de la lógica o comportamiento general del sistema y sus
operaciones, no es necesaria una copia paso a paso, entre el modelo y el sistema
real, sólo es necesaria la esencia de este último. En esta etapa deben definirse qué
aspectos del sistema serán representados en el modelo y cuáles no. Además, se
deberá establecer con qué nivel de detalle se hará dicha representación (recuerde
que el nivel de detalle depende en gran medida de lo que el dueño del sistema esté
dispuesto a pagar). Todo lo que se desea en este punto es ingeniar un bosquejo o
modelo conceptual del sistema (diagramas de flujo, de hilos, correlación o de
actividades serán necesarios).
4) Recolección y procesamiento de datos
Los objetivos del estudio establecen, en gran medida, la clase de datos que deben
ser obtenidos y cuántos detalles son adecuados a fin de no perder información
valiosa. Los datos pueden ser obtenidos de observaciones de un sistema ya
existente. En el caso de un sistema inexistente, los datos deben ser estimados. En
esta etapa es vital, para ambos casos, que se involucren las personas que en verdad
saben lo qué está pasando en el sistema real (operadores, supervisores,
inspectores, todos aquellos que conocen a detalle el sistema). Un ejemplo de
algunos datos que deben obtenerse son las condiciones y parámetros del proceso
de producción, personal que labora y las acciones que realizan, materiales o
materias primas utilizadas, maquinaria o equipos, esquemas, planos,
procedimientos y, si es factible, datos históricos, fotos y videos. Todo esto con el
fin de despejar cualquier duda, por muy simple o lógica que esta sea. Mediante
estos datos se obtendrán los valores de los parámetros estadísticos (definición de
variables respecto a una distribución de probabilidad) que serán utilizados durante
la programación del modelo de simulación (más detalles se dan en los Capítulos
2 y 3).
5) Construcción del modelo
Es muy importante entender qué métricas se usarán. En este sentido, Banks et al.
(2009) contextualiza que “la construcción de un modelo de simulación es tanto
un arte como una ciencia”. Sin embargo, la experiencia dicta que, para dar una
solución concreta al problema en cuestión, es necesario un buen aporte de

creatividad por parte del analista. En este punto el objetivo es ganar conocimiento
acerca de la naturaleza del sistema, así como proyectar situaciones alternas
desprendidas por causa de un desencadenamiento de eventos distintos a las
condiciones normales de operación. Con el propósito de pronosticar eventos,
evaluar consecuencias y proponer alternativas que contribuyan a mejorar el
comportamiento de éste. Es aquí donde los términos información, análisis, critica,
diseño y creatividad se integran para dar forma a la estructura del modelo. El
lector observará que esta etapa requiere de conocimiento, habilidades y
experiencia personal; sin embargo, este paso es el más divertido de todo el estudio.
Al comenzar a construir el modelo se debe considerar la magnitud y el

nivel de detalle requerido. Es recomendable empezar con un modelo simple para
después modificarlo hasta uno de mayor complejidad, es decir, la modelación de
un sistema pequeño y simple es rápida y certera si la información requerida está
completa y es correcta. Sin embargo, cuando un sistema es complicado o
demasiado grande, la clave implica la fragmentación del sistema en módulos más
pequeños y simples con la intención de evaluarlos por separado antes de
integrarlos en un sólo modelo. Esto facilitará el hallazgo de errores por
información incorrecta, incompleta, mala programación, etc. Sin embargo, la
complejidad del modelo final no debe exceder los requerimientos que cumplan
con el propósito para el cual se está haciendo el diseño. En cuanto a los datos de
entrada y las condiciones iniciales, es necesario que desde el inicio se determinen
los valores asignados a las variables y parámetros del modelo, para lo cual es
importante recurrir a los supuestos del modelo conceptual y a métodos de ensayo
y error.
Finalmente, la idealización del sistema debe ser codificada en un formato

que sea reconocido por un computador digital. La formulación de la codificación
requiere que se definan tres aspectos importantes: (1) la información de entrada y
condiciones iniciales, (2) el software a emplear, y (3) las habilidades y experiencia
del programador. La información de entrada y condiciones iniciales garantizan la
certeza de que el modelo realmente representa al sistema real. Por tanto, antes de
iniciar la programación en algún software de simulación se hace eminente la
importancia de interpretar y depurar la información, y con ello crear diagramas de
flujo que describan la información del sistema y su lógica de interacción. En
cuanto a computación se refiere, es necesario elegir el software adecuado para el
sistema a modelar, ya que estos pueden ser muy distintos al momento de modelar
un sistema industrial. Como tercero y último punto, es conveniente mencionar
que las habilidades y experiencia del programador determinan la calidad del
modelo, ya que sus conocimientos y habilidades adquiridas en proyectos similares
como su creatividad e ingenio servirán como base para planear, organizar, dirigir
y controlar un proyecto de simulación exitoso. Al finalizar esta etapa, el modelo
será verificado y validado con la intención de poner en evidencia posibles
desviaciones con respecto al sistema real.

6) Verificación
Después de construido el modelo en un software de simulación, es necesario

asegurar que el modelo conceptual refleje con precisión los parámetros, sucesos
y lógica del sistema real. Aquí es donde se podrá verificar si el modelador alimentó
al software de simulación con información correcta. Asimismo, se debe
corroborar que al momento de terminar el modelo no hayan cambiado las
condiciones del sistema real. Por lo tanto, es necesario comprobar lo anterior para
asegurar un modelado correcto.
7) Validación
Validar un modelo es hacer un juicio relativo; su utilidad debe ser juzgada y

comparada con el sistema real mediante la realización de pruebas del modelo con
respecto al sistema real en condiciones normales de operación. El modelo es
válido si representa adecuadamente al sistema que está siendo modelado. Aquí se
pueden formular preguntas del siguiente tipo: ¿La secuencia de movimientos y
operaciones son correctas?, ¿Son semejantes los estadísticos del modelo con los
de la realidad? Si lo anterior es correcto, entonces podría decirse que el modelo sí
representa al sistema real.
8) Diseño de experimentos
Posteriormente, una vez desarrollado, validado y verificado el modelo de

simulación, éste puede ser utilizado para investigar una amplia variedad de
preguntas del tipo ¿Qué pasa si...?, acerca del mundo real (Kelton et. al., 2008).
En este paso se planean los experimentos que se harán mediante el modelo de
simulación establecido (qué es lo que desea saber y cómo los experimentos de
simulación lo llevarán a obtener las respuestas de forma precisa y eficaz). Algunos
de los aspectos que se deben definir son: las condiciones bajo las cuales se harán
las simulaciones, la duración del tiempo que se desea simular y el número de
simulaciones requeridas (réplicas).
Algunos ejemplos de esto serían: simular el modelo del sistema bajo

condiciones extremas (catástrofes), aumento o disminución de producción, paros
programados en los equipos por mantenimiento ó fayas repentinas, crecimiento
o expansión con proyecciones a diferentes lapsos de tiempo, remplazos, bajas o
habilitación de equipos y todas las distintas modificaciones posibles que nos
lleven a obtener respuestas a la solución del problema abordado en los objetivos
del proyecto.
9) Producción de corridas de simulación y análisis
El objetivo aquí es medir el comportamiento del sistema simulado, por lo que en

este paso se realizan los experimentos establecidos en el punto anterior bajo las

condiciones de interés prestablecidas. El análisis de los resultados de las

simulaciones implica el análisis estadístico de los resultados (tablas de datos y
gráficos) provenientes del paso anterior, con el objeto de hacer inferencia
estadística y proyectar los valores de las medidas de desempeño que son de
interés.
10) Corridas adicionales
Las simulaciones adicionales se hacen necesarias cuando no se está conforme con

los resultados obtenidos en algún panorama proyectado en los pasos anteriores,
o bien cuando se tiene idea de nuevos escenarios que podrían ir incluso más allá
de los objetivos buscados en un inicio. Si se determina que son necesarias las
corridas adicionales, podría requerirse de un nuevo diseño del experimento y por
tanto un nuevo análisis de resultados.
11) Puesta en marcha del modelo
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. Lo anterior
permitirá tomar decisiones con mayor certidumbre fundamentadas bajo los
resultados del análisis estadístico de un modelo de simulación. Sin embargo, tanto
el modelador como el dueño del sistema deberán estar conscientes de que la
información colectada del modelo tiene desviaciones estadísticas por el empleo
de números aleatorios, lo que conlleva a un ciento margen de error. Entonces, al
dar resultados numéricos, lo recomendable es presentarlos con rangos y no en
términos puntuales.
Otra recomendación final es revisar que al concluir el proyecto realmente

se hayan contestado las preguntas y los supuestos que dan respuesta a la solución
del problema abordado. Las opiniones de los involucrados en el proyecto quizá
determinen la aplicación de cambios en un sistema existente o la construcción de
un sistema nuevo. Sin embargo, también puede resultar como una conclusión del
estudio de simulación, que el nuevo sistema propuesto no sea económicamente
atractivo o que por razones económicas sea mejor dejarlo como esta. Esta última
conclusión al proyecto también es una alternativa que debe tomarse en cuenta.

Documentación
Por último, no olvide que los resultados del trabajo deben ser redactados en forma
clara y concisa en un reporte final. Esto tiene el propósito de describir todos los
aspectos importantes del estudio, por este motivo la documentación del proyecto
tendrá que ser una tarea continua durante toda la construcción del modelo de
simulación, esto incluye desde la formulación del problema, objetivos,
consideraciones para elaborar el modelo conceptual y su transformación en el
modelo computacional, criterios utilizados, resultados de los experimentos,
recomendaciones establecidas, conclusiones, hasta las observaciones derivadas de
su implantación. Es importante señalar las recomendaciones claras y sustentables
de lo que el modelador cree oportuno, esto incluye tanto los detalles del análisis
como una presentación, así mismo se recomienda entregar un manual de usuario
para que el cliente o dueño del sistema tenga una mayor facilidad al momento de
dar uso al modelo de simulación concluido.
1.7. VENTAJAS Y DESVENTAJAS DE LA SIMULACIÓN
1.7.1. Ventajas
Las ventajas de un modelo de simulación son muchas y muy variadas, sin

embargo, aquí se describen algunos de los principales beneficios en el preciso
momento cuando se toman decisiones importantes para la empresa.
1. No es necesaria la interrupción de la operación del sistema real. De esta

forma pueden ser exploradas nuevas políticas, reglas de decisión, flujos de
información, procedimientos organizacionales y operacionales, sin alterar el
curso del sistema que se desea evaluar.
2. Realismo. Los modelos de simulación pueden ser realistas en el sentido de
que capturan las características del sistema que está siendo modelado.
3. Aplicación para sistemas no existentes. Los sistemas para los que va a ser
investigado su comportamiento no tienen que existir previamente. Sólo
estarán presentes en las mentes de los diseñadores.
4. Acortamiento o alargamiento de la representación del tiempo real. La
representación del tiempo real puede ser comprimida en los modelos de
simulación. La operación equivalente del sistema real de días, semanas ó meses
a menudo puede ser simulada en una computadora en tan sólo segundos,
minutos u horas. Esto quiere decir que, comparativamente con el tiempo
requerido para la experimentación de un sistema real, mediante la simulación
se puede realizar un mayor número de experimentos, por lo que aumenta el
número de alternativas que pueden ser investigadas. Por otro lado, si se
requiere, la representación del tiempo real puede ser alargada para observar

con más detalle el fenómeno bajo investigación.

5. Especificación diferida de objetivos. Algunos tipos de modelos analíticos
requieren el especificar un objetivo a la salida de la actividad de modelado, el
subsecuente desarrollo del modelo está condicionado a este objetivo. En
cambio, en la simulación no es requerida esta formulación inicial de objetivos.
Esto posibilita tener un conjunto de opciones con lo que se logra un diseño
que eventualmente resulta ser satisfactorio para la toma de decisiones con
criterios múltiples. La especificación diferida de uno o más objetivos también
es una ventaja cuando, aquellos, para los cuales se está haciendo el diseño, no
se ponen de acuerdo inicialmente en los objetivos o cuando la importancia de
distintos objetivos no es evidente o está sujeta a debate.
6. Control de los experimentos. Dentro de la simulación cada variable puede
ser mantenida constantemente, excepto aquellas cuya influencia está siendo
estudiada. Por ello, el efecto de variables no controladas en el comportamiento
del sistema no tiene que ser considerado durante la simulación. Sin embargo,
durante la experimentación con un sistema real, a menudo es requerido este
control.
7. Entrenamiento. La simulación no requiere un gran nivel de sofisticación
matemática en comparación con la modelación utilizada en soluciones
analíticas.
8. Menores costos. Algunos autores han estimado que los estudios diseñados
para estimar las características de un sistema propuesto, mediante la
simulación, pueden tener un costo de un dos por ciento o menos del capital
requerido para la construcción de un sistema real (Henrisken, 1983). De esta
forma, pueden ser probados nuevos diseños de equipos o de distribución física
de instalaciones o de sistemas de transporte, entre otros, sin la necesidad de
utilizar recursos para su compra.
1.7.2. Deventajas
Las principales desventajas pueden englobarse en:
9. Si el modelo de simulación es alimentado con datos e información errónea

colectada del sistema real, los resultados obtenidos pueden apoyar una
decisión equivoca.
10. Falta de obtención de resultados exactos. La simulación sólo proporciona
estimaciones, no resultados exactos debido a que la mayoría de los sistemas
reales están gobernados por variables aleatorias e impredecibles.
11. No es una técnica de optimización. La simulación es una técnica de evaluación
utilizada para responder a preguntas del tipo ¿qué pasa si...?, pero no para
preguntas de ¿qué es lo mejor? La simulación no genera soluciones, sino
que evalúa aquellas que se han propuesto.

Para conocer y profundizar en los temas tratados en este Capítulo se pueden

consultar las referencias citadas al final del libro.
Preguntas
1. ¿Qué determina la validez de un modelo de simulación?

2. ¿Mencione por qué un modelo de simulación no es una herramienta de
optimización?
3. ¿Explique por qué es necesario el uso de una computadora para obtener
información valida de un modelo de simulación?
4. ¿Describa cómo opera el tiempo en un modelo de simulación de eventos
discretos?
5. ¿Cuáles son las estrategias para obtener información estadística del
sistema real necesaria para modelar?
6. ¿Por qué será fundamental determinar correctamente el software a
emplear en un modelo de simulación?
Actividades
1. Enumere y describa brevemente los pasos necesarios para crear un

modelo de simulación.
2. Mencione y describa brevemente tres ejemplos en los cuales se tenga un
problema real donde la simulación sea una alternativa que contribuya con
el mejor desempeño del sistema.
3. Investigue dentro del campo de la simulación la definición de los
siguientes elementos: una entidad, un atributo, una variable, un recurso y
una etiqueta.
4. Con base en la actividad del punto anterior, determine los elementos de
cada uno de estos sistemas.
 Un centro comercial, una caseta de peaje, un banco, una estación de

gas, una línea de producción de automóviles y una universidad
5. Menciona la importancia de la ingeniería de sistemas dentro de la

simulación.
6. Identifique un sistema real y cree un diagrama de flujo general de sus
operaciones. Posteriormente, en un mapa mental explique a la clase cómo
el sistema puede ser descompuesto en subsistemas y cómo iniciaría Usted
la construcción de un modelo de simulación.
7. Con sus propias palabras, mencione la diferencia entre tiempo fijo y
tiempo variable.
8. Indique la importancia que tiene el tiempo con respecto a los eventos
dentro de un modelo de simulación.

2
CAPÍTULO 2. Muestreo y
Distribuciones de
Probabilidad
2.1. INTRODUCCIÓN
2.2. TAMAÑO DE LA MUESTRA
2.2.1. Estimación Preliminar de Variables
2.2.2. Cálculo del Número de Observaciones
2.2.3. Frecuencia de Visitas al Centro de Trabajo para Realizar
Observaciones y Tipo de Muestreo
2.3. DISTRIBUCIÓN DE PROBABILIDAD
2.3.1 Experimento y Espacio Muestral
2.3.2 Variable Aleatoria
2.3.3 Tipos de Distribuciones
 Distribución discreta
 Distribución continua
OBJETIVO DE APRENDIZAJE
Después de revisado el Capítulo 2, el lector comprenderá que en un proyecto

de simulación es necesario saber qué clase de información debe ser recolectada
y con qué nivel de detalle se requiere. Por lo tanto, el apartado describe los
criterios que son necesarios e importantes al determinar los métodos de
recolección de datos, su clasificación y utilidad, con la finalidad de recolectar la
información suficiente de los sistemas a modelar y con ello idealizar conceptos
básicos de probabilidad y estadística con un nivel de certidumbre necesarios.
Adicionalmente, se hace una analogía de temas relacionados con las diferentes
distribuciones de probabilidad definidas teóricamente.

2.1. INTRODUCCIÓN
Al intentar dar soluciones a problemáticas existentes en el sector industrial y de

servicios a través la simulación, así como mejorar los niveles productivos de los
mismos con la mayor certeza posible, es innegablemente necesario el uso de
probabilidades y estadísticas. La estadística inicia desde la recolección de la
información, presentación, análisis y termina hasta sacar conclusiones de los datos
para tomar decisiones acerca de una población, por lo tanto, resulta importante y
necesario ilustrar en términos generales los métodos estadísticos esenciales para
describir y entender la variabilidad de los sistemas. El principal objetivo del
análisis de variables es estimar e inferir las características de interés de una
población específica a partir de una muestra definida (Montgomery y Runger,
2009, p. 3).
A ello, el presente capítulo inicia definiendo conceptos básicos de estadística y

probabilidad para posteriormente proponer estrategias en la determinación del
tamaño de la muestra (factores principales en un estudio de simulación),
posteriormente, se puntualizan los términos de experimento, espacio muestral o
espacio de muestreo y variable aleatoria. Se ilustran de igual forma las variables
aleatorias continuas y discretas, se indica cómo diferenciarlas unas de las otras,
además, se exponen ejemplos de funciones de densidad y de probabilidad, así
como la estadística descriptiva que las define.
2.2. TAMAÑO DE LA MUESTRA
La estadística es el área de estudio o disciplina de las matemáticas que se apoya de

un conjunto de técnicas y procesos para la observación, recolección, organización,
descripción, presentación y análisis de datos numéricos para realizar inferencias
del comportamiento de un fenómeno o población. Si es posible conocer el
fenómeno que genera los datos se podrá anticipar cómo serán los siguientes datos
que se observen, o se podrá aprender a provocarlos o evitarlos (Montgomery y
Runger, 2009, p. 2).
Una población es un conjunto total de elementos que puede ser pequeña

o grande (datos, objetos y/o individuos) y al número de observaciones que hay
en una población se le llama tamaño de la población, la cual pude ser finita o infinita,
se denota al tamaño de la población con el símbolo “𝑁”. Por ejemplo, una
población podría ser el tiempo que tarda un operario en armar una caja de cartón
la cual sigue una distribución normal con media µ y una desviación 𝜎 y, así
entonces la operación es referida como una población normal o población
distribuida normalmente. Sin embargo, la población debe considerarse en gran
medida conceptual ya que muchas veces resulta imposible o poco práctico observar

Capítulo 2. Muestreo y Distribuciones de Probabilidad. 25
a la población completa debido a que con frecuencia no se cuenta con toda la

información necesaria, se requeriría de una enorme cantidad de tiempo y puede
ser demasiado costoso el análisis. Por tal razón, dependemos de una porción de
observaciones de la población, a esta porción o subconjunto de observaciones se
le llama muestra y nos ayudará a inferir sobre la población para tomar decisiones.
Véase la figura 2.1. La muestra es un subconjunto de individuos seleccionados
de una población para realizar inferencias estadística de las propiedades de la
totalidad de un conjunto de elementos, se denota al tamaño de la muestra o
número de observaciones con el símbolo “n” (Montgomery y Runger, 2009, p. 260-
265).
Fuente: Elaboración propia con base en Montgomery y Runger, 2009.
Figura 2.1. Relación existente entre población, muestra y variables.
Entendido lo anterior, en la mayoría de los modelos de simulación es

necesario tomar una muestra aleatoria de una población específica para sacar
conclusiones acerca de esta misma. Una muestra puede ser tomada de una población
estática o de un proceso en curso, para cualquiera que sea el caso la base matemática para esto
es que haya una variable aleatoria asociada con una distribución que gobierne el comportamiento
de la población; en este sentido puede pensarse en la población como la variable
aleatoria y su distribución; una muestra es sólo una secuencia de observaciones
distribuidas en forma independiente e idéntica (IID, por sus siglas en inglés) en
esta variable aleatoria, (Kelton et al., 2008), véase la parate inferior de la figura 2.1.
A esto, y dado que no se conocen con exactitud los parámetros o la distribución
de la población, es necesaria la toma de una muestra para hacer inferencias y
probar hipótesis (más información respetiva al ajuste de datos a una distribuciones
de probabilidad se da en el Capítulo 3).

Ejemplos de muestreo son: investigar el tiempo de operación de una

máquina, la velocidad a la que llegan las personas a un banco, el tiempo que tarda
un camión al ir de un punto al otro, el tiempo que un operario dedica a las distintas
actividades que constituyen una tarea, el número de automóviles que entran a una
caseta de peaje en un periodo de tiempo, al determinar el número de envases con
un llenado incompleto que se producen en un día por una dosificadora de yogurt,
o quizá al medir el nivel diario de agua en una presa, entre otros temas, donde
cada una de estas variables podría ser definida como una población.
Por otro lado, los errores más comunes en la selección de una muestra se
cometen al tomar la información que está más a la mano, la que se toma sin
determinar un tamaño adecuado de la misma o la que se emplea sólo con el hecho
de hacer un juicio subjetivo de la población. Estas técnicas podrían introducir
sesgo en la muestra y como consecuencia el parámetro de interés se sobreestimará
considerablemente al utilizarla, pues estos mismos datos que son observaciones
del sistema real se sujetarán a una distribución que servirá como una entrada en
el modelo de simulación (Montgomery y Runger, 2009, p. 262). Entonces, si el
modelo es alimentado con datos incorrectos, los datos resultantes que también
son estadísticos en el modelo de simulación podrían tener sesgo, y ocurrirá lo que
coloquialmente se dice; “si un sistema se alimenta con basura, producirá basura”.
Para contribuir al tema, he aquí los pasos para un estudio de muestreo:
1) Hacer una estimación preliminar de las variables para las que se busca
información.
2) Calcular el número de observaciones que se tomarán.
3) Determinar la frecuencia de las observaciones en el centro de trabajo y el
tipo de muestreo.
2.2.1. Estimación Preliminar de Variables
En Niebel y Freivalds (2009), se indica que la teoría del muestreo se basa en leyes
fundamentales de probabilidad; donde en un instante dado, un evento puede estar
presente o ausente. Al intentar determinar el número de observaciones 𝑛 que se
deben tomar en un estudio de muestreo, con mucha frecuencia, el analista
desconoce la probabilidad de ocurrencia 𝑝, sin embargo, la mejor estimación de
𝑝 es 𝑝̂ (proporción basada de la muestra). Se espera que el valor de 𝑝̂ de cualquier
muestra tomada este aproximadamente el 95% de las veces dentro del intervalo
del parámetro 𝑝 ± 1.96 desviaciones estándar.
A lo anterior, Niebel y Freivalds puntualiza que, para poder estimar a la variable

𝑝, la proporción basada de la muestra 𝑝̂ se obtiene de una estimación preliminar
o muestreo piloto con una muestra de tamaño 𝑛, y frecuentemente se utiliza la
información de dos o tres días:

𝑝̂ = ∑ 𝑥𝑖 ⁄𝑁 (1)
𝑖=1
Donde
̂𝒑 = Proporción basada de la muestra,
𝒙𝒊 = Número de ocurrencias observadas en 𝑛 observaciones

aleatorias en el día 𝑖(𝑖 = 1, 2, … , 𝑘),
𝒏 = Número de observaciones por día,
𝒌 = Número total de días que se tomaron observaciones, y
𝑵 = Número total de observaciones aleatorias.
No hay que olvidar que a mayor número de observaciones 𝑛 o número de días 𝑘

en la muestra piloto más se aproximará el valor de 𝑝̂ al valor de 𝑝. Esta
información también puede ser obtenida a partir de datos históricos, con
información técnica de los equipos, o en su caso si no se cuenta con ninguna de
las anteriores el valor estimado 𝑝̂ será igual a 0.5 (50%).
2.2.2. Cálculo del Número de Observaciones
Para identificar la mejor distribución que se ajuste a un conjunto de datos, el

número de ciclos o muestras a observar resulta ser uno de los temas de mayor
conflicto, lo anterior debido a que como se ha dicho, el tiempo ciclo de las
operaciones individuales influye directamente en un modelo de simulación, a ello,
García (2005), menciona que los métodos más comunes para determinar el
número de observaciones son el método 1) estadístico y 2) el método tradicional:
Método Estadístico
En la referencia (Niebel y Freivalds, 2009, p. 442), se describe que al intentar

determinar el número de observaciones necesarias 𝑛, el recolector de datos deberá
conocer la exactitud con la cual se desean los resultados, ya que el número de
observaciones necesarias en un estudio de muestreo depende directamente de la

tolerancia o un límite aceptable del error ℓ con un nivel de confianza de

(1 − 𝛼)100%, donde:
ℓ = 𝑍𝛼⁄2 √𝑝𝑞/𝑛 (2)
Al despejar a 𝑛 nos queda como:
(𝑍𝛼⁄2 )2 𝑝𝑞
𝑛 = (3)
ℓ2
Donde
𝒑 = probabilidad de ocurrencia,
𝒒 = 𝟏 − 𝒑 = probabilidad de una ausencia de ocurrencia,
𝒏 = número total de observaciones,
𝒁𝜶⁄𝟐 = valor de tablas de la distribución normal con 𝛼 grados
de libertad, y
𝓵 = Error admitido.
Por ejemplo, el intervalo de confianza requerido para estudiar un proceso

es del 95%, α = 5%, ó 0.05, y por tanto el valor de 𝑍0.05⁄2 en las tablas de una
distribución normal es 1.96, para cualquier otro valor de confianza requerido, el
valor de 𝑍𝛼⁄2 cambia.
Es importante mencionar que entre más se acerque el tamaño de la

muestra al tamaño de la población, mayor certidumbre se tendrá en los resultados.
3,000 lecturas del tiempo que invierte un operario al armar una caja de cartón dan
un resultado considerablemente más confiable que 200. Si bien es cierto, la
obtención de un número elevado de observaciones mejora la exactitud de los
resultados (cuantas más observaciones, mayor validez tendrá la respuesta final),
pero a su vez se incurre en una elevada inversión de tiempo y recursos, mismo
hecho que se traduce en costos, por tanto, quizá 200 observaciones son
suficientes. Los siguientes ejemplos ilustran el caso de un muestreo simple, la
técnica para muestreos correlacionados y un caso de muestreo con población
finita (los ejemplos son una adaptación de los modelos matemáticos propuestos
en Niebel y Freivalds, 2009, p. 442-450):
Ejemplo 2.1. Muestreo simple de unidades de producción
En una línea de producción un inspector de control de calidad revisa

aleatoriamente sobres que contienen medicamento para el ganado ovino, se desea
determinar mediante un estudio de muestreo el número de observaciones
necesarias para estimar con un 96% de confianza el porcentaje de productos

buenos y defectuosos. Antes de determinar el número de observaciones

necesarias para el estudio de muestreo, el inspector de calidad hace un estudio
piloto y se encontró que, al revisar 60 sobres, 9 de ellos no tenían la cantidad
indicada de solución por lo que los considero como defectuosos, esta información
le permitió definir a 𝑝̂ = 9/60 = 0.15, o 15%. Sin embargo, el inspector de calidad
desea una exactitud con una estimación dentro del intervalo de 14 a 16%. Lo
anterior, hace suponer al inspector que si la probabilidad obtenida a partir de la
proporción basada de la muestra es 𝑝̂ = 15%, entonces el límite del error ℓ es de
0.01, o del 1% (figura 2.2).
Fuente: Elaboración propia con base en Niebel y Freivalds, 2009.
Figura 2.2. Rango de tolerancia del porcentaje de holgura en los sobres determinados
como defectuosos.
Dadas las condiciones anteriores, es posible determinar el número de 𝑛

observaciones necesarias.
(𝑍𝛼⁄2 )2 𝑝𝑞
𝑛 =
ℓ2
(2.054)2 (0.15)(0.85)
𝑛= = 5,379 observaciones
(0.01)2
Como se puede ver, la cantidad de muestras que necesita tomar el

inspector de calidad es quizá elevada (5,379 sobres), sin embargo, si por alguna
razón el inspector desea disminuir esta cantidad a sólo 1,000. El límite del error
podría cambiar:
ℓ = 𝑍𝛼⁄2 √𝑝𝑞/𝑛
(0.15)(0.85)
ℓ = 2.054 √ = 0.0232 = 2.3%
1,000
Por tanto, al tomar sólo 1,000 muestras, el límite de error pasaría de ±

1% a ± 2.3%, lo que implica disminuir la exactitud de los resultados deseados al

definir el porcentaje de sobres buenos o defectuosos.
Por otro lado, es importante entender que en un sistema bajo estudio

podrían tomarse observaciones o muestreos correlacionados. Niebel y Freivalds
(2009), contextualizan que “si se estudian varios trabajadores de manera
simultánea, las observaciones no pueden considerarse independientes. A ello,
Richarrdson y Pape (1992) estudiaron dicho problema, el resultado fue un
intervalo de confianza corregido que se calcula después de la recolección de
datos”. Véase el siguiente ejemplo.
Ejemplo 2.2. Muestreos correlacionados
El gerente de un Banco ha notado que en algunos momentos del día no

tiene espacio suficiente para que sus clientes tomen asiento mientras esperan a ser
atendidos por algún cajero y, en algunos otros instantes del tiempo los lugares
disponibles están sobrados. Debido a esto, desea determinar si los 50 lugares
disponibles en la actualidad son suficientes para sus clientes. Datos históricos del
Banco indican que en las horas pico el 94% de los asientos están ocupados. Un
supervisor del mismo Banco realiza un estudio de muestreo piloto con intención
de confirmar la proporción de espacios vacíos a distintas horas del día, lo anterior
lo lleva a realizar 8 observaciones aleatorias de las 10:00 de la mañana hasta las
5:00 de la tarde, observando los resultados de la tabla 2.1.
Tabal 2.1. Muestreo piloto en el Banco
Visitas Lugares 𝑦(𝑗)2

Realizadas Desocupados
(muestra) 𝒋 𝒚(𝒋)
1 2 4
2 6 36
3 7 49
4 6 36
5 6 36
6 2 4
7 3 9
8 4 16
TOTAL 36 190
Entonces la proporción basada de la muestra o la probabilidad de

encontrar un lugar desocupado en cualquier instante del día es 𝑝 =
36⁄(8 ∗ 50) = 0.09 = 9%. Como en cada una de las 8 visitas realizadas a lo
largo del día se observó la disponibilidad de los 50 lugares, entonces se puede
decir que las muestras no pueden considerarse independientes sino

correlacionadas. Por lo tanto, el límite del error deberá calcularse a partir de la

siguiente formula definida por Richarrdson y Pape (1992).
1⁄
∑ 𝑦(𝑗)2 ⁄𝑛(𝑗) − 𝑛𝑝 2 2
ℓ = 𝑍𝛼⁄2 [ ] (4)
𝑛(𝑚 − 1)
Donde
𝒑= probabilidad de ocurrencia,
𝒎= número de muestras correlacionadas,
𝒏= número total de observaciones,
𝒏(𝒋) = número total de espacios a ocupar, maquinas a revisar,
número de trabajadores o cualquier otro factor de
interés en la 𝑗-ésima observación, y
𝒚(𝒋) = número de espacios desocupados, maquinas
descompuestas, trabajadores “inactivos” o cualquier
otro factor de interés en la 𝑗-ésima observación.
Atendiendo lo anterior, si se quisiera saber con un 99% de confianza

cuántos asientos del Banco estarán disponibles en un instante cualquiera del
tiempo en que este mismo opera, tenemos que:
1⁄
190⁄50 − 400(0.09)2 2
ℓ = 2.58 [ ] = 0.0365 = 3.65%
400(8 − 1)
Bajo los supuestos anteriores, el gerente del Banco puede concluir que 9
± 3.65% de los asientos estarán disponibles en cualquier instante en el que un
cliente llegue al Banco (esto es entre 3 y 6 asientos disponibles aproximadamente).
Esto permite suponer que si el Banco sigue funcionando bajo estas condiciones
no tendrá problemas con sus clientes, pues frecuentemente encontrarán lugares
disponibles donde esperar antes de ser atendidos. Es importante hacer notar que,
aunque el sistema tiene espacios disponibles a cualquier instante del día, no se
descarta la posibilidad de que en algún momento algún cliente tenga que esperar
de pie porque todos los asientos están ocupados.
A esto, para evitar errores de representatividad, una sugerencia es

recopilar un mayor número de muestras en el transcurso de varios días.

Ejemplo 2.3. Muestreos con población finita
Dentro de los sistemas industriales o de servicios, frecuentemente

conocemos con claridad el total de la población. En estos casos la pregunta a
responder es ¿Cuántas muestras del total son necesarias estudiar para estimar a la
población?, la respuesta a esta pregunta la determina la siguiente ecuación:
𝑁𝑇 𝑍𝛼⁄2 2 𝑝𝑞
𝑛= (5)
ℓ 2 (𝑁𝑇 − 1) + 𝑍𝛼⁄2 2 𝑝𝑞
Donde
𝑁𝑇 = número total de unidades que constituyen a la

población.
En una planta donde se elaboran etiquetas para frascos de vidrio, el

responsable del almacén de producto terminado observa que dentro de una caja
hay una etiqueta mal impresa que sobresale. El responsable del almacén ésta
angustiado por que no sabe con claridad cuantas de las 10,000 etiquetas que
contiene la caja tienen este defecto y como no quiere revisar el total de estas,
decide llamar a un inspector de control de calidad para que le ayude a determinar
cuál es la cantidad de etiquetas que deberá muestrear para conocer la cantidad
estimada de etiquetas defectuosas y así agregarlas como repuesto a la caja para
que el cliente no tenga ninguna queja del producto. El inspector de calidad maneja
los siguientes datos, nivel de confianza del 95%; límite aceptable de error 3%; y
una probabilidad de ocurrencia del 5%.
(10,000) ∗ (1.962 ) ∗ (0.05) ∗ (0.95)

𝑛= = 199
(0.032 )(10,000 − 1)+(1.962 ) ∗ (0.05) ∗ (0.95)
El número de etiquetas necesarias para repuesto son 199.
1) Método Tradicional
En la referencia Caso (2006) se hace notar que, no es posible utilizar

exclusivamente los métodos estadísticos para calcular el número de observaciones
a realizar, debido a que se requiere de un tamaño de muestra basado en la

dispersión de las lecturas individuales, bajo este criterio, el número de ciclos que
deberá observase para obtener un tiempo medio representativo de una operación
también se determina mediante los procedimientos sujeridos en García (2005):
1. Tabla Westinghouse
2. Criterio de la General Electric Co.
Westinghouse
La tabla Westinghouse obtenida empíricamente (tabla 2.2), indica el número de

observaciones necesarias respecto a la duración del ciclo y al número de piezas
que se fabrican al año. La tabla es exclusiva para operaciones repetitivas realizadas
por operadores especializados. En caso no contar con un operario especializado,
el número de observaciones obtenidas de las tablas deberá ser multiplicado por
1.5.
Tabla 2.2. Número de observaciones, Método Westinghouse.

Fuente: Elaboración propia con base en García, 2005.
Tiempo Número mínimo de ciclos a estudiar
ciclo por pieza Más de 10,000 De 1,000 a 10,000 Menos de 1,000
(horas): por año: por año: por año:
1.000 5 3 2
0.800 6 3 2
0.500 8 4 3
0.300 10 5 4
0.200 12 6 5
0.120 15 8 6
0.080 20 10 8
0.050 25 12 10
0.035 30 15 12
0.020 40 20 15
0.012 50 25 20
0.008 60 30 25
0.005 80 40 30
0.003 100 50 40
0.002 120 60 50
Menos de 0.002 140 60 60

Para hacer uso de la tabla 2.2, es necesario conocer el tiempo promedio

de ciclo por cada pieza producida (columna 1) y el número de piezas producidas
o ciclos por operación anuales (columnas 1, 2, 3). Por ejemplo, si el tiempo ciclo
es de 0.05 horas (3 minutos) y la producción anual es menor de 1,000 piezas,
entonces el número mínimo de piezas a observar será de 10.
General Electric Co.
Otra guía para un analista de tiempos es propuesta por la compañía General

Electric. La tabla 2.3 describe los criterios para determinar el número de ciclos a
observar.
Tabla 2.3. Número de observaciones, Criterios General Electric Co.

Fuente: Elaboración propia con base en García, 2005.
Tiempo ciclo Observaciones
(minutos): por realizar:
0.10 200
0.25 100
0.50 60
0.75 40
1.00 30
2.00 20
4.00 – 5.00 15
5.00 – 10.00 10
10.00 – 20.00 8
20.00 – 40.00 5
Más de 40.00 3
Para hacer uso de la Tabla 2.3, es necesario conocer el tiempo ciclo en

minutos de la operación a estudiar, por ejemplo, si el tiempo ciclo es de 2 minutos,
entonces el número de observaciones a colectar será de 20.
Es importante notar que, dado que existen muchos métodos de

recolección de datos, se debe tener cuidado al elegir el adecuado. Habrá
aplicaciones donde la poca precisión en la toma de datos no alterará de manera
significativa los resultados obtenidos, sin embargo, en otras, esto podría cambiar
completamente los resultados del modelo. Estos y otros factores como la
frecuencia con la que se toman los datos del sistema son temas de interés.

2.2.3. Frecuencia de Visitas al Centro de Trabajo para Realizar Observaciones y Tipo

de Muestreo
El número de visitas que se debe hacer al centro de trabajo dependerá

directamente del número total de observaciones requeridas, además del tiempo y
los recursos que el analista tenga disponibles para invertir en dicha actividad. Por
ejemplo, se determinó que en una planta productora de lácteos son necesarias 500
observaciones de camiones pipa para establecer el tiempo que se invierte en la
descarga de leche y, si cada 80 minutos llega un camión cargado a la planta, se
esperaría entonces que en un día de 24 horas (1,440 min) se tomarán
observaciones de aproximadamente 1,440/80 = 18, de los 500 camiones, lo que
demoraría alrededor de 500/18 = 27.7778 o bien 28 días tomar el total de las
observaciones, entonces un solo analista tendría que visitar el centro de trabajo
18x28 = 540 veces para colectar estos datos. Ahora bien, si lo que se quiere es
observar en 20 días un total de 2,200 cartones de leche que una maquina
dosificadora procesa, se tendrían que hacer 2,200/20 = 110 observaciones darías,
por lo que quizá el analista requiera de 11 visitas al centro de trabajo en las cuales
tome 10 observaciones en cada visita. Obviamente, la disminución del tiempo
necesario para realizar el total de las observaciones y el incremento o disminución
de la cantidad de estas seguirá en función de la naturaleza de la actividad, del
número de analistas, del tiempo disponible para colectar la información y del nivel
de confianza necesario, pues resulta claro que si el limite aceptable del error l
incrementa, el número de observaciones disminuye.
Recomendaciones
No toda la información que se pueda obtener será de ayuda para el análisis de los
datos; está información deberá ser oportuna, confiable y relevante. Niebel y
Freivalds (2009), puntualizan que al realizar la recolección de datos se deben
tomar en cuenta que:
 Las observaciones tomadas en un muestreo deberán ser aleatorias.

 Para hacer una visita de muestreo adecuada, el analista deberá ubicar en piso
una posición que le permita visualizar claramente lo que desea observar,
hacer la observación y registrar exactamente lo que sucede en el momento
preciso de la observación.
 Diseñar un formato adecuado para la recolección de los datos en piso o bien
algún dispositivo digital que facilite la recolección; es importante la descarga
de toda la información recolectada en la computadora para un análisis
posterior.
 En cada visita a piso para tomar una muestra, el analista deberá tomar los

datos de interés, pero no deberá ignorar el registro de los acontecimientos

por los cuales el operario está desocupado o no cumple con sus actividades
normales (falta de materia prima, descompostura de la máquina, accidentes,
errores, entre otros).
 Si la población a muestrear es un operario, el analista deberá informar al
mismo con anterioridad sobre dicha actividad. Esto, en virtud de evitar lo
más que se pueda los sesgos por un ritmo de trabajo distinto al normal, ya
que un operario puede intimidarse y cometer errores o bien concentrarse en
la operación y mejorar su productividad.
 Para evitar sesgos al realizar un muestreo de trabajo siempre es
recomendable utilizar una cámara de video, pues esta permite registrar la
exactitud de la actividad en progreso de un operario.
 Tomar la muestra del operario de tipo medio o el que está algo más arriba
del promedio, permitirá obtener un estudio más satisfactorio que el
efectuado con un operario poco experto o con uno altamente calificado.
2.3. DISTRIBUCIÓN DE PROBABILIDAD
2.3.1. Experimentos y Epacio Muestral
Los estadísticos utilizan la palabra experimento para describir cualquier proceso

que genere un conjunto de datos. Un ejemplo simple de experimento estadístico
es el lanzamiento de una moneda al aire. En tal experimento sólo hay dos
resultados posibles: cara o cruz. Otro experimento sería el lanzamiento de un misil
y la observación de su velocidad en tiempos específicos, las opiniones de los
votantes respecto de un nuevo impuesto sobre ventas también se pueden
considerar como observaciones de un experimento. Particularmente nos
interesan las observaciones que se obtienen por la repetición del experimento
varias veces. En la mayoría de los casos dependerán del azar. En conclusión, un
experimento es un proceso cuyo resultado no se conoce con certidumbre. Los
criterios y modelos aquí descritos, y en especial el apartado 2.3.2 contienen
información propuesta por el libro de texto Probabilidad y Estadística para
Ingeniería y Ciencias de Walpole et al. (2012), p. 81-91.
En la teoría de probabilidad, el conjunto de todos los posibles resultados

que se pueden obtener de un experimento de carácter aleatorio se llama espacio
muestral y se denota con el símbolo S. A cada resultado o componente de un
espacio muestral se le llama punto muestral o, simplemente, muestra.
Considerando el siguiente ejemplo, si el experimento consiste en lanzar una
moneda lo que interesa es saber si el resultado es cara o cruz.

S = {A, B} (6)
Donde el símbolo { } significa que el "conjunto compuesto por" A y B

corresponde a "caras" y "cruces", respectivamente.
Ahora considere el experimento de lanzar un dado. Si es del interés

conocer el número que muestra la cara superior del dado después de haberlo
lanzado, el espacio muestral sería:
S = {1, 2, 3, 4, 5, 6}
A ello, si un espacio muestral contiene un número finito de posibilidades,

o una serie interminable con tantos elementos como números enteros existentes,
se llama espacio muestral discreto. Por otro lado, si un espacio muestral
contiene un número infinito de posibilidades igual al número de puntos en un
segmento de línea, se le llama espacio muestral continuo, con lo que un espacio
muestral puede clasificarse como discreto o continuo.
2.3.2. Variables Aleatorias
Una variable aleatoria es una función que asigna un número real

(cualquier número mayor que -∞ y menor que ∞) para cada punto en el espacio
muestral S.
Para dar un ejemplo, considérese el siguiente experimento de lanzar un

par de dados, donde no interesa conocer el número que muestre la cara superior
de cada dado:
S = {(1, 1), (1, 2),…, (6, 6)}
(i, j)
Aquí (i, j) toman el valor de la cara superior del dado uno y dos,
respectivamente. Si X es una variable aleatoria correspondiente a la suma de los
dos dados, X toma el valor de 7 para el resultado (4, 3). En general se denota una
variable aleatoria por la letra mayúscula X, Y, Z y los valores que las variables
aleatorias toman se denotan con las literales x, y, z. Dadas las condiciones
anteriores, si existe un espacio muestral discreto y uno continuo, también existen
variables aleatorias discretas y continuas, los temas siguientes dan argumentos de
ambos casos.
Variable aleatoria discreta
Una variable 𝑋 se dice ser discreta si puede tomar más de un número contable de

valores, es decir, 𝑥1 , 𝑥2 , … , 𝑥𝑛 ("contable" significa que el conjunto de valores

posibles se puede poner en una correspondencia de uno a uno con el conjunto de
enteros positivos). Así que una variable aleatoria que toma un número finito de
valores 𝑥1 , 𝑥2 , … , 𝑥𝑛 (cada uno con cierta probabilidad) es discreta.
Las variables aleatorias discretas tienen tanto una función de probabilidad

(𝑓 (𝑥)) como una función de distribución acumulada (𝐹(𝑥)) que las define:
Función de Probabilidad
La probabilidad de que una variable discreta 𝑋 tome el valor 𝑥 esta dado por:
𝑓 (𝑥) = 𝑃( 𝑋 = 𝑥 )
El conjunto de pares ordenados (𝑥, 𝑓 (𝑥)) es una función de

probabilidad o una distribución de probabilidad de la variable aleatoria discreta 𝑋
si, para cada resultado posible 𝑥,
1.- 𝑓 (𝑥) ≥ 0,
2.- ∑ 𝑓(𝑥) = 1,
𝑥
3.- 𝑃( 𝑋 = 𝑥 ) = 𝑓 (𝑥)
A menudo es útil ver una distribución de probabilidad en forma de

gráfica. Se pueden graficar los puntos o resultados (𝑥, 𝑓 (𝑥)) con rectángulos de
manera que las bases de igual ancho se centren en cada valor 𝑥, y sus altura sean
iguales a las probabilidades correspondientes dadas por 𝑓(𝑥). Las bases se
construyen de forma tal que no dejen espacios entre los rectángulos. La figura 2.3
se denomina histograma de probabilidad.
f (x) 0.6
0.5
0.4
0.3
0.2
0.1
0
0 1 2
Fuente: Elaboración propia con base en Walpole et al., 2012.

Figura 2.3. Histograma de probabilidad.

Función de Distribución Acumulada
La función de distribución acumulada 𝐹(𝑥) de una variable aleatoria discreta 𝑋

con distribución de probabilidad 𝑓(𝑥) es:
𝐹(𝑥) = 𝑃(𝑥 ≤ 𝑥) = ∑𝑡≤𝑥 𝑓(𝑡), para −∞ < 𝑥 < ∞
La gráfica de la distribución acumulada aparece como una función

escalonada en la figura 2.4, y se obtiene al graficar los puntos (𝑥, 𝐹(𝑥)). Ejemplos
al tema pueden consultarse en Walpole et al. (2012).
1.2
f (x)
1
0.8
0.6
0.4
0.2
0
0 1 2 3
Figura 2.4. Distribución acumulada discreta.
Variable aleatoria continúa
Una variable aleatoria se dice ser continúa cuando ésta toma un número infinito
de valores diferentes no negativos. Considérese una variable aleatoria cuyos
valores son los pesos de toda la gente mayor de 21 años. Entre dos valores
cualquiera que sea, digamos 58.647 y 60.193 kilogramos, hay un número infinito
de pesos, uno de las cuales es 60 kilogramos. Una variable aleatoria continúa tiene
una probabilidad cero de tomar exactamente cualquiera de sus valores, a ello, las
variables continuas tienen función de densidad (𝑓 (𝑥)) y función de distribución
acumulada (𝐹(𝑥)).

Función de Densidad
El cálculo de probabilidades para distintos intervalos de variables aleatorias

continuas es 𝑃(𝑎 < 𝑋 < 𝑏), 𝑃(𝑊 ≥ 𝑐), etc. Obsérvese que cuando 𝑋 es
continúa,
𝑃(𝑎 < 𝑋 ≤ 𝑏) = 𝑃(𝑎 < 𝑋 < 𝑏) + 𝑃(𝑋 = 𝑏) = 𝑃(𝑎 < 𝑋 > 𝑏)
Aunque la distribución de probabilidad de una variable aleatoria continua

no se puede representar de forma tabular, sí se establece como una fórmula, la
cual necesariamente será una función de los valores numéricos de la variable
aleatoria continúa 𝑋 y como tal se representará mediante la notación funcional
𝑓(𝑥). Al tratar con variables continúas 𝑓(𝑥), por lo general, se llama función de
densidad de probabilidad, o simplemente función de densidad de 𝑋. Como 𝑋 se
define sobre un espacio muestral continuo, es posible que 𝑓(𝑥) tenga un número
infinito de discontinuidades. Sin embargo, la mayoría de las funciones de densidad
que tienen aplicaciones prácticas en el análisis de datos estadísticos son continuas
y sus gráficas pueden tomar diferentes formas, algunas de la cuales se presentan
en la figura 2.5. Comúnmente se utilizan áreas para representar probabilidades y
éstas son valores numéricos positivos, la función de densidad debe estar
completamente por arriba del eje 𝑥.
a) b) c) d)
Figura 2.5. Funciones de densidad típicas.
Una función de densidad de probabilidad se construye de manera que el

área bajo la curva limitada por el eje 𝑥 sea igual a 1, cuando se calcula en el rango
de 𝑋 para el que se define 𝑓(𝑥). Si este rango de 𝑋 es un intervalo infinito, siempre
es posible extender el intervalo para incluir a todo el conjunto de números reales
al definir 𝑓(𝑥) como cero en todos los puntos de las partes extendidas del
intervalo. En la figura 2.6, la probabilidad de que 𝑋 tome un valor entre 𝑎 y 𝑏 es
igual al área sombreada bajo la función de densidad entre las ordenadas en 𝑥 = 𝑎
y 𝑥 = 𝑏, el cálculo integral está dada por:

𝑏
𝑃(𝑎 < 𝑋 < 𝑏) = ∫ 𝑓(𝑥)𝑑𝑥
𝑎
f (x)
x
a b
Figura 2.6. Función de densidad de probabilidad para 𝑃(𝑎 < 𝑋 < 𝑏).
La función 𝑓(𝑥) es una función de densidad de probabilidad para la

variable aleatoria continua 𝑋, definida en el conjunto de números reales 𝑅, si:
1.- 𝑓(𝑥) ≥ 0, para toda 𝑥 𝜖 𝑅.

∞
2.- ∫ 𝑓(𝑥) 𝑑𝑥 = 1
−∞
∞
3.-
𝑃(𝑎 < 𝑋 < 𝑏) = ∫ 𝑓(𝑥) 𝑑𝑥
−∞
Función de Distribución Acumulada
La función de distribución acumulada 𝐹(𝑥) de una variable aleatoria continua 𝑋

con función de densidad 𝑓(𝑥) es:

𝑥
𝐹(𝑥) = 𝑃(𝑋 ≤ 𝑥) = ∫−∞ 𝑓(𝑡) 𝑑𝑡, para −∞ < 𝑥 < ∞
Como consecuencia inmediata de la formula anterior se escriben los dos

resultados,
𝑑𝐹(𝑥)
𝑃(𝑎 < 𝑋 < 𝑏) = 𝐹(𝑏) − 𝐹(𝑎), y 𝑓(𝑥) =
𝑑𝑥
La distribución acumulada 𝐹(𝑥) se expresa de forma gráfica. Véase la figura 2.7.
f (x)
1.0
0.5
x
-1 0 1 2

Figura 2.7. Función de distribución acumulada continúa para −1 < 𝑥 < 2.
2.3.3. Tipos de Distribuciones
El tipo de distribución se realiza dependiendo del tipo de variable a estudiar:

a) Si se trata de una variable discreta (datos o valores enteros), se espera una
distribución discreta, algunos ejemplos son: Bernoulli, Binomial,
Geométrica, entre otras.
b) Por otro lado, si la variable es continua (datos dentro de un intervalo), la
distribución generada será una distribución continua, por ejemplo: la
Normal, Erlang, Exponencial, Weibull, etc.

Para el desarrollo de un proyecto de simulación utilizando datos

aleatorios tales como tiempos de interarribos o tamaños de la demanda, es
necesario especificar la distribución de probabilidad que represente a dichos
tiempos. Casi todos los sistemas reales contienen una o más fuentes de
aleatoriedad tal como se ilustra en la tabla 2.4, por tal motivo es necesario
representar cada fuente de variabilidad del sistema con una distribución de
probabilidad en el modelo de simulación.
Tabla 2.4. Ejemplos de fuentes de aleatoriedad en los sistemas reales.
Tipo de sistema Fuente de aleatoriedad

Tiempo de preparación
Tiempos de procesamiento
Fabricación
Tiempos de falla
Tiempos de reparación de máquinas
Hospital Tiempos de arribo y tipo de servicio solicitado
Tiempo de atención
Tiempos entre llegadas de clientes
Banco Tipo de servicio
Tiempo de servicio
Logística Tiempo de embarque
Tiempos entre arribos a una estación
El propósito de esta sección es mostrar la variedad de distribuciones que

se han definido para ser utilizadas en modelos de simulación, a ello, las tablas 2.5
y 2.6 contienen una lista de las distribuciones de probabilidad propuestas por el
libro de texto Simulation Modeling & Analysis (Simulación Modelado y Análisis)
de Law Averill (2007) y de la Guía del software ExpertFit (Law, A.M. y Associates,
Inc., 1995-2011). Así mismo, se dan ejemplos definidos dentro de la ayuda del
software FlexSim (apartado Estadísticas).
Distribución Discreta
La tabla 2.5, muestra una clasificación de las distribuciones discretas usadas en

FlexSim. La 1er. columna describe al tipo de distribución, la 2da. incluye su
notación, mientras que la 3ra. puntualiza los parámetros necesarios para su
inclusión en el Software FlexSim. El termino stream (o semilla), es un detonador
de números aleatorios que activa un valor inicial en la generación de datos o
valores aleatorios que graficarán la función de densidad de cada distribución.

Tabla 2.5. Distribuciones discretas, notación y parámetros.
Distribución Notación Parámetros en FlexSim

Bernoulli bernoulli (prob, succeed-value, fail-
bernoulli(𝐩, 𝐚, 𝐛)
value, stream)
Binomial binomial(t, p) binomial (trials, probability, stream)
Geometric geometric(p) geometric (prob, stream)
Hypergeometric hypergeometric(t, m, hypergeometric (trials, successes,
n) size, stream)
Logarithmic logarithmic (α) logarithmic (num theta, stream)
Negative negbinomial(𝐬, 𝐩) negbinomial (successes, prob,
Binomial stream)
Poisson poisson(𝛌) poisson (mean, stream)
Uniform duniform(𝐚, 𝐛) duniform (min, max, stream)
Discrete --- dempirical(tablename, stream)
Empirical
Un ejemplo de una distribución discreta con información respectiva que

la describe, parámetros y gráfica representativa, se da en la tabla 2.6:
Tabla 2.6. Distribuciones Bernoulli.
bernoulli(prob, succeed-value, fail-value,

Bernoulli Bernoulli(𝑝, 𝑎, 𝑏)
getstream(current))
Se utiliza para modelar una ocurrencia aleatoria que tiene dos posibles resultados como
una prueba de pasa/no pasa o éxito/fracaso. Es posible generar más de dos valores de
anidación de comandos de Bernoulli, sin embargo, es mejor utilizar distribuciones
empíricas en estos casos.
1−p si x = 0
Función de probabilidad p(x) = { p si x = 1
0 en cualquier otro caso
Función de acumulada p(x)

0 si x < 0
= {1 − p si 0 ≤ x < 1
1 si x ≥ 1
Parámetros p ∈ (0, 1)
Rango {0, 1}

Media P
Varianza p(1 − p)
1
0 si p < 2
1
Moda 0 y 1 si p = 2
1
1 si p > 2
{
Comentarios:
1. Una variable aleatoria 𝑋 con distribución de probabilidad Bernoulli (𝑝) se
puede considerar como el resultado de un experimento de "éxito" o "falla".
Si la probabilidad de existo es 𝑝, dejemos que sea 𝑋 = 0 si el experimento
falla y 𝑋 = 1 si el experimento es exitoso, entonces 𝑋~ Bernoulli (𝑝).
2. Si 𝑡 es un entero positivo y 𝑋1 , 𝑋2 , … , 𝑋𝑡 son variables aleatorias

independientes con distribución Bernoulli (𝑝), luego 𝑋1 + 𝑋2 + ⋯ + 𝑋𝑡
tienen una distribución binomial con parámetros 𝑡 y 𝑝. Cuando se realizan
varios experimentos de Bernoulli y estos son mutuamente independientes y
la probabilidad de éxito no cambia, se le llama a la sucesión de experimentos
"ensayos de Bernoulli".
3. Supongamos que empezamos hacer réplicas independientes de un ensayo
Bernoulli con probabilidad 𝑝 de éxitos en cada ensayo. Entonces el número
de fallos antes de observar el primer éxito tiene una distribución geométrica
con parámetro (𝑝). Para un entero positivo𝑠, el número de fracasos antes de
observar algún éxito tiene una distribución binomial negativa con parámetros
𝑠 y 𝑝.
4. La distribución Bernoulli (𝑝) es un caso especial de la distribución binomial

(con 𝑡 = 1 y el mismo valores para 𝑝).
Ejemplo de distribución Bernoulli (90, 1, 2, getstream(current)) en FlexSim;

El comando de Bernoulli en este ejemplo tiene una probabilidad 𝑝 = 90% de devolver
el valor de 𝑎 = 1, en caso contrario devolverá 𝑏 = 2 y getstream(current) devuelve un
flujo aleatorio único asociado con el objeto.

Bernoulli
p(x)
1-p
x
0 1
Bernoulli en FlexSim
Distribución Continua
La tabla 2.7 da información relevante para la aplicación de 29 distribuciones

continuas en modelos de simulación:

Tabla 2.7. Distribuciones continuas, notación y parámetros.
Distribución Notación Parámetros en FlexSim

Beta beta(𝐚, 𝐛, 𝛂𝟏 , 𝛂𝟐 ) beta (min, max, shape1, shape2,
stream)
Cauchy cauchy(γ, β) cauchy (location, scale, stream)
Continuous --- cempirical(tablename, stream)
Empirical
Empirical --- empirical(tablename, stream)
Erlang erlang(γ, β, m) erlang (location, scale, shape,
stream)
Exponential exponential(γ, β) exponential (location, scale,
stream)
Extreme Value EVTA(γ, β) extremevalue1a (location, scale,
Type A stream)
Extreme Value EVTB(γ, β) extremevalue1b (location, scale,
Tipo B stream)
Gamma gamma(γ, β, α) gamma (location, scale, shape,
stream)
Inverse inversegaussian(γ, β, α) inversegaussian (location, scale,
Gaussian shape, stream)
Inverse Weibull inverseweibull(γ, β, α) inverseweibull (location, scale,
shape, stream)
Inverted Weibull invertedweibull(γ, β, α) invertedweibull (location, scale,
shape, stream)
Johnson SB johnsonbounded(𝒂, 𝒃, 𝜶𝟏 , 𝜶𝟐 ) johnsonbounded (min, max,
shape1, shape2, stream)
Johnson SU johnsonunbounded(𝛄, 𝛃, 𝛂𝟏 , 𝛂𝟏 ) johnsonunbounded (location, scale,
shape1, shape2, stream)
Laplace laplace (γ, β) laplace (location, scale, stream)
Logistic logistic(γ, β) logistic (location, scale, stream)
Log-Laplace loglaplac (𝛄, 𝛃, 𝛂) loglaplace (location, scale, shape,
stream)
Log-logistic loglogistic (𝛄, 𝛃, 𝛂) loglogistic (location, scale, shape,
stream)
Log-normal lognormal(𝛄, 𝛍, 𝛔) lognormal (location, normalmean,
normalstdev, stream)
Log-normal2 lognormal2( 𝛄, 𝛃, 𝛂) lognormal2 (location, scale, shape,
stream)
Normal normal(𝛍, 𝛔) normal (mean, stddev, stream)
Pareto pareto(𝛄, 𝛃) pareto (min, scale, stream)
Pearson Type 5 pearsont5(𝛄, 𝛃, 𝛂) pearsont5 (location, scale, shape,
stream)
Pearson Type 6 pearsont6(𝛄, 𝛃, 𝛂𝟏 , 𝛂𝟐 ) pearsont6 (location, scale, shape1,
shape2, stream)
Random Walk randomwalk(𝛄, 𝛃, 𝛂) randomwalk (location, scale, shape,
stream)
Triangular triangular(𝐚, 𝐛, 𝐦) triangular (min, max, mode,
stream)
Student's t riangular(𝐚, 𝐛) qstudentt (confidence,
degreesoffreedom)
Uniform uniform(𝐚, 𝐛) uniform (min, max, stream)
Weibull weibull(𝛄, 𝛃, 𝛂) weibull (location, scale, shape,
stream)

Un ejemplo de una distribución discreta con información respectiva que la

describe, parámetros y gráfica representativa, se da en la tabla 2.8:
Tabla 2.8. Distribuciones Beta.
Beta beta(a, b, α1, α2) bernoulli(min, max, shape1, shape2, getstream(current))
Es utilizada como la aproximación de un modelo en la ausencia de datos, distribución de una

proporción aleatoria, tal como la proporción de artículos en un embarque y el tiempo para
completar una tarea.
𝑥 − 𝑎 𝑎1−1 𝑏 − 𝑥 𝑎2−1
[ ] [ ]
𝑏−𝑎 𝑏−𝑎 𝑠𝑖 𝑎 < 𝑥 < 𝑏
f(x) = {
(𝑏 − 𝑎)𝐵(𝑎1 , 𝑎2 )
0 en cualquier otro caso
Donde 𝐵(𝛼1 , 𝛼2 ) es la función de beta, definida por

Función de densidad
1
B(z1 , z2 ) = ∫ t z1−1 (1 − t)z2−1 dt
0
Para cualquier número real 𝑧1 > 0 y 𝑧2 > 0. Algunas de las propiedades

de la función beta son:
𝛤(𝑧1 )𝛤(𝑧1 )
𝐵(𝑧1 , 𝑧2 ) = 𝐵(𝑧2 , 𝑧1 ), 𝐵 (𝑧1 , 𝑧2 ) = 𝛤(𝑧1 +𝑧2 )
Parámetros Parámetro de forma α1 > 0

Parámetro de forma α2 > 0
Parámetro del punto menor A ∈ (−∞, ∞)
Parámetro del punto superior 𝑏 (𝑏 > 𝑎)
Rango (a, b)
Media 𝛼1
𝑎 + (𝑏 − 𝑎 )
𝛼1 + 𝛼2
Varianza 𝑎1 𝑎2
(𝑏 − 𝑎 )2 2
(𝑎1 𝑎2 ) (𝑎1 + 𝑎2 + 1 )
α1 − 1
a + (b − a) si α1 > 1, α2 > 1
α1 + α2 − 2
a y b si α1 < 1, α2 < 1
Moda a si (α1 < 1, α2 ≥ 1) or (α1 = 1, α2 > 1)
b si (α1 ≥ 1, α2 < 1) or (α1 > 1, α2 = 1)
unicamente no existe si α1 = α2 = 1
{

Comentarios:
1. La distribución U(0, 1) y beta(1, 1) son la misma.

2. Si 𝑋1 y 𝑋2 son variables aleatorias independientes con 𝑋𝑖 ~ gamma(𝛼, 𝛽), entonces
𝑋1 /(𝑋1 + 𝑋2 ) ~ beta(𝛼1 , 𝛼2 ).
3. Una variable aleatoria beta 𝑋 en [0, 1] puede ser ajustada y relocalizada para obtener
una variable aleatoria beta en [𝟎, 𝟏] de la misma forma por la transformación de 𝒂 +
(𝒃 − 𝒂)𝑿.
4. 𝑿 ~ beta(𝜶𝟏 , 𝜶𝟐 ) si y solo si 𝟏 − 𝑿 ~ beta(𝜶𝟐 , 𝜶𝟏 ).
5. 𝑿 ~ beta(𝜶𝟏 , 𝜶𝟐 ) si y solo si 𝒀 = 𝑿/(𝟏 − 𝑿) tiene una distribución Pearson tipo VI
con parámetros de forma 𝜶𝟏 , 𝜶𝟐 y parámetro de escala 1, se denota por PT6(𝜶𝟏 , 𝜶𝟐 , 𝟏).
6. La densidad de beta(1, 2) es un triángulo a la izquierda y la densidad de beta(2, 1) es un
triángulo a la derecha.
∞ si 𝛼1 < 1
7. 𝑙𝑖𝑚𝑥→0 𝑓 (𝑥 ) = {𝛼2 si 𝛼1 = 1
0 si 𝛼1 > 1
∞ si 𝛼2 < 1
𝑙𝑖𝑚𝑥→1 𝑓(𝑥 ) = { 𝛼2 si 𝛼2 = 1
0 si 𝛼2 > 1
1
8. La densidad es simétrica 𝑥 = 2 si y solo si 𝛼1 = 𝛼2 . también la media y la moda son
iguales si y solo si 𝛼1 = 𝛼2 .
Ejemplo de distribución beta(0, 1, 1, 3, getstream(current)) en FlexSim;
Una distribución beta teniendo un valor mínimo 𝑎 = 0, un valor máximo de 𝑏 = 1, parámetros

de forma de 1 y 3 respectivamente para 𝛼1 y 𝛼2 y valor de semilla getstream(current) para un
flujo aleatorio único de datos.

Beta
Beta en FlexSim

Una característica que distingue a FlexSim de otras herramientas de

simulación es la capacidad de generar rápida y fácilmente variabilidad y
aleatoriedad en un modelo de simulación. FlexSim brinda la capacidad de simular
diferentes tipos de fluctuaciones según las propias características de cada sistema
empresarial. Afortunadamente, no es necesario conocer muchas matemáticas o
programación complicadas para crear estas expresiones estadísticas, dado que
FlexSim tiene una herramienta llamada Selector de Distribución que permite
seleccionar una distribución estadística adecuada para calcular cualquier tipo de
aleatoriedad. Dependiendo del tipo de distribución elegida se creará una expresión
matemática basada en las propiedades de la misma y la aplicará automáticamente
a la configuración de demanda diaria o de tiempos de proceso según el recurso
donde sea definida. Un ejemplo del Selector de Distribución se da en la figura 2.8:
Selección de
distribución estadística.
Definición de
parámetros.
El gráfico muestra
visualmente la
probabilidad de que
esta distribución
matemática genere
ciertos valores (en el
ejemplo, entre 5 y 15).
Figura 2.8. Ejemplo de una distribución
uniforme en FlexSim.
Para emplear diferentes criterios o rangos de números números aleatorios, es

posible cambiar la configuración de cada distribución estadística. El Selector de
Distribución le permite seleccionar entre más de treinta posibles distribuciones
estadísticas para generar números aleatorios. Consulte distribuciones estadísticas
de uso común para obtener una descripción general de otros ejemplos de
distribuciones de uso frecuente (libros recomendados: Walpole et al., 2012;
Montgomery y Runger, 2009; Law et. al., 2007; Kelton et al., 2008; Banks et at.,
2009).
Por otro lado, es de importancia saber que distribución emplear y bajo

que criterios, para ello la herramienta ExpertFit de FlexSim permite determinar la
mejor distribución ajustada a un conjuto de datos históricos o datos recopilados
de un estudio de tiempo. El método y ejemplos de pruebas de bondad de ajuste
se analizarán con más detalle en el siguiente capítulo.

Preguntas
1. ¿Qué implica el tema estadística inferencial?

2. ¿Por qué es importante hacer un muestreo adecuado?
3. ¿A qué se refiere el término estocástico?
4. ¿Cómo son diferenciados los momentos del tiempo discreto y continuo
(de un ejemplo de cada uno)?
5. ¿Qué es un número aleatorio y cuál es la diferencia con una variable
aleatoria?
6. ¿Cuál es la diferencia entre una distribución uniforme continua
(uniform(𝐚, 𝐛)) y una discreta (duniform(𝐚, 𝐛))?
7. ¿En qué casos se usa principalmente una distribución Exponencial,
Normal, Trialgular, Binomila y Uniforme Discreta?
Actividades
1. Investigue porqué la simulación no es una herramienta de optimización.

2. Explique el método matemático del algoritmo lineal para generar
números aleatorios.
3. Analice como Excel genera números aleatorios entre 0 y 1 y en diferentes
rangos.
4. Para obtener más información sobre distribuciones de probabilidad
considere hacer un análisis de otras distribuciones estadísticas en un libro
sobre el tema.
5. Averigüe y analice los tres métodos matemáticos para identificar a que
distribución de probabilidad corresponde un conjunto de datos (pruebas
de bondad de ajuste).
6. Defina cuáles son los métodos matemáticos usados para la generación de
variables aleatorias.
7. De un ejemplo del método de transformada inversa para generar una
variable aleatoria.

3
CAPÍTULO 3. Identificación de
Distribuciones con
ExpertFit
3.1 DATOS DE ENTRADA EN UN MODELO DE SIMULACIÓN

3.2 RECOLECTAR DATOS DEL SISTEMA REAL DE INTERÉS
3.3 DISTRIBUCIONES ASOCIADAS A UN CONJUNTO DE
DATOS
3.4 USO DE EXPERTFIT
3.4.1. Tipos de Análisis en ExpertFit
3.4.2. Data Analysis
3.4.3. Análisis de un Conjunto de Datos Paso a Paso
3.5 RESUMEN DEL CAPÍTULO
3.6 ACTIVIDADES COMPLEMENTARIAS
El Capítulo describe de manera general lo importante que es la recolección de

datos del sistema real de interés y muestra cómo mediante el uso del software
ExpertFit es posible identificar la distribución que mejor se ajuste a un
conjunto de datos disponibles. Después de concluido el capítulo, Usted deberá
tener una idea clara de cómo usar ExpertFit para:
1. Determinar los estadísticos de un conjunto de datos.

2. Crear histogramas y gráficos variados para el análisis de los datos.
3. Aplicar pruebas de bondad de ajuste para determinar la mejor distribución
de probabilidad.
4. Obtener los parámetros de la mejor distribución asociada con los datos
de entrada para su aplicación en el Software FlexSim.
NOTAS:
Los apartados 3.2, 3.3 y 3.4 son un resumen de los términos dados en el manual de
ayuda de ExpertFit proporcionado por Law A. M. y Averill M. Law & Associates, Inc.
(1995-2011), complementados con un ejemplo claro que guía al lector hacia el mejor
uso del software. Por otro lado, las figuras mostradas son impresiones del software
ExpertFit versión 8.01, propiedad de la empresa Averill M. Law & Associates. Inc.
(2011-2019).

3.1. DATOS DE ENTRADA EN UN MODELO DE SIMULACIÓN
Tal como se describió en el capítulo 1 y 2, el movimiento subyacente a través del

tiempo se logra en la simulación al generar tiempos entre llegadas, de operación
y/o servicio a partir de las distribuciones de probabilidad especificadas. El
procedimiento de generar estos tiempos a partir de distribuciones de probabilidad
se conoce como muestreo de distribución de probabilidad, generación de
variables aleatorias o bien, muestreo de Monte Carlo. Winston (2005) afirma
que, el principio de muestreo de distribuciones discretas se basa en la
interpretación de la probabilidad en relación con la frecuencia. Es decir, a la larga,
nos gustaría que los resultados ocurrieran con las frecuencias especificadas por
las distribuciones de probabilidad. Sin embargo, obtener las distribuciones
apropiadas las cuales se ajusten con la mayor precisión posible al comportamiento
del sistema real, es una tarea compleja pues requiere de la inversión de recursos y
tiempo.
Existen diferentes alternativas para determinar la distribución de

probabilidad que mejor se ajuste a un conjunto de datos, una manera de hacerlo
implica lo siguiente (Banks et. al., 2009):
a) Recolectar datos del sistema real de interés. Esto a menudo requiere tiempo
sustancial y compromiso de recursos. Desafortunadamente, en algunas
situaciones no es posible recolectar los datos (por ejemplo, cuando el tiempo
es extremadamente limitado, cuando el proceso de entrada aún no existe, o
cuando las leyes o reglas prohíben la recolección de datos). Cuando los datos
no están disponibles, la opinión de expertos y conocimiento del proceso
debe ser usado para realizar estimaciones aproximadas.
b) Identificación de las distribuciones asociadas a un conjunto de datos. Para

poder hacer una buena elección es recomendable seguir tres pasos:
Paso 1. Identificar una distribución de probabilidad que represente el

proceso de entrada. Cuando los datos están disponibles este paso
usualmente comienza con el desarrollo de una distribución de
frecuencias o histograma de los datos. Dada la distribución de
frecuencia y un conocimiento estructural del proceso, una familia de
distribuciones es escogida.
Paso 2. Escoger parámetros que determinen una instancia especifica de la

familia de la distribución. Cuando los datos estén disponibles, esos
parámetros pueden ser estimados a partir de los mismos datos.
Paso 3. Evaluar la distribución elegida y los parámetros de bondad asociados.

La bondad de la distribución puede ser evaluada de manera

Capítulo 3. Ideintificación de Distribuciones con ExpertFit. 55
informal, vía métodos gráficos, o de manera formal, vía pruebas

estadísticas. Las pruebas, Chi-cuadrada, Kolmogorov-smirnov y
Andenson-Darling son pruebas de bondad de ajuste estándar y
representan a una prueba de hipótesis estadística. Si el
planteamiento de hipótesis respecto a una distribución de
probabilidad dada no es aceptado, entonces es necesario regresar al
primer paso. Escoger una familia diferente de distribuciones y
repetir el procedimiento. Si muchas iteraciones fallan en este
proceso será necesario encontrar una distribución empírica la cual
se ajuste a los datos colectados.
3.2. RECOLECTAR DATOS DEL SISTEMA REAL DE INTERÉS
La recolección de datos, es sumamente importante y es una de las tareas más

difícil al intentar modelar un sistema a través de la simulación. Un modelo de
simulación puede mostrarse adecuadamente pero si los datos de entrada o las
distribuciones de probabilidad son imprecisas, o mal analizadas, la simulación
puede devolver datos que conlleven a tomar decisiones erróneas las cuales
repercutirán negativamente dentro del sistema real.
Los siguientes puntos describen algunas recomendaciones al realizar una

colección de datos:
1. La observación. Durante las visitas al sistema real, trate de recolectar toda la

información que pueda, observe y pregunte cuantas veces sea necesario e
incluso si es permitido grabe videos para su consulta posterior. Si los datos
son recolectados automáticamente (por ejemplo, recolección de datos por
medio de una computadora) o por alguna otra persona, confirme que la
información es colectada en un formato útil para Usted. Si es necesario hacer
muestreos, asegúrese de hacerlos correctamente (ver el Capítulo 2), además
disponga del tiempo necesario y no olvide tomar tanta información como
pueda. Por otro lado, no descarte la posibilidad de hacer censos pues es
probable que se encuentre con tiempos extensos requeridos para completar
algún proceso (por ejemplo, la frecuencia con que arriba un camión a la
planta, la producción de una pieza, la cantidad de piezas defectuosas en un
turno, etc.), los cuales también son de importancia.
2. Seleccione la información colectada y adminístrela. Haga un pre-análisis de datos y

clasifique la información la cual proveerá distribuciones de probabilidad al
modelo de simulación (comúnmente se crean bases de datos en archivos
electrónicos como Excel), el resto de la información consérvela por separado
pues será útil al intentar definir la lógica de operación del modelo.

3. Datos Homogéneos. Tome datos en periodos sucesivos y durante el mismo

periodo de tiempo, por ejemplo revise la homogeneidad de los datos de las
8:00 am a las 10:00 am y de las 10:00 am a las 12:00 pm. en diferentes días
de la semana. Para hacer una valoración simple de la homogeneidad puede
revisarse que las medias de las distribuciones de probabilidad de las muestras
(por ejemplo, el tiempo promedio invertido al atender a un cliente en el
cajero de un banco) sean las mismas. Para hacer un análisis más completo,
se sugiere revisar el tema “Inferencias Estadísticas para Dos Muestras”, del
libro de Montgomery y Runger (2009).
4. Diagrama de flujo y autocorrelación. Para indicar una relación entre un equipo y

otro, entre departamentos o entre alguna variable de interés, es importante
tener un diagrama de flujo. Además, es necesario considerar la secuencia de
actividades de un elemento dentro del sistema las cuales aparenten
independencia pero que de hecho tiene autocorrelación. La autocorrelación
puede observarse en la asignación de equipos de producción. Por ejemplo,
la asignación de un equipo puede estar relacionada con la calidad de la pieza
a procesar, es decir, si la pieza no pasa la prueba esta podría regresar a
reproceso, a defectivos o bien podría ser aceptada con observaciones. Otras
herramientas de utilidad son: diagrama de procesos operativos, diagrama de
flujo de procesos, diagrama de flujo de distribución o hilos, entre otros.
Consulte Niebel y Freivalds (2009), p. 25-35.
3.3. DISTRIBUCIONES ASOCIADAS A UN CONJUNTO DE

DATOS
En la actualidad, existe una amplia variedad de software disponible para lograr

identificar la distribución que mejor se ajuste a un conjunto de datos, entre estos
están ExpertFit ®, Stat::Fit® y algunos más como BestFit® el cual está integrado
en el procesador de entradas @Risk´s® o bien el integrado en Arena® (Banks et.
al., 2009). En esta sección, se mostrará el uso de ExpertFit el cual es un
complemento del procesador FlexSim. ExpertFit será usado para seleccionar la
distribución que mejor se ajuste a un conjunto de datos disponibles, se indicará la
forma en que puede especificarse una distribución de probabilidad cuando no se
dispone de datos y se describirá la estimación de sus parámetros para el uso dentro
de los objetos de FlexSim.
Es de suma importancia que el lector comprenda la forma en que opera

ExpertFit o cualquier otro software al intentar asociar un conjunto de datos a un
conjunto de distribuciones de probabilidad, de tal forma que este pueda ser usado
adecuadamente. Desafortunadamente, en este libro no se discuten los métodos

matemáticos (Chi-cuadrada, Kolmogorov-smirnov y Andenson-Darling) para

hacer pruebas de bondad de ajuste y estimación de parámetros manualmente. Para
esto y otros detalles al tema, consulte Banks et. al., (2009) y Law (2007).
Antes de continuar, es importante hacer notar dos cuestiones para tener

acceso y hacer uso de software ExpertFit:
1. Si se cuenta con una licencia de FlexSim completa puede activar la ventana

principal del software ExpertFit de la siguiente forma: de inicio a FlexSim y,
dentro del Menú Principal Statistics selecciones ExpertFit. De inmediato
podrá visualizar una pantalla emergente de la versión completa de ExpertFit.
Si por el contrario Usted cuenta con la versión libre de FlexSim, esta opción
se mostrara inhabilitada.
2. En caso de no contar con una versión completa de FlexSim y para un mejor

entendimiento de la herramienta por analizar, se recomienda al lector
descargar el demo (DOWNLOAD DEMO) del software ExpertFit versión
8.01, propiedad de la empresa Law y Associates, Inc. (2011-2019), en la
siguiente liga:
http://www.averill-law.com/distribution-fitting/
para tener éxito en la descarga, basta con llenar el formulario solicitado en la

página web anterior, descargar la aplicación e introducir el código de acceso
que se envía al correo proporcionado en el formulario. Si tiene algún
problema para descargar el código, envié un correo electrónico a
averill@simulation.ws, donde seguramente lo apoyaran con sus dudas.
3.4. USO DE EXPERTFIT
ExpertFit permite evaluar y determinar de manera rápida, automática y exacta cual

es la mejor distribución de probabilidad que se ajusta a un conjunto de datos,
además por medio de una fuente de aleatoriedad proporciona un análisis cuando
se tiene ausencia de estos mismos. ExpertFit fue desarrollado por Averill M. Law
& Associates y dado que es el resultado de 33 años de investigación estadística,
actualmente es usado por analistas que estudian sistemas del mundo real a través
de un modelo de simulación de eventos discretos en diferentes áreas como
manufactura, logística, centros médicos, redes de comunicación, entre otras y, en
diversas disciplinas tales como en la economía, las finanzas, la química, el medio
ambiente, la física, la ingeniería, y todo aquel lugar donde se desea hacer un simple
análisis de datos o bien un análisis de riesgos (Law, 2007). La aplicación dispone
de 40 distribuciones, 30 diagramas gráficos de alta calidad, 3 pruebas de bondad
de ajuste, permite un tamaño de muestra de hasta 100,000 datos, se pueden crear

histogramas interactivos, da un soporte claro para modelos de simulación, entre

otras bondades (Law y Associates, Inc., 2011-2019).
3.4.1. Tipos de Análisis en ExpertFit
ExpertFit puede realizar principalmente tres tipos de análisis, los cuales se

clasifican en dos apartados (ver figura 3.1). El primero de estos apartados es
empleado cuando se dispone de datos y el segundo cuando se carece de los
mismos.
Fit Distributions to Data. Permite adaptar distribuciones a los datos.
 Data Analysis (Análisis de Datos). Es usada para determinar cuál de las

distribuciones de probabilidad que mejor se ajusta a un conjunto de datos.
El usuario puede decidir entre determinar la mejor distribución
automáticamente o especificar a su consideración una distribución
manualmente.
Construct distributions in the absence of data. Permite construir

distribuciones en ausencia de datos.
 Task-Time Models (Modelos de Tiempo de Tareas). Se utiliza para especificar

una distribución de probabilidad del tiempo en que se ejecuta una tarea
cuando no se dispone de datos. Para ejecutar este módulo son necesarias
estimaciones subjetivas de parámetros tales como: el tiempo mínimo en que
se ejecuta la tarea y el tiempo ideal en que se ejecuta la tarea. ExpertFit
especifica una distribución Weibull, Lognormal o Triangular como un
modelo del tiempo en que se ejecutará la tarea (para una distribución
triangular, es posible utilizar el tiempo máximo de la tarea en lugar del ideal).
 Machine-Breakdown Models (Modelos de Averías en Máquinas). Se utiliza para

modelar tiempos inactivos de una máquina aleatoriamente cuando no se
dispone de datos reales de tiempo de inactividad. Para ejecutar este módulo
son necesarias estimaciones subjetivas de parámetros tales como: la
eficiencia de la máquina (por ejemplo, el 90% o 0.90) y el tiempo medio de
inactividad. ExpertFit especifica una distribución para indicar el tiempo en
que la máquina estará en operación y una distribución para modelar el tiempo
de inactividad.

Ventana 2.
Ventana 1.
Figura 3.1. Ventanas de inicio en ExpertFit. Para visualizar la segunda ventana de

clic izquierdo en New… de la primer ventana Proyect 1.
En la ventana no. 2, personalice la pantalla de nombre Project-Element

Name y de clic en el recuadro Ok. Posterior a ello, se mostrara una nueva pantalla
llamada Project Directory, donde una fila de color negro indicara el proyecto en el
que se trabaja, basta con dar clic izquierdo en el botón Analyze… y podrá observar
la figura 3.2 de nombre Data Analysis (Modulo Análisis de Datos) del siguiente
apartado.
3.4.2. Data Analysis
Antes de iniciar con la descripción de la figura 3.2, se precisa información de

interés:
Existen dos modos de operación a la hora de intentar determinar cuál es

la distribución que mejor se ajuste a los datos: Standart Mode y Advanced
Mode, por lo que es posible cambiar de un modo a otro en cualquier momento
seleccionando del menú principal la opción Mode. La alternativa que aparece por
defecto es Modo Estándar, este modo de análisis es empleado el 95 por ciento de
las veces y da una buena representación de los datos. El Modo Avanzado contiene
una gran cantidad de características adicionales para el usuario sofisticado.
Adicionalmente, es posible elegir entre dos niveles de precisión en los ajustes de
distribuciones: Normal y High, para elegir entre ambas puede seleccione del menú
principal la opción Precision. La precisión normal (por defecto) proporciona una

buena estimación de conjuntos de parámetros de una distribución de datos y tiene

un pequeño tiempo de ejecución. La precisión alta proporciona mejores
estimaciones de los parámetros para la mayoría de los conjuntos de datos, pero
su tiempo de ejecución es mayor cuando se analizan grandes conjuntos de datos.
Sin embargo, sin importar el modo y la precisión empleados para determinar a
qué distribución corresponden los datos, es necesario seguir la siguiente secuencia
de pasos:
Paso 1. Data (Datos). Sería oportuno tener un conjunto de datos disponibles en

un archivo (por ejemplo en Excel), para copiarlos y pegarlos dentro del
editor de datos de ExpertFit.
Paso 2. Models (Modelos). Se usara para "determinar" las distribuciones de

probabilidad que mejor correspondan con el conjunto de datos.
Paso 3. Comparisons (Comparación). El usuario podrá comparar las

distribuciones que mejor se ajusten al conjunto de datos.
Paso 4. Applications (Aplicaciones). Es el último paso necesario para determinar

o mostrar características de una distribución (por ejemplo, sus momentos
o función de densidad). Con ello será posible representar la distribución
de probabilidad dentro de los objetos de FlexSim.
Figura 3.2. Ventana principal de ExpertFit para la operación con datos.

Como se puede observar, los menús antes mencionados en la figura 3.2

dan al lector una idea de la variedad de acciones que se pueden desarrollar, sin
embargo, para ser precisos el siguiente apartado es una guía paso a paso en la
descripción de un caso de estudio singular.
3.4.3. Análisis de un Conjunto de Datos Paso a Paso
Antes de iniciar un proyecto dentro del módulo Data Analysis considere las
siguientes recomendaciones.
1. Cantidad y tipos de datos necesarios. La cantidad de datos necesarios para que

ExpertFit realice un análisis deberá ser de entre 10 y 100,000 observaciones.
Sin embargo, se recomienda que el número de observaciones del fenómeno
aleatorio de interés sea de por lo menos 100 datos. Recuerde que entre mayor
sea el número de datos, mejor será la discriminación entre distintas
distribuciones. Es posible introducir uno o más valores de datos por línea
(en este último caso, las observaciones deben estar separadas por espacios
en blanco o bien por una coma). El conjunto de datos corresponderá con el
formato ASCII (acrónimo inglés de American Standard Code for
Information Interchange) y podrán ser copiados desde una hoja de cálculo
activa como Excel con Ctrl+C para tenerlos disponibles en el portapapeles
y posteriormente ser pegados dentro del editor de datos de ExpertFit.
2. Al recolectar observaciones de variables aleatorias continuas (por ejemplo,

el tiempo en que un operario arma una caja), es importante que los valores
de los datos tengan una resolución suficiente (un número considerable de
decimales) para que el muestreo tenga un número amplio de valores
distintos. De lo contrario, será difícil que ExpertFit encuentre una
distribución continua que se ajuste adecuadamente.
3. Para poder hacer una depuración adecuada de los datos colectados, es

necesario identificar si un valor contenido dentro de un conjunto de datos es
correcto o incorrecto. Por tanto, el tener claro cómo opera el proceso que produjo
esos datos es indispensable. Así, si son encontrados dentro del conjunto de
datos con valores atípicos o fuera de lo común (demasiado pequeños o
grandes comparados con el resto), será posible saber si estas observaciones
son legítimas o simplemente son el resultado de un mal registro o medición.
4. Por otro lado, si se recolectan los tiempos de llegada de los clientes a un

supermercado y no el tiempo entre llegada de un cliente a otro, Usted puede
convertirlos en ExpertFit mediante el transformador DIFF (comprar ficheros
y muestra la diferencia entre dos ficheros).

Paso 1. Data
Introducción de datos. Después de revisadas las consideraciones anteriores, al

dar clic en la única pestaña activa llamada Enter Data… de la ventana Data
Analysis (figura 3.2), se desplegará una nueva ventana con el nombre de Enter-
Data Options (vea figura 3.3), con tres opciones diferentes para los datos de
entrada.
Figura 3.3. Ventana -Opciones

de datos de entrada.
Cada una de las opciones anteriores admite situaciones variadas, las cuales
se describen como sigue:
 Read Data from File, admite la lectura de datos desde un archivo externo.
 Enter/Edit Data Values, es empleada para introducir o editar valores de

datos (vea figura 3.4). Aquí se podrán pegar valores copiados desde alguna
base de datos externa (Paste at End from Clipboard), se podrán copiar datos
hacia una base de datos externa (Copy Data to Clipboard) o bien es posible
ordenar los valores de los datos (Sort Data Values). Además se permite editar
cada valor por separado si fuese necesario (Single-Value Editing).
 Data Set, elimina un conjunto de datos definidos.
Caso de estudio:
Ejemplo 3.1. Los datos de la tabla 3.1, representan el tiempo entre las llegadas de
clientes en una central de autobuses de la ciudad de Pachuca Hidalgo, México.

Tabla 3.1. Tiempo en minutos del arribo de clientes a la central de autobuses.
1.2612 1.3352 0.7624 0.6891 0.9117 2.0866 0.1030 0.0235 0.0217 0.4330
3.0628 0.3043 0.0688 1.1471 0.3381 0.9148 0.5979 0.5819 0.1166 0.3529
0.9140 0.7904 0.4831 1.5379 0.4093 1.9359 0.6797 0.6029 0.3983 1.7758
0.4271 4.6666 0.0138 0.1239 0.0422 0.5146 0.3471 0.6811 1.3994 0.6210
0.8327 0.4165 0.0012 0.4262 2.1210 0.7529 0.7172 0.0804 1.2710 0.2072
0.3606 1.3682 1.4619 0.2013 1.5348 0.0440 0.2699 2.4408 0.8494 0.4980
0.5505 0.2020 0.0777 0.3545 0.0376 0.3133 1.4440 0.8855 0.3526 0.3781
0.5881 0.8652 0.2093 0.0666 0.3959 0.2591 0.3729 0.5406 3.8330 1.0269
1.8715 0.6112 0.7447 0.2072 0.1275 1.2193 0.0073 0.8614 1.1969 2.3287
1.2586 0.5554 0.0095 0.6133 0.9226 0.0475 0.8421 0.2186 0.2059 1.6732
Para iniciar, seleccione la opción Enter/Edit Data Values de la ventana

de opciones Enter-Data Options. Después introduzca los datos de la tabla 3.1.
Para hacer esto, puede elegir entre la introducción individual por medio de la
opción Single-Value Editing o bien puede capturar los datos dentro de algún libro
de Excel para posteriormente copiarlos en conjunto al portapapeles y tenerlos
disponibles para cuando pulse Paste at End from Clipboard (ver la Figura 3.4).
Captura de datos
individuales
Captura de datos
desde una base de
datos externa
Figura 3.4. Ventana -Editor de Datos.
Posteriormente, una vez que se introdujeron los datos, de clic en Ok para

generar la ventana Data-Summary Table. La Tabla Resumen de Datos, muestra
a manera de resumen las estadísticas descriptivas de la variable correspondiente
al conjunto de datos. En nuestro ejemplo, podemos ver que para un conjunto de
n = 100 observaciones la media es igual a 0.77608 (vea la figura 3.5). Además, el
valor positivo de la asimetría (skewness) de la muestra indica que la distribución
subyacente de los datos está sesgada a la derecha (es decir, que tiene una cola a la
derecha y no a la izquierda, vea el histograma de la figura 3.7). Para salir de esta
ventana y continuar con el proceso, de clic en Done.

Figura 3.5. Ventana – Tabla de Resumen de Datos.
Nota: Si todos los valores de los datos en el archivo son enteros (sin
importar si son positivos o negativos), la muestra se considera como número
entero. De lo contrario, se definen como números reales. Los valores reales deben
tener magnitudes de entre -1.0E+99 y 1.0E+99. Después de introducir los valores
en el editor de datos de ExpertFit y al dar clic en OK inmediatamente se mostrara
una tabla con el resumen estadístico del conjunto de datos siempre y cuando los
datos sean de valor real. De no ser así, si todos los valores de los datos son
números enteros, entonces se le cuestionará sobre si los datos deben ser
considerados como valores reales o no (vea la figura 3.6).
Figura 3.6. Al presionar Sí, estará indicando que el conjunto

de datos son valores reales.
Para comprobar lo anterior intente con la admisión de datos enteros dentro

del Editor de Datos.

En estos momentos, Usted puede ver como se habilitan cuatro opciones más
dentro de la ficha Data. Revisemos como operan:
1. Dentro de View/Modify Data (Ver/Modificar Datos), es posible ver y

modificar los datos introducidos de acuerdo con ciertas condiciones
iniciales:
 En View Data, podrá ver el conjunto de datos introducidos ya sean de
manera ordenada o desordenada.
 En Modify Data, es posible modificar los datos introducidos mediante dos

alternativas.
o Create a Subset (Crear un Subconjunto). Esto se utiliza para

especificar un subconjunto de la muestra de datos introducidos para
el análisis; el subconjunto se convierte en la muestra actual. Tenga
en cuenta que el subconjunto debe contener al menos 10
observaciones. Para elegir el subconjunto puede probar entre tres
opciones: Data Value, Select by Position in Unsorted Data y Select by
Position in Sorted Data.
o Perform a Transformation (Realizar una Transformación). Al elegir la

opción será posible hacer transformaciones en la muestra de datos
introducidos para el análisis. Por ejemplo, si da clic en el signo “+”,
puede añadir un valor especificado en cada observación o bien si
presiona “SQRT” podría tomar la raíz cuadrada de cada
observación, etc. Así mismo, el transformador DIFF sustituye el
tiempo de llegada del i-esimo cliente por el periodo de tiempo entre
llegadas de un cliente y otro.
2. Data Summary (Resumen de datos). Aquí el lector podrá observar

nuevamente la ventana Data-Summary Table con el resumen estadístico del
conjunto de datos tal como: el número de observaciones, observación
mínima o máxima, media, mediana, varianza, etc.
3. Histogram (Histograma). Dentro de esta opción es posible elegir y

configurar tanto un histograma como una tabla de frecuencias (vease la
figura 3.7):
 Histogram. La opción permite graficar un histograma de acuerdo con

las observaciones dadas.
 Frequency Table. Muestra una serie de proporciones de acuerdo con

los rangos del conjunto de datos.

Figura 3.7. Histograma del conjunto de datos introducidos.
Para este ejemplo, cree un histograma parecido al de la figura 3.7 pero

dentro de la tabla de datos Histogram Configuration cambie el ancho del intervalo
(Intervel width) de 0.36000 al de 0.2 haciendo clic en ("=") y observe lo que
sucede. Como se puede ver, es posible cambiar el ancho del intervalo configurado
en automático por ExpertFit a uno que visualice un histograma menos desigual
médiate pruebas de ensayo y error. Sin embargo, Law (2007), recomienda que al
construir su propio histograma considere un ancho de intervalo de 0.2, no
obstante, esto no es una regla, Usted puede usar el ancho del intervalo que mejor
crea conveniente.
Nota: Tenga en cuenta que también es posible cambiar tanto el Punto

Inicial del Primer Intervalo como Número de Intervalos (ver figura 3.8).
Figura 3.8. Histograma del conjunto de datos introducidos con un Punto Inicial del
Primer Intervalo igual a 0, un Ancho de Intervalo de 0.2 y con un Número de 10
Intervalos.

4. Assess Independence (Evaluar la Independencia). Esto se utiliza para

determinar si un conjunto de datos mezclados o sin ordenar, son una muestra
independiente. Esto es un requisito para muchos de los procedimientos
estadísticos (por ejemplo, la estimación de máxima probabilidad). Para tal efecto,
se pueden crear dos tipos de análisis (vease la figura 3.9):
 Scatter Plot. Un diagrama de dispersión es un gráfico de los pares

(𝑋𝑖 , 𝑋𝑖+1 ) para 𝑖 = 1, 2, … , 𝑛 − 1, donde 𝑋1 , 𝑋2, … , 𝑋𝑛 son las
observaciones sin ordenar.
 Lag Correlations. Es posible observar una correlación rezagada de los

datos introducidos mediante una gráfica o una tabla:
o Plot. Una gráfica de correlación es un gráfico de la muestra de

correlación 𝜌̂𝑗 para 𝑗 = 1, 2, … , 20 (máximo). El índice 𝑗 se llama
a menudo rezago. La correlación de la muestra ( 𝜌̂𝑗 ) es una
estimación de la verdadera correlación (𝜌𝑗 ), entre dos
observaciones que son 𝑗 observaciones separadas en el tiempo.
Tenga en cuenta que el valor de 𝜌𝑗 estará en el intervalo [−1, 1].
o Table. Muestra la correlación teórica 𝜌̂𝑗 para determinar si las 𝑋𝑖

de la muestra son o no independientes.
Para mayor información respecto al tema “Técnicas para la Evaluación

de la Independencia de la Muestra”, consulte la página 312 del libro de Law
(2007).
Figura 3.9. Gráfico de dispersión y gráfica de correlación rezagada del conjunto de

datos introducidos.

Paso 2. Models
El uso de la ficha Modelos es el segundo paso en la búsqueda de una distribución

de probabilidad que mejor se ajuste al conjunto de datos (vease la figura 3.10).
Figura 3.10. Ventana principal para hacer ajuste de modelos.
Dentro del botón Automated Fitting… (Ajuste automatizado), se permite

hacer un ajuste automático, clasificación y evaluación de los modelos por medio
de una caracterización establecida por defecto del rango de la variable aleatoria.
Para determinar la familia de distribuciones de probabilidad que mejor se

ajuste al conjunto de datos introducidos anteriormente, seleccione Automated
Fitting …, a continuación se mostrara una nueva ventana llamada Automated-
Fitting Results con los resultados de las distribuciones que corresponden con el
conjunto de datos (vease la figura 3.11).
Como se puede observar, esta última ventana, se clasifica a su vez en tres

apartados: Relative Evaluation of Candidate Models, Absolute Evaluation of the Selected
Model y Additional Information about the Selected Model, las cuales describen lo
siguiente:
 Al interior del apartado Evaluación Relativa de los Modelos Candidatos,

se muestra un ranking de los tres mejores modelos sobre la base de las
estadísticas de clasificación utilizadas por ExpertFit. Para nuestro caso, se
enlista en primer lugar la distribución Erlang con parámetros de localización,
escala y forma de 0, 0.77608 y 1 respectivamente, seguido de una distribución
Exponential y una Weibull. A cada modelo se le asigna una puntuación de la

evaluación relativa de 0 a 100 (siendo 100 la mejor puntuación). Cuanto

mayor sea la puntuación de un modelo, mejor es en relación con los otros
modelos especificados. Tenga en cuenta que un modelo con una puntuación
moderadamente alta (por ejemplo, 89) todavía podría ser una muy buena
representación de los datos, ya que puede haber varios buenos modelos de
la competencia que abaten la puntuación del mejor modelo.
Evaluación relativa de los

modelos candidatos
Evaluación absoluta del

modelo seleccionado
Información adicional
sobre el modelo
seleccionado
Figura 3.11. Ventana de evaluación de los modelos candidatos.
 Dentro del apartado, Evaluación Absoluta del Modelo Seleccionado,

podrá observarse la evaluación absoluta de la distribución de probabilidad
con la puntuación más alta la cual se mostrara con uno de los tres mensajes
siguientes: Good, Indeterminate or Bad. Estos mensajes, se deben considerar
como pautas en cuanto a cómo se debe proceder. En nuestro caso el mensaje
de evaluación absoluta es “Good o Bueno”, lo que nos indica que no hay
razón para desconfiar que el modelo de distribución de probabilidad Erlang
y la media de la muestra son casi idénticos. Sin embargo, esto será explicado
más adelante en el paso 3 “Comparisons”. Por otro lado, si no se muestra
una clasificación Good, la cual indique un buen ajuste a un conjunto de
datos, esto podría ser debido a una de las siguientes razones:

1. Los datos de valor real se han redondeado tanto que al discretizar los
datos se complica encajar en una distribución continua.
2. El conjunto de datos es una mezcla de dos o más poblaciones no

homogéneas.
Recuérdese también que existen literalmente cientos de distribuciones de

probabilidad creadas, por lo que sería buen hacer un análisis previo para conocer
sus aplicaciones, el modelo matemático que las representa, la forma de su gráfica
y los parámetros que las definen (un resumen de lo anterior se hace en el Capítulo
2 de este libro).
 El último apartado Información Adicional Sobre el Modelo

Seleccionado, añade información adicional para ayudarle a determinar la
calidad general del modelo o distribución seleccionada. En particular, si el
"error" de la media del modelo con respecto a la media de la muestra es
"grande", entonces es posible que desee rechazar el modelo seleccionado,
independientemente de la "Evaluación Absoluta."
Adicionalmente, dentro de esta misma evaluación ExpertFit también

especifica el número total de modelos que se ajustan a los datos. En nuestro caso,
son definidos 14 modelos con puntuación entre 0.00 y 90.38 (dentro de la opción
"Comparisons", podrá visualizar el "Informe de Evaluación" para alguna
distribución que no es de los tres mejores modelos). Para salir de la ventana actual,
presione el botón Done.
Después de abandonar la ventana anterior, dentro de la ficha “Modelos”

Usted podrá observar debajo de Specified Models, una lista desplegable de todas las
distribuciones las cuales podrían representar al conjunto de datos (se enumeran
en orden decreciente respecto a su "Puntuación Relativa"). Además, podrá ver
activas dos opciones más las cuales permiten hacer ajustes individuales o en
conjunto:
o La pestaña Fit Individual Models (Ajustar los Modelos Individuales),

permite hacer una ajuste manual de las distribuciones específicas. Los
valores de los parámetros se pueden estimar a partir de datos o pueden
ser especificados por el usuario.
o View/Delete Models (Ver/Borrar Modelos). Dentro de esta opción, Usted
puede especificar si desea mostrar o eliminar los parámetros de un
modelo en específico o de todos en conjunto (Show Model Parameters y
Delete Models, respectivamente).

Paso 3. Comparisons
Dentro de la ficha Comparaciones (ver la figura 3.12), es posible comparar y

hacer pruebas con las distintas distribuciones de probabilidad que mejor se ajusten
al conjunto de datos. Para tal caso, se definen tres los botones 1) Graphical
Comparisons…, 2) Goodness-of-Fit Tests y 3) Evaluate a Model.
Figura 3.12. Ventana principal para hacer ajuste de modelos.
1. Para continuar con el ejemplo, iniciaremos con una comparación gráfica

del modelo de distribución Erlang propuesto por ExperFit. Para poder
hacer una evaluación específica, de clic izquierdo sobre el botón
Graphical Comparisons… (Comparaciones Gráficas) el cual se
encuentra contenido dentro de la ventana Modelo y Comparación de
Datos. Una vez dentro de Graphical Comparisons, marque la opción
Density-Histogram Plot (Densidad-Gráfico de Histograma) y de Apply
(véase figura 3.13).

Figura 3.13. Densidad del Histograma para la distribución Erlang ajustada por
ExperFit y los datos del tiempo entre llegada de los clientes a la central de autobuses.
Como se puedo observar, es posible hacer una comparación entre el

histograma definido por los datos de entrada y distintos modelos de distribución.
Sin embargo, existen tres tipos de comparaciones gráficas adicionales las cuales
son:
 Frequency-Comparison Plot (Frecuencia-Comparación de Gráfico). La

opción admite la comparación de uno o más histogramas de modelos
teóricos con el histograma de los datos introducidos.
 Distribution-Function-Differences Plot (Distribución-Función-

Diferencias de Gráficos). Al interior del rango de los datos, se traza la
diferencia entre la función de distribución de un modelo y la función de
distribución de la muestra.
P-P Plot (gráfica P-P). Muestra la discrepancia relativa que existen entre
la linealidad de los datos de origen y del modelo de distribución seleccionado.
Entre menor sea la discrepancia mayor será la certidumbre que se tenga con la
distribución seleccionada.
Antes de concluir el tema, elabórese un gráfico con la opción Distribution-

Function-Differences Plot pero con una distribución Exponencial tal como se muestra
en la figura 3.14. Observe como el gráfico muestra la diferencia entre la función
de distribución Exponencial y la función de distribución de la muestra sobre el
rango de los datos. La calidad del modelo es definida por la desviación vertical de
la línea trazada sobre el eje X. Entre más se apegue la línea gráfica del modelo al

eje horizontal de altura 0, menor será la desviación y por tanto se tendrá un mejor
ajuste. Para este ejemplo, la diferencias verticales en el grafico están cerca de 0,
esto es una indicación adicional de que la distribución Exponencial es un buen
modelo para los datos y por tanto, la función de distribución de la muestra, es una
correcta estimación de la verdadera función de distribución subyacente de los
datos.
Figura 3.14. Diferencia

entre la función de
distribución Exponencial y
la función de distribución
de la muestra sobre el
rango de los datos.
2. Goodness-of-Fit Tests (pruebas de bondad de ajuste). Una prueba de

bondad de ajuste se puede utilizar para probar formalmente si los datos son
una muestra independiente de una distribución particular (modelo). Para
comprender e interpretar adecuadamente las pruebas de bondad de ajuste
consulte Banks et. al., (2009) y Law (2007).
Este modulo ofrece tres tipos distintos de pruebas:
1. Anderson-Darling (sólo datos reales),

2. Kolmogorov-Smirnov (sólo datos reales), y
3. Prueba de Chi-Cuadrada (datos enteros y reales)
Para ejemplificar una de estas tres pruebas, de clic sobre Goodness-of-

Fit Tests. Una vez dentro, seleccione la prueba Chi-Square Test de la lista mostrada.
La prueba de Chi-Cuadrada es la prueba de bondad de ajuste más conocido y
ampliamente aplicable. Sin embargo, tiene el grave defecto de que no hay receta
definitiva para la selección del número de intervalos. No obstante, en la página
341 del libro de Law (2007) se recomienda que el número de intervalos deberá ser
de al menos 5. Para indicar el número de intervalos en nuestro ejemplo, haga clic
en el botón de signo igual ("=") del "Number of Intervals" y asigne el valor de 8
(véase figura 3.15). Finalmente de Apply para observarlos resultados.

Figura 3.15. Pruebas de bondad de ajuste Chi-Cuadrada para el modelo Erlang con
un número de intervalos igual a 8.
Dentro de la tabla de resultados, se muestran los estadísticos los cuales

sustentan la decisión de aceptar o rechazar un modelo el cual represente a los
datos introducidos. El estadístico de prueba se compara con el valor crítico
respecto a un nivel de significancia (alfa) deseado. Si el estadístico de prueba es
mayor que el valor crítico elegido, se rechaza el modelo. De lo contrario, el
modelo no se rechaza. Observe en la figura 3.16, que cuando el nivel (alfa) es de
0.1 el valor crítico es 12.017 y si este es comparado con el estadístico de prueba
el cual es de 2.72 podemos decir que no existen pruebas suficientes para rechazar
que los datos correspondan a una distribución Erlang. En resumen, no hay
ninguna razón para creer que la distribución de Erlang no proporciona una buena
distribución de probabilidad que modelo los datos del tiempo de llegada de los
clientes a la central de autobuses dentro del software FlexSim.
Figura 3.16. Resultados de la pruebas de bondad de ajuste Chi-Cuadrada para el

modelo Erlang.

Tal como se observó, las pruebas de bondad de ajuste proporcionan una

orientación útil para evaluar la idoneidad de un modelo de entrada potencial, sin
embargo, no existe una única distribución correcta en una aplicación real, por lo
que Banks et. al., (2009) advierte que no debe ser esclavo de la sentencia de este
tipo de prueba ya que el dictamen dependerá en gran medida de la cantidad y
calidad de los datos (las pruebas tiende a tener baja potencia para pequeños a
moderados tamaños de muestra). Por lo tanto, no ignore las características físicas
del proceso real cuando seleccione una distribución. Pregúntese sobre la
naturaleza del proceso, confirme si los datos son discretos o continuos, o si se
está limitado o no. Este conocimiento, el cual no depende de los datos, puede
acortar las familias de distribuciones que podemos elegir. Y tenga encuentra que
probablemente no exista una distribución real para cualquier entrada estocástica
que guie a resultados útiles en un experimento de simulación.
En conclusión, el lector debe tener en cuenta que el hecho de que

ExpertFit acepte o rechace alguna prueba no significa necesariamente que la
distribución sometida a la prueba es exactamente la distribución adecuada o la que
han producido los datos.
3. Evaluate a Model (Evaluar un Modelo). Aquí, es posible especificar si se

debe mostrar un informe de la evaluación, respecto a las tres mejores
distribuciones que mejor se ajustaron al conjunto de datos (sobre la base de
sus resultados relativos) o si se debe mostrar un gráfico de diferencias:
 Evaluation Report (Informe de la Evaluación).
 DF-Differences Plot (Distribución-Función-Diferencias de Gráficos).
Paso 4. Applications
La ficha llamada Aplicaciones, es el último paso necesario para definir las

características de la distribución de probabilidad seleccionada que mejor se ajuste
al conjunto de datos si es que existe una distribución adecuada.
 Use a Specified Distribution (Model). La caracterización y uso de un

modelo de distribución especificado se puede hacer a través de los siguientes
puntos.
o Characteristcs. Permite visualizar la función de densidad de la trama,

momentos, entre otros temas, de una distribución seleccionada.
o Simulation Representation. Se utiliza para colocar una distribución adaptada

al formato adecuado para su empleo dentro de FlexSim.

 Use an Empirical Distribution. Si el modelo elegido no es una buena

representación de los datos, es necesario utilizar las siguientes dos
aplicaciones para identificar una distribución empírica la cual se ajuste a los
mismos.
o Characteristcs. Es empleado para definir una distribución empírica sobre

la base de los datos, y para mostrar sus principales características, tales
como su función de distribución, la probabilidad acumulada para un
valor 𝑥, y el percentil para una probabilidad 𝑝.
o Simulation Representation. Se utiliza para colocar una distribución empírica

al formato adecuado para su empleo dentro de FlexSim.
Hechas las observaciones anteriores, identifique los parámetros de la distribución

Erlang al formato adecuado del software de simulación FlexSim tal como se
observa en la Figura 3.17.
Nótese que como resultados de la figura 3.17, se observan los valores

correspondientes a los parámetros de Localización, Escala y Forma de la
distribución Erlang (erlang(𝛄, 𝛃, 𝐦) o bien
erlang(location, scale, shape, 𝑠𝑡𝑟𝑒𝑎𝑚)) necesarios para representar los
tiempos entre llegada de los clientes a la central de autobuses dentro de FlexSim
(erlang(0.000, 0.776, 1.000, 𝑠𝑡𝑟𝑒𝑎𝑚). Más información para el uso del
software FlexSim y aplicación de las distribuciones de probabilidad puede
consultarse en los siguientes Capítulos.
Código de la Distribución
Erlang para su uso dentro de
FlexSim.
Figura 3.17. Parámetros de Localización, Escala y Forma de la distribución Erlang

en FlexSim.

3.5. RESUMEN DEL CAPÍTULO
Como se observa, existen diferentes maneras en que estas cuatro pestañas (Data,
Models, Comparisons, Applications) se podrían utilizar para determinar la
mejor distribución que se ajuste a un conjunto de datos, los siguientes pasos son
un resumen de las recomendaciones descritas en el presente capítulo:
1. Realizar un estudio de tiempos para obtener un conjunto de datos de una

actividad o ciclo de trabajo (revisar Capítulo 2).
2. Introducir los datos en ExpertFit, analizar la información estadística (Data)

y crear un histograma (Histogram Options). El propósito de preparar un
histograma es inferir una distribución de probabilidad conocida de una
familia de distribuciones. Si el histograma de los datos colectados tiene una
forma similar a una de las distribución teórica, se asume (hipótesis) que dicho
comportamiento de los datos son una garantía de una distribución dada.
3. Seleccione la distribución que mejor se ajuste a los datos (Models). En este

punto se ponen a prueba los datos de entrada con respecto a las pruebas de
bondad de ajuste (Anderson-Darling, Kolmogorov-Smirnov y Prueba de
Chi-Cuadrada).
4. Confirmar en la pestaña Comparisons que efectivamente la distribución elegida

es la mejor distribución.
5. Luego de que ha seleccionado una distribución de una familia de

distribuciones, el siguiente paso es estimar los parámetros de esa
distribución. Elijase la opción Applications para definir los parámetros de la
distribución de probabilidad seleccionada. Esta acción nos indicará cuales
son los datos o el formato adecuado para su aplicación en el software
FlexSim.
Note además, que todos los análisis correspondientes hechos en ExpertFit se

pueden almacenar en un archivo (Excel, Word, entre otros) para su posterior
reutilización, o bien, es posible almacenar temporalmente texto e imágenes en el
equipo (portapapeles) para después pegarlos en una ubicación diferente.

Preguntas
1. ¿Qué es una variable aleatoria?

2. ¿Para qué son usadas las distribuciones de probabilidad?
3. ¿Además de ExpertFit que otro software puede emplearse en el ajuste de
datos?
4. Adicional a las pruebas de bondad de ajuste, ¿qué otras virtudes tiene el
software ExpertFit?
5. Averigüe y analice que tipos de datos (continuos o discretos) son
necesarios para la determinación del tipo de distribución según las
diferentes pruebas: Chi-Cuadrada, Kolmogorov-Smirnov y Andenson-
Darling.
Actividades
1. Investigue qué es la Simulación Monte Carlo y de un ejemplo simple en

Excel que incluya 2 o más variables.
2. En Excel genere 100 variables aleatorias de una distribución exponencial
con 𝜆 = 10, una distribución normal con media de 20 y varianza de 5, y
una distribución binomial con parámetros N = 12, p = 0.6, q = 0.4.
3. Con la herramienta ExpertFit, determine, qué tipo de distribución siguen
los datos; emplee la prueba Chi-Cuadrada.
95 75 30 40 15 4 41 38 38 3
93 81 36 93 84 20 60 93 52 76
59 61 6 78 14 55 44 83 86 3
97 75 51 44 32 12 58 94 43 71
52 31 7 79 81 91 88 15 42 24
4. Determine, qué tipo de distribución siguen los datos; emplee la prueba

Chi-Cuadrada.
5 5 4 2 0 4 3 2 1 4
1 0 0 5 1 1 0 5 4 1
3 4 2 5 5 4 5 0 3 4
0 3 4 2 5 3 1 5 4 2
0 2 1 0 4 4 2 0 0 3

5. Haciendo uso de la herramienta ExpertFit, determine, qué tipo de

distribución siguen los datos; emplee la prueba Kolmogorov-Smirnov.
127.74 129.98 122.07 126.57 123.55 122.5 129.63 120.73 127.54 123.04
127.21 120.07 122.22 126.37 121.15 121.76 120.25 125.42 126.18 121.75
128.12 126.16 124.5 122.3 123.06 128.85 123.68 121.77 128.72 126.83
128.16 128.72 127.73 121.59 122.42 120.01 127.55 122.79 125.54 129.51
129.19 129.9 126 127.86 129.14 128.05 121 121.62 121.53 120.18
6. Según la prueba Anderson-Darling; ¿Cuál es la distribución que mejor se

ajusta al conjunto de datos?
3.22 3.20 7.77 9.26 2.80 7.37 4.04 12.13 8.90 2.90
5.66 0.87 12.79 10.14 2.74 18.31 3.55 4.45 7.84 10.41
8.98 11.99 9.97 8.97 5.30 12.60 0.89 7.40 16.73 6.33
4.11 6.47 10.41 4.29 12.96 7.91 8.85 19.96 5.50 4.43
13.31 12.55 19.98 2.70 19.41 13.10 1.52 16.38 17.44 4.00
7. Además del análisis que realiza ExpertFit a un conjunto de datos para

determinar el tipo de distribución que siguen los mismos; ¿Cree Usted
qué sea necesario conocer el origen de los datos al momento de tomar
una decisión para elegir una u otra distribución representativa?
Argumente su respuesta.

4 CAPÍTULO

4. Del Software
FlexSim
4.1 DESCRIPCIÓN DEL SOFTWARE

4.2 APLICACIONES DEL SOFTWARE
4.3 FLEXSIM
4.3.1 Características y Terminología de FlexSim
4.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 (FlexSim Express),
visite la página https://www.flexsim.com/ y dé clic en “DOWNLOAD FREE
TRIAL”.

4.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:
3. Sus extensas secciones de pre-construidos permiten abordar situaciones

mucho más complejas sin tener que escribir código de software.
4. El software se orienta a objetos, lo que admite una mayor visualización del
flujo de producción.
5. 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.
6. FlexSim proporciona una herramienta para el ingreso de bases de datos
(Database Connector). Esta función facilita la conexión a una base de datos
y la importación o exportación de datos, incluidos datos administrados por
Microsoft SQL Server, MySQL, Oracle, PostgreSQL y otros. La
herramienta incluye una sólida API (Application Programming Interface)
de Database FlexScript.
7. 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.
8. La generación de distintos escenarios y condiciones variadas son fáciles de
programar.
9. Con el nuevo modulo People es posible modelar sistemas no productivos
que se basan en personas en lugar de artículos.
10. Las distribuciones de probabilidad se pueden representar con gran
precisión en lugar de valores promedio para mostrar fielmente la realidad.
11. El software cuenta con una alta variedad de plantillas Dashboard que
permiten disponer de más de 50 tipos de estadísticos y gráfico, para crear

Capítulo 4. Del Software FlexSim. 83
reportes con suficiente detalle.

12. Es posible la creación de tokens a través de una interfaz basada en fechas,
o mediante una programación diaria o semanal repetida. Esta actividad
proporciona un control significativo sobre los horarios.
13. Una de las contribuciones más importantes de FlexSim es el modulo
Emulation con las aplicaciones OPC DA Connection (Open Plataform
Communications - Data Access) y Modbus Connection (TPC/IPv4,
TPC/IPv6 y RTU) mismas que proporcionan protocolos de comunicación
basados en estándares y especificaciones para la telecomunicación
industrial. Dichas plataformas permiten la comunicación y transferencia de
datos en tiempo real entre recursos industriales y el software FlexSim.
4.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,
simulación distribuida en diferentes 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 que FlexSim es una herramienta clave para mejorar los
resultados al dar respuestas acertadas a los problemas planteados (FlexSim
Software Products, Inc., 2019). Ejemplos de casos de éxito se describen a
continuacion:
 Fabricación: CUMMINS, VALE, REMINGTON, MICHELIN,

QUALCOMM, ETC.
 Producción o ensamblaje: GILLETE, WHIRLPOOL, HELLA, RYOBI,
KAISER ALUMINUM, ETC.
 Lean / six sigma: MATTEL, NISSAN, FOTH, GULFSTREAM,
FOXCONN, ETC.
 Transportadores: SIGMA ALIMENTOS, JOHNSON CONTROLS,
ROYAL HASKONING, GEORGIA PACIFIC, RIO TINTO, ETC.
 Línea de embotellado: ABB, COCA COLA, TETRA PAK, SANMINA,
REDWOOD ROBOTICS, ETC.
 Embalaje: AVON, GOOD YEAR, ABBOTT, ULTRADENT, ABEL
WOMACK, ETC.
 Almacenamiento: CLOROX, GENERAL MILLS, MERCURY, PUBLIX,
CROWN, ETC.

 Manejo de materiales: LAM RESEARCH, OU PONT,

INTERNATIONAL PAPER, CATERPILLAR, FORD, ETC.
 Logística: WILLIAMS MOVING INTERNATIONAL, FEDEX, FIAT,
IBM, SCHEFFER, ETC.
 Cadena de suministro: SHELL, APPLE. EXEL, SCHLUMBERGER,
VOLKSWAGEN, ETC.
 Transporte: KOMATSU, APM TERMINALS, NORFOLK SOUTHERN,
ALOUETTE, GATES, ETC.
 Aeropuerto: DHL, BOEING, AS&E, U.S. AIR FORCE, ETC.
 Terminal de contenedores: MOFFAT & NICHOL.
 Emergencia: U.S.ARMY, NEENAN, SMITHGROUP JJR,
HUNTINGTON INGALL INDUSTRIES, DISNEY, ETC.
 Defensa: NASA, RAYTHEON, LOS ALAMOS, ATK, UTC
AEROSPACE SYSTEMS, ETC.
 Planificación de proyectos: BOSTON SCIENTIFIC, COVIDIEN,
SANDIA NATIONAL LABORATORIES, Y.12, GENERAL
DYNAMICS, ETC.
 Negocios: TAMPA GENERAL HOSPITAL, UTMB HEALTH,
CARDINAL HEALTH, NEBRASKA FURNITURE MART, BAPTIST
HEALTH SOUTH FLORIDA, ETC.
 Simulacion al por menor: STOP&SHOP, VOLVO, BLUE BUNNY,
KINETICS TRUSTED INNOVATION, ETC.
 Call center: DISCOVER FINANCIAL SERVICES, GOOGLE,
ORACLE, USAA, DEPARMENT OF VETERANS AFFAIRS, LIFE
TOUCH, ETC.
 Servicio al cliente: MEMORIAL HERMANN, MONTEFIORE,
CLOROX, PUBLIX, DHL, ETC.
 Salud: COVIDIEN, GENESIS, BOSTON SCIENTIFIC,
HEALTHPARTNERS, ST VICENTS HOSPITAL, ETC.
 Flujo en edificios: DISNEY, APPLE, GOOGLE, CANNONDESING,
CITY OF HOPE, ETC.
 Minería: RIO TINTO, VALE, ARCELORMITTAL, ALCAN, RUNGE
PINCOCK MINARCO, ETC.
 Eventos discretos: MICHELIN, ATK, WHIRLPOOL, MAGNA,
BOSTON SCIENTIFIC, ETC.

4.3. FLEXSIM
4.3.1. Características y Terminología de FlexSim
El software descrito en este libro contiene la versión libre 19.0.0 actualizada el 03

de enero de 2019, 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 30 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 primera ventana

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

de arranque (Start Page).
Si es seleccionada la opción New

Model se desplegará la Figura 4.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 4.2. Ventana de diálogo

para asignar las unidades de
medida necesarias.
Ventana principal de FlexSim
En la Figura 4.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 el modelo (Quick Properties o Propiedades Rápidas).

Posteriormente, el lector verá la descripción general de cada uno de estos
contenidos.
a) Menú Principal c) Panel de Ejecución de la Simulación

b) Barra de Herramientas
f) Propiedades Rápidas
d) Biblioteca de objetos
e) Área de Trabajo
Figura 4.3. Ventana principal de FlexSim.
a) Menú principal
File. Con el menú mostrado en la Figura 4.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.

– 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
Figura 4.4. Ventana del menú File. 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 4.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 4.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 4.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.
 Open Default Workspace: Esta función restablece al espacio de trabajo
predeterminado en un inicio.
 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), es posible 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.
 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.
 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.
Figura 4.6. Ventana del menú View.

 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.
 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.
 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.
 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 4.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.
Figura 4.7. Ventana

del menú Build.
Execute. Los botones resaltados en la Figura 4.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.


menú Execute.
Statistics. La ventana del menú mostrada en la Figura 4.9, despliega una lista de
alternativas las cuales operan estadísticas del modelo:
– 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.

menú Statistics.
Debug. El menú se basa en herramientas que apoyan la programación en

FlexSim, mismas que se ilustran en la Figura 4.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.

menú Debug.
Help. Por último, la Figura 4.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).
– FlexScript API Reference: Abre el manual de usuario en el submenú
“FlexScript Class Reference” del apartado Códigos en FlexSim, mismo
que lista las diferentes clases que están disponibles en FlexScript, sus
métodos y propiedades.
– Commands: Despliega una lista de comandos donde se resumen sus
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.
– License Agreement: Muestra el acuerdo de licencia entre FlexSim Software
Products, Inc., una corporación de Utah ("FlexSim") y Usted
("Cliente"). Se indica la aceptación a los términos del software.
https://www.flexsim.com/sw/eula/
– 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.

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í se comprenderá cómo
se pueden conectar, seleccionar y crear objetos (véase Figura 4.12).
Figura 4.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 con el 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 – El í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 4.13).
Toolbox. Como se observa en la Figura 4.13, la gama de comandos es amplia y

variada, sin embargo, aquí sólo se describen algunos usos:
 Global Table y Time Table, son submenús los cuales proporcionan y

permiten agregar, borrar y editar tablas globales y tablas de horario en el
modelo, respectivamente.
 El submenú MTBF MTTR, proporciona la funcionalidad de agregar,
borrar y editar Tiempos Medios entre Fallas (MTBF) y Tiempos Medios de
Reparación (MTTR) de acuerdo con los objetos del modelo.
 Dashboard, permite agregar variables gráficas para analizar estadísticas
mientras el modelo es ejecutado.

 Group. 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.
 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.
 Task Sequences List, es una de las diversas
herramientas del comando Global List, la cual
permite al usuario agregar, borrar y editar Figura 4.13. Ventana
secuencias de tareas en el modelo. Toolbox.
 Al desplegar la opción Statistics podrá elegir
entre otras la opción Statistics Collector. La opción Colección de Estadísticos
es usada para observar eventos en el modelo y colectar datos sobre dichos
eventos, la alternativa es especialmente usada para comparar distintos
estados entre objetos, graficarlos o exportarlos.
 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.).
 La herramienta Visual ayuda a administrar los objetos visuales (Model
Floor) que están disponibles en la biblioteca de FlexSim, además, permite
crear o importar un plano de planta (Model Background) con las extenciones
.dxf o .dwg (AutoCAD) y .png, .jpg, .bmp (archivo de imagen).
 Para concluir la descripción general de Toolbox, el botón Connectivity,
despliega las siguientes opciones:
o Database Connector, los conectores de base de datos son usados para
hacer una conección con una base de datos para después importar o
exportar caracteres, incluyendo Microsoft SQL Server, MySQL, Oracle,
PostgreSQL, y otros.
o Excel Import/Export, la interfaz de Excel se diseñó para importar y
exportar hojas de trabajo de más de un libro.
o Emulation, la herramienta Emulación permite crear un enlace entre
FlexSim y PLCs (Programmable Logic Controllers) externos o con
clientes/servidores que se comunican con PLCs para la transferencia
de datos en tiempo real. Esta herramienta puede crear conexiones
múltiples y definir variables para cada una de esas conexiones. La
herramienta admite dos protocolos, OPC DA y Modbus.

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 4.14).
Figura 4.14. Barra, 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.).
Display Mode. Muestra el tiempo en que el modelo se detendrá Seconds o Date

and Time.
Dentro de estas últimas alternativas, al dar clic en Seconds se permitirá

establecer el tiempo de paro requerido en segundos. Asimismo, la alternativa 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). Por otro lado,
también puede asignarse un tiempo de precalentamiento del sistema o Warmup
Time.
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 o viseversa. El valor de 1 es el quivalente al avance
en tiempo real.

d) Biblioteca de Objetos
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. La Figura 4.15 hace un desglose de los diferentes objetos en FlexSim.
FlowItem
Figura 4.15. Biblioteca de objetos.

Como puede observarse, en la ventana Library de FlexSim, se pueden

encontrar tanto objetos necesarios para simulación con cambios discretos como
continuos, los mismos, se clasifican en nueve categorías distintas: Fixed Resources
(Recursos Fijos), Task Executers (Recursos Móviles o Ejecutores de Tareas), Travel
Networks (Redes de Viaje), Conveyors (Transportadores o Bandas Transportadoras),
Visual (Visuales), A* Navigation (Navegación), People (Personas), AGV (Vehículos
Guiados Automáticamente) y Fluids (Fluidos). Además, como ya se mencionó
dentro de menú Barra de Herramientas en el comando FlowItem Bin, también
existen los objetos definidos como FlowItem Bin.
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 (Processor, Queue respectivamente), aquí es donde la
entidad puede sufrir cambios o alteraciones para ser transformada
(MultiProcessor), aquí también se pueden unir, agrupar (Combiner), separar o
cortar (Separator), 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. Para dar ejemplos de estos se enuncian los siguientes:
- 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, el Setup Time (tiempo 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 (Use Transport). 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 FlowItems, 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 acción 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 de 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.

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 (FlowItem).
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.). Existen ocho 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.
Travel Networks, Visual, A* Navigation, People y AGV
El apartado incluye recursos especiales diseñados para tareas específicas que

contribuyen de igual forma al mejor desempeño del modelo.
- Travel Networks
Existen tanto NetworkNodes, como TrafficControls, los primeros 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. El objeto TrafficControl es usado para
controlar el tráfico en un área definida de una NetworkNode.
- 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 estadisticos dinámicos, mismos que se actualizan
mientras el modelo se está simulando y tienen una gran variedad de usos
adicionales como colocación de texto, hora, etc.
- A* Navigation
AStarNavigator (A*) es un algoritmo de búsqueda utilizado para encontrar

un camino entre los puntos. El algoritmo usa una cuadrícula de nodos
por los cuales viajan los recursos moviles. Cada nodo especifica en qué
dirección se pueden mover los recursos, identificando la ruta más corta.
La red de nodos se puede modificarse creando barreras que restrinjen el
espacio dónde los recursos pueden moverse o incluso pueden influir en
ellos para viajar a lo largo de ciertos caminos.

- People
El modulo People integra objetos 3D que representan ubicaciones,

personal, transporte y equipos con los que las personas interactuarán a
medida que avanzan en el modelo. Este modulo de objetos permite
representar, visualizar y analizar sistemas de líneas de espera o teoría de
colas, ya sea de un restaurant, filas de espera aeroportuarias o un sistema
que no produce nada tangible (por ejemplo, tramites administrativos en
dependencias gubernamentales).
La herramienta Process Flow proporciona la lógica para crear, mover,

escoltar y transportar a estas personas a donde necesitan ir, con qué
personal estarán y qué equipo usarán.
- AGV
El modulo AGV incluye recursos que permiten crear rutas de viaje

donde vehículos guiados automaticamente (AGV por sus siglas en
ingles), viajarán utilizando lógicas definidas previamente.
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) Área de Trabajo
Model View Window o Área de Trabajo, se refiere al Layout 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.
f) Propiedades Rápidas
La ventana Quick Properties describe las propiedades tanto del área de trabajo como
de cualquier objeto incluido y seleccionado en el modelo. La ventana muestra las
propiedades más comúnmente utilizadas para el objeto resaltado, estadísticas,
propiedades generales (dimensión, tamaño, forma, entre otras) y etiquetas se
mostrarán para la mayoría de los objetos.
Si las propiedades rápidas se han cerrado, puede abrirlas a través del menú View.
4.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 son un componente crucial en la lógica de un
modelo, dado que permiten almacenar información como variables
personalizadas que se pueden especificar en objetos (FlowItem), tokens u objetos
3D, las mismas permiten rastrear informacion importante e incluso cambiar
dinámicamente la lógica de lo que sucede durante la simulación.
Por ejemplo, si desea realizar un seguimiento del número de piezas

(FlowItems) con identificador de tipo 3 (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

Nota: Un FlowItem otros. Al igual que un ItemType, una Label puede ser colocada en un FlowItem
puede tener tanto una
al inicio, durante o al final del proceso mediante la utilización de algunos
Label como un
comandos como los contenidos en un Trigger. Una misma Label puede tener
ItemType, mientras
que a los objetos diferentes valores para distintos FlowItems (entre estos pueden ser: números,
Fixed Resources y texto o bien tablas con información), esto permite hacer diferencias al manipular
Task Executers sólo la operación de los FlowItems en los objetos y es de suma importancia para
se les puede asignar indicar la ruta, flujo o destino que tomará la entidad en la lógica de un sistema.
Labels. 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 (con chile, con queso
o las papas tradicionales únicamente acompañadas con sal) y su cantidad (25, 50,
ó 100 gramos).
En FlexSim Usted puede utilizar los comandos setlabelnum(), getlabelnum(),

y label() para interactuar con las etiquetas que se hayan creado.
Port Connections
Como ya se mencionó, en un modelo de simulación los FlowItems son operados

por recursos fijos y frecuentemente son apoyados por recursos móviles para ser
transportados de un lugar a otro, pero ¿cuál es el mecanismo utilizado para
lograrlo? Cada objeto en FlexSim tiene un número ilimitado de conexiones a
través del cual se comunica con otros objetos, estas son llamadas Port Connections
(conexiones de puertos) las cuales pueden establecer las condiciones necesarias
entre los objetos para definir un flujo. Hay tres tipos de puertos: Output Port
(puerto de salida), Input Port (puerto de entrada) y Center Port Connection
(conexiones de puerto central). Para establecer una relación entre un Output Port
y un Input Port, es necesario conectar el Output Port de un objeto inicial al Input Port
del objeto siguiente según corresponda al flujo que deben seguir las FlowItems
en el modelo. Así, cada relación de salida-entrada definirá una trayectoria posible
de los FlowItems entre los recursos fijos, dicha trayectoria deberá corresponder
al diagrama de flujo del sistema real. Los puertos de entrada y salida se utilizan
para establecer la ruta de los FlowItems por los recursos fijos y pueden emplearse
también para crear redes de nodos o tránsito (NetworkNodes) necesarias para que
los recursos móviles transporten los FlowItems de un recurso fijo a otro. Las
Center Port Connection se originan en el centro de los objetos, estas relaciones
son empleadas para que un objeto sea capaz de hacer referencia a otro, en FlexSim
es común que un Fixed Resources haga uso de un Task Executers mediante una
conexión de puerto central, tal como la conexión entre un Processor, Queue o

Conveyor con un recurso móvil como: Operator, Transporter o Elevator.
Independientemente de la conexión de puerto empleada, ya sea de

entrada/salida o centro, siempre se hace referencia a un número con el fin de ser
utilizado más adelante. Si se observa la Figura 4.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 abordarán 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 incorporados en el modelo.
Output
Input
Center
Figura 4.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
Nota: para trabajar dejar de presionar la letra del teclado seleccionada, se arrastra el mouse y se da un
correctamente con el clic sobre el segundo objeto determinado. Al hacer esto, se crea automáticamente
uso de las teclas, un puerto de salida y uno de entrada, un puerto central en ambos objetos o una
usted deberá conexión extendida según corresponda a la letra presionada. Para desconectar un
permanecer en la par de objetos dependerá de cómo fueron conectados: si se conectó con la letra
vista ortográfica, de “A” desconectamos con la “Q”, la conexión de la letra “S” se rompe con la letra
lo contrario, las “W” y la conexión “D” con la “E”, la desconexión de objetos obedece al patrón
pulsaciones de tecla anterior por lo que esta acción deberá ser en el mismo orden con el que fueron
no funcionarán hasta
conectados. Ver Figura 4.17.
la segunda vez que se
pongan a prueba.
Esta acción se puede
hacer si se pulsa el
botón derecho del
mouse sobre el área
de trabajo y se
desmarca la casilla
Perspective Projection
contenida en la
ventana derecha de
Figura 4.17. Imagen ilustrativa de conexiones con el uso del teclado.
nombre Quick
Properties. Si
después de esta
acción desea Interacción del teclado
regresar a la vista en
Resulta oportuno mencionar que estas no son las únicas teclas habilitadas en el
perspectiva, es
teclado como apoyo en la construcción de un modelo de simulación en FlexSim.
necesario activar
Existen algunas más y estos son sus usos (Figura 4.18).
nuevamente el
comando Perspective
Projection. Para más
detalles, revise el
siguiente apartado.
Figura 4.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
es empleada básicamente para ocultar en forma sucesiva las conexiones,
nodos y las flechas construidas con NetworkNode. También crea nuevos
puntos de Spline en una red de rutas. Para ver su funcionalidad, mantenga
presionada la letra X del teclado y haga clic sobre uno de los nodos de la
red con el botón izquierdo del mouse.
 B: Visualización de conexiones, nodos y flechas de una red. Su
funcionalidad es totalmente opuesta a la X. Así pues, las conexiones,
nodos y flechas diseñadas por NetworkNode y ocultadas por la activación
de la letra X pueden ser vistas nuevamente al mantener presionada la letra
B y dando clic con el botón izquierdo del mouse sobre el nodo que no
fue oculto. En el objeto TrafficControl también puede ser utilizada esta
tecla.
 V: Visualización de Output Port/Input Port, se utiliza para ver los
nombres de los puertos de entrada y salida de un objeto. Para observar
su funcionamiento, mantenga presionada la tecla V y haga clic en un
objeto con el botón izquierdo del mouse.
 C: Visualización de las conexiones de Puerto Central, se emplea para ver
las conexiones de Puerto Central de un objeto. Presiónela y haga clic en
un objeto con este tipo de conexión y podrá notar los resultados.
 F y R: Estas dos letras se usan para crear objetos y conectarlos a la vez,
dichas funciones fueron explicadas anteriormente en la barra de
herramientas.
 G: Propiedades de conmutación rápida, su activación permite cambiar el
enfoque de la ventana de propiedades de un objeto dentro del modelo.
La vista ortográfica recuerda la última ventana de propiedades que se
abrió. Después de activar la vista ortográfica, mantenga presionada la
tecla G y haga clic en un objeto, la última ventana de propiedades abierta
actualizará su enfoque para el nuevo objeto.
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 Proyection (proyección 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 (véase Figura 4.19). 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.
Perspective Proyection Orthographic View
Views
FlexSim
Data Tree View
Figura 4.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 4.20 ilustra tales acciones.). Si los tres ejes de colores
no se muestran, vaya al menú Edit>Resize and Rotate Objects.
Figura 4.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 puede hacer 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 4.21).

Objeto resaltado
Figura 4.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 4.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.

Task Executers
Fixed Resources
Conveyors
Travel Networks
FlowItem
s
Figura 4.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.

5 CAPÍTULO 5.

Construcción de un
Modelo Básico
5.1 INTRODUCIR LOS OBJETOS DE FLEXSIM

5.2 CONEXIÓN DE PUERTOS PARA DEFINIR EL
FLUJO DE LOS FLOWITEMS
5.3 EDITAR LAS PROPIEDADES DE LOS OBJETOS
5.4 EJECUTAR EL MODELO
5.5 NAVEGACIÓN Y VISTAS ANIMADAS
5.6 REPORTE Y ESTADÍSTICAS DE LOS OBJETOS
5.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!

5.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 5. Construcción de un Modelo Básico. 117
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 con
el 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
5.1.
Figura 5.1. Colocación de Fixed Resources dentro de Model View (3D) tomados de
la biblioteca para construir nuestro primer modelo.
5.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 5.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.
Entradas/Salidas Centro/Centro
Desconector Q W
Conector A S
Vista V C
Figura 5.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 manera 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 5.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 5.3) muestra las configuraciones

disponibles.
5.3. EDITAR LAS PROPIEDADES DE LOS OBJETOS

5.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, Figura 5.3. Vista de
dimensiones, color, etc.). configuraciones.
Todos los objetos en FlexSim tienen atributos y parámetros, estos varían

dependiendo del tipo de objeto, pueden ser editados y modificados. Al dar doble clic
con el botón izquierdo del mouse sobre el objeto de interés o al hacer clic derecho al
objeto y seleccionar la opción "Properties" del menú emergente, se despliega una
ventana de propiedades misma que a pesar de ser diferente para cada objeto, tiene
muchas similitudes con las ventanas de propiedades de otros objetos (las propiedades
también se visualizan dentro del panel Quick Properties al dar un simple clic en el
objeto). Esta ventana, define entre muchas otras cosas 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 5.4, ilustra la ventana de propiedades de un Processor.

Imagen del objeto
Nombre del objeto
Descripción del objeto
Propiedades
Botones del panel
Previo/siguiente
Figura 5.4.
Imagen ilustrativa
Centrar vista del objeto
de la ventana de
Vista de árbol
propiedades de
Ayuda 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. 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. Nota: Algunas
propiedades del
Botones del panel. Son tres y se describen a continuación: objeto se actualizan
de manera inmediata
 Apply (Aplicar) - Aplica al objeto los cambios realizados en la ventana. al cambiarlas en la
 OK - Aplica al objeto los cambios realizados en la ventana y cierra la ventana. ventana. Estos
cambios
 Cancel (Cancelar) - Cierra la ventana sin aplicar los cambios realizados.
permanecerán y no
Previo/siguiente. Son útiles para hacer rápidas modificaciones a las propiedades de se moverán, aunque
sean cancelados. Por
varios objetos de la misma clase. En estos botones se aplicarán los cambios realizados
ejemplo, al colocar
en la ventana del objeto y se podrá cambiar el enfoque de la ventana del objeto
Breakdowns, Labels,
anterior a la siguiente o viceversa. al modificar la
apariencia, posición,
Centrar vista del objeto: La herramienta ubica a los recursos en la posición central
rotación, tamaño y
del área de trabajo. puertos.
Vista de árbol. Este botón abre una ventana que muestra sólo el árbol de edición
del objeto.
Ayuda. Al pulsar este botón se abrirá el manual de usuario en la página que describe
la ficha que se encuentre seleccionada.
Más detalles sobre la edición de objetos se revisarán en los ejemplos

complementarios.

5.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
5.5.
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
Figura 5.5. Configuración del tiempo de opciones:
llegada de los frascos de yogurt al sistema.
- 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 Model.find("Operator1")
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 5.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
ventana emergente para editar las
propiedades del ConveyorType1,
localice el campo de texto
denominado Speed.
Figura 5.6. Configuración de la velocidad de
avance y la 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 5.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 5.7. Configuración

tiempo del proceso de la
máquina etiquetadora.

5.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 4.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.
5.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 4.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.
5.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 5.8.
Informe Resumido
Informe del Estado Opciones
Documentación
del Modelo
Figura 5.8.
Ventana de
informe y Generar Reporte
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 5.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.

5.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 5.10 como referencia para crear el modelo,
recuerde que será necesaria una línea como esta para cada tipo de cliente.
Nota: usted
necesitará tres
líneas como estas
para representar su
modelo.
Figura 5.10. Diagrama de flujo del problema.
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 5.11:
Figura 5.11. Diagrama 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 Compra
de 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

6 CAPÍTULO 6.

Construcción de un
Modelo Paso a Paso
6.1 DESCRIPCIÓN DEL CASO DE ESTUDIO

6.2 PASO 1. DISEÑO Y CONEXIÓN DEL MODELO PRELIMINAR
6.3 PASO 2. ITEMTYPE Y ESTRATEGIAS DE RUTEO (SEND TO
PORT), DESDE EL SOURCE HASTA EL SINK
6.4 PASO 3. EDICIÓN Y COMPORTAMIENTO DE OBJETOS
(INTER- ARRIVALTIME, DEMPIRICAL, TRIGGERS, LABELS,
FLOWITEM BIN Y PROCESS TIME)
6.5 PASO 4. AÑADIENDO TASK EJECUTERS (OPERATOR Y
DISPATCHER) AL MODELO
6.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.

6.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 6. Construcción de un Modelo Paso a Paso. 139
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 tienen 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

6.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 6.1, e intente colocar los
recursos tal como se observa. Antes de continuar, guarde este modelo con el
nombre de Ejemplo 2.
Figura 6.1. Vista

preliminar del modelo
a construir.
Conveyor
El Conveyor 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 6.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 6.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.
Control verde Controles rojos
Transfers
Dirección
Exit Transfers Entry Transfers
Figura 6.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.
6.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 listas 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 una
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 primera 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 (Processor1) 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.
6.4. PASO 3. EDICIÓN Y COMPORTAMIENTO DE OBJETOS

(INTER- ARRIVALTIME, DEMPIRICAL, TRIGGERS, LABELS,
FLOWITEM BIN Y PROCESS TIME)
6.4.1. Iniciemos con la Programación del Source:
1. Para que las piezas lleguen al sistema exponencialmente cada 30

segundos (figura 6.2.1), es necesario entrar a la ventana de propiedades
del Source. En la primera pestaña, ubique la lista de selección de
opciones Inter-Arrivaltime, seleccione Statistical

Distribution>exponential y coloque los valores (0, 30, 0).
Figura 6.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 6.3.
Nombre de la tabla
No. Columnas
Porcentajes No. Filas
No. De ItemType
Figura 6.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 6.4,
donde quedo asignado el comando.
Figura 6.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 6.5,
muestra el ejemplo de otra
Figura 6.5. Pestaña Triggers de un Processor.
pestaña Triggers, pero esta vez 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 6.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 6.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 6.7. Ventana de diálogo

para asignar ItemType y un color.
Figura 6.6. Lista
típica de selección
de opciones de un
OnEntry.
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 6.8. La segunda Label (Pieza Defectuosa) será definida dentro de la ventana
de propiedades de la banda transportadora.
Figura 6.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 primera 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 primera 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 6.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 6.9.
Pick List Ejemplo de los
distintos usos de
una Pick List.
Popup
Ventana Edición de Códigos
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:
Conveyor.DecisionPoint current = param(1);

Object item = param(2);
Conveyor conveyor = param(3);
Conveyor.Item conveyorItem = conveyor.itemData[item];
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, compilador C++ o mediante código DLL-Linked.
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:
Conveyor.DecisionPoint current = param(1);
Object item = param(2);
Conveyor conveyor = param(3);
Conveyor.Item conveyorItem = conveyor.itemData[item];
{
treenode involved = item;
string labelname = "Pieza Defectuosa";
double newvalue = 2;
setnodenum(assertlabel(involved,labelname,DATATYPE_NUMBER),newvalue);
}
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 6.10.
Figura 6.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 6.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).
Salida
Transporte
Entrada
Figura 6.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
Figura 6.12. La imagen

muestra las distintas
categorías elegibles en
Send To Port.
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

6.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.
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 Processor4
procese únicamente las piezas
Figura 6.13.
con el ItemType 1, el Processor5
Programación del
manipulará a las piezas con el
flujo de los
ItemType 2 y así
FlowItems mediante
la clasificación consecutivamente. Véase figura
Values By Case. 6.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 Figura 6.14. Programación de prioridades de en una línea
las piezas que tengan la de espera.
etiqueta “Pieza
Defectuosa”.
Finalmente, de clic en
Apply y Ok. Véase figura
6.14.

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
Figura 6.15. Tiempos de proceso variados.
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 6.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 a un equipo, este será
valorado 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 6.16.
Figura 6.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.

6.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
Figura 6.17. Conexión de un Dispatcher.
acuerdo a como estas vayan
apareciendo, pero los
modeladores pueden especificar sus propias estrategias en el Dispatcher si así lo
desean. Para configurar un equipo de recursos móviles como se muestra en la figura
6.17, arrastre un Dispatcher y dos o más Operators al área de trabajo. Conecte con la
tecla “A” presionada, al Dispatcher con los Operators. A continuación, conecte con Nota: conecte del
la tecla “S” presionada, al Dispatcher con el primer Queue. Para terminar, entre a la Dispatcher a los
ventana de propiedades del Queue y en la pestaña Flow active Use Transport. Ahora Operadores no al
que hemos terminado, el equipo de recursos móviles funcionará adecuadamente. Si revés, de lo
desea intentar diferentes configuraciones, puede agregar o quitar recursos móviles en contrario los
su modelo en cualquier momento y ver cuáles son los resultados. Con la misma Operators no se
facilidad con la que conecto Operators puede conectar cualquier otro recurso móvil. moverán.

6.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
6.18. Finalmente analice la
tendencia de los puntos rojos y
trate de pensar en una solución
a este problema.
Figura 6.18. Utilización del gráfico Time in
System dentro del modelo de simulación.
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 6.19. Estadísticos de

algunos recursos y gráfica de
pastel que muestra sólo 8
estados de los 51 disponibles
en un objeto.

Figura 6.20. Imagen ilustrativa del modelo final.

7 CAPÍTULO 7.

Aplicaciones y Usos
Variados
7.1 INTRODUCCIÓN
7.2 EJEMPLO: 1.1. SISTEMAS PULLED O PUSHED Y EL USO DE LA
DISTRIBUCIÓN BERNOULLI
7.3 EJEMPLO: SISTEMA DE ENRUTAMIENTOS COMPLEJOS
7.4 EJEMPLO: LÓGICA FLEXSCRIPT Y PRIORIDAD DE USO
7.5 EJEMPLO: LOS OBJETOS TASK EXECUTERS Y LA
INTERRUPCIÓN DE TAREAS
7.6 EJEMPLO: RECURSOS MÓVILES Y RUTAS DE VIAJE
7.7 EJEMPLO: USO DEL RECURSO COMBINER E IMPORTACIÓN
DE DATOS DE EXCEL
7.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.

7.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 distintos
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.
7.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
en el ItemType de un FlowItem.

Capítulo 7. Aplicaciones y Usos Variados. 171
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.
7.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.

7.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 7.1, guarde el modelo con el
nombre de Ejemplo 3.
Figura 7.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 donde
podrá identificar los colores para los Figura 7.2. Programación del Source.
dos distintos ItemTypes creados con

la distribución Bernoulli. Asigne un color para cada ItemType y dé clic en Apply y

Ok. Véase la figura 7.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 7.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 7.3. Programación

del tiempo de proceso y
estrategia Pull.

7.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.
7.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
tipo de datos son comandos empleados para hacer referencia a una Label.
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 7.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.
Nota: tanto los

puertos de entrada
como los de salida
de las diferentes
estaciones deberán
estar conectados al
Queue.
Figura 7.4. Distribución y conexiones de los puertos del modelo.
Asegúrese de que su diseño luzca exactamente como el que se muestra en la

figura anterior. El primer procesador debe estar conectado en el puerto de salida uno
del Queue, el segundo procesador en el segundo puerto de salida, y así sucesivamente
hasta que el Sink se encuentre en el sexto puerto de salida.

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 autoincrementará 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 7.5.

Figura 7.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 7.6).
Recuerde que los datos insertados en las celdas de esta tabla representan los números
de cada puerto. Por ejemplo, si el valor es 1 se indica que el producto deberá salir por
el puerto uno con dirección a la “Estacion_1”, si es 3 el producto saldrá por el puerto
tres y llegará a la “Estacion_3” y así en suceción hasta que el producto salga del
sistema por el puerto 6 con dirección al Sink.
Figura 7.6.
Propiedades de la tabla
global.

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 7.7.
La segunda instrucción
importante dentro del Queue
debe programarse en la pestaña
Figura 7.7. Comando
Flow. Aquí es donde se indicará
que incrementa una
la salida de los distintos
unidad en la Label
productos a las diferentes
“Etapa” cada vez que
estaciones de trabajo según
un FlowItem entre al
Queue. 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
7.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.
Nombre de la Tabla Global.
Comando necesario para referenciar la Figura 7.8. Asignación

posición de la fila dentro de la Tabla de productos a las
Global.
distintas estaciones de
Comando necesario para referenciar la trabajo mediante la
posición de la columna dentro de la
Tabla Global. instrucción Send To
Port.
1. ¿Es posible cambiar todos los FlowItems dentro del modelo a un color
común en función de su etapa de operación?
La respuesta a esta pregunta es “Sí”. Para hacerlo regrese nuevamente al Queue,

busque la pestaña Triggers, y dentro de la lista OnExit seleccione Set Color By Case.
Agregue los comandos necesarios como se muestra en la figura 7.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 7.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 7.10.), abra la
ventana de propiedades del Source y en la primera 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 7.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.

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

7.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., 2018, 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, f o r , 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 una 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 principio 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 7.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 7.11. Ilustración

del modelo concluido.

Programación
En la ventana de propiedades del

Source (figura 7.12), deberá
programar 20 lotes con 5 piezas
cada uno, esta acción la puede
encontrar en el menú Arrival
Style>Arrival Sequence y al
pulsando el botón Refresh Arrivals
se postrarán los cambios.
Figura 7.12. Programación del 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 Sampler. Este
comando está disponible en cualquier
lista de selección de opciones que
solicite el uso de un operador. Abra la
Nota: indique al
ventana de propiedades de Queue y
operador
busque la pestaña Flow, active el botón Figura 7.13. Referenciando a recurso
transportar tres
piezas a la vez.
User Transport y, habilite la herramienta móvil OPERADOR_1.
Sampler, de clic izquierdo sobre el
OPERADOR_1. Véase la figura 7.13.

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 primera
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.
Nota: La distancia máxima entre el ALMACEN_1 y 2 deberá ser de 3 metros.

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 7.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 móvil
mediante una
conexión de puerto
central y a través de
la opción Direct
Reference, pero
ahora se mostrará
Figura 7.14. Programación del tiempo de preparación, una tercera
tiempo de proceso, asignación de operario y prioridad de las alternativa.
tareas para la MAQUINA_1.

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

7.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 7.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
Figura 7.15.
Diseño final del
ejemplo 6.
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.
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 7.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 desplazará 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, para
introducir una secuencia de
Figura 7.16. La ventana de
tareas antes de que la primera
propiedades del Transporter
termine.
es parecida a la que
 Dispatcher Pass To: Permite muestran todos los recursos
crear estrategias para móviles. La pestaña inicial
compartir tareas a otros se clasifica en dos secciones,
recursos móviles. Si hay más la primera permite
tareas que números de manipular las propiedades y
recursos móviles, las tareas operación del recurso móvil,
son colocadas en una línea de y la segunda aborda su
espera y serán asignadas hasta comportamiento respecto a
que un recurso móvil esté la ejecución de tareas.
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 7.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 7.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.
7.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.

7.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 7.18). Lo anterior
creará una conexión con una línea negra, observe que a 1/3 y 2/3 de distancia están
dos flechas encontradas. Las flechas verdes indican que un recurso móvil puede
avanzar en ambas direcciones (Passing), el color amarillo señala un camino sin paso
(Non-passing) y el rojo significa que no existe una conexión (No Connection). Entonces,
si las dos flechas son de color verde la conexión se considera como bilateral y si
alguna de las flechas es roja se bloquerá el acceso en algún sentido, por lo que la
conexión será unilateral. Para cambiar estos colores, puede hacer clic derecho sobre
el punto verde y en la ventana emergente seleccione otra opción.
Figura 7.18. Conexión

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

Nota: al dar clic

presionando la tecla
“X” pero sobre los
puntos Spline el
resultado será un
incremento de
puntos Spline sobre
la curva.
Figura 7.19. Curva

y sus puntos de
control Spline.
Una vez configurada y definida la trayectoria, los recursos móviles podrán

utilizar la ruta trazada. Si desea que esta no sea visible mientras el modelo es ejecutado,
presione la tecla “X” y dé múltiples clics sobre algún NetworkNode.
Concepto 3: Tiempo de viaje
El tiempo requerido para que un recurso móvil viaje entre dos nodos de la red es
igual a la distancia existente entre los nodos dividida entre la velocidad a la que viaja
el recurso móvil (suponiendo que no hay aceleración o desaceleración). La Current
Distance está dada en términos de unidades de la red y marca la distancia entre dos
nodos elegidos. La figura 7.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.
Conexión del
NN1 al NN2

Distancia actual
de propiedades del
NN1. Para tener acceso
Distancia virtual 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 7.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 7.21. Diseño final del modelo 7.
7.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.
7.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 importar o exportar datos de multiples hojas de
trabajo de más de un libro de Excel a FlexSim, en lugar de crear Tablas Globales
complejas. Para los usuarios avanzados que desean hacer importaciones
personalizadas, FlexSim proporciona comandos integrales con un lenguaje propio
para el modelado. También es posible hacer una interfaz gráfica agradable que
configure tanto la importación de una sola hoja, así como de varias hojas a la vez. El
presente modelo ilustra la utilización de la herramienta Excel 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 7.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 7.22.
ArrivoOrdenes:
Frecuencia de llegada,
nombre de la orden y
cantidad de órdenes
solicitadas.
Figura 7.23.
ProductosOrden:
Diferentes órdenes de
clientes con diferentes
productos por cada
orden.
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 7.22 y 7.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 la agenda de la frecuencia de llegada, el nombre de la orden y la cantidad
de órdenes solicitadas, como ArrivoOrdenes, la hoja que contiene las órdenes de los
diferentes clientes con sus respectivos productos solicitados, llámela ProductosOrden.
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 Excel

Interface lo primero que debe hacer es agregar “tablas destino” a la interfaz Table to
the Excel Import, 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 the
Excel Import ( ). Al momento de dar clic izquierdo, se mostrará una ventana con
una nueva línea de importación de datos de nombre “ImportLine1”. En la figura
7.24, es posible observar 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.
Para establecer el libro de Excel que se desea importar, haga clic en el botón
examinar ( … ) ubicado al lado derecho de la lista Excel Workbook. Esta acción
abrirá un explorador de archivos mismo que permite elegir el archivo de trabajo de
Excel para copiar los datos necesarios. 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 “ArrivoOrdenes”).
Libro de Excel importado
Nombre de la
hoja de Excel
Tabla destino para

importación de datos
Coordenadas de posición
inicial, y total de filas y
columnas
Figura 7.24. Excel
Interface: Interfaz de Excel
para importar y exportar
bases de datos.
La siguiente lista desplegable Table Data, 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. Por el momento deje la opción
predeterminada como Source_Pallet (Source Arrival Schedule). Finalmente, active el uso
de encabezado de filas (Use Row Headers) y columnas (Use Column Headers), 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 3 para indicar el inicio de la lectura de datos en la columna C (o
columna 3) y hasta un total de 3 columnas. Una vez que tenga la interfaz configurada,
haga clic en el botón Import Tables (ubicado en la parte inferior izquierda de la
ventana Excel Interface), 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, observe
la ventana de propiedades del Source_Pallet y revise que automáticamente en la tabla
de Excel se han añadido los datos correspondientes. La siguiente figura 7.25 muestra
los resultados de la primera configuración empleando el importador de datos de
Excel.
Nota: aprovechando que está dentro del objeto Source_Pallet, indique el uso de
FlowItem Pallet en lugar de Box dentro de la lista de selección “FlowItem Class”.
Por otro lado, es importante indicar en la pestaña Trigger del objeto Source_Pallet la
agregación de etiquetas (ItemType) a cada Pallet. Es decir, es necesario que el Pallet
con el ItemType número 1 represente la OrdenHidalgo, con el número 2 se deberá
representar la OrdenQueretaro, con el número 3 la OrdenPuebla, y asi sucesivamente.
Para lograr lo antes dicho, en la pestaña Trigger de clic izquierdo en Add a new trigger
y elijase la opción On Creation. Posteriormente en la nueva lista de selección de
opciones creada elija Data, Set Item Type, y finalmente dentro del recuadro Type
seleccione rownumber.
Figura 7.25. Programación

del Source_Pallet con
importador de datos de
Excel (ImportLine1).

La segunda tabla de Excel (figura 7.23.) será definida dentro de una Global
Table, dicha acción permitirá programar correctamente los diferentes productos que
contendrá cada orden solicitada por los clientes. Para realizar tal acción, 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
Excel Import/Export ( ), mismo que se encuentra a la derecha, en la ventana
Quick Properties.
Hecho lo anterior, es necesario que repita el procedimiento previo a la

importación de datos de Excel pero en la nueva línea de importación (ImportLine2),
aquí, es necesario vincular a la hoja de Excel llamada ProductosOrden con la tabla de
datos “Tabla Global_1 (Global Table)”. Una vez terminada la configuración, importe
los datos de Excel y no olvide verificar que los datos se hayan agregado correctamente
dentro de la Tabla Global. En este ejercicio el nombre de la tabla es “Tabla Global_1”,
misma que fue creada anteriormente.
Combiner
Dentro de la ventana de propiedades del Combiner en la pestaña Combiner se

encuentran las opciones principales que describen el comportamiento de este objeto:
Pack, Join y Batch, aquí mismo se encuentra la tabla Components List la cual se
actualiza automáticamente cada vez que es conectado un nuevo puerto de entrada al
Combiner (véase la figura 7.26). Tenga en cuenta que la primera columna muestra en
orden ascendente los puertos de entrada iniciando con el puerto 2, esto indica al
Combiner suministrar FlowItems de todos los puertos a partir del número 2. Como
puede ver, el puerto 1 no se agrega a la lista, 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 de entrada 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 de entrada 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 7.26, es
necesario entonces que vincule al Combiner con la Tabla Global que ahora contiene
los datos de las órdenes definidas en Excel. Esto se puede hacer dentro de la pestaña
Triggers del Combiner, al elegir de la lista de selección de opciones OnEntry el comando
Update Combiner Component List. Aquí dentro sólo es necesario elegir el uso de
la tabla " Tabla Global_1" y posteriormente dar clic en Apply y Ok.
Nota: los cambios

en la tabla de
nombre
Components List,
se actualizan
conforme a la tabla
Tabla Global_1 al
dar Reset y ejecutar
el modelo.
Figura 7.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
distinto. Lo dicho, se puede realizar dentro de la pestaña Triggers de cada Source.

Para no saturar el modelo de una cantidad excesiva FlowItems es importante

limitar la capacidad de los objetos Queue a una capacidad máxima de 50 unidades, el
resto de los recursos no requieren modificaciones, así que con esto se ha terminado
la programación del modelo.
Figura 7.27. Presentación

del modelo final.
Por otro lado, si desea tener conocimiento del número de ordenes

procesadas por cada cliente podría agregarse una gráfica o tabla de datos tipo
Dashboard. Cree una nuevo Dashboard, busque dentro del apartado WIP Templates
el recurso “WIP By Type” y agregelo a la ventana emergente. Posteriormente, dentro
de la ventana de propiedades de la nueva tabla indique la referencia del recurso
Combiner como objeto de entrada (Entrance Objects), y sustituya el texto de los
recuradros Type Display y WIP Display por “Cliente” y “OrdenesProcesadas”,
respectivamente. Con ello podrá visualizar el número ItemType correspondiente con
la cantidad de ordenes que se han procesado dentro del objeto Combiner mientras el
modelo es ejecutado.

7.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)
7.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 primera 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 reanudará 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 (7.28 y 7.29):

de la herramienta
MTBF/MTTR.

Split
Indicador de
mantenimiento
UnPac
k
Figura 7.29. Presentación

del modelo final.

8 CAPÍTULO

8.Un Modelo
Fluidos
de
8.1 SIMULACIÓN DE FLUIDOS

8.1.1 Descripción del Caso de Estudio
8.1.2 Descripción de los Objetos del Modelo
8.1.3 Descripción de Términos para el Modelado de Fluidos
8.2 CONSTRUCCIÓN DEL MODELO
8.2.1 Conexión de Objetos
8.2.2 Configuración de los Objetos
8.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á:
5. Modelar fácilmente Materiales Fluidos.

6. Convertir FlowItems en Material Fluido y Material Fluido en FlowItems.
7. Transferir y almacenar Material Fluido.
8. Utilizar marcas de nivel para mantener el control de volumen en los
tanques contenedores.
9. Podrá mezclar tanto Materiales Fluidos como Discretos.

8.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., 2018). 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.
8.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 8. Un Modelo de Fluidos 223
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 8.1 y 8.2).
Figura 8.1. Diagrama

de flujo de producción
de postres.
8.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.
 La unidad 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.
8.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.
8.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 FluidMixer1 (Fluid Objects).
 1 FluidProcessor de nombre FluidProcessor1 (Fluid Objects).
 1 FluidToItem de nombre FluidToItem1 (Fluid Objects).
 3 Conveyors de nombre Conveyor1, Conveyor2 y Conveyor3 (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).

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 19.2.4 podrá darse
cuenta de 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 atender las observaciones de la última nota mencionada
en el apartado 8.2.2 “Configuración de los objetos”.
8.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 8.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 FluidMixer1
– Del FluidMixer1 al FluidProcessor1
– Del FluidProcessor1 al FluidToItem1
– Del FluidToItem1 al Conveyor2

– Conectar también del Almacen3 al Conveyor1 y del Conveyor1 al Combiner

– Del Conveyor2 al Combiner1 donde se espera la llegada de frascos
– Del Combiner1 al Conveyor3 y finalmente al Sink1
Lo anterior se repite con una línea de conexiones paralela, pero desde el

Almacen2 al FluidMixer1.
Nota: no se
El Almacen1 y el Almacen2 llaman a un operador distinto para transportar los
preocupe ahora por
FlowItems hasta los ItemToFluid1, ItemToFluid2, respectivamente, por lo que los
la estética de su
Operators deberán tener una conexión de puerto central tanto del Almacen1 como
modelo, ya que
del Almacen2, (véase la figura 8.2).
cada objeto tomará
forma mientras se
avanza en la
programación del
mismo.
Figura 8.2. Vista previa del modelo completo.
8.2.2. Configuración de los Objetos
Configuración de los Sources (ver figura 8.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 lleven

los FlowItems creados hasta los dos objetos ItemToFluids (Use Transport de la pestaña
Nota: si desea
Flow). Respecto al Almacen3 sólo es necesario escoger de la lista de selección de
cambiar el color de
opciones FlowItem Class la alternativa Cylinder para representar a los frascos.
los FlowItems
Finalmente, en este mismo Source se debe configurar el campo Inter-Arrivaltime a
puede usar el
1.5 segundos.
comando Set Object
Color de la opción
OnExit de la
pestaña Triggers.
Figura 8.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 Figura 8.4. Ventana de propiedades del
ItemToFluids1.

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 8.4:
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,
posteriormente una tabla de colores aparecerá. Seleccionar el 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 de leche) y
los de la otra línea de color verde (línea de 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
8.5).
Repetir estos pasos para el

ItemToFluid2, no olvide
cambiar su capacidad máxima a
20 litros e indicar la necesidad
de crear 5 litros de fruta por
cada FlowItem (cubetas de
preparado de fruta) que entre al
Figura 8.5. Configuración de proporciones, ItemToFluid2.
velocidad y capacidad del objeto
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 las líneas se deberán realizar los
siguientes pasos (ver la figura 8.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.

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 abiertos. 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 8.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 8.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 8.7.
6. Para finalizar dé clic en Apply y Ok.

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.

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 se hace 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 1 a un valor de 5 segundos y el tiempo de retardo
para el paso 2 a un valor de 0 segundos (observar la figura 8.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.
 Dentro de
PreparadoDeFruta, ajuste
Figura 8.8. Configuración el Port a 2, Amount a 3, y
de la entrada y mezcla de
Step a 2.
ingredientes dentro del
FluidMixer.
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 (de la pestaña Steps) en
cualquier punto del tiempo
simulado. Esta herramienta se
encuentra visible por defecto,
pero se puede ocultar si hace
clic dentro del recuadro Draw
Level Indicator. Si es asignado el
valor de 1 en el campo “Y” de
la fila posición, la barra
indicadora pasará al frente del Figura 8.9.
Mixer. De la misma forma Configuración del
puede manipular el resto de los indicador de nivel del
campos hasta conseguir un FluidMixer.
efecto más realista (véase la
figura 8.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 8.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.
Nota: dentro de
este objeto puede
cambiar el aspecto
del FlowItem de
salida tal como su
forma, tamaño,
color, etc.
Figura 8.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

objeto que en todo momento sólo puede recoger material fluido suficiente
para 1 FlowItem. Si este valor es mayor, el FluidToItem formará una línea
de espera y con ello se creará demasiado espacio de almacenamiento en el
modelo.
Nota: observe que
3. En la pestaña Triggers de este mismo objeto, es posible asiganrle un nombre
el Conveyor usado al nuevo FlowItem. En OnExit>Data>Set Name, agregese la palabra
es diferente al “Postre”. Así, todos los nuevos FlowItems serán llamados Postre.
mostrado en el 4. Dar clic en Apply y acontinuación en Ok para guardar los cambios.
Ejemplo 2 del
Capítulo 4, para
activar este nuevo Configuraciones finales. Una vez terminada la configuración del objeto
Conveyor diríjase al FluidToItem, se programan los siguientes objetos:
menú File>Global
Preferences>Environme  Para este modelo, los Conveyors se mantienen con sus propiedades de
nt y active la casilla inicio, pero deberán ser indicadas sus dimensiones y dirección hasta lograr el
“Display Legacy diseño deseado.
Conveyours in the
 Al objeto Combiner llegan tanto FlowItems (frascos) como FlowItems
Library”. El nuevo
(Postres). Para que la velocidad de envase sea de 3,600 frascos por hora, en
objeto se mostrará
en la ventana el campo Process Time de la ventana de propiedades del Combiner, coloque el
Library para su uso. valor de 1 para indicar que sea envasado un frasco por segundo. En la
pestaña Combiner elegir el modo de combinar Join para visualizar en la salida
sólo un producto. Para concluir la programación de este objeto, en la pestaña

Triggers, puede cambiar el color de los frascos de salida a un color verde.

 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.
8.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 8.11).
Figura 8.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 primera 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. 241
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) l l e g a n c a d a 5 s e g u n d o s e x p o n e n c i a l m e n t e a u n
s i s t e m a d e 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”.

10. 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.
11. 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.

12. 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”.
13. 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 F. 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, pp. 1-26.
Banks, J.; Carson, J. S.; Nelson, B. L.; Nicol, D. M. (2009). Discrete-Event
System Simulation, (5a ed.). U.S.A.: Prentice-Hall.
Barceló G. M. (2008). Una Historia de la Informática, Rambla del Poblenou,
Barcelona, Editorial UOC, pp. 77-80.
Beaverstock M.; Greenwood A. G.; Lavery E.; Nordgren W. (2018). Applied
Simulation Modeling and Analysis using FlexSim, (5a ed.). USA: Orem,
UT.: FlexSim Software Products, Inc.
Bernard Z. (1976). Theory of Modeling and Simulation, (1a ed.). USA: New
York: John Wiley & Sons.
Bernard Z.; Tag G. K.; Herbert P. (2000). Theory of Modeling and Simulation,
(2a ed.). USA, 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.
Caso A. (2006). Técnicas de Medición del Trabajo, (2a ed.). España, Madrid:
Fundación Confemetal.
Coss B. R. (2003). Simulación: Un enfoque práctico, (20a ed.). México, D.F.:
Limusa, 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. (2019). Improve performance. Save money,
Who is using FlexSim? Fecha de última consulta, marzo de 2019.
http://www.flexsim.com/
García D. E.; García R. H.; Cárdenas L. E. (2006). Simulación y Análisis de
Sistemas con ProModel, (1a ed.). México: Prentice Hall - Pearson
Educación., pp. 1-13.
García R. (2005). Estudio del Trabajo Ingeniería de Métodos y Medición del
Trabajo, (2a ed.). México: McGraw-Hill, Inc.
Henrisken, J. O. (1983). The Integrated Simulation Environment, Operations
Research, Vol. 31, No. 6, November-December 1983, U.S.A., pp. 153-
1073.

Kelton, W. D.; Sadowski, R. P.; Sturrock D. T. (2008). Simulación con Software

Arena, (4a ed.). México: McGraw-Hill, Inc.
Lakshmanan R. (1983). Desing and Implementation of a PASCAL Based
Interactive Network Simulation Language for Microcomputers,
unpublished Ph.D. dissertation, Oakland University, Rochester, Michigan.
Law, A. (2007). Simulation Modeling and Analysis, (4a ed.). USA: McGraw Hill,
Inc.
Law, A. M.; Associates, Inc. (1995-2011). ExpertFit Version 8 User’s Guide.
Introduction to ExpertFit. USA, AZ: Averill M. Law.
Law, A. M.; Associates, Inc. (2011-2019). ExpertFit –The leading distribution-
fitting software since 1983. USA, AZ. Fecha de última consulta, junio de
2018.
http://www.averill-law.com/distribution-fitting/
Marcowitz H. M.; Bernard H.; Herbert W. K. (1963). SIMSCRIPT: A Simulation
Programming Language, The RAND Corporation: Prentice Hall.
Montgomery, C. D.; Runger C. G., (2009). Probabilidad y Estadísticas
Aplicadas a la Ingeniería, (2a ed.). México: Limusa Wiley.
Nance R. 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.
Niebel, W. B; Freivalds A. (2009). Ingeniería Industrial, Métodos, Estándares
y Diseño del Trabajo, (12a ed.). México: McGraw-Hill, Inc.
Richarrdson, W. J.; Pape, E. S. (1992). Work Sampling, en Handbook of
Industrial Engeineering, (2a ed.). Gavriel Salvendy. USA, Nueva York:
John Wiley & Sons.
Tocher, K. D.; Owen D. G. (1960). The Automatic Programming of
Simulations, Introceedings of the Second International Conference on
Operational Research, pp.50-68.
Von N. (1992). John Von Neumann y los Orígenes de la Computación
Moderna. William Aspray - Gedisa Editorial.
Walpole, R. E.; Myers, R. H.; Myers, S. L.; Ye K. (2012). Probabilidad y
Estadística para Ingeniería y Ciencias, (9a ed.). México: Pearson
Educación.
Wexelblatt R. 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 W. L. (2005). Investigación de Operaciones Aplicación y Algoritmos,
(4a ed.). México: Thomson Learning, pp. 1-273. 1145-1158.

Isaías Simón
De nacionalidad mexicana, es Ingeniero Industrial por el Instituto

Tecnológico Superior del Occidente del Estado de Hidalgo (ITSOEH).
Tiene una Maestría en Ingeniero Industrial por la Universidad Autónoma
del Estado de Hidalgo (UAEH) y el grado de Doctor en Manufactura
Avanzada por el Centro de Tecnología Avanzada (CIATEQ).
Es actualmente Coordinador de la carrera de Ingeniería Industrial de la

Escuela Superior de Ciudad Sahagún (UAEH), destacando actividades de
gestión, vinculación y administración a nivel académico, además, es
Profesor Investigador de la misma institución. Sus intereses de
investigación actuales son hacia la ingeniería de sistemas productivos,
simulación de sistemas y los sistemas de manufactura inteligentes
Además colabora como:
 Catedrático – en la UAEH y el Instituto Tecnológico de Pachuca

(ITP);
 Catedrático – en el Doctorado y Maestría en Manufactura Avanzada
(CIATEQ-CONACYT), y en la Maestría en Gestión y Desarrollo de
Nuevas Tecnologías (UAEH); y
 Director de 3D Random-Systems Simulation, grupo de ingeniería
dedicado a la toma de decisiones con tecnología de punta en
simulación de sistemas productivos y de servicios con la herramienta
FlexSim.
Correo electrónico del autor: isaias.simn@gmail.com

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/

Un Primer Paso A La Simulacion Con Flexsim - I. Simón Marmolejo

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Un Primer Paso A La Simulacion Con Flexsim - I. Simón Marmolejo

Cargado por

Copyright:

Formatos disponibles

Un primer paso a la

Segunda Edición FlexSim Express

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

ISAÍAS SIMÓN MARMOLEJO

Estados Unidos México España Argentina Bolivia Chile

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

Bibliografía: Simón-Marmolejo, I.; M. Authorized by:

Simón-Marmolejo, I.; Ortiz Domínguez, M.

Correo electrónico del autor: isaias.simn@gmail.com

1er. edición: Julio 2016

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

En memoria de doña Sofía Mendoza Ruíz y Esperanza Mota Porras quienes me

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

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

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

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 abordan

Dentro del 2do. Capítulo de nombre “Muestreo y Distribuciones de

El 3er Capítulo “Identificación de Distribuciones con ExpertFit”, describe

Respecto al tema “Del Software FlexSim” contenido en el 4to Capítulo, se

Para iniciar con la creación de un modelo, el 5to. Capítulo “Construcción

Con intención de plantear un escenario más completo, el 6to. Capítulo

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

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

En los modelos venideros se ilustra la manera de manipular material que se

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

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á

 Windows 8 o 10 (con 64-bit).

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

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

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

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,

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

1.1. DEFINICIÓN DE SIMULACIÓN

Para el desarrollo del presente trabajo resulta conveniente iniciar definiendo el

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

El primer simulador fue GSP (General Simulation Program) acreditado

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

adaptado especialmente al cálculo numérico y a la computación científica,

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

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

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

1.2.1. 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 la simulación orientada a objetos en 3D con el software

Dado que las alternativas para el desarrollo de un proyecto de simulación

1. Permitir un uso simple y entendible. Los manuales, libros o tutoriales del

Prepared exclusively for carlos.andres.marin.ram@gmail.com Transaction: 0061314885

5. El software también deberá permitir la programación de rutinas diferentes a

1.3. MODELO DE SIMULACIÓN

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