GPSS-Plus es un motor de simulación por eventos discretos y sistemas continuos orientado a modelar y analizar el comportamiento de sistemas reales a lo largo del tiempo. Su propósito no es programar aplicaciones, sino describir cómo funciona un sistema<\/strong> y observar su evolución bajo distintas condiciones.<\/p>\r\n En esencia, opera como un laboratorio digital donde fluye un conjunto de entidades (clientes, productos, vehículos, señales o paquetes de datos) a través de una red de procesos y recursos con capacidades y demoras definidas.<\/p>\r\n El objetivo es transformar una descripción real del sistema en un modelo ejecutable: desde una línea de producción industrial o una cadena logística, hasta el tráfico de datos en una red o un protocolo de emergencia. Al simular miles de escenarios en minutos, permite realizar previsiones, optimizar decisiones y diseñar protocolos de contingencia dentro de un entorno de simulación generalista.<\/p>\r\n Existen diferentes enfoques para abordar el modelado de sistemas tanto por su interfaz como por su objetivo.<\/p>\r\n Basados en Drag & Drop discretos y\/o continuos:<\/u><\/p>\r\n Discretos basados en lenguajes propios o generalistas:<\/u><\/p>\r\n Gracias a la herencia de los conceptos clave de GPSS clásico, GPSS-Plus se sitúa en ambos mundos, utilizando un lenguaje propio para definir el modelo, y se apoya en la potencia de un lenguaje generalista cuando el dominio lo requiere.<\/p>\r\n El objetivo último es que todo pueda comprenderse:<\/p>\r\n <\/p>\r\n Las principales innovaciones introducidas son:<\/p>\r\n El cambio más significativo está en el manejo de los parámetros de los bloques y comandos. En GPSS clásico, los parámetros A, B, C... ofrecían una sintaxis fija y limitada.<\/p>\r\n Ejemplo clásico:<\/p>\r\n En GPSS-Plus, se mantiene esa estructura, pero se extiende con un formato JSON-like, que permite especificar más detalles sin romper la simplicidad:<\/p>\r\n Esto hace posible integrar parámetros gráficos, de comportamiento, o lógicos, sin inventar nuevas variantes sintácticas para cada caso.<\/p>\r\n GPSS-Plus representa visualmente las entidades y los bloques mediante elementos gráficos simples: “bolitas” que se desplazan por un canvas siguiendo exactamente el flujo del modelo. Esta representación permite observar el sistema en tiempo real, comprender su dinámica de forma inmediata y facilitar la detección de cuellos de botella o comportamientos inesperados durante la ejecución. Las entidades virtuales<\/b> son la ayuda para describir lo invisible del modelo. Para quien venga de otros paradigmas, recogen lo que antes se describía fuera en otro lenguaje. Para quien se inicia, simplemente son otra entidad más.<\/p>\r\n En GPSS-Plus, todo lo que ocurre en el sistema se desarrolla en el tiempo y puede observarse mientras sucede. Para que eso sea posible todos los comportamientos se tratan de la misma forma: Como entidades<\/u> que se mueven, abstractas, visibles o un simple volumen.<\/p>\r\n Las entidades virtuales no se visualizan, pero son entidades completas<\/strong> que ejecutan lógica interna o eventos del sistema. Nacen para describir ese comportamiento con Según su ciclo de vida, existen tres tipos principales:<\/p>\r\n Reactores<\/strong>, que atienden eventos concretos y desaparecen.<\/p>\r\n <\/li>\r\n Agentes<\/strong>, que no mueren y gestionan el universo del modelo.<\/p>\r\n <\/li>\r\n Componentes<\/strong>, entidades vivas que existen como parte de otra entidad y mueren con ella.<\/p>\r\n <\/li>\r\n<\/ul>\r\n Con este enfoque, el modelo se convierte en un ecosistema de ejecuciones concurrentes<\/strong>. Una entidad puede esperar un autobús mientras atiende una llamada; un agente puede controlar el tráfico; el sol puede salir y ponerse sin que ninguna entidad principal tenga que ocuparse de ello.<\/p>\r\n Se observa que muchos conceptos habituales de la Programación Procedural o la Orientada a Objetos se reinterpretan: el comportamiento no se encapsula en objetos jerárquicos, sino que se modela explícitamente como entidades que coexisten y actúan en paralelo dentro del sistema. Al describirse íntegramente como un modelo explícito, GPSS-Plus permite que su comportamiento pueda ser analizado, interpretado y contrastado de forma automática. Una inteligencia artificial o auditor externo puede reconstruir qué hace el sistema, detectar incoherencias internas y contrastar la intención del modelador con la ejecución real del modelo. En GPSS-Plus, las variables ( El modelado continuo en GPSS-Plus se apoya en una idea simple: dividir el tiempo en pequeños fotogramas. Al ejecutar estos pasos de forma sucesiva dentro de la cola de eventos, el comportamiento continuo emerge de manera natural.<\/p>\r\n Los modelos de simulación pueden perseguir tres objetivos principales: Gracias a la Rehidratación<\/b>, el modelo no solo se conecta al mundo real, sino que se sincroniza con su estado en curso, permitiendo que el simulador 'despierte' en mitad de un proceso sin perder la continuidad operativa tras el último dato almacenado incluso tras la modificación del modelo.<\/p>\r\n <\/p>\r\n Además de estas innovaciones, GPSS-Plus incorpora múltiples extensiones que amplían su expresividad, modularidad y potencia:<\/p>\r\n Nuevos recursos<\/strong>: bloques nuevos como Creación dinámica de recursos<\/strong>: Lo que en motores Drag&Drop exigiría arrastrar cientos de bloques manualmente, en GPSS-Plus se logra con un simple bucle Behavior functions<\/strong>: a partir de datos reales o simulados, crea interpolaciones automáticas que encapsulan comportamientos complejos (por ejemplo, distintos tramos de una carretera o máquina).<\/p>\r\n <\/li>\r\n Funciones nativas<\/strong>: herramientas como Gráficas automáticas<\/strong>: basta con tabular datos para generar gráficos dentro del entorno de simulación.<\/p>\r\n <\/li>\r\n Contextos ( Depuración total<\/strong>: el sistema permite el seguimiento detallado de la cola de eventos, de cada entidad, recurso o variable, facilitando el análisis y la corrección de modelos.<\/p>\r\n <\/p>\r\n <\/li>\r\n<\/ul>\r\n <\/p>",
"descripcion": null,
"parametros": null,
"parametros_json": "",
"ejemplo": null,
"hijos": []
},
{
"id": "132",
"nombre": "Season 1: Hola mundo",
"texto": " Para entender GPSS ó GPSS-Plus y cualquier motor de simulación, primero debemos entender qué significa un sistema de eventos discretos (DES).<\/p>\r\n Un Sistema de Eventos Discretos (DES) modela procesos complejos basándose en la idea de que la actividad del sistema es una secuencia de eventos discretos.<\/p>\r\n El sistema completo se representa como la combinación de estos eventos puntuales que, al ejecutarse en el tiempo, simulan un proceso de la vida real.<\/p>\r\n Motores de simulación<\/b> como GPSS<\/b> y GPSS-Plus<\/b> son las herramientas clave para este análisis. Su función es modelar y analizar cómo los recursos<\/b> (máquinas, estaciones de trabajo, ventanillas, o vehículos) son gestionados en conjunción con las entidades<\/b> (clientes, productos) y sus respectivas colas de espera<\/b>.<\/p>\r\n Este enfoque genera informes y estadísticas que, entre muchas:<\/p>\r\n Identifican cuellos de botella<\/b> y minimizan tiempos de espera.<\/p>\r\n <\/li>\r\n Optimizan<\/b> el uso de los recursos de manera eficiente.<\/p>\r\n <\/li>\r\n Estudian y protocolizan<\/b> acciones y contingencias ante cualquier eventualidad o fallo en el sistema.<\/p>\r\n <\/li>\r\n<\/ol>",
"descripcion": null,
"parametros": null,
"parametros_json": "",
"ejemplo": null,
"hijos": [
{
"id": "133",
"nombre": "Un ejemplo simple",
"texto": " Simularemos un sistema básico donde las entidades (clientes) llegan a un recurso (ventanilla), esperan si está ocupada, son atendidas y luego se retiran. En este modelo:<\/p>\r\n Para los que conozcan GPSS clásico<\/b> tendríamos:<\/p>\r\n En GPSS-Plus<\/b>, es muy similar, pero con representación gráfica. Para ello, configuramos recursos y parámetros adicionales:<\/p>\r\n Paso final:<\/b> Pulsa Play y observa el resultado. La primera entidad saldrá del "Generate" entre los momentos 60 y 70.<\/p>\r\n Como se puede observar, el programa no ha cambiado demasiado para añadir la parte gráfica. Básicamente, hemos definido la situación espacial de los elementos.<\/p>",
"descripcion": "",
"parametros": "",
"parametros_json": "",
"ejemplo": "",
"hijos": []
},
{
"id": "137",
"nombre": "Sintaxis: Los comandos y los bloques",
"texto": " En una simulación, hay dos elementos principales en juego:<\/p>\r\n 1. Las ENTIDADES<\/b> o transacciones son los elementos que que cambian su estado con la simulación, pueden representar personas, cajas o cualquier elemento. En GPSS-Plus se representan con bolitas de colores. Estas entidades interactúan con el entorno. Por ejemplo, entran en juego a través del bloque 2. Los RECURSOS<\/b>, que conforman el entorno y son utilizados por las entidades, como una ventanilla de atención o una caja más grande que la que represente una entidad.<\/p>\r\n Por ejemplo, una persona (entidad) se acerca a una ventanilla (recurso). Esta ventanilla tendrá un COMANDO<\/b> que la define, y una serie de BLOQUES<\/b> que describen qué hace la persona en relación con la ventanilla.<\/p>\r\n Un ejemplo de definición de un recurso como ventanilla es el COMANDO:<\/p>\r\n <\/b>Un ejemplo de instrucción para que una entidad ocupe esa ventanilla es el BLOQUE:<\/p>\r\n <\/b>En resumen, nos basamos en dos elementos principales: bloques<\/b> y comandos<\/b>.<\/p>\r\n 1. Bloques <\/b>ligados a las entidades<\/b><\/p>\r\n Los bloques son instrucciones que las ENTIDADES ejecutan directamente<\/b> durante la simulación. Cada bloque define una acción específica que afecta al flujo o estado de esa entidad.<\/p>\r\n Sintaxis general: Ejemplos de bloque:<\/p>\r\n Los parámetros se denominan por letras (A, B, C, ...). Dependiendo del bloque, también pueden incluir parámetros en formato JSON-like, que usualmente definen aspectos gráficos o avanzados. Otro ejemplo:<\/p>\r\n 2. Comandos <\/b>ligados a los recursos y entorno del motor<\/b><\/p>\r\n Los comandos configuran el entorno de la simulación. A diferencia de los bloques, no son ejecutados directamente por las entidades. En cambio, definen recursos, posiciones gráficas y reglas del sistema.<\/p>\r\n Sintaxis general:<\/b><\/p>\r\n COMANDO {NAME:theName, OPCIONES JSON-LIKE}<\/p>\r\n Ejemplo para definir un almacén:<\/p>\r\n Este formato permite agregar información adicional como la posición (X, Y).<\/p>",
"descripcion": "",
"parametros": "",
"parametros_json": "",
"ejemplo": "",
"hijos": []
},
{
"id": "213",
"nombre": "Variables: Savevalues y Assigns",
"texto": " En GPSS-Plus, las variables<\/b> permiten almacenar información que puede ser utilizada por las entidades o para configurar elementos del entorno. Estas variables se dividen principalmente en dos tipos:<\/p>\r\n 1. SAVEVALUE<\/b> (variables globales):Las variables globales son accesibles por cualquier entidad y se mantienen durante toda la simulación. Son útiles para almacenar datos compartidos, como contadores, acumuladores o estados globales.<\/p>\r\n Sintaxis:<\/b> Ejemplo:<\/p>\r\n Este comando establece la variable global "TiempoEspera" con un valor de 8.<\/p>\r\n Una vez definido, el valor puede actualizarse en cualquier momento:<\/p>\r\n El valor de "TiempoEspera" ahora es 10.<\/p>\r\n Para recuperar el valor de una variable global se utilizan los SNA<\/b> que tienen un formato particular: Por ejemplo, incrementar el valor de un savevalue se puede hacer mediante:<\/p>\r\n <\/b>O a través del método:<\/b><\/p>\r\n Particularmente, y debido a que estas variables son usadas por más de una entidad, tiene un COMANDO asociado para su creación e inicialización llamado <\/b>Su sintaxix es simple:<\/p>\r\n Recuerda que 2. ASSIGN<\/b> (variables locales de la entidad): Sintaxis:<\/b> Ejemplo:<\/p>\r\n Este bloque asigna el valor 1 a la variable "Identificador" de la entidad actual que invoca el ASSIGN.<\/p>\r\n Para recuperar el valor de una variable local con su SNA <\/b>de formato: P$<\/b>Identificador <\/b>es la forma que permite obtener el valor de una variable local de la entidad.<\/p>\r\n Diferencias clave entre SAVEVALUE y ASSIGN:<\/b><\/p>\r\n Ejemplo combinado:<\/b><\/p>\r\n En este ejemplo, combinamos SAVEVALUE y ASSIGN para calcular el tiempo promedio de espera en una ventanilla. Si el tiempo está definido por un ADVANCE 15,10 significa que estarán entre 15 y 25 tiempos. Eso debería ir aproximando el promedio a 20.<\/p>\r\n En este código: De esta manera, Más adelante veremos como ambos BLOQUES admiten mucho más que variables numerales.<\/p>\r\n <\/p>",
"descripcion": "",
"parametros": "",
"parametros_json": "",
"ejemplo": "",
"hijos": []
},
{
"id": "134",
"nombre": "Estructura: IF, CALL, PROCEDURE",
"texto": " En este ejemplo, simulamos un sistema donde cada entidad elige aleatoriamente una de tres ventanillas<\/strong> para ser atendida. Cada ventanilla tiene su propia cola, y el flujo se distribuye de forma desigual en función del tiempo de servicio.<\/p>\r\n La lógica de decisión se resuelve exclusivamente mediante procedimientos estructurados.<\/p>\r\n Con respecto al anterior sólo tenemos unos pocos BLOQUES nuevos:<\/p>\r\n Este bloque crea una variable local en la entidad (llamada Este es un bloque de estructura de control "IF". Y este otro bloque de estructura de control no requiere tampoco muchas presentaciones. Que tampoco requieren mucha presentación. Encapsulan un conjunto de acciones ( <\/p>",
"descripcion": " En este ejemplo, simulamos un sistema donde cada entidad elige aleatoriamente una de tres ventanillas<\/strong> para ser atendida. Cada ventanilla tiene su propia cola, y el flujo se distribuye de forma desigual en función del tiempo de servicio.<\/p>\r\n La lógica de decisión se resuelve exclusivamente mediante procedimientos estructurados, sin uso de saltos ni etiquetas.<\/p>\r\n Con respecto al anterior sólo tenemos unos pocos BLOQUES nuevos:<\/p>\r\n Este bloque almacena en una memoria propia de cada entidad llamamos en este caso<\/b> "ALEATORIO" el valor calculado por "RANDOM", que es un número aleatorio entre 0 y 1. Este es un bloque de estructura de control "IF". Y este otro bloque de estructura de control no requiere tampoco muchas presentaciones. Que tampoco requieren mucha presentación. Encapsulan un conjunto de acciones ( <\/p>",
"parametros": "",
"parametros_json": "",
"ejemplo": "",
"hijos": []
},
{
"id": "248",
"nombre": "Recursos: Storage",
"texto": "\/* Almacenes: STORAGE\r\nGestión de capacidad y uso de un almacén.\r\n*\/\r\n\r\nINITIAL capacidad,40 ; define un savevalue llamado capacidad de valor 40\r\n\r\nSTORAGE {NAME:almacen1, X:300, Y:200, capacity:X$capacidad}\r\n\r\nPOSITION {NAME:SALIDA, X:500, Y:200}\r\n\r\n; Texto que muestra el contenido actual\r\nGRAPHIC {NAME:texto1, Type:TEXT, X:320, Y:240, Text:\"Cajas actuales: 0\"}\r\n\r\nSTART 100\r\n\r\n; Camiones llegando cada 10 unidades de tiempo\r\nGENERATE 10,0 {NAME:Camion, X:100, Y:200}\r\n\r\nADVANCE 15 {TO:almacen1}\r\nENTER almacen1,(random*15)+1 ; Ocupa entre 1 y 16 unidades del storage\r\nsavevalue uso,X$capacidad - R$(almacen1,LEFT)\r\nMOVE {name:texto1,text:\"Cajas actuales X$uso : R$(almacen1,OCCUPIED)\"}\r\nADVANCE 40,10\r\nLEAVE almacen1 ; Libera las unidades ocupadas\r\nsavevalue uso,X$capacidad - R$(almacen1,LEFT)\r\nMOVE {name:texto1,text:\"Cajas actuales X$uso : R$(almacen1,OCCUPIED)\"}\r\nADVANCE 15 {TO:SALIDA}\r\nTERMINATE 1\r\n",
"descripcion": " Uno de los recursos clásicos es el ¿Qué es un ¿Cómo funciona? Se define con una capacidad total, por ejemplo 40 unidades.<\/p>\r\n Las entidades usan el bloque Si una entidad quiere ocupar más de lo que hay disponible, esperará automáticamente en una cola interna hasta que el La cola de eventos:<\/b><\/p>\r\n En el corazón de cualquier simulación de eventos discretos se encuentra la cola de eventos<\/strong>, una estructura que define cómo y cuándo<\/strong> se ejecutan las acciones de las entidades en el modelo. Este enfoque de eventos discretos<\/strong> es lo que lo distingue de otros lenguajes de programación.<\/p>\r\n Hay que pensar que es como si cada entidad tuviese su propia programación, como se haría en C o Python, pero saltando entre entidades según el orden temporal<\/strong> que marca esta cola. Si simulamos 10 entidades, hay 10 programas corriendo “a la vez” (o casi).<\/p>\r\n ¿Qué es la cola de eventos?<\/strong><\/p>\r\n Es una lista ordenada de acciones programadas<\/strong>, cada una asociada a un instante de tiempo simulado (AC1). La cola garantiza que las acciones se ejecuten en el orden correcto según el tiempo en que deben ocurrir<\/strong>.<\/p>\r\n Lo más importante: está ordenada por tiempo<\/strong>. Por ejemplo:<\/p>\r\n Ejemplo: Evolución de la cola de eventos<\/strong><\/p>\r\n Supongamos el caso clásico de un banco donde los clientes entran por la puerta y son atendidos en una ventanilla. Las entidades son generadas con Imaginemos que estamos en el instante Ahora mismo, tenemos una entidad, la 5, que es la siguiente en la cola. Extraeremos ese elemento de la cola para procesarlo. ¡Ahora sabemos que el tiempo es 5! No porque el tiempo haya pasado, sino porque nuestra siguiente tarea está programada para T=5. Ya estamos en el evento siguiente. Toca actualizar el tiempo del sistema de nuevo: "AC1" que ahora toma el valor 7. Como decíamos, no es que el tiempo haya pasado, es que la cola de eventos hace saltar el tiempo porque no tiene nada que hacer hasta T=7. Ahora sería el momento de volver a mover el tiempo del sistema y atender el siguiente elemento: la Entidad 9. <\/p>\r\n Así seguirá viva la cola de eventos hasta que se cumpla alguna de las opciones que finalicen el programa. <\/b><\/p>\r\n Las colas de los recursos:<\/b><\/p>\r\n Otras colas existentes son las de los recursos que cada uno de ellos puede tener una o dos según el caso.<\/p>\r\n Estas listas están ordenadas por orden de llegada y su gestión depende exclusivamente del propio recurso.<\/p>\r\n Por ejemplo, una Cuando una entidad intenta hacer <\/strong><\/p>\r\n\r\n
\r\n
\r\nGENERATE 5\r\nADVANCE 10 {From:"Madrid", To:"Paris"}\r\nTERMINATE<\/pre>\r\n1. La sintaxis: compatibilidad extendida<\/h3>\r\n
\r\nADVANCE 30,10 ; Espera entre 30 y 40 tiempos<\/pre>\r\n
\r\nADVANCE 30,10 {From:"Madrid", To:"Paris"}<\/pre>\r\n2. Visualización gráfica<\/h3>\r\n
\r\n
\r\nEsta visualización, inexistente en GPSS clásico, introduce una nueva forma de interactuar con el modelo, donde la observación directa se convierte en una herramienta clave de validación y comprensión.<\/p>\r\n3. Entidades virtuales (VE)<\/h3>\r\n
ON_ENTER<\/code>, un TIMER <\/code>o TIMEOUT<\/code>, y viven en el propio modelo.<\/p>\r\n\r\n
\r\n
\r\nNo hay this, ni parent, ni child: todos son brothers. Las funciones dejan de ser llamadas puntuales y pasan a convertirse en procedimientos vivos. No existe “this.respirar()” que siempre respira igual, sino una persona que camina y, al mismo tiempo, respira un aire diferente.
\r\n <\/p>\r\n4. Auditoría del modelo y V&V.<\/h3>\r\n
\r\n
\r\nEsta capacidad introduce una evolución natural de los procesos clásicos de verificación y validación (V&V), que dejan de basarse únicamente en revisión manual y análisis estadístico. Se incorpora así la coherencia entre historia (H), modelo (M) y ejecución (E) sentando las bases de un nuevo enfoque de validación.
\r\n <\/p>\r\n5. Variables estructuradas<\/h3>\r\n
SAVEVALUE<\/code>, ASSIGN<\/code>) pueden contener números, strings, arrays u objetos<\/strong>.
\r\nEsto permite trabajar con estructuras de datos complejas directamente en el modelo, sin recurrir a lenguajes externos ni perder legibilidad. Por ejemplo:<\/p>\r\n\r\nASSIGN DATOS, {tipo:"Estudiante", Nombre:"Antonio", Edad: 22, Calificaciones: [8,5.8,6,8]}<\/pre>\r\n6. Sistema híbrido discreto - continuo<\/h3>\r\n
INTEGRATE<\/code>, DYNAMIC<\/code>, SOLVE <\/code>son las herramientas básicas que permiten definir estructuras de sistema continuo integrada en el mismo corazón de lo discreto. RK4, matrices Jacobianas y Newton Raphson permiten simular fluidos, voltajes o velocidades con el mismo DSL. <\/p>\r\n7. Sandbox, gemelos digitales y edge software<\/h3>\r\n
\r\n
\r\n- Sandbox<\/b>, orientado a la simulación acotada y a la obtención de resultados, con o sin precarga de datos históricos.
\r\n- Gemelo digital<\/b>, donde el modelo acompaña a un sistema real para su verificación, control u operación predictiva.
\r\n- Edge software<\/b>, en el que el modelo constituye el propio sistema, ejecutándose de forma permanente como lógica operativa.
\r\n
\r\nEn los dos últimos casos, el modelo debe interactuar con el entorno externo. GPSS-Plus permite este acoplamiento mediante el BRIDGER<\/b>, que actúa como un canal bidireccional genérico entre el modelo y sistemas físicos reales.
\r\n
\r\nDesde el punto de vista del lenguaje, el acceso a recursos externos es uniforme: una base de datos, un fichero o un sensor se manejan con la misma sintaxis. Abrir un relé o almacenar un dato se expresa mediante BRIDGE_WRITE<\/code>, y sustituir un GENERATE<\/code> que simula la entrada de un paquete por una suscripción a un sensor real de movimiento es prácticamente inmediato. La transición entre sandbox a gemelo digital o edge software resulta así transparente.<\/p>\r\nOtras extensiones destacadas:<\/h3>\r\n
\r\n
STOCK<\/code>, RESTROOM,<\/code> CONDITIONS<\/code>, máquinas de estados finitos que amplían la paleta clásica (STORAGE<\/code>, FACILITY<\/code>...).<\/p>\r\n <\/li>\r\n<\/ul>\r\n\r\n
FOREACH <\/code>y un NEWFACILITY<\/code>. Esta es la diferencia clave entre un lenguaje textual y las interfaces gráficas clásicas.<\/p>\r\n <\/li>\r\n<\/ul>\r\n\r\n
\r\n
CONCAT<\/code>, MERGE<\/code> , PUSH <\/code>extienden el lenguaje sin depender de código externo.<\/p>\r\n <\/li>\r\n CX$<\/code>)<\/strong>: cada modelo puede definir contextos independientes, ideales para crear librerías, módulos o componentes reutilizables.<\/p>\r\n <\/li>\r\n
\r\n¿Y qué es un evento discreto? Un evento discreto<\/b> es una acción o cambio que ocurre en un momento determinado y finaliza en otro:<\/p>\r\n\r\n
\r\n
\r\n
\r\nGENERATE 60,10 ; Entidades generadas cada 60 a 70 unidades de tiempo. \r\nADVANCE 10 ; Tarda 10 tiempos en colocarse en la cola de la ventanilla. \r\nSEIZE VENTANILLA ; La entidad llega a la cola de la ventanilla. \r\nADVANCE 60,30 ; Tiempo de atención: 60 a 90 tiempos. \r\nRELEASE VENTANILLA ; Abandona la ventanilla. \r\nADVANCE 10 ; Tarda 10 segundos en irse. \r\nTERMINATE 1 ; La entidad finaliza. \r\nSTART 100 ; Ejecuta esta acción hasta que 100 entidades hayan sido atendidas.<\/pre>\r\n
\r\nFACILITY {NAME:VENTANILLA, X:300, Y:300} ; Definimos la ventanilla en el espacio. \r\nPOSITION {NAME:SALIDA, X:500, Y:300} ; Definimos la salida en el espacio. \r\n\r\nGENERATE 60,10 {NAME:GEN1, X:100, Y:300} ; Posicionamos el generador de entidades. \r\nADVANCE 10 {TO:VENTANILLA} ; Avanza hasta la ventanilla. \r\nSEIZE VENTANILLA ; Asignación del recurso "VENTANILLA". \r\nADVANCE 60,30 ; Tiempo de atención: 60 a 90 tiempos. \r\nRELEASE VENTANILLA ; Liberación del recurso. \r\nADVANCE 10 {TO:SALIDA} ; Avanza hasta la salida. \r\nTERMINATE 1 ; La entidad finaliza. \r\nSTART 100 ; Ejecuta esta acción hasta que 100 entidades hayan sido atendidas.<\/pre>\r\nGENERATE<\/b><\/code>, avanzan por un circuito con ADVANCE<\/code> y mueren en un TERMINATE<\/b><\/code>.<\/p>\r\n\r\nFACILITY {name:Ventanilla1, x:100, y:100}<\/pre>\r\n\r\nSEIZE Ventanilla1<\/pre>\r\n
\r\n<\/b>
\r\nBLOQUE [PARÁMETROS A,B,C..] {OPCIONES JSON-LIKE}<\/p>\r\n\r\nASSIGN nombreVariable,10\r\nTERMINATE 1<\/pre>\r\n
\r\nEjemplo:<\/p>\r\n\r\nMOD {COLOR:#FF0000} ; pone de color rojo una entidad.<\/pre>\r\n\r\nADVANCE 10,5 {TO:Ventanilla1} ; la entidad avanza en tiempo hacia "Ventanilla1"<\/pre>\r\n\r\nSTORAGE {NAME:ALMACEN1, CAPACITY:10, X:270, Y:200}\r\n<\/pre>\r\n
\r\nSAVEVALUE variable, valor<\/b><\/p>\r\n\r\nSAVEVALUE TiempoEspera, 8\r\n<\/pre>\r\n
\r\nSAVEVALUE TiempoEspera, 10\r\n<\/pre>\r\n
\r\n
\r\nX$nombreSavevalue ó <\/b>X$(nombreSavevalue)<\/b><\/p>\r\n\r\n; X$TiempoEspera ó X$(TiempoEspera)\r\n\r\nIF (X$TiempoEspera>10)\r\n...<\/pre>\r\n
\r\nSAVEVALUE TiempoEspera, X$TiempoEspera + 1<\/pre>\r\n
<\/b>SAVEVALUE.inc TiempoEspera<\/pre>\r\n
INITIAL<\/b><\/code>.<\/b><\/p>\r\n\r\nINITIAL TiempoEspera,10<\/pre>\r\n
INITIAL <\/code>es un comando. Se usa al comienzo del programa para inicializar.<\/p>\r\n
\r\nLas variables locales pertenecen a una entidad específica. Cada entidad puede tener su propio valor para una misma variable, lo que las hace útiles para gestionar datos exclusivos de cada entidad.<\/p>\r\n
\r\nASSIGN variable, valor<\/b><\/p>\r\n\r\nASSIGN Identificador, 1\r\n<\/pre>\r\n
\r\n
\r\nP$nombreAssign ó <\/b>P$(nombreAssign)<\/b><\/p>\r\n\r\n; P$Identificador ó P$(Identificador)\r\nif(<\/b>P$Identificador>5) ...<\/b><\/pre>\r\n
\r\n
\r\nINITIAL TiempoTotal, 0 \r\nINITIAL NumEntidades, 0 \r\nFacility {NAME:Ventanilla,X:354,Y:204} \r\nGraphic {NAME:Text1,Type:TEXT,X:358,Y:321,Text:"Promedio"} \r\nPosition {NAME:Salida,X:577,Y:201} \r\nSTART 50 \r\n;---------------------------------\r\n\r\nGenerate 20,0 {NAME:GEN1,X:100,Y:207} \r\nADVANCE 10 {to:Ventanilla} \r\nSEIZE Ventanilla \r\nASSIGN TiempoInicio, AC1$ \r\nADVANCE 15,10 \r\nASSIGN TiempoFinal, AC1$ \r\nRELEASE Ventanilla \r\nADVANCE 15 {to:Salida} \r\nASSIGN TiempoEntidad, (P$TiempoFinal - P$TiempoInicio) \r\nSAVEVALUE NumEntidades, X$NumEntidades + 1 \r\nSAVEVALUE TiempoTotal, X$TiempoTotal + P$TiempoEntidad \r\nSAVEVALUE promedio, round(X$TiempoTotal \/ X$NumEntidades,3) \r\nMOVE {NAME:Text1,text:"Promedio: X$promedio"} \r\nTERMINATE 1 <\/pre>\r\n
\r\n- Cada entidad calcula su tiempo de espera en la ventanilla.
\r\n- Los tiempos se acumulan en la variable global "TiempoTotal".
\r\n- El número de entidades atendidas se cuenta en "NumEntidades".
\r\n- Al final de la simulación, puedes calcular el tiempo promedio de espera:
\r\nTiempoPromedio = X$TiempoTotal \/ X$NumEntidades<\/b><\/p>\r\nSAVEVALUE <\/code>y ASSIGN <\/code>trabajan juntos para ofrecer un manejo eficiente de datos en la simulación.<\/p>\r\n\r\nFACILITY {NAME:VENTANILLA1,X:320,Y:450}\r\nFACILITY {NAME:VENTANILLA2,X:320,Y:300}\r\nFACILITY {NAME:VENTANILLA3,X:320,Y:150}\r\n\r\nPOSITION {NAME:POS1,X:160,Y:300}\r\nPOSITION {NAME:POS2,X:497,Y:300}\r\n\r\nSTART 30 ; Se ejecutará hasta que se completen 30 entidades\r\n\r\nGENERATE 10,0 {NAME:GEN1,X:60,Y:300}\r\nADVANCE 20,0 {TO:POS1}\r\nASSIGN ALEATORIO,RANDOM\r\nIF (P$ALEATORIO<0.3)\r\n CALL CAMINO1\r\n ELSE \r\n IF (P$ALEATORIO<0.6)\r\n CALL CAMINO2\r\n ELSE\r\n CALL CAMINO3\r\n ENDIF\r\nENDIF\r\nADVANCE 20 {TO:POS2}\r\nTERMINATE 1\r\n\r\n;---------------------------------------------\r\n\r\nPROCEDURE CAMINO1\r\nADVANCE 20 {TO:VENTANILLA1}\r\nSEIZE VENTANILLA1\r\nADVANCE 25,10\r\nRELEASE VENTANILLA1\r\nENDPROCEDURE \r\n\r\nPROCEDURE CAMINO2\r\nADVANCE 20 {TO:VENTANILLA2}\r\nSEIZE VENTANILLA2\r\nADVANCE 10,2\r\nRELEASE VENTANILLA2\r\nENDPROCEDURE \r\n\r\nPROCEDURE CAMINO3\r\nADVANCE 20 {TO:VENTANILLA3}\r\nSEIZE VENTANILLA3\r\nADVANCE 10,2\r\nRELEASE VENTANILLA3\r\nENDPROCEDURE <\/pre>\r\n\r\nASSIGN ALEATORIO,RANDOM\r\n<\/pre>\r\n
ALEATORIO<\/code>) y le asigna un número aleatorio entre 0 y 1, usando la función RANDOM<\/code>.
\r\n
\r\nEstas variables locales también se llaman parámetros<\/em> y se accede a ellas con la notación SNA P$Nombre<\/code>
\r\n
\r\nP$ALEATORIO<\/code><\/p>\r\n\r\n
\r\nIF (P$ALEATORIO<0.3)<\/pre>\r\n
\r\n
\r\nComo se puede ver, es un "if" igual al de cualquier otro lenguaje. Comparamos una variable con un número.<\/p>\r\n
\r\nLlama a un "PROCEDURE".<\/p>\r\n\r\nCALL CAMINO1\r\n<\/pre>\r\n
\r\nPor último<\/p>\r\n\r\nPROCEDURE CAMINO1\r\n...\r\nENDPROCEDURE 100 ; produciría un assign en la entidad invocadora llamado CAMINO1 de valor 100<\/pre>\r\n
PROCEDURE<\/code>).<\/p>\r\nENDPROCEDURE <\/code>Puede tener de un valor en el parámetro A que será retornado del mismo modo que si hubieramos generado una instrucción ASSIGN<\/code>. Recuperable como P$NombredelProcedure (P.E. P$CAMINO1). En este caso, no se utiliza.<\/p>\r\n\r\nFACILITY {NAME:VENTANILLA1,X:320,Y:450}\r\nFACILITY {NAME:VENTANILLA2,X:320,Y:300}\r\nFACILITY {NAME:VENTANILLA3,X:320,Y:150}\r\n\r\nPOSITION {NAME:POS1,X:160,Y:300}\r\nPOSITION {NAME:POS2,X:497,Y:300}\r\n\r\nSTART 30 ; Se ejecutará hasta que se completen 30 entidades\r\n\r\nGENERATE 10,0 {NAME:GEN1,X:60,Y:300}\r\nADVANCE 20,0 {TO:POS1}\r\nASSIGN ALEATORIO,RANDOM\r\nIF (P$ALEATORIO<0.3)\r\n CALL CAMINO1\r\n ELSE \r\n IF (P$ALEATORIO<0.6)\r\n CALL CAMINO2\r\n ELSE\r\n CALL CAMINO3\r\n ENDIF\r\nENDIF\r\nADVANCE 20 {TO:POS2}\r\nTERMINATE 1\r\n\r\n;---------------------------------------------\r\n\r\nPROCEDURE CAMINO1\r\nADVANCE 20 {TO:VENTANILLA1}\r\nSEIZE VENTANILLA1\r\nADVANCE 25,10\r\nRELEASE VENTANILLA1\r\nENDPROCEDURE \r\n\r\nPROCEDURE CAMINO2\r\nADVANCE 20 {TO:VENTANILLA2}\r\nSEIZE VENTANILLA2\r\nADVANCE 10,2\r\nRELEASE VENTANILLA2\r\nENDPROCEDURE \r\n\r\nPROCEDURE CAMINO3\r\nADVANCE 20 {TO:VENTANILLA3}\r\nSEIZE VENTANILLA3\r\nADVANCE 10,2\r\nRELEASE VENTANILLA3\r\nENDPROCEDURE <\/pre>\r\n\r\nASSIGN ALEATORIO,RANDOM\r\n<\/pre>\r\n
\r\nA estos "Assigns" se les denomina "parámetros" y son accesibles de mediante la notación SNA<\/b>:
\r\n
\r\nP$ALEATORIO<\/code><\/p>\r\n\r\n
\r\nIF (P$ALEATORIO<0.3)<\/pre>\r\n
\r\n
\r\nComo se puede ver, es un "if" igual al de cualquier otro lenguaje. Comparamos una variable con un número.<\/p>\r\n\r\nCALL CAMINO1\r\n<\/pre>\r\n
\r\nLlama a un "PROCEDURE".
\r\n
\r\nPor último<\/p>\r\n\r\nPROCEDURE CAMINO1\r\n...\r\nENDPROCEDURE 100 ; produciría un assign en la entidad invocadora llamado CAMINO1 de valor 100<\/pre>\r\n
PROCEDURE<\/code>).<\/p>\r\nENDPROCEDURE <\/code>Puede teter de un valor en el parámetro A que será retornado del mismo modo que si hubieramos generado una instrucción ASSIGN<\/code>. Recuperable como P$NombredelProcedure (P.E. P$CAMINO1). En este caso, no se utiliza.<\/p>\r\nSTORAGE<\/code>.<\/p>\r\nFACILITY<\/code> representa cosas como una ventanilla, una máquina o un operario: solo puede atender a una entidad a la vez y según su capacidad (con CAPACITY:3 la FACILITY atendería 3 entidades). STORAGE, en cambio, representa algo como un almacén, un tanque, o una red que puede usarse parcialmente.<\/p>\r\nSTORAGE<\/code>? Un STORAGE <\/code>es un tipo de recurso que no se ocupa por entidad, sino por cantidad. Se usa cuando una entidad debe reservar parte de un recurso sin ocuparlo por completo. Por ejemplo, un camión puede dejar 10 cajas en un almacén que admite hasta 40.<\/p>\r\n\r\nSTORAGE {NAME:almacen1, X:300, Y:200, capacity:40}<\/pre>\r\nENTER <\/code>para ocupar cierta cantidad, y LEAVE <\/code>para devolverla.<\/p>\r\n\r\nENTER almacen1,5\r\nLEAVE almacen1 <\/pre>\r\n
STORAGE<\/code> tenga suficiente capacidad libre. No necesitas programar nada adicional para gestionar esa espera.
\r\n
\r\nEn el ejemplo: Almacén de cajas definido (STORAGE<\/code>) con 40 unidades de capacidad. Los camiones llegan cada 10 unidades de tiempo y depositan entre 1 y 16 cajas. Después de un tiempo, se retiran liberando el espacio ocupado. Verás en el texto de pantalla cuántas cajas hay almacenadas en cada momento.
\r\n
\r\nAdemás de realizarse el cálculo a través de sumas y restas, se puede hacer directamente consultando el SNA correspondiente a la ocupación del STORAGE<\/code>:<\/p>\r\n\r\nR$(almacen1,OCCUPIED) ; Unidades actualmente ocupadas\r\nR$(almacen1,LEFT) ; Unidades disponibles<\/pre>",
"parametros": null,
"parametros_json": null,
"ejemplo": null,
"hijos": []
},
{
"id": "307",
"nombre": "La cola de eventos: el motor de la simulación",
"texto": "\r\nTiempo 15 - Atender a la entidad 14 en el paso 88\r\nTiempo 45 - Atender a la entidad 22 en el paso 16\r\nTiempo 77 - Atender a la entidad 16 en el paso 25<\/pre>\r\n
GENERATE<\/code> y pasan un tiempo siendo atendidas mediante ADVANCE<\/code>.<\/p>\r\nT = 5<\/code>, con la siguiente cola:<\/p>\r\n\r\nT 5: Entidad 5: Esperando en la cola de la ventanilla\r\nT 7: Generate: Generar elemento, cliente que va a entrar por la puerta\r\nT 8: Entidad 9: Dirigiéndose a la cola de la ventanilla\r\nT 16: Entidad 3: Dirigiéndose a la cola de la ventanilla\r\n<\/pre>\r\n
\r\n
\r\nVamos a pensar que, por ejemplo, la Entidad 5 se encuentra en el "paso" (posición de su programación) que indica un ADVANCE 10 para ser atendida.
\r\nAnte esto, la solución es colocarse en la cola en T=15 (5+10) y cesar en su ejecución mientras es atendida.
\r\nAhora la cola de eventos tendrá esta situación:<\/p>\r\n\r\nT 7: Generate: Generar elemento\r\nT 8: Entidad 9: Dirigiendose a la cola de la ventanilla\r\nT 15: Entidad 5: Ir a la salida\r\nT 16: Entidad 3: Dirigiendose a la cola de la ventanilla\r\n<\/pre>\r\n
\r\n
\r\nExtraemos el elemento de la cola y nos encontramos con un GENERATE 20,5. Por lo tanto, debemos calcular qué tiempo será ese definido por 20,5; algo entre 20 y 25. Supongamos el resultado de 22. Es decir, entrará otra persona dentro de 22 tiempos. La cola pasa ahora a tener este otro aspecto después de moverse el GENERATE y realizar 2 tareas<\/b>:
\r\n
\r\n1.- En propio GENERATE avanza 20 (parámetro A) (7+20=27).
\r\n2.- Crear una nueva entidad (la número 10) para que pueda llevar a cabo sus tareas en 22 momentos después (7+22=29).<\/p>\r\n\r\nT 8: Entidad 9: Dirigiendose a la cola de la ventanilla\r\nT 15: Entidad 5: Ir a la salida\r\nT 16: Entidad 3: Dirigiendose a la cola de la ventanilla\r\nT 27: Generate: Generar elemento\r\nT 29: Entidad 10: Dirigiendose a la cola de la ventanilla<\/pre>\r\n
\r\nEsta cola de eventos en GPSS-Plus tiene, además, otras características para poder realizar las tareas en el mundo gráfico y añadir los eventos tipo "ON_*".
\r\n
\r\nEn esta cola GPSS-Plus, tenemos 5 tipos de elementos:<\/b><\/p>\r\n\r\n
facility <\/code>tiene dos listas, la de entidades ocupantes y la de entidades en cola.<\/p>\r\nSEIZE<\/code>, si el recurso está ocupado, pasará a la lista de espera. Si no hay entidades en el recurso, lo ocupará ingresando en la lista de ocupantes.
\r\n
\r\nCuando realize RELEASE<\/code>, abandonará esta lista y forzará al recurso a buscar alguna entidad en su cola pendiente de entrar. Si hay alguna, la incorporará a la lista de ocupantes y planificará su entrada en la cola de eventos en ese mismo momento, por lo que esa entidad tomará el control del motor en cuanto la saliente cese su actividad.<\/p>\r\n