Esempio n. 1
0
        private void Simular()
        {
            var inicioFinInstance  = new InicioFinDelegate(InicioFin);
            var columnasInstance   = new ColumnasDelegate(AgregarColumnas);
            var filaInstance       = new FilaDelegate(AgregarFila);
            var statusInstance     = new StatusDelegate(ActualizarStatus);
            var resultadosInstance = new ResultadosDelegate(MostrarResultados);

            Invoke(inicioFinInstance, false);

            //manejo de llegadas
            var horaInicio = DateTime.Today.AddHours(8);
            var horaFin    = DateTime.Today.AddHours(18);
            var media      = double.Parse(txt_llegadas_media.Text);
            //media = media / 24;
            //media = media / 60;
            var           lambda = 1 / media;
            IDistribucion distribucionLlegadas = new DistribucionExponencialNegativa(lambda);
            Llegada       llegadas             = new Llegada(distribucionLlegadas, horaInicio, horaFin);

            //manejo de Quitado de Alfombras
            DateTime tiempoQA         = DateTime.Parse(txt_tiempoQA.Text);
            var      colaQA           = new ColaFifo("Quitado de Alfombra");
            var      quitadoAlfombras = new Servidor(tiempoQA, colaQA, "Quitado de Alfombra", false, true);

            //manejo de Aspirado
            var generadorCongMixto   = new CongruencialMixto(1000, 12, 17, 5000);
            var aspirado_a           = double.Parse(txt_aspirado_a.Text);
            var aspirado_b           = double.Parse(txt_aspirado_b.Text);
            var distribucionAspirado = new DistribucionUniforme(aspirado_a, aspirado_b, generadorCongMixto);
            var colaAspirado         = new ColaFifo("Aspirado");
            var aspirado             = new Servidor(distribucionAspirado, colaAspirado, "Aspirado", false, false);

            //manejo de Lavado

            var lavado_a           = double.Parse(txt_lavado_a.Text);
            var lavado_b           = double.Parse(txt_lavado_b.Text);
            var distribucionLavado = new DistribucionUniforme(lavado_a, lavado_b, generadorCongMixto);
            //var distribucionLavado = new DistribucionUniforme(lavado_a, lavado_b);
            var colaLS    = new ColaFifo("Lavadero");
            var lavadero1 = new Servidor(distribucionLavado, colaLS, "Lavadero 1", false, false);
            var lavadero2 = new Servidor(distribucionLavado, colaLS, "Lavadero 2", false, false);

            //manejo de secado

            var secadora = new Servidor("Secadora", true, false);

            //manejo de puesta de alfombra
            DateTime tiempoPA      = DateTime.Parse(txt_puesta_alfombras.Text);
            var      colaPA        = new ColaFifo("Puesta de Alfombra");
            var      ponerAlfombra = new Servidor(tiempoPA, colaPA, "Puesta de Alfombra", false, true);


            var dias  = int.Parse(txt_dias.Text);
            var desde = int.Parse(txt_desde.Text);
            var hasta = int.Parse(txt_hasta.Text);

            decimal promedioAtendidos   = 0;
            decimal promedioPermanencia = 0;

            var simulacion = 0;
            var numAutos   = 0;
            var clientes   = new List <Cliente>();
            int colaMax    = 0;
            var atendidos  = 0;

            _cancelar = false;
            for (var dia = 1; dia <= dias; dia++)
            {
                if (_cancelar == true)
                {
                    break;
                }


                decimal permanenciaDiaria = 0;
                llegadas.Abrir();

                while (llegadas.EstaAbierto() ||
                       !quitadoAlfombras.EstaLibre() ||
                       !aspirado.EstaLibre() ||
                       !aspirado.EstaLibre() ||
                       !secadora.EstaLibre() ||
                       !lavadero1.EstaLibre() ||
                       !lavadero2.EstaLibre() ||
                       !ponerAlfombra.EstaLibre())
                {
                    if (_cancelar)
                    {
                        break;
                    }

                    simulacion++;


                    var eventos = new List <Evento>
                    {
                        new Evento("Llegada", llegadas.ProximaLlegada),
                        new Evento("Cierre", llegadas.Cierre),
                        new Evento("Fin de Quitado de Alfombras", quitadoAlfombras.ProximoFinAtencion),
                        new Evento("Fin de Aspirado", aspirado.ProximoFinAtencion),
                        new Evento("Fin de Secado", secadora.ProximoFinAtencion),
                        new Evento("Fin de Lavadero 1", lavadero1.ProximoFinAtencion),
                        new Evento("Fin de Lavadero 2", lavadero2.ProximoFinAtencion),
                        new Evento("Fin Puesta de alfombras", ponerAlfombra.ProximoFinAtencion),
                    };

                    var relojActual  = eventos.Where(ev => ev.Hora.HasValue).Min(ev => ev.Hora).Value;
                    var eventoActual = eventos.First(ev => ev.Hora.Equals(relojActual)).Nombre;

                    switch (eventoActual)
                    {
                    case "Llegada":
                        numAutos++;
                        String tipoAuto         = ObtenerTipo();
                        var    alfombraLlegando = new Alfombra($"Alfombra de Auto {numAutos}");
                        var    clienteLlegando  = new Cliente($"Auto {numAutos}", tipoAuto, alfombraLlegando);
                        clienteLlegando.Llegar(relojActual);
                        quitadoAlfombras.LlegadaCliente(relojActual, clienteLlegando);
                        llegadas.ActualizarLlegada(1);
                        if (simulacion <= hasta)
                        {
                            clientes.Add(clienteLlegando);

                            Invoke(columnasInstance, numAutos);
                        }
                        break;

                    case "Fin de Quitado de Alfombras":
                        var clienteSinAlfombra = quitadoAlfombras.FinAtencion();
                        aspirado.LlegadaCliente(relojActual, clienteSinAlfombra);
                        if (lavadero1.EstaLibre())
                        {
                            lavadero1.LlegadaCliente(relojActual, clienteSinAlfombra);
                        }
                        else
                        {
                            lavadero2.LlegadaCliente(relojActual, clienteSinAlfombra);
                        }

                        break;

                    case "Fin de Aspirado":
                        var clienteAspirado = aspirado.FinAtencion();
                        if (clienteAspirado.Humedad <= 1)
                        {
                            ponerAlfombra.LlegadaCliente(relojActual, clienteAspirado);
                        }
                        break;

                    case "Fin de Lavadero 1":
                        if (lavadero1.ClienteActual.Humedad < 1)
                        {
                            var clienteSeco = lavadero1.FinAtencion();
                            ponerAlfombra.LlegadaCliente(relojActual, clienteSeco);
                        }
                        else
                        {
                            if (secadora.EstaLibre())
                            {
                                var clienteLavado1 = lavadero1.FinAtencion();
                                secadora.LlegadaCliente(relojActual, clienteLavado1);
                            }
                            else
                            {
                                lavadero1.cambiarEstado("Bloqueado");
                                lavadero1.ComenzarSecado(relojActual);
                            }
                        }


                        break;

                    case "Fin de Lavadero 2":
                        if (lavadero2.ClienteActual.Humedad < 1)
                        {
                            var clienteSeco = lavadero2.FinAtencion();
                            ponerAlfombra.LlegadaCliente(relojActual, clienteSeco);
                        }
                        else
                        {
                            if (secadora.EstaLibre())
                            {
                                var clienteLavado2 = lavadero2.FinAtencion();
                                secadora.LlegadaCliente(relojActual, clienteLavado2);
                            }
                            else
                            {
                                lavadero2.cambiarEstado("Bloqueado");
                                lavadero2.ComenzarSecado(relojActual);
                            }
                        }
                        break;

                    case "Fin de Secado":
                        Cliente clienteASecado = null;
                        Cliente clienteSecado  = secadora.FinAtencion();
                        if (lavadero1.EstaBloqueado() & lavadero2.EstaBloqueado())
                        {
                            clienteASecado = lavadero1.ClienteActual;
                            clienteASecado.CalcularSecado(relojActual);
                            lavadero1.cambiarEstado("Libre");
                            lavadero1.FinAtencion();
                            secadora.LlegadaCliente(relojActual, clienteASecado);
                        }
                        else
                        {
                            if (lavadero1.EstaBloqueado())
                            {
                                clienteASecado = lavadero1.ClienteActual;
                                clienteASecado.CalcularSecado(relojActual);
                                lavadero1.cambiarEstado("Libre");
                                lavadero1.FinAtencion();
                                secadora.LlegadaCliente(relojActual, clienteASecado);
                            }
                            else
                            {
                                if (lavadero2.EstaBloqueado())
                                {
                                    clienteASecado = lavadero2.ClienteActual;
                                    clienteASecado.CalcularSecado(relojActual);
                                    lavadero2.cambiarEstado("Libre");
                                    lavadero2.FinAtencion();
                                    secadora.LlegadaCliente(relojActual, clienteASecado);
                                }
                            }
                        }

                        ponerAlfombra.LlegadaCliente(relojActual, clienteSecado);

                        break;

                    case "Fin Puesta de alfombras":

                        var clienteSaliendo = ponerAlfombra.FinAtencion();
                        if (clienteSaliendo != null)
                        {
                            clienteSaliendo.Salir(relojActual);
                            permanenciaDiaria = (permanenciaDiaria * atendidos + clienteSaliendo.TiempoEnSistema) / (atendidos + 1);
                            atendidos++;
                        }
                        break;

                    case "Cierre":
                        llegadas.Cerrar();
                        colaQA.Vaciar();
                        break;
                    }

                    colaMax = quitadoAlfombras.MaxCola;
                    if (simulacion % 10 == 0)
                    {
                        Invoke(statusInstance, dia, relojActual, simulacion);
                    }
                    //termina la simulacion
                    if (simulacion >= desde && simulacion <= hasta)
                    { //esto invoca el metodo de llenado de la fila
                        Invoke(filaInstance, relojActual, eventoActual, llegadas, colaQA, quitadoAlfombras, colaAspirado,
                               aspirado, colaLS, lavadero1, lavadero2, secadora, colaPA, ponerAlfombra, atendidos, permanenciaDiaria, clientes);
                    }
                }

                var permanenciaAnterior = promedioPermanencia * promedioAtendidos * (dia - 1);
                promedioAtendidos = (promedioAtendidos * (dia - 1) + atendidos) / dia;


                if (promedioAtendidos != 0)
                {
                    promedioPermanencia = (permanenciaAnterior + permanenciaDiaria * atendidos) / (promedioAtendidos * dia);
                }
            }

            Invoke(resultadosInstance, promedioAtendidos, promedioPermanencia, colaMax, atendidos);
            Invoke(inicioFinInstance, true);
            var resultado = _cancelar ? "interrumpida" : "completa";

            MessageBox.Show($@"Simulación {resultado}", @"Resultado");
        }
