Fase Uno-Modelizacion-y-Simulacion-Libro-de-Practicas-Con-Simio-edited PDF

Modelización y Simulación:
Libro de Prácticas con SIMIO
Jeffrey Allen Joines

Stephen Dean Roberts
North Carolina State University
F. Javier Otamendi
Universidad Rey Juan Carlos, Madrid,
ISBN: 978-0-9829782-4-5
Modelización y Simulación: Libro de Prácticas
con SIMIO
Jeffrey Allen Joines
Stephen Dean Roberts
Raleigh, North Carolina
F. Javier Otamendi
Universidad Rey Juan Carlos
Madrid, España
Noviembre 2017
Edición 3.1
Spanish Electronic Book ISBN: 978-0-9829782-4-5
Published by SIMIO, LLC, (http://www.simio.com)
Modelización y Simulación: Libro de Prácticas con SIMIO

Tabla de Contenidos
Los autores ................................................................................................................................................................ v
Prefacio: Aprendizaje Activo ............................................................................................................................ vii
1ª PARTE: ¿QUÉ HACE A ESTE LIBRO DIFERENTE? ......................................................................................... VII
2ª PARTE: ¿QUIÉN SE BENEFICIA DE LA ENSEÑANZA ACTIVA? ................................................................... VII
3ª PARTE: ¿POR QUÉ ENFATIZAR EN LA “MODELIZACIÓN”? ....................................................................... VIII
4ª PARTE: ORGANIZACIÓN DEL LIBRO ............................................................................................................ VIII
5ª PARTE: ESTILOS Y FORMATOS UTILIZADOS EN ESTE LIBRO ..................................................................... IX
6ª PARTE: RECONOCIMIENTOS ............................................................................................................................. X
Capítulo 1 Introducción a SIMIO: La Tienda de Helados ............................................................................ 1
SECCIÓN 1.1: EL INICIO ........................................................................................................................................ 1
SECCIÓN 1.2: LA TIENDA DE HELADOS ............................................................................................................. 3
SECCIÓN 1.3: POTENCIANDO LA ANIMACIÓN ................................................................................................... 6
SECCIÓN 1.4: VIENDO RESULTADOS .................................................................................................................. 8
SECCIÓN 1.5: COMENTARIO ............................................................................................................................... 10
Capítulo 2 Modelizando Distancias y Desplazamientos: Un Aeropuerto, ............................................... 11
SECCIÓN 2.1: DESARROLLANDO EL MODELO .................................................................................................. 11
SECCIÓN 2.2: UTILIZANDO LA BIBLIOTECA DE DISEÑO 3D DE GOOGLE ................................................... 12
SECCIÓN 2.3: EXAMINANDO LOS RESULTADOS .............................................................................................. 13
SECCIÓN 2.4: USANDO EXPERIMENTOS ............................................................................................................ 14
Capítulo 3 Caminos con Desvíos, Tablas de Ritmos y Dependencias entre Entidades:
Aeropuerto bis .................................................................................................................................................... 16
SECCIÓN 3.1: ELECCIÓN DE CAMINOS ............................................................................................................. 16
SECCIÓN 3.2: CAMBIANDO EL RITMO O PATRÓN DE LLEGADA ................................................................... 18
SECCIÓN 3.3: DIFERENCIANDO ENTRE ENTIDADES: TABLAS DE DATOS .................................................... 19
SECCIÓN 3.4: MÁS SOBRE RUTAS ..................................................................................................................... 21
SECCIÓN 3.5: HORARIOS Y TURNOS DE TRABAJO .......................................................................................... 22
Capítulo 4 Secuencias y Viajeros: Célula de Fabricación ........................................................................... 24
SECCIÓN 4.1: CONSTRUYENDO EL MODELO ................................................................................................... 25
SECCIÓN 4.2: ESPECIFICANDO LAS CAPACIDADES ......................................................................................... 26
SECCIÓN 4.3: INCORPORANDO SECUENCIAS ................................................................................................... 27
SECCIÓN 4.4: MEJORA: CARRITOS DE TRANSFERENCIA ............................................................................... 28
Capítulo 5 Agrupaciones, Funciones, Variables de Estado, y Estadísticas:
Ensamblaje de Tarjetas de Memoria................................................................................................................ 32
SECCIÓN 5.1: CREANDO EL MODELO ............................................................................................................... 32
SECCIÓN 5.2: CAMBIANDO EL TIEMPO DE PROCESO EN FUNCIÓN DE LA LONGITUD DE LA COLA ........ 35
SECCIÓN 5.3: AÑADIENDO MÁS ANIMACIÓN ................................................................................................. 37
SECCIÓN 5.4: CREANDO ESTADÍSTICAS ........................................................................................................... 38
Capítulo 6 Procesos en SIMIO: Ensamblaje de Tarjetas de Memoria bis ............................................. 41
SECCIÓN 6.1: LOS DISPARADORES DE PROCESO: ILUSTRANDO EL PROCESO ASSIGN ............................. 41
SECCIÓN 6.2: CREANDO UN PROCESO “REUTILIZABLE” ............................................................................... 42
SECCIÓN 6.3: OBTENIENDO ESTADÍSTICAS SOBRE VARIABLES DE OBSERVACIÓN
(TALLY STATISTICS) ........................................................................................................................................... 43
SECCIÓN 6.4: UNA INTRODUCCIÓN A RECURSOS (RESOURCES).................................................................. 46
Tabla de Contenidos i
Capítulo 7 Tiempos de Proceso Específicos por Pieza y Fuentes Únicas: Célula de Fabricación bis 48
SECCIÓN 7.1: NUEVO ENUNCIADO DEL PROBLEMA ................................................................................ 48
SECCIÓN 7.2: UN CARRIL DE TRANSFERENCIA ........................................................................................ 53
SECCIÓN 7.3: FALLOS DE MÁQUINA EN LA CÉLULA DE FABRICACIÓN................................................... 56
SECCIÓN 7.4: COMENTARIO..................................................................................................................... 57
Capítulo 8 “Material Consumido”, Cambios, Propiedades: Un Ensamblaje...................................... 59
SECCIÓN 8.1: ENSAMBLAJE DE UNA MAQUETA ...................................................................................... 59
SECCIÓN 8.2: TIEMPO DE PREPARACIÓN EN FUNCIÓN DE LA SECUENCIA .............................................. 61
SECCIÓN 8.3: UTILIZANDO MATERIALES EN LA OPERACIÓN .................................................................. 63
SECCIÓN 8.4: LLEGADA DE MATERIA PRIMA DURANTE LA SIMULACIÓN .............................................. 65
SECCIÓN 8.5: IMPLANTANDO UN ENFOQUE JUSTO-A-TIEMPO (JUST-IN-TIME) ...................................... 67
SECCIÓN 8.6: COMENTARIO..................................................................................................................... 70
Índice ......................................................................................................................................................................…71
iv Modelización y Simulación: Libro de Prácticas con SIMIO

Los autores
JEFFREY A. JOINES es Associate Professor y Associate Department Head of
Undergraduate Programs en el Department of Textile Engineering, Chemistry, and Science de
NC State University. Obtuvo un B.S. en Electrical Engineering y B.S. en Industrial
Engineering, un M.S en Industrial Engineering, y Ph.D. en Industrial Engineering, todos de la
NC State University. Recibió en 1997 el premio Pritsker Doctoral Dissertation Award del
Institute of Industrial Engineers. Es miembro de IEEE, IIE, ASEE, Tau Beta Pi, Etta Kappa
Nu, Alpha Pi Mu y Phi Kappa Phi. Sus investigaciones versan sobre la optimización de la
cadena de suministros utilizando simulación y métodos de optimización computacional. El Dr. Joines imparte
clases tanto de grado como de post-grado en Computer information systems, Computer based modeling in
Excel and VBA, y Computer Simulation for Six-Sigma. El Dr. Joines también ha impartido clases en Design
for Six Sigma, Simulation and Six Sigma, y Data Management to Assist in Six Sigma en programas Six
Sigma Black Belt and Master Black Belt. El Dr. Joines ha sido Program Chair de la 2005 Winter Simulation
Conference (WSC) y el editor de los Proceedings de 2000 WSC así como que ha desarrollado y mantenido el
sistema de gestión de artículos de WSC en el período 2000-2009. Forma parte del consejo de WSC
representando a IEEE Systems, Man, and Cybernetics Society. Ha sido también autor y session chair en
varias Winter Simulation Conferences.
El Dr. Joines está involucrado en la utilización de tecnología en el aula y cómo afecta en la capacidad para
resolver problemas. Se le concedieron los premios a la docencia NC State University Outstanding Teaching
Award y College of Textiles Outstanding Teacher, lo que le ha permitido ser admitido como miembro de la
Academy of Outstanding Teachers. En 2009, el Dr. Joines (junto con el Profesor Roberts) han sido
galardonados con el premio Gertrude Cox Award for Innovative Excellence in Teaching and Learning with
Technology for Transformative Large Scale Projects.
STEPHEN D. ROBERTS es el A. Doug Allison Distinguished Professor in the Edward P.

Fitts Department of Industrial and Systems Engineering at NC State University. El Dr.
Roberts obtuvo sus títulos, Ph.D., M.S.I.E., and B.S.I.E. (with Distinction) por School of
Industrial Engineering de Purdue University. Su principal interés estriba en la simulación y la
ingeniería en sistemas sanitarios y de salud. Empezó en NC State University en 1990, y ha
sido Department Head of the Department of Industrial Engineering y Interim Director of the
Integrated Manufacturing Systems Engineering Institute. Con anterioridad, estuvo en el Department of
Internal Medicine en Indiana University School of Medicine y en School of Industrial Engineering at Purdue
University. También fué el Director of the Health Systems Research Group at Regenstrief Institute for Health
Care. Con anterioridad, estuvo como docente el Department of Industrial and Systems Engineering de the
University of Florida y fué el Director of the Health Systems Research Division of the J. Hillis Miller Health
Center, University of Florida. Ha estado de sabático en Wolverine Software y en University of Central
Florida/Institute for Simulation and Training.
El Profesor Roberts es miembro de Alpha Pi Mu, Tau Beta Pi, Sigma Xi, Sigma Tau, y Omega Rho y Fellow
of the Institute of Industrial Engineers. Ha obtenido la Kaiser Aluminum Fellowship y la NDEA Title IV
Fellowship. Recibió los premios AIIE 1967 Graduate Research Award, Outstanding Paper Award at the 12 th
Annual Simulation Symposium, Pritsker and Associates Outstanding Undergraduate Teaching Award in the
Purdue School of Industrial Engineering, CA Anderson Outstanding Teacher in the NCSU Department of
Industrial and Systems Engineering, Outstanding Teacher from the NCSU College of Engineering, NCSU
Academy of Outstanding Teachers, Gertrude M. Cox Award for Transformative projects from NC State
University (con el Profesor Joines), Distinguished Service Award from INFORMS College on Simulation, y
ha sido miembro, Vice - Chair, y Chair de Winter Simulation Conference (WSC) Board of Directors
representando a TIMS (ahora INFORMS) College on Simulation, y Secretary, Vice-President/Treasurer,
President, and Past-President de WSC Foundation Board. Fué Proceeding Editor de 1983 WSC, Associate
Program Chair en 1985, y Program Chair en 1986. Ha sido WSC presenter, session chair, track coordinator, y
keynote speaker.
Los autores v
F. JAVIER OTAMENDI es Profesor Titular del Departamento de Economía Aplicada I en
la Universidad Rey Juan Carlos de Madrid y Coordinador de las Titulaciones Económicas.
Obtuvo sus títulos de Ingeniería Industrial y Management (B.S y M.S) en Oklahoma State
University. Con posterioridad obtuvo el título de Licenciado en Administración y Dirección
de Empresas en la Universidad Complutense de Madrid y el título de Doctor por la
Universidad Politécnica de Cartagena por el Programa de Tecnologías Industriales. Su
principal interés estriba en la optimización de sistemas vía simulación así como la aplicación de la
simulación en las ciencias económicas y del transporte. Su carrera docente empezó en la Universidad Carlos
de Madrid enseñando simulación y gestión de calidad, y siguió en la Universidad Complutense de Madrid
y en Saint Louis University, Madrid, enseñando estadística para las ciencias sociales. En la actualidad,
imparte clases de estadísticas en los grados y de dirección de operaciones y simulación en postgrado.
También estuvo dos años como investigador en el Centro COTEC I+D aplicando simulación en aeropuertos.
El Dr. Otamendi ha sido el Conference Chair y Proceedings Editor de European Conference in Modelling
and Simulation en 2009 (ECMS09). Es miembro del Consejo de ECMS desde 2007. Ha participado como
ponente, track chair o session chair en ECMS, SCSC y otros congresos de simulación.
vi Modelización y Simulación: Libro de Prácticas con SIMIO

Prefacio: Aprendizaje Activo
La mayoría de los libros se escriben con un tono explicativo y los autores se encuentran con tremendos
problemas para explicar, con todo lujo de detalles, los conceptos y las ideas que se transmiten. Este estilo
también es el habitual en los libros sobre simulación, de los que existen básicamente dos categorías – los que
utilizan como base un lenguaje específico y los que no. Si el libro se basa en un lenguaje de simulación,
entonces se han de explicar las principales características y los posibles usos del software a la vez que se
explican conceptos básicos de simulación. Por el contrario, los libros que no se basan en un lenguaje en
particular se concentran en los conceptos fundamentales sobre simulación, especialmente en los aspectos
estadísticos o analíticos. El libro asume como mínimo tener instalada la versión 3.42 de SIMIO.
1ª Parte: ¿Qué hace a este libro diferente?
Este libro es distinto a la mayoría. Para empezar, está escrito en lo que se podría llamar un estilo
participativo. El lector no se puede sentar a leerlo sin un ordenador en el que esté instalado SIMIO. Con este
libro se espera que se participe activamente mediante la utilización de SIMIO a medida que se vayan pasando
las páginas. Nosotros, los autores, intentamos mantener una conversación con usted, lector. Nuestro
convencimiento es que la simulación no es un deporte para el espectador. Tiene que trabajar a la vez para
desarrollar competencias con el SIMIO, competencias que se desarrollan a través de la práctica. Este libro le
invita a practicar y a utilizar sus conocimientos y capacidades.
En segundo lugar, el libro se enfoca en la modelización con SIMIO, dejando aparte la mayoría del análisis
estadístico y de toma de decisiones, ya que estos conceptos se deben aprender en otra parte. No es que no
pensemos que estos temas sean importantes, porque son vitales (y cuando enseñamos simulación los
incluimos como una parte fundamental del curso), pero no vamos a emplear demasiado tiempo en este
documento, porque existen libros excelentes que pueden cubrir el vacío que dejamos. Sugerimos que, si el
lector está enseñando/aprendiendo simulación, que a la vez disponga de uno de estos libros que no están
basados en un software en particular1
Por último, este libro es deliberadamente barato (tanto el libro electrónico como su versión en papel). Un
nuevo lenguaje de simulación como SIMIO va a estar cambiando constantemente. De hecho, la gente de
SIMIO intenta tener nuevas versiones (llamadas “sprints”) una vez cada tres meses. Cualquier libro que
describa las tripas de SIMIO se volverá obsoleto rápidamente, por lo que queremos que se añadan las nuevas
características en nuevas versiones a menudo. Es posible que cambiemos algo el contenido del libro a medida
que encontremos nuevos ejemplos o enfoques. Si el lector no paga mucho por el libro, es posible que vuelva
a adquirir nuevas versiones para estar al día con los nuevos contenidos.
2ª Parte: ¿Quién se beneficia de la Enseñanza Activa?
Nuestra intención es que usted, como lector, se convierta en un alumno activo y, como sugiere el título,
trabaje a la vez que lee. Nuestra experiencia en las aulas es que el alumno aprende más al hacer los trabajos,
por lo que este “manual de trabajo” se centra en el trabajo de laboratorio, en lo que nuestros alumnos hacen
en clase. Los capítulos de este libro generalmente corresponden a una sesión de practica de laboratorio. Si el
lector no es alumno de enseñanza reglada, pero quiere aprender SIMIO por su cuenta, pensamos que este
enfoque es atractivo para la auto-enseñanza. Un capítulo se puede cubrir en una tarde.
Por ejemplo, Discrete-Event System Simulation (5th Edition), Jerry Banks, John Carson, Barry Nelson, David Nicol, Prentice-Hall,
2010 (622 páginas)
Prefacio: Aprendizaje Activo vii
Existen diversos mecanismos para incluir la enseñanza activa en un aula. Algunos profesores empiezan la
clase con algún tipo de planteamiento del problema y de orientación hacia las técnicas de modelización
apropiadas en ese caso. Algunos otros van directamente al grano y realizan un ejercicio junto con los
alumnos. Y otros intentan que los alumnos sigan el manual a su propio ritmo. Aún así, lo que es crítico en
este tipo de enseñanza son los denominados “momentos de enseñanza”, como oposición a las clases
magistrales. Estos momentos aparecen cuando se hacen preguntas u observaciones, lo que provoca una
discusión en detalle sobre un tema en concreto. Algunas personas piensan en este proceso como un sistema
de educación tipo “pull”. El enfoque asusta a muchos profesores porque no se puede seguir un formato
estándar de clase o porque la discusión se alargue y algún tema se deje “sin cubrir”.
Para asegurar que todos los implicados participan en este proceso activo de enseñanza, normalmente
entregamos al principio de la clase una o dos páginas con preguntas que deben surgir al resolver el ejercicio.
Hemos incluido algunas de ellas a lo largo y ancho del libro. Son preguntas que tienen respuestas cortas y
que requieren que los alumnos presten atención a lo que van desarrollando. El resultado es una clase con un
alto nivel de asistencia y participación, aunque no se controle oficialmente la asistencia, porque puntuamos a
aquéllos que entregan los ejercicios al finalizar la clase. Asignaturas en la que se sigue esta metodología
docente se crean una reputación de obligada asistencia.
3ª Parte: ¿Por qué enfatizar en la “Modelización”?
Bajo nuestro punto de vista, la modelización vía simulación es una forma de “ingeniería de sistemas”,
entendidos sistemas como procesos productivos o logísticos, incluso administrativos. Nuestra intención es
hacer ingeniería o re-ingeniería de un proceso o sistema, pero, al ser complejo, dificultoso o incluso
imposible experimentar con tal sistema, necesitamos desarrollar un modelo en un ordenador a imagen y
semejanza del real o del futuro sistema, y experimentar con ese modelo (de forma similar a lo que hacen con
un túnel de viento los diseñadores de nuevos aviones). La actividad crítica es el “desarrollo del modelo” – lo
que se llama “modelización mediante simulación”, o “simulación” simplemente. Este tipo de modelización
no es una ciencia exacta, pero se basa en un enfoque de resolución de problemas. Para desarrollar un modelo
se necesita: (1) un conjunto robusto de conceptos sobre modelización (y el lenguaje en que se realiza la
simulación), y (2) una implantación en un ordenador. Luego para ser un buen “simulador”, es necesario que
adquieras conocimientos sobre los conceptos de modelización y experiencia en su uso.
SIMIO proporciona un amplio abanico de conceptos y posibilidades sobre modelización vía simulación así
como capacidades atractivas tanto visuales como tabulares para presentar resultados numéricos. Sin embargo,
cualquiera que haya tenido experiencia en simulación sabe que los lenguajes y las herramientas tienen
limitaciones y alguna vez no han podido desarrollar el modelo como les hubiera gustado. En lugar de utilizar
el enfoque de “unidad/objeto, atributo y recurso”, SIMIO se basa en un paradigma con orientación a objetos
más general, en el que los objetos ejecutan “procesos u órdenes”. Así, además de disponer de los objetos y
procesos incluidos en una librería estándar, el usuario puede añadir más, quitar los actuales o cambiarlos para
satisfacer sus necesidades particulares.
Por lo que aprender a utilizar SIMIO requerirá de un cambio de mentalidad. Tendrá el usuario que apartar los
enfoques que hayan utilizado con otros lenguajes y empezar a adoptar otra visión a la hora de atacar el
proceso de desarrollo del modelo. Pensamos que si se trabaja este libro con cariño y atención, se aprenderá lo
suficiente sobre el enfoque que sigue SIMIO como para poder subir un nivel y convertirlo en su propio
enfoque sobre simulación.
4ª Parte: Organización del libro
Este libro está organizado de forma conceptual para hacer modelos rápidamente. En los primeros cinco
capítulos, nos concentramos en el uso de la Librería de Objetos Estándar, “Standard Library Objects”, de
SIMIO. Se puede realizar mucha modelización sin necesidad de recurrir a conceptos u objetos más
complejos. Los siguientes siete capítulos explican cómo ampliar los objetos estándar utilizando procesos,
viii Modelización y Simulación: Libro de Prácticas con SIMIO
“processes”. Este aprendizaje dota de mayor flexibilidad a la modelización sin necesidad de inventar una
nueva librería de objetos. Los últimos capítulos se utilizan para discutir la creación de nuevos objetos y la
modificación de los ya existentes en SIMIO, de forma que se demuestre todo el poder de este enfoque
orientado a objetos.
El libro está diseñado para que sea lea capítulo a capítulo, aunque sea posible elegir ciertos conceptos y
temas. En los primeros capítulos, construimos modelos de forma directa sin mucha explicación de cómo se
seleccionan ciertas características. En los últimos capítulos, por el contrario, se argumentan las elecciones de
las distintas opciones así como otras posibles vías de modelización. Otros capítulos al final del libro
profundizan también en ciertos temas vistos con anterioridad, puesto que es sabido que la redundancia en el
aprendizaje ayuda a fortalecer los conceptos. Para cuando se acabe con el libro, se debe por tanto estar bien
preparado para construir modelos en SIMIO y entender las bondades de los distintos enfoques que se pueden
utilizar.
Al final de la mayoría de los capítulos, se incluyen comentarios sobre los temas tratados. Se enfatizarán las
fortalezas y debilidades del enfoque de modelización y el lenguaje utilizado (no tenemos intereses
financieros en SIMIO). Los diseñadores de SIMIO fueron también los diseñadores de Arena, por lo que se
encontrarán trazas y reminiscencias de Arena en SIMIO. Ya que alguno de los lectores migrará desde Arena,
proporcionaremos información sobre estas trazas. Sin embargo, prepárense para ir mucho más allá de lo
aprendido con otros lenguajes de simulación.
Cuando se compara Arena y SIMIO, no se encontrarán en SIMIO rutinas de análisis para datos de entrada o
de salida. SIMIO probablemente nunca tendrá la capacidad de analizar los datos de entrada, ya que hay
muchos disponibles2. Cuando se usa un modelizador de datos de entrada, es necesario establecer de forma
correcta una relación entre los parámetros estimados por el modelizador y los parámetros necesarios en
SIMIO. El analista de resultados, “Output Analyzer”, y el analista de procesos, “Process Analyzer”, han sido
incorporados a SIMIO, con la posibilidad de escribir información en ficheros externos para su posterior
análisis. SIMIO está mejorando la presentación de resultados casi de forma diaria. También ha incorporado
recientemente rutinas sobre selección y ranking de subconjuntos de alternativas, así como posibilidades de
optimización.
En un sentido muy limitado, SIMIO es como Arena con las capacidades de Siman para analizar procesos. Sin
embargo, esta visión no hace justicia a la mayor flexibilidad y las enormes posibilidades ofrecidas por
SIMIO. Además, SIMIO presenta la posibilidad de representar a escala el modelo en 3D, y posee una
orientación a objetos que permite añadir y modificar objetos de forma sencilla. SIMIO dispone de una
apariencia y una disposición más modernas y, en nuestra opinión, unas posibilidades mayores que las de la
mayoría de los otros lenguajes de simulación.
5ª Parte: Estilos y Formatos Utilizados en este Libro
Ciertos estilos se utilizan en este libro para ilustrar objetos, nombres y parámetros y para diferenciarlos
claramente. Los objetos estándar de SIMIO se escriben en Versales y una fuente Courier New (SERVER)
mientras que los creados por el usuario también irán en negrita (DELAYOBJECT). Las propiedades asociadas
con estos objetos se incluyen en cursiva (Processing Time). Los nombres de los procesos irán en cursiva y
entre-comillados, como “OnEnteredProcessing”, mientras que los disparadores de proceso, “triggers”
(Exited) sólo irán en cursiva al ser propiedades. Etapas en los procesos, como Assign se presentan en
cursiva y en Courier New. SIMIO utiliza también muchas expresiones, que se indican en Courier New (
SrvOffice.Contents >0). Los nombres de los objetos que han sido definidos por el usuario irán en
negrita (incluir un servidor, SERVER, de nombre SrvOffice). Los valores asociados con las propiedades se
incluirán de la misma forma que las expresiones o entre comillas para cadenas de texto (“True”).
Por ejemplo, véase EasyFit en http://www.mathwave.com/
Prefacio: Aprendizaje Activo ix

6ª Parte: Reconocimientos
Queremos dar las gracias a nuestros alumnos, que han ayudado mucho a nuestra comprensión del proceso de
aprendizaje y que a menudo nos hacen que demostremos nuestra ignorancia o nuestra falta de preparación.
Apreciamos también la respuesta amable de la gente de SIMIO a nuestra inacabable batería de preguntas y
dudas, en especial a Dave Sturrock y a Dennis Pegden. Finalmente, queremos dar las gracias a nuestras
familias por su comprensión y paciencia porque a menudo pasamos más tiempo hablando entre nosotros que
con ellos.
Por favor, hágannos saber cómo mejorar este “workbook” y cómo podemos satisfacer mejor sus necesidades.
Jeff Joines (JeffJoines@ncsu.edu)

Steve Roberts (roberts@ncsu.edu)

Raleigh, North Carolina
Javier Otamendi (franciscojavier.otamendi@urjc.es)
Universidad Rey Juan Carlos

Madrid, España
x Modelización y Simulación: Libro de Prácticas con SIMIO

Capítulo 1
Introducción a SIMIO: La Tienda de Helados
La simulación es muy útil. Casi cualquier persona que conoce y aprende simulación ve sus tremendas
posibilidades de aplicación al mundo real. Prácticamente, cualquier sistema de fabricación, producción o
servicios se puede beneficiar de un estudio basado en modelos de simulación. SIMIO puede hacer que la
aplicación sea no sólo fácil de realizar sino que sirva a la vez como un enfoque robusto y potente para
analizar problemas complejos.
La simulación es divertida. Se pueden crear modelos que sean atractivos visualmente y SIMIO eleva el
disfrute a niveles insospechados con su capacidad de presentación en 3 dimensiones (3D). Lo que significa
que no sólo el lector puede ver cómo se comporta el modelo, sino también los que trabajan con él,
aumentando la credibilidad del proceso.
Sección 1.1: El inicio
Asumimos que ha instalado SIMIO en su ordenador y que está listo para empezar.
Paso 1: Abra SIMIO o bien a través del menú Inicio en Windows o bien haciendo clic en un icono de
SIMIO, “ ”, que quizás haya incluido en la barra de herramientas de Windows o en el Escritorio.
Barra de
Parece MS SIMIO Office
Crear un
nuevo modelo
Información
General de SIMIO
Modelos
Elementales
Versión
Modelos
Completos
Figura 1.1: Abriendo la ventano de SIMIO
Introducción a SIMIO: La Tienda de Helados 1

La ventana que se abre según la Figura 1.1 se asemeja a las de Microsoft Office. Se ha de fijar en los recursos
que SIMIO le facilita. “SimBits” hace referencia a la librería de modelos elementales (cada uno ilustrando
una estructura de modelización particular de SIMIO) y “Example Projects” hace referencia a la librería con
modelos completos. También se muestra la versión de SIMIO3. Querrá mantener su versión actualizada.
Pinche ahora en “Create a new model.” para crear un nuevo modelo.
Undo/Redo
MySimioProject
Unidades
Pestaña de
Ejecución Objetos in
Pestaña MySimioProject
Abrir/Cerrar
Panel de
[Librería Tapiz de Navegación
Estándar] Diseño
Inspector de
Propiedades
[Librería de
Proyecto]
Figura 1.2: Creando un nuevo modelo

Paso 2: Cuando se crea un nuevo modelo (véase la Figura 1.2), se definen automáticamente dos objetos. El
tipo de entidades, MODELENTITY, que creará “entities” (traducido en este manual como “unidad o
entidad”) que se mueven por el modelo mientras que el modelo, MODEL, contendrá el posicionamiento de
los objetos y el flujo de las unidades. Dicho de otra forma, las unidades se mueven alrededor y entre los
objetos que están posicionados.
Paso 3: Haga clic con el botón derecho del ratón en MODELENTITY y MODEL en el Panel de Navegación,
Navigation Panel, y seleccione las propiedades o características del modelo, Model Properties.
Pregunta 1: ¿Cuál es el nombre por defecto de MODELENTITY?
3
Las versiones “Sprint” de SIMIO salen aproximadamente una vez cada tres meses, por lo que el software irá cambiando
rápidamente. Asegúrese de conseguir las actualizaciones con nuevas características y con correcciones de posibles errores.
2 Modelización y Simulación: Libro de Prácticas con SIMIO
Pregunta 2: ¿Cuál es el tipo de objeto de MODEL?
Paso 4: Tenga en cuenta siempre los botones Undo/Redo. Se pueden utilizar para corregir errores y recuperar
componentes del modelo previamente utilizados. Cuando una acción no pueda ser revertida, SIMIO
lanzará una advertencia.
Paso 5: Las unidades (“Units”) son una forma conveniente de especificar las unidades por defecto de tiempo,
distancia o longitud y de flujo.
Sección 1.2: La Tienda de Helados
Una pequeña tienda de helados vende cucuruchos de helado. Los clientes llegan y esperan en cola hasta ser
atendidos por uno de los dos dependientes. Estos dependientes reciben y preparan el pedido y se lo entregan
al cliente, quien se dirige al cajero para pagar. Después de pagar, los clientes se van de la tienda. Mientras se
prepara la simulación, suele ser conveniente realizar un diagrama de proceso o flujograma. La Figura 1.3
muestra los cuatro procesos en que se divide la compra y el pago del helado.
Llegada Elección del Pago del Salida del

del Cliente Helado Helado Cliente
Dependiente En el Cajero
Figura 1.3: Flujograma de la Tienda de

Helados Asumamos que conocemos lo siguiente:
Que los clientes llegan a la tienda según un modelo de probabilidad exponencial, con un tiempo
medio entre llegadas de 0.5 minutos.
Que el tiempo que tarda el dependiente en interactuar con el cliente y entregarle el cucurucho de
helado se puede representar mediante un modelo de probabilidad triangular, con un mínimo 0.4
minutos, una moda o valor más habitual de 0.9 minutos, y un máximo de 1.5 minutos.
Que el tiempo que emplea el cajero en cobrar sigue también una distribución triangular con un
mínimo de 0.3, una moda de 0.4 minutos, y un máximo de 0.6 minutos.
Que el tiempo de desplazamiento entre cada proceso es de 15 segundos.
Si ambos dependientes están ocupados, los clientes esperarán en una única cola según lleguen, siguiendo lo
que se denomina una prioridad FCFS (first-come, first-served; o FIFO; al primero que entra, primero se le
atiende). También hay cola única delante del cajero. Asumiremos también que no hay problemas de espacio.
Paso 1: Debería estar bastante claro que los clientes deberían ser modelizados con un MODELENTITY
mientras que el MODEL representará el flujograma presentado en la Figura 1.3.
Paso 2: Añada objetos en el modelo haciendo un clic sobre el objeto que se desee en la [Standard Library].
Arrastre el objeto sobre el tapiz de diseño y vuelva a hacer clic para colocarlos en posición (también
puede hacer clic y arrastrar los objetos para recolocarlos o borrarlos del modelo). Cuando haga clic en un
objeto, sus propiedades aparecen en el inspector de propiedades, property inspector (que suele estar
colocado en el panel inferior derecho) - véase Figura 1.4.

Añada un objeto fuente o generador de entidades, SOURCE, dos objetos que procesan o transforman
entidades, SERVER, que será traducido por facilidad como servidor, y un objeto sumidero o
eliminador de entidades, SINK – véase Figura 1.4.
Conecte los objetos con un camino con tiempo de desplazamiento o retardo, TIMEPATH, haciendo clic
en el nodo de salida (“output”, diamante azul) de un objeto y conectándolo con el nodo de entrada
(“input”, diamante gris) de otro objeto. Puede hacer clic entre los nodos para crear un aspecto de
línea quebrada lo que permite tener más flexibilidad a la hora de representar la conexión entre los
objetos.
Note cambios en la barra
Objeto Fuente
(Source)
Propiedades
Seleccionado
de la Fuente
Servidor
Nombre
del Objeto
Camino con
Tiempo de
Desplazamiento
Figura 1.4: Comenzando a Modelizar

Paso 3: Añada nombres (“name”) a cada objeto. Puede cambiar el nombre de un objeto directamente4 o en
la propiedad “General” dentro de la ventana de propiedades.
Pregunta 3: Un objeto servidor, SERVER, tiene tres líneas (“lines”) que lo rodean. ¿Cómo se llaman?
Pregunta 4: Un objeto SERVER tiene un nodo “input” y otro “output”. Estos nodos son también objetos de
la [Standard Library]. ¿Cuál es el nombre en la librería estándar del nodo de entrada?
Pregunta 5: ¿Cuál es el nombre en la librería estándar del nodo de salida?
Haga doble click encima del objeto para cambiar el nombre directamente.
Paso 4: Haga clic en cada objeto y rellene sus propiedades según las hipótesis y los datos de partida. La
Figura 1.5 muestra las propiedades asociadas con el objeto fuente, SOURCE.
Nombre de la Entidad
Propiedades
Objeto Fuente Llegadas en función
de Tiempo entre
Llegadas
Unidades de
Tiempo Editor de
Expresiones
Revela
Detalles
Descripción de
la Propiedad
Figura 1.5: Propiedades de una Fuente

Es importante estar seguro de que las unidades de tiempo son las correctas cuando se identifican expresiones
que incluyen tiempos y distancias. Para introducir o revelar detalles en una ventana de diálogo, debe hacer
clic en el icono . El editor de expresiones, Expression Editor, te permite escribir expresiones con el
siguiente formato:
Object.SubObject.SubObject(parámetros)
Para activar el editor de expresiones, empiece por especificar un carácter. Selecciona el objeto, su(s)
subobjeto(s), y su(s) propiedades. Los editores de expresiones tienen la facilidad de “auto-completar”, lo que
significa que se completará el nombre a partir de los primeros caracteres. También indica si existen
subobjetos disponibles para este objeto en particular.
Pregunta 6: ¿Qué unidades de tiempo están asociadas al tiempo entre llegadas?
Paso 5: Complete su modelo añadiendo información a los dos servidores, SERVERS:
Para el objeto PEDIR:

Initial Capacity: 2
Processing time: Random.Triangular(0.4, 0.9,1.5)
Units: Minutes
Para el objeto PAGAR:
Processing time: Random.Triangular(0.3, 0.4, 0.6)
Units: Minutes
Para los objetos TIMEPATH:
TravelTime: 15
o Units: Seconds

Note que los nombres de los objetos están listados en la categoría “General” en el inspector de
propiedades.
Paso 6: Antes de ejecutar el modelo, vamos a cambiar el momento de tiempo en el que acabará la
simulación en el configurador Run Setup, en la pestaña Ejecutar (“Run”), como muestra la Figura 1.6.
Determinando
el final
Figura 1.6: Determinando el Tiempo de Ejecución
Paso 7: Ahora, simulemos durante un rato – haga clic en el botón para empezar la simulación.
Paso 8: Vea cómo se mueven las entidades, MODELENTITIES ( ), por los caminos, TIMEPATHS. Las
entidades se acumulan en el lugar denominado contenidos de la fila de entrada,
INPUTBUFFER.CONTENTS, y se procesan en la fila PROCESSING.CONTENTS, ambos mostrados como
“líneas” que rodean los objetos servidor. Puede mover los objetos mientras el modelo está en ejecución.
Paso 9: Haga clic en la pestaña “View” y seleccione “3-D”.
Pregunta 7: Mantenga apretado el botón izquierdo del ratón, y muévalo a derecha y a izquierda, arriba y
abajo. ¿Qué sucede?
Pregunta 8: Mantenga apretado el botón derecho del ratón, y muévalo a derecha y a izquierda, arriba y
abajo. ¿Qué sucede?
Paso 10: Cambie entre las vistas 2-D y 3-D usando las teclas “2” y “3”
Pregunta 9: ¿Qué sucede en 2-D cuando se mantiene apretado el botón izquierdo del ratón, y éste se
mueve a derecha y a izquierda, arriba y abajo?
Pregunta 10: ¿Qué sucede en 2-D cuando se mantiene apretado el botón derecho del ratón, y éste se
mueve a derecha y a izquierda, arriba y abajo?
Paso 11: Experimente en 2-D y 3-D mientras mueve las estaciones y cambia el “layout” del modelo.
Cambie el tiempo de desplazamiento del puesto Pedir a 50 segundos para percibir otro tipo de cambio.
Sección 1.3: Potenciando la Animación
La animación, Animation, es a menudo lo que interesa a la gente acerca de un modelo. Un modelo de SIMIO
en 3-D, aunque pueda requerir algo de trabajo adicional, puede motivar cierta atención extra. En esta sección,
le daremos instrucciones para crear una animación que se asemeje a lo que se muestra en la Figura 1.7.

Figura 1.7: Animación
Paso 1: Haga que los clientes aparezcan como personas, en vez de triángulos. Haga clic en MODELENTITY en
el panel [Project Library] y arrástrelo dentro del tapiz. Seleccione el triángulo verde y, dentro de la
sección Symbol→Project Symbols, busque dentro de los grupos y seleccione una persona de
“Library\People”, haciendo clic sobre el icono para sustituir al triángulo. Mire la figura en 3-D y
agrándela pasando el ratón por encima.
Paso 2: Seleccione el objeto Pedir y elija una mesa, “table”, como figura. Repita el procedimiento para el
objeto Pagar. Ajuste el tamaño de los objetos SERVER para que correspondan con el tamaño de una
persona.
Paso 3: Ahora, añadamos gente de pie detrás de las mesas. Para hacerlo, cambie a 3-D y seleccione la
pestaña para dibujar, “Drawing”. Haga clic en el botón “Place Symbol” y seleccione una persona que
represente al dependiente. Cuando la persona ha sido posicionada, puede hacer clic en una de las
esquinas y presionar la tecla Ctrl para rotar el dibujo. Sitúe a la persona detrás de la mesa. Duplique al
dependiente utilizando la secuencia Ctrl-V y Ctrl-P. Haga lo mismo para el objeto Pagar.
Paso 4: Mueva los símbolos por el tapiz para conseguir una mejor visualización de la tienda de helados.
Puede ahora añadir paredes utilizando la herramienta “Polyline” del Drawing panel. Asegúrese de incluir
la altura del objeto en la sección “Object”. Debe darse cuenta de que las medidas de distancia están
especificadas en metros salvo que lo especifique en Unidades. Puede que tenga que modificar la altura de
los objetos para que sean consistentes.
Paso 5: En una animación anterior, el camino entre Pagar y Salida debería también incluir un “path
decorator”. Los decoradores de caminos se pueden invocar seleccionando el camino y seleccionando
“Decorator”. Para visualizar mejor a la gente en este camino, el tiempo de desplazamiento a 300
segundos.

Paso 6: Ejecute la simulación y mire la animación. Cuando simule, puede que necesite ajustar su apariencia
tanto en 2-D como en 3-D. Los símbolos que representan las colas o filas de espera se pueden alargar.
Por ejemplo, el número de personas que esperan para pedir puede ser muy larga, por lo que igual desea
alargar esa línea. Lo mismo puede suceder con la de procesamiento Processing.Contents.
Recuerde que la longitud no tiene impacto en la capacidad sino sólo en la animación (incluso puede haber
más en espera que dibujados).
Pregunta 11: Enseñe la simulación a sus amigos. ¿Cuál es su reacción?
Sección 1.4: Viendo Resultados
Aunque la animación llama la atención, el objetivo de la simulación es comprender las características

numéricas del sistema que está modelizando. Típicamente, estará haciendo cambios en el modelo hasta que
identifique los cambios que quiera proponer o recomendar.
Paso 1: Primero, miremos los resultados del modelo básico, mostrados en la Figura 1.8. Quizá podamos
denominar a este modelo “sistema actual” (“present system”). En la pestaña de ejecución, “Run”, cambie
la duración de la simulación a 8 horas. Los resultados de las simulación se pueden ver en la pestaña de
resultados, “Results”.
Pestaña de
Resultados
Atributos Filtro
Variable
Reordenar
Resultados
Figura 1.8: Viendo Resultados

Paso 2: Los resultados de la simulación se muestran en forma de tabla, “pivot table.” En la tabla se disponen
los resultados en función de atributos, que son las cabeceras de cada columna.
Paso 3: Cada atributo va acompañado de dos símbolos – uno para re-ordenar la columna y otro para filtrar o
seleccionar lo que se muestra en cada columna.
Pregunta 12: Filtre la estadísticas para mostrar sólo las medias para MODELENTITY. ¿Cuál es el número
medio en el sistema, Number in System, y el tiempo medio de permanencia en el sistema, Time
in System?
Paso 4: Los atributos se pueden mover a derecha e izquierda en la pantalla.
Paso 5: Haciendo clic con el botón derecho en “Results Field”, puede mostrar “show field list.” Así puede
añadir otros campos de cálculo a las columnas.
Paso 6: Las categorías, “Categories”, para las que se pueden obtener estadísticas son: Contenido, Content,
Producción total, Throughput, Capacidad, Capacity, Tiempo de flujo, FlowTime, Estado en el que se
encuentra un recurso, ResourceState y Tiempo de espera, HoldingTime. Estos resultados se aplican a
cada fuente de datos.
Paso 7: La utilización de recursos, Resource utilization, incluye tanto la utilización programada,

“ScheduledUtilization”, como las unidades asignadas, “UnitsAllocated”, programadas,
“UnitsScheduled”, y usadas, “UnitsUtilized”. Estas variables hacen referencia a la utilización real de la
capacidad de un objeto así como a la capacidad programada media. La utilización programada,
“ScheduledUtilization”, se calcula como el ratio que resulta de dividir el tiempo real de uso de un recurso
entre el tiempo total que estaba previsto que trabajara según la programación.
Pregunta 13: ¿Cuál es la utilización de la capacidad del objeto Pedir?
Paso 8: Advierta que el tiempo de espera se muestra como “HoldingTime” del “InputBuffer” mientras que
“Content” de InputBuffer muestra el número en espera.5
Pregunta 14: ¿Cuál es el número medio (contents) en el InputBuffer de Pedir?
Pregunta 15: ¿Cuál es el tiempo medio de espera (holding time) en el InputBuffer de Pedir?
Pregunta 16: ¿Por qué el número medio de Content de Pedir es igual a la media de unidades
programadas, UnitsAllocated, con anterioridad?
Pregunta 17: ¿Cuál es la utilización del objeto Pagar?
Paso 9: Para volver al modelo, necesita seleccionar la pestaña “Facility”, que está a la misma altura que la
pestaña “Results”.
La terminología de SIMIO de “HoldingTime” y “Content” puede parecer que no sea estándar. Generalmente, la Teoría de Colas o
de Líneas de Espera utiliza los términos “waiting time” y “number in queue”. También “waiting line length” o “number waiting” son
términos que se utilizan en vez de “number in queue.”

Sección 1.5: Comentario
Si ha estado construyendo el modelo con nosotros, puede haber notado lo siguiente:
El botón de deshacer/rehacer de SIMIO, undo/redo, es muy conveniente. En el caso de caminos,

puede cambiar el tipo de camino usando el botón derecho del ratón. Estas características facilitan
la posibilidad de probar, y entonces deshacer o rehacer los cambios.
Las entidades no cambian de orientación durante la animación sino son los caminos los que
ayudan a cambiar de dirección, pero manteniendo la orientación en las líneas que representan las
colas de espera o de procesamiento (lo que puede ser una oportunidad para una nueva versión de
SIMIO).
La herramienta visual para mostrar resultados de forma gráfica se describirá más tarde.
La noción de una librería estándar de la que se arrastran objetos dentro del tapiz es muy similar a
la forma en que se construyen modelos a partir de módulos en Arena. En lugar de los cuadros de
diálogo de Arena, SIMIO utiliza el inspector de propiedades.
Si usted está familiarizado con el diseño orientado a objetos, Object Oriented Design (OOD), la librería de
SIMIO, [Standard Library], debería ser denominada más apropiadamente como una librería de clase, “class”
library. Son las clases de las que se crean objetos. La acción de seleccionar y mover al tapiz estos objetos es
lo que permite crear una instancia del objeto. Las propiedades, tal como se muestran en el inspector de
propiedades, son las características básicas de los objetos. Más adelante, verá cómo añadir propiedades. Las
propiedades se pueden inicializar pero no cambiar. Otro tipo de atributo, al que SIMIO denomina variable de
estado, STATE variable, puede ser incluida en el modelo si los atributos han de ser modificados durante la
simulación.

Capítulo 2
Modelizando Distancias y Desplazamientos: Un
Aeropuerto,
Nuestro objetivo es modelizar gente en su llegada al aeropuerto para pasar el proceso de facturación. En
primer lugar, sólo nos preocuparemos con el tiempo que necesitan los pasajeros para llegar al control de
seguridad, y que se puedan determinar el número de mostradores necesarios en facturación. Los pasajeros
llegan al terminal y se acercan al puesto de facturación para obtener el billete. Después del check-in, los
pasajeros se dirigen al control de seguridad.
Los pasajeros llegan de acuerdo a un modelo exponencial con una media de un minuto entre llegadas. Se
dirigen andando hacia el mostrador de facturación a un ritmo de entre 2 y 4 millas por hora (según un modelo
uniforme).
Los pasajeros cubren una distancia de 50 yardas desde la entrada al edificio hasta el check-in. Después de la
facturación, han de recorrer 65 yardas hasta el control de seguridad.
Existen en la actualidad 4 mostradores con sus respectivos operarios, que tardan entre 2 y 5 minutos por
pasajero, siguiendo una distribución uniforme. Los pasajeros esperan en una fila común a todos los puestos
según su orden de llegada.
El modelo de simulación debe ser ejecutado para un período de 24 horas.
Sección 2.1: Desarrollando el modelo
Paso 1: Cree un nuevo modelo, como el que se muestra en la Figura 2.1. Haga clic con el botón derecho en
objetos en el panel [Navigation] y vea sus propiedades. Llame al proyecto, PROJECT, “Aeropuerto”.
Incluya el valor “Pasajeros” en la propiedad Model Name. Llame al modelo, MODEL, “Aeropuerto”.
Añada una fuente o llegada, SOURCE, un servidor, SERVER, y un sumidero o salida, SINK, de a librería
estándar al tapiz Facility, y conéctelos utilizando un camino, PATH (todo esto puede ser realizado
utilizando el Add-In desde “Project Home”).
Paso 2: Haga clic y arrastre dentro del tapiz una entidad de MODELENTITY desde el panel [Project Library].
Cambie los nombres de los objetos para identificar el puesto o la operación que representan. Cambie
también el nombre de DefaultEntity a Pasajero. Cambie su símbolo a una persona utilizando la librería
de objetos y personas.
Modelizando Distancias y Desplazamientos: Un Aeropuerto, 11

Figura 2.1: El Modelo Básico
Paso 3: Incluya la velocidad de movimiento del pasajero como Random.Uniform(2,4) en millas por
hora (miles per hour), en el objeto Pasajero. Incluya el ritmo de llegadas en la propiedad interarrival
time, Random.Exponential(1) en minutos, en el objeto Llegada. Ponga como ProcessTime en
CheckIn Random.Uniform(2,5) en minutos y determine la capacidad de este elemento como 4.
Paso 4: Para los caminos, cambie la propiedad Drawn to Scale , dibujar a escala, a “FALSE” e incluya las
distancias correctas en ambos objetos. Recuerde que el camino desde la entrada a check-in es de 50
yardas mientras que el camino entre check-in y seguridad es de 65 yardas.
Sección 2.2: Utilizando la Biblioteca de Diseño 3D de Google
Paso 1: Aunque ya podríamos ver la simulación, cambiemos el símbolo del CheckIn. Se puede hacer tanto
haciendo clic en el objeto y cambiando el símbolo a alguno de los predeterminados de SIMIO, o
descargando nuevos símbolos desde Google’s 3D Warehouse. O si ya dispone de modelos en su
ordenador, importando dibujos desde ellos.
Paso 2: Para utilizar nuevos símbolos, seleccione el objeto CheckIn y elija alguna de las opciones de Project
Symbols. “Google’s 3D Warehouse” debería aparecer cuando selecciona el botón “Download Symbol”,
que le permitirá buscar el modelo que quiera. Cuando lo haya encontrado, haga clic en “Download
Model” y SIMIO los importará en una ventana en la que se pueden cambiar sus propiedades, como el
tamaño y la orientación. Pruebe a buscar “Airport Baggage”.
Paso 3: Cuando haya descargado de Google, aparece la ventana “Import”. Puede ver el símbolo descargado
en 2D o 3D. El símbolo tiene su longitud, anchura y altura en metros, variables que pueden ser
modificadas. También se muestra una ayuda, “hint”, sobre la altura, en relación a la de una persona.
Finalmente, se puede rotar el objeto de forma que tenga la orientación6 adecuada.
Paso 4: Posicione el CheckIn de forma que el input BASICNODE, la fila InputBuffer, y la fila de Processing
se asemejen a un aeropuerto, siguiendo la Figura 2.2.
Paso 5: Ejecute el modelo y ajuste la animación (en 2D y 3D). Modifique la fila Processing de CheckIn de
forma que sólo 4 personas puedan estar en proceso a la vez (recuerde que la capacidad es cuatro).
Utilice la ventana “hint”, que se abre al presionar la tecla “h” del teclado: ayuda a rotar, dimensionar y mover objetos en SIMIO.
Processing (para Símbolo
4 puestos) Descargado
Input
Input Buffer
Queue
Figura 2.2: CheckIn
Sección 2.3: Examinando los resultados
Los resultados de una simulación son variables aleatorias producidas por las entidades que fluyen por el
modelo y son procesadas. Su llegada es aleatoria lo mismo que los tiempos de proceso. Así, una repetición o
ejecución del modelo resulta en un único valor experimental. Este valor no es preciso, por lo que necesitamos
hacer muchas repeticiones para mejorar la precisión.
Paso 1: Cambie la duración de una repetición a 24 horas y ejecute la simulación. Cuando finalice, haga clic
en “Results” y accede a la pantalla de resultados.
Pregunta 1: ¿Cuál es el número medio de personas esperando en el mostrador de facturación?
Pregunta 2: ¿Cuánto tiempo esperan de media?
Pregunta 3: ¿Piensa que son buenos resultados? ¿Por qué sí o por qué no?
Paso 2: Para ganar en confianza en nuestros resultados, el modelo ha de ser simulado varias veces. En la
pestaña “Project Home” se puede añadir un experimento que facilite la ejecución múltiple de un modelo.
En la pestaña “Design”, cambie el número de repeticiones a 10 y realice el experimento. Debe tardar
poco y el final de cada repetición debe ir apareciendo en la ventana de comentarios en la parte de debajo
de la pantalla. Las repeticiones no tienen que ser realizadas en un orden secuencial, pues dependerá de las
características del ordenador.
Paso 3: Puede ver los resultados en la tabla “Pivot Grid” o en la pestaña “Reports”. Los campos incluidos
ahora son el mínimo “Minimum”, el máximo “Maximum”, y el error “Half-width”. El error es la mitad
de la anchura de un intervalo de confianza del 95%. El nivel de confianza, “Confidence Level”, puede ser
modificado en las propiedades del experimento, Experiment Properties.
Pregunta 4: ¿Cuáles fueron los resultados para el número de pasajeros en el sistema de facturación, en
términos medios, mínimos y máximos, y de error?
Paso 4: Se puede añadir la desviación típica o estándar de la media haciendo clic con el botón derecho sobre
Filter Fields, y seleccionando la opción Std. Dev de “Show Field List”.
Pregunta 5: ¿Qué valor ha obtenido para la desviación típica del número de pasajeros en el sistema?

Paso 5: Para quitar un campo, arrástrelo a la lista de campos, PivotGrid Field List.
Sección 2.4: Usando experimentos
Suponga ahora que queremos analizar el efecto de los cambios en la capacidad o número de operarios en los
mostradores de facturación o check-in. Podríamos simplemente cambiar la capacidad y volver a ejecutar la
simulación para obtener nuevos resultados. Una forma mejor es montar un experimento de SIMIO,
“experiments”.
Paso 1: En el panel Facility, seleccione el objeto CheckIn. Haga clic con el botón derecho en la propiedad
capacidad inicial, Initial Capacity, y seleccione “Set Referenced Property”. Cree una nueva propiedad,
“Create New Referenced Property”, y denomínela CheckInCapacity.
Paso 2: En la pestaña “Project Home”, cree un nuevo experimento, “New Experiment”, y vea la pestaña de
diseño, “Design”. Se muestra nuestra nueva propiedad de referencia en una nueva columna.
Paso 3: Añada nuevos escenarios, nuevas filas en la tabla, y cambie los valores de la nueva variable
CheckInCapacity a 2, 3 y 4. Puede añadir filas haciendo clic en el símbolo asterisco “*” de la primera
columna. La tabla del experimento debe asemejarse a la mostrada en la Figura 2.3.
Propiedad de
Referencia
Figura 2.3: Escenarios del Experimento

Paso 4: Ejecute el experimento, que se compone de 10 repeticiones de cada escenario. Se finaliza
rápidamente puesto que SIMIO utiliza todos los procesadores de su ordenador.
Paso 5: Advierta que la tabla de resultados, Pivot Grid, incluye ahora columnas para cada escenario.
Pregunta 6: ¿Cuál es el tiempo medio en el sistema mínimo para el Scenario Cap4?
Paso 6: La pestaña de resultados, “Reports”, es una buena forma de comparar escenarios, pues estos se
ordenan bajo cualquier variable.
Pregunta 7: ¿Cuál es el valor medio y el error para el tiempo medio de permanencia en el sistema? ¿Por
escenario?
Paso 7: Suele ayudar y es aconsejable añadir variables de salida o respuesta, “responses”, en el experimento.
Simplemente, haga clic en “Add Response” en la pestaña “Design”. Añada las siguientes dos respuestas
con las siguientes expresiones:
Tiempo en el Sistema (TimeInSystem): Pasajero.TimeInSystem.Average

Número total atendido (TotalNumberProcessed): Pasajero.NumberDestroyed
Paso 8: Haga reset y empiece otra vez la simulación mirando a los resultados en los gráficos de respuesta
(“Response Chart” results) a la vez que la tabla de resultados (véase Figura 2.4). Para organizar las

pestañas, haga clic en la pestaña que desea mover y arrástrela a la posición que desee en la ventana.
También lo puede hacer con el botón derecho, para moverlas de forma agregada.
Respuestas
Gráficos de
Máximo respuesta
Mínimo Percentil del

75%
Media
Percentil del
25% Mediana
Figura 2.4: Resultados obtenidos

Paso 9: Claramente, a medida que la capacidad sube (hay más operarios), el tiempo en el sistema baja y el
número de clientes atendidos aumenta.
Paso 10: Puede modificar la gráfica utilizando las opciones proporcionadas por el “Response Chart”. La
gráfica muestra por defecto el máximo valor observado de la variable, el percentil del 75% o cuartil 3, la
mediana o el percentil del 50%, el percentil del 25% o cuartil 1 y el mínimo (véase Figura 2.4). La
sombra proporciona además el intervalo de confianza de la media, con el nivel de confianza especificado
en el experimento.
La desviación típica que se muestra en el “Results Field” es realmente el error estándar

(desviación típica de la media). No se calculan las desviaciones típicas de una repetición del
modelo, aunque sería posible y disponer de ella ayudaría en ciertos casos (por ejemplo, al
determinar políticas de gestión de stocks). El peligro estriba en que la desviación típica tomando
como base una única repetición no puede ser utilizada para calcular un intervalo de confianza
robusto, ya que las observaciones no provienen de una distribución normal y no son
independientes e idénticamente distribuidas (iid).
La tabla de los experimentos es similar al Process Analyzer de Arena. SIMIO, sin embargo,
permite ejecutar repeticiones y escenarios en múltiples procesadores en paralelo. Los gráficos en
SIMIO se denominan SMORE (SIMIO Measure of Risk and Error) plots (para más información,
lea el “Experiment Response Chart” en la documentación de SIMIO).
El Capítulo 12 describirá con más detalle la forma de analizar resultados: Gráficos SMORE,
selección de alternativas (selección de subconjuntos - subset selection -, ranking y selección -
ranking/selection -, y optimización).
En Arena, las salidas de los modelos se gestionan en MSAccess. SIMIO gestiona los resultados
internamente.

Capítulo 3
Caminos con Desvíos, Tablas de Ritmos y
Dependencias entre Entidades: Aeropuerto bis
En un aeropuerto, existe normalmente más de un tipo de facturación, así como más de un tipo de pasajero
(por ejemplo, auto check-in o un pasajero internacional). Nuestro objetivo es mejorar el modelo desarrollado
en el Capítulo 2, para dirigir los flujos hacia los diferentes mostradores de facturación cambiando los
patrones de llegada de los pasajeros en función de su tipología. Los cambios se realizan utilizando tablas de
datos (data tables) y de ritmos (rate tables). Como en el capítulo anterior, nuestra principal preocupación es
controlar el tiempo que tardan los pasajeros en facturar y llegar al control de seguridad, buscando determinar
el número de mostradores de facturación necesarios.
Sección 3.1: Elección de Caminos
Paso 1: Borre el objeto EXPERIMENT del modelo del aeropuerto desarrollado en el capítulo anterior.
Mejoraremos el modelo para incluir la elección de tres posibles rutas a seguir por los pasajeros que
llegan al aeropuerto. Los pasajeros que necesitan facturar y coger sus billetes pueden tanto facturar en la
acera exterior del terminal o en los mostradores principales dentro del aeropuerto, mientras que el resto
que no ha de facturar puede ir directamente hacia el control de seguridad (véase Figura 3.1).
Ruta1
Ruta2
Ruta3
Figura 3.1: Creando Caminos

Ruta1: Los pasajeros que facturan en la acera necesitan recorrer 10 yardas para llegar al mostrador
donde un único operario emplea para facturar entre 1 y 5 minutos, con una valor más habitual o
moda de 2 minutos. Una vez que han facturado, recorren 125 yardas hasta el control de seguridad.
Ruta2: Los pasajeros que han realizado la facturación online y no necesitan pasar por el mostrador,
sólo necesitan recorrer las 125 yardas hasta el control de seguridad.
Ruta3: El resto de pasajeros, que van a utilizar los mostradores dentro del edificio, necesitan recorrer
50 yardas hasta alcanzar uno de los dos mostradores que existen. Los operarios emplean por pasajero
entre 3 y 10 minutos, según un modelo uniforme. Para llegar al control de seguridad, han de recorrer
65 yardas más.
Paso 2: Se ha observado la distribución de probabilidades por ruta de los pasajeros (Tabla 3.1).

Tabla 3.1: Tipos de Pasajero
Check-in Porcentaje
Acera 10%
Mostrador 70%
No Check-in (Carry on) 20%
Paso 3: Para modelizar la decisión de un pasajero sobre su posible ruta, se ha de utilizar la propiedad
Selection Weight , de los objetos camino, PATH. La probabilidad de elegir una ruta en particular es el peso
otorgado a esa ruta dividido por la suma de los pesos otorgados a cada una de las rutas alternativas.
Incluya ahora los pesos a cada ruta (véase Figura 3.2).
Peso según
Probabilidad
Figura 3.2: Pesos para Cada Ruta

Paso 4: Recuerde que hay que seleccionar también la regla de conexión, en este caso de salida, Outbound
Link Rule. En esta caso hay que hacer referencia a las probabilidades, por lo que se elige la opción “By
Link Weight” en Output@Llegada (véase Figura 3.3).
Reglas de
Conexión
Figura 3.3: Regla de Salida

Paso 5: Simule el modelo una vez, con una duración de 24 horas. Puede que quiera mejorar la animación.
Pregunta 1: ¿Cuál es el número medio de pasajeros esperando tanto en la acera como en los
mostradores?
Pregunta 2: ¿Y los tiempos medios de espera en ambos procesos de facturación?
Caminos con Desvíos, Tablas de Ritmos y Dependencias entre Entidades: Aeropuerto bis 17
Pregunta 3: ¿Cuál es el tiempo medio de espera en el sistema de facturación?
Sección 3.2: Cambiando el Ritmo o Patrón de Llegada
Los pasajeros no suelen llegar con un ritmo constante a lo largo de todo el día a un aeropuerto (incluso si
llegan de forma aleatoria), por lo que debemos ampliar nuestro modelo para manejar esa situación. Nuestro
nuevo enfoque es permitir variaciones en los ritmos de llegada a lo largo del día. Para modelizar estos
cambios de ritmo, utilizaremos un objeto en SIMIO que se denomina tabla de ritmos, RATE TABLE. Esta tabla
se ha de referenciar cuando se determine la lógica de llegadas de un objeto fuente, o SOURCE. Es importante
comprender que los tiempos entre llegadas consecutivas para estos ritmos asumirán que provienen, como es
habitual, de una distribución exponencial. La media de esta distribución es lo que cambia durante el día. Si
estos tiempos son uniformes, es conocido que el número de llegadas sigue una distribución Poisson. Como el
parámetro (su media) cambia con el tiempo, se denomina formalmente como un proceso de llegadas “Poisson
no-homogéneo”, o NHPP (Non-Homogeneous Poisson Process). De esta forma, cuando se utiliza una tabla
de ritmos de SIMIO, se asuma que el proceso de llegadas es NHPP.
Paso 1: Para crear un patrón de llegadas, RATE TABLE, seleccione los datos en la pestaña “Data” y luego
haga clic en Create→Rate Table, asignando el nombre PassengerArrivalRate. La Tabla 3.2 muestra el
flujo por hora a lo largo de las 24 horas del día. Se muestra que llegan más pasajeros por la mañana entre
las 6 y las 9 y por la tarde entre las 18 y las 20 horas. Un ritmo de 0 implica que no llegan clientes
durante esa hora.
Tabla 3.2: Patrón Horario de Llegadas

Comienzo del Intervalo Final del Intervalo de Tiempo Ritmo de
de Tiempo Llegada
Día 1, 00:00:00 Día 1, 01:00:00 0
Día 1, 01:00:00 Día 1, 02:00:00 0
Día 1, 02:00:00 Día 1, 03:00:00 0
Día 1, 03:00:00 Día 1, 04:00:00 0
Día 1, 04:00:00 Día 1, 05:00:00 0
Día 1, 05:00:00 Día 1, 06:00:00 30
Día 1, 06:00:00 Día 1, 07:00:00 90
Día 1, 07:00:00 Día 1, 08:00:00 100
Día 1, 08:00:00 Día 1, 09:00:00 75
Día 1, 09:00:00 Día 1, 10:00:00 60
Día 1, 10:00:00 Día 1, 11:00:00 60
Día 1, 11:00:00 Día 1, 12:00:00 30
Día 1, 12:00:00 Día 1, 13:00:00 30
Día 1, 13:00:00 Día 1, 14:00:00 30
Día 1, 14:00:00 Día 1, 15:00:00 60
Día 1, 15:00:00 Día 1, 16:00:00 60
Día 1, 16:00:00 Día 1, 17:00:00 75
Día 1, 17:00:00 Día 1, 18:00:00 100
Día 1, 18:00:00 Día 1, 19:00:00 90
Día 1, 19:00:00 Día 1, 20:00:00 30
Día 1, 20:00:00 Día 1, 21:00:00 0
Día 1, 21:00:00 Día 1, 22:00:00 0
Día 1, 22:00:00 Día 1, 23:00:00 0
Día 1, 23:00:00 Día 2, 00:00:00 0

Aunque puede modificar la duración y el número de los intervalos de tiempo durante los cuales el
ritmo de llegada es constante, no se puede modificar el ritmo, que está fijado según los eventos por
hora, events per hour.
Paso 2: Modifique la fuente Llegada (véase la Figura 3.4 en busca de detalles).
Modifique las
llegadas
Figura 3.4: Especifique un Ritmo de Llegada Variable

Paso 3: Ejecute el modelo otra vez y analice los resultados.
Pregunta 4: ¿Cuál es el tiempo medio de espera en cada uno de los tipos de mostrador?
Pregunta 5: ¿Cuál es el tiempo medio de facturación de un pasajero?
Sección 3.3: Diferenciando entre Entidades: Tablas de Datos
En un aeropuerto aparecen distintos tipos de pasajero. Algunos son viajeros nacionales mientras que otros
son viajeros internacionales. Algunos pasajeros son minusválidos y requieren atención especial. Los
diferentes tipos de pasajeros implican distintos tipos de proceso. Para modelizar estos tres casos, se usan
tablas de datos, Data Tables.
Paso 1: Para crear una tabla de datos, DATA TABLE, haga clic en “Tables” en la pestaña “Data”, y luego en
“Add Data Table.” Llámela PassengerTable. En nuestra tabla de datos, se ha de mostrar el tiempo de
procesos para cada uno de los tres tipos de pasajero en cada mostrador de facturación. Seleccione las
propiedades en la opción “Standard Property” en la sección Properties. La propiedad PassengerPriority
será de tipo entero, Integer, mientras que los tiempos de facturación serán propiedades tipo Expression7.
Las prioridades 1, 2, y 3 representan los pasajeros nacionales, internacionales y minusválidos (Figura
3.5).
Propiedades
Figura 3.5: La Tabla de Datos
Si primero especifica el nombre “General”, se convertirá en el valor por defecto de la propiedad “DisplayName”.
Aunque los tiempos de facturación estén en minutos, no tenemos que especificar sus unidades, “Unit
Type” (véase Figura 3.68).
Dejar sin
Especificar las
Unidades de
Tiempo
Figura 3.6: Propiedades de Check-In

Paso 2: Referenciaremos estos tiempos de llegada directamente desde la tabla de datos, utilizando la
propiedad, InitialPriority , y la variable de estado Priority del objeto Pasajero. Para inicializar las
prioridades de forma diferente para representar cada uno de los tipos de Pasajero, debemos utilizar una
distribución discreta, Discrete (introducida según su distribución acumulada). En la Figura 3.7, cada
tipo de pasajero que es igualmente posible.
Distribución
Prioridad
Discreta donde
Inicial cada tipo de
pasajero es
igualmente
posible (un
tercio)
Figura 3.7: Propiedades de Pasajero

Paso 3: Una propiedad, “property”, de un objeto se inicializa cuando se crea el objeto y no puede ser
cambiada. Aún es más, comparte sus valores con todos los demás objetos. Una variable de estado, “state
variable”, es una característica de un objeto que sí puede ser alterado. Además, las variables de estado
pueden ser asociadas con objetos individuales y así cada objeto tiene sus propios valores (pero
modificables). La propiedad InitialPriority se define en SIMIO para todas las entidades del modelo, pero
se asigna inmediatamente por SIMIO cuando se crea la correspondiente variable de estado Priority
(también definida por SIMIO).
Pregunta 6: ¿Dónde se puede encontrar la definición de MODELENTITY sobre la variable de estado

Priority?
Puede parecer obvio que las unidades de las propiedades de tiempo se deben especificar; sin embargo, si las unidades de tiemp o no
están en horas (véase Paso 3), SIMIO no hará la interpretación apropiada. Por eso es mejor dejar las unidades sin especificar y no se
intentarán convertir los datos hasta que se usen.
Paso 4: Necesitamos ahora especificar el tiempo de proceso de los distintos mostradores de facturación para
que dependa del tipo de pasajero. Para ello se trabaja con la variable de estado Priority:
En CurbSideCheckin:
PasajeroTabla[Pasajeros.Priority].CurbSideCheckInTime
En CheckIn:
PasajeroTabla[Pasajeros.Priority].InsideCheckInTime
Perciba que lo que va entre corchetes [] se usa para designar la fila específica dentro de la tabla, de forma
similar a las matrices en los lenguajes de programación. Desafortunadamente, el editor de expresiones no
conoce las propiedades de la tabla de datos, DATA TABLE, por lo que se debe teclear la propiedad dentro
de la expresión. También, asegúrese de que las unidades del tiempo de proceso son minutos.
Paso 5: Ejecute el modelo. Acuérdese de que no llega nadie hasta las 5am, por lo que no hay animación
hasta ese momento.
Pregunta 7: ¿Cuál es el tiempo medio de espera por tipo de facturación (Curbside y Inside)? 9
Pregunta 8: ¿Cuál es tiempo medio de facturación para un pasajero?
Sección 3.4: Más sobre Rutas
Hay veces que las filas en los mostradores tradicionales de dentro del edificio parecen saturadas. Decidimos
añadir un segundo mostrador dentro del terminal para atender a los pasajeros durante los períodos pico.
Esencialmente, los pasajeros se dirigirán a aquella fila que tenga menos gente. La distancia desde este
segundo grupo de mostradores al control de seguridad es de 75 yardas.
Paso 1: Añada el segundo mostrador. Llámelo CheckIn2. Asuma que tiene una capacidad de 1 y un tiempo
de proceso igual a los de los otros mostradores. Añada un camino adicional de 75 yardas hasta el control
de seguridad, Security.
Paso 2: Hay que modelizar la decisión que toman los pasajeros que facturan en el interior del terminal de
forma que se dirijan a la fila con menos gente. Hay varias formas para modificar el modelo. Quizá la
forma más obvia sea añadir un TRANSFERNODE que manda pasajeros a la cola más corta. La distancia
desde LLEGADA a este TRANSFERNODE es de 50 yardas (recuerde que el peso es 70 para este camino y que
tendrá que borrar el camino original hacia el objeto CheckIn).
En el TRANSFERNODE se debe especificar la regla Outbound Link Rule como “By Link Weight”
Marque las propiedades de pesos, Selection Weights, de los dos caminos que salen del
TRANSFERNODE (el “valor” de una expresión verdadera, “true”, es 1 y 0 si es falsa, “false”)
Hacia CheckIn:
CheckIn.InputBuffer.Contents.NumberWaiting <=
CheckIn2.InputBuffer.Contents.NumberWaiting
Los resultados del modelo no se separan automáticamente por tipo de pasajero. Hay que utilizar conceptos (por ejemplo, añadir tus
propias variables de resultados) que se describen en el Capítulo 5 y en el Capítulo 6.
Hacia CheckIn2:
CheckIn2.InputBuffer. Contents.NumberWaiting <
CheckIn.InputBuffer.Contents.NumberWaiting
Pregunta 9: ¿Cuál de los dos mostradores es el elegido cuando existen empates porque las filas
InputBuffer tienen el mismo número de pasajeros (por ejemplo, si las dos están vacías)?
Pregunta 10: ¿Cuál es la utilización de CheckIn2? ¿Tiene sentido tener los dos mostradores?
Sección 3.5: Horarios y Turnos de Trabajo
Supongamos que deseamos tener abierto el segundo mostrador sólo entre las 10am y las 6pm. Esta
problemática requiere la utilización de horarios de trabajo, que serán especificados con el componente
“Schedules” de la pestaña “Data”.
Paso 1: Haga clic en el botón “Add Schedule” en el icono “Schedules” de la pestaña “Data”. Denomine este
horario como SecondCheckInStation. Cambie el patrón de días de trabajo, Days in Work Pattern, a 1 –
este horario se repetirá todos los días.
Paso 2: En la pestaña de ciclo de trabajo, “Work Cycle”, haga clic con el botón derecho en la ventana para
que aparezca el editor de ciclos, “Edit Cycle Item”. Incluya un valor de 1 en la variable que especifica
que este recurso sí trabaja durante un período reducido, On Shift Value, y que empieza su jornada a las
10am y la acaba a las 6pm.
Paso 3: En la tapiz Facility, haga clic en el objeto CheckIn2. Cambie el tipo de capacidad de trabajo,
Capacity Type a WorkSchedule y el horario Work Schedule a SecondCheckInStation (Figura 3.8).
Horario de
Trabajo
Figura 3.8: Especificando un Work Schedule

Paso 4: Ahora, necesitamos asegurarnos de que la gente que elige facturar dentro del terminal sólo va hacia
el segundo mostrador CheckIn2 cuando esté abierto. Se necesita otro TRANSFERNODE (Figura 3.9).
Input@CheckIn
Llegada de
Pasajeros TRANSFERNODE en el que se
elige la fila más corta
Nuevo TRANSFERNODE
para elegir un mostrador Input@CheckIn2
que esté abierto
Figura 3.9: Añadiendo un TransferNode para Mejorar la Lógica

El nuevo TRANSFERNODE debe dirigir también a los pasajeros según el peso By Link Weight.
El camino hasta Input@CheckIn tiene una distancia de 0 y una propiedad

Selection Weight: TimeNow <=10 || TimeNow>=18

El camino hacia TRANSFERNODE para elegir la fila más corta tampoco tiene longitud y
como propiedad Selection Weight: TimeNow > 10 && TimeNow <18
Paso 5: Ejecute el modelo y obtenga los siguientes resultados:
Pregunta 11: ¿Cuál es el tiempo medio de facturación de un pasajero?
Pregunta 12: ¿Cuál es el tiempo medio de espera de un pasajero en el mostrador situado en la acera?
Pregunta 13: ¿Cuál es el tiempo medio de espera de un pasajero en el mostrador del terminal?
Pregunta 14: ¿Cuánto tiempo está trabajando el operario que está situado en el mostrador de la acera?
¿Porcentaje de utilización?
Pregunta 15: ¿Cuánto tiempo están trabajando los operarios que están situados en los mostradores
interiores? ¿Porcentaje de utilización?
Paso 6: Dése cuenta que en la simulación, hay pasajeros que están en fila cuando el mostrador CheckIn2
cierra porque acaba su jornada. Allí se quedan estancados; solucionaremos el problema en otro capítulo
más adelante.
La especificación de NHPP en SIMIO es casi idéntica a la de Arena, incluso cuando se fija en

número de unidades según el ritmo de llegada (llegadas por hora).
SIMIO cambia la probabilidad acumulada y su valor de cómo se especificaba una distribución
discreta en Arena. Ambas requieren que se incluyan de forma acumulada. Tenga cuidado.
No resulta obvio que las unidades de medida no deban ser especificadas cuando se usan en las
tablas de datos otras que no sean horas (o metros). La razón no está clara y se basa en cómo
SIMIO convierte tiempos en horas y distancias en metros. Por ejemplo, supongamos que su tabla
de datos incluye un tiempo de proceso de 30 minutos (especificando minutos). SIMIO
almacenará este valor como 0.5 horas. Si entonces se referencia este tiempo como tiempo de
proceso en minutos, el valor se usa como si fuera en minutos. Al dejarlo sin especificar, los datos
de la tabla no se convierten y se interpretan de forma correcta. Más aún, podríamos decir también
que el tiempo de proceso es en horas y si la tabla de tiempos utiliza minutos como unidad, la
conversión también es correcta. Lo que se ha dicho sobre tiempo también aplica a distancias,
pues la unidad básica en SIMIO es el metro. Una de las razones de utilizar este sistema de
conversión es que se referencia directamente la propiedad de tabla a través de su fila y SIMIO no
se acuerda de las unidades de esta propiedad. Más adelante, utilizaremos referencias que no
emplean una referencia directa y por tanto no serán necesarias estas manipulaciones de unidades.
En SIMIO, cuando la capacidad de un servidor se hace cero y todavía hay entidades que se están
procesando, se acabarán las operaciones. Los usuarios de Arena reconocerán esta situación como
una de las tres reglas de resolución de conflictos (“ignore”, wait, preempt). Si ésta no es la regla
deseada, necesitará implementar una regla adicional utilizando conceptos más avanzados, que
serán descritos más adelante.
Capítulo 4
Secuencias y Viajeros: Célula de Fabricación
Más opciones de modelización utilizando objetos básicos SOURCE, SERVER, y
SINK. Secuencias de entidades.
Uso de vehículos
Una pequeña célula de fabricación está compuesta por tres estaciones de trabajo en la que se procesan cuatro
piezas distintas. Las estaciones A, B, y C, se disponen de forma que las piezas sigan una ruta circular (Figura
4.1). Si una pieza cumple su último proceso en la Operación C, tendrá que ir a la Operación A y luego a la B
antes de dirigirse hacia la salida. Se desea realizar una simulación de una semana de 5 días, con un jornada
de trabajo diaria de 8 horas, para un total de 40 horas en una semana.
Llegada Salida de
de Piezas Dirección de Piezas
Movimiento
Figura 4.1: Disposición en Planta o Layout

Layout:
Todas las piezas llegan a la entrada, “Parts Arrive”, y salen de la planta por la salida, “Parts Leave”. La
velocidad de movimiento es constante a 2 millas por hora. Piense que las unidades de velocidad por defecto
en SIMIO, Initial Desired Speed, para las distintas entidades es metros por segundo.
Las distancias (yardas) entre estaciones se muestran en la Tabla 4.1.
Tabla 4.1: Distancias entre Estaciones

Caminos Distancias (yardas)
Desde la Entrada a la Operación A 25
Desde la Operación A a la Operación B 35
Desde la Operación B a la Salida 20
Desde la Salida a la Operación C 30
Desde la Operación C a la Entrada 40

Piezas:
La llegada de piezas es como sigue10:
La Pieza 1 llega aleatoriamente con una media de 15 minutos entre llegadas.
La Pieza 2 tiene un tiempo entre llegadas con una media de 17 minutos y una desviación típica de 3
minutos.
La Pieza 3 puede llegar con un tiempo entre llegadas consecutivas entre 14 y 18 minutos.
La Pieza 4 llega en lotes de 5, con una cadencia prácticamente exacta de 1 hora y 10 minutos.
Pregunta 1: ¿Qué distribuciones elegiría para modelizar estos cuatro procesos de llegada?
Cada una de los tipos de piezas (entity) presenta una ruta distinta de procesamiento. De hecho, no todas
tienen que pasar por todas las estaciones. Las secuencias se muestran en la Tabla 4.2.
Tabla 4.2: Secuencia por Pieza
Paso 1 2 3
Pieza 1 Operación A Operación C
Pieza 2 Operación A Operación B Operación C
Pieza 3 Operación A Operación B
Pieza 4 Operación B Operación C
Propiedades de las Estaciones:

La Operación A es una máquina con un tiempo de proceso que varía entre 2 y 8 minutos con un valor
modal de 5 minutos.
La Operación B tiene dos máquinas, cada una con un tiempo de proceso que varía entre 5 y 11
minutos, con un tiempo más habitual de 9 minutos.
La Operación C se compone de dos máquinas que operan durante las cuatro primeras horas de cada
día y una máquina que lo hace durante las últimas cuatro horas. Cada una tiene un tiempo de proceso
que varía entre 2 y 11 minutos con una moda de 6 minutos.
Pregunta 2: ¿Qué distribuciones siguen los tiempo de proceso?
Sección 4.1: Construyendo el Modelo
Paso 1: Primero, cree el modelo en SIMIO utilizando cuatro fuentes, SOURCES, para cada una de las cuatro
entidades (arrastrando cuatro MODELENTITIES dentro del tapiz). Son necesarias cuatro fuentes de piezas
porque cada una tiene su propio proceso de llegada. Necesitaremos tres servidores, SERVERS (uno para
cada estación) y un único sumidero, SINK. Denomine cada objeto de forma que sean fácilmente
reconocibles (Figura 4.2).
Paso 2: Probablemente el mejor método para simular la circulación circular sea utilizar un nodo básico
BASICNODE, tanto en la entrada como en la salida de cada estación11. Esto permite a las entidades seguir
el patrón de las secuencias sin tener que añadir procesos no deseados.
Por ahora, le dejaremos pensar sobre cuál es la distribución más adecuada en función de estos parámetros.
Secuencias y Viajeros: Célula de Fabricación 25

Paso 3: Conecte los objetos utilizando conectores, CONNECTORS, y caminos, PATHS. Percátese de que como
no hay tiempo o distancia a recorrer entre los caminos circulares y las estaciones, usaremos conectores.
Las distancias entre estaciones se calcularán utilizando cinco caminos que conectan cada nodo de entrada
y de salida. Asegúrese que dibuja los conectores y los caminos en la dirección correcta – si hace un
zoom, verá las “flechas” como se muestra en la Figura 4.2.
Conectores
Nodo
Básico
Caminos
Figura 4.2: Modelo Inicial

Paso 4: Cambie las propiedades de cada entidad de forma que se muevan a la velocidad deseada de 2 millas
por hora12.
Paso 5: Cambie las propiedades de las fuentes de forma que incluyan la pieza y los patrones de llegada
correctos. Elegimos la distribución Exponencial, Normal, y Uniforme, respectivamente, para los tiempos
de llegada de las piezas 1, 2, y 3, incluyendo los parámetros proporcionados para cada caso. Para la Pieza
4, elegimos un tiempo entre llegadas constante de 70 minutos y en la propiedad lote, Entities Per Arrival,
introducimos un valor de 5.
Paso 6: Incluya las distancias entre estaciones que cubren cada uno de los cinco caminos. Tendrá que
especificar como “False” la propiedad Drawn To Scale para cada camino.
Paso 7: Utilice para el tiempo de proceso de cada estación la distribución Beta habitual en la técnica Pert de
control de duración de tareas, Pert (BetaPert). En general, se prefiere la distribución Beta a Triangular. Se
especifican las dos con los mismos parámetros (mínimo, moda, máximo), pero no son tan probables los
valores extremos, lo que suele representar más fiablemente los tiempos de proceso.
Sección 4.2: Especificando las Capacidades
Paso 1: Especifique las capacidades de la Operación A y la Operación B como “1” y “2”, respectivamente.
Para la Operación C, necesitaremos añadir un horario que recoja los cambios en capacidad a lo largo de
la jornada.
Un TRANFERNODE para la entrada/salida de una estación romperá la secuencia interna de SIMIO en cuanto a los pasos de las piezas
si no es cuidadoso.
Seleccione las cuatro entidades utilizando la tecla Ctrl y especifique la velocidad simultáneamente para todas las entidades.
Paso 2: En la pestaña “Data”, seleccione “Schedules” en el panel izquierdo, y luego “Add Schedule”. Llame
al horario, work schedule, ScheduleForC y deje sin rellenar la propiedad de fecha de inicio, Starting
Date, que será identificada en las opciones del menú de ejecución, Run.
SIMIO repetirá el ciclo de trabajo tantas veces como días haya en el patrón de trabajo. Dado que
nuestra simulación empezará a las 12am y durará 40 horas, hemos de rellenar el campo “días” como
“1” en la propiedad Work Pattern y dejar que se repita el ciclo una vez pasadas 24 horas.
Señale ahora las cuatro primeras horas de la pestaña “Work Cycle” empezando a las 12am y haga clic
con el botón derecho para añadir un nuevo elemento en el ciclo de trabajo. Cuando aparezca la
ventana de diálogo, cambie la opción a On Shift con un valor de “2” y haga clic en OK. Señale
después las cuatro siguientes horas, añada un elemento, y cambie la opción a On Shift con un
valor de “1”. Repita este proceso para todo el día.
Paso 3: Vuelva a la pestaña “Facility” y asigne a la propiedad Capacity Type de la Operación C el valor
“WorkSchedule”, incluyendo ScheduleForC.
Pregunta 3: ¿Durante cuántas horas en un día de 24 horas es la capacidad de la Operación C igual a 2?
Sección 4.3: Incorporando Secuencias
Según la configuración actual de nuestro modelo, las entidades se separarán en los nodos en función de pesos
y de la dirección del enlace. Sin embargo, deseamos que las piezas sigan una secuencia establecida de
estaciones. Queremos estar seguros que siguen una ruta circular hasta que lleguen al nodo que les dirige a la
estación apropiada. Para modelizar esta situación, utilizaremos las denominadas Tablas de Secuencias,
“Sequence Tables” (pestaña “Data”).
Paso 1: Haga clic en el botón con el que se añade una tabla, “Add Sequence Table”, y denomine la nueva
tabla como SequencePart1 para que corresponda con la primera pieza. Añada otras tres tablas, una para
cada una de las otras tres piezas.
Paso 2: Añada la secuencia de nodos que debe seguir la Pieza 1. Sólo es necesario incluir los nodos a visitar
así como la salida. Una vez que la secuencia está lista, siempre seguirá la ruta más corta hasta llegar al
primer nodo de la lista. La secuencia correcta para la Part1 se detalla en la Figura 4.313.
Asegúrese de
incluir la salida en
la secuencia
Figura 4.3: Secuencia para la Pieza 1

Paso 3: Incluya la secuencia para cada una de las otras tres piezas. Los nombres de las estaciones pueden
aparecer de forma diferente en función de cómo hayan sido denominados.
Vea que se especifican los nodos de entrada de los SERVERS y SINK en vez de los objetos.

Paso 4: Vuelva a la pestaña “Facility” y haga clic en la entidad Part1. Establezca la propiedad de secuencia
inicial, Initial Sequence, en “SequencePart1”, que ha sido creada con anterioridad para la Pieza 1. Haga
lo mismo para las otras entidades y sus secuencias.
Paso 5: Para cada uno de los 7 nodos, TRANSFERNODES (nodos de salida de cada fuente y estación), cambie la
propiedad de destino, Entity Destination Type, a “By Sequence”. Cuando por primera vez una entidad
pasa por uno de los nodos en que la opción es “By Sequence”, el nodo marca como destino de la entidad
el valor del indicador de la primera fila de la tabla de secuencias, SEQUENCE TABLE. Después de eso, cada
vez que una unidad pasa por un nodo de transferencia con destino “By Sequence”, el indicador de fila de
la tabla se incrementa en 1 y el destino de la entidad se marca como el siguiente nodo en la tabla14.
Pregunta 4: Al pasar por un BASICNODE, ¿cambiará el indicador de fila de una tabla de secuencias,
SEQUENCE TABLE?
Paso 6: Antes de ejecutar la simulación, puede ser apropiado cambiar los colores de cada una de las piezas
de forma que sea fácil distinguirlas en el modelo. También ayudará para verificar que siguen la secuencia
correcta. Ejecute la simulación durante 40 horas a un ritmo lento para cerciorarse de que las piezas
siguen la secuencia correcta.
Pregunta 5: Desactive las llegadas de todos los tipos de piezas menos de 1. ¿Sigue la secuencia correcta?
Sección 4.4: Mejora: Carritos de Transferencia
Podemos ahora aprender que en lugar de que dejen el sistema, las piezas han de ser transportadas en un
carrito hasta el almacén que está situado a 300 yardas. El carrito puede transportar un máximo de 3 piezas a
una velocidad de 4 pies por segundo. Después de descargar las piezas, ha de volver a recoger un nuevo lote
de piezas o esperar a que haya alguna para ser transportada. El carrito no tiene por qué estar lleno para
dirigirse al almacén, esto es, llevará las piezas que estén disponibles, en este caso, 1, 2 ó 3.
Paso 1: Borre el conector entre el objeto salida y el nodo básico anterior. Incluya un nodo de transferencia,
TRANSFERNODE, entre los dos. Llame a este nuevo nodo TransferCart. Conecte el BASICNODE al
TRANSFERNODE con un camino, PATH, de 10 yardas de longitud. Conecte el nodo de transferencia al
sumidero con un camino o PATH (asegurando que es bidireccional, bidirectional, de forma que el carrito
pueda moverse en ambas direcciones). Fije la longitud del camino en 300 yardas.
Paso 2: Arrastre dentro del tapiz un vehículo, VEHICLE de la [Standard Library]. Los cambios deben
asemejarse a lo mostrado en la Figura 4.4.
14
Si el indicador de fila corresponde a la última fila y la entidad entra en un TRANSFERNODE con un destino “By Sequence”, el
indicador de fila volverá a tomar el valor 1.
Parking del Cart
Crear espacio hasta

TRANSFERNODE para tres piezas
TransferCart alargando la fila de
donde se cogen
piezas
Figura 4.4: Añadiendo un Vehículo

Paso 3: Cambie la propiedad del TRANSFERNODE, Ride On Transporter, a “True” y especifique como
transportador, Transporter Name, a “Cart” (Figura 4.5). Cada vez que una entidad pase por este nodo,
generará una petición de transporte al vehículo especificado. La entidad no puede continuar hasta que el
vehículo llega a recogerla.
Figura 4.5: Especificando el Nodo para que las Entidades Utilicen un Transportador
Paso 4: Use la Figura 4.6 como guía para que el vehículo Cart circule con la velocidad deseada, Initial
Desired Speed, 4 pies por segundo, así como su capacidad de transporte, Ride Capacity, a 3. Recuerde
también que debe asignar el sitio donde debe aparcar un vehículo, Initial Node(Home), como
TransferCart. Cambie ahora la propiedad Idle Action a “Park At Home”, con lo que el vehículo se
dirigirá a su garaje cuando no hay entidades que hayan lanzado peticiones de transporte. Si no lo indicara
así, el vehículo se mantendría en la salida hasta recibir una nueva petición. Aumente también el tamaño
del lugar donde las entidades esperan a ser recogidas (Figura 4.4).

Figura 4.6: Propiedades del Vehículo
Paso 5: Adicionalmente, se necesita un lugar donde aparcar al vehículo de forma que no desaparezca cuando
esté aparcado15. Haga clic en el nodo TransferCart y seleccione “Draw Queue” de la pestaña
“Appearance”. Haga clic a su vez en “ParkingStation.Contents”. Un cursor con forma de cruz
aparecerá en el tapiz. Haga clic con el botón izquierdo en el lugar donde quiere situarlo (antes de hacer
clic con el botón derecho para localizar el final de la fila, puede continuar haciendo clic con el botón
izquierdo para añadir más vértices). Haga clic en la fila y en la ventana de propiedades para cambiar
Queue State ParkingStation.Contents. Esta fila permitirá la animación del parking del nodo
TransferCart para los vehículos que aparquen en este nodo.
Paso 6: Simule para ver cómo se comporta el vehículo visualmente.
Paso 7: El modelo no muestra cuántas piezas están esperando al carrito en el nodo de transferencia, por lo
que será útil ver cuántas se encuentran esperando en cualquier momento de la ejecución. Podemos añadir
la denominada Fila Separada, “Detached Queue.”
Paso 8: En la pestaña de “Animation”, haga clic en “Detached Queue.” Aparecerá un cursor en el tapiz
principal. Haga clic con el botón izquierdo en el sitio donde quiere que empiece la fila y después con el
derecho en el lugar que quiere que finalice (antes de hacer clic con el botón derecho para localizar el
final de la fila, puede continuar haciendo clic con el botón izquierdo para añadir más vértices). Como se
aprecia en la Figura 4.7, dibuje la fila en forma de “L”. De otra forma, una entidad parece que está
intentando entrar en el nodo y al sobreponer “L” se muestran todas las entidades que están esperando ser
transportadas.
Fila Separada
para las entidades
que esperan para
ser recogidas
Figura 4.7: Fila de Recogida
La fila de aparcamiento sólo es para la animación, puesto que el transportador está físicamente en el nodo incluso si no se muestra
en pantalla.
Haga clic ahora en la cola y en la ventana de propiedades cambie Queue State a
TransferCart.RidePickupQueue, donde TransferCart es el nombre del nodo de
transferencia en donde se recogen las piezas acabadas. Su nombre puede ser diferente.
Paso 9: Simule para ver cómo se comporta la Fila Separada.
Pregunta 6: ¿Cuál es el porcentaje de utilización del carrito durante las 40 horas que dura la repetición?
Los horarios y patrones de trabajo, Work schedules, las secuencias, sequences, las colas
separadas, detached queues, y los transportadores o vehículos, presentan en SIMIO
características similares a las de Arena.
La animación en SIMIO garantiza un vista atractiva, mucho más realista que la de Arena. El
uso de vehículos en SIMIO es fácil de implantar y más fácil de usar que en Arena.

Capítulo 5
Agrupaciones, Funciones, Variables de Estado, y
Estadísticas: Ensamblaje de Tarjetas de Memoria
Agrupando y combinando
entidades Direccionando entidades
Tiempo de proceso que depende del tamaño de la
fila Estadísticas y variables de salida
Las tarjetas de memoria contienen unos chips de memoria insertados mediante una operación de ensamblaje,
con capacidad 4. Cada tarjeta de memoria requiere cuatro chips. Las tarjetas de memoria, así como los chips,
llegan de forma aleatoria, por lo que el ensamblador espera a tener cuatro chips del mismo tipo y una tarjeta
antes de realizar el ensamblado. Después, la tarjeta de memoria ensamblada se manda a una de tres
estaciones de empaquetado, cada una con un operario. Las tarjetas se mandan a la fila de empaquetado con
un menor número de unidades esperando. Estas características numéricas se resumen en la Tabla 5.1.
Tabla 5.1: Distribuciones Numéricas de las Características de las Tarjetas de Memoria

De A Tiempo (minutos)
Llegada de las Tarjetas de Memoria Ensamblaje de Uniforme(3,5) minutos
Tarjeta
Llegada de los Chips de Memoria Ensamblaje de Uniforme(4,6) minutos
Tiempos de Tarjeta
Desplazamiento Ensamblaje de Tarjeta Packer Operación 1 Pert(10,12,15) minutos
Ensamblaje de Tarjeta Packer Operación 2 Pert(5,7,10) minutos
Ensamblaje de Tarjeta Packer Operación 3 Pert(4,5,7) minutos
Cualquier Operación de Exit 3.5 minutos
Empaquetado
Tiempo entre Llegadas para las Tarjetas de Memoria Exponencial(2) minutos

Información
Tiempo entre Llegadas para los Chips de Memoria Exponencial(0.5) minutos
de Llegadas
50% de los chips son de Tipo 1 y 50% de Tipo 2 Discreta
Tiempos de Tiempo de proceso del Ensamblaje de Tarjeta Uniforme(2,4) minutos
proceso Tiempo de Empaquetado Triangular(3,5,8) minutos
Sección 5.1: Creando el Modelo
Paso 1: Cree un nuevo modelo con dos fuentes, SOURCES, una para tarjetas y otra para chips de memoria.
Añada dos entidades, MODELENTITIES, en el modelo, una denominada MemoryBoard para tarjetas, y
otra denominada Memory para chips.
Paso 2: Utilice distintos símbolos para diferenciar las entidades (Figura 5.1). Puede utilizar sus propios
símbolos si hace clic en el botón “New Symbol” en la sección “Create” de la pestaña “Project Home”.
Cuando cree un símbolo nuevo, debe especificar su altura, “height”, en metros. En el caso mostrado en
la Figura 5.1, se ha creado un rectángulo con una altura de 0.5 metros16. No hay que preocuparse en
Las tarjetas de memoria no son de 0.5 metros de ancho pero se ha hecho así para facilitar su visión en 3-D.
exceso sobre las especificaciones exactas ya que el símbolo puede ajustarse manualmente después de
hacer clic en el símbolo de MemoryBoard y utilizando nuestro nuevo símbolo (haciendo clic en
SYMBOL1 y en Symbols→Project Symbols).
Paso 3: Para los chips de memoria, añada un símbolo adicional17, coloreando este segundo símbolo con un
color diferente para diferenciarlos en el sistema.
Paso 4: Introduzca en el modelo un objeto agrupador, COMBINER, denominado BoardAssembly, para

representar la operación de ensamblado, como se muestra en la Figura 5.1, Este nuevo elemento
combinará un objeto “padre” (tarjeta) con un objeto “miembro” (chip). Especifique la capacidad inicial
del objeto BoardAssembly como “4”. Conecte las dos fuentes, SOURCES, con los nodos mediante
caminos, TIME PATHS.
Figura 5.1: Initial Memory Board Model

Paso 5: Recuerde que una tarjeta requiere cuatro chips idénticos. Por tanto, el combinador, COMBINER, debe
agrupar cuatro miembros del mismo tipo. Añada una variable de estado a las entidades para
distinguir entre los dos tipos de chips. Seleccione MODELENTITY en el panel [Navigation] y elija la
sección “States” de la pestaña “Definitions”. Como coexisten dos tipos distintos de chips, incluya
una nueva variable “Discrete State”, de nombre ChipType.
Paso 6: Volviendo a la pestaña “Facility”, haga clic en MemoryArrivals. Para asignar la nueva variable
ChipType, se especificará una asignación, Before Existing State Assignment, de forma que se
otorgue un valor a ChipType antes de que la entidad abandone la fuente. Haga clic en la opción que
se encuentra a la derecha de Before Exiting State Assignments para que aparezca el editor de
propiedades, “Repeating Property Editor”, y añada la siguiente propiedad:
State Variable Name: ModelEntity.ChipType

New Value: Random.Discrete(1,.5,1,1)18
Como es igual de probable que el chip sea de un tipo o del otro, se utiliza una distribución discreta
para asignar a ChipType el valor 1 o el valor 2.
Paso 7: Ahora, agrupe (batch) 4 miembros en el COMBINER mediante la especificación de Match Members
como una regla de agrupación, Matching Rule, con ModelEntity.ChipType como una propiedad
Member Match Expresión (Figura 5.2).19
Seleccione Memory y luego el botón Symbols→Additional Symbols→Add Additional Symbol.

La distribución Discrete debe ser especificada según las probabilidades acumuladas.
Agrupaciones, Funciones, Variables de Estado, y Estadísticas: Ensamblaje de Tarjetas de Memoria 33

Figura 5.2: Especificando la Lógica de Agrupación en un Combiner
Paso 8: Incluya 3 SERVERS, uno por empaquetadora con el tiempo de proceso apropiado, y un SINK
denominado Exit (Figura 5.3). Utilice TIMEPATHS para conectar la ensambladora con las empaquetadoras
y añada los tiempos de desplazamiento correspondientes (no conecte todavía las empaquetadoras con la
salida).
Utilice este
TRANSFERNODE
Figura 5.3: Las Empaquetadoras en el Modelo

Paso 9: Recuerde que las ensambladoras necesitan elegir la empaquetadora con el menor número ya
asignado. En el TRANSFERNODE de salida asociado al COMBINER, la decisión de direccionamiento necesita
ser especificada, utilizando la propiedad de destino, Entity Destination Type.
Paso 10: Cuando una tarjeta ya está ensamblada, puede seleccionar uno de tres destinos: Input@Packer1,
Input@Packer2, o Input@Packer3. Cree un nuevo nodo LIST (pestaña “Definitions”) y denomínelo
LstPackers, empezando con Input@Packer1 (Figura 5.4).
Figura 5.4: Nodo Lista para Elegir Empaquetadora

Paso 11: Ahora, en el TRANSFERNODE, especifique que las entidades deben ser direccionadas a los destinos de
acuerdo a las siguientes propiedades:
Entity Destination Type: Select from List

Node List Name: LstPackers
Selection Goal: Smallest Value ()
Los combinadores pueden casar entidades entre sí, casar miembros entre sí o casar ciertos miembros con padres.
Selection Expression: Candidate.Node.NumberRoutingIn+
Candidate.Server.InputBuffer.Contents.NumberWaiting+
Candidate.Server.Processing.Contents.NumberWaiting20
Pregunta 1: Examine la expresión de selección, Selection Expression, y advierta que se compone de tres
componentes. ¿Qué representan cada uno de ellos?
Paso 12: Especifique la forma de trasladarse desde las empaquetadoras a la salida utilizando una propiedad
del modelo, “Model Property”, que se encuentra en la pestaña “Definitions”. Incluya una propiedad
numérica de tipo real, “Real” , elegida del menú “Standard Property” y opción TimeToExit, y
especifique su valor por defecto, Default Value, como “3.5”, con las unidades por defecto en minutos
(Unit Type, Time; Default Units, Minutes).
Paso 13: Ahora ya puede especificar el tiempo de desplazamiento, Travel Time, de cada uno de los
caminos hasta la salida21 como , esto es, con una propiedad de referencia, reference
property. Si desea cambiar ahora el tiempo de desplazamiento de los tres caminos a la vez, sólo hay que
cambiar la nueva propiedad.
Paso 14: Guarde el modelo y ejecútelo durante 10 horas, y conteste a las siguientes preguntas.
Pregunta 2: ¿Cuánto están las entidades en el sistema (desde la entrada a la salida)?
Pregunta 3: ¿Cuál es el grado de ocupación de BoardAssembly?
Pregunta 4: ¿Cuál es el grado de ocupación de cada una de los empaquetadoras?
Sección 5.2: Cambiando el Tiempo de Proceso en Función de la Longitud de la Cola
Supongamos que es necesario cambiar el ritmo de operación de Packer1 en función del número de tarjetas
que están esperando (tamaño de la fila). Específicamente, la eficiencia de la empaquetadora es sólo del 80%
cuando no hay tarjetas esperando, 90% cuando hay 1, y 100% cuando hay al menos dos.
Paso 1: Necesita ahora incluir una tabla de eficiencias, “efficiency” table, para determinar el tiempo de
proceso. Esta tabla puede ser también modelizada como una tabla “Function” en SIMIO (dicho de otra
forma, f(x)). En la pestaña “Data”, añada una tabla discreta, “Discrete Function Table”, cuyos valores
son 0.8 cuando x = 0, 0.9 cuando x = 1, 1 cuando x = 2, y 1 cuando x = 100 (Tabla 5.2).
La designación de candidato, Candidate, es una referencia que toma como valor la identidad del objeto al que está haciendo
referencia. Aquí hace referencia al nodo hacia el que la entidad está siendo dirigida y la fila específica de entrada, INPUTBUFFER, o de
procesamiento, PROCESSING, de la estación que está al final del camino.
Seleccione a la vez los tres caminos y después haga click con el botón derecho en la propiedad Travel Time y seleccione la nueva
propiedad de referencia TimeToExit.

Tabla 5.2: Tabla con Función
Recuerde que la tabla interpola para valores que se encuentren entre los valores especificados.
Denomine Efficiency a la tabla.
Paso 2: En la propiedad ProcessTime de Packer1, cambie la expresión de forma que la distribución

Triangular se divida por la función de eficiencia cuando se calcula el tiempo real de proceso. Para buscar
en tablas, SIMIO utiliza la notación [] (no ()). La nueva expresión se define como sigue:
Random.Triangular(3,5,8)/
Function.Efficiency[Packer1.InputBuffer.Contents.NumberWaiting]
Pregunta 5: ¿Por qué dividimos el tiempo original del proceso entre la eficiencia?
Paso 3: Quisiéramos estar seguros de que nuestra función “eficiencia” está funcionando. Para comprobarlo,
utilizaremos un gráfico de estado, “Status Plot”, que se puede encontrar en la pestaña “Animation”.
Utilice las siguientes especificaciones para el gráfico.
Title: Efficiency at Packer 1

X Axis: Time
Y Axis: Number in Packer 1 Queue
Time Range: 10 Minutos
Asimismo, añada la expresión que será dibujada:
Paso 4: Parte del gráfico se muestra en la Figura 5.5.
Figura 5.5: Gráfico de Eficiencia

Pregunta 6: ¿Da la sensación que la función de eficiencia está funcionando?

Sección 5.3: Añadiendo Más Animación
Paso 1: Arreglemos primero la animación de la tarjeta de memoria de forma que parezca que los chips están
pegados. Haga clic en el símbolo de MEMORYBOARD y añada una fila del tipo BATCHMEMBERS que está
incluida en “Attached Animation” en el menú “Draw Queue”. Posiciónela encima del MEMORYBOARD
como se muestra en la Figura 5.6.
BATCHMEMBERS
Figura 5.6: Fila de Chips Ensamblados

Para poner un objeto encima de otro, necesita seleccionar el objeto y apretar luego la tecla Shift. Es
probablemente mejor hacerlo cambiando iterativamente entre 2-D y 3-D.22
Paso 2: Utilicemos el color de las tarjetas para designar y diferenciar entre los dos tipos. Para hacer esto,
haga clic en la entidad MEMORY y después en “Add Additional Symbol” en la sección “Additional
Symbols” dentro de la pestaña Symbols. Puede colorear un símbolo en rojo y el otro en verde mediante la
simple selección de un símbolo, activándolo como “Active Symbol”, y cambiándolo de color. Fíjese que
los dos símbolos han sido numerados como 0 y 1 (no 1 y 2).
Paso 3: También se puede asignar colores a los diferentes tipos de chip. Seleccione la fuente
MemoryArrivals. Haga clic en el recuadro que se encuentra a la derecha de Before Exiting State
Assignments, dado que queremos asignar el color antes de que la entidad se vaya de la fuente. Se abre
entonces el editor de propiedades “Repeating Property Editor”. Se debe añadir una variable de estado
adicional con las características siguientes:
State Variable Name: ModelEntity.Picture

New Value: ModelEntity.ChipType-1
El valor de una variable de estado, “state variable”, en contraposición al de una propiedad, puede
ser modificado durante la simulación, y el dibujo de una entidad se trata en SIMIO como si fuera
una característica de la entidad (lo que a veces se denomina como un atributo de la entidad).
Pregunta 7: ¿Por qué restamos 1 de la propiedad ChipType?
Paso 4: Simule para ver que la animación se comporta como debe.
Pregunta 8: ¿Cambian los chip de color en función de su tipo?
Paso 5: Supongamos que queremos que el símbolo que sale de la estación de empaquetado parezca un
“paquete”. Se puede realizar la animación de diversas formas. Una forma fácil es utilizar una asignación
Recuerde que la tecla “h” hace aparecer instrucciones sobre cómo mover los objetos tanto en 2D como en 3D, así como ideas
sobre cómo manipular objetos. Presionando la tecla “h” otra vez hace desaparecer las instrucciones.

de estado antes de dejar una estación, Before Exiting State Assignments; en este caso, en las
empaquetadoras. Desde una de las empaquetadoras, invoque al editor de propiedades, Repeating
Property Editor, y añada:
State Variable Name: ModelEntity.Size.Height

New Value: 2.1
Puede que tenga que experimentar con el valor. La idea es cambiar la altura, “height”, de la tarjeta de
memoria de forma que encapsule los chips para que no se vean (se esconde entonces los miembros
del lote dentro de la tarjeta).
Paso 6: Ejecute el modelo y ajuste la altura hasta que el icono que sale de la empaquetadora parezca un
paquete. Tendrá que realizar el mismo cambio en el resto de empaquetadoras.
Paso 7: Mire el modelo en 3-D y vea los cambios realizados.
Paso 8: Guarde el modelo y ejecútelo durante un período de 10 horas y conteste a las preguntas siguientes.
Pregunta 9: ¿Cuánto están las entidades en el sistema (desde la entrada a la salida)?
Pregunta 10: ¿Cuál es el grado de ocupación de BoardAssembly?
Pregunta 11: ¿Cuál es el grado de ocupación de cada una de las empaquetadoras?
Pregunta 12: ¿Cuál es el número medio de entidades en MemberInputBuffer?
Pregunta 13: ¿Cuál es el número medio de entidades en ParentInputBuffer?
Pregunta 14: ¿Cómo es la fila CombinerBatch?
Sección 5.4: Creando Estadísticas
Algunas veces, el proceso automático de cálculo y presentación de estadística simplemente no proporciona la

información que interesa. Por ejemplo, nos gustaría conocer el tiempo que emplean las tarjetas y los chips en
ir desde la entrada a la salida, o la eficiencia media de Packer1. El tiempo en el sistema, o en un subsistema,
es un ejemplo de lo que generalmente se conoce como variables basadas en observaciones, “observation-
based” statistics. Este tipo de variable se denomina en SIMIO como variable contador, “Tally Statistic”. En el
caso de la eficiencia, su valor cambia (con saltos discretos) a lo largo del tiempo, y la variable resultado se
denomina generalmente como variable basada en el tiempo, “time-persistent” o “time-weighted”. En SIMIO,
este tipo de variable se denomina variable de estado, “State Statistic” y como la eficiencia cambia al suceder
eventos concretos, se denomina variable de estado discreta “Discrete State Statistic”.23
Paso 1: Considere primero la variable eficiencia. Para calcular su valor, tenemos que definir una variable de
estado. En la pestaña “Definitions”, seleccione “States” y haga clic en “Discrete State” para definir una
nueva variable Packer1Efficiency.
No confundir una variable de estado, “state variable”, con una estadística de estado, “state statistic”.
Pregunta 15: Existen diversas variables de estado, pero la única discreta es la relevante. ¿Qué hay de
discreto en los cambio en eficiencia?
Paso 2: Para garantizar que Packer1Efficiency proporciona el valor correcto, modifiquemos las
asignaciones, “State Assignments”, en Packer1. En particular, hagamos la siguiente asignación al entrar
en la estación, On Entering:
State Variable: Packer1Efficiency

New Value:
Paso 3: Finalmente, necesitamos definir la estadística del tipo estado, “State Statistic”, lo que podemos
realizar desde la pestaña “Definitions”, pero en la sección de elementos, “Elements”. Denominémosla
Packer1Utilization y usemos Packer1Efficiency como nombre de la variable de estado, State Variable
Name.
Paso 4: Guarde y ejecute el modelo de simulación.
Pregunta 16: ¿Cuál es el grado de ocupación de la empaquetadora 1, Packer1Utilization?
Paso 5: Obtengamos también estadísticas sobre el tiempo de permanencia en el sistema tanto de las tarjetas
de memoria como de los chips. Una vez más, hay diversas formas de hacer esto. Aunque piense que tiene
que proporcionar información adicional a SIMIO, este es un caso en el que podemos ayudarnos en la
forma en que SIMIO calcula estadísticas. Recuerde que automáticamente se obtiene el tiempo en el
sistema de las entidades que cruzan el sumidero o salida. Utilizaremos esta forma de modelizar.
Paso 6: Para obtener resultados de las tarjetas y los chips, podemos separarlos y mandarlos a salidas distintas
– y hacerlo sin cambiar las estadísticas habituales. Nuestro enfoque se muestra en la Figura 5.7.
Miembros
separados
Figura 5.7: Separando Entidades
Se sustituye el sumidero, SINK, por un separador, SEPARATOR, de la [Standard Library], para que ayude
a separar los “padres” de los “miembros”. Los miembros se separan y se mandan a diferentes salidas.
Los distintos objetos se conectan con conectores, CONNECTORS.
La separación de miembros se basa en pesos, “Selection Weight.” El peso para las RedLeaves es:
ModelEntity.ChipType==1. Y para las GreenLeaves es: ModelEntity.ChipType==2.
Paso 7: Ejecute el modelo durante 10 horas y conteste a las siguientes preguntas.
Pregunta 17: ¿Cuál es el tiempo de permanencia de las tarjetas de memoria en el sistema?

Pregunta 18: ¿Cuál es el tiempo de permanencia de los chips rojos en el sistema?
Pregunta 19: ¿Cuál es el tiempo de permanencia de los chips verdes en el sistema?
Pregunta 20: ¿Cuál es el grado medio de ocupación de la empaquetadora 1 en las 10 horas?
Las funciones y las gráficas de SIMIO se asemejan a las de Arena. En cambio, las capacidades de
animación de SIMIO son claramente mejores.
El cálculo de estadísticas para variables de estado en SIMIO es similar al usado en Arena para las
variables que dependen del tiempo. El cálculo de estadísticas basadas en observaciones en SIMIO
no puede ser realizado en un módulo como en Arena. Sin embargo, como veremos en el siguiente
capítulo, el uso de procesos puede fácilmente adaptarse para obtener este tipo de información.

Capítulo 6
Procesos en SIMIO: Ensamblaje de Tarjetas de Memoria
bis
Disparadores de procesos, Add-On Process Triggers
Procesos Reutilizables
Pasos en un proceso (Asignar o Assign, Decidir o Decide, Contar o Tally,
Desagrupar o Unbatch, Apresar o Seize, Retrasar o Delay, Liberar o Release, etc.)
Recursos
Una característica innovadora de SIMIO es su capacidad para modificar el comportamiento de un objeto

mediante la utilización de procesos, SIMIO “Processes.” Estos procesos ofrecen una amplia gama de
oportunidades de modelización, que se emplearán en este y posteriores capítulos. Los procesos son muy
flexibles y pueden modelizar comportamientos dispares, yendo mucho más allá de las posibilidades
intrínsecas de un objeto (como un servidor, SERVER). Los procesos ayudan a ampliar y expandir las
capacidades de modelización del SIMIO básico.
Hay dos consideraciones básicas cuando se desarrollan y se usan procesos:

“Cuándo” se llama, se invoca o se ejecuta el proceso, y
“Cómo” se escribe un proceso para producir el comportamiento deseado.
Típicamente, los procesos se invocan mediante acciones de los objetos durante la simulación o por eventos
que el modelizador diseña. Escribir un proceso es similar a crear un flujograma estilizado, con excepción de
que los componentes del flujograma son etapas lógicas como Asignar, Decidir, Contar, Transferir, Apresar,
Retrasar, Liberar ... La ejecución de un proceso se realiza con una señal, ficha o “token.” Las fichas (o fichas)
provocan la realización de los pasos del proceso para un objeto, normalmente, el objeto que lanza la ficha o
aquel cuyo comportamiento se ve modificado por el proceso.
Sección 6.1: Los Disparadores de Proceso: Ilustrando el Proceso Assign
Casi todos los objetos de SIMIO tienen disparadores, “Add-On Process Triggers”. Estos disparadores hacen
que se ejecuten procesos externos, esto es, procesos arbitrarios diseñados por el propio usuario para cambiar
o expandir el comportamiento de un objeto (por ejemplo, SERVER). La otra opción sería clonarlos o hacer
subclases de los objetos (vea el Capítulo 18 para más información sobre subclases).
En el Capítulo 5, se cambiaron ciertas características o atributos de las entidades. En un caso, los distintos
tipos de una entidad (chips) se colorearon para facilitar su diferenciación, y, en un segundo caso, se
incrementó la altura de otra entidad (tarjeta de memoria) para mejorar la animación del modelo. En ambos
casos, cambiamos los valores de variables de estado, “state variables”, utilizando las propiedades de
asignación de estados, “State Assignments”. Verá que las posibilidades de realizar este tipo de asignaciones
son limitadas, mientras que son más numerosas si se utilizan disparadores. Más aún, los “State Assignments”
sólo pueden asignar valores, mientras que un proceso puede incorporar lógica más compleja que las
asignaciones simples.
Paso 1: Veamos cómo se pueden replicar las asignaciones, “State Assignments”, utilizando disparadores.
Abra el modelo usado en el Capítulo 5. Primero, elimine los “State Assignment” de MemoryArrivals
(utilizando el editor de propiedades).
Procesos en SIMIO: Ensamblaje de Tarjetas de Memoria bis 41

Paso 2: Haga clic en el menú “Add-On Process Triggers” para expandirlo.
Pregunta 1: ¿Qué disparadores están disponibles para los objetos fuente, SOURCE?
Pregunta 2: ¿Cuándo se pueden utilizar “State Assignments” con los objetos fuente?
Paso 3: Elija el disparador que se dispara cuando sale una entidad, “Exited”. Haciendo doble clic en este
disparador se creará un nuevo proceso denominado MemoryArrivals_Exited y se le remitirá a la
pestaña de procesos, “Processes”. Verá un flujograma con un comienzo, “Begin”, y un final, “End”
(Figura 6.1). Haciendo clic en uno de los pasos del proceso, puede insertarlo en el flujograma, que se
ajustará automáticamente.
Pregunta 3: Enumere alguno de las etapas disponibles que se pueden utilizar para crear un proceso.
Pregunta 4: ¿Por qué ha elegido los que ha citado?
Paso 4: Inserte una etapa asignar, Assign (Figura 6.1).
Insertar un paso “Assign”
Figura 6.1: Insertando un paso Assign

Paso 5: En propiedades, puede ver un sitio para incluir el nombre de la variable de estado, State Variable
Name, y su nuevo valor, Value. También puede invocar al editor de propiedades, Repeating property
Editor, si hace clic al lado de “Assignments (More).” En cualquier caso, añada las dos siguientes
asignaciones:
State Variable Name: ModelEntity.ChipType

New Value: Random.Discrete(1,.5,2,1)
State Variable Name: ModelEntity.Picture

New Value: ModelEntity.ChipType-1
Paso 6: Borre la asignación “On Entering” en Packer1. Cree un disparador “Entered” e introduzca un
proceso Assign que hace lo siguiente:
State Variable Name: Packer1Efficiency

New Value:
Sección 6.2: Creando un Proceso “Reutilizable”
En el modelo del Capítulo 5, la asignación utilizada para cambiar la altura de las tarjetas de memoria para
que la entidad se asemejara a un paquete compacto fue realizada en cada empaquetadora. Por supuesto, este
enfoque puede ser duplicado mediante la creación de un disparador “Exited” para cada una de las
empaquetadoras. Sin embargo, la misma lógica de asignación de la altura ha de ser incluida en cada uno de
los tres disparadores “Exited”. Creemos entonces un proceso que pueda se referenciado por cada una de las

empaquetadoras, en vez de crear un proceso distinto para cada empaquetadora. Este tipo de proceso se
denomina “reutilizable” y permite su modificación en un único sitio en lugar de en tres.
Paso 1: En la pestaña “Processes”, haga clic en el botón de creación de un proceso, “Create Process”,
denominando el nuevo proceso como Packaged. Añada una etapa Assign al flujograma con las
siguientes asignaciones.
State Variable Name: ModelEntity.Size.Height

New Value: 2.1
Paso 2: Borre los “State Assignments” de cada una de las empaquetadoras.
Paso 3: Vaya al disparador “Exited Add-On Process Trigger” de cada uno de las empaquetadoras. En lugar
de crear uno nuevo, seleccione el disparador Packaged de la lista.
Pregunta 5: ¿Cuál es la ventaja de tener un proceso y referenciarlo a cada operación de empaquetado en

lugar de tener los procesos duplicados en cada empaquetadora?
Paso 4: Ejecute el modelo y asegúrese de que replica el comportamiento previo.
Sección 6.3: Obteniendo Estadísticas Sobre Variables de Observación (Tally Statistics)
Recuerde que las estadísticas basadas en la observación se denominan TALLY en SIMIO. Estas estadísticas se
recogen como observaciones durante la ejecución de una simulación. Como ejemplos más habituales se
pueden citar los tiempos de permanencia en una fila, los tiempos totales de permanencia en el sistema o los
tiempos de ciclo. En general, son estadísticas cuyas observaciones son intervalos de tiempo.
Paso 1: Consideremos que son necesarias las estadísticas TALLY del tiempo que están tanto las tarjetas de
memoria como de los chips hasta que empiezan a ser empaquetadas en Packer1. Necesitamos definir
primero un nuevo elemento. En la sección “Definitions→Elements”, haga clic en “Tally Statistic” para
crear una nueva variable denominada SystemTimePacker1.
Paso 2: Necesitamos definir el proceso de recogida de observaciones. Inserte una etapa Tally en
Packer1_Entered (Figura 6.2). En este caso:
Value Type: Expression

TallyStatistic Name: SystemTimePacker1
Value: TimeNow-ModelEntity.TimeCreated24
Figura 6.2: Utilizando una Etapa Tally para Controlar el Tiempo antes de la Empaquetadora 1
Pregunta 6: ¿Podría ser el valor simplemente ModelEntity.TimeInSystem?
TimeNow es la hora actual del reloj de la simulación y la función TimeCreated devuelve la hora en que la entidad fue creada.

Paso 3: Guarde el modelo y ejecútelo para ver los resultados.
Pregunta 7: ¿Cuál es el tiempo que tardan tanto las tarjetas como los chips desde la entrada hasta el
comienzo de la operación de empaquetado 1?
Paso 4: Suponga que ahora queremos saber el tiempo que emplea una entidad ensamblada desde que
empieza en la estación Packer1 hasta la salida después de 4 horas de simulación. Tenemos que modificar
nuestro proceso para que sólo se obtengan las observaciones referidas a las tarjetas pasadas las primeras
cuatro horas.
Paso 5: Modifique nuestro proceso “Packer1_Entered” y añada una etapa decidir, Decide, antes de Tally
(Figura 6.3). Esta etapa Decide es similar a una función SI en Excel donde si una condición es
verdadera el proceso continuará por una rama del flujograma, la rama “True”, y en caso contrario seguirá
por la otra rama, “False”. La propiedad que marca el tipo de decisión, Decide Type, debe basarse en una
condición, “ConditionBased”, con una expresión Expression que indique: TimeNow > 4.
Figura 6.3: Añadiendo una Etapa Decide

Paso 6: Guarde y ejecute el modelo.
Pregunta 8: ¿Qué tiempo de permanencia obtiene para las tarjetas y los chips desde que llegan hasta el
momento en que empiezan a ser empaquetados en Packer1?
Paso 7: Es posible que desea usar etapas de proceso para reemplazar los cambios en la modelización que se
realizaron sobre el modelo del Capítulo 5 de forma que se obtengan estadísticas de tiempo en el sistema
por tipo de chip (verde o rojo) y para las tarjetas.
Primero, vuelva a introducir el sumidero original Exit (SINK)

Borre todas los objetos (SEPARATOR y los tres SINKS) que se implementaron cuando se reemplazó
Exit.25
Conecte las tres operaciones de empaquetado con el sumidero de forma similar a lo que se hizo en la
Figura 5.3.
Paso 8: Definamos tres nuevas estadísticas TALLY (recuerde que son elementos, “Elements”), denominadas
BoardTimeInSystem, RedTimeInSystem, y GreenTimeInSystem.
Paso 9: Creemos un proceso en el sumidero que utilice el disparador de destrucción de entidades,

“Destroying Entity”. Este proceso se denomina Exit_DestroyingEntity (Figura 6.4).
Cuando borra un nodo, desaparecen todas sus conexiones. Puede conectar nodos rápidamente si aprieta las teclas Shift y Ctrl, y
hace clic en el nodo de origen y arrastra el conector hasta el destino. Tendrá que seleccionar el tipo de conexión.
Figura 6.4: Proceso de Destrucción de Entidades
Ha sido necesario incluir una etapa previa, para desagrupar, UnBatch, las entidades. Ha sido elegida
del panel de etapas y del conjunto de todas las etapas, “All Steps (A-Z)”. La etapa UnBatch
funciona como un objeto separador, SEPARATOR, excepto que se utiliza para desagrupar los “padres”
y los “miembros” y dirigirlos por las ramas correctas.
La etapa decidir, Decide, es condicional, basada en la condición:

ModelEntity.ChipType==1
Las etapas Tally simplemente graban el tiempo en el sistema, ModelEntity.TimeInSystem,

en cada una de las etapas en función del tipo de entidad.
Pregunta 9: ¿Cuáles son las ventajas y las desventajas de este enfoque frente al original donde el modelo
físico se cambió para obtener estadísticas?
Pregunta 10: ¿Qué otras etapas que aparecen en la lista “All Steps (A-Z)” no aparecen en las etapas más
comunes, “Common Steps”?
Paso 10: Guarde y ejecute el modelo de forma que observe si hay diferencias con el modelo anterior.
Pregunta 11: ¿Cuánto tiempo están las tarjetas de memoria en el sistema (desde la entrada a la salida)?
Pregunta 12: ¿Cuánto tiempo están los chips verdes en el sistema (desde la entrada a la salida)?
Pregunta 13: ¿Cuánto tiempo están los chips rojos en el sistema (desde la entrada a la salida)?
Paso 11: Los resultados deben ser comparables con los obtenidos en el capítulo anterior.
Pregunta 14: Dado que los resultados son comparables, ¿qué enfoque es más fácil para usted?26
La gente suele intentar no utilizar procesos al principio, especialmente si pueden realizar los modelos sin ellos (esta es parte de la
nueva forma de pensar que require SIMIO). Sin embargo, encontrará que el tiempo invertido en aprender a utilizarlos vale la pena en
cuanto se enfrente a sistemas más complicados. El resto de capítulos ilustrará por qué los procesos son tan esenciales.

Sección 6.4: Una Introducción a Recursos (Resources)
A veces la capacidad no se reduce a objetos como SERVERS o COMBINERS, que se basan en sus capacidades
internas. En cambio, la limitación puede no estar fijada en el sentido de que la capacidad está situada en una
localización concreta. Por ejemplo, supongamos que la operación de ensamblaje de las tarjetas de memoria
requiere de un accesorio o útil para ensamblar los chips en la tarjeta de memoria. Además, el mismo útil se
utiliza para transferir la unidad ensamblada hasta empaquetado. Para cada operación de ensamblaje, el útil
debe acercarse desde la empaquetadora, para lo que se tarda unos 3 minutos. Asumamos que existen 10 útiles
idénticos disponibles para la doble operación ensamblaje-empaquetado.
Paso 1: Primero, arrastre y deje un objeto recurso, R ESOURCE27 en el tapiz, quizá debajo del combinador,
COMBINER como se nuestra en la Figura 6.5. Llame al recurso Fixture y asígnele una capacidad inicial,
Initial Capacity, de 10 (no modificaremos la capacidad en este caso).
Es un recurso
RESOURCE fijo
Figura 6.5: Añadiendo el Recurso Fixture

Paso 2: Se necesita especificar la lógica de utilización de este recurso. El útil será “apresado” justo antes de
del ensamblaje y “liberado” justo después del empaquetado. Hay que dotar tiempo para que vuelva a
la primera estación, por lo que se necesitará de los procesos para manipular los recursos,
RESOURCES.
Paso 3: Para sustituir el combinador, COMBINER, BoardAssembly, cree un disparador “Processing”

denominado BoardAssembly_Processing. Este disparador se ejecuta justo antes de que el
combinador esté listo para empezar a procesar. La etapa utilizada para apresar un recurso, Seize,
será utilizada para especificar que se necesita un Fixture antes de empezar a ensamblar (Figura 6.6)
y apresar o conseguir una unidad de capacidad. No nos ha de importar ahora cuál de los útiles se
apresa, puesto que son idénticos. Una vez que los útiles han sido apresados (lo que quiere decir que
están disponibles), se va a utilizar un retardo, Delay, de 3 minutos para representar el tiempo
necesario para traer el útil desde las empaquetadoras.
El Capítulo 13 cubrirá con más detalle el objeto RESOURCE.

Figura 6.6: Apresando una Unidad de Útil y Acercándolo
Paso 4: Cuando se acaba un paquete, se libera el útil para poder ser utilizado otra vez en el ensamblaje. Este
proceso tiene que ser modelizado para cada uno de las tres empaquetadoras, de forma que será más
fácil utilizar el proceso reutilizable Packaged, al que se llama cuando la tarjeta de memoria sale de
la estación de empaquetado. A partir de la pestaña “Processes”, incluya la etapa soltar o liberar,
Release (Figura 6.7), lo que liberará una unidad de Fixture.
Figura 6.7: Soltando un Útil Fixture

Paso 5: Ejecute el modelo y obtenga el tiempo en el sistema de tarjetas de memoria y chips.
Paso 6: Cambie la capacidad del útil a 20, y simule otra vez.
Pregunta 15: ¿Cuál es la diferencia en el tiempo en el sistema de tarjetas y chips si se comparan los
resultados de los dos escenarios (10 frente a 20 útiles)?
Las bondades de los procesos lógicos de SIMIO es una de sus características sobresalientes, pues
permite extender y particularizar los modelos de forma única y poderosa. Su uso puede requerir
un cambio de mentalidad en la forma de enfocar la simulación.
En Arena los bloques y los elementos de SIMAN corresponden someramente con las etapas y los
elementos en SIMIO. Sin embargo, en Arena los módulos han sido compuestos a partir de los
componentes de SIMAN, por lo que todo viene de SIMAN. En SIMIO, los objetos son
totalmente nuevos y existen varias definiciones y procesos disponibles para alterar el
comportamiento de los modelos estándar de SIMIO. El potencial de estas características de
SIMIO no se encuentra en Arena/SIMAN.
Se pueden realizar muchos tipos de modelizaciones diferentes utilizando recursos, una cualidad
que exploraremos en otros capítulos (Capítulo 13, Capítulo 14, Capítulo 16, etc.).

Capítulo 7
Tiempos de Proceso Específicos por Pieza y
Fuentes Únicas: Célula de Fabricación bis
Tiempos de proceso que dependen del tipo de pieza
Fuente de piezas únicas para muchos tipos de piezas
Sección 7.1: Nuevo Enunciado del Problema
Recuerde el enunciado del problema del Capítulo 4 donde el objetivo era modelizar cuatro tipos de piezas
que pasaban por tres estaciones: A, B, y C. Las estaciones estaban situadas de forma que el patrón de
movimiento es circular y unidireccional (Figura 7.1). Por ejemplo, si se termina una pieza en la Operación C,
tendrá que recorrer el camino hasta la Operación A, y luego hasta la Operación B, antes de que puede
dirigirse hasta la salida. Queremos simular un período de 40 horas. Las piezas se mueven a una velocidad de
2 millas por hora.
Llegada Salida de
de Piezas Travel Direction Piezas
Figura 7.1: Layout de la Célula de Fabricación

En el Capítulo 4, el tiempo de proceso para cada una de las estaciones era el mismo independientemente del
tipo de pieza. En este capítulo, el tiempo va a depender de la pieza a fabricar, según los valores mostrados en
la Tabla 7.1.
Tabla 7.1: Secuencias y Tiempos de Proceso (en Minutos)

Pieza 1 2 3
Pieza 1 Station A (Pert(2,5,8)) Station C (Pert(2,6,11))
Pieza 2 Station A (Pert(1,3,4)) Station B (Uniforme(5 a 11) Station C (Uniforme(2 a 11))
Pieza 3 Station A (Triangular(2,5,8)) Station B (Triangular(5,9,11))
Pieza 4 Station B (Pert(5,9,11)) Station C (Triangular (2,6,11))
También en el Capítulo 4, las piezas llegaban desde cuatro fuentes distintas, cada una con su propio patrón de
llegadas. Algunas veces, es necesario modelizar utilizando una única fuente, aunque haya cuatro tipos
distintos de piezas, cada uno con un porcentaje sobre el total (Tabla 7.2).

Tabla 7.2: Porcentaje por Tipo de Pieza
Tipo de Pieza Porcentajes
Pieza A 25%
Pieza B 35%
Pieza C 15%
Pieza D 25%
Pregunta 1: ¿Cuándo piensa que es mejor disponer de una única fuente en vez de múltiples fuentes?
Las distancias en yardas se muestran en la Tabla 7.3.
Tabla 7.3: Distancias en Metros Entre Estaciones

Camino desde Distancia (yardas)
Entrada a Operación A 25
Operación A a Operación B 35
Operación B a Salida 20
Salida a Operación C 30
Operación C a Entrada 40
Paso 1: Abra en primer lugar el modelo del Capítulo 4, guárdelo con otro nombre, y borre todas las fuentes
menos una (Figura 7.2).
Única Fuente
Nodo básico
de Salida
Figura 7.2: Modelo con la Célula de Fabricación

Paso 2: Para modelizar el tiempo de procesos de forma que sea dependiente del tipo de pieza, el tiempo de
procesos necesita ser adjuntado en la tabla original de secuencias. (Nota: se podría utilizar una expresión
más complicada para el tiempo de proceso, utilizando reglas SI – si la pieza es de tipo A, entonces el
tiempo de proceso es X, si es B, Y, ..., pero la rutina se complica si el número de piezas diferente
aumenta).
Paso 3: En la pestaña “Data”, haga clic en SequencePart1 que está asociada con la Pieza 1. Debido a que
los tiempos de proceso pueden seguir cualquier distribución (o expresión válida), añada una columna
Tiempos de Proceso Específicos por Pieza y Fuentes Únicas: Célula de Fabricación bis 49
nueva para incluir expresiones denominada ProcessingTimes a partir del menú Standard Property.
Asegúrese de que la columna tiene las unidades apropiadas haciendo que Unit Type sea “Time” y las
unidades por defecto, Default Units, “minutes.”
Paso 4: Fije el tiempo de proceso para StationA según la función Pert, Random.Pert(2,5,8), el de
StationC según Random.Pert(2,6,11)y finalmente Exit en 0 (Figura 7.3).
Figura 7.3: Nueva Tabla de Secuencia para la Pieza A

Paso 5: Repita los dos últimos pasos para las otras tres piezas, creando la tabla de secuencias con los datos
incluidos en la Tabla 7.1.
Paso 6: Para que una única fuente sea capaz de producir múltiples tipos de entidades, se ha de crear una
nueva tabla de datos para especificar el tipo de pieza de las entidades así como el mix de producto en
porcentaje. Añada una tabla nueva denominada TableParts con cuatro columnas (Tabla 7.4).
Tabla 7.4: Definiciones de las Columnas

Columna Nombre Tipo
1 PartType Entity
2 ProcessingTime Expression
3 PartMix Integer (or Real)
4 PartSequence Sequence
A continuación, especifique cada entidad como una nueva fila con la información correspondiente
(Tabla 7.5).
Tabla 7.5: Contenidos de TableParts
Especificar SequencePart1.ProcessingTimes implica que el tiempo de proceso vendrá

de la columna asociada con ProcessingTimes en la tabla SequencePart1.
Paso 7: Para que se pueda utilizar tiempos de proceso dependientes del tipo de pieza, cambie las expresiones
de tiempo de proceso en las tres estaciones de forma que se lean los valores
TableParts.ProcessingTime. Más en concreto, esta lógica hace que el tiempo de proceso se lea de la
columna ProcessingTime de la tabla de datos, TableParts. Como cada pieza se mueve en función de las
filas de su propia tabla de secuencias, obtendrá el tiempo de proceso de la fila correspondiente. La
propiedad es ahora una propiedad del tipo referencia

, que sólo puede ser convertida a una propiedad
normal haciendo clic con el botón derecho en la etiqueta ProcessingTime y especificando el nuevo valor.
Paso 8: Para generar múltiples tipos de piezas de la misma fuente, el tipo de entidad, Entity Type, necesita ser
modificado para incluir cada tipo de entidad. En la fuente, SOURCE, especifique que el valor de Entity
Type se busque en TableParts.PartType. Esta especificación permite que Entity Type pueda ser de
cualquiera de los tipos especificados en la tabla.
Paso 9: Haga que el tiempo entre llegadas sucesivas de piezas se comporte según una distribución
Exponential con una media 10 minutos.
Paso 10: Para determinar qué tipo de pieza se crea, se debe incluir en las propiedades del objeto los
porcentajes del mix de productos. La fuente, SOURCE, tiene una categoría de propiedades para asignar
valores de una tabla, “Table Reference Assignment”. Existe la posibilidad de realizar dos asignaciones:
antes de la creación de una entidad, Before Creating Entities, o justo después de haberlas creado, On
Created Entity. En este caso, queremos realizar la asignación antes de la creación deforma que se cree el
tipo de pieza de forma correcta (Figura 7.4).
Tabla de
Piezas
Fila
Figura 7.4: Haciendo la Asignación hacia la Tabla de Referencia

Puede especificar qué tabla (TableParts) y qué fila se asocian al objeto. En este caso, la fila se determina
de forma aleatoria utilizando los porcentajes incluidos en la columna PartMix y especificando que se
ha de generar una fila aleatoria (TableParts.PartMix.RandomRow).
Paso 11: La asignación a una tabla de referencia se puede realizar de forma alternativa utilizando un
disparador, “Add-On Process Triggers”, en el objeto fuente, SOURCE. El proceso que se dispara puede
añadir flexibilidad (aunque no sea necesario en este ejemplo), puesto que el objeto dispone de cuatro
disparadores distintos (Tabla 7.6).
Tabla 7.6: Disparadores Disponibles para un Objeto SOURCE

Disparador Descripción
Initialized Se ejecutará al comienzo de la simulación
Creating Entities Se ejecutará antes de que se cree la entidad
Created Entity Se ejecutará después de crear la entidad
Exited Se ejecutará justo después de que la entidad abandone la
fuente
Paso 12: El tipo de pieza se tiene que determinar antes de crear la entidad (Creating Entities). Para llamar a
este proceso de creación, Creating Entities, haga doble clic en la etiqueta para crear un proceso, o utilice
la pestaña “Processes”. Esta acción añadirá un proceso SrcParts_CreatingEntities así como que hará
que “Processes” sea la pestaña activa.
Paso 13: Hay que asociar también una fila de la tabla de piezas a la entidad que se va a crear. Incluya la etapa
Set Table (listada en la sección All Steps (A-Z)), arrastrándola entre Begin y End (Figura 7.5).
Figura 7.5: Añadiendo la Etapa Set Table en un Proceso

Paso 14: En la ventana de propiedades de la etapa Set Table (Figura 7.5), especifique qué tabla
(TableParts) y qué fila de la tabla se asocia al objeto. En este caso, la fila de determina de forma
aleatoria utilizando la columna PartMix y especificando que una fila aleatoria ha de ser generada
(TableParts.PartMix.RandomRow).
Figura 7.6: Propiedades de la Etapa Set Table

La fila aleatoria, “Random Row”, se obtiene como antes de la columna PartMix de la tabla TableParts.
Asegúrese de que el tipo de objeto, Object Type, se especifica como ficha, Token, porque la entidad no
ha sido todavía creada. Después de que se ejecute el proceso, se creará la entidad y se hará que herede las
propiedades de la ficha, TOKEN, asociada.
Paso 15: Ejecute la simulación por un período de 40 horas a velocidad lenta para asegurarse de que las piezas
siguen su secuencia correctamente y conteste a las preguntas siguientes:
Pregunta 2: ¿Cuánto tiempo está cada tipo de pieza en el sistema?
Pregunta 3: ¿Cuál es el grado de ocupación de las estaciones, SERVERS?
Pregunta 4: ¿Cuánto tiempo están las piezas (conjuntamente) en el sistema?
Pregunta 5: ¿Cuál es el grado de ocupación de cada recurso?

Sección 7.2: Un carril de transferencia
Suponga ahora que la transferencia entre las estaciones de la célula de fabricación se realiza con un carril de
transferencia, que es una cinta transportadora continua, continuous conveyor, posiblemente en circuito
cerrado, que tiene estaciones de carga/descarga. Cuando una pieza se sitúa en una de estas estaciones, la línea
entera se para hasta que la pieza se coloca sobre ella o se retira de ella. Estas operaciones tardan entre 0.5 y
1.5 minutos.
SIMIO dispone de dos formas de modelizar las cintas: acumuladoras, accumulating, y no acumuladoras, non-
accumulating. Las cintas acumuladoras permiten que las piezas se junten al final, puesto que la cinta se sigue
moviendo aunque no pueda descargar en una estación. Como ejemplo, se pueden mencionar las cintas de
rodillos. Una cinta no acumuladora se debe parar hasta que la operación de carga/descarga finaliza. Como
ejemplo, se puede mencionar los sistemas aéreos con balancinas que llevan piezas durante el ensamblaje de
coches.
Las cintas en SIMIO no tienen estaciones de carga/descarga, por lo que el carril de transferencia tendrá que
ser modelizado como una serie de cintas individuales. Como el carril se para durante las operaciones, el
concepto de no acumulación es el que hay que emplear, aunque las cintas deben coordinarse entre sí.
Paso 1: Cambie todos los caminos interiores del modelo a cintas. Seleccione un camino y acceda haciendo
clic con el botón derecho al submenú Convert To Type. Para mejorar visualmente el modelo, añada
decoradores de caminos para las cintas (Figura 7.7) a través de la pestaña “Path Decorators”.
Paso 2: Modifique también los símbolos de las piezas de forma que sus dimensiones sean de 1 un metro de
ancho por 1 metro de largo por medio metro de alto. Seleccione las cuatro piezas y cambie sus
dimensiones utilizando la propiedad General→Size and Location. Tendremos que ser un poco más
específicos sobre estas dimensiones cuando dimensionemos también la cinta. Hemos creado estos
símbolos utilizando la sección “Create” de la pestaña “Project Home”, y haciendo clic en “New Symbol”
y seleccionando “Create a New Symbol”. Cuando estemos creando el símbolo, debemos prestar atención
a su tamaño (la cuadrícula está en metros).
Nuevos Símbolos
para las piezas
Cintas
Figura 7.7: Vista en 3D de las Cintas Transportadoras

Paso 3: Es necesario especificar las propiedades de las cintas. Las longitudes de los caminos (recordemos
que eran 25, 35, 20, 30, y 40 yardas) no tienen que ser modificada. Selecciones las cinco cintas
(apretando la tecla ctrl.) y marque la velocidad como 0.5 metros/segundo para cada cinta. A la vez, y
manteniendo todas seleccionadas, hay que marcar la propiedad de acumulación, Accumulating, como
falsa, “False”, para cada cinta.
Paso 4: En la propiedad de alineamiento de la entidad, Entity Alignment, elija la opción Cell Location. Esta
opción equivale conceptualmente a dividir la cinta en celdas. Las piezas que van sobre la cinta han de ser
posicionadas sobre una celda. Así, fije el número de celdas en el número asociado a la longitud de la
cinta. Si no es así, y selecciona la opción Any Location, una pieza puede ir sobre la cinta en cualquier
lugar, incluso interfiriendo con otras.
Paso 5: Repita el paso anterior para cada cinta que conforma el carril de transferencia.
Paso 6: Dado que el carril de transferencia está formado por muchas cintas en vez de una, hay que
sincronizarlas de forma que cuando las piezas se cargan/descargan de una de las cintas, el carril entero
(el conjunto de cintas) se para hasta que acabe la operación.28 Defina primero una variable discreta de
estado (a partir de la pestaña “Definitions”) y denomínela como número de nodos funcionando,
NumberNodesWorking. Esta variable representará el número de nodos que están o colocando o
retirando piezas del carril. Cuando esta variable es 0, el carril se moverá, y cuando la variable de estado
sea al menos 1, el carril entero se pasará.
Paso 7: Añada ahora un proceso Nuevo (a través de la pestaña “Processes”, seleccione “Create Process”).
Llámelo On_Off_Entered. Este proceso consistirá en las etapas incluidas en la Figura 7.8.
Figura 7.8: Proceso que Refleja la Entrada/Salida de Partes del Carril

Cuando una pieza llega a una operación de carga/descarga, la etapa Assign incrementa
NumberNodesWorking en una unidad (NumberNodesWorking = NumberNodesWorking +1)
y todas las cintas tienen que pararse, haciendo que su velocidad sea cero (Figura 7.9)
Figura 7.9: Incrementando el Número de Nodos Trabajando y Parando las Cintas

La etapa Delay se utiliza para modelizar el tiempo de carga/descarga, que se asume que sigue una
distribución uniforme con un mínimo de 0.5 y un máximo de 1.5 minutos.
La segunda etapa Assign reducirá el número de nodos trabajando, NumberNodesWorking.
La sincronización no es exacta dado que la cinta aguas abajo no conoce que una celda de la cinta aguas arriba está ocupada y que
piezas que están en una celda pueden entrar en conflicto con otras piezas que llegan de una cinta anterior.
La etapa Decide se basa en la condición de que el número de nodos en espera es 0,
NumberNodesWaiting == 0, lo que significa que no hay otros nodos cargando o descargando
sobre el carril.
La última etapa Assign hace que las cintas vuelvan a arrancar. SIMIO guarda internamente todos
las velocidades en metros por hora, por lo que una asignación de 0.5 se guardará como 0.5 metros
por hora. Si la variable de estado tiene unidades distintas, éstas se pueden especificar vía
asignaciones. Asegúrese de que cambia las unidades a metros por segundo o una especificación de
0.5 metros por segundo será tratada como 0.5 metros por hora 29. Puede convertir 0.5 metros por
segundo en 1800 metros por hora para que sean unidades consistentes con la interpretación de cómo
SIMIO realiza las asignaciones, así como evitar tener que hacer la conversión todas las veces. La
Figura 7.10 muestra cómo se arranca el carril.
Figura 7.10: Arrancando las Cintas

Paso 8: Hay que invocar el proceso genérico On_Off_Entered en el momento adecuado (cuando una pieza
se carga o descarga). Seleccione On_Off_Entered como el proceso a ejecutar desde todos los nodos y
del camino especificado en la Tabla 7.7.
Tabla 7.7: Todos los Disparadores que Deben ser Incluidos en la Lógica de Carga/Descarga
Disparador de Procesos A qué Objeto se Asocia
Exited Output@SrcParts (TRANSFERNODE)
Entered Input@StationA (BASICNODE)
Exited Output@StationA (TRANSFERNODE)
Entered Input@StationB (BASICNODE)
Exited Output@StationB (TRANSFERNODE)
Entered Path7 (PATH): El camino que sale de la célula.
Entered Input@StationC (BASICNODE)
Exited Output@StationC (TRANSFERNODE)
Pregunta 6: ¿Por qué no usar simplemente el proceso On_Off_Entered en el BASICNODE de
entrada/salida de la cinta?
Paso 9: Ejecute la simulación durante 40 horas a velocidad lenta para asegurarse de que las piezas siguen de
forma correcta la secuencia y conteste a las siguientes preguntas.
La presunción de un tiempo interno representa una elección de eficiencia en contra de la facilidad de uso.
Pregunta 7: ¿Cuánto tiempo está cada tipo de pieza en el sistema?
Pregunta 8: ¿Cuál es el grado de ocupación de cada estación, SERVERS?
Pregunta 9: ¿Cuánto tiempo emplean las piezas en ser procesadas?
Pregunta 10: ¿Cuántas piezas hay de media en el Conveyor2?
Pregunta 11: ¿Cuál es el tiempo medio de permanencia en el Conveyor3?
Sección 7.3: Fallos de Máquina en la Célula de Fabricación
Los fallos son parte de la mayoría de sistemas mecánicos. SIMIO proporciona algunos métodos relativamente
simples para modelizar estos fallos o roturas dentro de la sección de fiabilidad, “Reliability Logic”, de los
objetos SERVER (y también de otros objetos). Por supuesto, en el caso de un carril de transferencia, se necesita
parar el carril cuando una de las máquinas o estaciones esté siendo reparada.30
Asumamos que la Operación C, StationC, es poco fiable. En particular, asumamos que el tiempo entre fallos,
MTBF (Mean Time Between Failures), sigue una distribución exponencial con una media de 10 horas,
mientras que el tiempo medio de reparación, MTTR (Mean Time To Repair), se modeliza con una
distribución Triangular (0.5, 1, 2), en horas.
Paso 1: En la sección “Reliability Logic” de la Operación C, especifique que el tipo de fallo, Failure Type, se
base en el tiempo, “Calendar Time Based”, que el tiempo entre fallos, Uptime Behavior, sea
Random.Exponential(10), con Units en horas, y que el tiempo de reparación, Time To Repair, sea
Random.Triangular(0.5,1,2), con unidades en horas (Figura 7.11).
Figura 7.11: Especificando Fallo y Reparación

Paso 2: Cuando falla la Operación C, StationC, se debe detener el carril entero, y debe reiniciarse una vez que sea
reparada la estación. Seleccione StationC y cree unos disparadores de procesos, reparando, “Repairing”, y
reparado, “Repaired”, para generar los procesos nuevos StationC_Repairing y StationC_Repaired. El
disparador “Repairing” se ha de invocar cuando suceda el fallo, mientras que el disparador “Repaired” debe
ser invocado cuando la estación haya sido reparada. En StationC_Repairing, utilice una etapa Assign para
desconectar todas las cintas y poner su velocidad, DesiredSpeed, a “0”. En StationC_Repaired, utilice
una etapa Assign para volver a arrancar las
El coste tremendo de parada debido a que se paraliza el carril entero es la razón fundamental de por qué cada vez es más difí cil
encontrar carriles y otros sistemas totalmente automatizados.
cintas si no hay nodos realizando operaciones de carga/descarga (asignando DesiredSpeed = 0.5
para todas las cintas) como se aprecia en la Figura 7.12.31
Figura 7.12: Disparadores de los Procesos Repaired y Repairing

Paso 3: El proceso On_Off_Entered no debería hacer que el carril arrancase si la Operación C, StationC, ha
fallado y está siendo reparada. Cambie la etapa Decide del proceso On_Off_Entered de forma que la
expresión condicional sea la siguiente32:
(NumberNodesWorking==0) && (StationC.Failure.Active==False)
Paso 4: Finalmente, cambie la animación de StationC de forma que tome el color rojo cuando ha fallado.
Seleccione StationC y haga clic en el botón “Add Additional Symbol”. Cambie el color del segundo
símbolo a rojo utilizando la sección Decoration. Después de seleccionar la estación StationC, asigne la
propiedad Current Symbol Index de StationC a Math.if(StationC.Failure.Active ==
1,1,0), lo que hará que el símbolo tome el valor 0 o 1 (acuérdese de que el indicador de símbolo
empieza en 0).33
Paso 5: Ejecute el modelo y asegúrese de que el carril se detiene cuando la estación está siendo reparada.
Pregunta 12: ¿Hay algo acerca de la animación que no le acabe de gustar?
Algunas características de SIMIO explicadas en este capítulo tienen características análogas en

Arena. Pero Arena no ofrece la posibilidad de modificar los procesos ejecutados por los objetos,
ni visualiza la simulación en 3D.
No es deseable en cambio que los tipos de fallo en SIMIO no incluyan como opción fallos
basados en el tiempo de proceso.
En este capítulo se empiezan a explotar los procesos de SIMIO para desarrollar y modelizar
comportamientos más complejos de los objetos en el modelo.
El uso del concepto de cintas transportadoras es relativamente fácil de implantar y favorece la
animación.
Copie las etapas Decide y Assign del proceso On_Off_Entered.

La función Object.Failure.Active devolverá “true” si el objeto ha fallado.
En el Capítulo 10 se discutirá en profundidad sobre fallos.
Capítulo 8
“Material Consumido”, Cambios, Propiedades: Un
Ensamblaje
El objeto Estación de Trabajo, Workstation
Tiempos de preparación dependientes de la secuencia
Material consumido
Propiedades
Sección 8.1: Ensamblaje de una Maqueta
Un proceso de ensamblaje de una maqueta es un proceso en el que se construye una maqueta a partir de los
componentes disponibles. Las peticiones de ensamblaje llegan a una estación de trabajo siguiendo una
distribución Poisson con un tiempo entre llegadas de 3 minutos. La orden se realiza por una cantidad de
unidades iguales. Las maquetas se ensamblan a partir de 3 componentes; un subcomponente SubA, un
subcomponente B, y dos conectores – este estructura de producto se denomina también lista de materiales o
Bill of Materials (BOM). Cada maqueta se procesa en un tiempo que se asemeja a una distribución triangular
de parámetros (0.1, 0.2, 0.3) minutos. Sólo se puede ensamblar una unidad a la vez en la estación. Se desea
obtener para el análisis de la estación el número de unidades producidas así como de componentes utilizados,
así como información sobre el cumplimiento de los pedidos.
Existen cuatro tipos de maquetas producidas a partir del mismo BOM, según el color: 15% amarillas, 20%
rojas, 35% azules, y 10% verdes. Después de completar un pedido, se necesita 1 minuto para limpiar la
estación, así como 2 minutos para prepararse para el siguiente pedido. Esta restricción sufrirá modificaciones
más adelante. Finalmente, los pedidos tardan en llegar a la estación entre 1 y 2 minutos, lo mismo que tardan
para llegar a la salida desde la estación.
Paso 1: Cree un nuevo modelo que tenga una fuente, SOURCE (OrdersArrive), un sumidero, SINK
(OrdersLeave), y una estación de trabajo, WORKSTATION (KitOperation) .
Los caminos se recorren en Uniform(1,2) minutos. Las
maquetas llegan cada Exponential(3) minutos.
El tiempo requerido para cada maqueta se modeliza como Triangular(0.1, 0.2, 0.3)
minutos.
La limpieza es de 1 minuto.
El tiempo actual de cambio es de 2 minutos.
Paso 2: Incluya una nueva entidad, MODELENTITY, de nombre Orders.
Paso 3: Añada 3 símbolos adicionales para la entidad Orders. Seleccione Order y haga clic en el botón Add
Additional Symbol. Asigne color a los símbolos adicionales: “Amarillo”, “Rojo”, y “Azul”. Los símbolos
se enumeran empezando en 0.
“Material Consumido”, Cambios, Propiedades: Un Ensamblaje 59

Paso 4: Todos los objetos de SIMIO tienen ciertas características programadas. Las propiedades se
inicializan al comienzo de la simulación (por ejemplo, número inicial en el sistema, número máximo de
llegadas), y sus valores no pueden ser cambiados a lo largo de la ejecución. La variable de estado
Priority es un ejemplo para una entidad y ha sido utilizado con anterioridad para representar el tipo de
objeto. En SIMIO, tiene la posibilidad de añadir sus propias propiedades así como estados a los objetos.
Las propiedades, Properties, y los estados, States, se añaden utilizando la pestaña “Definitions”.
Seleccione MODELENTITY en el panel [Navigation] y seleccione la sección Definitions→States. Cada
pedido ha de tener una cantidad diferente y se necesita una variable de estado para almacenar esa
información.
Debe usar la variable de estado discreta, “Discrete State Variable”, de nombre Picture, para
representar la imagen que va a representar a la entidad. Esa variable la proporciona SIMIO.
Debe añadir, en cambio, otra variable de estado discreta, “Discrete State Variable”, de nombre
OrderQuantity, que representará la cantidad de maquetas en el pedido.
Paso 5: Se necesita una tabla para determinar el porcentaje de veces de cada tipo de pedido y el número
correspondiente al dibujo del símbolo. Seleccione MODEL en el panel [Navigation]. Cree una
TableSymbol para los dibujos de las entidades (Tabla 8.1) a través de la pestaña “Data”.
Tabla 8.1: Símbolo y Porcentaje por Tipo de Pedido
Paso 6: Hay que determinar el tipo de pedido (Verde, Amarillo, etc.), la cantidad que lleva el pedido, o
tamaño del pedido, y el dibujo correcto. Las asignaciones de valores a las variables de estado para las
entidades entrantes a través de la fuente serán realizadas por el disparador de procesos denominado
“procesado”, “Processed” y cuyo nombre será OrdersArrive_CreatedEntity. Es este proceso, podemos
realizar las asignaciones de los valores de las variables de estado para las piezas entrantes, como se
muestra en la Figura 8.1.34
Figura 8.1: Etapas del Proceso OrdersArrive_CreatedEntity

Paso 7: Use la etapa Set Table para asignar aleatoriamente la fila de TableSymbol a la entidad que será
utilizada en la etapa Assign para especificar la figura.
Pregunta 1: ¿Por qué se decidió utilizar la tabla en el disparador “Created” en vez de en el disparador
“Creating” como se hizo en la Figura 7.5?
34
En lugar de utilizar un disparador de procesos, se podía haber utilizado la asignación On Created Entity Table Reference
Assignment para conseguir el mismo objetivo.
Paso 8: Asigne el dibujo correcto así como el tamaño del pedido. Puede hacer esto en dos etapas diferentes o
en una misma etapa con múltiples filas, si hace clic en el botón “0 Rows”. Tiene que añadir cada
asignación como se muestra desde la Figura 8.2 hasta la Figura 8.4.
Use el editor “Repeating Property Editor” para hacer asignaciones múltiples (Figura 8.2).
Figura 8.2: Haciendo Asignaciones Múltiples

Haga que el dibujo represente el símbolo asociado con el tipo de pedido (Figura 8.3).
Figura 8.3: Asignación de Imagen

Asigne la tamaño del pedido según una distribución Binomial (Figura 8.4).
Figura 8.4: Asignación del Tamaño del Pedido

Pregunta 2: Se está utilizando una variable aleatoria Binomial para modelizar el tamaño de pedido.
¿Por qué sumamos 1?
Paso 9: Guarde el modelo y ejecútelo durante un período de 8 horas
Pregunta 3: ¿Cuál es el tiempo medio de flujo para los pedidos?
Pregunta 4: ¿Cuántos pedidos fueron procesados en 8 horas?
Pregunta 5: ¿Qué nos falta en el modelo?
Sección 8.2: Tiempo de Preparación en Función de la Secuencia
Cuando la estación de procesado de las maquetas cambia de un color a otro, se incurre en un tiempo de
cambio o preparación de máquina que depende del color que precedió al pedido actual. El tiempo de cambio,
en minutos, se muestra en la Tabla 8.2.

Tabla 8.2: Tiempos de Cambio (De/A, From/To) en Horas
Añadamos los tiempos de cambio, dependientes de la secuencia, en nuestro modelo. En las propiedades de la
estación, WORKSTATION, se puede especificar los tiempos de cambio como si fueran constantes (Specific) (dos
minutos para cada operación). Pero antes de utilizar tiempos que dependan de la secuencia, debemos ver
cómo se incorporan los tiempos de cambio en un modelo de SIMIO.
Paso 1: Primero, se necesita una lista, LIST, de identificadores que se puedan utilizar en una tabla de
cambios, en la que, en este caso, se escriba como una lista de caracteres, Strings. Utilizando la pestaña
“Definitions”, genere una lista, LIST, de caracteres, de nombre Colors. Los contenidos de la lista Colors
corresponderán con los nombres de los colores asignados: “Green”, “Yellow”, “Red”, y “Blue” como se
muestra en la siguiente Figura. Es importante que se incluyan en el orden correspondiente a los símbolos
(0, 1, 2, y 3).
Figura 8.5: Lista de Colores

Paso 2: Utilizando la pestaña “Data”, añada una matriz de cambios, CHANGEOVERS, de nombre Changeover.
Use la lista Colors como lista asociada. Cambie las unidades de tiempo a horas e introduzca los valores
en la matriz a partir de la Tabla 8.2.
Paso 3: Especifique la lógica de los tiempos de cambio en la estación KitOperation (Figura 8.6).
Setup Time Type: Sequence Dependent

Operation Attribute: TableSymbol.Symbol
Changeover Matrix: Changeover
Figura 8.6: Especificando los Cambios Según la Secuencia en la Operación
Paso 4: Se puede especificar el resto de elementos de la lógica para la estación de trabajo
Propiedad Operation Quantity (el número de unidades en cada pedido):

ModelEntity.OrderQuantity

Processing Batch Size (Lote): 1
(Este es el número de unidades que se pueden procesar simultáneamente. Por lo que si la
cantidad, Operation Quantity, es 10, y el tamaño de lote es 2, será necesario realizar 5 lotes para
procesar el pedido entero y con cada lote necesitando de un tiempo de proceso diferente.)
Teardown Time (Limpieza): 1 minuto
Paso 5: La estación puede estar en estados distintos: esperando piezas, starved, procesándolas, processing,
preparándose, setup, y limpiando, teardown. Para ver cómo varían los porcentajes a lo largo del tiempo,
añada un gráfico de tarta, “Status Pie” a partir de la pestaña “Animation”. Especifique la propiedad Data
Type, como una lista de estados, ListState, que debe relacionarse con
KitOpereaton.ResourceState.
Paso 6: Guarde el modelo y ejecute la simulación para un período de 1 hora. Luego, ejecútelo en modo
rápido, fast-forward, para un período de 2, 4, y 8 horas. Después de 8 horas, conteste a lo siguiente.
Pregunta 6: ¿Cuál es el tiempo medio de flujo para los pedidos?
Pregunta 7: ¿Cuántos pedidos fueron procesados en 8 horas?
Pregunta 8: ¿Qué nos falta en el modelo?
Sección 8.3: Utilizando Materiales en la Operación
El objeto “estación de trabajo” tiene más posibilidades que un objeto “server”. Por ejemplo, puede utilizarse
para controlar las materias primas que tiene que consumirse, según lo especificado en el “bill of materials” de
la pieza que se está procesando. Si las materias primas no están disponibles, las piezas no pueden ser
procesadas.
Paso 1: Guarde el modelo como un nuevo proyecto.
Paso 2: Tenemos que declarar la existencia de las materias primas que lleva una maqueta así como la lista de
materiales que especifica la cantidad de cada tipo de materia prima que se necesita para fabricar una
maqueta. Se necesita definir cuatro nuevos “Elements”, del tipo MATERIAL, a partir de la sección
Definitions→Elements.
Cree SubA, SubB, y Connectors como tipos de material, todos con una cantidad inicial, Initial
Quantities, de “0” unidades, lo que será cambiado en breve.
Cree KitsBOM como un elemento tipo MATERIAL, pero utilizando el editor de propiedades
BillofMaterial, como muestra la Figura 8.7, en la que se define qué materiales componen el producto
final (1 SubA y 1 SubB y 2 Connectors).

Figura 8.7: Bill of Materials
Finalmente, cree un elemento de tipo “Material” denominada Kits (con cantidad inicial, Initial
Quantity, de 0), para representar el producto final producido con las materias primas según el BOM.
Paso 3: Como el nivel de inventario es una característica física de nuestro modelo y sólo necesita ser
inicializado al comenzar la simulación, es el momento ideal de utilizar una propiedad de SIMIO.
Utilizando la pestaña “Definitions”, haga clic en “Properties” para añadir nuevas propiedades a los
objetos. Cree tres nueva propiedades “Standard Real Properties”, InitInvA, InitInvB, e InitInvC.
Coloque estas propiedades en la nueva categoría InvModel. La primera vez, hay que teclear el nombre
de la nueva categoría (InvModel) en la ventana correspondiente. Para las dos nuevas propiedades puede
seleccionar la categoría del desplegable.
Paso 4: Vuelva a “Elements” e indique Initial Quantity, de cada uno de los tres materiales como una
propiedad de referencia hacia las nuevas propiedades definidas. Recuerde que esta operación se realiza
haciendo clic con el botón derecho en el desplegable y seleccionando la propiedad de referencia.
Paso 5: Como parte del análisis, cree algunas estadísticas para estudiar los materiales que se han consumido
así como sobre el producto final. Existen tres tipos de estadísticas que se pueden definir. Recuerde que
una estadística “Tally” es una estadística basada en observaciones (por ejemplo, tiempo de espera en una
fila). Una estadística de estado, “State statistic”, es en cambio una estadística basada en el tiempo que
monitoriza una variable de estado (número en una fila). Una estadística de final de simulación, “Output
Statistic” puede utilizarse para mostrar el valor de una expresión, una vez al final de cada repetición.
Añada 4 estadísticas finales, OUTPUT STATISTICS, con los siguientes nombres y expresiones.
SubAConsumed que muestre SubA.QuantityConsumed

SubBConsumed que muestre SubB.QuantityConsumed
ConecteorsConsumed que muestre Connectors.QuantityConsumed
KitsProduced que muestre Kits.QuantityProduced
Paso 6: Vuelva a KitOperation y rellene las propiedades Other Requirements (por ejemplo, Material
Consumido, Material Consumption, Nombre del Material Consumido, Consumed Material Name,
Cantidad Consumida, Consumed Quantity, Producción de Materiales, Material Production, Nombre del
Material Producido, Produced Material Name, y Cantidad Producida, Produced Quantity) como se
muestra en la Figura 8.8. Estas propiedades harán que la estación consuma materiales según lo indicado
en el BOM cuando se procesan las maquetas.

Figura 8.8: Otros Requisitos de Material para una Operación
Paso 7: Haga clic en las propiedades del modelo, Model “Properties” (haciendo clic con el ratón derecho en
el objeto “Model” en el [Navigation Panel]). En la sección InvModel, asigne los valores de InitInvA
como 100, InitInvB como 100, y InitInvC como 200.
Paso 8: Guarde el modelo y ejecútelo por un período de 8 horas y observe las estadísticas. Aunque desee ver
la animación durante un rato, necesitará ejecutarlo en modo rápido hasta el final para obtener los
resultados.
Pregunta 9: Después de analizar el número de maquetas producidas, ¿tiene alguna duda sobre las
especificaciones del modelo?
Pregunta 10: ¿Cuántas maquetas se producen en el período de 8 horas?
Paso 9: Cambie el valor del inventario inicial para permitir que se produzcan maquetas durante las 8 horas.
Pregunta 11: ¿Cuántos pedidos se atendieron durante las 8 horas?
Pregunta 12: ¿Cuántas maquetas se producen ahora?
Pregunta 13: ¿Qué cantidad de materias primas SubAs y SubBs se necesitaron?
Pregunta 14: ¿Cuántos Connectors se utilizaron?
Pregunta 15: ¿Cuál es el tiempo de ciclo de los pedidos?
Sección 8.4: Llegada de Materia Prima Durante la Simulación
En lugar de que las materias primas estén disponibles para todo el período de 8 horas al principio de la
simulación, las materias primas han de llegar cada dos horas, empezando en 0. ¿Cómo se modeliza esta
nueva situación en SIMIO?
Paso 1: Tome algunas estadísticas sobre los niveles de inventario para las tres materias primas a lo largo de
un día: SubA, SubB, y Connectors. Dado que el inventario es una estadística basada en el tiempo, hay

que añadir primero tres variables de estado, STATE STATISTICS, utilizando la sección
Definitions→Elements.
SubAAvailable: SubA.QuantityAvailable
SubBAvailable: SubB.QuantityAvailable
ConnectorsAvailable: Connectors.QuantityAvailable
Para cada una de las estadísticas añadidas, incluya User como Category y Number como Data Item.
Paso 2: Guarde el modelo y ejecútelo durante un período de 8 horas utilizando como cantidades iniciales de
stock, 1000, 1000, y 2000 para SubA, SubB, y Connectors (especificándolas en “Model Properties”).
Pregunta 16: ¿Cuál fue la disponibilidad media de SubAAvailable?
Pregunta 17: ¿Cuál fue la disponibilidad media de SubBAvailable?
Pregunta 18: ¿Cuál fue la disponibilidad media de ConnectorsAvailable?
Pregunta 19: ¿Cuántas maquetas se han producido?
Paso 3: Implementemos ahora un sistema de reposición en el que un operario aparece por la estación de
maquetas cada dos horas, empezando en 0, y rellena stock de SubA, SubB, y Connectors hasta un nivel
prefijado.
Paso 4: Añada tres propiedades de tamaño de pedido, SubAOrderQty, SubBOrderQty, y ConnOrderQty,

utilizando la pestaña “Definitions”. Cada una de estas propiedades debe ser definida como “Integer” en
Data Format dentro de la categoría InvModel. Estas propiedades se usarán como las cantidades que el
operario utiliza para reponer el inventario de materias primas.
Paso 5: Utilizando la sección Definitions→Elements, añada un temporizador, TIMER, que lanzará un evento
basado en un intervalo de tiempo (un “timer event” es una interrupción en la simulación que permitirá
que un proceso se ejecute).
Ejecute el temporizador en 0.0 (la propiedad Time Offset debe ser 0) y debe activar un proceso cada
2 horas (Time Interval debe ser 2).
Llame StockerArrives al temporizador.
Paso 6: Utilizando la pestaña “Processes”, cree un proceso, RespondtoTimerEvent, que responda al

temporizador (Figura 8.9).
Triggering Event: StockerArrives.Event

Añada una etapa Assign que haga las asignaciones siguientes al proceso que iguala siempre la
cantidad disponible a la cantidad de pedido-
SubA.QuantityAvailable = SubAOrderQty
SubB.QuantityAvailable = SubBOrderQty
Connectors.QuantityAvailable = ConnOrderQty

Figura 8.9: Proceso Utilizado para Responder al Evento Generado por el Temporizador
Paso 7: En las propiedades del modelos, “Model Properties”, inicialice las cantidades de las materias primas
SubA, SubB, y Connectors a 0, ya que el primer evento StockerArrives sucede en el minuto 0.0 y se
rellenará el stock en el comienzo de la simulación. Fije las cantidades de pedido de SubA, SubB, y
Connectors en 250, 250, y 500, respectivamente.
Paso 8: Guarde el modelo y ejecútelo durante un período de 8 horas y conteste a lo siguiente.
Sección 8.5: Implantando un enfoque Justo-A-Tiempo (Just-In-Time)
El ejemplo anterior asume que el reponedor llegará exactamente cada dos horas y subirá el nivel de stock
hasta el límite establecido. Sin embargo, la compañía desea implantar una filosofía de producción similar al
Just-In-Time (JIT). Tienen un proveedor que tiene un almacén situado muy cerca de la planta y que
responderá a los pedidos rápidamente. La compañía ha implantado un sistema de monitorización tal que
cuando un pedido hace que el inventario baje por debajo de un límite, se lanza un pedido al proveedor que lo
ha de atender en 1 hora.
Paso 1: Guarde el modelo con su propio nombre. Tiene que borrar ahora el temporizador StockerArrives y
el proceso RespondToTimerEvent o deshabilítelo cambiando el valor de la propiedad Initially Enabled
a False, utilizando la propiedad “General” del temporizador, TIMER.
Paso 2: Añada un nuevo sumidero, SINK, InventoryLevel. Posiciónelo debajo de la estación que fabrica la
maqueta.
Paso 3: Vaya a la pestaña “Definitions” y añada tres elementos controladores, MONITOR, MonitorA,
MonitorB, y MonitorC, utilizando la sección “Element”. Un elemento controlador puede ser utilizado
para monitorizar el valor de una variable de estado cuando ésta cambia su valor o cuando el valor cruza
un límite. Las propiedades de MonitorA se pueden ver en la Figura 8.10.

Figura 8.10: Propiedades del Controlador
Lo siguiente ayuda a controlar el nivel de inventario de SubA.
Monitor Type debe ser CrossingStateChange

Crossing Direction debe ser Negative (una reducción de 5 a 4 hará que se lance un evento)
El Threshold Value debe indicar una propiedad a una nueva referencia, New Reference,
SubAReorderPT.
El controlador puede causar que un evento se lance de la misma forma que un temporizador,
pero no utilizaremos esta cualidad en este momento.
Paso 4: Repita el mismo proceso para las materias primas SubB y Connector utilizando las propiedades de
referencia SubBReorderPt y ConnReorderPt, respectivamente.
Paso 5: Añada tres Fuentes, SOURCES (suppliers), SupplierA, SupplierB, y SupplierC, que enviarán las
materias primas a la estación, como se muestra en la Figura 8.11.
Figura 8.11: Proveedores

Asuma que se tarda entre 50 y 65 minutos en suministrar las materias primas entre las Fuentes y el
sumidero Inventory (el tiempo se modeliza con la propiedad Travel Time de un TIMEPATH).
Fije la propiedad Arrival Mode de los proveedores en On Event y los nombres Event Name to
MonitorA.Event, MonitorB.Event y MonitorC.Event respectivamente para
cada una de las tres fuentes. La fuente creará entidades cuando el evento generado por el
controlador se activa y manda las entidades a la operación correspondiente.
Paso 6: Cuando la material prima llega al final del camino, necesita sumar al nivel actual la cantidad del
pedido. Añada un disparador de proceso (“ReachedEnd”) que calcula este nuevo valor. La Figura 8.12
enseña cómo añadir la cantidad SubA y el tamaño de pedido35.
SIMIO proporciona una etapa producir, Produce, que hace esencialmente lo mismo y otra consumir, Consume, con la que se
realiza una resta, pero la lógica utilizando una etapa Assign parece directa.
Figura 8.12: Incrementando la Cantidad Disponible
Paso 7: Repita el proceso para las otras dos materias primas al final de sus respectivos caminos.
Paso 8: En las propiedades del modelo, fije los valores iniciales de las materias principales SubA, SubB, y
Connectors otra vez en 250, 250, y 500, dado que la acción de reposición se activa convenientemente.
Fije los puntos de pedido y los tamaños de pedido en los valores incluidos en la Tabla 8.3.
Tabla 8.3: Punto de Pedido (Reorder Point) y Tamaño de Pedido (Order Quantity)
Materia Punto de Tamaño de
Prima Pedido Pedido
SubA 125 200
SubB 125 200
Connector 250 400
Paso 9: Añada seis etiquetas de estado, “Status Labels” utilizando la pestaña “Animation”, para que se
muestren las cantidades disponibles de cada uno de los tres niveles de materias primas disponibles:
SubA, SubB, y Connectors (Figura 8.13). Estas primeras tres etiquetas son simplemente texto, mientras
que las otras tres tendrán una expresión (Figura 8.14) para mostrar la cantidad disponible
QuantityAvailable.
Figura 8.13: Etiquetas de Estado
Figura 8.14: La Expresión de las Etiquetas de Estado

Paso 10: Guarde el modelo y ejecútelo durante un período de 8 horas, y conteste a las siguientes preguntas.

Este es uno de los capítulos más interesantes en cuanto que ilustra cómo modelizar lo que se
considera un operación compleja compuesta no sólo por temas de inventarios, sino también por
conceptos relacionados con la cadena de suministros, que serán nuevamente explorados en el
Capítulo 12, Capítulo 22 y Capítulo 25.
Se han introducido otras capacidades muy valiosas en este capítulo que deberían ser ampliadas,
lo que haremos en capítulos futuros.
Como si fuera un ejercicio de modelización, ¿cómo construiría un modelo equivalente en otro
lenguaje de simulación?

Índice
A
Add Additional Symbol
E
ModelEntity, Efficiency Table, 38
63 Server, 60 Elements, 42
Add-On Process Elements (Elementos)
Trigger Reached End, 99 Failure (Fallo), 91
Add-On Process Triggers (Disparadores), Material (Material), 66
44 Allocation Request Monitor (Controlador), 75
Seize, 244 Output Statistic (Estadística de Salida), 67
Allocation Requests, Process (Proceso), 173
236 Animation, 6 RoutingGroup (Grupo de Destinos), 161
Animation (Animación) State Statistic (Estadística de Estado), 67
Circular Gauge, 77 Station (Estación), 154
Status Label, 86 Storage (Almacén), 182
Status Labels, 72 Tally Statistic (Estadística de Observación), 46
Status Pie, 66 Timer (Temporizador), 69, 104
Status Plot, 39 Entities Per Arrival, 92
Event (Evento), 80
B Experiment (Experimento)
Response, 108
BasicNode (Nodo Básico), 28 Response Chart, 110
Scenarios, 108
C Subset Selection,
110 Experiment Scenarios,
Candidate, 38 15 Expression Editor, 5
.Node.NumberRoutingIn, 38 External Node, 170
.Server.Inputbuffer.Contents, 38 External View, 170
.Server.Processing.Contents, 38 InputNode, 179
Changeovers (Cambios), 65 OutputNode, 179
Combiner
Match Members, 37
Combiner (Agrupador, Combinador),
F
36 Conector (Conector), 29 Conveyor Failure
(Cinta Transportadora) Active Function. See Elements
Accumulating, 56 Failure Function Table, 39
Entity Alignment, 57
Non-Accumulating, 56
Create Symbol, 74
G
Google 3D Warehouse, 13
D
Data Table I
Row Specification, 23 Input Location Functions, 133
Debugging (Buscar Errores), 85
Break Point Button,
139 Breakpoint, 86 K
Dashboard Window, 86 Kanban Approach, 230
Model Trace, 85
Status Label,
86 Watch, 86 L
Detached Queue, 33 Level State (Variable de Nivel), 75
Draw Queue, 40 List (Lista), 65
Drawing Node, 95
Create Symbol. See Create Symbol Objects, 118
Drawn to Scale, 13 Strings, 65
Índice 71
M Bidirectional, 32
Selection Weight Property, 19
Material (Material), 66 Travel Time, 38
Math (Matemática), 91 Pivot Grid, 15, 221
Epsilon, 140 Priority
If, 91 InitialPriority Property, 22
Is, 147 Priority State Variable, 22
Max, 105 Process
Min, 105 Model Create Process, 46
(Modelo), 2 OnInitialized, 77
ModelEntity Override (Desactivar), 162
Initial Desired Speed, 27 Processed, 63
Initial Sequence, 31 Processing, 49
ModelEntity (Entidad), Restore (Restablecer), 162
2 Modelo Process Steps (Etapas de Proceso)
Model Properties, Assign (Asignar), 45
2 Modelos Create (Crear), 107
Aeropuerto, 12 Decide (Decidir), 47
Aeropuerto Bis, 18 Delay (Retrasar), 49
Almacén, 152 Destroy (Destruir), 205
Cadena de Suministro con Múltiples Productos, 246 EndTransfer (Acabar Transferencia), 172
Cadena de Suministros Simple, 102 Execute (Ejecutar), 155
Cadenas de Suministros Avanzada, 194 Fire (Disparar), 82
Carril de Transferencia, 56 Insert (Insertar), 182
Célula de Fabricación, 27 Interrupt (Interrumpir), 84
Célula de Fabricación bis, 51 Release (Liberar, Soltar),
Clínica de Cuidados Intensivos, 88 50 Remove (Retirar), 84
Clínica de Cuidados Intensivos bis, 94 Remove (Sacar), 182
Clínica Veterinaria, 117 Ride (Transportar), 148
Clínica Veterinaria bis, 126 Route (Dirigir, Enviar), 161
Clínica Veterinaria Tres, 131 Search (Buscar), 83, 146
Ensamblaje de Tarjetas de Memoria, 35 Seize (Apresar, Agarrar), 49
Ensamblaje de Tarjetas de Memoria bis, 44 Set Node (Fijar Nodo), 84
Ensamblaje de una Maqueta, 62 Set Table (Fijar Tabla), 55
Gasolinera, 78 Tally (Contar), 46
La Tienda de Helado, 3 Transfer (Transferir), 84
Línea de Camisas, 185 UnBatch (Desagrupar), 48
Objeto Delay (Retardo), 159 Wait (Esperar), 81
Objeto Delay bis, 168 Project Management (Gestión de Proyectos)
Planificación de Procesos/Gestión de Proyectos, 211 Critical Path (Camino Crítico), 211
Sistemas Kanban con Operarios Multidisciplinares, Earliest Finish (Finalización Más Temprana), 212
230 Latest Finish (Finalización Más Tardía), 212
Sucursal de un Banco, 141 Percent CP(Critical Path) (Criticidad), 212
Tanque Simple, 74 Slack (Holgura), 212
Una Célula de Fabricación, 178 Properties (Propiedades)
Monitor (Controlador, Monitorizador), Element Reference, 173
70 Multiple SKUs, 246 Object Reference, 126
Repeat Group, 176
O Standard Property,
22 Property, 23
OptQuest, 112
Constraints, 114
R
P Ranking y selección, 111
Rate Table, 20
Paneles Reference Property, 38
[Project Library], 7 Referenced Property, 127
[Standard Library], 3 Reneging (Abandonar una Fila), 83
Navigation Panel, 2 Repeating Property Editor, 36
Paths (Caminos), 19 Bill of Materials, 66

Release, 120 Statistics (Estadísticas)
Seize, 119 Observation-Based, 41
State Variable Assignment, 40 State Statistic, 42
Reports, 15 Tally
Resource (Recurso), 49 Stopping Condition, 93
Initial Capacity, 49 Tally Statistic, 41, See Elements Tally
Responses, 15 Time-persistent, 41
Response Results, 16 Subclassing (Clonar), 154
Results (Resultados), 8 Delay Objeto, 159
Categories, 9 Derived/Specialized, 159
Capacity, 9 Server, 154, 195, 230
Content, 9 TimePath, 212
FlowTime, 9 TransferNode, 159
HoldingTime, 10 Vehicle, 187
ResourceState, 9
Symbol, 35
Throughput, 9
Pivot Grid/Table, 9, 14
Resource utilization, 10 T
Run Setup, 6 Tables
Data Table, 22
S Sequence Table, 30
TimePath (Camino con Duración o Retardo), 4
Schedules, 30 Timer Element. See Elements Timer
Seize (Apresar) TransferNode (Nodo de Transferencia)
Request Visit Property, Entity Destination Type, 31, 37
136 Separator (Separador), 42 Inherited Properties, 160
Server (Servidor, Operación), 4
Outbound Link Rule, 24
Current Symbol Index, Ride On Transporter, 32
60 InputBuffer.Contents, Selection Expression, 38
6 Processing.Contents, 6 TransferNode Properties, 19
ProcessTime, 39
Reliability Logic, 59
Static Ranking Rule, 129 V
SIMIO Vehicle (Vehículo), 32
Crear un modelo nuevo, 2 Idle Action, 32
Inicio, 1
Initial Desired Speed, 32
Sink (Sumidero), 4 Initial Node(Home), 32
Sistemas Lean, 230 ParkingStation.Contents,
SMORE, 109 33 Ride Capacity, 32
Source (Fuente), 4 Task Selection Strategy, 150
Add-On Process Triggers, 54 View, 6
Entities Per Arrival, 29
2-D, 6
Initial Capacity, 3-D, 6
15 Source, 5
Table Reference Assignment, 54
Time Varying Arrival Rate, 21 W
Standard Property, Work Schedules, 24, 30
22 Integer, 22 Work Schedules (Horarios, Turnos)
List, 224 Work Cycle, 30
Real, 38
Worker (Operario, Trabajador), 135
State, 176
Dynamic Selection Rule, 137
String, 121 Workstation (Estación de Trabajo), 62
State Variable, 23 Other Requirements, 67
Before Existing State Assignment,
36 Discrete State, 36
Station (Estación) Z
EntryQueue, 168
Zero-Time Events, 139
Inprocess Queue, 168
Índice 73

Fase Uno-Modelizacion-y-Simulacion-Libro-de-Practicas-Con-Simio-edited PDF

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

Fase Uno-Modelizacion-y-Simulacion-Libro-de-Practicas-Con-Simio-edited PDF

Cargado por

Copyright:

Formatos disponibles

Modelización y Simulación:

Libro de Prácticas con SIMIO

Jeffrey Allen Joines

Raleigh, North Carolina

Spanish Electronic Book ISBN: 978-0-9829782-4-5

Published by SIMIO, LLC, (http://www.simio.com)

Modelización y Simulación: Libro de Prácticas con SIMIO

iv Modelización y Simulación: Libro de Prácticas con SIMIO

STEPHEN D. ROBERTS es el A. Doug Allison Distinguished Professor in the Edward P.

vi Modelización y Simulación: Libro de Prácticas con SIMIO

1ª Parte: ¿Qué hace a este libro diferente?

2ª Parte: ¿Quién se beneficia de la Enseñanza Activa?

3ª Parte: ¿Por qué enfatizar en la “Modelización”?

4ª Parte: Organización del libro

5ª Parte: Estilos y Formatos Utilizados en este Libro

Por ejemplo, véase EasyFit en http://www.mathwave.com/

Prefacio: Aprendizaje Activo ix

Jeff Joines (JeffJoines@ncsu.edu)

North Carolina State University

Javier Otamendi (franciscojavier.otamendi@urjc.es)

Universidad Rey Juan Carlos

x Modelización y Simulación: Libro de Prácticas con SIMIO

Sección 1.1: El inicio

Figura 1.1: Abriendo la ventano de SIMIO

Introducción a SIMIO: La Tienda de Helados 1

Figura 1.2: Creando un nuevo modelo

Pregunta 1: ¿Cuál es el nombre por defecto de MODELENTITY?

Sección 1.2: La Tienda de Helados

Llegada Elección del Pago del Salida del

Figura 1.3: Flujograma de la Tienda de

Introducción a SIMIO: La Tienda de Helados 3

Note cambios en la barra

Figura 1.4: Comenzando a Modelizar

Pregunta 5: ¿Cuál es el nombre en la librería estándar del nodo de salida?

Figura 1.5: Propiedades de una Fuente

Pregunta 6: ¿Qué unidades de tiempo están asociadas al tiempo entre llegadas?

Paso 5: Complete su modelo añadiendo información a los dos servidores, SERVERS:

Para el objeto PEDIR:

Introducción a SIMIO: La Tienda de Helados 5

Figura 1.6: Determinando el Tiempo de Ejecución

Paso 9: Haga clic en la pestaña “View” y seleccione “3-D”.

Sección 1.3: Potenciando la Animación

6 Modelización y Simulación: Libro de Prácticas con SIMIO

Introducción a SIMIO: La Tienda de Helados 7

Pregunta 11: Enseñe la simulación a sus amigos. ¿Cuál es su reacción?

Sección 1.4: Viendo Resultados

Aunque la animación llama la atención, el objetivo de la simulación es comprender las características

Figura 1.8: Viendo Resultados

8 Modelización y Simulación: Libro de Prácticas con SIMIO

Paso 4: Los atributos se pueden mover a derecha e izquierda en la pantalla.

Paso 7: La utilización de recursos, Resource utilization, incluye tanto la utilización programada,

Pregunta 13: ¿Cuál es la utilización de la capacidad del objeto Pedir?

Pregunta 14: ¿Cuál es el número medio (contents) en el InputBuffer de Pedir?

Pregunta 17: ¿Cuál es la utilización del objeto Pagar?

Introducción a SIMIO: La Tienda de Helados 9

Si ha estado construyendo el modelo con nosotros, puede haber notado lo siguiente:

El botón de deshacer/rehacer de SIMIO, undo/redo, es muy conveniente. En el caso de caminos,

10 Modelización y Simulación: Libro de Prácticas con SIMIO

El modelo de simulación debe ser ejecutado para un período de 24 horas.

Sección 2.1: Desarrollando el modelo

Modelizando Distancias y Desplazamientos: Un Aeropuerto, 11

Sección 2.2: Utilizando la Biblioteca de Diseño 3D de Google

Figura 2.2: CheckIn