/// <summary>
/// Cria uma nova instância.
/// </summary>
/// <param name="tipo">Tipo.</param>
/// <param name="tempo">Tempo</param>
/// <param name="origem">Fila de origem.</param>
/// <param name="destino">Fila de destino.</param>
public Evento(TipoDeEvento tipo, double tempo, Fila origem, Fila destino)
{
Tipo = tipo;
Tempo = tempo;
Origem = origem;
Destino = destino;
}
private void atualizaOsTempos(List <Fila> filas, List <double[]> tempos, Evento proximoEvento)
{
tempoPassado = proximoEvento.Tempo - ultimoEvento;
for (int i = 0; i < tempos.Count; i++)
{
Fila filaAux = filas[i];
tempos[i][filaAux.TamanhoAtual] += tempoPassado;
tempos[i][filaAux.Capacidade + 1] += proximoEvento.Tempo;
}
ultimoEvento = proximoEvento.Tempo;
}
/// <summary>
/// Executa a simulação das filas.
/// </summary>
/// <param name="filas">Filas para executar.</param>
public void Executar(List <Fila> filas)
{
List <double[]> execucoes = calculaAsExecucoes(filas);
for (int execucao = 0; execucao < EXECUCOES; execucao++)
{
zeraAsFilas(filas);
configuraASementeAtual(execucao);
List <double[]> tempos = configuraOsTempos(filas);
List <Evento> eventos = pegaOsEventosDaFila(filas);
executa(filas, execucoes, tempos, eventos);
}
for (int i = 0; i < execucoes.Count; i++)
{
double[] execucao = execucoes[i];
for (int j = 0; j < execucao.Count(); j++)
{
execucao[j] /= EXECUCOES;
}
Fila fila = filas[i];
Console.WriteLine("--");
Console.WriteLine(fila.ToString());
for (int k = 0; k < fila.Capacidade; k++)
{
Console.WriteLine("MEDIA DE TEMPO PARA FILA: " + execucao[k]);
if (execucao[k] == 0.0)
{
break;
}
}
}
double[] primeiraExec = execucoes.First();
double media = primeiraExec[primeiraExec.Count() - 2];
Console.WriteLine("Média do tempo total de execução: " + media);
}
/// <summary>
/// Cria uma nova instância sem fila de destino.
/// </summary>
/// <param name="tipo">Tipo.</param>
/// <param name="tempo">Tempo</param>
/// <param name="origem">Fila de origem.</param>
public Evento(TipoDeEvento tipo, double tempo, Fila origem) : this(tipo, tempo, origem, null)
{
}
private void executa(List <Fila> filas, List <double[]> execucoes, List <double[]> tempos, List <Evento> eventos)
{
for (int nrosAleatorios = 0; nrosAleatorios < NUMEROS_ALEATORIOS;)
{
Evento proximoEvento = pegaOProximoEvento(eventos);
Fila filaDoEvento = proximoEvento.Origem;
double[] arrayDeTemposDaFila = tempos[filaDoEvento.PosicaoNoArray];
atualizaOsTempos(filas, tempos, proximoEvento);
switch (proximoEvento.Tipo)
{
case TipoDeEvento.CHEGADA:
if (filaDoEvento.TemEspaco)
{
filaDoEvento.TamanhoAtual++;
if (filaDoEvento.TemServidorSobrando)
{
double numeroAleatorio = gerador.Gera();
string destino = filaDoEvento.PegaDestino(numeroAleatorio);
double numeroAleatorioComMinMax = gerador.Gera(filaDoEvento.Atendimento.Minimo, filaDoEvento.Atendimento.Maximo);
double tempo1 = arrayDeTemposDaFila[filaDoEvento.Capacidade + 1] + numeroAleatorioComMinMax;
nrosAleatorios += 2;
if (string.IsNullOrWhiteSpace(destino))
{
Evento evt1 = new Evento(TipoDeEvento.SAIDA, tempo1, filaDoEvento);
eventos.Add(evt1);
}
else
{
Fila filaDestino = filas.First(x => x.Nome == destino);
Evento evt1 = new Evento(TipoDeEvento.PASSAGEM, tempo1, filaDoEvento, filaDestino);
eventos.Add(evt1);
}
}
}
else
{
filaDoEvento.PerdaDeClientes++;
}
double tempo2 = arrayDeTemposDaFila[filaDoEvento.Capacidade + 1] + gerador.Gera(filaDoEvento.Chegada.Minimo, filaDoEvento.Chegada.Maximo);
Evento evt2 = new Evento(TipoDeEvento.CHEGADA, tempo2, filaDoEvento);
eventos.Add(evt2);
nrosAleatorios += 1;
break;
case TipoDeEvento.SAIDA:
filaDoEvento.TamanhoAtual--;
if (filaDoEvento.TemServidorSobrando)
{
double numeroAleatorio = gerador.Gera();
string destino = filaDoEvento.PegaDestino(numeroAleatorio);
double numeroAleatorioComMinMax = gerador.Gera(filaDoEvento.Atendimento.Minimo, filaDoEvento.Atendimento.Maximo);
double tempo1 = arrayDeTemposDaFila[filaDoEvento.Capacidade + 1] + numeroAleatorioComMinMax;
nrosAleatorios += 2;
if (string.IsNullOrWhiteSpace(destino))
{
Evento evt1 = new Evento(TipoDeEvento.SAIDA, tempo1, filaDoEvento);
eventos.Add(evt1);
}
else
{
Fila filaDestino = filas.First(x => x.Nome == destino);
Evento evt1 = new Evento(TipoDeEvento.PASSAGEM, tempo1, filaDoEvento, filaDestino);
eventos.Add(evt1);
}
}
if (proximoEvento.Tipo == TipoDeEvento.PASSAGEM)
{
Fila filaDestino = proximoEvento.Destino;
if (filaDestino.TemEspaco)
{
filaDestino.TamanhoAtual++;
if (filaDestino.TemServidorSobrando)
{
double[] temposDaFilaDestino = tempos[filaDestino.PosicaoNoArray];
double proximoAleatorio = gerador.Gera();
string destino = filaDestino.PegaDestino(proximoAleatorio);
int arrayDoTempo = filaDestino.Capacidade + 1;
proximoAleatorio = gerador.Gera(filaDestino.Atendimento.Minimo, filaDestino.Atendimento.Maximo);
double tempo = temposDaFilaDestino[arrayDoTempo] + proximoAleatorio;
nrosAleatorios += 2;
if (string.IsNullOrWhiteSpace(destino))
{
Evento evt1 = new Evento(TipoDeEvento.SAIDA, tempo, filaDoEvento);
eventos.Add(evt1);
}
else
{
filaDestino = filas.First(x => x.Nome == destino);
Evento evt1 = new Evento(TipoDeEvento.PASSAGEM, tempo, filaDoEvento, filaDestino);
eventos.Add(evt1);
}
}
}
else
{
filaDestino.PerdaDeClientes++;
}
}
break;
}
}
for (int i = 0; i < execucoes.Count; i++)
{
double[] execucao = execucoes[i];
double[] tempo = tempos[i];
for (int j = 0; j < tempo.Count(); j++)
{
execucao[j] += tempo[j];
}
execucao[execucao.Count() - 1] += filas[i].PerdaDeClientes;
}
}