Esempio n. 2
0
        private void Simular()
        {
            //delegates
            var inicioFinInstance  = new InicioFinDelegate(InicioFin);
            var columnasInstance   = new ColumnasDelegate(AgregarColumnas);
            var filaInstance       = new FilaDelegate(AgregarFila);
            var statusInstance     = new StatusDelegate(ActualizarStatus);
            var resultadosInstance = new ResultadosDelegate(MostrarResultados);

            //preparación inicial del formulario
            Invoke(inicioFinInstance, false);

            //clientes
            var entreLlegadas        = double.Parse(txt_llegadas.Text);
            var distribucionLlegadas = new DistribucionUniforme(entreLlegadas, entreLlegadas);

            var minInicio  = (double)DateTimeConverter.EnMinutos($"{txt_apertura.Text}:00");
            var horaInicio = DateTime.Today.AddMinutes(minInicio);

            var minFin  = (double)DateTimeConverter.EnMinutos($"{txt_cierre.Text}:00");
            var horaFin = DateTime.Today.AddMinutes(minFin);

            var local = new Llegada(distribucionLlegadas, horaInicio, horaFin);

            var colaMax = int.Parse(txt_cola_max.Text);

            //grupos
            var probabilidadGrupo2 = double.Parse(txt_grupos_2.Text);
            var probabilidadGrupo4 = double.Parse(txt_grupos_4.Text);

            var grupos = new DistribucionAleatoria(new List <Probabilidad>
            {
                new Probabilidad(2, probabilidadGrupo2),
                new Probabilidad(4, probabilidadGrupo4)
            });

            //menús
            var probabilidadMenu1 = double.Parse(txt_menu_1.Text);
            var probabilidadMenu2 = double.Parse(txt_menu_2.Text);

            var menus = new DistribucionAleatoria(new List <Probabilidad>
            {
                new Probabilidad(1, probabilidadMenu1),
                new Probabilidad(2, probabilidadMenu2)
            });

            var demoraMenu1       = double.Parse(txt_demora_menu_1.Text);
            var distribucionMenu1 = new DistribucionUniforme(demoraMenu1, demoraMenu1);

            var demoraMenu2       = double.Parse(txt_demora_menu_2.Text);
            var distribucionMenu2 = new DistribucionUniforme(demoraMenu2, demoraMenu2);

            //mozo
            var demoraCarta       = double.Parse(txt_carta.Text);
            var distribucionCarta = new DistribucionUniforme(demoraCarta, demoraCarta);

            var demoraPedido       = double.Parse(txt_pedido.Text);
            var distribucionPedido = new DistribucionUniforme(demoraPedido, demoraPedido);

            //comida
            var media    = double.Parse(txt_comida_media.Text);
            var varianza = double.Parse(txt_comida_varianza.Text);

            var distribucionComida = new DistribucionNormal(media, varianza);

            //eventos
            var inicio = int.Parse(txt_desde.Text);
            var fin    = int.Parse(txt_hasta.Text);

            //servidores
            var colaMesas = new ColaVacia();
            var mesa1     = new Servidor(distribucionComida, colaMesas, "Mesa 1");
            var mesa2     = new Servidor(distribucionComida, colaMesas, "Mesa 2");
            var mesa3     = new Servidor(distribucionComida, colaMesas, "Mesa 3");
            var mesa4     = new Servidor(distribucionComida, colaMesas, "Mesa 4");
            var mesa5     = new Servidor(distribucionComida, colaMesas, "Mesa 5");
            var mesa6     = new Servidor(distribucionComida, colaMesas, "Mesa 6");
            var mesa7     = new Servidor(distribucionComida, colaMesas, "Mesa 7");
            var mesa8     = new Servidor(distribucionComida, colaMesas, "Mesa 8");
            var mesa9     = new Servidor(distribucionComida, colaMesas, "Mesa 9");
            var mesa10    = new Servidor(distribucionComida, colaMesas, "Mesa 10");

            var mesas = new List <Ocupacion>
            {
                new Ocupacion(mesa1),
                new Ocupacion(mesa2),
                new Ocupacion(mesa3),
                new Ocupacion(mesa4),
                new Ocupacion(mesa5),
                new Ocupacion(mesa6),
                new Ocupacion(mesa7),
                new Ocupacion(mesa8),
                new Ocupacion(mesa9),
                new Ocupacion(mesa10)
            };

            var colaMozo = new ColaPriorizada("mozo");
            var mozo     = new ServidorDoble(distribucionCarta, distribucionPedido, colaMozo, "mozo");

            var colaCocina = new ColaFifo("cocina");
            var cocina     = new ServidorDoble(distribucionMenu1, distribucionMenu2, colaCocina, "cocina");

            //simulación

            var     simulacion       = 0;
            var     numCliente       = 0;
            var     colaLocal        = new ColaFifo("local");
            var     clientes         = new List <VectorCliente>();
            var     atendidos        = 0;
            var     perdidos         = 0;
            var     acumuladorEspera = new PromedioAcumulado();
            decimal esperaPromedio   = 0;

            local.Abrir();

            _cancelar = false;

            while (local.EstaAbierto() ||
                   !mozo.EstaLibre() ||
                   !cocina.EstaLibre() ||
                   mesas.Any(m => !m.Mesa.EstaLibre()))
            {
                if (_cancelar)
                {
                    break;
                }

                simulacion++;

                var eventos = new List <Evento>
                {
                    new Evento("Llegada", local.ProximaLlegada),
                    new Evento("Cierre", local.Cierre),
                    new Evento("Fin Mozo", mozo.ProximoFinAtencion),
                    new Evento("Fin Cocina", cocina.ProximoFinAtencion),
                    new Evento("Fin Mesa 1", mesa1.ProximoFinAtencion),
                    new Evento("Fin Mesa 2", mesa2.ProximoFinAtencion),
                    new Evento("Fin Mesa 3", mesa3.ProximoFinAtencion),
                    new Evento("Fin Mesa 4", mesa4.ProximoFinAtencion),
                    new Evento("Fin Mesa 5", mesa5.ProximoFinAtencion),
                    new Evento("Fin Mesa 6", mesa6.ProximoFinAtencion),
                    new Evento("Fin Mesa 7", mesa7.ProximoFinAtencion),
                    new Evento("Fin Mesa 8", mesa8.ProximoFinAtencion),
                    new Evento("Fin Mesa 9", mesa9.ProximoFinAtencion),
                    new Evento("Fin Mesa 10", mesa10.ProximoFinAtencion),
                };

                // ReSharper disable once PossibleInvalidOperationException
                var relojActual  = eventos.Where(ev => ev.Hora.HasValue).Min(ev => ev.Hora).Value;
                var eventoActual = eventos.First(ev => ev.Hora.Equals(relojActual)).Nombre;

                switch (eventoActual)
                {
                case "Llegada":
                    local.ActualizarLlegada();
                    numCliente++;
                    var clienteLlegando = new Cliente($"Grupo {numCliente}", 1);
                    clienteLlegando.Llegar(relojActual);
                    var cantidadGrupo = (int)grupos.ObtenerValor();

                    if (simulacion < fin)
                    {
                        clientes.Add(new VectorCliente
                        {
                            Cliente  = clienteLlegando,
                            Cantidad = cantidadGrupo
                        });
                        //agrego las columnas para el vector de estados del cliente
                        Invoke(columnasInstance, numCliente);
                    }

                    if (mesas.Any(m => m.EstaLibre()))
                    {
                        var mesaLibre = mesas.First(m => m.EstaLibre());
                        mesaLibre.Ocupar(clienteLlegando, cantidadGrupo);
                        mozo.LlegadaGrupo(relojActual, clienteLlegando, cantidadGrupo);
                        if (simulacion < fin)
                        {
                            clientes.Last().Mesa = mesaLibre.Mesa.Nombre;
                        }
                    }
                    else if (colaLocal.Cantidad() < colaMax)
                    {
                        colaLocal.AgregarCliente(clienteLlegando);
                    }
                    else
                    {
                        clienteLlegando.Salir(relojActual);
                        perdidos += cantidadGrupo;
                    }
                    break;

                case "Fin Mozo":
                    var clienteAtendido = mozo.FinAtencion();
                    var mesa            = mesas.Single(m => clienteAtendido.Equals(m.Cliente));
                    if (clienteAtendido.Prioridad.Equals(1))
                    {
                        var pedido          = (int)menus.ObtenerValor();
                        var cantidadPedidos = mesa.Cantidad;
                        clienteAtendido.CambiarPrioridad(pedido);
                        cocina.LlegadaGrupo(relojActual, clienteAtendido, cantidadPedidos);

                        if (simulacion < fin)
                        {
                            clientes.Single(c => c.Cliente.Equals(clienteAtendido))
                            .Menu         = $"Menu {pedido}";
                            eventoActual += " (Carta)";
                        }
                    }
                    else
                    {
                        mesa.Mesa.LlegadaCliente(relojActual, clienteAtendido);
                        eventoActual += " (Pedido)";
                    }
                    break;

                case "Fin Cocina":
                    var clienteConPedido = cocina.FinAtencion();
                    clienteConPedido.CambiarPrioridad(2);
                    mozo.LlegadaCliente(relojActual, clienteConPedido);
                    break;

                case "Fin Mesa 1":
                    var clienteSaliendo1 = mesa1.FinAtencion();
                    clienteSaliendo1.Salir(relojActual);
                    var cantidadAtendidos1 = mesas.Single(m => m.Mesa.Equals(mesa1)).Cantidad;
                    atendidos += cantidadAtendidos1;

                    for (var i = 0; i < cantidadAtendidos1; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo1.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa1)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Fin Mesa 2":
                    var clienteSaliendo2 = mesa2.FinAtencion();
                    clienteSaliendo2.Salir(relojActual);
                    var cantidadAtendidos2 = mesas.Single(m => m.Mesa.Equals(mesa2)).Cantidad;
                    atendidos += cantidadAtendidos2;

                    for (var i = 0; i < cantidadAtendidos2; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo2.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa2)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Fin Mesa 3":
                    var clienteSaliendo3 = mesa3.FinAtencion();
                    clienteSaliendo3.Salir(relojActual);
                    var cantidadAtendidos3 = mesas.Single(m => m.Mesa.Equals(mesa3)).Cantidad;
                    atendidos += cantidadAtendidos3;

                    for (var i = 0; i < cantidadAtendidos3; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo3.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa3)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Fin Mesa 4":
                    var clienteSaliendo4 = mesa4.FinAtencion();
                    clienteSaliendo4.Salir(relojActual);
                    var cantidadAtendidos4 = mesas.Single(m => m.Mesa.Equals(mesa4)).Cantidad;
                    atendidos += cantidadAtendidos4;

                    for (var i = 0; i < cantidadAtendidos4; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo4.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa4)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Fin Mesa 5":
                    var clienteSaliendo5 = mesa5.FinAtencion();
                    clienteSaliendo5.Salir(relojActual);
                    var cantidadAtendidos5 = mesas.Single(m => m.Mesa.Equals(mesa5)).Cantidad;
                    atendidos += cantidadAtendidos5;

                    for (var i = 0; i < cantidadAtendidos5; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo5.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa5)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Fin Mesa 6":
                    var clienteSaliendo6 = mesa6.FinAtencion();
                    clienteSaliendo6.Salir(relojActual);
                    var cantidadAtendidos6 = mesas.Single(m => m.Mesa.Equals(mesa6)).Cantidad;
                    atendidos += cantidadAtendidos6;

                    for (var i = 0; i < cantidadAtendidos6; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo6.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa6)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Fin Mesa 7":
                    var clienteSaliendo7 = mesa7.FinAtencion();
                    clienteSaliendo7.Salir(relojActual);
                    var cantidadAtendidos7 = mesas.Single(m => m.Mesa.Equals(mesa7)).Cantidad;
                    atendidos += cantidadAtendidos7;

                    for (var i = 0; i < cantidadAtendidos7; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo7.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa7)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Fin Mesa 8":
                    var clienteSaliendo8 = mesa8.FinAtencion();
                    clienteSaliendo8.Salir(relojActual);
                    var cantidadAtendidos8 = mesas.Single(m => m.Mesa.Equals(mesa8)).Cantidad;
                    atendidos += cantidadAtendidos8;

                    for (var i = 0; i < cantidadAtendidos8; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo8.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa8)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Fin Mesa 9":
                    var clienteSaliendo9 = mesa9.FinAtencion();
                    clienteSaliendo9.Salir(relojActual);
                    var cantidadAtendidos9 = mesas.Single(m => m.Mesa.Equals(mesa9)).Cantidad;
                    atendidos += cantidadAtendidos9;

                    for (var i = 0; i < cantidadAtendidos9; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo9.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa9)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Fin Mesa 10":
                    var clienteSaliendo10 = mesa10.FinAtencion();
                    clienteSaliendo10.Salir(relojActual);
                    var cantidadAtendidos10 = mesas.Single(m => m.Mesa.Equals(mesa10)).Cantidad;
                    atendidos += cantidadAtendidos10;

                    for (var i = 0; i < cantidadAtendidos10; i++)
                    {
                        esperaPromedio = acumuladorEspera.CalcularSiguiente(clienteSaliendo10.TiempoEspera);
                    }

                    mesas.Single(m => m.Mesa.Equals(mesa10)).Liberar();

                    if (!colaLocal.Vacia())
                    {
                        var clienteEsperando  = colaLocal.ProximoCliente();
                        var cantidadEsperando = (int)grupos.ObtenerValor();
                        mesas.First(m => m.EstaLibre()).Ocupar(clienteEsperando, cantidadEsperando);
                        mozo.LlegadaGrupo(relojActual, clienteEsperando, cantidadEsperando);
                    }
                    break;

                case "Cierre":
                    local.Cerrar();
                    foreach (var cliente in colaLocal.Clientes)
                    {
                        var cantidadAfuera = (int)grupos.ObtenerValor();
                        cliente.Salir(relojActual);
                        perdidos += cantidadAfuera;
                    }
                    colaLocal.Vaciar();
                    break;
                }
                //agrego la fila del evento actual
                if (simulacion >= inicio && simulacion <= fin)
                {
                    Invoke(filaInstance, relojActual, eventoActual, local, colaLocal, colaMozo, mozo,
                           colaCocina, cocina, mesas, atendidos, perdidos, esperaPromedio, clientes);
                }

                //cada 10 eventos actualizo el status
                if (simulacion % 10 == 0)
                {
                    Invoke(statusInstance, relojActual, simulacion);
                }
            }
            //muestro los resultados
            Invoke(resultadosInstance, atendidos, perdidos, esperaPromedio);

            //dejo el formulario como estaba
            Invoke(inicioFinInstance, true);
        }
Esempio n. 3
0
        private void btn_simular_Click(object sender, EventArgs e)
        {
            var distribucionCargaAuto   = new Uniforme(1, 3);
            var distribucionCargaCamion = new Uniforme(3, 5);

            var distribucionCursoAgua = new Uniforme(55, 65);

            var colaRecepcion = new ColaFifo("Recepción de vehiculos");

            var transbordador1 = new Servidor(distribucionCargaAuto, distribucionCargaCamion, distribucionCursoAgua,
                                              colaRecepcion, "Transbordador 1", 10);
            var transbordador2 = new Servidor(distribucionCargaAuto, distribucionCargaCamion, distribucionCursoAgua,
                                              colaRecepcion, "Transbordador 2", 20);

            Llegada llegadasContinente;
            Llegada llegadasIsla;

            var horaInicio = DateTime.Today.AddHours(7);
            var horaFin    = DateTime.Today.AddHours(20);

            var distribucionLlegadaAutosContinenteAIslaDe730A12     = new Uniforme(10, 20);
            var distribucionLlegadaAutosContinenteAIslaDe12A19      = new Uniforme(25, 35);
            var distribucionLlegadaCamionesContinenteAIslaDe7A11    = new Uniforme(17, 23);
            var distribucionLlegadaCamionesContinenteAIslaDe11A1930 = new Uniforme(110, 130);

            var distribucionLlegadaCamionesIslaAContinenteDe10A18 = new Uniforme(30, 90);
            var distribucionLlegadaAutosIslaAContinenteDe10A18    = new Uniforme(30, 90);

            var dias  = int.Parse(txt_dias.Text);
            var desde = int.Parse(txt_desde.Text);
            var hasta = int.Parse(txt_hasta.Text);

            decimal promedioAtendidosAutosEnContinentePorDia    = 0;
            decimal promedioAtendidosCamionesEnContinentePorDia = 0;
            decimal promedioAtendidosAutosEnIslaPorDia          = 0;
            decimal promedioAtendidosCamionesEnIslaPorDia       = 0;
            int     colaMaximaIsla       = 0;
            int     colaMaximaContinente = 0;
            decimal promedioNoAtendidosVehiculosPorDia = 0;

            var colaEnIsla       = new List <Cliente>();
            var colaEnContinente = new List <Cliente>();
            var simulacion       = 0;

            var clientes = new List <Cliente>();

            _cancelar = false;

            llegadasContinente = new Llegada(distribucionLlegadaAutosContinenteAIslaDe730A12, horaInicio, horaFin);
            llegadasIsla       = new Llegada(distribucionLlegadaAutosIslaAContinenteDe10A18, horaInicio, horaFin);

            var esMantenido1 = false;
            var esMantenido2 = false;

            var mantenimiento = 0;

            for (var dia = 1; dia < dias; dia++)
            {
                if (_cancelar)
                {
                    break;
                }

                mantenimiento = dia;

                llegadasContinente.Abrir();
                llegadasIsla.Abrir();

                while (llegadasContinente.EstaAbierto() ||
                       llegadasIsla.EstaAbierto() ||
                       transbordador1.EstaLibre() ||
                       transbordador2.EstaLibre())
                {
                    simulacion++;

                    llegadasContinente.ActualizarLlegada();
                    llegadasIsla.ActualizarLlegada();


                    var eventos = new List <Evento>
                    {
                        new Evento("Llegada Continente", llegadasContinente.ProximaLlegada),
                        new Evento("Llegada Isla", llegadasIsla.ProximaLlegada),
                        new Evento("Cierre", llegadasContinente.Cierre),
                        new Evento("Fin Carga Transbordador 1", transbordador1.ProximoFinCarga),
                        new Evento("Fin Carga Transbordador 2", transbordador2.ProximoFinCarga),
                        new Evento("Fin Curso Agua Transbordador 1", transbordador1.ProximoFinCursoAgua),
                        new Evento("Fin Curso Agua Transbordador 2", transbordador2.ProximoFinCursoAgua),
                        new Evento("Fin Descarga Transbordador 1", transbordador1.ProximoFinDescarga),
                        new Evento("Fin Descarga Transbordador 2", transbordador2.ProximoFinDescarga),
                        new Evento("Fin Mantenimiento Transbordador 1", transbordador1.ProximoFinMantenimiento),
                        new Evento("Fin Mantenimiento Transbordador 2", transbordador2.ProximoFinMantenimiento),
                    };

                    var relojActual  = eventos.Where(ev => ev.Hora.HasValue).Min(ev => ev.Hora).Value;
                    var eventoActual = eventos.First(ev => ev.Hora.Equals(relojActual)).Nombre;

                    if (mantenimiento % 5 == 0)
                    {
                        if (!esMantenido1)
                        {
                            esMantenido1 = true;
                            transbordador1.SetMantenimiento(relojActual);
                        }
                        else
                        {
                            esMantenido1 = false;
                            transbordador2.SetMantenimiento(relojActual);
                        }
                    }

                    switch (eventoActual)
                    {
                    case "Llegada Continente":
                        Cliente clienteContinente = new Cliente(simulacion.ToString(), ObtenerTipoVehiculo());

                        if (colaEnContinente.Count == 0)
                        {
                            if ((transbordador1.EstaLibre() && !transbordador1.EstaLleno() &&
                                 transbordador1.EstaEnContinente()) ||
                                (transbordador2.EstaLibre() && !transbordador2.EstaLleno() &&
                                 transbordador2.EstaEnContinente()))
                            {
                                if (transbordador1.EstaLibre())
                                {
                                    colaEnContinente.First().TipoCliente = ObtenerTipoVehiculo();
                                    transbordador1.ActualizarFinCarga(relojActual, colaEnContinente.First());
                                }
                                else
                                {
                                    colaEnContinente.First().TipoCliente = ObtenerTipoVehiculo();
                                    transbordador2.ActualizarFinCarga(relojActual,
                                                                      colaEnContinente.First());
                                }

                                colaEnContinente.RemoveAt(0);
                            }
                            else
                            {
                                colaEnContinente.Add(clienteContinente);
                            }
                        }
                        else
                        {
                            colaEnContinente.Add(clienteContinente);
                        }

                        CargarGrilla(relojActual.ToString("HH:mm:ss"), eventoActual, dia.ToString(), transbordador1.Estado, transbordador2.Estado,
                                     transbordador1.Ubicacion, transbordador2.Ubicacion, colaEnContinente.First().TipoCliente, (llegadasContinente.ProximaLlegada - relojActual).Value.ToString("HH:mm:ss"), llegadasContinente.ProximaLlegada.Value.ToString("HH:mm:ss"),
                                     colaEnContinente.Count.ToString(),
                                     (transbordador1.ProximoFinCarga - relojActual).Value.ToString("HH:mm:ss"), transbordador1.ProximoFinCarga.Value.ToString("HH:mm:ss"),
                                     transbordador1.VehiculosABordo.Where(vehiculo => vehiculo.TipoCliente == "Auto").ToList().Count.ToString(),
                                     transbordador1.VehiculosABordo.Where(vehiculo => vehiculo.TipoCliente == "Camion").ToList().Count.ToString(),
                                     string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty,
                                     string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty,
                                     string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty,
                                     string.Empty, string.Empty, string.Empty, string.Empty);

                        break;

                    case "Llegada Isla":
                        Cliente clienteIsla = new Cliente(simulacion.ToString(), ObtenerTipoVehiculo());

                        if (colaEnIsla.Count == 0)
                        {
                            if ((transbordador1.EstaLibre() && !transbordador1.EstaLleno() &&
                                 !transbordador1.EstaEnContinente()) ||
                                (transbordador2.EstaLibre() && !transbordador2.EstaLleno() &&
                                 !transbordador2.EstaEnContinente()))
                            {
                                if (transbordador1.EstaLibre())
                                {
                                    colaEnIsla.First().TipoCliente = ObtenerTipoVehiculo();
                                    transbordador1.ActualizarFinCarga(relojActual,
                                                                      colaEnIsla.First());
                                }
                                else
                                {
                                    colaEnIsla.First().TipoCliente = ObtenerTipoVehiculo();
                                    transbordador2.ActualizarFinCarga(relojActual,
                                                                      colaEnIsla.First());
                                }

                                colaEnIsla.RemoveAt(0);
                            }
                            else
                            {
                                colaEnIsla.Add(clienteIsla);
                            }
                        }
                        else
                        {
                            colaEnIsla.Add(clienteIsla);
                        }

                        break;

                    case "Cierre":
                        llegadasContinente.Cerrar();
                        llegadasIsla.Cerrar();


                        break;

                    case "Fin Carga Transbordador 1":
                        if (transbordador1.EstaEnContinente())
                        {
                            if (colaEnContinente.Count > 0 && !transbordador1.EstaLleno())
                            {
                                colaEnContinente.First().TipoCliente = ObtenerTipoVehiculo();
                                transbordador1.ActualizarFinCarga(relojActual,
                                                                  colaEnContinente.First());

                                colaEnContinente.RemoveAt(0);
                            }

                            if (transbordador1.EstaLleno())
                            {
                                transbordador1.SetEnCursoAgua(relojActual);
                            }
                        }
                        else     //esta en isla
                        {
                            if (colaEnIsla.Count > 0)
                            {
                                colaEnIsla.First().TipoCliente = ObtenerTipoVehiculo();
                                transbordador1.ActualizarFinCarga(relojActual,
                                                                  colaEnIsla.First());

                                colaEnIsla.RemoveAt(0);
                            }

                            if (transbordador1.EstaLleno())
                            {
                                transbordador1.SetEnCursoAgua(relojActual);
                            }
                        }

                        break;

                    case "Fin Carga Transbordador 2":

                        if (transbordador2.EstaEnContinente())
                        {
                            if (colaEnContinente.Count > 0 && !transbordador2.EstaLleno())
                            {
                                colaEnContinente.First().TipoCliente = ObtenerTipoVehiculo();
                                transbordador2.ActualizarFinCarga(relojActual,
                                                                  colaEnContinente.First());

                                colaEnContinente.RemoveAt(0);
                            }

                            if (transbordador2.EstaLleno())
                            {
                                transbordador2.SetEnCursoAgua(relojActual);
                            }
                        }
                        else     //esta en isla
                        {
                            if (colaEnIsla.Count > 0)
                            {
                                colaEnIsla.First().TipoCliente = ObtenerTipoVehiculo();
                                transbordador2.ActualizarFinCarga(relojActual,
                                                                  colaEnIsla.First());

                                colaEnIsla.RemoveAt(0);
                            }

                            if (transbordador2.EstaLleno())
                            {
                                transbordador2.SetEnCursoAgua(relojActual);
                            }
                        }

                        break;

                    case "Fin Curso Agua Transbordador 1":

                        transbordador1.SetDescargaVehiculos();

                        if (transbordador1.VehiculosABordo.Count > 0)
                        {
                            transbordador1.ProximoFinDescarga = new DateTime(
                                long.Parse((transbordador1.VehiculosABordo.First().TiempoCarga / 2).ToString()));
                            transbordador1.VehiculosABordo.RemoveAt(0);
                        }

                        break;

                    case "Fin Curso Agua Transbordador 2":
                        transbordador2.SetDescargaVehiculos();

                        if (transbordador2.VehiculosABordo.Count > 0)
                        {
                            transbordador2.ProximoFinDescarga = new DateTime(
                                long.Parse((transbordador2.VehiculosABordo.First().TiempoCarga / 2).ToString()));
                            transbordador2.VehiculosABordo.RemoveAt(0);
                        }

                        break;

                    case "Fin Descarga Transbordador 1":

                        if (transbordador1.VehiculosABordo.Count > 0)
                        {
                            transbordador1.ProximoFinDescarga = new DateTime(
                                long.Parse((transbordador1.VehiculosABordo.First().TiempoCarga / 2).ToString()));
                            transbordador1.VehiculosABordo.RemoveAt(0);
                        }
                        else
                        {
                            transbordador1.SetLibre();
                        }

                        break;

                    case "Fin Descarga Transbordador 2":
                        if (transbordador2.VehiculosABordo.Count > 0)
                        {
                            transbordador2.ProximoFinDescarga = new DateTime(
                                long.Parse((transbordador2.VehiculosABordo.First().TiempoCarga / 2).ToString()));
                            transbordador2.VehiculosABordo.RemoveAt(0);
                        }
                        else
                        {
                            transbordador2.SetLibre();
                        }

                        break;

                    case "Fin Mantenimiento Transbordador 1":
                        if (colaEnContinente.Count > 0)
                        {
                            colaEnContinente.First().TipoCliente = ObtenerTipoVehiculo();
                            transbordador1.ActualizarFinCarga(relojActual,
                                                              colaEnContinente.First());

                            colaEnContinente.RemoveAt(0);
                        }

                        break;

                    case "Fin Mantenimiento Transbordador 2":
                        if (colaEnContinente.Count > 0)
                        {
                            colaEnContinente.First().TipoCliente = ObtenerTipoVehiculo();
                            transbordador2.ActualizarFinCarga(relojActual,
                                                              colaEnContinente.First());

                            colaEnContinente.RemoveAt(0);
                        }

                        break;
                    }
                }
            }
        }